diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLTableDataType.java b/src/main/java/com/alibaba/druid/sql/ast/SQLTableDataType.java new file mode 100644 index 0000000000..65388f7b3b --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLTableDataType.java @@ -0,0 +1,122 @@ +package com.alibaba.druid.sql.ast; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; +import com.alibaba.druid.util.FnvHash; + +import java.sql.Types; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class SQLTableDataType extends SQLObjectImpl implements SQLDataType { + private DbType dbType; + private List columns = new ArrayList(); + + public SQLTableDataType() { + + } + + public SQLTableDataType(DbType dbType) { + this.dbType = dbType; + } + + @Override + public String getName() { + return "TABLE"; + } + + @Override + public void setName(String name) { + throw new UnsupportedOperationException(); + } + + @Override + public long nameHashCode64() { + return FnvHash.Constants.TABLE; + } + + @Override + public List getArguments() { + return Collections.emptyList(); + } + + @Override + public Boolean getWithTimeZone() { + return null; + } + + @Override + public void setWithTimeZone(Boolean value) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isWithLocalTimeZone() { + return false; + } + + @Override + public void setWithLocalTimeZone(boolean value) { + throw new UnsupportedOperationException(); + } + + @Override + public DbType getDbType() { + return dbType; + } + + @Override + public void setDbType(DbType dbType) { + this.dbType = dbType; + } + + @Override + protected void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + acceptChild(visitor, columns); + } + visitor.endVisit(this); + } + + public SQLTableDataType clone() { + SQLTableDataType x = new SQLTableDataType(dbType); + + for (SQLColumnDefinition item : columns) { + SQLColumnDefinition item2 = item.clone(); + item2.setParent(x); + x.columns.add(item2); + } + + return x; + } + + public List getColumns() { + return columns; + } + + public int jdbcType() { + return Types.STRUCT; + } + + @Override + public boolean isInt() { + return false; + } + @Override + public boolean isNumberic() { + return false; + } + + @Override + public boolean isString() { + return false; + } + + @Override + public boolean hasKeyLength() { + return false; + } + +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableChangeOwner.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableChangeOwner.java new file mode 100644 index 0000000000..b05b95fa3d --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableChangeOwner.java @@ -0,0 +1,51 @@ +/* + * 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.sql.ast.statement; + +import com.alibaba.druid.sql.ast.SQLName; +import com.alibaba.druid.sql.ast.SQLObjectImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.util.ArrayList; +import java.util.List; + +public class SQLAlterTableChangeOwner extends SQLObjectImpl implements SQLAlterTableItem { + private final List partition = new ArrayList(4); + private SQLName owner; + + public List getPartition() { + return partition; + } + + @Override + protected void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + + } + visitor.endVisit(this); + } + + public SQLName getOwner() { + return owner; + } + + public void setOwner(SQLName x) { + if (x != null) { + x.setParent(this); + } + this.owner = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateViewStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateViewStatement.java index 78e710a6cf..7ed709ca83 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateViewStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateViewStatement.java @@ -18,10 +18,7 @@ package com.alibaba.druid.sql.ast.statement; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.SQLUtils; import com.alibaba.druid.sql.ast.*; -import com.alibaba.druid.sql.ast.expr.SQLCharExpr; -import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; -import com.alibaba.druid.sql.ast.expr.SQLLiteralExpr; -import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; +import com.alibaba.druid.sql.ast.expr.*; import com.alibaba.druid.sql.visitor.SQLASTVisitor; import java.util.ArrayList; @@ -50,6 +47,9 @@ public class SQLCreateViewStatement extends SQLStatementImpl implements SQLCreat private SQLLiteralExpr comment; + private SQLVariantRefExpr returns; // odps + private SQLTableDataType returnsDataType; // odps + // clickhouse protected boolean onCluster; private SQLName to; @@ -331,6 +331,29 @@ public class SQLCreateViewStatement extends SQLStatementImpl implements SQLCreat this.to = x; } + public SQLVariantRefExpr getReturns() { + return returns; + } + + public void setReturns(SQLVariantRefExpr x) { + if (x != null) { + x.setParent(this); + } + this.returns = x; + } + + public SQLTableDataType getReturnsDataType() { + return returnsDataType; + } + + public void + setReturnsDataType(SQLTableDataType x) { + if (x != null) { + x.setParent(this); + } + this.returnsDataType = x; + } + public SQLCreateViewStatement clone() { SQLCreateViewStatement x = new SQLCreateViewStatement(); @@ -368,6 +391,14 @@ public class SQLCreateViewStatement extends SQLStatementImpl implements SQLCreat to = x.to.clone(); } + if (x.returns != null) { + returns = x.returns.clone(); + } + + if (x.returnsDataType != null) { + returnsDataType = x.returnsDataType.clone(); + } + return x; } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLPurgeTableStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLPurgeTableStatement.java index 34042d3c3a..cbd198d66e 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLPurgeTableStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLPurgeTableStatement.java @@ -25,6 +25,8 @@ import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class SQLPurgeTableStatement extends SQLStatementImpl implements SQLDropStatement { private SQLExprTableSource table; + private boolean all; + private int count; public SQLPurgeTableStatement() { @@ -62,4 +64,19 @@ public class SQLPurgeTableStatement extends SQLStatementImpl implements SQLDropS this.table = x; } + public int getCount() { + return count; + } + + public void setCount(int count) { + this.count = count; + } + + public boolean isAll() { + return all; + } + + public void setAll(boolean all) { + this.all = all; + } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/ast/HiveMultiInsertStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/ast/HiveMultiInsertStatement.java index 248f708fd0..9d1a587dda 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/ast/HiveMultiInsertStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/ast/HiveMultiInsertStatement.java @@ -35,8 +35,12 @@ public class HiveMultiInsertStatement extends SQLStatementImpl { super (DbType.hive); } - public void setFrom(SQLTableSource from) { - this.from = from; + public void setFrom(SQLTableSource x) { + if (x != null) { + x.setParent(this); + } + + this.from = x; } public SQLTableSource getFrom() { diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveCreateFunctionStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveCreateFunctionStatement.java index a40cbcfa70..486ed27d12 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveCreateFunctionStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveCreateFunctionStatement.java @@ -9,10 +9,12 @@ import com.alibaba.druid.sql.dialect.hive.visitor.HiveASTVisitor; import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class HiveCreateFunctionStatement extends SQLCreateFunctionStatement implements SQLCreateStatement { + protected boolean declare = false; protected SQLExpr className; protected SQLExpr locationn; protected SQLExpr symbol; protected ResourceType resourceType; + protected String code; public void accept0(SQLASTVisitor visitor) { if (visitor instanceof HiveASTVisitor) { @@ -75,7 +77,23 @@ public class HiveCreateFunctionStatement extends SQLCreateFunctionStatement impl this.resourceType = resourceType; } + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public boolean isDeclare() { + return declare; + } + + public void setDeclare(boolean declare) { + this.declare = declare; + } + public static enum ResourceType { - JAR, FILE, ARCHIVE + JAR, FILE, ARCHIVE, CODE } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlExprParser.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlExprParser.java index de747d12a5..613428d743 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlExprParser.java @@ -1247,7 +1247,7 @@ public class MySqlExprParser extends SQLExprParser { return dataType; } - public SQLAssignItem parseAssignItem(boolean variant) { + public SQLAssignItem parseAssignItem(boolean variant, SQLObject parent) { SQLAssignItem item = new SQLAssignItem(); SQLExpr var = primary(); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsDeclareVariableStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsDeclareVariableStatement.java new file mode 100644 index 0000000000..54536cf471 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsDeclareVariableStatement.java @@ -0,0 +1,60 @@ +package com.alibaba.druid.sql.dialect.odps.ast; + +import com.alibaba.druid.sql.ast.SQLDataType; +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.statement.SQLSelectStatement; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; + +public class OdpsDeclareVariableStatement extends OdpsStatementImpl { + private String variant; + private SQLDataType dataType; + private SQLExpr initValue; + + public OdpsDeclareVariableStatement() { + + } + + public OdpsDeclareVariableStatement(String variant, SQLExpr initValue) { + this.variant = variant; + this.initValue = initValue; + } + + @Override + protected void accept0(OdpsASTVisitor v) { + if (v.visit(this)) { + acceptChild(v, dataType); + acceptChild(v, initValue); + } + v.endVisit(this); + } + + public String getVariant() { + return variant; + } + + public void setVariant(String variant) { + this.variant = variant; + } + + public SQLExpr getInitValue() { + return initValue; + } + + public void setInitValue(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.initValue = x; + } + + public SQLDataType getDataType() { + return dataType; + } + + public void setDataType(SQLDataType x) { + if (x != null) { + x.setParent(this); + } + this.dataType = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsCreateTableParser.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsCreateTableParser.java index 42a5d40e9b..2feaa11050 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsCreateTableParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsCreateTableParser.java @@ -19,10 +19,7 @@ import com.alibaba.druid.sql.ast.ClusteringType; import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.SQLName; import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr; -import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition; -import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement; -import com.alibaba.druid.sql.ast.statement.SQLSelect; -import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem; +import com.alibaba.druid.sql.ast.statement.*; import com.alibaba.druid.sql.dialect.hive.ast.HiveInputOutputFormat; import com.alibaba.druid.sql.dialect.odps.ast.OdpsCreateTableStatement; import com.alibaba.druid.sql.parser.ParserException; @@ -70,30 +67,43 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { stmt.setComment(this.exprParser.primary()); } - if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { - lexer.nextToken(); - stmt.setLifecycle(this.exprParser.expr()); - } + for (;;) { + if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { + parseTblProperties(stmt); - - if (lexer.identifierEquals(FnvHash.Constants.STORED)) { - lexer.nextToken(); - accept(Token.AS); - - if (lexer.identifierEquals(FnvHash.Constants.INPUTFORMAT)) { - HiveInputOutputFormat format = new HiveInputOutputFormat(); - lexer.nextToken(); - format.setInput(this.exprParser.primary()); - - if (lexer.identifierEquals(FnvHash.Constants.OUTPUTFORMAT)) { - lexer.nextToken(); - format.setOutput(this.exprParser.primary()); - } - stmt.setStoredAs(format); - } else { - SQLName name = this.exprParser.name(); - stmt.setStoredAs(name); + continue; } + + if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { + lexer.nextToken(); + stmt.setLifecycle(this.exprParser.expr()); + + continue; + } + + if (lexer.identifierEquals(FnvHash.Constants.STORED)) { + lexer.nextToken(); + accept(Token.AS); + + if (lexer.identifierEquals(FnvHash.Constants.INPUTFORMAT)) { + HiveInputOutputFormat format = new HiveInputOutputFormat(); + lexer.nextToken(); + format.setInput(this.exprParser.primary()); + + if (lexer.identifierEquals(FnvHash.Constants.OUTPUTFORMAT)) { + lexer.nextToken(); + format.setOutput(this.exprParser.primary()); + } + stmt.setStoredAs(format); + } else { + SQLName name = this.exprParser.name(); + stmt.setStoredAs(name); + } + + continue; + } + + break; } if (lexer.token() == Token.LIKE) { @@ -184,181 +194,209 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { } accept(Token.RPAREN); } - - if (lexer.token() == Token.COMMENT) { - lexer.nextToken(); - stmt.setComment(this.exprParser.primary()); - } - - if (lexer.token() == Token.PARTITIONED) { - lexer.nextToken(); - accept(Token.BY); - accept(Token.LPAREN); - - for (;;) { - switch (lexer.token()) { - case INDEX: - case KEY: - case IDENTIFIER: - case GROUP: - case INTERVAL: - break; - default: - throw new ParserException("expect identifier. " + lexer.info()); - } - - SQLColumnDefinition column = this.exprParser.parseColumn(); - stmt.addPartitionColumn(column); - - if (lexer.isKeepComments() && lexer.hasComment()) { - column.addAfterComment(lexer.readAndResetComments()); - } - - if (lexer.token() != Token.COMMA) { - break; - } else { - lexer.nextToken(); + + + for (;;) { + if (lexer.token() == Token.COMMENT) { + lexer.nextToken(); + stmt.setComment(this.exprParser.primary()); + } + + if (lexer.token() == Token.PARTITIONED) { + lexer.nextToken(); + accept(Token.BY); + accept(Token.LPAREN); + + for (; ; ) { + switch (lexer.token()) { + case INDEX: + case KEY: + case IDENTIFIER: + case GROUP: + case INTERVAL: + case LOOP: + break; + default: + throw new ParserException("expect identifier. " + lexer.info()); + } + + SQLColumnDefinition column = this.exprParser.parseColumn(); + stmt.addPartitionColumn(column); + if (lexer.isKeepComments() && lexer.hasComment()) { column.addAfterComment(lexer.readAndResetComments()); } + + if (lexer.token() != Token.COMMA) { + break; + } else { + lexer.nextToken(); + if (lexer.isKeepComments() && lexer.hasComment()) { + column.addAfterComment(lexer.readAndResetComments()); + } + } } + + accept(Token.RPAREN); } - - accept(Token.RPAREN); - } - if (lexer.identifierEquals(FnvHash.Constants.RANGE)) { - lexer.nextToken(); - if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) { - stmt.setClusteringType(ClusteringType.Range); - } - } - - if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) { - lexer.nextToken(); - accept(Token.BY); - accept(Token.LPAREN); - for (; ; ) { - SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem(); - stmt.addClusteredByItem(item); - if (lexer.token() == Token.COMMA) { - lexer.nextToken(); - continue; - } - break; - } - accept(Token.RPAREN); - } - - - if (lexer.identifierEquals(FnvHash.Constants.SORTED)) { - lexer.nextToken(); - accept(Token.BY); - accept(Token.LPAREN); - for (; ; ) { - SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem(); - stmt.addSortedByItem(item); - if (lexer.token() == Token.COMMA) { - lexer.nextToken(); - continue; - } - break; - } - accept(Token.RPAREN); - } - - if (stmt.getClusteringType() != ClusteringType.Range && - (stmt.getClusteredBy().size() > 0 || stmt.getSortedBy().size() > 0)) { - accept(Token.INTO); - if (lexer.token() == Token.LITERAL_INT) { - stmt.setBuckets(lexer.integerValue().intValue()); + if (lexer.identifierEquals(FnvHash.Constants.RANGE)) { lexer.nextToken(); - } else { - throw new ParserException("into buckets must be integer. " + lexer.info()); + if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) { + stmt.setClusteringType(ClusteringType.Range); + } + + continue; + } + + if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) { + lexer.nextToken(); + accept(Token.BY); + accept(Token.LPAREN); + for (; ; ) { + SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem(); + stmt.addClusteredByItem(item); + if (lexer.token() == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RPAREN); + + continue; + } + + if (lexer.identifierEquals(FnvHash.Constants.ROW)) { + SQLExternalRecordFormat recordFormat = this.exprParser.parseRowFormat(); + stmt.setRowFormat(recordFormat); + continue; + } + + if (lexer.identifierEquals(FnvHash.Constants.SORTED)) { + lexer.nextToken(); + accept(Token.BY); + accept(Token.LPAREN); + for (; ; ) { + SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem(); + stmt.addSortedByItem(item); + if (lexer.token() == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RPAREN); + + continue; + } + + if (stmt.getClusteringType() != ClusteringType.Range && + (stmt.getClusteredBy().size() > 0 || stmt.getSortedBy().size() > 0) && lexer.token() == Token.INTO) { + lexer.nextToken(); + if (lexer.token() == Token.LITERAL_INT) { + stmt.setBuckets(lexer.integerValue().intValue()); + lexer.nextToken(); + } else { + throw new ParserException("into buckets must be integer. " + lexer.info()); + } + acceptIdentifier("BUCKETS"); + + if (lexer.token() == Token.INTO) { + lexer.nextToken(); + + if (lexer.token() == Token.LITERAL_INT) { + stmt.setShards(lexer.integerValue().intValue()); + lexer.nextToken(); + } else { + throw new ParserException("into shards must be integer. " + lexer.info()); + } + + acceptIdentifier("SHARDS"); + } + + continue; } - acceptIdentifier("BUCKETS"); if (lexer.token() == Token.INTO) { lexer.nextToken(); if (lexer.token() == Token.LITERAL_INT) { - stmt.setShards(lexer.integerValue().intValue()); + stmt.setIntoBuckets( + new SQLIntegerExpr(lexer.integerValue().intValue())); lexer.nextToken(); + acceptIdentifier("BUCKETS"); } else { throw new ParserException("into shards must be integer. " + lexer.info()); } - - acceptIdentifier("SHARDS"); + continue; } - } - if (lexer.token() == Token.INTO) { - lexer.nextToken(); - - if (lexer.token() == Token.LITERAL_INT) { - stmt.setIntoBuckets( - new SQLIntegerExpr(lexer.integerValue().intValue())); + if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { lexer.nextToken(); - acceptIdentifier("BUCKETS"); - } else { - throw new ParserException("into shards must be integer. " + lexer.info()); + stmt.setLifecycle(this.exprParser.expr()); + continue; } - } - - if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { - lexer.nextToken(); - stmt.setLifecycle(this.exprParser.expr()); - } - while (lexer.identifierEquals(FnvHash.Constants.STORED)) { - lexer.nextToken(); - if (lexer.token() == Token.AS) { + while (lexer.identifierEquals(FnvHash.Constants.STORED)) { lexer.nextToken(); - SQLName storedAs = this.exprParser.name(); - stmt.setStoredAs(storedAs); - } else { - accept(Token.BY); - SQLExpr storedBy = this.exprParser.expr(); - stmt.setStoredBy(storedBy); + if (lexer.token() == Token.AS) { + lexer.nextToken(); + SQLName storedAs = this.exprParser.name(); + stmt.setStoredAs(storedAs); + } else { + accept(Token.BY); + SQLExpr storedBy = this.exprParser.expr(); + stmt.setStoredBy(storedBy); + } } - } - if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { - lexer.nextToken(); - stmt.setLifecycle(this.exprParser.expr()); - } + if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { + lexer.nextToken(); + stmt.setLifecycle(this.exprParser.expr()); + continue; + } - if (lexer.token() == Token.WITH) { - lexer.nextToken(); - acceptIdentifier("SERDEPROPERTIES"); - accept(Token.LPAREN); - this.exprParser.exprList(stmt.getWithSerdeproperties(), stmt); - accept(Token.RPAREN); - } + if (lexer.token() == Token.WITH) { + lexer.nextToken(); + acceptIdentifier("SERDEPROPERTIES"); + accept(Token.LPAREN); + this.exprParser.exprList(stmt.getWithSerdeproperties(), stmt); + accept(Token.RPAREN); + continue; + } - if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { - parseTblProperties(stmt); - } + if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { + parseTblProperties(stmt); + continue; + } - if (lexer.identifierEquals(FnvHash.Constants.LOCATION)) { - lexer.nextToken(); - SQLExpr location = this.exprParser.expr(); - stmt.setLocation(location); - } + if (lexer.identifierEquals(FnvHash.Constants.LOCATION)) { + lexer.nextToken(); + SQLExpr location = this.exprParser.expr(); + stmt.setLocation(location); + continue; + } - if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { - parseTblProperties(stmt); - } + if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { + parseTblProperties(stmt); + continue; + } - if (lexer.identifierEquals(FnvHash.Constants.USING)) { - lexer.nextToken(); - SQLExpr using = this.exprParser.expr(); - stmt.setUsing(using); - } + if (lexer.identifierEquals(FnvHash.Constants.USING)) { + lexer.nextToken(); + SQLExpr using = this.exprParser.expr(); + stmt.setUsing(using); + continue; + } - if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { - lexer.nextToken(); - stmt.setLifecycle(this.exprParser.expr()); + if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { + lexer.nextToken(); + stmt.setLifecycle(this.exprParser.expr()); + continue; + } + + break; } return stmt; 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 e15b9749cf..8c5e003d31 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 @@ -92,7 +92,9 @@ public class OdpsExprParser extends SQLExprParser { if (FnvHash.Constants.DATETIME == hash_lower && lexer.stringVal().charAt(0) != '`' - && lexer.token() == Token.LITERAL_CHARS) { + && (lexer.token() == Token.LITERAL_CHARS + || lexer.token() == Token.LITERAL_ALIAS) + ) { String literal = lexer.stringVal(); lexer.nextToken(); @@ -155,6 +157,13 @@ public class OdpsExprParser extends SQLExprParser { public SQLExpr primaryRest(SQLExpr expr) { if(lexer.token() == Token.COLON) { lexer.nextToken(); + if (lexer.token() == Token.LITERAL_INT && expr instanceof SQLPropertyExpr) { + SQLPropertyExpr propertyExpr = (SQLPropertyExpr) expr; + Number integerValue = lexer.integerValue(); + lexer.nextToken(); + propertyExpr.setName(propertyExpr.getName() + ':' + integerValue.intValue()); + return propertyExpr; + } expr = dotRest(expr); return expr; } @@ -242,6 +251,7 @@ public class OdpsExprParser extends SQLExprParser { if (lexer.identifierEquals(FnvHash.Constants.GSON) || lexer.identifierEquals(GSONBUILDER) || lexer.identifierEquals("STRING") + || lexer.identifierEquals("INTEGER") ) { lexer.nextToken(); String methodName = lexer.stringVal(); 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 021dd3c22f..2c79a96eca 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 @@ -54,6 +54,11 @@ public class OdpsLexer extends Lexer { public OdpsLexer(String input, SQLParserFeature... features){ super(input); + + if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、') { + ch = charAt(++pos); + } + dbType = DbType.odps; super.keywords = DEFAULT_ODPS_KEYWORDS; this.skipComment = true; @@ -66,6 +71,11 @@ public class OdpsLexer extends Lexer { public OdpsLexer(String input, boolean skipComment, boolean keepComments){ super(input, skipComment); + + if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、') { + ch = charAt(++pos); + } + dbType = DbType.odps; this.skipComment = skipComment; this.keepComments = keepComments; @@ -74,6 +84,11 @@ public class OdpsLexer extends Lexer { public OdpsLexer(String input, CommentHandler commentHandler){ super(input, commentHandler); + + if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、') { + ch = charAt(++pos); + } + dbType = DbType.odps; super.keywords = DEFAULT_ODPS_KEYWORDS; } @@ -181,6 +196,22 @@ public class OdpsLexer extends Lexer { ch = charAt(++pos); return; } + + if (ch == '#' + && charAt(pos + 1) == 'C' + && charAt(pos + 2) == 'O' + && charAt(pos + 3) == 'D' + && charAt(pos + 4) == 'E') { + int p1 = text.indexOf("#END CODE", pos + 1); + if (p1 != -1) { + int end = p1 + "#END CODE".length(); + stringVal = text.substring(pos, end); + token = Token.CODE; + pos = end; + ch = charAt(pos); + return; + } + } super.scanVariable(); } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsSelectParser.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsSelectParser.java index 8619c885bb..3561491194 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsSelectParser.java @@ -72,8 +72,13 @@ public class OdpsSelectParser extends SQLSelectParser { queryBlock.setDistionOption(SQLSetQuantifier.DISTINCT); lexer.nextToken(); } else if (lexer.token() == Token.UNIQUE) { - queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE); + Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); + if (lexer.token() == Token.DOT) { + lexer.reset(mark); + } else { + queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE); + } } else if (lexer.token() == Token.ALL) { String str = lexer.stringVal(); lexer.nextToken(); @@ -97,11 +102,16 @@ public class OdpsSelectParser extends SQLSelectParser { } if (lexer.token() == Token.COMMENT) { + Lexer.SavePoint mark = lexer.mark(); + String tokenStr = lexer.stringVal(); lexer.nextToken(); if (lexer.token() == Token.COMMA) { - queryBlock.addSelectItem(new SQLIdentifierExpr(tokenStr)); + SQLIdentifierExpr expr = new SQLIdentifierExpr(tokenStr); + queryBlock.addSelectItem(expr); lexer.nextToken(); + } else { + lexer.reset(mark); } } @@ -110,8 +120,13 @@ public class OdpsSelectParser extends SQLSelectParser { queryBlock.setDistionOption(SQLSetQuantifier.DISTINCT); lexer.nextToken(); } else if (lexer.token() == Token.UNIQUE) { - queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE); + Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); + if (lexer.token() == Token.DOT) { + lexer.reset(mark); + } else { + queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE); + } } else if (lexer.token() == Token.ALL) { Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsStatementParser.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsStatementParser.java index 4107d80931..1496ea4b8b 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsStatementParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/parser/OdpsStatementParser.java @@ -21,6 +21,7 @@ import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; import com.alibaba.druid.sql.ast.statement.*; import com.alibaba.druid.sql.dialect.hive.ast.HiveInsert; import com.alibaba.druid.sql.dialect.hive.ast.HiveMultiInsertStatement; +import com.alibaba.druid.sql.dialect.hive.stmt.HiveCreateFunctionStatement; import com.alibaba.druid.sql.dialect.hive.stmt.HiveLoadDataStatement; import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlKillStatement; import com.alibaba.druid.sql.dialect.odps.ast.*; @@ -328,36 +329,121 @@ public class OdpsStatementParser extends SQLStatementParser { return true; } + if (lexer.token() == Token.FUNCTION) { + HiveCreateFunctionStatement stmt = (HiveCreateFunctionStatement) parseHiveCreateFunction(); + stmt.setDeclare(true); + statementList.add(stmt); + return true; + } + if (lexer.token() == Token.VARIANT && lexer.stringVal().startsWith("@")) { Lexer.SavePoint mark = lexer.mark(); String variant = lexer.stringVal(); lexer.nextToken(); - accept(Token.COLONEQ); - switch (lexer.token()) { - case LITERAL_INT: - case LITERAL_FLOAT: - case LITERAL_CHARS: - case CASE: { - SQLExpr expr = this.exprParser.expr(); - SQLExprStatement stmt = new SQLExprStatement( - new SQLAssignItem(new SQLIdentifierExpr(variant), expr) - ); - statementList.add(stmt); - return true; + if (lexer.token() == Token.COLONEQ) { + lexer.nextToken(); + switch (lexer.token()) { + case LITERAL_INT: + case LITERAL_FLOAT: + case LITERAL_CHARS: + case IDENTIFIER: + case CASE: { + SQLExpr expr = this.exprParser.expr(); + SQLExprStatement stmt = new SQLExprStatement( + new SQLAssignItem(new SQLIdentifierExpr(variant), expr) + ); + statementList.add(stmt); + return true; + } + default: + SQLSelectStatement stmt = this.parseSelect(); + + OdpsQueryAliasStatement aliasQueryStatement = new OdpsQueryAliasStatement(variant, stmt); + statementList.add(aliasQueryStatement); + return true; } - default: - SQLSelectStatement stmt = this.parseSelect(); - - OdpsQueryAliasStatement aliasQueryStatement = new OdpsQueryAliasStatement(variant, stmt); - statementList.add(aliasQueryStatement); - return true; } + + OdpsDeclareVariableStatement stmt = new OdpsDeclareVariableStatement(); + + if (lexer.token() != Token.EQ && lexer.token() != Token.SEMI && lexer.token() != Token.EOF) { + stmt.setDataType( + this.exprParser.parseDataType() + ); + } + + if (lexer.token() == Token.EQ) { + stmt.setInitValue( + this.exprParser.expr() + ); + } + + if (lexer.token() == Token.SEMI) { + lexer.nextToken(); + } + statementList.add(stmt); + return true; + } + + if (lexer.token() == Token.IF) { + SQLStatement stmt = parseIf(); + statementList.add(stmt); + return true; + } + + if (lexer.token() == Token.CODE) { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextToken(); + if (lexer.token() == Token.EOF || lexer.token() == Token.SEMI) { + return true; + } + lexer.reset(mark); } return false; } + public SQLStatement parseIf() { + accept(Token.IF); + SQLIfStatement ifStmt = new SQLIfStatement(); + ifStmt.setCondition( + this.exprParser.expr() + ); + + if (lexer.identifierEquals("BEGIN")) { + lexer.nextToken(); + parseStatementList(ifStmt.getStatements(), -1, ifStmt); + accept(Token.END); + } else { + SQLStatement stmt = parseStatement(); + ifStmt.getStatements().add(stmt); + stmt.setParent(ifStmt); + } + + if (lexer.token() == Token.SEMI) { + lexer.nextToken(); + } + + if (lexer.token() == Token.ELSE) { + lexer.nextToken(); + + SQLIfStatement.Else elseItem = new SQLIfStatement.Else(); + if (lexer.identifierEquals("BEGIN")) { + lexer.nextToken(); + parseStatementList(elseItem.getStatements(), -1, ifStmt); + accept(Token.END); + } else { + SQLStatement stmt = parseStatement(); + elseItem.getStatements().add(stmt); + stmt.setParent(elseItem); + } + ifStmt.setElseItem(elseItem); + } + + return ifStmt; + } + public SQLStatement parseKill() { acceptIdentifier("KILL"); MySqlKillStatement stmt = new MySqlKillStatement(); @@ -639,6 +725,10 @@ public class OdpsStatementParser extends SQLStatementParser { accept(Token.SET); + if (lexer.token() == Token.SET && dbType == DbType.odps) { + lexer.nextToken(); + } + if (lexer.identifierEquals("LABEL")) { OdpsSetLabelStatement stmt = new OdpsSetLabelStatement(); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsASTVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsASTVisitor.java index c5d19c06a9..4c655415de 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsASTVisitor.java @@ -248,4 +248,12 @@ public interface OdpsASTVisitor extends HiveASTVisitor { } + default boolean visit(OdpsDeclareVariableStatement x) { + return true; + } + + default void endVisit(OdpsDeclareVariableStatement x) { + + } + } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsSchemaStatVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsSchemaStatVisitor.java index 4b39110219..564f1eb547 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsSchemaStatVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsSchemaStatVisitor.java @@ -17,6 +17,7 @@ package com.alibaba.druid.sql.dialect.odps.visitor; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; +import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock; import com.alibaba.druid.sql.dialect.hive.visitor.HiveSchemaStatVisitor; import com.alibaba.druid.sql.dialect.odps.ast.*; import com.alibaba.druid.sql.repository.SchemaRepository; @@ -66,4 +67,7 @@ public class OdpsSchemaStatVisitor extends HiveSchemaStatVisitor implements Odps return false; } + public boolean visit(OdpsSelectQueryBlock x) { + return visit((SQLSelectQueryBlock) x); + } } diff --git a/src/main/java/com/alibaba/druid/sql/parser/Lexer.java b/src/main/java/com/alibaba/druid/sql/parser/Lexer.java index 235cdb3ba7..c8f21840ae 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/Lexer.java +++ b/src/main/java/com/alibaba/druid/sql/parser/Lexer.java @@ -676,6 +676,7 @@ public class Lexer { } public final SQLType scanSQLType() { + _loop: for (;;) { while (isWhitespace(ch)) { ch = charAt(++pos); @@ -707,10 +708,31 @@ public class Lexer { } } + if (dbType == DbType.odps) { + while (ch == ';') { + ch = charAt(++pos); - if (ch == '-' && pos + 1 < text.length() && text.charAt(pos + 1) == '-') { + if (isEOF()) { + return SQLType.EMPTY; + } + + while (isWhitespace(ch)) { + ch = charAt(++pos); + } + continue _loop; + } + } + + if (pos + 1 < text.length() + && ((ch == '-' && text.charAt(pos + 1) == '-') || (ch == '—' && text.charAt(pos + 1) == '—'))) { int index = text.indexOf('\n', pos + 2); if (index == -1) { + reset(0); + nextToken(); + if (token == EOF) { + return SQLType.EMPTY; + } + return SQLType.UNKNOWN; } @@ -769,12 +791,61 @@ public class Lexer { } else if (hashCode == FnvHash.Constants.ALTER) { return SQLType.ALTER; } else if (hashCode == FnvHash.Constants.SHOW) { + nextToken(); + if (identifierEquals(FnvHash.Constants.STATISTIC)) { + return SQLType.SHOW_STATISTIC; + } else if (identifierEquals(FnvHash.Constants.STATISTIC_LIST)) { + return SQLType.SHOW_STATISTIC_LIST; + } else if (identifierEquals(FnvHash.Constants.TABLES) || identifierEquals("TABLES;")) { + return SQLType.SHOW_TABLES; + } else if (identifierEquals(FnvHash.Constants.PARTITIONS)) { + return SQLType.SHOW_PARTITIONS; + } else if (identifierEquals(FnvHash.Constants.CATALOGS)) { + return SQLType.SHOW_CATALOGS; + } else if (identifierEquals(FnvHash.Constants.FUNCTIONS)) { + return SQLType.SHOW_FUNCTIONS; + } else if (identifierEquals(FnvHash.Constants.ROLES)) { + return SQLType.SHOW_ROLES; + } else if (identifierEquals(FnvHash.Constants.LABEL)) { + return SQLType.SHOW_LABEL; + } else if (identifierEquals(FnvHash.Constants.GRANTS)) { + return SQLType.SHOW_GRANTS; + } else if (identifierEquals(FnvHash.Constants.GRANT) + || token == GRANT + ) { + return SQLType.SHOW_GRANT; + } else if (identifierEquals(FnvHash.Constants.RECYCLEBIN)) { + return SQLType.SHOW_RECYCLEBIN; + } else if (identifierEquals("VARIABLES")) { + return SQLType.SHOW_VARIABLES; + } else if (identifierEquals("HISTORY")) { + return SQLType.SHOW_HISTORY; + } else if (identifierEquals("PACKAGES")) { + return SQLType.SHOW_PACKAGES; + } else if (identifierEquals("PACKAGE")) { + return SQLType.SHOW_PACKAGE; + } else if (identifierEquals("CHANGELOGS")) { + return SQLType.SHOW_CHANGELOGS; + } else if (identifierEquals("ACL")) { + return SQLType.SHOW_ACL; + } else if (token == CREATE) { + nextToken(); + if (token == TABLE) { + return SQLType.SHOW_CREATE_TABLE; + } + } return SQLType.SHOW; } else if (hashCode == FnvHash.Constants.DESC) { return SQLType.DESC; } else if (hashCode == FnvHash.Constants.DESCRIBE) { return SQLType.DESC; } else if (hashCode == FnvHash.Constants.SET) { + nextToken(); + if (identifierEquals(FnvHash.Constants.LABEL)) { + return SQLType.SET_LABEL; + } else if (identifierEquals("PROJECT")) { + return SQLType.SET_PROJECT; + } return SQLType.SET; } else if (hashCode == FnvHash.Constants.KILL) { return SQLType.KILL; @@ -785,6 +856,23 @@ public class Lexer { } else if (hashCode == FnvHash.Constants.DROP) { return SQLType.DROP; } else if (hashCode == FnvHash.Constants.LIST) { + nextToken(); + if (identifierEquals(FnvHash.Constants.USERS)) { + return SQLType.LIST_USERS; + } else if (identifierEquals(FnvHash.Constants.TABLES)) { + return SQLType.LIST_TABLES; + } else if (identifierEquals(FnvHash.Constants.ROLES)) { + return SQLType.LIST_ROLES; + } else if (identifierEquals("TENANT")) { + nextToken(); + if (identifierEquals(FnvHash.Constants.ROLES)) { + return SQLType.LIST_TENANT_ROLES; + } + } else if (identifierEquals("TRUSTEDPROJECTS")) { + return SQLType.LIST_TRUSTEDPROJECTS; + } else if (identifierEquals("ACCOUNTPROVIDERS")) { + return SQLType.LIST_ACCOUNTPROVIDERS; + } return SQLType.LIST; } else if (hashCode == FnvHash.Constants.ROLLBACK) { return SQLType.ROLLBACK; @@ -803,13 +891,7 @@ public class Lexer { } else if (hashCode == FnvHash.Constants.READ) { return SQLType.READ; } else if (hashCode == FnvHash.Constants.WITH) { - if (dbType == DbType.mysql - || dbType == DbType.hive - || dbType == DbType.odps - || dbType == DbType.oracle) { - return SQLType.SELECT; - } - return SQLType.UNKNOWN; + return SQLType.WITH; } else if (hashCode == FnvHash.Constants.DUMP) { nextToken(); if (identifierEquals(FnvHash.Constants.DATA)) { @@ -821,12 +903,31 @@ public class Lexer { return SQLType.ADD_USER; } else if (token == TABLE) { return SQLType.ADD_TABLE; + } else if (token == FUNCTION) { + return SQLType.ADD_FUNCTION; + } else if (identifierEquals(FnvHash.Constants.STATISTIC)) { + return SQLType.ADD_STATISTIC; + } else if (identifierEquals(FnvHash.Constants.RESOURCE)) { + return SQLType.ADD_RESOURCE; + } else if (identifierEquals("VOLUME")) { + return SQLType.ADD_VOLUME; + } else if (identifierEquals("ACCOUNTPROVIDER")) { + return SQLType.ADD_ACCOUNTPROVIDER; + } else if (identifierEquals("TRUSTEDPROJECT")) { + return SQLType.ADD_TRUSTEDPROJECT; + } else { + return SQLType.ADD; } } else if (hashCode == FnvHash.Constants.REMOVE) { nextToken(); if (token == Token.USER || identifierEquals(FnvHash.Constants.USER)) { return SQLType.REMOVE_USER; } + + if (identifierEquals(FnvHash.Constants.RESOURCE)) { + return SQLType.REMOVE_RESOURCE; + } + return SQLType.REMOVE; } else if (hashCode == FnvHash.Constants.TUNNEL) { nextToken(); if (identifierEquals(FnvHash.Constants.DOWNLOAD)) { @@ -834,6 +935,68 @@ public class Lexer { } } else if (hashCode == FnvHash.Constants.UPLOAD) { return SQLType.UPLOAD; + } else if (hashCode == FnvHash.Constants.WHOAMI) { + return SQLType.WHOAMI; + } else if (hashCode == FnvHash.Constants.COUNT) { + return SQLType.COUNT; + } else if (hashCode == FnvHash.Constants.CLONE) { + return SQLType.CLONE; + } else if (hashCode == FnvHash.Constants.LOAD) { + return SQLType.LOAD; + } else if (hashCode == FnvHash.Constants.INSTALL) { + return SQLType.INSTALL; + } else if (hashCode == FnvHash.Constants.UNLOAD) { + return SQLType.UNLOAD; + } else if (hashCode == FnvHash.Constants.ALLOW) { + return SQLType.ALLOW; + } else if (hashCode == FnvHash.Constants.PURGE) { + return SQLType.PURGE; + } else if (hashCode == FnvHash.Constants.RESTORE) { + return SQLType.RESTORE; + } else if (hashCode == FnvHash.Constants.EXSTORE) { + return SQLType.EXSTORE; + } else if (hashCode == FnvHash.Constants.UNDO) { + return SQLType.UNDO; + } else if (hashCode == FnvHash.Constants.REMOVE) { + return SQLType.REMOVE; + } else if (hashCode == FnvHash.Constants.FROM) { + if (dbType == DbType.odps || dbType == DbType.hive) { + return SQLType.INSERT_MULTI; + } + } else if (hashCode == FnvHash.Constants.ADD) { + return SQLType.ADD; + } else if (hashCode == FnvHash.Constants.IF) { + return SQLType.SCRIPT; + } else if (hashCode == FnvHash.Constants.FUNCTION) { + if (dbType == DbType.odps) { + return SQLType.SCRIPT; + } + } else if (hashCode == FnvHash.Constants.BEGIN) { + if (dbType == DbType.odps || dbType == DbType.oracle) { + return SQLType.SCRIPT; + } + } else if (ch == '@') { + nextToken(); + if (token == VARIANT && dbType == DbType.odps) { + nextToken(); + + if (token == TABLE) { + return SQLType.SCRIPT; + } + + // datatype + if (token == IDENTIFIER) { + nextToken(); + } + + if (token == COLONEQ || token == SEMI) { + return SQLType.SCRIPT; + } + } + } + + if (ch == EOI) { + return SQLType.EMPTY; } return SQLType.UNKNOWN; @@ -858,10 +1021,16 @@ public class Lexer { sqlType = SQLType.CREATE_TABLE; break; case VIEW: - sqlType = SQLType.CREATE_VIEW; - break _for; + if (sqlType == SQLType.CREATE) { + sqlType = SQLType.CREATE_VIEW; + break _for; + } + break; case FUNCTION: - sqlType = SQLType.CREATE_FUNCTION; + if (sqlType == SQLType.CREATE) { + sqlType = SQLType.CREATE_FUNCTION; + break _for; + } break; case SELECT: if (sqlType == SQLType.CREATE_TABLE) { @@ -870,10 +1039,14 @@ public class Lexer { } break; default: - if (identifierEquals(FnvHash.Constants.ROLE)) { + if (sqlType == SQLType.CREATE && identifierEquals(FnvHash.Constants.ROLE)) { sqlType = SQLType.CREATE_ROLE; break _for; } + if (sqlType == SQLType.CREATE && identifierEquals(FnvHash.Constants.PACKAGE)) { + sqlType = SQLType.CREATE_PACKAGE; + break _for; + } break; } @@ -889,8 +1062,15 @@ public class Lexer { return SQLType.DROP_VIEW; } else if (token == FUNCTION) { return SQLType.DROP_FUNCTION; + } else if (identifierEquals(FnvHash.Constants.ROLE)) { + return SQLType.DROP_ROLE; } else if (identifierEquals(FnvHash.Constants.RESOURCE)) { return SQLType.DROP_RESOURCE; + } else if (identifierEquals(FnvHash.Constants.MATERIALIZED)) { + nextToken(); + if (token == VIEW) { + return SQLType.DROP_MATERIALIZED_VIEW; + } } } else if (sqlType == SQLType.ALTER) { nextToken(); @@ -898,16 +1078,25 @@ public class Lexer { return SQLType.ALTER_USER; } else if (token == TABLE) { return SQLType.ALTER_TABLE; + } else if (token == VIEW) { + return SQLType.ALTER_VIEW; } } else if (sqlType == SQLType.INSERT) { + nextToken(); + boolean overwrite = token == OVERWRITE; for (int i = 0; i < 1000;++i) { nextToken(); if (token == SELECT) { - return SQLType.INSERT_SELECT; + return overwrite + ? SQLType.INSERT_OVERWRITE_SELECT + : SQLType.INSERT_INTO_SELECT; } else if (token == VALUES) { - return SQLType.INSERT_VALUES; + return overwrite ? SQLType.INSERT_OVERWRITE_VALUES : SQLType.INSERT_INTO_VALUES; } else if (token == ERROR || token == EOF) { + if (overwrite) { + sqlType = SQLType.INSERT_OVERWRITE; + } break; } } 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 80eb77e370..37f6573106 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java @@ -28,6 +28,7 @@ import com.alibaba.druid.util.HexBin; import com.alibaba.druid.util.MySqlUtils; import com.alibaba.druid.util.StringUtils; +import java.math.BigDecimal; import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; @@ -327,6 +328,7 @@ public class SQLExprParser extends SQLParser { lexer.nextToken(); sqlExpr = expr(); + if (lexer.token == Token.COMMA) { SQLListExpr listExpr = new SQLListExpr(); listExpr.addItem(sqlExpr); @@ -503,12 +505,29 @@ public class SQLExprParser extends SQLParser { case NEW: throw new ParserException("TODO " + lexer.info()); case LITERAL_INT: - sqlExpr = new SQLIntegerExpr(lexer.integerValue()); + Number number = lexer.integerValue(); lexer.nextToken(); + + if (lexer.identifierEquals(FnvHash.Constants.BD)) { + SQLDecimalExpr decimalExpr = new SQLDecimalExpr(); + decimalExpr.setValue(new BigDecimal(number.intValue())); + lexer.nextToken(); + sqlExpr = decimalExpr; + } else { + sqlExpr = new SQLIntegerExpr(number); + } break; case LITERAL_FLOAT: sqlExpr = lexer.numberExpr(); lexer.nextToken(); + + if (lexer.identifierEquals(FnvHash.Constants.BD)) { + SQLDecimalExpr decimalExpr = new SQLDecimalExpr(); + decimalExpr.setValue(new BigDecimal(sqlExpr.toString())); + lexer.nextToken(); + sqlExpr = decimalExpr; + } + break; case LITERAL_CHARS: { sqlExpr = new SQLCharExpr(lexer.stringVal()); @@ -875,6 +894,7 @@ public class SQLExprParser extends SQLParser { case LBRACE: case IF: case CHECK: + case REPLACE: sqlExpr = primary(); while (lexer.token == Token.HINT) { @@ -919,6 +939,9 @@ public class SQLExprParser extends SQLParser { case NULL: case INTERVAL: case LBRACE: + case IF: + case CHECK: + case REPLACE: sqlExpr = primary(); while (lexer.token == Token.HINT) { @@ -1042,6 +1065,9 @@ public class SQLExprParser extends SQLParser { case SET: { Lexer.SavePoint savePoint = lexer.mark(); lexer.nextToken(); + if (lexer.token == Token.SET && dbType == DbType.odps) { + lexer.nextToken(); + } if (lexer.token() == Token.LPAREN) { sqlExpr = new SQLIdentifierExpr("SET"); } else { @@ -1103,6 +1129,7 @@ public class SQLExprParser extends SQLParser { case UNIQUE: case PROCEDURE: case REFERENCES: + case IS: if (dbType == DbType.odps || dbType == DbType.hive) { sqlExpr = new SQLIdentifierExpr(lexer.stringVal()); lexer.nextToken(); @@ -1320,8 +1347,6 @@ public class SQLExprParser extends SQLParser { case LTEQ: case GT: case GTEQ: - case PLUS: - case SUB: case STAR: case DIV: case SLASH: @@ -1332,6 +1357,20 @@ public class SQLExprParser extends SQLParser { case END: case AS: return new SQLIdentifierExpr(str); + case PLUS: + case SUB: { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextToken(); + if (lexer.token == Token.LITERAL_INT) { + lexer.nextToken(); + if (lexer.token == Token.IDENTIFIER) { + lexer.reset(mark); + break; + } + } + + return new SQLIdentifierExpr(str); + } default: break; } @@ -1355,12 +1394,16 @@ public class SQLExprParser extends SQLParser { throw new ParserException("Syntax error. " + lexer.info()); } - String unit = lexer.stringVal(); + String unit = lexer.stringVal().toUpperCase(); lexer.nextToken(); + if (unit.equals("DAYS")) { + unit = "DAY"; + } + SQLIntervalExpr intervalExpr = new SQLIntervalExpr(); intervalExpr.setValue(value); - intervalExpr.setUnit(SQLIntervalUnit.valueOf(unit.toUpperCase())); + intervalExpr.setUnit(SQLIntervalUnit.valueOf(unit)); return intervalExpr; } @@ -1429,6 +1472,10 @@ public class SQLExprParser extends SQLParser { if (lexer.token == Token.LPAREN) { lexer.nextToken(); + if (lexer.token == Token.COMMA && dbType == DbType.odps) { + lexer.nextToken(); + } + SQLListExpr listExpr = new SQLListExpr(); this.exprList(listExpr.getItems(), listExpr); item = listExpr; @@ -1992,8 +2039,10 @@ public class SQLExprParser extends SQLParser { expr = expr(); } - expr.setParent(parent); - exprCol.add(expr); + if (expr != null) { + expr.setParent(parent); + exprCol.add(expr); + } if (lexer.token == Token.COMMA) { if (dbType == DbType.mysql) { @@ -2126,6 +2175,7 @@ public class SQLExprParser extends SQLParser { case FOR: case LEAVE: case REPEAT: + case LOOP: case IS: identName = lexer.stringVal(); lexer.nextToken(); @@ -2316,6 +2366,14 @@ public class SQLExprParser extends SQLParser { lexer.nextToken(); exprList(over.getPartitionBy(), over); } + } else if (lexer.token == Token.ALL) { + SQLName name = this.name(); + name.setParent(over); + over.getPartitionBy().add(name); + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + exprList(over.getPartitionBy(), over); + } } else { exprList(over.getPartitionBy(), over); } @@ -3356,15 +3414,20 @@ public class SQLExprParser extends SQLParser { rightExp = bitOr(); expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrGreater, rightExp, getDbType()); break; - case LIKE: + case LIKE: { + Lexer.SavePoint mark = lexer.mark(); lexer.nextTokenValue(); + if (lexer.token == Token.COMMA) { + lexer.reset(mark); + return expr; + } 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 ) + if (length > 1 + && name.charAt(0) == name.charAt(length - 1) && name.charAt(0) != '`' ) { rightExp = new SQLCharExpr(name.substring(1, length - 1)); @@ -3381,6 +3444,7 @@ public class SQLExprParser extends SQLParser { expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType()); } break; + } case ILIKE: lexer.nextToken(); rightExp = bitOr(); @@ -3788,7 +3852,7 @@ public class SQLExprParser extends SQLParser { SQLStructDataType struct = new SQLStructDataType(dbType); accept(Token.LT); - for (;;) { + for (; ; ) { SQLName name; switch (lexer.token) { case GROUP: @@ -3825,6 +3889,22 @@ public class SQLExprParser extends SQLParser { accept(Token.GT); } return struct; + } else if (lexer.token == Token.TABLE) { + lexer.nextToken(); + SQLTableDataType table = new SQLTableDataType(); + accept(Token.LPAREN); + for (;;) { + SQLColumnDefinition column = this.parseColumn(); + column.setParent(table); + table.getColumns().add(column); + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RPAREN); + return table; } else if (lexer.identifierEquals(FnvHash.Constants.ROW) || lexer.token == Token.ROW) { lexer.nextToken(); return parseSqlRowDataType(); @@ -4690,14 +4770,34 @@ public class SQLExprParser extends SQLParser { } public SQLAssignItem parseAssignItem() { - return parseAssignItem(true); + return parseAssignItem(true, null); } public SQLAssignItem parseAssignItem(boolean variant) { + return parseAssignItem(variant, null); + } + + public SQLAssignItem parseAssignItem(boolean variant, SQLObject parent) { SQLAssignItem item = new SQLAssignItem(); + if (lexer.token == Token.DOT && dbType == DbType.odps) { + lexer.nextToken(); + } + SQLExpr var = primary(); + if (var instanceof SQLPropertyExpr && lexer.token == Token.SUB && dbType == DbType.odps) { + SQLPropertyExpr propertyExpr = (SQLPropertyExpr) var; + String name = propertyExpr.getName() + '-'; + lexer.nextToken(); + if (lexer.token == Token.IDENTIFIER) { + name += lexer.stringVal(); + lexer.nextToken(); + } + propertyExpr.setName(name); + var = this.primaryRest(propertyExpr); + } + if (variant && var instanceof SQLIdentifierExpr) { SQLIdentifierExpr ident = (SQLIdentifierExpr) var; if (lexer.identifierEquals(FnvHash.Constants.CLUSTER) @@ -4766,7 +4866,9 @@ public class SQLExprParser extends SQLParser { } } - if (lexer.token == Token.COMMA && DbType.postgresql == dbType) { + if (lexer.token == Token.COMMA + && (DbType.postgresql == dbType + || (DbType.odps == dbType && parent instanceof SQLSetStatement))) { SQLListExpr listExpr = new SQLListExpr(); listExpr.addItem(expr); expr.setParent(listExpr); diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java b/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java index 23ab83d00c..186962de01 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java @@ -228,7 +228,10 @@ public class SQLParser { case TRIGGER: case CREATE: case ASC: + case INOUT: case DESC: + case SCHEMA: + case IS: if (dbType == DbType.odps || dbType == DbType.hive) { String strVal = lexer.stringVal(); lexer.nextToken(); @@ -356,19 +359,24 @@ public class SQLParser { case TABLESPACE: case REPEAT: case PRIMARY: + case UNIQUE: + case LEAVE: alias = lexer.stringVal(); lexer.nextToken(); break; case INTERSECT: case EXCEPT: case DESC: + case INOUT: case MINUS: { alias = lexer.stringVal(); Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); if (lexer.token() != Token.COMMA - && lexer.token() != Token.RPAREN) { + && lexer.token() != Token.RPAREN + && lexer.token() != Token.FROM + ) { alias = null; lexer.reset(mark); } @@ -384,6 +392,10 @@ public class SQLParser { case SEQUENCE: case TO: case REFERENCES: + case LIKE: + case NULL: + case RIGHT: + case LEFT: if (dbType == DbType.odps || dbType == DbType.hive) { alias = lexer.stringVal(); lexer.nextToken(); @@ -555,6 +567,8 @@ public class SQLParser { case PRIMARY: case FOREIGN: case REFERENCES: + case INTO: + case USE: alias = lexer.stringVal(); lexer.nextToken(); return alias; 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 a229d07939..686da2ccf7 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java @@ -1139,7 +1139,15 @@ public class SQLSelectParser extends SQLParser { tableReference.setHint(hint); } - SQLExpr expr = expr(); + SQLExpr expr; + switch (lexer.token) { + case ALL: + expr = this.exprParser.name(); + break; + default: + expr = expr(); + break; + } if (expr instanceof SQLBinaryOpExpr) { throw new ParserException("Invalid from clause : " + expr.toString().replace("\n", " ")); @@ -1511,7 +1519,16 @@ public class SQLSelectParser extends SQLParser { if (rightTableSource == null) { boolean aliasToken = lexer.token == Token.LITERAL_ALIAS; - SQLExpr expr = this.expr(); + SQLExpr expr; + switch (lexer.token) { + case ALL: + expr = this.exprParser.name(); + break; + default: + expr = this.expr(); + break; + } + if (aliasToken && expr instanceof SQLCharExpr) { expr = new SQLIdentifierExpr(((SQLCharExpr) expr).getText()); } diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java b/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java index fd4749ea8c..b0ed3a1a34 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java @@ -1133,6 +1133,18 @@ public class SQLStatementParser extends SQLParser { return stmt; } + if (lexer.token == ALL) { + lexer.nextToken(); + + SQLPurgeTableStatement stmt = new SQLPurgeTableStatement(); + stmt.setAll(true); + + if (lexer.token == LITERAL_INT) { + stmt.setCount(lexer.integerValue().intValue()); + lexer.nextToken(); + } + return stmt; + } if (lexer.identifierEquals("TEMPORARY")) { lexer.nextToken(); @@ -2188,6 +2200,14 @@ public class SQLStatementParser extends SQLParser { } stmt.addItem(item); + } else if (lexer.identifierEquals("CHANGEOWNER")) { + lexer.nextToken(); + accept(TO); + SQLName name = this.exprParser.name(); + SQLAlterTableChangeOwner changeOwner = new SQLAlterTableChangeOwner(); + changeOwner.setOwner(name); + + stmt.addItem(changeOwner); } else if (lexer.identifierEquals(FnvHash.Constants.ARCHIVE)) { lexer.nextToken(); @@ -3182,7 +3202,7 @@ public class SQLStatementParser extends SQLParser { public void parseAssignItems(List items, SQLObject parent, boolean variant) { for (;;) { - SQLAssignItem item = exprParser.parseAssignItem(variant); + SQLAssignItem item = exprParser.parseAssignItem(variant, parent); item.setParent(parent); items.add(item); @@ -4417,6 +4437,15 @@ public class SQLStatementParser extends SQLParser { accept(Token.RPAREN); } + if (lexer.identifierEquals("RETURNS")) { + lexer.nextToken(); + SQLVariantRefExpr varRef = (SQLVariantRefExpr) this.exprParser.expr(); + createView.setReturns(varRef); + createView.setReturnsDataType( + (SQLTableDataType) this.exprParser.parseDataType() + ); + } + if (lexer.token == Token.COMMENT) { lexer.nextToken(); SQLCharExpr comment = (SQLCharExpr) exprParser.primary(); @@ -5224,7 +5253,9 @@ public class SQLStatementParser extends SQLParser { if (lexer.token == Token.LPAREN) { lexer.nextToken(); - exprParser.names(entry.getColumns()); + if (lexer.token != RPAREN) { + exprParser.names(entry.getColumns()); + } accept(Token.RPAREN); } @@ -6941,7 +6972,10 @@ public class SQLStatementParser extends SQLParser { HiveCreateFunctionStatement stmt = new HiveCreateFunctionStatement(); stmt.setDbType(dbType); - accept(Token.CREATE); + if (lexer.token == CREATE) { + lexer.nextToken(); + } + if (lexer.identifierEquals(FnvHash.Constants.TEMPORARY)) { lexer.nextToken(); stmt.setTemporary(true); @@ -6951,6 +6985,21 @@ public class SQLStatementParser extends SQLParser { SQLName name = this.exprParser.name(); stmt.setName(name); + if (lexer.token == LPAREN) { + lexer.nextToken(); + while (lexer.token != RPAREN) { + SQLParameter param = new SQLParameter(); + param.setName(this.exprParser.name()); + param.setDataType(this.exprParser.parseDataType()); + if (lexer.token == COMMA) { + lexer.nextToken(); + } + stmt.getParameters().add(param); + param.setParent(stmt); + } + accept(RPAREN); + } + if (lexer.token() == Token.AS) { lexer.setToken(Token.IDENTIFIER); lexer.nextToken(); @@ -6983,6 +7032,11 @@ public class SQLStatementParser extends SQLParser { } else if (lexer.identifierEquals(FnvHash.Constants.FILE)) { lexer.nextToken(); stmt.setResourceType(HiveCreateFunctionStatement.ResourceType.FILE); + } else if (lexer.token == Token.CODE) { + stmt.setCode(lexer.stringVal()); + lexer.nextToken(); + stmt.setResourceType(HiveCreateFunctionStatement.ResourceType.CODE); + return stmt; } SQLExpr location = this.exprParser.primary(); diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLType.java b/src/main/java/com/alibaba/druid/sql/parser/SQLType.java index 96a6fb7d56..0e54316c70 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLType.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLType.java @@ -4,8 +4,15 @@ public enum SQLType { SELECT, UPDATE, INSERT_SELECT, + INSERT_INTO_SELECT, + INSERT_OVERWRITE_SELECT, INSERT_VALUES, + INSERT_INTO_VALUES, + INSERT_OVERWRITE_VALUES, INSERT, + INSERT_INTO, + INSERT_OVERWRITE, + INSERT_MULTI, DELETE, MERGE, @@ -20,10 +27,37 @@ public enum SQLType { EXPLAIN, SHOW, + SHOW_TABLES, + SHOW_USERS, + SHOW_PARTITIONS, + SHOW_CATALOGS, + SHOW_FUNCTIONS, + SHOW_ROLES, + SHOW_PACKAGE, + SHOW_PACKAGES, + SHOW_CHANGELOGS, + SHOW_ACL, + SHOW_RECYCLEBIN, + SHOW_VARIABLES, + SHOW_HISTORY, + SHOW_GRANT, + SHOW_GRANTS, + SHOW_CREATE_TABLE, + SHOW_STATISTIC, + SHOW_STATISTIC_LIST, + SHOW_LABEL, DESC, SET, + SET_PROJECT, + SET_LABEL, DUMP_DATA, LIST, // for analyticdb + LIST_USERS, + LIST_TABLES, + LIST_ROLES, + LIST_TENANT_ROLES, + LIST_TRUSTEDPROJECTS, + LIST_ACCOUNTPROVIDERS, WHO, // for analyticdb GRANT, REVOKE, @@ -36,6 +70,7 @@ public enum SQLType { ADD_USER, REMOVE_USER, + REMOVE_RESOURCE, CREATE_USER, CREATE_TABLE, @@ -43,18 +78,69 @@ public enum SQLType { CREATE_VIEW, CREATE_FUNCTION, CREATE_ROLE, + CREATE_PACKAGE, + DROP_USER, DROP_TABLE, DROP_VIEW, + DROP_MATERIALIZED_VIEW, DROP_FUNCTION, + DROP_ROLE, DROP_RESOURCE, ALTER_USER, ALTER_TABLE, + ALTER_VIEW, READ, ADD_TABLE, + ADD_FUNCTION, + ADD_RESOURCE, + ADD_TRUSTEDPROJECT, + ADD_VOLUME, + ADD_STATISTIC, + ADD_ACCOUNTPROVIDER, TUNNEL_DOWNLOAD, UPLOAD, - UNKNOWN + WHOAMI, + SCRIPT, + COUNT, + + ADD, + CLONE, + LOAD, + INSTALL, + UNLOAD, + ALLOW, + PURGE, + RESTORE, + EXSTORE, + UNDO, + REMOVE, + + EMPTY, + + ALTER_TABLE_ADD_PARTITION, + ALTER_TABLE_MERGE_PARTITION, + ALTER_TABLE_DROP_PARTITION, + ALTER_TABLE_RENAME_PARTITION, + ALTER_TABLE_SET_LIFECYCLE, + ALTER_TABLE_ENABLE_LIFECYCLE, + ALTER_TABLE_DISABLE_LIFECYCLE, + ALTER_TABLE_RENAME, + ALTER_TABLE_ADD_COLUMN, + ALTER_TABLE_RENAME_COLUMN, + ALTER_TABLE_ALTER_COLUMN, + ALTER_TABLE_SET_TBLPROPERTIES, + ALTER_TABLE_SET_COMMENT, + ALTER_TABLE_TOUCH, + ALTER_TABLE_CHANGE_OWNER, + + MULTI, + + WITH, + SET_UNKNOWN, + UNKNOWN, + + ERROR, } 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 4b4a36931a..cf0cc48ceb 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/Token.java +++ b/src/main/java/com/alibaba/druid/sql/parser/Token.java @@ -262,6 +262,8 @@ public enum Token { LITERAL_CHARS, LITERAL_NCHARS, + CODE, // odps + LITERAL_PATH, LITERAL_ALIAS, diff --git a/src/main/java/com/alibaba/druid/sql/repository/SchemaRepository.java b/src/main/java/com/alibaba/druid/sql/repository/SchemaRepository.java index 64775060ec..f573cc8a44 100644 --- a/src/main/java/com/alibaba/druid/sql/repository/SchemaRepository.java +++ b/src/main/java/com/alibaba/druid/sql/repository/SchemaRepository.java @@ -375,6 +375,15 @@ public class SchemaRepository { resolveVisitor.visit(stmt); } + public void resolve(SQLSelect select, SchemaResolveVisitor.Option... options) { + if (select == null) { + return; + } + + SchemaResolveVisitor resolveVisitor = createResolveVisitor(options); + resolveVisitor.visit(select); + } + public void resolve(SQLSelectQueryBlock queryBlock, SchemaResolveVisitor.Option... options) { if (queryBlock == null) { return; diff --git a/src/main/java/com/alibaba/druid/sql/repository/SchemaResolveVisitorFactory.java b/src/main/java/com/alibaba/druid/sql/repository/SchemaResolveVisitorFactory.java index 03d96a032f..29ba8c89b0 100644 --- a/src/main/java/com/alibaba/druid/sql/repository/SchemaResolveVisitorFactory.java +++ b/src/main/java/com/alibaba/druid/sql/repository/SchemaResolveVisitorFactory.java @@ -1890,6 +1890,14 @@ class SchemaResolveVisitorFactory { checkParameter(visitor, identifierExpr); SQLTableSource tableSource = unwrapAlias(visitor.getContext(), null, identifierExpr.nameHashCode64()); + if (tableSource == null && x.getParent() instanceof HiveMultiInsertStatement) { + SQLWithSubqueryClause with = ((HiveMultiInsertStatement) x.getParent()).getWith(); + if (with != null) { + SQLWithSubqueryClause.Entry entry = with.findEntry(identifierExpr.nameHashCode64()); + tableSource = entry; + } + } + if (tableSource != null) { identifierExpr.setResolvedTableSource(tableSource); return; 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 44583a8167..7a8be80904 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java @@ -2652,4 +2652,19 @@ public interface SQLASTVisitor { return true; } + default void endVisit(SQLAlterTableChangeOwner x) { + + } + + default boolean visit(SQLAlterTableChangeOwner x) { + return true; + } + + default void endVisit(SQLTableDataType x) { + + } + + default boolean visit(SQLTableDataType x) { + return true; + } } diff --git a/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java b/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java index 034fbae5a7..1841d14b3f 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java @@ -1200,6 +1200,8 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter { public boolean visit(SQLSelectQueryBlock x) { SQLTableSource from = x.getFrom(); + setMode(x, Mode.Select); + boolean isHiveMultiInsert = false; if (from == null) { isHiveMultiInsert = x.getParent() != null @@ -1218,8 +1220,6 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter { return false; } - setMode(x, Mode.Select); - // if (x.getFrom() instanceof SQLSubqueryTableSource) { // x.getFrom().accept(this); // return false; @@ -3199,4 +3199,9 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter { public boolean visit(SQLSavePointStatement x) { return false; } + + public boolean visit(SQLShowPartitionsStmt x) { + setMode(x, Mode.DESC); + return true; + } } diff --git a/src/main/java/com/alibaba/druid/stat/TableStat.java b/src/main/java/com/alibaba/druid/stat/TableStat.java index 498a25b1cd..eb2543e407 100644 --- a/src/main/java/com/alibaba/druid/stat/TableStat.java +++ b/src/main/java/com/alibaba/druid/stat/TableStat.java @@ -623,6 +623,7 @@ public class TableStat { DropIndex(256), // CreateIndex(512), // Replace(1024), + DESC(2048) ; // public final int mark; diff --git a/src/main/java/com/alibaba/druid/support/opds/udf/ExportFunctions.java b/src/main/java/com/alibaba/druid/support/opds/udf/ExportFunctions.java index dbf25d9b58..d020741611 100644 --- a/src/main/java/com/alibaba/druid/support/opds/udf/ExportFunctions.java +++ b/src/main/java/com/alibaba/druid/support/opds/udf/ExportFunctions.java @@ -18,12 +18,18 @@ package com.alibaba.druid.support.opds.udf; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.SQLUtils; import com.alibaba.druid.sql.ast.SQLStatement; -import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; -import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr; +import com.alibaba.druid.sql.ast.expr.*; +import com.alibaba.druid.sql.dialect.odps.ast.OdpsNewExpr; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; +import com.alibaba.druid.sql.parser.SQLParserFeature; +import com.alibaba.druid.sql.visitor.SQLASTVisitorAdapter; import com.alibaba.druid.sql.visitor.SchemaStatVisitor; import com.aliyun.odps.udf.UDF; +import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; public class ExportFunctions extends UDF { @@ -39,8 +45,10 @@ public class ExportFunctions extends UDF { DbType dbType = dbTypeName == null ? null : DbType.valueOf(dbTypeName); try { - List statementList = SQLUtils.parseStatements(sql, dbType); - SchemaStatVisitor visitor = SQLUtils.createSchemaStatVisitor(dbType); + List statementList = SQLUtils.parseStatements(sql, dbType + , SQLParserFeature.EnableMultiUnion + , SQLParserFeature.EnableSQLBinaryOpExprGroup); + Visitor visitor = new Visitor(); for (SQLStatement stmt : statementList) { stmt.accept(visitor); @@ -49,22 +57,19 @@ public class ExportFunctions extends UDF { StringBuffer buf = new StringBuffer(); List functions = visitor.getFunctions(); + Set functionSet = new LinkedHashSet<>(); for (int i = 0; i < functions.size(); i++) { - if (i != 0) { - buf.append(","); - } - SQLMethodInvokeExpr func = functions.get(i); - String funcName = func.getMethodName(); - buf.append(funcName); + functionSet.add(functions.get(i).getMethodName()); } - for (int i = 0; i < visitor.getAggregateFunctions().size(); i++) { - if (buf.length() > 0) { + for (String funcName : functionSet) { + if (funcName.length() > 2 && funcName.charAt(0) == '`' && funcName.charAt(funcName.length() - 1) == '`') { + funcName = funcName.substring(1, funcName.length() - 1); + } + if (buf.length() != 0) { buf.append(","); } - SQLAggregateExpr func = visitor.getAggregateFunctions().get(i); - String funcName = func.getMethodName(); buf.append(funcName); } @@ -78,6 +83,58 @@ public class ExportFunctions extends UDF { } return null; + } catch (StackOverflowError ex) { + System.err.println("error sql : " + sql); + ex.printStackTrace(); + + if (throwError) { + throw ex; + } + + return null; + } + } + + public static class Visitor extends SQLASTVisitorAdapter implements OdpsASTVisitor { + private final List functions = new ArrayList(); + + public boolean visit(SQLMethodInvokeExpr x) { + functions.add(x); + return true; + } + + public boolean visit(SQLAggregateExpr x) { + functions.add(x); + return true; + } + + public boolean visit(OdpsNewExpr x) { + functions.add(x); + return true; + } + + public List getFunctions() { + return functions; + } + + public boolean visit(SQLCastExpr x) { + functions.add(new SQLMethodInvokeExpr("CAST")); + return true; + } + + public boolean visit(SQLBetweenExpr x) { + functions.add(new SQLMethodInvokeExpr("BETWEEN")); + return true; + } + + public boolean visit(SQLCaseExpr x) { + functions.add(new SQLMethodInvokeExpr("CASE")); + return true; + } + + public boolean visit(SQLInListExpr x) { + functions.add(new SQLMethodInvokeExpr("IN")); + return true; } } } diff --git a/src/main/java/com/alibaba/druid/support/opds/udf/ExportInputTables.java b/src/main/java/com/alibaba/druid/support/opds/udf/ExportInputTables.java index b713853ea8..935b6fd8b8 100644 --- a/src/main/java/com/alibaba/druid/support/opds/udf/ExportInputTables.java +++ b/src/main/java/com/alibaba/druid/support/opds/udf/ExportInputTables.java @@ -15,78 +15,9 @@ */ package com.alibaba.druid.support.opds.udf; -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.*; -import com.alibaba.druid.sql.repository.SchemaRepository; -import com.alibaba.druid.sql.visitor.SchemaStatVisitor; -import com.alibaba.druid.stat.TableStat; -import com.aliyun.odps.udf.UDF; - -import java.util.List; -import java.util.Map; - -public class ExportInputTables extends UDF { - - public String evaluate(String sql) throws Throwable { - return evaluate(sql, null, false); - } - - public String evaluate(String sql, String dbTypeName) throws Throwable { - return evaluate(sql, dbTypeName, false); - } - - public String evaluate(String sql, String dbTypeName, boolean throwError) throws Throwable { - DbType dbType = dbTypeName == null ? null : DbType.valueOf(dbTypeName); - - Throwable error = null; - try { - SchemaRepository repo = new SchemaRepository(dbType); - List statementList = SQLUtils.parseStatements(sql, dbType); - SchemaStatVisitor visitor = SQLUtils.createSchemaStatVisitor(repo, dbType); - - for (SQLStatement stmt : statementList) { - if (stmt instanceof SQLCreateViewStatement) { - repo.accept(stmt); - } else if (stmt instanceof SQLCreateTableStatement) { - repo.accept(stmt); - } else if (stmt instanceof SQLDropTableStatement) { - repo.accept(stmt); - } else if (stmt instanceof SQLDropViewStatement) { - repo.accept(stmt); - } - - stmt.accept(visitor); - } - - StringBuffer buf = new StringBuffer(); - - for (Map.Entry entry : visitor.getTables().entrySet()) { - TableStat.Name name = entry.getKey(); - - TableStat stat = entry.getValue(); - if (stat.getSelectCount() == 0) { - continue; - } - - if (buf.length() != 0) { - buf.append(','); - } - buf.append(name.toString()); - } - - return buf.toString(); - } catch (Exception ignored) { - error = ignored; - } catch (StackOverflowError ignored) { - error = ignored; - } - - if (throwError && error != null) { - throw error; - } - - return null; +public class ExportInputTables extends ExportIO { + public String evaluate(String sql, String dbTypeName, String projectName) { + return new DependencyExtractor(sql, dbTypeName, projectName) + .inputs(); } } diff --git a/src/main/java/com/alibaba/druid/support/opds/udf/ExportOutputTables.java b/src/main/java/com/alibaba/druid/support/opds/udf/ExportOutputTables.java index 8d064b89f0..03c964f02b 100644 --- a/src/main/java/com/alibaba/druid/support/opds/udf/ExportOutputTables.java +++ b/src/main/java/com/alibaba/druid/support/opds/udf/ExportOutputTables.java @@ -17,63 +17,23 @@ package com.alibaba.druid.support.opds.udf; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.SQLUtils; +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLName; import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.ast.statement.*; +import com.alibaba.druid.sql.dialect.hive.ast.HiveInsertStatement; +import com.alibaba.druid.sql.parser.SQLParserFeature; +import com.alibaba.druid.sql.repository.SchemaObject; +import com.alibaba.druid.sql.repository.SchemaRepository; import com.alibaba.druid.sql.visitor.SchemaStatVisitor; import com.alibaba.druid.stat.TableStat; import com.aliyun.odps.udf.UDF; -import java.util.List; -import java.util.Map; +import java.util.*; -public class ExportOutputTables extends UDF { +public class ExportOutputTables extends ExportIO { - public String evaluate(String sql) throws Throwable { - return evaluate(sql, null, false); - } - - public String evaluate(String sql, String dbTypeName) throws Throwable { - return evaluate(sql, dbTypeName, false); - } - - public String evaluate(String sql, String dbTypeName, boolean throwError) throws Throwable { - DbType dbType = dbTypeName == null ? null : DbType.valueOf(dbTypeName); - - Throwable error = null; - try { - List statementList = SQLUtils.parseStatements(sql, dbType); - SchemaStatVisitor visitor = SQLUtils.createSchemaStatVisitor(dbType); - - for (SQLStatement stmt : statementList) { - stmt.accept(visitor); - } - - StringBuffer buf = new StringBuffer(); - - for (Map.Entry entry : visitor.getTables().entrySet()) { - TableStat.Name name = entry.getKey(); - - TableStat stat = entry.getValue(); - if (stat.getInsertCount() == 0) { - continue; - } - - if (buf.length() != 0) { - buf.append(','); - } - buf.append(name.toString()); - } - - return buf.toString(); - } catch (Exception ignored) { - // skip - } catch (StackOverflowError ignored) { - // skip - } - - if (throwError && error != null) { - throw error; - } - - return null; + public String evaluate(String sql, String dbTypeName, String projectName) { + return outputs(sql, dbTypeName, projectName); } } diff --git a/src/main/java/com/alibaba/druid/support/opds/udf/MetaSqlExtract.java b/src/main/java/com/alibaba/druid/support/opds/udf/MetaSqlExtract.java index 60690a0b52..43622ab2b5 100644 --- a/src/main/java/com/alibaba/druid/support/opds/udf/MetaSqlExtract.java +++ b/src/main/java/com/alibaba/druid/support/opds/udf/MetaSqlExtract.java @@ -21,10 +21,14 @@ public class MetaSqlExtract extends UDF { } String sql = xml.substring(p0, p1); - if (sql.startsWith(" " stmtList = SQLUtils.parseStatements(sql, DbType.odps, SQLParserFeature.EnableMultiUnion); + List stmtList = SQLUtils.parseStatements(sql, DbType.odps + , SQLParserFeature.EnableMultiUnion + , SQLParserFeature.EnableSQLBinaryOpExprGroup); CodeStatVisitor v = new CodeStatVisitor(); for (SQLStatement stmt : stmtList) { @@ -74,6 +79,12 @@ public class SqlCodeStat extends UDF { @JSONField(ordinal = 8) public int over; + @JSONField(ordinal = 9) + public int subQuery; + + @JSONField(ordinal = 10) + public int lateralView; + @JSONField(ordinal = 40) public int insert; @@ -86,6 +97,9 @@ public class SqlCodeStat extends UDF { @JSONField(ordinal = 43) public int insertSelect; + @JSONField(ordinal = 44) + public int insertMulti; + @JSONField(ordinal = 51) public int update; @@ -113,22 +127,28 @@ public class SqlCodeStat extends UDF { @JSONField(ordinal = 80) public int set; + @JSONField(ordinal = 90) + public int alter; + @JSONField(ordinal = 100) - public int condition; - - @JSONField(ordinal = 101) - public int joinCondition; - - @JSONField(ordinal = 102) - public int valueCondition; - - @JSONField(ordinal = 103) - public int otherCondition; - - @JSONField(ordinal = 104) - public int limit; + public int read; @JSONField(ordinal = 200) + public int condition; + + @JSONField(ordinal = 201) + public int joinCondition; + + @JSONField(ordinal = 202) + public int valueCondition; + + @JSONField(ordinal = 203) + public int otherCondition; + + @JSONField(ordinal = 204) + public int limit; + + @JSONField(ordinal = 300) public int aggregate; @JSONField(ordinal = 201) @@ -138,7 +158,7 @@ public class SqlCodeStat extends UDF { public int having; } - private static class CodeStatVisitor extends OdpsASTVisitorAdapter { + static class CodeStatVisitor extends OdpsASTVisitorAdapter { SqlStat stat = new SqlStat(); public void preVisit(SQLObject x) { @@ -159,7 +179,17 @@ public class SqlCodeStat extends UDF { } else { stat.insertInto++; } - + } else if (x instanceof HiveMultiInsertStatement) { + stat.insert++; + stat.insertMulti++; + stat.insertSelect++; + for (HiveInsert item : ((HiveMultiInsertStatement) x).getItems()) { + if (item.isOverwrite()) { + stat.insertOverwrite++; + } else { + stat.insertInto++; + } + } } else if (x instanceof SQLDropStatement) { stat.drop++; if (x instanceof SQLDropTableStatement) { @@ -180,6 +210,10 @@ public class SqlCodeStat extends UDF { stat.update++; } else if (x instanceof SQLSetStatement) { stat.set++; + } else if (x instanceof SQLAlterStatement) { + stat.alter++; + } else if (x instanceof OdpsReadStatement) { + stat.read++; } } } @@ -189,6 +223,11 @@ public class SqlCodeStat extends UDF { return true; } + public boolean visit(SQLLateralViewTableSource x) { + stat.lateralView++; + return true; + } + public boolean visit(OdpsSelectQueryBlock x) { return visit((SQLSelectQueryBlock) x); } @@ -228,10 +267,14 @@ public class SqlCodeStat extends UDF { public boolean visit(SQLSubqueryTableSource x) { stat.from++; + stat.subQuery++; return true; } public boolean visit(SQLJoinTableSource x) { + if (!(x.getParent() instanceof SQLJoinTableSource)) { + stat.from++; + } stat.join++; return true; } @@ -304,5 +347,9 @@ public class SqlCodeStat extends UDF { , SerializerFeature.PrettyFormat , SerializerFeature.NotWriteDefaultValue); } + + public java.util.Map toMap() { + return (java.util.Map) JSON.toJSON(stat); + } } } diff --git a/src/main/java/com/alibaba/druid/support/opds/udf/SqlTypeUDF.java b/src/main/java/com/alibaba/druid/support/opds/udf/SqlTypeUDF.java index 54129cfb53..3f8fdeda3d 100644 --- a/src/main/java/com/alibaba/druid/support/opds/udf/SqlTypeUDF.java +++ b/src/main/java/com/alibaba/druid/support/opds/udf/SqlTypeUDF.java @@ -1,13 +1,20 @@ package com.alibaba.druid.support.opds.udf; import com.alibaba.druid.DbType; -import com.alibaba.druid.sql.parser.Lexer; -import com.alibaba.druid.sql.parser.ParserException; -import com.alibaba.druid.sql.parser.SQLParserUtils; -import com.alibaba.druid.sql.parser.SQLType; -import com.alibaba.druid.sql.visitor.ParameterizedOutputVisitorUtils; +import com.alibaba.druid.sql.SQLUtils; +import com.alibaba.druid.sql.ast.SQLStatement; +import com.alibaba.druid.sql.ast.statement.*; +import com.alibaba.druid.sql.dialect.hive.ast.HiveInsertStatement; +import com.alibaba.druid.sql.dialect.hive.ast.HiveMultiInsertStatement; +import com.alibaba.druid.sql.dialect.odps.ast.OdpsDeclareVariableStatement; +import com.alibaba.druid.sql.dialect.odps.ast.OdpsQueryAliasStatement; +import com.alibaba.druid.sql.parser.*; import com.aliyun.odps.udf.UDF; +import java.util.List; +import java.util.Set; +import java.util.TreeSet; + public class SqlTypeUDF extends UDF { public String evaluate(String sql) { return evaluate(sql, null, false); @@ -17,22 +24,315 @@ public class SqlTypeUDF extends UDF { return evaluate(sql, dbTypeName, false); } + static SQLType getSqlType(SQLAlterTableStatement stmt) { + List items = stmt.getItems(); + SQLAlterTableItem item = null; + if (items.size() == 1) { + item = items.get(0); + } else if (items.size() > 1) { + item = items.get(0); + + for (int i = 1; i < items.size(); i++) { + SQLAlterTableItem t = items.get(i); + if (t != null && t.getClass() != item.getClass()) { + item = null; + break; + } + } + } + + SQLType sqlType = SQLType.ALTER_TABLE; + if (item instanceof SQLAlterTableAddPartition) { + sqlType = SQLType.ALTER_TABLE_ADD_PARTITION; + } else if (item instanceof SQLAlterTableDropPartition) { + sqlType = SQLType.ALTER_TABLE_DROP_PARTITION; + } else if (item instanceof SQLAlterTableMergePartition) { + sqlType = SQLType.ALTER_TABLE_MERGE_PARTITION; + } else if (item instanceof SQLAlterTableRenamePartition) { + sqlType = SQLType.ALTER_TABLE_RENAME_PARTITION; + } else if (item instanceof SQLAlterTableSetLifecycle) { + sqlType = SQLType.ALTER_TABLE_SET_LIFECYCLE; + } else if (item instanceof SQLAlterTableEnableLifecycle) { + sqlType = SQLType.ALTER_TABLE_ENABLE_LIFECYCLE; + } else if (item instanceof SQLAlterTableDisableLifecycle) { + sqlType = SQLType.ALTER_TABLE_DISABLE_LIFECYCLE; + } else if (item instanceof SQLAlterTableRename) { + sqlType = SQLType.ALTER_TABLE_RENAME; + } else if (item instanceof SQLAlterTableAddColumn) { + sqlType = SQLType.ALTER_TABLE_ADD_COLUMN; + } else if (item instanceof SQLAlterTableAlterColumn) { + sqlType = SQLType.ALTER_TABLE_ALTER_COLUMN; + } else if (item instanceof SQLAlterTableSetOption) { + sqlType = SQLType.ALTER_TABLE_SET_TBLPROPERTIES; + } else if (item instanceof SQLAlterTableSetComment) { + sqlType = SQLType.ALTER_TABLE_SET_COMMENT; + } else if (item instanceof SQLAlterTableRenameColumn) { + sqlType = SQLType.ALTER_TABLE_RENAME_COLUMN; + } else if (item instanceof SQLAlterTableTouch) { + sqlType = SQLType.ALTER_TABLE_TOUCH; + } else if (item instanceof SQLAlterTableChangeOwner) { + sqlType = SQLType.ALTER_TABLE_CHANGE_OWNER; + } + return sqlType; + } + + static SQLType getStmtSqlType(SQLStatement stmt, SQLType sqlType) { + if (stmt instanceof SQLCreateTableStatement) { + if (((SQLCreateTableStatement) stmt).getSelect() != null) { + sqlType = SQLType.CREATE_TABLE_AS_SELECT; + } else { + sqlType = SQLType.CREATE_TABLE; + } + } else if (stmt instanceof HiveInsertStatement) { + HiveInsertStatement hiveInsert = (HiveInsertStatement) stmt; + sqlType = hiveInsert.isOverwrite() + ? SQLType.INSERT_OVERWRITE + : SQLType.INSERT_INTO; + if (hiveInsert.getQuery() != null) { + sqlType = hiveInsert.isOverwrite() + ? SQLType.INSERT_OVERWRITE_SELECT + : SQLType.INSERT_INTO_SELECT; + } else if (hiveInsert.getValuesList().size() > 0) { + sqlType = hiveInsert.isOverwrite() + ? SQLType.INSERT_OVERWRITE_VALUES + : SQLType.INSERT_INTO_VALUES; + } + } else if (stmt instanceof SQLUpdateStatement) { + sqlType = SQLType.UPDATE; + } else if (stmt instanceof SQLDeleteStatement) { + sqlType = SQLType.DELETE; + } else if (stmt instanceof SQLSelectStatement) { + sqlType = SQLType.SELECT; + } else if (stmt instanceof HiveMultiInsertStatement) { + sqlType = SQLType.INSERT_MULTI; + } else if (stmt instanceof SQLDropTableStatement) { + sqlType = SQLType.DROP_TABLE; + } else if (stmt instanceof SQLDropViewStatement) { + sqlType = SQLType.DROP_VIEW; + } else if (stmt instanceof SQLPurgeTableStatement) { + sqlType = SQLType.PURGE; + } else if (stmt instanceof SQLShowStatement) { + if (stmt instanceof SQLShowCatalogsStatement) { + sqlType = SQLType.SHOW_CATALOGS; + } else if (stmt instanceof SQLShowCreateTableStatement) { + sqlType = SQLType.SHOW_CREATE_TABLE; + } else if (stmt instanceof SQLShowGrantsStatement) { + sqlType = SQLType.SHOW_GRANTS; + } else if (stmt instanceof SQLShowRecylebinStatement) { + sqlType = SQLType.SHOW_RECYCLEBIN; + } else if (stmt instanceof SQLShowStatisticStmt) { + sqlType = SQLType.SHOW_STATISTIC; + } else if (stmt instanceof SQLShowStatisticListStmt) { + sqlType = SQLType.SHOW_STATISTIC_LIST; + } else if (stmt instanceof SQLShowTablesStatement) { + sqlType = SQLType.SHOW_TABLES; + } else if (stmt instanceof SQLShowUsersStatement) { + sqlType = SQLType.SHOW_USERS; + } else if (stmt instanceof SQLShowPartitionsStmt) { + sqlType = SQLType.SHOW_PARTITIONS; + } else if (sqlType == null) { + sqlType = SQLType.SHOW; + } + } else if (stmt instanceof OdpsQueryAliasStatement + || stmt instanceof OdpsDeclareVariableStatement + ) { + sqlType = SQLType.SCRIPT; + } else if (stmt instanceof SQLAlterTableStatement) { + sqlType = getSqlType((SQLAlterTableStatement) stmt); + } + + return sqlType; + } + public String evaluate(String sql, String dbTypeName, boolean throwError) { if (sql == null || sql.isEmpty()) { return null; } + DbType dbType = dbTypeName == null ? null : DbType.valueOf(dbTypeName); + + SQLType sqlType = null; try { - DbType dbType = dbTypeName == null ? null : DbType.valueOf(dbTypeName); - Lexer lexer = SQLParserUtils.createLexer(sql, dbType); - SQLType sqlType = lexer.scanSQLTypeV2(); - return sqlType != null ? sqlType.name() : "null"; + List stmtList = SQLUtils.parseStatements(sql, dbType); + + if (stmtList.size() == 0) { + return SQLType.EMPTY.name(); + } + + int setCnt = 0, notSetCnt = 0; + SQLStatement notSetStmt = null; + for (SQLStatement stmt : stmtList) { + if (stmt instanceof SQLSetStatement) { + setCnt++; + } else { + notSetStmt = stmt; + notSetCnt++; + } + } + + if (setCnt == stmtList.size()) { + Lexer lexer = SQLParserUtils.createLexer(sql, dbType); + sqlType = lexer.scanSQLTypeV2(); + if (sqlType != null) { + return sqlType.name(); + } + return SQLType.SET.name(); + } + + if (notSetCnt == 1) { + Lexer lexer = SQLParserUtils.createLexer(sql, dbType); + sqlType = lexer.scanSQLTypeV2(); + sqlType = SqlTypeUDF.getStmtSqlType(notSetStmt, sqlType); + } else { + for (SQLStatement stmt : stmtList) { + if (stmt instanceof OdpsQueryAliasStatement + || stmt instanceof OdpsDeclareVariableStatement) { + return SQLType.SCRIPT.name(); + } + } + + Set typeNameSet = new TreeSet<>(); + for (SQLStatement stmt : stmtList) { + if (stmt instanceof SQLSetStatement) { + continue; + } + + SQLType type = SqlTypeUDF.getStmtSqlType(stmt, null); + if (type != null) { + typeNameSet.add(type.name()); + } + } + + if (typeNameSet.size() == 1) { + return typeNameSet.stream().findFirst().get(); + } + + if (typeNameSet.size() > 0) { + StringBuffer buf = new StringBuffer(); + for (String s : typeNameSet) { + if (buf.length() != 0) { + buf.append(','); + } + buf.append(s); + } + return "MULTI:" + buf.toString(); + } + sqlType = SQLType.MULTI; + } } catch (ParserException ex) { + sql = sql.trim(); + int semiIndex = sql.indexOf(';'); + if (semiIndex == sql.length() - 1 || semiIndex == -1 && sql.indexOf('\n') == -1) { + String singleLineSqlType = getSqlTypeForSingleLineSql(sql, dbType); + if (singleLineSqlType != null) { + return singleLineSqlType; + } + } else { + if (sql.lastIndexOf('\n', semiIndex) == -1) { + String firstSql = sql.substring(0, semiIndex).trim().toLowerCase(); + if (firstSql.startsWith("set ")) { + String restSql = sql.substring(semiIndex + 1); + return evaluate(restSql, dbTypeName, throwError); + } + } + } + + try { + Lexer lexer = SQLParserUtils.createLexer(sql, dbType); + + int semiCnt = 0; + for_: + for(Token token = null;;) { + lexer.nextToken(); + + if (token == Token.VARIANT && lexer.token() == Token.COLONEQ) { + return SQLType.SCRIPT.name(); + } + + token = lexer.token(); + switch (token) { + case EOF: + case ERROR: + break for_; + case SEMI: + semiCnt++; + break; + default: + break; + } + } + } catch (ParserException ignored) { + + } + + sqlType = SQLType.ERROR; + + } catch (Throwable ex) { if (throwError) { throw new IllegalArgumentException("error sql : \n" + sql, ex); } - return null; + sqlType = SQLType.ERROR; } + + if (sqlType != null) { + return sqlType.name(); + } + + return SQLType.UNKNOWN.name(); + } + + private String getSqlTypeForSingleLineSql(String sql, DbType dbType) { + try { + SQLType sqlType; + Lexer lexer = SQLParserUtils.createLexer(sql, dbType); + sqlType = lexer.scanSQLTypeV2(); + if (sqlType == null) { + return null; + } + + if (sqlType == SQLType.WITH) { + lexer = SQLParserUtils.createLexer(sql, dbType); + + int updateCnt = 0, insertCnt = 0, deleteCnt = 0; + for_: + for (Token token = null; ; ) { + Token last = token; + lexer.nextToken(); + token = lexer.token(); + + if (last == Token.INSERT) { + if (token == Token.OVERWRITE) { + return SQLType.INSERT_OVERWRITE_SELECT.name(); + } else if (token == Token.INTO) { + return SQLType.INSERT_INTO_SELECT.name(); + } + } + switch (token) { + case EOF: + case ERROR: + break for_; + case INSERT: + insertCnt++; + break; + case DELETE: + deleteCnt++; + break; + case UPDATE: + updateCnt++; + break; + default: + break; + } + } + if (updateCnt == 0 && insertCnt == 0 && deleteCnt == 0) { + return SQLType.SELECT.name(); + } + } + return sqlType.name(); + } catch (ParserException ignored) { + + } + return null; } } diff --git a/src/main/java/com/alibaba/druid/util/FnvHash.java b/src/main/java/com/alibaba/druid/util/FnvHash.java index f20df12ecf..f6c96c8bfb 100644 --- a/src/main/java/com/alibaba/druid/util/FnvHash.java +++ b/src/main/java/com/alibaba/druid/util/FnvHash.java @@ -745,6 +745,7 @@ public final class FnvHash { long VARBIT = fnv1a_64_lower("VARBIT"); long DECODE = fnv1a_64_lower("DECODE"); long IF = fnv1a_64_lower("IF"); + long FUNCTION = fnv1a_64_lower("FUNCTION"); long EXTERNAL = fnv1a_64_lower("EXTERNAL"); long SORTED = fnv1a_64_lower("SORTED"); long CLUSTERED = fnv1a_64_lower("CLUSTERED"); @@ -783,11 +784,13 @@ public final class FnvHash { long ARRAY = fnv1a_64_lower("ARRAY"); long SCALAR = fnv1a_64_lower("SCALAR"); long STRUCT = fnv1a_64_lower("STRUCT"); + long TABLE = fnv1a_64_lower("TABLE"); long UNIONTYPE = fnv1a_64_lower("UNIONTYPE"); long TDDL = fnv1a_64_lower("TDDL"); long CONCURRENTLY = fnv1a_64_lower("CONCURRENTLY"); long TABLES = fnv1a_64_lower("TABLES"); + long ROLES = fnv1a_64_lower("ROLES"); long NOCACHE = fnv1a_64_lower("NOCACHE"); long NOPARALLEL = fnv1a_64_lower("NOPARALLEL"); long EXIST = fnv1a_64_lower("EXIST"); @@ -1001,6 +1004,8 @@ public final class FnvHash { long RECOVER = fnv1a_64_lower("RECOVER"); long BACKUP = fnv1a_64_lower("BACKUP"); long RESTORE = fnv1a_64_lower("RESTORE"); + long EXSTORE = fnv1a_64_lower("EXSTORE"); + long UNDO = fnv1a_64_lower("UNDO"); long NOSCAN = fnv1a_64_lower("NOSCAN"); long EXTENDED = fnv1a_64_lower("EXTENDED"); long FORMATTED = fnv1a_64_lower("FORMATTED"); @@ -1031,7 +1036,9 @@ public final class FnvHash { long GROUP = fnv1a_64_lower("GROUP"); long GROUPING = fnv1a_64_lower("GROUPING"); long WITH = fnv1a_64_lower("WITH"); + long FROM = fnv1a_64_lower("FROM"); long WHO = fnv1a_64_lower("WHO"); + long WHOAMI = fnv1a_64_lower("WHOAMI"); long GRANTS = fnv1a_64_lower("GRANTS"); long STATISTIC = fnv1a_64_lower("STATISTIC"); long STATISTIC_LIST = fnv1a_64_lower("STATISTIC_LIST"); @@ -1124,5 +1131,8 @@ public final class FnvHash { long TUNNEL = fnv1a_64_lower("TUNNEL"); long DOWNLOAD = fnv1a_64_lower("DOWNLOAD"); long UPLOAD = fnv1a_64_lower("UPLOAD"); + long CLONE = fnv1a_64_lower("CLONE"); + long INSTALL = fnv1a_64_lower("INSTALL"); + long UNLOAD = fnv1a_64_lower("UNLOAD"); } }