From 06bc2184969138b4f16396ae0cc65a698047bfce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=AB=98=E9=93=81?= Date: Sun, 5 Sep 2021 02:17:03 +0800 Subject: [PATCH] improved odps support --- .../com/alibaba/druid/sql/ast/SQLOver.java | 34 +- .../druid/sql/ast/expr/SQLDateExpr.java | 8 +- .../SQLAlterMaterializedViewStatement.java | 18 + .../statement/SQLAlterTableAlterColumn.java | 10 +- .../ast/statement/SQLAlterTableStatement.java | 13 + .../SQLAlterViewRenameStatement.java | 22 +- .../statement/SQLAnalyzeTableStatement.java | 6 + .../ast/statement/SQLCloneTableStatement.java | 20 +- .../statement/SQLCreateFunctionStatement.java | 9 + .../SQLCreateMaterializedViewStatement.java | 34 +- .../statement/SQLExternalRecordFormat.java | 5 - .../sql/ast/statement/SQLJoinTableSource.java | 27 +- .../statement/SQLLateralViewTableSource.java | 15 + .../sql/ast/statement/SQLMergeStatement.java | 9 + .../ast/statement/SQLShowACLStatement.java | 55 ++ .../statement/SQLShowHistoryStatement.java | 17 + .../ast/statement/SQLShowRoleStatement.java | 43 ++ .../statement/SQLShowVariantsStatement.java} | 9 +- .../stmt/HiveCreateFunctionStatement.java | 4 + .../hive/stmt/HiveLoadDataStatement.java | 13 + .../mysql/parser/MySqlCreateTableParser.java | 4 +- .../mysql/parser/MySqlStatementParser.java | 24 +- .../mysql/visitor/MySqlASTVisitor.java | 8 - .../mysql/visitor/MySqlOutputVisitor.java | 2 +- .../mysql/visitor/MySqlSchemaStatVisitor.java | 2 +- .../odps/ast/OdpsAddTableStatement.java | 7 +- .../odps/ast/OdpsAlterTableSetFileFormat.java | 29 ++ .../sql/dialect/odps/ast/OdpsNewExpr.java | 20 + .../odps/ast/OdpsQueryAliasStatement.java | 9 + .../odps/ast/OdpsRestoreStatement.java | 93 ++++ .../odps/ast/OdpsShowChangelogsStatement.java | 91 ++++ .../odps/ast/OdpsUndoTableStatement.java | 77 +++ .../odps/parser/OdpsCreateTableParser.java | 54 +- .../dialect/odps/parser/OdpsExprParser.java | 104 +++- .../sql/dialect/odps/parser/OdpsLexer.java | 68 ++- .../dialect/odps/parser/OdpsSelectParser.java | 24 +- .../odps/parser/OdpsStatementParser.java | 336 ++++++++++++- .../dialect/odps/visitor/OdpsASTVisitor.java | 32 ++ .../odps/visitor/OdpsOutputVisitor.java | 28 +- .../odps/visitor/OdpsSchemaStatVisitor.java | 44 ++ .../alibaba/druid/sql/parser/CharTypes.java | 6 +- .../com/alibaba/druid/sql/parser/Lexer.java | 77 ++- .../druid/sql/parser/SQLExprParser.java | 330 +++++++++++- .../alibaba/druid/sql/parser/SQLParser.java | 104 +++- .../druid/sql/parser/SQLSelectParser.java | 143 +++++- .../druid/sql/parser/SQLStatementParser.java | 468 ++++++++++++------ .../sql/visitor/SQLASTOutputVisitor.java | 57 ++- .../druid/sql/visitor/SQLASTVisitor.java | 29 +- .../druid/sql/visitor/SchemaStatVisitor.java | 26 +- .../com/alibaba/druid/stat/TableStat.java | 14 +- .../java/com/alibaba/druid/util/FnvHash.java | 1 + 51 files changed, 2315 insertions(+), 367 deletions(-) create mode 100644 src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowACLStatement.java create mode 100644 src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowRoleStatement.java rename src/main/java/com/alibaba/druid/sql/{dialect/mysql/ast/statement/MySqlShowVariantsStatement.java => ast/statement/SQLShowVariantsStatement.java} (84%) create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAlterTableSetFileFormat.java create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsRestoreStatement.java create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsShowChangelogsStatement.java create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsUndoTableStatement.java diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLOver.java b/src/main/java/com/alibaba/druid/sql/ast/SQLOver.java index 04d0980660..e6ae03da05 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLOver.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLOver.java @@ -26,6 +26,7 @@ public class SQLOver extends SQLObjectImpl implements SQLReplaceable { protected SQLOrderBy orderBy; protected SQLOrderBy distributeBy; protected SQLOrderBy sortBy; + protected SQLOrderBy clusterBy; // for db2 protected SQLName of; @@ -41,6 +42,8 @@ public class SQLOver extends SQLObjectImpl implements SQLReplaceable { protected SQLExpr windowingBetweenEnd; protected WindowingBound windowingBetweenEndBound; + protected boolean excludeCurrentRow; + public SQLOver(){ } @@ -72,6 +75,10 @@ public class SQLOver extends SQLObjectImpl implements SQLReplaceable { sortBy.accept(visitor); } + if (clusterBy != null) { + clusterBy.accept(visitor); + } + if (of != null) { of.accept(visitor); } @@ -83,11 +90,22 @@ public class SQLOver extends SQLObjectImpl implements SQLReplaceable { return orderBy; } - public void setOrderBy(SQLOrderBy orderBy) { - if (orderBy != null) { - orderBy.setParent(this); + public void setOrderBy(SQLOrderBy x) { + if (x != null) { + x.setParent(this); } - this.orderBy = orderBy; + this.orderBy = x; + } + + public SQLOrderBy getClusterBy() { + return clusterBy; + } + + public void setClusterBy(SQLOrderBy x) { + if (x != null) { + x.setParent(this); + } + this.clusterBy = x; } public SQLOrderBy getDistributeBy() { @@ -183,6 +201,14 @@ public class SQLOver extends SQLObjectImpl implements SQLReplaceable { this.windowingBetweenEndBound = windowingBetweenEndBound; } + public boolean isExcludeCurrentRow() { + return excludeCurrentRow; + } + + public void setExcludeCurrentRow(boolean excludeCurrentRow) { + this.excludeCurrentRow = excludeCurrentRow; + } + @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDateExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDateExpr.java index d7ce186d9f..ead67b9984 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDateExpr.java +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDateExpr.java @@ -203,7 +203,13 @@ public class SQLDateExpr extends SQLExprImpl implements SQLLiteralExpr, SQLValua return Collections.emptyList(); } - public static long supportDbTypes = DbType.of(DbType.mysql, DbType.oracle, DbType.presto, DbType.postgresql, DbType.ads, DbType.hive, DbType.odps); + public static long supportDbTypes = DbType.of(DbType.mysql + , DbType.oracle + , DbType.presto + , DbType.postgresql + , DbType.ads + , DbType.hive + , DbType.odps); public static boolean isSupport(DbType dbType) { return (dbType.mask & supportDbTypes) != 0; diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterMaterializedViewStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterMaterializedViewStatement.java index 5c58aa4f5e..37d6c9672e 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterMaterializedViewStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterMaterializedViewStatement.java @@ -20,6 +20,9 @@ import com.alibaba.druid.sql.ast.SQLName; import com.alibaba.druid.sql.ast.SQLStatementImpl; import com.alibaba.druid.sql.visitor.SQLASTVisitor; +import java.util.ArrayList; +import java.util.List; + public class SQLAlterMaterializedViewStatement extends SQLStatementImpl implements SQLAlterStatement { private SQLName name; @@ -30,6 +33,7 @@ public class SQLAlterMaterializedViewStatement extends SQLStatementImpl implemen private boolean refreshOnDemand; private boolean refreshStartWith; private boolean refreshNext; + private final List partitions = new ArrayList(); // odps private Boolean enableQueryRewrite; @@ -38,6 +42,7 @@ public class SQLAlterMaterializedViewStatement extends SQLStatementImpl implemen // for ADB protected boolean refreshOnOverWrite; + private boolean rebuild; public SQLName getName() { @@ -151,12 +156,25 @@ public class SQLAlterMaterializedViewStatement extends SQLStatementImpl implemen this.next = x; } + public boolean isRebuild() { + return rebuild; + } + + public void setRebuild(boolean rebuild) { + this.rebuild = rebuild; + } + + public List getPartitions() { + return partitions; + } + @Override protected void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { acceptChild(visitor, name); acceptChild(visitor, startWith); acceptChild(visitor, next); + acceptChild(visitor, partitions); } visitor.endVisit(this); } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableAlterColumn.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableAlterColumn.java index 68b393dcbe..8c66b87335 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableAlterColumn.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableAlterColumn.java @@ -29,9 +29,10 @@ public class SQLAlterTableAlterColumn extends SQLObjectImpl implements SQLAlterT private boolean dropNotNull; private SQLExpr setDefault; private boolean dropDefault; - private SQLName first; + private boolean first; private SQLName after; private SQLDataType dataType; + private boolean toFirst; @Override protected void accept0(SQLASTVisitor visitor) { @@ -93,14 +94,11 @@ public class SQLAlterTableAlterColumn extends SQLObjectImpl implements SQLAlterT this.originColumn = x; } - public SQLName getFirst() { + public boolean isFirst() { return first; } - public void setFirst(SQLName x) { - if (x != null) { - x.setParent(this); - } + public void setFirst(boolean x) { this.first = x; } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableStatement.java index 967e08fbe0..a3225145c5 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterTableStatement.java @@ -48,6 +48,7 @@ public class SQLAlterTableStatement extends SQLStatementImpl implements SQLDDLSt // odps private boolean mergeSmallFiles = false; + protected boolean range; protected final List clusteredBy = new ArrayList(); protected final List sortedBy = new ArrayList(); protected int buckets; @@ -235,6 +236,18 @@ public class SQLAlterTableStatement extends SQLStatementImpl implements SQLDDLSt return null; } + public void setItems(List items) { + this.items = items; + } + + public boolean isRange() { + return range; + } + + public void setRange(boolean range) { + this.range = range; + } + public List getClusteredBy() { return clusteredBy; } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterViewRenameStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterViewRenameStatement.java index b52683f746..8d9918cb26 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterViewRenameStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAlterViewRenameStatement.java @@ -24,6 +24,8 @@ public class SQLAlterViewRenameStatement extends SQLStatementImpl implements SQL private SQLName name; private SQLName to; + private SQLName changeOwnerTo; + public SQLName getName() { return name; } @@ -39,11 +41,22 @@ public class SQLAlterViewRenameStatement extends SQLStatementImpl implements SQL return to; } - public void setTo(SQLName to) { - if (to != null) { - to.setParent(this); + public void setTo(SQLName x) { + if (x != null) { + x.setParent(this); } - this.to = to; + this.to = x; + } + + public SQLName getChangeOwnerTo() { + return changeOwnerTo; + } + + public void setChangeOwnerTo(SQLName x) { + if (x != null) { + x.setParent(this); + } + this.changeOwnerTo = x; } @Override @@ -51,6 +64,7 @@ public class SQLAlterViewRenameStatement extends SQLStatementImpl implements SQL if (visitor.visit(this)) { acceptChild(visitor, name); acceptChild(visitor, to); + acceptChild(visitor, changeOwnerTo); } visitor.endVisit(this); } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAnalyzeTableStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAnalyzeTableStatement.java index bff7a55269..15b6613d3c 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAnalyzeTableStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLAnalyzeTableStatement.java @@ -33,6 +33,7 @@ public class SQLAnalyzeTableStatement extends SQLStatementImpl { private SQLPartitionRef partition; private boolean forColums = false; + private List columns = new ArrayList<>(); private boolean cacheMetadata; private boolean noscan; private boolean computeStatistics; @@ -51,6 +52,7 @@ public class SQLAnalyzeTableStatement extends SQLStatementImpl { if (visitor.visit(this)) { this.acceptChild(visitor, tableSources); this.acceptChild(visitor, partition); + this.acceptChild(visitor, columns); this.acceptChild(visitor, adbSchema); this.acceptChild(visitor, adbColumns); this.acceptChild(visitor, adbColumnsGroup); @@ -75,6 +77,10 @@ public class SQLAnalyzeTableStatement extends SQLStatementImpl { throw new UnsupportedOperationException(); } + public List getColumns() { + return columns; + } + public void setTable(SQLExprTableSource table) { if (table != null) { table.setParent(this); diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCloneTableStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCloneTableStatement.java index 90e920b8c4..1d37fdfb08 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCloneTableStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCloneTableStatement.java @@ -31,7 +31,8 @@ public class SQLCloneTableStatement extends SQLStatementImpl { protected SQLExprTableSource to; - protected boolean overwriteIfExists = false; + protected boolean ifExistsOverwrite = false; + protected boolean ifExistsIgnore = false; public SQLCloneTableStatement() { @@ -89,17 +90,26 @@ public class SQLCloneTableStatement extends SQLStatementImpl { this.setFrom(new SQLExprTableSource(x)); } - public boolean isOverwriteIfExists() { - return overwriteIfExists; + public boolean isIfExistsOverwrite() { + return ifExistsOverwrite; } - public void setOverwriteIfExists(boolean overwriteIfExists) { - this.overwriteIfExists = overwriteIfExists; + public void setIfExistsOverwrite(boolean ifExistsOverwrite) { + this.ifExistsOverwrite = ifExistsOverwrite; + } + + public boolean isIfExistsIgnore() { + return ifExistsIgnore; + } + + public void setIfExistsIgnore(boolean ifExistsIgnore) { + this.ifExistsIgnore = ifExistsIgnore; } @Override protected void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { + acceptChild(visitor, from); acceptChild(visitor, to); } visitor.endVisit(this); diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateFunctionStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateFunctionStatement.java index 1a178c0249..1a5df62852 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateFunctionStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateFunctionStatement.java @@ -53,6 +53,7 @@ public class SQLCreateFunctionStatement extends SQLStatementImpl implements SQLC private String wrappedSource; private String language; private boolean temporary; + protected boolean ifNotExists = false; public SQLCreateFunctionStatement() { @@ -291,4 +292,12 @@ public class SQLCreateFunctionStatement extends SQLStatementImpl implements SQLC public void setTemporary(boolean temporary) { this.temporary = temporary; } + + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateMaterializedViewStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateMaterializedViewStatement.java index e2c9eef16e..91e73078b9 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateMaterializedViewStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateMaterializedViewStatement.java @@ -28,8 +28,10 @@ import java.util.List; * Created by wenshao on 30/06/2017. */ public class SQLCreateMaterializedViewStatement extends SQLStatementImpl implements OracleSegmentAttributes, SQLCreateStatement, SQLReplaceable { + protected SQLExpr lifyCycle; private SQLName name; private List columns = new ArrayList(); + private boolean ifNotExists; private boolean refreshFast; private boolean refreshComplete; @@ -81,6 +83,7 @@ public class SQLCreateMaterializedViewStatement extends SQLStatementImpl impleme protected List distributedBy = new ArrayList(); protected final List tableOptions = new ArrayList(); protected SQLExpr comment; + private List partitionedOn = new ArrayList(); public SQLName getName() { return name; @@ -93,6 +96,14 @@ public class SQLCreateMaterializedViewStatement extends SQLStatementImpl impleme this.name = name; } + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + } + public List getColumns() { return columns; } @@ -394,6 +405,10 @@ public class SQLCreateMaterializedViewStatement extends SQLStatementImpl impleme this.withRowId = withRowId; } + public List getPartitionedOn() { + return partitionedOn; + } + public void addOption(String name, SQLExpr value) { SQLAssignItem assignItem = new SQLAssignItem(new SQLIdentifierExpr(name), value); assignItem.setParent(this); @@ -427,11 +442,22 @@ public class SQLCreateMaterializedViewStatement extends SQLStatementImpl impleme return comment; } - public void setComment(SQLExpr comment) { - if (comment != null) { - comment.setParent(this); + public void setComment(SQLExpr x) { + if (x != null) { + x.setParent(this); } - this.comment = comment; + this.comment = x; + } + + public SQLExpr getLifyCycle() { + return lifyCycle; + } + + public void setLifyCycle(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.lifyCycle = x; } @Override diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExternalRecordFormat.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExternalRecordFormat.java index ae7ebdbe6c..d44af6cd62 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExternalRecordFormat.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExternalRecordFormat.java @@ -16,7 +16,6 @@ public class SQLExternalRecordFormat extends SQLObjectImpl { private SQLExpr linesTerminatedBy; private SQLExpr nullDefinedAs; private SQLExpr serde; - protected final List serdeProperties = new ArrayList(); private Boolean logfile; private Boolean badfile; @@ -167,10 +166,6 @@ public class SQLExternalRecordFormat extends SQLObjectImpl { this.missingFieldValuesAreNull = missingFieldValuesAreNull; } - public List getSerdeProperties() { - return serdeProperties; - } - public SQLExternalRecordFormat clone() { SQLExternalRecordFormat x = new SQLExternalRecordFormat(); diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLJoinTableSource.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLJoinTableSource.java index 9b3eb37f42..b141b12063 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLJoinTableSource.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLJoinTableSource.java @@ -708,11 +708,12 @@ public class SQLJoinTableSource extends SQLTableSourceImpl implements SQLReplace } public static class UDJ extends SQLObjectImpl { - protected String function; + protected SQLExpr function; protected final List arguments = new ArrayList(); protected String alias; protected final List columns = new ArrayList(); protected List sortBy = new ArrayList(); + protected List properties = new ArrayList(); public UDJ() { @@ -731,9 +732,13 @@ public class SQLJoinTableSource extends SQLTableSourceImpl implements SQLReplace return sortBy; } + public UDJ(SQLExpr function) { + this.function = function; + } + public UDJ clone() { UDJ x = new UDJ(); - x.function = function; + x.function = function.clone(); for (SQLExpr arg : arguments) { SQLExpr t = arg.clone(); t.setParent(x); @@ -745,18 +750,20 @@ public class SQLJoinTableSource extends SQLTableSourceImpl implements SQLReplace t.setParent(x); x.columns.add(t); } + + for (SQLAssignItem property : properties) { + SQLAssignItem c = property.clone(); + c.setParent(x); + x.properties.add(c); + } return x; } - public UDJ(String function) { - this.function = function; - } - - public String getFunction() { + public SQLExpr getFunction() { return function; } - public void setFunction(String function) { + public void setFunction(SQLExpr function) { this.function = function; } @@ -775,5 +782,9 @@ public class SQLJoinTableSource extends SQLTableSourceImpl implements SQLReplace public void setAlias(String alias) { this.alias = alias; } + + public List getProperties() { + return properties; + } } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLLateralViewTableSource.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLLateralViewTableSource.java index b2f456f386..d99bfce45f 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLLateralViewTableSource.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLLateralViewTableSource.java @@ -15,6 +15,7 @@ */ package com.alibaba.druid.sql.ast.statement; +import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.SQLHint; import com.alibaba.druid.sql.ast.SQLName; import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr; @@ -32,6 +33,12 @@ public class SQLLateralViewTableSource extends SQLTableSourceImpl { private List columns = new ArrayList(2); + private SQLExpr on; // odps + + public SQLLateralViewTableSource() { + + } + @Override protected void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { @@ -148,4 +155,12 @@ public class SQLLateralViewTableSource extends SQLTableSourceImpl { public void setOuter(boolean outer) { this.outer = outer; } + + public SQLExpr getOn() { + return on; + } + + public void setOn(SQLExpr on) { + this.on = on; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLMergeStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLMergeStatement.java index ce2d9d6202..0ea4a18b9c 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLMergeStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLMergeStatement.java @@ -113,6 +113,7 @@ public class SQLMergeStatement extends SQLStatementImpl { private List items = new ArrayList(); private SQLExpr where; private SQLExpr deleteWhere; + private boolean delete; public List getItems() { return items; @@ -125,6 +126,14 @@ public class SQLMergeStatement extends SQLStatementImpl { this.items.add(item); } + public boolean isDelete() { + return delete; + } + + public void setDelete(boolean delete) { + this.delete = delete; + } + public SQLExpr getWhere() { return where; } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowACLStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowACLStatement.java new file mode 100644 index 0000000000..98e029dfed --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowACLStatement.java @@ -0,0 +1,55 @@ +/* + * 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.SQLExpr; +import com.alibaba.druid.sql.ast.SQLReplaceable; +import com.alibaba.druid.sql.ast.SQLStatementImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLShowACLStatement extends SQLStatementImpl implements SQLShowStatement, SQLReplaceable { + + protected SQLExprTableSource table; + + public SQLExprTableSource getTable() { + return table; + } + + public void setTable(SQLExprTableSource x) { + if (x != null) { + x.setParent(this); + } + this.table = x; + } + + @Override + protected void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + if (table != null) { + table.accept(visitor); + } + } + } + + @Override + public boolean replace(SQLExpr expr, SQLExpr target) { + if (table != null) { + return table.replace(expr, target); + } + + return false; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowHistoryStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowHistoryStatement.java index c141702021..ed65d7ba14 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowHistoryStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowHistoryStatement.java @@ -18,10 +18,19 @@ package com.alibaba.druid.sql.ast.statement; import com.alibaba.druid.sql.ast.SQLStatementImpl; import com.alibaba.druid.sql.visitor.SQLASTVisitor; +import java.util.List; +import java.util.ArrayList; + public class SQLShowHistoryStatement extends SQLStatementImpl implements SQLShowStatement { protected SQLExprTableSource table; private boolean tables; + private List properties = new ArrayList<>(); + private List partitions = new ArrayList<>(); + + public SQLShowHistoryStatement() { + + } public SQLExprTableSource getTable() { return table; @@ -50,4 +59,12 @@ public class SQLShowHistoryStatement extends SQLStatementImpl implements SQLShow public void setTables(boolean tables) { this.tables = tables; } + + public List getProperties() { + return properties; + } + + public List getPartitions() { + return partitions; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowRoleStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowRoleStatement.java new file mode 100644 index 0000000000..f3846ae07d --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowRoleStatement.java @@ -0,0 +1,43 @@ +/* + * 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.SQLStatementImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLShowRoleStatement extends SQLStatementImpl implements SQLShowStatement { + private SQLName grant; + + @Override + protected void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + acceptChild(visitor, grant); + } + visitor.endVisit(this); + } + + public SQLName getGrant() { + return grant; + } + + public void setGrant(SQLName x) { + if (x != null) { + x.setParent(this); + } + this.grant = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlShowVariantsStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowVariantsStatement.java similarity index 84% rename from src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlShowVariantsStatement.java rename to src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowVariantsStatement.java index 7690ccd929..142039ca35 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlShowVariantsStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLShowVariantsStatement.java @@ -13,12 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.alibaba.druid.sql.dialect.mysql.ast.statement; +package com.alibaba.druid.sql.ast.statement; import com.alibaba.druid.sql.ast.SQLExpr; -import com.alibaba.druid.sql.dialect.mysql.visitor.MySqlASTVisitor; +import com.alibaba.druid.sql.ast.SQLStatementImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; -public class MySqlShowVariantsStatement extends MySqlStatementImpl implements MySqlShowStatement { +public class SQLShowVariantsStatement extends SQLStatementImpl { private boolean global = false; private boolean session = false; @@ -58,7 +59,7 @@ public class MySqlShowVariantsStatement extends MySqlStatementImpl implements My this.where = where; } - public void accept0(MySqlASTVisitor visitor) { + public void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { acceptChild(visitor, like); acceptChild(visitor, where); 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 7c64433ea9..b1352640d7 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 @@ -14,6 +14,10 @@ public class HiveCreateFunctionStatement extends SQLCreateFunctionStatement impl protected ResourceType resourceType; protected String code; + public HiveCreateFunctionStatement() { + + } + public void accept0(SQLASTVisitor visitor) { if (visitor instanceof HiveASTVisitor) { accept0((HiveASTVisitor) visitor); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveLoadDataStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveLoadDataStatement.java index fc63db68d3..ba199f6220 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveLoadDataStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/stmt/HiveLoadDataStatement.java @@ -28,6 +28,7 @@ public class HiveLoadDataStatement extends SQLStatementImpl { private SQLExpr storedAs; private SQLExpr rowFormat; protected Map serdeProperties = new LinkedHashMap(); + protected SQLExpr using; public HiveLoadDataStatement() { super(DbType.hive); @@ -156,6 +157,18 @@ public class HiveLoadDataStatement extends SQLStatementImpl { this.rowFormat = x; } + public SQLExpr getUsing() { + return using; + } + + public void setUsing(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + + this.using = x; + } + public Map getSerdeProperties() { return serdeProperties; } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlCreateTableParser.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlCreateTableParser.java index 6d77a15598..515e4f6f5e 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlCreateTableParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlCreateTableParser.java @@ -853,8 +853,8 @@ public class MySqlCreateTableParser extends SQLCreateTableParser { if (lexer.identifierEquals(FnvHash.Constants.DBPARTITIONS)) { lexer.nextToken(); - SQLExpr dbPartitoins = this.exprParser.primary(); - stmt.setDbPartitions(dbPartitoins); + SQLExpr dbPartitions = this.exprParser.primary(); + stmt.setDbPartitions(dbPartitions); continue; } 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 f7189f5901..d1dcc91d3f 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 @@ -2695,7 +2695,7 @@ public class MySqlStatementParser extends SQLStatementParser { if (lexer.identifierEquals(VARIABLES)) { lexer.nextToken(); - MySqlShowVariantsStatement stmt = parseShowVariants(); + SQLShowVariantsStatement stmt = parseShowVariants(); return stmt; } @@ -2712,7 +2712,7 @@ public class MySqlStatementParser extends SQLStatementParser { if (lexer.identifierEquals(VARIABLES)) { lexer.nextToken(); - MySqlShowVariantsStatement stmt = parseShowVariants(); + SQLShowVariantsStatement stmt = parseShowVariants(); stmt.setGlobal(true); return stmt; } @@ -2742,7 +2742,7 @@ public class MySqlStatementParser extends SQLStatementParser { if (lexer.identifierEquals(VARIABLES)) { lexer.nextToken(); - MySqlShowVariantsStatement stmt = parseShowVariants(); + SQLShowVariantsStatement stmt = parseShowVariants(); stmt.setSession(true); return stmt; } @@ -4084,24 +4084,6 @@ public class MySqlStatementParser extends SQLStatementParser { return stmt; } - private MySqlShowVariantsStatement parseShowVariants() { - MySqlShowVariantsStatement stmt = new MySqlShowVariantsStatement(); - - if (lexer.token() == Token.LIKE) { - lexer.nextToken(); - SQLExpr like = exprParser.expr(); - stmt.setLike(like); - } - - if (lexer.token() == Token.WHERE) { - lexer.nextToken(); - SQLExpr where = exprParser.expr(); - stmt.setWhere(where); - } - - return stmt; - } - private MySqlShowWarningsStatement parseShowWarnings() { MySqlShowWarningsStatement stmt = new MySqlShowWarningsStatement(); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlASTVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlASTVisitor.java index b656778ed9..a630b5a6ff 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlASTVisitor.java @@ -691,14 +691,6 @@ public interface MySqlASTVisitor extends SQLASTVisitor { } - default boolean visit(MySqlShowVariantsStatement x) { - return true; - } - - default void endVisit(MySqlShowVariantsStatement x) { - - } - default boolean visit(MySqlShowTraceStatement x) { return true; } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlOutputVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlOutputVisitor.java index 03a03a255f..c26d20bf36 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlOutputVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlOutputVisitor.java @@ -3427,7 +3427,7 @@ public class MySqlOutputVisitor extends SQLASTOutputVisitor implements MySqlASTV } @Override - public boolean visit(MySqlShowVariantsStatement x) { + public boolean visit(SQLShowVariantsStatement x) { print0(ucase ? "SHOW " : "show "); if (x.isGlobal()) { diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlSchemaStatVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlSchemaStatVisitor.java index c1135f43f2..28d8a37e34 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlSchemaStatVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/visitor/MySqlSchemaStatVisitor.java @@ -483,7 +483,7 @@ public class MySqlSchemaStatVisitor extends SchemaStatVisitor implements MySqlAS } @Override - public boolean visit(MySqlShowVariantsStatement x) { + public boolean visit(SQLShowVariantsStatement x) { return false; } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAddTableStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAddTableStatement.java index 99656a4f1a..b3b58a4e78 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAddTableStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAddTableStatement.java @@ -18,7 +18,6 @@ package com.alibaba.druid.sql.dialect.odps.ast; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.SQLName; -import com.alibaba.druid.sql.ast.SQLPartitionValue; import com.alibaba.druid.sql.ast.statement.SQLAlterStatement; import com.alibaba.druid.sql.ast.statement.SQLAssignItem; import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; @@ -31,7 +30,7 @@ import java.util.List; public class OdpsAddTableStatement extends OdpsStatementImpl implements SQLAlterStatement { private SQLExprTableSource table; - private final List partitoins = new ArrayList(); + private final List partitions = new ArrayList(); protected SQLExpr comment; protected boolean force; @@ -85,8 +84,8 @@ public class OdpsAddTableStatement extends OdpsStatementImpl implements SQLAlter this.force = force; } - public List getPartitoins() { - return partitoins; + public List getPartitions() { + return partitions; } public SQLName getToPackage() { diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAlterTableSetFileFormat.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAlterTableSetFileFormat.java new file mode 100644 index 0000000000..6b64716e38 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsAlterTableSetFileFormat.java @@ -0,0 +1,29 @@ +package com.alibaba.druid.sql.dialect.odps.ast; + +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.statement.SQLAlterTableItem; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; + +public class OdpsAlterTableSetFileFormat extends OdpsObjectImpl + implements SQLAlterTableItem { + private SQLExpr value; + + @Override + public void accept0(OdpsASTVisitor v) { + if (v.visit(this)) { + acceptChild(v, value); + } + v.endVisit(this); + } + + public SQLExpr getValue() { + return value; + } + + public void setValue(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.value = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsNewExpr.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsNewExpr.java index 77f07028a0..906a543047 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsNewExpr.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsNewExpr.java @@ -1,15 +1,27 @@ package com.alibaba.druid.sql.dialect.odps.ast; import com.alibaba.druid.FastsqlException; +import com.alibaba.druid.sql.ast.SQLArgument; +import com.alibaba.druid.sql.ast.SQLDataType; import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr; import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; import com.alibaba.druid.sql.visitor.SQLASTVisitor; import java.io.IOException; +import java.util.List; +import java.util.ArrayList; public class OdpsNewExpr extends SQLMethodInvokeExpr implements OdpsObject { private boolean array = false; + + private List initValues = new ArrayList<>(); + private List typeParameters = new ArrayList<>(); + + public OdpsNewExpr() { + + } + @Override public OdpsNewExpr clone() { OdpsNewExpr x = new OdpsNewExpr(); @@ -68,4 +80,12 @@ public class OdpsNewExpr extends SQLMethodInvokeExpr implements OdpsObject { public void setArray(boolean array) { this.array = array; } + + public List getInitValues() { + return initValues; + } + + public List getTypeParameters() { + return typeParameters; + } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsQueryAliasStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsQueryAliasStatement.java index c616e0b75a..a862aa299c 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsQueryAliasStatement.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsQueryAliasStatement.java @@ -5,6 +5,7 @@ import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; public class OdpsQueryAliasStatement extends OdpsStatementImpl { private String variant; + private boolean cache; private SQLSelectStatement statement; public OdpsQueryAliasStatement() { @@ -39,4 +40,12 @@ public class OdpsQueryAliasStatement extends OdpsStatementImpl { public void setStatement(SQLSelectStatement statement) { this.statement = statement; } + + public boolean isCache() { + return cache; + } + + public void setCache(boolean cache) { + this.cache = cache; + } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsRestoreStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsRestoreStatement.java new file mode 100644 index 0000000000..08cd133393 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsRestoreStatement.java @@ -0,0 +1,93 @@ +/* + * 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.dialect.odps.ast; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLName; +import com.alibaba.druid.sql.ast.statement.SQLAlterStatement; +import com.alibaba.druid.sql.ast.statement.SQLAssignItem; +import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; + +import java.util.ArrayList; +import java.util.List; + +public class OdpsRestoreStatement + extends OdpsStatementImpl implements SQLAlterStatement { + + private final List properties = new ArrayList(); + private final List partitions = new ArrayList(); + private SQLExprTableSource table; + private SQLExpr to; + + private String alias; + + public OdpsRestoreStatement() { + super.dbType = DbType.odps; + } + + + @Override + protected void accept0(OdpsASTVisitor visitor) { + if (visitor.visit(this)) { + this.acceptChild(visitor, table); + } + visitor.endVisit(this); + } + + public SQLExprTableSource getTable() { + return table; + } + + public void setTable(SQLExprTableSource table) { + if (table != null) { + table.setParent(table); + } + this.table = table; + } + + public void setTable(SQLName table) { + this.setTable(new SQLExprTableSource(table)); + } + + public List getProperties() { + return properties; + } + + public List getPartitions() { + return partitions; + } + + public SQLExpr getTo() { + return to; + } + + public void setTo(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.to = x; + } + + public String getAlias() { + return alias; + } + + public void setAlias(String alias) { + this.alias = alias; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsShowChangelogsStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsShowChangelogsStatement.java new file mode 100644 index 0000000000..ab94c9c179 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsShowChangelogsStatement.java @@ -0,0 +1,91 @@ +/* + * 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.dialect.odps.ast; + +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLStatementImpl; +import com.alibaba.druid.sql.ast.statement.SQLAssignItem; +import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.util.ArrayList; +import java.util.List; + +public class OdpsShowChangelogsStatement extends SQLStatementImpl { + protected SQLExprTableSource table; + private boolean tables; + private List properties = new ArrayList<>(); + private List partitions = new ArrayList<>(); + private SQLExpr id; + + public OdpsShowChangelogsStatement() { + + } + + public SQLExprTableSource getTable() { + return table; + } + + public void setTable(SQLExprTableSource x) { + if (x != null) { + x.setParent(this); + } + this.table = x; + } + + @Override + protected void accept0(SQLASTVisitor visitor) { + accept0((OdpsASTVisitor) visitor); + } + + public void accept0(OdpsASTVisitor visitor) { + if (visitor.visit(this)) { + acceptChild(visitor, table); + acceptChild(visitor, properties); + acceptChild(visitor, partitions); + acceptChild(visitor, id); + } + visitor.endVisit(this); + } + + public boolean isTables() { + return tables; + } + + public void setTables(boolean tables) { + this.tables = tables; + } + + public List getProperties() { + return properties; + } + + public List getPartitions() { + return partitions; + } + + public SQLExpr getId() { + return id; + } + + public void setId(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.id = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsUndoTableStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsUndoTableStatement.java new file mode 100644 index 0000000000..814efcade8 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/ast/OdpsUndoTableStatement.java @@ -0,0 +1,77 @@ +/* + * 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.dialect.odps.ast; + +import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLName; +import com.alibaba.druid.sql.ast.statement.SQLAlterStatement; +import com.alibaba.druid.sql.ast.statement.SQLAssignItem; +import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; +import com.alibaba.druid.sql.dialect.odps.visitor.OdpsASTVisitor; + +import java.util.ArrayList; +import java.util.List; + +public class OdpsUndoTableStatement + extends OdpsStatementImpl implements SQLAlterStatement { + + private SQLExprTableSource table; + private List partitions = new ArrayList<>(); + private SQLExpr to; + + public OdpsUndoTableStatement() { + super.dbType = DbType.odps; + } + + + @Override + protected void accept0(OdpsASTVisitor visitor) { + if (visitor.visit(this)) { + this.acceptChild(visitor, table); + this.acceptChild(visitor, partitions); + this.acceptChild(visitor, to); + } + visitor.endVisit(this); + } + + public SQLExprTableSource getTable() { + return table; + } + + public void setTable(SQLExprTableSource table) { + if (table != null) { + table.setParent(table); + } + this.table = table; + } + + public void setTable(SQLName table) { + this.setTable(new SQLExprTableSource(table)); + } + + public SQLExpr getTo() { + return to; + } + + public void setTo(SQLExpr to) { + this.to = to; + } + + public List getPartitions() { + return partitions; + } +} 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 58fac1b746..133e7a2f1d 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 @@ -116,11 +116,13 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { stmt.setLike(name); } else if (lexer.token() == Token.AS) { lexer.nextToken(); - + OdpsSelectParser selectParser = new OdpsSelectParser(this.exprParser); SQLSelect select = selectParser.select(); - + stmt.setSelect(select); + } else if (lexer.token() != Token.LPAREN && stmt.isExternal()) { + // skip } else { accept(Token.LPAREN); @@ -192,12 +194,22 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { case TO: case DECLARE: case REFERENCES: + case FOREIGN: + case ESCAPE: + case BY: + case ALTER: + case SOME: + case ASC: + case NULL: + case CURSOR: + case FETCH: + case OVER: + case DATABASE: column = this.exprParser.parseColumn(stmt); break; default: throw new ParserException("expect identifier. " + lexer.info()); } - stmt.getTableElementList().add(column); @@ -223,6 +235,7 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { if (lexer.token() == Token.COMMENT) { lexer.nextToken(); stmt.setComment(this.exprParser.primary()); + continue; } if (lexer.token() == Token.PARTITIONED) { @@ -234,11 +247,15 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { switch (lexer.token()) { case INDEX: case KEY: + case CHECK: case IDENTIFIER: case GROUP: case INTERVAL: case LOOP: case USER: + case TABLE: + case PARTITION: + case SEQUENCE: break; default: throw new ParserException("expect identifier. " + lexer.info()); @@ -262,6 +279,7 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { } accept(Token.RPAREN); + continue; } if (lexer.identifierEquals(FnvHash.Constants.RANGE)) { @@ -356,23 +374,47 @@ public class OdpsCreateTableParser extends SQLCreateTableParser { continue; } + if (lexer.token() == Token.AS && stmt.getSelect() == null) { + lexer.nextToken(); + + OdpsSelectParser selectParser = new OdpsSelectParser(this.exprParser); + SQLSelect select = selectParser.select(); + + stmt.setSelect(select); + continue; + } + if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { lexer.nextToken(); stmt.setLifecycle(this.exprParser.expr()); continue; } - while (lexer.identifierEquals(FnvHash.Constants.STORED)) { + if (lexer.identifierEquals(FnvHash.Constants.STORED)) { lexer.nextToken(); if (lexer.token() == Token.AS) { lexer.nextToken(); - SQLName storedAs = this.exprParser.name(); - stmt.setStoredAs(storedAs); + + 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 storedAs = this.exprParser.name(); + stmt.setStoredAs(storedAs); + } } else { accept(Token.BY); SQLExpr storedBy = this.exprParser.expr(); stmt.setStoredBy(storedBy); } + continue; } if (lexer.identifierEquals(FnvHash.Constants.LIFECYCLE)) { 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 ccd08c5f43..f5ab428655 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 @@ -36,7 +36,8 @@ public class OdpsExprParser extends SQLExprParser { public final static long[] AGGREGATE_FUNCTIONS_CODES; static { - String[] strings = { "AVG", // + String[] strings = { + "AVG", // "COUNT", // "LAG", "LEAD", @@ -46,7 +47,9 @@ public class OdpsExprParser extends SQLExprParser { "SUM", // "ROW_NUMBER", "WM_CONCAT", - "COLLECT_LIST"// + "STRAGG", + "COLLECT_LIST", + "COLLECT_SET"// }; AGGREGATE_FUNCTIONS_CODES = FnvHash.fnv1a_64_lower(strings, true); AGGREGATE_FUNCTIONS = new String[AGGREGATE_FUNCTIONS_CODES.length]; @@ -110,6 +113,16 @@ public class OdpsExprParser extends SQLExprParser { SQLDateExpr d = new SQLDateExpr(literal); expr = d; + } else if (FnvHash.Constants.TIMESTAMP == hash_lower + && lexer.stringVal().charAt(0) != '`' + && (lexer.token() == Token.LITERAL_CHARS + || lexer.token() == Token.LITERAL_ALIAS) + ) { + String literal = lexer.stringVal(); + lexer.nextToken(); + + SQLTimestampExpr ts = new SQLTimestampExpr(literal); + expr = ts; } else { expr = new SQLIdentifierExpr(stringVal); if (lexer.token() != Token.COMMA) { @@ -258,24 +271,97 @@ public class OdpsExprParser extends SQLExprParser { SQLIdentifierExpr ident = (SQLIdentifierExpr) expr; OdpsNewExpr newExpr = new OdpsNewExpr(); - if (lexer.identifierEquals(FnvHash.Constants.GSON) - || lexer.identifierEquals(GSONBUILDER) - || lexer.identifierEquals("STRING") - || lexer.identifierEquals("INTEGER") - ) { - lexer.nextToken(); + if (lexer.token() == Token.IDENTIFIER) { //.GSON + Lexer.SavePoint mark = lexer.mark(); + String methodName = lexer.stringVal(); + lexer.nextToken(); + switch (lexer.token()) { + case ON: + case WHERE: + case GROUP: + case ORDER: + case INNER: + case JOIN: + case FULL: + case OUTER: + case LEFT: + case RIGHT: + case LATERAL: + case FROM: + case COMMA: + case RPAREN: + return ident; + default: + break; + } + + while (lexer.token() == Token.DOT) { + lexer.nextToken(); + methodName += '.' + lexer.stringVal(); + lexer.nextToken(); + } + newExpr.setMethodName(methodName); + + if (lexer.token() == Token.LT) { + lexer.nextToken(); + for (;;) { + if (lexer.token() == Token.GT) { + break; + } + SQLDataType paramType = this.parseDataType(false); + paramType.setParent(newExpr); + newExpr.getTypeParameters().add(paramType); + if (lexer.token() == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.GT); + } + if (lexer.token() == Token.LBRACKET) { lexer.nextToken(); this.exprList(newExpr.getArguments(), newExpr); accept(Token.RBRACKET); + if (lexer.token() == Token.LBRACKET) { + lexer.nextToken(); + accept(Token.RBRACKET); + } + newExpr.setArray(true); + + if (lexer.token() == Token.LBRACE) { + lexer.nextToken(); + for (;;) { + if (lexer.token() == Token.RPAREN) { + break; + } + + SQLExpr item = this.expr(); + newExpr.getInitValues().add(item); + item.setParent(newExpr); + + if (lexer.token() == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RBRACE); + } + if (lexer.token() == Token.LBRACKET) { + expr = primaryRest(newExpr); + } else { + expr = newExpr; + } } else { accept(Token.LPAREN); this.exprList(newExpr.getArguments(), newExpr); accept(Token.RPAREN); + expr = newExpr; } - expr = newExpr; } else if (lexer.identifierEquals("java") || lexer.identifierEquals("com")) { SQLName name = this.name(); String strName = ident.getName() + ' ' + name.toString(); 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 31b5d98b9a..b51eafa5ac 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 @@ -21,8 +21,7 @@ import com.alibaba.druid.sql.parser.*; import java.util.HashMap; import java.util.Map; -import static com.alibaba.druid.sql.parser.CharTypes.isFirstIdentifierChar; -import static com.alibaba.druid.sql.parser.CharTypes.isIdentifierChar; +import static com.alibaba.druid.sql.parser.CharTypes.*; import static com.alibaba.druid.sql.parser.LayoutCharacters.EOI; public class OdpsLexer extends Lexer { @@ -55,9 +54,7 @@ public class OdpsLexer extends Lexer { public OdpsLexer(String input, SQLParserFeature... features){ super(input); - if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、') { - ch = charAt(++pos); - } + init(); dbType = DbType.odps; super.keywords = DEFAULT_ODPS_KEYWORDS; @@ -72,27 +69,38 @@ 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); - } + init(); dbType = DbType.odps; this.skipComment = skipComment; this.keepComments = keepComments; super.keywords = DEFAULT_ODPS_KEYWORDS; } - + public OdpsLexer(String input, CommentHandler commentHandler){ super(input, commentHandler); - if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、') { - ch = charAt(++pos); - } + init(); dbType = DbType.odps; super.keywords = DEFAULT_ODPS_KEYWORDS; } + private void init() { + if (ch == '】' || ch == ' ' || ch == ',' || ch == ':' || ch == '、' || ch == '\u200C' || ch == ';') { + ch = charAt(++pos); + } + + if (ch == '上' && charAt(pos + 1) == '传') { + pos += 2; + ch = charAt(pos); + + while(isWhitespace(ch)) { + ch = charAt(++pos); + } + } + } + public void scanComment() { scanHiveComment(); } @@ -114,6 +122,10 @@ public class OdpsLexer extends Lexer { if (ch == '`') { bufPos++; ch = charAt(++pos); + if (ch == '`') { + ch = charAt(++pos); + continue; + } break; } else if (ch == EOI) { throw new ParserException("illegal identifier. " + info()); @@ -131,7 +143,10 @@ public class OdpsLexer extends Lexer { return; } - final boolean firstFlag = isFirstIdentifierChar(first); + final boolean firstFlag = isFirstIdentifierChar(first) + || ch == 'å' + || ch == 'ß' + || ch == 'ç'; if (!firstFlag) { throw new ParserException("illegal identifier. " + info()); } @@ -142,7 +157,12 @@ public class OdpsLexer extends Lexer { for (;;) { ch = charAt(++pos); - if (ch != 'ó' && ch != 'å' && ch != 'é' && ch != 'í' + if (ch != 'ó' + && ch != 'å' + && ch != 'é' + && ch != 'í' + && ch != 'ß' + && ch != 'ü' && !isIdentifierChar(ch)) { if (ch == '{' && charAt(pos - 1) == '$') { int endIndex = this.text.indexOf('}', pos); @@ -161,6 +181,10 @@ public class OdpsLexer extends Lexer { break; } + if (ch == ';') { + break; + } + bufPos++; continue; } @@ -209,11 +233,19 @@ public class OdpsLexer extends Lexer { } if (ch == '#' - && charAt(pos + 1) == 'C' - && charAt(pos + 2) == 'O' - && charAt(pos + 3) == 'D' - && charAt(pos + 4) == 'E') { + && (charAt(pos + 1) == 'C' || charAt(pos + 1) == 'c') + && (charAt(pos + 2) == 'O' || charAt(pos + 2) == 'o') + && (charAt(pos + 3) == 'D' || charAt(pos + 3) == 'd') + && (charAt(pos + 4) == 'E' || charAt(pos + 4) == 'e') + ) { int p1 = text.indexOf("#END CODE", pos + 1); + int p2 = text.indexOf("#end code", pos + 1); + if (p1 == -1) { + p1 = p2; + } else if (p1 > p2 && p2 != -1){ + p1 = p2; + } + if (p1 != -1) { int end = p1 + "#END CODE".length(); stringVal = text.substring(pos, end); 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 6e1442b1da..6e792eaecc 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 @@ -130,10 +130,22 @@ public class OdpsSelectParser extends SQLSelectParser { } else if (lexer.token() == Token.ALL) { Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); - if (lexer.token() == Token.DOT || lexer.token() == Token.COMMA) { - lexer.reset(mark); - } else { - queryBlock.setDistionOption(SQLSetQuantifier.ALL); + switch (lexer.token()) { + case DOT: + case COMMA: + case SUB: + case PLUS: + case SLASH: + case GT: + case GTEQ: + case EQ: + case LT: + case LTEQ: + lexer.reset(mark); + break; + default: + queryBlock.setDistionOption(SQLSetQuantifier.ALL); + break; } } } @@ -176,6 +188,10 @@ public class OdpsSelectParser extends SQLSelectParser { } } + if (lexer.identifierEquals(FnvHash.Constants.ZORDER)) { + queryBlock.setZOrderBy(this.exprParser.parseZOrderBy()); + } + if (lexer.identifierEquals(FnvHash.Constants.SORT)) { lexer.nextToken(); accept(Token.BY); 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 0d23474ef5..1025ff4fe9 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 @@ -17,7 +17,10 @@ package com.alibaba.druid.sql.dialect.odps.parser; import com.alibaba.druid.DbType; import com.alibaba.druid.sql.ast.*; +import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr; +import com.alibaba.druid.sql.ast.expr.SQLAnyExpr; import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; +import com.alibaba.druid.sql.ast.expr.SQLQueryExpr; 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; @@ -118,7 +121,7 @@ public class OdpsStatementParser extends SQLStatementParser { if (lexer.token() == Token.PARTITION) { lexer.nextToken(); - this.exprParser.parseAssignItem(stmt.getPartitoins(), stmt); + this.exprParser.parseAssignItem(stmt.getPartitions(), stmt); } if (lexer.token() == Token.AS) { @@ -266,6 +269,10 @@ public class OdpsStatementParser extends SQLStatementParser { && stmt.getObject() instanceof SQLIdentifierExpr && ((SQLIdentifierExpr) stmt.getObject()).nameEquals("TENANT")) { lexer.nextToken(); stmt.setObject(new SQLIdentifierExpr("TENANT ROLES")); + } else if (lexer.identifierEquals("OUTPUT") + && stmt.getObject() instanceof SQLIdentifierExpr && ((SQLIdentifierExpr) stmt.getObject()).nameEquals("TEMPORARY")) { + lexer.nextToken(); + stmt.setObject(new SQLIdentifierExpr("TEMPORARY OUTPUT")); } statementList.add(stmt); @@ -360,6 +367,68 @@ public class OdpsStatementParser extends SQLStatementParser { return true; } + if (lexer.identifierEquals(FnvHash.Constants.BEGIN)) { + SQLStatement stmt = parseBlock(); + statementList.add(stmt); + return true; + } + + if (lexer.identifierEquals(FnvHash.Constants.RESTORE)) { + lexer.nextToken(); + accept(Token.TABLE); + OdpsRestoreStatement stmt = new OdpsRestoreStatement(); + stmt.setTable(this.exprParser.name()); + + if (lexer.token() == Token.LPAREN) { + this.exprParser.parseAssignItem(stmt.getProperties(), stmt); + } + + if (lexer.token() == Token.PARTITION) { + lexer.nextToken(); + this.exprParser.parseAssignItem(stmt.getPartitions(), stmt); + } + + if (lexer.token() == Token.TO) { + lexer.nextToken(); + acceptIdentifier("LSN"); + stmt.setTo( + this.exprParser.expr() + ); + } + + if (lexer.token() == Token.AS) { + lexer.nextToken(); + stmt.setAlias( + this.alias() + ); + } + + statementList.add(stmt); + return true; + } + + if (lexer.identifierEquals(FnvHash.Constants.UNDO)) { + lexer.nextToken(); + accept(Token.TABLE); + OdpsUndoTableStatement stmt = new OdpsUndoTableStatement(); + stmt.setTable( + new SQLExprTableSource( + this.exprParser.name() + ) + ); + + if (lexer.token() == Token.PARTITION) { + lexer.nextToken(); + this.exprParser.parseAssignItem(stmt.getPartitions(), stmt); + } + accept(Token.TO); + stmt.setTo( + this.exprParser.expr() + ); + statementList.add(stmt); + return true; + } + if (lexer.token() == Token.FUNCTION) { HiveCreateFunctionStatement stmt = (HiveCreateFunctionStatement) parseHiveCreateFunction(); stmt.setDeclare(true); @@ -374,10 +443,25 @@ public class OdpsStatementParser extends SQLStatementParser { if (lexer.token() == Token.COLONEQ) { lexer.nextToken(); + + boolean cache = false; + if (lexer.identifierEquals(FnvHash.Constants.CACHE)) { + lexer.nextToken(); + accept(Token.ON); + cache = true; + } + + Lexer.SavePoint lpMark = null; + if (lexer.token() == Token.LPAREN) { + lpMark = lexer.mark(); + lexer.nextToken(); + }; + switch (lexer.token()) { case LITERAL_INT: case LITERAL_FLOAT: case LITERAL_CHARS: + case LITERAL_ALIAS: case IDENTIFIER: case CASE: case CAST: @@ -385,7 +469,14 @@ public class OdpsStatementParser extends SQLStatementParser { case VARIANT: case REPLACE: case NEW: + case SUB: + case TRUE: + case FALSE: { + if (lpMark != null) { + lexer.reset(lpMark); + } + SQLExpr expr = this.exprParser.expr(); SQLExprStatement stmt = new SQLExprStatement( new SQLAssignItem(new SQLIdentifierExpr(variant), expr) @@ -394,9 +485,49 @@ public class OdpsStatementParser extends SQLStatementParser { return true; } default: - SQLSelectStatement stmt = this.parseSelect(); + if (lpMark != null) { + lexer.reset(lpMark); + } + + boolean paren = lexer.token() == Token.LPAREN; + Lexer.SavePoint parenMark = lexer.mark(); + SQLSelect select; + try { + select = new OdpsSelectParser(this.exprParser) + .select(); + } catch (ParserException error) { + if (paren) { + lexer.reset(parenMark); + SQLExpr expr = this.exprParser.expr(); + SQLExprStatement stmt = new SQLExprStatement( + new SQLAssignItem(new SQLIdentifierExpr(variant), expr) + ); + statementList.add(stmt); + return true; + } + throw error; + } + switch (lexer.token()) { + case GT: + case GTEQ: + case EQ: + case LT: + case LTEQ: + statementList.add( + new SQLExprStatement( + new SQLAssignItem(new SQLIdentifierExpr(variant), + this.exprParser.exprRest(new SQLQueryExpr(select)) + ) + ) + ); + return true; + default: + break; + } + SQLSelectStatement stmt = new SQLSelectStatement(select, dbType); OdpsQueryAliasStatement aliasQueryStatement = new OdpsQueryAliasStatement(variant, stmt); + aliasQueryStatement.setCache(cache); statementList.add(aliasQueryStatement); return true; } @@ -522,26 +653,33 @@ public class OdpsStatementParser extends SQLStatementParser { stmt.setRowFormat(format); } - if (lexer.identifierEquals(FnvHash.Constants.STORED)) { - lexer.nextToken(); - if (lexer.token() == Token.BY) { + for (;;) { + if (lexer.identifierEquals(FnvHash.Constants.STORED)) { lexer.nextToken(); - } else { - accept(Token.AS); + if (lexer.token() == Token.BY) { + lexer.nextToken(); + } else { + accept(Token.AS); + } + stmt.setStoredAs( + this.exprParser.name()); + continue; } - stmt.setStoredAs( - this.exprParser.name()); - } - if (lexer.token() == Token.WITH) { - lexer.nextToken(); - acceptIdentifier("SERDEPROPERTIES"); - this.exprParser.parseAssignItem(stmt.getSerdeProperties(), stmt); - } + if (lexer.token() == Token.WITH) { + lexer.nextToken(); + acceptIdentifier("SERDEPROPERTIES"); + this.exprParser.parseAssignItem(stmt.getSerdeProperties(), stmt); + continue; + } - if (identifierEquals("PROPERTIES")) { - lexer.nextToken(); - this.exprParser.parseAssignItem(stmt.getProperties(), stmt); + if (identifierEquals("PROPERTIES")) { + lexer.nextToken(); + this.exprParser.parseAssignItem(stmt.getProperties(), stmt); + continue; + } + + break; } return stmt; @@ -568,8 +706,14 @@ public class OdpsStatementParser extends SQLStatementParser { if (lexer.token() == Token.IF) { lexer.nextToken(); accept(Token.EXISTS); - accept(OVERWRITE); - stmt.setOverwriteIfExists(true); + + if (lexer.token() == OVERWRITE) { + lexer.nextToken(); + stmt.setIfExistsOverwrite(true); + } else { + acceptIdentifier("IGNORE"); + stmt.setIfExistsIgnore(true); + } } return stmt; @@ -650,7 +794,24 @@ public class OdpsStatementParser extends SQLStatementParser { SQLSelectParser selectParser = createSQLSelectParser(); from = selectParser.parseTableSourceRest(from); - stmt.setFrom(from); + if (lexer.token() == Token.WHERE) { + lexer.nextToken(); + SQLExpr where = this.exprParser.expr(); + SQLSelectQueryBlock queryBlock = new SQLSelectQueryBlock(); + queryBlock.addSelectItem(new SQLAllColumnExpr()); + queryBlock.setFrom(from); + queryBlock.setWhere(where); + + if (lexer.token() == Token.GROUP) { + selectParser.parseGroupBy(queryBlock); + } + + stmt.setFrom( + new SQLSubqueryTableSource(queryBlock) + ); + } else { + stmt.setFrom(from); + } } else { SQLCommentHint hint = null; if (lexer.token() == Token.HINT) { @@ -658,9 +819,24 @@ public class OdpsStatementParser extends SQLStatementParser { } accept(Token.LPAREN); + boolean paren2 = lexer.token() == Token.LPAREN; + SQLSelectParser selectParser = createSQLSelectParser(); SQLSelect select = selectParser.select(); + SQLTableSource from = null; + if (paren2 && lexer.token() != Token.RPAREN) { + String subQueryAs = null; + if (lexer.token() == Token.AS) { + lexer.nextToken(); + subQueryAs = tableAlias(true); + } else { + subQueryAs = tableAlias(false); + } + SQLSubqueryTableSource subQuery = new SQLSubqueryTableSource(select, subQueryAs); + from = selectParser.parseTableSourceRest(subQuery); + } + accept(Token.RPAREN); String alias; @@ -678,7 +854,13 @@ public class OdpsStatementParser extends SQLStatementParser { accept(Token.IDENTIFIER); } - SQLSubqueryTableSource from = new SQLSubqueryTableSource(select, alias); + if (from == null) { + from = new SQLSubqueryTableSource(select, alias); + } else { + if (alias != null) { + from.setAlias(alias); + } + } SQLTableSource tableSource = selectParser.parseTableSourceRest(from); @@ -812,7 +994,7 @@ public class OdpsStatementParser extends SQLStatementParser { if (lexer.token() == Token.LIKE) { lexer.nextToken(); stmt.setLike(this.exprParser.expr()); - } else if (lexer.token() == Token.LITERAL_CHARS) { + } else if (lexer.token() == Token.LITERAL_CHARS || lexer.token() == Token.LITERAL_ALIAS) { stmt.setLike(this.exprParser.expr()); } @@ -873,6 +1055,11 @@ public class OdpsStatementParser extends SQLStatementParser { return stmt; } + if (lexer.identifierEquals("VARIABLES")) { + lexer.nextToken(); + return parseShowVariants(); + } + if (lexer.token() == Token.CREATE) { return parseShowCreateTable(); } @@ -883,13 +1070,48 @@ public class OdpsStatementParser extends SQLStatementParser { SQLShowFunctionsStatement stmt = new SQLShowFunctionsStatement(); if (lexer.token() == Token.LIKE) { lexer.nextToken(); - SQLExpr like = this.exprParser.expr(); - stmt.setLike(like); + stmt.setLike( + this.exprParser.expr() + ); + } else if (lexer.token() == Token.LITERAL_CHARS || lexer.token() == IDENTIFIER) { + stmt.setLike( + this.exprParser.expr() + ); } return stmt; } + if (lexer.identifierEquals(FnvHash.Constants.ROLE)) { + lexer.nextToken(); + + SQLShowRoleStatement stmt = new SQLShowRoleStatement(); + + if (lexer.token() == Token.GRANT) { + lexer.nextToken(); + stmt.setGrant( + this.exprParser.name() + ); + } + return stmt; + } + + if (lexer.identifierEquals("ACL")) { + lexer.nextToken(); + + SQLShowACLStatement stmt = new SQLShowACLStatement(); + + if (lexer.token() == Token.FOR) { + lexer.nextToken(); + stmt.setTable( + new SQLExprTableSource( + this.exprParser.name() + ) + ); + } + return stmt; + } + if (lexer.identifierEquals(FnvHash.Constants.ROLES)) { lexer.nextToken(); @@ -916,6 +1138,58 @@ public class OdpsStatementParser extends SQLStatementParser { } } + if (lexer.token() == Token.LPAREN) { + this.exprParser.parseAssignItem(stmt.getProperties(), stmt); + } + + if (lexer.token() == Token.PARTITION) { + lexer.nextToken(); + this.exprParser.parseAssignItem(stmt.getPartitions(), stmt); + } + + return stmt; + } + + if (lexer.identifierEquals("CHANGELOGS")) { + lexer.nextToken(); + OdpsShowChangelogsStatement stmt = new OdpsShowChangelogsStatement(); + + if (lexer.token() == Token.FOR) { + lexer.nextToken(); + if (lexer.identifierEquals(FnvHash.Constants.TABLES)) { + lexer.nextToken(); + stmt.setTables(true); + } else if (lexer.token() == Token.TABLE) { + lexer.nextToken(); + stmt.setTable( + new SQLExprTableSource( + this.exprParser.name() + ) + ); + } else if (lexer.token() == IDENTIFIER) { + stmt.setTable( + new SQLExprTableSource( + this.exprParser.name() + ) + ); + } + } + + if (lexer.token() == Token.LPAREN) { + this.exprParser.parseAssignItem(stmt.getProperties(), stmt); + } + + if (lexer.token() == Token.PARTITION) { + lexer.nextToken(); + this.exprParser.parseAssignItem(stmt.getPartitions(), stmt); + } + + if (lexer.token() == Token.LITERAL_INT) { + stmt.setId( + this.exprParser.primary() + ); + } + return stmt; } @@ -1190,11 +1464,14 @@ public class OdpsStatementParser extends SQLStatementParser { if (lexer.token() == OVERWRITE) { stmt.setOverwrite(true); lexer.nextToken(); + } else if (lexer.token() == Token.INTO){ + lexer.nextToken(); } accept(Token.TABLE); - stmt.setInto(this.exprParser.expr()); + stmt.setInto( + this.exprParser.expr()); if (lexer.token() == Token.PARTITION) { lexer.nextToken(); @@ -1264,6 +1541,13 @@ public class OdpsStatementParser extends SQLStatementParser { stmt.setStoredAs(this.exprParser.expr()); } + if (lexer.identifierEquals(FnvHash.Constants.USING)) { + lexer.nextToken(); + stmt.setUsing( + this.exprParser.expr() + ); + } + return stmt; } } 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 3b91632dd3..bbefb514d3 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 @@ -145,6 +145,14 @@ public interface OdpsASTVisitor extends HiveASTVisitor { return true; } + default void endVisit(OdpsShowChangelogsStatement x) { + + } + + default boolean visit(OdpsShowChangelogsStatement x) { + return true; + } + default void endVisit(OdpsListStmt x) { } @@ -272,4 +280,28 @@ public interface OdpsASTVisitor extends HiveASTVisitor { } + default boolean visit(OdpsAlterTableSetFileFormat x) { + return true; + } + + default void endVisit(OdpsAlterTableSetFileFormat x) { + + } + + default boolean visit(OdpsRestoreStatement x) { + return true; + } + + default void endVisit(OdpsRestoreStatement x) { + + } + + default boolean visit(OdpsUndoTableStatement x) { + return true; + } + + default void endVisit(OdpsUndoTableStatement x) { + + } + } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsOutputVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsOutputVisitor.java index 0d86e4f4d9..6296b398e8 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsOutputVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/odps/visitor/OdpsOutputVisitor.java @@ -839,10 +839,10 @@ public class OdpsOutputVisitor extends HiveOutputVisitor implements OdpsASTVisit print0(ucase ? "ADD TABLE " : "add table "); x.getTable().accept(this); - List partitoins = x.getPartitoins(); - if (partitoins.size() > 0) { + List partitions = x.getPartitions(); + if (partitions.size() > 0) { print0(ucase ? " PARTITION (" : " partition ("); - printAndAccept(partitoins, ", "); + printAndAccept(partitions, ", "); print(')'); } @@ -933,6 +933,13 @@ public class OdpsOutputVisitor extends HiveOutputVisitor implements OdpsASTVisit return false; } + @Override + public boolean visit(OdpsAlterTableSetFileFormat x) { + print0(ucase ? "SET FILEFORMAT " : "set fileformat "); + x.getValue().accept(this); + return false; + } + @Override public boolean visit(OdpsCountStatement x) { List headHints = x.getHeadHintsDirect(); @@ -950,10 +957,10 @@ public class OdpsOutputVisitor extends HiveOutputVisitor implements OdpsASTVisit print0(ucase ? "COUNT " : "count "); x.getTable().accept(this); - List partitoins = x.getPartitions(); - if (partitoins.size() > 0) { + List partitions = x.getPartitions(); + if (partitions.size() > 0) { print0(ucase ? " PARTITION (" : " partition ("); - printAndAccept(partitoins, ", "); + printAndAccept(partitions, ", "); print(')'); } return false; @@ -1058,7 +1065,14 @@ public class OdpsOutputVisitor extends HiveOutputVisitor implements OdpsASTVisit if (storedAs != null) { println(); print0(ucase ? "STORED AS " : "stored as "); - storedAs.accept(this); + printExpr(storedAs); + } + + SQLExpr using = x.getUsing(); + if (using != null) { + println(); + print0(ucase ? "USING " : "using "); + printExpr(using); } return false; 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 564f1eb547..4512ba1937 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 @@ -16,6 +16,9 @@ package com.alibaba.druid.sql.dialect.odps.visitor; import com.alibaba.druid.DbType; +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; +import com.alibaba.druid.sql.ast.statement.SQLAssignItem; 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; @@ -23,6 +26,8 @@ import com.alibaba.druid.sql.dialect.odps.ast.*; import com.alibaba.druid.sql.repository.SchemaRepository; import com.alibaba.druid.stat.TableStat; +import java.util.List; + public class OdpsSchemaStatVisitor extends HiveSchemaStatVisitor implements OdpsASTVisitor { public OdpsSchemaStatVisitor() { @@ -64,9 +69,48 @@ public class OdpsSchemaStatVisitor extends HiveSchemaStatVisitor implements Odps stat.incrementAddCount(); } + resolvePartitions(table, x.getPartitions()); + return false; } + @Override + public boolean visit(OdpsUnloadStatement x) { + SQLExprTableSource table = (SQLExprTableSource) x.getFrom(); + TableStat stat = getTableStatWithUnwrap(table.getExpr()); + if (stat != null) { + stat.incrementSelectCount(); + } + + resolvePartitions(table, x.getPartitions()); + + return false; + } + + @Override + public boolean visit(OdpsCountStatement x) { + SQLExprTableSource table = x.getTable(); + TableStat stat = getTableStatWithUnwrap(table.getExpr()); + if (stat != null) { + stat.incrementSelectCount(); + } + + resolvePartitions(table, x.getPartitions()); + + return false; + } + + private void resolvePartitions(SQLExprTableSource table, List parttions) { + for (SQLAssignItem partition : parttions) { + SQLExpr target = partition.getTarget(); + if (target instanceof SQLIdentifierExpr) { + SQLIdentifierExpr columnName = (SQLIdentifierExpr) target; + columnName.setResolvedTableSource(table); + columnName.accept(this); + } + } + } + public boolean visit(OdpsSelectQueryBlock x) { return visit((SQLSelectQueryBlock) x); } diff --git a/src/main/java/com/alibaba/druid/sql/parser/CharTypes.java b/src/main/java/com/alibaba/druid/sql/parser/CharTypes.java index fd104aa71f..feab70d6ef 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/CharTypes.java +++ b/src/main/java/com/alibaba/druid/sql/parser/CharTypes.java @@ -112,9 +112,9 @@ public class CharTypes { } whitespaceFlags[160] = true; // 特别处理 - whitespaceFlags[223] = true; // 特别处理, odps - whitespaceFlags[229] = true; // 特别处理, odps - whitespaceFlags[231] = true; // 特别处理, odps +// whitespaceFlags[223] = true; // 特别处理, odps +// whitespaceFlags[229] = true; // 特别处理, odps +// whitespaceFlags[231] = true; // 特别处理, odps ç } /** 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 53d2447618..9feeca18b3 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/Lexer.java +++ b/src/main/java/com/alibaba/druid/sql/parser/Lexer.java @@ -1156,6 +1156,28 @@ public class Lexer { token = LITERAL_PATH; } + public final void nextTokenForSet() { + while (isWhitespace(ch)) { + ch = charAt(++pos); + } + + if (isFirstIdentifierChar(ch) || ch == '{') { + stringVal = null; + mark = pos; + while (ch != ';' && ch != EOI) { + ch = charAt(++pos); + } + + bufPos = pos - mark; + + stringVal = this.subString(mark, bufPos); + token = IDENTIFIER; + return; + } + + nextToken(); + } + public final void nextToken() { startPos = pos; bufPos = 0; @@ -1205,6 +1227,12 @@ public class Lexer { } } + if (ch == '—' && charAt(pos + 1) == '—' && charAt(pos + 2) == '\n') { + pos += 3; + ch = charAt(pos); + continue; + } + scanIdentifier(); return; } @@ -2335,29 +2363,34 @@ public class Lexer { } for (;;) { - char c2; - if (ch == '*' - && ((c2 = charAt(pos + 1)) == '/' - || (c2 == ' ' && charAt(pos + 2) == '/') - || (c2 == ' ' && charAt(pos + 2) == ' ' && charAt(pos + 3) == '/')) - ) { - if (c2 == ' ') { - bufPos ++; - scanChar(); - } + if (ch == '*') { + if (charAt(pos + 1) == '/') { - if (charAt(pos + 1) == ' ') { - bufPos ++; + bufPos += 2; scanChar(); + scanChar(); + break; + } else if (isWhitespace(charAt(pos + 1))) { + int i = 2; + for (;i < 1024 * 1024;++i) { + if (!isWhitespace(charAt(pos + i))) { + break; + } + } + if (charAt(pos + i) == '/') { + bufPos += 2; + pos += (i + 1); + ch = charAt(pos); + break; + } } - - bufPos += 2; - scanChar(); - scanChar(); - break; } + scanChar(); + if (ch == EOI) { + break; + } bufPos++; } @@ -2740,7 +2773,10 @@ public class Lexer { return; } token = Token.LITERAL_FLOAT; - } else if (ch != '`') { + return; + } + + if (ch != '`') { if (isFirstIdentifierChar(ch) && ch != ')' && !(ch == 'b' && bufPos == 1 && charAt(pos - 1) == '0' && dbType != DbType.odps) @@ -2765,10 +2801,11 @@ public class Lexer { stringVal = addSymbol(); hash_lower = FnvHash.hashCode64(stringVal); token = Token.IDENTIFIER; - } else { - token = Token.LITERAL_INT; + return; } } + + token = Token.LITERAL_INT; } public void scanHexaDecimal() { 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 239f9aee96..bbcfeabe52 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java @@ -253,7 +253,11 @@ public class SQLExprParser extends SQLParser { Lexer.SavePoint savePoint = lexer.mark(); lexer.nextToken(); - if (lexer.token == Token.COMMA || lexer.token == Token.EOF || lexer.token == Token.ON || lexer.token == Token.RPAREN) { + if (lexer.token == Token.COMMA + || lexer.token == Token.EOF + || lexer.token == Token.ON + || lexer.token == Token.WHERE + || lexer.token == Token.RPAREN) { lexer.reset(savePoint); return expr; } @@ -326,6 +330,11 @@ public class SQLExprParser extends SQLParser { case LPAREN: int paranCount = 0; lexer.nextToken(); + if (lexer.token == Token.RPAREN) { + lexer.nextToken(); + sqlExpr = new SQLMethodInvokeExpr(); + break; + } sqlExpr = expr(); @@ -486,6 +495,15 @@ public class SQLExprParser extends SQLParser { } else if (DbType.mysql == dbType && hash_lower == FnvHash.Constants.REAL && lexer.token == Token.LITERAL_CHARS) { sqlExpr = new SQLRealExpr(lexer.stringVal()); lexer.nextToken(); + } else if (hash_lower == FnvHash.Constants.DATE && lexer.token == Token.LITERAL_ALIAS) { + sqlExpr = new SQLDateExpr(lexer.stringVal()); + lexer.nextToken(); + } else if (hash_lower == FnvHash.Constants.DATETIME && lexer.token == Token.LITERAL_ALIAS) { + sqlExpr = new SQLDateTimeExpr(lexer.stringVal()); + lexer.nextToken(); + } else if (hash_lower == FnvHash.Constants.TIMESTAMP && lexer.token == Token.LITERAL_ALIAS) { + sqlExpr = new SQLTimestampExpr(lexer.stringVal()); + lexer.nextToken(); } else { char c0 = ident.charAt(0); if (c0 == '`' || c0 == '[' || c0 == '"') { @@ -757,13 +775,24 @@ public class SQLExprParser extends SQLParser { sqlExpr = caseExpr; break; - case EXISTS: + case EXISTS: { + String strVal = lexer.stringVal(); lexer.nextToken(); - accept(Token.LPAREN); - sqlExpr = new SQLExistsExpr(createSelectParser().select()); - accept(Token.RPAREN); - parseQueryPlanHint(sqlExpr); + switch (lexer.token) { + case COMMA: + case DOT: + sqlExpr = new SQLIdentifierExpr(strVal); + break; + default: + accept(Token.LPAREN); + sqlExpr = new SQLExistsExpr(createSelectParser().select()); + accept(Token.RPAREN); + parseQueryPlanHint(sqlExpr); + break; + } + break; + } case NOT: lexer.nextToken(); if (lexer.token == Token.EXISTS) { @@ -895,6 +924,9 @@ public class SQLExprParser extends SQLParser { case LBRACE: case IF: case CHECK: + case INDEX: + case PRIMARY: + case KEY: case REPLACE: sqlExpr = primary(); @@ -1071,6 +1103,9 @@ public class SQLExprParser extends SQLParser { } if (lexer.token() == Token.LPAREN) { sqlExpr = new SQLIdentifierExpr("SET"); + } else if (lexer.token == Token.DOT) { + sqlExpr = new SQLIdentifierExpr("SET"); + sqlExpr = this.primaryRest(sqlExpr); } else { lexer.reset(savePoint); throw new ParserException("ERROR. " + lexer.info()); @@ -1135,6 +1170,11 @@ public class SQLExprParser extends SQLParser { case DECLARE: case DROP: case RLIKE: + case FOREIGN: + case FETCH: + case ASC: + case CURSOR: + case ALTER: if (dbType == DbType.odps || dbType == DbType.hive) { sqlExpr = new SQLIdentifierExpr(lexer.stringVal()); lexer.nextToken(); @@ -1148,8 +1188,22 @@ public class SQLExprParser extends SQLParser { lexer.nextToken(); switch (lexer.token) { case COMMA: + case RPAREN: + case AS: + case EQ: + case EQEQ: + case LT: + case LTEQ: + case GT: + case GTEQ: + case LTGT: + case SEMI: sqlExpr = new SQLIdentifierExpr(str); - lexer.nextToken(); + break; + case DOT: + sqlExpr = primaryRest( + new SQLIdentifierExpr(str) + ); break; default: lexer.reset(mark); @@ -1171,6 +1225,7 @@ public class SQLExprParser extends SQLParser { break; } throw new ParserException("ERROR. " + lexer.info()); + case BETWEEN: case IN: if (dbType == DbType.odps) { String str = lexer.stringVal(); @@ -1183,6 +1238,7 @@ public class SQLExprParser extends SQLParser { case GT: case RPAREN: case IS: + case AS: sqlExpr = new SQLIdentifierExpr(str); break; default: @@ -1229,9 +1285,14 @@ public class SQLExprParser extends SQLParser { case COLONCOLON: if (dbType == DbType.odps) { lexer.nextToken(); - SQLMethodInvokeExpr method = (SQLMethodInvokeExpr) this.primary(); - method.setOwner(new SQLIdentifierExpr("")); - sqlExpr = method; + SQLExpr temp = this.primary(); + if (temp instanceof SQLArrayExpr) { + sqlExpr = temp; + } else { + SQLMethodInvokeExpr method = (SQLMethodInvokeExpr) temp; + method.setOwner(new SQLIdentifierExpr("")); + sqlExpr = method; + } break; } throw new ParserException("ERROR. " + lexer.info()); @@ -1260,6 +1321,8 @@ public class SQLExprParser extends SQLParser { case GTEQ: case LT: case LTEQ: + case STAR: + case DIV: return primaryRest(new SQLIdentifierExpr(str)); case COMMA: case PLUS: @@ -1269,6 +1332,7 @@ public class SQLExprParser extends SQLParser { case GROUP: case SEMI: case AS: + case FROM: return new SQLIdentifierExpr(str); case IDENTIFIER: if (dbType == DbType.odps) { @@ -1371,6 +1435,7 @@ public class SQLExprParser extends SQLParser { case SEMI: case ASC: case DESC: + case ELSE: return new SQLIdentifierExpr(str); case PLUS: case SUB: { @@ -1389,6 +1454,9 @@ public class SQLExprParser extends SQLParser { return new SQLIdentifierExpr(str); } default: + if (lexer.identifierEquals(FnvHash.Constants.GROUPING)) { + return new SQLIdentifierExpr(str); + } break; } @@ -1906,11 +1974,18 @@ public class SQLExprParser extends SQLParser { } else if (lexer.token == Token.VARIANT && lexer.stringVal().startsWith("$")) { name = lexer.stringVal(); lexer.nextToken(); - } else if (lexer.token == Token.LITERAL_INT && dbType == DbType.hive) { + } else if ((lexer.token == Token.LITERAL_INT || lexer.token == Token.LITERAL_FLOAT) + && (dbType == DbType.hive || dbType == DbType.odps)) { name = lexer.numberString(); lexer.nextToken(); } else { - throw new ParserException("error : " + lexer.info()); + if (lexer.token == Token.DOT && dbType == DbType.odps && expr.toString().equals("odps.sql.mapper")) { + lexer.nextToken(); + name = lexer.stringVal(); + lexer.nextToken(); + } else { + throw new ParserException("error : " + lexer.info()); + } } if (lexer.token == Token.LPAREN) { @@ -2232,6 +2307,15 @@ public class SQLExprParser extends SQLParser { case TO: case DECLARE: case AS: + case BY: + case EXISTS: + case FOREIGN: + case ALTER: + case ASC: + case NULL: + case CURSOR: + case FETCH: + case DATABASE: if (dbType == DbType.odps) { identName = lexer.stringVal(); lexer.nextToken(); @@ -2364,7 +2448,18 @@ public class SQLExprParser extends SQLParser { } protected void filter(SQLAggregateExpr x) { + Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); + + switch (lexer.token) { + case COMMA: + case FROM: + lexer.reset(mark); + return; + default: + break; + } + accept(Token.LPAREN); accept(Token.WHERE); SQLExpr filter = this.expr(); @@ -2434,6 +2529,7 @@ public class SQLExprParser extends SQLParser { over.setOrderBy(parseOrderBy()); over.setDistributeBy(parseDistributeBy()); over.setSortBy(parseSortBy()); + over.setClusterBy(parseClusterBy()); if (lexer.token == Token.OF) { lexer.nextToken(); @@ -2459,6 +2555,7 @@ public class SQLExprParser extends SQLParser { if (lexer.token == Token.LITERAL_INT || lexer.token == Token.LITERAL_FLOAT || lexer.token == Token.LITERAL_CHARS + || lexer.token == Token.CAST ) { SQLExpr betweenBegin = this.additive(); over.setWindowingBetweenBegin(betweenBegin); @@ -2472,6 +2569,9 @@ public class SQLExprParser extends SQLParser { SQLExpr betweenBegin = this.primary(); over.setWindowingBetweenBegin(betweenBegin); } + } else if (lexer.token == Token.INTERVAL) { + SQLExpr betweenBegin = this.primary(); + over.setWindowingBetweenBegin(betweenBegin); } final SQLOver.WindowingBound beginBound = parseWindowingBound(); @@ -2487,6 +2587,9 @@ public class SQLExprParser extends SQLParser { ) { SQLExpr betweenEnd = this.additive(); over.setWindowingBetweenEnd(betweenEnd); + } else if (lexer.token == Token.INTERVAL) { + SQLExpr betweenBegin = this.additive(); + over.setWindowingBetweenEnd(betweenBegin); } else if (lexer.token == Token.IDENTIFIER) { long hash = lexer.hash_lower(); @@ -2507,6 +2610,7 @@ public class SQLExprParser extends SQLParser { if (lexer.token == Token.LITERAL_INT || lexer.token == Token.LITERAL_FLOAT || lexer.token == Token.LITERAL_CHARS + || lexer.token == Token.INTERVAL ) { SQLExpr betweenBegin = this.additive(); over.setWindowingBetweenBegin(betweenBegin); @@ -2529,6 +2633,13 @@ public class SQLExprParser extends SQLParser { } } + if (lexer.identifierEquals(FnvHash.Constants.EXCLUDE)) { + lexer.nextToken(); + acceptIdentifier("CURRENT"); + acceptIdentifier("ROW"); + over.setExcludeCurrentRow(true); + } + accept(Token.RPAREN); } @@ -2665,6 +2776,31 @@ public class SQLExprParser extends SQLParser { return null; } + public SQLOrderBy parseClusterBy() { + if (lexer.identifierEquals(FnvHash.Constants.CLUSTER)) { + SQLOrderBy orderBy = new SQLOrderBy(); + + lexer.nextToken(); + + if (lexer.identifierEquals(FnvHash.Constants.SIBLINGS)) { + lexer.nextToken(); + orderBy.setSibings(true); + } + + accept(Token.BY); + + orderBy(orderBy.getItems(), orderBy); + + if (lexer.token == Token.ORDER) { + throw new ParserException(lexer.info()); // dual order by + } + + return orderBy; + } + + return null; + } + public void orderBy(List items, SQLObject parent) { SQLSelectOrderByItem item = parseSelectOrderByItem(); item.setParent(parent); @@ -2687,6 +2823,38 @@ public class SQLExprParser extends SQLParser { if (lexer.token() == Token.LITERAL_ALIAS) { expr = name(); expr = primaryRest(expr); + expr = exprRest(expr); + } else if (lexer.token == Token.LPAREN) { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextToken(); + for (int i = 0;;++i) { + expr = this.expr(); + if (lexer.token == Token.ASC) { + lexer.nextToken(); + item.setType(SQLOrderingSpecification.ASC); + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + continue; + } + accept(Token.RPAREN); + } else if (lexer.token == Token.DESC) { + lexer.nextToken(); + item.setType(SQLOrderingSpecification.DESC); + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + continue; + } + accept(Token.RPAREN); + } else { + if (i > 0 && lexer.token == Token.RPAREN) { + lexer.nextToken(); + break; + } + lexer.reset(mark); + expr = expr(); + } + break; + } } else { expr = expr(); } @@ -2858,8 +3026,15 @@ public class SQLExprParser extends SQLParser { } if (lexer.token == Token.IN) { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextTokenLParen(); + if (lexer.token == Token.COMMA) { + lexer.reset(mark); + return expr; + } + SQLInListExpr inListExpr = new SQLInListExpr(expr); List targetList = inListExpr.getTargetList(); if (lexer.token == Token.LPAREN) { @@ -3313,6 +3488,7 @@ public class SQLExprParser extends SQLParser { } public SQLExpr relationalRest(SQLExpr expr) { + final SQLExpr initExpr = expr; SQLExpr rightExp; Token token = lexer.token; @@ -3562,8 +3738,13 @@ public class SQLExprParser extends SQLParser { break; case EQEQ: if (dbType == DbType.odps || dbType == DbType.hive) { + Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); try { + if (lexer.token == Token.SEMI) { + lexer.reset(mark); + break; + } rightExp = bitOr(); } catch (EOFParserException e) { throw new ParserException("EOF, " + expr + "=", e); @@ -3659,6 +3840,10 @@ public class SQLExprParser extends SQLParser { return expr; } + if (expr == initExpr) { + return expr; + } + switch (lexer.token) { case BETWEEN: case IS: @@ -3950,7 +4135,15 @@ public class SQLExprParser extends SQLParser { SQLTableDataType table = new SQLTableDataType(); accept(Token.LPAREN); for (;;) { - SQLColumnDefinition column = this.parseColumn(); + SQLColumnDefinition column; + if (lexer.token == Token.STAR) { + lexer.nextToken(); + column = new SQLColumnDefinition(); + column.setName("*"); + accept(Token.ANY); + } else { + column = this.parseColumn(); + } column.setParent(table); table.getColumns().add(column); if (lexer.token == Token.COMMA) { @@ -4813,7 +5006,7 @@ public class SQLExprParser extends SQLParser { public void parseAssignItem(List outList, SQLObject parent) { accept(Token.LPAREN); for (;;) { - SQLAssignItem item = this.parseAssignItem(); + SQLAssignItem item = this.parseAssignItem(true, parent); item.setParent(parent); outList.add(item); if (lexer.token() == Token.COMMA) { @@ -4840,7 +5033,26 @@ public class SQLExprParser extends SQLParser { lexer.nextToken(); } - SQLExpr var = primary(); + SQLExpr var; + + if (dbType == DbType.odps && lexer.identifierEquals("NC_TO_BE_EXECUTED")) { + lexer.nextToken(); // skip + } + + if (lexer.identifierEquals(FnvHash.Constants.TBLPROPERTIES)) { + var = new SQLIdentifierExpr(lexer.stringVal()); + lexer.nextToken(); + + if (lexer.token == Token.LPAREN && dbType == DbType.odps) { + SQLListExpr list = new SQLListExpr(); + this.exprList(list.getItems(), list); + item.setTarget(new SQLIdentifierExpr("tblproperties")); + item.setValue(list); + return item; + } + } else { + var = primary(); + } if (var instanceof SQLPropertyExpr && lexer.token == Token.SUB && dbType == DbType.odps) { SQLPropertyExpr propertyExpr = (SQLPropertyExpr) var; @@ -4856,7 +5068,20 @@ public class SQLExprParser extends SQLParser { var = this.primaryRest(propertyExpr); } - if (var instanceof SQLPropertyExpr && lexer.token == Token.IDENTIFIER && dbType == DbType.odps) { + if (var instanceof SQLIdentifierExpr && dbType == DbType.odps) { + SQLIdentifierExpr identExpr = (SQLIdentifierExpr) var; + if ((identExpr.getName().equalsIgnoreCase("et") + || identExpr.getName().equalsIgnoreCase("odps") + ) + && lexer.token == Token.IDENTIFIER) { + SQLExpr expr = this.primary(); + identExpr.setName( + identExpr.getName() + ' ' + expr.toString() + ); + } + } + + if (var instanceof SQLPropertyExpr && dbType == DbType.odps) { SQLPropertyExpr propertyExpr = (SQLPropertyExpr) var; if (identifierEquals("DATEADD")) { @@ -4870,6 +5095,24 @@ public class SQLExprParser extends SQLParser { String name = propertyExpr.getName() + func; propertyExpr.setName(name); + } else if (propertyExpr.getName().equalsIgnoreCase("enab") && identifierEquals("le")) { + String name = propertyExpr.getName() +lexer.stringVal(); + lexer.nextToken(); + propertyExpr.setName(name); + } else if (propertyExpr.getName().equalsIgnoreCase("sq") && identifierEquals("l")) { + String name = propertyExpr.getName() +lexer.stringVal(); + lexer.nextToken(); + propertyExpr.setName(name); + } else if (propertyExpr.getName().equalsIgnoreCase("s") && identifierEquals("ql")) { + String name = propertyExpr.getName() +lexer.stringVal(); + lexer.nextToken(); + propertyExpr.setName(name); + var = this.primaryRest(propertyExpr); + } else if (lexer.token == Token.BY) { + String name = propertyExpr.getName() + ' ' + lexer.stringVal(); + lexer.nextToken(); + propertyExpr.setName(name); + var = this.primaryRest(propertyExpr); } } @@ -4882,9 +5125,41 @@ public class SQLExprParser extends SQLParser { String str = ident.getName() + " " + lexer.stringVal(); lexer.nextToken(); ident.setName(str); + } else if (lexer.token == Token.IDENTIFIER && dbType == DbType.odps) { + ident.setName(ident.getName() + ' ' + lexer.stringVal()); + lexer.nextToken(); + while (lexer.token == Token.IDENTIFIER) { + ident.setName(ident.getName() + ' ' + lexer.stringVal()); + lexer.nextToken(); + } } - var = new SQLVariantRefExpr((ident).getName()); + String identName = (ident).getName(); + if (identName.indexOf('@') != -1 + || identName.indexOf('#') != -1 + || identName.indexOf(':') != -1 + || identName.indexOf(' ') != -1) { + var = new SQLVariantRefExpr(identName); + } + } + + if (var instanceof SQLMethodInvokeExpr && dbType == DbType.odps) { + SQLMethodInvokeExpr func = (SQLMethodInvokeExpr) var; + + SQLExpr owner = func.getOwner(); + if (owner != null) { + item.setTarget(new SQLPropertyExpr(owner, func.getMethodName())); + } else { + item.setTarget(new SQLIdentifierExpr(func.getMethodName())); + } + + SQLListExpr properties = new SQLListExpr(); + for (SQLExpr argument : func.getArguments()) { + properties.addItem(argument); + } + + item.setValue(properties); + return item; } item.setTarget(var); @@ -4899,11 +5174,17 @@ public class SQLExprParser extends SQLParser { lexer.nextToken(); item.setValue(new SQLIdentifierExpr("ON")); return item; - } else if (lexer.token == Token.RPAREN || lexer.token == Token.COMMA) { - return item; + } else if (lexer.token == Token.RPAREN || lexer.token == Token.COMMA || lexer.token == Token.SET) { + if (dbType == DbType.odps || dbType == DbType.hive) { + return item; + } } else { if (lexer.token == Token.EQ) { - lexer.nextToken(); + if (dbType == DbType.odps) { + lexer.nextTokenForSet(); + } else { + lexer.nextToken(); + } if (lexer.token == Token.SEMI && dbType == DbType.odps) { return item; } @@ -4968,6 +5249,9 @@ public class SQLExprParser extends SQLParser { expr.setParent(listExpr); do { lexer.nextToken(); + if (lexer.token == Token.SET && dbType == DbType.odps) { + break; + } SQLExpr listItem = this.expr(); listItem.setParent(listExpr); listExpr.addItem(listItem); @@ -6339,12 +6623,6 @@ public class SQLExprParser extends SQLParser { if (lexer.identifierEquals(FnvHash.Constants.SERDE)) { lexer.nextToken(); format.setSerde(this.expr()); - - if (lexer.token == Token.WITH) { - lexer.nextToken(); - acceptIdentifier("serdeproperties"); - this.parseAssignItem(format.getSerdeProperties(), format); - } } return format; 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 3bb13a49a6..4faa9f6231 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java @@ -144,7 +144,6 @@ public class SQLParser { Lexer.SavePoint mark = lexer.mark(); lexer.nextToken(); if (lexer.token == Token.PARTITION - || lexer.token == Token.UNION || lexer.identifierEquals(FnvHash.Constants.DIMENSION) || lexer.identifierEquals(FnvHash.Constants.IGNORE) || lexer.identifierEquals(FnvHash.Constants.KEEP)) { @@ -205,6 +204,8 @@ public class SQLParser { } case OUTER: case IN: + case SET: + case BY: { Lexer.SavePoint mark = lexer.mark(); String strVal = lexer.stringVal(); @@ -212,11 +213,14 @@ public class SQLParser { switch (lexer.token) { case WHERE: case GROUP: + case ORDER: case LEFT: case RIGHT: case FULL: case RPAREN: case ON: + case JOIN: + case SEMI: { return strVal; } @@ -239,6 +243,8 @@ public class SQLParser { case IS: case DECLARE: case DROP: + case FETCH: + case LOCK: if (dbType == DbType.odps || dbType == DbType.hive) { String strVal = lexer.stringVal(); lexer.nextToken(); @@ -265,6 +271,8 @@ public class SQLParser { switch (lexer.token) { case FROM: case GROUP: + case ORDER: + case ON: return strVal; default: lexer.reset(mark); @@ -295,14 +303,25 @@ public class SQLParser { } case MINUS: case EXCEPT: + case LIMIT: + case BETWEEN: if (dbType == DbType.odps){ Lexer.SavePoint mark = lexer.mark(); String strVal = lexer.stringVal(); lexer.nextToken(); switch (lexer.token) { - case SEMI: case EOF: + case COMMA: + case WHERE: case GROUP: + case ORDER: + case LEFT: + case RIGHT: + case FULL: + case RPAREN: + case ON: + case JOIN: + case SEMI: return strVal; default: lexer.reset(mark); @@ -310,6 +329,25 @@ public class SQLParser { } } break; + case UNION: { + Lexer.SavePoint mark = lexer.mark(); + String strVal = lexer.stringVal(); + lexer.nextToken(); + switch (lexer.token) { + case GROUP: + case ORDER: + case SEMI: + case LEFT: + case RIGHT: + case INNER: + case JOIN: + case RPAREN: + return strVal; + default: + lexer.reset(mark); + return null; + } + } default: break; } @@ -352,6 +390,24 @@ public class SQLParser { return strVal; } } + case BETWEEN: { + Lexer.SavePoint mark = lexer.mark(); + String strVal = lexer.stringVal(); + lexer.nextToken(); + switch (lexer.token) { + case GROUP: + case ORDER: + case SEMI: + case LEFT: + case RIGHT: + case INNER: + case JOIN: + return strVal; + default: + lexer.reset(mark); + return null; + } + } default: break; } @@ -440,11 +496,12 @@ public class SQLParser { case TABLESPACE: case REPEAT: case PRIMARY: + case FOREIGN: case UNIQUE: case LEAVE: case ENABLE: case DISABLE: - case DISTRIBUTE: + case REPLACE: alias = lexer.stringVal(); lexer.nextToken(); break; @@ -460,6 +517,12 @@ public class SQLParser { case EXPLAIN: case CREATE: case LIMIT: + case USE: + case BY: + case ALTER: + case IN: + case INTO: + case ASC: { alias = lexer.stringVal(); @@ -468,6 +531,8 @@ public class SQLParser { if (lexer.token() != Token.COMMA && lexer.token() != Token.RPAREN && lexer.token() != Token.FROM + && lexer.token() != Token.SEMI + && lexer.token() != Token.SEMI ) { alias = null; lexer.reset(mark); @@ -488,6 +553,7 @@ public class SQLParser { case NULL: case RIGHT: case LEFT: + case DATABASE: if (dbType == DbType.odps || dbType == DbType.hive) { alias = lexer.stringVal(); lexer.nextToken(); @@ -496,6 +562,7 @@ public class SQLParser { break; case GROUP: case ORDER: + case DISTRIBUTE: case DEFAULT: if (dbType == DbType.odps || dbType == DbType.hive) { Lexer.SavePoint mark = lexer.mark(); @@ -541,6 +608,14 @@ public class SQLParser { } else if (lexer.token == Token.LITERAL_CHARS) { alias = "'" + lexer.stringVal() + "'"; lexer.nextToken(); + } else if (lexer.token == Token.LITERAL_FLOAT && dbType == DbType.odps) { + String numStr = lexer.numberString(); + lexer.nextToken(); + if (lexer.token == Token.IDENTIFIER) { + numStr += lexer.stringVal(); + lexer.nextToken(); + } + return numStr; } else { switch (lexer.token) { case KEY: @@ -626,8 +701,6 @@ public class SQLParser { case KILL: case SHOW: case NULL: - case ORDER: - case GROUP: case ALL: case CONSTRAINT: case INNER: @@ -667,9 +740,30 @@ public class SQLParser { case FOR: case PARTITIONED: case REPLACE: + case ALTER: + case EXPLAIN: + case ASC: + case DATABASE: + case TRUE: + case FALSE: + case OUTER: + case DROP: alias = lexer.stringVal(); lexer.nextToken(); return alias; + case GROUP: + case ORDER: + if (dbType == DbType.odps || dbType == DbType.hive) { + Lexer.SavePoint mark = lexer.mark(); + alias = lexer.stringVal(); + lexer.nextToken(); + if (lexer.token == Token.BY) { + lexer.reset(mark); + alias = null; + } + break; + } + break; case QUES: alias = "?"; lexer.nextToken(); 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 1ca2e74bca..96762e692b 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java @@ -130,8 +130,24 @@ public class SQLSelectParser extends SQLParser { if (lexer.token == Token.UNION) { do { + Lexer.SavePoint uninMark = lexer.mark(); lexer.nextToken(); + switch (lexer.token) { + case GROUP: + case ORDER: + case WHERE: + case RPAREN: + lexer.reset(uninMark); + return selectQuery; + default: + break; + } + + if (lexer.token == Token.SEMI && dbType == DbType.odps) { + break; + } + SQLUnionQuery union = createSQLUnionQuery(); if (union.getRelations().isEmpty()) { union.setLeft(selectQuery); @@ -592,6 +608,7 @@ public class SQLSelectParser extends SQLParser { case SELECT: case LPAREN: case WITH: + case FROM: entry.setSubQuery(select()); break; default: @@ -802,7 +819,7 @@ public class SQLSelectParser extends SQLParser { } } - protected void parseGroupBy(SQLSelectQueryBlock queryBlock) { + public void parseGroupBy(SQLSelectQueryBlock queryBlock) { if (lexer.token == Token.GROUP) { lexer.nextTokenBy(); accept(Token.BY); @@ -971,7 +988,44 @@ public class SQLSelectParser extends SQLParser { lexer.reset(mark); } - SQLExpr item = this.exprParser.expr(); + SQLExpr item; + if (lexer.identifierEquals(FnvHash.Constants.ROLLUP)) { + SQLMethodInvokeExpr rollup = new SQLMethodInvokeExpr(lexer.stringVal()); + lexer.nextToken(); + if (lexer.token == Token.LPAREN) { + lexer.nextToken(); + for (;;) { + if (lexer.token == Token.RPAREN) { + break; + } + + SQLExpr expr; + if (lexer.token == Token.LPAREN) { + accept(Token.LPAREN); + SQLListExpr list = new SQLListExpr(); + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + } + this.exprParser.exprList(list.getItems(), list); + accept(Token.RPAREN); + expr = list; + } else { + expr = this.exprParser.expr(); + } + rollup.addArgument(expr); + + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RPAREN); + } + item = rollup; + } else { + item = this.exprParser.expr(); + } if(DbType.mysql == dbType) { if (lexer.token == Token.DESC) { @@ -1040,7 +1094,10 @@ public class SQLSelectParser extends SQLParser { } else if (lexer.token == Token.LPAREN) { tableSource = parseTableSource(); - while ((lexer.token == Token.UNION || lexer.token == Token.EXCEPT || lexer.token == Token.INTERSECT) + while ((lexer.token == Token.UNION + || lexer.token == Token.EXCEPT + || lexer.token == Token.INTERSECT + || lexer.token == Token.MINUS) && tableSource instanceof SQLUnionQueryTableSource) { SQLUnionQueryTableSource unionQueryTableSource = (SQLUnionQueryTableSource) tableSource; SQLUnionQuery union = unionQueryTableSource.getUnion(); @@ -1147,6 +1204,7 @@ public class SQLSelectParser extends SQLParser { SQLExpr expr; switch (lexer.token) { case ALL: + case SET: expr = this.exprParser.name(); break; default: @@ -1318,7 +1376,10 @@ public class SQLSelectParser extends SQLParser { } } else if (lexer.token == Token.LPAREN && tableSource instanceof SQLExprTableSource - && ((SQLExprTableSource) tableSource).getExpr() instanceof SQLVariantRefExpr) { + && (((SQLExprTableSource) tableSource).getExpr() instanceof SQLVariantRefExpr + || ((SQLExprTableSource) tableSource).getExpr() instanceof SQLIdentifierExpr + ) + ) { lexer.nextToken(); SQLExprTableSource exprTableSource = (SQLExprTableSource) tableSource; this.exprParser.names(exprTableSource.getColumns(), exprTableSource); @@ -1387,6 +1448,11 @@ public class SQLSelectParser extends SQLParser { joinType = SQLJoinTableSource.JoinType.LEFT_OUTER_JOIN; } + if (dbType == DbType.odps && lexer.token == Token.IDENTIFIER && lexer.stringVal().startsWith("join@")) { + lexer.stringVal = lexer.stringVal().substring(5); + break; + } + accept(Token.JOIN); break; case RIGHT: @@ -1479,10 +1545,23 @@ public class SQLSelectParser extends SQLParser { rightTableSource = this.parseTableSource(); } - if (lexer.token == Token.UNION && rightTableSource instanceof SQLSubqueryTableSource) { - SQLSelect select = ((SQLSubqueryTableSource) rightTableSource).getSelect(); - SQLSelectQuery query = queryRest(select.getQuery(), true); - select.setQuery(query); + if (lexer.token == Token.UNION + || lexer.token == Token.EXCEPT + || lexer.token == Token.MINUS + || lexer.token == Token.INTERSECT) { + if (rightTableSource instanceof SQLSubqueryTableSource) { + SQLSelect select = ((SQLSubqueryTableSource) rightTableSource).getSelect(); + SQLSelectQuery query = queryRest(select.getQuery(), true); + select.setQuery(query); + } else if (rightTableSource instanceof SQLUnionQueryTableSource) { + SQLUnionQueryTableSource unionTableSrc = (SQLUnionQueryTableSource) rightTableSource; + unionTableSrc.setUnion((SQLUnionQuery) + queryRest( + unionTableSrc.getUnion() + ) + ) + ; + } } accept(Token.RPAREN); @@ -1601,7 +1680,19 @@ public class SQLSelectParser extends SQLParser { primaryTableSourceRest(rightTableSource); } else if (rightTableSource.getAlias() == null && !(rightTableSource instanceof SQLValuesTableSource)) { - String tableAlias = this.tableAlias(false); + String tableAlias; + if (lexer.token == Token.AS) { + lexer.nextToken(); + + if (lexer.token != Token.ON) { + tableAlias = this.tableAlias(true); + } else { + tableAlias = null; + } + } else { + tableAlias = this.tableAlias(false); + } + if (tableAlias != null) { rightTableSource.setAlias(tableAlias); @@ -1672,13 +1763,14 @@ public class SQLSelectParser extends SQLParser { if (dbType == DbType.odps && lexer.identifierEquals(FnvHash.Constants.USING)) { SQLJoinTableSource.UDJ udj = new SQLJoinTableSource.UDJ(); lexer.nextToken(); - udj.setFunction(lexer.stringVal()); - accept(Token.IDENTIFIER); + udj.setFunction(this.exprParser.name()); accept(Token.LPAREN); this.exprParser.exprList(udj.getArguments(), udj); accept(Token.RPAREN); - udj.setAlias(alias()); + if (lexer.token != Token.AS) { + udj.setAlias(alias()); + } accept(Token.AS); accept(Token.LPAREN); @@ -1691,6 +1783,12 @@ public class SQLSelectParser extends SQLParser { this.exprParser.orderBy(udj.getSortBy(), udj); } + if (lexer.token == Token.WITH) { + lexer.nextToken(); + acceptIdentifier("UDFPROPERTIES"); + this.exprParser.parseAssignItem(udj.getProperties(), udj); + } + join.setUdj(udj); } } else if (lexer.token == Token.USING @@ -1848,10 +1946,20 @@ public class SQLSelectParser extends SQLParser { lexer.nextToken(); } - SQLMethodInvokeExpr udtf = (SQLMethodInvokeExpr) this.exprParser.expr(); + SQLMethodInvokeExpr udtf = (SQLMethodInvokeExpr) this.exprParser.primary(); lateralViewTabSrc.setMethod(udtf); - String alias = as(); + String alias; + if (lexer.token == Token.AS) { + lexer.nextToken(); + if (lexer.token == Token.AS) { + lexer.nextToken(); + } + + alias = alias(); + } else { + alias = as(); + } if (alias != null) { lateralViewTabSrc.setAlias(alias); } @@ -1860,6 +1968,13 @@ public class SQLSelectParser extends SQLParser { parseLateralViewAs(lateralViewTabSrc); } + if (lexer.token == Token.ON) { + lexer.nextToken(); + lateralViewTabSrc.setOn( + this.exprParser.expr() + ); + } + return parseTableSourceRest(lateralViewTabSrc); } 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 2a824a4dd7..ba7955e115 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java @@ -30,6 +30,7 @@ import com.alibaba.druid.sql.dialect.mysql.ast.MySqlKey; import com.alibaba.druid.sql.dialect.mysql.ast.statement.*; import com.alibaba.druid.sql.dialect.mysql.parser.MySqlExprParser; import com.alibaba.druid.sql.dialect.odps.ast.OdpsAlterTableSetChangeLogs; +import com.alibaba.druid.sql.dialect.odps.ast.OdpsAlterTableSetFileFormat; import com.alibaba.druid.sql.dialect.oracle.parser.OracleExprParser; import com.alibaba.druid.sql.repository.SchemaRepository; import com.alibaba.druid.util.FnvHash; @@ -564,10 +565,17 @@ public class SQLStatementParser extends SQLParser { char markChar = lexer.current(); int markBp = lexer.bp(); + int parenCount = 0; do { lexer.nextToken(); + parenCount++; } while (lexer.token == Token.LPAREN); + if (lexer.token == RPAREN && parenCount == 1 && dbType == DbType.odps) { + lexer.nextToken(); + continue; + } + if (lexer.token == Token.SELECT) { lexer.reset(markBp, markChar, Token.LPAREN); SQLStatement stmt = parseSelect(); @@ -604,8 +612,7 @@ public class SQLStatementParser extends SQLParser { // throw new ParserException("syntax error, " + lexer.token + " " // + lexer.stringVal() + ", pos " // + lexer.pos()); - //throw new ParserException("not supported." + lexer.info()); - printError(lexer.token); + throw new ParserException("not supported." + lexer.info()); } @@ -1811,93 +1818,7 @@ public class SQLStatementParser extends SQLParser { if (lexer.token == Token.DROP) { parseAlterDrop(stmt); } else if (lexer.identifierEquals(FnvHash.Constants.ADD)) { - lexer.nextToken(); - - boolean ifNotExists = false; - - if (lexer.token == Token.IF) { - lexer.nextToken(); - accept(Token.NOT); - accept(Token.EXISTS); - ifNotExists = true; - } - - if (lexer.token == Token.PRIMARY) { - SQLPrimaryKey primaryKey = this.exprParser.parsePrimaryKey(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(primaryKey); - stmt.addItem(item); - } else if (lexer.token == UNIQUE) { - SQLUnique unique = this.exprParser.parseUnique(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(unique); - stmt.addItem(item); - } else if (lexer.token == Token.IDENTIFIER) { - SQLAlterTableAddColumn item = parseAlterTableAddColumn(); - stmt.addItem(item); - } else if (lexer.token == LPAREN) { - if (dbType == DbType.h2) { - lexer.nextToken(); - SQLAlterTableAddColumn item = parseAlterTableAddColumn(); - stmt.addItem(item); - accept(RPAREN); - } - } else if (lexer.token == Token.COLUMN) { - lexer.nextToken(); - SQLAlterTableAddColumn item = parseAlterTableAddColumn(); - stmt.addItem(item); - } else if (lexer.token == Token.CHECK) { - SQLCheck check = this.exprParser.parseCheck(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(check); - stmt.addItem(item); - } else if (lexer.token == Token.CONSTRAINT) { - SQLConstraint constraint = this.exprParser.parseConstaint(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); - stmt.addItem(item); - } else if (lexer.token == Token.FOREIGN) { - SQLConstraint constraint = this.exprParser.parseForeignKey(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); - stmt.addItem(item); - } else if (lexer.token == Token.PARTITION) { - for (;;) { - lexer.nextToken(); - SQLAlterTableAddPartition addPartition = new SQLAlterTableAddPartition(); - - addPartition.setIfNotExists(ifNotExists); - - accept(Token.LPAREN); - - parseAssignItems(addPartition.getPartitions(), addPartition, false); - - accept(Token.RPAREN); - - if (lexer.identifierEquals(FnvHash.Constants.LOCATION)) { - lexer.nextToken(); - SQLExpr location = this.exprParser.primary(); - addPartition.setLocation(location); - } - - stmt.addItem(addPartition); - - if (lexer.token == Token.PARTITION) { - continue; - } - if (lexer.token == Token.COMMA) { - lexer.nextToken(); - - if(lexer.identifierEquals("ADD") || lexer.token == Token.PARTITION) { - continue; - } - } - - - break; - } - } else if (lexer.token == DEFAULT) { - SQLConstraint constraint = this.exprParser.parseConstaint(); - SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); - stmt.addItem(item); - } else { - throw new ParserException("TODO " + lexer.info()); - } + alterTableAdd(stmt); } else if (lexer.token == Token.DISABLE) { lexer.nextToken(); @@ -2002,6 +1923,13 @@ public class SQLStatementParser extends SQLParser { changeColumn.setColumn(column); stmt.addItem(changeColumn); + } else if (lexer.token == Token.NULL) { + lexer.nextToken(); + stmt.addItem( + new SQLAlterTableAddConstraint( + new SQLNullConstraint() + ) + ); } else { SQLColumnDefinition column = this.exprParser.parseColumn(); @@ -2011,8 +1939,12 @@ public class SQLStatementParser extends SQLParser { if (lexer.identifierEquals(FnvHash.Constants.AFTER)) { lexer.nextToken(); - SQLName after = this.exprParser.name(); - alterColumn.setAfter(after); + alterColumn.setAfter( + this.exprParser.name() + ); + } else if (lexer.identifierEquals(Constants.FIRST)) { + lexer.nextToken(); + alterColumn.setFirst(true); } stmt.addItem(alterColumn); @@ -2110,6 +2042,11 @@ public class SQLStatementParser extends SQLParser { OdpsAlterTableSetChangeLogs item = new OdpsAlterTableSetChangeLogs(); item.setValue(this.exprParser.primary()); stmt.addItem(item); + } else if (lexer.identifierEquals("FILEFORMAT") && dbType == DbType.odps) { + lexer.nextToken(); + OdpsAlterTableSetFileFormat item = new OdpsAlterTableSetFileFormat(); + item.setValue(this.exprParser.primary()); + stmt.addItem(item); } else { throw new ParserException("TODO " + lexer.info()); } @@ -2179,6 +2116,9 @@ public class SQLStatementParser extends SQLParser { accept(RPAREN); stmt.addItem(alterTablePartition); continue; + } else if (lexer.identifierEquals(FnvHash.Constants.ADD)) { + alterTableAdd(stmt); + continue; } } @@ -2285,8 +2225,17 @@ public class SQLStatementParser extends SQLParser { acceptIdentifier("SMALLFILES"); stmt.setMergeSmallFiles(true); } - } else if (DbType.odps == dbType && lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) { - lexer.nextToken(); + } else if (DbType.odps == dbType + && (lexer.identifierEquals(Constants.RANGE) + || lexer.identifierEquals(Constants.CLUSTERED))) + { + if (lexer.identifierEquals(Constants.RANGE)) { + lexer.nextToken(); + acceptIdentifier("CLUSTERED"); + stmt.setRange(true); + } else { + lexer.nextToken(); + } accept(Token.BY); accept(Token.LPAREN); @@ -2354,21 +2303,30 @@ public class SQLStatementParser extends SQLParser { } else if (lexer.token == Token.VIEW) { lexer.nextToken(); SQLName viewName = this.exprParser.name(); + SQLAlterViewRenameStatement stmt = new SQLAlterViewRenameStatement(); + stmt.setName(viewName); if (lexer.identifierEquals("RENAME")) { lexer.nextToken(); accept(Token.TO); - SQLAlterViewRenameStatement stmt = new SQLAlterViewRenameStatement(); - stmt.setName(viewName); - - SQLName newName = this.exprParser.name(); - - stmt.setTo(newName); - - return stmt; + stmt.setTo( + exprParser.name() + ); } - throw new ParserException("TODO " + lexer.info()); + + if (lexer.identifierEquals("CHANGEOWNER")) { + lexer.nextToken(); + accept(TO); + + stmt.setChangeOwnerTo( + exprParser.name() + ); + } + + return stmt; + } else if (lexer.identifierEquals(FnvHash.Constants.MATERIALIZED)) { + return parseAlterMaterialized(); } else if (lexer.token == Token.INDEX) { lexer.reset(mark); return parseAlterIndex(); @@ -2385,6 +2343,96 @@ public class SQLStatementParser extends SQLParser { throw new ParserException("TODO " + lexer.info()); } + private void alterTableAdd(SQLAlterTableStatement stmt) { + lexer.nextToken(); + + boolean ifNotExists = false; + + if (lexer.token == Token.IF) { + lexer.nextToken(); + accept(Token.NOT); + accept(Token.EXISTS); + ifNotExists = true; + } + + if (lexer.token == Token.PRIMARY) { + SQLPrimaryKey primaryKey = this.exprParser.parsePrimaryKey(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(primaryKey); + stmt.addItem(item); + } else if (lexer.token == UNIQUE) { + SQLUnique unique = this.exprParser.parseUnique(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(unique); + stmt.addItem(item); + } else if (lexer.token == Token.IDENTIFIER) { + SQLAlterTableAddColumn item = parseAlterTableAddColumn(); + stmt.addItem(item); + } else if (lexer.token == LPAREN) { + if (dbType == DbType.h2) { + lexer.nextToken(); + SQLAlterTableAddColumn item = parseAlterTableAddColumn(); + stmt.addItem(item); + accept(RPAREN); + } + } else if (lexer.token == Token.COLUMN) { + lexer.nextToken(); + SQLAlterTableAddColumn item = parseAlterTableAddColumn(); + stmt.addItem(item); + } else if (lexer.token == Token.CHECK) { + SQLCheck check = this.exprParser.parseCheck(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(check); + stmt.addItem(item); + } else if (lexer.token == Token.CONSTRAINT) { + SQLConstraint constraint = this.exprParser.parseConstaint(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); + stmt.addItem(item); + } else if (lexer.token == Token.FOREIGN) { + SQLConstraint constraint = this.exprParser.parseForeignKey(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); + stmt.addItem(item); + } else if (lexer.token == Token.PARTITION) { + for (;;) { + lexer.nextToken(); + SQLAlterTableAddPartition addPartition = new SQLAlterTableAddPartition(); + + addPartition.setIfNotExists(ifNotExists); + + accept(Token.LPAREN); + + parseAssignItems(addPartition.getPartitions(), addPartition, false); + + accept(Token.RPAREN); + + if (lexer.identifierEquals(Constants.LOCATION)) { + lexer.nextToken(); + SQLExpr location = this.exprParser.primary(); + addPartition.setLocation(location); + } + + stmt.addItem(addPartition); + + if (lexer.token == Token.PARTITION) { + continue; + } + if (lexer.token == Token.COMMA) { + lexer.nextToken(); + + if(lexer.identifierEquals("ADD") || lexer.token == Token.PARTITION) { + continue; + } + } + + + break; + } + } else if (lexer.token == DEFAULT) { + SQLConstraint constraint = this.exprParser.parseConstaint(); + SQLAlterTableAddConstraint item = new SQLAlterTableAddConstraint(constraint); + stmt.addItem(item); + } else { + throw new ParserException("TODO " + lexer.info()); + } + } + protected SQLStatement parseAlterDatabase() { throw new ParserException("TODO " + lexer.info()); } @@ -2448,7 +2496,7 @@ public class SQLStatementParser extends SQLParser { item.setCascade(true); } stmt.addItem(item); - } else if (lexer.token == Token.COLUMN) { + } else if (lexer.token == Token.COLUMN || lexer.identifierEquals(Constants.COLUMNS)) { lexer.nextToken(); SQLAlterTableDropColumnItem item = new SQLAlterTableDropColumnItem(); @@ -2456,7 +2504,15 @@ public class SQLStatementParser extends SQLParser { item.getColumns().add( this.exprParser.name()); } else { + boolean paren = false; + if (lexer.token == LPAREN) { + lexer.nextToken(); + paren = true; + } this.exprParser.names(item.getColumns()); + if (paren) { + accept(RPAREN); + } } if (lexer.token == Token.CASCADE) { @@ -3266,8 +3322,7 @@ public class SQLStatementParser extends SQLParser { } public SQLStatement parseCreate() { - char markChar = lexer.current(); - int markBp = lexer.bp(); + Lexer.SavePoint mark = lexer.mark(); List comments = null; if (lexer.isKeepComments() && lexer.hasComment()) { @@ -3300,7 +3355,7 @@ public class SQLStatementParser extends SQLParser { Token token = lexer.token; switch (lexer.token) { case TABLE: { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); SQLCreateTableParser createTableParser = getSQLCreateTableParser(); SQLCreateTableStatement stmt = createTableParser.parseCreateTable(); @@ -3331,11 +3386,11 @@ public class SQLStatementParser extends SQLParser { case DATABASE: { lexer.nextToken(); if (lexer.identifierEquals("LINK")) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateDbLink(); } - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); SQLStatement stmt = parseCreateDatabase(); if (comments != null) { @@ -3348,11 +3403,11 @@ public class SQLStatementParser extends SQLParser { case SCHEMA: { lexer.nextToken(); if (lexer.identifierEquals("LINK")) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateDbLink(); } - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); SQLStatement stmt = parseCreateSchema(); if (comments != null) { @@ -3363,10 +3418,10 @@ public class SQLStatementParser extends SQLParser { return stmt; } case USER: - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateUser(); case FUNCTION: { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); SQLStatement createFunct = this.parseCreateFunction(); SQLStatement stmt = createFunct; return stmt; @@ -3380,42 +3435,42 @@ public class SQLStatementParser extends SQLParser { lexer.nextToken(); } if (lexer.token == Token.PROCEDURE) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateProcedure(); } if (lexer.token == Token.VIEW) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateView(); } if (lexer.token == Token.TRIGGER) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateTrigger(); } - if (lexer.token == Token.FUNCTION) { - lexer.reset(markBp, markChar, Token.CREATE); + if (lexer.token == Token.FUNCTION || lexer.identifierEquals(Constants.SQL)) { + lexer.reset(mark); return parseCreateFunction(); } if (lexer.identifierEquals(FnvHash.Constants.PACKAGE)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreatePackage(); } if (lexer.identifierEquals(FnvHash.Constants.TYPE)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateType(); } if (lexer.identifierEquals(FnvHash.Constants.PUBLIC)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateSynonym(); } if (lexer.identifierEquals(FnvHash.Constants.SYNONYM)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateSynonym(); } @@ -3424,38 +3479,38 @@ public class SQLStatementParser extends SQLParser { } else if (lexer.identifierEquals(FnvHash.Constants.PUBLIC)) { lexer.nextToken(); if (lexer.identifierEquals("SYNONYM")) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateSynonym(); } else { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateDbLink(); } } else if (lexer.identifierEquals("SHARE")) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateDbLink(); } else if (lexer.identifierEquals("SYNONYM")) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateSynonym(); } else if (token == Token.VIEW) { return parseCreateView(); } else if (token == Token.TRIGGER) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateTrigger(); } else if (token == Token.PROCEDURE) { SQLCreateProcedureStatement stmt = parseCreateProcedure(); stmt.setCreate(true); return stmt; } else if (lexer.identifierEquals(FnvHash.Constants.BITMAP)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateIndex(true); } else if (lexer.identifierEquals(FnvHash.Constants.MATERIALIZED)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateMaterializedView(); } else if (lexer.identifierEquals(FnvHash.Constants.TYPE)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateType(); } else if (lexer.identifierEquals(FnvHash.Constants.EXTERNAL)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); SQLCreateTableStatement createTable = parseCreateTable(); if (comments != null) { createTable.addBeforeComment(comments); @@ -3463,22 +3518,22 @@ public class SQLStatementParser extends SQLParser { } return createTable; } else if (lexer.identifierEquals(FnvHash.Constants.TABLEGROUP)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateTableGroup(); } else if (lexer.identifierEquals(FnvHash.Constants.SQL) && dbType == DbType.odps) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateFunction(); } else if (lexer.identifierEquals(FnvHash.Constants.DIMENSION)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateTable(); } else if (lexer.identifierEquals(FnvHash.Constants.ROLE)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateRole(); } else if (lexer.identifierEquals(Constants.RESOURCE)) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateResourceGroup(); } else if (lexer.token() == FOREIGN) { - lexer.reset(markBp, markChar, Token.CREATE); + lexer.reset(mark); return parseCreateTable(); } @@ -3553,6 +3608,14 @@ public class SQLStatementParser extends SQLParser { accept(Token.VIEW); SQLCreateMaterializedViewStatement stmt = new SQLCreateMaterializedViewStatement(); + + if (lexer.token == IF) { + lexer.nextToken(); + accept(Token.NOT); + accept(EXISTS); + stmt.setIfNotExists(true); + } + stmt.setName(this.exprParser.name()); if (this.dbType == DbType.mysql) { @@ -3708,6 +3771,21 @@ public class SQLStatementParser extends SQLParser { } break; } + } else if (dbType == DbType.odps) { + if (lexer.identifierEquals(Constants.LIFECYCLE)) { + lexer.nextToken(); + stmt.setLifyCycle( + this.exprParser.primary() + ); + } + + if (lexer.token == Token.PARTITIONED) { + lexer.nextToken(); + accept(ON); + accept(LPAREN); + this.exprParser.names(stmt.getPartitionedOn(), stmt); + accept(RPAREN); + } } else { if (lexer.token == Token.PARTITION) { SQLPartitionBy partitionBy = this.exprParser.parsePartitionBy(); @@ -4286,6 +4364,10 @@ public class SQLStatementParser extends SQLParser { protected void parseUpdateSet(SQLUpdateStatement update) { accept(Token.SET); + if (lexer.token == COMMA && dbType == DbType.odps) { + lexer.nextToken(); + } + for (;;) { SQLUpdateSetItem item = this.exprParser.parseUpdateSetItem(); update.addItem(item); @@ -5060,6 +5142,13 @@ public class SQLStatementParser extends SQLParser { } accept(Token.THEN); + if (lexer.token == DELETE) { + lexer.nextToken(); + updateClause.setDelete(true); + stmt.setUpdateClause(updateClause); + break; + } + accept(Token.UPDATE); accept(Token.SET); @@ -5147,6 +5236,14 @@ public class SQLStatementParser extends SQLParser { } else { accept(Token.MATCHED); } + + if (lexer.token == AND) { // odps + lexer.nextToken(); + insertClause.setWhere( + this.exprParser.expr() + ); + } + accept(Token.THEN); accept(Token.INSERT); @@ -5304,9 +5401,29 @@ public class SQLStatementParser extends SQLParser { if (lexer.token == Token.LPAREN) { lexer.nextToken(); - if (lexer.token != RPAREN) { - exprParser.names(entry.getColumns()); + + for (;;) { + if (lexer.token == RPAREN) { + break; + } + + SQLName name = exprParser.name(); + if (dbType == DbType.odps) { + if (lexer.identifierEquals(Constants.STRING) + || lexer.identifierEquals(Constants.INT) + || lexer.identifierEquals(Constants.BIGINT) + ) { + lexer.nextToken(); // skip + } + } + name.setParent(entry); + entry.getColumns().add(name); + if (lexer.token == COMMA) { + lexer.nextToken(); + continue; + } } + accept(Token.RPAREN); } @@ -6346,14 +6463,23 @@ public class SQLStatementParser extends SQLParser { } if (!columnsParsed && lexer.token == Token.LPAREN) { - Lexer.SavePoint savePoint = lexer.mark(); + Lexer.SavePoint m1 = lexer.mark(); lexer.nextToken(); - if (lexer.token != SELECT) { + boolean select; + if (lexer.token == LPAREN) { + Lexer.SavePoint m2 = lexer.mark(); + lexer.nextToken(); + select = lexer.token == SELECT; + lexer.reset(m2); + } else { + select = lexer.token == SELECT; + } + if (!select) { parseInsertColumns(insert); accept(Token.RPAREN); } else { - lexer.reset(savePoint); + lexer.reset(m1); } } @@ -6677,6 +6803,12 @@ public class SQLStatementParser extends SQLParser { lexer.nextToken(); acceptIdentifier("COLUMNS"); stmt.setForColums(true); + + if (lexer.token == LPAREN) { + lexer.nextToken(); + this.exprParser.names(stmt.getColumns(), stmt); + accept(RPAREN); + } } if (lexer.identifierEquals(FnvHash.Constants.CACHE)) { @@ -6929,7 +7061,10 @@ public class SQLStatementParser extends SQLParser { SQLAlterMaterializedViewStatement stmt = new SQLAlterMaterializedViewStatement(); stmt.setDbType(dbType); - accept(ALTER); + if (lexer.token == ALTER) { + lexer.nextToken(); + } + acceptIdentifier("MATERIALIZED"); accept(Token.VIEW); @@ -7000,6 +7135,10 @@ public class SQLStatementParser extends SQLParser { if (!refresh) { throw new ParserException("refresh clause is empty. " + lexer.info()); } + } else if (lexer.identifierEquals("REBUILD")) { + lexer.nextToken(); + stmt.setRebuild(true); + continue; } else { break; } @@ -7022,6 +7161,13 @@ public class SQLStatementParser extends SQLParser { stmt.setEnableQueryRewrite(enableQueryRewrite); } + if (lexer.token == PARTITION) { + lexer.nextToken(); + accept(LPAREN); + this.exprParser.exprList(stmt.getPartitions(), stmt); + accept(RPAREN); + } + return stmt; } @@ -7033,6 +7179,12 @@ public class SQLStatementParser extends SQLParser { lexer.nextToken(); } + if (lexer.token == OR) { + lexer.nextToken(); + accept(REPLACE); + stmt.setOrReplace(true); + } + if (lexer.identifierEquals(FnvHash.Constants.TEMPORARY)) { lexer.nextToken(); stmt.setTemporary(true); @@ -7046,6 +7198,13 @@ public class SQLStatementParser extends SQLParser { accept(Token.FUNCTION); + if (lexer.token == IF) { + lexer.nextToken(); + accept(NOT); + accept(EXISTS); + stmt.setIfNotExists(true); + } + SQLName name = this.exprParser.name(); stmt.setName(name); @@ -7073,6 +7232,12 @@ public class SQLStatementParser extends SQLParser { stmt.setReturnDataType(returnDataType); } + if (lexer.token == IDENTIFIER && lexer.stringVal().toUpperCase().startsWith("RETURNS@")) { + lexer.nextToken(); + SQLDataType returnDataType = this.exprParser.parseDataType(); + stmt.setReturnDataType(returnDataType); + } + if (lexer.token() == Token.AS) { lexer.setToken(Token.IDENTIFIER); lexer.nextToken(); @@ -7141,6 +7306,25 @@ public class SQLStatementParser extends SQLParser { return stmt; } + + public SQLShowVariantsStatement parseShowVariants() { + SQLShowVariantsStatement stmt = new SQLShowVariantsStatement(); + + if (lexer.token() == Token.LIKE) { + lexer.nextToken(); + SQLExpr like = exprParser.expr(); + stmt.setLike(like); + } + + if (lexer.token() == Token.WHERE) { + lexer.nextToken(); + SQLExpr where = exprParser.expr(); + stmt.setWhere(where); + } + + return stmt; + } + public SQLStatement parseClone() { throw new ParserException("TODO " + lexer.info()); } 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 522982f156..4d23ea5b25 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java @@ -4090,7 +4090,7 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet public boolean visit(SQLJoinTableSource.UDJ x) { print0(ucase ? "USING " : "using "); - print0(x.getFunction()); + x.getFunction().accept(this); print('('); printAndAccept(x.getArguments(), ", "); print0(") "); @@ -4098,6 +4098,13 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet print0(ucase ? " AS (" : " as ("); printAndAccept(x.getColumns(), ", "); print0(")"); + + List properties = x.getProperties(); + if (!properties.isEmpty()) { + print0(ucase ? " WITH UDFPROPERTIES (" : " with udfproperties ("); + printAndAccept(properties, ", "); + print(')'); + } return false; } @@ -5162,6 +5169,10 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet print0(ucase ? beginBound.name : beginBound.name_lower); } } + + if (x.isExcludeCurrentRow()) { + print0(ucase ? " EXCLUDE CURRENT ROW" : " exclude current row"); + } print(')'); return false; @@ -5351,6 +5362,10 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet after.accept(this); } + if (x.isFirst()) { + print0(ucase ? " FIRST" : " first"); + } + return false; } @@ -5514,6 +5529,9 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet List clusteredBy = x.getClusteredBy(); if (clusteredBy.size() > 0) { println(); + if (x.isRange()) { + print0(ucase ? "RANGE " : "range "); + } print0(ucase ? "CLUSTERED BY (" : "clustered by ("); printAndAccept(clusteredBy, ","); print0(")"); @@ -6485,8 +6503,18 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet public boolean visit(SQLAlterViewRenameStatement x) { print0(ucase ? "ALTER VIEW " : "alter view "); x.getName().accept(this); - print0(ucase ? " RENAME TO " : " rename to "); - x.getTo().accept(this); + + SQLName to = x.getTo(); + if (to != null) { + print0(ucase ? " RENAME TO " : " rename to "); + printExpr(to); + } + + SQLName changeOwnerTo = x.getChangeOwnerTo(); + if (to != null) { + print0(ucase ? " CHANGEOWNER TO " : " changeowner to "); + printExpr(changeOwnerTo); + } return false; } @@ -7709,6 +7737,10 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet @Override public boolean visit(MergeUpdateClause x) { + if (x.isDelete()) { + print0(ucase ? "WHEN MATCHED THEN DELETE" : "when matched then delete"); + return false; + } print0(ucase ? "WHEN MATCHED THEN UPDATE SET " : "when matched then update set "); printAndAccept(x.getItems(), ", "); @@ -8440,6 +8472,17 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet } } + if (x.isRebuild()) { + print0(ucase ? " REBUILD" : " rebuild"); + } + + List partitions = x.getPartitions(); + if (!partitions.isEmpty()) { + print0(ucase ? "PARTITIONS (" : "partitions ("); + printAndAccept(partitions, ", "); + print(')'); + } + return false; } @@ -8731,6 +8774,14 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet print0(ucase ? " AS " : " as "); printAndAccept(x.getColumns(), ", "); } + + SQLExpr on = x.getOn(); + if (on != null) { + println(); + print0(ucase ? "ON " : "on "); + printExpr(on); + } + this.indentCount--; return false; } 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 0a342e11d5..b431007129 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java @@ -22,10 +22,7 @@ import com.alibaba.druid.sql.ast.expr.*; import com.alibaba.druid.sql.ast.statement.*; import com.alibaba.druid.sql.dialect.hive.ast.HiveInputOutputFormat; import com.alibaba.druid.sql.dialect.hive.stmt.HiveCreateTableStatement; -import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlKillStatement; -import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLAlterResourceGroupStatement; -import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLCreateResourceGroupStatement; -import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLListResourceGroupStatement; +import com.alibaba.druid.sql.dialect.mysql.ast.statement.*; public interface SQLASTVisitor { @@ -2684,6 +2681,14 @@ public interface SQLASTVisitor { return true; } + default void endVisit(SQLShowRoleStatement x) { + + } + + default boolean visit(SQLShowRoleStatement x) { + return true; + } + default void endVisit(SQLShowRolesStatement x) { } @@ -2692,4 +2697,20 @@ public interface SQLASTVisitor { return true; } + default boolean visit(SQLShowVariantsStatement x) { + return true; + } + + default void endVisit(SQLShowVariantsStatement x) { + + } + + default boolean visit(SQLShowACLStatement x) { + return true; + } + + default void endVisit(SQLShowACLStatement x) { + + } + } 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 35d07cf301..7dca1113e1 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java @@ -3071,7 +3071,12 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter { public boolean visit(SQLAnalyzeTableStatement x) { for (SQLExprTableSource table : x.getTables()) { - table.accept(this); + if (table != null) { + TableStat stat = getTableStat(table.getName()); + if (stat != null) { + stat.incrementAnalyzeCount(); + } + } } SQLExprTableSource table = x.getTables().size() == 1 ? x.getTables().get(0) : null; @@ -3189,6 +3194,25 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter { return false; } + @Override + public boolean visit(SQLCloneTableStatement x) { + SQLExprTableSource from = x.getFrom(); + if (from != null) { + TableStat stat = getTableStat(from.getName()); + if (stat != null) { + stat.incrementSelectCount(); + } + } + + SQLExprTableSource to = x.getTo(); + if (to != null) { + TableStat stat = getTableStat(to.getName()); + if (stat != null) { + stat.incrementInsertCount(); + } + } + return false; + } @Override public boolean visit(SQLSyncMetaStatement x) { diff --git a/src/main/java/com/alibaba/druid/stat/TableStat.java b/src/main/java/com/alibaba/druid/stat/TableStat.java index eb2543e407..99643c880b 100644 --- a/src/main/java/com/alibaba/druid/stat/TableStat.java +++ b/src/main/java/com/alibaba/druid/stat/TableStat.java @@ -40,7 +40,8 @@ public class TableStat { int dropIndexCount = 0; int referencedCount = 0; int addCount = 0; // odps add table - int addPartitionCount= 0; // odps add table + int addPartitionCount= 0; // odps add partition + int analyzeCount = 0; // odps analyze table public TableStat() { @@ -170,6 +171,14 @@ public class TableStat { this.insertCount = insertCount; } + public int getAnalyzeCount() { + return analyzeCount; + } + + public void incrementAnalyzeCount() { + this.analyzeCount++; + } + public String toString() { StringBuilder buf = new StringBuilder(4); if (mergeCount > 0) { @@ -208,6 +217,9 @@ public class TableStat { if (addPartitionCount > 0) { buf.append("AddPartition"); } + if (analyzeCount > 0) { + buf.append("Analyze"); + } return buf.toString(); } diff --git a/src/main/java/com/alibaba/druid/util/FnvHash.java b/src/main/java/com/alibaba/druid/util/FnvHash.java index 99a7072736..6b8718d735 100644 --- a/src/main/java/com/alibaba/druid/util/FnvHash.java +++ b/src/main/java/com/alibaba/druid/util/FnvHash.java @@ -938,6 +938,7 @@ public final class FnvHash { long ALWAYS = fnv1a_64_lower("ALWAYS"); long VISIBLE = fnv1a_64_lower("VISIBLE"); long INCLUDING = fnv1a_64_lower("INCLUDING"); + long EXCLUDE = fnv1a_64_lower("EXCLUDE"); long EXCLUDING = fnv1a_64_lower("EXCLUDING"); long ROUTINE = fnv1a_64_lower("ROUTINE"); long IDENTIFIED = fnv1a_64_lower("IDENTIFIED");