PreparedStatement.executeBatch() Throws BatchUpdateException "Unable to retrieve column metadata." When Insert SQL Column Name Case Does Not Match Table (#2695)

muskan124947 · wooln · web-flow · commit 6c85e2cd1f9d · 2025-06-26T10:08:21.000+05:30
* test: add tests for column case sensitivity in batch execution

- Add test case for matching column case in batch execution
- Add test case for mismatched column case in batch execution, expected SQLServerException

* fix(batch): improve column metadata handling for batch execution

- Update column index search to be case-insensitive in SQLServerPreparedStatement
- Remove failing test case in BatchExecutionTest that was checking for specific exception

* test(BatchExecutionTest): Add cleanup for caseSensitiveTable in the finally block

* test: remove unused test case for column case matching

* feat(collation): add case sensitivity check for database collation

- Add getIsCaseSensitive() method to SQLCollation class
- Update SQLServerPreparedStatement to use case sensitivity information
- Improve performance by avoiding unnecessary case-insensitive comparisons

* fix(batch): handle case sensitivity for column names in batch execution

- Add support for case-sensitive column names in SQLServerBulkBatchInsertRecord
- Update SQLServerBulkRecord to handle case sensitivity in column metadata
- Modify SQLServerPreparedStatement to pass case sensitivity information to batch records
- Add tests for case-sensitive and case-insensitive column name handling in batch execution

* refactor: Replace wildcard import with specific SQLServerException import in BatchExecutionTest

* revert: throw BatchUpdateException

* perf: remove redundant column index calculation

* test(BatchExecutionTest): Add case sensitive and case insensitive database in unit test.

* fix: handle null SortOrder in getIsCaseSensitive to keep it defensive

- Return false (case-insensitive) if sortOrder is not found

* Updated logic for null handling

---------

Co-authored-by: 徐云金YunjinXu &lt;xuyunjin@foxmail.com&gt;
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLCollation.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLCollation.java
@@ -78,6 +78,17 @@ int getCollationSortID() {
         return this.sortId;
     }
 
+    /**
+     * return collation is case-sensitive or not
+     *
+     * @return
+     */
+    boolean getIsCaseSensitive() {
+        SortOrder sortOrder = sortOrderIndex.get(this.sortId);
+        // consider case-insensitive if no SortOrder entry
+        return sortOrder != null && sortOrder.name.contains("_CS_");
+    }
+
     boolean isEqual(SQLCollation col) {
         return (col != null && col.info == info && col.sortId == sortId);
     }
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkBatchInsertRecord.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkBatchInsertRecord.java
@@ -44,7 +44,7 @@ class SQLServerBulkBatchInsertRecord extends SQLServerBulkRecord {
      * Constructs a SQLServerBulkBatchInsertRecord with the batch parameter, column list, value list, and encoding
      */
     SQLServerBulkBatchInsertRecord(ArrayList<Parameter[]> batchParam, ArrayList<String> columnList,
-            ArrayList<String> valueList, String encoding) throws SQLServerException {
+            ArrayList<String> valueList, String encoding, boolean columnNameCaseSensitive) throws SQLServerException {
         initLoggerResources();
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) {
             loggerExternal.entering(loggerPackageName, loggerClassName, new Object[] {batchParam, encoding});
@@ -61,6 +61,7 @@ class SQLServerBulkBatchInsertRecord extends SQLServerBulkRecord {
         this.batchParam = batchParam;
         this.columnList = columnList;
         this.valueList = valueList;
+        this.columnNameCaseSensitive = columnNameCaseSensitive;
         columnMetadata = new HashMap<>();
 
         loggerExternal.exiting(loggerPackageName, loggerClassName);
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkRecord.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkRecord.java
@@ -64,6 +64,8 @@ protected class ColumnMetadata {
      */
     protected transient DateTimeFormatter timeFormatter = null;
 
+    protected boolean columnNameCaseSensitive = false;
+
     /*
      * Logger
      */
@@ -153,7 +155,10 @@ void checkDuplicateColumnName(int positionInTable, String colName) throws SQLSer
                 // duplicate check is not performed in case of same
                 // positionInTable value
                 if (null != entry && entry.getKey() != positionInTable && null != entry.getValue()
-                        && colName.trim().equalsIgnoreCase(entry.getValue().columnName)) {
+                        && (this.columnNameCaseSensitive
+                        ? colName.trim().equals(entry.getValue().columnName)
+                        : colName.trim().equalsIgnoreCase(entry.getValue().columnName)
+                )) {
                     throw new SQLServerException(SQLServerException.getErrString("R_BulkDataDuplicateColumn"), null);
                 }
             }
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
@@ -2199,7 +2199,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL
                         }
 
                         SQLServerBulkBatchInsertRecord batchRecord = new SQLServerBulkBatchInsertRecord(
-                                batchParamValues, bcOperationColumnList, bcOperationValueList, null);
+                                batchParamValues, bcOperationColumnList, bcOperationValueList, null, isDBColationCaseSensitive());
 
                         for (int i = 1; i <= rs.getColumnCount(); i++) {
                             Column c = rs.getColumn(i);
@@ -2216,7 +2216,22 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL
                                 jdbctype = ti.getSSType().getJDBCType().getIntValue();
                             }
                             if (null != bcOperationColumnList && !bcOperationColumnList.isEmpty()) {
-                                int columnIndex = bcOperationColumnList.indexOf(c.getColumnName());
+                                // connection contains database name
+                                boolean isCaseSensitive = isDBColationCaseSensitive();
+                                int columnIndex = -1;
+                                if (isCaseSensitive) {
+                                    columnIndex = bcOperationColumnList.indexOf(c.getColumnName());
+                                } else {
+                                    // find index ignore case
+                                    for (int opi = 0; opi < bcOperationColumnList.size(); opi++) {
+                                        String opCol = bcOperationColumnList.get(opi);
+                                        if (opCol != null && opCol.equalsIgnoreCase(c.getColumnName())) {
+                                            columnIndex = opi;
+                                            break;
+                                        }
+                                    }
+                                }
+
                                 if (columnIndex > -1) {
                                     columnMappings.put(columnIndex + 1, i);
                                     batchRecord.addColumnMetadata(columnIndex + 1, c.getColumnName(), jdbctype,
@@ -2392,7 +2407,7 @@ public long[] executeLargeBatch() throws SQLServerException, BatchUpdateExceptio
                         }
 
                         SQLServerBulkBatchInsertRecord batchRecord = new SQLServerBulkBatchInsertRecord(
-                                batchParamValues, bcOperationColumnList, bcOperationValueList, null);
+                                batchParamValues, bcOperationColumnList, bcOperationValueList, null, isDBColationCaseSensitive());
 
                         for (int i = 1; i <= rs.getColumnCount(); i++) {
                             Column c = rs.getColumn(i);
@@ -2484,6 +2499,12 @@ public long[] executeLargeBatch() throws SQLServerException, BatchUpdateExceptio
         }
     }
 
+    private boolean isDBColationCaseSensitive() throws SQLServerException {
+        if (null == connection.getDatabaseCollation())
+            return false;
+        return connection.getDatabaseCollation().getIsCaseSensitive();
+    }
+
     private void checkValidColumns(TypeInfo ti) throws SQLServerException {
         int jdbctype = ti.getSSType().getJDBCType().getIntValue();
         String typeName;
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java
@@ -10,6 +10,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 
 import java.lang.reflect.Field;
 import java.sql.BatchUpdateException;
@@ -72,6 +73,8 @@ public class BatchExecutionTest extends AbstractTest {
             .escapeIdentifier(RandomUtil.getIdentifier("timestamptable1"));
     private static String timestampTable2 = AbstractSQLGenerator
             .escapeIdentifier(RandomUtil.getIdentifier("timestamptable2"));
+    private static String caseSensitiveDatabase = "BD_Collation_SQL_Latin1_General_CP1_CS_AS";
+    private static String caseInsensitiveDatabase = "BD_Collation_SQL_Latin1_General_CP1_CI_AS";
 
     /**
      * This tests the updateCount when the error query does cause a SQL state HY008.
@@ -568,6 +571,114 @@ public void testBatchStatementCancellation() throws Exception {
         }
     }
 
+    @Test
+    @Tag(Constants.xAzureSQLDB)
+    public void testExecuteBatchColumnCaseMismatch_CI() throws Exception {
+        String connectionStringCollationCaseInsensitive = TestUtils.addOrOverrideProperty(connectionString, "databaseName", caseInsensitiveDatabase);
+        String tableName = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("caseInsensitiveTable"));
+
+        try (Connection conTemp = DriverManager.getConnection(connectionString); Statement stmt = conTemp.createStatement()) {
+            TestUtils.dropDatabaseIfExists(caseInsensitiveDatabase, connectionString);
+            stmt.executeUpdate("CREATE DATABASE " + caseInsensitiveDatabase);
+            stmt.executeUpdate("ALTER DATABASE " + caseInsensitiveDatabase + " COLLATE SQL_Latin1_General_CP1_CI_AS;");
+
+            // Insert Timestamp using prepared statement when useBulkCopyForBatchInsert=true
+            try (Connection con = DriverManager.getConnection(connectionStringCollationCaseInsensitive
+                    + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;")) {
+                try (Statement statement = con.createStatement()) {
+                    TestUtils.dropTableIfExists(tableName, statement);
+                    String createSql = "CREATE TABLE" + tableName + " (c1 varchar(10))";
+                    statement.execute(createSql);
+                }
+                // upper case C1
+                try (PreparedStatement preparedStatement = con.prepareStatement("INSERT INTO " + tableName + "(C1) VALUES(?)")) {
+                    preparedStatement.setObject(1, "value1");
+                    preparedStatement.addBatch();
+                    preparedStatement.setObject(1, "value2");
+                    preparedStatement.addBatch();
+                    preparedStatement.executeBatch();
+                }
+            }
+        } finally {
+            TestUtils.dropDatabaseIfExists(caseInsensitiveDatabase, connectionString);
+        }
+    }
+
+    // adapter Azure pipeline CI, need to add a new environment variable `mssql_jdbc_test_connection_properties_collation_cs`
+    @Test
+    @Tag(Constants.xAzureSQLDB)
+    public void testExecuteBatchColumnCaseMismatch_CS_throwException() throws Exception {
+        String connectionStringCollationCaseSensitive = TestUtils.addOrOverrideProperty(connectionString, "databaseName", caseSensitiveDatabase);
+        String tableName = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("caseSensitiveTable"));
+
+        try (Connection conTemp = DriverManager.getConnection(connectionString); Statement stmt = conTemp.createStatement()) {
+            TestUtils.dropDatabaseIfExists(caseSensitiveDatabase, connectionString);
+            stmt.executeUpdate("CREATE DATABASE " + caseSensitiveDatabase);
+            stmt.executeUpdate("ALTER DATABASE " + caseSensitiveDatabase + " COLLATE SQL_Latin1_General_CP1_CS_AS;");
+
+            try (Connection con = DriverManager.getConnection(connectionStringCollationCaseSensitive
+                    + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;")) {
+                try (Statement statement = con.createStatement()) {
+                    TestUtils.dropTableIfExists(tableName, statement);
+                    String createSql = "CREATE TABLE" + tableName + " (c1 varchar(10))";
+                    statement.execute(createSql);
+                }
+                // upper case C1
+                try (PreparedStatement preparedStatement = con.prepareStatement("INSERT INTO " + tableName + "(C1) VALUES(?)")) {
+                    preparedStatement.setObject(1, "value1");
+                    preparedStatement.addBatch();
+                    preparedStatement.setObject(1, "value2");
+                    preparedStatement.addBatch();
+                    try {
+                        preparedStatement.executeBatch();
+                        fail("Should have failed");
+                    } catch (Exception ex) {
+                        assertInstanceOf(java.sql.BatchUpdateException.class, ex);
+                        assertEquals("Unable to retrieve column metadata.", ex.getMessage());
+                    }
+                }
+            }
+        } finally {
+            TestUtils.dropDatabaseIfExists(caseSensitiveDatabase, connectionString);
+        }
+    }
+
+    // adapter Azure pipeline CI, need to add a new environment variable `mssql_jdbc_test_connection_properties_collation_cs`
+    @Test
+    @Tag(Constants.xAzureSQLDB)
+    public void testExecuteBatchColumnCaseMismatch_CS() throws Exception {
+        String connectionStringCollationCaseSensitive = TestUtils.addOrOverrideProperty(connectionString, "databaseName", caseSensitiveDatabase);
+        String tableName = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("caseSensitiveTable"));
+
+        try (Connection conTemp = DriverManager.getConnection(connectionString); Statement stmt = conTemp.createStatement()) {
+            TestUtils.dropDatabaseIfExists(caseSensitiveDatabase, connectionString);
+            stmt.executeUpdate("CREATE DATABASE " + caseSensitiveDatabase);
+            stmt.executeUpdate("ALTER DATABASE " + caseSensitiveDatabase + " COLLATE SQL_Latin1_General_CP1_CS_AS;");
+
+            // Insert Timestamp using prepared statement when useBulkCopyForBatchInsert=true
+            try (Connection con = DriverManager.getConnection(connectionStringCollationCaseSensitive
+                    + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;")) {
+                try (Statement statement = con.createStatement()) {
+                    TestUtils.dropTableIfExists(tableName, statement);
+                    String createSql = "CREATE TABLE" + tableName + " (c1 varchar(10), C1 varchar(10))";
+                    statement.execute(createSql);
+                }
+                // upper case C1
+                try (PreparedStatement preparedStatement = con.prepareStatement("INSERT INTO " + tableName + "(c1, C1) VALUES(?,?)")) {
+                    preparedStatement.setObject(1, "value1-1");
+                    preparedStatement.setObject(2, "value1-2");
+                    preparedStatement.addBatch();
+                    preparedStatement.setObject(1, "value2-1");
+                    preparedStatement.setObject(2, "value2-2");
+                    preparedStatement.addBatch();
+                    preparedStatement.executeBatch();
+                }
+            }
+        } finally {
+            TestUtils.dropDatabaseIfExists(caseSensitiveDatabase, connectionString);
+        }
+    }
+
     /**
      * Get a PreparedStatement object and call the addBatch() method with 3 SQL statements and call the executeBatch()
      * method and it should return array of Integer values of length 3
