kuzudb · andyfengHKU · Nov 25, 2022 · Nov 21, 2022
diff --git a/src/antlr4/Cypher.g4 b/src/antlr4/Cypher.g4
@@ -246,8 +246,8 @@ oC_PatternElement
         ;
 
 oC_NodePattern
-    : '(' SP? ( oC_Variable SP? )? ( oC_NodeLabel SP? )? ( kU_Properties SP? )? ')'
-        | SP? ( oC_Variable SP? )? ( oC_NodeLabel SP? )? ( kU_Properties SP? )? { notifyNodePatternWithoutParentheses($oC_Variable.text, $oC_Variable.start); }
+    : '(' SP? ( oC_Variable SP? )? ( oC_NodeLabels SP? )? ( kU_Properties SP? )? ')'
+        | SP? ( oC_Variable SP? )? ( oC_NodeLabels SP? )? ( kU_Properties SP? )? { notifyNodePatternWithoutParentheses($oC_Variable.text, $oC_Variable.start); }
         ;
 
 oC_PatternElementChain
@@ -267,6 +267,9 @@ oC_RelationshipDetail
 kU_Properties
     : '{' SP? ( oC_PropertyKeyName SP? ':' SP? oC_Expression SP? ( ',' SP? oC_PropertyKeyName SP? ':' SP? oC_Expression SP? )* )? '}';
 
+oC_NodeLabels
+     :  oC_NodeLabel ( SP? oC_NodeLabel )* ;
+
 oC_NodeLabel
     : ':' SP? oC_LabelName ;
 

