fix: support e-strings for PostgreSQL (#607)

PostgreSQL by default follows the SQL standard, which says that quotes inside
quoted strings must be escaped by specifying the quote twice. That is like this:

```sql
'It''s a valid string'
```

PostgreSQL however also supports escaping using a backslash. To enable this, the
string must be prefixed by an e or E:

```sql
e'It\'s a valid string'
```

Author: olavloite

parser/statement_parser.go

@@ -216,6 +216,13 @@ func (p *StatementParser) supportsBackslashEscape() bool {
 	return p.Dialect != databasepb.DatabaseDialect_POSTGRESQL
 }
 
+// supportsEscapeStrings returns true if the dialect supports enabling escaping using backslashes
+// by prepending an e or E to the string. Example:
+// e'It\'s a valid string' => This is the string "It's a valid string".
+func (p *StatementParser) supportsEscapeStrings() bool {
+	return p.Dialect == databasepb.DatabaseDialect_POSTGRESQL
+}
+
 // supportsEscapeQuoteWithQuote returns true if the dialect supports escaping a quote within a quoted
 // literal by repeating the quote twice. Example (note that the way that two single quotes are written in the following
 // examples is something that is enforced by gofmt):
@@ -402,6 +409,17 @@ func (p *StatementParser) skipMultiLineComment(sql []byte, pos int) int {
 // could not be read.
 // The quote length is either 1 for normal quoted strings, and 3 for triple-quoted string.
 func (p *StatementParser) skipQuoted(sql []byte, pos int, quote byte) (int, int, error) {
+	isEscapeString := false
+	if p.supportsEscapeStrings() && pos > 0 {
+		// TODO: Also implement support for the standard_conforming_strings property in PostgreSQL.
+		//       See https://www.postgresql.org/docs/current/runtime-config-compatible.html#GUC-STANDARD-CONFORMING-STRINGS
+		// Check if it is an escape-string. This enables the use of a backslash to start an escape sequence, even if
+		// the dialect normally does not support that. Escape strings start with an e or E, e.g. "e'It\'s valid'".
+		// The second part of the check is to verify that the e or E is not part of a keyword, e.g. WHERE.
+		// The following is valid SQL, but does not designate an escape-string:
+		// SELECT * FROM my_table WHERE'test'=col1;
+		isEscapeString = (sql[pos-1] == 'e' || sql[pos-1] == 'E') && (pos == 1 || !isLatinLetter(sql[pos-2]))
+	}
 	isTripleQuoted := p.supportsTripleQuotedLiterals() && len(sql) > pos+2 && sql[pos+1] == quote && sql[pos+2] == quote
 	if isTripleQuoted && (isMultibyte(sql[pos+1]) || isMultibyte(sql[pos+2])) {
 		isTripleQuoted = false
@@ -434,7 +452,7 @@ func (p *StatementParser) skipQuoted(sql []byte, pos int, quote byte) (int, int,
 				// This was the end quote.
 				return pos + 1, quoteLength, nil
 			}
-		} else if p.supportsBackslashEscape() && len(sql) > pos+1 && c == '\\' && sql[pos+1] == quote {
+		} else if (p.supportsBackslashEscape() || isEscapeString) && len(sql) > pos+1 && c == '\\' && sql[pos+1] == quote {
 			// This is an escaped quote (e.g. 'foo\'bar').
 			// Note that in raw strings, the \ officially does not start an
 			// escape sequence, but the result is still the same, as in a raw

parser/statement_parser_test.go

@@ -897,6 +897,32 @@ SELECT * FROM PersonsTable WHERE id=@id`,
 		?it\'?s'?`)),
 			},
 		},
+		"e-string": {
+			input: `SELECT e'ab\'c?'`,
+			wantSQL: map[databasepb.DatabaseDialect]string{
+				databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL: `SELECT e'ab\'c?'`,
+				databasepb.DatabaseDialect_POSTGRESQL:          `SELECT e'ab\'c?'`,
+			},
+			want: map[databasepb.DatabaseDialect][]string{
+				databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL: {},
+				databasepb.DatabaseDialect_POSTGRESQL:          {},
+			},
+		},
+		"not an e-string": {
+			input: `SELECT * from my_table WHERE'ab\'c?' = col1`,
+			wantSQL: map[databasepb.DatabaseDialect]string{
+				databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL: `SELECT * from my_table WHERE'ab\'c?' = col1`,
+				databasepb.DatabaseDialect_POSTGRESQL:          ``,
+			},
+			want: map[databasepb.DatabaseDialect][]string{
+				databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL: {},
+				databasepb.DatabaseDialect_POSTGRESQL:          nil,
+			},
+			wantErr: map[databasepb.DatabaseDialect]error{
+				databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL: nil,
+				databasepb.DatabaseDialect_POSTGRESQL:          spanner.ToSpannerError(status.Error(codes.InvalidArgument, "SQL statement contains an unclosed literal: SELECT * from my_table WHERE'ab\\'c?' = col1")),
+			},
+		},
 	}
 	for _, dialect := range []databasepb.DatabaseDialect{databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL, databasepb.DatabaseDialect_POSTGRESQL} {
 		parser, err := NewStatementParser(dialect, 1000)