This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch vector-index-dev
in repository https://gitbox.apache.org/repos/asf/doris.git
commit 340a67aecd7f019a87dd765c0510a71d364d3979
Author: morrySnow <zhangwen...@selectdb.com>
AuthorDate: Mon May 19 12:16:02 2025 +0800
[opt](vector) refactor some scan code
---
.../trees/copier/LogicalPlanDeepCopier.java | 29 ++++++++-
.../plans/logical/LogicalCatalogRelation.java | 68 ++++++++++++++++++++--
.../nereids/trees/plans/logical/LogicalEsScan.java | 22 +++++--
.../trees/plans/logical/LogicalFileScan.java | 41 ++++++++-----
.../trees/plans/logical/LogicalHudiScan.java | 52 ++++++++++-------
.../trees/plans/logical/LogicalJdbcScan.java | 22 ++++---
.../trees/plans/logical/LogicalOdbcScan.java | 18 +++---
.../trees/plans/logical/LogicalOlapScan.java | 18 +-----
.../trees/plans/logical/LogicalSchemaScan.java | 59 +++++++++++--------
9 files changed, 225 insertions(+), 104 deletions(-)
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java
index a6e724f8454..d74851dec3c 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java
@@ -19,6 +19,7 @@ package org.apache.doris.nereids.trees.copier;
import org.apache.doris.nereids.exceptions.AnalysisException;
import org.apache.doris.nereids.properties.OrderKey;
+import org.apache.doris.nereids.trees.expressions.Alias;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
@@ -98,7 +99,33 @@ public class LogicalPlanDeepCopier extends
DefaultPlanRewriter<DeepCopierContext
return newRelation;
}
- // TODO update scan
+ @Override
+ public Plan visitLogicalCatalogRelation(LogicalCatalogRelation
catalogRelation, DeepCopierContext context) {
+ if
(context.getRelationReplaceMap().containsKey(catalogRelation.getRelationId())) {
+ return
context.getRelationReplaceMap().get(catalogRelation.getRelationId());
+ }
+ LogicalCatalogRelation newRelation =
+
catalogRelation.withRelationId(StatementScopeIdGenerator.newRelationId());
+ updateReplaceMapWithOutput(catalogRelation, newRelation,
context.exprIdReplaceMap);
+ List<NamedExpression> virtualColumns =
catalogRelation.getVirtualColumns().stream()
+ .map(e -> {
+ if (e instanceof Alias) {
+ return new Alias(((Alias) e).child(), e.getName());
+ }
+ return e;
+ })
+ .collect(ImmutableList.toImmutableList());
+ for (int i = 0; i < virtualColumns.size(); i++) {
+
context.exprIdReplaceMap.put(catalogRelation.getVirtualColumns().get(i).getExprId(),
+ virtualColumns.get(i).getExprId());
+ }
+ virtualColumns = virtualColumns.stream()
+ .map(o -> (NamedExpression)
ExpressionDeepCopier.INSTANCE.deepCopy(o, context))
+ .collect(ImmutableList.toImmutableList());
+ newRelation = newRelation.withVirtualColumns(virtualColumns);
+ context.putRelation(catalogRelation.getRelationId(), newRelation);
+ return newRelation;
+ }
@Override
public Plan visitLogicalCatalogRelation(LogicalCatalogRelation relation,
DeepCopierContext context) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCatalogRelation.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCatalogRelation.java
index 3d1ddf9a26a..684142962d3 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCatalogRelation.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCatalogRelation.java
@@ -31,6 +31,7 @@ import org.apache.doris.nereids.properties.FdFactory;
import org.apache.doris.nereids.properties.FdItem;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.TableFdItem;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -41,6 +42,7 @@ import org.apache.doris.qe.ConnectContext;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
@@ -60,22 +62,40 @@ public abstract class LogicalCatalogRelation extends
LogicalRelation implements
protected final ImmutableList<Slot> operativeSlots;
+ // use for virtual slot
+ protected final List<NamedExpression> virtualColumns;
+
public LogicalCatalogRelation(RelationId relationId, PlanType type,
TableIf table, List<String> qualifier) {
this(relationId, type, table, qualifier, Optional.empty(),
Optional.empty());
}
public LogicalCatalogRelation(RelationId relationId, PlanType type,
TableIf table, List<String> qualifier,
Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
- this(relationId, type, table, qualifier, groupExpression,
logicalProperties, ImmutableList.of());
+ this(relationId, type, table, qualifier, ImmutableList.of(),
ImmutableList.of(),
+ groupExpression, logicalProperties);
}
+ /**
+ * Constructs a LogicalCatalogRelation with specified parameters.
+ *
+ * @param relationId Unique identifier for this relation
+ * @param type Plan type
+ * @param table Table object associated with this relation
+ * @param qualifier List of qualifiers, typically [catalogName,
databaseName]
+ * @param operativeSlots Collection of operative slots
+ * @param virtualColumns List of virtual columns
+ * @param groupExpression Optional group expression
+ * @param logicalProperties Optional logical properties
+ */
public LogicalCatalogRelation(RelationId relationId, PlanType type,
TableIf table, List<String> qualifier,
- Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties,
- Collection<Slot> operativeSlots) {
+ Collection<Slot> operativeSlots, List<NamedExpression>
virtualColumns,
+ Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
super(relationId, type, groupExpression, logicalProperties);
this.table = Objects.requireNonNull(table, "table can not be null");
this.qualifier =
ImmutableList.copyOf(Objects.requireNonNull(qualifier, "qualifier can not be
null"));
this.operativeSlots = ImmutableList.copyOf(operativeSlots);
+ this.virtualColumns =
Utils.fastToImmutableList(Objects.requireNonNull(virtualColumns,
+ "virtualColumns can not be null"));
}
@Override
@@ -108,10 +128,16 @@ public abstract class LogicalCatalogRelation extends
LogicalRelation implements
@Override
public List<Slot> computeOutput() {
- return table.getBaseSchema()
+ Builder<Slot> slots = ImmutableList.builder();
+ table.getBaseSchema()
.stream()
.map(col -> SlotReference.fromColumn(table, col, qualified()))
- .collect(ImmutableList.toImmutableList());
+ .forEach(slots::add);
+ // add virtual slots
+ for (NamedExpression virtualColumn : virtualColumns) {
+ slots.add(virtualColumn.toSlot());
+ }
+ return slots.build();
}
@Override
@@ -133,6 +159,15 @@ public abstract class LogicalCatalogRelation extends
LogicalRelation implements
return Utils.qualifiedName(qualifier, table.getName());
}
+ @Override
+ public List<Slot> getOperativeSlots() {
+ return operativeSlots;
+ }
+
+ public List<NamedExpression> getVirtualColumns() {
+ return virtualColumns;
+ }
+
@Override
public void computeUnique(DataTrait.Builder builder) {
Set<Slot> outputSet = Utils.fastToImmutableSet(getOutputSet());
@@ -206,4 +241,27 @@ public abstract class LogicalCatalogRelation extends
LogicalRelation implements
// don't generate any equal pair
}
+ public LogicalCatalogRelation withVirtualColumns(List<NamedExpression>
virtualColumns) {
+ return this;
+ }
+
+ public abstract LogicalCatalogRelation withRelationId(RelationId
relationId);
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ if (!super.equals(o)) {
+ return false;
+ }
+ LogicalCatalogRelation that = (LogicalCatalogRelation) o;
+ return Objects.equals(operativeSlots, that.operativeSlots)
+ && Objects.equals(virtualColumns, that.virtualColumns);
+ }
+
+ @Override
+ public int hashCode() {
+ return super.hashCode();
+ }
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
index 8fb916b8a5e..2835c8e69cf 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
@@ -20,12 +20,15 @@ package org.apache.doris.nereids.trees.plans.logical;
import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
+import com.google.common.collect.ImmutableList;
+
import java.util.List;
import java.util.Optional;
@@ -38,13 +41,15 @@ public class LogicalEsScan extends LogicalCatalogRelation {
* Constructor for LogicalEsScan.
*/
public LogicalEsScan(RelationId id, TableIf table, List<String> qualifier,
+ List<NamedExpression> virtualColumns,
Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
- super(id, PlanType.LOGICAL_ES_SCAN, table, qualifier, groupExpression,
logicalProperties);
+ super(id, PlanType.LOGICAL_ES_SCAN, table, qualifier,
+ ImmutableList.of(), virtualColumns, groupExpression,
logicalProperties);
}
public LogicalEsScan(RelationId id, TableIf table, List<String> qualifier)
{
- this(id, table, qualifier, Optional.empty(), Optional.empty());
+ this(id, table, qualifier, ImmutableList.of(), Optional.empty(),
Optional.empty());
}
@Override
@@ -57,19 +62,24 @@ public class LogicalEsScan extends LogicalCatalogRelation {
@Override
public LogicalEsScan withGroupExpression(Optional<GroupExpression>
groupExpression) {
- return new LogicalEsScan(relationId, table, qualifier, groupExpression,
- Optional.of(getLogicalProperties()));
+ return new LogicalEsScan(relationId, table, qualifier, virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
- return new LogicalEsScan(relationId, table, qualifier,
groupExpression, logicalProperties);
+ return new LogicalEsScan(relationId, table, qualifier, virtualColumns,
groupExpression, logicalProperties);
}
@Override
public LogicalEsScan withRelationId(RelationId relationId) {
- return new LogicalEsScan(relationId, table, qualifier,
Optional.empty(), Optional.empty());
+ return new LogicalEsScan(relationId, table, qualifier, virtualColumns,
Optional.empty(), Optional.empty());
+ }
+
+ @Override
+ public LogicalEsScan withVirtualColumns(List<NamedExpression>
virtualColumns) {
+ return new LogicalEsScan(relationId, table, qualifier, virtualColumns,
Optional.empty(), Optional.empty());
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
index ecdcc07db12..d44b1e4f9d7 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.TableSample;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -33,6 +34,7 @@ import
org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Collection;
@@ -50,16 +52,24 @@ public class LogicalFileScan extends LogicalCatalogRelation
{
protected final Optional<TableSnapshot> tableSnapshot;
protected final Optional<TableScanParams> scanParams;
+ public LogicalFileScan(RelationId id, ExternalTable table, List<String>
qualifier,
+ Optional<TableSample> tableSample, Optional<TableSnapshot>
tableSnapshot) {
+ this(id, table, qualifier,
table.initSelectedPartitions(MvccUtil.getSnapshotFromContext(table)),
+ tableSample, tableSnapshot, ImmutableList.of(),
Optional.empty(), Optional.empty());
+ }
+
/**
* Constructor for LogicalFileScan.
*/
protected LogicalFileScan(RelationId id, ExternalTable table, List<String>
qualifier,
- Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties,
SelectedPartitions selectedPartitions, Optional<TableSample>
tableSample,
Optional<TableSnapshot> tableSnapshot,
Collection<Slot> operativeSlots,
- Optional<TableScanParams> scanParams) {
- super(id, PlanType.LOGICAL_FILE_SCAN, table, qualifier,
groupExpression, logicalProperties, operativeSlots);
+ Optional<TableScanParams> scanParams,
+ List<NamedExpression> virtualColumns,
+ Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
+ super(id, PlanType.LOGICAL_FILE_SCAN, table, qualifier,
operativeSlots, virtualColumns,
+ groupExpression, logicalProperties);
this.selectedPartitions = selectedPartitions;
this.tableSample = tableSample;
this.tableSnapshot = tableSnapshot;
@@ -72,7 +82,8 @@ public class LogicalFileScan extends LogicalCatalogRelation {
Optional<TableScanParams> scanParams) {
this(id, table, qualifier, Optional.empty(), Optional.empty(),
table.initSelectedPartitions(MvccUtil.getSnapshotFromContext(table)),
- tableSample, tableSnapshot, operativeSlots, scanParams);
+ tableSample, tableSnapshot, operativeSlots, scanParams,
+ Optional.empty(), Optional.empty(),Optional.empty());
}
public SelectedPartitions getSelectedPartitions() {
@@ -109,30 +120,30 @@ public class LogicalFileScan extends
LogicalCatalogRelation {
@Override
public LogicalFileScan withGroupExpression(Optional<GroupExpression>
groupExpression) {
- return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier, groupExpression,
- Optional.of(getLogicalProperties()), selectedPartitions,
tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot,
virtualColumns, groupExpression,
+ Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier,
- groupExpression, logicalProperties, selectedPartitions,
tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ selectedPartitions, tableSample, tableSnapshot, virtualColumns,
+ groupExpression, logicalProperties);
}
public LogicalFileScan withSelectedPartitions(SelectedPartitions
selectedPartitions) {
- return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier, Optional.empty(),
- Optional.of(getLogicalProperties()), selectedPartitions,
tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot, virtualColumns,
+ Optional.empty(), Optional.of(getLogicalProperties()));
}
@Override
public LogicalFileScan withRelationId(RelationId relationId) {
- return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier, Optional.empty(),
- Optional.empty(), selectedPartitions, tableSample,
tableSnapshot,
- operativeSlots, scanParams);
+ return new LogicalFileScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot, virtualColumns,
+ Optional.empty(), Optional.empty());
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
index 6d5fa3e050b..86a36290eed 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
@@ -35,6 +35,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.GreaterThan;
import org.apache.doris.nereids.trees.expressions.GreaterThanEqual;
import org.apache.doris.nereids.trees.expressions.LessThanEqual;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.literal.StringLiteral;
@@ -43,6 +44,7 @@ import org.apache.doris.nereids.trees.plans.RelationId;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.apache.hudi.common.table.HoodieTableMetaClient;
import org.apache.logging.log4j.LogManager;
@@ -69,25 +71,32 @@ public class LogicalHudiScan extends LogicalFileScan {
* Constructor for LogicalHudiScan.
*/
protected LogicalHudiScan(RelationId id, ExternalTable table, List<String>
qualifier,
- Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties,
SelectedPartitions selectedPartitions, Optional<TableSample>
tableSample,
Optional<TableSnapshot> tableSnapshot,
Optional<TableScanParams> scanParams,
Optional<IncrementalRelation> incrementalRelation,
- Collection<Slot> operativeSlots) {
- super(id, table, qualifier, groupExpression, logicalProperties,
- selectedPartitions, tableSample, tableSnapshot,
operativeSlots, scanParams);
+ Collection<Slot> operativeSlots,
+ List<NamedExpression> virtualColumns,
+ Optional<GroupExpression> groupExpression,
+ Optional<LogicalProperties> logicalProperties) {
+ super(id, table, qualifier, selectedPartitions, tableSample,
tableSnapshot, operativeSlots,
+ virtualColumns, groupExpression, logicalProperties);
Objects.requireNonNull(scanParams, "scanParams should not null");
Objects.requireNonNull(incrementalRelation, "incrementalRelation
should not null");
this.incrementalRelation = incrementalRelation;
}
public LogicalHudiScan(RelationId id, ExternalTable table, List<String>
qualifier,
- Optional<TableSample> tableSample, Optional<TableSnapshot>
tableSnapshot,
Collection<Slot> operativeSlots,
- Optional<TableScanParams> scanParams) {
+ Optional<TableScanParams> scanParams,
+ Optional<TableSample> tableSample, Optional<TableSnapshot>
tableSnapshot) {
this(id, table, qualifier, Optional.empty(), Optional.empty(),
((HMSExternalTable)
table).initHudiSelectedPartitions(tableSnapshot), tableSample, tableSnapshot,
- scanParams, Optional.empty(), operativeSlots);
+ Optional.empty(), Optional.empty(),
+ ImmutableList.of(), Optional.empty(), Optional.empty());
+ }
+
+ public Optional<TableScanParams> getScanParams() {
+ return scanParams;
}
public Optional<IncrementalRelation> getIncrementalRelation() {
@@ -132,30 +141,30 @@ public class LogicalHudiScan extends LogicalFileScan {
@Override
public LogicalHudiScan withGroupExpression(Optional<GroupExpression>
groupExpression) {
- return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier, groupExpression,
- Optional.of(getLogicalProperties()), selectedPartitions,
tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot, scanParams,
incrementalRelation, virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier,
- groupExpression, logicalProperties, selectedPartitions,
tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ selectedPartitions, tableSample, tableSnapshot, scanParams,
incrementalRelation, virtualColumns,
+ groupExpression, logicalProperties);
}
public LogicalHudiScan withSelectedPartitions(SelectedPartitions
selectedPartitions) {
- return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier, Optional.empty(),
- Optional.of(getLogicalProperties()), selectedPartitions,
tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot, scanParams,
incrementalRelation, virtualColumns,
+ Optional.empty(), Optional.of(getLogicalProperties()));
}
@Override
public LogicalHudiScan withRelationId(RelationId relationId) {
- return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier, Optional.empty(),
- Optional.empty(), selectedPartitions, tableSample,
tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return new LogicalHudiScan(relationId, (ExternalTable) table,
qualifier,
+ selectedPartitions, tableSample, tableSnapshot, scanParams,
incrementalRelation, virtualColumns,
+ Optional.empty(), Optional.empty());
}
@Override
@@ -218,8 +227,9 @@ public class LogicalHudiScan extends LogicalFileScan {
"Failed to create incremental relation for table: " +
table.getFullQualifiers(), e);
}
}
- return new LogicalHudiScan(relationId, table, qualifier,
Optional.empty(),
- Optional.empty(), selectedPartitions, tableSample, tableSnapshot,
- optScanParams, newIncrementalRelation, operativeSlots);
+ newScanParams = Optional.ofNullable(scanParams);
+ return new LogicalHudiScan(relationId, table, qualifier,
+ selectedPartitions, tableSample, tableSnapshot, newScanParams,
newIncrementalRelation, virtualColumns,
+ Optional.empty(), Optional.empty());
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
index 53176f72c53..13491ea76f9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
@@ -22,6 +22,7 @@ import org.apache.doris.catalog.TableIf;
import org.apache.doris.datasource.ExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -29,6 +30,7 @@ import
org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
@@ -41,14 +43,14 @@ public class LogicalJdbcScan extends LogicalCatalogRelation
{
/**
* Constructor for LogicalJdbcScan.
*/
- public LogicalJdbcScan(RelationId id, TableIf table, List<String>
qualifier,
- Optional<GroupExpression> groupExpression,
- Optional<LogicalProperties> logicalProperties) {
- super(id, PlanType.LOGICAL_JDBC_SCAN, table, qualifier,
groupExpression, logicalProperties);
+ public LogicalJdbcScan(RelationId id, TableIf table, List<String>
qualifier, List<NamedExpression> virtualColumns,
+ Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
+ super(id, PlanType.LOGICAL_JDBC_SCAN, table, qualifier,
ImmutableList.of(), virtualColumns,
+ groupExpression, logicalProperties);
}
public LogicalJdbcScan(RelationId id, TableIf table, List<String>
qualifier) {
- this(id, table, qualifier, Optional.empty(), Optional.empty());
+ this(id, table, qualifier, ImmutableList.of(), Optional.empty(),
Optional.empty());
}
@Override
@@ -68,19 +70,21 @@ public class LogicalJdbcScan extends LogicalCatalogRelation
{
@Override
public LogicalJdbcScan withGroupExpression(Optional<GroupExpression>
groupExpression) {
- return new LogicalJdbcScan(relationId, table, qualifier,
groupExpression,
- Optional.of(getLogicalProperties()));
+ return new LogicalJdbcScan(relationId, table, qualifier,
virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
- return new LogicalJdbcScan(relationId, table, qualifier,
groupExpression, logicalProperties);
+ return new LogicalJdbcScan(relationId, table, qualifier,
virtualColumns,
+ groupExpression, logicalProperties);
}
@Override
public LogicalJdbcScan withRelationId(RelationId relationId) {
- return new LogicalJdbcScan(relationId, table, qualifier,
Optional.empty(), Optional.empty());
+ return new LogicalJdbcScan(relationId, table, qualifier,
virtualColumns,
+ Optional.empty(), Optional.empty());
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
index 3ce9b8d7403..f63585d099f 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
@@ -21,6 +21,7 @@ import org.apache.doris.catalog.OdbcTable;
import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -28,6 +29,7 @@ import
org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
@@ -37,14 +39,14 @@ import java.util.Optional;
*/
public class LogicalOdbcScan extends LogicalCatalogRelation {
- public LogicalOdbcScan(RelationId id, TableIf table, List<String>
qualifier,
- Optional<GroupExpression> groupExpression,
- Optional<LogicalProperties> logicalProperties) {
- super(id, PlanType.LOGICAL_ODBC_SCAN, table, qualifier,
groupExpression, logicalProperties);
+ public LogicalOdbcScan(RelationId id, TableIf table, List<String>
qualifier, List<NamedExpression> virtualColumns,
+ Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
+ super(id, PlanType.LOGICAL_ODBC_SCAN, table, qualifier,
+ ImmutableList.of(), virtualColumns, groupExpression,
logicalProperties);
}
public LogicalOdbcScan(RelationId id, TableIf table, List<String>
qualifier) {
- this(id, table, qualifier, Optional.empty(), Optional.empty());
+ this(id, table, qualifier, ImmutableList.of(), Optional.empty(),
Optional.empty());
}
@Override
@@ -64,19 +66,19 @@ public class LogicalOdbcScan extends LogicalCatalogRelation
{
@Override
public LogicalOdbcScan withGroupExpression(Optional<GroupExpression>
groupExpression) {
- return new LogicalOdbcScan(relationId, table, qualifier,
groupExpression,
+ return new LogicalOdbcScan(relationId, table, qualifier,
virtualColumns, groupExpression,
Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
- return new LogicalOdbcScan(relationId, table, qualifier,
groupExpression, logicalProperties);
+ return new LogicalOdbcScan(relationId, table, qualifier,
virtualColumns, groupExpression, logicalProperties);
}
@Override
public LogicalOdbcScan withRelationId(RelationId relationId) {
- return new LogicalOdbcScan(relationId, table, qualifier,
Optional.empty(), Optional.empty());
+ return new LogicalOdbcScan(relationId, table, qualifier,
virtualColumns, Optional.empty(), Optional.empty());
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
index b1f57386aab..f51791e4653 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
@@ -140,9 +140,6 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
private final Map<String, Set<List<String>>> colToSubPathsMap;
private final Map<Slot, Map<List<String>, SlotReference>> subPathToSlotMap;
- // use for virtual slot
- private final List<NamedExpression> virtualColumns;
-
// use for ann push down
private final List<OrderKey> annOrderKeys;
private final Optional<Long> annLimit;
@@ -210,7 +207,7 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
Collection<Slot> operativeSlots, List<NamedExpression>
virtualColumns,
List<OrderKey> annOrderKeys, Optional<Long> annLimit) {
super(id, PlanType.LOGICAL_OLAP_SCAN, table, qualifier,
- groupExpression, logicalProperties, operativeSlots);
+ operativeSlots, virtualColumns, groupExpression,
logicalProperties);
Preconditions.checkArgument(selectedPartitionIds != null,
"selectedPartitionIds can not be null");
this.selectedTabletIds = Utils.fastToImmutableList(selectedTabletIds);
@@ -240,7 +237,6 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
this.directMvScan = directMvScan;
this.colToSubPathsMap = colToSubPathsMap;
this.subPathToSlotMap = Maps.newHashMap();
- this.virtualColumns = Utils.fastToImmutableList(virtualColumns);
this.annOrderKeys = Utils.fastToImmutableList(annOrderKeys);
this.annLimit = annLimit;
}
@@ -393,6 +389,7 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
* @param virtualColumns generated virtual columns
* @return scan with virtual columns
*/
+ @Override
public LogicalOlapScan withVirtualColumns(List<NamedExpression>
virtualColumns) {
LogicalProperties logicalProperties = getLogicalProperties();
List<Slot> output = Lists.newArrayList(logicalProperties.getOutput());
@@ -573,10 +570,6 @@ public class LogicalOlapScan extends
LogicalCatalogRelation implements OlapScan
return preAggStatus.isUnset();
}
- public List<NamedExpression> getVirtualColumns() {
- return virtualColumns;
- }
-
public List<OrderKey> getAnnOrderKeys() {
return annOrderKeys;
}
@@ -747,7 +740,7 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
annOrderKeys, annLimit);
}
- Map<Slot, Slot> constructReplaceMap(MTMV mtmv) {
+ private Map<Slot, Slot> constructReplaceMap(MTMV mtmv) {
Map<Slot, Slot> replaceMap = new HashMap<>();
// Need remove invisible column, and then mapping them
List<Slot> originOutputs = new ArrayList<>();
@@ -777,10 +770,6 @@ public class LogicalOlapScan extends
LogicalCatalogRelation implements OlapScan
return replaceMap;
}
- public List<Slot> getOperativeSlots() {
- return operativeSlots;
- }
-
@Override
public boolean equals(Object o) {
if (this == o) {
@@ -801,7 +790,6 @@ public class LogicalOlapScan extends LogicalCatalogRelation
implements OlapScan
&& Objects.equals(selectedPartitionIds,
that.selectedPartitionIds)
&& Objects.equals(hints, that.hints)
&& Objects.equals(tableSample, that.tableSample)
- && Objects.equals(virtualColumns, that.virtualColumns)
&& Objects.equals(annOrderKeys, that.annOrderKeys)
&& Objects.equals(annLimit, that.annLimit);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
index d969f505a4c..6e5e62da092 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
@@ -20,12 +20,15 @@ package org.apache.doris.nereids.trees.plans.logical;
import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
+import com.google.common.collect.ImmutableList;
+
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@@ -41,18 +44,31 @@ public class LogicalSchemaScan extends
LogicalCatalogRelation {
private final Optional<String> schemaTable;
public LogicalSchemaScan(RelationId id, TableIf table, List<String>
qualifier) {
- super(id, PlanType.LOGICAL_SCHEMA_SCAN, table, qualifier);
- this.filterPushed = false;
- this.schemaCatalog = Optional.empty();
- this.schemaDatabase = Optional.empty();
- this.schemaTable = Optional.empty();
+ this(id, table, qualifier, false,
+ Optional.empty(), Optional.empty(), Optional.empty(),
ImmutableList.of(),
+ Optional.empty(), Optional.empty());
}
- public LogicalSchemaScan(RelationId id, TableIf table, List<String>
qualifier,
- Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties,
- boolean filterPushed, Optional<String> schemaCatalog,
Optional<String> schemaDatabase,
- Optional<String> schemaTable) {
- super(id, PlanType.LOGICAL_SCHEMA_SCAN, table, qualifier,
groupExpression, logicalProperties);
+ /**
+ * Constructs a LogicalSchemaScan with the specified parameters.
+ *
+ * @param id Unique identifier for this relation
+ * @param table The table interface representing the underlying data source
+ * @param qualifier The qualifier list representing the path to this table
+ * @param filterPushed Whether filter has been pushed down to this scan
operation
+ * @param schemaCatalog Optional catalog name in the schema
+ * @param schemaDatabase Optional database name in the schema
+ * @param schemaTable Optional table name in the schema
+ * @param virtualColumns List of virtual columns to be included in the scan
+ * @param groupExpression Optional group expression for memo representation
+ * @param logicalProperties Optional logical properties for this plan node
+ */
+ public LogicalSchemaScan(RelationId id, TableIf table, List<String>
qualifier, boolean filterPushed,
+ Optional<String> schemaCatalog, Optional<String> schemaDatabase,
Optional<String> schemaTable,
+ List<NamedExpression> virtualColumns,
+ Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties) {
+ super(id, PlanType.LOGICAL_SCHEMA_SCAN, table, qualifier,
ImmutableList.of(), virtualColumns,
+ groupExpression, logicalProperties);
this.filterPushed = filterPushed;
this.schemaCatalog = schemaCatalog;
this.schemaDatabase = schemaDatabase;
@@ -75,11 +91,6 @@ public class LogicalSchemaScan extends
LogicalCatalogRelation {
return schemaTable;
}
- @Override
- public TableIf getTable() {
- return table;
- }
-
@Override
public <R, C> R accept(PlanVisitor<R, C> visitor, C context) {
return visitor.visitLogicalSchemaScan(this, context);
@@ -87,28 +98,28 @@ public class LogicalSchemaScan extends
LogicalCatalogRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression)
{
- return new LogicalSchemaScan(relationId, table, qualifier,
- groupExpression, Optional.of(getLogicalProperties()),
filterPushed,
- schemaCatalog, schemaDatabase, schemaTable);
+ return new LogicalSchemaScan(relationId, table, qualifier,
filterPushed,
+ schemaCatalog, schemaDatabase, schemaTable, virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression>
groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan>
children) {
- return new LogicalSchemaScan(relationId, table, qualifier,
groupExpression, logicalProperties, filterPushed,
- schemaCatalog, schemaDatabase, schemaTable);
+ return new LogicalSchemaScan(relationId, table, qualifier,
filterPushed,
+ schemaCatalog, schemaDatabase, schemaTable, virtualColumns,
groupExpression, logicalProperties);
}
@Override
public LogicalSchemaScan withRelationId(RelationId relationId) {
- return new LogicalSchemaScan(relationId, table, qualifier,
Optional.empty(), Optional.empty(), filterPushed,
- schemaCatalog, schemaDatabase, schemaTable);
+ return new LogicalSchemaScan(relationId, table, qualifier,
filterPushed,
+ schemaCatalog, schemaDatabase, schemaTable, virtualColumns,
Optional.empty(), Optional.empty());
}
public LogicalSchemaScan withSchemaIdentifier(Optional<String>
schemaCatalog, Optional<String> schemaDatabase,
Optional<String> schemaTable) {
- return new LogicalSchemaScan(relationId, table, qualifier,
Optional.empty(),
- Optional.of(getLogicalProperties()), true, schemaCatalog,
schemaDatabase, schemaTable);
+ return new LogicalSchemaScan(relationId, table, qualifier, true,
schemaCatalog, schemaDatabase, schemaTable,
+ virtualColumns, Optional.empty(),
Optional.of(getLogicalProperties()));
}
@Override
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
