kuzudb · andyfengHKU · Sep 21, 2023 · Sep 21, 2023
diff --git 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
@@ -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
@@ -406,7 +406,7 @@ std::shared_ptr<NodeExpression> 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<std::unique_ptr<StructField>> nodeFields;
     nodeFields.push_back(std::make_unique<StructField>(

diff --git 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<BoundProjectionBody> 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
@@ -63,7 +63,7 @@ std::unique_ptr<BoundReadingClause> 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
@@ -177,7 +177,7 @@ std::shared_ptr<Expression> ExpressionBinder::bindInternalIDExpression(
     std::shared_ptr<Expression> 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<Expression> ExpressionBinder::bindLabelFunction(const Expression
                 std::make_unique<Value>(LogicalType{LogicalTypeID::STRING}, labelName));
         }
         auto nodeTableIDs = catalogContent->getNodeTableIDs();
-        children.push_back(node.getInternalIDProperty());
+        children.push_back(node.getInternalID());
         auto labelsValue =
             std::make_unique<Value>(*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
@@ -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
@@ -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
@@ -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> expression) {
-        internalIDExpression = std::move(expression);
+    inline void setInternalID(std::unique_ptr<Expression> expression) {
+        internalID = std::move(expression);
     }
-    inline std::shared_ptr<Expression> getInternalIDProperty() const {
-        assert(internalIDExpression != nullptr);
-        return internalIDExpression->copy();
-    }
-    inline std::string getInternalIDPropertyName() const {
-        return internalIDExpression->getUniqueName();
+    inline std::shared_ptr<Expression> getInternalID() const {
+        assert(internalID != nullptr);
+        return internalID->copy();
     }
 
 private:
-    std::unique_ptr<Expression> internalIDExpression;
+    std::unique_ptr<Expression> internalID;
 };
 
 } // namespace binder

diff --git 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<planner::LogicalOperator*> resolveScanNodeIDsToApplySemiMask(
+    std::vector<planner::LogicalOperator*> 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
@@ -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<planner::LogicalOperator> pushDownToScanNode(
-        std::shared_ptr<binder::NodeExpression> node, std::shared_ptr<binder::Expression> predicate,
+        std::shared_ptr<binder::Expression> nodeID, std::vector<common::table_id_t> tableIDs,
+        std::shared_ptr<binder::Expression> predicate,
         std::shared_ptr<planner::LogicalOperator> child);
 
     // Finish the current push down optimization by apply remaining predicates as a single filter.
@@ -46,8 +47,8 @@ class FilterPushDownOptimizer {
         std::shared_ptr<planner::LogicalOperator> op);
 
     std::shared_ptr<planner::LogicalOperator> appendScanNodeProperty(
-        std::shared_ptr<binder::NodeExpression> node, binder::expression_vector properties,
-        std::shared_ptr<planner::LogicalOperator> child);
+        std::shared_ptr<binder::Expression> nodeID, std::vector<common::table_id_t> nodeTableIDs,
+        binder::expression_vector properties, std::shared_ptr<planner::LogicalOperator> child);
     std::shared_ptr<planner::LogicalOperator> appendFilter(
         std::shared_ptr<binder::Expression> predicate,
         std::shared_ptr<planner::LogicalOperator> child);
@@ -66,7 +67,7 @@ class FilterPushDownOptimizer {
 
         void addPredicate(std::shared_ptr<binder::Expression> predicate);
         std::shared_ptr<binder::Expression> 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
@@ -20,27 +20,27 @@
 
 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
@@ -27,8 +27,8 @@ class LogicalOperatorVisitor {
         return op;
     }
 
-    virtual void visitScanNode(planner::LogicalOperator* op) {}
-    virtual std::shared_ptr<planner::LogicalOperator> visitScanNodeReplace(
+    virtual void visitScanInternalID(planner::LogicalOperator* op) {}
+    virtual std::shared_ptr<planner::LogicalOperator> visitScanInternalIDReplace(
         std::shared_ptr<planner::LogicalOperator> op) {
         return op;
     }

diff --git 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
@@ -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
@@ -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
@@ -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<binder::Expression> internalID, std::vector<common::table_id_t> 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<binder::Expression> getInternalID() const { return internalID; }
+    inline std::vector<common::table_id_t> getTableIDs() const { return tableIDs; }
+
+    inline std::unique_ptr<LogicalOperator> copy() final {
+        return make_unique<LogicalScanInternalID>(internalID, tableIDs);
+    }
+
+private:
+    std::shared_ptr<binder::Expression> internalID;
+    std::vector<common::table_id_t> 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
diff --git a/src/include/planner/operator/scan/logical_scan_node_property.h b/src/include/planner/operator/scan/logical_scan_node_property.h
@@ -1,34 +1,38 @@
 #pragma once
 
-#include "binder/expression/node_expression.h"
 #include "planner/operator/logical_operator.h"
 
 namespace kuzu {
 namespace planner {
 
 class LogicalScanNodeProperty : public LogicalOperator {
 public:
-    LogicalScanNodeProperty(std::shared_ptr<binder::NodeExpression> node,
-        binder::expression_vector properties, std::shared_ptr<LogicalOperator> child)
+    LogicalScanNodeProperty(std::shared_ptr<binder::Expression> nodeID,
+        std::vector<common::table_id_t> nodeTableIDs, binder::expression_vector properties,
+        std::shared_ptr<LogicalOperator> 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<binder::NodeExpression> getNode() const { return node; }
+    inline std::shared_ptr<binder::Expression> getNodeID() const { return nodeID; }
+    inline std::vector<common::table_id_t> getTableIDs() const { return nodeTableIDs; }
     inline binder::expression_vector getProperties() const { return properties; }
 
-    inline std::unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalScanNodeProperty>(node, properties, children[0]->copy());
+    inline std::unique_ptr<LogicalOperator> copy() final {
+        return make_unique<LogicalScanNodeProperty>(
+            nodeID, nodeTableIDs, properties, children[0]->copy());
     }
 
 private:
-    std::shared_ptr<binder::NodeExpression> node;
+    std::shared_ptr<binder::Expression> nodeID;
+    std::vector<common::table_id_t> 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
@@ -15,19 +15,19 @@ enum class SemiMaskType : uint8_t {
 class LogicalSemiMasker : public LogicalOperator {
 public:
     LogicalSemiMasker(SemiMaskType type, std::shared_ptr<binder::Expression> key,
-        std::shared_ptr<binder::NodeExpression> node, std::vector<LogicalOperator*> ops,
+        std::vector<common::table_id_t> nodeTableIDs, std::vector<LogicalOperator*> ops,
         std::shared_ptr<LogicalOperator> 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<binder::Expression> getKey() const { return key; }
-    inline std::shared_ptr<binder::NodeExpression> getNode() const { return node; }
+    inline std::vector<common::table_id_t> getNodeTableIDs() const { return nodeTableIDs; }
     inline std::vector<LogicalOperator*> getOperators() const { return ops; }
 
     inline std::unique_ptr<LogicalOperator> copy() override {
@@ -37,7 +37,7 @@ class LogicalSemiMasker : public LogicalOperator {
 private:
     SemiMaskType type;
     std::shared_ptr<binder::Expression> key;
-    std::shared_ptr<binder::NodeExpression> node;
+    std::vector<common::table_id_t> nodeTableIDs;
     std::vector<LogicalOperator*> ops;
 };