diff --git a/src/binder/bind/bind_ddl.cpp b/src/binder/bind/bind_ddl.cpp
@@ -34,7 +34,7 @@ unique_ptr<BoundStatement> Binder::bindCreateRelClause(const Statement& statemen
     auto relConnections = createRelClause.getRelConnections();
     vector<pair<table_id_t, table_id_t>> srcDstTableIDs;
     for (auto& [srcTableName, dstTableName] : relConnections) {
-        srcDstTableIDs.emplace_back(bindNodeTable(srcTableName), bindNodeTable(dstTableName));
+        srcDstTableIDs.emplace_back(bindNodeTableID(srcTableName), bindNodeTableID(dstTableName));
     }
     return make_unique<BoundCreateRelClause>(
         tableName, move(propertyNameDataTypes), relMultiplicity, srcDstTableIDs);

diff --git a/src/binder/bind/bind_graph_pattern.cpp b/src/binder/bind/bind_graph_pattern.cpp
@@ -37,6 +37,31 @@ unique_ptr<QueryGraph> Binder::bindPatternElement(
     return queryGraph;
 }
 
+// TODO(Xiyang): remove this validation when we support full multi-labeled query
+static void validateNodeRelConnectivity(table_id_t srcTableID, table_id_t dstTableID,
+    table_id_t relTableID, const CatalogContent& catalogContent) {
+    for (auto& [srcTableID_, dstTableID_] :
+        catalogContent.getRelTableSchema(relTableID)->srcDstTableIDs) {
+        if (srcTableID_ == srcTableID && dstTableID_ == dstTableID) {
+            return;
+        }
+    }
+    throw BinderException("Node table " + catalogContent.getNodeTableName(srcTableID) +
+                          " doesn't connect to " + catalogContent.getNodeTableName(dstTableID) +
+                          " through rel table " + catalogContent.getRelTableName(relTableID) + ".");
+}
+
+// E.g. MATCH (:person)-[:studyAt]->(:person) ...
+static void validateNodeRelConnectivity(const Catalog& catalog_, const RelExpression& rel,
+    const NodeExpression& srcNode, const NodeExpression& dstNode) {
+    for (auto srcTableID : srcNode.getTableIDs()) {
+        for (auto dstTableID : dstNode.getTableIDs()) {
+            validateNodeRelConnectivity(
+                srcTableID, dstTableID, rel.getTableID(), *catalog_.getReadOnlyVersion());
+        }
+    }
+}
+
 void Binder::bindQueryRel(const RelPattern& relPattern, const shared_ptr<NodeExpression>& leftNode,
     const shared_ptr<NodeExpression>& rightNode, QueryGraph& queryGraph,
     PropertyKeyValCollection& collection) {
@@ -56,8 +81,6 @@ void Binder::bindQueryRel(const RelPattern& relPattern, const shared_ptr<NodeExp
     auto isLeftNodeSrc = RIGHT == relPattern.getDirection();
     auto srcNode = isLeftNodeSrc ? leftNode : rightNode;
     auto dstNode = isLeftNodeSrc ? rightNode : leftNode;
-    validateNodeAndRelTableIsConnected(
-        catalog, tableID, srcNode->getTableID(), dstNode->getTableID());
     if (srcNode->getUniqueName() == dstNode->getUniqueName()) {
         throw BinderException("Self-loop rel " + parsedName + " is not supported.");
     }
@@ -79,6 +102,7 @@ void Binder::bindQueryRel(const RelPattern& relPattern, const shared_ptr<NodeExp
     if (!parsedName.empty()) {
         variablesInScope.insert({parsedName, queryRel});
     }
+    validateNodeRelConnectivity(catalog, *queryRel, *srcNode, *dstNode);
     for (auto i = 0u; i < relPattern.getNumPropertyKeyValPairs(); ++i) {
         auto [propertyName, rhs] = relPattern.getProperty(i);
         auto boundLhs = expressionBinder.bindRelPropertyExpression(queryRel, propertyName);
@@ -97,12 +121,8 @@ shared_ptr<NodeExpression> Binder::bindQueryNode(
         auto prevVariable = variablesInScope.at(parsedName);
         ExpressionBinder::validateExpectedDataType(*prevVariable, NODE);
         queryNode = static_pointer_cast<NodeExpression>(prevVariable);
-        auto otherTableID = bindNodeTable(nodePattern.getTableName());
-        KU_ASSERT(queryNode->getTableID() != ANY_TABLE_ID);
-        if (otherTableID != ANY_TABLE_ID && queryNode->getTableID() != otherTableID) {
-            throw BinderException(
-                "Multi-table is not supported. Node " + parsedName + " is given multiple tables.");
-        }
+        auto otherTableIDs = bindNodeTableIDs(nodePattern.getTableNames());
+        queryNode->addTableIDs(otherTableIDs);
     } else {
         queryNode = createQueryNode(nodePattern);
     }
@@ -119,19 +139,27 @@ shared_ptr<NodeExpression> Binder::bindQueryNode(
 
 shared_ptr<NodeExpression> Binder::createQueryNode(const NodePattern& nodePattern) {
     auto parsedName = nodePattern.getVariableName();
-    auto tableID = bindNodeTable(nodePattern.getTableName());
-    auto queryNode = make_shared<NodeExpression>(getUniqueExpressionName(parsedName), tableID);
+    auto tableIDs = bindNodeTableIDs(nodePattern.getTableNames());
+    auto queryNode = make_shared<NodeExpression>(getUniqueExpressionName(parsedName), tableIDs);
     queryNode->setAlias(parsedName);
     queryNode->setRawName(parsedName);
-    if (ANY_TABLE_ID == tableID) {
-        throw BinderException(
-            "Any-table is not supported. " + parsedName + " does not have a table.");
-    }
     if (!parsedName.empty()) {
         variablesInScope.insert({parsedName, queryNode});
     }
     return queryNode;
 }
 
+unordered_set<table_id_t> Binder::bindNodeTableIDs(const vector<string>& nodeTableNames) {
+    unordered_set<table_id_t> result;
+    for (auto& nodeTableName : nodeTableNames) {
+        auto nodeTableID = bindNodeTableID(nodeTableName);
+        if (nodeTableID == ANY_TABLE_ID) {
+            throw BinderException("Any-table is not supported");
+        }
+        result.insert(nodeTableID);
+    }
+    return result;
+}
+
 } // namespace binder
 } // namespace kuzu
diff --git a/src/binder/bind/bind_projection_clause.cpp b/src/binder/bind/bind_projection_clause.cpp
@@ -74,6 +74,10 @@ expression_vector Binder::rewriteProjectionExpressions(const expression_vector&
 
 expression_vector Binder::rewriteNodeAsAllProperties(const shared_ptr<Expression>& expression) {
     auto& node = (NodeExpression&)*expression;
+    if (node.getNumTableIDs() > 1) {
+        throw BinderException(
+            "Cannot rewrite multi-labeled node " + node.getRawName() + " as all properties.");
+    }
     expression_vector result;
     for (auto& property : catalog.getReadOnlyVersion()->getAllNodeProperties(node.getTableID())) {
         auto propertyExpression = expressionBinder.bindNodePropertyExpression(expression, property);

diff --git a/src/binder/bind/bind_updating_clause.cpp b/src/binder/bind/bind_updating_clause.cpp
@@ -53,6 +53,10 @@ unique_ptr<BoundUpdatingClause> Binder::bindCreateClause(const UpdatingClause& u
 
 unique_ptr<BoundCreateNode> Binder::bindCreateNode(
     shared_ptr<NodeExpression> node, const PropertyKeyValCollection& collection) {
+    if (node->getNumTableIDs() > 1) {
+        throw BinderException(
+            "Create multi-labeled node " + node->getRawName() + "is not supported.");
+    }
     auto nodeTableSchema = catalog.getReadOnlyVersion()->getNodeTableSchema(node->getTableID());
     auto primaryKey = nodeTableSchema->getPrimaryKey();
     shared_ptr<Expression> primaryKeyExpression;
@@ -130,6 +134,10 @@ unique_ptr<BoundUpdatingClause> Binder::bindDeleteClause(const UpdatingClause& u
 }
 
 unique_ptr<BoundDeleteNode> Binder::bindDeleteNode(shared_ptr<NodeExpression> node) {
+    if (node->getNumTableIDs() > 1) {
+        throw BinderException(
+            "Delete multi-labeled node " + node->getRawName() + "is not supported.");
+    }
     auto nodeTableSchema = catalog.getReadOnlyVersion()->getNodeTableSchema(node->getTableID());
     auto primaryKey = nodeTableSchema->getPrimaryKey();
     auto primaryKeyExpression = expressionBinder.bindNodePropertyExpression(node, primaryKey);

diff --git a/src/binder/binder.cpp b/src/binder/binder.cpp
@@ -41,7 +41,7 @@ table_id_t Binder::bindRelTable(const string& tableName) const {
     return catalog.getReadOnlyVersion()->getRelTableIDFromName(tableName);
 }
 
-table_id_t Binder::bindNodeTable(const string& tableName) const {
+table_id_t Binder::bindNodeTableID(const string& tableName) const {
     if (tableName.empty()) {
         return ANY_TABLE_ID;
     }
@@ -69,21 +69,6 @@ void Binder::validateFirstMatchIsNotOptional(const SingleQuery& singleQuery) {
     }
 }
 
-void Binder::validateNodeAndRelTableIsConnected(
-    const Catalog& catalog_, table_id_t relTableID, table_id_t srcTableID, table_id_t dstTableID) {
-    assert(relTableID != ANY_TABLE_ID && srcTableID != ANY_TABLE_ID && dstTableID != ANY_TABLE_ID);
-    for (auto& [srcTableID_, dstTableID_] :
-        catalog_.getReadOnlyVersion()->getRelTableSchema(relTableID)->srcDstTableIDs) {
-        if (srcTableID_ == srcTableID && dstTableID_ == dstTableID) {
-            return;
-        }
-    }
-    throw BinderException(
-        "Node table " + catalog_.getReadOnlyVersion()->getNodeTableName(srcTableID) +
-        " doesn't connect to " + catalog_.getReadOnlyVersion()->getNodeTableName(dstTableID) +
-        " through rel table " + catalog_.getReadOnlyVersion()->getRelTableName(relTableID) + ".");
-}
-
 void Binder::validateProjectionColumnNamesAreUnique(const expression_vector& expressions) {
     auto existColumnNames = unordered_set<string>();
     for (auto& expression : expressions) {

diff --git a/src/binder/expression_binder.cpp b/src/binder/expression_binder.cpp
@@ -143,6 +143,9 @@ shared_ptr<Expression> ExpressionBinder::bindNodePropertyExpression(
     shared_ptr<Expression> node, const string& propertyName) {
     auto catalogContent = binder->catalog.getReadOnlyVersion();
     auto nodeExpression = static_pointer_cast<NodeExpression>(node);
+    if (nodeExpression->getNumTableIDs() > 1) {
+        throw BinderException("Cannot bind property for multi-labeled node " + node->getRawName());
+    }
     if (catalogContent->containNodeProperty(nodeExpression->getTableID(), propertyName)) {
         auto& property =
             catalogContent->getNodeProperty(nodeExpression->getTableID(), propertyName);

diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp
@@ -277,11 +277,6 @@ const Property& CatalogContent::getRelProperty(
     assert(false);
 }
 
-const Property& CatalogContent::getNodePrimaryKeyProperty(table_id_t tableID) const {
-    auto primaryKeyId = nodeTableSchemas.at(tableID)->primaryKeyPropertyIdx;
-    return nodeTableSchemas.at(tableID)->structuredProperties[primaryKeyId];
-}
-
 vector<Property> CatalogContent::getAllNodeProperties(table_id_t tableID) const {
     return nodeTableSchemas.at(tableID)->getAllNodeProperties();
 }

diff --git a/src/include/binder/binder.h b/src/include/binder/binder.h
@@ -34,7 +34,7 @@ class Binder {
     shared_ptr<Expression> bindWhereExpression(const ParsedExpression& parsedExpression);
 
     table_id_t bindRelTable(const string& tableName) const;
-    table_id_t bindNodeTable(const string& tableName) const;
+    table_id_t bindNodeTableID(const string& tableName) const;
 
     shared_ptr<Expression> createVariable(const string& name, const DataType& dataType);
 
@@ -112,17 +112,14 @@ class Binder {
     shared_ptr<NodeExpression> bindQueryNode(const NodePattern& nodePattern, QueryGraph& queryGraph,
         PropertyKeyValCollection& collection);
     shared_ptr<NodeExpression> createQueryNode(const NodePattern& nodePattern);
+    unordered_set<table_id_t> bindNodeTableIDs(const vector<string>& nodeTableNames);
 
     /*** validations ***/
     // E.g. Optional MATCH (a) RETURN a.age
     // Although this is doable in Neo4j, I don't think the semantic make a lot of sense because
     // there is nothing to left join on.
     static void validateFirstMatchIsNotOptional(const SingleQuery& singleQuery);
 
-    // E.g. MATCH (:person)-[:studyAt]->(:person) ...
-    static void validateNodeAndRelTableIsConnected(const Catalog& catalog_, table_id_t relTableID,
-        table_id_t srcTableID, table_id_t dstTableID);
-
     // E.g. ... RETURN a, b AS a
     static void validateProjectionColumnNamesAreUnique(const expression_vector& expressions);
 

diff --git a/src/include/binder/expression/node_expression.h b/src/include/binder/expression/node_expression.h
@@ -6,12 +6,19 @@ namespace kuzu {
 namespace binder {
 
 class NodeExpression : public Expression {
-
 public:
-    NodeExpression(const string& uniqueName, table_id_t tableID)
-        : Expression{VARIABLE, NODE, uniqueName}, tableID{tableID} {}
+    NodeExpression(const string& uniqueName, unordered_set<table_id_t> tableIDs)
+        : Expression{VARIABLE, NODE, uniqueName}, tableIDs{std::move(tableIDs)} {}
 
-    inline table_id_t getTableID() const { return tableID; }
+    inline void addTableIDs(const unordered_set<table_id_t>& tableIDsToAdd) {
+        tableIDs.insert(tableIDsToAdd.begin(), tableIDsToAdd.end());
+    }
+    inline uint32_t getNumTableIDs() const { return tableIDs.size(); }
+    inline unordered_set<table_id_t> getTableIDs() const { return tableIDs; }
+    inline table_id_t getTableID() const {
+        assert(tableIDs.size() == 1);
+        return *tableIDs.begin();
+    }
 
     inline string getIDProperty() const { return uniqueName + "." + INTERNAL_ID_SUFFIX; }
 
@@ -21,7 +28,7 @@ class NodeExpression : public Expression {
     }
 
 private:
-    table_id_t tableID;
+    unordered_set<table_id_t> tableIDs;
 };
 
 } // namespace binder

diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h
@@ -92,8 +92,6 @@ class CatalogContent {
     virtual const Property& getNodeProperty(table_id_t tableID, const string& propertyName) const;
     virtual const Property& getRelProperty(table_id_t tableID, const string& propertyName) const;
 
-    const Property& getNodePrimaryKeyProperty(table_id_t tableID) const;
-
     vector<Property> getAllNodeProperties(table_id_t tableID) const;
     inline const vector<Property>& getRelProperties(table_id_t tableID) const {
         return relTableSchemas.at(tableID)->properties;
@@ -116,7 +114,7 @@ class CatalogContent {
     /**
      * Graph topology functions.
      */
-
+    // TODO(Xiyang): remove
     virtual const unordered_set<table_id_t>& getRelTableIDsForNodeTableDirection(
         table_id_t tableID, RelDirection direction) const;
 

diff --git a/src/include/common/types/node_id_t.h b/src/include/common/types/node_id_t.h
@@ -5,6 +5,7 @@ namespace common {
 
 typedef uint64_t table_id_t;
 typedef uint64_t node_offset_t;
+constexpr node_offset_t INVALID_NODE_OFFSET = UINT64_MAX;
 
 // System representation for nodeID.
 struct nodeID_t {

diff --git a/src/include/parser/query/graph_pattern/node_pattern.h b/src/include/parser/query/graph_pattern/node_pattern.h
@@ -11,29 +11,29 @@ namespace kuzu {
 namespace parser {
 
 /**
- * NodePattern represents "(nodeName:NodeTable {p1:v1, p2:v2, ...})"
+ * NodePattern represents "(nodeName:NodeTable+ {p1:v1, p2:v2, ...})"
  */
 class NodePattern {
 public:
-    NodePattern(string name, string tableName,
+    NodePattern(string name, vector<string> tableNames,
         vector<pair<string, unique_ptr<ParsedExpression>>> propertyKeyValPairs)
-        : variableName{std::move(name)}, tableName{std::move(tableName)},
+        : variableName{std::move(name)}, tableNames{std::move(tableNames)},
           propertyKeyValPairs{std::move(propertyKeyValPairs)} {}
 
     virtual ~NodePattern() = default;
 
     inline string getVariableName() const { return variableName; }
 
-    inline string getTableName() const { return tableName; }
+    inline vector<string> getTableNames() const { return tableNames; }
 
     inline uint32_t getNumPropertyKeyValPairs() const { return propertyKeyValPairs.size(); }
     inline pair<string, ParsedExpression*> getProperty(uint32_t idx) const {
         return make_pair(propertyKeyValPairs[idx].first, propertyKeyValPairs[idx].second.get());
     }
 
-private:
+protected:
     string variableName;
-    string tableName;
+    vector<string> tableNames;
     vector<pair<string, unique_ptr<ParsedExpression>>> propertyKeyValPairs;
 };
 

diff --git a/src/include/parser/query/graph_pattern/rel_pattern.h b/src/include/parser/query/graph_pattern/rel_pattern.h
@@ -16,12 +16,18 @@ class RelPattern : public NodePattern {
     RelPattern(string name, string tableName, string lowerBound, string upperBound,
         ArrowDirection arrowDirection,
         vector<pair<string, unique_ptr<ParsedExpression>>> propertyKeyValPairs)
-        : NodePattern{std::move(name), std::move(tableName), std::move(propertyKeyValPairs)},
+        : NodePattern{std::move(name), vector<string>{std::move(tableName)},
+              std::move(propertyKeyValPairs)},
           lowerBound{std::move(lowerBound)}, upperBound{std::move(upperBound)},
           arrowDirection{arrowDirection} {}
 
     ~RelPattern() = default;
 
+    inline string getTableName() const {
+        assert(tableNames.size() == 1);
+        return tableNames[0];
+    }
+
     inline string getLowerBound() const { return lowerBound; }
 
     inline string getUpperBound() const { return upperBound; }