diff --git a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java index 2ad08d6..1ebbe21 100644 --- a/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java +++ b/core/src/main/java/com/alibaba/druid/sql/SQLUtils.java @@ -677,6 +677,14 @@ public class SQLUtils { return parseStatements(sql, DbType.of(dbType), features); } + /** + * Reads a whole script; statements the strict parser cannot read come back as + * {@link com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement} in place, the rest as today. + */ + public static List parseStatementsLenient(String sql, DbType dbType) { + return new com.alibaba.druid.sql.parser.LenientScriptParser(sql, dbType).parse(); + } + public static List parseStatements(String sql, DbType dbType, SQLParserFeature... features) { SQLStatementParser parser = SQLParserUtils.createSQLStatementParser(sql, dbType, features); List stmtList = new ArrayList(); diff --git a/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java new file mode 100644 index 0000000..336039b --- /dev/null +++ b/core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnparsedStatement.java @@ -0,0 +1,69 @@ +package com.alibaba.druid.sql.ast.statement; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.SQLStatementImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; +import com.alibaba.druid.sql.visitor.VisitorFeature; + +/** + * A statement the strict parser could not read, kept as its source text by the lenient script read. + */ +public class SQLUnparsedStatement extends SQLStatementImpl { + private final String sql; + private final String error; + private final int line; + private final int column; + + public SQLUnparsedStatement(DbType dbType, String sql, String error, int line, int column) { + super(dbType); + this.sql = sql; + this.error = error; + this.line = line; + this.column = column; + } + + /** The statement's source text, exactly as written, without its delimiter. */ + public String getSql() { + return sql; + } + + /** The strict parser's message for this text, positions counted from the start of the whole script. */ + public String getError() { + return error; + } + + public int getLine() { + return line; + } + + public int getColumn() { + return column; + } + + @Override + protected void accept0(SQLASTVisitor v) { + // nothing to visit + } + + @Override + public void output(StringBuilder buf) { + buf.append(sql); + } + + @Override + public String toString() { + return sql; + } + + @Override + public String toString(VisitorFeature... features) { + return sql; + } + + @Override + public SQLUnparsedStatement clone() { + SQLUnparsedStatement x = new SQLUnparsedStatement(dbType, sql, error, line, column); + x.setAfterSemi(afterSemi); + return x; + } +} diff --git a/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java new file mode 100644 index 0000000..9fba816 --- /dev/null +++ b/core/src/main/java/com/alibaba/druid/sql/parser/LenientScriptParser.java @@ -0,0 +1,462 @@ +package com.alibaba.druid.sql.parser; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement; + +import java.util.ArrayList; +import java.util.List; + +/** + * Reads a whole script in one lexer pass. Every statement the strict parser reads is returned as today; every + * statement it cannot read is returned as {@link SQLUnparsedStatement} holding its exact source text and the strict + * parser's message for that text, with positions moved to the script. The extent of an unparsed statement is found + * by scanning its tokens with the dialect's block structure (a compound statement is one statement) up to the + * semicolon that ends it at the top level; a statement whose lexer never recovers runs to the end of the input. + */ +public class LenientScriptParser { + /** the script as handed in */ + private final String sql; + /** the text the lexer reads: the parser factory rewrites CRLF to LF, so lexer positions refer to this one */ + private final String text; + private final DbType dbType; + private final SQLStatementParser parser; + private final Lexer lexer; + + public LenientScriptParser(String sql, DbType dbType) { + this.sql = sql; + this.dbType = dbType == null ? DbType.other : dbType; + this.parser = SQLParserUtils.createSQLStatementParser(sql, this.dbType, new SQLParserFeature[0]); + this.lexer = parser.getLexer(); + this.text = lexer.text; + } + + /** original offset of a normalized offset; end = true maps the exclusive end of a slice */ + private int orig(int idx, boolean end) { + if (text.length() == sql.length()) { + return idx; + } + if (end) { + if (idx <= 0) { + return 0; + } + return orig(idx - 1, false) + 1; + } + // walk both strings: every "\r\n" of the original is one "\n" of the text + int j = 0; + for (int i = 0; i < idx && j < sql.length(); i++) { + if (sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(i) == '\n') { + j++; + } + j++; + } + if (idx < text.length() && j < sql.length() && sql.charAt(j) == '\r' && j + 1 < sql.length() && sql.charAt(j + 1) == '\n' && text.charAt(idx) == '\n') { + j++; + } + return j; + } + + public List parse() { + List out = new ArrayList(); + while (true) { + // delimiters and comment tokens between statements, handled as the dialect's own loop handles them: the + // base loop hands the comments after a delimiter to the previous statement, Oracle's loop leaves them for + // the next one + try { + while (true) { + while (lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) { + lexer.nextToken(); + } + if (lexer.token() != Token.SEMI) { + break; + } + char ch = lexer.ch; + lexer.nextToken(); + if (!out.isEmpty()) { + SQLStatement last = out.get(out.size() - 1); + last.setAfterSemi(true); + if (!isOracle() && lexer.isKeepComments()) { + if (ch == '\n' && lexer.getComments() != null && !lexer.getComments().isEmpty() + && !(last instanceof com.alibaba.druid.sql.ast.statement.SQLSetStatement)) { + lexer.getComments().add(0, new String("\n")); + } + last.addAfterComment(lexer.readAndResetComments()); + } + } + } + } catch (RuntimeException e) { + // the lexer failed on the first token after a delimiter: that statement runs to the end of the input + addUnparsed(out, firstTokenStart(lexer.mark), text.length()); + return out; + } + if (lexer.token() == Token.EOF) { + break; + } + Lexer.SavePoint sp = lexer.mark(); + int before = out.size(); + boolean ok; + try { + // one statement through the dialect's own loop, which also consumes delimiters and comments as today + parser.parseStatementList(out, before + 1, null); + // what the strict loop accepted as one statement is one statement; only delimiters and comments + // followed by the end of the input add nothing + ok = out.size() == before + 1 || (out.size() == before && lexer.token() == Token.EOF); + } catch (RuntimeException e) { + ok = false; + } + if (ok) { + if (out.size() == before) { + break; + } + continue; + } + while (out.size() > before) { + out.remove(out.size() - 1); + } + lexer.reset(sp); + int[] se = skipStatement(); + addUnparsed(out, se[0], se[1]); + if (se[1] >= text.length()) { + return out; + } + // the lexer stands on the delimiter; the next round's strict loop consumes it as today + } + return out; + } + + /** + * The lexer's startPos for a token that follows kept comments points at the first comment; the statement's text + * begins at its first token, so step over whitespace and comments from there (offsets in the lexer's text). + */ + private int firstTokenStart(int from) { + int i = from < 0 ? 0 : from; + int n = text.length(); + while (i < n) { + char c = text.charAt(i); + if (Character.isWhitespace(c)) { + i++; + } else if (c == '-' && i + 1 < n && text.charAt(i + 1) == '-') { + while (i < n && text.charAt(i) != '\n') { + i++; + } + } else if (c == '#' && isMySql()) { + while (i < n && text.charAt(i) != '\n') { + i++; + } + } else if (c == '/' && i + 1 < n && text.charAt(i + 1) == '*') { + int close = text.indexOf("*/", i + 2); + if (close < 0) { + return i; + } + i = close + 2; + } else { + break; + } + } + return i; + } + + /** start and end are offsets in the lexer's text; the item keeps the original characters */ + private void addUnparsed(List out, int start, int end) { + if (start < 0) { + start = 0; + } + if (end > text.length()) { + end = text.length(); + } + if (end < start) { + end = start; + } + int oStart = orig(start, false); + int oEnd = end >= text.length() ? sql.length() : orig(end, true); + if (oEnd < oStart) { + oEnd = oStart; + } + start = oStart; + String item = sql.substring(oStart, oEnd); + String msg = strictMessage(item); + int line = 1, col = 1; + for (int i = 0; i < start; i++) { + if (sql.charAt(i) == '\n') { + line++; + col = 1; + } else { + col++; + } + } + String moved = move(msg, start, line, col); + int[] lc = lineCol(moved); + SQLUnparsedStatement u = new SQLUnparsedStatement(dbType, item, moved, lc[0], lc[1]); + out.add(u); + } + + /** The strict parser's message for the text on its own. */ + private String strictMessage(String text) { + try { + SQLStatementParser p = SQLParserUtils.createSQLStatementParser(text, dbType, new SQLParserFeature[0]); + List l = new ArrayList(); + p.parseStatementList(l, -1, null); + if (p.getLexer().token() != Token.EOF) { + return "syntax error : " + p.getLexer().info(); + } + return "syntax error"; + } catch (RuntimeException e) { + return e.getMessage() == null ? e.toString() : e.getMessage(); + } + } + + // ------------------------------------------------------------------ extent + + private boolean isMySql() { + return dbType == DbType.mysql || dbType == DbType.mariadb || dbType == DbType.tidb || dbType == DbType.oceanbase + || dbType == DbType.polardbx || dbType == DbType.drds || dbType == DbType.ads; + } + + private boolean isOracle() { + return dbType == DbType.oracle || dbType == DbType.oceanbase_oracle || dbType == DbType.polardb2; + } + + private boolean isSqlServer() { + return dbType == DbType.sqlserver || dbType == DbType.jtds; + } + + private boolean isPg() { + return dbType == DbType.postgresql || dbType == DbType.edb || dbType == DbType.greenplum || dbType == DbType.gaussdb + || dbType == DbType.hologres || dbType == DbType.redshift; + } + + /** + * From the first token of a statement, scan to the delimiter ending it as a top level statement. Returns the end + * offset (exclusive) of its last token and leaves the lexer on that delimiter (or EOF). When the lexer cannot read + * on, the statement runs to the end of the input. + */ + private int[] skipStatement() { + // leading delimiters and comment tokens belong to no statement + try { + while (lexer.token() == Token.SEMI || lexer.token() == Token.MULTI_LINE_COMMENT || lexer.token() == Token.LINE_COMMENT) { + lexer.nextToken(); + } + } catch (RuntimeException e) { + // the lexer failed on the first token: that statement runs to the end of the input + return new int[] {firstTokenStart(lexer.mark), text.length()}; + } + int start = firstTokenStart(lexer.startPos); + if (lexer.token() == Token.EOF) { + return new int[] {start, start}; + } + int depth = 0; + // per depth: whether the next BEGIN at this level is the body of an already opened block (DECLARE, IS/AS) + boolean[] absorb = new boolean[256]; + int end = lexer.pos(); + boolean stmtStart = true; + boolean afterEnd = false; + boolean routinePending = false; + Token prev = null; + while (true) { + Token t = lexer.token(); + if (t == Token.EOF) { + return new int[] {start, end}; + } + if (t == Token.ERROR) { + // a literal, quoted name or comment the lexer could not close runs to the end of the input; + // any other unreadable character is just a token of the statement + char c = lexer.startPos < text.length() ? text.charAt(lexer.startPos) : ' '; + if (lexer.pos() >= text.length() || c == '\'' || c == '"' || c == '`' || c == '[' || c == '/') { + return new int[] {start, text.length()}; + } + } + if (t == Token.SEMI && depth == 0) { + if (isSqlServer()) { + // IF cond stmt; ELSE stmt; is one statement + Lexer.SavePoint sp = lexer.mark(); + try { + lexer.nextToken(); + } catch (RuntimeException e) { + return new int[] {start, text.length()}; + } + if (lexer.token() == Token.ELSE) { + prev = Token.SEMI; + stmtStart = true; + // fall through to treat ELSE as an ordinary token + } else { + lexer.reset(sp); + return new int[] {start, end}; + } + } else { + return new int[] {start, end}; + } + } + t = lexer.token(); + boolean startHere = stmtStart; + boolean opener = false; + boolean closerKeyword = false; + if (afterEnd) { + if (t == Token.IF || t == Token.LOOP || t == Token.CASE || t == Token.WHILE || t == Token.REPEAT + || lexer.identifierEquals("TRY") || lexer.identifierEquals("CATCH")) { + closerKeyword = true; + } + afterEnd = false; + } + if (!closerKeyword) { + if (t == Token.BEGIN) { + opener = beginOpensBlock(); + if (opener && depth > 0 && absorb[depth]) { + opener = false; + absorb[depth] = false; + } + } else if (t == Token.CASE || t == Token.LOOP) { + opener = true; + } else if (t == Token.IF) { + opener = startHere && !isSqlServer(); + } else if (t == Token.WHILE || t == Token.REPEAT) { + opener = startHere && isMySql(); + } else if (t == Token.DECLARE) { + if (startHere && (isOracle() || isPg())) { + opener = true; + if (depth + 1 < absorb.length) { + absorb[depth + 1] = true; + } + } + } else if (t == Token.PROCEDURE || t == Token.FUNCTION || lexer.identifierEquals("PACKAGE")) { + if (isOracle() && (startHere || prev == Token.CREATE || prev == Token.REPLACE)) { + routinePending = true; + } + } else if ((t == Token.IS || t == Token.AS) && routinePending) { + routinePending = false; + opener = true; + if (depth + 1 < absorb.length) { + absorb[depth + 1] = true; + } + } else if (t == Token.END) { + if (depth > 0) { + absorb[depth] = false; + depth--; + } + afterEnd = true; + } + } + if (opener) { + depth++; + if (t == Token.BEGIN || t == Token.LOOP || t == Token.CASE || t == Token.IF || t == Token.WHILE || t == Token.REPEAT) { + // a fresh block: nothing pending to absorb at this level unless set above + if (t != Token.BEGIN && depth < absorb.length && !(t == Token.DECLARE)) { + absorb[depth] = absorb[depth] && false; + } + } + } + stmtStart = t == Token.SEMI || t == Token.BEGIN || t == Token.THEN || t == Token.ELSE || t == Token.DO + || t == Token.LOOP || t == Token.EXCEPTION || t == Token.ELSEIF + || (t == Token.VARIANT && lexer.stringVal() != null && lexer.stringVal().startsWith("$")) + || (t == Token.VARIANT && ":".equals(lexer.stringVal())) + || (t == Token.IS || t == Token.AS) && opener + || t == Token.GTGT; + prev = t; + end = lexer.pos(); + try { + lexer.nextToken(); + } catch (RuntimeException e) { + return new int[] {start, text.length()}; + } + } + } + + /** BEGIN opens a block unless the dialect reads it as a transaction command. Consumes nothing (peeks and resets). */ + private boolean beginOpensBlock() { + if (isOracle()) { + return true; + } + Lexer.SavePoint sp = lexer.mark(); + boolean block; + try { + lexer.nextToken(); + Token n = lexer.token(); + if (isMySql()) { + block = !(n == Token.SEMI || n == Token.EOF || n == Token.IDENTIFIER); + } else if (isSqlServer()) { + block = !(lexer.identifierEquals("TRANSACTION") || lexer.identifierEquals("TRAN") || lexer.identifierEquals("DISTRIBUTED")); + } else { + block = !(n == Token.SEMI || n == Token.EOF || lexer.identifierEquals("WORK") || lexer.identifierEquals("TRANSACTION") + || lexer.identifierEquals("ISOLATION") || lexer.identifierEquals("READ") || lexer.identifierEquals("DEFERRABLE") + || lexer.identifierEquals("NOT")); + } + } catch (RuntimeException e) { + block = true; + } + lexer.reset(sp); + return block; + } + + // ------------------------------------------------------------------ positions + + /** Rewrites every "pos N, line L, column C" in a message from the statement's frame to the script's. */ + static String move(String m, int start, int sLine, int sCol) { + if (m == null) { + return null; + } + StringBuilder sb = new StringBuilder(); + int i = 0; + while (true) { + int p = m.indexOf("pos ", i); + if (p < 0) { + sb.append(m.substring(i)); + break; + } + int pe = p + 4; + while (pe < m.length() && Character.isDigit(m.charAt(pe))) { + pe++; + } + if (pe == p + 4 || !m.startsWith(", line ", pe)) { + sb.append(m, i, pe); + i = pe; + continue; + } + int le = pe + 7; + while (le < m.length() && Character.isDigit(m.charAt(le))) { + le++; + } + if (le == pe + 7 || !m.startsWith(", column ", le)) { + sb.append(m, i, le); + i = le; + continue; + } + int ce = le + 9; + while (ce < m.length() && Character.isDigit(m.charAt(ce))) { + ce++; + } + if (ce == le + 9) { + sb.append(m, i, ce); + i = ce; + continue; + } + int pos = Integer.parseInt(m.substring(p + 4, pe)); + int line = Integer.parseInt(m.substring(pe + 7, le)); + int col = Integer.parseInt(m.substring(le + 9, ce)); + sb.append(m, i, p).append("pos ").append(pos + start).append(", line ").append(line + sLine - 1) + .append(", column ").append(line == 1 ? col + sCol - 1 : col); + i = ce; + } + return sb.toString(); + } + + static int[] lineCol(String m) { + if (m == null) { + return new int[] {-1, -1}; + } + int li = m.indexOf(", line "); + if (li < 0) { + return new int[] {-1, -1}; + } + int l = num(m, li + 7); + int ci = m.indexOf(", column ", li); + int c = ci < 0 ? -1 : num(m, ci + 9); + return new int[] {l, c}; + } + + static int num(String m, int j) { + int k = j; + while (k < m.length() && Character.isDigit(m.charAt(k))) { + k++; + } + return k == j ? -1 : Integer.parseInt(m.substring(j, k)); + } +} diff --git a/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java new file mode 100644 index 0000000..9bdc701 --- /dev/null +++ b/core/src/test/java/com/alibaba/druid/bvt/sql/LenientScriptReadTest.java @@ -0,0 +1,227 @@ +package com.alibaba.druid.bvt.sql; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.SQLUtils; +import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.ast.statement.SQLUnparsedStatement; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +/** + * The lenient whole-script read: SQLUtils.parseStatementsLenient returns what the strict call reads as today and the + * rest as SQLUnparsedStatement carrying the statement's exact text and the strict message for that text on its own, + * with pos, line and column counted from the script start. + */ +public class LenientScriptReadTest { + private static final Pattern POS = Pattern.compile("pos (\\d+), line (\\d+), column (\\d+)"); + + private static List unparsedOf(List list) { + List out = new ArrayList(); + for (SQLStatement s : list) { + if (s instanceof SQLUnparsedStatement) { + out.add((SQLUnparsedStatement) s); + } + } + return out; + } + + /** the message the strict call gives for a text on its own */ + private static String strictMessage(String sql, DbType dbType) { + try { + SQLUtils.parseStatements(sql, dbType); + } catch (Exception e) { + return e.getMessage(); + } + fail("the text should not parse on its own: " + sql); + return null; + } + + /** the same message with pos, line and column counted from the script start, for a statement starting at (offset, line, column) */ + private static String counted(String standalone, int offset, int line, int column) { + Matcher m = POS.matcher(standalone); + StringBuffer sb = new StringBuffer(); + while (m.find()) { + int p = Integer.parseInt(m.group(1)), l = Integer.parseInt(m.group(2)), c = Integer.parseInt(m.group(3)); + m.appendReplacement(sb, "pos " + (p + offset) + ", line " + (l + line - 1) + ", column " + (l == 1 ? c + column - 1 : c)); + } + m.appendTail(sb); + return sb.toString(); + } + + private static int lineOf(String error) { + Matcher m = POS.matcher(error); + assertTrue(m.find(), error); + return Integer.parseInt(m.group(2)); + } + + private static int columnOf(String error) { + Matcher m = POS.matcher(error); + assertTrue(m.find(), error); + return Integer.parseInt(m.group(3)); + } + + @Test + public void allGoodComesBackAsStrict() { + String sql = "select id from t where x = 1; insert into t (a) values (2); update t set a = 3;"; + List strict = SQLUtils.parseStatements(sql, DbType.mysql); + List lenient = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(strict.size(), lenient.size()); + for (int i = 0; i < strict.size(); ++i) { + assertEquals(strict.get(i).toString(), lenient.get(i).toString()); + } + assertTrue(unparsedOf(lenient).isEmpty()); + } + + @Test + public void badSimpleStatementBetweenGoodOnes() { + String bad = "select a from where a = 1"; + String sql = "select 1; " + bad + "; select 3;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(3, list.size()); + assertFalse(list.get(0) instanceof SQLUnparsedStatement); + assertFalse(list.get(2) instanceof SQLUnparsedStatement); + + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals(bad, u.getSql()); + assertEquals(bad, u.toString()); + String standalone = strictMessage(bad, DbType.mysql); + assertEquals(counted(standalone, 10, 1, 11), u.getError()); + assertEquals(lineOf(u.getError()), u.getLine()); + assertEquals(columnOf(u.getError()), u.getColumn()); + } + + @Test + public void errorLineCountedFromScriptStart() { + String sql = "select 1;\nselect * from t where a ==== 1;\nselect 3;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(3, list.size()); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals("select * from t where a ==== 1", u.getSql()); + assertEquals("ERROR. pos 38, line 2, column 27, token ==", u.getError()); + assertEquals(2, u.getLine()); + assertEquals(27, u.getColumn()); + } + + @Test + public void whatFollowsParsesAsTheScriptWithoutIt() { + String script = "select 1; nonsense here; select 2 from t; create table x (id bigint);"; + String without = "select 1; select 2 from t; create table x (id bigint);"; + List lenient = SQLUtils.parseStatementsLenient(script, DbType.mysql); + List strict = SQLUtils.parseStatements(without, DbType.mysql); + assertEquals(4, lenient.size()); + assertTrue(lenient.get(1) instanceof SQLUnparsedStatement); + assertEquals(strict.get(0).toString(), lenient.get(0).toString()); + assertEquals(strict.get(1).toString(), lenient.get(2).toString()); + assertEquals(strict.get(2).toString(), lenient.get(3).toString()); + } + + @Test + public void compoundStatementIsOneStatement() { + String sql = "create procedure p() begin if x > 0 then begin select bad from; end; end if; end; select 7;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(2, list.size()); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(0); + assertEquals("create procedure p() begin if x > 0 then begin select bad from; end; end if; end", u.getSql()); + assertFalse(list.get(1) instanceof SQLUnparsedStatement); + } + + @Test + public void compoundLoopsAreOneStatement() { + String sql = "create procedure p() begin while i < 10 do set i = i + + ; end while; end; select 7;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(2, list.size()); + assertEquals("create procedure p() begin while i < 10 do set i = i + + ; end while; end", + ((SQLUnparsedStatement) list.get(0)).getSql()); + assertFalse(list.get(1) instanceof SQLUnparsedStatement); + } + + @Test + public void oracleDeclareSectionBelongsToTheBlock() { + String sql = "begin null; end;\ndeclare x number; begin x := ; end;\nselect 1 from dual;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.oracle); + assertEquals(3, list.size()); + assertFalse(list.get(0) instanceof SQLUnparsedStatement); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals("declare x number; begin x := ; end", u.getSql()); + assertEquals(2, u.getLine()); + assertFalse(list.get(2) instanceof SQLUnparsedStatement); + } + + @Test + public void sqlServerIfElseBranchesAreOneStatement() { + String sql = "if 1 = 1 select bad from; else select 2;\nselect 3;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.sqlserver); + assertEquals(2, list.size()); + assertEquals("if 1 = 1 select bad from; else select 2", ((SQLUnparsedStatement) list.get(0)).getSql()); + assertFalse(list.get(1) instanceof SQLUnparsedStatement); + } + + @Test + public void keywordsAsNamesFunctionsModifiersAndTransactionsOpenNothing() { + String sql = "begin; select 1; commit; select if(a, 1, 2) from t; select `end` from t; drop table if exists t2;" + + " delete from where a = 1; select 4;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + List bad = unparsedOf(list); + assertEquals(1, bad.size()); + assertEquals("delete from where a = 1", bad.get(0).getSql()); + assertEquals(8, list.size()); + assertFalse(list.get(7) instanceof SQLUnparsedStatement); + } + + @Test + public void unclosedStringRunsToTheEndOfTheInput() { + String tail = "select 'abc; select 3;"; + String sql = "select 1; " + tail; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(2, list.size()); + assertFalse(list.get(0) instanceof SQLUnparsedStatement); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals(tail, u.getSql()); + assertEquals(counted(strictMessage(tail, DbType.mysql), 10, 1, 11), u.getError()); + } + + @Test + public void textIsExactUnderCrlf() { + String bad = "select a from where a = 1"; + String sql = "select 1;\r\n" + bad + ";\r\nselect 3;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(3, list.size()); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals(bad, u.getSql()); + assertEquals(2, u.getLine()); + assertEquals(counted(strictMessage(bad, DbType.mysql), 11, 2, 1), u.getError()); + assertFalse(list.get(2) instanceof SQLUnparsedStatement); + } + + @Test + public void commentAheadOfABadStatementIsNotPartOfItsText() { + String bad = "select a from where a = 1"; + String sql = "select 1;\n-- note\n" + bad + ";\n/* block */ select 3;"; + List list = SQLUtils.parseStatementsLenient(sql, DbType.mysql); + assertEquals(3, list.size()); + SQLUnparsedStatement u = (SQLUnparsedStatement) list.get(1); + assertEquals(bad, u.getSql()); + assertEquals(3, u.getLine()); + assertEquals(counted(strictMessage(bad, DbType.mysql), 18, 3, 1), u.getError()); + assertFalse(list.get(2) instanceof SQLUnparsedStatement); + } + + @Test + public void strictEntryPointsUnchanged() { + try { + SQLUtils.parseStatements("select 1; select a from where a = 1; select 3;", DbType.mysql); + fail("the strict call must still fail on a bad statement"); + } catch (Exception e) { + assertTrue(e.getMessage().contains("pos "), e.getMessage()); + } + } +}