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(