fix(sqlite): format size_t error details with %llu in sqlite3_mprintf

SQLite's printf has no z length modifier: "%zu" parses as its %z
(free-after-use string) conversion, so every error path that formatted a
size_t dereferenced the integer as a char* and crashed. That turned
invalid input into a segfault instead of an error, e.g. CREATE VIRTUAL
TABLE ... vec0(embedding float[0]) and loading an HNSW index with a
dangling entry point. Use %llu with explicit casts; the existing
test_overflow and test_persistence_fuzz cases now pass instead of
crashing.

Author: trvon

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

@@ -433,7 +433,8 @@ int save_hnsw_index(sqlite3* db, const char* schema, const char* table,
         sqlite3_finalize(stmt);
         sqlite3_exec(db, "ROLLBACK", nullptr, nullptr, nullptr);
         if (pzErr)
-            *pzErr = sqlite3_mprintf("Failed to save HNSW node %zu", failedNodeId);
+            *pzErr = sqlite3_mprintf("Failed to save HNSW node %llu",
+                                     static_cast<unsigned long long>(failedNodeId));
         return rc;
     }
 
@@ -530,7 +531,8 @@ HNSWIndex<T, Metric> load_hnsw_index(sqlite3* db, const char* schema, const char
         if (node.id != node_id) {
             sqlite3_finalize(stmt);
             if (pzErr)
-                *pzErr = sqlite3_mprintf("HNSW node id mismatch for rowid %zu", node_id);
+                *pzErr = sqlite3_mprintf("HNSW node id mismatch for rowid %llu",
+                                         static_cast<unsigned long long>(node_id));
             throw std::runtime_error("HNSW node id mismatch");
         }
         nodes.emplace(node_id, std::move(node));
@@ -546,14 +548,15 @@ HNSWIndex<T, Metric> load_hnsw_index(sqlite3* db, const char* schema, const char
 
     if (!nodes.empty() && nodes.find(entry_point_id) == nodes.end()) {
         if (pzErr)
-            *pzErr = sqlite3_mprintf("HNSW entry point %zu missing from nodes", entry_point_id);
+            *pzErr = sqlite3_mprintf("HNSW entry point %llu missing from nodes",
+                                     static_cast<unsigned long long>(entry_point_id));
         throw std::runtime_error("HNSW entry point missing from nodes");
     }
 
     for (auto& [id, node] : nodes) {
         for (auto& layer : node.edges) {
-            std::erase_if(layer,
-                          [&](size_t neighbor_id) { return nodes.find(neighbor_id) == nodes.end(); });
+            std::erase_if(
+                layer, [&](size_t neighbor_id) { return nodes.find(neighbor_id) == nodes.end(); });
         }
     }
 
@@ -606,7 +609,8 @@ int save_hnsw_node_incremental(sqlite3* db, const char* schema, const char* tabl
     sqlite3_finalize(stmt);
 
     if (rc != SQLITE_DONE && pzErr) {
-        *pzErr = sqlite3_mprintf("Failed to save HNSW node %zu", node.id);
+        *pzErr = sqlite3_mprintf("Failed to save HNSW node %llu",
+                                 static_cast<unsigned long long>(node.id));
     }
 
     return rc;
@@ -657,7 +661,8 @@ int save_hnsw_nodes_incremental(sqlite3* db, const char* schema, const char* tab
             sqlite3_finalize(stmt);
             sqlite3_exec(db, "ROLLBACK", nullptr, nullptr, nullptr);
             if (pzErr)
-                *pzErr = sqlite3_mprintf("Failed to save HNSW node %zu", node.id);
+                *pzErr = sqlite3_mprintf("Failed to save HNSW node %llu",
+                                         static_cast<unsigned long long>(node.id));
             return rc;
         }
     }

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

@@ -16,9 +16,9 @@
 #include <vector>
 #include "../distances/l2.hpp"
 #include "../index/hnsw.hpp"
+#include "../index/hnsw_persistence.hpp"
 #include "../utils/error.hpp"
 #include "parsers.hpp"
-#include "../index/hnsw_persistence.hpp"
 
 #include <unordered_map>
 #include "value.hpp"
@@ -94,9 +94,8 @@ inline void vec0_registry_remove(sqlite3* db, std::string_view schema_name,
     vec0_table_registry().erase(vec0_registry_key(db, schema_name, table_name));
 }
 template <typename Fn>
-inline auto vec0_with_table(sqlite3* db, std::string_view schema_name,
-                            std::string_view table_name, Fn&& fn)
-    -> decltype(fn(static_cast<Vec0Table*>(nullptr))) {
+inline auto vec0_with_table(sqlite3* db, std::string_view schema_name, std::string_view table_name,
+                            Fn&& fn) -> decltype(fn(static_cast<Vec0Table*>(nullptr))) {
     std::lock_guard<std::mutex> lk(vec0_registry_mutex());
     auto& reg = vec0_table_registry();
     auto it = reg.find(vec0_registry_key(db, schema_name, table_name));
@@ -341,9 +340,8 @@ vec0_run_ann_query(Vec0Table* table, const Value& query_value, size_t k, size_t
             const size_t entry_count = std::min(kMaxRouteEntryPoints, ordered_rowids.size());
             route_entry_points.reserve(entry_count);
             for (size_t i = 0; i < entry_count; ++i) {
-                const size_t index = entry_count == 1
-                                         ? 0
-                                         : i * (ordered_rowids.size() - 1) / (entry_count - 1);
+                const size_t index =
+                    entry_count == 1 ? 0 : i * (ordered_rowids.size() - 1) / (entry_count - 1);
                 route_entry_points.push_back(static_cast<size_t>(ordered_rowids[index]));
             }
         }
@@ -605,8 +603,9 @@ inline int vec0Create(sqlite3* db, void* pAux, int argc, const char* const* argv
     parse_vec0_schema(argc, argv, embedding_col, dims);
 
     if (dims == 0 || dims > kMaxVec0Dimensions) {
-        *pzErr = sqlite3_mprintf("vec0: dimensions must be in [1, %zu], got %zu",
-                                 kMaxVec0Dimensions, dims);
+        *pzErr = sqlite3_mprintf("vec0: dimensions must be in [1, %llu], got %llu",
+                                 static_cast<unsigned long long>(kMaxVec0Dimensions),
+                                 static_cast<unsigned long long>(dims));
         return SQLITE_ERROR;
     }
     if (embedding_col.empty() || embedding_col.find('"') != std::string::npos) {