lbug 0.12.3-dev.2 → 0.12.3-dev.21

package/lbug-source/test/test_helper/test_helper.cpp

@@ -32,6 +32,7 @@ void TestHelper::executeScript(const std::string& cypherScript, Connection& conn
         std::cout << "cypherScript: " << cypherScript << " doesn't exist. Skipping..." << std::endl;
         return;
     }
+    auto cypherDir = std::filesystem::path(cypherScript).parent_path();
     std::ifstream file(cypherScript);
     if (!file.is_open()) {
         throw Exception(stringFormat("Error opening file: {}, errno: {}.", cypherScript, errno));
@@ -68,9 +69,40 @@ void TestHelper::executeScript(const std::string& cypherScript, Connection& conn
             index = end + 1;
         }
         for (auto& csvFilePath : csvFilePaths) {
-            auto fullPath = appendLbugRootPath(csvFilePath);
+            std::string fullPath = csvFilePath;
+            if (std::filesystem::path(csvFilePath).is_relative()) {
+                if (std::filesystem::path(csvFilePath).parent_path().empty()) {
+                    fullPath = (cypherDir / csvFilePath).string();
+                } else {
+                    fullPath = appendLbugRootPath(csvFilePath);
+                }
+            }
             line.replace(line.find(csvFilePath), csvFilePath.length(), fullPath);
         }
+        // Also handle storage = 'path' for parquet tables
+        std::vector<std::string> storagePaths;
+        size_t storageIndex = 0;
+        while (true) {
+            size_t start = line.find("storage = '", storageIndex);
+            if (start == std::string::npos) {
+                break;
+            }
+            start += 11; // length of "storage = '"
+            size_t end = line.find("'", start);
+            if (end == std::string::npos) {
+                break;
+            }
+            std::string storagePath = line.substr(start, end - start);
+            storagePaths.push_back(storagePath);
+            storageIndex = end + 1;
+        }
+        for (auto& storagePath : storagePaths) {
+            auto fullPath = appendLbugRootPath(storagePath);
+            size_t pos = line.find(storagePath);
+            if (pos != std::string::npos) {
+                line.replace(pos, storagePath.length(), fullPath);
+            }
+        }
 #ifdef __STATIC_LINK_EXTENSION_TEST__
         if (line.starts_with("load extension")) {
             continue;

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/test_runner/test_parser.cpp

@@ -87,6 +87,9 @@ void TestParser::extractDataset() {
             testGroup->datasetType = TestGroup::DatasetType::JSON;
             testGroup->dataset = currentToken.params[2];
         }
+    } else if (datasetType == "GRAPH-STD") {
+        testGroup->datasetType = TestGroup::DatasetType::GRAPH_STD;
+        testGroup->dataset = currentToken.params[2];
     } else {
         throw TestException(
             "Invalid dataset type `" + currentToken.params[1] + "` [" + path + ":" + line + "].");

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());
     }