Rename SQL parser components.

toverdijk · mp911de · commit c74bd6e3439d · 2022-05-25T11:58:35.000+02:00
[#512][#513]
diff --git a/src/main/java/io/r2dbc/postgresql/ParsedSql.java b/src/main/java/io/r2dbc/postgresql/ParsedSql.java
@@ -20,7 +20,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 
-class TokenizedSql {
+class ParsedSql {
 
     private final String sql;
 
@@ -30,7 +30,7 @@ class TokenizedSql {
 
     private final int parameterCount;
 
-    public TokenizedSql(String sql, List<TokenizedStatement> statements) {
+    public ParsedSql(String sql, List<TokenizedStatement> statements) {
         this.sql = sql;
         this.statements = statements;
         this.statementCount = statements.size();
diff --git a/src/main/java/io/r2dbc/postgresql/PostgresqlBatch.java b/src/main/java/io/r2dbc/postgresql/PostgresqlBatch.java
@@ -40,7 +40,7 @@ final class PostgresqlBatch implements io.r2dbc.postgresql.api.PostgresqlBatch {
     public PostgresqlBatch add(String sql) {
         Assert.requireNonNull(sql, "sql must not be null");
 
-        if (!(PostgresqlSqlLexer.tokenize(sql).getParameterCount() == 0)) {
+        if (!(PostgresqlSqlParser.tokenize(sql).getParameterCount() == 0)) {
             throw new IllegalArgumentException(String.format("Statement '%s' is not supported.  This is often due to the presence of parameters.", sql));
         }
 
diff --git a/src/main/java/io/r2dbc/postgresql/PostgresqlSqlParser.java b/src/main/java/io/r2dbc/postgresql/PostgresqlSqlParser.java
@@ -27,7 +27,7 @@
  *
  * @since 0.9
  */
-class PostgresqlSqlLexer {
+class PostgresqlSqlParser {
 
     private static final char[] SPECIAL_AND_OPERATOR_CHARS = {
         '+', '-', '*', '/', '<', '>', '=', '~', '!', '@', '#', '%', '^', '&', '|', '`', '?',
@@ -38,15 +38,15 @@ class PostgresqlSqlLexer {
         Arrays.sort(SPECIAL_AND_OPERATOR_CHARS);
     }
 
-    public static TokenizedSql tokenize(String sql) {
-        List<TokenizedSql.Token> tokens = new ArrayList<>();
-        List<TokenizedSql.TokenizedStatement> statements = new ArrayList<>();
+    public static ParsedSql tokenize(String sql) {
+        List<ParsedSql.Token> tokens = new ArrayList<>();
+        List<ParsedSql.TokenizedStatement> statements = new ArrayList<>();
 
         int statementStartIndex = 0;
         int i = 0;
         while (i < sql.length()) {
             char c = sql.charAt(i);
-            TokenizedSql.Token token = null;
+            ParsedSql.Token token = null;
 
             if (isWhitespace(c)) {
                 i++;
@@ -73,25 +73,25 @@ public static TokenizedSql tokenize(String sql) {
                     token = getParameterOrDollarQuoteToken(sql, i);
                     break;
                 case ';':
-                    token = new TokenizedSql.Token(TokenizedSql.TokenType.STATEMENT_END, ";");
+                    token = new ParsedSql.Token(ParsedSql.TokenType.STATEMENT_END, ";");
                     break;
                 default:
                     break;
             }
             if (token == null) {
                 if (isSpecialOrOperatorChar(c)) {
-                    token = new TokenizedSql.Token(TokenizedSql.TokenType.SPECIAL_OR_OPERATOR, Character.toString(c));//getSpecialOrOperatorToken(sql, i);
+                    token = new ParsedSql.Token(ParsedSql.TokenType.SPECIAL_OR_OPERATOR, Character.toString(c));//getSpecialOrOperatorToken(sql, i);
                 } else {
                     token = getDefaultToken(sql, i);
                 }
             }
 
             i += token.getValue().length();
 
-            if (token.getType() == TokenizedSql.TokenType.STATEMENT_END) {
+            if (token.getType() == ParsedSql.TokenType.STATEMENT_END) {
 
                 tokens.add(token);
-                statements.add(new TokenizedSql.TokenizedStatement(sql.substring(statementStartIndex, i), tokens));
+                statements.add(new ParsedSql.TokenizedStatement(sql.substring(statementStartIndex, i), tokens));
 
                 tokens = new ArrayList<>();
                 statementStartIndex = i + 1;
@@ -101,27 +101,27 @@ public static TokenizedSql tokenize(String sql) {
         }
         // If tokens is not empty, implicit statement end
         if (!tokens.isEmpty()) {
-            statements.add(new TokenizedSql.TokenizedStatement(sql.substring(statementStartIndex), tokens));
+            statements.add(new ParsedSql.TokenizedStatement(sql.substring(statementStartIndex), tokens));
         }
 
-        return new TokenizedSql(sql, statements);
+        return new ParsedSql(sql, statements);
     }
 
-    private static TokenizedSql.Token getDefaultToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getDefaultToken(String sql, int beginIndex) {
         for (int i = beginIndex + 1; i < sql.length(); i++) {
             char c = sql.charAt(i);
             if (Character.isWhitespace(c) || isSpecialOrOperatorChar(c)) {
-                return new TokenizedSql.Token(TokenizedSql.TokenType.DEFAULT, sql.substring(beginIndex, i));
+                return new ParsedSql.Token(ParsedSql.TokenType.DEFAULT, sql.substring(beginIndex, i));
             }
         }
-        return new TokenizedSql.Token(TokenizedSql.TokenType.DEFAULT, sql.substring(beginIndex));
+        return new ParsedSql.Token(ParsedSql.TokenType.DEFAULT, sql.substring(beginIndex));
     }
 
     private static boolean isSpecialOrOperatorChar(char c) {
         return Arrays.binarySearch(SPECIAL_AND_OPERATOR_CHARS, c) >= 0;
     }
 
-    private static TokenizedSql.Token getBlockCommentToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getBlockCommentToken(String sql, int beginIndex) {
         int depth = 1;
         for (int i = beginIndex + 2; i < (sql.length() - 1); i++) {
             char c1 = sql.charAt(i);
@@ -134,44 +134,44 @@ private static TokenizedSql.Token getBlockCommentToken(String sql, int beginInde
                 i++;
             }
             if (depth == 0) {
-                return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex, i + 1));
+                return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex, i + 1));
             }
         }
         throw new IllegalArgumentException("Sql cannot be parsed: unclosed block comment (comment opened at index " + beginIndex + ") in statement: " + sql);
     }
 
-    private static TokenizedSql.Token getCommentToLineEndToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getCommentToLineEndToken(String sql, int beginIndex) {
         int lineEnding = sql.indexOf('\n', beginIndex);
         if (lineEnding == -1) {
-            return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex));
+            return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex));
         } else {
-            return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex, lineEnding));
+            return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex, lineEnding));
         }
     }
 
-    private static TokenizedSql.Token getDollarQuoteToken(String sql, String tag, int beginIndex) {
+    private static ParsedSql.Token getDollarQuoteToken(String sql, String tag, int beginIndex) {
         int nextQuote = sql.indexOf(tag, beginIndex + tag.length());
         if (nextQuote == -1) {
             throw new IllegalArgumentException("Sql cannot be parsed: unclosed quote (quote opened at index " + beginIndex + ") in statement: " + sql);
         } else {
-            return new TokenizedSql.Token(TokenizedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + tag.length()));
+            return new ParsedSql.Token(ParsedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + tag.length()));
         }
     }
 
-    private static TokenizedSql.Token getParameterToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getParameterToken(String sql, int beginIndex) {
         for (int i = beginIndex + 1; i < sql.length(); i++) {
             char c = sql.charAt(i);
             if (isWhitespace(c) || isSpecialOrOperatorChar(c)) {
-                return new TokenizedSql.Token(TokenizedSql.TokenType.PARAMETER, sql.substring(beginIndex, i));
+                return new ParsedSql.Token(ParsedSql.TokenType.PARAMETER, sql.substring(beginIndex, i));
             }
             if (!isAsciiDigit(c)) {
                 throw new IllegalArgumentException("Sql cannot be parsed: illegal character in parameter or dollar-quote tag: " + c);
             }
         }
-        return new TokenizedSql.Token(TokenizedSql.TokenType.PARAMETER, sql.substring(beginIndex));
+        return new ParsedSql.Token(ParsedSql.TokenType.PARAMETER, sql.substring(beginIndex));
     }
 
-    private static TokenizedSql.Token getParameterOrDollarQuoteToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getParameterOrDollarQuoteToken(String sql, int beginIndex) {
         char firstChar = sql.charAt(beginIndex + 1);
         if (firstChar == '$') {
             return getDollarQuoteToken(sql, "$$", beginIndex);
@@ -191,21 +191,21 @@ private static TokenizedSql.Token getParameterOrDollarQuoteToken(String sql, int
         }
     }
 
-    private static TokenizedSql.Token getStandardQuoteToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getStandardQuoteToken(String sql, int beginIndex) {
         int nextQuote = sql.indexOf('\'', beginIndex + 1);
         if (nextQuote == -1) {
             throw new IllegalArgumentException("Sql cannot be parsed: unclosed quote (quote opened at index " + beginIndex + ") in statement: " + sql);
         } else {
-            return new TokenizedSql.Token(TokenizedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + 1));
+            return new ParsedSql.Token(ParsedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + 1));
         }
     }
 
-    private static TokenizedSql.Token getQuotedIdentifierToken(String sql, int beginIndex) {
+    private static ParsedSql.Token getQuotedIdentifierToken(String sql, int beginIndex) {
         int nextQuote = sql.indexOf('\"', beginIndex + 1);
         if (nextQuote == -1) {
             throw new IllegalArgumentException("Sql cannot be parsed: unclosed quoted identifier (identifier opened at index " + beginIndex + ") in statement: " + sql);
         } else {
-            return new TokenizedSql.Token(TokenizedSql.TokenType.QUOTED_IDENTIFIER, sql.substring(beginIndex, nextQuote + 1));
+            return new ParsedSql.Token(ParsedSql.TokenType.QUOTED_IDENTIFIER, sql.substring(beginIndex, nextQuote + 1));
         }
     }
 
diff --git a/src/main/java/io/r2dbc/postgresql/PostgresqlStatement.java b/src/main/java/io/r2dbc/postgresql/PostgresqlStatement.java
@@ -65,19 +65,19 @@ final class PostgresqlStatement implements io.r2dbc.postgresql.api.PostgresqlSta
 
     private final ConnectionContext connectionContext;
 
-    private final TokenizedSql tokenizedSql;
+    private final ParsedSql parsedSql;
 
     private int fetchSize;
 
     private String[] generatedColumns;
 
     PostgresqlStatement(ConnectionResources resources, String sql) {
         this.resources = Assert.requireNonNull(resources, "resources must not be null");
-        this.tokenizedSql = PostgresqlSqlLexer.tokenize(Assert.requireNonNull(sql, "sql must not be null"));
+        this.parsedSql = PostgresqlSqlParser.tokenize(Assert.requireNonNull(sql, "sql must not be null"));
         this.connectionContext = resources.getClient().getContext();
-        this.bindings = new ArrayDeque<>(this.tokenizedSql.getParameterCount());
+        this.bindings = new ArrayDeque<>(this.parsedSql.getParameterCount());
 
-        if (this.tokenizedSql.getStatementCount() > 1 && this.tokenizedSql.getParameterCount() > 0) {
+        if (this.parsedSql.getStatementCount() > 1 && this.parsedSql.getParameterCount() > 0) {
             throw new IllegalArgumentException(String.format("Statement '%s' cannot be created. This is often due to the presence of both multiple statements and parameters at the same time.", sql));
         }
 
@@ -90,7 +90,7 @@ public PostgresqlStatement add() {
         if (binding != null) {
             binding.validate();
         }
-        this.bindings.add(new Binding(this.tokenizedSql.getParameterCount()));
+        this.bindings.add(new Binding(this.parsedSql.getParameterCount()));
         return this;
     }
 
@@ -117,8 +117,8 @@ public PostgresqlStatement bindNull(String identifier, Class<?> type) {
     public PostgresqlStatement bindNull(int index, Class<?> type) {
         Assert.requireNonNull(type, "type must not be null");
 
-        if (index >= this.tokenizedSql.getParameterCount()) {
-            throw new UnsupportedOperationException(String.format("Cannot bind parameter %d, statement has %d parameters", index, this.tokenizedSql.getParameterCount()));
+        if (index >= this.parsedSql.getParameterCount()) {
+            throw new UnsupportedOperationException(String.format("Cannot bind parameter %d, statement has %d parameters", index, this.parsedSql.getParameterCount()));
         }
 
         BindingLogger.logBindNull(this.connectionContext, index, type);
@@ -130,7 +130,7 @@ public PostgresqlStatement bindNull(int index, Class<?> type) {
     private Binding getCurrentOrFirstBinding() {
         Binding binding = this.bindings.peekLast();
         if (binding == null) {
-            Binding newBinding = new Binding(this.tokenizedSql.getParameterCount());
+            Binding newBinding = new Binding(this.parsedSql.getParameterCount());
             this.bindings.add(newBinding);
             return newBinding;
         } else {
@@ -141,20 +141,20 @@ private Binding getCurrentOrFirstBinding() {
     @Override
     public Flux<io.r2dbc.postgresql.api.PostgresqlResult> execute() {
         if (this.generatedColumns == null) {
-            return execute(this.tokenizedSql.getSql());
+            return execute(this.parsedSql.getSql());
         }
-        return execute(GeneratedValuesUtils.augment(this.tokenizedSql.getSql(), this.generatedColumns));
+        return execute(GeneratedValuesUtils.augment(this.parsedSql.getSql(), this.generatedColumns));
     }
 
     @Override
     public PostgresqlStatement returnGeneratedValues(String... columns) {
         Assert.requireNonNull(columns, "columns must not be null");
 
-        if (this.tokenizedSql.hasDefaultTokenValue("RETURNING")) {
+        if (this.parsedSql.hasDefaultTokenValue("RETURNING")) {
             throw new IllegalStateException("Statement already includes RETURNING clause");
         }
 
-        if (!this.tokenizedSql.hasDefaultTokenValue("DELETE", "INSERT", "UPDATE")) {
+        if (!this.parsedSql.hasDefaultTokenValue("DELETE", "INSERT", "UPDATE")) {
             throw new IllegalStateException("Statement is not a DELETE, INSERT, or UPDATE command");
         }
 
@@ -174,7 +174,7 @@ public String toString() {
         return "PostgresqlStatement{" +
             "bindings=" + this.bindings +
             ", context=" + this.resources +
-            ", sql='" + this.tokenizedSql.getSql() + '\'' +
+            ", sql='" + this.parsedSql.getSql() + '\'' +
             ", generatedColumns=" + Arrays.toString(this.generatedColumns) +
             '}';
     }
@@ -199,7 +199,7 @@ private int getIdentifierIndex(String identifier) {
     private Flux<io.r2dbc.postgresql.api.PostgresqlResult> execute(String sql) {
         ExceptionFactory factory = ExceptionFactory.withSql(sql);
 
-        if (this.tokenizedSql.getParameterCount() != 0) {
+        if (this.parsedSql.getParameterCount() != 0) {
             // Extended query protocol
             if (this.bindings.size() == 0) {
                 throw new IllegalStateException("No parameters have been bound");
diff --git a/src/test/java/io/r2dbc/postgresql/PostgresqlSqlParserTest.java b/src/test/java/io/r2dbc/postgresql/PostgresqlSqlParserTest.java

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ final class PostgresqlBatch implements io.r2dbc.postgresql.api.PostgresqlBatch {`
`40`	`40`	`public PostgresqlBatch add(String sql) {`
`41`	`41`	`Assert.requireNonNull(sql, "sql must not be null");`
`42`	`42`
`43`		`- if (!(PostgresqlSqlLexer.tokenize(sql).getParameterCount() == 0)) {`
	`43`	`+ if (!(PostgresqlSqlParser.tokenize(sql).getParameterCount() == 0)) {`
`44`	`44`	`throw new IllegalArgumentException(String.format("Statement '%s' is not supported. This is often due to the presence of parameters.", sql));`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@`
`27`	`27`	`*`
`28`	`28`	`* @since 0.9`
`29`	`29`	`*/`
`30`		`-class PostgresqlSqlLexer {`
	`30`	`+class PostgresqlSqlParser {`
`31`	`31`
`32`	`32`	`private static final char[] SPECIAL_AND_OPERATOR_CHARS = {`
`33`	`33`	'+', '-', '*', '/', '<', '>', '=', '~', '!', '@', '#', '%', '^', '&', '\|', '`', '?',
`@@ -38,15 +38,15 @@ class PostgresqlSqlLexer {`
`38`	`38`	`Arrays.sort(SPECIAL_AND_OPERATOR_CHARS);`
`39`	`39`	`}`
`40`	`40`
`41`		`- public static TokenizedSql tokenize(String sql) {`
`42`		`- List<TokenizedSql.Token> tokens = new ArrayList<>();`
`43`		`- List<TokenizedSql.TokenizedStatement> statements = new ArrayList<>();`
	`41`	`+ public static ParsedSql tokenize(String sql) {`
	`42`	`+ List<ParsedSql.Token> tokens = new ArrayList<>();`
	`43`	`+ List<ParsedSql.TokenizedStatement> statements = new ArrayList<>();`
`44`	`44`
`45`	`45`	`int statementStartIndex = 0;`
`46`	`46`	`int i = 0;`
`47`	`47`	`while (i < sql.length()) {`
`48`	`48`	`char c = sql.charAt(i);`
`49`		`- TokenizedSql.Token token = null;`
	`49`	`+ ParsedSql.Token token = null;`
`50`	`50`
`51`	`51`	`if (isWhitespace(c)) {`
`52`	`52`	`i++;`
`@@ -73,25 +73,25 @@ public static TokenizedSql tokenize(String sql) {`
`73`	`73`	`token = getParameterOrDollarQuoteToken(sql, i);`
`74`	`74`	`break;`
`75`	`75`	`case ';':`
`76`		`- token = new TokenizedSql.Token(TokenizedSql.TokenType.STATEMENT_END, ";");`
	`76`	`+ token = new ParsedSql.Token(ParsedSql.TokenType.STATEMENT_END, ";");`
`77`	`77`	`break;`
`78`	`78`	`default:`
`79`	`79`	`break;`
`80`	`80`	`}`
`81`	`81`	`if (token == null) {`
`82`	`82`	`if (isSpecialOrOperatorChar(c)) {`
`83`		`- token = new TokenizedSql.Token(TokenizedSql.TokenType.SPECIAL_OR_OPERATOR, Character.toString(c));//getSpecialOrOperatorToken(sql, i);`
	`83`	`+ token = new ParsedSql.Token(ParsedSql.TokenType.SPECIAL_OR_OPERATOR, Character.toString(c));//getSpecialOrOperatorToken(sql, i);`
`84`	`84`	`} else {`
`85`	`85`	`token = getDefaultToken(sql, i);`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`i += token.getValue().length();`
`90`	`90`
`91`		`- if (token.getType() == TokenizedSql.TokenType.STATEMENT_END) {`
	`91`	`+ if (token.getType() == ParsedSql.TokenType.STATEMENT_END) {`
`92`	`92`
`93`	`93`	`tokens.add(token);`
`94`		`- statements.add(new TokenizedSql.TokenizedStatement(sql.substring(statementStartIndex, i), tokens));`
	`94`	`+ statements.add(new ParsedSql.TokenizedStatement(sql.substring(statementStartIndex, i), tokens));`
`95`	`95`
`96`	`96`	`tokens = new ArrayList<>();`
`97`	`97`	`statementStartIndex = i + 1;`
`@@ -101,27 +101,27 @@ public static TokenizedSql tokenize(String sql) {`
`101`	`101`	`}`
`102`	`102`	`// If tokens is not empty, implicit statement end`
`103`	`103`	`if (!tokens.isEmpty()) {`
`104`		`- statements.add(new TokenizedSql.TokenizedStatement(sql.substring(statementStartIndex), tokens));`
	`104`	`+ statements.add(new ParsedSql.TokenizedStatement(sql.substring(statementStartIndex), tokens));`
`105`	`105`	`}`
`106`	`106`
`107`		`- return new TokenizedSql(sql, statements);`
	`107`	`+ return new ParsedSql(sql, statements);`
`108`	`108`	`}`
`109`	`109`
`110`		`- private static TokenizedSql.Token getDefaultToken(String sql, int beginIndex) {`
	`110`	`+ private static ParsedSql.Token getDefaultToken(String sql, int beginIndex) {`
`111`	`111`	`for (int i = beginIndex + 1; i < sql.length(); i++) {`
`112`	`112`	`char c = sql.charAt(i);`
`113`	`113`	`if (Character.isWhitespace(c) \|\| isSpecialOrOperatorChar(c)) {`
`114`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.DEFAULT, sql.substring(beginIndex, i));`
	`114`	`+ return new ParsedSql.Token(ParsedSql.TokenType.DEFAULT, sql.substring(beginIndex, i));`
`115`	`115`	`}`
`116`	`116`	`}`
`117`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.DEFAULT, sql.substring(beginIndex));`
	`117`	`+ return new ParsedSql.Token(ParsedSql.TokenType.DEFAULT, sql.substring(beginIndex));`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`private static boolean isSpecialOrOperatorChar(char c) {`
`121`	`121`	`return Arrays.binarySearch(SPECIAL_AND_OPERATOR_CHARS, c) >= 0;`
`122`	`122`	`}`
`123`	`123`
`124`		`- private static TokenizedSql.Token getBlockCommentToken(String sql, int beginIndex) {`
	`124`	`+ private static ParsedSql.Token getBlockCommentToken(String sql, int beginIndex) {`
`125`	`125`	`int depth = 1;`
`126`	`126`	`for (int i = beginIndex + 2; i < (sql.length() - 1); i++) {`
`127`	`127`	`char c1 = sql.charAt(i);`
`@@ -134,44 +134,44 @@ private static TokenizedSql.Token getBlockCommentToken(String sql, int beginInde`
`134`	`134`	`i++;`
`135`	`135`	`}`
`136`	`136`	`if (depth == 0) {`
`137`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex, i + 1));`
	`137`	`+ return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex, i + 1));`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`	`throw new IllegalArgumentException("Sql cannot be parsed: unclosed block comment (comment opened at index " + beginIndex + ") in statement: " + sql);`
`141`	`141`	`}`
`142`	`142`
`143`		`- private static TokenizedSql.Token getCommentToLineEndToken(String sql, int beginIndex) {`
	`143`	`+ private static ParsedSql.Token getCommentToLineEndToken(String sql, int beginIndex) {`
`144`	`144`	`int lineEnding = sql.indexOf('\n', beginIndex);`
`145`	`145`	`if (lineEnding == -1) {`
`146`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex));`
	`146`	`+ return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex));`
`147`	`147`	`} else {`
`148`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.COMMENT, sql.substring(beginIndex, lineEnding));`
	`148`	`+ return new ParsedSql.Token(ParsedSql.TokenType.COMMENT, sql.substring(beginIndex, lineEnding));`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`- private static TokenizedSql.Token getDollarQuoteToken(String sql, String tag, int beginIndex) {`
	`152`	`+ private static ParsedSql.Token getDollarQuoteToken(String sql, String tag, int beginIndex) {`
`153`	`153`	`int nextQuote = sql.indexOf(tag, beginIndex + tag.length());`
`154`	`154`	`if (nextQuote == -1) {`
`155`	`155`	`throw new IllegalArgumentException("Sql cannot be parsed: unclosed quote (quote opened at index " + beginIndex + ") in statement: " + sql);`
`156`	`156`	`} else {`
`157`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + tag.length()));`
	`157`	`+ return new ParsedSql.Token(ParsedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + tag.length()));`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- private static TokenizedSql.Token getParameterToken(String sql, int beginIndex) {`
	`161`	`+ private static ParsedSql.Token getParameterToken(String sql, int beginIndex) {`
`162`	`162`	`for (int i = beginIndex + 1; i < sql.length(); i++) {`
`163`	`163`	`char c = sql.charAt(i);`
`164`	`164`	`if (isWhitespace(c) \|\| isSpecialOrOperatorChar(c)) {`
`165`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.PARAMETER, sql.substring(beginIndex, i));`
	`165`	`+ return new ParsedSql.Token(ParsedSql.TokenType.PARAMETER, sql.substring(beginIndex, i));`
`166`	`166`	`}`
`167`	`167`	`if (!isAsciiDigit(c)) {`
`168`	`168`	`throw new IllegalArgumentException("Sql cannot be parsed: illegal character in parameter or dollar-quote tag: " + c);`
`169`	`169`	`}`
`170`	`170`	`}`
`171`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.PARAMETER, sql.substring(beginIndex));`
	`171`	`+ return new ParsedSql.Token(ParsedSql.TokenType.PARAMETER, sql.substring(beginIndex));`
`172`	`172`	`}`
`173`	`173`
`174`		`- private static TokenizedSql.Token getParameterOrDollarQuoteToken(String sql, int beginIndex) {`
	`174`	`+ private static ParsedSql.Token getParameterOrDollarQuoteToken(String sql, int beginIndex) {`
`175`	`175`	`char firstChar = sql.charAt(beginIndex + 1);`
`176`	`176`	`if (firstChar == '$') {`
`177`	`177`	`return getDollarQuoteToken(sql, "$$", beginIndex);`
`@@ -191,21 +191,21 @@ private static TokenizedSql.Token getParameterOrDollarQuoteToken(String sql, int`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`
`194`		`- private static TokenizedSql.Token getStandardQuoteToken(String sql, int beginIndex) {`
	`194`	`+ private static ParsedSql.Token getStandardQuoteToken(String sql, int beginIndex) {`
`195`	`195`	`int nextQuote = sql.indexOf('\'', beginIndex + 1);`
`196`	`196`	`if (nextQuote == -1) {`
`197`	`197`	`throw new IllegalArgumentException("Sql cannot be parsed: unclosed quote (quote opened at index " + beginIndex + ") in statement: " + sql);`
`198`	`198`	`} else {`
`199`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + 1));`
	`199`	`+ return new ParsedSql.Token(ParsedSql.TokenType.STRING_CONSTANT, sql.substring(beginIndex, nextQuote + 1));`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`203`		`- private static TokenizedSql.Token getQuotedIdentifierToken(String sql, int beginIndex) {`
	`203`	`+ private static ParsedSql.Token getQuotedIdentifierToken(String sql, int beginIndex) {`
`204`	`204`	`int nextQuote = sql.indexOf('\"', beginIndex + 1);`
`205`	`205`	`if (nextQuote == -1) {`
`206`	`206`	`throw new IllegalArgumentException("Sql cannot be parsed: unclosed quoted identifier (identifier opened at index " + beginIndex + ") in statement: " + sql);`
`207`	`207`	`} else {`
`208`		`- return new TokenizedSql.Token(TokenizedSql.TokenType.QUOTED_IDENTIFIER, sql.substring(beginIndex, nextQuote + 1));`
	`208`	`+ return new ParsedSql.Token(ParsedSql.TokenType.QUOTED_IDENTIFIER, sql.substring(beginIndex, nextQuote + 1));`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`