diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLBinaryOperator.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLBinaryOperator.java index 56c4b01bcc..5508a64929 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLBinaryOperator.java +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLBinaryOperator.java @@ -58,6 +58,7 @@ public enum SQLBinaryOperator { LessThanOrGreater("<>", 110), Like("LIKE", 110), + SoudsLike("SOUNDS LIKE", 110), NotLike("NOT LIKE", 110), ILike("ILIKE", 110), diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLCastExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLCastExpr.java index 04b80f0110..bc40f66096 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLCastExpr.java +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLCastExpr.java @@ -15,17 +15,14 @@ */ package com.alibaba.druid.sql.ast.expr; -import com.alibaba.druid.sql.ast.SQLDataType; -import com.alibaba.druid.sql.ast.SQLExpr; -import com.alibaba.druid.sql.ast.SQLExprImpl; -import com.alibaba.druid.sql.ast.SQLObjectWithDataType; +import com.alibaba.druid.sql.ast.*; import com.alibaba.druid.sql.visitor.SQLASTVisitor; import java.util.Arrays; import java.util.Collections; import java.util.List; -public class SQLCastExpr extends SQLExprImpl implements SQLObjectWithDataType { +public class SQLCastExpr extends SQLExprImpl implements SQLObjectWithDataType, SQLReplaceable { protected SQLExpr expr; protected SQLDataType dataType; @@ -64,6 +61,16 @@ public class SQLCastExpr extends SQLExprImpl implements SQLObjectWithDataType { visitor.endVisit(this); } + @Override + public boolean replace(SQLExpr expr, SQLExpr target) { + if (this.expr == expr) { + setExpr(target); + return true; + } + + return false; + } + @Override public List getChildren() { return Arrays.asList(this.expr, this.dataType); diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLContainsExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLContainsExpr.java new file mode 100644 index 0000000000..bc8687a758 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLContainsExpr.java @@ -0,0 +1,168 @@ +/* + * Copyright 1999-2018 Alibaba Group Holding Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.druid.sql.ast.expr; + +import com.alibaba.druid.sql.ast.*; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +public final class SQLContainsExpr extends SQLExprImpl implements SQLReplaceable, Serializable { + + private static final long serialVersionUID = 1L; + private boolean not = false; + private SQLExpr expr; + private List targetList = new ArrayList(); + + public SQLContainsExpr() { + + } + + public SQLContainsExpr(SQLExpr expr) { + this.setExpr(expr); + } + + public SQLContainsExpr(SQLExpr expr, boolean not) { + this.setExpr(expr); + this.not = not; + } + + public SQLContainsExpr clone() { + SQLContainsExpr x = new SQLContainsExpr(); + x.not = not; + if (expr != null) { + x.setExpr(expr.clone()); + } + for (SQLExpr e : targetList) { + SQLExpr e2 = e.clone(); + e2.setParent(x); + x.targetList.add(e2); + } + return x; + } + + public boolean isNot() { + return this.not; + } + + public void setNot(boolean not) { + this.not = not; + } + + public SQLExpr getExpr() { + return this.expr; + } + + public void setExpr(SQLExpr expr) { + if (expr != null) { + expr.setParent(this); + } + + this.expr = expr; + } + + public List getTargetList() { + return this.targetList; + } + + public void setTargetList(List targetList) { + this.targetList = targetList; + } + + protected void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + acceptChild(visitor, this.expr); + acceptChild(visitor, this.targetList); + } + + visitor.endVisit(this); + } + + public List getChildren() { + List children = new ArrayList(); + if (this.expr != null) { + children.add(this.expr); + } + children.addAll(this.targetList); + return children; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((expr == null) ? 0 : expr.hashCode()); + result = prime * result + (not ? 1231 : 1237); + result = prime * result + ((targetList == null) ? 0 : targetList.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + SQLContainsExpr other = (SQLContainsExpr) obj; + if (expr == null) { + if (other.expr != null) { + return false; + } + } else if (!expr.equals(other.expr)) { + return false; + } + if (not != other.not) { + return false; + } + if (targetList == null) { + if (other.targetList != null) { + return false; + } + } else if (!targetList.equals(other.targetList)) { + return false; + } + return true; + } + + public SQLDataType computeDataType() { + return SQLBooleanExpr.DEFAULT_DATA_TYPE; + } + + @Override + public boolean replace(SQLExpr expr, SQLExpr target) { + if (this.expr == expr) { + setExpr(target); + return true; + } + + for (int i = 0; i < targetList.size(); i++) { + if (targetList.get(i) == expr) { + targetList.set(i, target); + target.setParent(this); + return true; + } + } + + return false; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLRealExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLRealExpr.java new file mode 100644 index 0000000000..1fff29973f --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLRealExpr.java @@ -0,0 +1,104 @@ +/* + * Copyright 1999-2018 Alibaba Group Holding Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.druid.sql.ast.expr; + +import com.alibaba.druid.sql.ast.SQLObject; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.util.Collections; +import java.util.List; + +public class SQLRealExpr extends SQLNumericLiteralExpr implements SQLValuableExpr { + + private Float value; + + public SQLRealExpr(){ + + } + + public SQLRealExpr(Float value){ + super(); + this.value = value; + } + + public SQLRealExpr clone() { + return new SQLRealExpr(value); + } + + @Override + public List getChildren() { + return Collections.emptyList(); + } + + @Override + public Number getNumber() { + return value; + } + + public Float getValue() { + return value; + } + + public void setValue(Float value) { + this.value = value; + } + + protected void accept0(SQLASTVisitor visitor) { + visitor.visit(this); + + visitor.endVisit(this); + } + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((value == null) ? 0 : value.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + SQLRealExpr other = (SQLRealExpr) obj; + if (value == null) { + if (other.value != null) { + return false; + } + } else if (!value.equals(other.value)) { + return false; + } + return true; + } + + @Override + public void setNumber(Number number) { + if (number == null) { + this.setValue(null); + return; + } + + this.setValue(number.floatValue()); + } + +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLSelectItem.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLSelectItem.java index fec297ae7c..c4a2dcee60 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLSelectItem.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLSelectItem.java @@ -163,7 +163,7 @@ public class SQLSelectItem extends SQLObjectImpl implements SQLReplaceable { @Override public boolean replace(SQLExpr expr, SQLExpr target) { - if (expr == expr) { + if (this.expr == expr) { setExpr(target); return true; } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveLexer.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveLexer.java index f5b35c2d39..6f60493700 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveLexer.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveLexer.java @@ -47,6 +47,7 @@ public class HiveLexer extends Lexer { map.put("IF", Token.IF); map.put("TRUE", Token.TRUE); map.put("FALSE", Token.FALSE); + map.put("RLIKE", Token.RLIKE); DEFAULT_HIVE_KEYWORDS = new Keywords(map); } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlLexer.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlLexer.java index ee14a2495a..1f61cb122a 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlLexer.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlLexer.java @@ -61,6 +61,9 @@ public class MySqlLexer extends Lexer { map.put("UNDO", Token.UNDO); map.put("SQLSTATE", Token.SQLSTATE); map.put("CONDITION", Token.CONDITION); + map.put("MOD", Token.MOD); + map.put("CONTAINS", Token.CONTAINS); + map.put("RLIKE", Token.RLIKE); DEFAULT_MYSQL_KEYWORDS = new Keywords(map); } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java index e7725b0243..b178239851 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java @@ -3161,7 +3161,7 @@ public class MySqlStatementParser extends SQLStatementParser { SQLExpr sqlSecurity = this.exprParser.name(); stmt.setSqlSecurity(sqlSecurity); - } else if (lexer.identifierEquals(FnvHash.Constants.CONTAINS)) { + } else if (lexer.identifierEquals(FnvHash.Constants.CONTAINS) || lexer.token() == Token.CONTAINS) { lexer.nextToken(); acceptIdentifier("SQL"); stmt.setContainsSql(true); @@ -3201,7 +3201,7 @@ public class MySqlStatementParser extends SQLStatementParser { SQLExpr sqlSecurity = this.exprParser.name(); stmt.setSqlSecurity(sqlSecurity); - } else if (lexer.identifierEquals(FnvHash.Constants.CONTAINS)) { + } else if (lexer.identifierEquals(FnvHash.Constants.CONTAINS) || lexer.token() == Token.CONTAINS) { lexer.nextToken(); acceptIdentifier("SQL"); stmt.setContainsSql(true); @@ -4383,7 +4383,7 @@ public class MySqlStatementParser extends SQLStatementParser { stmt.setDeterministic(true); continue; } - if (lexer.identifierEquals(FnvHash.Constants.CONTAINS)) { + if (lexer.identifierEquals(FnvHash.Constants.CONTAINS) || lexer.token() == Token.CONTAINS) { lexer.nextToken(); acceptIdentifier("SQL"); stmt.setContainsSql(true); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsExprParser.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsExprParser.java index 016933c37e..9838758c39 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsExprParser.java @@ -152,16 +152,16 @@ public class OdpsExprParser extends SQLExprParser { return super.primaryRest(expr); } - + public SQLExpr relationalRest(SQLExpr expr) { if (lexer.identifierEquals("REGEXP")) { lexer.nextToken(); - SQLExpr rightExp = equality(); + SQLExpr rightExp = bitOr(); rightExp = relationalRest(rightExp); - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.RegExp, rightExp, JdbcConstants.MYSQL); + return new SQLBinaryOpExpr(expr, SQLBinaryOperator.RegExp, rightExp, dbType); } return super.relationalRest(expr); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsLexer.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsLexer.java index 8d0bb72ace..4b468a5a52 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsLexer.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsLexer.java @@ -47,6 +47,7 @@ public class OdpsLexer extends Lexer { map.put("DISTRIBUTE", Token.DISTRIBUTE); map.put("TRUE", Token.TRUE); map.put("FALSE", Token.FALSE); + map.put("RLIKE", Token.RLIKE); DEFAULT_ODPS_KEYWORDS = new Keywords(map); } diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java b/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java index 83d1a24883..5cf1d38f4a 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java @@ -89,7 +89,7 @@ public class SQLExprParser extends SQLParser { if (token == Token.COMMA) { return expr; } else if (token == Token.EQ) { - expr = equalityRest2(expr); + expr = relationalRest(expr); expr = andRest(expr); expr = orRest(expr); return expr; @@ -107,7 +107,7 @@ public class SQLExprParser extends SQLParser { expr = bitOrRest(expr); expr = inRest(expr); expr = relationalRest(expr); - expr = equalityRest(expr); +// expr = equalityRest(expr); expr = andRest(expr); expr = orRest(expr); @@ -228,20 +228,20 @@ public class SQLExprParser extends SQLParser { SQLExpr rightExp = bitXor(); expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.DIV, rightExp, getDbType()); expr = multiplicativeRest(expr); - } else if (lexer.identifierEquals(FnvHash.Constants.MOD)) { + } else if (lexer.identifierEquals(FnvHash.Constants.MOD) || lexer.token == Token.MOD) { Lexer.SavePoint savePoint = lexer.mark(); lexer.nextToken(); - if (lexer.token == Token.COMMA) { + if (lexer.token == Token.COMMA || lexer.token == Token.EOF) { lexer.reset(savePoint); return expr; } - SQLExpr rightExp = primary(); + SQLExpr rightExp = bitXor(); - rightExp = relationalRest(rightExp); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Modulus, rightExp, dbType); - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.Modulus, rightExp, JdbcConstants.MYSQL); + expr = multiplicativeRest(expr); } return expr; } @@ -768,6 +768,9 @@ public class SQLExprParser extends SQLParser { sqlExpr = new SQLBinaryExpr(strVal); break; } + case CONTAINS: + sqlExpr = inRest(null); + break; case SET: { Lexer.SavePoint savePoint = lexer.mark(); lexer.nextToken(); @@ -1670,100 +1673,6 @@ public class SQLExprParser extends SQLParser { return expr; } - public final SQLExpr equality() { - SQLExpr expr = bitOr(); - return equalityRest(expr); - } - - private SQLExpr equalityRest2(SQLExpr expr) { - SQLExpr rightExp; - lexer.nextToken(); - try { - if (lexer.token == Token.LITERAL_INT) { - rightExp = new SQLIntegerExpr(lexer.integerValue()); - lexer.nextToken(); - - if (lexer.token == Token.AND - || lexer.token == Token.RPAREN - || lexer.token == Token.EOF - || lexer.token == Token.OR) { - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType); - } - - rightExp = primaryRest(rightExp); - rightExp = bitXorRest(rightExp); - rightExp = multiplicativeRest(rightExp); - rightExp = additiveRest(rightExp); - rightExp = shiftRest(rightExp); - rightExp = bitAndRest(rightExp); - rightExp = bitOrRest(rightExp); - rightExp = inRest(rightExp); - rightExp = relationalRest(rightExp); - } else { - rightExp = bitOr(); - } - } catch (EOFParserException e) { - throw new ParserException("EOF, " + expr + "=", e); - } - - if (lexer.token == Token.COLONEQ) { - lexer.nextToken(); - SQLExpr colonExpr = expr(); - rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType); - } - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType); - - if (lexer.token == Token.IS || lexer.token == Token.BETWEEN) { - expr = relationalRest(expr); - } - - return expr; - } - - - public SQLExpr equalityRest(SQLExpr expr) { - SQLExpr rightExp; - - final Token token = lexer.token; - if (token == Token.EQ) { - lexer.nextToken(); - try { - rightExp = bitOr(); - } catch (EOFParserException e) { - throw new ParserException("EOF, " + expr + "=", e); - } - - if (lexer.token == Token.COLONEQ) { - lexer.nextToken(); - SQLExpr colonExpr = expr(); - rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType); - } - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType); - } else if (lexer.token() == Token.EQGT) { - lexer.nextToken(); - rightExp = expr(); - String argumentName = ((SQLIdentifierExpr) expr).getName(); - return new OracleArgumentExpr(argumentName, rightExp); - } else if (token == Token.BANGEQ || token == Token.CARETEQ) { - lexer.nextToken(); - rightExp = bitOr(); - rightExp = equalityRest(rightExp); - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotEqual, rightExp, dbType); - } else if (token == Token.COLONEQ) { - lexer.nextToken(); - rightExp = expr(); - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Assignment, rightExp, dbType); - } - - if (lexer.token == Token.IS || lexer.token == Token.BETWEEN) { - expr = relationalRest(expr); - } - - return expr; - } - public final SQLExpr inRest(SQLExpr expr) { if (lexer.token == Token.IN) { lexer.nextTokenLParen(); @@ -1821,6 +1730,52 @@ public class SQLExprParser extends SQLParser { expr = inSubQueryExpr; } } + } else if (lexer.token == Token.CONTAINS) { + lexer.nextTokenLParen(); + + SQLContainsExpr containsExpr = new SQLContainsExpr(expr); + List targetList = containsExpr.getTargetList(); + if (lexer.token == Token.LPAREN) { + lexer.nextTokenValue(); + + if (lexer.token == Token.WITH) { + SQLSelect select = this.createSelectParser().select(); + SQLInSubQueryExpr queryExpr = new SQLInSubQueryExpr(select); + queryExpr.setExpr(expr); + accept(Token.RPAREN); + return queryExpr; + } + + for (;;) { + SQLExpr item; + if (lexer.token == Token.LITERAL_INT) { + item = new SQLIntegerExpr(lexer.integerValue()); + lexer.nextToken(); + if (lexer.token != Token.COMMA && lexer.token != Token.RPAREN) { + item = this.primaryRest(item); + item = this.exprRest(item); + } + } else { + item = this.expr(); + } + + item.setParent(containsExpr); + targetList.add(item); + if (lexer.token == Token.COMMA) { + lexer.nextTokenValue(); + continue; + } + break; + } + + accept(Token.RPAREN); + } else { + SQLExpr itemExpr = primary(); + itemExpr.setParent(containsExpr); + targetList.add(itemExpr); + } + + expr = containsExpr; } return expr; @@ -2007,7 +1962,7 @@ public class SQLExprParser extends SQLParser { } public SQLExpr relational() { - SQLExpr expr = equality(); + SQLExpr expr = bitOr(); return relationalRest(expr); } @@ -2016,289 +1971,414 @@ public class SQLExprParser extends SQLParser { SQLExpr rightExp; Token token = lexer.token; - if (token == Token.LT) { - SQLBinaryOperator op = SQLBinaryOperator.LessThan; - lexer.nextToken(); - if (lexer.token == Token.EQ) { + switch (token) { + case EQ:{ lexer.nextToken(); - op = SQLBinaryOperator.LessThanOrEqual; + try { + rightExp = bitOr(); + } catch (EOFParserException e) { + throw new ParserException("EOF, " + expr + "=", e); + } + + if (lexer.token == Token.COLONEQ) { + lexer.nextToken(); + SQLExpr colonExpr = expr(); + rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType); + } + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType); } - - rightExp = bitOr(); - expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType()); - // expr = relationalRest(expr); - } else if (token == Token.LTEQ) { - lexer.nextToken(); - rightExp = bitOr(); - - // rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqual, rightExp, getDbType()); - } else if (token == Token.LTEQGT) { - lexer.nextToken(); - rightExp = bitOr(); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqualOrGreaterThan, rightExp, getDbType()); - } else if (token == Token.GT) { - SQLBinaryOperator op = SQLBinaryOperator.GreaterThan; - - lexer.nextToken(); - - if (lexer.token == Token.EQ) { - lexer.nextToken(); - op = SQLBinaryOperator.GreaterThanOrEqual; - } - - rightExp = bitOr(); - - expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType()); - } else if (token == Token.GTEQ) { - lexer.nextToken(); - rightExp = bitOr(); - - // rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.GreaterThanOrEqual, rightExp, getDbType()); - } else if (token == Token.BANGLT) { - lexer.nextToken(); - rightExp = bitOr(); - - // rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLessThan, rightExp, getDbType()); - } else if (token == Token.BANGGT) { - lexer.nextToken(); - rightExp = bitOr(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotGreaterThan, rightExp, getDbType()); - } else if (token == Token.LTGT) { - lexer.nextToken(); - rightExp = bitOr(); - - // rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrGreater, rightExp, getDbType()); - } else if (token == Token.LIKE) { - lexer.nextTokenValue(); - rightExp = bitOr(); - - // rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Like, rightExp, getDbType()); - - if (lexer.token == Token.ESCAPE) { - lexer.nextToken(); - rightExp = primary(); - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType()); - } - } else if (lexer.identifierEquals(FnvHash.Constants.RLIKE)) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.RLike, rightExp, getDbType()); - } else if (token == Token.ILIKE) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.ILike, rightExp, getDbType()); - } else if (token == Token.MONKEYS_AT_AT) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.AT_AT, rightExp, getDbType()); - } else if (token == Token.MONKEYS_AT_GT) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_Contains, rightExp, getDbType()); - } else if (token == Token.LT_MONKEYS_AT) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_ContainedBy, rightExp, getDbType()); - } else if (token == (Token.NOT)) { - lexer.nextToken(); - expr = notRationalRest(expr); - } else if (token == Token.BETWEEN) { - lexer.nextToken(); - SQLExpr beginExpr = bitOr(); - accept(Token.AND); - SQLExpr endExpr = bitOr(); - expr = new SQLBetweenExpr(expr, beginExpr, endExpr); - } else if (token == (Token.IS)) { - lexer.nextTokenNotOrNull(); - - SQLBinaryOperator op; - if (lexer.token == Token.NOT) { - op = SQLBinaryOperator.IsNot; + break; + case IS: { lexer.nextTokenNotOrNull(); - } else { - op = SQLBinaryOperator.Is; + + SQLBinaryOperator op; + if (lexer.token == Token.NOT) { + op = SQLBinaryOperator.IsNot; + lexer.nextTokenNotOrNull(); + } else { + op = SQLBinaryOperator.Is; + } + rightExp = primary(); + expr = new SQLBinaryOpExpr(expr, op, rightExp, dbType); } - rightExp = primary(); - expr = new SQLBinaryOpExpr(expr, op, rightExp, dbType); - } else if (token == Token.IN) { - expr = inRest(expr); - } else if (lexer.identifierEquals(FnvHash.Constants.REGEXP)) { - lexer.nextToken(); - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.RegExp, rightExp, JdbcConstants.MYSQL); - - } else if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { - if (lexer.identifierEquals(FnvHash.Constants.SIMILAR)) { + break; + case EQGT: { lexer.nextToken(); - accept(Token.TO); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SIMILAR_TO, rightExp, getDbType()); - } else if (token == Token.TILDE) { - lexer.nextToken(); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match, rightExp, getDbType()); - } else if (token == Token.TILDE_STAR) { - lexer.nextToken(); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match_Insensitive, rightExp, getDbType()); - } else if (token == Token.BANG_TILDE) { - lexer.nextToken(); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match, rightExp, getDbType()); - } else if (token == Token.BANG_TILDE_STAR) { - lexer.nextToken(); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match_POSIX_Regular_Match_Insensitive, rightExp, getDbType()); - } else if (token == Token.TILDE_EQ) { - lexer.nextToken(); - - rightExp = equality(); - - rightExp = relationalRest(rightExp); - - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SAME_AS, rightExp, getDbType()); + rightExp = expr(); + String argumentName = ((SQLIdentifierExpr) expr).getName(); + expr = new OracleArgumentExpr(argumentName, rightExp); } + break; + case BANGEQ: + case CARETEQ: { + lexer.nextToken(); + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotEqual, rightExp, dbType); + } + break; + case COLONEQ:{ + lexer.nextToken(); + rightExp = expr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Assignment, rightExp, dbType); + } + break; + case LT:{ + SQLBinaryOperator op = SQLBinaryOperator.LessThan; + + lexer.nextToken(); + if (lexer.token == Token.EQ) { + lexer.nextToken(); + op = SQLBinaryOperator.LessThanOrEqual; + } + + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType()); + } + break; + case LTEQ: { + lexer.nextToken(); + rightExp = bitOr(); + + // rightExp = relationalRest(rightExp); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqual, rightExp, getDbType()); + } + break; + case LTEQGT: { + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqualOrGreaterThan, rightExp, getDbType()); + } + break; + case GT: { + SQLBinaryOperator op = SQLBinaryOperator.GreaterThan; + + lexer.nextToken(); + + if (lexer.token == Token.EQ) { + lexer.nextToken(); + op = SQLBinaryOperator.GreaterThanOrEqual; + } + + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType()); + } + break; + case GTEQ:{ + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.GreaterThanOrEqual, rightExp, getDbType()); + } + break; + case BANGLT:{ + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLessThan, rightExp, getDbType()); + } + break; + case BANGGT: + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotGreaterThan, rightExp, getDbType()); + break; + case LTGT: + lexer.nextToken(); + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrGreater, rightExp, getDbType()); + break; + case LIKE: + lexer.nextTokenValue(); + rightExp = bitOr(); + + if (rightExp.getClass() == SQLIdentifierExpr.class) { + String name = ((SQLIdentifierExpr) rightExp).getName(); + int length = name.length(); + if(length > 1 && name.charAt(0) == name.charAt(length -1 )) { + rightExp = new SQLCharExpr(name.substring(1, length - 1)); + } + } + + // rightExp = relationalRest(rightExp); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Like, rightExp, getDbType()); + + if (lexer.token == Token.ESCAPE) { + lexer.nextToken(); + rightExp = primary(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType()); + } + break; + case ILIKE: + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.ILike, rightExp, getDbType()); + break; + case MONKEYS_AT_AT: + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.AT_AT, rightExp, getDbType()); + break; + case MONKEYS_AT_GT: + lexer.nextToken(); + rightExp = bitOr(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_Contains, rightExp, getDbType()); + break; + case LT_MONKEYS_AT: + lexer.nextToken(); + rightExp = bitOr(); + + rightExp = relationalRest(rightExp); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_ContainedBy, rightExp, getDbType()); + break; + case NOT: + lexer.nextToken(); + expr = notRationalRest(expr); + break; + case BETWEEN: + lexer.nextToken(); + SQLExpr beginExpr = relational(); + accept(Token.AND); + SQLExpr endExpr = relational(); + expr = new SQLBetweenExpr(expr, beginExpr, endExpr); + break; + case IN: + case CONTAINS: + expr = inRest(expr); + break; + case EQEQ: + if (JdbcConstants.ODPS.equals(dbType)) { + lexer.nextToken(); + try { + rightExp = bitOr(); + } catch (EOFParserException e) { + throw new ParserException("EOF, " + expr + "=", e); + } + + if (lexer.token == Token.COLONEQ) { + lexer.nextToken(); + SQLExpr colonExpr = expr(); + rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType); + } + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType); + } + break; + case TILDE: + if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + + rightExp = relational(); + + rightExp = relationalRest(rightExp); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match, rightExp, getDbType()); + } + break; + case TILDE_STAR: + if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + rightExp = relational(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match_Insensitive, rightExp, getDbType()); + } + break; + case BANG_TILDE: + if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + rightExp = relational(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match, rightExp, getDbType()); + } + break; + case BANG_TILDE_STAR: + if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + rightExp = relational(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match_POSIX_Regular_Match_Insensitive, rightExp, getDbType()); + } + break; + case TILDE_EQ: + if (JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + rightExp = relational(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SAME_AS, rightExp, getDbType()); + } + break; + case RLIKE: + lexer.nextToken(); + rightExp = relational(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.RLike, rightExp, getDbType()); + break; + case IDENTIFIER: + long hash = lexer.hash_lower; + if (hash == FnvHash.Constants.SOUNDS) { + lexer.nextToken(); + accept(Token.LIKE); + + rightExp = relational(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SoudsLike, rightExp, getDbType()); + } else if (hash == FnvHash.Constants.REGEXP) { + lexer.nextToken(); + rightExp = relational(); + + return new SQLBinaryOpExpr(expr, SQLBinaryOperator.RegExp, rightExp, JdbcConstants.MYSQL); + + } else if (hash == FnvHash.Constants.SIMILAR && JdbcConstants.POSTGRESQL.equals(lexer.dbType)) { + lexer.nextToken(); + accept(Token.TO); + + rightExp = relational(); + + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SIMILAR_TO, rightExp, getDbType()); + } + break; + default: + break; } - if (lexer.token == Token.IS - || lexer.token == Token.BETWEEN) { - expr = relationalRest(expr); + switch (lexer.token) { + case BETWEEN: + case IS: + case EQ: + case IN: + case CONTAINS: + case BANG_TILDE_STAR: + case TILDE_EQ: + case LT: + case LTEQ: + case LTEQGT: + case GT: + case GTEQ: + case LTGT: + case BANGEQ: + case LIKE: + case NOT: + expr = relationalRest(expr); + break; + default: + break; } return expr; } public SQLExpr notRationalRest(SQLExpr expr) { - if (lexer.token == (Token.LIKE)) { - lexer.nextTokenValue(); - SQLExpr rightExp = equality(); + switch (lexer.token) { + case LIKE: + lexer.nextTokenValue(); + SQLExpr rightExp = bitOr(); - rightExp = relationalRest(rightExp); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLike, rightExp, getDbType()); - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLike, rightExp, getDbType()); - - if (lexer.token == Token.ESCAPE) { - lexer.nextToken(); - rightExp = expr(); - expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType()); - } - } else if (lexer.token == Token.IN) { - lexer.nextToken(); - - SQLInListExpr inListExpr = new SQLInListExpr(expr, true); - if (lexer.token == Token.LPAREN) { - lexer.nextToken(); - - exprList(inListExpr.getTargetList(), inListExpr); - expr = inListExpr; - - accept(Token.RPAREN); - } else { - SQLExpr valueExpr = this.primary(); - valueExpr.setParent(inListExpr); - inListExpr.getTargetList().add(valueExpr); - expr = inListExpr; - } - - if (inListExpr.getTargetList().size() == 1) { - SQLExpr targetExpr = inListExpr.getTargetList().get(0); - if (targetExpr instanceof SQLQueryExpr) { - SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr(); - inSubQueryExpr.setNot(true); - inSubQueryExpr.setExpr(inListExpr.getExpr()); - inSubQueryExpr.setSubQuery(((SQLQueryExpr) targetExpr).getSubQuery()); - expr = inSubQueryExpr; + if (lexer.token == Token.ESCAPE) { + lexer.nextToken(); + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType()); } - } + break; + case IN: + lexer.nextToken(); - expr = relationalRest(expr); - return expr; - } else if (lexer.token == (Token.BETWEEN)) { - lexer.nextToken(); - SQLExpr beginExpr = bitOr(); - accept(Token.AND); - SQLExpr endExpr = bitOr(); + SQLInListExpr inListExpr = new SQLInListExpr(expr, true); + if (lexer.token == Token.LPAREN) { + lexer.nextToken(); - expr = new SQLBetweenExpr(expr, true, beginExpr, endExpr); + exprList(inListExpr.getTargetList(), inListExpr); + expr = inListExpr; - return expr; - } else if (lexer.identifierEquals(FnvHash.Constants.RLIKE)) { - lexer.nextToken(); - SQLExpr rightExp = primary(); + accept(Token.RPAREN); + } else { + SQLExpr valueExpr = this.primary(); + valueExpr.setParent(inListExpr); + inListExpr.getTargetList().add(valueExpr); + expr = inListExpr; + } - rightExp = relationalRest(rightExp); + if (inListExpr.getTargetList().size() == 1) { + SQLExpr targetExpr = inListExpr.getTargetList().get(0); + if (targetExpr instanceof SQLQueryExpr) { + SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr(); + inSubQueryExpr.setNot(true); + inSubQueryExpr.setExpr(inListExpr.getExpr()); + inSubQueryExpr.setSubQuery(((SQLQueryExpr) targetExpr).getSubQuery()); + expr = inSubQueryExpr; + } + } - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRLike, rightExp, getDbType()); - } else if (lexer.token == Token.ILIKE) { - lexer.nextToken(); - SQLExpr rightExp = primary(); + break; + case CONTAINS: + lexer.nextToken(); - rightExp = relationalRest(rightExp); + SQLContainsExpr containsExpr = new SQLContainsExpr(expr, true); + if (lexer.token == Token.LPAREN) { + lexer.nextToken(); - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotILike, rightExp, getDbType()); - } else if (lexer.identifierEquals(FnvHash.Constants.REGEXP)) { - lexer.nextToken(); - SQLExpr rightExp = primary(); + exprList(containsExpr.getTargetList(), containsExpr); + expr = containsExpr; - rightExp = relationalRest(rightExp); + accept(Token.RPAREN); + } else { + SQLExpr valueExpr = this.primary(); + valueExpr.setParent(containsExpr); + containsExpr.getTargetList().add(valueExpr); + expr = containsExpr; + } - return new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRegExp, rightExp, JdbcConstants.MYSQL); - } else { - throw new ParserException("TODO " + lexer.info()); + if (containsExpr.getTargetList().size() == 1) { + SQLExpr targetExpr = containsExpr.getTargetList().get(0); + if (targetExpr instanceof SQLQueryExpr) { + SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr(); + inSubQueryExpr.setNot(true); + inSubQueryExpr.setExpr(containsExpr.getExpr()); + inSubQueryExpr.setSubQuery(((SQLQueryExpr) targetExpr).getSubQuery()); + expr = inSubQueryExpr; + } + } + + break; + case BETWEEN: + lexer.nextToken(); + SQLExpr beginExpr = relational(); + accept(Token.AND); + SQLExpr endExpr = relational(); + + expr = new SQLBetweenExpr(expr, true, beginExpr, endExpr); + break; + case ILIKE: + lexer.nextToken(); + rightExp = bitOr(); + + return new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotILike, rightExp, getDbType()); + case LPAREN: + expr = this.primary(); + break; + case RLIKE: + lexer.nextToken(); + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRLike, rightExp, getDbType()); + break; + case IDENTIFIER: + long hash = lexer.hash_lower; + if (hash == FnvHash.Constants.REGEXP) { + lexer.nextToken(); + rightExp = bitOr(); + expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRegExp, rightExp, getDbType()); + } + break; + default: + throw new ParserException("TODO " + lexer.info()); } + return expr; } diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java b/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java index 8e1f396290..7dbec27e35 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java @@ -391,7 +391,24 @@ public class SQLSelectParser extends SQLParser { long hash_lower = lexer.hash_lower(); lexer.nextTokenEq(); - SQLExpr identExpr = new SQLIdentifierExpr(ident, hash_lower); + SQLExpr identExpr; + if (lexer.token == Token.LITERAL_CHARS) { + String literal = lexer.stringVal; + if (hash_lower == FnvHash.Constants.TIMESTAMP) { + identExpr = new SQLTimestampExpr(literal); + lexer.nextToken(); + } else if (hash_lower == FnvHash.Constants.DATE) { + identExpr = new SQLDateExpr(literal); + lexer.nextToken(); + } else if (hash_lower == FnvHash.Constants.REAL) { + identExpr = new SQLRealExpr(Float.parseFloat(literal)); + lexer.nextToken(); + } else { + identExpr = new SQLIdentifierExpr(ident, hash_lower); + } + } else { + identExpr = new SQLIdentifierExpr(ident, hash_lower); + } if (lexer.token == Token.DOT) { identExpr = this.exprParser.primaryRest(identExpr); @@ -401,6 +418,7 @@ public class SQLSelectParser extends SQLParser { SQLExpr rightExp; lexer.nextToken(); + try { rightExp = this.exprParser.bitOr(); } catch (EOFParserException e) { @@ -408,6 +426,29 @@ public class SQLSelectParser extends SQLParser { } where = new SQLBinaryOpExpr(identExpr, SQLBinaryOperator.Equality, rightExp, dbType); + switch (lexer.token) { + case BETWEEN: + case IS: + case EQ: + case IN: + case CONTAINS: + case BANG_TILDE_STAR: + case TILDE_EQ: + case LT: + case LTEQ: + case LTEQGT: + case GT: + case GTEQ: + case LTGT: + case BANGEQ: + case LIKE: + case NOT: + where = this.exprParser.relationalRest(where); + break; + default: + break; + } + where = this.exprParser.andRest(where); where = this.exprParser.orRest(where); } else { @@ -418,17 +459,17 @@ public class SQLSelectParser extends SQLParser { where = this.exprParser.expr(); } // where = this.exprParser.expr(); - + if (beforeComments != null) { where.addBeforeComment(beforeComments); } - + if (lexer.hasComment() && lexer.isKeepComments() // && lexer.token != Token.INSERT // odps multi-insert ) { where.addAfterComment(lexer.readAndResetComments()); } - + queryBlock.setWhere(where); } } diff --git a/src/main/java/com/alibaba/druid/sql/parser/Token.java b/src/main/java/com/alibaba/druid/sql/parser/Token.java index 843cf777b2..fd9f07cdd8 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/Token.java +++ b/src/main/java/com/alibaba/druid/sql/parser/Token.java @@ -100,6 +100,8 @@ public enum Token { END("END"), EXISTS("EXISTS"), IN("IN"), + CONTAINS("CONTAINS"), + RLIKE("RLIKE"), NEW("NEW"), ASC("ASC"), diff --git a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java index 6b28b1aba8..06bba25b7d 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java @@ -6427,4 +6427,80 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet return false; } + + public boolean visit(SQLContainsExpr x) { + SQLExpr expr = x.getExpr(); + if (expr != null) { + printExpr(expr); + print(' '); + } + + if (x.isNot()) { + print0(ucase ? "NOT CONTAINS (" : " not contains ("); + } else { + print0(ucase ? "CONTAINS (" : " contains ("); + } + + final List list = x.getTargetList(); + + boolean printLn = false; + if (list.size() > 5) { + printLn = true; + for (int i = 0, size = list.size(); i < size; ++i) { + if (!(list.get(i) instanceof SQLCharExpr)) { + printLn = false; + break; + } + } + } + + if (printLn) { + this.indentCount++; + println(); + for (int i = 0, size = list.size(); i < size; ++i) { + if (i != 0) { + print0(", "); + println(); + } + SQLExpr item = list.get(i); + printExpr(item); + } + this.indentCount--; + println(); + } else { + List targetList = x.getTargetList(); + for (int i = 0; i < targetList.size(); i++) { + if (i != 0) { + print0(", "); + } + printExpr(targetList.get(i)); + } + } + + print(')'); + return false; + } + + public boolean visit(SQLRealExpr x) { + Float value = x.getValue(); + print0(ucase ? "REAL '" : "real '"); + print(value); + print('\''); + + return false; + } + + public void print(float value) { + if (this.appender == null) { + return; + } + + if (appender instanceof StringBuilder) { + ((StringBuilder) appender).append(value); + } else if (appender instanceof StringBuffer) { + ((StringBuffer) appender).append(value); + } else { + print0(Float.toString(value)); + } + } } diff --git a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java index ce544d62ad..5fbae9f89f 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java @@ -832,4 +832,10 @@ public interface SQLASTVisitor { boolean visit(SQLValuesTableSource x); void endVisit(SQLValuesTableSource x); + + boolean visit(SQLContainsExpr x); + void endVisit(SQLContainsExpr x); + + boolean visit(SQLRealExpr x); + void endVisit(SQLRealExpr x); } diff --git a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java index 3b05206bb9..2eeae2a510 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java @@ -24,7 +24,6 @@ import com.alibaba.druid.sql.ast.statement.SQLMergeStatement.MergeUpdateClause; import com.alibaba.druid.sql.ast.statement.SQLWhileStatement; import com.alibaba.druid.sql.ast.statement.SQLDeclareStatement; import com.alibaba.druid.sql.ast.statement.SQLCommitStatement; -import com.alibaba.druid.sql.parser.SQLParserFeature; public class SQLASTVisitorAdapter implements SQLASTVisitor { protected int features; @@ -1973,6 +1972,24 @@ public class SQLASTVisitorAdapter implements SQLASTVisitor { } + @Override + public boolean visit(SQLContainsExpr x) { + return true; + } + + public void endVisit(SQLContainsExpr x) { + + } + + @Override + public boolean visit(SQLRealExpr x) { + return true; + } + + public void endVisit(SQLRealExpr x) { + + } + public final boolean isEnabled(VisitorFeature feature) { return VisitorFeature.isEnabled(this.features, feature); } diff --git a/src/main/java/com/alibaba/druid/util/FnvHash.java b/src/main/java/com/alibaba/druid/util/FnvHash.java index f88ae629bc..fb39bd7a07 100644 --- a/src/main/java/com/alibaba/druid/util/FnvHash.java +++ b/src/main/java/com/alibaba/druid/util/FnvHash.java @@ -644,5 +644,6 @@ public final class FnvHash { long DBPARTITION = fnv1a_64_lower("DBPARTITION"); long TBPARTITION = fnv1a_64_lower("TBPARTITION"); long TBPARTITIONS = fnv1a_64_lower("TBPARTITIONS"); + long SOUNDS = fnv1a_64_lower("SOUNDS"); } } diff --git a/src/test/java/com/alibaba/druid/bvt/sql/postgresql/PGUpdateTest0.java b/src/test/java/com/alibaba/druid/bvt/sql/postgresql/PGUpdateTest0.java new file mode 100644 index 0000000000..adb4919ee6 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/sql/postgresql/PGUpdateTest0.java @@ -0,0 +1,58 @@ +/* + * Copyright 1999-2017 Alibaba Group Holding Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.druid.bvt.sql.postgresql; + +import com.alibaba.druid.sql.PGTest; +import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.dialect.postgresql.parser.PGSQLStatementParser; +import com.alibaba.druid.sql.dialect.postgresql.visitor.PGSchemaStatVisitor; +import com.alibaba.druid.stat.TableStat; + +import java.util.List; + +public class PGUpdateTest0 extends PGTest { + + public void test_0() throws Exception { + String sql = "update student a set grade = tmp.grade from (values (1, 'A')) as tmp(id, grade) where a.id = tmp.id"; + + PGSQLStatementParser parser = new PGSQLStatementParser(sql); + List statementList = parser.parseStatementList(); + SQLStatement stmt = statementList.get(0); + + assertEquals("UPDATE student a\n" + + "SET grade = tmp.grade\n" + + "FROM (VALUES (1, 'A')) AS tmp (id, grade)\n" + + "WHERE a.id = tmp.id", stmt.toString()); + + assertEquals(1, statementList.size()); + + PGSchemaStatVisitor visitor = new PGSchemaStatVisitor(); + stmt.accept(visitor); + + System.out.println("Tables : " + visitor.getTables()); + System.out.println("fields : " + visitor.getColumns()); +// System.out.println("coditions : " + visitor.getConditions()); + + assertTrue(visitor.getTables().containsKey(new TableStat.Name("student"))); + + assertEquals(2, visitor.getColumns().size() ); + + assertTrue(visitor.containsColumn("student", "id")); + assertTrue(visitor.containsColumn("student", "grade")); + } + + +}