dais-polymtl · anasdorbani · Dec 2, 2025 · Dec 2, 2025 · Dec 2, 2025 · Dec 2, 2025
diff --git a/.github/workflows/MainDistributionPipeline.yml b/.github/workflows/MainDistributionPipeline.yml
@@ -26,16 +26,16 @@ jobs:
     name: Build extension binaries
     uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@main
     with:
-      duckdb_version: v1.4.0
+      duckdb_version: v1.4.2
       extension_name: flock
       ci_tools_version: main
       exclude_archs: 'wasm_mvp;wasm_threads;wasm_eh'
 
   duckdb-stable-build:
     name: Build extension binaries
-    uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@v1.4.0
+    uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@v1.4.2
     with:
-      duckdb_version: v1.4.0
-      ci_tools_version: v1.4.0
+      duckdb_version: v1.4.2
+      ci_tools_version: v1.4.2
       extension_name: flock
       exclude_archs: 'wasm_mvp;wasm_threads;wasm_eh'
diff --git a/duckdb b/duckdb
diff --git a/extension-ci-tools b/extension-ci-tools
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -5,6 +5,7 @@ add_subdirectory(model_manager)
 add_subdirectory(prompt_manager)
 add_subdirectory(custom_parser)
 add_subdirectory(secret_manager)
+add_subdirectory(metrics)
 
 set(EXTENSION_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/flock_extension.cpp ${EXTENSION_SOURCES}

diff --git a/src/core/config/config.cpp b/src/core/config/config.cpp
@@ -65,8 +65,6 @@ void Config::ConfigureGlobal() {
 void Config::ConfigureLocal(duckdb::DatabaseInstance& db) {
     auto con = Config::GetConnection(&db);
     ConfigureTables(con, ConfigType::LOCAL);
-    con.Query(
-            duckdb_fmt::format("ATTACH DATABASE '{}' AS flock_storage;", Config::get_global_storage_path().string()));
 }
 
 void Config::ConfigureTables(duckdb::Connection& con, const ConfigType type) {
@@ -89,4 +87,61 @@ void Config::Configure(duckdb::ExtensionLoader& loader) {
     }
 }
 
+void Config::AttachToGlobalStorage(duckdb::Connection& con, bool read_only) {
+    con.Query(duckdb_fmt::format("ATTACH DATABASE '{}' AS flock_storage {};",
+                                 Config::get_global_storage_path().string(), read_only ? "(READ_ONLY)" : ""));
+}
+
+void Config::DetachFromGlobalStorage(duckdb::Connection& con) {
+    con.Query("DETACH DATABASE flock_storage;");
+}
+
+bool Config::StorageAttachmentGuard::TryAttach(bool read_only) {
+    try {
+        Config::AttachToGlobalStorage(connection, read_only);
+        return true;
+    } catch (const std::exception&) {
+        return false;
+    }
+}
+
+bool Config::StorageAttachmentGuard::TryDetach() {
+    try {
+        Config::DetachFromGlobalStorage(connection);
+        return true;
+    } catch (const std::exception&) {
+        return false;
+    }
+}
+
+void Config::StorageAttachmentGuard::Wait(int milliseconds) {
+    auto start = std::chrono::steady_clock::now();
+    auto duration = std::chrono::milliseconds(milliseconds);
+    while (std::chrono::steady_clock::now() - start < duration) {
+        // Busy-wait until the specified duration has elapsed
+    }
+}
+
+Config::StorageAttachmentGuard::StorageAttachmentGuard(duckdb::Connection& con, bool read_only)
+    : connection(con), attached(false) {
+    for (int attempt = 0; attempt < MAX_RETRIES; ++attempt) {
+        if (TryAttach(read_only)) {
+            attached = true;
+            return;
+        }
+        Wait(RETRY_DELAY_MS);
+    }
+    Config::AttachToGlobalStorage(connection, read_only);
+    attached = true;
+}
+
+Config::StorageAttachmentGuard::~StorageAttachmentGuard() {
+    if (attached) {
+        try {
+            Config::DetachFromGlobalStorage(connection);
+        } catch (...) {
+        }
+    }
+}
+
 }// namespace flock
diff --git a/src/core/config/model.cpp b/src/core/config/model.cpp
@@ -32,6 +32,8 @@ void Config::SetupDefaultModelsConfig(duckdb::Connection& con, std::string& sche
                 "('default', 'gpt-4o-mini', 'openai'), "
                 "('gpt-4o-mini', 'gpt-4o-mini', 'openai'), "
                 "('gpt-4o', 'gpt-4o', 'openai'), "
+                "('gpt-4o-transcribe', 'gpt-4o-transcribe', 'openai'),"
+                "('gpt-4o-mini-transcribe', 'gpt-4o-mini-transcribe', 'openai'),"
                 "('text-embedding-3-large', 'text-embedding-3-large', 'openai'), "
                 "('text-embedding-3-small', 'text-embedding-3-small', 'openai');",
                 schema_name, table_name));

