bug fixes and performance improvements

Author: trvon

.github/workflows/ci.yml

@@ -0,0 +1,114 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            meson \
+            ninja-build \
+            pkg-config \
+            libsqlite3-dev \
+            libbenchmark-dev \
+            python3-pip \
+            gcovr
+
+      - name: Configure (coverage)
+        run: meson setup build_coverage -Dbuildtype=debugoptimized -Db_coverage=true
+
+      - name: Build
+        run: meson compile -C build_coverage
+
+      - name: Test
+        run: meson test -C build_coverage
+
+      - name: Coverage (summary + artifacts)
+        run: |
+          gcovr -r . \
+            --object-directory build_coverage \
+            --exclude '.*build.*' \
+            --exclude '.*third_party.*' \
+            --exclude '.*benchmarks.*' \
+            --gcov-ignore-parse-errors=suspicious_hits.warn \
+            --merge-mode-functions=merge-use-line-0 \
+            --print-summary \
+            --html-details coverage/index.html \
+            --cobertura coverage/coverage.xml
+
+      - name: Upload coverage artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: coverage/
+
+  tsan:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            clang \
+            meson \
+            ninja-build \
+            pkg-config \
+            libsqlite3-dev
+
+      - name: Configure (TSAN)
+        run: |
+          CC=clang CXX=clang++ meson setup build_tsan \
+            -Dbuildtype=debugoptimized \
+            -Db_sanitize=thread
+
+      - name: Build
+        run: meson compile -C build_tsan
+
+      - name: Test
+        run: meson test -C build_tsan
+
+  benchmarks:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            meson \
+            ninja-build \
+            pkg-config \
+            libsqlite3-dev \
+            libbenchmark-dev
+
+      - name: Configure (release + benchmarks)
+        run: meson setup build_bench -Dbuildtype=release -Denable_benchmarks=true
+
+      - name: Build
+        run: meson compile -C build_bench
+
+      - name: Run benchmarks
+        run: |
+          mkdir -p bench_results
+          ./build_bench/benchmarks/rag_pipeline_benchmark --benchmark_min_time=0.2s --benchmark_out=bench_results/rag.json --benchmark_out_format=json
+          ./build_bench/benchmarks/batch_distance_benchmark --benchmark_min_time=0.2s --benchmark_out=bench_results/batch.json --benchmark_out_format=json
+
+      - name: Upload benchmark artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: bench_results
+          path: bench_results/*.json

include/sqlite-vec-cpp/distances/batch.hpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <execution>
+#include <numeric>
 #include <span>
 #include <vector>
 #include "../concepts/distance_metric.hpp"

include/sqlite-vec-cpp/index/hnsw.hpp

@@ -238,6 +238,10 @@ template <concepts::VectorElement StorageT, typename MetricT> class HNSWIndex {
             return;
 
         size_t actual_threads = num_threads ? num_threads : std::thread::hardware_concurrency();
+        if (actual_threads == 0) {
+            actual_threads = 1;
+        }
+
         ThreadPool pool(actual_threads);
 
         pool.parallel_for(ids.size(),
@@ -260,6 +264,10 @@ template <concepts::VectorElement StorageT, typename MetricT> class HNSWIndex {
             return;
 
         size_t actual_threads = num_threads ? num_threads : std::thread::hardware_concurrency();
+        if (actual_threads == 0) {
+            actual_threads = 1;
+        }
+
         ThreadPool pool(actual_threads);
 
         constexpr size_t DEFAULT_BATCH_SIZE = 256;

include/sqlite-vec-cpp/sqlite/context.hpp

@@ -70,9 +70,11 @@ class Context {
 
     /// Set blob result with custom destructor
     template <typename Deleter>
-    void result_blob(std::span<const std::uint8_t> blob, Deleter&& deleter) const noexcept {
+    void result_blob(std::span<const std::uint8_t> blob,
+                     [[maybe_unused]] Deleter&& deleter) const noexcept {
         // Note: For custom deleters, would need to wrap in a C callback
         // For now, just use SQLITE_TRANSIENT
+        (void)deleter;
         result_blob(blob);
     }
 

include/sqlite-vec-cpp/sqlite/registration.hpp

@@ -98,6 +98,32 @@ inline Result<void> register_all_functions(sqlite3* db) {
         return err<void>(Error::sqlite_error("Failed to register vec_bit", rc));
     }
 
+    // Register vec_f32_simple function (for vec0 compatibility)
+    // This version doesn't set subtype so virtual table xUpdate can access blob
+    rc = sqlite3_create_function_v2(db, "vec_f32_simple", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC,
+                                    nullptr, vec_f32_simple, nullptr, nullptr, nullptr);
+    if (rc != SQLITE_OK) {
+        return err<void>(Error::sqlite_error("Failed to register vec_f32_simple", rc));
+    }
+
+    // Register vec_int8 function (int8 vector creation from JSON)
+    rc = sqlite3_create_function_v2(db, "vec_int8", 1,
+                                    SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_SUBTYPE |
+                                        SQLITE_RESULT_SUBTYPE,
+                                    nullptr, vec_int8, nullptr, nullptr, nullptr);
+    if (rc != SQLITE_OK) {
+        return err<void>(Error::sqlite_error("Failed to register vec_int8", rc));
+    }
+
+    // Register vec_bit function (bit vector creation from blob)
+    rc = sqlite3_create_function_v2(db, "vec_bit", 1,
+                                    SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_SUBTYPE |
+                                        SQLITE_RESULT_SUBTYPE,
+                                    nullptr, vec_bit, nullptr, nullptr, nullptr);
+    if (rc != SQLITE_OK) {
+        return err<void>(Error::sqlite_error("Failed to register vec_bit", rc));
+    }
+
     // Register enhanced functions (C++20/23 specific features)
     rc = sqlite3_create_function_v2(db, "vec_dot", 2, SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr,
                                     vec_dot, nullptr, nullptr, nullptr);

include/sqlite-vec-cpp/sqlite/utility_functions.hpp

@@ -63,14 +63,9 @@ inline void vec_f32_impl(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
     std::size_t size = vec.size() * sizeof(float);
     unsigned int subtype = static_cast<unsigned int>(VectorElementType::Float32);
 
-    fprintf(stderr, "[vec_f32_impl] DEBUG: vec.size()=%zu, data=%p, size=%zu, subtype=%u\n",
-            vec.size(), data, size, subtype);
-
     // Use the wrapper method that correctly sets blob + subtype
     context.result_blob_with_subtype(
         std::span<const std::uint8_t>(reinterpret_cast<const std::uint8_t*>(data), size), subtype);
-
-    fprintf(stderr, "[vec_f32_impl] DEBUG: result_blob_with_subtype called successfully\n");
 }
 
 /// SQLite function: vec_int8(json_or_blob) -> int8 vector blob

include/sqlite-vec-cpp/sqlite/vec0_module.hpp

@@ -1,12 +1,15 @@
 #pragma once
 
 #include <sqlite3.h>
+#include <cstdint>
 #include <cstring>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
 #include "../utils/error.hpp"
+#include "parsers.hpp"
+#include "value.hpp"
 
 namespace sqlite_vec_cpp::sqlite {
 
@@ -84,7 +87,11 @@ inline bool parse_vec0_schema(int argc, const char* const* argv, std::string& em
 
 // Helper: Create shadow tables for vec0 storage
 inline int create_shadow_tables(sqlite3* db, const char* schema, const char* table,
-                                const char* embedding_col, size_t dims, char** pzErr) {
+                                const char* embedding_col, [[maybe_unused]] size_t dims,
+                                char** pzErr) {
+    // Note: dims parameter is reserved for future use (validation, typed vectors)
+    (void)dims;
+
     // Shadow table for metadata
     std::ostringstream meta_sql;
     meta_sql << "CREATE TABLE IF NOT EXISTS \"" << schema << "\".\"" << table << "_metadata\" ("
@@ -124,6 +131,9 @@ inline int vec0Create(sqlite3* db, void* pAux, int argc, const char* const* argv
                       sqlite3_vtab** ppVTab, char** pzErr) {
     (void)pAux;
 
+    // Enable shadow table writes through xUpdate
+    sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
+
     if (argc < 3) {
         *pzErr = sqlite3_mprintf("vec0: insufficient arguments");
         return SQLITE_ERROR;
@@ -342,12 +352,33 @@ inline int vec0Update(sqlite3_vtab* pVTab, int argc, sqlite3_value** argv, sqlit
         bool is_insert = (sqlite3_value_type(argv[0]) == SQLITE_NULL);
         int64_t rowid = is_insert ? 0 : sqlite3_value_int64(argv[0]);
 
-        // argv[2] = embedding column value
-        const void* blob = sqlite3_value_blob(argv[2]);
-        int bytes = sqlite3_value_bytes(argv[2]);
+        // argv layout per SQLite vtab spec:
+        // - argv[0]: old rowid (or NULL)
+        // - argv[1]: new rowid (or NULL)
+        // - argv[2..]: column values in declared order
+        if (argc < 4) {
+            return SQLITE_MISUSE;
+        }
+
+        // Our declared schema is: CREATE TABLE x(rowid INTEGER PRIMARY KEY, "embedding")
+        // So the embedding column value is argv[3] (argv[2] corresponds to rowid column value).
+        sqlite3_value* embedding_val = argv[3];
+        const void* blob = sqlite3_value_blob(embedding_val);
+        int bytes = sqlite3_value_bytes(embedding_val);
+
+        // If xUpdate doesn't materialize function-returned blobs, parse JSON/text and bind as blob
+        std::vector<float> parsed_vec;
+        if (sqlite3_value_type(embedding_val) == SQLITE_TEXT) {
+            Value value(embedding_val);
+            auto parsed = parse_vector_from_value<float>(value);
+            if (parsed) {
+                parsed_vec = std::move(parsed.value());
+                blob = parsed_vec.data();
+                bytes = static_cast<int>(parsed_vec.size() * sizeof(float));
+            }
+        }
 
         if (is_insert) {
-            // INSERT
             std::ostringstream sql;
             sql << "INSERT INTO \"" << table->schema_name << "\".\"" << table->table_name
                 << "_vectors\" (\"" << table->embedding_column << "\") VALUES (?)";
@@ -357,9 +388,13 @@ inline int vec0Update(sqlite3_vtab* pVTab, int argc, sqlite3_value** argv, sqlit
             if (rc != SQLITE_OK)
                 return rc;
 
-            sqlite3_bind_blob(stmt, 1, blob, bytes, SQLITE_TRANSIENT);
-            rc = sqlite3_step(stmt);
+            if (blob && bytes > 0) {
+                sqlite3_bind_blob(stmt, 1, blob, bytes, SQLITE_TRANSIENT);
+            } else {
+                sqlite3_bind_null(stmt, 1);
+            }
 
+            rc = sqlite3_step(stmt);
             if (rc == SQLITE_DONE) {
                 *pRowid = sqlite3_last_insert_rowid(table->db);
                 rc = SQLITE_OK;
@@ -368,7 +403,6 @@ inline int vec0Update(sqlite3_vtab* pVTab, int argc, sqlite3_value** argv, sqlit
             sqlite3_finalize(stmt);
             return rc;
         } else {
-            // UPDATE
             std::ostringstream sql;
             sql << "UPDATE \"" << table->schema_name << "\".\"" << table->table_name
                 << "_vectors\" SET \"" << table->embedding_column << "\"=? WHERE rowid=" << rowid;
@@ -378,9 +412,13 @@ inline int vec0Update(sqlite3_vtab* pVTab, int argc, sqlite3_value** argv, sqlit
             if (rc != SQLITE_OK)
                 return rc;
 
-            sqlite3_bind_blob(stmt, 1, blob, bytes, SQLITE_TRANSIENT);
-            rc = sqlite3_step(stmt);
+            if (blob && bytes > 0) {
+                sqlite3_bind_blob(stmt, 1, blob, bytes, SQLITE_TRANSIENT);
+            } else {
+                sqlite3_bind_null(stmt, 1);
+            }
 
+            rc = sqlite3_step(stmt);
             if (rc == SQLITE_DONE) {
                 *pRowid = rowid;
                 rc = SQLITE_OK;
@@ -419,7 +457,8 @@ static sqlite3_module vec0_module = {
     /* xSavepoint    */ nullptr,
     /* xRelease      */ nullptr,
     /* xRollbackTo   */ nullptr,
-    /* xShadowName   */ nullptr};
+    /* xShadowName   */ nullptr,
+    /* xIntegrity    */ nullptr};
 
 inline Result<void> register_vec0_module(sqlite3* db) {
     if (!db) {