java.lang.IllegalArgumentException:SQL数组不能为空

我有一个DBImporter类，它工作得很好，并且在数据库表中正确插入了数据。我正在尝试从.CSV文件中获取数据并插入到Oracle表中

到目前为止，我只处理我的目录中的一个文件，而且工作正常。现在我想处理多个文件。因此，在正确运行第一个文件进程并插入数据的过程中，在第二个文件中，它开始读取数据并抛出错误，如下所示：

java.lang.IllegalArgumentException: SQL array must not be empty

下面是我的课程。我认为这个错误是在最后的提交批处理过程中发生的，但不确定

jdbcTemplate.batchUpdate（sqlBatch.toArray（新字符串[sqlBatch.size（）]）

@服务
公共类数据库导入器{
私有最终静态记录器log=LoggerFactory.getLogger（DBImporter.class）；
私有静态最终列表NULL_值=Arrays.asList（“，”N.A“，”N.A“，”未知”）；
私有静态最终列表COL_HEADERS=Arrays.asList（“ID”、“NM”、“TYE”、“SA”）；
专用静态最终整数批大小=50；
私有布尔eof=false；
私有字符串表名；
@自动连线
私有JdbcTemplate JdbcTemplate；
public void setTableName（字符串tableName）{
this.tableName=tableName；
}
@事务性（rollboor=IOException.class）
公共void进程文件（BufferedReader读取器，字符串表名）{
this.tableName=tableName；
List sqlBatch=new ArrayList（批次大小）；
日志信息（“Starte auslesen der Daten”）；
long t1=System.currentTimeMillis（）；
日志信息（“开始时间：+t1”）；
jdbcTemplate.execute（“从”+tableName中删除”）；
而（！eof）{
试一试{
Map dbColumns=getDBColumns（）；
//获取与列标题相关的db列数据列表。
List columnData=COL_HEADERS.stream（）.map（dbColumns:：get）.collect（toList（））；
//如果下一个有效数据行从“FRO”或“BO”开始，则获取下一个有效数据行。
List dataRow=findNextLineStartingWith（读卡器，“R”，“T”）；
String query=createSql（columnData，dataRow）；
添加（查询）；
//处理批处理。
if（sqlBatch.size（）>=批大小）{
jdbcTemplate.batchUpdate（sqlBatch.toArray（新字符串[sqlBatch.size（）]）；
sqlBatch.clear（）；
}
}捕获（非法状态）{
打破
}捕获（IOE异常）{
log.error（例如getLocalizedMessage（））；
}
}
//提交最后一批。
jdbcTemplate.batchUpdate（sqlBatch.toArray（新字符串[sqlBatch.size（）]）；
sqlBatch.clear（）；
长增量=System.currentTimeMillis（）-t1；
log.info（“总运行时间：+delta/1000+“秒”）；
}
/**
*使用数据行创建SQL insert查询。
* 
*@param tableName表的名称。
*@param columnData列数据列表。
*@param dataRow要插入的数据行。
*@return生成的SQL查询字符串。
*/
私有字符串createSql（列表列数据，列表数据行）{
列表值=新的ArrayList（columnData.size（））；
对于（int i=0；i}否则，如果（columnData.get（i）.getType（）>=Types.NUMERIC&&columnData.get（i）.getType（），则最终批处理可能为空

如果您刚刚提交了
BATCH\u SIZE
条目并清除了
sqlBatch
，这是可能的。如果您的
while
循环此时退出，
没有要提交的元素

您需要通过添加大小检查来解决此问题，例如：

// Commit the final batch (only if there is something left)
if (sqlBatch.isEmpty() == false) {
    jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
    sqlBatch.clear();
}


编辑：

正如
@Vasif
指出的，您需要在方法的不同调用之间重置
eof

一个简单的解决方案（尽管有点黑客化）是

一个合适的解决方案是重构代码，使其不依赖于抛出的这些异常

一些提示：


摆脱
readLineOrThrow
删除
findNextLineStartingWith
中的
while（true）
，如果下一行为
null
，则返回空列表
调整外部循环以适当处理此返回值
（注意：如果出现
IOException
，可能还需要中断循环）
您的最终批次可能为空

如果您刚刚提交了
BATCH\u SIZE
条目并清除了
sqlBatch
，这是可能的。如果您的
while
循环此时退出，
没有要提交的元素

您需要通过添加大小检查来解决此问题，例如：

// Commit the final batch (only if there is something left)
if (sqlBatch.isEmpty() == false) {
    jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
    sqlBatch.clear();
}


编辑：

正如
@Vasif
指出的，您需要在方法的不同调用之间重置
eof

一个简单的解决方案（尽管有点黑客化）是

一个合适的解决方案是重构代码，使其不依赖于抛出的这些异常

一些提示：


摆脱
readLineOrThrow
删除
findNextLineStartingWith
中的
while（true）
，如果下一行为
null
，则返回空列表
调整外部循环以适当处理此返回值
（注意：如果出现
IOException
，可能还需要中断循环）
请尝试以下更改：

        // Commit the final batch.
if (sqlBatch.size() > 0){
   jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
   sqlBatch.clear();
}

及

但是，如果您想要一个更清晰、更安全的解决方案，请对代码进行如下更改：

public class DBImporter {

    private final static Logger log = LoggerFactory.getLogger(DBImporter.class);
    private static final List<String> NULL_VALUES = Arrays.asList("", "N.A", "N.A", "UNKNOWN");
    private static final List<String> COL_HEADERS = Arrays.asList("USER_ID", "NAME", "TYPE", "SRC_DATA");
    private static final int BATCH_SIZE = 50;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(rollbackFor = IOException.class)
    public void processFile(BufferedReader reader, String tableName) {
        AtomicBoolean eof = new AtomicBoolean(false);
        List<String> sqlBatch = new ArrayList<String>(BATCH_SIZE);

        log.info("Starte auslesen der Daten");
        long t1 = System.currentTimeMillis();
        log.info("Start time: " + t1);

        jdbcTemplate.execute("DELETE FROM " + tableName);

        while (!eof.get()) {
            try {
                Map<String, ColumnData> dbColumns = getDBColumns(tableName);

                // Get a list of db column data related to the column headers.
                List<ColumnData> columnData = COL_HEADERS.stream().map(dbColumns::get).collect(toList());

                // Get the next valid data row if its starts from "R" or "T".
                List<String> dataRow = findNextLineStartingWith(reader, eof, "R", "T");

                String query = createSql(tableName, columnData, dataRow);
                sqlBatch.add(query);

                // Process batch.
                if (sqlBatch.size() >= BATCH_SIZE) {
                    jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
                    sqlBatch.clear();
                }
            } catch (IllegalStateException e) {
                break;
            } catch (IOException e) {
                log.error(e.getLocalizedMessage());
            }
        }

        // Commit the final batch.
        jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
        sqlBatch.clear();

        long delta = System.currentTimeMillis() - t1;
        log.info("Total runtime : " + delta / 1000 + " seconds");
    }

    /**
     * Create a SQL insert query using the data row.
     *
     * @param tableName  Name of the table.
     * @param columnData Column data list.
     * @param dataRow    Data row to be inserted.
     * @return Generated SQL query string.
     */
    private String createSql(String tableName, List<ColumnData> columnData, List<String> dataRow) {
        List<String> values = new ArrayList<>(columnData.size());

        for (int i = 0; i < columnData.size(); i++) {
            if (NULL_VALUES.contains(dataRow.get(i))) {
                values.add("NULL");
            } else if (columnData.get(i).getType() >= Types.NUMERIC && columnData.get(i).getType() <= Types.DOUBLE) {
                values.add(dataRow.get(i));
            } else {
                values.add("'" + dataRow.get(i).replace("'", "''") + "'");
            }
        }

        return "INSERT INTO " + tableName + " (" +
                columnData.stream().filter(Objects::nonNull).map(ColumnData::getName).collect(joining(", ")) +
                ", SYSTEM_INSERTED_AT) VALUES (" +
                values.stream().collect(joining(", ")) +
                ", CURRENT_TIMESTAMP)";
    }

    /**
     * Find the next line starting with the given string and split it into columns.
     *
     * @param reader   BufferedReader object to be used.
     * @param prefixes A list of prefixes to look for in the string.
     * @return List of data objects.
     * @throws IOException
     */
    private List<String> findNextLineStartingWith(BufferedReader reader, AtomicBoolean eof, String... prefixes) throws IOException {
        while (true) {
            String line = readLineOrThrow(reader, eof);
            for (String prefix : prefixes)
                if (line.startsWith(prefix)) {
                    ArrayList<String> data = new ArrayList<>();
                    // Split the line using the delimiter.
                    data.addAll(Arrays.asList(line.split(";")));

                    // Build the row to be inserted.
                    List<String> row = Arrays.asList(data.get(1), data.get(2).trim(), "", "");

                    // Insert type depending on the prefix.
                    if (prefix.equals("R"))
                        row.set(2, "USER");
                    else if (prefix.equals("T"))
                        row.set(2, "PERM");

                    row.set(3, String.join(";", row.subList(0, 3)));

                    return row;
                }
        }
    }

    /**
     * Read a single line in the file.
     *
     * @param reader BufferedReader object to be used.
     * @return
     * @throws IOException
     */
    private String readLineOrThrow(BufferedReader reader, AtomicBoolean eof) throws IOException {
        String line = reader.readLine();
        if (line == null) {
            eof.set(true);
            throw new IllegalStateException("Unexpected EOF");
        }

        return line.trim();
    }

    /**
     * Read database column metadata.
     *
     * @param tableName Name of the table to process.
     * @return A map containing column information.
     */
    private Map<String, ColumnData> getDBColumns(String tableName) {
        Map<String, ColumnData> result = new HashMap<>();
        try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
            ResultSet rs = connection.getMetaData().getColumns(null, null, tableName, null);
            while (rs.next()) {
                String columnName = rs.getString(4).toUpperCase();
                int type = rs.getInt(5);
                result.put(columnName, new ColumnData(columnName, type));
            }
            return result;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}


公共类DBImporter{
私有最终静态记录器log=LoggerFactory.getLogger（DBImporter.class）；
私有静态最终列表NULL_值=A
    @Transactional(rollbackFor = IOException.class)
    public void processFile(BufferedReader reader, String tableName) {
        eof = false;
        ...

public class DBImporter {

    private final static Logger log = LoggerFactory.getLogger(DBImporter.class);
    private static final List<String> NULL_VALUES = Arrays.asList("", "N.A", "N.A", "UNKNOWN");
    private static final List<String> COL_HEADERS = Arrays.asList("USER_ID", "NAME", "TYPE", "SRC_DATA");
    private static final int BATCH_SIZE = 50;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(rollbackFor = IOException.class)
    public void processFile(BufferedReader reader, String tableName) {
        AtomicBoolean eof = new AtomicBoolean(false);
        List<String> sqlBatch = new ArrayList<String>(BATCH_SIZE);

        log.info("Starte auslesen der Daten");
        long t1 = System.currentTimeMillis();
        log.info("Start time: " + t1);

        jdbcTemplate.execute("DELETE FROM " + tableName);

        while (!eof.get()) {
            try {
                Map<String, ColumnData> dbColumns = getDBColumns(tableName);

                // Get a list of db column data related to the column headers.
                List<ColumnData> columnData = COL_HEADERS.stream().map(dbColumns::get).collect(toList());

                // Get the next valid data row if its starts from "R" or "T".
                List<String> dataRow = findNextLineStartingWith(reader, eof, "R", "T");

                String query = createSql(tableName, columnData, dataRow);
                sqlBatch.add(query);

                // Process batch.
                if (sqlBatch.size() >= BATCH_SIZE) {
                    jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
                    sqlBatch.clear();
                }
            } catch (IllegalStateException e) {
                break;
            } catch (IOException e) {
                log.error(e.getLocalizedMessage());
            }
        }

        // Commit the final batch.
        jdbcTemplate.batchUpdate(sqlBatch.toArray(new String[sqlBatch.size()]));
        sqlBatch.clear();

        long delta = System.currentTimeMillis() - t1;
        log.info("Total runtime : " + delta / 1000 + " seconds");
    }

    /**
     * Create a SQL insert query using the data row.
     *
     * @param tableName  Name of the table.
     * @param columnData Column data list.
     * @param dataRow    Data row to be inserted.
     * @return Generated SQL query string.
     */
    private String createSql(String tableName, List<ColumnData> columnData, List<String> dataRow) {
        List<String> values = new ArrayList<>(columnData.size());

        for (int i = 0; i < columnData.size(); i++) {
            if (NULL_VALUES.contains(dataRow.get(i))) {
                values.add("NULL");
            } else if (columnData.get(i).getType() >= Types.NUMERIC && columnData.get(i).getType() <= Types.DOUBLE) {
                values.add(dataRow.get(i));
            } else {
                values.add("'" + dataRow.get(i).replace("'", "''") + "'");
            }
        }

        return "INSERT INTO " + tableName + " (" +
                columnData.stream().filter(Objects::nonNull).map(ColumnData::getName).collect(joining(", ")) +
                ", SYSTEM_INSERTED_AT) VALUES (" +
                values.stream().collect(joining(", ")) +
                ", CURRENT_TIMESTAMP)";
    }

    /**
     * Find the next line starting with the given string and split it into columns.
     *
     * @param reader   BufferedReader object to be used.
     * @param prefixes A list of prefixes to look for in the string.
     * @return List of data objects.
     * @throws IOException
     */
    private List<String> findNextLineStartingWith(BufferedReader reader, AtomicBoolean eof, String... prefixes) throws IOException {
        while (true) {
            String line = readLineOrThrow(reader, eof);
            for (String prefix : prefixes)
                if (line.startsWith(prefix)) {
                    ArrayList<String> data = new ArrayList<>();
                    // Split the line using the delimiter.
                    data.addAll(Arrays.asList(line.split(";")));

                    // Build the row to be inserted.
                    List<String> row = Arrays.asList(data.get(1), data.get(2).trim(), "", "");

                    // Insert type depending on the prefix.
                    if (prefix.equals("R"))
                        row.set(2, "USER");
                    else if (prefix.equals("T"))
                        row.set(2, "PERM");

                    row.set(3, String.join(";", row.subList(0, 3)));

                    return row;
                }
        }
    }

    /**
     * Read a single line in the file.
     *
     * @param reader BufferedReader object to be used.
     * @return
     * @throws IOException
     */
    private String readLineOrThrow(BufferedReader reader, AtomicBoolean eof) throws IOException {
        String line = reader.readLine();
        if (line == null) {
            eof.set(true);
            throw new IllegalStateException("Unexpected EOF");
        }

        return line.trim();
    }

    /**
     * Read database column metadata.
     *
     * @param tableName Name of the table to process.
     * @return A map containing column information.
     */
    private Map<String, ColumnData> getDBColumns(String tableName) {
        Map<String, ColumnData> result = new HashMap<>();
        try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
            ResultSet rs = connection.getMetaData().getColumns(null, null, tableName, null);
            while (rs.next()) {
                String columnName = rs.getString(4).toUpperCase();
                int type = rs.getInt(5);
                result.put(columnName, new ColumnData(columnName, type));
            }
            return result;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}