apply(ResultSet resultSet) {
+ try {
+ return new ObjectArrayRowBuilder(
+ resultSet,
+ Pair.left(list).toArray(new ColumnMetaData.Rep[list.size()]),
+ Ints.toArray(Pair.right(list)));
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ };
+ }
- private static Time shift(Time v) {
- if (v == null) {
- return null;
- }
- long time = v.getTime();
- int offset = TimeZone.getDefault().getOffset(time);
- return new Time((time + offset) % DateTimeUtils.MILLIS_PER_DAY);
- }
+ public Object[] apply() {
+ try {
+ final Object[] values = new Object[columnCount];
+ for (int i = 0; i < columnCount; i++) {
+ values[i] = value(i);
+ }
+ return values;
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
- private static Date shift(Date v) {
- if (v == null) {
- return null;
- }
- long time = v.getTime();
- int offset = TimeZone.getDefault().getOffset(time);
- return new Date(time + offset);
- }
- }
+ /**
+ * Gets a value from a given column in a JDBC result set.
+ *
+ * @param i Ordinal of column (1-based, per JDBC)
+ */
+ private Object value(int i) throws SQLException {
+ // MySQL returns timestamps shifted into local time. Using
+ // getTimestamp(int, Calendar) with a UTC calendar should prevent this,
+ // but does not. So we shift explicitly.
+ switch (types[i]) {
+ case Types.TIMESTAMP:
+ return shift(resultSet.getTimestamp(i + 1));
+ case Types.TIME:
+ return shift(resultSet.getTime(i + 1));
+ case Types.DATE:
+ return shift(resultSet.getDate(i + 1));
+ }
+ return reps[i].jdbcGet(resultSet, i + 1);
+ }
- /** Ensures that if two data sources have the same definition, they will use
- * the same object.
- *
- * This in turn makes it easier to cache
- * {@link org.apache.calcite.sql.SqlDialect} objects. Otherwise, each time we
- * see a new data source, we have to open a connection to find out what
- * database product and version it is. */
- static class DataSourcePool {
- public static final DataSourcePool INSTANCE = new DataSourcePool();
+ private static Timestamp shift(Timestamp v) {
+ if (v == null) {
+ return null;
+ }
+ long time = v.getTime();
+ int offset = TimeZone.getDefault().getOffset(time);
+ return new Timestamp(time + offset);
+ }
- private final LoadingCache, BasicDataSource> cache =
- CacheBuilder.newBuilder().softValues().build(
- new CacheLoader, BasicDataSource>() {
- @Override public BasicDataSource load(@Nonnull List key) {
- BasicDataSource dataSource = new BasicDataSource();
- dataSource.setUrl(key.get(0));
- dataSource.setUsername(key.get(1));
- dataSource.setPassword(key.get(2));
- dataSource.setDriverClassName(key.get(3));
- return dataSource;
- }
- });
+ private static Time shift(Time v) {
+ if (v == null) {
+ return null;
+ }
+ long time = v.getTime();
+ int offset = TimeZone.getDefault().getOffset(time);
+ return new Time((time + offset) % DateTimeUtils.MILLIS_PER_DAY);
+ }
- public DataSource get(String url, String driverClassName,
- String username, String password) {
- // Get data source objects from a cache, so that we don't have to sniff
- // out what kind of database they are quite as often.
- final List key =
- ImmutableNullableList.of(url, username, password, driverClassName);
- return cache.getUnchecked(key);
+ private static Date shift(Date v) {
+ if (v == null) {
+ return null;
+ }
+ long time = v.getTime();
+ int offset = TimeZone.getDefault().getOffset(time);
+ return new Date(time + offset);
+ }
}
- }
}
// End JdbcUtils.java
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/polardbx-calcite/src/main/java/org/apache/calcite/plan/RelOptUtil.java
index 9aa33c713..586d39887 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -35,6 +35,7 @@
import org.apache.calcite.rel.RelShuttle;
import org.apache.calcite.rel.RelVisitor;
import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.core.Aggregate;
import org.apache.calcite.rel.core.AggregateCall;
import org.apache.calcite.rel.core.Calc;
import org.apache.calcite.rel.core.Correlate;
@@ -2819,6 +2820,64 @@ public static MultiJoin projectMultiJoin(
multiJoin.getPostJoinFilter());
}
+
+ /**
+ * Checks whether the given {@link RelNode} tree contains any aggregate operations.
+ *
+ * @param node The relational expression node to inspect
+ * @return True if an aggregate operation is found in the node or its subtree; False otherwise
+ */
+ public static boolean containsAgg(RelNode node) {
+ // If the node is a HepRelVertex, replace it with its current rel
+ if (isHepRelVertex(node)) {
+ node = ((HepRelVertex) node).getCurrentRel();
+ }
+
+ try {
+ RelVisitor visitor = createAggregateFinder();
+ // Traverse the node and its children
+ visitor.go(node);
+ // If no aggregate is found, return false
+ return false;
+ } catch (Util.FoundOne e) {
+ // If an aggregate is found, return true
+ return true;
+ }
+ }
+
+ /**
+ * Helper method to check if the provided node is an instance of {@link HepRelVertex}.
+ *
+ * @param node The relational expression node to examine
+ * @return True if the node is a HepRelVertex; False otherwise
+ */
+ private static boolean isHepRelVertex(RelNode node) {
+ return node instanceof HepRelVertex;
+ }
+ /**
+ * Constructs a {@link RelVisitor} that finds instances of aggregate operations ({@link Aggregate}).
+ *
+ * @return A visitor instance to search for aggregates
+ */
+ private static RelVisitor createAggregateFinder() {
+ return new RelVisitor() {
+ @Override
+ public void visit(RelNode node, int ordinal, RelNode parent) {
+ // If the node is a HepRelVertex, replace it with its current rel
+ if (isHepRelVertex(node)) {
+ node = ((HepRelVertex) node).getCurrentRel();
+ }
+ // Check if the node is an aggregate operation
+ if (node instanceof Aggregate) {
+ // Throw a marker exception to signal that an aggregate was found
+ throw Util.FoundOne.NULL;
+ }
+ // Continue visiting child nodes
+ super.visit(node, ordinal, parent);
+ }
+ };
+ }
+
public static T addTrait(
T rel, RelTrait trait) {
//noinspection unchecked
@@ -3301,7 +3360,7 @@ public static RelNode projectMapping(
* @param project the project to be tested
* @return true if the project has no subquery
*/
- static boolean notSubquery(LogicalProject project) {
+ public static boolean notSubquery(LogicalProject project) {
for (RexNode r : project.getProjects()) {
if (RexUtil.containsCorrelation(r)) { return false; }
if (RexUtil.hasSubQuery(r)) { return false;}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java b/polardbx-calcite/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
index da88116e6..21fe3a080 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
@@ -205,6 +205,7 @@ private void clearProcessed(RelSet set) {
RelSubset optimizingGroup = null;
boolean canPassThrough = node instanceof PhysicalNode
&& !passThroughCache.contains(node);
+ boolean passThroughSuccess = false;
if (!canPassThrough && subset.taskState != null) {
optimizingGroup = subset;
} else {
@@ -229,9 +230,14 @@ private void clearProcessed(RelSet set) {
Task task = getOptimizeInputTask(node, otherSubset);
if (task != null) {
tasks.push(task);
+ passThroughSuccess = true;
}
}
}
+ // if pass through failed, optimizingGroup current subset
+ if ((!passThroughSuccess) && subset.taskState == RelSubset.OptimizeState.OPTIMIZING && optimizingGroup == null) {
+ optimizingGroup = subset;
+ }
if (optimizingGroup == null) {
// FIXME
// In case some implementations use rules to convert between different physical conventions.
@@ -281,7 +287,6 @@ void log(Task task) {
if (!first) {
builder.append(")");
}
-
LOGGER.debug(builder.toString());
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/core/TableScan.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/core/TableScan.java
index 8b65158b3..2596b56a7 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/core/TableScan.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/core/TableScan.java
@@ -137,6 +137,7 @@ protected TableScan(RelInput input) {
this(input.getCluster(), input.getTraitSet(), input.getTable("table"));
this.flashback = input.getExpression("flashback");
this.indexNode = RexUtil.deSeriIndexHint(input.getStringList("index"));
+ this.flashbackOperator = input.getSqlOperator("flashbackOperator");
}
//~ Methods ----------------------------------------------------------------
@@ -176,8 +177,9 @@ public ImmutableIntList identity() {
@Override public RelWriter explainTerms(RelWriter pw) {
return super.explainTerms(pw)
.item("table", table.getQualifiedName())
- .itemIf("index", RexUtil.seriIndexHint(indexNode), indexNode!=null)
+ .itemIf("index", RexUtil.seriIndexHint(indexNode), indexNode != null)
.item("flashback", flashback)
+ .itemIf("flashbackOperator", flashbackOperator, flashbackOperator != null)
;
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableArchivePartition.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableArchivePartition.java
new file mode 100644
index 000000000..3324b404c
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableArchivePartition.java
@@ -0,0 +1,35 @@
+package org.apache.calcite.rel.ddl;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.DDL;
+import org.apache.calcite.sql.SqlDdl;
+import org.apache.calcite.sql.SqlNode;
+
+import java.util.List;
+
+/**
+ * @author wumu
+ */
+public class AlterTableArchivePartition extends DDL {
+
+ protected AlterTableArchivePartition(RelOptCluster cluster, RelTraitSet traits, SqlDdl ddl, SqlNode tableName) {
+ super(cluster, traits, null);
+ this.sqlNode = ddl;
+ this.setTableName(tableName);
+ }
+
+ public static AlterTableArchivePartition create(RelOptCluster cluster, SqlDdl ddl, SqlNode tableName) {
+ return new AlterTableArchivePartition(cluster, cluster.traitSet(), ddl, tableName);
+ }
+
+ @Override
+ public AlterTableArchivePartition copy(
+ RelTraitSet traitSet, List inputs) {
+ assert traitSet.containsIfApplicable(Convention.NONE);
+ return new AlterTableArchivePartition(this.getCluster(), traitSet, this.ddl, getTableName());
+ }
+}
+
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableGroupOptimizePartition.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableGroupOptimizePartition.java
new file mode 100644
index 000000000..f8826d0b2
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/ddl/AlterTableGroupOptimizePartition.java
@@ -0,0 +1,43 @@
+package org.apache.calcite.rel.ddl;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlDdl;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.parser.SqlParserPos;
+
+import java.util.List;
+
+public class AlterTableGroupOptimizePartition extends AlterTableGroupDdl {
+
+ protected AlterTableGroupOptimizePartition(RelOptCluster cluster, RelTraitSet traits, SqlDdl ddl,
+ RelDataType rowType,
+ String tableGroupName) {
+ super(cluster, traits, ddl, rowType);
+ this.tableGroupName = tableGroupName;
+ this.sqlNode = ddl;
+ this.setTableName(new SqlIdentifier(tableGroupName, SqlParserPos.ZERO));
+ }
+
+ public static AlterTableGroupOptimizePartition create(RelOptCluster cluster, RelTraitSet traits, SqlDdl ddl,
+ RelDataType rowType,
+ String tableGroupName) {
+
+ return new AlterTableGroupOptimizePartition(cluster, traits, ddl, rowType, tableGroupName);
+ }
+
+ @Override
+ public AlterTableGroupOptimizePartition copy(
+ RelTraitSet traitSet, List inputs) {
+ assert traitSet.containsIfApplicable(Convention.NONE);
+ return new AlterTableGroupOptimizePartition(this.getCluster(), traitSet, this.ddl, rowType, tableGroupName);
+ }
+
+ @Override
+ public String getTableGroupName() {
+ return tableGroupName;
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSemiJoin.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSemiJoin.java
index ccab1e0a7..4c97be9bf 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSemiJoin.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSemiJoin.java
@@ -411,8 +411,12 @@ public RexNode visitCall(RexCall call) {
return null;
}
if (relBuilder.peek().getRowType().getFieldCount() > this.getOperands().size()) {
- if (operator.getKind() != EXISTS && operator.getKind() != NOT_EXISTS
- && operator.getKind() != SCALAR_QUERY) {
+ if (operator.getKind() == EXISTS || operator.getKind() == NOT_EXISTS) {
+ if (!RelOptUtil.containsAgg(relBuilder.peek()) &&
+ !(relBuilder.peek() instanceof LogicalProject)) {
+ relBuilder.project(rexBuilder.makeInputRef(relBuilder.peek(), 0));
+ }
+ } else if (operator.getKind() != SCALAR_QUERY) {
List rexNodes = Lists.newArrayList();
for (int i = 0; i < this.getOperands().size(); i++) {
rexNodes.add(rexBuilder.makeInputRef(relBuilder.peek(), i));
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSort.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSort.java
index 81a4eb786..3a737dd98 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSort.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/LogicalSort.java
@@ -44,6 +44,7 @@
* targeted at any particular engine or calling convention.
*/
public class LogicalSort extends Sort {
+ private final SortOptimizationContext sortOptimizationContext = new SortOptimizationContext();
protected boolean ignore = false;
protected LogicalSort(RelOptCluster cluster, RelTraitSet traitSet,
@@ -97,11 +98,13 @@ public static LogicalSort create(RelTraitSet traitSet, RelNode input, RelCollati
RelCollation newCollation, RexNode offset, RexNode fetch) {
LogicalSort logicalSort = new LogicalSort(getCluster(), traitSet, newInput, newCollation,
offset, fetch, ignore);
+ logicalSort.sortOptimizationContext.copyFrom(sortOptimizationContext);
return logicalSort;
}
public Sort copy(RelNode newInput, RelCollation newCollation) {
LogicalSort logicalSort = new LogicalSort(getCluster(), traitSet, newInput, newCollation, offset, fetch, ignore);
+ logicalSort.sortOptimizationContext.copyFrom(sortOptimizationContext);
return logicalSort;
}
@@ -142,6 +145,10 @@ public boolean isIgnore() {
public void setIgnore(boolean ignore) {
this.ignore = ignore;
}
+
+ public SortOptimizationContext getSortOptimizationContext() {
+ return sortOptimizationContext;
+ }
}
// End LogicalSort.java
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/SortOptimizationContext.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/SortOptimizationContext.java
new file mode 100644
index 000000000..7d46644d7
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/logical/SortOptimizationContext.java
@@ -0,0 +1,20 @@
+package org.apache.calcite.rel.logical;
+
+public class SortOptimizationContext {
+ private boolean isSortPushed = false;
+
+ public SortOptimizationContext() {}
+
+ void copyFrom(SortOptimizationContext aggOptimizationContext) {
+ this.isSortPushed = aggOptimizationContext.isSortPushed;
+ }
+
+ public boolean isSortPushed() {
+ return isSortPushed;
+ }
+
+ public void setSortPushed(boolean sortPushed) {
+ isSortPushed = sortPushed;
+ }
+
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
index 2f375ee4a..a05b39435 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
@@ -100,6 +100,13 @@ public Double getSelectivity(Sort rel, RelMetadataQuery mq,
public Double getSelectivity(Correlate rel, RelMetadataQuery mq,
RexNode predicate) {
+ if (predicate == null || rel == null) {
+ return 1.0D;
+ }
+ int maxIndex = RexUtil.findMaxIndex(predicate);
+ if (maxIndex >= rel.getLeft().getRowType().getFieldCount()) {
+ return 1.0D;
+ }
return mq.getSelectivity(rel.getLeft(), predicate);
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
index b46e8b9f9..87a491a08 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
@@ -65,6 +65,7 @@
import org.apache.calcite.sql.SqlBinaryOperator;
import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCallParam;
+import org.apache.calcite.sql.SqlDelete;
import org.apache.calcite.sql.SqlDialect;
import org.apache.calcite.sql.SqlDynamicParam;
import org.apache.calcite.sql.SqlIdentifier;
@@ -395,9 +396,15 @@ public Result result(SqlNode node, Collection clauses,
return new Result(node, clauses, alias4, rel.getRowType(), aliases);
}
final String alias5;
+ /**
+ * set existForceIndex = true when forced index exists to make neededAlias not null,
+ * otherwise alias will be implicit in asFrom()
+ */
+ boolean existForceIndex = node.getKind() == SqlKind.IDENTIFIER && ((SqlIdentifier)node).indexNode != null;
if (alias2 == null
|| !alias2.equals(alias4)
- || !dialect.hasImplicitTableAlias()) {
+ || !dialect.hasImplicitTableAlias()
+ || existForceIndex) {
alias5 = alias4;
} else {
alias5 = null;
@@ -1435,7 +1442,7 @@ public SqlNode asFrom() {
//}
// MySQL only support syntax showed above.
// So that we must put AS OF in front of alias and index_hint_list behind alias
- if (node instanceof SqlIdentifier && ((SqlIdentifier) node).flashback != null
+ if (node instanceof SqlIdentifier
&& ((SqlIdentifier) node).indexNode != null) {
// Move index hint from identifier to alias
final SqlIdentifier identifier = (SqlIdentifier) node;
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
index 2677755ad..f193139b1 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/CalcRelSplitter.java
@@ -404,16 +404,21 @@ private int chooseLevels(
// For dynamic rex node (constant value), pull up its level to avoid project calculation.
int maxLevel = Integer.MIN_VALUE;
+ int[] maxRefLevel = new int[exprLevels.length];
+ Arrays.fill(maxRefLevel, Integer.MAX_VALUE);
for (int i = 0; i < exprLevels.length; i++) {
maxLevel = Math.max(maxLevel, exprLevels[i]);
+ for (int j : RexUtil.LocalRefFinder.findAllLocalRefs(exprs[i])) {
+ maxRefLevel[j] = Math.min(maxRefLevel[j], exprLevels[i]);
+ }
}
+
for (int i = 0; i < exprs.length; i++) {
RexNode rexNode = exprs[i];
if (rexNode instanceof RexDynamicParam) {
- exprLevels[i] = maxLevel;
+ exprLevels[i] = Math.min(maxRefLevel[i], maxLevel);
}
}
-
return levelCount;
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
index f65d874b1..8471a5ae3 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rel/rules/FilterAggregateTransposeRule.java
@@ -92,6 +92,13 @@ public void onMatch(RelOptRuleCall call) {
final Filter filterRel = call.rel(0);
final Aggregate aggRel = call.rel(1);
+ if (aggRel.getGroupCount() == 0) {
+ // We can not push the Filter pass the Aggregate without group keys. The whole
+ // input dataset would be the only group if there is no GROUP BY. Think about the case:
+ // 'select count(*) from T1 having false', the result is expected to be an empty set,
+ // but it would return zero if we push the Filter pass the Aggregate.
+ return;
+ }
final List conditions =
RelOptUtil.conjunctions(filterRel.getCondition());
final RexBuilder rexBuilder = filterRel.getCluster().getRexBuilder();
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexBuilder.java b/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexBuilder.java
index b90caa7f3..2da52809d 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -16,6 +16,7 @@
*/
package org.apache.calcite.rex;
+import com.alibaba.polardbx.common.datatype.Decimal;
import com.alibaba.polardbx.common.datatype.UInt64;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
@@ -906,6 +907,12 @@ public RexLiteral makeFlag(Enum flag) {
SqlTypeName.SYMBOL);
}
+ public RexLiteral makeCharNullLiteral() {
+ RelDataType type = typeFactory.createSqlType(SqlTypeName.CHAR);
+ type = typeFactory.createTypeWithNullability(type, true);
+ return new RexLiteral(null, type, SqlTypeName.CHAR);
+ }
+
/**
* Internal method to create a call to a literal. Code outside this package
* should call one of the type-specific methods such as
@@ -1635,6 +1642,10 @@ private static Object clean(Object o, RelDataType type) {
if (o instanceof BigDecimal) {
return o;
}
+ if (o instanceof Decimal) {
+ // avoid precision loss
+ return ((Decimal) o).toBigDecimal();
+ }
return new BigDecimal(((Number) o).longValue());
case FLOAT:
if (o instanceof BigDecimal) {
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexUtil.java b/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexUtil.java
index 643d6f7a5..ce6e0372a 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -16,25 +16,39 @@
*/
package org.apache.calcite.rex;
+import com.alibaba.polardbx.common.exception.TddlRuntimeException;
+import com.alibaba.polardbx.common.exception.code.ErrorCode;
import com.alibaba.polardbx.common.jdbc.ParameterContext;
import com.alibaba.polardbx.common.jdbc.RawString;
+import com.alibaba.polardbx.common.utils.logger.Logger;
+import com.alibaba.polardbx.common.utils.logger.LoggerFactory;
import com.alibaba.polardbx.druid.util.StringUtils;
+import com.alibaba.polardbx.util.RexMemoryLimitHelper;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
-import com.google.common.collect.*;
-import com.alibaba.polardbx.common.exception.TddlRuntimeException;
-import com.alibaba.polardbx.common.exception.code.ErrorCode;
-import com.alibaba.polardbx.common.utils.logger.Logger;
-import com.alibaba.polardbx.common.utils.logger.LoggerFactory;
-import com.alibaba.polardbx.util.RexMemoryLimitHelper;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import org.apache.calcite.linq4j.function.Predicate1;
import org.apache.calcite.plan.RelOptPredicateList;
import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.rel.*;
-import org.apache.calcite.rel.core.*;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelVisitor;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.core.CorrelationId;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.Project;
import org.apache.calcite.rel.logical.LogicalFilter;
import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.logical.LogicalTableScan;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
import org.apache.calcite.rel.type.RelDataTypeFamily;
@@ -42,7 +56,17 @@
import org.apache.calcite.rex.RexTableInputRef.RelTableRef;
import org.apache.calcite.runtime.PredicateImpl;
import org.apache.calcite.schema.Schemas;
-import org.apache.calcite.sql.*;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlBinaryOperator;
+import org.apache.calcite.sql.SqlFunction;
+import org.apache.calcite.sql.SqlIndexHint;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlPostfixOperator;
+import org.apache.calcite.sql.SqlPrefixOperator;
import org.apache.calcite.sql.dialect.MysqlSqlDialect;
import org.apache.calcite.sql.fun.SqlCaseOperator;
import org.apache.calcite.sql.fun.SqlCastFunction;
@@ -52,7 +76,6 @@
import org.apache.calcite.sql.type.SqlTypeFamily;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.sql.util.SqlString;
import org.apache.calcite.sql.validate.SqlValidatorUtil;
import org.apache.calcite.sql2rel.CorrelationReferenceFinder;
import org.apache.calcite.util.ControlFlowException;
@@ -61,12 +84,26 @@
import org.apache.calcite.util.Pair;
import org.apache.calcite.util.Util;
import org.apache.calcite.util.mapping.Mappings;
-import org.apache.http.protocol.ExecutionContext;
import javax.annotation.Nonnull;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
import java.util.stream.Collectors;
+import static org.apache.calcite.sql.type.SqlTypeName.CHAR_TYPES;
+import static org.apache.calcite.sql.type.SqlTypeName.INT_TYPES;
+
/**
* Utility methods concerning row-expressions.
*/
@@ -596,8 +633,14 @@ protected RexNode handle(RexFieldAccess fieldAccess) {
(RexCorrelVariable) fieldAccess.getReferenceExpr();
if (v.getId().equals(id)) {
RexCorrelVariable newRexCor = new RexCorrelVariable(v.getId(), type);
- int newIndex = shiftIndex.get(fieldAccess.getField().getIndex());
- RexFieldAccess newRexField = new RexFieldAccess(newRexCor, type.getFieldList().get(newIndex));
+ RexFieldAccess newRexField;
+ if(shiftIndex.containsKey(fieldAccess.getField().getIndex())){
+ int newIndex = shiftIndex.get(fieldAccess.getField().getIndex());
+ newRexField = new RexFieldAccess(newRexCor, type.getFieldList().get(newIndex));
+ }else{
+ newRexField = new RexFieldAccess(newRexCor, type.getFieldList().get(fieldAccess.getField().getIndex()));
+ }
+
return newRexField;
}
return fieldAccess;
@@ -2936,6 +2979,85 @@ public Void visitDynamicParam(RexDynamicParam dynamicParam) {
}
}
+ public static class EqualAndInExprFinder extends RexVisitorImpl {
+ private Map> map = Maps.newHashMap();
+ private List fields;
+
+ public EqualAndInExprFinder(LogicalTableScan scan) {
+ super(true);
+ fields = scan.getRowType().getFieldList();
+ }
+
+ public Void visitCall(RexCall call) {
+ if (call.getKind() == SqlKind.EQUALS) {
+ if (call.getOperands().get(0) instanceof RexInputRef &&
+ call.getOperands().get(1) instanceof RexDynamicParam) {
+ RexInputRef ref = (RexInputRef) call.getOperands().get(0);
+ RexDynamicParam param = (RexDynamicParam) call.getOperands().get(1);
+ RelDataType type = fields.get(ref.getIndex()).getType();
+ if (CHAR_TYPES.contains(type.getSqlTypeName()) &&
+ INT_TYPES.contains(param.getType().getSqlTypeName())) {
+ if (map.get("int2char") == null) {
+ map.put("int2char", Sets.newHashSet());
+ }
+ map.get("int2char").add(param.getIndex());
+ } else if (INT_TYPES.contains(type.getSqlTypeName())
+ && CHAR_TYPES.contains(param.getType().getSqlTypeName())) {
+ if (map.get("char2int") == null) {
+ map.put("char2int", Sets.newHashSet());
+ }
+ map.get("char2int").add(param.getIndex());
+ }
+ } else if (call.getOperands().get(1) instanceof RexInputRef &&
+ call.getOperands().get(0) instanceof RexDynamicParam) {
+ RexInputRef ref = (RexInputRef) call.getOperands().get(1);
+ RexDynamicParam param = (RexDynamicParam) call.getOperands().get(0);
+ RelDataType type = fields.get(ref.getIndex()).getType();
+ if (CHAR_TYPES.contains(type.getSqlTypeName())
+ && INT_TYPES.contains(param.getType().getSqlTypeName())) {
+ if (map.get("int2char") == null) {
+ map.put("int2char", Sets.newHashSet());
+ }
+ map.get("int2char").add(param.getIndex());
+ } else if (INT_TYPES.contains(type.getSqlTypeName())
+ && CHAR_TYPES.contains(param.getType().getSqlTypeName())) {
+ if (map.get("char2int") == null) {
+ map.put("char2int", Sets.newHashSet());
+ }
+ map.get("char2int").add(param.getIndex());
+ }
+ }
+ } else if (call.getKind() == SqlKind.IN) {
+ if (call.getOperands().get(0) instanceof RexInputRef &&
+ call.getOperands().get(1).getKind() == SqlKind.ROW &&
+ ((RexCall) call.getOperands().get(1)).getOperands().get(0) instanceof RexDynamicParam) {
+ RexInputRef ref = (RexInputRef) call.getOperands().get(0);
+ RexDynamicParam param =
+ (RexDynamicParam) ((RexCall) call.getOperands().get(1)).getOperands().get(0);
+ RelDataType type = fields.get(ref.getIndex()).getType();
+ if (CHAR_TYPES.contains(type.getSqlTypeName())) {
+ if (map.get("int2char") == null) {
+ map.put("int2char", Sets.newHashSet());
+ }
+ map.get("int2char").add(param.getIndex());
+ } else if (INT_TYPES.contains(type.getSqlTypeName())) {
+ if (map.get("char2int") == null) {
+ map.put("char2int", Sets.newHashSet());
+ }
+ map.get("char2int").add(param.getIndex());
+ }
+ }
+ } else {
+ return super.visitCall(call);
+ }
+ return null;
+ }
+
+ public Map> getMap() {
+ return map;
+ }
+ }
+
public static class SubQueryCounter extends RexVisitorImpl {
private int subqueryCount = 0;
@@ -3192,6 +3314,30 @@ public List getSubQueries() {
}
}
+ static public class LocalRefFinder extends RexVisitorImpl {
+ private Set rexLocalRefs = Sets.newHashSet();
+
+ protected LocalRefFinder() {
+ super(true);
+ }
+
+ @Override
+ public Void visitLocalRef(RexLocalRef localRef) {
+ rexLocalRefs.add(localRef.getIndex());
+ return null;
+ }
+
+ public Set getRexLocalRefs() {
+ return rexLocalRefs;
+ }
+
+ public static Set findAllLocalRefs(RexNode rexNode) {
+ LocalRefFinder localRefFinder = new LocalRefFinder();
+ rexNode.accept(localRefFinder);
+ return localRefFinder.getRexLocalRefs();
+ }
+ }
+
static public class AllIndexInFinder extends RexVisitorImpl {
private List indexList = Lists.newArrayList();
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTable.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTable.java
index 197e3129e..cae22244a 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTable.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTable.java
@@ -369,6 +369,10 @@ public boolean isExpireLocalPartition() {
return alters != null && alters.size() == 1 && alters.get(0) instanceof SqlAlterTableExpireLocalPartition;
}
+ public boolean isCleanupExpiredData() {
+ return alters != null && alters.size() == 1 && alters.get(0) instanceof SqlAlterTableCleanupExpiredData;
+ }
+
public boolean isAlterIndexVisibility() {
return alters != null
&& alters.size() == 1
@@ -480,6 +484,10 @@ public boolean isModifyPartitionValues() {
return alters.size() > 0 && alters.get(0) instanceof SqlAlterTableModifyPartitionValues;
}
+ public boolean isOptimizePartition() {
+ return alters.size() > 0 && alters.get(0) instanceof SqlAlterTableOptimizePartition;
+ }
+
public List getLogicalReferencedTables() {
return logicalReferencedTables;
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableArchivePartition.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableArchivePartition.java
new file mode 100644
index 000000000..7e40f13e7
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableArchivePartition.java
@@ -0,0 +1,100 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlString;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author wumu
+ */
+public class SqlAlterTableArchivePartition extends SqlAlterTable {
+
+ private final SqlIdentifier originTableName;
+
+ private Set targetPartitions;
+ private final boolean subPartitionsArchive;
+
+ public SqlAlterTableArchivePartition(SqlIdentifier tableName,
+ String sql,
+ Set targetPartitions,
+ boolean subPartitionsArchive) {
+ super(null, tableName, null, sql, null, new ArrayList<>(), SqlParserPos.ZERO);
+ originTableName = tableName;
+ this.targetPartitions = targetPartitions;
+ this.subPartitionsArchive = subPartitionsArchive;
+ }
+
+ @Override
+ public SqlIdentifier getOriginTableName() {
+ return originTableName;
+ }
+
+ @Override
+ public List getOperandList() {
+ return Arrays.asList(name);
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ unparse(writer, leftPrec, rightPrec, false);
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec, boolean withOriginTableName) {
+ final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.SELECT, "ALTER TABLE", "");
+
+ name.unparse(writer, leftPrec, rightPrec);
+
+ writer.endList(frame);
+ }
+
+ @Override
+ public void setTargetTable(SqlIdentifier sqlIdentifier) {
+ this.name = sqlIdentifier;
+ }
+
+ private String prepare() {
+ return getSourceSql();
+ }
+
+ public String getSchemaName() {
+ return originTableName.getComponent(0).getLastName();
+ }
+
+ public String getPrimaryTableName() {
+ return originTableName.getComponent(1).getLastName();
+ }
+
+ @Override
+ public SqlNode getTargetTable() {
+ return super.getTargetTable();
+ }
+
+ @Override
+ public String toString() {
+ return prepare();
+ }
+
+ @Override
+ public SqlString toSqlString(SqlDialect dialect) {
+ String sql = prepare();
+ return new SqlString(dialect, sql);
+ }
+
+ public Set getTargetPartitions() {
+ return targetPartitions;
+ }
+
+ public void setTargetPartitions(Set targetPartitions) {
+ this.targetPartitions = targetPartitions;
+ }
+
+ public boolean isSubPartitionsArchive() {
+ return subPartitionsArchive;
+ }
+
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableCleanupExpiredData.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableCleanupExpiredData.java
new file mode 100644
index 000000000..b649b7627
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableCleanupExpiredData.java
@@ -0,0 +1,46 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlString;
+
+import java.util.List;
+
+/**
+ * see com/alibaba/polardbx/druid/sql/dialect/mysql/parser/MySqlStatementParser.java:7484
+ * key words: "EXPIRE"
+ *
+ * @author guxu
+ */
+public class SqlAlterTableCleanupExpiredData extends SqlAlterSpecification {
+
+ private static final SqlOperator OPERATOR = new SqlSpecialOperator("CLEANUP EXPIRED DATA", SqlKind.CLEANUP_EXPIRED_DATA);
+
+ public SqlAlterTableCleanupExpiredData(SqlParserPos pos, List partitions) {
+ super(pos);
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public List getOperandList() {
+ return null;
+ }
+
+
+ @Override
+ public String toString() {
+ return "CLEANUP EXPIRED DATA";
+ }
+
+ @Override
+ public SqlString toSqlString(SqlDialect dialect) {
+ return new SqlString(dialect ,toString());
+ }
+
+
+ @Override
+ public boolean supportFileStorage() { return true;}
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableModifyTtlOptions.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableModifyTtlOptions.java
new file mode 100644
index 000000000..af919a60c
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableModifyTtlOptions.java
@@ -0,0 +1,163 @@
+package org.apache.calcite.sql;
+
+import com.alibaba.polardbx.druid.DbType;
+import com.alibaba.polardbx.druid.sql.SQLUtils;
+import org.apache.calcite.sql.parser.SqlParserPos;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**.
+ *
+ * @author chenghui.lch
+ */
+public class SqlAlterTableModifyTtlOptions extends SqlAlterSpecification {
+
+ private static final SqlOperator OPERATOR = new SqlSpecialOperator("MODIFY TTL", SqlKind.MODIFY_TTL);
+
+ private String ttlEnable = null;
+ private SqlNode ttlExpr = null;
+ private SqlNode ttlJob = null;
+ private String archiveTableSchema = null;
+ private String archiveTableName = null;
+ private String archiveKind = null;
+ private Integer arcPreAllocate = null;
+ private Integer arcPostAllocate = null;
+
+ public SqlAlterTableModifyTtlOptions(SqlParserPos pos) {
+ super(pos);
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public List getOperandList() {
+ List opList = new ArrayList<>();
+ opList.add(ttlExpr);
+ opList.add(ttlJob);
+ return opList;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.SELECT, "MODIFY TTL", "");
+
+ if (ttlEnable != null) {
+ writer.print(" TTL_ENABLE = ");
+ writer.print(String.format("'%s'", ttlEnable));
+ writer.print(" ");
+ }
+
+ if (ttlExpr != null) {
+ writer.print(" TTL_EXPR = ");
+ ttlExpr.unparse(writer,leftPrec, rightPrec);
+ writer.print(" ");
+ }
+
+ if (ttlJob != null) {
+ writer.print(" TTL_JOB = ");
+ ttlJob.unparse(writer,leftPrec, rightPrec);
+ writer.print(" ");
+ }
+
+ if (archiveTableSchema != null) {
+ writer.print(" ARCHIVE_TABLE_SCHEMA = ");
+ writer.print(String.format("'%s'", archiveTableSchema));
+ writer.print(" ");
+ }
+
+ if (archiveTableName != null) {
+ writer.print(" ARCHIVE_TABLE_NAME = ");
+ writer.print(String.format("'%s'", archiveTableSchema));
+ writer.print(" ");
+ }
+
+ if (archiveKind != null) {
+ writer.print(" ARCHIVE_KIND = ");
+ writer.print(String.format("'%s'", archiveKind));
+ writer.print(" ");
+ }
+
+ if (arcPreAllocate != null) {
+ writer.print(" ARC_PRE_ALLOCATE = ");
+ writer.print(arcPreAllocate);
+ writer.print(" ");
+ }
+
+ if (arcPostAllocate != null) {
+ writer.print(" ARC_POST_ALLOCATE = ");
+ writer.print(arcPostAllocate);
+ writer.print(" ");
+ }
+
+ writer.endList(frame);
+ }
+
+ public String getTtlEnable() {
+ return ttlEnable;
+ }
+
+ public void setTtlEnable(String ttlEnable) {
+ this.ttlEnable = ttlEnable;
+ }
+
+ public SqlNode getTtlExpr() {
+ return ttlExpr;
+ }
+
+ public void setTtlExpr(SqlNode ttlExpr) {
+ this.ttlExpr = ttlExpr;
+ }
+
+ public SqlNode getTtlJob() {
+ return ttlJob;
+ }
+
+ public void setTtlJob(SqlNode ttlJob) {
+ this.ttlJob = ttlJob;
+ }
+
+ public String getArchiveTableName() {
+ return archiveTableName;
+ }
+
+ public void setArchiveTableName(String archiveTableName) {
+ this.archiveTableName = archiveTableName;
+ }
+
+ public String getArchiveTableSchema() {
+ return archiveTableSchema;
+ }
+
+ public void setArchiveTableSchema(String archiveTableSchema) {
+ this.archiveTableSchema = archiveTableSchema;
+ }
+
+ public String getArchiveKind() {
+ return archiveKind;
+ }
+
+ public void setArchiveKind(String archiveKind) {
+ this.archiveKind = archiveKind;
+ }
+
+ public Integer getArcPreAllocate() {
+ return arcPreAllocate;
+ }
+
+ public void setArcPreAllocate(Integer arcPreAllocate) {
+ this.arcPreAllocate = arcPreAllocate;
+ }
+
+ public Integer getArcPostAllocate() {
+ return arcPostAllocate;
+ }
+
+ public void setArcPostAllocate(Integer arcPostAllocate) {
+ this.arcPostAllocate = arcPostAllocate;
+ }
+
+}
\ No newline at end of file
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableMovePartition.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableMovePartition.java
index 226b4cc96..5753381cf 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableMovePartition.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableMovePartition.java
@@ -17,7 +17,6 @@
package org.apache.calcite.sql;
import org.apache.calcite.sql.parser.SqlParserPos;
-import org.eclipse.jetty.util.BlockingCallback;
import java.util.List;
import java.util.Map;
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableOptimizePartition.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableOptimizePartition.java
new file mode 100644
index 000000000..f10afd261
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableOptimizePartition.java
@@ -0,0 +1,90 @@
+package org.apache.calcite.sql;
+
+import com.alibaba.polardbx.common.utils.GeneralUtil;
+import com.alibaba.polardbx.druid.sql.ast.SQLExpr;
+import com.alibaba.polardbx.druid.sql.ast.SQLName;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author chenghui.lch
+ */
+public class SqlAlterTableOptimizePartition extends SqlAlterSpecification {
+
+ private static final SqlOperator OPERATOR = new SqlSpecialOperator("OPTIMIZE PARTITION", SqlKind.OPTIMIZE_PARTITION);
+
+ protected final List partitions;
+
+ protected SqlNode parent;
+ protected boolean isSubPartition;
+
+ public SqlAlterTableOptimizePartition(SqlParserPos pos, List partitions, boolean isSubPartition) {
+ super(pos);
+ this.partitions = partitions;
+ this.isSubPartition = isSubPartition;
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public List getOperandList() {
+ return this.partitions;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.SELECT, "OPTIMIZE", "");
+
+ writer.keyword("PARTITION");
+ final SqlWriter.Frame partFrame = writer.startList(SqlWriter.FrameTypeEnum.SELECT, "(", ")");
+ int i = 0;
+ for (SqlNode sqlNode : partitions) {
+ sqlNode.unparse(writer, leftPrec, rightPrec);
+ i++;
+ if (i < partitions.size()) {
+ writer.sep(",");
+ }
+ }
+ writer.endList(partFrame);
+
+ writer.endList(frame);
+ }
+
+ public List getPartitions() {
+ return partitions;
+ }
+
+ public SqlNode getParent() {
+ return parent;
+ }
+
+ public void setParent(SqlNode parent) {
+ this.parent = parent;
+ }
+
+ @Override
+ public void validate(SqlValidator validator, SqlValidatorScope scope) {
+ validator.setColumnReferenceExpansion(false);
+ if (GeneralUtil.isNotEmpty(partitions)) {
+ List partDefs = new ArrayList<>();
+ partDefs.addAll(partitions);
+ int partColCnt = -1;
+ SqlPartitionBy.validatePartitionDefs(validator, scope, partDefs, partColCnt, -1, true, false);
+ }
+ }
+
+ public boolean isSubPartition() {
+ return isSubPartition;
+ }
+
+ public void setSubPartition(boolean subPartition) {
+ isSubPartition = subPartition;
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableRemoveTtlOptions.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableRemoveTtlOptions.java
new file mode 100644
index 000000000..b6d1c550c
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlAlterTableRemoveTtlOptions.java
@@ -0,0 +1,36 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**.
+ *
+ * @author chenghui.lch
+ */
+public class SqlAlterTableRemoveTtlOptions extends SqlAlterSpecification {
+
+ private static final SqlOperator OPERATOR = new SqlSpecialOperator("REMOVE TTL", SqlKind.REMOVE_TTL);
+
+ public SqlAlterTableRemoveTtlOptions(SqlParserPos pos) {
+ super(pos);
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public List getOperandList() {
+ List opList = new ArrayList<>();
+ return opList;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.SELECT, "REMOVE TTL", "");
+ writer.endList(frame);
+ }
+}
\ No newline at end of file
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlBaseline.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlBaseline.java
index c5101b936..f9a034837 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlBaseline.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlBaseline.java
@@ -38,20 +38,17 @@ public class SqlBaseline extends SqlDal {
private String operation;
private List baselineIds = new ArrayList<>();
- private SqlSelect select;
- private SqlNode statement;
+ private SqlNode select;
private String sql;
private String parameterizedSql;
private String hint;
- public SqlBaseline(SqlParserPos pos, String operation, List baselineIds, SqlSelect select,
- SqlNode statement) {
+ public SqlBaseline(SqlParserPos pos, String operation, List baselineIds, SqlNode select) {
super(pos);
this.operands = new ArrayList<>(0);
this.operation = operation;
this.baselineIds.addAll(baselineIds);
this.select = select;
- this.statement = statement;
this.operator = new SqlBaselineOperator(operation);
}
@@ -72,14 +69,6 @@ public void setBaselineIds(List baselineIds) {
this.baselineIds.addAll(baselineIds);
}
- public SqlSelect getSelect() {
- return select;
- }
-
- public void setSelect(SqlSelect select) {
- this.select = select;
- }
-
public String getHint() {
return hint;
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarIndex.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarIndex.java
index b6c8273d2..af437c877 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarIndex.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarIndex.java
@@ -39,12 +39,16 @@ public class SqlCheckColumnarIndex extends SqlDdl { // Use DDL here to utilize a
private SqlIdentifier tableName;
private String extraCmd;
- public SqlCheckColumnarIndex(SqlParserPos pos, SqlIdentifier indexName, SqlIdentifier tableName, String extraCmd) {
+ private List extras;
+
+ public SqlCheckColumnarIndex(SqlParserPos pos, SqlIdentifier indexName, SqlIdentifier tableName, String extraCmd,
+ List extras) {
super(OPERATOR, pos);
this.name = indexName;
this.indexName = indexName;
this.tableName = tableName;
this.extraCmd = extraCmd;
+ this.extras = extras;
}
public SqlIdentifier getIndexName() {
@@ -136,19 +140,23 @@ public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, S
@Override
public SqlNode clone(SqlParserPos pos) {
- return new SqlCheckColumnarIndex(this.pos, indexName, tableName, extraCmd);
+ return new SqlCheckColumnarIndex(this.pos, indexName, tableName, extraCmd, extras);
}
public SqlCheckColumnarIndex replaceIndexName(SqlIdentifier newIndexName) {
- return new SqlCheckColumnarIndex(pos, newIndexName, tableName, extraCmd);
+ return new SqlCheckColumnarIndex(pos, newIndexName, tableName, extraCmd, extras);
}
public boolean withTableName() {
return null != tableName;
}
+ public List getExtras() {
+ return extras;
+ }
+
public enum CheckCciExtraCmd {
- UNKNOWN, DEFAULT, CHECK, LOCK, CLEAR, SHOW, META;
+ UNKNOWN, DEFAULT, CHECK, LOCK, CLEAR, SHOW, META, INCREMENT, SNAPSHOT;
private static final Map VALUE_MAP = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
static {
@@ -157,6 +165,8 @@ public enum CheckCciExtraCmd {
VALUE_MAP.put("CLEAR", CLEAR);
VALUE_MAP.put("SHOW", SHOW);
VALUE_MAP.put("META", META);
+ VALUE_MAP.put("INCREMENT", INCREMENT);
+ VALUE_MAP.put("SNAPSHOT", SNAPSHOT);
}
public static CheckCciExtraCmd of(String stringVal) {
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarSnapshot.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarSnapshot.java
new file mode 100644
index 000000000..0eba7ca0f
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCheckColumnarSnapshot.java
@@ -0,0 +1,79 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SqlCheckColumnarSnapshot extends SqlDal {
+
+ private static final SqlSpecialOperator OPERATOR = new SqlCheckColumnarSnapshotOperator();
+
+ private SqlNode tableName;
+
+ public SqlCheckColumnarSnapshot(SqlParserPos pos, SqlNode tableName) {
+ super(pos);
+ this.tableName = tableName;
+ }
+
+ public SqlNode getTableName() {
+ return tableName;
+ }
+
+ public void setTableNames(SqlNode tableName) {
+ this.tableName = tableName;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ final SqlWriter.Frame selectFrame = writer.startList(SqlWriter.FrameTypeEnum.SELECT);
+ writer.sep("CHECK COLUMNAR SNAPSHOT");
+ tableName.unparse(writer, leftPrec, rightPrec);
+ writer.endList(selectFrame);
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public SqlKind getKind() {
+ return SqlKind.CHECK_COLUMNAR_SNAPSHOT;
+ }
+
+ @Override
+ public void validate(SqlValidator validator, SqlValidatorScope scope) {
+ }
+
+ public static class SqlCheckColumnarSnapshotOperator extends SqlSpecialOperator {
+
+ public SqlCheckColumnarSnapshotOperator() {
+ super("CHECK_COLUMNAR_SNAPSHOT", SqlKind.CHECK_COLUMNAR_SNAPSHOT);
+ }
+
+ @Override
+ public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, SqlCall call) {
+ final RelDataTypeFactory typeFactory = validator.getTypeFactory();
+ List columns = new ArrayList<>();
+ columns.add(
+ new RelDataTypeFieldImpl("Columnar_Index_Name", 0, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("Partition_Name", 1, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("Result", 2, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("Diff", 3, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("Advice", 4, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ return typeFactory.createStructType(columns);
+ }
+ }
+
+ @Override
+ public SqlNode clone(SqlParserPos pos) {
+ return new SqlCheckColumnarSnapshot(this.pos, tableName);
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateIndex.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateIndex.java
index e9fbb4dd4..d984ab226 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateIndex.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateIndex.java
@@ -17,6 +17,7 @@
package org.apache.calcite.sql;
import com.alibaba.polardbx.common.ColumnarTableOptions;
+import com.alibaba.polardbx.common.ColumnarOptions;
import com.alibaba.polardbx.common.utils.GeneralUtil;
import com.alibaba.polardbx.druid.sql.SQLUtils;
import com.alibaba.polardbx.druid.sql.ast.SQLExpr;
@@ -35,10 +36,8 @@
import org.apache.calcite.sql.pretty.SqlPrettyWriter;
import org.apache.calcite.sql.util.SqlString;
import org.apache.calcite.util.ImmutableNullableList;
-import org.apache.commons.collections.CollectionUtils;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -90,6 +89,7 @@ public class SqlCreateIndex extends SqlCreate {
private SqlCreateTable primaryTableNode;
private final boolean withImplicitTableGroup;
private boolean visible = true;
+ private final Map columnarOptions;
private SqlCreateIndex(SqlParserPos pos,
SqlIdentifier indexName,
@@ -117,7 +117,8 @@ private SqlCreateIndex(SqlParserPos pos,
boolean withImplicitTableGroup,
SqlNode engineName,
List dictColumns,
- boolean visible) {
+ boolean visible,
+ Map columnarOptions) {
super(OPERATOR, pos, false, false);
this.indexName = indexName;
this.originIndexName = originIndexName;
@@ -146,6 +147,7 @@ private SqlCreateIndex(SqlParserPos pos,
this.engineName = engineName;
this.dictColumns = dictColumns;
this.visible = visible;
+ this.columnarOptions = columnarOptions;
}
public SqlCreateIndex(SqlParserPos pos,
@@ -179,7 +181,8 @@ public SqlCreateIndex(SqlParserPos pos,
boolean withImplicitTableGroup,
SqlNode engineName,
List dictColumns,
- boolean visible) {
+ boolean visible,
+ Map columnarOptions) {
super(OPERATOR, pos, replace, ifNotExists);
this.name = name;
this.originTableName = originTableName;
@@ -210,6 +213,7 @@ public SqlCreateIndex(SqlParserPos pos,
this.engineName = engineName;
this.dictColumns = dictColumns;
this.visible = visible;
+ this.columnarOptions = columnarOptions;
}
public static SqlCreateIndex createLocalIndex(SqlIdentifier indexName, SqlIdentifier tableName,
@@ -246,7 +250,8 @@ public static SqlCreateIndex createLocalIndex(SqlIdentifier indexName, SqlIdenti
withImplicitTableGroup,
null,
null,
- true);
+ true,
+ null);
}
public static SqlCreateIndex createGlobalIndex(SqlParserPos pos, SqlIdentifier indexName, SqlIdentifier table,
@@ -284,7 +289,8 @@ public static SqlCreateIndex createGlobalIndex(SqlParserPos pos, SqlIdentifier i
withImplicitTableGroup,
null,
null,
- visible);
+ visible,
+ null);
}
public static SqlCreateIndex createClusteredIndex(SqlParserPos pos, SqlIdentifier indexName, SqlIdentifier table,
@@ -323,7 +329,8 @@ public static SqlCreateIndex createClusteredIndex(SqlParserPos pos, SqlIdentifie
withImplicitTableGroup,
null,
null,
- visible);
+ visible,
+ null);
}
public static SqlCreateIndex createColumnarIndex(SqlParserPos pos, SqlIdentifier indexName, SqlIdentifier table,
@@ -339,7 +346,8 @@ public static SqlCreateIndex createColumnarIndex(SqlParserPos pos, SqlIdentifier
boolean withImplicitTableGroup,
SqlNode engineName,
List dictKeys,
- boolean visible) {
+ boolean visible,
+ Map columnarOptions) {
return new SqlCreateIndex(pos,
indexName,
indexName,
@@ -366,7 +374,8 @@ public static SqlCreateIndex createColumnarIndex(SqlParserPos pos, SqlIdentifier
withImplicitTableGroup,
engineName,
dictKeys,
- visible);
+ visible,
+ columnarOptions);
}
public SqlNode getEngineName() {
@@ -744,7 +753,8 @@ public SqlNode clone(SqlParserPos pos) {
withImplicitTableGroup,
engineName,
dictColumns,
- visible);
+ visible,
+ columnarOptions);
}
public SqlCreateIndex rebuildCovering(Collection coveringColumns) {
@@ -787,7 +797,8 @@ public SqlCreateIndex rebuildCovering(Collection coveringColumns) {
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
/**
@@ -824,7 +835,8 @@ public SqlCreateIndex rebuildToGsi(SqlIdentifier newName, SqlNode dbPartition) {
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
/**
@@ -861,7 +873,8 @@ public SqlCreateIndex rebuildToGsiNewPartition(SqlIdentifier newName, SqlNode ne
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
public SqlCreateIndex rebuildToExplicitLocal(SqlIdentifier newName, String sql) {
@@ -891,7 +904,8 @@ public SqlCreateIndex rebuildToExplicitLocal(SqlIdentifier newName, String sql)
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
public SqlCreateIndex replaceTableName(SqlIdentifier newTableName) {
@@ -921,7 +935,8 @@ public SqlCreateIndex replaceTableName(SqlIdentifier newTableName) {
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
public SqlCreateIndex replaceIndexName(SqlIdentifier newIndexName) {
@@ -951,20 +966,24 @@ public SqlCreateIndex replaceIndexName(SqlIdentifier newIndexName) {
withImplicitTableGroup,
engineName,
dictColumns,
- this.visible);
+ this.visible,
+ columnarOptions);
}
/**
* columnar index options
*/
public Map getColumnarOptions() {
- Map options = new HashMap<>();
- if (CollectionUtils.isNotEmpty(dictColumns)) {
- String columns = dictColumns.stream()
- .map(sqlIndexColumnName -> SqlIdentifier.surroundWithBacktick(sqlIndexColumnName.getColumnNameStr()))
- .collect(Collectors.joining(","));
- options.put(ColumnarTableOptions.DICTIONARY_COLUMNS, columns);
+ Map options = columnarOptions;
+ // Normalize dict columns.
+ String dictColumnStr = options.get(ColumnarOptions.DICTIONARY_COLUMNS);
+ if (null != dictColumnStr) {
+ dictColumnStr = SQLUtils.splitNamesByComma(dictColumnStr.toLowerCase()).stream()
+ .map(SqlIdentifier::surroundWithBacktick)
+ .collect(Collectors.joining(","));
+ options.put(ColumnarOptions.DICTIONARY_COLUMNS, dictColumnStr);
}
+
return options;
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateTable.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateTable.java
index ca20cf251..f6d1f9e19 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateTable.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlCreateTable.java
@@ -35,13 +35,13 @@
import com.alibaba.polardbx.druid.sql.ast.SQLOrderingSpecification;
import com.alibaba.polardbx.druid.sql.ast.SQLPartitionByRange;
import com.alibaba.polardbx.druid.sql.ast.SQLStatement;
+import com.alibaba.polardbx.druid.sql.ast.expr.SQLCharExpr;
import com.alibaba.polardbx.druid.sql.ast.expr.SQLHexExpr;
import com.alibaba.polardbx.druid.sql.ast.expr.SQLIdentifierExpr;
import com.alibaba.polardbx.druid.sql.ast.expr.SQLIntegerExpr;
import com.alibaba.polardbx.druid.sql.ast.expr.SQLMethodInvokeExpr;
import com.alibaba.polardbx.druid.sql.ast.expr.SQLPropertyExpr;
import com.alibaba.polardbx.druid.sql.ast.statement.SQLAssignItem;
-import com.alibaba.polardbx.druid.sql.ast.statement.SQLCharacterDataType;
import com.alibaba.polardbx.druid.sql.ast.statement.SQLColumnDefinition;
import com.alibaba.polardbx.druid.sql.ast.statement.SQLColumnPrimaryKey;
import com.alibaba.polardbx.druid.sql.ast.statement.SQLColumnUniqueKey;
@@ -63,6 +63,7 @@
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import lombok.Data;
import org.apache.calcite.linq4j.Enumerator;
import org.apache.calcite.linq4j.Linq4j;
import org.apache.calcite.linq4j.QueryProvider;
@@ -106,6 +107,7 @@
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
@@ -115,7 +117,6 @@
import static com.alibaba.polardbx.common.TddlConstants.IMPLICIT_COL_NAME;
import static com.alibaba.polardbx.common.TddlConstants.IMPLICIT_KEY_NAME;
-import static com.alibaba.polardbx.common.TddlConstants.UGSI_PK_INDEX_NAME;
import static com.alibaba.polardbx.common.exception.code.ErrorCode.ERR_CREATE_SELECT_WITH_OSS;
/**
@@ -164,6 +165,17 @@ public class SqlCreateTable extends SqlCreate {
private List> fullTextKeys;
private List> spatialKeys;
private List> foreignKeys;
+
+ public List getLocalIndexes() {
+ return localIndexes;
+ }
+
+ public void setLocalIndexes(
+ List localIndexes) {
+ this.localIndexes = localIndexes;
+ }
+
+ private List localIndexes;
private List checks;
private List logicalReferencedTables = null;
@@ -200,6 +212,12 @@ public class SqlCreateTable extends SqlCreate {
private SqlNode sqlPartition = null;
private SqlNode localPartition = null;
+ // for row-level ttl definition
+ private String ttlEnable = null;
+ private SqlNode ttlExpr = null;
+ private SqlNode ttlJob = null;
+ private SqlNode ttlDefinition = null;
+
private SqlNode tableGroupName = null;
private boolean withImplicitTableGroup = false;
private SqlNode joinGroupName = null;
@@ -208,6 +226,9 @@ public class SqlCreateTable extends SqlCreate {
private Engine engine = null;
private ArchiveMode archiveMode;
+ /**
+ * the target table
+ */
private String loadTableName = null;
private String loadTableSchema = null;
@@ -225,6 +246,11 @@ public class SqlCreateTable extends SqlCreate {
boolean replaceInto = false;
protected boolean onlyConvertTableMode = false;
+ @Data
+ public static class PrepareSqlStringOptions {
+ protected boolean ttlDefinitionAllowed = false;
+ }
+
public void setIgnore(boolean ignore) {
this.ignore = ignore;
}
@@ -443,7 +469,8 @@ public SqlCreateTable(SqlParserPos pos, boolean replace, boolean ifNotExists, Sq
boolean pushDownForeignKeys,
boolean replaceInto,
String rowFormat,
- boolean uniqueShardingKey) {
+ boolean uniqueShardingKey,
+ SqlNode ttlDefinition) {
super(OPERATOR, pos, replace, ifNotExists);
this.name = name;
this.likeTableName = likeTableName;
@@ -503,6 +530,8 @@ public SqlCreateTable(SqlParserPos pos, boolean replace, boolean ifNotExists, Sq
this.replaceInto = replaceInto;
this.rowFormat = rowFormat;
this.uniqueShardingKey = uniqueShardingKey;
+ this.ttlDefinition = ttlDefinition;
+
}
public boolean shouldLoad() {
@@ -825,6 +854,38 @@ public void setDBPartition(boolean newPartitionDb) {
DbPartition = newPartitionDb;
}
+ public String getTtlEnable() {
+ return ttlEnable;
+ }
+
+ public void setTtlEnable(String ttlEnable) {
+ this.ttlEnable = ttlEnable;
+ }
+
+ public SqlNode getTtlExpr() {
+ return ttlExpr;
+ }
+
+ public void setTtlExpr(SqlNode ttlExpr) {
+ this.ttlExpr = ttlExpr;
+ }
+
+ public SqlNode getTtlJob() {
+ return ttlJob;
+ }
+
+ public void setTtlJob(SqlNode ttlJob) {
+ this.ttlJob = ttlJob;
+ }
+
+ public SqlNode getTtlDefinition() {
+ return ttlDefinition;
+ }
+
+ public void setTtlDefinition(SqlNode ttlDefinition) {
+ this.ttlDefinition = ttlDefinition;
+ }
+
/**
* Column definition.
*/
@@ -1077,7 +1138,8 @@ public SqlCreateTable clone(SqlParserPos pos) {
pushDownForeignKeys,
replaceInto,
rowFormat,
- uniqueShardingKey);
+ uniqueShardingKey,
+ ttlDefinition);
ret.setWithImplicitTableGroup(withImplicitTableGroup);
return ret;
}
@@ -1238,6 +1300,7 @@ private void addLocalIndexesForShardKeys(MySqlCreateTableStatement stmt, Set partKeyList = shardKeys.stream().collect(Collectors.toList());
List subPartKeyList = subPartKeys.stream().collect(Collectors.toList());
@@ -1256,18 +1319,18 @@ private void addLocalIndexesForShardKeys(MySqlCreateTableStatement stmt, Setof(), false, partStrategy, partKeyList, false, "");
}
}
}
- if (useSubPartBy) {
+ if (useSubPartBy && !isCreateTtlTmpTbl) {
// addCompositeIndex(subPartKeys, stmt);
SqlCreateTable.addCompositeIndexForAutoTbl(null, stmt,
false, ImmutableList.of(), false, subpartStrategy, subPartKeyList, false, "");
- if (usePartBy && addPartColIndexLater) {
+ if (usePartBy && addPartColIndexLater && !isCreateTtlTmpTbl) {
SqlCreateTable.addCompositeIndexForAutoTbl(null, stmt,
false, ImmutableList.of(), false, partStrategy, partKeyList, false, "");
}
@@ -1283,6 +1346,30 @@ public void addLocalPartitionSuffix(MySqlCreateTableStatement stmt) {
Lists.newArrayList(new SQLCommentHint("!50500 PARTITION BY " + localPartitionSuffix.toString())));
}
+ protected boolean isCreateTtlTmpTable(MySqlCreateTableStatement stmt) {
+ boolean isCreateTtlTmpTbl = false;
+ List options = stmt.getTableOptions();
+ for (int i = 0; i < options.size(); i++) {
+ SQLAssignItem option = options.get(i);
+ SQLExpr key = option.getTarget();
+ SQLExpr val = option.getValue();
+ if (key instanceof SQLIdentifierExpr) {
+ SQLIdentifierExpr keyId = (SQLIdentifierExpr) key;
+ String keyIdStr = SQLUtils.normalize(keyId.getName());
+ if (keyIdStr.equalsIgnoreCase("TTL_TEMPORARY")) {
+ if (val instanceof SQLCharExpr) {
+ SQLCharExpr valStrExpr = (SQLCharExpr) val;
+ String valStrExprVal = SQLUtils.normalizeNoTrim(valStrExpr.getText());
+ if (valStrExprVal != null && valStrExprVal.equalsIgnoreCase("Y")) {
+ isCreateTtlTmpTbl = true;
+ }
+ }
+ }
+ }
+ }
+ return isCreateTtlTmpTbl;
+ }
+
private static void removePolarDBXExclusiveFeature(MySqlCreateTableStatement stmt) {
final Iterator iterator = stmt.getTableElementList().iterator();
while (iterator.hasNext()) {
@@ -1323,17 +1410,17 @@ private static void removeLBACAttr(final MySqlCreateTableStatement stmt) {
}
}
Iterator optionIterator = stmt.getTableOptions().iterator();
- while (optionIterator.hasNext()){
+ while (optionIterator.hasNext()) {
SQLAssignItem item = optionIterator.next();
//去除表的安全策略
if (item.getTarget() instanceof SQLIdentifierExpr &&
- "SECURITY POLICY".equalsIgnoreCase(((SQLIdentifierExpr) item.getTarget()).getName())){
+ "SECURITY POLICY".equalsIgnoreCase(((SQLIdentifierExpr) item.getTarget()).getName())) {
optionIterator.remove();
}
}
}
- private String prepare() {
+ private String prepare(PrepareSqlStringOptions options) {
List statementList = SQLUtils.parseStatementsWithDefaultFeatures(sourceSql, JdbcConstants.MYSQL);
MySqlCreateTableStatement stmt = (MySqlCreateTableStatement) statementList.get(0);
Set shardKeys = new HashSet<>();
@@ -1363,6 +1450,37 @@ private String prepare() {
stmt.setPartitioning(null);
}
+ // local partition
+ if (localPartition == null) {
+ stmt.setLocalPartitioning(null);
+ }
+
+ // remove all ttl options for physql template
+ List tableOptions = stmt.getTableOptions();
+ List tableNewOptions = new ArrayList<>();
+ if (tableOptions != null) {
+ for (int i = 0; i < tableOptions.size(); i++) {
+ SQLAssignItem item = tableOptions.get(i);
+ SQLExpr key = item.getTarget();
+ if (key instanceof SQLIdentifierExpr) {
+ SQLIdentifierExpr id = (SQLIdentifierExpr) key;
+ String keyVal = id.getName();
+ if (keyVal.equalsIgnoreCase("TTL_ENABLE")
+ || keyVal.equalsIgnoreCase("TTL_LEVEL")
+ || keyVal.equalsIgnoreCase("TTL_EXPR")
+ || keyVal.equalsIgnoreCase("TTL_JOB")
+ || keyVal.equalsIgnoreCase("TTL")) {
+ if (options == null || !options.isTtlDefinitionAllowed()) {
+ continue;
+ }
+ }
+ }
+ tableNewOptions.add(item);
+ }
+ tableOptions.clear();
+ tableOptions.addAll(tableNewOptions);
+ }
+
if (localPartitionSuffix != null) {
addLocalPartitionSuffix(stmt);
}
@@ -1469,6 +1587,9 @@ public static void addForeignKeyIndex(Set shardKeys, MySqlCreateTableSta
}
+ /**
+ * 注：mysql8.0 函数索引会返回null，需注意返回值
+ */
public static String getIndexColumnName(final SQLSelectOrderByItem indexColumnDef) {
final SQLExpr expr = indexColumnDef.getExpr();
@@ -1527,18 +1648,22 @@ public static void addIndex(Map indexColumnDefMap, M
final String k = SQLUtils.normalizeNoTrim(((SQLIdentifierExpr) expr).getSimpleName());
// Do not add local index for foreign key column
- unindexedColumns.remove(k);
+ if (k != null) {
+ unindexedColumns.remove(k);
+ }
}
} else if (sqlTableElement instanceof MySqlTableIndex && !((MySqlTableIndex) sqlTableElement).isGlobal()) {
final String k = getIndexColumnName(((MySqlTableIndex) sqlTableElement).getColumns().get(0));
// Do not add local index for first column of existing local index
- unindexedColumns.remove(k);
+ if (k != null) {
+ unindexedColumns.remove(k);
+ }
// Store existing index name
Optional.ofNullable(((MySqlTableIndex) sqlTableElement).getName())
.map(in -> SQLUtils.normalizeNoTrim(in.getSimpleName())).ifPresent(existingIndexNames::add);
- if (gsi && indexColumns.contains(k) && needAddIndexColumns) { // Filter preliminarily
+ if (gsi && k != null && indexColumns.contains(k) && needAddIndexColumns) { // Filter preliminarily
final Set elementColumns = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
for (SQLSelectOrderByItem column : ((MySqlTableIndex) sqlTableElement).getColumns()) {
final String one = getIndexColumnName(column);
@@ -1546,10 +1671,7 @@ public static void addIndex(Map indexColumnDefMap, M
}
if (indexColumns.equals(elementColumns)) {
if (isUniqueIndex) {
- if (!((MySqlTableIndex) sqlTableElement).getName().getSimpleName()
- .equalsIgnoreCase(UGSI_PK_INDEX_NAME)) {
- it.remove(); // Need to be replaced with MySqlUnique
- }
+ it.remove(); // Need to be replaced with MySqlUnique
} else {
needAddIndexColumns = false;
((MySqlTableIndex) sqlTableElement).setIndexType(indexType);
@@ -1561,13 +1683,15 @@ public static void addIndex(Map indexColumnDefMap, M
final String k = getIndexColumnName(((MySqlKey) sqlTableElement).getColumns().get(0));
// Do not add local index for first column of existing local index
- unindexedColumns.remove(k);
+ if (k != null) {
+ unindexedColumns.remove(k);
+ }
// Store existing index name
Optional.ofNullable(((MySqlKey) sqlTableElement).getName())
.map(in -> SQLUtils.normalizeNoTrim(in.getSimpleName())).ifPresent(existingIndexNames::add);
- if (gsi && indexColumns.contains(k) && needAddIndexColumns) { // Filter preliminarily
+ if (gsi && k != null && indexColumns.contains(k) && needAddIndexColumns) { // Filter preliminarily
final Set elementColumns = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
for (SQLSelectOrderByItem column : ((MySqlKey) sqlTableElement).getColumns()) {
final String one = getIndexColumnName(column);
@@ -1576,11 +1700,7 @@ public static void addIndex(Map indexColumnDefMap, M
if (indexColumns.equals(elementColumns)) {
if (isUniqueIndex && !(sqlTableElement instanceof MySqlUnique)
&& !(sqlTableElement instanceof MySqlPrimaryKey)) {
- // never remove implicit pk info
- if (!((MySqlKey) sqlTableElement).getName().getSimpleName()
- .equalsIgnoreCase(UGSI_PK_INDEX_NAME)) {
- it.remove(); // Need to be replaced with MySqlUnique
- }
+ it.remove(); // Need to be replaced with MySqlUnique
} else if (sqlTableElement instanceof MySqlPrimaryKey) {
needAddIndexColumns = false;
} else {
@@ -2063,6 +2183,14 @@ public static Set getPartitionKeys(SqlNode partitionBy,
return allPartColNameSet;
}
+ public String toSqlStringForCdc(PrepareSqlStringOptions options) {
+ return prepare(options);
+ }
+
+ protected String prepare() {
+ return prepare(null);
+ }
+
@Override
public String toString() {
return prepare();
@@ -2505,6 +2633,7 @@ public static void addCompositeIndex(Map indexColumn
boolean autoShardIndexAlreadyExists = false;
boolean needAddIndexColumns = isGsi;
final Iterator it = stmt.getTableElementList().iterator();
+
while (it.hasNext()) {
final SQLTableElement sqlTableElement = it.next();
if (sqlTableElement instanceof SQLColumnDefinition) {
@@ -2538,10 +2667,12 @@ public static void addCompositeIndex(Map indexColumn
shardingColumnDefMap.put(columnName, columnDef);
}
- } else if (sqlTableElement instanceof MySqlTableIndex && !((MySqlTableIndex) sqlTableElement).isGlobal()) {
- if (((MySqlTableIndex) sqlTableElement).getColumns().size() > 0) {
+ } else if (sqlTableElement instanceof MySqlTableIndex) {
+ if (!((MySqlTableIndex) sqlTableElement).isGlobal()
+ && ((MySqlTableIndex) sqlTableElement).getColumns().size() > 0) {
List indexingColumnsName = ((MySqlTableIndex) sqlTableElement).getColumns()
- .stream().map(SqlCreateTable::getIndexColumnName).collect(Collectors.toList());
+ .stream().map(SqlCreateTable::getIndexColumnName).filter(Objects::nonNull)
+ .collect(Collectors.toList());
if (listContainsIgnoreCase(indexingColumnsName, shardingKey)) {
autoShardIndexAlreadyExists = true;
@@ -2553,18 +2684,19 @@ public static void addCompositeIndex(Map indexColumn
if (indexColumns.equals(elementColumns)) {
if (isUniqueIndex) {
- if (!((MySqlTableIndex) sqlTableElement).getName().getSimpleName()
- .equalsIgnoreCase(UGSI_PK_INDEX_NAME)) {
- it.remove(); // Need to be replaced with MySqlUnique
- }
+ it.remove(); // Need to be replaced with MySqlUnique
} else {
needAddIndexColumns = false;
}
}
}
}
- } else if (sqlTableElement instanceof MySqlKey && !(sqlTableElement instanceof MySqlUnique
- && ((MySqlUnique) sqlTableElement).isGlobal())) {
+ final MySqlTableIndex tableIndex = (MySqlTableIndex) sqlTableElement;
+ if (tableIndex.getName() != null) {
+ final String indexName = ((SQLIdentifierExpr) tableIndex.getName()).normalizedName();
+ existingIndexNames.add(indexName);
+ }
+ } else if (sqlTableElement instanceof MySqlKey) {
// if (((MySqlKey) sqlTableElement).getColumns().size() > 1) {
// existIndexList.add(sqlTableElement);
@@ -2588,9 +2720,12 @@ public static void addCompositeIndex(Map indexColumn
//
// }
- if (((MySqlKey) sqlTableElement).getColumns().size() > 0) {
+ if (!(sqlTableElement instanceof MySqlUnique
+ && ((MySqlUnique) sqlTableElement).isGlobal())
+ && ((MySqlKey) sqlTableElement).getColumns().size() > 0) {
List indexingColumnsName = ((MySqlKey) sqlTableElement).getColumns()
- .stream().map(SqlCreateTable::getIndexColumnName).collect(Collectors.toList());
+ .stream().map(SqlCreateTable::getIndexColumnName).filter(Objects::nonNull)
+ .collect(Collectors.toList());
if (listContainsIgnoreCase(indexingColumnsName, shardingKey)) {
autoShardIndexAlreadyExists = true;
@@ -2603,11 +2738,7 @@ public static void addCompositeIndex(Map indexColumn
if (indexColumns.equals(elementColumns)) {
if (isUniqueIndex && !(sqlTableElement instanceof MySqlUnique)
&& !(sqlTableElement instanceof MySqlPrimaryKey)) {
- // never remove implicit pk info
- if (!((MySqlKey) sqlTableElement).getName().getSimpleName()
- .equalsIgnoreCase(UGSI_PK_INDEX_NAME)) {
- it.remove(); // Need to be replaced with MySqlUnique
- }
+ it.remove(); // Need to be replaced with MySqlUnique
} else if (sqlTableElement instanceof MySqlPrimaryKey) {
needAddIndexColumns = false;
} else {
@@ -2617,6 +2748,11 @@ public static void addCompositeIndex(Map indexColumn
}
}
}
+ final MySqlKey tableIndex = (MySqlKey) sqlTableElement;
+ if (tableIndex.getName() != null) {
+ final String indexName = ((SQLIdentifierExpr) tableIndex.getName()).normalizedName();
+ existingIndexNames.add(indexName);
+ }
} else if (sqlTableElement instanceof MysqlForeignKey) {
// Store existing index name
Optional.ofNullable(((MysqlForeignKey) sqlTableElement).getName())
@@ -2690,7 +2826,8 @@ public static void addCompositeIndex(Map indexColumn
buildUnifiedIndexColumnDef(orderedIndexColumnNames, indexColumnDefMap, columnDefMap);
List indexingColumnsName =
- indexColumnList.stream().map(SqlCreateTable::getIndexColumnName).collect(Collectors.toList());
+ indexColumnList.stream().map(SqlCreateTable::getIndexColumnName).filter(Objects::nonNull)
+ .collect(Collectors.toList());
if (listContainsIgnoreCase(indexingColumnsName, shardingKey)) {
autoShardIndexAlreadyExists = true;
@@ -2714,7 +2851,8 @@ public static void addCompositeIndex(Map indexColumn
buildUnifiedIndexColumnDef(indexColumnDefMap.keySet(), indexColumnDefMap, columnDefMap);
List indexingColumnsName =
- indexColumnList.stream().map(SqlCreateTable::getIndexColumnName).collect(Collectors.toList());
+ indexColumnList.stream().map(SqlCreateTable::getIndexColumnName).filter(Objects::nonNull)
+ .collect(Collectors.toList());
if (listContainsIgnoreCase(indexingColumnsName, shardingKey)) {
autoShardIndexAlreadyExists = true;
@@ -2736,7 +2874,7 @@ public static void addCompositeIndex(Map indexColumn
// if (!indexAlreadExists) {
if (!autoShardIndexAlreadyExists || addFkIndex) {
List indexColumnInfos =
- preparAutoCompositeIndexs(shardingKey, columnDefMap, 191);
+ prepareAutoCompositeIndexes(shardingKey, columnDefMap, 191);
Set orderedIndexColumnNames = new LinkedHashSet<>(shardingKey);
final String suffix = buildUnifyIndexName(orderedIndexColumnNames, 45);
@@ -2767,15 +2905,15 @@ public static void addCompositeIndex(Map indexColumn
}
public static String buildForeignKeyName(String foreignKeyIndexName, Set existingIndexNames,
- String suffix) {
+ String suffix) {
return foreignKeyIndexName == null ?
buildForeignKeyIndexName(existingIndexNames, suffix) :
SqlIdentifier.surroundWithBacktick(foreignKeyIndexName);
}
- private static List preparAutoCompositeIndexs(List shardKeys,
- Map columnDefMap,
- int maxLen) {
+ private static List prepareAutoCompositeIndexes(List shardKeys,
+ Map columnDefMap,
+ int maxLen) {
int totalIndexLen = 0;
int totalCharTypeIndexLen = 0;
int charTypeCount = 0;
@@ -2945,6 +3083,7 @@ public int getColTypeLen() {
public boolean isCharType() {
return isCharType;
}
+
}
// End SqlCreateTable.java
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
index dd258330f..a31c9d95a 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
@@ -18,6 +18,7 @@
import com.alibaba.polardbx.common.charset.CharsetName;
import com.alibaba.polardbx.config.ConfigDataMode;
+import com.alibaba.polardbx.rpc.result.XResultUtil;
import com.google.common.base.Preconditions;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -437,10 +438,15 @@ public void unparse(
writer.endList(frame);
}
} else if (sqlTypeName.allowsPrec() && (precision >= 0)) {
+ // 15 is the default precision,
+ // see org.apache.calcite.rel.type.RelDataTypeSystemImpl.getDefaultPrecision for more details.
+ if (SqlTypeName.APPROX_TYPES.contains(sqlTypeName) && precision == 15) {
+ return;
+ }
final SqlWriter.Frame frame =
writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
writer.print(precision);
- if (sqlTypeName.allowsScale() && (scale >= 0)) {
+ if (sqlTypeName.allowsScale() && (scale >= 0) && scale < XResultUtil.DECIMAL_NOT_SPECIFIED) {
writer.sep(",", true);
writer.print(scale);
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDelete.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDelete.java
index 6661ba006..32b9709fc 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDelete.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlDelete.java
@@ -402,6 +402,46 @@ public SqlNodeList getAliases() {
return aliases;
}
+ /**
+ * get force index from sqlDelete
+ * @return SqlIdentifier
+ */
+ public SqlIdentifier getForceIndex() {
+ if (sourceSelect == null || sourceSelect.getFrom() == null || !(sourceSelect
+ .getFrom() instanceof SqlIdentifier)) {
+ return null;
+ }
+
+ SqlNodeList indexNodes = (SqlNodeList) ((SqlIdentifier) sourceSelect.getFrom()).indexNode;
+
+ if (indexNodes == null || indexNodes.size() == 0) {
+ return null;
+ }
+
+ // get first force index hint
+ SqlIndexHint sqlIndexHint = null;
+ for (SqlNode node : indexNodes) {
+ if (node instanceof SqlIndexHint && ((SqlIndexHint) node).forceIndex()) {
+ sqlIndexHint = (SqlIndexHint) node;
+ break;
+ }
+ }
+
+ if (sqlIndexHint == null) {
+ return null;
+ }
+
+ SqlNodeList indexList = sqlIndexHint.getIndexList();
+
+ if (indexList != null &&
+ indexList.size() > 0 &&
+ indexList.get(0) instanceof SqlIdentifier) {
+ return (SqlIdentifier) indexList.get(0);
+ }
+
+ return null;
+ }
+
public void setWithTableAlias(boolean withTableAlias) {
this.withTableAlias = withTableAlias;
}
@@ -433,6 +473,7 @@ public boolean isWithTableAlias() {
*/
writer.keyword("FROM");
targetTable.unparse(writer, opLeft, opRight);
+
if (alias != null) {
writer.keyword("AS");
alias.unparse(writer, opLeft, opRight);
@@ -508,7 +549,6 @@ public boolean singleTable() {
return false;
}
-
public SqlNode getSourceTableNode() {
if (fromUsing()) {
return using;
@@ -584,6 +624,12 @@ public SqlDelete initTableInfo(TableInfo srcInfo) {
this.subQueryTableMap = subQueryTableMap;
this.withTableAlias = withAlias.get();
+ if (this.sourceTables.size() == 1 && this.getSourceSelect().getFrom() != null
+ && this.getSourceSelect().getFrom().getKind() == SqlKind.AS) {
+ // set this.withTableAlias = true when single table delete with force index
+ setWithTableAlias(true);
+ }
+
this.sourceTableCollected = true;
return this;
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlFunction.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlFunction.java
index acb328cf8..ab5767e88 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlFunction.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlFunction.java
@@ -69,6 +69,7 @@ public String apply(Integer a0) {
NON_PUSHDOWN_FUNCTION.add(NEXTVAL_FUNC_NAME);
NON_PUSHDOWN_FUNCTION.add(CURRVAL_FUNC_NAME);
NON_PUSHDOWN_FUNCTION.add("PART_ROUTE");
+ NON_PUSHDOWN_FUNCTION.add("TIME_TO_TSO");
// Information Functions
NON_PUSHDOWN_FUNCTION.add("CONNECTION_ID");
@@ -136,6 +137,11 @@ public String apply(Integer a0) {
DYNAMIC_FUNCTION.add("USER");
DYNAMIC_FUNCTION.add("VERSION");
+ DYNAMIC_FUNCTION.add("GET_LOCK");
+ DYNAMIC_FUNCTION.add("IS_FREE_LOCK");
+ DYNAMIC_FUNCTION.add("IS_USED_LOCK");
+ DYNAMIC_FUNCTION.add("RELEASE_ALL_LOCKS");
+ DYNAMIC_FUNCTION.add("RELEASE_LOCK");
}
public static boolean isDynamic(SqlFunction func) {
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexDefinition.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexDefinition.java
index 876bbb312..8bcfb343c 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexDefinition.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexDefinition.java
@@ -75,6 +75,8 @@ public class SqlIndexDefinition extends SqlCall {
private final SqlNode engineName;
private final List dictColumns;
private final boolean withImplicitTableGroup;
+ // Key should be lowercase.
+ private final Map columnarOptions;
public SqlIndexDefinition(SqlParserPos pos,
boolean hasConstraint,
@@ -101,7 +103,8 @@ public SqlIndexDefinition(SqlParserPos pos,
SqlNode engineName,
List dictColumns,
boolean withImplicitTableGroup,
- boolean visible) {
+ boolean visible,
+ Map columnarOptions) {
super(pos);
this.hasConstraint = hasConstraint;
this.uniqueConstraint = uniqueConstraint;
@@ -128,6 +131,7 @@ public SqlIndexDefinition(SqlParserPos pos,
this.dictColumns = dictColumns;
this.withImplicitTableGroup = withImplicitTableGroup;
this.visible = visible;
+ this.columnarOptions = columnarOptions;
}
public SqlIndexDefinition(SqlParserPos pos,
@@ -157,7 +161,8 @@ public SqlIndexDefinition(SqlParserPos pos,
SqlNode engineName,
List dictColumns,
boolean withImplicitTableGroup,
- boolean visible) {
+ boolean visible,
+ Map columnarOptions) {
super(pos);
this.hasConstraint = hasConstraint;
this.uniqueConstraint = uniqueConstraint;
@@ -186,6 +191,7 @@ public SqlIndexDefinition(SqlParserPos pos,
this.dictColumns = dictColumns;
this.withImplicitTableGroup = withImplicitTableGroup;
this.visible = visible;
+ this.columnarOptions = columnarOptions;
}
public static SqlIndexDefinition localIndex(SqlParserPos pos, boolean hasConstraint,
@@ -217,7 +223,8 @@ public static SqlIndexDefinition localIndex(SqlParserPos pos, boolean hasConstra
null,
null,
false,
- true);
+ true,
+ null);
}
public static SqlIndexDefinition localIndex(SqlParserPos pos, boolean hasConstraint,
@@ -250,7 +257,8 @@ public static SqlIndexDefinition localIndex(SqlParserPos pos, boolean hasConstra
null,
null,
withImplicitTableGroup,
- true);
+ true,
+ null);
}
public static SqlIndexDefinition globalIndex(SqlParserPos pos, boolean hasConstraint,
@@ -286,7 +294,8 @@ public static SqlIndexDefinition globalIndex(SqlParserPos pos, boolean hasConstr
null,
null,
withImplicitTablegroup,
- visible);
+ visible,
+ null);
}
public static SqlIndexDefinition clusteredIndex(SqlParserPos pos, boolean hasConstraint,
@@ -322,7 +331,8 @@ public static SqlIndexDefinition clusteredIndex(SqlParserPos pos, boolean hasCon
null,
null,
withImplicitTablegroup,
- visible);
+ visible,
+ null);
}
public static SqlIndexDefinition columnarIndex(SqlParserPos pos, boolean hasConstraint,
@@ -334,7 +344,8 @@ public static SqlIndexDefinition columnarIndex(SqlParserPos pos, boolean hasCons
List clusteredKeys,
List options, SqlNode tableGroupName,
SqlNode engineName, List dictColumns,
- boolean withImplicitTablegroup, boolean visible) {
+ boolean withImplicitTablegroup, boolean visible,
+ Map columnarOptions) {
return new SqlIndexDefinition(pos,
hasConstraint,
uniqueConstraint,
@@ -360,7 +371,8 @@ public static SqlIndexDefinition columnarIndex(SqlParserPos pos, boolean hasCons
engineName,
dictColumns,
withImplicitTablegroup,
- visible);
+ visible,
+ columnarOptions);
}
@Override
@@ -417,7 +429,6 @@ public void unparse(SqlWriter writer, int leftPrec, int rightPrec, boolean withO
if (writer instanceof SqlPrettyWriter) {
((SqlPrettyWriter) writer).setQuoteAllIdentifiers(false);
}
-
if (null != dbPartitionBy) {
writer.keyword("DBPARTITION BY");
dbPartitionBy.unparse(writer, leftPrec, rightPrec);
@@ -631,6 +642,10 @@ public SqlNode getOriginPartitioning() {
return originPartitioning;
}
+ public Map getColumnarOptions() {
+ return columnarOptions;
+ }
+
public SqlIndexDefinition replacePartitioning(SqlNode newPartition) {
return new SqlIndexDefinition(pos,
hasConstraint,
@@ -659,7 +674,8 @@ public SqlIndexDefinition replacePartitioning(SqlNode newPartition) {
engineName,
dictColumns,
withImplicitTableGroup,
- visible);
+ visible,
+ columnarOptions);
}
public SqlIndexDefinition replaceCovering(Collection coveringColumns) {
@@ -700,7 +716,8 @@ public SqlIndexDefinition replaceCovering(Collection coveringColumns) {
engineName,
dictColumns,
withImplicitTableGroup,
- this.visible);
+ this.visible,
+ columnarOptions);
}
public SqlIndexDefinition mergeCovering(Collection coveringColumns) {
@@ -755,7 +772,8 @@ public SqlIndexDefinition mergeCovering(Collection coveringColumns) {
engineName,
dictColumns,
withImplicitTableGroup,
- visible);
+ visible,
+ columnarOptions);
}
}
@@ -795,7 +813,8 @@ public SqlIndexDefinition rebuildToGsi(SqlIdentifier newName, SqlNode dbPartitio
engineName,
dictColumns,
withImplicitTableGroup,
- visible);
+ visible,
+ columnarOptions);
}
/**
@@ -833,7 +852,8 @@ public SqlIndexDefinition rebuildToGsiNewPartition(SqlIdentifier newName, SqlNod
engineName,
dictColumns,
withImplicitTableGroup,
- visible);
+ visible,
+ columnarOptions);
}
public SqlIndexDefinition rebuildToExplicitLocal(SqlIdentifier newName) {
@@ -864,7 +884,8 @@ public SqlIndexDefinition rebuildToExplicitLocal(SqlIdentifier newName) {
engineName,
dictColumns,
withImplicitTableGroup,
- visible);
+ visible,
+ columnarOptions);
}
public SqlNode getPartitioning() {
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexHintOperator.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexHintOperator.java
index 87d8eb1c1..2b94317da 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexHintOperator.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlIndexHintOperator.java
@@ -23,6 +23,7 @@
import org.apache.calcite.util.Litmus;
import java.util.List;
+import java.util.Objects;
/**
*
@@ -108,9 +109,22 @@ public void unparse(
if (call.operandCount() > 2) {
SqlWriter.Frame frameFunc = writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
for (int i = 0; i < sqlNodeList.size(); i++) {
- SqlCharStringLiteral sqlNode = (SqlCharStringLiteral)sqlNodeList.get(i);
- String value2 = sqlNode.getNlsString().getValue();
- writer.sep(value2);
+ SqlNode node = sqlNodeList.get(i);
+ if (node instanceof SqlCharStringLiteral){
+ SqlCharStringLiteral sqlNode = (SqlCharStringLiteral)node;
+ String value2 = sqlNode.getNlsString().getValue();
+ writer.sep(value2);
+ } else if (node instanceof SqlIdentifier){
+ SqlIdentifier sqlNode = (SqlIdentifier)node;
+ String value2 = sqlNode.getLastName();
+ writer.sep(value2);
+ } else {
+ throw new IllegalArgumentException("not support sql hint:" + node);
+ }
+ if(Objects.equals(value0, "FORCE INDEX")){
+ // force index only support one index
+ break;
+ }
if (i != sqlNodeList.size() - 1) {
writer.sep(",");
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlKind.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlKind.java
index 30362e943..cd5684838 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlKind.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlKind.java
@@ -1022,6 +1022,20 @@ public enum SqlKind {
*/
SINGLE_VALUE,
+ /**
+ * The {@code JSON_OBJECTAGG} aggregate function.
+ */
+ JSON_OBJECTAGG,
+
+ JSON_OBJECT_GLOBALAGG,
+
+ /**
+ * The {@code JSON_ARRAYAGG} aggregate function.
+ */
+ JSON_ARRAYAGG,
+
+ JSON_ARRAY_GLOBALAGG,
+
/**
* The {code __FIRST_VALUE} internal aggregate function.
*/
@@ -1596,6 +1610,8 @@ public enum SqlKind {
SHOW_DDL_JOBS,
+ SHOW_DDL_ENGINE,
+
SHOW_DDL_RESULTS,
SHOW_SCHEDULE_RESULTS,
@@ -1696,6 +1712,8 @@ public enum SqlKind {
CHECK_COLUMNAR_PARTITION,
+ CHECK_COLUMNAR_SNAPSHOT,
+
CHECK_COLUMNAR_INDEX, // As a special DDL.
CHECK_GLOBAL_INDEX, // As a special DDL.
@@ -1750,6 +1768,8 @@ public enum SqlKind {
TERMINATE_REBALANCE_JOB,
+ RESUME_REBALANCE_JOB,
+
SKIP_REBALANCE_SUBJOB,
REMOVE_DDL_JOB,
@@ -1831,6 +1851,11 @@ public enum SqlKind {
*/
EXCHANGE_PARTITION,
+ /**
+ * partition management: optimize partition.
+ */
+ OPTIMIZE_PARTITION,
+
/**
* partition management: alter table group split into partitions xxx by hot value(xxx[,..,xxx])
*/
@@ -1841,6 +1866,10 @@ public enum SqlKind {
*/
MODIFY_SUBPARTITION,
+ MODIFY_TTL,
+
+ REMOVE_TTL,
+
/**
* partition management: create new tablegroup
*/
@@ -1932,6 +1961,11 @@ public enum SqlKind {
*/
REPARTITION_LOCAL_PARTITION,
+ /**
+ * expire local partition
+ */
+ CLEANUP_EXPIRED_DATA,
+
LOCAL_PARTITION,
CREATE_FUNCTION,
@@ -2071,6 +2105,7 @@ public enum SqlKind {
SHOW_DDL_STATUS,
SHOW_REBALANCE_BACKFILL,
SHOW_DDL_JOBS,
+ SHOW_DDL_ENGINE,
SHOW_DDL_RESULTS,
SHOW_SCHEDULE_RESULTS,
SHOW_LOCALITY_INFO,
@@ -2123,6 +2158,7 @@ public enum SqlKind {
CHECK_GLOBAL_INDEX,
CHECK_COLUMNAR_INDEX,
CHECK_COLUMNAR_PARTITION,
+ CHECK_COLUMNAR_SNAPSHOT,
ANALYZE_TABLE,
OPTIMIZE_TABLE);
@@ -2134,6 +2170,7 @@ public enum SqlKind {
PAUSE_REBALANCE_JOB,
ROLLBACK_DDL_JOB,
TERMINATE_REBALANCE_JOB,
+ RESUME_REBALANCE_JOB,
SKIP_REBALANCE_SUBJOB,
REMOVE_DDL_JOB,
INSPECT_DDL_JOB_CACHE,
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTable.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTable.java
index ca2e54b57..8d70c3006 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTable.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTable.java
@@ -16,7 +16,6 @@
package org.apache.calcite.sql;
-import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTableDdl.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTableDdl.java
index 6af6ea901..c0345d266 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTableDdl.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlOptimizeTableDdl.java
@@ -17,10 +17,12 @@
package org.apache.calcite.sql;
import com.google.common.base.Joiner;
+import groovy.sql.Sql;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.validate.SqlValidator;
import org.apache.calcite.sql.validate.SqlValidatorScope;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -31,11 +33,11 @@ public class SqlOptimizeTableDdl extends SqlDdl { // Use DDL here to utilize asy
private static final SqlSpecialOperator OPERATOR = new SqlOptimizeTable.SqlOptimizeTableOperator();
- private final List tableNames;
- private final boolean noWriteToBinlog;
- private final boolean local;
+ private List tableNames;
+ private final boolean noWriteToBinlog;
+ private final boolean local;
- public SqlOptimizeTableDdl(SqlParserPos pos, List tableNames, boolean noWriteToBinlog, boolean local){
+ public SqlOptimizeTableDdl(SqlParserPos pos, List tableNames, boolean noWriteToBinlog, boolean local) {
super(OPERATOR, pos);
this.name = tableNames.get(0);
this.tableNames = tableNames;
@@ -43,6 +45,14 @@ public SqlOptimizeTableDdl(SqlParserPos pos, List tableNames, boolean n
this.local = local;
}
+ @Override
+ public void setTargetTable(SqlNode sqlIdentifier) {
+ super.setTargetTable(sqlIdentifier);
+ List newTableNames = new ArrayList<>();
+ newTableNames.add(name);
+ this.tableNames = newTableNames;
+ }
+
@Override
public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
final SqlWriter.Frame selectFrame = writer.startList(SqlWriter.FrameTypeEnum.SELECT);
@@ -68,7 +78,7 @@ public SqlOperator getOperator() {
@Override
public List getOperandList() {
- return Arrays.asList(name);
+ return tableNames;
}
@Override
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlResumeRebalanceJob.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlResumeRebalanceJob.java
new file mode 100644
index 000000000..30dd12f7f
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlResumeRebalanceJob.java
@@ -0,0 +1,90 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author wumu
+ */
+public class SqlResumeRebalanceJob extends SqlDal implements DdlJobUtility {
+
+ private static final SqlSpecialOperator OPERATOR = new SqlResumeRebalanceJobOperator();
+ private boolean all;
+ private List jobIds = new ArrayList<>();
+
+ public SqlResumeRebalanceJob(SqlParserPos pos, boolean all) {
+ super(pos);
+ this.operands = new ArrayList<>(0);
+ this.all = all;
+ }
+
+ @Override
+ public boolean isAll() {
+ return all;
+ }
+
+ public void setAll(boolean all) {
+ this.all = all;
+ }
+
+ @Override
+ public List getJobIds() {
+ return jobIds;
+ }
+
+ public void setJobIds(List jobIds) {
+ this.jobIds.clear();
+ this.jobIds.addAll(jobIds);
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ final SqlWriter.Frame selectFrame = writer.startList(SqlWriter.FrameTypeEnum.SELECT);
+ writer.sep("RESUME REBALANCE");
+ if (isAll()) {
+ writer.print("ALL");
+ } else {
+ writer.print(StringUtils.join(jobIds, ","));
+ }
+ writer.endList(selectFrame);
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ return OPERATOR;
+ }
+
+ @Override
+ public SqlKind getKind() {
+ return SqlKind.RESUME_REBALANCE_JOB;
+ }
+
+ public static class SqlResumeRebalanceJobOperator extends SqlSpecialOperator {
+
+ public SqlResumeRebalanceJobOperator() {
+ super("RESUME_REBALANCE_JOB", SqlKind.RESUME_REBALANCE_JOB);
+ }
+
+ @Override
+ public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, SqlCall call) {
+ final RelDataTypeFactory typeFactory = validator.getTypeFactory();
+ List columns = new LinkedList<>();
+
+ columns.add(new RelDataTypeFieldImpl("JOB_ID", 0, typeFactory.createSqlType(SqlTypeName.INTEGER)));
+ columns.add(new RelDataTypeFieldImpl("STATUS", 1, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+
+ return typeFactory.createStructType(columns);
+ }
+ }
+
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlShowDdlEngine.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlShowDdlEngine.java
new file mode 100644
index 000000000..94f0ebc38
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlShowDdlEngine.java
@@ -0,0 +1,98 @@
+package org.apache.calcite.sql;
+
+import lombok.Getter;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @version 1.0
+ */
+public class SqlShowDdlEngine extends SqlShow {
+
+ private SqlSpecialOperator operator;
+
+ private boolean full;
+
+ public SqlShowDdlEngine(SqlParserPos pos, List specialIdentifiers,
+ boolean full) {
+ super(pos, specialIdentifiers);
+ this.full = full;
+ }
+
+ public boolean isFull() {
+ return full;
+ }
+
+ public void setFull(boolean full) {
+ this.full = full;
+ }
+
+ @Override
+ protected boolean showWhere() {
+ return false;
+ }
+
+ @Override
+ public SqlOperator getOperator() {
+ if (null == operator) {
+ operator = new SqlShowDdlEngineOperator(this.full);
+ }
+ return operator;
+ }
+
+ @Override
+ public SqlKind getShowKind() {
+ return SqlKind.SHOW_DDL_ENGINE;
+ }
+
+ public static class SqlShowDdlEngineOperator extends SqlSpecialOperator {
+
+ private boolean full;
+
+ public SqlShowDdlEngineOperator(boolean full) {
+ super("SHOW_DDL_ENGINE", SqlKind.SHOW_DDL_ENGINE);
+ this.full = full;
+ }
+
+ @Override
+ public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, SqlCall call) {
+ final RelDataTypeFactory typeFactory = validator.getTypeFactory();
+ List columns = new LinkedList<>();
+
+ columns.add(new RelDataTypeFieldImpl("JOB_ID", 0, typeFactory.createSqlType(SqlTypeName.INTEGER)));
+ if (full) {
+ columns.add(
+ new RelDataTypeFieldImpl("PARENT_JOB_ID", 1, typeFactory.createSqlType(SqlTypeName.INTEGER)));
+ }
+ columns.add(new RelDataTypeFieldImpl("SERVER", 2, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("OBJECT_SCHEMA", 3, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("OBJECT_NAME", 4, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ if (full) {
+ columns.add(
+ new RelDataTypeFieldImpl("NEW_OBJECT_NAME", 5, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ }
+ columns.add(new RelDataTypeFieldImpl("JOB_TYPE", 6, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("PHASE", 7, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("STATE", 8, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(new RelDataTypeFieldImpl("PROGRESS", 9, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ if (full) {
+ columns.add(new RelDataTypeFieldImpl("DDL_STMT", 10, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ }
+ columns.add(new RelDataTypeFieldImpl("GMT_CREATED", 11, typeFactory.createSqlType(SqlTypeName.TIMESTAMP)));
+ columns.add(new RelDataTypeFieldImpl("GMT_MODIFIED", 12, typeFactory.createSqlType(SqlTypeName.TIMESTAMP)));
+ columns.add(new RelDataTypeFieldImpl("REMARK", 13, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+ columns.add(
+ new RelDataTypeFieldImpl("BACKFILL_PROGRESS", 14, typeFactory.createSqlType(SqlTypeName.VARCHAR)));
+
+ return typeFactory.createStructType(columns);
+ }
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlStartReplicaCheck.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlStartReplicaCheck.java
index d8db2e6d0..b8b0e444a 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlStartReplicaCheck.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlStartReplicaCheck.java
@@ -38,6 +38,7 @@ public class SqlStartReplicaCheck extends SqlDal {
private SqlNode dbName;
private SqlNode tableName;
private SqlNode channel;
+ private SqlNode mode;
public SqlStartReplicaCheck(SqlParserPos pos, SqlNode channel, SqlNode dbName) {
super(pos);
@@ -69,6 +70,14 @@ public void setChannel(SqlNode channel) {
this.channel = channel;
}
+ public SqlNode getMode() {
+ return mode;
+ }
+
+ public void setMode(SqlNode mode) {
+ this.mode = mode;
+ }
+
@Override
public SqlOperator getOperator() {
return OPERATOR;
@@ -83,9 +92,13 @@ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
tableName.unparse(writer, 0, 0);
}
if (channel != null) {
- writer.keyword("FOR CHANNEL");
+ writer.keyword("CHANNEL=");
channel.unparse(writer, 0, 0);
}
+ if (mode != null) {
+ writer.keyword("MODE=");
+ mode.unparse(writer, 0, 0);
+ }
}
public static class SqlStartReplicaCheckOperator extends SqlSpecialOperator {
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveDefinitionExpr.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveDefinitionExpr.java
new file mode 100644
index 000000000..0670913ca
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveDefinitionExpr.java
@@ -0,0 +1,180 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlVisitor;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.util.EqualsContext;
+import org.apache.calcite.util.Litmus;
+
+/**
+ * @author chenghui.lch
+ */
+public class SqlTimeToLiveDefinitionExpr extends SqlNode {
+
+ protected SqlNode ttlEnableExpr;
+ protected SqlNode ttlExpr;
+ protected SqlNode ttlJobExpr;
+ protected SqlNode ttlFilterExpr;
+ protected SqlNode archiveTypeExpr;
+ protected SqlNode archiveTableSchemaExpr;
+ protected SqlNode archiveTableNameExpr;
+ protected SqlNode archiveTablePreAllocateExpr;
+ protected SqlNode archiveTablePostAllocateExpr;
+
+ public SqlTimeToLiveDefinitionExpr() {
+ super(SqlParserPos.ZERO);
+ }
+
+ @Override
+ public SqlNode clone(SqlParserPos pos) {
+ return null;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+
+// final SqlWriter.Frame startFrame = writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
+
+ writer.print("TTL_DEFINITION(");
+ if (ttlEnableExpr != null) {
+ writer.print("TTL_ENABLE = ");
+ ttlEnableExpr.unparse(writer, leftPrec, rightPrec);
+ }
+ if (ttlExpr != null) {
+ writer.print(", ");
+ writer.print("TTL_EXPR = ");
+ ttlExpr.unparse(writer, leftPrec, rightPrec);
+ }
+ if (ttlJobExpr != null) {
+ writer.print(", ");
+ writer.print("TTL_JOB = ");
+ ttlJobExpr.unparse(writer, leftPrec, rightPrec);
+ }
+ if (ttlFilterExpr != null) {
+ writer.print(", ");
+ writer.print("TTL_FILTER = ");
+ ttlFilterExpr.unparse(writer, leftPrec, rightPrec);
+ }
+ if (archiveTypeExpr != null) {
+ writer.print(", ");
+ writer.print("ARCHIVE_TYPE = ");
+ archiveTypeExpr.unparse(writer, leftPrec, rightPrec);
+ }
+
+ if (archiveTableSchemaExpr != null) {
+ writer.print(", ");
+ writer.print("ARCHIVE_TABLE_SCHEMA = ");
+ archiveTableSchemaExpr.unparse(writer, leftPrec, rightPrec);
+ }
+
+ if (archiveTableNameExpr != null) {
+ writer.print(", ");
+ writer.print("ARCHIVE_TABLE_NAME = ");
+ archiveTableNameExpr.unparse(writer, leftPrec, rightPrec);
+ }
+
+ if (archiveTablePreAllocateExpr != null) {
+ writer.print(", ");
+ writer.print("ARCHIVE_TABLE_PRE_ALLOCATE = ");
+ archiveTablePreAllocateExpr.unparse(writer, leftPrec, rightPrec);
+ }
+
+ if (archiveTablePostAllocateExpr != null) {
+ writer.print(", ");
+ writer.print("ARCHIVE_TABLE_POST_ALLOCATE = ");
+ archiveTablePostAllocateExpr.unparse(writer, leftPrec, rightPrec);
+ }
+
+ writer.print(")");
+ }
+
+ @Override
+ public void validate(SqlValidator validator, SqlValidatorScope scope) {
+
+ }
+
+ @Override
+ public R accept(SqlVisitor visitor) {
+ return null;
+ }
+
+ @Override
+ public boolean equalsDeep(SqlNode node, Litmus litmus, EqualsContext context) {
+ return false;
+ }
+
+
+ public SqlNode getTtlExpr() {
+ return ttlExpr;
+ }
+
+ public void setTtlExpr(SqlNode ttlExpr) {
+ this.ttlExpr = ttlExpr;
+ }
+
+ public SqlNode getTtlJobExpr() {
+ return ttlJobExpr;
+ }
+
+ public void setTtlJobExpr(SqlNode ttlJobExpr) {
+ this.ttlJobExpr = ttlJobExpr;
+ }
+
+ public SqlNode getTtlFilterExpr() {
+ return ttlFilterExpr;
+ }
+
+ public void setTtlFilterExpr(SqlNode ttlFilterExpr) {
+ this.ttlFilterExpr = ttlFilterExpr;
+ }
+
+ public SqlNode getArchiveTypeExpr() {
+ return archiveTypeExpr;
+ }
+
+ public void setArchiveTypeExpr(SqlNode archiveTypeExpr) {
+ this.archiveTypeExpr = archiveTypeExpr;
+ }
+
+ public SqlNode getArchiveTableSchemaExpr() {
+ return archiveTableSchemaExpr;
+ }
+
+ public void setArchiveTableSchemaExpr(SqlNode archiveTableSchemaExpr) {
+ this.archiveTableSchemaExpr = archiveTableSchemaExpr;
+ }
+
+
+ public SqlNode getArchiveTablePreAllocateExpr() {
+ return archiveTablePreAllocateExpr;
+ }
+
+ public void setArchiveTablePreAllocateExpr(SqlNode archiveTablePreAllocateExpr) {
+ this.archiveTablePreAllocateExpr = archiveTablePreAllocateExpr;
+ }
+
+ public SqlNode getArchiveTablePostAllocateExpr() {
+ return archiveTablePostAllocateExpr;
+ }
+
+ public void setArchiveTablePostAllocateExpr(SqlNode archiveTablePostAllocateExpr) {
+ this.archiveTablePostAllocateExpr = archiveTablePostAllocateExpr;
+ }
+
+ public SqlNode getTtlEnableExpr() {
+ return ttlEnableExpr;
+ }
+
+ public void setTtlEnableExpr(SqlNode ttlEnableExpr) {
+ this.ttlEnableExpr = ttlEnableExpr;
+ }
+
+ public SqlNode getArchiveTableNameExpr() {
+ return archiveTableNameExpr;
+ }
+
+ public void setArchiveTableNameExpr(SqlNode archiveTableNameExpr) {
+ this.archiveTableNameExpr = archiveTableNameExpr;
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveExpr.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveExpr.java
new file mode 100644
index 000000000..908148245
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveExpr.java
@@ -0,0 +1,98 @@
+package org.apache.calcite.sql;
+
+import com.alibaba.polardbx.druid.sql.SQLUtils;
+import com.google.common.base.Joiner;
+import org.apache.calcite.sql.dialect.MysqlSqlDialect;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlVisitor;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.util.EqualsContext;
+import org.apache.calcite.util.Litmus;
+import org.apache.commons.lang.StringUtils;
+
+/**
+ * @author chenghui.lch
+ */
+public class SqlTimeToLiveExpr extends SqlNode {
+
+ protected SqlNode column;
+ protected SqlNode expireAfter;
+ protected SqlNode unit;
+ protected SqlNode timezone;
+
+ public SqlTimeToLiveExpr() {
+ super(SqlParserPos.ZERO);
+ }
+
+ @Override
+ public SqlNode clone(SqlParserPos pos) {
+ return null;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+
+// final SqlWriter.Frame startFrame = writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
+
+ writer.print(column.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql());
+ writer.print(" ");
+ writer.print("EXPIRE AFTER ");
+ writer.print(expireAfter.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql());
+ writer.print(" ");
+ writer.print(SQLUtils.normalize(unit.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql()));
+ if (timezone != null) {
+ writer.print(" ");
+ writer.print("TIMEZONE ");
+ writer.print(timezone.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql());
+ }
+// writer.endList(startFrame);
+ }
+
+ @Override
+ public void validate(SqlValidator validator, SqlValidatorScope scope) {
+
+ }
+
+ @Override
+ public R accept(SqlVisitor visitor) {
+ return null;
+ }
+
+ @Override
+ public boolean equalsDeep(SqlNode node, Litmus litmus, EqualsContext context) {
+ return false;
+ }
+
+ public SqlNode getColumn() {
+ return column;
+ }
+
+ public void setColumn(SqlNode column) {
+ this.column = column;
+ }
+
+ public SqlNode getExpireAfter() {
+ return expireAfter;
+ }
+
+ public void setExpireAfter(SqlNode expireAfter) {
+ this.expireAfter = expireAfter;
+ }
+
+ public SqlNode getUnit() {
+ return unit;
+ }
+
+ public void setUnit(SqlNode unit) {
+ this.unit = unit;
+ }
+
+ public SqlNode getTimezone() {
+ return timezone;
+ }
+
+ public void setTimezone(SqlNode timezone) {
+ this.timezone = timezone;
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveJobExpr.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveJobExpr.java
new file mode 100644
index 000000000..6505472b1
--- /dev/null
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/SqlTimeToLiveJobExpr.java
@@ -0,0 +1,69 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.dialect.MysqlSqlDialect;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlVisitor;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.util.EqualsContext;
+import org.apache.calcite.util.Litmus;
+
+/**
+ * @author chenghui.lch
+ */
+public class SqlTimeToLiveJobExpr extends SqlNode {
+
+ protected SqlNode cron;
+ protected SqlNode timezone;
+
+ public SqlTimeToLiveJobExpr() {
+ super(SqlParserPos.ZERO);
+ }
+
+ @Override
+ public SqlNode clone(SqlParserPos pos) {
+ return null;
+ }
+
+ @Override
+ public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+ writer.print("CRON ");
+ writer.print(cron.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql());
+ if (timezone != null) {
+ writer.print(" ");
+ writer.print("TIMEZONE ");
+ writer.print(timezone.toSqlString(MysqlSqlDialect.DEFAULT, false).getSql());
+ }
+ }
+
+ @Override
+ public void validate(SqlValidator validator, SqlValidatorScope scope) {
+
+ }
+
+ @Override
+ public R accept(SqlVisitor visitor) {
+ return null;
+ }
+
+ @Override
+ public boolean equalsDeep(SqlNode node, Litmus litmus, EqualsContext context) {
+ return false;
+ }
+
+ public SqlNode getCron() {
+ return cron;
+ }
+
+ public void setCron(SqlNode cron) {
+ this.cron = cron;
+ }
+
+ public SqlNode getTimezone() {
+ return timezone;
+ }
+
+ public void setTimezone(SqlNode timezone) {
+ this.timezone = timezone;
+ }
+}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/fun/SqlCheckSumV2Function.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/fun/SqlCheckSumV2Function.java
index 98f7dbcf7..5fba7d154 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/fun/SqlCheckSumV2Function.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/fun/SqlCheckSumV2Function.java
@@ -45,7 +45,6 @@ public SqlCheckSumV2Function() {
false);
}
-
@Override
public RelDataType deriveType(
SqlValidator validator,
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
index b23336c74..fa141e46c 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/BasicSqlType.java
@@ -67,17 +67,17 @@ public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName,
computeDigest();
}
- /**
- * Constructs a type with precision/length and scale.
- *
- * @param typeName Type name
- */
- public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName,
- int precision, int scale) {
- this(typeSystem, typeName, true, precision, scale);
+ /**
+ * Constructs a type with precision/length and scale.
+ *
+ * @param typeName Type name
+ */
+ public BasicSqlType(RelDataTypeSystem typeSystem, SqlTypeName typeName,
+ int precision, int scale) {
+ this(typeSystem, typeName, true, precision, scale);
// assert typeName.allowsPrecScale(true, true);
- computeDigest();
- }
+ computeDigest();
+ }
/**
* Internal constructor.
@@ -181,8 +181,8 @@ protected void generateTypeString(StringBuilder sb, boolean withDetail) {
boolean printPrecision = precision != PRECISION_NOT_SPECIFIED;
boolean printScale = scale != SCALE_NOT_SPECIFIED;
- if (SqlTypeName.DATETIME_TYPES.contains(typeName)) {
- // for time/datetime/timestamp, we should print fsp(scale) rather than precision.
+ if (SqlTypeName.DATETIME_TYPES.contains(typeName) || SqlTypeName.APPROX_TYPES.contains(typeName)) {
+ // for time/datetime/timestamp/float/real/double, we should print fsp(scale) rather than precision.
if (getScale() >= 0) {
sb.append('(');
sb.append(getScale());
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/OperandTypes.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
index f3fd33a37..8f0896398 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
@@ -256,6 +256,26 @@ public boolean test(Integer number) {
}
});
+ public static final FamilyOperandTypeChecker STRING_OPTIONAL_NUMERIC =
+ family(ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.NUMERIC),
+ new PredicateImpl() {
+ // Second operand optional (operand index 0, 1)
+ @Override
+ public boolean test(Integer number) {
+ return number == 1;
+ }
+ });
+
+ public static final FamilyOperandTypeChecker BINARY_OPTIONAL_NUMERIC =
+ family(ImmutableList.of(SqlTypeFamily.BINARY, SqlTypeFamily.NUMERIC),
+ new PredicateImpl() {
+ // Second operand optional (operand index 0, 1)
+ @Override
+ public boolean test(Integer number) {
+ return number == 1;
+ }
+ });
+
public static final FamilyOperandTypeChecker ANY_STRING_STRING =
family(SqlTypeFamily.ANY, SqlTypeFamily.STRING, SqlTypeFamily.STRING);
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index 0ee71650d..12fe4fc06 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -50,6 +50,7 @@ public RelDataType createSqlType(SqlTypeName typeName) {
}
assertBasic(typeName);
RelDataType newType = new BasicSqlType(typeSystem, typeName);
+ newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
return canonize(newType);
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
index 8271c5fbf..61afcd6f9 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
@@ -18,6 +18,7 @@
import com.alibaba.polardbx.common.charset.CharsetName;
import com.alibaba.polardbx.common.datatype.DecimalTypeBase;
+import com.alibaba.polardbx.common.properties.DynamicConfig;
import com.alibaba.polardbx.common.utils.time.MySQLTimeTypeUtil;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
@@ -69,9 +70,9 @@ public enum SqlTypeName {
YEAR(PrecScale.NO_NO, false, Types.INTEGER, SqlTypeFamily.NUMERIC),
DECIMAL(PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES, false, Types.DECIMAL,
SqlTypeFamily.NUMERIC),
- FLOAT(PrecScale.NO_NO, false, Types.FLOAT, SqlTypeFamily.NUMERIC),
+ FLOAT(PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES, false, Types.FLOAT, SqlTypeFamily.NUMERIC),
REAL(PrecScale.NO_NO, false, Types.REAL, SqlTypeFamily.NUMERIC),
- DOUBLE(PrecScale.NO_NO, false, Types.DOUBLE, SqlTypeFamily.NUMERIC),
+ DOUBLE(PrecScale.NO_NO | PrecScale.YES_NO | PrecScale.YES_YES, false, Types.DOUBLE, SqlTypeFamily.NUMERIC),
UNSIGNED(PrecScale.NO_NO, false, Types.BIGINT, SqlTypeFamily.NUMERIC),
SIGNED(PrecScale.NO_NO, false, Types.BIGINT, SqlTypeFamily.NUMERIC),
@@ -416,6 +417,9 @@ public boolean allowsPrecNoScale() {
}
public boolean allowsPrec() {
+ if (SqlTypeName.APPROX_TYPES.contains(this) && !DynamicConfig.getInstance().isEnableFloatingTypePrecision()) {
+ return false;
+ }
return allowsPrecScale(true, true) || allowsPrecScale(true, false);
}
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index bc3fcc42f..88f99e743 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -5444,6 +5444,10 @@ public void validateDdl(
}
if (GeneralUtil.isNotEmpty(createTable.getColumnarKeys())) {
+ //support columnar index in UT
+// if (!ConfigDataMode.isPolarDbX()) {
+// throw new NotSupportException("Creating Clustered Columnar Index on DRDS mode");
+// }
createTable.getColumnarKeys().forEach(s -> gsiNames.add(s.getKey().getLastName()));
}
@@ -7411,13 +7415,6 @@ private String removeDbPrefix(String currentSchema, SqlNameMatcher sqlNameMatche
}
public void validateUpdate(SqlUpdate call) {
- if (call.getSourceExpressionList() != null) {
- for (SqlNode node : call.getSourceExpressionList()) {
- if (node instanceof SqlSelect) { // Don't allow sub-query in update set clause.
- throw newValidationError(node, RESOURCE.updateNotSupport(node.toString()));
- }
- }
- }
if (call.singleTable()) {
final SqlValidatorNamespace targetNamespace = getNamespace(call);
validateNamespace(targetNamespace, unknownType);
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/polardbx-calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index a4f7a5e07..76a66a14d 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -88,6 +88,7 @@
import org.apache.calcite.rel.ddl.AlterStoragePool;
import org.apache.calcite.rel.ddl.AlterSystemSetConfig;
import org.apache.calcite.rel.ddl.AlterTable;
+import org.apache.calcite.rel.ddl.AlterTableArchivePartition;
import org.apache.calcite.rel.ddl.AlterTableGroupAddPartition;
import org.apache.calcite.rel.ddl.AlterTableGroupAddTable;
import org.apache.calcite.rel.ddl.AlterTableGroupDropPartition;
@@ -95,6 +96,7 @@
import org.apache.calcite.rel.ddl.AlterTableGroupMergePartition;
import org.apache.calcite.rel.ddl.AlterTableGroupModifyPartition;
import org.apache.calcite.rel.ddl.AlterTableGroupMovePartition;
+import org.apache.calcite.rel.ddl.AlterTableGroupOptimizePartition;
import org.apache.calcite.rel.ddl.AlterTableGroupRenamePartition;
import org.apache.calcite.rel.ddl.AlterTableGroupReorgPartition;
import org.apache.calcite.rel.ddl.AlterTableGroupSetLocality;
@@ -229,6 +231,7 @@
import org.apache.calcite.sql.SqlAlterSystemSetConfig;
import org.apache.calcite.sql.SqlAlterTable;
import org.apache.calcite.sql.SqlAlterTableAddPartition;
+import org.apache.calcite.sql.SqlAlterTableArchivePartition;
import org.apache.calcite.sql.SqlAlterTableDropPartition;
import org.apache.calcite.sql.SqlAlterTableExtractPartition;
import org.apache.calcite.sql.SqlAlterTableGroup;
@@ -245,6 +248,7 @@
import org.apache.calcite.sql.SqlAlterTableModifyPartitionValues;
import org.apache.calcite.sql.SqlAlterTableModifySubPartitionValues;
import org.apache.calcite.sql.SqlAlterTableMovePartition;
+import org.apache.calcite.sql.SqlAlterTableOptimizePartition;
import org.apache.calcite.sql.SqlAlterTablePartitionCount;
import org.apache.calcite.sql.SqlAlterTablePartitionKey;
import org.apache.calcite.sql.SqlAlterTableRemovePartitioning;
@@ -3179,7 +3183,28 @@ protected final void createAggImpl(Blackboard bb, final AggConverter aggConverte
final RelNode inputRel = bb.root;
// Project the expressions required by agg and having.
- bb.setRoot(RelOptUtil.createProject(inputRel, preExprs, true).setHints(inputRel.getHints()), false);
+ RelNode rel = RelOptUtil.createProject(inputRel, preExprs, true).setHints(inputRel.getHints());
+ CorrelationUse correlationUse = null;
+ if (rel instanceof LogicalProject) {
+ Map exprIndex = Maps.newHashMap();
+ correlationUse = getCorrelationUse(bb, rel, exprIndex, firstValueForSubquery, firstValueTarget);
+ if (correlationUse != null) {
+ // update correlation id rowtype
+ RelDataType newType = ((Project) rel).getInput().getRowType();
+ RelNode newrel =
+ RexUtil.replaceRexFieldAccess(correlationUse.r, exprIndex, correlationUse.id, newType);
+ correlationUse = new CorrelationUse(correlationUse.id, correlationUse.requiredColumns, newrel);
+ }
+ }
+
+ if (correlationUse == null) {
+ bb.setRoot(rel, false);
+ } else {
+ LogicalProject logicalProject = (LogicalProject) correlationUse.r;
+ bb.setRoot(
+ LogicalProject.create(logicalProject.getInput(), logicalProject.getProjects(), rel.getRowType(),
+ ImmutableSet.of(correlationUse.id)), false);
+ }
bb.mapRootRelToFieldProjection.put(bb.root, r.groupExprProjection);
// REVIEW jvs 31-Oct-2007: doesn't the declaration of
@@ -3334,7 +3359,7 @@ protected RelNode createAggregate(Blackboard bb, ImmutableBitSet groupSet, Immut
}
if (isNotNullOperands.size() > 0) {
relNode = LogicalFilter.create(
- relNode, RexUtil.composeConjunction(rexBuilder, isNotNullOperands, true));
+ relNode, RexUtil.composeConjunction(rexBuilder, isNotNullOperands, true));
}
}
return LogicalAggregate.create(relNode, groupSet, groupSets, aggregateCalls);
@@ -3754,7 +3779,8 @@ private RelNode convertAlterTable(SqlAlterTable query) {
|| (alterSpecItem instanceof SqlAlterTableDropPartition)
|| (alterSpecItem instanceof SqlAlterTableModifyPartitionValues)
|| (alterSpecItem instanceof SqlAlterTableTruncatePartition)
- || (alterSpecItem instanceof SqlAlterTableReorgPartition);
+ || (alterSpecItem instanceof SqlAlterTableReorgPartition)
+ || (alterSpecItem instanceof SqlAlterTableOptimizePartition);
if (!changePartition) {
query = checkAndRewriteGsiName(query);
@@ -3778,7 +3804,7 @@ private RelNode convertAlterTable(SqlAlterTable query) {
|| o instanceof SqlAlterTableExtractPartition || o instanceof SqlAlterTableMergePartition
|| o instanceof SqlAlterTableMovePartition || o instanceof SqlAlterTableAddPartition
|| o instanceof SqlAlterTableDropPartition || o instanceof SqlAlterTableModifyPartitionValues
- || o instanceof SqlAlterTableTruncatePartition)
+ || o instanceof SqlAlterTableTruncatePartition || o instanceof SqlAlterTableOptimizePartition)
.findFirst();
if (mergeSplitItem.isPresent()) {
throw new RuntimeException(
@@ -3795,6 +3821,8 @@ private RelNode convertAlterTable(SqlAlterTable query) {
return AlterTablePartitionCount.create(getCluster(), query, query.getOperandList().get(0));
} else if (query instanceof SqlAlterTableRemovePartitioning) {
return AlterTableRemovePartitioning.create(getCluster(), query, query.getOperandList().get(0));
+ } else if (query instanceof SqlAlterTableArchivePartition) {
+ return AlterTableArchivePartition.create(getCluster(), query, query.getOperandList().get(0));
}
return AlterTable.create(getCluster(), query, query.getOperandList().get(0), new HashMap<>());
@@ -3954,6 +3982,9 @@ private RelNode convertAlterTableGroup(SqlAlterTableGroup query) {
} else if (item instanceof SqlAlterTableTruncatePartition) {
return AlterTableGroupTruncatePartition.create(getCluster(), getCluster().traitSetOf(Convention.NONE),
query, targetRowType, tableGroupName);
+ } else if (item instanceof SqlAlterTableOptimizePartition) {
+ return AlterTableGroupOptimizePartition.create(getCluster(), getCluster().traitSetOf(Convention.NONE),
+ query, targetRowType, tableGroupName);
} else if (item instanceof SqlAlterTableReorgPartition) {
return AlterTableGroupReorgPartition.create(getCluster(), getCluster().traitSetOf(Convention.NONE),
query, targetRowType, partRexInfoCtxByLevel, tableGroupName);
@@ -4701,6 +4732,8 @@ public Map> getRexInfoFromSqlAlterSpecByLevel(
} else if (sqlAlterSpecifications.get(0) instanceof SqlAlterTableTruncatePartition) {
+ } else if (sqlAlterSpecifications.get(0) instanceof SqlAlterTableOptimizePartition) {
+
} else if (sqlAlterSpecifications.get(0) instanceof SqlAlterTableModifyPartitionValues) {
SqlAlterTableModifyPartitionValues modifyPartition =
(SqlAlterTableModifyPartitionValues) sqlAlterSpecifications.get(0);
@@ -5410,9 +5443,15 @@ protected RelNode convertDelete(SqlDelete call) {
ImmutableList.of(), ImmutableList.of());
}
+ protected void checkSubqueryInSetClause(SqlUpdate call) {
+
+ }
+
protected RelNode convertUpdate(SqlUpdate call) {
interceptDMLAllTableSql(call);
+ checkSubqueryInSetClause(call);
+
// Source table info
// Map column to table it belongs to
final Map aliasTableMap = new HashMap<>();
diff --git a/polardbx-calcite/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java b/polardbx-calcite/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
index a84fbdbb9..064cca4cc 100644
--- a/polardbx-calcite/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
+++ b/polardbx-calcite/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
@@ -16,10 +16,10 @@
*/
package org.apache.calcite.util.javac;
+import org.codehaus.commons.compiler.util.resource.MapResourceFinder;
+import org.codehaus.commons.compiler.util.resource.ResourceFinder;
import org.codehaus.janino.JavaSourceClassLoader;
import org.codehaus.janino.util.ClassFile;
-import org.codehaus.janino.util.resource.MapResourceFinder;
-import org.codehaus.janino.util.resource.ResourceFinder;
import java.io.File;
import java.io.FileOutputStream;
diff --git a/polardbx-calcite/src/test/java/org/apache/calcite/sql/SqlCheckColumnarIndexTest.java b/polardbx-calcite/src/test/java/org/apache/calcite/sql/SqlCheckColumnarIndexTest.java
new file mode 100644
index 000000000..f8e50bc40
--- /dev/null
+++ b/polardbx-calcite/src/test/java/org/apache/calcite/sql/SqlCheckColumnarIndexTest.java
@@ -0,0 +1,44 @@
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.dialect.CalciteSqlDialect;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.pretty.SqlPrettyWriter;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+public class SqlCheckColumnarIndexTest {
+ @Test
+ public void testNormalCase() {
+ SqlParserPos pos = SqlParserPos.ZERO;
+ String indexNameStr = "test_index";
+ SqlIdentifier indexName = new SqlIdentifier(indexNameStr, pos);
+ String tableNameStr = "test_table";
+ SqlIdentifier tableName = new SqlIdentifier(tableNameStr, pos);
+ String extraCmd = "increment";
+ List extras = new ArrayList<>();
+ extras.add(100L);
+ extras.add(200L);
+
+ SqlCheckColumnarIndex sqlCheckColumnarIndex = new SqlCheckColumnarIndex(pos, indexName, tableName, extraCmd, extras);
+
+ assertEquals(indexNameStr, sqlCheckColumnarIndex.getIndexName().toString());
+ assertEquals(tableNameStr, sqlCheckColumnarIndex.getTableName().toString());
+ assertEquals(extraCmd, sqlCheckColumnarIndex.getExtraCmd());
+ assertEquals(extras, sqlCheckColumnarIndex.getExtras());
+
+ SqlValidator validator = mock(SqlValidator.class);
+ SqlValidatorScope scope = mock(SqlValidatorScope.class);
+ sqlCheckColumnarIndex.validate(validator, scope);
+
+ SqlPrettyWriter writer = new SqlPrettyWriter(CalciteSqlDialect.DEFAULT);
+ sqlCheckColumnarIndex.unparse(writer, 0, 0);
+ assertEquals("CHECK COLUMNAR INDEX \"test_index\"\nON \"test_table\"\nINCREMENT", writer.toString());
+ }
+}
diff --git a/polardbx-common/pom.xml b/polardbx-common/pom.xml
index 9910129de..c34cde549 100644
--- a/polardbx-common/pom.xml
+++ b/polardbx-common/pom.xml
@@ -30,24 +30,12 @@
fastjson
- mysql
- mysql-connector-java
-
-
-
-
- commons-logging
- commons-logging-api
- provided
+ com.alibaba
+ druid
- log4j
- log4j
- provided
+ mysql
+ mysql-connector-java
@@ -121,51 +109,23 @@
slf4j-simple
org.slf4j
-
- org.apache.arrow
- arrow-vector
-
-
- org.apache.arrow
- arrow-memory-netty
-
org.apache.hadoop
- hadoop-client
+ hadoop-common
+
+
+
+ org.apache.hadoop
+ hadoop-hdfs-client
${hadoop.version}
-
-
- commons-logging
- commons-logging
-
-
- slf4j-api
- org.slf4j
-
-
- jsr311-api
- javax.ws.rs
-
-
- slf4j-reload4j
- org.slf4j
-
-
com.aliyun.oss
aliyun-sdk-oss
- 3.10.2
-
-
- commons-logging
- commons-logging
-
-
@@ -177,22 +137,16 @@
com.emc.ecs
nfs-client
-
-
- org.roaringbitmap
- RoaringBitmap
-
-
-
- com.github.ben-manes.caffeine
- caffeine
-
org.mockito
mockito-inline
test
+
+ org.roaringbitmap
+ RoaringBitmap
+
@@ -232,27 +186,26 @@
mac
-
+
- Version Calculation
- generate-sources
-
- exec
-
-
- ${basedir}/../saveVersion.sh
-
-
-
-