Few more test combinations

Author: David-Engel

src/test/java/com/microsoft/sqlserver/jdbc/preparedStatement/BatchExecutionWithBulkCopyTest.java

@@ -30,11 +30,13 @@
 import java.util.Calendar;
 import java.util.Random;
 import java.util.UUID;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.platform.runner.JUnitPlatform;
@@ -1408,51 +1410,28 @@ private void getCreateTableTemporalSQL(String tableName) throws SQLException {
         }
     }
 
-    /**
-     * Test insert-select fallback to normal execution for bulk copy API
-     */
-    @Test
-    public void testInsertSelectFallbackToNormalExecution() throws Exception {
-        String tableNameSource = AbstractSQLGenerator.escapeIdentifier("SourceTable");
-        String tableNameDestination = AbstractSQLGenerator.escapeIdentifier("DestinationTable");
-
-        String connectStringUrl = connectionString
-                + ";useBulkCopyForBatchInsert=true;sendStringParametersAsUnicode=false;";
-
-        try (Connection connection = PrepUtil.getConnection(connectStringUrl);
-                Statement stmt = connection.createStatement()) {
+    class FallbackWatcherLogHandler extends Handler implements AutoCloseable {
 
-            TestUtils.dropTableIfExists(tableNameSource, stmt);
-            String createSourceTableSQL = "CREATE TABLE " + tableNameSource + " (id INT, value VARCHAR(50))";
-            stmt.execute(createSourceTableSQL);
+        Logger stmtLogger = Logger.getLogger("com.microsoft.sqlserver.jdbc.internals.SQLServerStatement");
+        boolean gotFallbackMessage = false;
 
-            String insertSourceDataSQL = "INSERT INTO " + tableNameSource + " VALUES (1, 'TestValue1'), (2, 'TestValue2')";
-            stmt.execute(insertSourceDataSQL);
-
-            TestUtils.dropTableIfExists(tableNameDestination, stmt);
-            String createDestinationTableSQL = "CREATE TABLE " + tableNameDestination + " (id INT, value VARCHAR(50))";
-            stmt.execute(createDestinationTableSQL);
-
-            // Attempt unsupported INSERT-SELECT query for bulk copy api
-            String insertSelectSQL = "INSERT INTO " + tableNameDestination + " SELECT * FROM " + tableNameSource
-                    + " WHERE value = ?";
+        public FallbackWatcherLogHandler() {
+            stmtLogger.addHandler(this);
+        }
 
-            try (SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) connection
-                    .prepareStatement(insertSelectSQL)) {
-                pstmt.setString(1, "TestValue1");
-                pstmt.addBatch();
-                pstmt.executeBatch(); // This should fall back to normal execution flow
+        @Override
+        public void publish(LogRecord record) {
+            if (record.getMessage().contains("Falling back to the original implementation for Batch Insert.")) {
+                gotFallbackMessage = true;
             }
+        }
 
-            // Validate inserted data in destination table
-            String selectSQL = "SELECT * FROM " + tableNameDestination;
-            try (ResultSet rs = stmt.executeQuery(selectSQL)) {
-                assertTrue(rs.next(), "Expected at least one row in result set");
-                assertEquals(1, rs.getInt("id"));
-                assertEquals("TestValue1", rs.getString("value"));
+        @Override
+        public void flush() {}
 
-                Assertions.assertFalse(rs.next(), "No more rows expected");
-            }
+        @Override
+        public void close() throws SecurityException {
+            stmtLogger.removeHandler(this);
         }
     }
 
@@ -1469,6 +1448,7 @@ public void testBulkInsertStringAllCombinations() throws Exception {
         for (boolean useBulkCopy : bulkCopyOptions) {
             for (boolean sendUnicode : unicodeOptions) {
                 runBulkInsertStringTest(useBulkCopy, sendUnicode);
+                runBulkInsertStringTestForceFallback(useBulkCopy, sendUnicode);
             }
         }
     }
@@ -1532,6 +1512,166 @@ public void runBulkInsertStringTest(boolean useBulkCopy, boolean sendUnicode) th
         }
     }
 
