diff --git a/src/main/java/com/alibaba/druid/sql/ast/AutoIncrementType.java b/src/main/java/com/alibaba/druid/sql/ast/AutoIncrementType.java new file mode 100644 index 0000000000..c2aff5effa --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/AutoIncrementType.java @@ -0,0 +1,19 @@ +package com.alibaba.druid.sql.ast; + +public enum AutoIncrementType +{ + GROUP("GROUP"), SIMPLE("SIMPLE"), + SIMPLE_CACHE("SIMPLE WITH CACHE"), TIME("TIME"); + + private final String keyword; + + public String getKeyword() { + return this.keyword; + } + + private AutoIncrementType(String keyword){ + this.keyword = keyword; + } + + +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLAdhocTableSource.java b/src/main/java/com/alibaba/druid/sql/ast/SQLAdhocTableSource.java new file mode 100644 index 0000000000..65fcb3e326 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLAdhocTableSource.java @@ -0,0 +1,35 @@ +package com.alibaba.druid.sql.ast; + +import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement; +import com.alibaba.druid.sql.ast.statement.SQLTableSourceImpl; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLAdhocTableSource + extends SQLTableSourceImpl { + private SQLCreateTableStatement definition; + + public SQLAdhocTableSource(SQLCreateTableStatement definition) { + setDefinition(definition); + } + + @Override + protected void accept0(SQLASTVisitor v) { + if (v.visit(this)) { + if (definition != null) { + definition.accept(v); + } + } + v.endVisit(this); + } + + public SQLCreateTableStatement getDefinition() { + return definition; + } + + public void setDefinition(SQLCreateTableStatement x) { + if (x != null) { + x.setParent(this); + } + this.definition = x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentTimeExpr.java b/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentTimeExpr.java new file mode 100644 index 0000000000..dcec3ae025 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentTimeExpr.java @@ -0,0 +1,66 @@ +package com.alibaba.druid.sql.ast; + +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLCurrentTimeExpr + extends SQLExprImpl { + private final Type type; + + public SQLCurrentTimeExpr(Type type) { + if (type == null) { + throw new NullPointerException(); + } + + this.type = type; + } + + @Override + protected void accept0(SQLASTVisitor v) { + v.visit(this); + v.endVisit(this); + } + + public Type getType() { + return type; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (getClass() != o.getClass()) return false; + + SQLCurrentTimeExpr that = (SQLCurrentTimeExpr) o; + + return type == that.type; + } + + @Override + public int hashCode() { + return type.hashCode(); + } + + public SQLCurrentTimeExpr clone() { + return new SQLCurrentTimeExpr(type); + } + + public static enum Type { + CURRENT_TIME("CURRENT_TIME"), + CURRENT_DATE("CURRENT_DATE"), + CURDATE("CURDATE"), + CURTIME("CURTIME"), + CURRENT_TIMESTAMP("CURRENT_TIMESTAMP"), + LOCALTIME("LOCALTIME"), + LOCALTIMESTAMP("LOCALTIMESTAMP"), + SYSDATE("SYSDATE"), + ; + + public final String name; + public final String name_lower; + + Type(String name) + { + this.name = name; + this.name_lower = name.toLowerCase(); + } + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentUserExpr.java b/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentUserExpr.java new file mode 100644 index 0000000000..e5816ae067 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLCurrentUserExpr.java @@ -0,0 +1,38 @@ +package com.alibaba.druid.sql.ast; + +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLCurrentUserExpr + extends SQLExprImpl { + + public SQLCurrentUserExpr() { + } + + @Override + protected void accept0(SQLASTVisitor v) { + v.visit(this); + v.endVisit(this); + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + + if (this == o) { + return true; + } + + return getClass() == o.getClass(); + } + + @Override + public int hashCode() { + return 0; + } + + public SQLCurrentUserExpr clone() { + return new SQLCurrentUserExpr(); + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLPartitionBy.java b/src/main/java/com/alibaba/druid/sql/ast/SQLPartitionBy.java index 69b5759c2b..0aeff32e51 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLPartitionBy.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLPartitionBy.java @@ -15,6 +15,8 @@ */ package com.alibaba.druid.sql.ast; +import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; + import java.util.ArrayList; import java.util.List; @@ -102,5 +104,20 @@ public abstract class SQLPartitionBy extends SQLObjectImpl { } } + public boolean isPartitionByColumn(long columnNameHashCode64) { + for (SQLExpr column : columns) { + if (column instanceof SQLIdentifierExpr + && ((SQLIdentifierExpr) column) + .nameHashCode64() == columnNameHashCode64) { + return true; + } + } + + if (subPartitionBy != null) { + return subPartitionBy.isPartitionByColumn(columnNameHashCode64); + } + return false; + } + public abstract SQLPartitionBy clone(); } diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionBy.java b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionBy.java index b3c60d2648..f579d07f01 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionBy.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionBy.java @@ -73,5 +73,9 @@ public abstract class SQLSubPartitionBy extends SQLObjectImpl { } } + public boolean isPartitionByColumn(long columnNameHashCode64) { + return false; + } + public abstract SQLSubPartitionBy clone(); } diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByHash.java b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByHash.java index 367fca69a6..cdec8566e0 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByHash.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByHash.java @@ -61,4 +61,8 @@ public class SQLSubPartitionByHash extends SQLSubPartitionBy { return x; } + public boolean isPartitionByColumn(long columnNameHashCode64) { + return expr instanceof SQLName + && ((SQLName) expr).nameHashCode64() == columnNameHashCode64; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByList.java b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByList.java index 9d113b2601..ad9de2a1ef 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByList.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByList.java @@ -48,4 +48,9 @@ public class SQLSubPartitionByList extends SQLSubPartitionBy { } return x; } + + public boolean isPartitionByColumn(long columnNameHashCode64) { + return column != null + && column.nameHashCode64() == columnNameHashCode64; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByRange.java b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByRange.java index 8a0b4be7dd..f97b3723ea 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByRange.java +++ b/src/main/java/com/alibaba/druid/sql/ast/SQLSubPartitionByRange.java @@ -18,6 +18,7 @@ package com.alibaba.druid.sql.ast; import java.util.ArrayList; import java.util.List; +import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class SQLSubPartitionByRange extends SQLSubPartitionBy { @@ -43,4 +44,14 @@ public class SQLSubPartitionByRange extends SQLSubPartitionBy { return x; } + + public boolean isPartitionByColumn(long columnNameHashCode64) { + for (SQLExpr column : columns) { + if (column instanceof SQLIdentifierExpr + && ((SQLIdentifierExpr) column).nameHashCode64() == columnNameHashCode64) { + return true; + } + } + return false; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDecimalExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDecimalExpr.java new file mode 100644 index 0000000000..dc0d46ae3b --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLDecimalExpr.java @@ -0,0 +1,125 @@ +/* + * 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.expr; + +import com.alibaba.druid.sql.ast.SQLDataType; +import com.alibaba.druid.sql.ast.SQLDataTypeImpl; +import com.alibaba.druid.sql.ast.SQLObject; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.math.BigDecimal; +import java.util.Collections; +import java.util.List; + +public class SQLDecimalExpr + extends SQLNumericLiteralExpr implements SQLValuableExpr, Comparable +{ + public final static SQLDataType DATA_TYPE = new SQLDataTypeImpl("DECIMAL"); + + private BigDecimal value; + private transient String literal; + + public SQLDecimalExpr(){ + + } + + public SQLDecimalExpr(BigDecimal value){ + super(); + this.value = value; + } + + public SQLDecimalExpr(String value){ + super(); + this.value = new BigDecimal(value); + this.literal = value; + } + + public String getLiteral() { + return literal; + } + + public SQLDecimalExpr clone() { + return new SQLDecimalExpr(value); + } + + @Override + public List getChildren() { + return Collections.emptyList(); + } + + @Override + public Number getNumber() { + return value; + } + + public BigDecimal getValue() { + return value; + } + + public void setValue(BigDecimal value) { + this.value = value; + } + + protected void accept0(SQLASTVisitor visitor) { + visitor.visit(this); + + visitor.endVisit(this); + } + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((value == null) ? 0 : value.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + SQLDecimalExpr other = (SQLDecimalExpr) obj; + if (value == null) { + if (other.value != null) { + return false; + } + } else if (!value.equals(other.value)) { + return false; + } + return true; + } + + @Override + public void setNumber(Number number) { + if (number == null) { + this.setValue(null); + return; + } + + this.setValue(((BigDecimal) number)); + } + + @Override + public int compareTo(SQLDecimalExpr o) { + return value.compareTo(o.value); + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLIntervalUnit.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLIntervalUnit.java index f63f9289a0..ebb226f612 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLIntervalUnit.java +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLIntervalUnit.java @@ -1,5 +1,5 @@ /* - * Copyright 1999-2018 Alibaba Group Holding Ltd. + * 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. @@ -15,24 +15,95 @@ */ package com.alibaba.druid.sql.ast.expr; +import java.util.Calendar; +import java.util.Date; + public enum SQLIntervalUnit { - YEAR, YEAR_MONTH, - + YEAR, + YEAR_MONTH, QUARTER, + MONTH, + WEEK, + DAY, + DAY_HOUR, + DAY_MINUTE, + DAY_SECOND, + DAY_MICROSECOND, + HOUR, + HOUR_MINUTE, + HOUR_SECOND, + HOUR_MICROSECOND, + MINUTE, + MINUTE_SECOND, + MINUTE_MICROSECOND, + SECOND, + SECOND_MICROSECOND, + MICROSECOND, + DAY_OF_WEEK, + DOW, + DAY_OF_MONTH, + DAY_OF_YEAR, + YEAR_OF_WEEK, + YOW, + TIMEZONE_HOUR, + TIMEZONE_MINUTE, + DOY, + YEAR_TO_MONTH("YEAR TO MONTH") + ; - MONTH, WEEK, DAY, DAY_HOUR, DAY_MINUTE, DAY_SECOND, DAY_MICROSECOND, - - HOUR, HOUR_MINUTE, HOUR_SECOND, HOUR_MICROSECOND, - - MINUTE, MINUTE_SECOND, MINUTE_MICROSECOND, - - SECOND, SECOND_MICROSECOND, - - MICROSECOND; - + public final String name; public final String name_lcase; - - private SQLIntervalUnit() { - this.name_lcase = name().toLowerCase(); + + SQLIntervalUnit(String name) { + this.name = name; + this.name_lcase = name.toLowerCase(); + } + + SQLIntervalUnit() { + this.name = name(); + this.name_lcase = name.toLowerCase(); + } + + public static boolean add(Calendar calendar, int intervalInt, SQLIntervalUnit unit) { + switch (unit) { + case YEAR: + calendar.add(Calendar.YEAR, intervalInt); + return true; + case MONTH: + calendar.add(Calendar.MONTH, intervalInt); + return true; + case WEEK: + calendar.add(Calendar.WEEK_OF_MONTH, intervalInt); + return true; + case DAY: + calendar.add(Calendar.DAY_OF_MONTH, intervalInt); + return true; + case HOUR: + calendar.add(Calendar.HOUR_OF_DAY, intervalInt); + return true; + case MINUTE: + calendar.add(Calendar.MINUTE, intervalInt); + return true; + case SECOND: + calendar.add(Calendar.SECOND, intervalInt); + return true; + case MICROSECOND: + calendar.add(Calendar.MILLISECOND, intervalInt); + return true; + default: + return false; + } + } + + public boolean isDateTime() { + switch (this) { + case HOUR: + case MINUTE: + case SECOND: + case MICROSECOND: + return true; + default: + return false; + } } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/expr/SQLSizeExpr.java b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLSizeExpr.java new file mode 100644 index 0000000000..47c74aef10 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/expr/SQLSizeExpr.java @@ -0,0 +1,114 @@ +/* + * 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.expr; + +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLExprImpl; +import com.alibaba.druid.sql.ast.SQLObject; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.math.BigDecimal; +import java.util.Collections; +import java.util.List; + +public class SQLSizeExpr + extends SQLExprImpl { + + private SQLExpr value; + private Unit unit; + + public SQLSizeExpr(){ + + } + + public SQLSizeExpr(String value, char unit){ + this.unit = Unit.valueOf(Character.toString(unit).toUpperCase()); + if (value.indexOf('.') == -1) { + this.value = new SQLIntegerExpr(Integer.parseInt(value)); + } else { + this.value = new SQLNumberExpr(new BigDecimal(value)); + } + } + + public SQLSizeExpr(SQLExpr value, Unit unit){ + super(); + this.value = value; + this.unit = unit; + } + + @Override + public void accept0(SQLASTVisitor visitor) { + if (visitor.visit(this)) { + if (this.value != null) { + this.value.accept(visitor); + } + } + visitor.endVisit(this); + } + + public List getChildren() { + return Collections.singletonList(value); + } + + public SQLExpr getValue() { + return value; + } + + public void setValue(SQLExpr value) { + this.value = value; + } + + public Unit getUnit() { + return unit; + } + + public void setUnit(Unit unit) { + this.unit = unit; + } + + public static enum Unit { + B, K, M, G, T, P, E + } + + public SQLSizeExpr clone() { + SQLSizeExpr x = new SQLSizeExpr(); + + if (value != null) { + x.setValue(value.clone()); + } + x.unit = unit; + + return x; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SQLSizeExpr that = (SQLSizeExpr) o; + + if (value != null ? !value.equals(that.value) : that.value != null) return false; + return unit == that.unit; + } + + @Override + public int hashCode() { + int result = value != null ? value.hashCode() : 0; + result = 31 * result + (unit != null ? unit.hashCode() : 0); + return result; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLColumnDefinition.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLColumnDefinition.java index aec8b980cf..ca0fb7652c 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLColumnDefinition.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLColumnDefinition.java @@ -1,5 +1,5 @@ /* - * Copyright 1999-2018 Alibaba Group Holding Ltd. + * 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. @@ -15,22 +15,18 @@ */ package com.alibaba.druid.sql.ast.statement; -import java.util.ArrayList; -import java.util.List; - import com.alibaba.druid.sql.SQLUtils; -import com.alibaba.druid.sql.ast.SQLDataType; -import com.alibaba.druid.sql.ast.SQLExpr; -import com.alibaba.druid.sql.ast.SQLName; -import com.alibaba.druid.sql.ast.SQLObjectImpl; -import com.alibaba.druid.sql.ast.SQLObjectWithDataType; -import com.alibaba.druid.sql.ast.SQLReplaceable; +import com.alibaba.druid.sql.ast.*; import com.alibaba.druid.sql.ast.expr.SQLCharExpr; import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; import com.alibaba.druid.sql.visitor.SQLASTVisitor; -public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElement, SQLObjectWithDataType, SQLReplaceable { +import java.sql.Types; +import java.util.ArrayList; +import java.util.List; + +public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElement, SQLObjectWithDataType, SQLReplaceable, SQLDbTypedObject { protected String dbType; protected SQLName name; @@ -46,14 +42,37 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen // for mysql protected boolean autoIncrement = false; protected SQLExpr onUpdate; + protected SQLExpr format; protected SQLExpr storage; protected SQLExpr charsetExpr; + protected SQLExpr collateExpr; protected SQLExpr asExpr; protected boolean stored = false; protected boolean virtual = false; + protected boolean visible = false; + protected AutoIncrementType sequenceType; + protected boolean preSort = false; // for ads + protected int preSortOrder = 0; // for ads protected Identity identity; + + // for ads protected SQLExpr generatedAlawsAs; + protected SQLExpr delimiter; // for ads + protected SQLExpr delimiterTokenizer; // for ads3.0 multivalue + protected SQLExpr nlpTokenizer; // for ads3.0 multivalue + protected SQLExpr valueType; // for ads3.0 multivalue + protected boolean disableIndex = false; //for ads + protected SQLExpr jsonIndexAttrsExpr; // for ads + private SQLExpr unitCount; + private SQLExpr unitIndex; + private SQLExpr step; + private SQLCharExpr encode; + private SQLCharExpr compression; + + // for aliyun data lake anlytics + private List mappedBy; + private List colProperties; public SQLColumnDefinition(){ @@ -64,22 +83,11 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen } // for sqlserver - public void setIdentity(Identity x) { - if (x != null) { - x.setParent(this); + public void setIdentity(Identity identity) { + if (identity != null) { + identity.setParent(this); } - this.identity = x; - } - - public SQLExpr getGeneratedAlawsAs() { - return generatedAlawsAs; - } - - public void setGeneratedAlawsAs(SQLExpr x) { - if (x != null) { - x.setParent(this); - } - this.generatedAlawsAs = x; + this.identity = identity; } public Boolean getEnable() { @@ -110,6 +118,14 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen return name; } + public String getColumnName() { + if (name == null) { + return null; + } + + return name.getSimpleName(); + } + public long nameHashCode64() { if (name == null) { return 0; @@ -137,6 +153,14 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen public SQLDataType getDataType() { return dataType; } +// +// public int jdbcType() { +// if (dataType == null) { +// return Types.OTHER; +// } +// +// return dataType.jdbcType(); +// } public void setDataType(SQLDataType dataType) { if (dataType != null) { @@ -159,7 +183,58 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen public List getConstraints() { return constraints; } - + + public boolean isPrimaryKey() { + for (SQLColumnConstraint constraint : constraints) { + if (constraint instanceof SQLColumnPrimaryKey) { + return true; + } + } + + if (parent instanceof SQLCreateTableStatement) { + return ((SQLCreateTableStatement) parent) + .isPrimaryColumn( + nameHashCode64()); + } + + return false; + } + + public boolean isOnlyPrimaryKey() { + for (SQLColumnConstraint constraint : constraints) { + if (constraint instanceof SQLColumnPrimaryKey) { + return true; + } + } + + if (parent instanceof SQLCreateTableStatement) { + return ((SQLCreateTableStatement) parent) + .isPrimaryColumn( + nameHashCode64()); + } + + return false; + } + + public boolean isPartitionBy() { + if (!(parent instanceof SQLCreateTableStatement)) { + return false; + } + + SQLCreateTableStatement stmt = (SQLCreateTableStatement) parent; + final SQLPartitionBy partitioning = stmt.getPartitioning(); + if (partitioning == null) { + return false; + } + + if (name == null) { + return false; + } + + return partitioning.isPartitionByColumn( + nameHashCode64()); + } + public void addConstraint(SQLColumnConstraint constraint) { if (constraint != null) { constraint.setParent(this); @@ -167,17 +242,6 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen this.constraints.add(constraint); } - @Override - public void output(StringBuffer buf) { - name.output(buf); - buf.append(' '); - this.dataType.output(buf); - if (defaultExpr != null) { - buf.append(" DEFAULT "); - this.defaultExpr.output(buf); - } - } - @Override protected void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { @@ -194,7 +258,13 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen } public void setComment(String comment) { - this.setComment(new SQLCharExpr(comment)); + SQLCharExpr expr; + if (comment == null) { + expr = null; + } else { + expr = new SQLCharExpr(comment); + } + this.setComment(expr); } public void setComment(SQLExpr comment) { @@ -231,6 +301,17 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen this.charsetExpr = charsetExpr; } + public SQLExpr getCollateExpr() { + return collateExpr; + } + + public void setCollateExpr(SQLExpr x) { + if (charsetExpr != null) { + charsetExpr.setParent(this); + } + this.collateExpr = x; + } + public SQLExpr getAsExpr() { return asExpr; } @@ -258,6 +339,14 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen this.onUpdate = onUpdate; } + public SQLExpr getFormat() { + return format; + } + + public void setFormat(SQLExpr format) { + this.format = format; + } + public SQLExpr getStorage() { return storage; } @@ -278,15 +367,31 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen return true; } + if (comment == expr) { + setComment(target); + return true; + } + return false; } + public void setUnitCount(SQLExpr unitCount) { + if (unitCount != null) { + unitCount.setParent(this); + } + this.unitCount = unitCount; + } + public static class Identity extends SQLObjectImpl { private Integer seed; private Integer increment; private boolean notForReplication; + private boolean cycle; + + private Integer minValue; + private Integer maxValue; public Identity(){ @@ -308,6 +413,30 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen this.increment = increment; } + public boolean isCycle() { + return cycle; + } + + public void setCycle(boolean cycle) { + this.cycle = cycle; + } + + public Integer getMinValue() { + return minValue; + } + + public void setMinValue(Integer minValue) { + this.minValue = minValue; + } + + public Integer getMaxValue() { + return maxValue; + } + + public void setMaxValue(Integer maxValue) { + this.maxValue = maxValue; + } + public boolean isNotForReplication() { return notForReplication; } @@ -326,6 +455,9 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen Identity x = new Identity(); x.seed = seed; x.increment = increment; + x.cycle = cycle; + x.minValue = minValue; + x.maxValue = maxValue; x.notForReplication = notForReplication; return x; } @@ -379,6 +511,10 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen x.setOnUpdate(onUpdate.clone()); } + if (format != null) { + x.setFormat(format.clone()); + } + if (storage != null) { x.setStorage(storage.clone()); } @@ -387,6 +523,10 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen x.setCharsetExpr(charsetExpr.clone()); } + if (collateExpr != null) { + x.setCollateExpr(collateExpr.clone()); + } + if (asExpr != null) { x.setAsExpr(asExpr.clone()); } @@ -398,6 +538,47 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen x.setIdentity(identity.clone()); } + if (delimiter != null) { + x.setDelimiter(delimiter.clone()); + } + + if (valueType != null) { + x.setValueType(valueType.clone()); + } + + if (nlpTokenizer != null) { + x.setNplTokenizer(nlpTokenizer.clone()); + } + + x.preSort = preSort; + x.preSortOrder = preSortOrder; + + if (jsonIndexAttrsExpr != null) { + x.setJsonIndexAttrsExpr(jsonIndexAttrsExpr.clone()); + } + + if (mappedBy != null) { + for (SQLAssignItem item : mappedBy) { + SQLAssignItem item2 = item.clone(); + item2.setParent(this); + if (x.mappedBy == null) { + x.mappedBy = new ArrayList(); + } + x.mappedBy.add(item2); + } + } + + if (colProperties != null) { + for (SQLAssignItem item : colProperties) { + SQLAssignItem item2 = item.clone(); + item2.setParent(this); + if (x.colProperties == null) { + x.colProperties = new ArrayList(); + } + x.colProperties.add(item2); + } + } + return x; } @@ -435,22 +616,180 @@ public class SQLColumnDefinition extends SQLObjectImpl implements SQLTableElemen return false; } - public boolean isPrimaryKey() { - for (SQLColumnConstraint constraint : constraints) { - if (constraint instanceof SQLColumnPrimaryKey) { - return true; - } - } + public SQLExpr getGeneratedAlawsAs() { + return generatedAlawsAs; + } - if (parent instanceof SQLCreateTableStatement) { - return ((SQLCreateTableStatement) parent) - .isPrimaryColumn(nameHashCode64()); + public void setGeneratedAlawsAs(SQLExpr x) { + if (x != null) { + x.setParent(this); } + this.generatedAlawsAs = x; + } - return false; + public boolean isVisible() { + return visible; + } + + public void setVisible(boolean visible) { + this.visible = visible; + } + + public SQLExpr getDelimiter() { + return delimiter; + } + + public boolean isDisableIndex() { + return disableIndex; + } + + public void setDisableIndex(boolean disableIndex) { + this.disableIndex = disableIndex; + } + + public void setDelimiter(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.delimiter = x; + } + + public SQLExpr getDelimiterTokenizer() { + return delimiterTokenizer; + } + + public void setDelimiterTokenizer(SQLExpr delimiterTokenizer) { + this.delimiterTokenizer = delimiterTokenizer; + } + + public SQLExpr getNlpTokenizer() { + return nlpTokenizer; + } + + public void setNlpTokenizer(SQLExpr nlpTokenizer) { + this.nlpTokenizer = nlpTokenizer; + } + + public SQLExpr getValueType() { + return valueType; + } + + public void setValueType(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.valueType = x; + } + + public boolean isPreSort() { + return preSort; + } + + public void setPreSort(boolean preSort) { + this.preSort = preSort; + } + + public int getPreSortOrder() { + return preSortOrder; + } + + public void setPreSortOrder(int preSortOrder) { + this.preSortOrder = preSortOrder; + } + + public SQLExpr getJsonIndexAttrsExpr() { + return jsonIndexAttrsExpr; + } + + public void setJsonIndexAttrsExpr(SQLExpr jsonIndexAttrsExpr) { + this.jsonIndexAttrsExpr = jsonIndexAttrsExpr; + } + + public AutoIncrementType getSequenceType() { + return sequenceType; + } + + public void setSequenceType(AutoIncrementType sequenceType) { + this.sequenceType = sequenceType; } public String toString() { return SQLUtils.toSQLString(this, dbType); } + + public SQLExpr getUnitCount() { + return unitCount; + } + + public SQLExpr getUnitIndex() { + return unitIndex; + } + + public void setUnitIndex(SQLExpr unitIndex) { + if (unitIndex != null) { + unitIndex.setParent(this); + } + this.unitIndex = unitIndex; + } + + public SQLExpr getNplTokenizer() { + return nlpTokenizer; + } + + public void setNplTokenizer(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.nlpTokenizer = x; + } + + public SQLExpr getStep() { + return step; + } + + public void setStep(SQLExpr step) { + if (step != null) { + step.setParent(this); + } + this.step = step; + } + + public List getMappedBy() { + if (mappedBy == null) { + mappedBy = new ArrayList(); + } + return mappedBy; + } + + public List getMappedByDirect() { + return mappedBy; + } + + public List getColProperties() { + if (colProperties == null) { + colProperties = new ArrayList(); + } + return colProperties; + } + + public SQLCharExpr getEncode() { + return encode; + } + + public void setEncode(SQLCharExpr encode) { + this.encode = encode; + } + + public SQLCharExpr getCompression() { + return compression; + } + + public void setCompression(SQLCharExpr compression) { + this.compression = compression; + } + + public List getColPropertiesDirect() { + return colProperties; + } + } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExprTableSource.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExprTableSource.java index e3cf92a66f..2562b37739 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExprTableSource.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLExprTableSource.java @@ -34,6 +34,7 @@ public class SQLExprTableSource extends SQLTableSourceImpl implements SQLReplace protected SQLExpr expr; private List partitions; + protected SQLTableSampling sampling; private SchemaObject schemaObject; protected List columns; @@ -66,6 +67,17 @@ public class SQLExprTableSource extends SQLTableSourceImpl implements SQLReplace this.setExpr(new SQLIdentifierExpr(name)); } + public SQLTableSampling getSampling() { + return sampling; + } + + public void setSampling(SQLTableSampling x) { + if (x != null) { + x.setParent(this); + } + this.sampling = x; + } + public SQLName getName() { if (expr instanceof SQLName) { return (SQLName) expr; @@ -145,17 +157,25 @@ public class SQLExprTableSource extends SQLTableSourceImpl implements SQLReplace public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; + if (!super.equals(o)) return false; SQLExprTableSource that = (SQLExprTableSource) o; if (expr != null ? !expr.equals(that.expr) : that.expr != null) return false; - return partitions != null ? partitions.equals(that.partitions) : that.partitions == null; + if (partitions != null ? !partitions.equals(that.partitions) : that.partitions != null) return false; + if (sampling != null ? !sampling.equals(that.sampling) : that.sampling != null) return false; + if (schemaObject != null ? !schemaObject.equals(that.schemaObject) : that.schemaObject != null) return false; + return columns != null ? columns.equals(that.columns) : that.columns == null; } @Override public int hashCode() { - int result = expr != null ? expr.hashCode() : 0; + int result = super.hashCode(); + result = 31 * result + (expr != null ? expr.hashCode() : 0); result = 31 * result + (partitions != null ? partitions.hashCode() : 0); + result = 31 * result + (sampling != null ? sampling.hashCode() : 0); + result = 31 * result + (schemaObject != null ? schemaObject.hashCode() : 0); + result = 31 * result + (columns != null ? columns.hashCode() : 0); return result; } 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 92920f1781..815b348f5b 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 @@ -1,33 +1,38 @@ -/* - * Copyright 1999-2018 Alibaba Group Holding Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ package com.alibaba.druid.sql.ast.statement; import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.SQLObjectImpl; +import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl; +import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor; import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class SQLExternalRecordFormat extends SQLObjectImpl { private SQLExpr delimitedBy; private SQLExpr terminatedBy; + private SQLExpr escapedBy; + private SQLExpr collectionItemsTerminatedBy; + private SQLExpr mapKeysTerminatedBy; + private SQLExpr linesTerminatedBy; + private SQLExpr nullDefinedAs; + private SQLExpr serde; + + private Boolean logfile; + private Boolean badfile; + private boolean ltrim; + private boolean missingFieldValuesAreNull; + private boolean rejectRowsWithAllNullFields; @Override public void accept0(SQLASTVisitor visitor) { if (visitor.visit(this)) { acceptChild(visitor, delimitedBy); acceptChild(visitor, terminatedBy); + acceptChild(visitor, escapedBy); + acceptChild(visitor, collectionItemsTerminatedBy); + acceptChild(visitor, mapKeysTerminatedBy); + acceptChild(visitor, linesTerminatedBy); + acceptChild(visitor, nullDefinedAs); + acceptChild(visitor, serde); } visitor.endVisit(this); } @@ -47,10 +52,156 @@ public class SQLExternalRecordFormat extends SQLObjectImpl { return terminatedBy; } - public void setTerminatedBy(SQLExpr terminatedBy) { - if (terminatedBy != null) { - terminatedBy.setParent(this); + public void setTerminatedBy(SQLExpr x) { + if (x != null) { + x.setParent(this); } - this.terminatedBy = terminatedBy; + this.terminatedBy = x; + } + + public SQLExpr getSerde() { + return serde; + } + + public void setSerde(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.serde = x; + } + + public SQLExpr getMapKeysTerminatedBy() { + return mapKeysTerminatedBy; + } + + public void setMapKeysTerminatedBy(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + mapKeysTerminatedBy = x; + } + + public SQLExpr getCollectionItemsTerminatedBy() { + return collectionItemsTerminatedBy; + } + + public void setCollectionItemsTerminatedBy(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.collectionItemsTerminatedBy = x; + } + + public SQLExpr getEscapedBy() { + return escapedBy; + } + + public void setEscapedBy(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.escapedBy = x; + } + + public SQLExpr getLinesTerminatedBy() { + return linesTerminatedBy; + } + + public void setLinesTerminatedBy(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.linesTerminatedBy = x; + } + + public SQLExpr getNullDefinedAs() { + return nullDefinedAs; + } + + public void setNullDefinedAs(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.nullDefinedAs = x; + } + + public Boolean getLogfile() { + return logfile; + } + + public void setLogfile(Boolean logfile) { + this.logfile = logfile; + } + + public Boolean getBadfile() { + return badfile; + } + + public void setBadfile(Boolean badfile) { + this.badfile = badfile; + } + + public boolean isLtrim() { + return ltrim; + } + + public void setLtrim(boolean ltrim) { + this.ltrim = ltrim; + } + + public boolean isRejectRowsWithAllNullFields() { + return rejectRowsWithAllNullFields; + } + + public void setRejectRowsWithAllNullFields(boolean rejectRowsWithAllNullFields) { + this.rejectRowsWithAllNullFields = rejectRowsWithAllNullFields; + } + + public boolean isMissingFieldValuesAreNull() { + return missingFieldValuesAreNull; + } + + public void setMissingFieldValuesAreNull(boolean missingFieldValuesAreNull) { + this.missingFieldValuesAreNull = missingFieldValuesAreNull; + } + + public SQLExternalRecordFormat clone() { + SQLExternalRecordFormat x = new SQLExternalRecordFormat(); + + if (delimitedBy != null) { + x.setDelimitedBy(delimitedBy.clone()); + } + + if (escapedBy != null) { + x.setEscapedBy(escapedBy.clone()); + } + + if (collectionItemsTerminatedBy != null) { + x.setCollectionItemsTerminatedBy(collectionItemsTerminatedBy.clone()); + } + + if (mapKeysTerminatedBy != null) { + x.setMapKeysTerminatedBy(mapKeysTerminatedBy.clone()); + } + + if (linesTerminatedBy != null) { + x.setLinesTerminatedBy(linesTerminatedBy.clone()); + } + + if (nullDefinedAs != null) { + x.setNullDefinedAs(nullDefinedAs.clone()); + } + + if (serde != null) { + x.setSerde(serde.clone()); + } + + x.logfile = logfile; + x.badfile = badfile; + x.ltrim = ltrim; + x.missingFieldValuesAreNull = missingFieldValuesAreNull; + x.rejectRowsWithAllNullFields = rejectRowsWithAllNullFields; + + return x; } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSampling.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSampling.java new file mode 100644 index 0000000000..c10ceacd75 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSampling.java @@ -0,0 +1,174 @@ +package com.alibaba.druid.sql.ast.statement; + +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLObjectImpl; +import com.alibaba.druid.sql.ast.SQLReplaceable; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +public class SQLTableSampling + extends SQLObjectImpl implements SQLReplaceable { + private SQLExpr bucket; + private SQLExpr outOf; + private SQLExpr on; + private SQLExpr percent; + private SQLExpr rows; + private SQLExpr byteLength; + + private boolean bernoulli; + private boolean system; + + public SQLTableSampling clone() { + SQLTableSampling x = new SQLTableSampling(); + + if (bucket != null) { + x.setBucket(bucket.clone()); + } + + if (outOf != null) { + x.setOutOf(outOf.clone()); + } + + if (on != null) { + x.setOn(on.clone()); + } + + if (percent != null) { + x.setPercent(percent.clone()); + } + + if (rows != null) { + x.setRows(rows.clone()); + } + + if (byteLength != null) { + x.setByteLength(byteLength.clone()); + } + + x.bernoulli = bernoulli; + x.system = system; + return x; + } + + public SQLExpr getBucket() { + return bucket; + } + + public void setBucket(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.bucket = x; + } + + public SQLExpr getOutOf() { + return outOf; + } + + public void setOutOf(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.outOf = x; + } + + public SQLExpr getOn() { + return on; + } + + public void setOn(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.on = x; + } + + public SQLExpr getPercent() { + return percent; + } + + public void setPercent(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.percent = x; + } + + @Override + protected void accept0(SQLASTVisitor v) { + if (v.visit(this)) { + acceptChild(v, bucket); + acceptChild(v, outOf); + acceptChild(v, on); + acceptChild(v, percent); + acceptChild(v, byteLength); + } + v.endVisit(this); + } + + @Override + public boolean replace(SQLExpr expr, SQLExpr target) { + if (bucket == expr) { + setBucket(target); + return true; + } + + if (outOf == expr) { + setOutOf(target); + return true; + } + + if (on == expr) { + setOn(target); + return true; + } + + if (percent == expr) { + setPercent(target); + return true; + } + + if (byteLength == expr) { + setByteLength(target); + return true; + } + return false; + } + + public SQLExpr getByteLength() { + return byteLength; + } + + public void setByteLength(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.byteLength = x; + } + + public SQLExpr getRows() { + return rows; + } + + public void setRows(SQLExpr x) { + if (x != null) { + x.setParent(this); + } + this.rows = x; + } + + public boolean isBernoulli() { + return bernoulli; + } + + public void setBernoulli(boolean bernoulli) { + this.bernoulli = bernoulli; + } + + public boolean isSystem() { + return system; + } + + public void setSystem(boolean system) { + this.system = system; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSourceImpl.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSourceImpl.java index c4091e35b2..144578d2d4 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSourceImpl.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLTableSourceImpl.java @@ -144,4 +144,24 @@ public abstract class SQLTableSourceImpl extends SQLObjectImpl implements SQLTab public SQLObject resolveColum(long columnNameHash) { return findColumn(columnNameHash); } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SQLTableSourceImpl that = (SQLTableSourceImpl) o; + + if (aliasHashCode64() != that.aliasHashCode64()) return false; + if (hints != null ? !hints.equals(that.hints) : that.hints != null) return false; + return flashback != null ? flashback.equals(that.flashback) : that.flashback == null; + } + + @Override + public int hashCode() { + int result = (hints != null ? hints.hashCode() : 0); + result = 31 * result + (flashback != null ? flashback.hashCode() : 0); + result = 31 * result + (int) (aliasHashCode64() ^ (aliasHashCode64() >>> 32)); + return result; + } } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnnestTableSource.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnnestTableSource.java new file mode 100644 index 0000000000..c864f821c0 --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLUnnestTableSource.java @@ -0,0 +1,74 @@ +package com.alibaba.druid.sql.ast.statement; + +import com.alibaba.druid.sql.ast.SQLExpr; +import com.alibaba.druid.sql.ast.SQLName; +import com.alibaba.druid.sql.visitor.SQLASTVisitor; + +import java.util.ArrayList; +import java.util.List; + +public class SQLUnnestTableSource + extends SQLTableSourceImpl { + private final List items = new ArrayList(); + protected List columns = new ArrayList(); + private boolean ordinality = false; + + public SQLUnnestTableSource() { + + } + + @Override + protected void accept0(SQLASTVisitor v) { + if (v.visit(this)) { + acceptChild(v, items); + acceptChild(v, columns); + } + v.endVisit(this); + } + + public List getColumns() { + return columns; + } + + public void addColumn(SQLName column) { + column.setParent(this); + this.columns.add(column); + } + + public boolean isOrdinality() { + return ordinality; + } + + public void setOrdinality(boolean ordinality) { + this.ordinality = ordinality; + } + + public List getItems() { + return items; + } + + public void addItem(SQLExpr item) { + item.setParent(this); + this.items.add(item); + } + + public SQLUnnestTableSource clone() { + SQLUnnestTableSource x = new SQLUnnestTableSource(); + + for (SQLExpr item : items) { + SQLExpr item2 = item.clone(); + item2.setParent(x); + x.items.add(item2); + } + + for (SQLName column : columns) { + SQLName c2 = column.clone(); + c2.setParent(x); + x.columns.add(c2); + } + + x.alias = alias; + + return x; + } +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveCreateTableParser.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveCreateTableParser.java index 02a8a03af1..84cbcd9391 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveCreateTableParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveCreateTableParser.java @@ -26,6 +26,7 @@ import com.alibaba.druid.sql.ast.statement.SQLSelect; import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem; import com.alibaba.druid.sql.ast.statement.SQLTableElement; import com.alibaba.druid.sql.dialect.hive.stmt.HiveCreateTableStatement; +import com.alibaba.druid.sql.parser.Lexer; import com.alibaba.druid.sql.parser.ParserException; import com.alibaba.druid.sql.parser.SQLCreateTableParser; import com.alibaba.druid.sql.parser.SQLExprParser; @@ -38,6 +39,10 @@ public class HiveCreateTableParser extends SQLCreateTableParser { super(exprParser); } + public HiveCreateTableParser(Lexer lexer) { + super(new HiveExprParser(lexer)); + } + public SQLCreateTableStatement parseCreateTable(boolean acceptCreate) { HiveCreateTableStatement stmt = newCreateStatement(); diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveExprParser.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveExprParser.java index 8dcc6bd9a4..a35b349844 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveExprParser.java @@ -1,5 +1,5 @@ /* - * Copyright 1999-2018 Alibaba Group Holding Ltd. + * 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. @@ -15,24 +15,25 @@ */ package com.alibaba.druid.sql.dialect.hive.parser; -import java.util.Arrays; - +import com.alibaba.druid.sql.ast.SQLCurrentTimeExpr; +import com.alibaba.druid.sql.ast.SQLCurrentUserExpr; import com.alibaba.druid.sql.ast.SQLExpr; -import com.alibaba.druid.sql.ast.expr.SQLArrayExpr; -import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; -import com.alibaba.druid.sql.parser.Lexer; -import com.alibaba.druid.sql.parser.SQLExprParser; -import com.alibaba.druid.sql.parser.SQLParserFeature; -import com.alibaba.druid.sql.parser.Token; +import com.alibaba.druid.sql.ast.expr.*; +import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition; +import com.alibaba.druid.sql.ast.statement.SQLExternalRecordFormat; +import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlOutFileExpr; +import com.alibaba.druid.sql.parser.*; import com.alibaba.druid.util.FnvHash; +import java.util.Arrays; + public class HiveExprParser extends SQLExprParser { private final static String[] AGGREGATE_FUNCTIONS; private final static long[] AGGREGATE_FUNCTIONS_CODES; static { String[] strings = { "AVG", "COUNT", "MAX", "MIN", "STDDEV", "SUM", "ROW_NUMBER", - "ROWNUMBER" }; + "ROWNUMBER" }; AGGREGATE_FUNCTIONS_CODES = FnvHash.fnv1a_64_lower(strings, true); AGGREGATE_FUNCTIONS = new String[AGGREGATE_FUNCTIONS_CODES.length]; @@ -60,19 +61,229 @@ public class HiveExprParser extends SQLExprParser { } public SQLExpr primaryRest(SQLExpr expr) { - if (lexer.token() == Token.COLONCOLON) { - lexer.nextToken(); - String propertyName = lexer.stringVal(); - lexer.nextToken(); - expr = new SQLPropertyExpr(expr, propertyName); - } else if (lexer.token() == Token.LBRACKET) { - SQLArrayExpr array = new SQLArrayExpr(); - array.setExpr(expr); - lexer.nextToken(); - this.exprList(array.getValues(), array); - accept(Token.RBRACKET); - expr = array; +// if(lexer.token() == Token.COLON) { +// lexer.nextToken(); +// expr = dotRest(expr); +// return expr; +// } + + switch (lexer.token()) { + case LBRACKET: + SQLArrayExpr array = new SQLArrayExpr(); + array.setExpr(expr); + lexer.nextToken(); + this.exprList(array.getValues(), array); + accept(Token.RBRACKET); + return primaryRest(array); + case LITERAL_CHARS: + if (expr instanceof SQLCharExpr) { + String text2 = ((SQLCharExpr) expr).getText(); + do { + String chars = lexer.stringVal(); + text2 += chars; + lexer.nextToken(); + } while (lexer.token() == Token.LITERAL_CHARS || lexer.token() == Token.LITERAL_ALIAS); + expr = new SQLCharExpr(text2); + } + break; + case IDENTIFIER: + if (lexer.identifierEquals(FnvHash.Constants.BD) && expr instanceof SQLNumericLiteralExpr) { + lexer.nextToken(); + Number num = ((SQLNumericLiteralExpr) expr).getNumber(); + expr = new SQLDecimalExpr(num.toString()); + } + break; + default: + break; } + return super.primaryRest(expr); } + + public SQLExpr primary() { + final Token tok = lexer.token(); + switch (tok) { + case IDENTIFIER: + final long hash_lower = lexer.hash_lower(); + if (hash_lower == FnvHash.Constants.OUTLINE) { + lexer.nextToken(); + SQLExpr file = primary(); + SQLExpr expr = new MySqlOutFileExpr(file); + + return primaryRest(expr); + } + + SQLCurrentTimeExpr currentTimeExpr = null; + if (hash_lower == FnvHash.Constants.CURRENT_TIMESTAMP) { + currentTimeExpr = new SQLCurrentTimeExpr(SQLCurrentTimeExpr.Type.CURRENT_TIMESTAMP); + } else if (hash_lower == FnvHash.Constants.CURRENT_DATE) { + currentTimeExpr = new SQLCurrentTimeExpr(SQLCurrentTimeExpr.Type.CURRENT_DATE); + } else if (hash_lower == FnvHash.Constants.CURRENT_USER && isEnabled(SQLParserFeature.EnableCurrentUserExpr)) { + lexer.nextToken(); + return primaryRest(new SQLCurrentUserExpr()); + } + + if (currentTimeExpr != null) { + String methodName = lexer.stringVal(); + lexer.nextToken(); + + if (lexer.token() == Token.LPAREN) { + lexer.nextToken(); + if (lexer.token() == Token.LPAREN) { + lexer.nextToken(); + } else { + return primaryRest( + methodRest(new SQLIdentifierExpr(methodName), false) + ); + } + } + + return primaryRest(currentTimeExpr); + } + default: + break; + } + + return super.primary(); + } + + public SQLExternalRecordFormat parseRowFormat() { + lexer.nextToken(); + acceptIdentifier("FORMAT"); + + if (lexer.identifierEquals(FnvHash.Constants.DELIMITED)) { + lexer.nextToken(); + } + + SQLExternalRecordFormat format = new SQLExternalRecordFormat(); + + if (lexer.identifierEquals(FnvHash.Constants.FIELDS)) { + lexer.nextToken(); + acceptIdentifier("TERMINATED"); + accept(Token.BY); + + format.setTerminatedBy(this.expr()); + } else if (lexer.identifierEquals("FIELD")) { + throw new ParserException("syntax error, expect FIELDS, " + lexer.info()); + } + + if (lexer.token() == Token.ESCAPE || lexer.identifierEquals(FnvHash.Constants.ESCAPED)) { + lexer.nextToken(); + accept(Token.BY); + format.setEscapedBy(this.expr()); + } + + if (lexer.identifierEquals(FnvHash.Constants.LINES)) { + lexer.nextToken(); + acceptIdentifier("TERMINATED"); + accept(Token.BY); + + format.setLinesTerminatedBy(this.expr()); + } + + if (lexer.identifierEquals(FnvHash.Constants.COLLECTION)) { + lexer.nextToken(); + acceptIdentifier("ITEMS"); + acceptIdentifier("TERMINATED"); + accept(Token.BY); + format.setCollectionItemsTerminatedBy(this.expr()); + } + + if (lexer.identifierEquals(FnvHash.Constants.MAP)) { + lexer.nextToken(); + acceptIdentifier("KEYS"); + acceptIdentifier("TERMINATED"); + accept(Token.BY); + format.setMapKeysTerminatedBy(this.expr()); + } + + if (lexer.identifierEquals(FnvHash.Constants.SERDE)) { + lexer.nextToken(); + format.setSerde(this.expr()); + } + + return format; + } + + protected SQLExpr parseAliasExpr(String alias) { + String chars = alias.substring(1, alias.length() - 1); + + StringBuilder buf = null; + + for (int i = 0; i < chars.length(); ++i) { + char ch = chars.charAt(i); + if (ch == '\\' && i < chars.length() - 1) { + char next = chars.charAt(i + 1); + if (next == '\\') { + if (buf == null) { + buf = new StringBuilder(); + buf.append(chars.substring(0, i)); + } + buf.append('\\'); + ++i; + } else if (next == '\"') { + if (buf == null) { + buf = new StringBuilder(); + buf.append(chars.substring(0, i)); + } + buf.append('"'); + ++i; + } else { + if (buf != null) { + buf.append(ch); + } + } + } else { + if (buf != null) { + buf.append(ch); + } + } + } + + if (buf != null) { + chars = buf.toString(); + } + return new SQLCharExpr(chars); + } + + public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) { + if (lexer.identifierEquals(FnvHash.Constants.MAPPED)) { + lexer.nextToken(); + accept(Token.BY); + this.parseAssignItem(column.getMappedBy(), column); + } + + if (lexer.identifierEquals(FnvHash.Constants.COLPROPERTIES)) { + lexer.nextToken(); + this.parseAssignItem(column.getColProperties(), column); + } + + + return super.parseColumnRest(column); + } + + protected SQLExpr parseInterval() { + accept(Token.INTERVAL); + SQLExpr value = expr(); + + if (lexer.token() != Token.IDENTIFIER) { + throw new ParserException("Syntax error. " + lexer.info()); + } + + String unit = lexer.stringVal(); + lexer.nextToken(); + + SQLIntervalExpr intervalExpr = new SQLIntervalExpr(); + intervalExpr.setValue(value); + SQLIntervalUnit intervalUnit = SQLIntervalUnit.valueOf(unit.toUpperCase()); + if (intervalUnit == SQLIntervalUnit.YEAR + && lexer.token() == Token.TO) { + lexer.nextToken(); + acceptIdentifier("MONTH"); + intervalUnit = SQLIntervalUnit.YEAR_TO_MONTH; + } + intervalExpr.setUnit(intervalUnit); + + return intervalExpr; + } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveSelectParser.java b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveSelectParser.java index dc075e0c84..86d4ca969a 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/hive/parser/HiveSelectParser.java @@ -17,12 +17,18 @@ package com.alibaba.druid.sql.dialect.hive.parser; import com.alibaba.druid.sql.ast.SQLExpr; import com.alibaba.druid.sql.ast.SQLOrderingSpecification; +import com.alibaba.druid.sql.ast.expr.SQLSizeExpr; +import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem; import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock; +import com.alibaba.druid.sql.ast.statement.SQLTableSampling; +import com.alibaba.druid.sql.ast.statement.SQLTableSource; +import com.alibaba.druid.sql.parser.Lexer; import com.alibaba.druid.sql.parser.SQLExprParser; import com.alibaba.druid.sql.parser.SQLSelectListCache; import com.alibaba.druid.sql.parser.SQLSelectParser; import com.alibaba.druid.sql.parser.Token; +import com.alibaba.druid.util.FnvHash; public class HiveSelectParser extends SQLSelectParser { @@ -70,4 +76,82 @@ public class HiveSelectParser extends SQLSelectParser { } } + protected SQLTableSource parseTableSourceRest(SQLTableSource tableSource) { + if (lexer.identifierEquals(FnvHash.Constants.TABLESAMPLE) && tableSource instanceof SQLExprTableSource) { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextToken(); + if (lexer.token() == Token.LPAREN) { + lexer.nextToken(); + + SQLTableSampling sampling = new SQLTableSampling(); + + if (lexer.identifierEquals(FnvHash.Constants.BUCKET)) { + lexer.nextToken(); + SQLExpr bucket = this.exprParser.primary(); + sampling.setBucket(bucket); + + if (lexer.token() == Token.OUT) { + lexer.nextToken(); + accept(Token.OF); + SQLExpr outOf = this.exprParser.primary(); + sampling.setOutOf(outOf); + } + + if (lexer.token() == Token.ON) { + lexer.nextToken(); + SQLExpr on = this.exprParser.expr(); + sampling.setOn(on); + } + } + + if (lexer.token() == Token.LITERAL_INT || lexer.token() == Token.LITERAL_FLOAT) { + SQLExpr val = this.exprParser.primary(); + + if (lexer.identifierEquals(FnvHash.Constants.ROWS)) { + lexer.nextToken(); + sampling.setRows(val); + } else { + acceptIdentifier("PERCENT"); + sampling.setPercent(val); + } + } + + if (lexer.token() == Token.IDENTIFIER) { + String strVal = lexer.stringVal(); + char first = strVal.charAt(0); + char last = strVal.charAt(strVal.length() - 1); + if (last >= 'a' && last <= 'z') { + last -= 32; // to upper + } + + boolean match = false; + if ((first == '.' || (first >= '0' && first <= '9'))) { + switch (last) { + case 'B': + case 'K': + case 'M': + case 'G': + case 'T': + case 'P': + match = true; + break; + default: + break; + } + } + SQLSizeExpr size = new SQLSizeExpr(strVal.substring(0, strVal.length() - 2), last); + sampling.setByteLength(size); + lexer.nextToken(); + } + + final SQLExprTableSource table = (SQLExprTableSource) tableSource; + table.setSampling(sampling); + + accept(Token.RPAREN); + } else { + lexer.reset(mark); + } + } + return super.parseTableSourceRest(tableSource); + } } diff --git a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlSubPartitionByKey.java b/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlSubPartitionByKey.java index fe38740740..3b68bb3f1a 100644 --- a/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlSubPartitionByKey.java +++ b/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/statement/MySqlSubPartitionByKey.java @@ -81,4 +81,13 @@ public class MySqlSubPartitionByKey extends SQLSubPartitionBy implements MySqlOb cloneTo(x); return x; } + + public boolean isPartitionByColumn(long columnNameHashCode64) { + for (SQLName column : columns) { + if (column.nameHashCode64() == columnNameHashCode64) { + return true; + } + } + return false; + } } 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 eeaf604fa2..77c73d8a9e 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java @@ -3174,6 +3174,21 @@ public class SQLExprParser extends SQLParser { return unique; } + public void parseAssignItem(List outList, SQLObject parent) { + accept(Token.LPAREN); + for (;;) { + SQLAssignItem item = this.parseAssignItem(); + item.setParent(parent); + outList.add(item); + if (lexer.token() == Token.COMMA) { + lexer.nextToken(); + continue; + } + break; + } + accept(Token.RPAREN); + } + public SQLAssignItem parseAssignItem() { SQLAssignItem item = new SQLAssignItem(); diff --git a/src/main/java/com/alibaba/druid/sql/parser/SQLParserFeature.java b/src/main/java/com/alibaba/druid/sql/parser/SQLParserFeature.java index 628f8fd382..37e650f699 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLParserFeature.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLParserFeature.java @@ -27,6 +27,7 @@ public enum SQLParserFeature { StrictForWall, EnableMultiUnion, IgnoreNameQuotes, + EnableCurrentUserExpr, PipesAsConcat, // for mysql ; 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 9821be97e3..a4ecdb7f1d 100644 --- a/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java +++ b/src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java @@ -896,7 +896,7 @@ public class SQLSelectParser extends SQLParser { groupBy.setWithRollUp(true); } - if (JdbcConstants.MYSQL.equals(dbType) + if(JdbcConstants.MYSQL.equals(dbType) && lexer.token == Token.DESC) { lexer.nextToken(); // skip } @@ -919,7 +919,7 @@ public class SQLSelectParser extends SQLParser { } SQLExpr item = this.exprParser.expr(); - if (JdbcConstants.MYSQL.equals(dbType)) { + if(JdbcConstants.MYSQL.equals(dbType)) { if (lexer.token == Token.DESC) { lexer.nextToken(); // skip item =new MySqlOrderingExpr(item, SQLOrderingSpecification.DESC); @@ -1250,7 +1250,45 @@ public class SQLSelectParser extends SQLParser { accept(Token.RPAREN); } } + } else if (lexer.token() == Token.TABLE) { + HiveCreateTableParser createTableParser = new HiveCreateTableParser(lexer); + HiveCreateTableStatement stmt = (HiveCreateTableStatement) createTableParser + .parseCreateTable(false); + rightTableSource = new SQLAdhocTableSource(stmt); + primaryTableSourceRest(rightTableSource); } else { + if (lexer.identifierEquals(FnvHash.Constants.UNNEST)) { + Lexer.SavePoint mark = lexer.mark(); + lexer.nextToken(); + + if (lexer.token() == Token.LPAREN){ + lexer.nextToken(); + SQLUnnestTableSource unnest = new SQLUnnestTableSource(); + this.exprParser.exprList(unnest.getItems(), unnest); + accept(Token.RPAREN); + + if (lexer.token() == Token.WITH) { + lexer.nextToken(); + acceptIdentifier("ORDINALITY"); + unnest.setOrdinality(true); + } + + String alias = this.tableAlias(); + unnest.setAlias(alias); + + if (lexer.token() == Token.LPAREN) { + lexer.nextToken(); + this.exprParser.names(unnest.getColumns(), unnest); + accept(Token.RPAREN); + } + + SQLTableSource tableSrc = parseTableSourceRest(unnest); + rightTableSource = tableSrc; + } else { + lexer.reset(mark); + } + } + if (rightTableSource == null) { boolean aliasToken = lexer.token == Token.LITERAL_ALIAS; SQLExpr expr = this.expr(); 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 ebf9c9733b..c284f154e2 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java @@ -36,9 +36,12 @@ import java.util.Map; import java.util.Set; import com.alibaba.druid.sql.SQLUtils; +import com.alibaba.druid.sql.ast.SQLAdhocTableSource; import com.alibaba.druid.sql.ast.SQLArgument; import com.alibaba.druid.sql.ast.SQLArrayDataType; import com.alibaba.druid.sql.ast.SQLCommentHint; +import com.alibaba.druid.sql.ast.SQLCurrentTimeExpr; +import com.alibaba.druid.sql.ast.SQLCurrentUserExpr; import com.alibaba.druid.sql.ast.SQLDataType; import com.alibaba.druid.sql.ast.SQLDeclareItem; import com.alibaba.druid.sql.ast.SQLExpr; @@ -84,6 +87,7 @@ import com.alibaba.druid.sql.ast.expr.SQLCharExpr; import com.alibaba.druid.sql.ast.expr.SQLContainsExpr; import com.alibaba.druid.sql.ast.expr.SQLCurrentOfCursorExpr; import com.alibaba.druid.sql.ast.expr.SQLDateExpr; +import com.alibaba.druid.sql.ast.expr.SQLDecimalExpr; import com.alibaba.druid.sql.ast.expr.SQLDefaultExpr; import com.alibaba.druid.sql.ast.expr.SQLExistsExpr; import com.alibaba.druid.sql.ast.expr.SQLExprUtils; @@ -107,6 +111,7 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; import com.alibaba.druid.sql.ast.expr.SQLQueryExpr; import com.alibaba.druid.sql.ast.expr.SQLRealExpr; import com.alibaba.druid.sql.ast.expr.SQLSequenceExpr; +import com.alibaba.druid.sql.ast.expr.SQLSizeExpr; import com.alibaba.druid.sql.ast.expr.SQLSomeExpr; import com.alibaba.druid.sql.ast.expr.SQLTimestampExpr; import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr; @@ -6774,4 +6779,130 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter implements Paramet print0(Float.toString(value)); } } + + public boolean visit(SQLTableSampling x) { + print0(ucase ? "TABLESAMPLE " : "tablesample "); + + if (x.isBernoulli()) { + print0(ucase ? "BERNOULLI " : "bernoulli "); + } else if (x.isSystem()) { + print0(ucase ? "SYSTEM " : "system "); + } + + print('('); + + final SQLExpr bucket = x.getBucket(); + if (bucket != null) { + print0(ucase ? "BUCKET " : "bucket "); + bucket.accept(this); + } + + final SQLExpr outOf = x.getOutOf(); + if (outOf != null) { + print0(ucase ? " OUT OF " : " out of "); + outOf.accept(this); + } + + final SQLExpr on = x.getOn(); + if (on != null) { + print0(ucase ? " ON " : " on "); + on.accept(this); + } + + final SQLExpr percent = x.getPercent(); + if (percent != null) { + percent.accept(this); + print0(ucase ? " PERCENT" : " percent"); + } + + final SQLExpr rows = x.getRows(); + if (rows != null) { + rows.accept(this); + + if (JdbcConstants.MYSQL.equals(dbType)) { + print0(ucase ? " ROWS" : " rows"); + } + } + + final SQLExpr size = x.getByteLength(); + if (size != null) { + size.accept(this); + } + + print(')'); + return false; + } + + @Override + public boolean visit(SQLUnnestTableSource x) { + print0(ucase ? "UNNEST(" : "unnest("); + List items = x.getItems(); + printAndAccept(items, ", "); + print(')'); + + final List columns = x.getColumns(); + final String alias = x.getAlias(); + if (alias != null) { + if (columns.size() > 0) { + print0(ucase ?" AS " : " as "); + } else { + print(' '); + } + print0(alias); + } + + if (columns.size() > 0) { + print0(" ("); + for (int i = 0; i < columns.size(); i++) { + if (i != 0) { + print0(", "); + } + printExpr(columns.get(i)); + } + print(')'); + } + + if (x.isOrdinality()) { + print0(ucase ? " WITH ORDINALITY" : " with ordinality"); + } + + return false; + } + + @Override + public boolean visit(SQLAdhocTableSource x) { + final SQLCreateTableStatement definition = x.getDefinition(); + definition.accept(this); + return false; + } + + @Override + public boolean visit(SQLCurrentTimeExpr x) { + final SQLCurrentTimeExpr.Type type = x.getType(); + print(ucase ? type.name : type.name_lower); + return false; + } + + @Override + public boolean visit(SQLCurrentUserExpr x) { + print(ucase ? "CURRENT_USER" : "current_user"); + return false; + } + + @Override + public boolean visit(SQLSizeExpr x) { + x.getValue().accept(this); + print0(x.getUnit().name()); + return false; + } + + @Override + public boolean visit(SQLDecimalExpr x) { + BigDecimal value = x.getValue(); + print0(ucase ? "DECIMAL '" : "decimal '"); + print(value.toString()); + print('\''); + + 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 92a93e2eae..efb089e984 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java @@ -15,9 +15,12 @@ */ package com.alibaba.druid.sql.visitor; +import com.alibaba.druid.sql.ast.SQLAdhocTableSource; import com.alibaba.druid.sql.ast.SQLArgument; import com.alibaba.druid.sql.ast.SQLArrayDataType; import com.alibaba.druid.sql.ast.SQLCommentHint; +import com.alibaba.druid.sql.ast.SQLCurrentTimeExpr; +import com.alibaba.druid.sql.ast.SQLCurrentUserExpr; import com.alibaba.druid.sql.ast.SQLDataType; import com.alibaba.druid.sql.ast.SQLDataTypeRefExpr; import com.alibaba.druid.sql.ast.SQLDeclareItem; @@ -56,6 +59,7 @@ import com.alibaba.druid.sql.ast.expr.SQLCharExpr; import com.alibaba.druid.sql.ast.expr.SQLContainsExpr; import com.alibaba.druid.sql.ast.expr.SQLCurrentOfCursorExpr; import com.alibaba.druid.sql.ast.expr.SQLDateExpr; +import com.alibaba.druid.sql.ast.expr.SQLDecimalExpr; import com.alibaba.druid.sql.ast.expr.SQLDefaultExpr; import com.alibaba.druid.sql.ast.expr.SQLExistsExpr; import com.alibaba.druid.sql.ast.expr.SQLFlashbackExpr; @@ -76,6 +80,7 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; import com.alibaba.druid.sql.ast.expr.SQLQueryExpr; import com.alibaba.druid.sql.ast.expr.SQLRealExpr; import com.alibaba.druid.sql.ast.expr.SQLSequenceExpr; +import com.alibaba.druid.sql.ast.expr.SQLSizeExpr; import com.alibaba.druid.sql.ast.expr.SQLSomeExpr; import com.alibaba.druid.sql.ast.expr.SQLTimestampExpr; import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr; @@ -912,4 +917,24 @@ public interface SQLASTVisitor { boolean visit(SQLDataTypeRefExpr x); void endVisit(SQLDataTypeRefExpr x); + boolean visit(SQLTableSampling x); + void endVisit(SQLTableSampling x); + + boolean visit(SQLSizeExpr x); + void endVisit(SQLSizeExpr x); + + boolean visit(SQLUnnestTableSource x); + void endVisit(SQLUnnestTableSource x); + + boolean visit(SQLAdhocTableSource x); + void endVisit(SQLAdhocTableSource x); + + boolean visit(SQLCurrentTimeExpr x); + void endVisit(SQLCurrentTimeExpr x); + + boolean visit(SQLDecimalExpr x); + void endVisit(SQLDecimalExpr x); + + boolean visit(SQLCurrentUserExpr x); + void endVisit(SQLCurrentUserExpr x); } diff --git a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java index 3e81ee864c..82465d25a5 100644 --- a/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java +++ b/src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java @@ -15,9 +15,12 @@ */ package com.alibaba.druid.sql.visitor; +import com.alibaba.druid.sql.ast.SQLAdhocTableSource; import com.alibaba.druid.sql.ast.SQLArgument; import com.alibaba.druid.sql.ast.SQLArrayDataType; import com.alibaba.druid.sql.ast.SQLCommentHint; +import com.alibaba.druid.sql.ast.SQLCurrentTimeExpr; +import com.alibaba.druid.sql.ast.SQLCurrentUserExpr; import com.alibaba.druid.sql.ast.SQLDataType; import com.alibaba.druid.sql.ast.SQLDataTypeRefExpr; import com.alibaba.druid.sql.ast.SQLDeclareItem; @@ -56,6 +59,7 @@ import com.alibaba.druid.sql.ast.expr.SQLCharExpr; import com.alibaba.druid.sql.ast.expr.SQLContainsExpr; import com.alibaba.druid.sql.ast.expr.SQLCurrentOfCursorExpr; import com.alibaba.druid.sql.ast.expr.SQLDateExpr; +import com.alibaba.druid.sql.ast.expr.SQLDecimalExpr; import com.alibaba.druid.sql.ast.expr.SQLDefaultExpr; import com.alibaba.druid.sql.ast.expr.SQLExistsExpr; import com.alibaba.druid.sql.ast.expr.SQLFlashbackExpr; @@ -76,6 +80,7 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; import com.alibaba.druid.sql.ast.expr.SQLQueryExpr; import com.alibaba.druid.sql.ast.expr.SQLRealExpr; import com.alibaba.druid.sql.ast.expr.SQLSequenceExpr; +import com.alibaba.druid.sql.ast.expr.SQLSizeExpr; import com.alibaba.druid.sql.ast.expr.SQLSomeExpr; import com.alibaba.druid.sql.ast.expr.SQLTimestampExpr; import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr; @@ -2139,6 +2144,76 @@ public class SQLASTVisitorAdapter implements SQLASTVisitor { } + @Override + public void endVisit(SQLTableSampling x) { + + } + + @Override + public boolean visit(SQLTableSampling x) { + return true; + } + + @Override + public void endVisit(SQLSizeExpr x) { + + } + + @Override + public boolean visit(SQLSizeExpr x) { + return true; + } + + @Override + public void endVisit(SQLUnnestTableSource x) { + + } + + @Override + public boolean visit(SQLUnnestTableSource x) { + return true; + } + + @Override + public void endVisit(SQLAdhocTableSource x) { + + } + + @Override + public boolean visit(SQLCurrentTimeExpr x) { + return true; + } + + @Override + public void endVisit(SQLCurrentTimeExpr x) { + + } + + @Override + public boolean visit(SQLAdhocTableSource x) { + return true; + } + + @Override + public void endVisit(SQLDecimalExpr x) { + + } + + @Override + public boolean visit(SQLDecimalExpr x) { + return true; + } + + @Override + public void endVisit(SQLCurrentUserExpr x) { + + } + + @Override + public boolean visit(SQLCurrentUserExpr x) { + return true; + } + @Override public boolean visit(SQLDataTypeRefExpr x) { return true; diff --git a/src/main/java/com/alibaba/druid/util/FnvHash.java b/src/main/java/com/alibaba/druid/util/FnvHash.java index 0106038932..99ff70e44b 100644 --- a/src/main/java/com/alibaba/druid/util/FnvHash.java +++ b/src/main/java/com/alibaba/druid/util/FnvHash.java @@ -675,5 +675,19 @@ public final class FnvHash { long BIT_COUNT = fnv1a_64_lower("BIT_COUNT"); long WEIGHT_STRING = fnv1a_64_lower("WEIGHT_STRING"); long REVERSE = fnv1a_64_lower("REVERSE"); + long TABLESAMPLE = fnv1a_64_lower("TABLESAMPLE"); + long BUCKET = fnv1a_64_lower("BUCKET"); + long UNNEST = fnv1a_64_lower("UNNEST"); + long FIELDS = fnv1a_64_lower("FIELDS"); + long ESCAPED = fnv1a_64_lower("ESCAPED"); + long YEAR_TO_MONTH = fnv1a_64_lower("YEAR_TO_MONTH"); + long COLPROPERTIES = fnv1a_64_lower("COLPROPERTIES"); + long MAPPED = fnv1a_64_lower("MAPPED"); + long LINES = fnv1a_64_lower("LINES"); + long COLLECTION = fnv1a_64_lower("COLLECTION"); + long SERDE = fnv1a_64_lower("SERDE"); + long OUTLINE = fnv1a_64_lower("OUTLINE"); + long BD = fnv1a_64_lower("BD"); + long CURRENT_DATE = fnv1a_64_lower("CURRENT_DATE"); } }