diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Statement.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Statement.java index 40a57bd76ced..07666957f61f 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Statement.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/Statement.java @@ -25,6 +25,7 @@ import com.google.cloud.spanner.connection.AbstractStatementParser.ParametersInfo; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; import com.google.spanner.v1.ExecuteSqlRequest.QueryOptions; import java.io.Serializable; import java.util.Collections; @@ -320,7 +321,7 @@ public static final class StatementFactory { private final Dialect dialect; StatementFactory(Dialect dialect) { - this.dialect = dialect; + this.dialect = checkNotNull(dialect); } public Statement of(String sql) { @@ -353,26 +354,45 @@ public Statement of(String sql) { * *

* - * @param sql SQL statement with unnamed parameters denoted as ? + * @param sql SQL statement with unnamed parameters denoted as {@code ?} * @param values positional list of values for the unnamed parameters in the SQL string * @return Statement a statement that can be executed on Spanner + * @throws NullPointerException if {@code sql} or {@code values} is {@code null} + * @throws SpannerException with {@link ErrorCode#INVALID_ARGUMENT} if the number of {@code ?} + * positional parameters in {@code sql} does not match {@code values.length} (only {@code ?} + * placeholders outside string literals, quoted identifiers, and comments are counted; + * dialect-native placeholders such as {@code @p1} or {@code $1} are not counted) or if + * {@code sql} contains an unclosed literal * @see DatabaseClient#getStatementFactory */ public Statement withUnnamedParameters(String sql, Object... values) { - Map parameters = getUnnamedParametersMap(values); + checkNotNull(sql); + checkNotNull(values); AbstractStatementParser statementParser = AbstractStatementParser.getInstance(this.dialect); ParametersInfo parametersInfo = statementParser.convertPositionalParametersToNamedParameters('?', sql); - return new Statement(parametersInfo.sqlWithNamedParameters, parameters, null); + if (parametersInfo.numberOfParameters != values.length) { + throw SpannerExceptionFactory.newSpannerException( + ErrorCode.INVALID_ARGUMENT, + String.format( + "The number of positional parameters (?) in the SQL statement (%d) does not match" + + " the number of provided values (%d).", + parametersInfo.numberOfParameters, values.length)); + } + if (values.length == 0) { + return Statement.of(parametersInfo.sqlWithNamedParameters); + } + return new Statement( + parametersInfo.sqlWithNamedParameters, getUnnamedParametersMap(values), null); } private Map getUnnamedParametersMap(Object[] values) { - Map parameters = new HashMap<>(); + Map parameters = Maps.newHashMapWithExpectedSize(values.length); int index = 1; for (Object value : values) { parameters.put(getParameterName(index++), Value.toValue(value)); } - return parameters; + return Collections.unmodifiableMap(parameters); } } } diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/AbstractStatementParser.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/AbstractStatementParser.java index 8088d664632d..20e42bc8df33 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/AbstractStatementParser.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/AbstractStatementParser.java @@ -17,6 +17,7 @@ package com.google.cloud.spanner.connection; import static com.google.cloud.spanner.connection.SimpleParser.isValidIdentifierChar; +import static com.google.cloud.spanner.connection.SimpleParser.isValidIdentifierFirstChar; import static com.google.cloud.spanner.connection.StatementHintParser.convertHintsToOptions; import com.google.api.core.InternalApi; @@ -920,6 +921,12 @@ public boolean checkReturningClause(String sql) { /** Returns true if the dialect supports starting an escape sequence with a backslash. */ abstract boolean supportsBackslashEscape(); + /** + * Returns true if the dialect supports escape string constants prefixed with {@code E} or {@code + * e} (e.g. {@code E'foo\'bar'}). + */ + abstract boolean supportsEscapeStringConstants(); + /** * Returns true if the dialect supports single-line comments that start with a dash. * @@ -937,16 +944,18 @@ public boolean checkReturningClause(String sql) { /** Returns the query parameter prefix that should be used for this dialect. */ abstract String getQueryParameterPrefix(); - /** Reads a dollar-quoted string literal from position index in the given sql string. */ + /** Reads a dollar-quoted string literal tag from position index in the given sql string. */ String parseDollarQuotedString(String sql, int index) { - // Look ahead to the next dollar sign (if any). Everything in between is the quote tag. + // Look ahead to the next dollar sign (if any). A non-empty dollar-quote tag follows unquoted + // identifier rules: it must start with a letter or underscore and cannot contain '$'. StringBuilder tag = new StringBuilder(); + int startIndex = index; while (index < sql.length()) { char c = sql.charAt(index); if (c == DOLLAR) { return tag.toString(); } - if (!isValidIdentifierChar(c)) { + if (index == startIndex ? !isValidIdentifierFirstChar(c) : !isValidIdentifierChar(c)) { break; } tag.append(c); @@ -970,7 +979,22 @@ int skip(String sql, int currentIndex, @Nullable StringBuilder result) { || (supportsBacktickQuote() && currentChar == BACKTICK_QUOTE)) { appendIfNotNull(result, currentChar); return skipQuoted(sql, currentIndex, currentChar, result); - } else if (supportsDollarQuotedStrings() && currentChar == DOLLAR) { + } else if (supportsEscapeStringConstants() + && (currentChar == 'E' || currentChar == 'e') + && sql.length() > (currentIndex + 1) + && sql.charAt(currentIndex + 1) == SINGLE_QUOTE + && (currentIndex == 0 || !isValidIdentifierChar(sql.charAt(currentIndex - 1)))) { + // PostgreSQL escape string constants (E'...' / e'...') interpret backslash escapes even + // though standard PostgreSQL string literals do not, and can only start at a token boundary. + appendIfNotNull(result, currentChar); + appendIfNotNull(result, SINGLE_QUOTE); + return skipQuoted( + sql, currentIndex + 1, SINGLE_QUOTE, null, result, /* allowBackslashEscape= */ true); + } else if (supportsDollarQuotedStrings() + && currentChar == DOLLAR + && (currentIndex == 0 || !isValidIdentifierChar(sql.charAt(currentIndex - 1)))) { + // Unquoted PostgreSQL identifiers may contain '$', so a dollar-quoted literal can only start + // when '$' is not preceded by an identifier character. String dollarTag = parseDollarQuotedString(sql, currentIndex + 1); if (dollarTag != null) { appendIfNotNull(result, currentChar, dollarTag, currentChar); @@ -1015,16 +1039,17 @@ static int skipSingleLineComment( /** Skips a multi-line comment from startIndex and adds it to result if result is not null. */ int skipMultiLineComment(String sql, int startIndex, @Nullable StringBuilder result) { SimpleParser simpleParser = new SimpleParser(getDialect(), sql, startIndex, false); - if (simpleParser.skipMultiLineComment()) { - appendIfNotNull(result, sql.substring(startIndex, simpleParser.getPos())); - } + simpleParser.skipMultiLineComment(); + // Always preserve the comment text even when unterminated so malformed SQL is not truncated + // before reaching the server. + appendIfNotNull(result, sql.substring(startIndex, simpleParser.getPos())); return simpleParser.getPos(); } /** Skips a quoted string from startIndex. */ private int skipQuoted( String sql, int startIndex, char startQuote, @Nullable StringBuilder result) { - return skipQuoted(sql, startIndex, startQuote, null, result); + return skipQuoted(sql, startIndex, startQuote, null, result, supportsBackslashEscape()); } /** @@ -1037,6 +1062,16 @@ int skipQuoted( char startQuote, @Nullable String dollarTag, @Nullable StringBuilder result) { + return skipQuoted(sql, startIndex, startQuote, dollarTag, result, supportsBackslashEscape()); + } + + int skipQuoted( + String sql, + int startIndex, + char startQuote, + @Nullable String dollarTag, + @Nullable StringBuilder result, + boolean allowBackslashEscape) { boolean isTripleQuoted = supportsTripleQuotedStrings() && sql.length() > startIndex + 2 @@ -1080,7 +1115,7 @@ int skipQuoted( appendIfNotNull(result, currentChar); return currentIndex + 1; } - } else if (supportsBackslashEscape() + } else if (allowBackslashEscape && currentChar == BACKSLASH && length > currentIndex + 1 && (sql.charAt(currentIndex + 1) == startQuote @@ -1092,7 +1127,9 @@ int skipQuoted( appendIfNotNull(result, sql.charAt(currentIndex + 1)); currentIndex += 2; continue; - } else if (currentChar == '\n' && !isTripleQuoted && !supportsLineFeedInQuotedString()) { + } else if ((currentChar == '\n' || currentChar == '\r') + && !isTripleQuoted + && !supportsLineFeedInQuotedString()) { break; } currentIndex++; diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/PostgreSQLStatementParser.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/PostgreSQLStatementParser.java index 60b64b0cd4f7..b255cc5cd1ce 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/PostgreSQLStatementParser.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/PostgreSQLStatementParser.java @@ -76,6 +76,11 @@ boolean supportsBackslashEscape() { return false; } + @Override + boolean supportsEscapeStringConstants() { + return true; + } + @Override boolean supportsHashSingleLineComments() { return false; @@ -120,9 +125,9 @@ String removeCommentsAndTrimInternal(String sql) { while (index < length) { char c = sql.charAt(index); if (isInSingleLineComment) { - if (c == '\n') { + if (c == '\n' || c == '\r') { isInSingleLineComment = false; - // Include the line feed in the result. + // Include the line break in the result. res.append(c); } } else if (multiLineCommentLevel > 0) { diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SimpleParser.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SimpleParser.java index bfcb48f99a56..96794038e50f 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SimpleParser.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SimpleParser.java @@ -374,12 +374,18 @@ void skipWhitespaces() { */ @VisibleForTesting boolean skipSingleLineComment(int prefixLength) { - int endIndex = sql.indexOf('\n', pos + prefixLength); - if (endIndex == -1) { - pos = sql.length(); - return true; + for (int i = pos + prefixLength; i < sql.length(); i++) { + char c = sql.charAt(i); + if (c == '\n') { + pos = i + 1; + return true; + } + if (c == '\r') { + pos = (i + 1 < sql.length() && sql.charAt(i + 1) == '\n') ? i + 2 : i + 1; + return true; + } } - pos = endIndex + 1; + pos = sql.length(); return true; } @@ -394,13 +400,18 @@ boolean skipMultiLineComment() { && sql.length() > (pos + 1) && sql.charAt(pos + 1) == ASTERISK) { level++; + // Advance past both characters of '/*' so '/*/*/' cannot reuse '*' as '*/'. + pos += 2; + continue; } if (sql.charAt(pos) == ASTERISK && sql.length() > (pos + 1) && sql.charAt(pos + 1) == SLASH) { level--; + // Advance past both characters of '*/' so '*/*' cannot reuse '/' as '/*'. + pos += 2; if (level == 0) { - pos += 2; return true; } + continue; } pos++; } diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SpannerStatementParser.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SpannerStatementParser.java index 3e70170389cc..c6951aa8c887 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SpannerStatementParser.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SpannerStatementParser.java @@ -76,6 +76,11 @@ boolean supportsBackslashEscape() { return true; } + @Override + boolean supportsEscapeStringConstants() { + return false; + } + @Override boolean supportsHashSingleLineComments() { return true; @@ -153,9 +158,9 @@ String removeCommentsAndTrimInternal(String sql) { } else { // We are not in a quoted string. if (isInSingleLineComment) { - if (c == '\n') { + if (c == '\n' || c == '\r') { isInSingleLineComment = false; - // Include the line feed in the result. + // Include the line break in the result. res.append(c); } } else if (isInMultiLineComment) { diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/StatementTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/StatementTest.java index 9381d17ed1ce..33253ed294c2 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/StatementTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/StatementTest.java @@ -27,6 +27,7 @@ import com.google.cloud.ByteArray; import com.google.common.collect.ImmutableMap; import com.google.common.testing.EqualsTester; +import java.util.concurrent.atomic.AtomicBoolean; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @@ -200,4 +201,235 @@ public void testGetParameterName() { assertSame(Statement.getParameterName(i), Statement.getParameterName(i)); } } + + @Test + public void withUnnamedParametersMatchingCounts() { + Statement.StatementFactory gsqlFactory = + new Statement.StatementFactory(Dialect.GOOGLE_STANDARD_SQL); + Statement.StatementFactory pgFactory = new Statement.StatementFactory(Dialect.POSTGRESQL); + + Statement rawOf = gsqlFactory.of("SELECT * FROM Users WHERE id = ?"); + assertThat(rawOf.getSql()).isEqualTo("SELECT * FROM Users WHERE id = ?"); + assertThat(rawOf.getParameters()).isEmpty(); + + Statement gsqlZero = gsqlFactory.withUnnamedParameters("SELECT 1"); + assertThat(gsqlZero.getSql()).isEqualTo("SELECT 1"); + assertThat(gsqlZero.getParameters()).isEmpty(); + assertThrows( + UnsupportedOperationException.class, + () -> gsqlZero.getParameters().put("p1", Value.bool(true))); + + Statement pgZero = pgFactory.withUnnamedParameters("SELECT 1"); + assertThat(pgZero.getSql()).isEqualTo("SELECT 1"); + assertThat(pgZero.getParameters()).isEmpty(); + assertThrows( + UnsupportedOperationException.class, + () -> pgZero.getParameters().put("p1", Value.bool(true))); + + Statement gsqlOne = gsqlFactory.withUnnamedParameters("SELECT * FROM Users WHERE id = ?", 10L); + assertThat(gsqlOne.getSql()).isEqualTo("SELECT * FROM Users WHERE id = @p1"); + assertThat(gsqlOne.getParameters()).containsExactly("p1", Value.toValue(10L)); + assertThrows( + UnsupportedOperationException.class, + () -> gsqlOne.getParameters().put("p2", Value.bool(true))); + reserializeAndAssert(gsqlOne); + + Statement pgOne = pgFactory.withUnnamedParameters("SELECT * FROM users WHERE id = ?", 10L); + assertThat(pgOne.getSql()).isEqualTo("SELECT * FROM users WHERE id = $1"); + assertThat(pgOne.getParameters()).containsExactly("p1", Value.toValue(10L)); + assertThrows( + UnsupportedOperationException.class, + () -> pgOne.getParameters().put("p2", Value.bool(true))); + reserializeAndAssert(pgOne); + + Statement gsqlMulti = + gsqlFactory.withUnnamedParameters( + "INSERT INTO Users (id, name, active) VALUES (?, ?, ?)", 10L, "Alice", true); + assertThat(gsqlMulti.getSql()) + .isEqualTo("INSERT INTO Users (id, name, active) VALUES (@p1, @p2, @p3)"); + assertThat(gsqlMulti.getParameters()) + .containsExactly( + "p1", Value.toValue(10L), "p2", Value.toValue("Alice"), "p3", Value.bool(true)); + assertThrows(UnsupportedOperationException.class, () -> gsqlMulti.getParameters().clear()); + + Statement pgMulti = + pgFactory.withUnnamedParameters( + "INSERT INTO users (id, name, active) VALUES (?, ?, ?)", 10L, "Alice", true); + assertThat(pgMulti.getSql()) + .isEqualTo("INSERT INTO users (id, name, active) VALUES ($1, $2, $3)"); + assertThat(pgMulti.getParameters()) + .containsExactly( + "p1", Value.toValue(10L), "p2", Value.toValue("Alice"), "p3", Value.bool(true)); + assertThrows(UnsupportedOperationException.class, () -> pgMulti.getParameters().clear()); + } + + @Test + public void withUnnamedParametersNullHandling() { + assertThrows(NullPointerException.class, () -> new Statement.StatementFactory(null)); + + Statement.StatementFactory gsqlFactory = + new Statement.StatementFactory(Dialect.GOOGLE_STANDARD_SQL); + Statement.StatementFactory pgFactory = new Statement.StatementFactory(Dialect.POSTGRESQL); + + AtomicBoolean iteratorRequested = new AtomicBoolean(false); + Iterable unconsumedIterable = + () -> { + iteratorRequested.set(true); + throw new AssertionError("Iterator must not be consumed when sql is null"); + }; + + assertThrows(NullPointerException.class, () -> gsqlFactory.withUnnamedParameters(null)); + assertThrows( + NullPointerException.class, + () -> gsqlFactory.withUnnamedParameters(null, unconsumedIterable)); + assertFalse(iteratorRequested.get()); + + assertThrows( + NullPointerException.class, + () -> gsqlFactory.withUnnamedParameters("SELECT ?", (Object[]) null)); + assertThrows( + NullPointerException.class, + () -> pgFactory.withUnnamedParameters("SELECT 1", (Object[]) null)); + + Statement gsqlNullElement = + gsqlFactory.withUnnamedParameters("SELECT * FROM Users WHERE name = ?", (Object) null); + assertThat(gsqlNullElement.getSql()).isEqualTo("SELECT * FROM Users WHERE name = @p1"); + assertThat(gsqlNullElement.hasBinding("p1")).isTrue(); + assertThat(gsqlNullElement.getParameters().get("p1").isNull()).isTrue(); + assertThat(gsqlNullElement.getParameters().get("p1")).isEqualTo(Value.toValue(null)); + + Statement pgNullElement = + pgFactory.withUnnamedParameters("SELECT * FROM users WHERE name = ?", (Object) null); + assertThat(pgNullElement.getSql()).isEqualTo("SELECT * FROM users WHERE name = $1"); + assertThat(pgNullElement.getParameters().get("p1").isNull()).isTrue(); + } + + @Test + public void withUnnamedParametersTooFewValues() { + for (Dialect dialect : Dialect.values()) { + Statement.StatementFactory factory = new Statement.StatementFactory(dialect); + + SpannerException zeroForOne = + assertThrows( + SpannerException.class, + () -> factory.withUnnamedParameters("SELECT * FROM Users WHERE id = ?")); + assertEquals(ErrorCode.INVALID_ARGUMENT, zeroForOne.getErrorCode()); + assertThat(zeroForOne.getMessage()).contains("1"); + assertThat(zeroForOne.getMessage()).contains("0"); + + AtomicBoolean iteratorRequested = new AtomicBoolean(false); + Iterable unconsumedIterable = + () -> { + iteratorRequested.set(true); + throw new AssertionError("Iterator must not be consumed on parameter count mismatch"); + }; + + SpannerException oneForTwo = + assertThrows( + SpannerException.class, + () -> + factory.withUnnamedParameters( + "SELECT * FROM Users WHERE id = ? AND parent_id = ?", unconsumedIterable)); + assertEquals(ErrorCode.INVALID_ARGUMENT, oneForTwo.getErrorCode()); + assertThat(oneForTwo.getMessage()).contains("2"); + assertThat(oneForTwo.getMessage()).contains("1"); + assertFalse(iteratorRequested.get()); + } + } + + @Test + public void withUnnamedParametersTooManyValues() { + for (Dialect dialect : Dialect.values()) { + Statement.StatementFactory factory = new Statement.StatementFactory(dialect); + + SpannerException oneForZero = + assertThrows( + SpannerException.class, () -> factory.withUnnamedParameters("SELECT 1", 10L)); + assertEquals(ErrorCode.INVALID_ARGUMENT, oneForZero.getErrorCode()); + assertThat(oneForZero.getMessage()).contains("0"); + assertThat(oneForZero.getMessage()).contains("1"); + + SpannerException nullElementForZero = + assertThrows( + SpannerException.class, + () -> factory.withUnnamedParameters("SELECT 1", (Object) null)); + assertEquals(ErrorCode.INVALID_ARGUMENT, nullElementForZero.getErrorCode()); + + AtomicBoolean iteratorRequested = new AtomicBoolean(false); + Iterable unconsumedIterable = + () -> { + iteratorRequested.set(true); + throw new AssertionError("Iterator must not be consumed on parameter count mismatch"); + }; + + SpannerException threeForTwo = + assertThrows( + SpannerException.class, + () -> + factory.withUnnamedParameters( + "SELECT * FROM Users WHERE id = ? AND name = ?", + 10L, + "Alice", + unconsumedIterable)); + assertEquals(ErrorCode.INVALID_ARGUMENT, threeForTwo.getErrorCode()); + assertThat(threeForTwo.getMessage()).contains("2"); + assertThat(threeForTwo.getMessage()).contains("3"); + assertFalse(iteratorRequested.get()); + } + + Statement.StatementFactory gsqlFactory = + new Statement.StatementFactory(Dialect.GOOGLE_STANDARD_SQL); + SpannerException gsqlNativePlaceholder = + assertThrows( + SpannerException.class, + () -> gsqlFactory.withUnnamedParameters("SELECT * FROM Users WHERE id = @p1", 10L)); + assertEquals(ErrorCode.INVALID_ARGUMENT, gsqlNativePlaceholder.getErrorCode()); + + Statement.StatementFactory pgFactory = new Statement.StatementFactory(Dialect.POSTGRESQL); + SpannerException pgNativePlaceholder = + assertThrows( + SpannerException.class, + () -> pgFactory.withUnnamedParameters("SELECT * FROM users WHERE id = $1", 10L)); + assertEquals(ErrorCode.INVALID_ARGUMENT, pgNativePlaceholder.getErrorCode()); + } + + @Test + public void withUnnamedParametersIgnoresLiteralsAndComments() { + Statement.StatementFactory gsqlFactory = + new Statement.StatementFactory(Dialect.GOOGLE_STANDARD_SQL); + String gsql = + "-- ? line comment\n" + + "# ? hash comment\r" + + "/* ? block comment */ " + + "SELECT '?', \"?\", `?`, '''?''', 'it\\'s ?' FROM Users WHERE id = ?"; + Statement gsqlStmt = gsqlFactory.withUnnamedParameters(gsql, 42L); + assertThat(gsqlStmt.getSql()).endsWith("WHERE id = @p1"); + assertThat(gsqlStmt.getParameters()).containsExactly("p1", Value.toValue(42L)); + assertEquals( + ErrorCode.INVALID_ARGUMENT, + assertThrows(SpannerException.class, () -> gsqlFactory.withUnnamedParameters(gsql)) + .getErrorCode()); + assertEquals( + ErrorCode.INVALID_ARGUMENT, + assertThrows( + SpannerException.class, () -> gsqlFactory.withUnnamedParameters(gsql, 42L, 99L)) + .getErrorCode()); + + Statement.StatementFactory pgFactory = new Statement.StatementFactory(Dialect.POSTGRESQL); + String pgSql = + "-- ? line comment\r" + + "/* outer /* inner ? */ ? */ " + + "SELECT '?', \"?\", $$?$$, $tag$?$tag$, E'it\\'s ?' FROM users WHERE id = ?"; + Statement pgStmt = pgFactory.withUnnamedParameters(pgSql, 42L); + assertThat(pgStmt.getSql()).endsWith("WHERE id = $1"); + assertThat(pgStmt.getParameters()).containsExactly("p1", Value.toValue(42L)); + assertEquals( + ErrorCode.INVALID_ARGUMENT, + assertThrows(SpannerException.class, () -> pgFactory.withUnnamedParameters(pgSql)) + .getErrorCode()); + assertEquals( + ErrorCode.INVALID_ARGUMENT, + assertThrows(SpannerException.class, () -> pgFactory.withUnnamedParameters(pgSql, 42L, 99L)) + .getErrorCode()); + } } diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SimpleParserTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SimpleParserTest.java index 4747af2093f5..9599d50a785f 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SimpleParserTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SimpleParserTest.java @@ -247,4 +247,45 @@ static String skipHint(String sql) { parser.skipHint(); return parser.getSql().substring(parser.getPos()); } + + @Test + public void testSkipCommentsWithCarriageReturnAndNestedDelimiters() { + SimpleParser crParser = parserFor("-- comment\rSELECT"); + assertTrue(crParser.skipSingleLineComment(2)); + assertEquals("-- comment\r".length(), crParser.getPos()); + assertEquals(found("SELECT"), parserFor("-- comment\rSELECT").eatKeyword()); + + SimpleParser crlfParser = parserFor("-- comment\r\nSELECT"); + assertTrue(crlfParser.skipSingleLineComment(2)); + assertEquals("-- comment\r\n".length(), crlfParser.getPos()); + assertEquals(found("SELECT"), parserFor("-- comment\r\nSELECT").eatKeyword()); + + if (dialect == Dialect.GOOGLE_STANDARD_SQL) { + SimpleParser hashCrParser = parserFor("# comment\rSELECT"); + assertTrue(hashCrParser.skipSingleLineComment(1)); + assertEquals("# comment\r".length(), hashCrParser.getPos()); + assertEquals(found("SELECT"), parserFor("# comment\rSELECT").eatKeyword()); + } + + if (dialect == Dialect.POSTGRESQL) { + SimpleParser unclosedNested = parserFor("/*/*/"); + assertFalse(unclosedNested.skipMultiLineComment()); + assertEquals("/*/*/".length(), unclosedNested.getPos()); + + SimpleParser balancedSlashStarSlash = parserFor("/*/*/ */ */SELECT"); + assertTrue(balancedSlashStarSlash.skipMultiLineComment()); + assertEquals("/*/*/ */ */".length(), balancedSlashStarSlash.getPos()); + assertEquals(found("SELECT"), balancedSlashStarSlash.eatKeyword()); + + SimpleParser balancedStarSlashStar = parserFor("/* /* inner */* outer */SELECT"); + assertTrue(balancedStarSlashStar.skipMultiLineComment()); + assertEquals("/* /* inner */* outer */".length(), balancedStarSlashStar.getPos()); + assertEquals(found("SELECT"), balancedStarSlashStar.eatKeyword()); + } else { + SimpleParser nonNested = parserFor("/*/*/SELECT"); + assertTrue(nonNested.skipMultiLineComment()); + assertEquals("/*/*/".length(), nonNested.getPos()); + assertEquals(found("SELECT"), nonNested.eatKeyword()); + } + } } diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/StatementParserTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/StatementParserTest.java index 2ccdfd7babe3..ee90cb3662bb 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/StatementParserTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/StatementParserTest.java @@ -1926,6 +1926,140 @@ public void testClientSideStatementWithComment() { parsedStatement.getClientSideStatementType()); } + @Test + public void testPostgreSQLEscapeStrings() { + assumeTrue(dialect == Dialect.POSTGRESQL); + + ParametersInfo upperEscape = + parser.convertPositionalParametersToNamedParameters('?', "SELECT E'it\\'s ?', ?"); + assertEquals(1, upperEscape.numberOfParameters); + assertEquals("SELECT E'it\\'s ?', $1", upperEscape.sqlWithNamedParameters); + + ParametersInfo lowerEscape = + parser.convertPositionalParametersToNamedParameters('?', "SELECT e'a\\' ? b\\'', ?"); + assertEquals(1, lowerEscape.numberOfParameters); + assertEquals("SELECT e'a\\' ? b\\'', $1", lowerEscape.sqlWithNamedParameters); + + ParametersInfo trailingBackslash = + parser.convertPositionalParametersToNamedParameters('?', "SELECT E'path\\\\', ?"); + assertEquals(1, trailingBackslash.numberOfParameters); + assertEquals("SELECT E'path\\\\', $1", trailingBackslash.sqlWithNamedParameters); + + ParametersInfo doubledQuoteAndDelimiters = + parser.convertPositionalParametersToNamedParameters( + '?', "SELECT E'doubled''quote?', (?, E'\\'?')"); + assertEquals(1, doubledQuoteAndDelimiters.numberOfParameters); + assertEquals( + "SELECT E'doubled''quote?', ($1, E'\\'?')", + doubledQuoteAndDelimiters.sqlWithNamedParameters); + + // An identifier ending in 'e' or 'E' before a quote is a standard string literal, not E'...'. + ParametersInfo identifierEndingWithE = + parser.convertPositionalParametersToNamedParameters('?', "SELECT cole'\\', ?"); + assertEquals(1, identifierEndingWithE.numberOfParameters); + assertEquals("SELECT cole'\\', $1", identifierEndingWithE.sqlWithNamedParameters); + + assertEquals( + "SELECT E'\\' -- not a comment' \nFROM t", + parser.removeCommentsAndTrim("SELECT E'\\' -- not a comment' -- real comment\nFROM t")); + assertEquals( + ImmutableSet.of("$2"), + ((PostgreSQLStatementParser) parser).getQueryParameters("SELECT E'\\' $1', $2")); + assertFalse(parser.checkReturningClause("INSERT INTO t VALUES (E'\\' RETURNING *')")); + } + + @Test + public void testPostgreSQLDollarQuoteBoundaries() { + assumeTrue(dialect == Dialect.POSTGRESQL); + + ParametersInfo digitTag = + parser.convertPositionalParametersToNamedParameters('?', "SELECT $1$ ? $1$"); + assertEquals(1, digitTag.numberOfParameters); + assertEquals("SELECT $1$ $1 $1$", digitTag.sqlWithNamedParameters); + + ParametersInfo singleDigitTag = + parser.convertPositionalParametersToNamedParameters('?', "SELECT $1$, ?"); + assertEquals(1, singleDigitTag.numberOfParameters); + assertEquals("SELECT $1$, $1", singleDigitTag.sqlWithNamedParameters); + + ParametersInfo midIdentifierSingle = + parser.convertPositionalParametersToNamedParameters('?', "SELECT foo$bar$baz, ?"); + assertEquals(1, midIdentifierSingle.numberOfParameters); + assertEquals("SELECT foo$bar$baz, $1", midIdentifierSingle.sqlWithNamedParameters); + + ParametersInfo midIdentifierPair = + parser.convertPositionalParametersToNamedParameters('?', "SELECT foo$bar$baz, ?, x$bar$y"); + assertEquals(1, midIdentifierPair.numberOfParameters); + assertEquals("SELECT foo$bar$baz, $1, x$bar$y", midIdentifierPair.sqlWithNamedParameters); + + ParametersInfo midIdentifierDoubleDollar = + parser.convertPositionalParametersToNamedParameters('?', "SELECT foo$$bar, ?, x$$y"); + assertEquals(1, midIdentifierDoubleDollar.numberOfParameters); + assertEquals("SELECT foo$$bar, $1, x$$y", midIdentifierDoubleDollar.sqlWithNamedParameters); + + ParametersInfo validDollarQuotes = + parser.convertPositionalParametersToNamedParameters( + '?', "SELECT $$?$$, $_tag_1$?$_tag_1$, ($a$?$a$), ?"); + assertEquals(1, validDollarQuotes.numberOfParameters); + assertEquals( + "SELECT $$?$$, $_tag_1$?$_tag_1$, ($a$?$a$), $1", validDollarQuotes.sqlWithNamedParameters); + } + + @Test + public void testCommentAndCarriageReturnEdgeCases() { + String firstParam = dialect == Dialect.POSTGRESQL ? "$1" : "@p1"; + + ParametersInfo unterminatedComment = + parser.convertPositionalParametersToNamedParameters('?', "SELECT ?, /* unterminated ?"); + assertEquals(1, unterminatedComment.numberOfParameters); + assertEquals( + "SELECT " + firstParam + ", /* unterminated ?", unterminatedComment.sqlWithNamedParameters); + + ParametersInfo crSingleLineComment = + parser.convertPositionalParametersToNamedParameters('?', "-- comment ?\rSELECT ?"); + assertEquals(1, crSingleLineComment.numberOfParameters); + assertEquals("-- comment ?\rSELECT " + firstParam, crSingleLineComment.sqlWithNamedParameters); + assertEquals("SELECT 1", parser.removeCommentsAndTrim("-- comment\rSELECT 1")); + assertEquals("SELECT 1 \rFROM t", parser.removeCommentsAndTrim("SELECT 1 -- comment\rFROM t")); + assertTrue(parser.parse(Statement.of("-- comment\rSELECT 1")).isQuery()); + + if (dialect == Dialect.POSTGRESQL) { + ParametersInfo slashStarSlash = + parser.convertPositionalParametersToNamedParameters('?', "SELECT /*/*/ ? */ ? */ ?"); + assertEquals(1, slashStarSlash.numberOfParameters); + assertEquals("SELECT /*/*/ ? */ ? */ $1", slashStarSlash.sqlWithNamedParameters); + + ParametersInfo starSlashStar = + parser.convertPositionalParametersToNamedParameters('?', "SELECT /* /* inner */* ? */ ?"); + assertEquals(1, starSlashStar.numberOfParameters); + assertEquals("SELECT /* /* inner */* ? */ $1", starSlashStar.sqlWithNamedParameters); + + ParametersInfo pgCrLiteral = + parser.convertPositionalParametersToNamedParameters('?', "SELECT 'line1\r?line2', ?"); + assertEquals(1, pgCrLiteral.numberOfParameters); + assertEquals("SELECT 'line1\r?line2', $1", pgCrLiteral.sqlWithNamedParameters); + } else { + ParametersInfo hashCrComment = + parser.convertPositionalParametersToNamedParameters('?', "# comment ?\rSELECT ?"); + assertEquals(1, hashCrComment.numberOfParameters); + assertEquals("# comment ?\rSELECT @p1", hashCrComment.sqlWithNamedParameters); + assertEquals("SELECT 1", parser.removeCommentsAndTrim("# comment\rSELECT 1")); + assertTrue(parser.parse(Statement.of("# comment\rSELECT 1")).isQuery()); + + assertUnclosedLiteral(parser, "SELECT 'line1\rline2', ?"); + + ParametersInfo tripleQuotedCr = + parser.convertPositionalParametersToNamedParameters('?', "SELECT '''line1\r?line2''', ?"); + assertEquals(1, tripleQuotedCr.numberOfParameters); + assertEquals("SELECT '''line1\r?line2''', @p1", tripleQuotedCr.sqlWithNamedParameters); + + ParametersInfo nonNestedSlashStarSlash = + parser.convertPositionalParametersToNamedParameters('?', "SELECT /*/*/ ?"); + assertEquals(1, nonNestedSlashStarSlash.numberOfParameters); + assertEquals("SELECT /*/*/ @p1", nonNestedSlashStarSlash.sqlWithNamedParameters); + } + } + static void assertUnclosedLiteral(AbstractStatementParser parser, String sql) { SpannerException exception = assertThrows(