Fix minor issues (#3423)

CMakeLists.txt

@@ -217,7 +217,7 @@ add_subdirectory(third_party)
 if(${BUILD_KUZU})
 add_definitions(-DKUZU_ROOT_DIRECTORY="${PROJECT_SOURCE_DIR}")
 add_definitions(-DKUZU_CMAKE_VERSION="${CMAKE_PROJECT_VERSION}")
-add_definitions(-DKUZU_EXTENSION_VERSION="0.2.9")
+add_definitions(-DKUZU_EXTENSION_VERSION="0.3.0")
 
 include_directories(src/include)
 

extension/duckdb/src/duckdb_functions.cpp

@@ -10,32 +10,32 @@ using namespace kuzu::common;
 namespace kuzu {
 namespace duckdb_extension {
 
-static offset_t DuckDBClearCacheTableFunc(TableFuncInput& input, TableFuncOutput& output) {
+static offset_t clearCacheTableFunc(TableFuncInput& input, TableFuncOutput& output) {
     auto& dataChunk = output.dataChunk;
     auto sharedState = input.sharedState->ptrCast<CallFuncSharedState>();
     auto morsel = sharedState->getMorsel();
     if (!morsel.hasMoreToOutput()) {
         return 0;
     }
-    auto bindData = input.bindData->constPtrCast<DuckDBClearCacheBindData>();
-    bindData->databaseManager->invalidateCache(DuckDBStorageExtension::dbType);
+    auto bindData = input.bindData->constPtrCast<ClearCacheBindData>();
+    bindData->databaseManager->invalidateCache();
     dataChunk.getValueVector(0)->setValue<std::string>(0,
-        "All attached duckdb database caches have been cleared.");
+        "All attached database caches have been cleared.");
     return 1;
 }
 
-static std::unique_ptr<TableFuncBindData> DuckDBClearCacheBindFunc(ClientContext* context,
+static std::unique_ptr<TableFuncBindData> clearCacheBindFunc(ClientContext* context,
     TableFuncBindInput*) {
     std::vector<std::string> columnNames;
     std::vector<LogicalType> columnTypes;
     columnNames.emplace_back("message");
     columnTypes.emplace_back(*LogicalType::STRING());
-    return std::make_unique<DuckDBClearCacheBindData>(context->getDatabaseManager(),
+    return std::make_unique<ClearCacheBindData>(context->getDatabaseManager(),
         std::move(columnTypes), std::move(columnNames), 1 /* maxOffset */);
 }
 
-DuckDBClearCacheFunction::DuckDBClearCacheFunction()
-    : TableFunction{name, DuckDBClearCacheTableFunc, DuckDBClearCacheBindFunc,
+ClearCacheFunction::ClearCacheFunction()
+    : TableFunction{name, clearCacheTableFunc, clearCacheBindFunc,
           function::CallFunction::initSharedState, function::CallFunction::initEmptyLocalState,
           std::vector<LogicalTypeID>{}} {}
 

extension/duckdb/src/duckdb_storage.cpp

@@ -40,7 +40,7 @@ std::unique_ptr<main::AttachedDatabase> attachDuckDB(std::string dbName, std::st
 
 DuckDBStorageExtension::DuckDBStorageExtension(main::Database* database)
     : StorageExtension{attachDuckDB} {
-    auto duckDBClearCacheFunction = std::make_unique<DuckDBClearCacheFunction>();
+    auto duckDBClearCacheFunction = std::make_unique<ClearCacheFunction>();
     extension::ExtensionUtils::registerTableFunction(*database,
         std::move(duckDBClearCacheFunction));
 }

extension/duckdb/src/include/duckdb_functions.h

@@ -8,25 +8,25 @@
 namespace kuzu {
 namespace duckdb_extension {
 
-struct DuckDBClearCacheBindData : public function::CallTableFuncBindData {
+struct ClearCacheBindData : public function::CallTableFuncBindData {
     main::DatabaseManager* databaseManager;
 
-    DuckDBClearCacheBindData(main::DatabaseManager* databaseManager,
+    ClearCacheBindData(main::DatabaseManager* databaseManager,
         std::vector<common::LogicalType> returnTypes, std::vector<std::string> returnColumnNames,
         common::offset_t maxOffset)
         : CallTableFuncBindData{std::move(returnTypes), std::move(returnColumnNames), maxOffset},
           databaseManager{databaseManager} {}
 
     std::unique_ptr<TableFuncBindData> copy() const override {
-        return std::make_unique<DuckDBClearCacheBindData>(databaseManager, columnTypes, columnNames,
+        return std::make_unique<ClearCacheBindData>(databaseManager, columnTypes, columnNames,
             maxOffset);
     }
 };
 
-struct DuckDBClearCacheFunction final : public function::TableFunction {
-    static constexpr const char* name = "duckdb_clear_cache";
+struct ClearCacheFunction final : public function::TableFunction {
+    static constexpr const char* name = "clear_attached_db_cache";
 
-    DuckDBClearCacheFunction();
+    ClearCacheFunction();
 };
 
 } // namespace duckdb_extension

extension/duckdb/test/test_files/duckdb.test

@@ -54,12 +54,12 @@ Attached database successfully.
 Attached database successfully.
 -STATEMENT CALL SHOW_TABLES() RETURN *;
 ---- 6
-movies|FOREIGN|tinysnb(DUCKDB)|
-organisation|FOREIGN|tinysnb(DUCKDB)|
-person|FOREIGN|Other1(DUCKDB)|
-person|FOREIGN|tinysnb(DUCKDB)|
-tableOfTypes1|FOREIGN|tinysnb(DUCKDB)|
-tableOfTypes|FOREIGN|tinysnb(DUCKDB)|
+movies|ATTACHED|tinysnb(DUCKDB)|
+organisation|ATTACHED|tinysnb(DUCKDB)|
+person|ATTACHED|Other1(DUCKDB)|
+person|ATTACHED|tinysnb(DUCKDB)|
+tableOfTypes1|ATTACHED|tinysnb(DUCKDB)|
+tableOfTypes|ATTACHED|tinysnb(DUCKDB)|
 -STATEMENT LOAD FROM other1.person RETURN *;
 ---- 4
 1
@@ -88,7 +88,7 @@ Used database successfully.
 -STATEMENT LOAD FROM other1.person RETURN count(*);
 ---- 1
 4
--STATEMENT CALL DUCKDB_CLEAR_CACHE() RETURN *;
+-STATEMENT CALL CLEAR_ATTACHED_DB_CACHE() RETURN *;
 ---- ok
 -STATEMENT LOAD FROM other1.person RETURN count(*);
 ---- 1

extension/postgres/CMakeLists.txt

@@ -16,10 +16,10 @@ add_library(postgres_extension
         ../duckdb/src/duckdb_catalog.cpp
         ../duckdb/src/duckdb_table_catalog_entry.cpp
         ../duckdb/src/duckdb_type_converter.cpp
+        ../duckdb/src/duckdb_functions.cpp
         src/postgres_extension.cpp
         src/postgres_storage.cpp
-        src/postgres_catalog.cpp
-        src/postgres_functions.cpp)
+        src/postgres_catalog.cpp)
 
 include_directories(
         src/include

extension/postgres/src/postgres_storage.cpp

@@ -2,12 +2,11 @@
 
 #include <regex>
 
-#include "catalog/catalog_entry/table_catalog_entry.h"
 #include "common/exception/runtime.h"
 #include "common/string_utils.h"
+#include "duckdb_functions.h"
 #include "extension/extension.h"
 #include "postgres_catalog.h"
-#include "postgres_functions.h"
 
 namespace kuzu {
 namespace postgres_extension {
@@ -35,9 +34,8 @@ std::unique_ptr<main::AttachedDatabase> attachPostgres(std::string dbName, std::
 
 PostgresStorageExtension::PostgresStorageExtension(main::Database* database)
     : StorageExtension{attachPostgres} {
-    auto postgresClearCacheFunction = std::make_unique<PostgresClearCacheFunction>();
-    extension::ExtensionUtils::registerTableFunction(*database,
-        std::move(postgresClearCacheFunction));
+    auto clearCacheFunction = std::make_unique<duckdb_extension::ClearCacheFunction>();
+    extension::ExtensionUtils::registerTableFunction(*database, std::move(clearCacheFunction));
 }
 
 bool PostgresStorageExtension::canHandleDB(std::string dbType_) const {

extension/postgres/test/test_files/postgres.test

@@ -39,7 +39,7 @@ Binder exception: No database named tinysnb1 has been attached.
 -STATEMENT LOAD FROM pgscan.movies RETURN count(*);
 ---- 1
 3
--STATEMENT CALL POSTGRES_CLEAR_CACHE() RETURN *;
+-STATEMENT CALL CLEAR_ATTACHED_DB_CACHE() RETURN *;
 ---- ok
 -STATEMENT LOAD FROM pgscan.movies where length > 2500 RETURN name;
 ---- 1
@@ -55,14 +55,14 @@ The 😂😃🧘🏻‍♂️🌍🌦️🍞🚗 movie
 # be displayed.
 -STATEMENT CALL SHOW_TABLES() RETURN *;
 ---- 8
-movies|FOREIGN|pgscan(POSTGRES)|
-movies|FOREIGN|tinysnb(POSTGRES)|
-organisation|FOREIGN|pgscan(POSTGRES)|
-organisation|FOREIGN|tinysnb(POSTGRES)|
-persontest|FOREIGN|pgscan(POSTGRES)|
-persontest|FOREIGN|tinysnb(POSTGRES)|
-person|FOREIGN|pgscan(POSTGRES)|
-person|FOREIGN|tinysnb(POSTGRES)|
+movies|ATTACHED|pgscan(POSTGRES)|
+movies|ATTACHED|tinysnb(POSTGRES)|
+organisation|ATTACHED|pgscan(POSTGRES)|
+organisation|ATTACHED|tinysnb(POSTGRES)|
+persontest|ATTACHED|pgscan(POSTGRES)|
+persontest|ATTACHED|tinysnb(POSTGRES)|
+person|ATTACHED|pgscan(POSTGRES)|
+person|ATTACHED|tinysnb(POSTGRES)|
 
 -STATEMENT CALL TABLE_INFO('pgscan.person') RETURN *;
 ---- 14