Fix collation conflict in getIndexInfo() UNION ALL with different server/database collations

Author: Ananya2

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java

@@ -275,14 +275,22 @@ private void checkClosed() throws SQLServerException {
     "); " +
     "INSERT INTO @temp_sp_statistics " +
     "EXEC sp_statistics ?, ?, ?, ?, ?, ?; " +
-    "SELECT TABLE_QUALIFIER AS TABLE_CAT, TABLE_OWNER AS TABLE_SCHEM, " +
-    "TABLE_NAME, NON_UNIQUE, INDEX_QUALIFIER, INDEX_NAME, TYPE, " +
-    "ORDINAL_POSITION, COLUMN_NAME, ASC_OR_DESC, CARDINALITY, PAGES, FILTER_CONDITION " +
+    "SELECT TABLE_QUALIFIER COLLATE DATABASE_DEFAULT AS TABLE_CAT, " +
+    "TABLE_OWNER COLLATE DATABASE_DEFAULT AS TABLE_SCHEM, " +
+    "TABLE_NAME COLLATE DATABASE_DEFAULT AS TABLE_NAME, NON_UNIQUE, " +
+    "INDEX_QUALIFIER COLLATE DATABASE_DEFAULT AS INDEX_QUALIFIER, " +
+    "INDEX_NAME COLLATE DATABASE_DEFAULT AS INDEX_NAME, TYPE, " +
+    "ORDINAL_POSITION, COLUMN_NAME COLLATE DATABASE_DEFAULT AS COLUMN_NAME, ASC_OR_DESC, " +
+    "CARDINALITY, PAGES, FILTER_CONDITION " +
     "FROM @temp_sp_statistics " +
     "UNION ALL " +
-    "SELECT db_name() AS TABLE_CAT, sch.name AS TABLE_SCHEM, t.name AS TABLE_NAME, " +
-    "CASE WHEN i.is_unique = 1 THEN 0 ELSE 1 END AS NON_UNIQUE, t.name AS INDEX_QUALIFIER, i.name AS INDEX_NAME, " +
-    "i.type AS TYPE, ic.key_ordinal AS ORDINAL_POSITION, c.name AS COLUMN_NAME, " +
+    "SELECT db_name() AS TABLE_CAT, sch.name COLLATE DATABASE_DEFAULT AS TABLE_SCHEM, " +
+    "t.name COLLATE DATABASE_DEFAULT AS TABLE_NAME, " +
+    "CASE WHEN i.is_unique = 1 THEN 0 ELSE 1 END AS NON_UNIQUE, " +
+    "t.name COLLATE DATABASE_DEFAULT AS INDEX_QUALIFIER, " +
+    "i.name COLLATE DATABASE_DEFAULT AS INDEX_NAME, " +
+    "i.type AS TYPE, ic.key_ordinal AS ORDINAL_POSITION, " +
+    "c.name COLLATE DATABASE_DEFAULT AS COLUMN_NAME, " +
     "CASE WHEN ic.is_descending_key = 1 THEN 'D' ELSE 'A' END AS ASC_OR_DESC, " +
     "CASE WHEN i.index_id <= 1 THEN ps.row_count ELSE NULL END AS CARDINALITY, " +
     "CASE WHEN i.index_id <= 1 THEN ps.used_page_count ELSE NULL END AS PAGES, " +
@@ -294,7 +302,7 @@ private void checkClosed() throws SQLServerException {
     "INNER JOIN sys.schemas sch ON t.schema_id = sch.schema_id " +
     "LEFT JOIN sys.dm_db_partition_stats ps ON ps.object_id = i.object_id AND ps.index_id = i.index_id AND ps.index_id IN (0,1) " +
     "WHERE t.name = ? AND sch.name = ? AND ic.key_ordinal = 0 " +
-    "ORDER BY NON_UNIQUE, TYPE, INDEX_NAME, ORDINAL_POSITION";
+    "ORDER BY NON_UNIQUE, TYPE, INDEX_NAME COLLATE DATABASE_DEFAULT, ORDINAL_POSITION";
 
     private static final String INDEX_INFO_QUERY_DW = "SELECT db_name() AS TABLE_CAT, " +
     "sch.name AS TABLE_SCHEM, " +
@@ -1300,17 +1308,25 @@ public java.sql.ResultSet getIndexInfo(String cat, String schema, String table,
             if (this.connection.isAzureDW()) {
                 return getIndexInfoAzureDW(arguments, table, schema);
             } else {
-                PreparedStatement pstmt = (SQLServerPreparedStatement) this.connection.prepareStatement(INDEX_INFO_COMBINED_QUERY);
-                pstmt.setString(1, arguments[0]);  // table name for sp_statistics
-                pstmt.setString(2, arguments[1]);  // schema name for sp_statistics
-                pstmt.setString(3, arguments[2]);  // catalog for sp_statistics
-                pstmt.setString(4, arguments[3]);  // index name pattern for sp_statistics
-                pstmt.setString(5, arguments[4]);  // is_unique for sp_statistics
-                pstmt.setString(6, arguments[5]);  // accuracy for sp_statistics
-                pstmt.setString(7, table);         // table name for columnstore query
-                pstmt.setString(8, schema);        // schema name for columnstore query
-
-                return pstmt.executeQuery();
+                try {
+                    PreparedStatement pstmt = (SQLServerPreparedStatement) this.connection.prepareStatement(INDEX_INFO_COMBINED_QUERY);
+                    pstmt.setString(1, arguments[0]);  // table name for sp_statistics
+                    pstmt.setString(2, arguments[1]);  // schema name for sp_statistics
+                    pstmt.setString(3, arguments[2]);  // catalog for sp_statistics
+                    pstmt.setString(4, arguments[3]);  // index name pattern for sp_statistics
+                    pstmt.setString(5, arguments[4]);  // is_unique for sp_statistics
+                    pstmt.setString(6, arguments[5]);  // accuracy for sp_statistics
+                    pstmt.setString(7, table);         // table name for columnstore query
+                    pstmt.setString(8, schema);        // schema name for columnstore query
+
+                    return pstmt.executeQuery();
+                } catch (SQLException e) {
+                    if (loggerExternal.isLoggable(Level.FINER)) {
+                        loggerExternal.finer("INDEX_INFO_COMBINED_QUERY failed, falling back to sp_statistics: " + e.getMessage());
+                    }
+                    return getResultSetWithProvidedColumnNames(cat, CallableHandles.SP_STATISTICS, arguments,
+                            getIndexInfoColumnNames);
+                }
             }
         } finally {
             if (null != orgCat) {

src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java

@@ -21,6 +21,7 @@
 import java.sql.CallableStatement;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
@@ -1382,6 +1383,123 @@ public void testGetIndexInfoResultSetNextAfterFalse() throws SQLException {
                 }
             }
         }
+
+        @Test
+        @Tag(Constants.xAzureSQLDW)
+        @Tag(Constants.xAzureSQLDB)
+        public void testGetIndexInfoCollationConflict() throws SQLException {
+            /**
+             * Test case for GitHub Issue #2856: SQLServerDatabaseMetaData getIndexInfo collation conflict reproduction
+             * 
+             * This test reproduces the collation conflict issue where getIndexInfo() fails when 
+             * server collation differs from database collation in INDEX_INFO_COMBINED_QUERY.
+             */
+            
+            UUID id = UUID.randomUUID();
+            String testDbName = "CollationTestDB" + id;
+            String testTableName = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("CollationTestTable"));
+            
+            try (Connection masterConnection = getConnection()) {
+                TestUtils.dropDatabaseIfExists(testDbName, connectionString);
+                
+                // Create test database with different collation
+                try (Statement stmt = masterConnection.createStatement()) {
+                    stmt.execute(String.format("CREATE DATABASE [%s] COLLATE Finnish_Swedish_CI_AS", testDbName));
+                }
+                // Connect to the new database and test getIndexInfo
+                testGetIndexInfoInDifferentCollationDatabase(testDbName, testTableName);
+                
+            } catch (Exception e) {
+                fail(TestResource.getResource("R_unexpectedErrorMessage") + e.getMessage());
+            } finally {
+                TestUtils.dropDatabaseIfExists(testDbName, connectionString);
+            }
+        }
+        
+        /**
+         * Test getIndexInfo with the different collation database
+         */
+        private void testGetIndexInfoInDifferentCollationDatabase(String dbName, String tableName) throws SQLException {
+            try (Connection connection = getConnection(); Statement stmt = connection.createStatement()) {
+                // Switch to the test database with different collation
+                stmt.execute(String.format("USE [%s]", dbName));
+                
+                // Create test table and indexes in the different collation database
+                setupTestTableWithIndexes(connection, tableName);
+                
+                DatabaseMetaData dbmd = connection.getMetaData();
+                
+                // Test getIndexInfo - this should trigger INDEX_INFO_COMBINED_QUERY
+                try (ResultSet rs = dbmd.getIndexInfo(null, "dbo", tableName.replaceAll("\\[|\\]", ""), false, false)) {
+                    boolean foundIndexes = false;
+                    int count = 0;
+                    
+                    while (rs.next() && count < 20) {
+                        String indexName = rs.getString("INDEX_NAME");
+                        
+                        if (indexName != null) {
+                            foundIndexes = true;
+                        }
+                        count++;
+                    }
+                    assertTrue(foundIndexes, "Should find indexes on the test table");
+                }
+            }
+        }
+        
+        /**
+         * Create test table with mixed collation columns and indexes
+         */
+        private void setupTestTableWithIndexes(Connection connection, String tableName) throws SQLException {
+            // Clean up any existing test table first
+            try (Statement stmt = connection.createStatement()) {
+                TestUtils.dropTableIfExists(tableName.replaceAll("\\[|\\]", ""), stmt);
+            }
+            
+            // Create table with mixed collation columns
+            String createTableSql = 
+                "CREATE TABLE " + tableName + " (" +
+                "ID INT IDENTITY(1,1) PRIMARY KEY, " +
+                "NameDefault NVARCHAR(100), " +  // Will inherit Finnish_Swedish_CI_AS
+                "NameLatin1 NVARCHAR(100) COLLATE SQL_Latin1_General_CP1_CI_AS, " +  // Explicit Latin1
+                "NameFinnish NVARCHAR(100), " +  // Will inherit Finnish_Swedish_CI_AS
+                "Description NVARCHAR(255)" +   // Will inherit Finnish_Swedish_CI_AS
+                ")";
+            
+            try (PreparedStatement stmt = connection.prepareStatement(createTableSql)) {
+                stmt.executeUpdate();
+            }
+            
+            // Insert test data
+            String insertSql = "INSERT INTO " + tableName + " (NameDefault, NameLatin1, NameFinnish, Description) VALUES (?, ?, ?, ?)";
+            try (PreparedStatement stmt = connection.prepareStatement(insertSql)) {
+                stmt.setString(1, "Testiarvo1");      // Default (Finnish)
+                stmt.setString(2, "TestValue1");      // Latin1 
+                stmt.setString(3, "Ääkköset1");       // Finnish with special chars
+                stmt.setString(4, "Kuvaus 1");        // Description in Finnish
+                stmt.executeUpdate();
+                
+                stmt.setString(1, "Testiarvo2");      // Default (Finnish)
+                stmt.setString(2, "TestValue2");      // Latin1
+                stmt.setString(3, "Öljytuote2");      // Finnish with special chars  
+                stmt.setString(4, "Kuvaus 2");        // Description in Finnish
+                stmt.executeUpdate();
+            }
+            
+            // Create indexes that may trigger collation conflicts in INDEX_INFO_COMBINED_QUERY
+            String[] indexQueries = {
+                "CREATE NONCLUSTERED INDEX " + AbstractSQLGenerator.escapeIdentifier("IX_CollationTest_Default") + " ON " + tableName + " (NameDefault)",
+                "CREATE NONCLUSTERED INDEX " + AbstractSQLGenerator.escapeIdentifier("IX_CollationTest_Latin1") + " ON " + tableName + " (NameLatin1)", 
+                "CREATE NONCLUSTERED INDEX " + AbstractSQLGenerator.escapeIdentifier("IX_CollationTest_Finnish") + " ON " + tableName + " (NameFinnish)",
+                "CREATE NONCLUSTERED INDEX " + AbstractSQLGenerator.escapeIdentifier("IX_CollationTest_Mixed") + " ON " + tableName + " (NameDefault, NameLatin1, NameFinnish)"
+            };
+            
+            for (String indexSql : indexQueries) {
+                try (PreparedStatement stmt = connection.prepareStatement(indexSql)) {
+                    stmt.executeUpdate();
+                }
+            }
+        }
     }
 
     private void setupProcedures(String schemaName, String proc1, String proc1Body,