diff --git a/src/custom_parser/query/model_parser.cpp b/src/custom_parser/query/model_parser.cpp
@@ -2,6 +2,7 @@
 
 #include "flock/core/common.hpp"
 #include "flock/core/config.hpp"
+#include "flock/custom_parser/query_parser.hpp"
 #include <sstream>
 #include <stdexcept>
 
@@ -303,101 +304,123 @@ std::string ModelParser::ToSQL(const QueryStatement& statement) const {
     switch (statement.type) {
         case StatementType::CREATE_MODEL: {
             const auto& create_stmt = static_cast<const CreateModelStatement&>(statement);
-            auto con = Config::GetConnection();
-            auto result = con.Query(duckdb_fmt::format(
-                    " SELECT model_name"
-                    "  FROM flock_storage.flock_config.FLOCKMTL_MODEL_DEFAULT_INTERNAL_TABLE"
-                    " WHERE model_name = '{}'"
-                    " UNION ALL "
-                    " SELECT model_name "
-                    "   FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
-                    "  WHERE model_name = '{}';",
-                    create_stmt.model_name, create_stmt.catalog.empty() ? "flock_storage." : "", create_stmt.model_name));
-            if (result->RowCount() != 0) {
-                throw std::runtime_error(duckdb_fmt::format("Model '{}' already exist.", create_stmt.model_name));
-            }
+            query = ExecuteQueryWithStorage([&create_stmt](duckdb::Connection& con) {
+                auto result = con.Query(duckdb_fmt::format(
+                        " SELECT model_name"
+                        "  FROM flock_storage.flock_config.FLOCKMTL_MODEL_DEFAULT_INTERNAL_TABLE"
+                        " WHERE model_name = '{}'"
+                        " UNION ALL "
+                        " SELECT model_name "
+                        "   FROM flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                        "  WHERE model_name = '{}'"
+                        " UNION ALL "
+                        " SELECT model_name "
+                        "   FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                        "  WHERE model_name = '{}';",
+                        create_stmt.model_name, create_stmt.model_name, create_stmt.model_name));
+
+                auto& materialized_result = result->Cast<duckdb::MaterializedQueryResult>();
+                if (materialized_result.RowCount() != 0) {
+                    throw std::runtime_error(duckdb_fmt::format("Model '{}' already exist.", create_stmt.model_name));
+                }
 
-            query = duckdb_fmt::format(" INSERT INTO "
-                                       " {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                       " (model_name, model, provider_name, model_args) "
-                                       " VALUES ('{}', '{}', '{}', '{}');",
-                                       create_stmt.catalog, create_stmt.model_name, create_stmt.model,
-                                       create_stmt.provider_name, create_stmt.model_args.dump());
+                // Insert the new model
+                auto insert_query = duckdb_fmt::format(" INSERT INTO "
+                                                       " {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                                       " (model_name, model, provider_name, model_args) "
+                                                       " VALUES ('{}', '{}', '{}', '{}');",
+                                                       create_stmt.catalog, create_stmt.model_name, create_stmt.model,
+                                                       create_stmt.provider_name, create_stmt.model_args.dump());
+                con.Query(insert_query);
+
+                return std::string("SELECT 'Model created successfully' AS status");
+            },
+                                            false);
             break;
         }
         case StatementType::DELETE_MODEL: {
             const auto& delete_stmt = static_cast<const DeleteModelStatement&>(statement);
-            auto con = Config::GetConnection();
-
-            con.Query(duckdb_fmt::format(" DELETE FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                         "  WHERE model_name = '{}';",
-                                         delete_stmt.model_name));
-
-            query = duckdb_fmt::format(" DELETE FROM "
+            query = ExecuteSetQuery(
+                    duckdb_fmt::format(" DELETE FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                       "  WHERE model_name = '{}'; "
+                                       " DELETE FROM "
                                        " flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
                                        "  WHERE model_name = '{}';",
-                                       delete_stmt.model_name, delete_stmt.model_name);
+                                       delete_stmt.model_name, delete_stmt.model_name),
+                    "Model deleted successfully",
+                    false);
             break;
         }
         case StatementType::UPDATE_MODEL: {
             const auto& update_stmt = static_cast<const UpdateModelStatement&>(statement);
-            auto con = Config::GetConnection();
-            // get the location of the model_name if local or global
-            auto result = con.Query(
-                    duckdb_fmt::format(" SELECT model_name, 'global' AS scope "
-                                       "   FROM flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
-                                       "  WHERE model_name = '{}'"
-                                       " UNION ALL "
-                                       " SELECT model_name, 'local' AS scope "
-                                       "   FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
-                                       "  WHERE model_name = '{}';",
-                                       update_stmt.model_name, update_stmt.model_name, update_stmt.model_name));
+            query = ExecuteQueryWithStorage([&update_stmt](duckdb::Connection& con) {
+                // Get the location of the model_name if local or global
+                auto result = con.Query(
+                        duckdb_fmt::format(" SELECT model_name, 'global' AS scope "
+                                           "   FROM flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                                           "  WHERE model_name = '{}'"
+                                           " UNION ALL "
+                                           " SELECT model_name, 'local' AS scope "
+                                           "   FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                                           "  WHERE model_name = '{}';",
+                                           update_stmt.model_name, update_stmt.model_name, update_stmt.model_name));
+
+                auto& materialized_result = result->Cast<duckdb::MaterializedQueryResult>();
+                if (materialized_result.RowCount() == 0) {
+                    throw std::runtime_error(duckdb_fmt::format("Model '{}' doesn't exist.", update_stmt.model_name));
+                }
 
-            if (result->RowCount() == 0) {
-                throw std::runtime_error(duckdb_fmt::format("Model '{}' doesn't exist.", update_stmt.model_name));
-            }
+                auto catalog = materialized_result.GetValue(1, 0).ToString() == "global" ? "flock_storage." : "";
 
-            auto catalog = result->GetValue(1, 0).ToString() == "global" ? "flock_storage." : "";
+                con.Query(duckdb_fmt::format(" UPDATE {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                             "    SET model = '{}', provider_name = '{}', "
+                                             " model_args = '{}' WHERE model_name = '{}'; ",
+                                             catalog, update_stmt.new_model, update_stmt.provider_name,
+                                             update_stmt.new_model_args.dump(), update_stmt.model_name));
 
-            query = duckdb_fmt::format(" UPDATE {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                       "    SET model = '{}', provider_name = '{}', "
-                                       " model_args = '{}' WHERE model_name = '{}'; ",
-                                       catalog, update_stmt.new_model, update_stmt.provider_name,
-                                       update_stmt.new_model_args.dump(), update_stmt.model_name);
+                return std::string("SELECT 'Model updated successfully' AS status");
+            },
+                                            false);
             break;
         }
         case StatementType::UPDATE_MODEL_SCOPE: {
             const auto& update_stmt = static_cast<const UpdateModelScopeStatement&>(statement);
-            auto con = Config::GetConnection();
-            auto result =
-                    con.Query(duckdb_fmt::format(" SELECT model_name "
-                                                 "   FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
-                                                 "  WHERE model_name = '{}';",
-                                                 update_stmt.catalog, update_stmt.model_name));
-            if (result->RowCount() != 0) {
-                throw std::runtime_error(
-                        duckdb_fmt::format("Model '{}' already exist in {} storage.", update_stmt.model_name,
-                                           update_stmt.catalog == "flock_storage." ? "global" : "local"));
-            }
+            query = ExecuteQueryWithStorage([&update_stmt](duckdb::Connection& con) {
+                auto result = con.Query(duckdb_fmt::format(" SELECT model_name "
+                                                           "   FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                                                           "  WHERE model_name = '{}';",
+                                                           update_stmt.catalog, update_stmt.model_name));
+
+                auto& materialized_result = result->Cast<duckdb::MaterializedQueryResult>();
+                if (materialized_result.RowCount() != 0) {
+                    throw std::runtime_error(
+                            duckdb_fmt::format("Model '{}' already exist in {} storage.", update_stmt.model_name,
+                                               update_stmt.catalog == "flock_storage." ? "global" : "local"));
+                }
 
-            con.Query(duckdb_fmt::format("INSERT INTO {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                         "(model_name, model, provider_name, model_args) "
-                                         "SELECT model_name, model, provider_name, model_args "
-                                         "FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                         "WHERE model_name = '{}'; ",
-                                         update_stmt.catalog,
-                                         update_stmt.catalog == "flock_storage." ? "" : "flock_storage.",
-                                         update_stmt.model_name));
-
-            query = duckdb_fmt::format("DELETE FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
-                                       "WHERE model_name = '{}'; ",
-                                       update_stmt.catalog == "flock_storage." ? "" : "flock_storage.",
-                                       update_stmt.model_name);
+                con.Query(duckdb_fmt::format("INSERT INTO {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                             "(model_name, model, provider_name, model_args) "
+                                             "SELECT model_name, model, provider_name, model_args "
+                                             "FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                             "WHERE model_name = '{}'; ",
+                                             update_stmt.catalog,
+                                             update_stmt.catalog == "flock_storage." ? "" : "flock_storage.",
+                                             update_stmt.model_name));
+
+                con.Query(duckdb_fmt::format("DELETE FROM {}flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
+                                             "WHERE model_name = '{}'; ",
+                                             update_stmt.catalog == "flock_storage." ? "" : "flock_storage.",
+                                             update_stmt.model_name));
+
+                return std::string("SELECT 'Model scope updated successfully' AS status");
+            },
+                                            false);
             break;
         }
         case StatementType::GET_MODEL: {
             const auto& get_stmt = static_cast<const GetModelStatement&>(statement);
-            query = duckdb_fmt::format("SELECT 'global' AS scope, * "
+            query = ExecuteGetQuery(
+                    duckdb_fmt::format("SELECT 'global' AS scope, * "
                                        "FROM flock_storage.flock_config.FLOCKMTL_MODEL_DEFAULT_INTERNAL_TABLE "
                                        "WHERE model_name = '{}' "
                                        "UNION ALL "
@@ -408,20 +431,22 @@ std::string ModelParser::ToSQL(const QueryStatement& statement) const {
                                        "SELECT 'local' AS scope, * "
                                        "FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE "
                                        "WHERE model_name = '{}';",
-                                       get_stmt.model_name, get_stmt.model_name, get_stmt.model_name, get_stmt.model_name);
+                                       get_stmt.model_name, get_stmt.model_name, get_stmt.model_name, get_stmt.model_name),
+                    true);
             break;
         }
 
         case StatementType::GET_ALL_MODEL: {
-            query = duckdb_fmt::format(" SELECT 'global' AS scope, * "
-                                       " FROM flock_storage.flock_config.FLOCKMTL_MODEL_DEFAULT_INTERNAL_TABLE"
-                                       " UNION ALL "
-                                       " SELECT 'global' AS scope, * "
-                                       " FROM flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
-                                       " UNION ALL "
-                                       " SELECT 'local' AS scope, * "
-                                       " FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE;",
-                                       Config::get_global_storage_path().string());
+            query = ExecuteGetQuery(
+                    " SELECT 'global' AS scope, * "
+                    " FROM flock_storage.flock_config.FLOCKMTL_MODEL_DEFAULT_INTERNAL_TABLE"
+                    " UNION ALL "
+                    " SELECT 'global' AS scope, * "
+                    " FROM flock_storage.flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE"
+                    " UNION ALL "
+                    " SELECT 'local' AS scope, * "
+                    " FROM flock_config.FLOCKMTL_MODEL_USER_DEFINED_INTERNAL_TABLE;",
+                    true);
             break;
         }
         default:
+39 −27		.github/workflows/TestCITools.yml
+11 −6		.github/workflows/_extension_deploy.yml
+86 −12		.github/workflows/_extension_distribution.yml
+5 −2		README.md
+20 −10		config/distribution_matrix.json
+3 −3		makefiles/c_api_extensions/base.Makefile
+9 −3		makefiles/duckdb_extension.Makefile
+19 −1		scripts/modify_distribution_matrix.py