lbug 0.12.3-dev.13 → 0.12.3-dev.15

package/lbug-source/src/planner/operator/scan/logical_count_rel_table.cpp

@@ -0,0 +1,24 @@
+#include "planner/operator/scan/logical_count_rel_table.h"
+
+namespace lbug {
+namespace planner {
+
+void LogicalCountRelTable::computeFactorizedSchema() {
+    createEmptySchema();
+    // Only output the count expression in a single-state group.
+    // This operator is a source - it has no child in the logical plan.
+    // The bound node is used internally for scanning but not exposed.
+    auto groupPos = schema->createGroup();
+    schema->insertToGroupAndScope(countExpr, groupPos);
+    schema->setGroupAsSingleState(groupPos);
+}
+
+void LogicalCountRelTable::computeFlatSchema() {
+    createEmptySchema();
+    // For flat schema, create a single group with the count expression.
+    auto groupPos = schema->createGroup();
+    schema->insertToGroupAndScope(countExpr, groupPos);
+}
+
+} // namespace planner
+} // namespace lbug

package/lbug-source/src/processor/map/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(lbug_processor_mapper
         map_acc_hash_join.cpp
         map_accumulate.cpp
         map_aggregate.cpp
+        map_count_rel_table.cpp
         map_standalone_call.cpp
         map_table_function_call.cpp
         map_copy_to.cpp

package/lbug-source/src/processor/map/map_count_rel_table.cpp

@@ -0,0 +1,55 @@
+#include "planner/operator/scan/logical_count_rel_table.h"
+#include "processor/operator/scan/count_rel_table.h"
+#include "processor/plan_mapper.h"
+#include "storage/storage_manager.h"
+
+using namespace lbug::common;
+using namespace lbug::planner;
+using namespace lbug::storage;
+
+namespace lbug {
+namespace processor {
+
+std::unique_ptr<PhysicalOperator> PlanMapper::mapCountRelTable(
+    const LogicalOperator* logicalOperator) {
+    auto& logicalCountRelTable = logicalOperator->constCast<LogicalCountRelTable>();
+    auto outSchema = logicalCountRelTable.getSchema();
+
+    auto storageManager = StorageManager::Get(*clientContext);
+
+    // Get the node tables for scanning bound nodes
+    std::vector<NodeTable*> nodeTables;
+    for (auto tableID : logicalCountRelTable.getBoundNodeTableIDs()) {
+        nodeTables.push_back(storageManager->getTable(tableID)->ptrCast<NodeTable>());
+    }
+
+    // Get the rel tables
+    std::vector<RelTable*> relTables;
+    for (auto tableID : logicalCountRelTable.getRelTableIDs()) {
+        relTables.push_back(storageManager->getTable(tableID)->ptrCast<RelTable>());
+    }
+
+    // Determine rel data direction from extend direction
+    auto extendDirection = logicalCountRelTable.getDirection();
+    RelDataDirection relDirection;
+    if (extendDirection == ExtendDirection::FWD) {
+        relDirection = RelDataDirection::FWD;
+    } else if (extendDirection == ExtendDirection::BWD) {
+        relDirection = RelDataDirection::BWD;
+    } else {
+        // For BOTH, we'll scan FWD (shouldn't reach here as optimizer filters BOTH)
+        relDirection = RelDataDirection::FWD;
+    }
+
+    // Get the output position for the count expression
+    auto countOutputPos = getDataPos(*logicalCountRelTable.getCountExpr(), *outSchema);
+
+    auto printInfo = std::make_unique<CountRelTablePrintInfo>(
+        logicalCountRelTable.getRelGroupEntry()->getName());
+
+    return std::make_unique<CountRelTable>(std::move(nodeTables), std::move(relTables),
+        relDirection, countOutputPos, getOperatorID(), std::move(printInfo));
+}
+
+} // namespace processor
+} // namespace lbug

package/lbug-source/src/processor/map/plan_mapper.cpp

@@ -62,6 +62,9 @@ std::unique_ptr<PhysicalOperator> PlanMapper::mapOperator(const LogicalOperator*
     case LogicalOperatorType::COPY_TO: {
         physicalOperator = mapCopyTo(logicalOperator);
     } break;
+    case LogicalOperatorType::COUNT_REL_TABLE: {
+        physicalOperator = mapCountRelTable(logicalOperator);
+    } break;
     case LogicalOperatorType::CREATE_MACRO: {
         physicalOperator = mapCreateMacro(logicalOperator);
     } break;

package/lbug-source/src/processor/operator/physical_operator.cpp

@@ -27,6 +27,8 @@ std::string PhysicalOperatorUtils::operatorTypeToString(PhysicalOperatorType ope
         return "BATCH_INSERT";
     case PhysicalOperatorType::COPY_TO:
         return "COPY_TO";
+    case PhysicalOperatorType::COUNT_REL_TABLE:
+        return "COUNT_REL_TABLE";
     case PhysicalOperatorType::CREATE_MACRO:
         return "CREATE_MACRO";
     case PhysicalOperatorType::CREATE_SEQUENCE:

package/lbug-source/src/processor/operator/scan/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(lbug_processor_operator_scan
         OBJECT
+        count_rel_table.cpp
         primary_key_scan_node_table.cpp
         scan_multi_rel_tables.cpp
         scan_node_table.cpp

package/lbug-source/src/processor/operator/scan/count_rel_table.cpp

@@ -0,0 +1,137 @@
+#include "processor/operator/scan/count_rel_table.h"
+
+#include "common/system_config.h"
+#include "main/client_context.h"
+#include "main/database.h"
+#include "processor/execution_context.h"
+#include "storage/buffer_manager/memory_manager.h"
+#include "storage/local_storage/local_rel_table.h"
+#include "storage/local_storage/local_storage.h"
+#include "storage/table/column.h"
+#include "storage/table/column_chunk_data.h"
+#include "storage/table/csr_chunked_node_group.h"
+#include "storage/table/csr_node_group.h"
+#include "storage/table/rel_table_data.h"
+#include "transaction/transaction.h"
+
+using namespace lbug::common;
+using namespace lbug::storage;
+using namespace lbug::transaction;
+
+namespace lbug {
+namespace processor {
+
+void CountRelTable::initLocalStateInternal(ResultSet* resultSet, ExecutionContext* /*context*/) {
+    countVector = resultSet->getValueVector(countOutputPos).get();
+    hasExecuted = false;
+    totalCount = 0;
+}
+
+// Count rels by using CSR metadata, accounting for deletions and uncommitted data.
+// This is more efficient than scanning through all edges.
+bool CountRelTable::getNextTuplesInternal(ExecutionContext* context) {
+    if (hasExecuted) {
+        return false;
+    }
+
+    auto transaction = Transaction::Get(*context->clientContext);
+    auto* memoryManager = context->clientContext->getDatabase()->getMemoryManager();
+
+    for (auto* relTable : relTables) {
+        // Get the RelTableData for the specified direction
+        auto* relTableData = relTable->getDirectedTableData(direction);
+        auto numNodeGroups = relTableData->getNumNodeGroups();
+        auto* csrLengthColumn = relTableData->getCSRLengthColumn();
+
+        // For each node group in the rel table
+        for (node_group_idx_t nodeGroupIdx = 0; nodeGroupIdx < numNodeGroups; nodeGroupIdx++) {
+            auto* nodeGroup = relTableData->getNodeGroup(nodeGroupIdx);
+            if (!nodeGroup) {
+                continue;
+            }
+
+            auto& csrNodeGroup = nodeGroup->cast<CSRNodeGroup>();
+
+            // Count from persistent (checkpointed) data
+            if (auto* persistentGroup = csrNodeGroup.getPersistentChunkedGroup()) {
+                // Sum the actual relationship lengths from the CSR header instead of using
+                // getNumRows() which includes dummy rows added for CSR offset array gaps
+                auto& csrPersistentGroup = persistentGroup->cast<ChunkedCSRNodeGroup>();
+                auto& csrHeader = csrPersistentGroup.getCSRHeader();
+
+                // Get the number of nodes in this CSR header
+                auto numNodes = csrHeader.length->getNumValues();
+                if (numNodes == 0) {
+                    continue;
+                }
+
+                // Create an in-memory chunk to scan the CSR length column into
+                auto lengthChunk =
+                    ColumnChunkFactory::createColumnChunkData(*memoryManager, LogicalType::UINT64(),
+                        false /*enableCompression*/, StorageConfig::NODE_GROUP_SIZE,
+                        ResidencyState::IN_MEMORY, false /*initializeToZero*/);
+
+                // Initialize scan state and scan the length column from disk
+                ChunkState chunkState;
+                csrHeader.length->initializeScanState(chunkState, csrLengthColumn);
+                csrLengthColumn->scan(chunkState, lengthChunk.get(), 0 /*offsetInChunk*/, numNodes);
+
+                // Sum all the lengths
+                auto* lengthData = reinterpret_cast<const uint64_t*>(lengthChunk->getData());
+                row_idx_t groupRelCount = 0;
+                for (offset_t i = 0; i < numNodes; ++i) {
+                    groupRelCount += lengthData[i];
+                }
+                totalCount += groupRelCount;
+
+                // Subtract deletions from persistent data
+                if (persistentGroup->hasVersionInfo()) {
+                    auto numDeletions =
+                        persistentGroup->getNumDeletions(transaction, 0, groupRelCount);
+                    totalCount -= numDeletions;
+                }
+            }
+
+            // Count in-memory committed data (not yet checkpointed)
+            // This data is stored in chunkedGroups within the NodeGroup
+            auto numChunkedGroups = csrNodeGroup.getNumChunkedGroups();
+            for (node_group_idx_t i = 0; i < numChunkedGroups; i++) {
+                auto* chunkedGroup = csrNodeGroup.getChunkedNodeGroup(i);
+                if (chunkedGroup) {
+                    auto numRows = chunkedGroup->getNumRows();
+                    totalCount += numRows;
+                    // Subtract deletions from in-memory committed data
+                    if (chunkedGroup->hasVersionInfo()) {
+                        auto numDeletions = chunkedGroup->getNumDeletions(transaction, 0, numRows);
+                        totalCount -= numDeletions;
+                    }
+                }
+            }
+        }
+
+        // Add uncommitted insertions from local storage
+        if (transaction->isWriteTransaction()) {
+            if (auto* localTable =
+                    transaction->getLocalStorage()->getLocalTable(relTable->getTableID())) {
+                auto& localRelTable = localTable->cast<LocalRelTable>();
+                // Count entries in the CSR index for this direction.
+                // We can't use getNumTotalRows() because it includes deleted rows.
+                auto& csrIndex = localRelTable.getCSRIndex(direction);
+                for (const auto& [nodeOffset, rowIndices] : csrIndex) {
+                    totalCount += rowIndices.size();
+                }
+            }
+        }
+    }
+
+    hasExecuted = true;
+
+    // Write the count to the output vector (single value)
+    countVector->state->getSelVectorUnsafe().setToUnfiltered(1);
+    countVector->setValue<int64_t>(0, static_cast<int64_t>(totalCount));
+
+    return true;
+}
+
+} // namespace processor
+} // namespace lbug

package/lbug-source/test/common/string_format.cpp

@@ -10,6 +10,7 @@ TEST(StringFormat, Basic) {
         "Some formatted data: a and 423");
 }
 
+#if !USE_STD_FORMAT
 TEST(StringFormat, Escape) {
     ASSERT_EQ(stringFormat("Escape this {{}} but not this {{ }}"),
         "Escape this {} but not this {{ }}");
@@ -29,6 +30,7 @@ TEST(StringFormat, TooManyArguments) {
 TEST(StringFormat, TooFewArguments) {
     ASSERT_THROW(stringFormat("Format with arguments {}"), InternalException);
 }
+#endif
 
 TEST(StringFormat, Format8BitTypes) {
     enum TestEnum : uint8_t {
@@ -38,7 +40,9 @@ TEST(StringFormat, Format8BitTypes) {
     char literal_character = 'a';
     TestEnum enum_val = TestEnum::NO;
     int8_t signed_int8 = 4;
-    ASSERT_EQ(stringFormat("{} {} {}", literal_character, enum_val, signed_int8), "a 1 4");
+    ASSERT_EQ(
+        stringFormat("{} {} {}", literal_character, static_cast<uint8_t>(enum_val), signed_int8),
+        "a 1 4");
 }
 
 TEST(StringFormat, FormatString) {
@@ -64,5 +68,9 @@ TEST(StringFormat, FormatIntegers) {
 TEST(StringFormat, FormatFloats) {
     float a = 2.3;
     double b = 5.4;
+#if USE_STD_FORMAT
+    ASSERT_EQ(stringFormat("{} {}", a, b), "2.3 5.4");
+#else
     ASSERT_EQ(stringFormat("{} {}", a, b), "2.300000 5.400000");
+#endif
 }

package/lbug-source/test/copy/copy_test.cpp

@@ -280,7 +280,7 @@ TEST_F(CopyTest, NodeInsertBMExceptionDuringCommitRecovery) {
         .executeFunc =
             [](main::Connection* conn, int) {
                 const auto queryString = common::stringFormat(
-                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {ID:i})", numValues);
+                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {{ID:i}})", numValues);
                 return conn->query(queryString);
             },
         .earlyExitOnFailureFunc = [](main::QueryResult*) { return false; },
@@ -300,7 +300,7 @@ TEST_F(CopyTest, RelInsertBMExceptionDuringCommitRecovery) {
                 conn->query("CREATE NODE TABLE account(ID INT64, PRIMARY KEY(ID))");
                 conn->query("CREATE REL TABLE follows(FROM account TO account);");
                 const auto queryString = common::stringFormat(
-                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {ID:i})", numNodes);
+                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {{ID:i}})", numNodes);
                 ASSERT_TRUE(conn->query(queryString)->isSuccess());
                 failureFrequency = 32;
             },
@@ -309,7 +309,7 @@ TEST_F(CopyTest, RelInsertBMExceptionDuringCommitRecovery) {
                 return conn->query(common::stringFormat(
                     "UNWIND RANGE(1,{}) AS i MATCH (a:account), (b:account) WHERE a.ID = i AND "
                     "b.ID = i + 1 CREATE (a)-[f:follows]->(b)",
-                    numNodes));
+                    numNodes - 1));
             },
         .earlyExitOnFailureFunc = [](main::QueryResult*) { return false; },
         .checkFunc =
@@ -407,7 +407,7 @@ TEST_F(CopyTest, NodeInsertBMExceptionDuringCheckpointRecovery) {
         .executeFunc =
             [](main::Connection* conn, int) {
                 return conn->query(common::stringFormat(
-                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {ID:i})", numValues));
+                    "UNWIND RANGE(1,{}) AS i CREATE (a:account {{ID:i}})", numValues));
             },
         .earlyExitOnFailureFunc = [](main::QueryResult*) { return true; },
         .checkFunc =

package/lbug-source/test/graph_test/CMakeLists.txt

@@ -8,7 +8,7 @@ target_include_directories(
         PUBLIC
         ../include/
 )
-target_link_libraries(graph_test PUBLIC GTEST_LIB lbug)
+target_link_libraries(graph_test PUBLIC GTEST_LIB lbug_shared)
 
 add_library(
         api_graph_test

package/lbug-source/test/optimizer/optimizer_test.cpp

@@ -1,5 +1,6 @@
 #include "graph_test/private_graph_test.h"
 #include "planner/operator/logical_plan_util.h"
+#include "planner/operator/scan/logical_count_rel_table.h"
 #include "test_runner/test_runner.h"
 
 namespace lbug {
@@ -17,6 +18,19 @@ public:
     std::unique_ptr<planner::LogicalPlan> getRoot(const std::string& query) {
         return TestRunner::getLogicalPlan(query, *conn);
     }
+
+    // Helper to check if a specific operator type exists in the plan
+    static bool hasOperatorType(planner::LogicalOperator* op, planner::LogicalOperatorType type) {
+        if (op->getOperatorType() == type) {
+            return true;
+        }
+        for (auto i = 0u; i < op->getNumChildren(); ++i) {
+            if (hasOperatorType(op->getChild(i).get(), type)) {
+                return true;
+            }
+        }
+        return false;
+    }
 };
 
 TEST_F(OptimizerTest, JoinHint) {
@@ -211,5 +225,37 @@ TEST_F(OptimizerTest, SubqueryHint) {
     ASSERT_STREQ(getEncodedPlan(q6).c_str(), "Filter()HJ(a._ID){S(a)}{E(a)Filter()S(b)}");
 }
 
+TEST_F(OptimizerTest, CountRelTableOptimizer) {
+    // Test that COUNT(*) over a single rel table is optimized to COUNT_REL_TABLE
+    auto q1 = "MATCH (a:person)-[e:knows]->(b:person) RETURN COUNT(*);";
+    auto plan1 = getRoot(q1);
+    ASSERT_TRUE(hasOperatorType(plan1->getLastOperator().get(),
+        planner::LogicalOperatorType::COUNT_REL_TABLE));
+    // Verify the query returns the correct result
+    auto result1 = conn->query(q1);
+    ASSERT_TRUE(result1->isSuccess());
+    ASSERT_EQ(result1->getNumTuples(), 1);
+    auto tuple1 = result1->getNext();
+    ASSERT_EQ(tuple1->getValue(0)->getValue<int64_t>(), 14);
+
+    // Test that COUNT(*) with GROUP BY is NOT optimized (has keys)
+    auto q2 = "MATCH (a:person)-[e:knows]->(b:person) RETURN a.fName, COUNT(*);";
+    auto plan2 = getRoot(q2);
+    ASSERT_FALSE(hasOperatorType(plan2->getLastOperator().get(),
+        planner::LogicalOperatorType::COUNT_REL_TABLE));
+
+    // Test that COUNT(*) with WHERE clause is NOT optimized (has filter)
+    auto q3 = "MATCH (a:person)-[e:knows]->(b:person) WHERE a.ID > 0 RETURN COUNT(*);";
+    auto plan3 = getRoot(q3);
+    ASSERT_FALSE(hasOperatorType(plan3->getLastOperator().get(),
+        planner::LogicalOperatorType::COUNT_REL_TABLE));
+
+    // Test that COUNT(DISTINCT ...) is NOT optimized
+    auto q4 = "MATCH (a:person)-[e:knows]->(b:person) RETURN COUNT(DISTINCT a);";
+    auto plan4 = getRoot(q4);
+    ASSERT_FALSE(hasOperatorType(plan4->getLastOperator().get(),
+        planner::LogicalOperatorType::COUNT_REL_TABLE));
+}
+
 } // namespace testing
 } // namespace lbug

package/lbug-source/test/test_helper/CMakeLists.txt

@@ -8,7 +8,7 @@ target_include_directories(
         PUBLIC
         ../include/
 )
-target_link_libraries(test_helper PUBLIC lbug)
+target_link_libraries(test_helper PUBLIC lbug_shared)
 
 add_library(
         api_test_helper

package/lbug-source/test/test_runner/CMakeLists.txt

@@ -15,4 +15,4 @@ target_include_directories(
         ../include/
 )
 
-target_link_libraries(test_runner PUBLIC GTEST_LIB lbug)
+target_link_libraries(test_runner PUBLIC GTEST_LIB lbug_shared)

package/lbug-source/test/test_runner/insert_by_row.cpp

@@ -111,23 +111,21 @@ std::string InsertDatasetByRow::TableInfo::getBodyForLoad() const {
 }
 
 std::string InsertDatasetByRow::NodeTableInfo::getLoadFromQuery() const {
-    const std::string query = "LOAD WITH HEADERS ({}) FROM {} "
-                              "CREATE (:{} {});";
     const auto header = getHeaderForLoad();
     const auto body = getBodyForLoad();
-    return stringFormat(query, header, filePath, name, "{" + body + "}");
+    return stringFormat("LOAD WITH HEADERS ({}) FROM {} CREATE (:{} {{{}}});", header, filePath,
+        name, body);
 }
 
 std::string InsertDatasetByRow::RelTableInfo::getLoadFromQuery() const {
-    const std::string query = "LOAD WITH HEADERS ({}) FROM {} "
-                              "MATCH (a:{}), (b:{}) WHERE a.{} = aid_ AND b.{} = bid_ "
-                              "CREATE (a)-[:{} {}]->(b);";
     auto header = stringFormat("aid_ {},bid_ {}", from.type, to.type);
     auto headerRest = getHeaderForLoad();
     header += headerRest.length() == 0 ? "" : "," + getHeaderForLoad();
     const auto body = getBodyForLoad();
-    return stringFormat(query, header, filePath, from.name, to.name, from.property, to.property,
-        name, "{" + body + "}");
+    return stringFormat("LOAD WITH HEADERS ({}) FROM {} "
+                        "MATCH (a:{}), (b:{}) WHERE a.{} = aid_ AND b.{} = bid_ "
+                        "CREATE (a)-[:{} {{{}}}]->(b);",
+        header, filePath, from.name, to.name, from.property, to.property, name, body);
 }
 
 } // namespace testing

package/lbug-source/test/test_runner/multi_copy_split.cpp

@@ -62,8 +62,7 @@ void SplitMultiCopyRandom::init() {
 
     const std::string tmpDir = TestHelper::getTempDir("multi_copy");
     auto totalFilePath = TestHelper::joinPath(tmpDir, tableName + ".csv");
-    std::string loadQuery = "COPY (LOAD FROM {} RETURN *) TO '{}';";
-    loadQuery = stringFormat(loadQuery, source, totalFilePath);
+    auto loadQuery = stringFormat("COPY (LOAD FROM {} RETURN *) TO '{}';", source, totalFilePath);
     spdlog::info("QUERY: {}", loadQuery);
     validateQuery(connection, loadQuery);
 
@@ -96,9 +95,8 @@ void SplitMultiCopyRandom::init() {
 }
 
 void SplitMultiCopyRandom::run() {
-    const std::string query = "COPY {} FROM \"{}\";";
     for (auto file : splitFilePaths) {
-        auto currQuery = stringFormat(query, tableName, file);
+        auto currQuery = stringFormat("COPY {} FROM \"{}\";", tableName, file);
         spdlog::info("QUERY: {}", currQuery);
         validateQuery(connection, currQuery);
     }

package/lbug-source/test/transaction/checkpoint_test.cpp

@@ -37,7 +37,7 @@ public:
         conn->query("CALL auto_checkpoint=false");
         conn->query("CREATE NODE TABLE test(id INT64 PRIMARY KEY, name STRING);");
         for (auto i = 0; i < 5000; i++) {
-            conn->query(stringFormat("CREATE (a:test {id: {}, name: 'name_{}'});", i, i));
+            conn->query(stringFormat("CREATE (a:test {{id: {}, name: 'name_{}'}});", i, i));
         }
         auto context = getClientContext(*conn);
         flakyCheckpointer.setCheckpointer(*context);

package/lbug-source/test/transaction/transaction_test.cpp

@@ -138,7 +138,8 @@ static void insertNodes(uint64_t startID, uint64_t num, lbug::main::Database& da
     auto conn = std::make_unique<lbug::main::Connection>(&database);
     for (uint64_t i = 0; i < num; ++i) {
         auto id = startID + i;
-        auto res = conn->query(stringFormat("CREATE (:test {id: {}, name: 'Person{}'});", id, id));
+        auto res =
+            conn->query(stringFormat("CREATE (:test {{id: {}, name: 'Person{}'}});", id, id));
         ASSERT_TRUE(res->isSuccess())
             << "Failed to insert test" << id << ": " << res->getErrorMessage();
     }
@@ -181,7 +182,7 @@ static void insertNodesWithMixedTypes(uint64_t startID, uint64_t num,
         auto score = 95.5 + (id % 10);
         auto isActive = (id % 2 == 0) ? "true" : "false";
         auto res = conn->query(
-            stringFormat("CREATE (:mixed_test {id: {}, score: {}, active: {}, name: 'User{}'});",
+            stringFormat("CREATE (:mixed_test {{id: {}, score: {}, active: {}, name: 'User{}'}});",
                 id, score, isActive, id));
         ASSERT_TRUE(res->isSuccess())
             << "Failed to insert mixed_test" << id << ": " << res->getErrorMessage();
@@ -227,7 +228,7 @@ static void insertRelationships(uint64_t startID, uint64_t num, lbug::main::Data
         auto toID = (startID + i + 1) % (num * 4);
         auto weight = 1.0 + (i % 10) * 0.1;
         auto res = conn->query(stringFormat("MATCH (a:person), (b:person) WHERE a.id = {} AND b.id "
-                                            "= {} CREATE (a)-[:knows {weight: {}}]->(b);",
+                                            "= {} CREATE (a)-[:knows {{weight: {}}}]->(b);",
             fromID, toID, weight));
         ASSERT_TRUE(res->isSuccess()) << "Failed to insert relationship from " << fromID << " to "
                                       << toID << ": " << res->getErrorMessage();
@@ -248,7 +249,8 @@ TEST_F(EmptyDBTransactionTest, ConcurrentRelationshipInsertions) {
 
     conn->query("BEGIN TRANSACTION;");
     for (auto i = 0; i < numTotalInsertions; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:person {id: {}, name: 'Person{}'});", i, i));
+        auto res =
+            conn->query(stringFormat("CREATE (:person {{id: {}, name: 'Person{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
     conn->query("COMMIT;");
@@ -286,7 +288,7 @@ static void insertComplexRelationships(uint64_t startID, uint64_t num,
         auto isVerified = (i % 3 == 0) ? "true" : "false";
         auto res =
             conn->query(stringFormat("MATCH (u:user), (p:product) WHERE u.id = {} AND p.id = {} "
-                                     "CREATE (u)-[:rates {rating: {}, verified: {}}]->(p);",
+                                     "CREATE (u)-[:rates {{rating: {}, verified: {}}}]->(p);",
                 userID, productID, rating, isVerified));
         ASSERT_TRUE(res->isSuccess())
             << "Failed to insert rating from user " << userID << " to product " << productID << ": "
@@ -309,12 +311,12 @@ TEST_F(EmptyDBTransactionTest, ConcurrentComplexRelationshipInsertions) {
 
     conn->query("BEGIN TRANSACTION;");
     for (auto i = 0; i < numTotalInsertions; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:user {id: {}, name: 'User{}'});", i, i));
+        auto res = conn->query(stringFormat("CREATE (:user {{id: {}, name: 'User{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
     for (auto i = 0; i < numTotalInsertions * 2; ++i) {
         auto res =
-            conn->query(stringFormat("CREATE (:product {id: {}, title: 'Product{}'});", i, i));
+            conn->query(stringFormat("CREATE (:product {{id: {}, title: 'Product{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
     conn->query("COMMIT;");
@@ -367,7 +369,7 @@ TEST_F(EmptyDBTransactionTest, ConcurrentNodeUpdates) {
 
     // First insert all nodes
     for (auto i = 0; i < numTotalNodes; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:test {id: {}, name: 'Person{}'});", i, i));
+        auto res = conn->query(stringFormat("CREATE (:test {{id: {}, name: 'Person{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
 
@@ -429,8 +431,8 @@ TEST_F(EmptyDBTransactionTest, ConcurrentMixedTypeUpdates) {
         auto score = 95.5 + (i % 10);
         auto isActive = (i % 2 == 0) ? "true" : "false";
         auto res = conn->query(
-            stringFormat("CREATE (:mixed_test {id: {}, score: {}, active: {}, name: 'User{}'});", i,
-                score, isActive, i));
+            stringFormat("CREATE (:mixed_test {{id: {}, score: {}, active: {}, name: 'User{}'}});",
+                i, score, isActive, i));
         ASSERT_TRUE(res->isSuccess());
     }
 
@@ -503,7 +505,8 @@ TEST_F(EmptyDBTransactionTest, ConcurrentRelationshipUpdates) {
 
     // Create nodes
     for (auto i = 0; i < numTotalUpdates; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:person {id: {}, name: 'Person{}'});", i, i));
+        auto res =
+            conn->query(stringFormat("CREATE (:person {{id: {}, name: 'Person{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
 
@@ -513,7 +516,7 @@ TEST_F(EmptyDBTransactionTest, ConcurrentRelationshipUpdates) {
         auto toID = (i + 1) % numTotalUpdates;
         auto weight = 1.0 + (i % 10) * 0.1;
         auto res = conn->query(stringFormat("MATCH (a:person), (b:person) WHERE a.id = {} AND b.id "
-                                            "= {} CREATE (a)-[:knows {weight: {}}]->(b);",
+                                            "= {} CREATE (a)-[:knows {{weight: {}}}]->(b);",
             fromID, toID, weight));
         ASSERT_TRUE(res->isSuccess());
     }
@@ -577,7 +580,7 @@ TEST_F(EmptyDBTransactionTest, ConcurrentNodeUpdatesWithMixedTransactions) {
 
     // Insert initial nodes
     for (auto i = 0; i < numTotalNodes; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:test {id: {}, name: 'Person{}'});", i, i));
+        auto res = conn->query(stringFormat("CREATE (:test {{id: {}, name: 'Person{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
 
@@ -650,7 +653,8 @@ TEST_F(EmptyDBTransactionTest, ConcurrentRelationshipUpdatesWithMixedTransaction
 
     // Create nodes
     for (auto i = 0; i < numTotalUpdates; ++i) {
-        auto res = conn->query(stringFormat("CREATE (:person {id: {}, name: 'Person{}'});", i, i));
+        auto res =
+            conn->query(stringFormat("CREATE (:person {{id: {}, name: 'Person{}'}});", i, i));
         ASSERT_TRUE(res->isSuccess());
     }
 
@@ -660,7 +664,7 @@ TEST_F(EmptyDBTransactionTest, ConcurrentRelationshipUpdatesWithMixedTransaction
         auto toID = i;
         auto weight = 20.0;
         auto res = conn->query(stringFormat("MATCH (a:person), (b:person) WHERE a.id = {} AND b.id "
-                                            "= {} CREATE (a)-[:knows {weight: {}}]->(b);",
+                                            "= {} CREATE (a)-[:knows {{weight: {}}}]->(b);",
             fromID, toID, weight));
         ASSERT_TRUE(res->isSuccess());
     }

package/lbug-source/tools/benchmark/count_rel_table.benchmark

@@ -0,0 +1,5 @@
+-NAME count_rel_table
+-PRERUN CREATE NODE TABLE account(ID INT64 PRIMARY KEY); CREATE REL TABLE follows(FROM account TO account); COPY account FROM "dataset/snap/amazon0601/parquet/amazon-nodes.parquet"; COPY follows FROM "dataset/snap/amazon0601/parquet/amazon-edges.parquet";
+-QUERY MATCH ()-[r:follows]->() RETURN COUNT(*)
+---- 1
+3387388

package/lbug-source/tools/shell/embedded_shell.cpp

@@ -543,6 +543,17 @@ std::vector<std::unique_ptr<QueryResult>> EmbeddedShell::processInput(std::strin
         historyLine = input;
         return queryResults;
     }
+    // Normalize trailing semicolons
+    if (!unicodeInput.empty() && unicodeInput.back() == ';') {
+        // trim trailing ;
+        while (!unicodeInput.empty() && unicodeInput.back() == ';') {
+            unicodeInput.pop_back();
+        }
+        if (unicodeInput.empty()) {
+            return queryResults;
+        }
+        unicodeInput += ';';
+    }
     // process shell commands
     if (!continueLine && unicodeInput[0] == ':') {
         processShellCommands(unicodeInput);

package/lbug-source/tools/shell/linenoise.cpp

@@ -3306,7 +3306,7 @@ bool cypherComplete(const char* z) {
         /* Token:           */
         /* State:       **  SEMI  WS  OTHER */
         /* 0 INVALID: */ {
-            1,
+            2,
             0,
             2,
         },
@@ -3553,8 +3553,8 @@ static int linenoiseEdit(int stdin_fd, int stdout_fd, char* buf, size_t buflen,
                 // check if this forms a complete Cypher statement or not or if enter is pressed in
                 // the middle of a line
                 l.buf[l.len] = '\0';
-                if (l.buf[0] != ':' &&
-                    (l.pos != l.len || linenoiseAllWhitespace(l.buf) || !cypherComplete(l.buf))) {
+                if (l.buf[0] != ':' && l.pos == l.len && !linenoiseAllWhitespace(l.buf) &&
+                    !cypherComplete(l.buf)) {
                     if (linenoiseEditInsertMulti(&l, "\r\n")) {
                         return -1;
                     }