From c075690716b84c6642d23dc31825daed9553cc2e Mon Sep 17 00:00:00 2001 From: xiyang Date: Thu, 21 Sep 2023 12:01:19 -0400 Subject: [PATCH] Rename logicalScanNode to logicalScanInternalID --- .../queries/ldbc-sf100/join/q29.benchmark | 2 +- .../queries/ldbc-sf100/join/q30.benchmark | 2 +- src/binder/bind/bind_graph_pattern.cpp | 2 +- src/binder/bind/bind_projection_clause.cpp | 8 +-- src/binder/bind/bind_reading_clause.cpp | 2 +- .../bind_function_expression.cpp | 4 +- src/binder/expression_visitor.cpp | 8 +-- src/function/aggregate/count.cpp | 2 +- .../binder/expression/node_expression.h | 15 ++--- .../optimizer/acc_hash_join_optimizer.h | 2 +- .../optimizer/filter_push_down_optimizer.h | 9 +-- .../optimizer/logical_operator_collector.h | 12 ++-- .../optimizer/logical_operator_visitor.h | 4 +- .../join_order/cardinality_estimator.h | 5 +- .../planner/operator/logical_operator.h | 2 +- .../planner/operator/logical_plan_util.h | 2 +- .../operator/scan/logical_scan_internal_id.h | 33 +++++++++++ .../planner/operator/scan/logical_scan_node.h | 30 ---------- .../scan/logical_scan_node_property.h | 24 ++++---- .../operator/sip/logical_semi_masker.h | 10 ++-- src/include/planner/query_planner.h | 10 ++-- src/include/processor/plan_mapper.h | 2 +- src/optimizer/acc_hash_join_optimizer.cpp | 47 ++++++++-------- src/optimizer/factorization_rewriter.cpp | 2 +- src/optimizer/filter_push_down_optimizer.cpp | 55 ++++++++++--------- src/optimizer/logical_operator_visitor.cpp | 8 +-- .../projection_push_down_optimizer.cpp | 38 ++++++------- .../remove_unnecessary_join_optimizer.cpp | 4 +- .../join_order/cardinality_estimator.cpp | 6 +- .../operator/extend/logical_extend.cpp | 8 +-- .../extend/logical_recursive_extend.cpp | 10 ++-- src/planner/operator/logical_hash_join.cpp | 8 +-- src/planner/operator/logical_operator.cpp | 6 +- src/planner/operator/logical_plan_util.cpp | 12 ++-- .../operator/persistent/logical_create.cpp | 4 +- .../operator/persistent/logical_delete.cpp | 6 +- .../operator/persistent/logical_set.cpp | 4 +- src/planner/operator/scan/CMakeLists.txt | 2 +- .../scan/logical_scan_internal_id.cpp | 19 +++++++ .../operator/scan/logical_scan_node.cpp | 19 ------- .../scan/logical_scan_node_property.cpp | 2 +- src/planner/plan/append_extend.cpp | 19 ++++--- src/planner/plan/append_scan_node.cpp | 28 ++++++---- src/planner/plan/append_set.cpp | 2 +- src/planner/plan/plan_join_order.cpp | 40 +++++++------- src/planner/plan/plan_subquery.cpp | 4 +- src/planner/plan/plan_update.cpp | 2 +- src/planner/subplans_table.cpp | 3 +- src/processor/map/expression_mapper.cpp | 6 +- src/processor/map/map_create.cpp | 6 +- src/processor/map/map_delete.cpp | 8 +-- src/processor/map/map_extend.cpp | 4 +- src/processor/map/map_path_property_probe.cpp | 2 +- src/processor/map/map_recursive_extend.cpp | 8 +-- src/processor/map/map_scan_frontier.cpp | 2 +- src/processor/map/map_scan_node.cpp | 15 +++-- src/processor/map/map_scan_node_property.cpp | 10 ++-- src/processor/map/map_semi_masker.cpp | 8 +-- src/processor/map/map_set.cpp | 8 +-- src/processor/map/plan_mapper.cpp | 4 +- test/optimizer/optimizer_test.cpp | 4 +- test/test_files/tinysnb/acc/acc_hj.test | 8 +-- .../tinysnb/generic_hash_join/basic.test | 2 +- .../tinysnb/parquet/tinysnb_parquet.test | 2 +- 64 files changed, 329 insertions(+), 316 deletions(-) create mode 100644 src/include/planner/operator/scan/logical_scan_internal_id.h delete mode 100644 src/include/planner/operator/scan/logical_scan_node.h create mode 100644 src/planner/operator/scan/logical_scan_internal_id.cpp delete mode 100644 src/planner/operator/scan/logical_scan_node.cpp diff --git a/benchmark/queries/ldbc-sf100/join/q29.benchmark b/benchmark/queries/ldbc-sf100/join/q29.benchmark index e652a7e781..cd8cd0bbfd 100644 --- a/benchmark/queries/ldbc-sf100/join/q29.benchmark +++ b/benchmark/queries/ldbc-sf100/join/q29.benchmark @@ -1,6 +1,6 @@ -NAME q29 -COMPARE_RESULT 1 -QUERY MATCH (a:Person)-[:knows]->(b:Person) RETURN MIN(a.birthday), MIN(b.birthday) --ENCODED_JOIN HJ(b._ID){E(b)S(a)}{S(b)} +-ENCODED_JOIN HJ(b._ID){E(b)S(a._ID)}{S(b._ID)} ---- 1 1980-02-01|1980-02-01 diff --git a/benchmark/queries/ldbc-sf100/join/q30.benchmark b/benchmark/queries/ldbc-sf100/join/q30.benchmark index 02c5325d08..6e4057c9e2 100644 --- a/benchmark/queries/ldbc-sf100/join/q30.benchmark +++ b/benchmark/queries/ldbc-sf100/join/q30.benchmark @@ -1,6 +1,6 @@ -NAME q30 -COMPARE_RESULT 1 -QUERY MATCH (a:Person)-[:knows]->(b:Person)-[:knows]->(c:Person) RETURN MIN(a.birthday), MIN(b.birthday), MIN(c.birthday) --ENCODED_JOIN HJ(c._ID){HJ(a._ID){E(c)E(a)S(b)}{S(a)}}{S(c)} +-ENCODED_JOIN HJ(c._ID){HJ(a._ID){E(c)E(a)S(b._ID)}{S(a._ID)}}{S(c._ID)} ---- 1 1980-02-01|1980-02-01|1980-02-01 diff --git a/src/binder/bind/bind_graph_pattern.cpp b/src/binder/bind/bind_graph_pattern.cpp index d5a47ac24d..d0e33c1907 100644 --- a/src/binder/bind/bind_graph_pattern.cpp +++ b/src/binder/bind/bind_graph_pattern.cpp @@ -406,7 +406,7 @@ std::shared_ptr Binder::createQueryNode( getUniqueExpressionName(parsedName), parsedName, tableIDs); queryNode->setAlias(parsedName); bindQueryNodeProperties(*queryNode); - queryNode->setInternalIDProperty(expressionBinder.createInternalNodeIDExpression(*queryNode)); + queryNode->setInternalID(expressionBinder.createInternalNodeIDExpression(*queryNode)); queryNode->setLabelExpression(expressionBinder.bindLabelFunction(*queryNode)); std::vector> nodeFields; nodeFields.push_back(std::make_unique( diff --git a/src/binder/bind/bind_projection_clause.cpp b/src/binder/bind/bind_projection_clause.cpp index 8543a9add9..3aeb5cf756 100644 --- a/src/binder/bind/bind_projection_clause.cpp +++ b/src/binder/bind/bind_projection_clause.cpp @@ -29,11 +29,11 @@ static expression_vector rewriteProjectionInWithClause(const expression_vector& for (auto& expression : expressions) { if (ExpressionUtil::isNodeVariable(*expression)) { auto node = (NodeExpression*)expression.get(); - result.push_back(node->getInternalIDProperty()); + result.push_back(node->getInternalID()); } else if (ExpressionUtil::isRelVariable(*expression)) { auto rel = (RelExpression*)expression.get(); - result.push_back(rel->getSrcNode()->getInternalIDProperty()); - result.push_back(rel->getDstNode()->getInternalIDProperty()); + result.push_back(rel->getSrcNode()->getInternalID()); + result.push_back(rel->getDstNode()->getInternalID()); result.push_back(rel->getInternalIDProperty()); } else if (ExpressionUtil::isRecursiveRelVariable(*expression)) { auto rel = (RelExpression*)expression.get(); @@ -131,7 +131,7 @@ std::unique_ptr Binder::bindProjectionBody( for (auto& expression : groupByExpressions) { if (ExpressionUtil::isNodeVariable(*expression)) { auto node = (NodeExpression*)expression.get(); - augmentedGroupByExpressions.push_back(node->getInternalIDProperty()); + augmentedGroupByExpressions.push_back(node->getInternalID()); } else if (ExpressionUtil::isRelVariable(*expression)) { auto rel = (RelExpression*)expression.get(); augmentedGroupByExpressions.push_back(rel->getInternalIDProperty()); diff --git a/src/binder/bind/bind_reading_clause.cpp b/src/binder/bind/bind_reading_clause.cpp index 8b37e96dc7..0cc3dfa4f1 100644 --- a/src/binder/bind/bind_reading_clause.cpp +++ b/src/binder/bind/bind_reading_clause.cpp @@ -63,7 +63,7 @@ std::unique_ptr Binder::bindMatchClause(const ReadingClause& queryGraph->addQueryNode(newDst); queryRel->setDstNode(newDst); auto predicate = expressionBinder.createEqualityComparisonExpression( - src->getInternalIDProperty(), newDst->getInternalIDProperty()); + src->getInternalID(), newDst->getInternalID()); selfLoopEdgePredicates.push_back(std::move(predicate)); } } diff --git a/src/binder/bind_expression/bind_function_expression.cpp b/src/binder/bind_expression/bind_function_expression.cpp index ca7a3b5b64..3908bbcc3e 100644 --- a/src/binder/bind_expression/bind_function_expression.cpp +++ b/src/binder/bind_expression/bind_function_expression.cpp @@ -177,7 +177,7 @@ std::shared_ptr ExpressionBinder::bindInternalIDExpression( std::shared_ptr expression) { if (ExpressionUtil::isNodeVariable(*expression)) { auto& node = (NodeExpression&)*expression; - return node.getInternalIDProperty(); + return node.getInternalID(); } if (ExpressionUtil::isRelVariable(*expression)) { return bindRelPropertyExpression(*expression, InternalKeyword::ID); @@ -225,7 +225,7 @@ std::shared_ptr ExpressionBinder::bindLabelFunction(const Expression std::make_unique(LogicalType{LogicalTypeID::STRING}, labelName)); } auto nodeTableIDs = catalogContent->getNodeTableIDs(); - children.push_back(node.getInternalIDProperty()); + children.push_back(node.getInternalID()); auto labelsValue = std::make_unique(*listType, populateLabelValues(nodeTableIDs, *catalogContent)); children.push_back(createLiteralExpression(std::move(labelsValue))); diff --git a/src/binder/expression_visitor.cpp b/src/binder/expression_visitor.cpp index 6d91c38026..37d121917e 100644 --- a/src/binder/expression_visitor.cpp +++ b/src/binder/expression_visitor.cpp @@ -55,7 +55,7 @@ expression_vector ExpressionChildrenCollector::collectExistentialSubqueryChildre expression_vector result; auto& subqueryExpression = (ExistentialSubqueryExpression&)expression; for (auto& node : subqueryExpression.getQueryGraphCollection()->getQueryNodes()) { - result.push_back(node->getInternalIDProperty()); + result.push_back(node->getInternalID()); } if (subqueryExpression.hasWhereExpression()) { result.push_back(subqueryExpression.getWhereExpression()); @@ -69,15 +69,15 @@ expression_vector ExpressionChildrenCollector::collectNodeChildren(const Express for (auto& property : node.getPropertyExpressions()) { result.push_back(property->copy()); } - result.push_back(node.getInternalIDProperty()); + result.push_back(node.getInternalID()); return result; } expression_vector ExpressionChildrenCollector::collectRelChildren(const Expression& expression) { expression_vector result; auto& rel = (RelExpression&)expression; - result.push_back(rel.getSrcNode()->getInternalIDProperty()); - result.push_back(rel.getDstNode()->getInternalIDProperty()); + result.push_back(rel.getSrcNode()->getInternalID()); + result.push_back(rel.getDstNode()->getInternalID()); for (auto& property : rel.getPropertyExpressions()) { result.push_back(property->copy()); } diff --git a/src/function/aggregate/count.cpp b/src/function/aggregate/count.cpp index c5b8b17338..30ff74cc6e 100644 --- a/src/function/aggregate/count.cpp +++ b/src/function/aggregate/count.cpp @@ -32,7 +32,7 @@ void CountFunction::paramRewriteFunc(binder::expression_vector& arguments) { assert(arguments.size() == 1); if (ExpressionUtil::isNodeVariable(*arguments[0])) { auto node = (NodeExpression*)arguments[0].get(); - arguments[0] = node->getInternalIDProperty(); + arguments[0] = node->getInternalID(); } else if (ExpressionUtil::isRelVariable(*arguments[0])) { auto rel = (RelExpression*)arguments[0].get(); arguments[0] = rel->getInternalIDProperty(); diff --git a/src/include/binder/expression/node_expression.h b/src/include/binder/expression/node_expression.h index 93babaec52..a7b4b350f8 100644 --- a/src/include/binder/expression/node_expression.h +++ b/src/include/binder/expression/node_expression.h @@ -13,19 +13,16 @@ class NodeExpression : public NodeOrRelExpression { : NodeOrRelExpression{std::move(dataType), std::move(uniqueName), std::move(variableName), std::move(tableIDs)} {} - inline void setInternalIDProperty(std::unique_ptr expression) { - internalIDExpression = std::move(expression); + inline void setInternalID(std::unique_ptr expression) { + internalID = std::move(expression); } - inline std::shared_ptr getInternalIDProperty() const { - assert(internalIDExpression != nullptr); - return internalIDExpression->copy(); - } - inline std::string getInternalIDPropertyName() const { - return internalIDExpression->getUniqueName(); + inline std::shared_ptr getInternalID() const { + assert(internalID != nullptr); + return internalID->copy(); } private: - std::unique_ptr internalIDExpression; + std::unique_ptr internalID; }; } // namespace binder diff --git a/src/include/optimizer/acc_hash_join_optimizer.h b/src/include/optimizer/acc_hash_join_optimizer.h index c765656ae0..642722b95f 100644 --- a/src/include/optimizer/acc_hash_join_optimizer.h +++ b/src/include/optimizer/acc_hash_join_optimizer.h @@ -30,7 +30,7 @@ class HashJoinSIPOptimizer : public LogicalOperatorVisitor { const binder::Expression& nodeID, planner::LogicalOperator* root); // Find all ScanNodeIDs under root which scans parameter nodeID. Note that there might be // multiple ScanNodeIDs matches because both node and rel table scans will trigger scanNodeIDs. - std::vector resolveScanNodeIDsToApplySemiMask( + std::vector resolveScanInternalIDsToApplySemiMask( const binder::Expression& nodeID, planner::LogicalOperator* root); // Find all ShortestPathExtend under root which extend to parameter nodeID. There will be at // most one match because rel table is scanned exactly once. diff --git a/src/include/optimizer/filter_push_down_optimizer.h b/src/include/optimizer/filter_push_down_optimizer.h index f5a3e1c700..dda6ebba38 100644 --- a/src/include/optimizer/filter_push_down_optimizer.h +++ b/src/include/optimizer/filter_push_down_optimizer.h @@ -37,7 +37,8 @@ class FilterPushDownOptimizer { // SCAN_NODE_ID->(SCAN_NODE_PROPERTY->FILTER)*->SCAN_NODE_PROPERTY // so that filter with higher selectivity is applied before scanning. std::shared_ptr pushDownToScanNode( - std::shared_ptr node, std::shared_ptr predicate, + std::shared_ptr nodeID, std::vector tableIDs, + std::shared_ptr predicate, std::shared_ptr child); // Finish the current push down optimization by apply remaining predicates as a single filter. @@ -46,8 +47,8 @@ class FilterPushDownOptimizer { std::shared_ptr op); std::shared_ptr appendScanNodeProperty( - std::shared_ptr node, binder::expression_vector properties, - std::shared_ptr child); + std::shared_ptr nodeID, std::vector nodeTableIDs, + binder::expression_vector properties, std::shared_ptr child); std::shared_ptr appendFilter( std::shared_ptr predicate, std::shared_ptr child); @@ -66,7 +67,7 @@ class FilterPushDownOptimizer { void addPredicate(std::shared_ptr predicate); std::shared_ptr popNodePKEqualityComparison( - const binder::NodeExpression& node); + const binder::Expression& nodeID); }; private: diff --git a/src/include/optimizer/logical_operator_collector.h b/src/include/optimizer/logical_operator_collector.h index 967e24b9a6..8d3cd7c572 100644 --- a/src/include/optimizer/logical_operator_collector.h +++ b/src/include/optimizer/logical_operator_collector.h @@ -20,27 +20,27 @@ class LogicalOperatorCollector : public LogicalOperatorVisitor { class LogicalFlattenCollector : public LogicalOperatorCollector { protected: - void visitFlatten(planner::LogicalOperator* op) override { ops.push_back(op); } + void visitFlatten(planner::LogicalOperator* op) final { ops.push_back(op); } }; class LogicalFilterCollector : public LogicalOperatorCollector { protected: - void visitFilter(planner::LogicalOperator* op) override { ops.push_back(op); } + void visitFilter(planner::LogicalOperator* op) final { ops.push_back(op); } }; -class LogicalScanNodeCollector : public LogicalOperatorCollector { +class LogicalScanInternalIDCollector : public LogicalOperatorCollector { protected: - void visitScanNode(planner::LogicalOperator* op) override { ops.push_back(op); } + void visitScanInternalID(planner::LogicalOperator* op) final { ops.push_back(op); } }; class LogicalIndexScanNodeCollector : public LogicalOperatorCollector { protected: - void visitIndexScanNode(planner::LogicalOperator* op) override { ops.push_back(op); } + void visitIndexScanNode(planner::LogicalOperator* op) final { ops.push_back(op); } }; class LogicalRecursiveExtendCollector : public LogicalOperatorCollector { protected: - void visitRecursiveExtend(planner::LogicalOperator* op) override { ops.push_back(op); } + void visitRecursiveExtend(planner::LogicalOperator* op) final { ops.push_back(op); } }; } // namespace optimizer diff --git a/src/include/optimizer/logical_operator_visitor.h b/src/include/optimizer/logical_operator_visitor.h index 91b8a9c93b..4415833072 100644 --- a/src/include/optimizer/logical_operator_visitor.h +++ b/src/include/optimizer/logical_operator_visitor.h @@ -27,8 +27,8 @@ class LogicalOperatorVisitor { return op; } - virtual void visitScanNode(planner::LogicalOperator* op) {} - virtual std::shared_ptr visitScanNodeReplace( + virtual void visitScanInternalID(planner::LogicalOperator* op) {} + virtual std::shared_ptr visitScanInternalIDReplace( std::shared_ptr op) { return op; } diff --git a/src/include/planner/join_order/cardinality_estimator.h b/src/include/planner/join_order/cardinality_estimator.h index ecc1307404..3f392aeebd 100644 --- a/src/include/planner/join_order/cardinality_estimator.h +++ b/src/include/planner/join_order/cardinality_estimator.h @@ -32,8 +32,9 @@ class CardinalityEstimator { inline uint64_t atLeastOne(uint64_t x) { return x == 0 ? 1 : x; } inline void addNodeIDDom(const binder::NodeExpression& node) { - if (!nodeIDName2dom.contains(node.getInternalIDPropertyName())) { - nodeIDName2dom.insert({node.getInternalIDPropertyName(), getNumNodes(node)}); + auto key = node.getInternalID()->getUniqueName(); + if (!nodeIDName2dom.contains(key)) { + nodeIDName2dom.insert({key, getNumNodes(node)}); } } uint64_t getNodeIDDom(const std::string& nodeIDName) { diff --git a/src/include/planner/operator/logical_operator.h b/src/include/planner/operator/logical_operator.h index 5fa93ee86b..544e1f20a1 100644 --- a/src/include/planner/operator/logical_operator.h +++ b/src/include/planner/operator/logical_operator.h @@ -44,7 +44,7 @@ enum class LogicalOperatorType : uint8_t { RENAME_PROPERTY, SCAN_FILE, SCAN_FRONTIER, - SCAN_NODE, + SCAN_INTERNAL_ID, SCAN_NODE_PROPERTY, SEMI_MASKER, SET_NODE_PROPERTY, diff --git a/src/include/planner/operator/logical_plan_util.h b/src/include/planner/operator/logical_plan_util.h index 6d5df11562..a6891f54a2 100644 --- a/src/include/planner/operator/logical_plan_util.h +++ b/src/include/planner/operator/logical_plan_util.h @@ -26,7 +26,7 @@ class LogicalPlanUtil { static void encodeHashJoin(LogicalOperator* logicalOperator, std::string& encodeString); static void encodeExtend(LogicalOperator* logicalOperator, std::string& encodeString); static void encodeRecursiveExtend(LogicalOperator* logicalOperator, std::string& encodeString); - static void encodeScanNodeID(LogicalOperator* logicalOperator, std::string& encodeString); + static void encodeScanInternalID(LogicalOperator* logicalOperator, std::string& encodeString); }; } // namespace planner diff --git a/src/include/planner/operator/scan/logical_scan_internal_id.h b/src/include/planner/operator/scan/logical_scan_internal_id.h new file mode 100644 index 0000000000..f069196306 --- /dev/null +++ b/src/include/planner/operator/scan/logical_scan_internal_id.h @@ -0,0 +1,33 @@ +#pragma once + +#include "planner/operator/logical_operator.h" + +namespace kuzu { +namespace planner { + +class LogicalScanInternalID : public LogicalOperator { +public: + explicit LogicalScanInternalID( + std::shared_ptr internalID, std::vector tableIDs) + : LogicalOperator{LogicalOperatorType::SCAN_INTERNAL_ID}, + internalID{std::move(internalID)}, tableIDs{std::move(tableIDs)} {} + + void computeFactorizedSchema() final; + void computeFlatSchema() final; + + inline std::string getExpressionsForPrinting() const final { return internalID->toString(); } + + inline std::shared_ptr getInternalID() const { return internalID; } + inline std::vector getTableIDs() const { return tableIDs; } + + inline std::unique_ptr copy() final { + return make_unique(internalID, tableIDs); + } + +private: + std::shared_ptr internalID; + std::vector tableIDs; +}; + +} // namespace planner +} // namespace kuzu diff --git a/src/include/planner/operator/scan/logical_scan_node.h b/src/include/planner/operator/scan/logical_scan_node.h deleted file mode 100644 index a7eda3f1bc..0000000000 --- a/src/include/planner/operator/scan/logical_scan_node.h +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include "binder/expression/node_expression.h" -#include "planner/operator/logical_operator.h" - -namespace kuzu { -namespace planner { - -class LogicalScanNode : public LogicalOperator { -public: - explicit LogicalScanNode(std::shared_ptr node) - : LogicalOperator{LogicalOperatorType::SCAN_NODE}, node{std::move(node)} {} - - void computeFactorizedSchema() override; - void computeFlatSchema() override; - - inline std::string getExpressionsForPrinting() const override { return node->toString(); } - - inline std::shared_ptr getNode() const { return node; } - - inline std::unique_ptr copy() override { - return make_unique(node); - } - -private: - std::shared_ptr node; -}; - -} // namespace planner -} // namespace kuzu diff --git a/src/include/planner/operator/scan/logical_scan_node_property.h b/src/include/planner/operator/scan/logical_scan_node_property.h index 00bd63d9fa..64a2afea93 100644 --- a/src/include/planner/operator/scan/logical_scan_node_property.h +++ b/src/include/planner/operator/scan/logical_scan_node_property.h @@ -1,6 +1,5 @@ #pragma once -#include "binder/expression/node_expression.h" #include "planner/operator/logical_operator.h" namespace kuzu { @@ -8,27 +7,32 @@ namespace planner { class LogicalScanNodeProperty : public LogicalOperator { public: - LogicalScanNodeProperty(std::shared_ptr node, - binder::expression_vector properties, std::shared_ptr child) + LogicalScanNodeProperty(std::shared_ptr nodeID, + std::vector nodeTableIDs, binder::expression_vector properties, + std::shared_ptr child) : LogicalOperator{LogicalOperatorType::SCAN_NODE_PROPERTY, std::move(child)}, - node{std::move(node)}, properties{std::move(properties)} {} + nodeID{std::move(nodeID)}, nodeTableIDs{std::move(nodeTableIDs)}, properties{std::move( + properties)} {} - void computeFactorizedSchema() override; - void computeFlatSchema() override; + void computeFactorizedSchema() final; + void computeFlatSchema() final; inline std::string getExpressionsForPrinting() const override { return binder::ExpressionUtil::toString(properties); } - inline std::shared_ptr getNode() const { return node; } + inline std::shared_ptr getNodeID() const { return nodeID; } + inline std::vector getTableIDs() const { return nodeTableIDs; } inline binder::expression_vector getProperties() const { return properties; } - inline std::unique_ptr copy() override { - return make_unique(node, properties, children[0]->copy()); + inline std::unique_ptr copy() final { + return make_unique( + nodeID, nodeTableIDs, properties, children[0]->copy()); } private: - std::shared_ptr node; + std::shared_ptr nodeID; + std::vector nodeTableIDs; binder::expression_vector properties; }; diff --git a/src/include/planner/operator/sip/logical_semi_masker.h b/src/include/planner/operator/sip/logical_semi_masker.h index db75b58b99..163191061c 100644 --- a/src/include/planner/operator/sip/logical_semi_masker.h +++ b/src/include/planner/operator/sip/logical_semi_masker.h @@ -15,19 +15,19 @@ enum class SemiMaskType : uint8_t { class LogicalSemiMasker : public LogicalOperator { public: LogicalSemiMasker(SemiMaskType type, std::shared_ptr key, - std::shared_ptr node, std::vector ops, + std::vector nodeTableIDs, std::vector ops, std::shared_ptr child) : LogicalOperator{LogicalOperatorType::SEMI_MASKER, std::move(child)}, type{type}, - key{std::move(key)}, node{std::move(node)}, ops{std::move(ops)} {} + key{std::move(key)}, nodeTableIDs{std::move(nodeTableIDs)}, ops{std::move(ops)} {} inline void computeFactorizedSchema() override { copyChildSchema(0); } inline void computeFlatSchema() override { copyChildSchema(0); } - inline std::string getExpressionsForPrinting() const override { return node->toString(); } + inline std::string getExpressionsForPrinting() const override { return key->toString(); } inline SemiMaskType getType() const { return type; } inline std::shared_ptr getKey() const { return key; } - inline std::shared_ptr getNode() const { return node; } + inline std::vector getNodeTableIDs() const { return nodeTableIDs; } inline std::vector getOperators() const { return ops; } inline std::unique_ptr copy() override { @@ -37,7 +37,7 @@ class LogicalSemiMasker : public LogicalOperator { private: SemiMaskType type; std::shared_ptr key; - std::shared_ptr node; + std::vector nodeTableIDs; std::vector ops; }; diff --git a/src/include/planner/query_planner.h b/src/include/planner/query_planner.h index 749b4db333..3a2c06534f 100644 --- a/src/include/planner/query_planner.h +++ b/src/include/planner/query_planner.h @@ -110,8 +110,6 @@ class QueryPlanner { void planBaseTableScans( SubqueryType subqueryType, const expression_vector& correlatedExpressions); void planCorrelatedExpressionsScan(const binder::expression_vector& correlatedExpressions); - std::unique_ptr getCorrelatedExpressionScanPlan( - const binder::expression_vector& correlatedExpressions); void planNodeScan(uint32_t nodePos); void planNodeIDScan(uint32_t nodePos); void planRelScan(uint32_t relPos); @@ -175,9 +173,11 @@ class QueryPlanner { // Append scan operators void appendExpressionsScan(const expression_vector& expressions, LogicalPlan& plan); - void appendScanNodeID(std::shared_ptr& node, LogicalPlan& plan); - void appendScanNodeProperties(const expression_vector& propertyExpressions, - std::shared_ptr node, LogicalPlan& plan); + void appendScanInternalID(std::shared_ptr internalID, + std::vector tableIDs, LogicalPlan& plan); + void appendScanNodeProperties(std::shared_ptr nodeID, + std::vector tableIDs, const expression_vector& properties, + LogicalPlan& plan); // Append extend operators void appendNonRecursiveExtend(std::shared_ptr boundNode, diff --git a/src/include/processor/plan_mapper.h b/src/include/processor/plan_mapper.h index c9413b6b3b..9b11dfeb38 100644 --- a/src/include/processor/plan_mapper.h +++ b/src/include/processor/plan_mapper.h @@ -42,7 +42,7 @@ class PlanMapper { std::unique_ptr mapOperator(planner::LogicalOperator* logicalOperator); std::unique_ptr mapScanFile(planner::LogicalOperator* logicalOperator); std::unique_ptr mapScanFrontier(planner::LogicalOperator* logicalOperator); - std::unique_ptr mapScanNode(planner::LogicalOperator* logicalOperator); + std::unique_ptr mapScanInternalID(planner::LogicalOperator* logicalOperator); std::unique_ptr mapIndexScanNode(planner::LogicalOperator* logicalOperator); std::unique_ptr mapUnwind(planner::LogicalOperator* logicalOperator); std::unique_ptr mapExtend(planner::LogicalOperator* logicalOperator); diff --git a/src/optimizer/acc_hash_join_optimizer.cpp b/src/optimizer/acc_hash_join_optimizer.cpp index ee0df3ac3a..283d7564ed 100644 --- a/src/optimizer/acc_hash_join_optimizer.cpp +++ b/src/optimizer/acc_hash_join_optimizer.cpp @@ -6,7 +6,7 @@ #include "planner/operator/logical_accumulate.h" #include "planner/operator/logical_hash_join.h" #include "planner/operator/logical_intersect.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" #include "planner/operator/sip/logical_semi_masker.h" using namespace kuzu::common; @@ -141,7 +141,7 @@ void HashJoinSIPOptimizer::visitPathPropertyProbe(planner::LogicalOperator* op) return; } auto recursiveRel = pathPropertyProbe->getRel(); - auto nodeID = recursiveRel->getRecursiveInfo()->node->getInternalIDProperty(); + auto nodeID = recursiveRel->getRecursiveInfo()->node->getInternalID(); std::vector opsToApplySemiMask; for (auto op_ : resolveOperatorsToApplySemiMask(*nodeID, pathPropertyProbe->getChild(1).get())) { @@ -171,7 +171,7 @@ bool HashJoinSIPOptimizer::isProbeSideQualified(planner::LogicalOperator* probeR std::vector HashJoinSIPOptimizer::resolveOperatorsToApplySemiMask( const binder::Expression& nodeID, planner::LogicalOperator* root) { std::vector result; - for (auto& op : resolveScanNodeIDsToApplySemiMask(nodeID, root)) { + for (auto& op : resolveScanInternalIDsToApplySemiMask(nodeID, root)) { result.push_back(op); } for (auto& op : resolveShortestPathExtendToApplySemiMask(nodeID, root)) { @@ -180,15 +180,14 @@ std::vector HashJoinSIPOptimizer::resolveOperatorsToA return result; } -std::vector HashJoinSIPOptimizer::resolveScanNodeIDsToApplySemiMask( +std::vector HashJoinSIPOptimizer::resolveScanInternalIDsToApplySemiMask( const binder::Expression& nodeID, planner::LogicalOperator* root) { std::vector result; - auto scanNodesCollector = LogicalScanNodeCollector(); - scanNodesCollector.collect(root); - for (auto& op : scanNodesCollector.getOperators()) { - auto scanNode = (LogicalScanNode*)op; - auto node = scanNode->getNode(); - if (nodeID.getUniqueName() == node->getInternalIDProperty()->getUniqueName()) { + auto collector = LogicalScanInternalIDCollector(); + collector.collect(root); + for (auto& op : collector.getOperators()) { + auto scan = reinterpret_cast(op); + if (nodeID.getUniqueName() == scan->getInternalID()->getUniqueName()) { result.push_back(op); } } @@ -204,7 +203,7 @@ HashJoinSIPOptimizer::resolveShortestPathExtendToApplySemiMask( for (auto& op : recursiveJoinCollector.getOperators()) { auto recursiveJoin = (LogicalRecursiveExtend*)op; auto node = recursiveJoin->getNbrNode(); - if (nodeID.getUniqueName() == node->getInternalIDProperty()->getUniqueName()) { + if (nodeID.getUniqueName() == node->getInternalID()->getUniqueName()) { result.push_back(op); return result; } @@ -217,21 +216,24 @@ std::shared_ptr HashJoinSIPOptimizer::appendNodeSemiMa std::shared_ptr child) { assert(!opsToApplySemiMask.empty()); auto op = opsToApplySemiMask[0]; - std::shared_ptr node; + std::shared_ptr key; + std::vector nodeTableIDs; switch (op->getOperatorType()) { - case LogicalOperatorType::SCAN_NODE: { - auto scanNode = (LogicalScanNode*)op; - node = scanNode->getNode(); + case LogicalOperatorType::SCAN_INTERNAL_ID: { + auto scan = reinterpret_cast(op); + key = scan->getInternalID(); + nodeTableIDs = scan->getTableIDs(); } break; case LogicalOperatorType::RECURSIVE_EXTEND: { - auto recursiveExtend = (LogicalRecursiveExtend*)op; - node = recursiveExtend->getNbrNode(); + auto extend = reinterpret_cast(op); + key = extend->getNbrNode()->getInternalID(); + nodeTableIDs = extend->getNbrNode()->getTableIDs(); } break; default: throw NotImplementedException("HashJoinSIPOptimizer::appendSemiMask"); } - auto semiMasker = std::make_shared( - SemiMaskType::NODE, node->getInternalIDProperty(), node, opsToApplySemiMask, child); + auto semiMasker = std::make_shared(SemiMaskType::NODE, std::move(key), + std::move(nodeTableIDs), opsToApplySemiMask, std::move(child)); semiMasker->computeFlatSchema(); return semiMasker; } @@ -242,11 +244,10 @@ std::shared_ptr HashJoinSIPOptimizer::appendPathSemiMa std::shared_ptr child) { assert(!opsToApplySemiMask.empty()); auto op = opsToApplySemiMask[0]; - assert(op->getOperatorType() == planner::LogicalOperatorType::SCAN_NODE); - auto scanNode = (LogicalScanNode*)op; - auto node = scanNode->getNode(); + assert(op->getOperatorType() == planner::LogicalOperatorType::SCAN_INTERNAL_ID); + auto scan = reinterpret_cast(op); auto semiMasker = std::make_shared( - SemiMaskType::PATH, pathExpression, node, opsToApplySemiMask, child); + SemiMaskType::PATH, pathExpression, scan->getTableIDs(), opsToApplySemiMask, child); semiMasker->computeFlatSchema(); return semiMasker; } diff --git a/src/optimizer/factorization_rewriter.cpp b/src/optimizer/factorization_rewriter.cpp index 2537ccd831..006242784b 100644 --- a/src/optimizer/factorization_rewriter.cpp +++ b/src/optimizer/factorization_rewriter.cpp @@ -138,7 +138,7 @@ void FactorizationRewriter::visitSetNodeProperty(planner::LogicalOperator* op) { auto setNodeProperty = (LogicalSetNodeProperty*)op; for (auto& info : setNodeProperty->getInfosRef()) { auto node = reinterpret_cast(info->nodeOrRel.get()); - auto lhsNodeID = node->getInternalIDProperty(); + auto lhsNodeID = node->getInternalID(); auto rhs = info->setItem.second; // flatten rhs auto rhsDependentGroupsPos = op->getChild(0)->getSchema()->getDependentGroupsPos(rhs); diff --git a/src/optimizer/filter_push_down_optimizer.cpp b/src/optimizer/filter_push_down_optimizer.cpp index e1f0341660..bcdf07e91d 100644 --- a/src/optimizer/filter_push_down_optimizer.cpp +++ b/src/optimizer/filter_push_down_optimizer.cpp @@ -7,7 +7,7 @@ #include "planner/operator/logical_hash_join.h" #include "planner/operator/scan/logical_dummy_scan.h" #include "planner/operator/scan/logical_index_scan.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" #include "planner/operator/scan/logical_scan_node_property.h" using namespace kuzu::binder; @@ -85,10 +85,13 @@ std::shared_ptr FilterPushDownOptimizer::visitCrossProductRepla std::shared_ptr FilterPushDownOptimizer::visitScanNodePropertyReplace( std::shared_ptr op) { - auto scanNodeProperty = (LogicalScanNodeProperty*)op.get(); - assert(scanNodeProperty->getChild(0)->getOperatorType() == LogicalOperatorType::SCAN_NODE); - auto node = ((LogicalScanNode&)*scanNodeProperty->getChild(0)).getNode(); - auto primaryKeyEqualityComparison = predicateSet->popNodePKEqualityComparison(*node); + auto scan = (LogicalScanNodeProperty*)op.get(); + auto nodeID = scan->getNodeID(); + auto tableIDs = scan->getTableIDs(); + std::shared_ptr primaryKeyEqualityComparison = nullptr; + if (tableIDs.size() == 1) { + primaryKeyEqualityComparison = predicateSet->popNodePKEqualityComparison(*nodeID); + } if (primaryKeyEqualityComparison != nullptr) { // Try rewrite index scan auto rhs = primaryKeyEqualityComparison->getChild(1); if (rhs->expressionType == ExpressionType::LITERAL) { @@ -96,8 +99,9 @@ std::shared_ptr FilterPushDownOptimizer::visitScanNode auto expressionsScan = std::make_shared(); expressionsScan->computeFlatSchema(); std::vector> infos; - infos.push_back(std::make_unique(node->getSingleTableID(), - node->getInternalIDProperty(), rhs, rhs->getDataType().copy())); + assert(tableIDs.size() == 1); + infos.push_back(std::make_unique( + tableIDs[0], nodeID, rhs, rhs->getDataType().copy())); auto indexScan = std::make_shared( std::move(infos), std::move(expressionsScan)); indexScan->computeFlatSchema(); @@ -108,26 +112,27 @@ std::shared_ptr FilterPushDownOptimizer::visitScanNode } } // Perform filter push down. - auto currentRoot = scanNodeProperty->getChild(0); + auto currentRoot = scan->getChild(0); for (auto& predicate : predicateSet->equalityPredicates) { - currentRoot = pushDownToScanNode(node, predicate, currentRoot); + currentRoot = pushDownToScanNode(nodeID, tableIDs, predicate, currentRoot); } for (auto& predicate : predicateSet->nonEqualityPredicates) { - currentRoot = pushDownToScanNode(node, predicate, currentRoot); + currentRoot = pushDownToScanNode(nodeID, tableIDs, predicate, currentRoot); } // Scan remaining properties. expression_vector properties; - for (auto& property : scanNodeProperty->getProperties()) { + for (auto& property : scan->getProperties()) { if (currentRoot->getSchema()->isExpressionInScope(*property)) { continue; } properties.push_back(property); } - return appendScanNodeProperty(node, properties, currentRoot); + return appendScanNodeProperty(nodeID, tableIDs, properties, currentRoot); } std::shared_ptr FilterPushDownOptimizer::pushDownToScanNode( - std::shared_ptr node, std::shared_ptr predicate, + std::shared_ptr nodeID, std::vector tableIDs, + std::shared_ptr predicate, std::shared_ptr child) { binder::expression_set propertiesSet; auto expressionCollector = std::make_unique(); @@ -137,10 +142,11 @@ std::shared_ptr FilterPushDownOptimizer::pushDownToSca // Property already matched continue; } - assert(propertyExpression->getVariableName() == node->getUniqueName()); + assert(propertyExpression->getVariableName() == + ((PropertyExpression&)*nodeID).getVariableName()); propertiesSet.insert(expression); } - auto scanNodeProperty = appendScanNodeProperty(std::move(node), + auto scanNodeProperty = appendScanNodeProperty(std::move(nodeID), std::move(tableIDs), expression_vector{propertiesSet.begin(), propertiesSet.end()}, std::move(child)); return appendFilter(std::move(predicate), scanNodeProperty); } @@ -162,13 +168,13 @@ std::shared_ptr FilterPushDownOptimizer::finishPushDow } std::shared_ptr FilterPushDownOptimizer::appendScanNodeProperty( - std::shared_ptr node, binder::expression_vector properties, - std::shared_ptr child) { + std::shared_ptr nodeID, std::vector nodeTableIDs, + binder::expression_vector properties, std::shared_ptr child) { if (properties.empty()) { return child; } auto scanNodeProperty = std::make_shared( - std::move(node), std::move(properties), std::move(child)); + std::move(nodeID), std::move(nodeTableIDs), std::move(properties), std::move(child)); scanNodeProperty->computeFlatSchema(); return scanNodeProperty; } @@ -190,13 +196,13 @@ void FilterPushDownOptimizer::PredicateSet::addPredicate( } } -static bool isNodePrimaryKey(const Expression& expression, const NodeExpression& node) { +static bool isNodePrimaryKey(const Expression& expression, const Expression& nodeID) { if (expression.expressionType != ExpressionType::PROPERTY) { // not property return false; } auto& propertyExpression = (PropertyExpression&)expression; - if (propertyExpression.getVariableName() != node.getUniqueName()) { + if (propertyExpression.getVariableName() != ((PropertyExpression&)nodeID).getVariableName()) { // not property for node return false; } @@ -205,18 +211,15 @@ static bool isNodePrimaryKey(const Expression& expression, const NodeExpression& std::shared_ptr FilterPushDownOptimizer::PredicateSet::popNodePKEqualityComparison( - const binder::NodeExpression& node) { - if (node.isMultiLabeled()) { // Multi-labeled node scan can not be converted to index scan. - return nullptr; - } + const binder::Expression& nodeID) { // We pop when the first primary key equality comparison is found. auto resultPredicateIdx = INVALID_VECTOR_IDX; for (auto i = 0u; i < equalityPredicates.size(); ++i) { auto predicate = equalityPredicates[i]; - if (isNodePrimaryKey(*predicate->getChild(0), node)) { + if (isNodePrimaryKey(*predicate->getChild(0), nodeID)) { resultPredicateIdx = i; break; - } else if (isNodePrimaryKey(*predicate->getChild(1), node)) { + } else if (isNodePrimaryKey(*predicate->getChild(1), nodeID)) { // Normalize primary key to LHS. auto leftChild = predicate->getChild(0); auto rightChild = predicate->getChild(1); diff --git a/src/optimizer/logical_operator_visitor.cpp b/src/optimizer/logical_operator_visitor.cpp index 18c633b7c1..1be985235d 100644 --- a/src/optimizer/logical_operator_visitor.cpp +++ b/src/optimizer/logical_operator_visitor.cpp @@ -13,8 +13,8 @@ void LogicalOperatorVisitor::visitOperatorSwitch(planner::LogicalOperator* op) { case LogicalOperatorType::EXPRESSIONS_SCAN: { visitExpressionsScan(op); } break; - case LogicalOperatorType::SCAN_NODE: { - visitScanNode(op); + case LogicalOperatorType::SCAN_INTERNAL_ID: { + visitScanInternalID(op); } break; case LogicalOperatorType::INDEX_SCAN_NODE: { visitIndexScanNode(op); @@ -99,8 +99,8 @@ std::shared_ptr LogicalOperatorVisitor::visitOperatorR case LogicalOperatorType::EXPRESSIONS_SCAN: { return visitExpressionsScanReplace(op); } - case LogicalOperatorType::SCAN_NODE: { - return visitScanNodeReplace(op); + case LogicalOperatorType::SCAN_INTERNAL_ID: { + return visitScanInternalIDReplace(op); } case LogicalOperatorType::INDEX_SCAN_NODE: { return visitIndexScanNodeReplace(op); diff --git a/src/optimizer/projection_push_down_optimizer.cpp b/src/optimizer/projection_push_down_optimizer.cpp index 6fd9249ccc..dbea3e4068 100644 --- a/src/optimizer/projection_push_down_optimizer.cpp +++ b/src/optimizer/projection_push_down_optimizer.cpp @@ -44,7 +44,7 @@ void ProjectionPushDownOptimizer::visitPathPropertyProbe(planner::LogicalOperato assert( pathPropertyProbe->getChild(0)->getOperatorType() == LogicalOperatorType::RECURSIVE_EXTEND); auto recursiveExtend = (LogicalRecursiveExtend*)pathPropertyProbe->getChild(0).get(); - auto boundNodeID = recursiveExtend->getBoundNode()->getInternalIDProperty(); + auto boundNodeID = recursiveExtend->getBoundNode()->getInternalID(); collectExpressionsInUse(boundNodeID); auto rel = recursiveExtend->getRel(); auto recursiveInfo = rel->getRecursiveInfo(); @@ -58,7 +58,7 @@ void ProjectionPushDownOptimizer::visitPathPropertyProbe(planner::LogicalOperato void ProjectionPushDownOptimizer::visitExtend(planner::LogicalOperator* op) { auto extend = (LogicalExtend*)op; - auto boundNodeID = extend->getBoundNode()->getInternalIDProperty(); + auto boundNodeID = extend->getBoundNode()->getInternalID(); collectExpressionsInUse(boundNodeID); } @@ -173,8 +173,8 @@ void ProjectionPushDownOptimizer::visitCreateRel(planner::LogicalOperator* op) { auto createRel = (LogicalCreateRel*)op; for (auto& info : createRel->getInfosRef()) { auto rel = info->rel; - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); for (auto& setItem : info->setItems) { collectExpressionsInUse(setItem.second); @@ -185,15 +185,15 @@ void ProjectionPushDownOptimizer::visitCreateRel(planner::LogicalOperator* op) { void ProjectionPushDownOptimizer::visitDeleteNode(planner::LogicalOperator* op) { auto deleteNode = (LogicalDeleteNode*)op; for (auto& node : deleteNode->getNodesRef()) { - collectExpressionsInUse(node->getInternalIDProperty()); + collectExpressionsInUse(node->getInternalID()); } } void ProjectionPushDownOptimizer::visitDeleteRel(planner::LogicalOperator* op) { auto deleteRel = (LogicalDeleteRel*)op; for (auto& rel : deleteRel->getRelsRef()) { - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); } } @@ -209,8 +209,8 @@ void ProjectionPushDownOptimizer::visitMerge(planner::LogicalOperator* op) { } for (auto& info : merge->getCreateRelInfosRef()) { auto rel = info->rel; - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); for (auto& setItem : info->setItems) { collectExpressionsInUse(setItem.second); @@ -218,30 +218,30 @@ void ProjectionPushDownOptimizer::visitMerge(planner::LogicalOperator* op) { } for (auto& info : merge->getCreateNodeSetInfosRef()) { auto node = (NodeExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(node->getInternalIDProperty()); + collectExpressionsInUse(node->getInternalID()); collectExpressionsInUse(info->setItem.second); } for (auto& info : merge->getOnCreateSetNodeInfosRef()) { auto node = (NodeExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(node->getInternalIDProperty()); + collectExpressionsInUse(node->getInternalID()); collectExpressionsInUse(info->setItem.second); } for (auto& info : merge->getOnMatchSetNodeInfosRef()) { auto node = (NodeExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(node->getInternalIDProperty()); + collectExpressionsInUse(node->getInternalID()); collectExpressionsInUse(info->setItem.second); } for (auto& info : merge->getOnCreateSetRelInfosRef()) { auto rel = (RelExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); collectExpressionsInUse(info->setItem.second); } for (auto& info : merge->getOnMatchSetRelInfosRef()) { auto rel = (RelExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); collectExpressionsInUse(info->setItem.second); } @@ -251,7 +251,7 @@ void ProjectionPushDownOptimizer::visitSetNodeProperty(planner::LogicalOperator* auto setNodeProperty = (LogicalSetNodeProperty*)op; for (auto& info : setNodeProperty->getInfosRef()) { auto node = (NodeExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(node->getInternalIDProperty()); + collectExpressionsInUse(node->getInternalID()); collectExpressionsInUse(info->setItem.second); } } @@ -260,8 +260,8 @@ void ProjectionPushDownOptimizer::visitSetRelProperty(planner::LogicalOperator* auto setRelProperty = (LogicalSetRelProperty*)op; for (auto& info : setRelProperty->getInfosRef()) { auto rel = (RelExpression*)info->nodeOrRel.get(); - collectExpressionsInUse(rel->getSrcNode()->getInternalIDProperty()); - collectExpressionsInUse(rel->getDstNode()->getInternalIDProperty()); + collectExpressionsInUse(rel->getSrcNode()->getInternalID()); + collectExpressionsInUse(rel->getDstNode()->getInternalID()); collectExpressionsInUse(rel->getInternalIDProperty()); collectExpressionsInUse(info->setItem.second); } diff --git a/src/optimizer/remove_unnecessary_join_optimizer.cpp b/src/optimizer/remove_unnecessary_join_optimizer.cpp index 2b12ae6cc3..e0c3457c63 100644 --- a/src/optimizer/remove_unnecessary_join_optimizer.cpp +++ b/src/optimizer/remove_unnecessary_join_optimizer.cpp @@ -35,11 +35,11 @@ std::shared_ptr RemoveUnnecessaryJoinOptimizer::visitH default: break; } - if (op->getChild(1)->getOperatorType() == LogicalOperatorType::SCAN_NODE) { + if (op->getChild(1)->getOperatorType() == LogicalOperatorType::SCAN_INTERNAL_ID) { // Build side is trivial. Prune build side. return op->getChild(0); } - if (op->getChild(0)->getOperatorType() == LogicalOperatorType::SCAN_NODE) { + if (op->getChild(0)->getOperatorType() == LogicalOperatorType::SCAN_INTERNAL_ID) { // Probe side is trivial. Prune probe side. return op->getChild(1); } diff --git a/src/planner/join_order/cardinality_estimator.cpp b/src/planner/join_order/cardinality_estimator.cpp index 3f35b62388..f611b21fc9 100644 --- a/src/planner/join_order/cardinality_estimator.cpp +++ b/src/planner/join_order/cardinality_estimator.cpp @@ -2,7 +2,7 @@ #include "planner/join_order/join_order_util.h" #include "planner/operator/extend/logical_extend.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" using namespace kuzu::binder; using namespace kuzu::common; @@ -23,8 +23,8 @@ void CardinalityEstimator::initNodeIDDom(QueryGraph* queryGraph) { } uint64_t CardinalityEstimator::estimateScanNode(LogicalOperator* op) { - auto scanNode = (LogicalScanNode*)op; - return atLeastOne(getNodeIDDom(scanNode->getNode()->getInternalIDPropertyName())); + auto scan = reinterpret_cast(op); + return atLeastOne(getNodeIDDom(scan->getInternalID()->getUniqueName())); } uint64_t CardinalityEstimator::estimateHashJoin( diff --git a/src/planner/operator/extend/logical_extend.cpp b/src/planner/operator/extend/logical_extend.cpp index a1bfe115b9..12761cedb1 100644 --- a/src/planner/operator/extend/logical_extend.cpp +++ b/src/planner/operator/extend/logical_extend.cpp @@ -11,7 +11,7 @@ f_group_pos_set LogicalExtend::getGroupsPosToFlatten() { return result; } auto inSchema = children[0]->getSchema(); - auto boundNodeGroupPos = inSchema->getGroupPos(*boundNode->getInternalIDProperty()); + auto boundNodeGroupPos = inSchema->getGroupPos(*boundNode->getInternalID()); if (!inSchema->getGroup(boundNodeGroupPos)->isFlat()) { result.insert(boundNodeGroupPos); } @@ -20,7 +20,7 @@ f_group_pos_set LogicalExtend::getGroupsPosToFlatten() { void LogicalExtend::computeFactorizedSchema() { copyChildSchema(0); - auto boundGroupPos = schema->getGroupPos(boundNode->getInternalIDPropertyName()); + auto boundGroupPos = schema->getGroupPos(*boundNode->getInternalID()); uint32_t nbrGroupPos = 0u; if (hasAtMostOneNbr) { nbrGroupPos = boundGroupPos; @@ -28,7 +28,7 @@ void LogicalExtend::computeFactorizedSchema() { assert(schema->getGroup(boundGroupPos)->isFlat()); nbrGroupPos = schema->createGroup(); } - schema->insertToGroupAndScope(nbrNode->getInternalIDProperty(), nbrGroupPos); + schema->insertToGroupAndScope(nbrNode->getInternalID(), nbrGroupPos); for (auto& property : properties) { schema->insertToGroupAndScope(property, nbrGroupPos); } @@ -36,7 +36,7 @@ void LogicalExtend::computeFactorizedSchema() { void LogicalExtend::computeFlatSchema() { copyChildSchema(0); - schema->insertToGroupAndScope(nbrNode->getInternalIDProperty(), 0); + schema->insertToGroupAndScope(nbrNode->getInternalID(), 0); for (auto& property : properties) { schema->insertToGroupAndScope(property, 0); } diff --git a/src/planner/operator/extend/logical_recursive_extend.cpp b/src/planner/operator/extend/logical_recursive_extend.cpp index 1028b686c5..b5be6590c5 100644 --- a/src/planner/operator/extend/logical_recursive_extend.cpp +++ b/src/planner/operator/extend/logical_recursive_extend.cpp @@ -10,7 +10,7 @@ namespace planner { f_group_pos_set LogicalRecursiveExtend::getGroupsPosToFlatten() { f_group_pos_set result; auto inSchema = children[0]->getSchema(); - auto boundNodeGroupPos = inSchema->getGroupPos(*boundNode->getInternalIDProperty()); + auto boundNodeGroupPos = inSchema->getGroupPos(*boundNode->getInternalID()); if (!inSchema->getGroup(boundNodeGroupPos)->isFlat()) { result.insert(boundNodeGroupPos); } @@ -19,7 +19,7 @@ f_group_pos_set LogicalRecursiveExtend::getGroupsPosToFlatten() { void LogicalRecursiveExtend::computeFlatSchema() { copyChildSchema(0); - schema->insertToGroupAndScope(nbrNode->getInternalIDProperty(), 0); + schema->insertToGroupAndScope(nbrNode->getInternalID(), 0); schema->insertToGroupAndScope(rel->getLengthExpression(), 0); switch (joinType) { case RecursiveJoinType::TRACK_PATH: { @@ -35,7 +35,7 @@ void LogicalRecursiveExtend::computeFlatSchema() { void LogicalRecursiveExtend::computeFactorizedSchema() { copyChildSchema(0); auto nbrGroupPos = schema->createGroup(); - schema->insertToGroupAndScope(nbrNode->getInternalIDProperty(), nbrGroupPos); + schema->insertToGroupAndScope(nbrNode->getInternalID(), nbrGroupPos); schema->insertToGroupAndScope(rel->getLengthExpression(), nbrGroupPos); switch (joinType) { case RecursiveJoinType::TRACK_PATH: { @@ -52,14 +52,14 @@ void LogicalScanFrontier::computeFlatSchema() { createEmptySchema(); schema->createGroup(); schema->setGroupAsSingleState(0); - schema->insertToGroupAndScope(node->getInternalIDProperty(), 0); + schema->insertToGroupAndScope(node->getInternalID(), 0); } void LogicalScanFrontier::computeFactorizedSchema() { createEmptySchema(); auto groupPos = schema->createGroup(); schema->setGroupAsSingleState(groupPos); - schema->insertToGroupAndScope(node->getInternalIDProperty(), groupPos); + schema->insertToGroupAndScope(node->getInternalID(), groupPos); } } // namespace planner diff --git a/src/planner/operator/logical_hash_join.cpp b/src/planner/operator/logical_hash_join.cpp index 7b0785044a..444e853e2f 100644 --- a/src/planner/operator/logical_hash_join.cpp +++ b/src/planner/operator/logical_hash_join.cpp @@ -3,7 +3,7 @@ #include "common/exception/not_implemented.h" #include "planner/operator/factorization/flatten_resolver.h" #include "planner/operator/factorization/sink_util.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" using namespace kuzu::common; @@ -171,11 +171,11 @@ bool LogicalHashJoin::isJoinKeyUniqueOnBuildSide(const binder::Expression& joinN } op = op->getChild(0).get(); } - if (op->getOperatorType() != LogicalOperatorType::SCAN_NODE) { + if (op->getOperatorType() != LogicalOperatorType::SCAN_INTERNAL_ID) { return false; } - auto scanNodeID = (LogicalScanNode*)op; - if (scanNodeID->getNode()->getInternalIDPropertyName() != joinNodeID.getUniqueName()) { + auto scan = reinterpret_cast(op); + if (scan->getInternalID()->getUniqueName() != joinNodeID.getUniqueName()) { return false; } return true; diff --git a/src/planner/operator/logical_operator.cpp b/src/planner/operator/logical_operator.cpp index 33f33fcb2e..835a42b55f 100644 --- a/src/planner/operator/logical_operator.cpp +++ b/src/planner/operator/logical_operator.cpp @@ -123,8 +123,8 @@ std::string LogicalOperatorUtils::logicalOperatorTypeToString(LogicalOperatorTyp case LogicalOperatorType::SCAN_FRONTIER: { return "SCAN_FRONTIER"; } - case LogicalOperatorType::SCAN_NODE: { - return "SCAN_NODE"; + case LogicalOperatorType::SCAN_INTERNAL_ID: { + return "SCAN_INTERNAL_ID"; } case LogicalOperatorType::SCAN_NODE_PROPERTY: { return "SCAN_NODE_PROPERTY"; @@ -151,7 +151,7 @@ std::string LogicalOperatorUtils::logicalOperatorTypeToString(LogicalOperatorTyp return "UNWIND"; } default: - throw NotImplementedException("LogicalOperatorTypeToString()"); + throw NotImplementedException("LogicalOperatorUtils::logicalOperatorTypeToString"); } } diff --git a/src/planner/operator/logical_plan_util.cpp b/src/planner/operator/logical_plan_util.cpp index 3df91e4e32..92ddeb99b6 100644 --- a/src/planner/operator/logical_plan_util.cpp +++ b/src/planner/operator/logical_plan_util.cpp @@ -4,7 +4,7 @@ #include "planner/operator/extend/logical_recursive_extend.h" #include "planner/operator/logical_hash_join.h" #include "planner/operator/logical_intersect.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" using namespace kuzu::binder; @@ -46,8 +46,8 @@ void LogicalPlanUtil::encodeJoinRecursive( encodeRecursiveExtend(logicalOperator, encodeString); encodeJoinRecursive(logicalOperator->getChild(0).get(), encodeString); } break; - case LogicalOperatorType::SCAN_NODE: { - encodeScanNodeID(logicalOperator, encodeString); + case LogicalOperatorType::SCAN_INTERNAL_ID: { + encodeScanInternalID(logicalOperator, encodeString); } break; default: for (auto i = 0u; i < logicalOperator->getNumChildren(); ++i) { @@ -83,10 +83,10 @@ void LogicalPlanUtil::encodeRecursiveExtend( encodeString += "RE(" + logicalExtend->getNbrNode()->toString() + ")"; } -void LogicalPlanUtil::encodeScanNodeID( +void LogicalPlanUtil::encodeScanInternalID( LogicalOperator* logicalOperator, std::string& encodeString) { - auto logicalScanNode = (LogicalScanNode*)logicalOperator; - encodeString += "S(" + logicalScanNode->getNode()->toString() + ")"; + auto scan = reinterpret_cast(logicalOperator); + encodeString += "S(" + scan->getInternalID()->toString() + ")"; } } // namespace planner diff --git a/src/planner/operator/persistent/logical_create.cpp b/src/planner/operator/persistent/logical_create.cpp index c21662841a..9ee7676eef 100644 --- a/src/planner/operator/persistent/logical_create.cpp +++ b/src/planner/operator/persistent/logical_create.cpp @@ -33,7 +33,7 @@ void LogicalCreateNode::computeFactorizedSchema() { for (auto& property : info->propertiesToReturn) { schema->insertToGroupAndScope(property, groupPos); } - schema->insertToGroupAndScopeMayRepeat(info->node->getInternalIDProperty(), groupPos); + schema->insertToGroupAndScopeMayRepeat(info->node->getInternalID(), groupPos); } } @@ -43,7 +43,7 @@ void LogicalCreateNode::computeFlatSchema() { for (auto& property : info->propertiesToReturn) { schema->insertToGroupAndScope(property, 0); } - schema->insertToGroupAndScopeMayRepeat(info->node->getInternalIDProperty(), 0); + schema->insertToGroupAndScopeMayRepeat(info->node->getInternalID(), 0); } } diff --git a/src/planner/operator/persistent/logical_delete.cpp b/src/planner/operator/persistent/logical_delete.cpp index a7faf17eab..412f49c9c7 100644 --- a/src/planner/operator/persistent/logical_delete.cpp +++ b/src/planner/operator/persistent/logical_delete.cpp @@ -18,7 +18,7 @@ f_group_pos_set LogicalDeleteNode::getGroupsPosToFlatten() { auto childSchema = children[0]->getSchema(); for (auto& node : nodes) { if (node->isMultiLabeled()) { - dependentGroupPos.insert(childSchema->getGroupPos(*node->getInternalIDProperty())); + dependentGroupPos.insert(childSchema->getGroupPos(*node->getInternalID())); } } return factorization::FlattenAll::getGroupsPosToFlatten(dependentGroupPos, childSchema); @@ -36,8 +36,8 @@ f_group_pos_set LogicalDeleteRel::getGroupsPosToFlatten(uint32_t idx) { f_group_pos_set result; auto rel = rels[idx]; auto childSchema = children[0]->getSchema(); - result.insert(childSchema->getGroupPos(*rel->getSrcNode()->getInternalIDProperty())); - result.insert(childSchema->getGroupPos(*rel->getDstNode()->getInternalIDProperty())); + result.insert(childSchema->getGroupPos(*rel->getSrcNode()->getInternalID())); + result.insert(childSchema->getGroupPos(*rel->getDstNode()->getInternalID())); return factorization::FlattenAll::getGroupsPosToFlatten(result, childSchema); } diff --git a/src/planner/operator/persistent/logical_set.cpp b/src/planner/operator/persistent/logical_set.cpp index 95d6013d92..878d77ca28 100644 --- a/src/planner/operator/persistent/logical_set.cpp +++ b/src/planner/operator/persistent/logical_set.cpp @@ -39,8 +39,8 @@ f_group_pos_set LogicalSetRelProperty::getGroupsPosToFlatten(uint32_t idx) { auto rel = reinterpret_cast(infos[idx]->nodeOrRel.get()); auto rhs = infos[idx]->setItem.second; auto childSchema = children[0]->getSchema(); - result.insert(childSchema->getGroupPos(*rel->getSrcNode()->getInternalIDProperty())); - result.insert(childSchema->getGroupPos(*rel->getDstNode()->getInternalIDProperty())); + result.insert(childSchema->getGroupPos(*rel->getSrcNode()->getInternalID())); + result.insert(childSchema->getGroupPos(*rel->getDstNode()->getInternalID())); for (auto groupPos : childSchema->getDependentGroupsPos(rhs)) { result.insert(groupPos); } diff --git a/src/planner/operator/scan/CMakeLists.txt b/src/planner/operator/scan/CMakeLists.txt index bd5f8579cf..9a33f415d9 100644 --- a/src/planner/operator/scan/CMakeLists.txt +++ b/src/planner/operator/scan/CMakeLists.txt @@ -3,7 +3,7 @@ add_library(kuzu_planner_scan logical_expressions_scan.cpp logical_index_scan.cpp logical_scan_file.cpp - logical_scan_node.cpp + logical_scan_internal_id.cpp logical_scan_node_property.cpp) set(ALL_OBJECT_FILES diff --git a/src/planner/operator/scan/logical_scan_internal_id.cpp b/src/planner/operator/scan/logical_scan_internal_id.cpp new file mode 100644 index 0000000000..38772c2a8f --- /dev/null +++ b/src/planner/operator/scan/logical_scan_internal_id.cpp @@ -0,0 +1,19 @@ +#include "planner/operator/scan/logical_scan_internal_id.h" + +namespace kuzu { +namespace planner { + +void LogicalScanInternalID::computeFactorizedSchema() { + createEmptySchema(); + auto groupPos = schema->createGroup(); + schema->insertToGroupAndScope(internalID, groupPos); +} + +void LogicalScanInternalID::computeFlatSchema() { + createEmptySchema(); + schema->createGroup(); + schema->insertToGroupAndScope(internalID, 0); +} + +} // namespace planner +} // namespace kuzu diff --git a/src/planner/operator/scan/logical_scan_node.cpp b/src/planner/operator/scan/logical_scan_node.cpp deleted file mode 100644 index e0ac669923..0000000000 --- a/src/planner/operator/scan/logical_scan_node.cpp +++ /dev/null @@ -1,19 +0,0 @@ -#include "planner/operator/scan/logical_scan_node.h" - -namespace kuzu { -namespace planner { - -void LogicalScanNode::computeFactorizedSchema() { - createEmptySchema(); - auto groupPos = schema->createGroup(); - schema->insertToGroupAndScope(node->getInternalIDProperty(), groupPos); -} - -void LogicalScanNode::computeFlatSchema() { - createEmptySchema(); - schema->createGroup(); - schema->insertToGroupAndScope(node->getInternalIDProperty(), 0); -} - -} // namespace planner -} // namespace kuzu diff --git a/src/planner/operator/scan/logical_scan_node_property.cpp b/src/planner/operator/scan/logical_scan_node_property.cpp index 9890558e61..6d9d4af42e 100644 --- a/src/planner/operator/scan/logical_scan_node_property.cpp +++ b/src/planner/operator/scan/logical_scan_node_property.cpp @@ -5,7 +5,7 @@ namespace planner { void LogicalScanNodeProperty::computeFactorizedSchema() { copyChildSchema(0); - auto groupPos = schema->getGroupPos(node->getInternalIDPropertyName()); + auto groupPos = schema->getGroupPos(*nodeID); for (auto& property : properties) { schema->insertToGroupAndScope(property, groupPos); } diff --git a/src/planner/plan/append_extend.cpp b/src/planner/plan/append_extend.cpp index 51e8b426cb..a808eea07f 100644 --- a/src/planner/plan/append_extend.cpp +++ b/src/planner/plan/append_extend.cpp @@ -82,7 +82,7 @@ void QueryPlanner::appendNonRecursiveExtend(std::shared_ptr boun ExtendDirection direction, const expression_vector& properties, LogicalPlan& plan) { auto boundNodeTableIDSet = getBoundNodeTableIDSet(*rel, direction, catalog); if (boundNode->getNumTableIDs() > boundNodeTableIDSet.size()) { - appendNodeLabelFilter(boundNode->getInternalIDProperty(), boundNodeTableIDSet, plan); + appendNodeLabelFilter(boundNode->getInternalID(), boundNodeTableIDSet, plan); } auto hasAtMostOneNbr = extendHasAtMostOneNbrGuarantee(*rel, *boundNode, direction, catalog); auto extend = make_shared( @@ -95,13 +95,13 @@ void QueryPlanner::appendNonRecursiveExtend(std::shared_ptr boun // update cardinality. Note that extend does not change cardinality. if (!hasAtMostOneNbr) { auto extensionRate = cardinalityEstimator->getExtensionRate(*rel, *boundNode); - auto group = extend->getSchema()->getGroup(nbrNode->getInternalIDProperty()); + auto group = extend->getSchema()->getGroup(nbrNode->getInternalID()); group->setMultiplier(extensionRate); } plan.setLastOperator(std::move(extend)); auto nbrNodeTableIDSet = getNbrNodeTableIDSet(*rel, direction, catalog); if (nbrNodeTableIDSet.size() > nbrNode->getNumTableIDs()) { - appendNodeLabelFilter(nbrNode->getInternalIDProperty(), nbrNode->getTableIDsSet(), plan); + appendNodeLabelFilter(nbrNode->getInternalID(), nbrNode->getTableIDsSet(), plan); } } @@ -117,7 +117,7 @@ void QueryPlanner::appendRecursiveExtend(std::shared_ptr boundNo // Create recursive extend if (boundNode->getNumTableIDs() > recursiveInfo->node->getNumTableIDs()) { appendNodeLabelFilter( - boundNode->getInternalIDProperty(), recursiveInfo->node->getTableIDsSet(), plan); + boundNode->getInternalID(), recursiveInfo->node->getTableIDsSet(), plan); } auto extend = std::make_shared(boundNode, nbrNode, rel, direction, RecursiveJoinType::TRACK_PATH, plan.getLastOperator(), recursivePlan->getLastOperator()); @@ -146,7 +146,7 @@ void QueryPlanner::appendRecursiveExtend(std::shared_ptr boundNo // Update cardinality auto hasAtMostOneNbr = extendHasAtMostOneNbrGuarantee(*rel, *boundNode, direction, catalog); if (!hasAtMostOneNbr) { - auto group = pathPropertyProbe->getSchema()->getGroup(nbrNode->getInternalIDProperty()); + auto group = pathPropertyProbe->getSchema()->getGroup(nbrNode->getInternalID()); group->setMultiplier(extensionRate); } plan.setLastOperator(std::move(pathPropertyProbe)); @@ -176,14 +176,15 @@ void QueryPlanner::createRecursivePlan(std::shared_ptr boundNode void QueryPlanner::createPathNodePropertyScanPlan( std::shared_ptr recursiveNode, LogicalPlan& plan) { - appendScanNodeID(recursiveNode, plan); + appendScanInternalID(recursiveNode->getInternalID(), recursiveNode->getTableIDs(), plan); expression_vector properties; for (auto& property : recursiveNode->getPropertyExpressions()) { properties.push_back(property->copy()); } - appendScanNodeProperties(properties, recursiveNode, plan); + appendScanNodeProperties( + recursiveNode->getInternalID(), recursiveNode->getTableIDs(), properties, plan); auto expressionsToProject = properties; - expressionsToProject.push_back(recursiveNode->getInternalIDProperty()); + expressionsToProject.push_back(recursiveNode->getInternalID()); expressionsToProject.push_back(recursiveNode->getLabelExpression()); appendProjection(expressionsToProject, plan); } @@ -191,7 +192,7 @@ void QueryPlanner::createPathNodePropertyScanPlan( void QueryPlanner::createPathRelPropertyScanPlan(std::shared_ptr recursiveNode, std::shared_ptr nbrNode, std::shared_ptr recursiveRel, ExtendDirection direction, LogicalPlan& plan) { - appendScanNodeID(recursiveNode, plan); + appendScanInternalID(recursiveNode->getInternalID(), recursiveNode->getTableIDs(), plan); expression_vector properties; for (auto& property : recursiveRel->getPropertyExpressions()) { properties.push_back(property->copy()); diff --git a/src/planner/plan/append_scan_node.cpp b/src/planner/plan/append_scan_node.cpp index 5d97cc910b..0e7a9ab384 100644 --- a/src/planner/plan/append_scan_node.cpp +++ b/src/planner/plan/append_scan_node.cpp @@ -1,33 +1,39 @@ -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" #include "planner/operator/scan/logical_scan_node_property.h" #include "planner/query_planner.h" +using namespace kuzu::common; +using namespace kuzu::binder; + namespace kuzu { namespace planner { -void QueryPlanner::appendScanNodeID(std::shared_ptr& node, LogicalPlan& plan) { +void QueryPlanner::appendScanInternalID( + std::shared_ptr internalID, std::vector tableIDs, LogicalPlan& plan) { assert(plan.isEmpty()); - auto scan = make_shared(node); + auto scan = make_shared(std::move(internalID), std::move(tableIDs)); scan->computeFactorizedSchema(); // update cardinality plan.setCardinality(cardinalityEstimator->estimateScanNode(scan.get())); plan.setLastOperator(std::move(scan)); } -void QueryPlanner::appendScanNodeProperties(const expression_vector& propertyExpressions, - std::shared_ptr node, LogicalPlan& plan) { - expression_vector propertyExpressionToScan; - for (auto& propertyExpression : propertyExpressions) { - if (plan.getSchema()->isExpressionInScope(*propertyExpression)) { +void QueryPlanner::appendScanNodeProperties(std::shared_ptr nodeID, + std::vector tableIDs, const expression_vector& properties, + LogicalPlan& plan) { + expression_vector propertiesToScan_; + for (auto& property : properties) { + if (((PropertyExpression&)*property).isInternalID()) { continue; } - propertyExpressionToScan.push_back(propertyExpression); + assert(!plan.getSchema()->isExpressionInScope(*property)); + propertiesToScan_.push_back(property); } - if (propertyExpressionToScan.empty()) { // all properties have been scanned before + if (propertiesToScan_.empty()) { return; } auto scanNodeProperty = make_shared( - std::move(node), std::move(propertyExpressionToScan), plan.getLastOperator()); + std::move(nodeID), std::move(tableIDs), propertiesToScan_, plan.getLastOperator()); scanNodeProperty->computeFactorizedSchema(); plan.setLastOperator(std::move(scanNodeProperty)); } diff --git a/src/planner/plan/append_set.cpp b/src/planner/plan/append_set.cpp index a231ca4419..0321a97b63 100644 --- a/src/planner/plan/append_set.cpp +++ b/src/planner/plan/append_set.cpp @@ -18,7 +18,7 @@ void QueryPlanner::appendSetNodeProperty( const std::vector& boundInfos, LogicalPlan& plan) { for (auto& boundInfo : boundInfos) { auto node = (NodeExpression*)boundInfo->nodeOrRel.get(); - auto lhsNodeID = node->getInternalIDProperty(); + auto lhsNodeID = node->getInternalID(); auto rhs = boundInfo->setItem.second; // flatten rhs auto rhsDependentGroupsPos = plan.getSchema()->getDependentGroupsPos(rhs); diff --git a/src/planner/plan/plan_join_order.cpp b/src/planner/plan/plan_join_order.cpp index 3456d9abf6..0a03f292fc 100644 --- a/src/planner/plan/plan_join_order.cpp +++ b/src/planner/plan/plan_join_order.cpp @@ -1,6 +1,6 @@ #include "binder/expression_visitor.h" #include "planner/join_order/cost_model.h" -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" #include "planner/query_planner.h" using namespace kuzu::common; @@ -28,7 +28,7 @@ static int32_t getConnectedQueryGraphIdx( for (auto i = 0u; i < queryGraphCollection.getNumQueryGraphs(); ++i) { auto queryGraph = queryGraphCollection.getQueryGraph(i); for (auto& queryNode : queryGraph->getQueryNodes()) { - if (expressionSet.contains(queryNode->getInternalIDProperty())) { + if (expressionSet.contains(queryNode->getInternalID())) { return i; } } @@ -207,7 +207,7 @@ void QueryPlanner::planBaseTableScans( case SubqueryType::INTERNAL_ID_CORRELATED: { for (auto nodePos = 0u; nodePos < queryGraph->getNumQueryNodes(); ++nodePos) { auto queryNode = queryGraph->getQueryNode(nodePos); - if (correlatedExpressionSet.contains(queryNode->getInternalIDProperty())) { + if (correlatedExpressionSet.contains(queryNode->getInternalID())) { // In un-nested subquery, e.g. MATCH (a) OPTIONAL MATCH (a)-[e1]->(b), the inner // query ("(a)-[e1]->(b)") needs to scan a, which is already scanned in the outer // query (a). To avoid scanning storage twice, we keep track of node table "a" and @@ -221,7 +221,7 @@ void QueryPlanner::planBaseTableScans( case SubqueryType::CORRELATED: { for (auto nodePos = 0u; nodePos < queryGraph->getNumQueryNodes(); ++nodePos) { auto queryNode = queryGraph->getQueryNode(nodePos); - if (correlatedExpressionSet.contains(queryNode->getInternalIDProperty())) { + if (correlatedExpressionSet.contains(queryNode->getInternalID())) { continue; } planNodeScan(nodePos); @@ -244,7 +244,7 @@ void QueryPlanner::planCorrelatedExpressionsScan( expression_set{correlatedExpressions.begin(), correlatedExpressions.end()}; for (auto nodePos = 0u; nodePos < queryGraph->getNumQueryNodes(); ++nodePos) { auto queryNode = queryGraph->getQueryNode(nodePos); - if (correlatedExpressionSet.contains(queryNode->getInternalIDProperty())) { + if (correlatedExpressionSet.contains(queryNode->getInternalID())) { newSubgraph.addQueryNode(nodePos); } } @@ -263,9 +263,9 @@ void QueryPlanner::planNodeScan(uint32_t nodePos) { auto newSubgraph = context->getEmptySubqueryGraph(); newSubgraph.addQueryNode(nodePos); auto plan = std::make_unique(); - appendScanNodeID(node, *plan); + appendScanInternalID(node->getInternalID(), node->getTableIDs(), *plan); auto properties = getProperties(*node); - appendScanNodeProperties(properties, node, *plan); + appendScanNodeProperties(node->getInternalID(), node->getTableIDs(), properties, *plan); auto predicates = getNewlyMatchedExpressions( context->getEmptySubqueryGraph(), newSubgraph, context->getWhereExpressions()); appendFilters(predicates, *plan); @@ -277,7 +277,7 @@ void QueryPlanner::planNodeIDScan(uint32_t nodePos) { auto newSubgraph = context->getEmptySubqueryGraph(); newSubgraph.addQueryNode(nodePos); auto plan = std::make_unique(); - appendScanNodeID(node, *plan); + appendScanInternalID(node->getInternalID(), node->getTableIDs(), *plan); context->addPlan(newSubgraph, std::move(plan)); } @@ -301,7 +301,7 @@ void QueryPlanner::planRelScan(uint32_t relPos) { auto plan = std::make_unique(); auto [boundNode, nbrNode] = getBoundAndNbrNodes(*rel, direction); auto extendDirection = ExtendDirectionUtils::getExtendDirection(*rel, *boundNode); - appendScanNodeID(boundNode, *plan); + appendScanInternalID(boundNode->getInternalID(), boundNode->getTableIDs(), *plan); appendExtendAndFilter(boundNode, nbrNode, rel, extendDirection, predicates, *plan); context->addPlan(newSubgraph, std::move(plan)); } @@ -368,17 +368,17 @@ void QueryPlanner::planWCOJoin(uint32_t leftLevel, uint32_t rightLevel) { } } -static LogicalScanNode* getSequentialScanNodeOperator(LogicalOperator* op) { +static LogicalOperator* getSequentialScan(LogicalOperator* op) { switch (op->getOperatorType()) { case LogicalOperatorType::FLATTEN: case LogicalOperatorType::FILTER: case LogicalOperatorType::SCAN_NODE_PROPERTY: case LogicalOperatorType::EXTEND: case LogicalOperatorType::PROJECTION: { // operators we directly search through - return getSequentialScanNodeOperator(op->getChild(0).get()); + return getSequentialScan(op->getChild(0).get()); } - case LogicalOperatorType::SCAN_NODE: { - return (LogicalScanNode*)op; + case LogicalOperatorType::SCAN_INTERNAL_ID: { + return op; } default: return nullptr; @@ -387,11 +387,13 @@ static LogicalScanNode* getSequentialScanNodeOperator(LogicalOperator* op) { // Check whether given node ID has sequential guarantee on the plan. static bool isNodeSequentialOnPlan(LogicalPlan& plan, const NodeExpression& node) { - auto sequentialScanNode = getSequentialScanNodeOperator(plan.getLastOperator().get()); - if (sequentialScanNode == nullptr) { + auto sequentialScan = + reinterpret_cast(getSequentialScan(plan.getLastOperator().get())); + if (sequentialScan == nullptr) { return false; } - return sequentialScanNode->getNode()->getUniqueName() == node.getUniqueName(); + return sequentialScan->getInternalID()->getUniqueName() == + node.getInternalID()->getUniqueName(); } // As a heuristic for wcoj, we always pick rel scan that starts from the bound node. @@ -419,7 +421,7 @@ void QueryPlanner::planWCOJoin(const SubqueryGraph& subgraph, auto boundNode = rel->getSrcNodeName() == intersectNode->getUniqueName() ? rel->getDstNode() : rel->getSrcNode(); - boundNodeIDs.push_back(boundNode->getInternalIDProperty()); + boundNodeIDs.push_back(boundNode->getInternalID()); auto relPos = context->getQueryGraph()->getQueryRelPos(rel->getUniqueName()); auto prevSubgraph = context->getEmptySubqueryGraph(); prevSubgraph.addQueryRel(relPos); @@ -445,7 +447,7 @@ void QueryPlanner::planWCOJoin(const SubqueryGraph& subgraph, rightPlansCopy.push_back(relPlan->shallowCopy()); } appendIntersect( - intersectNode->getInternalIDProperty(), boundNodeIDs, *leftPlanCopy, rightPlansCopy); + intersectNode->getInternalID(), boundNodeIDs, *leftPlanCopy, rightPlansCopy); for (auto& predicate : predicates) { appendFilter(predicate, *leftPlanCopy); } @@ -544,7 +546,7 @@ void QueryPlanner::planInnerHashJoin(const SubqueryGraph& subgraph, auto maxCost = context->subPlansTable->getMaxCost(newSubgraph); binder::expression_vector joinNodeIDs; for (auto& joinNode : joinNodes) { - joinNodeIDs.push_back(joinNode->getInternalIDProperty()); + joinNodeIDs.push_back(joinNode->getInternalID()); } auto predicates = getNewlyMatchedExpressions(std::vector{subgraph, otherSubgraph}, newSubgraph, diff --git a/src/planner/plan/plan_subquery.cpp b/src/planner/plan/plan_subquery.cpp index c061e3cd6f..ce76945430 100644 --- a/src/planner/plan/plan_subquery.cpp +++ b/src/planner/plan/plan_subquery.cpp @@ -16,8 +16,8 @@ static expression_vector getCorrelatedExpressions(const QueryGraphCollection& co } } for (auto& node : collection.getQueryNodes()) { - if (outerSchema->isExpressionInScope(*node->getInternalIDProperty())) { - result.push_back(node->getInternalIDProperty()); + if (outerSchema->isExpressionInScope(*node->getInternalID())) { + result.push_back(node->getInternalID()); } } return result; diff --git a/src/planner/plan/plan_update.cpp b/src/planner/plan/plan_update.cpp index 37f8838ad7..ef96755e40 100644 --- a/src/planner/plan/plan_update.cpp +++ b/src/planner/plan/plan_update.cpp @@ -70,7 +70,7 @@ void QueryPlanner::planMergeClause(binder::BoundUpdatingClause& updatingClause, switch (createInfo->updateTableType) { case binder::UpdateTableType::NODE: { auto node = (NodeExpression*)createInfo->nodeOrRel.get(); - mark = node->getInternalIDProperty(); + mark = node->getInternalID(); } break; case binder::UpdateTableType::REL: { auto rel = (RelExpression*)createInfo->nodeOrRel.get(); diff --git a/src/planner/subplans_table.cpp b/src/planner/subplans_table.cpp index 07469b80c2..e2fd9eb8f5 100644 --- a/src/planner/subplans_table.cpp +++ b/src/planner/subplans_table.cpp @@ -8,8 +8,7 @@ namespace planner { SubgraphPlans::SubgraphPlans(const kuzu::binder::SubqueryGraph& subqueryGraph) { for (auto i = 0u; i < subqueryGraph.queryGraph.getNumQueryNodes(); ++i) { if (subqueryGraph.queryNodesSelector[i]) { - nodeIDsToEncode.push_back( - subqueryGraph.queryGraph.getQueryNode(i)->getInternalIDProperty()); + nodeIDsToEncode.push_back(subqueryGraph.queryGraph.getQueryNode(i)->getInternalID()); } } maxCost = UINT64_MAX; diff --git a/src/processor/map/expression_mapper.cpp b/src/processor/map/expression_mapper.cpp index 4ec5ab6b44..ce87e3cf7f 100644 --- a/src/processor/map/expression_mapper.cpp +++ b/src/processor/map/expression_mapper.cpp @@ -138,7 +138,7 @@ std::unique_ptr ExpressionMapper::getNodeEvaluator( std::shared_ptr expression, const Schema* schema) { auto node = (NodeExpression*)expression.get(); expression_vector children; - children.push_back(node->getInternalIDProperty()); + children.push_back(node->getInternalID()); children.push_back(node->getLabelExpression()); for (auto& property : node->getPropertyExpressions()) { children.push_back(property->copy()); @@ -152,8 +152,8 @@ std::unique_ptr ExpressionMapper::getRelEvaluator( std::shared_ptr expression, const Schema* schema) { auto rel = (RelExpression*)expression.get(); expression_vector children; - children.push_back(rel->getSrcNode()->getInternalIDProperty()); - children.push_back(rel->getDstNode()->getInternalIDProperty()); + children.push_back(rel->getSrcNode()->getInternalID()); + children.push_back(rel->getDstNode()->getInternalID()); children.push_back(rel->getLabelExpression()); for (auto& property : rel->getPropertyExpressions()) { children.push_back(property->copy()); diff --git a/src/processor/map/map_create.cpp b/src/processor/map/map_create.cpp index b314b97daf..b355d815bf 100644 --- a/src/processor/map/map_create.cpp +++ b/src/processor/map/map_create.cpp @@ -38,7 +38,7 @@ std::unique_ptr PlanMapper::getNodeInsertExecutor( relTablesToInit.push_back(relsStore->getRelTable(schema->tableID)); } } - auto nodeIDPos = DataPos(outSchema.getExpressionPos(*node->getInternalIDProperty())); + auto nodeIDPos = DataPos(outSchema.getExpressionPos(*node->getInternalID())); std::vector lhsVectorPositions = populateLhsVectorPositions(info->setItems, outSchema); std::vector> evaluators; for (auto& [_, rhs] : info->setItems) { @@ -70,8 +70,8 @@ std::unique_ptr PlanMapper::getRelInsertExecutor(storage::Rel auto table = relsStore->getRelTable(relTableID); auto srcNode = rel->getSrcNode(); auto dstNode = rel->getDstNode(); - auto srcNodePos = DataPos(inSchema.getExpressionPos(*srcNode->getInternalIDProperty())); - auto dstNodePos = DataPos(inSchema.getExpressionPos(*dstNode->getInternalIDProperty())); + auto srcNodePos = DataPos(inSchema.getExpressionPos(*srcNode->getInternalID())); + auto dstNodePos = DataPos(inSchema.getExpressionPos(*dstNode->getInternalID())); auto lhsVectorPositions = populateLhsVectorPositions(info->setItems, outSchema); std::vector> evaluators; for (auto& [lhs, rhs] : info->setItems) { diff --git a/src/processor/map/map_delete.cpp b/src/processor/map/map_delete.cpp index 936f97b7eb..654b54c53e 100644 --- a/src/processor/map/map_delete.cpp +++ b/src/processor/map/map_delete.cpp @@ -13,7 +13,7 @@ namespace processor { static std::unique_ptr getNodeDeleteExecutor( NodesStore* store, const NodeExpression& node, const Schema& inSchema) { - auto nodeIDPos = DataPos(inSchema.getExpressionPos(*node.getInternalIDProperty())); + auto nodeIDPos = DataPos(inSchema.getExpressionPos(*node.getInternalID())); if (node.isMultiLabeled()) { std::unordered_map tableIDToTableMap; for (auto tableID : node.getTableIDs()) { @@ -43,10 +43,8 @@ std::unique_ptr PlanMapper::mapDeleteNode(LogicalOperator* log static std::unique_ptr getRelDeleteExecutor( storage::RelsStore* store, const binder::RelExpression& rel, const Schema& inSchema) { - auto srcNodePos = - DataPos(inSchema.getExpressionPos(*rel.getSrcNode()->getInternalIDProperty())); - auto dstNodePos = - DataPos(inSchema.getExpressionPos(*rel.getDstNode()->getInternalIDProperty())); + auto srcNodePos = DataPos(inSchema.getExpressionPos(*rel.getSrcNode()->getInternalID())); + auto dstNodePos = DataPos(inSchema.getExpressionPos(*rel.getDstNode()->getInternalID())); auto relIDPos = DataPos(inSchema.getExpressionPos(*rel.getInternalIDProperty())); auto statistics = &store->getRelsStatistics(); if (rel.isMultiLabeled()) { diff --git a/src/processor/map/map_extend.cpp b/src/processor/map/map_extend.cpp index d20d44d0fe..9a628bd443 100644 --- a/src/processor/map/map_extend.cpp +++ b/src/processor/map/map_extend.cpp @@ -93,8 +93,8 @@ std::unique_ptr PlanMapper::mapExtend(LogicalOperator* logical auto rel = extend->getRel(); auto extendDirection = extend->getDirection(); auto prevOperator = mapOperator(logicalOperator->getChild(0).get()); - auto inNodeVectorPos = DataPos(inSchema->getExpressionPos(*boundNode->getInternalIDProperty())); - auto outNodeVectorPos = DataPos(outSchema->getExpressionPos(*nbrNode->getInternalIDProperty())); + auto inNodeVectorPos = DataPos(inSchema->getExpressionPos(*boundNode->getInternalID())); + auto outNodeVectorPos = DataPos(outSchema->getExpressionPos(*nbrNode->getInternalID())); std::vector outVectorsPos; outVectorsPos.push_back(outNodeVectorPos); for (auto& expression : extend->getProperties()) { diff --git a/src/processor/map/map_path_property_probe.cpp b/src/processor/map/map_path_property_probe.cpp index 83c99bc7a7..0d80755e5f 100644 --- a/src/processor/map/map_path_property_probe.cpp +++ b/src/processor/map/map_path_property_probe.cpp @@ -48,7 +48,7 @@ std::unique_ptr PlanMapper::mapPathPropertyProbe( // Map build node property auto nodeBuildPrevOperator = mapOperator(logicalProbe->getChild(1).get()); auto nodeBuildSchema = logicalProbe->getChild(1)->getSchema(); - auto nodeKeys = expression_vector{recursiveInfo->node->getInternalIDProperty()}; + auto nodeKeys = expression_vector{recursiveInfo->node->getInternalID()}; auto nodeKeyTypes = ExpressionUtil::getDataTypes(nodeKeys); auto nodePayloads = ExpressionUtil::excludeExpressions(nodeBuildSchema->getExpressionsInScope(), nodeKeys); diff --git a/src/processor/map/map_recursive_extend.cpp b/src/processor/map/map_recursive_extend.cpp index e1fa0e08f0..d071db1d29 100644 --- a/src/processor/map/map_recursive_extend.cpp +++ b/src/processor/map/map_recursive_extend.cpp @@ -32,15 +32,15 @@ std::unique_ptr PlanMapper::mapRecursiveExtend( auto recursivePlanSchema = logicalRecursiveRoot->getSchema(); auto recursivePlanResultSetDescriptor = std::make_unique(recursivePlanSchema); - auto recursiveDstNodeIDPos = DataPos( - recursivePlanSchema->getExpressionPos(*recursiveInfo->nodeCopy->getInternalIDProperty())); + auto recursiveDstNodeIDPos = + DataPos(recursivePlanSchema->getExpressionPos(*recursiveInfo->nodeCopy->getInternalID())); auto recursiveEdgeIDPos = DataPos( recursivePlanSchema->getExpressionPos(*recursiveInfo->rel->getInternalIDProperty())); // Generate RecursiveJoin auto outSchema = extend->getSchema(); auto inSchema = extend->getChild(0)->getSchema(); - auto boundNodeIDPos = DataPos(inSchema->getExpressionPos(*boundNode->getInternalIDProperty())); - auto nbrNodeIDPos = DataPos(outSchema->getExpressionPos(*nbrNode->getInternalIDProperty())); + auto boundNodeIDPos = DataPos(inSchema->getExpressionPos(*boundNode->getInternalID())); + auto nbrNodeIDPos = DataPos(outSchema->getExpressionPos(*nbrNode->getInternalID())); auto lengthPos = DataPos(outSchema->getExpressionPos(*lengthExpression)); auto sharedState = createSharedState(*nbrNode, storageManager); auto pathPos = DataPos(); diff --git a/src/processor/map/map_scan_frontier.cpp b/src/processor/map/map_scan_frontier.cpp index d09157e33b..af7dbd518d 100644 --- a/src/processor/map/map_scan_frontier.cpp +++ b/src/processor/map/map_scan_frontier.cpp @@ -10,7 +10,7 @@ namespace processor { std::unique_ptr PlanMapper::mapScanFrontier( planner::LogicalOperator* logicalOperator) { auto scanFrontier = (LogicalScanFrontier*)logicalOperator; - auto nodeID = scanFrontier->getNode()->getInternalIDProperty(); + auto nodeID = scanFrontier->getNode()->getInternalID(); auto nodeIDPos = DataPos(scanFrontier->getSchema()->getExpressionPos(*nodeID)); return std::make_unique(nodeIDPos, getOperatorID(), std::string()); } diff --git a/src/processor/map/map_scan_node.cpp b/src/processor/map/map_scan_node.cpp index 08ef02cc59..e79216beb3 100644 --- a/src/processor/map/map_scan_node.cpp +++ b/src/processor/map/map_scan_node.cpp @@ -1,4 +1,4 @@ -#include "planner/operator/scan/logical_scan_node.h" +#include "planner/operator/scan/logical_scan_internal_id.h" #include "processor/operator/scan_node_id.h" #include "processor/plan_mapper.h" @@ -7,19 +7,18 @@ using namespace kuzu::planner; namespace kuzu { namespace processor { -std::unique_ptr PlanMapper::mapScanNode(LogicalOperator* logicalOperator) { - auto logicalScan = (LogicalScanNode*)logicalOperator; - auto outSchema = logicalScan->getSchema(); - auto node = logicalScan->getNode(); +std::unique_ptr PlanMapper::mapScanInternalID(LogicalOperator* logicalOperator) { + auto scan = reinterpret_cast(logicalOperator); + auto outSchema = scan->getSchema(); auto& nodesStore = storageManager.getNodesStore(); - auto dataPos = DataPos(outSchema->getExpressionPos(*node->getInternalIDProperty())); + auto dataPos = DataPos(outSchema->getExpressionPos(*scan->getInternalID())); auto sharedState = std::make_shared(); - for (auto& tableID : node->getTableIDs()) { + for (auto& tableID : scan->getTableIDs()) { auto nodeTable = nodesStore.getNodeTable(tableID); sharedState->addTableState(nodeTable); } return make_unique( - dataPos, sharedState, getOperatorID(), logicalScan->getExpressionsForPrinting()); + dataPos, sharedState, getOperatorID(), scan->getExpressionsForPrinting()); } } // namespace processor diff --git a/src/processor/map/map_scan_node_property.cpp b/src/processor/map/map_scan_node_property.cpp index c5ee9ea11e..85845492fc 100644 --- a/src/processor/map/map_scan_node_property.cpp +++ b/src/processor/map/map_scan_node_property.cpp @@ -15,17 +15,17 @@ std::unique_ptr PlanMapper::mapScanNodeProperty( auto outSchema = scanProperty.getSchema(); auto inSchema = scanProperty.getChild(0)->getSchema(); auto prevOperator = mapOperator(logicalOperator->getChild(0).get()); - auto node = scanProperty.getNode(); - auto inputNodeIDVectorPos = DataPos(inSchema->getExpressionPos(*node->getInternalIDProperty())); + auto inputNodeIDVectorPos = DataPos(inSchema->getExpressionPos(*scanProperty.getNodeID())); auto& nodeStore = storageManager.getNodesStore(); std::vector outVectorsPos; for (auto& expression : scanProperty.getProperties()) { outVectorsPos.emplace_back(outSchema->getExpressionPos(*expression)); } - if (node->isMultiLabeled()) { + auto tableIDs = scanProperty.getTableIDs(); + if (tableIDs.size() > 1) { std::unordered_map> tableIDToColumns; std::unordered_map tables; - for (auto& tableID : node->getTableIDs()) { + for (auto& tableID : tableIDs) { tables.insert({tableID, nodeStore.getNodeTable(tableID)}); std::vector columns; for (auto& expression : scanProperty.getProperties()) { @@ -44,7 +44,7 @@ std::unique_ptr PlanMapper::mapScanNodeProperty( std::move(tables), std::move(tableIDToColumns), std::move(prevOperator), getOperatorID(), scanProperty.getExpressionsForPrinting()); } else { - auto tableID = node->getSingleTableID(); + auto tableID = tableIDs[0]; auto tableSchema = catalog->getReadOnlyVersion()->getTableSchema(tableID); std::vector columnIDs; for (auto& expression : scanProperty.getProperties()) { diff --git a/src/processor/map/map_semi_masker.cpp b/src/processor/map/map_semi_masker.cpp index bcc9d7279d..bceafbe33c 100644 --- a/src/processor/map/map_semi_masker.cpp +++ b/src/processor/map/map_semi_masker.cpp @@ -14,9 +14,9 @@ std::unique_ptr PlanMapper::mapSemiMasker(LogicalOperator* log auto semiMasker = (LogicalSemiMasker*)logicalOperator; auto inSchema = semiMasker->getChild(0)->getSchema(); auto prevOperator = mapOperator(logicalOperator->getChild(0).get()); - auto node = semiMasker->getNode(); + auto tableIDs = semiMasker->getNodeTableIDs(); std::unordered_map> masksPerTable; - for (auto tableID : node->getTableIDs()) { + for (auto tableID : tableIDs) { masksPerTable.insert({tableID, std::vector{}}); } for (auto& op : semiMasker->getOperators()) { @@ -46,7 +46,7 @@ std::unique_ptr PlanMapper::mapSemiMasker(LogicalOperator* log auto info = std::make_unique(keyPos, std::move(masksPerTable)); switch (semiMasker->getType()) { case planner::SemiMaskType::NODE: { - if (node->isMultiLabeled()) { + if (tableIDs.size() > 1) { return std::make_unique(std::move(info), std::move(prevOperator), getOperatorID(), semiMasker->getExpressionsForPrinting()); } else { @@ -55,7 +55,7 @@ std::unique_ptr PlanMapper::mapSemiMasker(LogicalOperator* log } } case planner::SemiMaskType::PATH: { - if (node->isMultiLabeled()) { + if (tableIDs.size() > 1) { return std::make_unique(std::move(info), std::move(prevOperator), getOperatorID(), semiMasker->getExpressionsForPrinting()); } else { diff --git a/src/processor/map/map_set.cpp b/src/processor/map/map_set.cpp index f52bfced6a..b9d860289e 100644 --- a/src/processor/map/map_set.cpp +++ b/src/processor/map/map_set.cpp @@ -14,7 +14,7 @@ namespace processor { std::unique_ptr PlanMapper::getNodeSetExecutor(storage::NodesStore* store, planner::LogicalSetPropertyInfo* info, const planner::Schema& inSchema) { auto node = (NodeExpression*)info->nodeOrRel.get(); - auto nodeIDPos = DataPos(inSchema.getExpressionPos(*node->getInternalIDProperty())); + auto nodeIDPos = DataPos(inSchema.getExpressionPos(*node->getInternalID())); auto property = (PropertyExpression*)info->setItem.first.get(); auto propertyPos = DataPos(INVALID_DATA_CHUNK_POS, INVALID_VALUE_VECTOR_POS); if (inSchema.isExpressionInScope(*property)) { @@ -61,10 +61,8 @@ std::unique_ptr PlanMapper::mapSetNodeProperty(LogicalOperator std::unique_ptr PlanMapper::getRelSetExecutor(storage::RelsStore* store, planner::LogicalSetPropertyInfo* info, const planner::Schema& inSchema) { auto rel = (RelExpression*)info->nodeOrRel.get(); - auto srcNodePos = - DataPos(inSchema.getExpressionPos(*rel->getSrcNode()->getInternalIDProperty())); - auto dstNodePos = - DataPos(inSchema.getExpressionPos(*rel->getDstNode()->getInternalIDProperty())); + auto srcNodePos = DataPos(inSchema.getExpressionPos(*rel->getSrcNode()->getInternalID())); + auto dstNodePos = DataPos(inSchema.getExpressionPos(*rel->getDstNode()->getInternalID())); auto relIDPos = DataPos(inSchema.getExpressionPos(*rel->getInternalIDProperty())); auto property = (PropertyExpression*)info->setItem.first.get(); auto propertyPos = DataPos(INVALID_DATA_CHUNK_POS, INVALID_VALUE_VECTOR_POS); diff --git a/src/processor/map/plan_mapper.cpp b/src/processor/map/plan_mapper.cpp index fe206006ac..0a1f049ea5 100644 --- a/src/processor/map/plan_mapper.cpp +++ b/src/processor/map/plan_mapper.cpp @@ -38,8 +38,8 @@ std::unique_ptr PlanMapper::mapOperator(LogicalOperator* logic case LogicalOperatorType::SCAN_FRONTIER: { physicalOperator = mapScanFrontier(logicalOperator); } break; - case LogicalOperatorType::SCAN_NODE: { - physicalOperator = mapScanNode(logicalOperator); + case LogicalOperatorType::SCAN_INTERNAL_ID: { + physicalOperator = mapScanInternalID(logicalOperator); } break; case LogicalOperatorType::INDEX_SCAN_NODE: { physicalOperator = mapIndexScanNode(logicalOperator); diff --git a/test/optimizer/optimizer_test.cpp b/test/optimizer/optimizer_test.cpp index 66d950b518..481e820def 100644 --- a/test/optimizer/optimizer_test.cpp +++ b/test/optimizer/optimizer_test.cpp @@ -68,7 +68,7 @@ TEST_F(OptimizerTest, RemoveUnnecessaryJoinTest) { op = op->getChild(0); ASSERT_EQ(op->getOperatorType(), planner::LogicalOperatorType::FLATTEN); op = op->getChild(0); - ASSERT_EQ(op->getOperatorType(), planner::LogicalOperatorType::SCAN_NODE); + ASSERT_EQ(op->getOperatorType(), planner::LogicalOperatorType::SCAN_INTERNAL_ID); } TEST_F(OptimizerTest, ProjectionPushDownJoinTest) { @@ -84,7 +84,7 @@ TEST_F(OptimizerTest, ProjectionPushDownJoinTest) { TEST_F(OptimizerTest, RecursiveJoinTest) { auto encodedPlan = getEncodedPlan( "MATCH (a:person)-[:knows* SHORTEST 1..5]->(b:person) WHERE b.ID < 0 RETURN a.fName;"); - ASSERT_STREQ(encodedPlan.c_str(), "HJ(a._ID){RE(a)S(b)}{S(a)}"); + ASSERT_STREQ(encodedPlan.c_str(), "HJ(a._ID){RE(a)S(b._ID)}{S(a._ID)}"); } TEST_F(OptimizerTest, RecursiveJoinNoTrackPathTest) { diff --git a/test/test_files/tinysnb/acc/acc_hj.test b/test/test_files/tinysnb/acc/acc_hj.test index ab41ef35be..b004059dbf 100644 --- a/test/test_files/tinysnb/acc/acc_hj.test +++ b/test/test_files/tinysnb/acc/acc_hj.test @@ -7,7 +7,7 @@ -LOG AspBasic -STATEMENT MATCH (a:person)-[e1:knows]->(b:person) WHERE a.age > 35 RETURN b.fName --ENCODED_JOIN HJ(b._ID){E(b)S(a)}{S(b)} +-ENCODED_JOIN HJ(b._ID){E(b)S(a._ID)}{S(b._ID)} ---- 3 Alice Bob @@ -15,7 +15,7 @@ Dan -LOG AspMultiLabel -STATEMENT MATCH (a:person)-[e1:knows|:studyAt|:workAt]->(b:person:organisation) WHERE a.age > 35 RETURN b.fName, b.name --ENCODED_JOIN HJ(b._ID){E(b)S(a)}{S(b)} +-ENCODED_JOIN HJ(b._ID){E(b)S(a._ID)}{S(b._ID)} ---- 4 Alice| Bob| @@ -24,7 +24,7 @@ Dan| -LOG AspMultiKey -STATEMENT MATCH (a:person)-[e1:knows]->(b:person)-[e2:knows]->(c:person), (a)-[e3:knows]->(c) WHERE a.fName='Alice' RETURN b.fName, c.fName -#-ENCODED_JOIN HJ(c._id,b._id){E(b)E(c)S(a)}{HJ(b._id){S(b)}{E(b)S(c)}} +#-ENCODED_JOIN HJ(c._ID,b._ID){E(b)E(c)S(a._ID)}{HJ(b._id){S(b._ID)}{E(b)S(c._ID)}} -ENUMERATE ---- 6 Bob|Carol @@ -36,7 +36,7 @@ Dan|Carol -LOG AspMultiMaskToOneScan -STATEMENT MATCH (a:person)<-[e1:knows]-(b:person)-[e2:knows]->(c:person) WHERE a.fName='Alice' AND c.fName='Bob' RETURN b.fName -#-ENCODED_JOIN HJ(b._id){E(b)S(a)}{HJ(b._id){E(b)S(c)}{S(b)}} +#-ENCODED_JOIN HJ(b._ID){E(b)S(a._ID)}{HJ(b._ID){E(b)S(c._ID)}{S(b._ID)}} -ENUMERATE ---- 2 Carol diff --git a/test/test_files/tinysnb/generic_hash_join/basic.test b/test/test_files/tinysnb/generic_hash_join/basic.test index fd21fa6c7c..aa55787bb2 100644 --- a/test/test_files/tinysnb/generic_hash_join/basic.test +++ b/test/test_files/tinysnb/generic_hash_join/basic.test @@ -10,7 +10,7 @@ Elizabeth|Elizabeth|[96,59,65,88]|[96,59,65,88] -STATEMENT MATCH (a:person), (b:person) WHERE a.fName = b.fName AND a.ID < 6 RETURN a.fName, b.fName, a.ID, b.ID --ENCODED_JOIN HJ(a.fName=b.fName){S(a)}{S(b)} +-ENCODED_JOIN HJ(a.fName=b.fName){S(a._ID)}{S(b._ID)} ---- 4 Alice|Alice|0|0 Bob|Bob|2|2 diff --git a/test/test_files/tinysnb/parquet/tinysnb_parquet.test b/test/test_files/tinysnb/parquet/tinysnb_parquet.test index 590b22d2cf..760e504c18 100644 --- a/test/test_files/tinysnb/parquet/tinysnb_parquet.test +++ b/test/test_files/tinysnb/parquet/tinysnb_parquet.test @@ -10,7 +10,7 @@ -LOG AccAspMultiLabelParquet -STATEMENT MATCH (a:person)-[e1:knows|:studyAt|:workAt]->(b:person:organisation) WHERE a.age > 35 RETURN b.fName, b.name --ENCODED_JOIN HJ(b._ID){E(b)S(a)}{S(b)} +-ENCODED_JOIN HJ(b._ID){E(b)S(a._ID)}{S(b._ID)} ---- 4 Alice| Bob|