This is an automated email from the ASF dual-hosted git repository. caogaofei pushed a commit to branch ty/TableModelGrammar in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 09e1be46ebf62c20d0c992278ba9bfc554afcd28 Merge: c818ecda1af 095f86adc68 Author: Beyyes <[email protected]> AuthorDate: Tue Apr 16 09:31:46 2024 +0800 merge master .../java/org/apache/iotdb/db/conf/IoTDBConfig.java | 6 +- .../execution/operator/AggregationUtil.java | 3 + .../AbstractSeriesAggregationScanOperator.java | 3 + .../db/queryengine/plan/analyze/Analysis.java | 2 +- .../plan/relational/analyzer/Analysis.java | 25 +++----- .../plan/relational/analyzer/Field.java | 39 ++++++++++-- .../plan/relational/analyzer/RelationType.java | 2 + .../plan/relational/analyzer/ResolvedField.java | 5 ++ .../relational/analyzer/StatementAnalyzer.java | 40 ++++++------ .../plan/relational/metadata/ColumnSchema.java | 18 +++++- .../plan/relational/metadata/DeviceEntry.java | 43 +++++++++++++ .../plan/relational/metadata/Metadata.java | 40 +++++------- .../relational/metadata/TableMetadataImpl.java | 25 +------- .../plan/relational/planner/RelationPlanner.java | 13 ++-- .../relational/planner/node/TableScanNode.java | 13 ++++ .../plan/relational/analyzer/AnalyzerTest.java | 8 +-- .../plan/relational/analyzer/TestMatadata.java | 71 +--------------------- .../apache/iotdb/commons/conf/CommonConfig.java | 4 +- 18 files changed, 177 insertions(+), 183 deletions(-) diff --cc iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/RelationPlanner.java index b42cc50c693,d084324151f..0694f27b9c2 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/RelationPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/RelationPlanner.java @@@ -20,8 -20,7 +20,6 @@@ import org.apache.iotdb.db.queryengine. import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Field; import org.apache.iotdb.db.queryengine.plan.relational.analyzer.NodeRef; import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Scope; - import org.apache.iotdb.db.queryengine.plan.relational.metadata.ColumnHandle; - import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableHandle; -import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableSchema; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.TableScanNode; import org.apache.iotdb.db.relational.sql.tree.AliasedRelation; import org.apache.iotdb.db.relational.sql.tree.AstVisitor; @@@ -33,12 -29,8 +31,11 @@@ import org.apache.iotdb.db.relational.s import org.apache.iotdb.db.relational.sql.tree.QuerySpecification; import org.apache.iotdb.db.relational.sql.tree.SubqueryExpression; import org.apache.iotdb.db.relational.sql.tree.Table; +import org.apache.iotdb.db.relational.sql.tree.TableSubquery; +import org.apache.iotdb.db.relational.sql.tree.Union; +import org.apache.iotdb.db.relational.sql.tree.Values; import com.google.common.collect.ImmutableList; - import com.google.common.collect.ImmutableMap; import java.util.Collection; import java.util.List; @@@ -90,67 -81,134 +87,65 @@@ public class RelationPlanner extends As expansion.getRoot(), expansion.getScope(), expansion.getFieldMappings()); } - Query namedQuery = analysis.getNamedQuery(node); Scope scope = analysis.getScope(node); - TableHandle tableHandle = analysis.getTableHandle(node); ++ // TableHandle tableHandle = analysis.getTableHandle(node); - RelationPlan plan; - if (namedQuery != null) { - throw new RuntimeException("NamedQuery is not supported"); - } else { - TableSchema handle = analysis.getTableHandle(node); + ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder(); - ImmutableMap.Builder<Symbol, ColumnHandle> columnsBuilder = ImmutableMap.builder(); - ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder(); ++ // Collection<Field> fields = analysis.getMaterializedViewStorageTableFields(node); + Collection<Field> fields = scope.getRelationType().getAllFields(); + for (Field field : fields) { + Symbol symbol = symbolAllocator.newSymbol(field); + - // Collection<Field> fields = analysis.getMaterializedViewStorageTableFields(node); - Collection<Field> fields = scope.getRelationType().getAllFields(); - for (Field field : fields) { - Symbol symbol = symbolAllocator.newSymbol(field); - - outputSymbolsBuilder.add(symbol); - } + outputSymbolsBuilder.add(symbol); - columnsBuilder.put(symbol, analysis.getColumn(field)); + } - List<Symbol> outputSymbols = outputSymbolsBuilder.build(); - PlanNode root = new TableScanNode(idAllocator.genPlanNodeId(), null, outputSymbols, null); + List<Symbol> outputSymbols = outputSymbolsBuilder.build(); - PlanNode root = - new TableScanNode( - idAllocator.genPlanNodeId(), tableHandle, outputSymbols, columnsBuilder.buildOrThrow()); ++ PlanNode root = new TableScanNode(idAllocator.genPlanNodeId(), null, outputSymbols, null); - plan = new RelationPlan(root, scope, outputSymbols); - } + return new RelationPlan(root, scope, outputSymbols); - // TODO what's the meaning of RowFilters addColumnMasks? + // Query namedQuery = analysis.getNamedQuery(node); + // Collection<Field> fields = analysis.getMaterializedViewStorageTableFields(node); // plan = addRowFilters(node, plan); // plan = addColumnMasks(node, plan); - - return plan; } - // private RelationPlan addRowFilters(Table node, RelationPlan plan) { - // return addRowFilters(node, plan, Function.identity()); - // } - - // public RelationPlan addRowFilters( - // Table node, RelationPlan plan, Function<Expression, Expression> predicateTransformation) { - // List<Expression> filters = null; - // // analysis.getRowFilters(node); - // - // if (filters.isEmpty()) { - // return plan; - // } - // - // // The fields in the access control scope has the same layout as those for the table scope - // PlanBuilder planBuilder = newPlanBuilder(plan, analysis, session); - // // .withScope(accessControlScope.apply(node), plan.getFieldMappings()); - // - // for (Expression filter : filters) { - // // planBuilder = subqueryPlanner.handleSubqueries(planBuilder, filter, - // // analysis.getSubqueries(filter)); - // - // Expression predicate = coerceIfNecessary(analysis, filter, filter); - // predicate = predicateTransformation.apply(predicate); - // planBuilder = - // planBuilder.withNewRoot( - // new FilterNode(idAllocator.genPlanNodeId(), planBuilder.getRoot(), predicate)); - // } - // - // return new RelationPlan(planBuilder.getRoot(), plan.getScope(), plan.getFieldMappings()); - // } - - // private RelationPlan addColumnMasks(Table table, RelationPlan plan) { - // Map<String, Expression> columnMasks = analysis.getColumnMasks(table); - // - // // A Table can represent a WITH query, which can have anonymous fields. On the other - // hand, - // // it can't have masks. The loop below expects fields to have proper names, so bail out - // // if the masks are missing - // if (columnMasks.isEmpty()) { - // return plan; - // } - // - // // The fields in the access control scope has the same layout as those for the table - // scope - // PlanBuilder planBuilder = newPlanBuilder(plan, analysis, session) - // .withScope(analysis.getAccessControlScope(table), plan.getFieldMappings()); - // - // Assignments.Builder assignments = Assignments.builder(); - // assignments.putIdentities(planBuilder.getRoot().getOutputSymbols()); - // - // List<Symbol> fieldMappings = new ArrayList<>(); - // for (int i = 0; i < plan.getDescriptor().getAllFieldCount(); i++) { - // Field field = plan.getDescriptor().getFieldByIndex(i); - // - // Expression mask = columnMasks.get(field.getName().orElseThrow()); - // Symbol symbol = plan.getFieldMappings().get(i); - // Expression projection = symbol.toSymbolReference(); - // if (mask != null) { - // symbol = symbolAllocator.newSymbol(symbol); - // projection = coerceIfNecessary(analysis, mask, planBuilder.rewrite(mask)); - // } - // - // assignments.put(symbol, projection); - // fieldMappings.add(symbol); - // } - // - // planBuilder = planBuilder - // .withNewRoot(new ProjectNode( - // idAllocator.genPlanNodeId(), - // planBuilder.getRoot(), - // assignments.build())); - // - // return new RelationPlan(planBuilder.getRoot(), plan.getScope(), fieldMappings); - // } + @Override + protected RelationPlan visitQuerySpecification(QuerySpecification node, Void context) { + return new QueryPlanner(analysis, symbolAllocator, idAllocator, session, recursiveSubqueries) + .plan(node); + } @Override - protected RelationPlan visitAliasedRelation(AliasedRelation node, Void context) { - RelationPlan subPlan = process(node.getRelation(), context); + protected RelationPlan visitNode(Node node, Void context) { + throw new IllegalStateException("Unsupported node type: " + node.getClass().getName()); + } - PlanNode root = subPlan.getRoot(); - List<Symbol> mappings = subPlan.getFieldMappings(); + // ================================ Implemented later ===================================== + @Override + protected RelationPlan visitTableSubquery(TableSubquery node, Void context) { + throw new IllegalStateException("TableSubquery is not supported in current version."); + } - if (node.getColumnNames() != null) { - ImmutableList.Builder<Symbol> newMappings = ImmutableList.builder(); + @Override + protected RelationPlan visitValues(Values node, Void context) { + throw new IllegalStateException("Values is not supported in current version."); + } - // Adjust the mappings to expose only the columns visible in the scope of the aliased relation - for (int i = 0; i < subPlan.getDescriptor().getAllFieldCount(); i++) { - if (!subPlan.getDescriptor().getFieldByIndex(i).isHidden()) { - newMappings.add(subPlan.getFieldMappings().get(i)); - } - } + @Override + protected RelationPlan visitSubqueryExpression(SubqueryExpression node, Void context) { + throw new IllegalStateException("SubqueryExpression is not supported in current version."); + } - mappings = newMappings.build(); - } + @Override + protected RelationPlan visitJoin(Join node, Void context) { + throw new IllegalStateException("Join is not supported in current version."); + } - return new RelationPlan(root, analysis.getScope(node), mappings); + @Override + protected RelationPlan visitAliasedRelation(AliasedRelation node, Void context) { + throw new IllegalStateException("AliasedRelation is not supported in current version."); } @Override
