Add DDL to rel group

src/binder/bind/bind_copy.cpp

@@ -79,10 +79,19 @@ std::unique_ptr<BoundStatement> Binder::bindCopyFromClause(const Statement& stat
     auto& copyStatement = (CopyFrom&)statement;
     auto catalogContent = catalog.getReadOnlyVersion();
     auto tableName = copyStatement.getTableName();
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     // Bind to table schema.
     auto tableID = catalogContent->getTableID(tableName);
     auto tableSchema = catalogContent->getTableSchema(tableID);
+    switch (tableSchema->tableType) {
+    case TableType::REL_GROUP:
+    case TableType::RDF: {
+        throw BinderException(StringUtils::string_format("Cannot copy into {} table with type {}.",
+            tableName, TableTypeUtils::toString(tableSchema->tableType)));
+    }
+    default:
+        break;
+    }
     auto csvReaderConfig = bindParsingOptions(copyStatement.getParsingOptionsRef());
     auto filePaths = bindFilePaths(copyStatement.getFilePaths());
     auto fileType = bindFileType(filePaths);

src/binder/bind/bind_ddl.cpp

@@ -3,6 +3,7 @@
 #include "binder/ddl/bound_create_table.h"
 #include "binder/ddl/bound_drop_table.h"
 #include "catalog/node_table_schema.h"
+#include "catalog/rel_table_group_schema.h"
 #include "catalog/rel_table_schema.h"
 #include "common/exception/binder.h"
 #include "common/string_utils.h"
@@ -219,11 +220,35 @@
 std::unique_ptr<BoundStatement> Binder::bindDropTable(const Statement& statement) {
     auto& dropTable = reinterpret_cast<const Drop&>(statement);
     auto tableName = dropTable.getTableName();
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     auto catalogContent = catalog.getReadOnlyVersion();
     auto tableID = catalogContent->getTableID(tableName);
-    if (catalogContent->containsNodeTable(tableName)) {
-        validateNodeTableHasNoEdge(catalog, tableID);
+    auto tableSchema = catalogContent->getTableSchema(tableID);
+    switch (tableSchema->tableType) {
+    case TableType::NODE: {
+        for (auto& schema : catalogContent->getRelTableSchemas()) {
+            auto relTableSchema = reinterpret_cast<RelTableSchema*>(schema);
+            if (relTableSchema->isSrcOrDstTable(tableID)) {
+                throw BinderException(StringUtils::string_format(
+                    "Cannot delete node table {} referenced by rel table {}.",
+                    tableSchema->tableName, relTableSchema->tableName));
+            }
+        }
+    } break;
+    case TableType::REL: {
+        for (auto& schema : catalogContent->getRelTableGroupSchemas()) {
+            auto relTableGroupSchema = reinterpret_cast<RelTableGroupSchema*>(schema);
+            for (auto& relTableID : relTableGroupSchema->getRelTableIDs()) {
+                if (relTableID == tableSchema->getTableID()) {
+                    throw BinderException(StringUtils::string_format(
+                        "Cannot delete rel table {} referenced by rel group {}.",
+                        tableSchema->tableName, relTableGroupSchema->tableName));
+                }
+            }
+        }
+    }
+    default:
+        break;
     }
     return make_unique<BoundDropTable>(tableID, tableName);
 }
@@ -255,7 +280,7 @@
     auto tableName = info->tableName;
     auto newName = extraInfo->newName;
     auto catalogContent = catalog.getReadOnlyVersion();
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     if (catalogContent->containsTable(newName)) {
         throw BinderException("Table: " + newName + " already exists.");
     }
@@ -280,17 +305,31 @@
     }
 }
 