+    /**
+     * Test batch insert using an unsupported statement (falls back to batch mode) with accented and Unicode characters.
+     */
+    public void runBulkInsertStringTestForceFallback(boolean useBulkCopy, boolean sendUnicode) throws Exception {
+        String insertSQL = "INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableNameBulkString)
+                + " (charCol, varcharCol, longvarcharCol, ncharCol1, nvarcharCol1, longnvarcharCol1, "
+                + "ncharCol2, nvarcharCol2, longnvarcharCol2) VALUES ('Anaïs_Ni', ?, ?, ?, ?, ?, ?, ?, ?)";
+
+        String selectSQL = "SELECT charCol, varcharCol, longvarcharCol, ncharCol1, nvarcharCol1, "
+                + "longnvarcharCol1, ncharCol2, nvarcharCol2, longnvarcharCol2 FROM "
+                + AbstractSQLGenerator.escapeIdentifier(tableNameBulkString);
+
+        try (Connection connection = PrepUtil.getConnection(connectionString + ";useBulkCopyForBatchInsert="
+                + useBulkCopy + ";sendStringParametersAsUnicode=" + sendUnicode + ";");
+                SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) connection.prepareStatement(insertSQL);
+                Statement stmt = (SQLServerStatement) connection.createStatement()) {
+
+            getCreateTableWithStringData();
+
+            String charValue = "Anaïs_Ni";
+            String varcharValue = "café";
+            String longVarcharValue = "Sørén Kierkégaard";
+            String ncharValue1 = "José Müll";
+            String nvarcharValue1 = "José Müller";
+            String longNvarcharValue1 = "François Saldaña";
+            String ncharValue2 = "Test1汉字😀";
+            String nvarcharValue2 = "汉字";
+            String longNvarcharValue2 = "日本語";
+
+            pstmt.setString(1, varcharValue);
+            pstmt.setString(2, longVarcharValue);
+            pstmt.setString(3, ncharValue1);
+            pstmt.setString(4, nvarcharValue1);
+            pstmt.setString(5, longNvarcharValue1);
+            pstmt.setNString(6, ncharValue2);
+            pstmt.setNString(7, nvarcharValue2);
+            pstmt.setNString(8, longNvarcharValue2);
+            pstmt.addBatch();
+
+            try (FallbackWatcherLogHandler handler = new FallbackWatcherLogHandler()) {
+                pstmt.executeBatch();
+                if (useBulkCopy) {
+                    assertTrue(handler.gotFallbackMessage);
+                }
+            }
+
+            // Validate inserted data
+            try (ResultSet rs = stmt.executeQuery(selectSQL)) {
+                assertTrue(rs.next(), "Expected at least one row in result set");
+                assertEquals(charValue, rs.getString("charCol"));
+                assertEquals(varcharValue, rs.getString("varcharCol"));
+                assertEquals(longVarcharValue, rs.getString("longvarcharCol"));
+                assertEquals(ncharValue1, rs.getString("ncharCol1"));
+                assertEquals(nvarcharValue1, rs.getString("nvarcharCol1"));
+                assertEquals(longNvarcharValue1, rs.getString("longnvarcharCol1"));
+                assertEquals(ncharValue2, rs.getString("ncharCol2"));
+                assertEquals(nvarcharValue2, rs.getString("nvarcharCol2"));
+                assertEquals(longNvarcharValue2, rs.getString("longnvarcharCol2"));
+                assertFalse(rs.next());
+            }
+        }
+    }
+
+    @Test
+    public void testIssue2669Repro() throws Exception {
+        // Original repro
+        testIssue2669Variation(false, true);
+        // Variations
+        testIssue2669Variation(false, false);
+        testIssue2669Variation(true, true);
+        testIssue2669Variation(true, false);
+
+        // Test the same combos except falling back to batch insert
+        testIssue2669VariationForceFallback(false, true);
+        testIssue2669VariationForceFallback(false, false);
+        testIssue2669VariationForceFallback(true, true);
+        testIssue2669VariationForceFallback(true, false);
+    }
+
+    public void testIssue2669Variation(boolean sendStringsAsUnicode,
+            boolean useBulkCopyForBatchInsert) throws Exception {
+        String statesTable = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("states"));
+        try (Statement stmt = connection.createStatement()) {
+            TestUtils.dropTableIfExists(statesTable, stmt);
+            String createTableSQL = "CREATE TABLE " + statesTable + " (" + "StateCode nvarchar(50) NOT NULL " + ")";
+
+            stmt.execute(createTableSQL);
+        }
+
+        String insertSQL = "INSERT INTO " + statesTable + " (StateCode) VALUES (?)";
+
+        String selectSQL = "SELECT StateCode FROM " + statesTable;
+
+        try (Connection connection = PrepUtil.getConnection(connectionString + ";useBulkCopyForBatchInsert="
+                + useBulkCopyForBatchInsert + ";sendStringParametersAsUnicode=" + sendStringsAsUnicode + ";");
+                SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) connection.prepareStatement(insertSQL);
+                Statement stmt = (SQLServerStatement) connection.createStatement()) {
+
+            pstmt.setString(1, "OH");
+            pstmt.addBatch();
+            pstmt.executeBatch();
+
+            // Validate inserted data
+            try (ResultSet rs = stmt.executeQuery(selectSQL)) {
+                assertTrue(rs.next(), "Expected at least one row in result set");
+                assertEquals("OH", rs.getString("StateCode"));
+                assertFalse(rs.next());
+            }
+        } finally {
+            try (Statement stmt = connection.createStatement()) {
+                TestUtils.dropTableIfExists(statesTable, stmt);
+            }
+        }
+    }
+
+    public void testIssue2669VariationForceFallback(boolean sendStringsAsUnicode,
+            boolean useBulkCopyForBatchInsert) throws SQLException {
+        String statesTable = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("states"));
+        try (Statement stmt = connection.createStatement()) {
+            TestUtils.dropTableIfExists(statesTable, stmt);
+            String createTableSQL = "CREATE TABLE " + statesTable
+                    + " (StateCode nvarchar(50), StateCode2 nvarchar(50) NOT NULL " + ")";
+
+            stmt.execute(createTableSQL);
+        }
+
+        // Use an INSERT that forces fall back to plain batch insert
+        String insertSQL = "INSERT INTO " + statesTable + " (StateCode, StateCode2) VALUES ('NA', ?)";
+
+        String selectSQL = "SELECT StateCode, StateCode2 FROM " + statesTable;
+
+        try (Connection connection = PrepUtil.getConnection(connectionString + ";useBulkCopyForBatchInsert="
+                + useBulkCopyForBatchInsert + ";sendStringParametersAsUnicode=" + sendStringsAsUnicode + ";");
+                SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) connection.prepareStatement(insertSQL);
+                Statement stmt = (SQLServerStatement) connection.createStatement()) {
+
+                pstmt.setString(1, "OH");
+                pstmt.addBatch();
+
+                try (FallbackWatcherLogHandler handler = new FallbackWatcherLogHandler()) {
+                    pstmt.executeBatch();
+                    if (useBulkCopyForBatchInsert) {
+                        assertTrue(handler.gotFallbackMessage);
+                    }
+                }
+
+            // Validate inserted data
+            try (ResultSet rs = stmt.executeQuery(selectSQL)) {
+                assertTrue(rs.next(), "Expected at least one row in result set");
+                assertEquals("NA", rs.getString("StateCode"));
+                assertEquals("OH", rs.getString("StateCode2"));
+                assertFalse(rs.next());
+            }
+        } finally {
+            try (Statement stmt = connection.createStatement()) {
+                TestUtils.dropTableIfExists(statesTable, stmt);
+            }
+        }
+    }
+
     private void getCreateTableWithStringData() throws SQLException {
         try (Statement stmt = connection.createStatement()) {
             TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableNameBulkString), stmt);
@@ -1580,6 +1720,7 @@ public static void terminateVariation() throws SQLException {
             TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(doubleQuoteTableName), stmt);
             TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(schemaTableName), stmt);
             TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableNameBulkString), stmt);
+            TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableNameBulkComputedCols), stmt);
         }
     }
 }