From 602bec0ddca64cad926e2b520f57af71e3864d33 Mon Sep 17 00:00:00 2001 From: Aakash Saravanan Date: Tue, 17 Nov 2026 06:37:46 +0000 Subject: [PATCH] fix: classify CTE-prefixed DML as updates Signed-off-by: Aakash Saravanan --- NEXT_CHANGELOG.md | 2 + .../jdbc/api/impl/DatabricksStatement.java | 53 ++++- .../jdbc/common/util/SqlCommentParser.java | 32 ++- .../api/impl/DatabricksCteStatementTest.java | 221 ++++++++++++++++++ .../impl/DatabricksPreparedStatementTest.java | 15 ++ .../jdbc/common/util/SQLInterpolatorTest.java | 9 + .../common/util/SqlCommentParserTest.java | 39 ++++ 7 files changed, 360 insertions(+), 11 deletions(-) create mode 100644 src/test/java/com/databricks/jdbc/api/impl/DatabricksCteStatementTest.java diff --git a/NEXT_CHANGELOG.md b/NEXT_CHANGELOG.md index a64fbf4ef1..c90b2a841b 100644 --- a/NEXT_CHANGELOG.md +++ b/NEXT_CHANGELOG.md @@ -10,6 +10,8 @@ ### Updated +- `WITH ... INSERT/UPDATE/DELETE/MERGE` statements are now treated as updates: `executeUpdate()` and `executeLargeUpdate()` return the affected-row count instead of throwing after the write. This changes behavior for existing callers: `execute()` now returns `false`, and `executeQuery()` throws `RESULT_SET_ERROR` after the statement has run. To keep receiving the affected-row ResultSet, set `NonRowcountQueryPrefixes=WITH`. Prefixes match the start of the statement, so `NonRowcountQueryPrefixes=INSERT` alone does not opt out for a statement beginning with `WITH`. +- SQL classification and client-side placeholder detection recognize backslash-escaped quotes, raw string literals, and backslash-continued line comments. - Updated JSON-java to 20260814 to address CVE-2026-59171. - Reduced typed result getter CPU by resolving each column's converter once when its metadata is built and reusing it across rows. - Reduced driver CPU when reading Arrow results: `ResultSet.next()` and the `getXxx`/`getObject` getters no longer re-read connection settings, re-parse the column type name, or record telemetry on every row or value. Reading narrow primitive columns (for example a single `BOOLEAN` or `DOUBLE` column) now takes several times less CPU per row. diff --git a/src/main/java/com/databricks/jdbc/api/impl/DatabricksStatement.java b/src/main/java/com/databricks/jdbc/api/impl/DatabricksStatement.java index cea5d19a8f..9a5252e946 100644 --- a/src/main/java/com/databricks/jdbc/api/impl/DatabricksStatement.java +++ b/src/main/java/com/databricks/jdbc/api/impl/DatabricksStatement.java @@ -25,11 +25,17 @@ import java.util.List; import java.util.Map; import java.util.concurrent.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.apache.http.entity.InputStreamEntity; public class DatabricksStatement implements IDatabricksStatement, IDatabricksStatementInternal { private static final JdbcLogger LOGGER = JdbcLoggerFactory.getLogger(DatabricksStatement.class); + private static final Pattern CTE_STATEMENT_PATTERN = + Pattern.compile("\\)\\s*(\\w+)", Pattern.UNICODE_CHARACTER_CLASS); + private static final Pattern DML_PATTERN = + Pattern.compile("INSERT|UPDATE|DELETE|MERGE", Pattern.CASE_INSENSITIVE); /** * Sentinel value indicating update count has not yet been evaluated. Used for lazy evaluation to @@ -806,7 +812,7 @@ static boolean shouldReturnResultSet(String query, List nonRowcountQuery || SHOW_PATTERN.matcher(trimmedQuery).find() || DESCRIBE_PATTERN.matcher(trimmedQuery).find() || EXPLAIN_PATTERN.matcher(trimmedQuery).find() - || WITH_PATTERN.matcher(trimmedQuery).find() + || (WITH_PATTERN.matcher(trimmedQuery).find() && !isCteDml(trimmedQuery)) || SET_PATTERN.matcher(trimmedQuery).find() || MAP_PATTERN.matcher(trimmedQuery).find() || FROM_PATTERN.matcher(trimmedQuery).find() @@ -828,6 +834,37 @@ protected boolean shouldReturnResultSetWithConfig(String query) { query, connection.getConnectionContext().getNonRowcountQueryPrefixes()); } + private static boolean isCteDml(String query) { + // Only the words outside CTE bodies and column lists determine the outer statement. + StringBuilder topLevel = new StringBuilder(); + int[] depth = {0}; + SqlCommentParser.forEachNonCommentChar( + query, + (state, c) -> { + if (state != SqlCommentParser.State.NORMAL) { + return; + } + if (c == '(') { + depth[0]++; + } else if (c == ')') { + depth[0]--; + } + if (depth[0] == 0) { + topLevel.append(c); + } + }); + + Matcher statement = CTE_STATEMENT_PATTERN.matcher(topLevel); + while (statement.find()) { + String keyword = statement.group(1); + // A column list can be followed by AS or MAX RECURSION LEVEL before the CTE body. + if (!keyword.equalsIgnoreCase("AS") && !keyword.equalsIgnoreCase("MAX")) { + return DML_PATTERN.matcher(keyword).matches(); + } + } + return false; + } + static boolean isSelectQuery(String query) { String trimmedQuery = trimCommentsAndWhitespaces(query); return SELECT_PATTERN.matcher(trimmedQuery).find(); @@ -836,17 +873,17 @@ static boolean isSelectQuery(String query) { /** * Returns whether the query can have its result-set metadata retrieved via {@code DESCRIBE QUERY} * without executing it. {@code DESCRIBE QUERY} accepts the query forms that produce a result set - * from a top-level query expression: {@code SELECT}, {@code WITH} (CTEs), {@code VALUES}, {@code - * FROM (...)} and parenthesized selects. Other result-set-producing statements such as {@code - * SHOW}, {@code DESCRIBE} and {@code EXPLAIN} are not valid inputs to {@code DESCRIBE QUERY} and - * must be excluded. + * from a top-level query expression: {@code SELECT}, CTE queries, {@code VALUES}, {@code FROM + * (...)} queries and parenthesized selects. CTE-prefixed DML is excluded, as are other + * result-set-producing statements such as {@code SHOW}, {@code DESCRIBE} and {@code EXPLAIN} that + * are not valid inputs to {@code DESCRIBE QUERY}. */ static boolean isDescribableQuery(String query) { String trimmedQuery = trimCommentsAndWhitespaces(query); return SELECT_PATTERN.matcher(trimmedQuery).find() - || WITH_PATTERN.matcher(trimmedQuery).find() - || VALUES_PATTERN.matcher(trimmedQuery).find() - || FROM_PATTERN.matcher(trimmedQuery).find(); + || (WITH_PATTERN.matcher(trimmedQuery).find() && !isCteDml(trimmedQuery)) + || FROM_PATTERN.matcher(trimmedQuery).find() + || VALUES_PATTERN.matcher(trimmedQuery).find(); } static boolean isInsertQuery(String query) { diff --git a/src/main/java/com/databricks/jdbc/common/util/SqlCommentParser.java b/src/main/java/com/databricks/jdbc/common/util/SqlCommentParser.java index ed3b45743a..ac06b47c2f 100644 --- a/src/main/java/com/databricks/jdbc/common/util/SqlCommentParser.java +++ b/src/main/java/com/databricks/jdbc/common/util/SqlCommentParser.java @@ -34,6 +34,8 @@ public interface IndexedSqlCharConsumer { * Iterates over each character in the SQL string while keeping track of comment, string literal, * and identifier state. Each character that is not part of a comment calls the consumer with the * current state and character. Emits a ' ' character after each comment to avoid token fusion. + * Quote boundaries follow Spark's {@code SqlBaseLexer}; parser settings that change how token + * contents are interpreted do not change those boundaries. * * @param sql the SQL string to parse * @param consumer called for each visible character with its parsing state @@ -54,6 +56,7 @@ public static void forEachNonCommentChar(String sql, IndexedSqlCharConsumer cons State state = State.NORMAL; int blockCommentDepth = 0; + boolean rawString = false; for (int i = 0; i < sql.length(); i++) { char c = sql.charAt(i); @@ -69,9 +72,11 @@ public static void forEachNonCommentChar(String sql, IndexedSqlCharConsumer cons blockCommentDepth = 1; i++; // skip '*' } else if (c == '\'') { + rawString = hasRawStringPrefix(sql, i); state = State.IN_SINGLE_QUOTE; consumer.accept(state, c, i); } else if (c == '"') { + rawString = hasRawStringPrefix(sql, i); state = State.IN_DOUBLE_QUOTE; consumer.accept(state, c, i); } else if (c == '`') { @@ -84,21 +89,29 @@ public static void forEachNonCommentChar(String sql, IndexedSqlCharConsumer cons case IN_SINGLE_QUOTE: consumer.accept(state, c, i); - if (c == '\'' && next == '\'') { + if (!rawString && c == '\\' && next != '\0') { + consumer.accept(state, next, i + 1); + i++; + } else if (!rawString && c == '\'' && next == '\'') { consumer.accept(state, next, i + 1); i++; // skip escaped quote } else if (c == '\'') { state = State.NORMAL; + rawString = false; } break; case IN_DOUBLE_QUOTE: consumer.accept(state, c, i); - if (c == '"' && next == '"') { + if (!rawString && c == '\\' && next != '\0') { + consumer.accept(state, next, i + 1); + i++; + } else if (!rawString && c == '"' && next == '"') { consumer.accept(state, next, i + 1); i++; // skip escaped quote } else if (c == '"') { state = State.NORMAL; + rawString = false; } break; @@ -113,7 +126,9 @@ public static void forEachNonCommentChar(String sql, IndexedSqlCharConsumer cons break; case IN_LINE_COMMENT: - if (c == '\n' || c == '\r') { + if (c == '\\' && next == '\n') { + i++; + } else if (c == '\n' || c == '\r') { state = State.NORMAL; consumer.accept(state, ' ', i); if (c == '\r' && next == '\n') { @@ -141,6 +156,17 @@ public static void forEachNonCommentChar(String sql, IndexedSqlCharConsumer cons } } + private static boolean hasRawStringPrefix(String sql, int quoteIndex) { + if (quoteIndex == 0) { + return false; + } + char prefix = sql.charAt(quoteIndex - 1); + if (prefix != 'r' && prefix != 'R') { + return false; + } + return quoteIndex == 1 || !Character.isJavaIdentifierPart(sql.charAt(quoteIndex - 2)); + } + /** * Finds the source-string indices of placeholder ('?') characters that appear in {@link * State#NORMAL} state — i.e. not inside comments, string literals, or quoted identifiers. Used by diff --git a/src/test/java/com/databricks/jdbc/api/impl/DatabricksCteStatementTest.java b/src/test/java/com/databricks/jdbc/api/impl/DatabricksCteStatementTest.java new file mode 100644 index 0000000000..d4d4d58060 --- /dev/null +++ b/src/test/java/com/databricks/jdbc/api/impl/DatabricksCteStatementTest.java @@ -0,0 +1,221 @@ +package com.databricks.jdbc.api.impl; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import com.databricks.jdbc.api.internal.IDatabricksConnectionContext; +import com.databricks.jdbc.api.internal.IDatabricksSession; +import com.databricks.jdbc.common.StatementType; +import com.databricks.jdbc.common.Warehouse; +import com.databricks.jdbc.dbclient.impl.sqlexec.DatabricksSdkClient; +import com.databricks.jdbc.exception.DatabricksSQLException; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.Collections; +import java.util.Properties; +import java.util.stream.Stream; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +@ExtendWith(MockitoExtension.class) +class DatabricksCteStatementTest { + private static final String JDBC_URL = + "jdbc:databricks://sample-host.18.azuredatabricks.net:443/default;AuthMech=3;httpPath=/sql/1.0/warehouses/99999999;UseThriftClient=0;EnableTelemetry=0;EnableHeartbeat=0;"; + private static final String CTE_INSERT = + "WITH src AS (SELECT 1 AS id) INSERT INTO target SELECT id FROM src"; + private static final String CTE_SELECT = "WITH src AS (SELECT 1 AS id) SELECT id FROM src"; + + @Mock private DatabricksSdkClient client; + @Mock private DatabricksResultSet resultSet; + private DatabricksConnection connection; + + @AfterEach + void closeConnection() throws SQLException { + if (connection != null) { + connection.close(); + } + } + + @ParameterizedTest + @ValueSource( + strings = { + CTE_INSERT, + "WITH src AS (SELECT 1 AS id)\u00a0INSERT INTO target SELECT id FROM src", + "WITH src (SELECT 1 AS id) INSERT INTO target SELECT id FROM src", + "WITH src(id) (SELECT 1) INSERT INTO target SELECT id FROM src", + "WITH src(id) AS (VALUES (1)) INSERT INTO target SELECT id FROM src", + "WITH src(id) MAX RECURSION LEVEL :limit AS (VALUES (1)) INSERT INTO target SELECT id FROM src", + "WITH a AS (SELECT 1 AS id), b(id) AS (SELECT id FROM a) INSERT INTO target SELECT id FROM b", + "WITH a AS (WITH b AS (SELECT 1 AS id) SELECT id FROM b) INSERT INTO target SELECT id FROM a", + "WITH RECURSIVE a AS (SELECT 1 UNION ALL SELECT id + 1 FROM a WHERE id < 3) INSERT INTO target SELECT * FROM a", + "WITH `a)`(`id)`) AS (SELECT 1) INSERT INTO target SELECT * FROM `a)`", + "WITH a AS (SELECT ') UPDATE target' AS txt) INSERT INTO target SELECT txt FROM a", + "WITH a AS (SELECT 'it''s ) INSERT' AS txt) INSERT INTO target SELECT txt FROM a", + "WITH a AS (SELECT r'path\\' AS txt) UPDATE target SET id = 2", + "WITH a AS (SELECT \"column)\" FROM source) INSERT INTO target SELECT * FROM a", + "/* prefix */ wiTh a AS /* body */ (SELECT /* ( /* nested */ ) */ 1) -- main\nINSERT INTO target SELECT * FROM a", + "WITH a AS (SELECT 1 AS id) UPDATE target SET id = 2 WHERE id IN (SELECT id FROM a)", + "WITH a AS (SELECT 1 AS id) DELETE FROM target WHERE id IN (SELECT id FROM a)", + "WITH a AS (SELECT 1 AS id) MERGE INTO target t USING a ON t.id = a.id WHEN MATCHED THEN DELETE", + "WITH AS(id) AS (VALUES (1)) INSERT INTO target SELECT id FROM AS", + "WITH TABLE AS (SELECT 1 AS id) UPDATE target SET id = 2" + }) + void classifiesCteDmlAsUpdateCount(String sql) { + assertFalse(DatabricksStatement.shouldReturnResultSet(sql, Collections.emptyList())); + assertFalse(DatabricksStatement.isDescribableQuery(sql)); + } + + @ParameterizedTest + @ValueSource( + strings = { + CTE_SELECT, + "WITH UPDATE AS (SELECT 1 AS id) SELECT id FROM UPDATE", + "WITH insert AS (SELECT 7 AS id) FROM insert into SELECT *", + "WITH a AS (SELECT 1 AS id) SELECT (id) insert FROM a", + "WITH a AS (SELECT 1 AS id)\u00a0SELECT (id) INSERT FROM a", + "WITH a(id) AS (VALUES (1)), b AS (SELECT * FROM a) SELECT * FROM b", + "WITH a AS (SELECT 'INSERT INTO target' AS txt) SELECT txt FROM a", + "WITH a AS (SELECT 'it\\'s ) DELETE FROM target' AS txt) SELECT txt FROM a", + "WITH a AS (SELECT r'x''it\\'s ) DELETE FROM target' AS txt) SELECT txt FROM a", + "WITH a AS (SELECT 1 -- \\\n) UPDATE target\n) SELECT * FROM a", + "WITH a AS (SELECT 1) SELECT 'DELETE FROM target' FROM a", + "WITH a AS (SELECT 1) (SELECT * FROM a)", + "WITH a AS (SELECT 1) VALUES (2)", + "WITH a AS (SELECT 1) TABLE a", + "WITH a AS (SELECT 1) FROM a SELECT *" + }) + void preservesCteQueryClassification(String sql) { + assertTrue(DatabricksStatement.shouldReturnResultSet(sql, Collections.emptyList())); + assertTrue(DatabricksStatement.isDescribableQuery(sql)); + } + + @ParameterizedTest + @ValueSource(strings = {"WITH", "WITH SRC"}) + void honorsOriginalQueryPrefixOverride(String prefix) { + assertTrue( + DatabricksStatement.shouldReturnResultSet(CTE_INSERT, Collections.singletonList(prefix))); + assertFalse( + DatabricksStatement.shouldReturnResultSet(CTE_INSERT, Collections.singletonList("INSERT"))); + } + + static Stream dmlExecutions() { + return Stream.of(false, true) + .flatMap( + prepared -> + Stream.of("update", "largeUpdate", "execute") + .flatMap( + api -> Stream.of(0L, 1L).map(count -> Arguments.of(prepared, api, count)))); + } + + @ParameterizedTest + @MethodSource("dmlExecutions") + void exposesCteDmlUpdateCounts(boolean prepared, String api, long count) throws Exception { + try (Statement statement = statement(prepared, "")) { + when(resultSet.getUpdateCount()).thenReturn(count); + switch (api) { + case "update": + assertEquals( + count, + prepared + ? ((PreparedStatement) statement).executeUpdate() + : statement.executeUpdate(CTE_INSERT)); + break; + case "largeUpdate": + assertEquals( + count, + prepared + ? ((PreparedStatement) statement).executeLargeUpdate() + : statement.executeLargeUpdate(CTE_INSERT)); + break; + case "execute": + assertFalse( + prepared ? ((PreparedStatement) statement).execute() : statement.execute(CTE_INSERT)); + break; + default: + fail("Unexpected API: " + api); + } + assertEquals(count, statement.getUpdateCount()); + assertEquals(count, statement.getLargeUpdateCount()); + assertNull(statement.getResultSet()); + verifyExecution( + statement, CTE_INSERT, api.equals("execute") ? StatementType.SQL : StatementType.UPDATE); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void rejectsCteDmlInExecuteQuery(boolean prepared) throws Exception { + try (Statement statement = statement(prepared, "")) { + SQLException error = + assertThrows( + DatabricksSQLException.class, + () -> { + if (prepared) { + ((PreparedStatement) statement).executeQuery(); + } else { + statement.executeQuery(CTE_INSERT); + } + }); + assertEquals("RESULT_SET_ERROR", error.getSQLState()); + assertEquals(0, error.getErrorCode()); + assertTrue(error.getMessage().contains("execution was successful")); + verifyExecution(statement, CTE_INSERT, StatementType.QUERY); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void optOutReturnsCteDmlResultSet(boolean prepared) throws Exception { + try (Statement statement = statement(prepared, "NonRowcountQueryPrefixes=WITH;")) { + assertSame( + resultSet, + prepared + ? ((PreparedStatement) statement).executeQuery() + : statement.executeQuery(CTE_INSERT)); + assertSame(resultSet, statement.getResultSet()); + assertEquals(-1, statement.getUpdateCount()); + verifyExecution(statement, CTE_INSERT, StatementType.QUERY); + } + } + + private Statement statement(boolean prepared, String options) throws Exception { + IDatabricksConnectionContext context = + DatabricksConnectionContext.parse(JDBC_URL + options, new Properties()); + connection = new DatabricksConnection(context, client); + Statement statement = + prepared + ? new DatabricksPreparedStatement(connection, CTE_INSERT) + : new DatabricksStatement(connection); + when(client.executeStatement( + eq(CTE_INSERT), + eq(new Warehouse("99999999")), + anyMap(), + any(StatementType.class), + any(IDatabricksSession.class), + eq((DatabricksStatement) statement), + any())) + .thenReturn(resultSet); + return statement; + } + + private void verifyExecution(Statement statement, String sql, StatementType type) + throws Exception { + verify(client) + .executeStatement( + eq(sql), + eq(new Warehouse("99999999")), + anyMap(), + eq(type), + any(IDatabricksSession.class), + eq((DatabricksStatement) statement), + any()); + } +} diff --git a/src/test/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatementTest.java b/src/test/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatementTest.java index 7714736bd0..fef2577070 100644 --- a/src/test/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatementTest.java +++ b/src/test/java/com/databricks/jdbc/api/impl/DatabricksPreparedStatementTest.java @@ -6,8 +6,10 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.startsWith; import static org.mockito.Mockito.lenient; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -293,6 +295,19 @@ public void testGetMetaData_NoResultSet_NonSelectQuery_ReturnNull() throws Excep assertNull(statement.getMetaData()); } + @Test + public void testGetMetaData_NoResultSet_CteDml_ReturnsNull() throws Exception { + String cteInsert = "WITH source AS (SELECT 1 AS id) INSERT INTO target SELECT id FROM source"; + IDatabricksConnectionContext connectionContext = + DatabricksConnectionContext.parse(JDBC_URL, new Properties()); + DatabricksConnection connection = new DatabricksConnection(connectionContext, client); + DatabricksPreparedStatement statement = new DatabricksPreparedStatement(connection, cteInsert); + + assertNull(statement.getMetaData()); + verify(client, never()) + .executeStatement(startsWith("DESCRIBE QUERY"), any(), any(), any(), any(), any(), any()); + } + @Test public void testGetMetaData_NoResultSet_CteQuery_UsesDescribeQuery() throws Exception { // Regression test for issue #1562: getMetaData() must return metadata for CTE (WITH ...) diff --git a/src/test/java/com/databricks/jdbc/common/util/SQLInterpolatorTest.java b/src/test/java/com/databricks/jdbc/common/util/SQLInterpolatorTest.java index 2abb5ed5ca..58ffc68589 100644 --- a/src/test/java/com/databricks/jdbc/common/util/SQLInterpolatorTest.java +++ b/src/test/java/com/databricks/jdbc/common/util/SQLInterpolatorTest.java @@ -173,6 +173,15 @@ public void testQuestionMarkInStringLiteralNotTreatedAsPlaceholder() assertEquals(expected, SQLInterpolator.interpolateSQL(sql, params)); } + @Test + public void testInterpolateAfterBackslashEscapedQuote() throws DatabricksValidationException { + String sql = "SELECT 'it\\'s a path' AS label, ? AS value"; + Map params = new HashMap<>(); + params.put(1, getSqlParam(1, 7, DatabricksTypeUtil.INT)); + assertEquals( + "SELECT 'it\\'s a path' AS label, 7 AS value", SQLInterpolator.interpolateSQL(sql, params)); + } + @Test public void testQuestionMarkInQuotedIdentifierNotTreatedAsPlaceholder() throws DatabricksValidationException { diff --git a/src/test/java/com/databricks/jdbc/common/util/SqlCommentParserTest.java b/src/test/java/com/databricks/jdbc/common/util/SqlCommentParserTest.java index ca3c2ff315..1cf44de28e 100644 --- a/src/test/java/com/databricks/jdbc/common/util/SqlCommentParserTest.java +++ b/src/test/java/com/databricks/jdbc/common/util/SqlCommentParserTest.java @@ -90,6 +90,13 @@ public void testMultipleLineComments() { "-- comment\nSELECT 'foo', \"bar\", `baz` -- comment\n--comment\nFROM table -- comment\n-- comment")); } + @Test + public void testEscapedNewlineContinuesLineComment() { + assertEquals( + "SELECT 1", + SqlCommentParser.stripCommentsAndWhitespaces("-- first\\\nstill comment\nSELECT 1")); + } + // --- Single line block comment tests --- @Test @@ -446,11 +453,43 @@ public void testFindPlaceholderPositionsHandlesEscapedQuotes() { new int[] {sql.indexOf('?', 16)}, SqlCommentParser.findPlaceholderPositions(sql)); } + @Test + public void testFindPlaceholderPositionsHandlesBackslashEscapedQuotes() { + String sql = "select 'it\\'s ?' as x, ? as y from t"; + assertArrayEquals( + new int[] {sql.lastIndexOf('?')}, SqlCommentParser.findPlaceholderPositions(sql)); + + String doubleQuoted = "select \"dir\\\"name?\" as x, ? as y"; + assertArrayEquals( + new int[] {doubleQuoted.lastIndexOf('?')}, + SqlCommentParser.findPlaceholderPositions(doubleQuoted)); + } + + @Test + public void testFindPlaceholderPositionsHandlesRawStringEndingInBackslash() { + String sql = "select r'path\\' as x, ? as y from t"; + assertArrayEquals( + new int[] {sql.indexOf('?', sql.indexOf("as x"))}, + SqlCommentParser.findPlaceholderPositions(sql)); + } + + @Test + public void testFindPlaceholderPositionsSkipsContinuedLineComment() { + String sql = "-- \\\n? still comment\nselect ? from t"; + assertArrayEquals( + new int[] {sql.lastIndexOf('?')}, SqlCommentParser.findPlaceholderPositions(sql)); + } + @Test public void testFindPlaceholderPositionsHandlesCrlfLineComment() { String sql = "-- ?\r\nselect ? from t"; assertArrayEquals( new int[] {sql.indexOf('?', 6)}, SqlCommentParser.findPlaceholderPositions(sql)); + + String backslashBeforeCrlf = "-- \\\r\nselect ? from t"; + assertArrayEquals( + new int[] {backslashBeforeCrlf.lastIndexOf('?')}, + SqlCommentParser.findPlaceholderPositions(backslashBeforeCrlf)); } @Test