+static void validatePropertyDDLOnTable(TableSchema* tableSchema, const std::string& ddlOperation) {
+    switch (tableSchema->tableType) {
+    case TableType::REL_GROUP:
+    case TableType::RDF: {
+        throw BinderException(
+            StringUtils::string_format("Cannot {} property on table {} with type {}.", ddlOperation,
+                tableSchema->tableName, TableTypeUtils::toString(tableSchema->tableType)));
+    }
+    default:
+        return;
+    }
+}
+
 std::unique_ptr<BoundStatement> Binder::bindAddProperty(const Statement& statement) {
     auto& alter = reinterpret_cast<const Alter&>(statement);
     auto info = alter.getInfo();
     auto extraInfo = reinterpret_cast<ExtraAddPropertyInfo*>(info->extraInfo.get());
     auto tableName = info->tableName;
     auto dataType = bindDataType(extraInfo->dataType);
     auto propertyName = extraInfo->propertyName;
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     auto catalogContent = catalog.getReadOnlyVersion();
     auto tableID = catalogContent->getTableID(tableName);
     auto tableSchema = catalogContent->getTableSchema(tableID);
+    validatePropertyDDLOnTable(tableSchema, "add");
     validatePropertyNotExist(tableSchema, propertyName);
     if (dataType->getLogicalTypeID() == LogicalTypeID::SERIAL) {
         throw BinderException("Serial property in node table must be the primary key.");
@@ -310,10 +349,11 @@
     auto extraInfo = reinterpret_cast<ExtraDropPropertyInfo*>(info->extraInfo.get());
     auto tableName = info->tableName;
     auto propertyName = extraInfo->propertyName;
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     auto catalogContent = catalog.getReadOnlyVersion();
     auto tableID = catalogContent->getTableID(tableName);
     auto tableSchema = catalogContent->getTableSchema(tableID);
+    validatePropertyDDLOnTable(tableSchema, "drop");
     validatePropertyExist(tableSchema, propertyName);
     auto propertyID = tableSchema->getPropertyID(propertyName);
     if (tableSchema->getTableType() == TableType::NODE &&
@@ -333,10 +373,11 @@
     auto tableName = info->tableName;
     auto propertyName = extraInfo->propertyName;
     auto newName = extraInfo->newName;
-    validateNodeRelTableExist(tableName);
+    validateTableExist(tableName);
     auto catalogContent = catalog.getReadOnlyVersion();
     auto tableID = catalogContent->getTableID(tableName);
     auto tableSchema = catalogContent->getTableSchema(tableID);
+    validatePropertyDDLOnTable(tableSchema, "rename");
     validatePropertyExist(tableSchema, propertyName);
     auto propertyID = tableSchema->getPropertyID(propertyName);
     validatePropertyNotExist(tableSchema, newName);

src/binder/binder.cpp

@@ -172,24 +172,6 @@ void Binder::validateTableExist(const std::string& tableName) {
     }
 }
 
-void Binder::validateNodeRelTableExist(const std::string& tableName) {
-    if (!catalog.getReadOnlyVersion()->containsNodeTable(tableName) &&
-        !catalog.getReadOnlyVersion()->containsRelTable(tableName)) {
-        throw BinderException("Table " + tableName + " does not exist.");
-    }
-}
-
-void Binder::validateNodeTableHasNoEdge(const Catalog& _catalog, table_id_t tableID) {
-    for (auto& tableSchema : _catalog.getReadOnlyVersion()->getRelTableSchemas()) {
-        auto relTableSchema = reinterpret_cast<RelTableSchema*>(tableSchema);
-        if (relTableSchema->isSrcOrDstTable(tableID)) {
-            throw BinderException(StringUtils::string_format(
-                "Cannot delete a node table with edges. It is on the edges of rel: {}.",
-                relTableSchema->tableName));
-        }
-    }
-}
-
 std::string Binder::getUniqueExpressionName(const std::string& name) {
     return "_" + std::to_string(lastExpressionId++) + "_" + name;
 }

src/catalog/catalog.cpp

@@ -58,23 +58,34 @@ common::table_id_t Catalog::addRelTableGroupSchema(const binder::BoundCreateTabl
     auto tableID = catalogContentForWriteTrx->addRelTableGroupSchema(info);
     auto relTableGroupSchema =
         (RelTableGroupSchema*)catalogContentForWriteTrx->getTableSchema(tableID);
-    // TODO(Ziyi): remove this when we can log variable size record. See also wal_record.h
     for (auto relTableID : relTableGroupSchema->getRelTableIDs()) {
         wal->logRelTableRecord(relTableID);
     }
-    wal->logRelTableGroupRecord(tableID, relTableGroupSchema->getRelTableIDs());
     return tableID;
 }
 
-common::table_id_t Catalog::addRdfGraphSchema(const binder::BoundCreateTableInfo& info) {
+table_id_t Catalog::addRdfGraphSchema(const binder::BoundCreateTableInfo& info) {
     initCatalogContentForWriteTrxIfNecessary();
     return catalogContentForWriteTrx->addRdfGraphSchema(info);
 }
 
 void Catalog::dropTableSchema(table_id_t tableID) {
     initCatalogContentForWriteTrxIfNecessary();
-    catalogContentForWriteTrx->dropTableSchema(tableID);
-    wal->logDropTableRecord(tableID);
+    auto tableSchema = catalogContentForWriteTrx->getTableSchema(tableID);
+    switch (tableSchema->tableType) {
+    case TableType::REL_GROUP: {
+        auto relTableGroupSchema = reinterpret_cast<RelTableGroupSchema*>(tableSchema);
+        auto relTableIDs = relTableGroupSchema->getRelTableIDs();
+        catalogContentForWriteTrx->dropTableSchema(tableID);
+        for (auto relTableID : relTableIDs) {
+            wal->logDropTableRecord(relTableID);
+        }
+    } break;
+    default: {
+        catalogContentForWriteTrx->dropTableSchema(tableID);
+        wal->logDropTableRecord(tableID);
+    }
+    }
 }
 
 void Catalog::renameTable(table_id_t tableID, const std::string& newName) {

src/catalog/catalog_content.cpp

@@ -130,8 +130,18 @@ std::vector<TableSchema*> CatalogContent::getTableSchemas(
 }
 
 void CatalogContent::dropTableSchema(table_id_t tableID) {
-    auto tableName = getTableName(tableID);
-    tableNameToIDMap.erase(tableName);
+    auto tableSchema = getTableSchema(tableID);
+    switch (tableSchema->tableType) {
+    case common::TableType::REL_GROUP: {
+        auto relTableGroupSchema = reinterpret_cast<RelTableGroupSchema*>(tableSchema);
+        for (auto& relTableID : relTableGroupSchema->getRelTableIDs()) {
+            dropTableSchema(relTableID);
+        }
+    } break;
+    default:
+        break;
+    }
+    tableNameToIDMap.erase(tableSchema->tableName);
     tableSchemas.erase(tableID);
 }
 

src/common/CMakeLists.txt

@@ -20,6 +20,7 @@ add_library(kuzu_common
         type_utils.cpp
         utils.cpp
         string_utils.cpp
+        table_type.cpp
         ser_deser.cpp)
 
 target_link_libraries(kuzu_common Glob)

src/common/table_type.cpp

@@ -0,0 +1,31 @@
+#include "common/table_type.h"
+
+#include "common/exception/not_implemented.h"
+
+namespace kuzu {
+namespace common {
+
+std::string TableTypeUtils::toString(TableType tableType) {
+    switch (tableType) {
+    case TableType::UNKNOWN: {
+        return "UNKNOWN";
+    }
+    case TableType::NODE: {
+        return "NODE";
+    }
+    case TableType::REL: {
+        return "REL";
+    }
+    case TableType::RDF: {
+        return "RDF";
+    }
+    case TableType::REL_GROUP: {
+        return "REL_GROUP";
+    }
+    default:                                                       // LCOV_EXCL_START
+        throw NotImplementedException("TableTypeUtils::toString"); // LCOV_EXCL_STOP
+    }
+}
+
+} // namespace common
+} // namespace kuzu

src/function/table_functions.cpp

@@ -104,22 +104,7 @@ void ShowTablesFunction::tableFunc(std::pair<offset_t, offset_t> morsel,
     for (auto i = 0u; i < numTablesToOutput; i++) {
         auto tableSchema = tables[morsel.first + i];
         outputVectors[0]->setValue(i, tableSchema->tableName);
-
-        std::string typeString;
-        switch (tableSchema->tableType) {
-        case TableType::NODE: {
-            typeString = "NODE";
-        } break;
-        case TableType::REL: {
-            typeString = "REL";
-        } break;
-        case TableType::RDF: {
-            typeString = "RDF";
-        } break;
-        default: {
-            throw common::NotImplementedException{"ShowTablesFunction::tableFunc"};
-        }
-        };
+        std::string typeString = TableTypeUtils::toString(tableSchema->tableType);
         outputVectors[1]->setValue(i, typeString);
         outputVectors[2]->setValue(i, tableSchema->comment);
     }

src/include/binder/binder.h

@@ -255,11 +255,6 @@ class Binder {
 
     void validateTableType(common::table_id_t tableID, common::TableType expectedTableType);
     void validateTableExist(const std::string& tableName);
-    // TODO(Xiyang): remove this validation once we refactor DDL.
-    void validateNodeRelTableExist(const std::string& tableName);
-
-    static void validateNodeTableHasNoEdge(
-        const catalog::Catalog& _catalog, common::table_id_t tableID);
 
     /*** helpers ***/
     std::string getUniqueExpressionName(const std::string& name);

src/include/catalog/catalog_content.h

@@ -76,6 +76,9 @@ class CatalogContent {
     inline std::vector<TableSchema*> getRelTableSchemas() const {
         return getTableSchemas(common::TableType::REL);
     }
+    inline std::vector<TableSchema*> getRelTableGroupSchemas() const {
+        return getTableSchemas(common::TableType::REL_GROUP);
+    }
 
     std::vector<TableSchema*> getTableSchemas() const;
     std::vector<TableSchema*> getTableSchemas(

src/include/common/table_type.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 
 namespace kuzu {
 namespace common {
@@ -13,5 +14,9 @@ enum class TableType : uint8_t {
     REL_GROUP = 4,
 };
 
+struct TableTypeUtils {
+    static std::string toString(TableType tableType);
+};
+
 } // namespace common
 } // namespace kuzu

src/include/storage/wal/wal.h

@@ -103,8 +103,6 @@ class WAL : public BaseWALAndWALIterator {
 
     void logNodeTableRecord(common::table_id_t tableID);
     void logRelTableRecord(common::table_id_t tableID);
-    void logRelTableGroupRecord(
-        common::table_id_t tableID, std::vector<common::table_id_t> relTableIDs);
     void logRdfGraphRecord(common::table_id_t rdfGraphID, common::table_id_t nodeTableID,
         common::table_id_t relTableID);
 

src/include/storage/wal/wal_record.h

@@ -331,17 +331,6 @@ struct RelTableRecord {
     inline bool operator==(const RelTableRecord& rhs) const { return tableID == rhs.tableID; }
 };
 
-struct RelTableGroupRecord {
-    common::table_id_t tableID;
-    // TODO(Ziyi): add this back when we can serialize variable size record.
-    //    std::vector<RelTableRecord> relTableRecords;
-
-    RelTableGroupRecord() = default;
-    RelTableGroupRecord(common::table_id_t tableID) : tableID{tableID} {}
-
-    bool operator==(const RelTableGroupRecord& other) const;
-};
-
 struct RdfGraphRecord {
     common::table_id_t tableID;
     NodeTableRecord nodeTableRecord;
@@ -456,7 +445,6 @@ struct WALRecord {
         CommitRecord commitRecord;
         NodeTableRecord nodeTableRecord;
         RelTableRecord relTableRecord;
-        RelTableGroupRecord relTableGroupRecord;
         RdfGraphRecord rdfGraphRecord;
         DiskOverflowFileNextBytePosRecord diskOverflowFileNextBytePosRecord;
         CopyNodeRecord copyNodeRecord;
@@ -491,9 +479,6 @@ struct WALRecord {
         case WALRecordType::REL_TABLE_RECORD: {
             return relTableRecord == rhs.relTableRecord;
         }
-        case WALRecordType::REL_TABLE_GROUP_RECORD: {
-            return relTableGroupRecord == rhs.relTableGroupRecord;
-        }
         case WALRecordType::RDF_GRAPH_RECORD: {
             return rdfGraphRecord == rhs.rdfGraphRecord;
         }
@@ -531,8 +516,6 @@ struct WALRecord {
     static WALRecord newCatalogRecord();
     static WALRecord newNodeTableRecord(common::table_id_t tableID);
     static WALRecord newRelTableRecord(common::table_id_t tableID);
-    static WALRecord newRelTableGroupRecord(
-        common::table_id_t tableID, std::vector<common::table_id_t> relTableIDs);
     static WALRecord newRdfGraphRecord(common::table_id_t rdfGraphID,
         common::table_id_t nodeTableID, common::table_id_t relTableID);
     static WALRecord newOverflowFileNextBytePosRecord(

src/include/storage/wal_replayer.h

@@ -33,7 +33,6 @@ class WALReplayer {
     void replayNodeTableRecord(const WALRecord& walRecord);
     // TODO(Guodong/Ziyi) : fix this
     void replayRelTableRecord(const WALRecord& walRecord, bool isRdf = false);
-    void replayRelTableGroupRecord(const WALRecord& walRecord);
     void replayRdfGraphRecord(const WALRecord& walRecord);
     void replayOverflowFileNextBytePosRecord(const WALRecord& walRecord);
     void replayCopyNodeRecord(const WALRecord& walRecord);