Update Kuzu from branch (#55)

Co-authored-by: mewim <14037726+mewim@users.noreply.github.com>

Author: github-actions[bot]

Package.swift

@@ -385,6 +385,7 @@ let package = Package(
                 "kuzu/src/function/pattern/start_end_node_function.cpp",
                 "kuzu/src/function/scalar_macro_function.cpp",
                 "kuzu/src/function/sequence/sequence_functions.cpp",
+                "kuzu/src/function/string/concat_ws.cpp",
                 "kuzu/src/function/string/init_cap_function.cpp",
                 "kuzu/src/function/string/levenshtein_function.cpp",
                 "kuzu/src/function/string/regex_full_match_function.cpp",
@@ -773,6 +774,7 @@ let package = Package(
                 "kuzu/src/storage/local_storage/local_node_table.cpp",
                 "kuzu/src/storage/local_storage/local_rel_table.cpp",
                 "kuzu/src/storage/local_storage/local_storage.cpp",
+                "kuzu/src/storage/optimistic_allocator.cpp",
                 "kuzu/src/storage/overflow_file.cpp",
                 "kuzu/src/storage/page_manager.cpp",
                 "kuzu/src/storage/predicate/column_predicate.cpp",
@@ -1122,7 +1124,7 @@ let package = Package(
                 .headerSearchPath("kuzu/third_party/zstd/include"),
                 .define("ANTLR4CPP_STATIC"),
                 .define("BM_MALLOC"),
-                .define("KUZU_CMAKE_VERSION", to: "\"0.10.0.5\""),
+                .define("KUZU_CMAKE_VERSION", to: "\"0.10.0.6\""),
                 .define("KUZU_EXPORTS"),
                 .define("KUZU_EXTENSION_VERSION", to: "\"0.10.0\""),
                 .define("KUZU_ROOT_DIRECTORY", to: "\"kuzu\""),

Sources/cxx-kuzu/include/kuzu.h

@@ -428,8 +428,11 @@ KUZU_C_API void kuzu_prepared_statement_destroy(kuzu_prepared_statement* prepare
  */
 KUZU_C_API bool kuzu_prepared_statement_is_success(kuzu_prepared_statement* prepared_statement);
 /**
+ * @brief Returns the error message if the prepared statement is not prepared successfully.
+ * The caller is responsible for freeing the returned string with `kuzu_destroy_string`.
  * @param prepared_statement The prepared statement instance.
- * @return the error message if the statement is not prepared successfully.
+ * @return the error message if the statement is not prepared successfully or null
+ * if the statement is prepared successfully.
  */
 KUZU_C_API char* kuzu_prepared_statement_get_error_message(
     kuzu_prepared_statement* prepared_statement);
@@ -629,8 +632,9 @@ KUZU_C_API void kuzu_query_result_destroy(kuzu_query_result* query_result);
 KUZU_C_API bool kuzu_query_result_is_success(kuzu_query_result* query_result);
 /**
  * @brief Returns the error message if the query is failed.
+ * The caller is responsible for freeing the returned string with `kuzu_destroy_string`.
  * @param query_result The query result instance to check and return error message.
- * @return The error message if the query has failed.
+ * @return The error message if the query has failed, or null if the query is successful.
  */
 KUZU_C_API char* kuzu_query_result_get_error_message(kuzu_query_result* query_result);
 /**

Sources/cxx-kuzu/kuzu/extension/algo/test/prepare_test.cpp

@@ -1,4 +1,4 @@
-#include "main_test_helper/main_test_helper.h"
+#include "api_test/api_test.h"
 
 using namespace kuzu::common;
 

Sources/cxx-kuzu/kuzu/extension/duckdb/src/include/storage/duckdb_storage.h

@@ -18,7 +18,7 @@ class DuckDBStorageExtension final : public storage::StorageExtension {
 
     static constexpr bool SKIP_UNSUPPORTED_TABLE_DEFAULT_VAL = false;
 
-    explicit DuckDBStorageExtension(transaction::Transaction* transaction, main::Database& db);
+    DuckDBStorageExtension(transaction::Transaction* transaction, main::Database& db);
 
     bool canHandleDB(std::string dbType_) const override;
 };

Sources/cxx-kuzu/kuzu/extension/fts/src/function/create_fts_index.cpp

@@ -305,20 +305,23 @@ static offset_t tableFunc(const TableFuncInput& input, TableFuncOutput&) {
     auto onDiskIndex = std::make_unique<FTSIndex>(std::move(indexInfo), std::move(storageInfo),
         std::move(ftsConfig), context.clientContext);
     if (!context.clientContext->isInMemory()) {
+        // We currently can't support FSM reclaiming when rolling back checkpoint
+        // so we don't use the optimistic allocator here
+        auto& pageAllocator = *storageManager->getDataFH()->getPageManager();
         // Checkpoint internal tables.
         onDiskIndex->getInternalTableInfo().docTable->checkpoint(context.clientContext,
-            docTableEntry);
+            docTableEntry, pageAllocator);
         auto termsTableName = FTSUtils::getTermsTableName(bindData.tableID, bindData.indexName);
         auto termsTableEntry =
             context.clientContext->getCatalog()->getTableCatalogEntry(transaction, termsTableName);
         onDiskIndex->getInternalTableInfo().termsTable->checkpoint(context.clientContext,
-            termsTableEntry);
+            termsTableEntry, pageAllocator);
         auto appearsInTableName =
             FTSUtils::getAppearsInTableName(bindData.tableID, bindData.indexName);
         auto appearsInTableEntry = context.clientContext->getCatalog()->getTableCatalogEntry(
             transaction, appearsInTableName);
         onDiskIndex->getInternalTableInfo().appearsInfoTable->checkpoint(context.clientContext,
-            appearsInTableEntry);
+            appearsInTableEntry, pageAllocator);
     }
     nodeTable->addIndex(std::move(onDiskIndex));
     transaction->setForceCheckpoint();

Sources/cxx-kuzu/kuzu/extension/fts/src/function/query_fts_bind_data.cpp

@@ -1,10 +1,10 @@
 #include "function/query_fts_bind_data.h"
 
+#include "binder/binder.h"
 #include "binder/expression/expression_util.h"
 #include "catalog/fts_index_catalog_entry.h"
 #include "common/exception/binder.h"
 #include "common/string_utils.h"
-#include "function/stem.h"
 #include "libstemmer.h"
 #include "re2.h"
 #include "storage/storage_manager.h"
@@ -18,17 +18,29 @@ using namespace kuzu::common;
 using namespace kuzu::binder;
 using namespace kuzu::storage;
 
-QueryFTSOptionalParams::QueryFTSOptionalParams(const binder::expression_vector& optionalParams) {
+static std::shared_ptr<Expression> applyImplicitCastingIfNecessary(main::ClientContext* context,
+    std::shared_ptr<Expression> expr, LogicalType targetType) {
+    if (expr->getDataType() != targetType) {
+        Binder binder{context};
+        expr = binder.getExpressionBinder()->implicitCastIfNecessary(expr, targetType);
+        expr = binder.getExpressionBinder()->foldExpression(expr);
+    }
+    return expr;
+}
+
+QueryFTSOptionalParams::QueryFTSOptionalParams(main::ClientContext* context,
+    const binder::expression_vector& optionalParams) {
     for (auto& optionalParam : optionalParams) {
         auto paramName = StringUtils::getLower(optionalParam->getAlias());
         if (paramName == K::NAME) {
-            k = optionalParam;
+            k = applyImplicitCastingIfNecessary(context, optionalParam, LogicalType{K::TYPE});
         } else if (paramName == B::NAME) {
-            b = optionalParam;
+            b = applyImplicitCastingIfNecessary(context, optionalParam, LogicalType{B::TYPE});
         } else if (paramName == Conjunctive::NAME) {
-            conjunctive = optionalParam;
+            conjunctive = applyImplicitCastingIfNecessary(context, optionalParam,
+                LogicalType{Conjunctive::TYPE});
         } else if (paramName == TopK::NAME) {
-            topK = optionalParam;
+            topK = applyImplicitCastingIfNecessary(context, optionalParam, LogicalType{TopK::TYPE});
         } else {
             throw common::BinderException{"Unknown optional parameter: " + paramName};
         }

Sources/cxx-kuzu/kuzu/extension/fts/src/function/query_fts_index.cpp

@@ -409,10 +409,10 @@ static std::unique_ptr<TableFuncBindData> bindFunc(main::ClientContext* context,
     KU_ASSERT(index.has_value());
     auto& ftsIndex = index.value()->cast<FTSIndex>();
     auto& ftsStorageInfo = ftsIndex.getStorageInfo().constCast<FTSStorageInfo>();
-    auto bindData =
-        std::make_unique<QueryFTSBindData>(std::move(columns), std::move(graphEntry), nodeOutput,
-            std::move(query), *ftsIndexEntry, QueryFTSOptionalParams{input->optionalParamsLegacy},
-            ftsStorageInfo.numDocs, ftsStorageInfo.avgDocLen);
+    auto bindData = std::make_unique<QueryFTSBindData>(std::move(columns), std::move(graphEntry),
+        nodeOutput, std::move(query), *ftsIndexEntry,
+        QueryFTSOptionalParams{context, input->optionalParamsLegacy}, ftsStorageInfo.numDocs,
+        ftsStorageInfo.avgDocLen);
     context->setUseInternalCatalogEntry(false /* useInternalCatalogEntry */);
     return bindData;
 }

Sources/cxx-kuzu/kuzu/extension/fts/src/include/function/query_fts_bind_data.h

@@ -14,7 +14,8 @@ struct QueryFTSOptionalParams {
     std::shared_ptr<binder::Expression> conjunctive;
     std::shared_ptr<binder::Expression> topK;
 
-    explicit QueryFTSOptionalParams(const binder::expression_vector& optionalParams);
+    QueryFTSOptionalParams(main::ClientContext* context,
+        const binder::expression_vector& optionalParams);
 
     QueryFTSConfig getConfig() const;
 };

Sources/cxx-kuzu/kuzu/extension/fts/src/include/index/fts_index.h

@@ -34,8 +34,8 @@ class FTSIndex final : public storage::Index {
         storage::StorageManager* storageManager, storage::IndexInfo indexInfo,
         std::span<uint8_t> storageInfoBuffer);
 
-    std::unique_ptr<InsertState> initInsertState(transaction::Transaction* transaction,
-        storage::MemoryManager* mm, storage::visible_func isVisible) override;
+    std::unique_ptr<InsertState> initInsertState(main::ClientContext*,
+        storage::visible_func isVisible) override;
 
     void insert(transaction::Transaction* transaction, const common::ValueVector& nodeIDVector,
         const std::vector<common::ValueVector*>& indexVectors, InsertState& insertState) override;
@@ -45,15 +45,9 @@ class FTSIndex final : public storage::Index {
 
     void delete_(transaction::Transaction* transaction, const common::ValueVector& nodeIDVector,
         DeleteState& deleteState) override;
-    void commitInsert(transaction::Transaction*, const common::ValueVector&,
-        const std::vector<common::ValueVector*>&, InsertState&) override {
-        // DO NOTHING.
-        // For FTS index, insertions are handled when the new tuples are inserted into the base
-        // table being indexed.
-    }
 
-    void checkpoint(main::ClientContext*, bool forceCheckpointAll) override;
     void finalize(main::ClientContext* context) override;
+    void checkpoint(main::ClientContext*, storage::PageAllocator& pageAllocator) override;
 
     static storage::IndexType getIndexType() {
         static const storage::IndexType FTS_INDEX_TYPE{"FTS",

Sources/cxx-kuzu/kuzu/extension/fts/src/include/index/fts_update_state.h

@@ -36,8 +36,7 @@ struct FTSInsertState final : storage::Index::InsertState {
     storage::NodeTableInsertState termsTableInsertState;
     storage::RelTableInsertState appearsInTableInsertState;
 
-    FTSInsertState(storage::MemoryManager* mm, transaction::Transaction* transaction,
-        FTSInternalTableInfo& tableInfo);
+    FTSInsertState(main::ClientContext* context, FTSInternalTableInfo& tableInfo);
 };
 
 struct IndexTableState {