From 6ac9bb0177e5158c76c5d2a54d4611e09e5f419f Mon Sep 17 00:00:00 2001 From: lichen2015 Date: Thu, 2 Apr 2026 14:54:03 +0800 Subject: [PATCH] fix: refact c struct name (#302) --- examples/c/basic_example.c | 42 +- examples/c/collection_schema_example.c | 32 +- examples/c/doc_example.c | 61 +- examples/c/field_schema_example.c | 47 +- examples/c/index_example.c | 59 +- examples/c/optimized_example.c | 35 +- src/binding/c/CMakeLists.txt | 44 +- src/binding/c/c_api.cc | 936 ++++++++--------- src/include/zvec/c_api.h | 1341 ++++++++++++------------ tests/c/c_api_test.c | 696 ++++++------ tests/c/utils.c | 176 ++-- tests/c/utils.h | 97 +- 12 files changed, 1806 insertions(+), 1760 deletions(-) diff --git a/examples/c/basic_example.c b/examples/c/basic_example.c index 5b95c3b..efe1803 100644 --- a/examples/c/basic_example.c +++ b/examples/c/basic_example.c @@ -20,7 +20,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -34,19 +35,19 @@ static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { /** * @brief Create a simple test collection using CollectionSchema */ -static ZVecErrorCode create_simple_test_collection( - ZVecCollection **collection) { +static zvec_error_code_t create_simple_test_collection( + zvec_collection_t **collection) { // Create collection schema using C API - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("test_collection"); if (!schema) { return ZVEC_ERROR_INTERNAL_ERROR; } - ZVecErrorCode error = ZVEC_OK; + zvec_error_code_t error = ZVEC_OK; // Create index parameters using new API - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params) { zvec_collection_schema_destroy(schema); @@ -54,7 +55,8 @@ static ZVecErrorCode create_simple_test_collection( } zvec_index_params_set_invert_params(invert_params, true, false); - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params) { zvec_index_params_destroy(invert_params); zvec_collection_schema_destroy(schema); @@ -64,7 +66,7 @@ static ZVecErrorCode create_simple_test_collection( zvec_index_params_set_hnsw_params(hnsw_params, 16, 200); // Create and add ID field (primary key) - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_STRING, false, 0); zvec_field_schema_set_index_params(id_field, invert_params); error = zvec_collection_schema_add_field(schema, id_field); @@ -76,7 +78,7 @@ static ZVecErrorCode create_simple_test_collection( } // Create text field (inverted index) - ZVecFieldSchema *text_field = + zvec_field_schema_t *text_field = zvec_field_schema_create("text", ZVEC_DATA_TYPE_STRING, true, 0); zvec_field_schema_set_index_params(text_field, invert_params); error = zvec_collection_schema_add_field(schema, text_field); @@ -88,7 +90,7 @@ static ZVecErrorCode create_simple_test_collection( } // Create embedding field (HNSW index) - ZVecFieldSchema *embedding_field = zvec_field_schema_create( + zvec_field_schema_t *embedding_field = zvec_field_schema_create( "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, false, 3); zvec_field_schema_set_index_params(embedding_field, hnsw_params); error = zvec_collection_schema_add_field(schema, embedding_field); @@ -104,7 +106,7 @@ static ZVecErrorCode create_simple_test_collection( zvec_index_params_destroy(hnsw_params); // Use default options - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { zvec_collection_schema_destroy(schema); return ZVEC_ERROR_RESOURCE_EXHAUSTED; @@ -127,10 +129,10 @@ static ZVecErrorCode create_simple_test_collection( int main() { printf("=== ZVec C API Basic Example ===\n\n"); - ZVecErrorCode error; + zvec_error_code_t error; // Create collection using simplified function - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = create_simple_test_collection(&collection); if (handle_error(error, "creating collection") != ZVEC_OK) { return 1; @@ -141,7 +143,7 @@ int main() { float vector1[] = {0.1f, 0.2f, 0.3f}; float vector2[] = {0.4f, 0.5f, 0.6f}; - ZVecDoc *docs[2]; + zvec_doc_t *docs[2]; for (int i = 0; i < 2; ++i) { docs[i] = zvec_doc_create(); if (!docs[i]) { @@ -175,7 +177,7 @@ int main() { // Insert documents size_t success_count = 0; size_t error_count = 0; - error = zvec_collection_insert(collection, (const ZVecDoc **)docs, 2, + error = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 2, &success_count, &error_count); if (handle_error(error, "inserting documents") != ZVEC_OK) { zvec_collection_destroy(collection); @@ -196,7 +198,7 @@ int main() { } // Get collection statistics - ZVecCollectionStats *stats = NULL; + zvec_collection_stats_t *stats = NULL; error = zvec_collection_get_stats(collection, &stats); if (handle_error(error, "getting collection stats") == ZVEC_OK) { printf("✓ Collection stats - Document count: %llu\n", @@ -207,7 +209,7 @@ int main() { printf("Testing vector query...\n"); // Query documents - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); if (!query) { fprintf(stderr, "Failed to create vector query\n"); zvec_collection_destroy(collection); @@ -221,9 +223,9 @@ int main() { zvec_vector_query_set_include_vector(query, true); zvec_vector_query_set_include_doc_id(query, true); - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, + error = zvec_collection_query(collection, (const zvec_vector_query_t *)query, &results, &result_count); if (error != ZVEC_OK) { @@ -242,7 +244,7 @@ int main() { // Process query results for (size_t i = 0; i < result_count && i < 5; ++i) { - const ZVecDoc *doc = results[i]; + const zvec_doc_t *doc = results[i]; const char *pk = zvec_doc_get_pk_copy(doc); printf(" Result %zu: PK=%s, DocID=%llu, Score=%.4f\n", i + 1, diff --git a/examples/c/collection_schema_example.c b/examples/c/collection_schema_example.c index 38789c1..a2299b7 100644 --- a/examples/c/collection_schema_example.c +++ b/examples/c/collection_schema_example.c @@ -20,7 +20,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -37,10 +38,10 @@ static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { int main() { printf("=== ZVec Collection Schema Example ===\n\n"); - ZVecErrorCode error; + zvec_error_code_t error; // 1. Create collection schema - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("schema_example_collection"); if (!schema) { fprintf(stderr, "Failed to create collection schema\n"); @@ -55,7 +56,7 @@ int main() { zvec_collection_schema_get_max_doc_count_per_segment(schema)); // 3. Create index parameters - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params) { fprintf(stderr, "Failed to create invert index parameters\n"); @@ -64,7 +65,8 @@ int main() { } zvec_index_params_set_invert_params(invert_params, true, false); - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params) { fprintf(stderr, "Failed to create HNSW index parameters\n"); zvec_index_params_destroy(invert_params); @@ -75,7 +77,7 @@ int main() { zvec_index_params_set_hnsw_params(hnsw_params, 16, 200); // 4. Create and add ID field (primary key) - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_STRING, false, 0); if (!id_field) { fprintf(stderr, "Failed to create ID field\n"); @@ -91,7 +93,7 @@ int main() { printf("✓ ID field added successfully\n"); // 5. Create and add text field with inverted index - ZVecFieldSchema *text_field = + zvec_field_schema_t *text_field = zvec_field_schema_create("content", ZVEC_DATA_TYPE_STRING, true, 0); if (!text_field) { fprintf(stderr, "Failed to create text field\n"); @@ -108,7 +110,7 @@ int main() { printf("✓ Text field with inverted index added successfully\n"); // 6. Create and add vector field with HNSW index - ZVecFieldSchema *vector_field = zvec_field_schema_create( + zvec_field_schema_t *vector_field = zvec_field_schema_create( "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); if (!vector_field) { fprintf(stderr, "Failed to create vector field\n"); @@ -130,13 +132,13 @@ int main() { // printf("✓ Total field count: %zu\n", field_count); // 8. Create collection with schema - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { fprintf(stderr, "Failed to create collection options\n"); zvec_collection_schema_destroy(schema); return 1; } - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = zvec_collection_create_and_open("./schema_example_collection", schema, options, &collection); @@ -157,7 +159,7 @@ int main() { } // 10. Create documents - ZVecDoc *docs[2]; + zvec_doc_t *docs[2]; for (int i = 0; i < 2; i++) { docs[i] = zvec_doc_create(); if (!docs[i]) { @@ -194,7 +196,7 @@ int main() { // 11. Insert documents size_t success_count = 0, error_count = 0; - error = zvec_collection_insert(collection, (const ZVecDoc **)docs, 2, + error = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 2, &success_count, &error_count); if (handle_error(error, "inserting documents") != ZVEC_OK) { // Cleanup @@ -220,7 +222,7 @@ int main() { } // 13. Query test - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); if (!query) { fprintf(stderr, "Failed to create vector query\n"); zvec_collection_destroy(collection); @@ -234,9 +236,9 @@ int main() { zvec_vector_query_set_include_vector(query, true); zvec_vector_query_set_include_doc_id(query, true); - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, + error = zvec_collection_query(collection, (const zvec_vector_query_t *)query, &results, &result_count); if (error == ZVEC_OK) { printf("✓ Vector query successful - Returned %zu results\n", result_count); diff --git a/examples/c/doc_example.c b/examples/c/doc_example.c index 3604254..3ca8a2a 100644 --- a/examples/c/doc_example.c +++ b/examples/c/doc_example.c @@ -22,7 +22,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -36,10 +37,10 @@ static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { /** * @brief Create a test document with all data types * @param doc_index Document index for generating unique data - * @return ZVecDoc* Created document pointer + * @return zvec_doc_t* Created document pointer */ -static ZVecDoc *create_full_type_test_doc(int doc_index) { - ZVecDoc *doc = zvec_doc_create(); +static zvec_doc_t *create_full_type_test_doc(int doc_index) { + zvec_doc_t *doc = zvec_doc_create(); if (!doc) { fprintf(stderr, "Failed to create document\n"); return NULL; @@ -107,7 +108,7 @@ static ZVecDoc *create_full_type_test_doc(int doc_index) { /** * @brief Compare two documents for equality */ -static bool compare_documents(const ZVecDoc *doc1, const ZVecDoc *doc2) { +static bool compare_documents(const zvec_doc_t *doc1, const zvec_doc_t *doc2) { if (!doc1 || !doc2) return false; // Compare primary keys @@ -128,7 +129,7 @@ static bool compare_documents(const ZVecDoc *doc1, const ZVecDoc *doc2) { * @param doc The document to print * @param doc_index Document index for identification */ -static void print_doc(const ZVecDoc *doc, int doc_index) { +static void print_doc(const zvec_doc_t *doc, int doc_index) { if (!doc) { printf("Document %d: NULL document\n", doc_index); return; @@ -154,7 +155,7 @@ static void print_doc(const ZVecDoc *doc, int doc_index) { // ID field (using pointer function for strings) const void *id_value = NULL; size_t id_size = 0; - ZVecErrorCode error = zvec_doc_get_field_value_pointer( + zvec_error_code_t error = zvec_doc_get_field_value_pointer( doc, "id", ZVEC_DATA_TYPE_STRING, &id_value, &id_size); if (error == ZVEC_OK && id_value) { printf(" id: %.*s\n", (int)id_size, (const char *)id_value); @@ -263,10 +264,10 @@ static void print_doc(const ZVecDoc *doc, int doc_index) { int main() { printf("=== ZVec Document Example ===\n\n"); - ZVecErrorCode error; + zvec_error_code_t error; // 1. Create collection schema for document testing - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("doc_example_collection"); if (!schema) { fprintf(stderr, "Failed to create collection schema\n"); @@ -275,7 +276,7 @@ int main() { printf("✓ Collection schema created\n"); // 2. Create index parameters - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params) { fprintf(stderr, "Failed to create invert index parameters\n"); @@ -284,7 +285,8 @@ int main() { } zvec_index_params_set_invert_params(invert_params, true, false); - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params) { fprintf(stderr, "Failed to create HNSW index parameters\n"); zvec_index_params_destroy(invert_params); @@ -298,7 +300,7 @@ int main() { printf("Creating fields for all data types...\n"); // Id field with inverted index - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_STRING, false, 0); if (id_field) { zvec_field_schema_set_index_params(id_field, invert_params); @@ -309,17 +311,17 @@ int main() { } // Scalar fields - ZVecFieldSchema *string_field = + zvec_field_schema_t *string_field = zvec_field_schema_create("string_field", ZVEC_DATA_TYPE_STRING, true, 0); - ZVecFieldSchema *bool_field = + zvec_field_schema_t *bool_field = zvec_field_schema_create("bool_field", ZVEC_DATA_TYPE_BOOL, true, 0); - ZVecFieldSchema *int32_field = + zvec_field_schema_t *int32_field = zvec_field_schema_create("int32_field", ZVEC_DATA_TYPE_INT32, true, 0); - ZVecFieldSchema *int64_field = + zvec_field_schema_t *int64_field = zvec_field_schema_create("int64_field", ZVEC_DATA_TYPE_INT64, true, 0); - ZVecFieldSchema *float_field = + zvec_field_schema_t *float_field = zvec_field_schema_create("float_field", ZVEC_DATA_TYPE_FLOAT, true, 0); - ZVecFieldSchema *double_field = + zvec_field_schema_t *double_field = zvec_field_schema_create("double_field", ZVEC_DATA_TYPE_DOUBLE, true, 0); if (string_field) zvec_collection_schema_add_field(schema, string_field); @@ -330,9 +332,9 @@ int main() { if (double_field) zvec_collection_schema_add_field(schema, double_field); // Vector fields - ZVecFieldSchema *vector_fp32_field = zvec_field_schema_create( + zvec_field_schema_t *vector_fp32_field = zvec_field_schema_create( "vector_fp32", ZVEC_DATA_TYPE_VECTOR_FP32, false, 3); - ZVecFieldSchema *large_vector_field = zvec_field_schema_create( + zvec_field_schema_t *large_vector_field = zvec_field_schema_create( "large_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 16); if (vector_fp32_field) { @@ -352,13 +354,13 @@ int main() { } // 4. Create collection - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { fprintf(stderr, "Failed to create collection options\n"); zvec_collection_schema_destroy(schema); return -1; } - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = zvec_collection_create_and_open("./doc_example_collection", schema, options, &collection); @@ -374,7 +376,8 @@ int main() { #define DOC_COUNT 5 // Use dynamic allocation for MSVC compatibility (no VLA support) - ZVecDoc **test_docs = (ZVecDoc **)malloc(DOC_COUNT * sizeof(ZVecDoc *)); + zvec_doc_t **test_docs = + (zvec_doc_t **)malloc(DOC_COUNT * sizeof(zvec_doc_t *)); if (!test_docs) { fprintf(stderr, "Failed to allocate test documents\n"); goto cleanup; @@ -402,7 +405,7 @@ int main() { // Insert documents size_t success_count = 0, error_count = 0; - error = zvec_collection_insert(collection, (const ZVecDoc **)test_docs, + error = zvec_collection_insert(collection, (const zvec_doc_t **)test_docs, DOC_COUNT, &success_count, &error_count); if (handle_error(error, "inserting documents") == ZVEC_OK) { printf("✓ Documents inserted - Success: %zu, Failed: %zu\n", success_count, @@ -419,7 +422,7 @@ int main() { // Use the first document's vector for querying float query_vector[] = {0.0f, 0.0f, 0.0f}; - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); if (!query) { fprintf(stderr, "Failed to create vector query\n"); zvec_collection_destroy(collection); @@ -433,10 +436,10 @@ int main() { zvec_vector_query_set_include_vector(query, true); zvec_vector_query_set_include_doc_id(query, true); - ZVecDoc **query_results = NULL; + zvec_doc_t **query_results = NULL; size_t result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, + error = zvec_collection_query(collection, (const zvec_vector_query_t *)query, &query_results, &result_count); if (handle_error(error, "querying documents") != ZVEC_OK) { query_results = NULL; @@ -483,10 +486,10 @@ int main() { // Create filtered query zvec_vector_query_set_filter(query, "string_field = 'string_field_0'"); - ZVecDoc **filtered_results = NULL; + zvec_doc_t **filtered_results = NULL; size_t filtered_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, + error = zvec_collection_query(collection, (const zvec_vector_query_t *)query, &filtered_results, &filtered_count); if (handle_error(error, "filtered querying") == ZVEC_OK) { printf("Filtered query returned %zu results\n", filtered_count); diff --git a/examples/c/field_schema_example.c b/examples/c/field_schema_example.c index 036d67e..6279b42 100644 --- a/examples/c/field_schema_example.c +++ b/examples/c/field_schema_example.c @@ -20,7 +20,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -37,10 +38,10 @@ static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { int main() { printf("=== ZVec Field Schema Example ===\n\n"); - ZVecErrorCode error; + zvec_error_code_t error; // 1. Create collection schema - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("field_example_collection"); if (!schema) { fprintf(stderr, "Failed to create collection schema\n"); @@ -49,7 +50,7 @@ int main() { printf("✓ Collection schema created successfully\n"); // 2. Create different types of index parameters - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params) { fprintf(stderr, "Failed to create invert index parameters\n"); @@ -58,7 +59,8 @@ int main() { } zvec_index_params_set_invert_params(invert_params, true, false); - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params) { fprintf(stderr, "Failed to create HNSW index parameters\n"); zvec_index_params_destroy(invert_params); @@ -68,7 +70,8 @@ int main() { zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_COSINE); zvec_index_params_set_hnsw_params(hnsw_params, 16, 200); - ZVecIndexParams *flat_params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); + zvec_index_params_t *flat_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); if (!flat_params) { fprintf(stderr, "Failed to create Flat index parameters\n"); zvec_index_params_destroy(invert_params); @@ -91,7 +94,7 @@ int main() { printf("Creating scalar fields...\n"); // String field with inverted index - ZVecFieldSchema *name_field = + zvec_field_schema_t *name_field = zvec_field_schema_create("name", ZVEC_DATA_TYPE_STRING, false, 0); if (name_field) { zvec_field_schema_set_index_params(name_field, invert_params); @@ -102,7 +105,7 @@ int main() { } // Integer field - ZVecFieldSchema *age_field = + zvec_field_schema_t *age_field = zvec_field_schema_create("age", ZVEC_DATA_TYPE_INT32, true, 0); if (age_field) { error = zvec_collection_schema_add_field(schema, age_field); @@ -112,7 +115,7 @@ int main() { } // Float field - ZVecFieldSchema *score_field = + zvec_field_schema_t *score_field = zvec_field_schema_create("score", ZVEC_DATA_TYPE_FLOAT, true, 0); if (score_field) { error = zvec_collection_schema_add_field(schema, score_field); @@ -122,7 +125,7 @@ int main() { } // Boolean field - ZVecFieldSchema *active_field = + zvec_field_schema_t *active_field = zvec_field_schema_create("active", ZVEC_DATA_TYPE_BOOL, false, 0); if (active_field) { error = zvec_collection_schema_add_field(schema, active_field); @@ -135,7 +138,7 @@ int main() { printf("Creating vector fields...\n"); // Small dimension vector with HNSW index - ZVecFieldSchema *small_vector_field = zvec_field_schema_create( + zvec_field_schema_t *small_vector_field = zvec_field_schema_create( "small_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 32); if (small_vector_field) { zvec_field_schema_set_index_params(small_vector_field, hnsw_params); @@ -147,7 +150,7 @@ int main() { } // Medium dimension vector with Flat index - ZVecFieldSchema *medium_vector_field = zvec_field_schema_create( + zvec_field_schema_t *medium_vector_field = zvec_field_schema_create( "medium_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); if (medium_vector_field) { zvec_field_schema_set_index_params(medium_vector_field, flat_params); @@ -160,7 +163,7 @@ int main() { } // Large dimension vector with HNSW index - ZVecFieldSchema *large_vector_field = zvec_field_schema_create( + zvec_field_schema_t *large_vector_field = zvec_field_schema_create( "large_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 512); if (large_vector_field) { zvec_field_schema_set_index_params(large_vector_field, hnsw_params); @@ -172,13 +175,13 @@ int main() { } // 5. Create collection with the schema - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { fprintf(stderr, "Failed to create collection options\n"); zvec_collection_schema_destroy(schema); return -1; } - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = zvec_collection_create_and_open("./field_example_collection", schema, options, &collection); @@ -192,8 +195,8 @@ int main() { // 6. Create test documents with various field types printf("Creating test documents...\n"); - ZVecDoc *doc1 = zvec_doc_create(); - ZVecDoc *doc2 = zvec_doc_create(); + zvec_doc_t *doc1 = zvec_doc_create(); + zvec_doc_t *doc2 = zvec_doc_create(); if (!doc1 || !doc2) { fprintf(stderr, "Failed to create documents\n"); @@ -261,9 +264,9 @@ int main() { large_vec2, 512 * sizeof(float)); // 7. Insert documents - ZVecDoc *docs[] = {doc1, doc2}; + zvec_doc_t *docs[] = {doc1, doc2}; size_t success_count = 0, error_count = 0; - error = zvec_collection_insert(collection, (const ZVecDoc **)docs, 2, + error = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 2, &success_count, &error_count); if (handle_error(error, "inserting documents") == ZVEC_OK) { printf("✓ Documents inserted - Success: %zu, Failed: %zu\n", success_count, @@ -275,7 +278,7 @@ int main() { printf("✓ Collection flushed\n"); // Test vector query on medium vector field - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); if (!query) { fprintf(stderr, "Failed to create vector query\n"); goto cleanup; @@ -287,9 +290,9 @@ int main() { zvec_vector_query_set_include_vector(query, false); zvec_vector_query_set_include_doc_id(query, true); - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, + error = zvec_collection_query(collection, (const zvec_vector_query_t *)query, &results, &result_count); if (error == ZVEC_OK) { printf("✓ Vector query successful - Found %zu results\n", result_count); diff --git a/examples/c/index_example.c b/examples/c/index_example.c index 9bd7d62..403c0be 100644 --- a/examples/c/index_example.c +++ b/examples/c/index_example.c @@ -20,7 +20,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -37,10 +38,10 @@ static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { int main() { printf("=== ZVec Index Example ===\n\n"); - ZVecErrorCode error; + zvec_error_code_t error; // 1. Create collection schema - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("index_example_collection"); if (!schema) { fprintf(stderr, "Failed to create collection schema\n"); @@ -52,7 +53,7 @@ int main() { printf("Creating index parameters...\n"); // Inverted index parameters - ZVecIndexParams *invert_params_standard = + zvec_index_params_t *invert_params_standard = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params_standard) { fprintf(stderr, "Failed to create invert index parameters (standard)\n"); @@ -61,7 +62,7 @@ int main() { } zvec_index_params_set_invert_params(invert_params_standard, true, false); - ZVecIndexParams *invert_params_extended = + zvec_index_params_t *invert_params_extended = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!invert_params_extended) { fprintf(stderr, "Failed to create invert index parameters (extended)\n"); @@ -72,7 +73,7 @@ int main() { zvec_index_params_set_invert_params(invert_params_extended, true, true); // HNSW index parameters with different configurations - ZVecIndexParams *hnsw_params_fast = + zvec_index_params_t *hnsw_params_fast = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params_fast) { fprintf(stderr, "Failed to create HNSW index parameters (fast)\n"); @@ -84,7 +85,7 @@ int main() { zvec_index_params_set_metric_type(hnsw_params_fast, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params_fast, 16, 100); - ZVecIndexParams *hnsw_params_balanced = + zvec_index_params_t *hnsw_params_balanced = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params_balanced) { fprintf(stderr, "Failed to create HNSW index parameters (balanced)\n"); @@ -98,7 +99,7 @@ int main() { ZVEC_METRIC_TYPE_COSINE); zvec_index_params_set_hnsw_params(hnsw_params_balanced, 32, 200); - ZVecIndexParams *hnsw_params_accurate = + zvec_index_params_t *hnsw_params_accurate = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params_accurate) { fprintf(stderr, "Failed to create HNSW index parameters (accurate)\n"); @@ -113,7 +114,7 @@ int main() { zvec_index_params_set_hnsw_params(hnsw_params_accurate, 64, 400); // Flat index parameters - ZVecIndexParams *flat_params_l2 = + zvec_index_params_t *flat_params_l2 = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); if (!flat_params_l2) { fprintf(stderr, "Failed to create Flat index parameters (L2)\n"); @@ -127,7 +128,7 @@ int main() { } zvec_index_params_set_metric_type(flat_params_l2, ZVEC_METRIC_TYPE_L2); - ZVecIndexParams *flat_params_cosine = + zvec_index_params_t *flat_params_cosine = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); if (!flat_params_cosine) { fprintf(stderr, "Failed to create Flat index parameters (cosine)\n"); @@ -147,7 +148,7 @@ int main() { printf("Creating fields with various index types...\n"); // Fields with inverted indexes - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_STRING, false, 0); if (id_field) { zvec_field_schema_set_index_params(id_field, invert_params_standard); @@ -157,7 +158,7 @@ int main() { } } - ZVecFieldSchema *category_field = + zvec_field_schema_t *category_field = zvec_field_schema_create("category", ZVEC_DATA_TYPE_STRING, true, 0); if (category_field) { zvec_field_schema_set_index_params(category_field, invert_params_extended); @@ -168,7 +169,7 @@ int main() { } // Vector fields with HNSW indexes (different configurations) - ZVecFieldSchema *fast_search_field = zvec_field_schema_create( + zvec_field_schema_t *fast_search_field = zvec_field_schema_create( "fast_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 64); if (fast_search_field) { zvec_field_schema_set_index_params(fast_search_field, hnsw_params_fast); @@ -178,7 +179,7 @@ int main() { } } - ZVecFieldSchema *balanced_field = zvec_field_schema_create( + zvec_field_schema_t *balanced_field = zvec_field_schema_create( "balanced_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); if (balanced_field) { zvec_field_schema_set_index_params(balanced_field, hnsw_params_balanced); @@ -188,7 +189,7 @@ int main() { } } - ZVecFieldSchema *accurate_field = zvec_field_schema_create( + zvec_field_schema_t *accurate_field = zvec_field_schema_create( "accurate_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 256); if (accurate_field) { zvec_field_schema_set_index_params(accurate_field, hnsw_params_accurate); @@ -199,7 +200,7 @@ int main() { } // Vector field with Flat index - ZVecFieldSchema *exact_field = zvec_field_schema_create( + zvec_field_schema_t *exact_field = zvec_field_schema_create( "exact_vector", ZVEC_DATA_TYPE_VECTOR_FP32, false, 32); if (exact_field) { zvec_field_schema_set_index_params(exact_field, flat_params_l2); @@ -210,13 +211,13 @@ int main() { } // 4. Create collection - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { fprintf(stderr, "Failed to create collection options\n"); zvec_collection_schema_destroy(schema); return -1; } - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = zvec_collection_create_and_open("./index_example_collection", schema, options, &collection); @@ -230,7 +231,7 @@ int main() { // 5. Create test data printf("Creating test documents...\n"); - ZVecDoc *docs[3]; + zvec_doc_t *docs[3]; for (int i = 0; i < 3; i++) { docs[i] = zvec_doc_create(); if (!docs[i]) { @@ -297,7 +298,7 @@ int main() { // 6. Insert documents size_t success_count = 0, error_count = 0; - error = zvec_collection_insert(collection, (const ZVecDoc **)docs, 3, + error = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 3, &success_count, &error_count); if (handle_error(error, "inserting documents") == ZVEC_OK) { printf("✓ Documents inserted - Success: %zu, Failed: %zu\n", success_count, @@ -319,7 +320,7 @@ int main() { printf("Testing various index queries...\n"); // Test HNSW query (balanced) - ZVecVectorQuery *hnsw_query = zvec_vector_query_create(); + zvec_vector_query_t *hnsw_query = zvec_vector_query_create(); if (!hnsw_query) { fprintf(stderr, "Failed to create HNSW query\n"); goto cleanup; @@ -332,10 +333,11 @@ int main() { zvec_vector_query_set_include_vector(hnsw_query, false); zvec_vector_query_set_include_doc_id(hnsw_query, true); - ZVecDoc **hnsw_results = NULL; + zvec_doc_t **hnsw_results = NULL; size_t hnsw_result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)hnsw_query, - &hnsw_results, &hnsw_result_count); + error = + zvec_collection_query(collection, (const zvec_vector_query_t *)hnsw_query, + &hnsw_results, &hnsw_result_count); if (error == ZVEC_OK) { printf("✓ HNSW query successful - Found %zu results\n", hnsw_result_count); zvec_docs_free(hnsw_results, hnsw_result_count); @@ -343,7 +345,7 @@ int main() { zvec_vector_query_destroy(hnsw_query); // Test Flat query (exact) - ZVecVectorQuery *flat_query = zvec_vector_query_create(); + zvec_vector_query_t *flat_query = zvec_vector_query_create(); if (!flat_query) { fprintf(stderr, "Failed to create Flat query\n"); goto cleanup; @@ -356,10 +358,11 @@ int main() { zvec_vector_query_set_include_vector(flat_query, false); zvec_vector_query_set_include_doc_id(flat_query, true); - ZVecDoc **flat_results = NULL; + zvec_doc_t **flat_results = NULL; size_t flat_result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)flat_query, - &flat_results, &flat_result_count); + error = + zvec_collection_query(collection, (const zvec_vector_query_t *)flat_query, + &flat_results, &flat_result_count); if (error == ZVEC_OK) { printf("✓ Flat (exact) query successful - Found %zu results\n", flat_result_count); diff --git a/examples/c/optimized_example.c b/examples/c/optimized_example.c index 8f196b3..28be5c2 100644 --- a/examples/c/optimized_example.c +++ b/examples/c/optimized_example.c @@ -21,7 +21,8 @@ /** * @brief Print error message and return error code */ -static ZVecErrorCode handle_error(ZVecErrorCode error, const char *context) { +static zvec_error_code_t handle_error(zvec_error_code_t error, + const char *context) { if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -58,10 +59,10 @@ int main() { const char *version = zvec_get_version(); printf("ZVec Version: %s\n\n", version ? version : "Unknown"); - ZVecErrorCode error; + zvec_error_code_t error; // 1. Create optimized collection schema - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("optimized_example_collection"); if (!schema) { fprintf(stderr, "Failed to create collection schema\n"); @@ -70,7 +71,8 @@ int main() { printf("✓ Collection schema created\n"); // 2. Create optimized index parameters - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!hnsw_params) { fprintf(stderr, "Failed to create HNSW index parameters\n"); zvec_collection_schema_destroy(schema); @@ -80,11 +82,11 @@ int main() { zvec_index_params_set_hnsw_params(hnsw_params, 32, 200); // 3. Create fields with optimized configuration - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_STRING, false, 0); - ZVecFieldSchema *text_field = + zvec_field_schema_t *text_field = zvec_field_schema_create("text", ZVEC_DATA_TYPE_STRING, true, 0); - ZVecFieldSchema *embedding_field = zvec_field_schema_create( + zvec_field_schema_t *embedding_field = zvec_field_schema_create( "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); if (!id_field || !text_field || !embedding_field) { @@ -109,7 +111,7 @@ int main() { printf("✓ Fields configured with indexes\n"); // 4. Create collection with optimized options - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); if (!options) { fprintf(stderr, "Failed to create collection options\n"); goto cleanup_fields; @@ -117,7 +119,7 @@ int main() { zvec_collection_options_set_enable_mmap( options, true); // Enable memory mapping for better performance - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; error = zvec_collection_create_and_open("./optimized_example_collection", schema, options, &collection); zvec_collection_options_destroy(options); @@ -141,7 +143,7 @@ int main() { ? DOC_COUNT - batch_start : BATCH_SIZE; - ZVecDoc **batch_docs = malloc(current_batch_size * sizeof(ZVecDoc *)); + zvec_doc_t **batch_docs = malloc(current_batch_size * sizeof(zvec_doc_t *)); if (!batch_docs) { fprintf(stderr, "Failed to allocate batch documents\n"); break; @@ -190,7 +192,7 @@ int main() { // Insert batch size_t success_count, error_count; - error = zvec_collection_insert(collection, (const ZVecDoc **)batch_docs, + error = zvec_collection_insert(collection, (const zvec_doc_t **)batch_docs, current_batch_size, &success_count, &error_count); if (handle_error(error, "inserting batch") != ZVEC_OK) { @@ -233,7 +235,7 @@ int main() { goto cleanup_collection; } - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); if (!query) { fprintf(stderr, "Failed to create vector query\n"); free(query_vector); @@ -250,11 +252,12 @@ int main() { start_time = clock(); for (int q = 0; q < QUERY_COUNT; q++) { - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; - error = zvec_collection_query(collection, (const ZVecVectorQuery *)query, - &results, &result_count); + error = + zvec_collection_query(collection, (const zvec_vector_query_t *)query, + &results, &result_count); if (error != ZVEC_OK) { char *error_msg = NULL; zvec_get_last_error(&error_msg); @@ -281,7 +284,7 @@ int main() { zvec_vector_query_destroy(query); // 8. Memory usage information - ZVecCollectionStats *stats = NULL; + zvec_collection_stats_t *stats = NULL; error = zvec_collection_get_stats(collection, &stats); if (error == ZVEC_OK && stats) { printf("Collection Statistics:\n"); diff --git a/src/binding/c/CMakeLists.txt b/src/binding/c/CMakeLists.txt index 7ca8604..3007478 100644 --- a/src/binding/c/CMakeLists.txt +++ b/src/binding/c/CMakeLists.txt @@ -185,12 +185,46 @@ else() ${CMAKE_DL_LIBS} ) - # Static link libstdc++ to avoid runtime dependency - # Must be done in target_link_options to ensure correct order - target_link_options(zvec_c_api PRIVATE - -static-libstdc++ - -static-libgcc + # Link C++ standard library appropriately for the platform + # On Linux, we need to explicitly link libstdc++ + # Try static linking first, fall back to dynamic + + set(STATIC_LIBS_FOUND FALSE) + + # Try to find static libraries using compiler's built-in search + execute_process( + COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libstdc++.a + OUTPUT_VARIABLE LIBSTDCPP_A_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE ) + execute_process( + COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libgcc.a + OUTPUT_VARIABLE LIBGCC_A_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # Check if both static libraries exist (not just filename returned) + # If library not found, -print-file-name returns just the filename without path + if(EXISTS "${LIBSTDCPP_A_PATH}" AND EXISTS "${LIBGCC_A_PATH}") + # Verify we got actual paths, not just filenames + if(IS_ABSOLUTE "${LIBSTDCPP_A_PATH}" AND IS_ABSOLUTE "${LIBGCC_A_PATH}") + set(STATIC_LIBS_FOUND TRUE) + message(STATUS "Found static libraries: ${LIBSTDCPP_A_PATH}") + endif() + endif() + + if(STATIC_LIBS_FOUND) + # Both static libraries found - use them + target_link_options(zvec_c_api PRIVATE + -static-libstdc++ + -static-libgcc + ) + message(STATUS "Using static libstdc++ and libgcc") + else() + # Fall back to dynamic linking + # Note: We still need to link the libraries, just not statically + message(STATUS "Static libraries not found, using dynamic linking for libstdc++ and libgcc") + endif() endif() # Include directories diff --git a/src/binding/c/c_api.cc b/src/binding/c/c_api.cc index 255b03a..9144836 100644 --- a/src/binding/c/c_api.cc +++ b/src/binding/c/c_api.cc @@ -73,7 +73,7 @@ SET_LAST_ERROR(ZVEC_ERROR_UNKNOWN, std::string("Exception: ") + e.what()); \ } -// For functions returning ZVecErrorCode - complete try-catch wrapper +// For functions returning zvec_error_code_t - complete try-catch wrapper #define ZVEC_TRY_BEGIN_CODE ZVEC_TRY_BEGIN_VOID #define ZVEC_CATCH_END_CODE(code_on_error) \ } \ @@ -143,7 +143,7 @@ static std::mutex g_init_mutex; // Thread-local storage for error information static thread_local std::string last_error_message; -static thread_local ZVecErrorDetails last_error_details; +static thread_local zvec_error_details_t last_error_details; // Helper function: set error information (noexcept to avoid exceptions in error handling) static void set_last_error(const std::string &msg) noexcept { @@ -162,7 +162,7 @@ static void set_last_error(const std::string &msg) noexcept { } // Error setting function with detailed information (noexcept to avoid exceptions in error handling) -static void set_last_error_details(ZVecErrorCode code, const std::string &msg, +static void set_last_error_details(zvec_error_code_t code, const std::string &msg, const char *file = nullptr, int line = 0, const char *function = nullptr) noexcept { try { @@ -222,7 +222,7 @@ int zvec_get_version_patch(void) { // String management functions implementation // ============================================================================= -ZVecString *zvec_string_create(const char *str) { +zvec_string_t *zvec_string_create(const char *str) { if (!str) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "String pointer cannot be null"); @@ -230,10 +230,10 @@ ZVecString *zvec_string_create(const char *str) { } size_t len = strlen(str); - ZVecString *zstr = static_cast(malloc(sizeof(ZVecString))); + zvec_string_t *zstr = static_cast(malloc(sizeof(zvec_string_t))); if (!zstr) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, - "Failed to allocate memory for ZVecString"); + "Failed to allocate memory for zvec_string_t"); return nullptr; } @@ -252,17 +252,17 @@ ZVecString *zvec_string_create(const char *str) { return zstr; } -ZVecString *zvec_string_create_from_view(const ZVecStringView *view) { +zvec_string_t *zvec_string_create_from_view(const zvec_string_view_t *view) { if (!view || !view->data) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "String view or data cannot be null"); return nullptr; } - ZVecString *zstr = static_cast(malloc(sizeof(ZVecString))); + zvec_string_t *zstr = static_cast(malloc(sizeof(zvec_string_t))); if (!zstr) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, - "Failed to allocate memory for ZVecString"); + "Failed to allocate memory for zvec_string_t"); return nullptr; } @@ -283,17 +283,17 @@ ZVecString *zvec_string_create_from_view(const ZVecStringView *view) { return zstr; } -ZVecString *zvec_bin_create(const uint8_t *data, size_t length) { +zvec_string_t *zvec_bin_create(const uint8_t *data, size_t length) { if (!data) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Binary data pointer cannot be null"); return nullptr; } - ZVecString *zstr = static_cast(malloc(sizeof(ZVecString))); + zvec_string_t *zstr = static_cast(malloc(sizeof(zvec_string_t))); if (!zstr) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, - "Failed to allocate memory for ZVecString"); + "Failed to allocate memory for zvec_string_t"); return nullptr; } @@ -314,7 +314,7 @@ ZVecString *zvec_bin_create(const uint8_t *data, size_t length) { return zstr; } -ZVecString *zvec_string_copy(const ZVecString *str) { +zvec_string_t *zvec_string_copy(const zvec_string_t *str) { if (!str || !str->data) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Source string or data cannot be null"); @@ -324,7 +324,7 @@ ZVecString *zvec_string_copy(const ZVecString *str) { return zvec_string_create(str->data); } -const char *zvec_string_c_str(const ZVecString *str) { +const char *zvec_string_c_str(const zvec_string_t *str) { if (!str) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "String pointer cannot be null"); @@ -334,7 +334,7 @@ const char *zvec_string_c_str(const ZVecString *str) { return str->data; } -size_t zvec_string_length(const ZVecString *str) { +size_t zvec_string_length(const zvec_string_t *str) { if (!str) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "String pointer cannot be null"); @@ -344,7 +344,7 @@ size_t zvec_string_length(const ZVecString *str) { return str->length; } -int zvec_string_compare(const ZVecString *str1, const ZVecString *str2) { +int zvec_string_compare(const zvec_string_t *str1, const zvec_string_t *str2) { if (!str1 || !str2) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "String pointers cannot be null"); @@ -363,18 +363,18 @@ int zvec_string_compare(const ZVecString *str1, const ZVecString *str2) { // Configuration-related functions implementation // ============================================================================= -ZVecLogConfig *zvec_config_log_create_console(ZVecLogLevel level) { +zvec_log_config_t *zvec_config_log_create_console(zvec_log_level_t level) { try { auto *config = new zvec::GlobalConfig::ConsoleLogConfig( static_cast(level)); - return reinterpret_cast(config); + return reinterpret_cast(config); } catch (const std::exception &e) { SET_LAST_ERROR(ZVEC_ERROR_INTERNAL_ERROR, e.what()); return nullptr; } } -ZVecLogConfig *zvec_config_log_create_file(ZVecLogLevel level, const char *dir, +zvec_log_config_t *zvec_config_log_create_file(zvec_log_level_t level, const char *dir, const char *basename, uint32_t file_size, uint32_t overdue_days) { @@ -388,30 +388,30 @@ ZVecLogConfig *zvec_config_log_create_file(ZVecLogLevel level, const char *dir, auto *config = new zvec::GlobalConfig::FileLogConfig( static_cast(level), std::string(dir), std::string(basename), file_size, overdue_days); - return reinterpret_cast(config); + return reinterpret_cast(config); } catch (const std::exception &e) { SET_LAST_ERROR(ZVEC_ERROR_INTERNAL_ERROR, e.what()); return nullptr; } } -void zvec_config_log_destroy(ZVecLogConfig *config) { +void zvec_config_log_destroy(zvec_log_config_t *config) { if (config) { delete reinterpret_cast(config); } } -ZVecLogLevel zvec_config_log_get_level(const ZVecLogConfig *config) { +zvec_log_level_t zvec_config_log_get_level(const zvec_log_config_t *config) { if (!config) { return ZVEC_LOG_LEVEL_WARN; } auto *cpp_config = reinterpret_cast(config); - return static_cast(cpp_config->level); + return static_cast(cpp_config->level); } -ZVecErrorCode zvec_config_log_set_level(ZVecLogConfig *config, - ZVecLogLevel level) { +zvec_error_code_t zvec_config_log_set_level(zvec_log_config_t *config, + zvec_log_level_t level) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -421,7 +421,7 @@ ZVecErrorCode zvec_config_log_set_level(ZVecLogConfig *config, return ZVEC_OK; } -bool zvec_config_log_is_file_type(const ZVecLogConfig *config) { +bool zvec_config_log_is_file_type(const zvec_log_config_t *config) { if (!config) { return false; } @@ -430,59 +430,59 @@ bool zvec_config_log_is_file_type(const ZVecLogConfig *config) { return cpp_config->GetLoggerType() == zvec::FILE_LOG_TYPE_NAME; } -inline const zvec::GlobalConfig::FileLogConfig* file_config_from_config(const ZVecLogConfig *config) { +inline const zvec::GlobalConfig::FileLogConfig* file_config_from_config(const zvec_log_config_t *config) { auto *cpp_config = reinterpret_cast(config); return dynamic_cast(cpp_config); } -inline zvec::GlobalConfig::FileLogConfig* mutable_file_config_from_config(ZVecLogConfig *config) { +inline zvec::GlobalConfig::FileLogConfig* mutable_file_config_from_config(zvec_log_config_t *config) { auto *cpp_config = reinterpret_cast(config); return dynamic_cast(cpp_config); } -const char *zvec_config_log_get_dir(const ZVecLogConfig *config) { +const char *zvec_config_log_get_dir(const zvec_log_config_t *config) { auto* file_config = file_config_from_config(config); return file_config->dir.c_str(); } -ZVecErrorCode zvec_config_log_set_dir(ZVecLogConfig *config, const char *dir) { +zvec_error_code_t zvec_config_log_set_dir(zvec_log_config_t *config, const char *dir) { auto *file_config = mutable_file_config_from_config(config); file_config->dir = dir; return ZVEC_OK; } -const char *zvec_config_log_get_basename(const ZVecLogConfig *config) { +const char *zvec_config_log_get_basename(const zvec_log_config_t *config) { auto* file_config = file_config_from_config(config); return file_config->basename.c_str(); } -ZVecErrorCode zvec_config_log_set_basename(ZVecLogConfig *config, +zvec_error_code_t zvec_config_log_set_basename(zvec_log_config_t *config, const char *basename) { auto *file_config = mutable_file_config_from_config(config); file_config->basename = basename; return ZVEC_OK; } -uint32_t zvec_config_log_get_file_size(const ZVecLogConfig *config) { +uint32_t zvec_config_log_get_file_size(const zvec_log_config_t *config) { auto* file_config = file_config_from_config(config); return file_config->file_size; } -ZVecErrorCode zvec_config_log_set_file_size(ZVecLogConfig *config, +zvec_error_code_t zvec_config_log_set_file_size(zvec_log_config_t *config, uint32_t file_size) { auto *file_config = mutable_file_config_from_config(config); file_config->file_size = file_size; return ZVEC_OK; } -uint32_t zvec_config_log_get_overdue_days(const ZVecLogConfig *config) { +uint32_t zvec_config_log_get_overdue_days(const zvec_log_config_t *config) { auto* file_config = file_config_from_config(config); return file_config ? file_config->overdue_days : 0; } -ZVecErrorCode zvec_config_log_set_overdue_days(ZVecLogConfig *config, +zvec_error_code_t zvec_config_log_set_overdue_days(zvec_log_config_t *config, uint32_t days) { auto *file_config = mutable_file_config_from_config(config); file_config->overdue_days = days; @@ -493,23 +493,23 @@ ZVecErrorCode zvec_config_log_set_overdue_days(ZVecLogConfig *config, // Configuration Data Management Functions // ============================================================================ -ZVecConfigData *zvec_config_data_create(void) { +zvec_config_data_t *zvec_config_data_create(void) { try { auto *config = new zvec::GlobalConfig::ConfigData(); - return reinterpret_cast(config); + return reinterpret_cast(config); } catch (const std::exception &e) { SET_LAST_ERROR(ZVEC_ERROR_INTERNAL_ERROR, e.what()); return nullptr; } } -void zvec_config_data_destroy(ZVecConfigData *config) { +void zvec_config_data_destroy(zvec_config_data_t *config) { if (config) { delete reinterpret_cast(config); } } -ZVecErrorCode zvec_config_data_set_memory_limit(ZVecConfigData *config, +zvec_error_code_t zvec_config_data_set_memory_limit(zvec_config_data_t *config, uint64_t memory_limit_bytes) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); @@ -520,7 +520,7 @@ ZVecErrorCode zvec_config_data_set_memory_limit(ZVecConfigData *config, return ZVEC_OK; } -uint64_t zvec_config_data_get_memory_limit(const ZVecConfigData *config) { +uint64_t zvec_config_data_get_memory_limit(const zvec_config_data_t *config) { if (!config) { return 0; } @@ -529,8 +529,8 @@ uint64_t zvec_config_data_get_memory_limit(const ZVecConfigData *config) { return cpp_config->memory_limit_bytes; } -ZVecErrorCode zvec_config_data_set_log_config(ZVecConfigData *config, - ZVecLogConfig *log_config) { +zvec_error_code_t zvec_config_data_set_log_config(zvec_config_data_t *config, + zvec_log_config_t *log_config) { if (!config || !log_config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config or log_config pointer is null"); @@ -548,7 +548,7 @@ ZVecErrorCode zvec_config_data_set_log_config(ZVecConfigData *config, return ZVEC_OK; } -ZVecLogType zvec_config_data_get_log_type(const ZVecConfigData *config) { +zvec_log_type_t zvec_config_data_get_log_type(const zvec_config_data_t *config) { if (!config) { return ZVEC_LOG_TYPE_CONSOLE; } @@ -565,7 +565,7 @@ ZVecLogType zvec_config_data_get_log_type(const ZVecConfigData *config) { return ZVEC_LOG_TYPE_CONSOLE; } -ZVecErrorCode zvec_config_data_set_query_thread_count(ZVecConfigData *config, +zvec_error_code_t zvec_config_data_set_query_thread_count(zvec_config_data_t *config, uint32_t thread_count) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); @@ -576,7 +576,7 @@ ZVecErrorCode zvec_config_data_set_query_thread_count(ZVecConfigData *config, return ZVEC_OK; } -uint32_t zvec_config_data_get_query_thread_count(const ZVecConfigData *config) { +uint32_t zvec_config_data_get_query_thread_count(const zvec_config_data_t *config) { if (!config) { return 1; } @@ -585,8 +585,8 @@ uint32_t zvec_config_data_get_query_thread_count(const ZVecConfigData *config) { return cpp_config->query_thread_count; } -ZVecErrorCode zvec_config_data_set_invert_to_forward_scan_ratio( - ZVecConfigData *config, float ratio) { +zvec_error_code_t zvec_config_data_set_invert_to_forward_scan_ratio( + zvec_config_data_t *config, float ratio) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -597,7 +597,7 @@ ZVecErrorCode zvec_config_data_set_invert_to_forward_scan_ratio( } float zvec_config_data_get_invert_to_forward_scan_ratio( - const ZVecConfigData *config) { + const zvec_config_data_t *config) { if (!config) { return 0.0f; } @@ -606,8 +606,8 @@ float zvec_config_data_get_invert_to_forward_scan_ratio( return cpp_config->invert_to_forward_scan_ratio; } -ZVecErrorCode zvec_config_data_set_brute_force_by_keys_ratio( - ZVecConfigData *config, float ratio) { +zvec_error_code_t zvec_config_data_set_brute_force_by_keys_ratio( + zvec_config_data_t *config, float ratio) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -618,7 +618,7 @@ ZVecErrorCode zvec_config_data_set_brute_force_by_keys_ratio( } float zvec_config_data_get_brute_force_by_keys_ratio( - const ZVecConfigData *config) { + const zvec_config_data_t *config) { if (!config) { return 0.0f; } @@ -627,8 +627,8 @@ float zvec_config_data_get_brute_force_by_keys_ratio( return cpp_config->brute_force_by_keys_ratio; } -ZVecErrorCode zvec_config_data_set_optimize_thread_count( - ZVecConfigData *config, uint32_t thread_count) { +zvec_error_code_t zvec_config_data_set_optimize_thread_count( + zvec_config_data_t *config, uint32_t thread_count) { if (!config) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Config pointer is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -639,7 +639,7 @@ ZVecErrorCode zvec_config_data_set_optimize_thread_count( } uint32_t zvec_config_data_get_optimize_thread_count( - const ZVecConfigData *config) { + const zvec_config_data_t *config) { if (!config) { return 1; } @@ -653,7 +653,7 @@ uint32_t zvec_config_data_get_optimize_thread_count( // Initialization and cleanup interface implementation // ============================================================================= -ZVecErrorCode zvec_initialize(const ZVecConfigData *config) { +zvec_error_code_t zvec_initialize(const zvec_config_data_t *config) { std::lock_guard lock(g_init_mutex); if (g_initialized.load()) { @@ -686,7 +686,7 @@ ZVecErrorCode zvec_initialize(const ZVecConfigData *config) { return ZVEC_OK;) } -ZVecErrorCode zvec_shutdown(void) { +zvec_error_code_t zvec_shutdown(void) { std::lock_guard lock(g_init_mutex); if (!g_initialized.load()) { @@ -707,7 +707,7 @@ bool zvec_is_initialized(void) { // Error handling interface implementation // ============================================================================= -ZVecErrorCode zvec_get_last_error_details(ZVecErrorDetails *error_details) { +zvec_error_code_t zvec_get_last_error_details(zvec_error_details_t *error_details) { if (!error_details) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Error details pointer cannot be null"); @@ -724,7 +724,7 @@ void zvec_clear_error(void) { } // Helper functions: convert internal status to error code -static ZVecErrorCode status_to_error_code(const zvec::Status &status) { +static zvec_error_code_t status_to_error_code(const zvec::Status &status) { if (status.code() < zvec::StatusCode::OK || status.code() > zvec::StatusCode::UNKNOWN) { set_last_error("Unexpected status code: " + @@ -732,12 +732,12 @@ static ZVecErrorCode status_to_error_code(const zvec::Status &status) { return ZVEC_ERROR_UNKNOWN; } - return static_cast(status.code()); + return static_cast(status.code()); } // Helper function: handle Expected results template -static ZVecErrorCode handle_expected_result( +static zvec_error_code_t handle_expected_result( const tl::expected &result, T *out_value = nullptr) { if (result.has_value()) { if (out_value) { @@ -771,7 +771,7 @@ static char *copy_string(const std::string &str) { * @param results Results array to free * @param result_count Number of results */ -static void free_write_results_internal(ZVecWriteResult *results, +static void free_write_results_internal(zvec_write_result_t *results, size_t result_count) { if (!results) { return; @@ -787,9 +787,8 @@ static void free_write_results_internal(ZVecWriteResult *results, } // Helper function: convert per-doc statuses to C API write result array. -static ZVecErrorCode build_write_results( - const std::vector &statuses, - const std::vector &pks, ZVecWriteResult **results, +static zvec_error_code_t build_write_results( + const std::vector &statuses, zvec_write_result_t **results, size_t *result_count) { if (!results || !result_count) { return ZVEC_ERROR_INVALID_ARGUMENT; @@ -801,8 +800,8 @@ static ZVecErrorCode build_write_results( return ZVEC_OK; } - *results = static_cast( - calloc(*result_count, sizeof(ZVecWriteResult))); + *results = static_cast( + calloc(*result_count, sizeof(zvec_write_result_t))); if (!*results) { set_last_error("Failed to allocate memory for write results"); return ZVEC_ERROR_INTERNAL_ERROR; @@ -819,7 +818,7 @@ static ZVecErrorCode build_write_results( return ZVEC_OK; } -static std::vector collect_doc_pks(const ZVecDoc **docs, +static std::vector collect_doc_pks(const zvec_doc_t **docs, size_t doc_count) { std::vector pks; pks.reserve(doc_count); @@ -846,7 +845,7 @@ static std::vector collect_doc_pks(const ZVecDoc **docs, * a deep copy of the underlying C++ IndexParams object */ static std::shared_ptr convert_c_index_params_to_cpp( - const ZVecIndexParams *params) { + const zvec_index_params_t *params) { if (!params) { return nullptr; } @@ -918,10 +917,10 @@ void zvec_free(void *ptr) { } /** - * @brief Free a ZVecString structure + * @brief Free a zvec_string_t structure * @param str String structure to free (can be NULL) */ -void zvec_free_string(ZVecString *str) { +void zvec_free_string(zvec_string_t *str) { if (str) { if (str->data) { free((void *)str->data); @@ -935,11 +934,11 @@ void zvec_free_string(ZVecString *str) { * @param count Number of strings in the array * @return New string array, or NULL on failure */ -ZVecStringArray *zvec_string_array_create(size_t count) { - ZVecStringArray *array = (ZVecStringArray *)malloc(sizeof(ZVecStringArray)); +zvec_string_array_t *zvec_string_array_create(size_t count) { + zvec_string_array_t *array = (zvec_string_array_t *)malloc(sizeof(zvec_string_array_t)); array->count = count; - array->strings = (ZVecString *)malloc(sizeof(ZVecString) * count); - memset(array->strings, 0, sizeof(ZVecString) * count); + array->strings = (zvec_string_t *)malloc(sizeof(zvec_string_t) * count); + memset(array->strings, 0, sizeof(zvec_string_t) * count); return array; } @@ -949,12 +948,12 @@ ZVecStringArray *zvec_string_array_create(size_t count) { * @param count Number of strings * @return New string array, or NULL on failure */ -ZVecStringArray *zvec_string_array_create_from_strings(const char **strings, +zvec_string_array_t *zvec_string_array_create_from_strings(const char **strings, size_t count) { if (!strings || count == 0) { return nullptr; } - ZVecStringArray *array = zvec_string_array_create(count); + zvec_string_array_t *array = zvec_string_array_create(count); for (size_t i = 0; i < count; ++i) { zvec_string_array_add(array, i, strings[i]); } @@ -967,7 +966,7 @@ ZVecStringArray *zvec_string_array_create_from_strings(const char **strings, * @param idx Index to add at * @param str String to add */ -void zvec_string_array_add(ZVecStringArray *array, size_t idx, +void zvec_string_array_add(zvec_string_array_t *array, size_t idx, const char *str) { if (idx >= array->count) return; size_t len = strlen(str); @@ -981,7 +980,7 @@ void zvec_string_array_add(ZVecStringArray *array, size_t idx, * @brief Destroy a string array and free all memory * @param array String array to destroy (can be NULL) */ -void zvec_string_array_destroy(ZVecStringArray *array) { +void zvec_string_array_destroy(zvec_string_array_t *array) { if (!array) return; for (size_t i = 0; i < array->count; i++) { if (array->strings[i].data) { @@ -999,9 +998,9 @@ void zvec_string_array_destroy(ZVecStringArray *array) { * @return New byte array, or NULL on failure */ // Byte array helper functions -ZVecMutableByteArray *zvec_byte_array_create(size_t capacity) { - ZVecMutableByteArray *array = - (ZVecMutableByteArray *)malloc(sizeof(ZVecMutableByteArray)); +zvec_mutable_byte_array_t *zvec_byte_array_create(size_t capacity) { + zvec_mutable_byte_array_t *array = + (zvec_mutable_byte_array_t *)malloc(sizeof(zvec_mutable_byte_array_t)); if (!array) return nullptr; array->data = (uint8_t *)malloc(capacity); @@ -1020,7 +1019,7 @@ ZVecMutableByteArray *zvec_byte_array_create(size_t capacity) { * @brief Destroy a byte array and free all memory * @param array Byte array to destroy (can be NULL) */ -void zvec_byte_array_destroy(ZVecMutableByteArray *array) { +void zvec_byte_array_destroy(zvec_mutable_byte_array_t *array) { if (!array) return; if (array->data) { free(array->data); @@ -1034,8 +1033,8 @@ void zvec_byte_array_destroy(ZVecMutableByteArray *array) { * @return New float array, or NULL on failure */ // Float array helper functions -ZVecFloatArray *zvec_float_array_create(size_t count) { - ZVecFloatArray *array = (ZVecFloatArray *)malloc(sizeof(ZVecFloatArray)); +zvec_float_array_t *zvec_float_array_create(size_t count) { + zvec_float_array_t *array = (zvec_float_array_t *)malloc(sizeof(zvec_float_array_t)); if (!array) return nullptr; array->data = (const float *)malloc(sizeof(float) * count); @@ -1053,7 +1052,7 @@ ZVecFloatArray *zvec_float_array_create(size_t count) { * @brief Destroy a float array and free all memory * @param array Float array to destroy (can be NULL) */ -void zvec_float_array_destroy(ZVecFloatArray *array) { +void zvec_float_array_destroy(zvec_float_array_t *array) { if (!array) return; if (array->data) { free((void *)array->data); @@ -1062,8 +1061,8 @@ void zvec_float_array_destroy(ZVecFloatArray *array) { } // Int64 array helper functions -ZVecInt64Array *zvec_int64_array_create(size_t count) { - ZVecInt64Array *array = (ZVecInt64Array *)malloc(sizeof(ZVecInt64Array)); +zvec_int64_array_t *zvec_int64_array_create(size_t count) { + zvec_int64_array_t *array = (zvec_int64_array_t *)malloc(sizeof(zvec_int64_array_t)); if (!array) return nullptr; array->data = (const int64_t *)malloc(sizeof(int64_t) * count); @@ -1077,7 +1076,7 @@ ZVecInt64Array *zvec_int64_array_create(size_t count) { return array; } -void zvec_int64_array_destroy(ZVecInt64Array *array) { +void zvec_int64_array_destroy(zvec_int64_array_t *array) { if (!array) return; if (array->data) { free((void *)array->data); @@ -1103,7 +1102,7 @@ void zvec_free_str_array(char **array, size_t count) { free(array); } -ZVecErrorCode zvec_get_last_error(char **error_msg) { +zvec_error_code_t zvec_get_last_error(char **error_msg) { if (!error_msg) { set_last_error("Invalid argument: error_msg cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -1119,7 +1118,7 @@ void zvec_free_uint8_array(uint8_t *array) { } } -void zvec_free_field_schema(ZVecFieldSchema *field_schema) { +void zvec_free_field_schema(zvec_field_schema_t *field_schema) { if (field_schema) { // index_params is embedded, no need to free free(field_schema); @@ -1130,22 +1129,22 @@ void zvec_free_field_schema(ZVecFieldSchema *field_schema) { // CollectionOptions functions implementation // ============================================================================= -ZVecCollectionOptions *zvec_collection_options_create(void) { +zvec_collection_options_t *zvec_collection_options_create(void) { ZVEC_TRY_RETURN_NULL( - "Failed to create ZVecCollectionOptions", + "Failed to create zvec_collection_options_t", auto *options = new zvec::CollectionOptions(); - return reinterpret_cast(options);) + return reinterpret_cast(options);) return nullptr; } -void zvec_collection_options_destroy(ZVecCollectionOptions *options) { +void zvec_collection_options_destroy(zvec_collection_options_t *options) { if (options) { delete reinterpret_cast(options); } } -ZVecErrorCode zvec_collection_options_set_enable_mmap( - ZVecCollectionOptions *options, bool enable) { +zvec_error_code_t zvec_collection_options_set_enable_mmap( + zvec_collection_options_t *options, bool enable) { if (!options) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection options pointer is null"); @@ -1157,7 +1156,7 @@ ZVecErrorCode zvec_collection_options_set_enable_mmap( } bool zvec_collection_options_get_enable_mmap( - const ZVecCollectionOptions *options) { + const zvec_collection_options_t *options) { if (!options) { return true; // Default } @@ -1165,8 +1164,8 @@ bool zvec_collection_options_get_enable_mmap( return ptr->enable_mmap_; } -ZVecErrorCode zvec_collection_options_set_max_buffer_size( - ZVecCollectionOptions *options, size_t size) { +zvec_error_code_t zvec_collection_options_set_max_buffer_size( + zvec_collection_options_t *options, size_t size) { if (!options) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection options pointer is null"); @@ -1178,7 +1177,7 @@ ZVecErrorCode zvec_collection_options_set_max_buffer_size( } size_t zvec_collection_options_get_max_buffer_size( - const ZVecCollectionOptions *options) { + const zvec_collection_options_t *options) { if (!options) { return zvec::DEFAULT_MAX_BUFFER_SIZE; // Default } @@ -1186,8 +1185,8 @@ size_t zvec_collection_options_get_max_buffer_size( return ptr->max_buffer_size_; } -ZVecErrorCode zvec_collection_options_set_read_only( - ZVecCollectionOptions *options, bool read_only) { +zvec_error_code_t zvec_collection_options_set_read_only( + zvec_collection_options_t *options, bool read_only) { if (!options) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection options pointer is null"); @@ -1199,7 +1198,7 @@ ZVecErrorCode zvec_collection_options_set_read_only( } bool zvec_collection_options_get_read_only( - const ZVecCollectionOptions *options) { + const zvec_collection_options_t *options) { if (!options) { return false; // Default } @@ -1207,29 +1206,6 @@ bool zvec_collection_options_get_read_only( return ptr->read_only_; } -ZVecErrorCode zvec_collection_options_set_max_doc_count_per_segment( - ZVecCollectionOptions *options, uint64_t count) { - if (!options) { - SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, - "Collection options pointer is null"); - return ZVEC_ERROR_INVALID_ARGUMENT; - } - // Note: max_doc_count_per_segment is now part of CollectionSchema, not - // CollectionOptions This function is kept for backward compatibility but has - // no effect - return ZVEC_OK; -} - -uint64_t zvec_collection_options_get_max_doc_count_per_segment( - const ZVecCollectionOptions *options) { - if (!options) { - return zvec::MAX_DOC_COUNT_PER_SEGMENT; // Default - } - // Note: max_doc_count_per_segment is now part of CollectionSchema, not - // CollectionOptions - return zvec::MAX_DOC_COUNT_PER_SEGMENT; -} - // ============================================================================= // CollectionStats functions implementation // ============================================================================= @@ -1239,7 +1215,7 @@ uint64_t zvec_collection_options_get_max_doc_count_per_segment( * @param stats Collection stats handle * @return Document count, or 0 if stats is NULL */ -uint64_t zvec_collection_stats_get_doc_count(const ZVecCollectionStats *stats) { +uint64_t zvec_collection_stats_get_doc_count(const zvec_collection_stats_t *stats) { if (!stats) { return 0; } @@ -1252,7 +1228,7 @@ uint64_t zvec_collection_stats_get_doc_count(const ZVecCollectionStats *stats) { * @param stats Collection stats handle * @return Number of indexes, or 0 if stats is NULL */ -size_t zvec_collection_stats_get_index_count(const ZVecCollectionStats *stats) { +size_t zvec_collection_stats_get_index_count(const zvec_collection_stats_t *stats) { if (!stats) { return 0; } @@ -1268,7 +1244,7 @@ size_t zvec_collection_stats_get_index_count(const ZVecCollectionStats *stats) { * @note Returned string is owned by stats, do not free */ const char *zvec_collection_stats_get_index_name( - const ZVecCollectionStats *stats, size_t index) { + const zvec_collection_stats_t *stats, size_t index) { if (!stats) { return nullptr; } @@ -1289,7 +1265,7 @@ const char *zvec_collection_stats_get_index_name( * @return Completeness value (0.0-1.0), or 0.0 if invalid */ float zvec_collection_stats_get_index_completeness( - const ZVecCollectionStats *stats, size_t index) { + const zvec_collection_stats_t *stats, size_t index) { if (!stats) { return 0.0f; } @@ -1312,9 +1288,9 @@ float zvec_collection_stats_get_index_completeness( * @return New index params handle, or NULL on failure * @note Caller must call zvec_index_params_destroy() to free */ -ZVecIndexParams *zvec_index_params_create(ZVecIndexType index_type) { +zvec_index_params_t *zvec_index_params_create(zvec_index_type_t index_type) { ZVEC_TRY_RETURN_NULL( - "Failed to create ZVecIndexParams", + "Failed to create zvec_index_params_t", // Create appropriate C++ IndexParams based on type with default parameters zvec::IndexParams *cpp_params = nullptr; @@ -1349,7 +1325,7 @@ ZVecIndexParams *zvec_index_params_create(ZVecIndexType index_type) { } // Return as opaque pointer (raw pointer) - return reinterpret_cast(cpp_params);) + return reinterpret_cast(cpp_params);) return nullptr; } @@ -1358,7 +1334,7 @@ ZVecIndexParams *zvec_index_params_create(ZVecIndexType index_type) { * @brief Destroy index parameters and free memory * @param params Index params to destroy (can be NULL) */ -void zvec_index_params_destroy(ZVecIndexParams *params) { +void zvec_index_params_destroy(zvec_index_params_t *params) { if (params) { delete reinterpret_cast(params); } @@ -1370,8 +1346,8 @@ void zvec_index_params_destroy(ZVecIndexParams *params) { * @param metric_type Metric type to set * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_set_metric_type(ZVecIndexParams *params, - ZVecMetricType metric_type) { +zvec_error_code_t zvec_index_params_set_metric_type(zvec_index_params_t *params, + zvec_metric_type_t metric_type) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Index params pointer cannot be null"); @@ -1394,8 +1370,8 @@ ZVecErrorCode zvec_index_params_set_metric_type(ZVecIndexParams *params, * @param params Index parameters * @return Metric type, or default (L2) if NULL or not vector index */ -ZVecMetricType zvec_index_params_get_metric_type( - const ZVecIndexParams *params) { +zvec_metric_type_t zvec_index_params_get_metric_type( + const zvec_index_params_t *params) { if (!params) { return ZVEC_METRIC_TYPE_L2; // Default } @@ -1405,7 +1381,7 @@ ZVecMetricType zvec_index_params_get_metric_type( auto *vec_params = dynamic_cast(cpp_params); if (vec_params) { - return static_cast( + return static_cast( static_cast(vec_params->metric_type())); } } @@ -1418,8 +1394,8 @@ ZVecMetricType zvec_index_params_get_metric_type( * @param quantize_type Quantization type to set * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_set_quantize_type( - ZVecIndexParams *params, ZVecQuantizeType quantize_type) { +zvec_error_code_t zvec_index_params_set_quantize_type( + zvec_index_params_t *params, zvec_quantize_type_t quantize_type) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Index params pointer cannot be null"); @@ -1443,8 +1419,8 @@ ZVecErrorCode zvec_index_params_set_quantize_type( * @param params Index parameters * @return Quantization type, or UNDEFINED if NULL or not vector index */ -ZVecQuantizeType zvec_index_params_get_quantize_type( - const ZVecIndexParams *params) { +zvec_quantize_type_t zvec_index_params_get_quantize_type( + const zvec_index_params_t *params) { if (!params) { return ZVEC_QUANTIZE_TYPE_UNDEFINED; } @@ -1454,7 +1430,7 @@ ZVecQuantizeType zvec_index_params_get_quantize_type( auto *vec_params = dynamic_cast(cpp_params); if (vec_params) { - return static_cast( + return static_cast( static_cast(vec_params->quantize_type())); } } @@ -1466,12 +1442,12 @@ ZVecQuantizeType zvec_index_params_get_quantize_type( * @param params Index parameters * @return Index type, or FLAT as default if NULL */ -ZVecIndexType zvec_index_params_get_type(const ZVecIndexParams *params) { +zvec_index_type_t zvec_index_params_get_type(const zvec_index_params_t *params) { if (!params) { return ZVEC_INDEX_TYPE_FLAT; // Default } auto *cpp_params = reinterpret_cast(params); - return static_cast( + return static_cast( static_cast(cpp_params->type())); } @@ -1482,7 +1458,7 @@ ZVecIndexType zvec_index_params_get_type(const ZVecIndexParams *params) { * @param ef_construction Construction exploration factor * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_set_hnsw_params(ZVecIndexParams *params, int m, +zvec_error_code_t zvec_index_params_set_hnsw_params(zvec_index_params_t *params, int m, int ef_construction) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -1506,7 +1482,7 @@ ZVecErrorCode zvec_index_params_set_hnsw_params(ZVecIndexParams *params, int m, * @param params Index parameters (must be HNSW type) * @return m parameter value, or 0 on error */ -int zvec_index_params_get_hnsw_m(const ZVecIndexParams *params) { +int zvec_index_params_get_hnsw_m(const zvec_index_params_t *params) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Invalid params or not HNSW index type"); @@ -1527,7 +1503,7 @@ int zvec_index_params_get_hnsw_m(const ZVecIndexParams *params) { * @param params Index parameters (must be HNSW type) * @return ef_construction parameter value, or 0 on error */ -int zvec_index_params_get_hnsw_ef_construction(const ZVecIndexParams *params) { +int zvec_index_params_get_hnsw_ef_construction(const zvec_index_params_t *params) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Invalid params or not HNSW index type"); @@ -1551,7 +1527,7 @@ int zvec_index_params_get_hnsw_ef_construction(const ZVecIndexParams *params) { * @param use_soar Whether to use SOAR optimization * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_set_ivf_params(ZVecIndexParams *params, +zvec_error_code_t zvec_index_params_set_ivf_params(zvec_index_params_t *params, int n_list, int n_iters, bool use_soar) { if (!params) { @@ -1580,7 +1556,7 @@ ZVecErrorCode zvec_index_params_set_ivf_params(ZVecIndexParams *params, * @param out_use_soar Output for use_soar (can be NULL) * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_get_ivf_params(const ZVecIndexParams *params, +zvec_error_code_t zvec_index_params_get_ivf_params(const zvec_index_params_t *params, int *out_n_list, int *out_n_iters, bool *out_use_soar) { @@ -1609,7 +1585,7 @@ ZVecErrorCode zvec_index_params_get_ivf_params(const ZVecIndexParams *params, * @param enable_wildcard Enable wildcard search * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_set_invert_params(ZVecIndexParams *params, +zvec_error_code_t zvec_index_params_set_invert_params(zvec_index_params_t *params, bool enable_range_opt, bool enable_wildcard) { if (!params) { @@ -1636,7 +1612,7 @@ ZVecErrorCode zvec_index_params_set_invert_params(ZVecIndexParams *params, * @param out_enable_wildcard Output for enable_extended_wildcard (can be NULL) * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_index_params_get_invert_params(const ZVecIndexParams *params, +zvec_error_code_t zvec_index_params_get_invert_params(const zvec_index_params_t *params, bool *out_enable_range_opt, bool *out_enable_wildcard) { if (!params) { @@ -1663,8 +1639,8 @@ ZVecErrorCode zvec_index_params_get_invert_params(const ZVecIndexParams *params, // FieldSchema management interface implementation // ============================================================================= -ZVecFieldSchema *zvec_field_schema_create(const char *name, - ZVecDataType data_type, bool nullable, +zvec_field_schema_t *zvec_field_schema_create(const char *name, + zvec_data_type_t data_type, bool nullable, uint32_t dimension) { if (!name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field name cannot be null"); @@ -1678,18 +1654,18 @@ ZVecFieldSchema *zvec_field_schema_create(const char *name, nullable); // Return as opaque pointer (raw pointer) - return reinterpret_cast(cpp_schema);) + return reinterpret_cast(cpp_schema);) return nullptr; } -void zvec_field_schema_destroy(ZVecFieldSchema *schema) { +void zvec_field_schema_destroy(zvec_field_schema_t *schema) { if (schema) { delete reinterpret_cast(schema); } } -const char *zvec_field_schema_get_name(const ZVecFieldSchema *schema) { +const char *zvec_field_schema_get_name(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1699,7 +1675,7 @@ const char *zvec_field_schema_get_name(const ZVecFieldSchema *schema) { return cpp_schema->name().c_str(); } -ZVecErrorCode zvec_field_schema_set_name(ZVecFieldSchema *schema, +zvec_error_code_t zvec_field_schema_set_name(zvec_field_schema_t *schema, const char *name) { if (!schema || !name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -1711,19 +1687,19 @@ ZVecErrorCode zvec_field_schema_set_name(ZVecFieldSchema *schema, return ZVEC_OK; } -ZVecDataType zvec_field_schema_get_data_type(const ZVecFieldSchema *schema) { +zvec_data_type_t zvec_field_schema_get_data_type(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); return ZVEC_DATA_TYPE_UNDEFINED; } auto *cpp_schema = reinterpret_cast(schema); - return static_cast( + return static_cast( static_cast(cpp_schema->data_type())); } -ZVecErrorCode zvec_field_schema_set_data_type(ZVecFieldSchema *schema, - ZVecDataType data_type) { +zvec_error_code_t zvec_field_schema_set_data_type(zvec_field_schema_t *schema, + zvec_data_type_t data_type) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1734,19 +1710,19 @@ ZVecErrorCode zvec_field_schema_set_data_type(ZVecFieldSchema *schema, return ZVEC_OK; } -ZVecDataType zvec_field_schema_get_element_data_type( - const ZVecFieldSchema *schema) { +zvec_data_type_t zvec_field_schema_get_element_data_type( + const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); return ZVEC_DATA_TYPE_UNDEFINED; } auto *cpp_schema = reinterpret_cast(schema); - return static_cast( + return static_cast( static_cast(cpp_schema->element_data_type())); } -size_t zvec_field_schema_get_element_data_size(const ZVecFieldSchema *schema) { +size_t zvec_field_schema_get_element_data_size(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1756,7 +1732,7 @@ size_t zvec_field_schema_get_element_data_size(const ZVecFieldSchema *schema) { return cpp_schema->element_data_size(); } -bool zvec_field_schema_is_vector_field(const ZVecFieldSchema *schema) { +bool zvec_field_schema_is_vector_field(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1766,7 +1742,7 @@ bool zvec_field_schema_is_vector_field(const ZVecFieldSchema *schema) { return cpp_schema->is_vector_field(); } -bool zvec_field_schema_is_dense_vector(const ZVecFieldSchema *schema) { +bool zvec_field_schema_is_dense_vector(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1776,7 +1752,7 @@ bool zvec_field_schema_is_dense_vector(const ZVecFieldSchema *schema) { return cpp_schema->is_dense_vector(); } -bool zvec_field_schema_is_sparse_vector(const ZVecFieldSchema *schema) { +bool zvec_field_schema_is_sparse_vector(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1786,7 +1762,7 @@ bool zvec_field_schema_is_sparse_vector(const ZVecFieldSchema *schema) { return cpp_schema->is_sparse_vector(); } -bool zvec_field_schema_is_nullable(const ZVecFieldSchema *schema) { +bool zvec_field_schema_is_nullable(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1796,7 +1772,7 @@ bool zvec_field_schema_is_nullable(const ZVecFieldSchema *schema) { return cpp_schema->nullable(); } -ZVecErrorCode zvec_field_schema_set_nullable(ZVecFieldSchema *schema, +zvec_error_code_t zvec_field_schema_set_nullable(zvec_field_schema_t *schema, bool nullable) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -1808,7 +1784,7 @@ ZVecErrorCode zvec_field_schema_set_nullable(ZVecFieldSchema *schema, return ZVEC_OK; } -bool zvec_field_schema_has_invert_index(const ZVecFieldSchema *schema) { +bool zvec_field_schema_has_invert_index(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1818,7 +1794,7 @@ bool zvec_field_schema_has_invert_index(const ZVecFieldSchema *schema) { return cpp_schema->has_invert_index(); } -bool zvec_field_schema_is_array_type(const ZVecFieldSchema *schema) { +bool zvec_field_schema_is_array_type(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1828,7 +1804,7 @@ bool zvec_field_schema_is_array_type(const ZVecFieldSchema *schema) { return cpp_schema->is_array_type(); } -uint32_t zvec_field_schema_get_dimension(const ZVecFieldSchema *schema) { +uint32_t zvec_field_schema_get_dimension(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1838,7 +1814,7 @@ uint32_t zvec_field_schema_get_dimension(const ZVecFieldSchema *schema) { return cpp_schema->dimension(); } -ZVecErrorCode zvec_field_schema_set_dimension(ZVecFieldSchema *schema, +zvec_error_code_t zvec_field_schema_set_dimension(zvec_field_schema_t *schema, uint32_t dimension) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -1850,7 +1826,7 @@ ZVecErrorCode zvec_field_schema_set_dimension(ZVecFieldSchema *schema, return ZVEC_OK; } -ZVecIndexType zvec_field_schema_get_index_type(const ZVecFieldSchema *schema) { +zvec_index_type_t zvec_field_schema_get_index_type(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1861,12 +1837,12 @@ ZVecIndexType zvec_field_schema_get_index_type(const ZVecFieldSchema *schema) { if (!cpp_index_params) { return ZVEC_INDEX_TYPE_UNDEFINED; } - return static_cast( + return static_cast( static_cast(cpp_index_params->type())); } -const ZVecIndexParams *zvec_field_schema_get_index_params( - const ZVecFieldSchema *schema) { +const zvec_index_params_t *zvec_field_schema_get_index_params( + const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1879,11 +1855,11 @@ const ZVecIndexParams *zvec_field_schema_get_index_params( } // Return internal pointer directly - caller does not own and should not free // The pointer is valid as long as the schema is not modified or destroyed - return reinterpret_cast(cpp_index_params.get()); + return reinterpret_cast(cpp_index_params.get()); } -ZVecErrorCode zvec_field_schema_set_index_params( - ZVecFieldSchema *schema, const ZVecIndexParams *index_params) { +zvec_error_code_t zvec_field_schema_set_index_params( + zvec_field_schema_t *schema, const zvec_index_params_t *index_params) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1901,8 +1877,8 @@ ZVecErrorCode zvec_field_schema_set_index_params( return ZVEC_OK; } -ZVecErrorCode zvec_field_schema_validate(const ZVecFieldSchema *schema, - ZVecString **error_msg) { +zvec_error_code_t zvec_field_schema_validate(const zvec_field_schema_t *schema, + zvec_string_t **error_msg) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1927,7 +1903,7 @@ ZVecErrorCode zvec_field_schema_validate(const ZVecFieldSchema *schema, } // Internal helper function (forward declared earlier) -bool zvec_field_schema_has_index(const ZVecFieldSchema *schema) { +bool zvec_field_schema_has_index(const zvec_field_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Field schema pointer cannot be null"); @@ -1941,7 +1917,7 @@ bool zvec_field_schema_has_index(const ZVecFieldSchema *schema) { // CollectionSchema management interface implementation // ============================================================================= -ZVecCollectionSchema *zvec_collection_schema_create(const char *name) { +zvec_collection_schema_t *zvec_collection_schema_create(const char *name) { if (!name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection name cannot be null"); @@ -1953,19 +1929,19 @@ ZVecCollectionSchema *zvec_collection_schema_create(const char *name) { auto cpp_schema = new zvec::CollectionSchema(std::string(name)); // Return as opaque pointer (raw pointer) - return reinterpret_cast(cpp_schema);) + return reinterpret_cast(cpp_schema);) return nullptr; } -void zvec_collection_schema_destroy(ZVecCollectionSchema *schema) { +void zvec_collection_schema_destroy(zvec_collection_schema_t *schema) { if (schema) { delete reinterpret_cast(schema); } } const char *zvec_collection_schema_get_name( - const ZVecCollectionSchema *schema) { + const zvec_collection_schema_t *schema) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection schema pointer cannot be null"); @@ -1976,7 +1952,7 @@ const char *zvec_collection_schema_get_name( return strdup(cpp_schema->name().c_str()); } -ZVecErrorCode zvec_collection_schema_set_name(ZVecCollectionSchema *schema, +zvec_error_code_t zvec_collection_schema_set_name(zvec_collection_schema_t *schema, const char *name) { if (!schema || !name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -1991,8 +1967,8 @@ ZVecErrorCode zvec_collection_schema_set_name(ZVecCollectionSchema *schema, return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_add_field(ZVecCollectionSchema *schema, - const ZVecFieldSchema *field) { +zvec_error_code_t zvec_collection_schema_add_field(zvec_collection_schema_t *schema, + const zvec_field_schema_t *field) { if (!schema || !field) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection schema or field pointer cannot be null"); @@ -2011,9 +1987,9 @@ ZVecErrorCode zvec_collection_schema_add_field(ZVecCollectionSchema *schema, return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_schema_alter_field( - ZVecCollectionSchema *schema, const char *field_name, - const ZVecFieldSchema *new_field) { +zvec_error_code_t zvec_collection_schema_alter_field( + zvec_collection_schema_t *schema, const char *field_name, + const zvec_field_schema_t *new_field) { if (!schema || !field_name || !new_field) { SET_LAST_ERROR( ZVEC_ERROR_INVALID_ARGUMENT, @@ -2032,7 +2008,7 @@ ZVecErrorCode zvec_collection_schema_alter_field( return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_schema_drop_field(ZVecCollectionSchema *schema, +zvec_error_code_t zvec_collection_schema_drop_field(zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -2047,7 +2023,7 @@ ZVecErrorCode zvec_collection_schema_drop_field(ZVecCollectionSchema *schema, return status_to_error_code(status);) } -bool zvec_collection_schema_has_field(const ZVecCollectionSchema *schema, +bool zvec_collection_schema_has_field(const zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { return false; @@ -2057,8 +2033,8 @@ bool zvec_collection_schema_has_field(const ZVecCollectionSchema *schema, return cpp_schema->has_field(std::string(field_name)); } -ZVecFieldSchema *zvec_collection_schema_get_field( - const ZVecCollectionSchema *schema, const char *field_name) { +zvec_field_schema_t *zvec_collection_schema_get_field( + const zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { return nullptr; } @@ -2071,14 +2047,14 @@ ZVecFieldSchema *zvec_collection_schema_get_field( cpp_schema->get_field(std::string(field_name)); if (!cpp_field) { return nullptr; } // Return non-owning pointer - caller should NOT free this - return reinterpret_cast( + return reinterpret_cast( const_cast(cpp_field));) return nullptr; } -ZVecFieldSchema *zvec_collection_schema_get_forward_field( - const ZVecCollectionSchema *schema, const char *field_name) { +zvec_field_schema_t *zvec_collection_schema_get_forward_field( + const zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { return nullptr; } @@ -2091,14 +2067,14 @@ ZVecFieldSchema *zvec_collection_schema_get_forward_field( cpp_schema->get_forward_field(std::string(field_name)); if (!cpp_field) { return nullptr; } // Return non-owning pointer - caller should NOT free this - return reinterpret_cast( + return reinterpret_cast( const_cast(cpp_field));) return nullptr; } -ZVecFieldSchema *zvec_collection_schema_get_vector_field( - const ZVecCollectionSchema *schema, const char *field_name) { +zvec_field_schema_t *zvec_collection_schema_get_vector_field( + const zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { return nullptr; } @@ -2111,14 +2087,14 @@ ZVecFieldSchema *zvec_collection_schema_get_vector_field( cpp_schema->get_vector_field(std::string(field_name)); if (!cpp_field) { return nullptr; } // Return non-owning pointer - caller should NOT free this - return reinterpret_cast( + return reinterpret_cast( const_cast(cpp_field));) return nullptr; } -ZVecErrorCode zvec_collection_schema_get_forward_fields( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, +zvec_error_code_t zvec_collection_schema_get_forward_fields( + const zvec_collection_schema_t *schema, zvec_field_schema_t ***fields, size_t *count) { if (!schema || !fields || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -2133,7 +2109,7 @@ ZVecErrorCode zvec_collection_schema_get_forward_fields( auto forward_fields = cpp_schema->forward_fields(); *count = forward_fields.size(); - *fields = (ZVecFieldSchema **)zvec_malloc(*count * sizeof(ZVecFieldSchema *)); + *fields = (zvec_field_schema_t **)zvec_malloc(*count * sizeof(zvec_field_schema_t *)); if (!*fields) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, "Failed to allocate memory"); @@ -2143,13 +2119,13 @@ ZVecErrorCode zvec_collection_schema_get_forward_fields( for (size_t i = 0; i < *count; ++i) { // Return non-owning pointers - caller should NOT free these (*fields)[i] = - reinterpret_cast(forward_fields[i].get()); + reinterpret_cast(forward_fields[i].get()); } return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_get_forward_fields_with_index( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, +zvec_error_code_t zvec_collection_schema_get_forward_fields_with_index( + const zvec_collection_schema_t *schema, zvec_field_schema_t ***fields, size_t *count) { if (!schema || !fields || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -2164,7 +2140,7 @@ ZVecErrorCode zvec_collection_schema_get_forward_fields_with_index( auto fields_with_index = cpp_schema->forward_fields_with_index(); *count = fields_with_index.size(); - *fields = (ZVecFieldSchema **)zvec_malloc(*count * sizeof(ZVecFieldSchema *)); + *fields = (zvec_field_schema_t **)zvec_malloc(*count * sizeof(zvec_field_schema_t *)); if (!*fields) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, "Failed to allocate memory"); @@ -2174,13 +2150,13 @@ ZVecErrorCode zvec_collection_schema_get_forward_fields_with_index( for (size_t i = 0; i < *count; ++i) { // Return non-owning pointers - caller should NOT free these (*fields)[i] = - reinterpret_cast(fields_with_index[i].get()); + reinterpret_cast(fields_with_index[i].get()); } return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_get_forward_field_names( - const ZVecCollectionSchema *schema, const char ***names, size_t *count) { +zvec_error_code_t zvec_collection_schema_get_forward_field_names( + const zvec_collection_schema_t *schema, const char ***names, size_t *count) { if (!schema || !names || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Schema, names, and count cannot be null"); @@ -2208,8 +2184,8 @@ ZVecErrorCode zvec_collection_schema_get_forward_field_names( return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_get_forward_field_names_with_index( - const ZVecCollectionSchema *schema, const char ***names, size_t *count) { +zvec_error_code_t zvec_collection_schema_get_forward_field_names_with_index( + const zvec_collection_schema_t *schema, const char ***names, size_t *count) { if (!schema || !names || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Schema, names, and count cannot be null"); @@ -2238,8 +2214,8 @@ ZVecErrorCode zvec_collection_schema_get_forward_field_names_with_index( return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_get_all_field_names( - const ZVecCollectionSchema *schema, const char ***names, size_t *count) { +zvec_error_code_t zvec_collection_schema_get_all_field_names( + const zvec_collection_schema_t *schema, const char ***names, size_t *count) { if (!schema || !names || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Schema, names, and count cannot be null"); @@ -2267,8 +2243,8 @@ ZVecErrorCode zvec_collection_schema_get_all_field_names( return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_get_vector_fields( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, +zvec_error_code_t zvec_collection_schema_get_vector_fields( + const zvec_collection_schema_t *schema, zvec_field_schema_t ***fields, size_t *count) { if (!schema || !fields || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -2283,7 +2259,7 @@ ZVecErrorCode zvec_collection_schema_get_vector_fields( auto vector_fields = cpp_schema->vector_fields(); *count = vector_fields.size(); - *fields = (ZVecFieldSchema **)malloc(*count * sizeof(ZVecFieldSchema *)); + *fields = (zvec_field_schema_t **)malloc(*count * sizeof(zvec_field_schema_t *)); if (!*fields) { SET_LAST_ERROR(ZVEC_ERROR_RESOURCE_EXHAUSTED, "Failed to allocate memory"); @@ -2293,20 +2269,20 @@ ZVecErrorCode zvec_collection_schema_get_vector_fields( for (size_t i = 0; i < *count; ++i) { // Return non-owning pointers - caller should NOT free these (*fields)[i] = - reinterpret_cast(vector_fields[i].get()); + reinterpret_cast(vector_fields[i].get()); } return ZVEC_OK;) } uint64_t zvec_collection_schema_get_max_doc_count_per_segment( - const ZVecCollectionSchema *schema) { + const zvec_collection_schema_t *schema) { if (!schema) return 0; auto *cpp_schema = reinterpret_cast(schema); return cpp_schema->max_doc_count_per_segment(); } -ZVecErrorCode zvec_collection_schema_set_max_doc_count_per_segment( - ZVecCollectionSchema *schema, uint64_t max_doc_count) { +zvec_error_code_t zvec_collection_schema_set_max_doc_count_per_segment( + zvec_collection_schema_t *schema, uint64_t max_doc_count) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection schema pointer cannot be null"); @@ -2320,8 +2296,8 @@ ZVecErrorCode zvec_collection_schema_set_max_doc_count_per_segment( return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_validate( - const ZVecCollectionSchema *schema, ZVecString **error_msg) { +zvec_error_code_t zvec_collection_schema_validate( + const zvec_collection_schema_t *schema, zvec_string_t **error_msg) { if (!schema) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Collection schema pointer cannot be null"); @@ -2345,9 +2321,9 @@ ZVecErrorCode zvec_collection_schema_validate( return ZVEC_OK;) } -ZVecErrorCode zvec_collection_schema_add_index( - ZVecCollectionSchema *schema, const char *field_name, - const ZVecIndexParams *index_params) { +zvec_error_code_t zvec_collection_schema_add_index( + zvec_collection_schema_t *schema, const char *field_name, + const zvec_index_params_t *index_params) { if (!schema || !field_name || !index_params) { SET_LAST_ERROR( ZVEC_ERROR_INVALID_ARGUMENT, @@ -2364,7 +2340,7 @@ ZVecErrorCode zvec_collection_schema_add_index( return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_schema_drop_index(ZVecCollectionSchema *schema, +zvec_error_code_t zvec_collection_schema_drop_index(zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -2386,7 +2362,7 @@ ZVecErrorCode zvec_collection_schema_drop_index(ZVecCollectionSchema *schema, return ZVEC_OK;) } -bool zvec_collection_schema_has_index(const ZVecCollectionSchema *schema, +bool zvec_collection_schema_has_index(const zvec_collection_schema_t *schema, const char *field_name) { if (!schema || !field_name) { return false; @@ -2400,7 +2376,7 @@ bool zvec_collection_schema_has_index(const ZVecCollectionSchema *schema, // Helper functions // ============================================================================= -const char *zvec_error_code_to_string(ZVecErrorCode error_code) { +const char *zvec_error_code_to_string(zvec_error_code_t error_code) { switch (error_code) { case ZVEC_OK: return "OK"; @@ -2429,7 +2405,7 @@ const char *zvec_error_code_to_string(ZVecErrorCode error_code) { } } -const char *zvec_data_type_to_string(ZVecDataType data_type) { +const char *zvec_data_type_to_string(zvec_data_type_t data_type) { switch (data_type) { case ZVEC_DATA_TYPE_UNDEFINED: return "UNDEFINED"; @@ -2494,7 +2470,7 @@ const char *zvec_data_type_to_string(ZVecDataType data_type) { } } -const char *zvec_index_type_to_string(ZVecIndexType index_type) { +const char *zvec_index_type_to_string(zvec_index_type_t index_type) { switch (index_type) { case ZVEC_INDEX_TYPE_UNDEFINED: return "UNDEFINED"; @@ -2511,7 +2487,7 @@ const char *zvec_index_type_to_string(ZVecIndexType index_type) { } } -const char *zvec_metric_type_to_string(ZVecMetricType metric_type) { +const char *zvec_metric_type_to_string(zvec_metric_type_t metric_type) { switch (metric_type) { case ZVEC_METRIC_TYPE_UNDEFINED: return "UNDEFINED"; @@ -2532,20 +2508,20 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type) { // Doc functions implementation // ============================================================================= -ZVecDoc *zvec_doc_create(void) { +zvec_doc_t *zvec_doc_create(void) { ZVEC_TRY_RETURN_NULL("Failed to create document", { auto *doc_ptr = new zvec::Doc(); - return reinterpret_cast(doc_ptr); + return reinterpret_cast(doc_ptr); }) } -void zvec_doc_destroy(ZVecDoc *doc) { +void zvec_doc_destroy(zvec_doc_t *doc) { if (doc) { delete reinterpret_cast(doc); } } -void zvec_doc_clear(ZVecDoc *doc) { +void zvec_doc_clear(zvec_doc_t *doc) { if (!doc) return; ZVEC_TRY_BEGIN_VOID @@ -2554,7 +2530,7 @@ void zvec_doc_clear(ZVecDoc *doc) { ZVEC_CATCH_END_VOID } -void zvec_docs_free(ZVecDoc **docs, size_t count) { +void zvec_docs_free(zvec_doc_t **docs, size_t count) { if (!docs) return; for (size_t i = 0; i < count; ++i) { @@ -2564,11 +2540,11 @@ void zvec_docs_free(ZVecDoc **docs, size_t count) { free(docs); } -void zvec_write_results_free(ZVecWriteResult *results, size_t result_count) { +void zvec_write_results_free(zvec_write_result_t *results, size_t result_count) { free_write_results_internal(results, result_count); } -void zvec_doc_set_pk(ZVecDoc *doc, const char *pk) { +void zvec_doc_set_pk(zvec_doc_t *doc, const char *pk) { if (!doc || !pk) return; ZVEC_TRY_BEGIN_VOID @@ -2577,7 +2553,7 @@ void zvec_doc_set_pk(ZVecDoc *doc, const char *pk) { ZVEC_CATCH_END_VOID } -void zvec_doc_set_doc_id(ZVecDoc *doc, uint64_t doc_id) { +void zvec_doc_set_doc_id(zvec_doc_t *doc, uint64_t doc_id) { if (!doc) return; ZVEC_TRY_BEGIN_VOID @@ -2586,7 +2562,7 @@ void zvec_doc_set_doc_id(ZVecDoc *doc, uint64_t doc_id) { ZVEC_CATCH_END_VOID } -void zvec_doc_set_score(ZVecDoc *doc, float score) { +void zvec_doc_set_score(zvec_doc_t *doc, float score) { if (!doc) return; ZVEC_TRY_BEGIN_VOID @@ -2595,7 +2571,7 @@ void zvec_doc_set_score(ZVecDoc *doc, float score) { ZVEC_CATCH_END_VOID } -void zvec_doc_set_operator(ZVecDoc *doc, ZVecDocOperator op) { +void zvec_doc_set_operator(zvec_doc_t *doc, zvec_doc_operator_t op) { if (!doc) return; ZVEC_TRY_BEGIN_VOID @@ -2604,7 +2580,7 @@ void zvec_doc_set_operator(ZVecDoc *doc, ZVecDocOperator op) { ZVEC_CATCH_END_VOID } -ZVecErrorCode zvec_doc_set_field_null(ZVecDoc *doc, const char *field_name) { +zvec_error_code_t zvec_doc_set_field_null(zvec_doc_t *doc, const char *field_name) { if (!doc || !field_name) { set_last_error("Invalid arguments: null pointer"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -2623,7 +2599,7 @@ ZVecErrorCode zvec_doc_set_field_null(ZVecDoc *doc, const char *field_name) { // Helper function to extract scalar values from raw data template T extract_scalar_value(const void *value, size_t value_size, - ZVecErrorCode *error_code) { + zvec_error_code_t *error_code) { if (value_size != sizeof(T)) { if (error_code) { *error_code = ZVEC_ERROR_INVALID_ARGUMENT; @@ -2636,7 +2612,7 @@ T extract_scalar_value(const void *value, size_t value_size, // Helper function to extract vector values from raw data template std::vector extract_vector_values(const void *value, size_t value_size, - ZVecErrorCode *error_code) { + zvec_error_code_t *error_code) { if (value_size % sizeof(T) != 0) { if (error_code) { *error_code = ZVEC_ERROR_INVALID_ARGUMENT; @@ -2651,7 +2627,7 @@ std::vector extract_vector_values(const void *value, size_t value_size, // Helper function to extract array values from raw data template std::vector extract_array_values(const void *value, size_t value_size, - ZVecErrorCode *error_code) { + zvec_error_code_t *error_code) { if (value_size % sizeof(T) != 0) { if (error_code) { *error_code = ZVEC_ERROR_INVALID_ARGUMENT; @@ -2666,7 +2642,7 @@ std::vector extract_array_values(const void *value, size_t value_size, // Helper function to handle sparse vector extraction template std::pair, std::vector> extract_sparse_vector( - const void *value, size_t value_size, ZVecErrorCode *error_code) { + const void *value, size_t value_size, zvec_error_code_t *error_code) { if (value_size < sizeof(uint32_t)) { if (error_code) { *error_code = ZVEC_ERROR_INVALID_ARGUMENT; @@ -2713,9 +2689,9 @@ std::vector extract_string_array(const void *value, return string_array; } -// Helper function to extract string array from ZVecString** array +// Helper function to extract string array from zvec_string_t** array std::vector extract_string_array_from_zvec( - ZVecString **zvec_strings, size_t count) { + zvec_string_t **zvec_strings, size_t count) { std::vector string_array; string_array.reserve(count); @@ -2754,7 +2730,7 @@ std::vector extract_binary_array(const void *value, } static std::vector convert_zvec_docs_to_internal( - const ZVecDoc **zvec_docs, size_t doc_count) { + const zvec_doc_t **zvec_docs, size_t doc_count) { std::vector docs; docs.reserve(doc_count); @@ -2768,7 +2744,7 @@ static std::vector convert_zvec_docs_to_internal( } static zvec::Status convert_zvec_collection_schema_to_internal( - const ZVecCollectionSchema *schema, + const zvec_collection_schema_t *schema, zvec::CollectionSchema::Ptr &collection_schema) { // Get the underlying C++ CollectionSchema auto *cpp_schema = reinterpret_cast(schema); @@ -2779,8 +2755,8 @@ static zvec::Status convert_zvec_collection_schema_to_internal( return zvec::Status::OK(); } -ZVecErrorCode zvec_doc_add_field_by_value(ZVecDoc *doc, const char *field_name, - ZVecDataType data_type, +zvec_error_code_t zvec_doc_add_field_by_value(zvec_doc_t *doc, const char *field_name, + zvec_data_type_t data_type, const void *value, size_t value_size) { if (!doc || !field_name || !value) { @@ -2790,7 +2766,7 @@ ZVecErrorCode zvec_doc_add_field_by_value(ZVecDoc *doc, const char *field_name, ZVEC_TRY_RETURN_ERROR( "Failed to add field", auto *doc_ptr = reinterpret_cast(doc); - std::string name(field_name); ZVecErrorCode error_code = ZVEC_OK; + std::string name(field_name); zvec_error_code_t error_code = ZVEC_OK; switch (data_type) { // Scalar types @@ -2989,14 +2965,14 @@ ZVecErrorCode zvec_doc_add_field_by_value(ZVecDoc *doc, const char *field_name, break; } case ZVEC_DATA_TYPE_ARRAY_STRING: { - // Check if this is a ZVecString** array or a C-string array - // ZVecString** array has pointer-sized elements + // Check if this is a zvec_string_t** array or a C-string array + // zvec_string_t** array has pointer-sized elements constexpr size_t ptr_size = sizeof(void *); if (value_size % ptr_size == 0) { - // Likely a ZVecString** array + // Likely a zvec_string_t** array size_t count = value_size / ptr_size; - ZVecString **zvec_str_array = - reinterpret_cast(const_cast(value)); + zvec_string_t **zvec_str_array = + reinterpret_cast(const_cast(value)); auto string_array = extract_string_array_from_zvec(zvec_str_array, count); doc_ptr->set(name, std::move(string_array)); @@ -3085,8 +3061,8 @@ ZVecErrorCode zvec_doc_add_field_by_value(ZVecDoc *doc, const char *field_name, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, - const ZVecDocField *field) { +zvec_error_code_t zvec_doc_add_field_by_struct(zvec_doc_t *doc, + const zvec_doc_field_t *field) { if (!doc || !field) { set_last_error("Invalid arguments: null pointer"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -3098,7 +3074,7 @@ ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, std::string name(field->name.data, field->name.length); switch (field->data_type) { - // Scalar types (in ZVecDataType order: BINARY, STRING, BOOL, INT32, + // Scalar types (in zvec_data_type_t order: BINARY, STRING, BOOL, INT32, // INT64, UINT32, UINT64, FLOAT, DOUBLE) case ZVEC_DATA_TYPE_BINARY: { std::string val( @@ -3142,7 +3118,7 @@ ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, break; } - // Vector types (in ZVecDataType order: BINARY32, BINARY64, FP16, FP32, + // Vector types (in zvec_data_type_t order: BINARY32, BINARY64, FP16, FP32, // FP64, INT4, INT8, INT16) case ZVEC_DATA_TYPE_VECTOR_BINARY32: { std::vector vec(reinterpret_cast( @@ -3226,7 +3202,7 @@ ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, break; } - // Sparse vector types (in ZVecDataType order: FP16, FP32) + // Sparse vector types (in zvec_data_type_t order: FP16, FP32) case ZVEC_DATA_TYPE_SPARSE_VECTOR_FP16: { std::vector vec( reinterpret_cast( @@ -3245,7 +3221,7 @@ ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, break; } - // Array types (in ZVecDataType order: BINARY, STRING, BOOL, INT32, + // Array types (in zvec_data_type_t order: BINARY, STRING, BOOL, INT32, // INT64, UINT32, UINT64, FLOAT, DOUBLE) case ZVEC_DATA_TYPE_ARRAY_BINARY: { std::vector array_values; @@ -3360,13 +3336,13 @@ ZVecErrorCode zvec_doc_add_field_by_struct(ZVecDoc *doc, return ZVEC_OK;) } -const char *zvec_doc_get_pk_pointer(const ZVecDoc *doc) { +const char *zvec_doc_get_pk_pointer(const zvec_doc_t *doc) { if (!doc) return nullptr; auto doc_ptr = reinterpret_cast(doc); return doc_ptr->pk_ref().data(); } -const char *zvec_doc_get_pk_copy(const ZVecDoc *doc) { +const char *zvec_doc_get_pk_copy(const zvec_doc_t *doc) { if (!doc) return nullptr; auto doc_ptr = reinterpret_cast(doc); const std::string &pk = doc_ptr->pk_ref(); @@ -3377,7 +3353,7 @@ const char *zvec_doc_get_pk_copy(const ZVecDoc *doc) { return result; } -uint64_t zvec_doc_get_doc_id(const ZVecDoc *doc) { +uint64_t zvec_doc_get_doc_id(const zvec_doc_t *doc) { if (!doc) return 0; ZVEC_TRY_RETURN_SCALAR( @@ -3386,7 +3362,7 @@ uint64_t zvec_doc_get_doc_id(const ZVecDoc *doc) { return doc_ptr->doc_id();) } -float zvec_doc_get_score(const ZVecDoc *doc) { +float zvec_doc_get_score(const zvec_doc_t *doc) { if (!doc) return 0.0f; ZVEC_TRY_RETURN_SCALAR( @@ -3395,16 +3371,16 @@ float zvec_doc_get_score(const ZVecDoc *doc) { return doc_ptr->score();) } -ZVecDocOperator zvec_doc_get_operator(const ZVecDoc *doc) { +zvec_doc_operator_t zvec_doc_get_operator(const zvec_doc_t *doc) { if (!doc) return ZVEC_DOC_OP_INSERT; // default ZVEC_TRY_RETURN_SCALAR( "Failed to get document operator", ZVEC_DOC_OP_INSERT, auto doc_ptr = reinterpret_cast(doc); zvec::Operator op = doc_ptr->get_operator(); - return static_cast(op);) + return static_cast(op);) } -size_t zvec_doc_get_field_count(const ZVecDoc *doc) { +size_t zvec_doc_get_field_count(const zvec_doc_t *doc) { if (!doc) return 0; ZVEC_TRY_RETURN_SCALAR( @@ -3413,9 +3389,9 @@ size_t zvec_doc_get_field_count(const ZVecDoc *doc) { return doc_ptr->field_names().size();) } -ZVecErrorCode zvec_doc_get_field_value_basic(const ZVecDoc *doc, +zvec_error_code_t zvec_doc_get_field_value_basic(const zvec_doc_t *doc, const char *field_name, - ZVecDataType field_type, + zvec_data_type_t field_type, void *value_buffer, size_t buffer_size) { if (!doc || !field_name || !value_buffer) { @@ -3507,9 +3483,9 @@ ZVecErrorCode zvec_doc_get_field_value_basic(const ZVecDoc *doc, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_get_field_value_copy(const ZVecDoc *doc, +zvec_error_code_t zvec_doc_get_field_value_copy(const zvec_doc_t *doc, const char *field_name, - ZVecDataType field_type, + zvec_data_type_t field_type, void **value, size_t *value_size) { if (!doc || !field_name || !value || !value_size) { set_last_error("Invalid arguments: null pointer"); @@ -3975,9 +3951,9 @@ ZVecErrorCode zvec_doc_get_field_value_copy(const ZVecDoc *doc, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_get_field_value_pointer(const ZVecDoc *doc, +zvec_error_code_t zvec_doc_get_field_value_pointer(const zvec_doc_t *doc, const char *field_name, - ZVecDataType field_type, + zvec_data_type_t field_type, const void **value, size_t *value_size) { if (!doc || !field_name || !value || !value_size) { @@ -4156,7 +4132,7 @@ ZVecErrorCode zvec_doc_get_field_value_pointer(const ZVecDoc *doc, return ZVEC_OK;) } -bool zvec_doc_is_empty(const ZVecDoc *doc) { +bool zvec_doc_is_empty(const zvec_doc_t *doc) { if (!doc) { set_last_error("Document pointer is null"); return true; @@ -4168,7 +4144,7 @@ bool zvec_doc_is_empty(const ZVecDoc *doc) { return doc_ptr->is_empty();) } -ZVecErrorCode zvec_doc_remove_field(ZVecDoc *doc, const char *field_name) { +zvec_error_code_t zvec_doc_remove_field(zvec_doc_t *doc, const char *field_name) { if (!doc || !field_name) { set_last_error("Document pointer or field name is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4181,7 +4157,7 @@ ZVecErrorCode zvec_doc_remove_field(ZVecDoc *doc, const char *field_name) { } -bool zvec_doc_has_field(const ZVecDoc *doc, const char *field_name) { +bool zvec_doc_has_field(const zvec_doc_t *doc, const char *field_name) { if (!doc || !field_name) { set_last_error("Document pointer or field name is null"); return false; @@ -4193,7 +4169,7 @@ bool zvec_doc_has_field(const ZVecDoc *doc, const char *field_name) { return doc_ptr->has(std::string(field_name));) } -bool zvec_doc_has_field_value(const ZVecDoc *doc, const char *field_name) { +bool zvec_doc_has_field_value(const zvec_doc_t *doc, const char *field_name) { if (!doc || !field_name) { set_last_error("Document pointer or field name is null"); return false; @@ -4205,7 +4181,7 @@ bool zvec_doc_has_field_value(const ZVecDoc *doc, const char *field_name) { return doc_ptr->has_value(std::string(field_name));) } -bool zvec_doc_is_field_null(const ZVecDoc *doc, const char *field_name) { +bool zvec_doc_is_field_null(const zvec_doc_t *doc, const char *field_name) { if (!doc || !field_name) { set_last_error("Document pointer or field name is null"); return false; @@ -4217,7 +4193,7 @@ bool zvec_doc_is_field_null(const ZVecDoc *doc, const char *field_name) { return doc_ptr->is_null(std::string(field_name));) } -ZVecErrorCode zvec_doc_get_field_names(const ZVecDoc *doc, char ***field_names, +zvec_error_code_t zvec_doc_get_field_names(const zvec_doc_t *doc, char ***field_names, size_t *count) { if (!doc || !field_names || !count) { set_last_error("Invalid arguments"); @@ -4257,7 +4233,7 @@ ZVecErrorCode zvec_doc_get_field_names(const ZVecDoc *doc, char ***field_names, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_serialize(const ZVecDoc *doc, uint8_t **data, +zvec_error_code_t zvec_doc_serialize(const zvec_doc_t *doc, uint8_t **data, size_t *size) { if (!doc || !data || !size) { set_last_error("Invalid arguments"); @@ -4285,8 +4261,8 @@ ZVecErrorCode zvec_doc_serialize(const ZVecDoc *doc, uint8_t **data, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_deserialize(const uint8_t *data, size_t size, - ZVecDoc **doc) { +zvec_error_code_t zvec_doc_deserialize(const uint8_t *data, size_t size, + zvec_doc_t **doc) { if (!data || !doc || size == 0) { set_last_error("Invalid arguments"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4302,11 +4278,11 @@ ZVecErrorCode zvec_doc_deserialize(const uint8_t *data, size_t size, // Create a new Doc by copying the deserialized content auto *new_doc = new zvec::Doc(*deserialized_doc); - *doc = reinterpret_cast(new_doc); + *doc = reinterpret_cast(new_doc); return ZVEC_OK;) } -void zvec_doc_merge(ZVecDoc *doc, const ZVecDoc *other) { +void zvec_doc_merge(zvec_doc_t *doc, const zvec_doc_t *other) { if (!doc || !other) { set_last_error("Document pointers are null"); return; @@ -4319,7 +4295,7 @@ void zvec_doc_merge(ZVecDoc *doc, const ZVecDoc *other) { ZVEC_CATCH_END_VOID } -size_t zvec_doc_memory_usage(const ZVecDoc *doc) { +size_t zvec_doc_memory_usage(const zvec_doc_t *doc) { if (!doc) { set_last_error("Document pointer is null"); return 0; @@ -4331,8 +4307,8 @@ size_t zvec_doc_memory_usage(const ZVecDoc *doc) { return doc_ptr->memory_usage();) } -ZVecErrorCode zvec_doc_validate(const ZVecDoc *doc, - const ZVecCollectionSchema *schema, +zvec_error_code_t zvec_doc_validate(const zvec_doc_t *doc, + const zvec_collection_schema_t *schema, bool is_update, char **error_msg) { if (!doc || !schema) { set_last_error("Document or schema pointer is null"); @@ -4363,7 +4339,7 @@ ZVecErrorCode zvec_doc_validate(const ZVecDoc *doc, return ZVEC_OK;) } -ZVecErrorCode zvec_doc_to_detail_string(const ZVecDoc *doc, char **detail_str) { +zvec_error_code_t zvec_doc_to_detail_string(const zvec_doc_t *doc, char **detail_str) { if (!doc || !detail_str) { set_last_error("Invalid arguments"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4386,9 +4362,9 @@ ZVecErrorCode zvec_doc_to_detail_string(const ZVecDoc *doc, char **detail_str) { // Collection functions implementation // ============================================================================= -ZVecErrorCode zvec_collection_create_and_open( - const char *path, const ZVecCollectionSchema *schema, - const ZVecCollectionOptions *options, ZVecCollection **collection) { +zvec_error_code_t zvec_collection_create_and_open( + const char *path, const zvec_collection_schema_t *schema, + const zvec_collection_options_t *options, zvec_collection_t **collection) { ZVEC_TRY_RETURN_ERROR( "Exception in zvec_collection_create_and_open_with_schema", if (!path || !schema || !collection) { @@ -4415,19 +4391,19 @@ ZVecErrorCode zvec_collection_create_and_open( auto result = zvec::Collection::CreateAndOpen(path, *schema_ptr, collection_options); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { - *collection = reinterpret_cast( + *collection = reinterpret_cast( new std::shared_ptr(std::move(result.value()))); } return error_code;) } -ZVecErrorCode zvec_collection_open(const char *path, - const ZVecCollectionOptions *options, - ZVecCollection **collection) { +zvec_error_code_t zvec_collection_open(const char *path, + const zvec_collection_options_t *options, + zvec_collection_t **collection) { if (!path || !collection) { set_last_error("Invalid arguments: path and collection cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4443,17 +4419,17 @@ ZVecErrorCode zvec_collection_open(const char *path, } auto result = zvec::Collection::Open(path, collection_options); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { - *collection = reinterpret_cast( + *collection = reinterpret_cast( new std::shared_ptr(std::move(result.value()))); } return error_code;) } -ZVecErrorCode zvec_collection_close(ZVecCollection *collection) { +zvec_error_code_t zvec_collection_close(zvec_collection_t *collection) { if (!collection) { set_last_error("Invalid argument: collection cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4465,7 +4441,7 @@ ZVecErrorCode zvec_collection_close(ZVecCollection *collection) { return ZVEC_OK;) } -ZVecErrorCode zvec_collection_destroy(ZVecCollection *collection) { +zvec_error_code_t zvec_collection_destroy(zvec_collection_t *collection) { if (!collection) { set_last_error("Invalid argument: collection cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4481,7 +4457,7 @@ ZVecErrorCode zvec_collection_destroy(ZVecCollection *collection) { return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_flush(ZVecCollection *collection) { +zvec_error_code_t zvec_collection_flush(zvec_collection_t *collection) { if (!collection) { set_last_error("Invalid argument: collection cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4498,8 +4474,8 @@ ZVecErrorCode zvec_collection_flush(ZVecCollection *collection) { return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_get_schema(const ZVecCollection *collection, - ZVecCollectionSchema **schema) { +zvec_error_code_t zvec_collection_get_schema(const zvec_collection_t *collection, + zvec_collection_schema_t **schema) { if (!collection || !schema) { set_last_error("Invalid arguments: collection and schema cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4511,20 +4487,20 @@ ZVecErrorCode zvec_collection_get_schema(const ZVecCollection *collection, collection); auto result = coll->Schema(); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { const auto &cpp_schema = result.value(); // Create a copy of the schema and return as raw pointer auto *copied_schema = new zvec::CollectionSchema(cpp_schema); - *schema = reinterpret_cast(copied_schema); + *schema = reinterpret_cast(copied_schema); } return error_code;) } -ZVecErrorCode zvec_collection_get_options(const ZVecCollection *collection, - ZVecCollectionOptions **options) { +zvec_error_code_t zvec_collection_get_options(const zvec_collection_t *collection, + zvec_collection_options_t **options) { if (!collection || !options) { set_last_error("Invalid arguments"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4544,14 +4520,14 @@ ZVecErrorCode zvec_collection_get_options(const ZVecCollection *collection, } // Create and initialize options using new - *options = reinterpret_cast( + *options = reinterpret_cast( new zvec::CollectionOptions(result.value())); return ZVEC_OK;) } -ZVecErrorCode zvec_collection_get_stats(const ZVecCollection *collection, - ZVecCollectionStats **stats) { +zvec_error_code_t zvec_collection_get_stats(const zvec_collection_t *collection, + zvec_collection_stats_t **stats) { if (!collection || !stats) { set_last_error("Invalid arguments"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4571,13 +4547,13 @@ ZVecErrorCode zvec_collection_get_stats(const ZVecCollection *collection, } // Create a new CollectionStats object and return as opaque pointer - *stats = reinterpret_cast( + *stats = reinterpret_cast( new zvec::CollectionStats(result.value())); return ZVEC_OK;) } -void zvec_collection_stats_destroy(ZVecCollectionStats *stats) { +void zvec_collection_stats_destroy(zvec_collection_stats_t *stats) { if (stats) { delete reinterpret_cast(stats); } @@ -4599,23 +4575,23 @@ void zvec_collection_stats_destroy(ZVecCollectionStats *stats) { // HnswQueryParams implementation - wrapper around zvec::HnswQueryParams // ============================================================================= -ZVecHnswQueryParams *zvec_query_params_hnsw_create(int ef, float radius, +zvec_hnsw_query_params_t *zvec_query_params_hnsw_create(int ef, float radius, bool is_linear, bool is_using_refiner) { ZVEC_TRY_RETURN_NULL("Failed to create HnswQueryParams", auto *params = new zvec::HnswQueryParams( ef, radius, is_linear, is_using_refiner); - return reinterpret_cast(params);) + return reinterpret_cast(params);) return nullptr; } -void zvec_query_params_hnsw_destroy(ZVecHnswQueryParams *params) { +void zvec_query_params_hnsw_destroy(zvec_hnsw_query_params_t *params) { if (params) { delete reinterpret_cast(params); } } -ZVecErrorCode zvec_query_params_hnsw_set_ef(ZVecHnswQueryParams *params, +zvec_error_code_t zvec_query_params_hnsw_set_ef(zvec_hnsw_query_params_t *params, int ef) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4627,13 +4603,13 @@ ZVecErrorCode zvec_query_params_hnsw_set_ef(ZVecHnswQueryParams *params, return ZVEC_OK; } -int zvec_query_params_hnsw_get_ef(const ZVecHnswQueryParams *params) { +int zvec_query_params_hnsw_get_ef(const zvec_hnsw_query_params_t *params) { if (!params) return zvec::core_interface::kDefaultHnswEfSearch; auto *ptr = reinterpret_cast(params); return ptr->ef(); } -ZVecErrorCode zvec_query_params_hnsw_set_radius(ZVecHnswQueryParams *params, +zvec_error_code_t zvec_query_params_hnsw_set_radius(zvec_hnsw_query_params_t *params, float radius) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4645,13 +4621,13 @@ ZVecErrorCode zvec_query_params_hnsw_set_radius(ZVecHnswQueryParams *params, return ZVEC_OK; } -float zvec_query_params_hnsw_get_radius(const ZVecHnswQueryParams *params) { +float zvec_query_params_hnsw_get_radius(const zvec_hnsw_query_params_t *params) { if (!params) return 0.0f; auto *ptr = reinterpret_cast(params); return ptr->radius(); } -ZVecErrorCode zvec_query_params_hnsw_set_is_linear(ZVecHnswQueryParams *params, +zvec_error_code_t zvec_query_params_hnsw_set_is_linear(zvec_hnsw_query_params_t *params, bool is_linear) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4663,14 +4639,14 @@ ZVecErrorCode zvec_query_params_hnsw_set_is_linear(ZVecHnswQueryParams *params, return ZVEC_OK; } -bool zvec_query_params_hnsw_get_is_linear(const ZVecHnswQueryParams *params) { +bool zvec_query_params_hnsw_get_is_linear(const zvec_hnsw_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_linear(); } -ZVecErrorCode zvec_query_params_hnsw_set_is_using_refiner( - ZVecHnswQueryParams *params, bool is_using_refiner) { +zvec_error_code_t zvec_query_params_hnsw_set_is_using_refiner( + zvec_hnsw_query_params_t *params, bool is_using_refiner) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "HNSW query params pointer is null"); @@ -4682,7 +4658,7 @@ ZVecErrorCode zvec_query_params_hnsw_set_is_using_refiner( } bool zvec_query_params_hnsw_get_is_using_refiner( - const ZVecHnswQueryParams *params) { + const zvec_hnsw_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_using_refiner(); @@ -4692,23 +4668,23 @@ bool zvec_query_params_hnsw_get_is_using_refiner( // IVFQueryParams implementation - wrapper around zvec::IVFQueryParams // ============================================================================= -ZVecIVFQueryParams *zvec_query_params_ivf_create(int nprobe, +zvec_ivf_query_params_t *zvec_query_params_ivf_create(int nprobe, bool is_using_refiner, float scale_factor) { ZVEC_TRY_RETURN_NULL("Failed to create IVFQueryParams", auto *params = new zvec::IVFQueryParams( nprobe, is_using_refiner, scale_factor); - return reinterpret_cast(params);) + return reinterpret_cast(params);) return nullptr; } -void zvec_query_params_ivf_destroy(ZVecIVFQueryParams *params) { +void zvec_query_params_ivf_destroy(zvec_ivf_query_params_t *params) { if (params) { delete reinterpret_cast(params); } } -ZVecErrorCode zvec_query_params_ivf_set_nprobe(ZVecIVFQueryParams *params, +zvec_error_code_t zvec_query_params_ivf_set_nprobe(zvec_ivf_query_params_t *params, int nprobe) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4720,13 +4696,13 @@ ZVecErrorCode zvec_query_params_ivf_set_nprobe(ZVecIVFQueryParams *params, return ZVEC_OK; } -int zvec_query_params_ivf_get_nprobe(const ZVecIVFQueryParams *params) { +int zvec_query_params_ivf_get_nprobe(const zvec_ivf_query_params_t *params) { if (!params) return 10; auto *ptr = reinterpret_cast(params); return ptr->nprobe(); } -ZVecErrorCode zvec_query_params_ivf_set_scale_factor(ZVecIVFQueryParams *params, +zvec_error_code_t zvec_query_params_ivf_set_scale_factor(zvec_ivf_query_params_t *params, float scale_factor) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4738,13 +4714,13 @@ ZVecErrorCode zvec_query_params_ivf_set_scale_factor(ZVecIVFQueryParams *params, return ZVEC_OK; } -float zvec_query_params_ivf_get_scale_factor(const ZVecIVFQueryParams *params) { +float zvec_query_params_ivf_get_scale_factor(const zvec_ivf_query_params_t *params) { if (!params) return 10.0f; auto *ptr = reinterpret_cast(params); return ptr->scale_factor(); } -ZVecErrorCode zvec_query_params_ivf_set_radius(ZVecIVFQueryParams *params, +zvec_error_code_t zvec_query_params_ivf_set_radius(zvec_ivf_query_params_t *params, float radius) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4756,13 +4732,13 @@ ZVecErrorCode zvec_query_params_ivf_set_radius(ZVecIVFQueryParams *params, return ZVEC_OK; } -float zvec_query_params_ivf_get_radius(const ZVecIVFQueryParams *params) { +float zvec_query_params_ivf_get_radius(const zvec_ivf_query_params_t *params) { if (!params) return 0.0f; auto *ptr = reinterpret_cast(params); return ptr->radius(); } -ZVecErrorCode zvec_query_params_ivf_set_is_linear(ZVecIVFQueryParams *params, +zvec_error_code_t zvec_query_params_ivf_set_is_linear(zvec_ivf_query_params_t *params, bool is_linear) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4774,14 +4750,14 @@ ZVecErrorCode zvec_query_params_ivf_set_is_linear(ZVecIVFQueryParams *params, return ZVEC_OK; } -bool zvec_query_params_ivf_get_is_linear(const ZVecIVFQueryParams *params) { +bool zvec_query_params_ivf_get_is_linear(const zvec_ivf_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_linear(); } -ZVecErrorCode zvec_query_params_ivf_set_is_using_refiner( - ZVecIVFQueryParams *params, bool is_using_refiner) { +zvec_error_code_t zvec_query_params_ivf_set_is_using_refiner( + zvec_ivf_query_params_t *params, bool is_using_refiner) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "IVF query params pointer is null"); @@ -4793,7 +4769,7 @@ ZVecErrorCode zvec_query_params_ivf_set_is_using_refiner( } bool zvec_query_params_ivf_get_is_using_refiner( - const ZVecIVFQueryParams *params) { + const zvec_ivf_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_using_refiner(); @@ -4803,23 +4779,23 @@ bool zvec_query_params_ivf_get_is_using_refiner( // FlatQueryParams implementation - wrapper around zvec::FlatQueryParams // ============================================================================= -ZVecFlatQueryParams *zvec_query_params_flat_create(bool is_using_refiner, +zvec_flat_query_params_t *zvec_query_params_flat_create(bool is_using_refiner, float scale_factor) { ZVEC_TRY_RETURN_NULL( "Failed to create FlatQueryParams", auto *params = new zvec::FlatQueryParams(is_using_refiner, scale_factor); - return reinterpret_cast(params);) + return reinterpret_cast(params);) return nullptr; } -void zvec_query_params_flat_destroy(ZVecFlatQueryParams *params) { +void zvec_query_params_flat_destroy(zvec_flat_query_params_t *params) { if (params) { delete reinterpret_cast(params); } } -ZVecErrorCode zvec_query_params_flat_set_scale_factor( - ZVecFlatQueryParams *params, float scale_factor) { +zvec_error_code_t zvec_query_params_flat_set_scale_factor( + zvec_flat_query_params_t *params, float scale_factor) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Flat query params pointer is null"); @@ -4831,13 +4807,13 @@ ZVecErrorCode zvec_query_params_flat_set_scale_factor( } float zvec_query_params_flat_get_scale_factor( - const ZVecFlatQueryParams *params) { + const zvec_flat_query_params_t *params) { if (!params) return 10.0f; auto *ptr = reinterpret_cast(params); return ptr->scale_factor(); } -ZVecErrorCode zvec_query_params_flat_set_radius(ZVecFlatQueryParams *params, +zvec_error_code_t zvec_query_params_flat_set_radius(zvec_flat_query_params_t *params, float radius) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4849,13 +4825,13 @@ ZVecErrorCode zvec_query_params_flat_set_radius(ZVecFlatQueryParams *params, return ZVEC_OK; } -float zvec_query_params_flat_get_radius(const ZVecFlatQueryParams *params) { +float zvec_query_params_flat_get_radius(const zvec_flat_query_params_t *params) { if (!params) return 0.0f; auto *ptr = reinterpret_cast(params); return ptr->radius(); } -ZVecErrorCode zvec_query_params_flat_set_is_linear(ZVecFlatQueryParams *params, +zvec_error_code_t zvec_query_params_flat_set_is_linear(zvec_flat_query_params_t *params, bool is_linear) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, @@ -4867,14 +4843,14 @@ ZVecErrorCode zvec_query_params_flat_set_is_linear(ZVecFlatQueryParams *params, return ZVEC_OK; } -bool zvec_query_params_flat_get_is_linear(const ZVecFlatQueryParams *params) { +bool zvec_query_params_flat_get_is_linear(const zvec_flat_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_linear(); } -ZVecErrorCode zvec_query_params_flat_set_is_using_refiner( - ZVecFlatQueryParams *params, bool is_using_refiner) { +zvec_error_code_t zvec_query_params_flat_set_is_using_refiner( + zvec_flat_query_params_t *params, bool is_using_refiner) { if (!params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Flat query params pointer is null"); @@ -4886,7 +4862,7 @@ ZVecErrorCode zvec_query_params_flat_set_is_using_refiner( } bool zvec_query_params_flat_get_is_using_refiner( - const ZVecFlatQueryParams *params) { + const zvec_flat_query_params_t *params) { if (!params) return false; auto *ptr = reinterpret_cast(params); return ptr->is_using_refiner(); @@ -4896,22 +4872,22 @@ bool zvec_query_params_flat_get_is_using_refiner( // VectorQuery implementation - owns zvec::VectorQuery via raw pointer // ============================================================================= -ZVecVectorQuery *zvec_vector_query_create(void) { +zvec_vector_query_t *zvec_vector_query_create(void) { ZVEC_TRY_RETURN_NULL("Failed to create VectorQuery", auto *query = new zvec::VectorQuery(); query->topk_ = 10; query->include_doc_id_ = true; query->include_vector_ = false; - return reinterpret_cast(query);) + return reinterpret_cast(query);) return nullptr; } -void zvec_vector_query_destroy(ZVecVectorQuery *query) { +void zvec_vector_query_destroy(zvec_vector_query_t *query) { if (query) { delete reinterpret_cast(query); } } -ZVecErrorCode zvec_vector_query_set_topk(ZVecVectorQuery *query, int topk) { +zvec_error_code_t zvec_vector_query_set_topk(zvec_vector_query_t *query, int topk) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -4921,13 +4897,13 @@ ZVecErrorCode zvec_vector_query_set_topk(ZVecVectorQuery *query, int topk) { return ZVEC_OK; } -int zvec_vector_query_get_topk(const ZVecVectorQuery *query) { +int zvec_vector_query_get_topk(const zvec_vector_query_t *query) { if (!query) return 10; auto *ptr = reinterpret_cast(query); return ptr->topk_; } -ZVecErrorCode zvec_vector_query_set_field_name(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_field_name(zvec_vector_query_t *query, const char *field_name) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); @@ -4938,13 +4914,13 @@ ZVecErrorCode zvec_vector_query_set_field_name(ZVecVectorQuery *query, return ZVEC_OK; } -const char *zvec_vector_query_get_field_name(const ZVecVectorQuery *query) { +const char *zvec_vector_query_get_field_name(const zvec_vector_query_t *query) { if (!query) return nullptr; auto *ptr = reinterpret_cast(query); return ptr->field_name_.empty() ? nullptr : ptr->field_name_.c_str(); } -ZVecErrorCode zvec_vector_query_set_query_vector(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_query_vector(zvec_vector_query_t *query, const void *data, size_t size) { if (!query || !data || size == 0) { @@ -4957,7 +4933,7 @@ ZVecErrorCode zvec_vector_query_set_query_vector(ZVecVectorQuery *query, return ZVEC_OK; } -ZVecErrorCode zvec_vector_query_set_filter(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_filter(zvec_vector_query_t *query, const char *filter) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); @@ -4968,13 +4944,13 @@ ZVecErrorCode zvec_vector_query_set_filter(ZVecVectorQuery *query, return ZVEC_OK; } -const char *zvec_vector_query_get_filter(const ZVecVectorQuery *query) { +const char *zvec_vector_query_get_filter(const zvec_vector_query_t *query) { if (!query) return nullptr; auto *ptr = reinterpret_cast(query); return ptr->filter_.empty() ? nullptr : ptr->filter_.c_str(); } -ZVecErrorCode zvec_vector_query_set_include_vector(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_include_vector(zvec_vector_query_t *query, bool include) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); @@ -4985,13 +4961,13 @@ ZVecErrorCode zvec_vector_query_set_include_vector(ZVecVectorQuery *query, return ZVEC_OK; } -bool zvec_vector_query_get_include_vector(const ZVecVectorQuery *query) { +bool zvec_vector_query_get_include_vector(const zvec_vector_query_t *query) { if (!query) return false; auto *ptr = reinterpret_cast(query); return ptr->include_vector_; } -ZVecErrorCode zvec_vector_query_set_include_doc_id(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_include_doc_id(zvec_vector_query_t *query, bool include) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); @@ -5002,13 +4978,13 @@ ZVecErrorCode zvec_vector_query_set_include_doc_id(ZVecVectorQuery *query, return ZVEC_OK; } -bool zvec_vector_query_get_include_doc_id(const ZVecVectorQuery *query) { +bool zvec_vector_query_get_include_doc_id(const zvec_vector_query_t *query) { if (!query) return false; auto *ptr = reinterpret_cast(query); return ptr->include_doc_id_; } -ZVecErrorCode zvec_vector_query_set_output_fields(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_output_fields(zvec_vector_query_t *query, const char **fields, size_t count) { if (!query) { @@ -5029,7 +5005,7 @@ ZVecErrorCode zvec_vector_query_set_output_fields(ZVecVectorQuery *query, return ZVEC_OK; } -ZVecErrorCode zvec_vector_query_get_output_fields(const ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_get_output_fields(const zvec_vector_query_t *query, const char ***fields, size_t *count) { if (!query || !fields || !count) { @@ -5063,7 +5039,7 @@ ZVecErrorCode zvec_vector_query_get_output_fields(const ZVecVectorQuery *query, // VectorQuery) // ============================================================================= -ZVecErrorCode zvec_vector_query_set_query_params(ZVecVectorQuery *query, +zvec_error_code_t zvec_vector_query_set_query_params(zvec_vector_query_t *query, void *params) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Vector query pointer is null"); @@ -5085,8 +5061,8 @@ ZVecErrorCode zvec_vector_query_set_query_params(ZVecVectorQuery *query, } // Type-specific setters for cleaner ownership transfer -ZVecErrorCode zvec_vector_query_set_hnsw_params( - ZVecVectorQuery *query, ZVecHnswQueryParams *hnsw_params) { +zvec_error_code_t zvec_vector_query_set_hnsw_params( + zvec_vector_query_t *query, zvec_hnsw_query_params_t *hnsw_params) { if (!query || !hnsw_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or HNSW params pointer is null"); @@ -5102,8 +5078,8 @@ ZVecErrorCode zvec_vector_query_set_hnsw_params( return ZVEC_OK; } -ZVecErrorCode zvec_vector_query_set_ivf_params(ZVecVectorQuery *query, - ZVecIVFQueryParams *ivf_params) { +zvec_error_code_t zvec_vector_query_set_ivf_params(zvec_vector_query_t *query, + zvec_ivf_query_params_t *ivf_params) { if (!query || !ivf_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or IVF params pointer is null"); @@ -5118,8 +5094,8 @@ ZVecErrorCode zvec_vector_query_set_ivf_params(ZVecVectorQuery *query, return ZVEC_OK; } -ZVecErrorCode zvec_vector_query_set_flat_params( - ZVecVectorQuery *query, ZVecFlatQueryParams *flat_params) { +zvec_error_code_t zvec_vector_query_set_flat_params( + zvec_vector_query_t *query, zvec_flat_query_params_t *flat_params) { if (!query || !flat_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or Flat params pointer is null"); @@ -5139,23 +5115,23 @@ ZVecErrorCode zvec_vector_query_set_flat_params( // pointer // ============================================================================= -ZVecGroupByVectorQuery *zvec_group_by_vector_query_create(void) { +zvec_group_by_vector_query_t *zvec_group_by_vector_query_create(void) { ZVEC_TRY_RETURN_NULL( "Failed to create GroupByVectorQuery", auto *query = new zvec::GroupByVectorQuery(); query->group_count_ = 2; query->group_topk_ = 3; - return reinterpret_cast(query);) + return reinterpret_cast(query);) return nullptr; } -void zvec_group_by_vector_query_destroy(ZVecGroupByVectorQuery *query) { +void zvec_group_by_vector_query_destroy(zvec_group_by_vector_query_t *query) { if (query) { delete reinterpret_cast(query); } } -ZVecErrorCode zvec_group_by_vector_query_set_field_name( - ZVecGroupByVectorQuery *query, const char *field_name) { +zvec_error_code_t zvec_group_by_vector_query_set_field_name( + zvec_group_by_vector_query_t *query, const char *field_name) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5167,14 +5143,14 @@ ZVecErrorCode zvec_group_by_vector_query_set_field_name( } const char *zvec_group_by_vector_query_get_field_name( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return nullptr; auto *ptr = reinterpret_cast(query); return ptr->field_name_.empty() ? nullptr : ptr->field_name_.c_str(); } -ZVecErrorCode zvec_group_by_vector_query_set_group_by_field_name( - ZVecGroupByVectorQuery *query, const char *field_name) { +zvec_error_code_t zvec_group_by_vector_query_set_group_by_field_name( + zvec_group_by_vector_query_t *query, const char *field_name) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5186,15 +5162,15 @@ ZVecErrorCode zvec_group_by_vector_query_set_group_by_field_name( } const char *zvec_group_by_vector_query_get_group_by_field_name( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return nullptr; auto *ptr = reinterpret_cast(query); return ptr->group_by_field_name_.empty() ? nullptr : ptr->group_by_field_name_.c_str(); } -ZVecErrorCode zvec_group_by_vector_query_set_group_count( - ZVecGroupByVectorQuery *query, uint32_t count) { +zvec_error_code_t zvec_group_by_vector_query_set_group_count( + zvec_group_by_vector_query_t *query, uint32_t count) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5206,14 +5182,14 @@ ZVecErrorCode zvec_group_by_vector_query_set_group_count( } uint32_t zvec_group_by_vector_query_get_group_count( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return 2; auto *ptr = reinterpret_cast(query); return ptr->group_count_; } -ZVecErrorCode zvec_group_by_vector_query_set_group_topk( - ZVecGroupByVectorQuery *query, uint32_t topk) { +zvec_error_code_t zvec_group_by_vector_query_set_group_topk( + zvec_group_by_vector_query_t *query, uint32_t topk) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5225,14 +5201,14 @@ ZVecErrorCode zvec_group_by_vector_query_set_group_topk( } uint32_t zvec_group_by_vector_query_get_group_topk( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return 3; auto *ptr = reinterpret_cast(query); return ptr->group_topk_; } -ZVecErrorCode zvec_group_by_vector_query_set_query_vector( - ZVecGroupByVectorQuery *query, const void *data, size_t size) { +zvec_error_code_t zvec_group_by_vector_query_set_query_vector( + zvec_group_by_vector_query_t *query, const void *data, size_t size) { if (!query || !data || size == 0) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer or data is null/empty"); @@ -5243,8 +5219,8 @@ ZVecErrorCode zvec_group_by_vector_query_set_query_vector( return ZVEC_OK; } -ZVecErrorCode zvec_group_by_vector_query_set_filter( - ZVecGroupByVectorQuery *query, const char *filter) { +zvec_error_code_t zvec_group_by_vector_query_set_filter( + zvec_group_by_vector_query_t *query, const char *filter) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5256,14 +5232,14 @@ ZVecErrorCode zvec_group_by_vector_query_set_filter( } const char *zvec_group_by_vector_query_get_filter( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return nullptr; auto *ptr = reinterpret_cast(query); return ptr->filter_.empty() ? nullptr : ptr->filter_.c_str(); } -ZVecErrorCode zvec_group_by_vector_query_set_include_vector( - ZVecGroupByVectorQuery *query, bool include) { +zvec_error_code_t zvec_group_by_vector_query_set_include_vector( + zvec_group_by_vector_query_t *query, bool include) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5275,14 +5251,14 @@ ZVecErrorCode zvec_group_by_vector_query_set_include_vector( } bool zvec_group_by_vector_query_get_include_vector( - const ZVecGroupByVectorQuery *query) { + const zvec_group_by_vector_query_t *query) { if (!query) return false; auto *ptr = reinterpret_cast(query); return ptr->include_vector_; } -ZVecErrorCode zvec_group_by_vector_query_set_output_fields( - ZVecGroupByVectorQuery *query, const char **fields, size_t count) { +zvec_error_code_t zvec_group_by_vector_query_set_output_fields( + zvec_group_by_vector_query_t *query, const char **fields, size_t count) { if (!query) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "GroupByVectorQuery pointer is null"); @@ -5302,8 +5278,8 @@ ZVecErrorCode zvec_group_by_vector_query_set_output_fields( return ZVEC_OK; } -ZVecErrorCode zvec_group_by_vector_query_get_output_fields( - ZVecGroupByVectorQuery *query, const char ***fields, size_t *count) { +zvec_error_code_t zvec_group_by_vector_query_get_output_fields( + zvec_group_by_vector_query_t *query, const char ***fields, size_t *count) { if (!query || !fields || !count) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query, fields, or count pointer is null"); @@ -5330,8 +5306,8 @@ ZVecErrorCode zvec_group_by_vector_query_get_output_fields( return ZVEC_OK; } -ZVecErrorCode zvec_group_by_vector_query_set_query_params( - ZVecGroupByVectorQuery *query, void *params) { +zvec_error_code_t zvec_group_by_vector_query_set_query_params( + zvec_group_by_vector_query_t *query, void *params) { if (!query || !params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or params pointer is null"); @@ -5347,8 +5323,8 @@ ZVecErrorCode zvec_group_by_vector_query_set_query_params( } // Type-specific setters for GroupByVectorQuery -ZVecErrorCode zvec_group_by_vector_query_set_hnsw_params( - ZVecGroupByVectorQuery *query, ZVecHnswQueryParams *hnsw_params) { +zvec_error_code_t zvec_group_by_vector_query_set_hnsw_params( + zvec_group_by_vector_query_t *query, zvec_hnsw_query_params_t *hnsw_params) { if (!query || !hnsw_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or HNSW params pointer is null"); @@ -5363,8 +5339,8 @@ ZVecErrorCode zvec_group_by_vector_query_set_hnsw_params( return ZVEC_OK; } -ZVecErrorCode zvec_group_by_vector_query_set_ivf_params( - ZVecGroupByVectorQuery *query, ZVecIVFQueryParams *ivf_params) { +zvec_error_code_t zvec_group_by_vector_query_set_ivf_params( + zvec_group_by_vector_query_t *query, zvec_ivf_query_params_t *ivf_params) { if (!query || !ivf_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or IVF params pointer is null"); @@ -5379,8 +5355,8 @@ ZVecErrorCode zvec_group_by_vector_query_set_ivf_params( return ZVEC_OK; } -ZVecErrorCode zvec_group_by_vector_query_set_flat_params( - ZVecGroupByVectorQuery *query, ZVecFlatQueryParams *flat_params) { +zvec_error_code_t zvec_group_by_vector_query_set_flat_params( + zvec_group_by_vector_query_t *query, zvec_flat_query_params_t *flat_params) { if (!query || !flat_params) { SET_LAST_ERROR(ZVEC_ERROR_INVALID_ARGUMENT, "Query or Flat params pointer is null"); @@ -5408,9 +5384,9 @@ ZVecErrorCode zvec_group_by_vector_query_set_flat_params( * @note index_params is cloned internally, caller should still call * zvec_index_params_destroy() to free the original */ -ZVecErrorCode zvec_collection_create_index( - ZVecCollection *collection, const char *column_name, - const ZVecIndexParams *index_params) { +zvec_error_code_t zvec_collection_create_index( + zvec_collection_t *collection, const char *column_name, + const zvec_index_params_t *index_params) { if (!collection || !column_name || !index_params) { set_last_error( "Invalid arguments: collection, column_name, and index_params cannot " @@ -5437,7 +5413,7 @@ ZVecErrorCode zvec_collection_create_index( * @param column_name Column name to drop index from * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_collection_drop_index(ZVecCollection *collection, +zvec_error_code_t zvec_collection_drop_index(zvec_collection_t *collection, const char *column_name) { if (!collection || !column_name) { set_last_error( @@ -5460,7 +5436,7 @@ ZVecErrorCode zvec_collection_drop_index(ZVecCollection *collection, * @param collection Collection handle * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_collection_optimize(ZVecCollection *collection) { +zvec_error_code_t zvec_collection_optimize(zvec_collection_t *collection) { if (!collection) { set_last_error("Invalid argument: collection cannot be null"); return ZVEC_ERROR_INVALID_ARGUMENT; @@ -5487,8 +5463,8 @@ ZVecErrorCode zvec_collection_optimize(ZVecCollection *collection) { * @param expression Default value expression (can be NULL for no default) * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_collection_add_column(ZVecCollection *collection, - const ZVecFieldSchema *field_schema, +zvec_error_code_t zvec_collection_add_column(zvec_collection_t *collection, + const zvec_field_schema_t *field_schema, const char *expression) { if (!collection || !field_schema) { set_last_error( @@ -5521,7 +5497,7 @@ ZVecErrorCode zvec_collection_add_column(ZVecCollection *collection, * @param column_name Column name to drop * @return ZVEC_OK on success, error code on failure */ -ZVecErrorCode zvec_collection_drop_column(ZVecCollection *collection, +zvec_error_code_t zvec_collection_drop_column(zvec_collection_t *collection, const char *column_name) { if (!collection || !column_name) { set_last_error( @@ -5540,9 +5516,9 @@ ZVecErrorCode zvec_collection_drop_column(ZVecCollection *collection, return status_to_error_code(status);) } -ZVecErrorCode zvec_collection_alter_column( - ZVecCollection *collection, const char *column_name, const char *new_name, - const ZVecFieldSchema *new_schema) { +zvec_error_code_t zvec_collection_alter_column( + zvec_collection_t *collection, const char *column_name, const char *new_name, + const zvec_field_schema_t *new_schema) { if (!collection || !column_name) { set_last_error( "Invalid arguments: collection and column_name cannot be null"); @@ -5576,8 +5552,8 @@ ZVecErrorCode zvec_collection_alter_column( // DML Interface Implementation // ============================================================================= -ZVecErrorCode zvec_collection_insert(ZVecCollection *collection, - const ZVecDoc **docs, size_t doc_count, +zvec_error_code_t zvec_collection_insert(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count) { if (!collection || !docs || doc_count == 0 || !success_count || @@ -5597,7 +5573,7 @@ ZVecErrorCode zvec_collection_insert(ZVecCollection *collection, convert_zvec_docs_to_internal(docs, doc_count); auto result = (*coll_ptr)->Insert(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { *success_count = 0; @@ -5617,10 +5593,10 @@ ZVecErrorCode zvec_collection_insert(ZVecCollection *collection, return error_code;) } -ZVecErrorCode zvec_collection_insert_with_results(ZVecCollection *collection, - const ZVecDoc **docs, +zvec_error_code_t zvec_collection_insert_with_results(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, - ZVecWriteResult **results, + zvec_write_result_t **results, size_t *result_count) { if (!collection || !docs || doc_count == 0 || !results || !result_count) { set_last_error( @@ -5642,15 +5618,15 @@ ZVecErrorCode zvec_collection_insert_with_results(ZVecCollection *collection, std::vector pks = collect_doc_pks(docs, doc_count); auto result = (*coll_ptr)->Insert(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code != ZVEC_OK) { return error_code; } - return build_write_results(result.value(), pks, results, result_count);) + return build_write_results(result.value(), results, result_count);) } -ZVecErrorCode zvec_collection_update(ZVecCollection *collection, - const ZVecDoc **docs, size_t doc_count, +zvec_error_code_t zvec_collection_update(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count) { if (!collection || !docs || doc_count == 0 || !success_count || @@ -5670,7 +5646,7 @@ ZVecErrorCode zvec_collection_update(ZVecCollection *collection, convert_zvec_docs_to_internal(docs, doc_count); auto result = (*coll_ptr)->Update(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { *success_count = 0; @@ -5687,10 +5663,10 @@ ZVecErrorCode zvec_collection_update(ZVecCollection *collection, return error_code;) } -ZVecErrorCode zvec_collection_update_with_results(ZVecCollection *collection, - const ZVecDoc **docs, +zvec_error_code_t zvec_collection_update_with_results(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, - ZVecWriteResult **results, + zvec_write_result_t **results, size_t *result_count) { if (!collection || !docs || doc_count == 0 || !results || !result_count) { set_last_error( @@ -5712,15 +5688,15 @@ ZVecErrorCode zvec_collection_update_with_results(ZVecCollection *collection, std::vector pks = collect_doc_pks(docs, doc_count); auto result = (*coll_ptr)->Update(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code != ZVEC_OK) { return error_code; } - return build_write_results(result.value(), pks, results, result_count);) + return build_write_results(result.value(), results, result_count);) } -ZVecErrorCode zvec_collection_upsert(ZVecCollection *collection, - const ZVecDoc **docs, size_t doc_count, +zvec_error_code_t zvec_collection_upsert(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count) { if (!collection || !docs || doc_count == 0 || !success_count || @@ -5740,7 +5716,7 @@ ZVecErrorCode zvec_collection_upsert(ZVecCollection *collection, convert_zvec_docs_to_internal(docs, doc_count); auto result = (*coll_ptr)->Upsert(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { *success_count = 0; @@ -5757,10 +5733,10 @@ ZVecErrorCode zvec_collection_upsert(ZVecCollection *collection, return error_code;) } -ZVecErrorCode zvec_collection_upsert_with_results(ZVecCollection *collection, - const ZVecDoc **docs, +zvec_error_code_t zvec_collection_upsert_with_results(zvec_collection_t *collection, + const zvec_doc_t **docs, size_t doc_count, - ZVecWriteResult **results, + zvec_write_result_t **results, size_t *result_count) { if (!collection || !docs || doc_count == 0 || !results || !result_count) { set_last_error( @@ -5782,14 +5758,14 @@ ZVecErrorCode zvec_collection_upsert_with_results(ZVecCollection *collection, std::vector pks = collect_doc_pks(docs, doc_count); auto result = (*coll_ptr)->Upsert(internal_docs); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code != ZVEC_OK) { return error_code; } - return build_write_results(result.value(), pks, results, result_count);) + return build_write_results(result.value(), results, result_count);) } -ZVecErrorCode zvec_collection_delete(ZVecCollection *collection, +zvec_error_code_t zvec_collection_delete(zvec_collection_t *collection, const char *const *pks, size_t pk_count, size_t *success_count, size_t *error_count) { @@ -5814,7 +5790,7 @@ ZVecErrorCode zvec_collection_delete(ZVecCollection *collection, } auto result = (*coll_ptr)->Delete(primary_keys); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { *success_count = 0; @@ -5831,10 +5807,10 @@ ZVecErrorCode zvec_collection_delete(ZVecCollection *collection, return error_code;) } -ZVecErrorCode zvec_collection_delete_with_results(ZVecCollection *collection, +zvec_error_code_t zvec_collection_delete_with_results(zvec_collection_t *collection, const char *const *pks, size_t pk_count, - ZVecWriteResult **results, + zvec_write_result_t **results, size_t *result_count) { if (!collection || !pks || pk_count == 0 || !results || !result_count) { set_last_error( @@ -5861,15 +5837,15 @@ ZVecErrorCode zvec_collection_delete_with_results(ZVecCollection *collection, } auto result = (*coll_ptr)->Delete(primary_keys); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code != ZVEC_OK) { return error_code; } - return build_write_results(result.value(), primary_keys, results, + return build_write_results(result.value(), results, result_count);) } -ZVecErrorCode zvec_collection_delete_by_filter(ZVecCollection *collection, +zvec_error_code_t zvec_collection_delete_by_filter(zvec_collection_t *collection, const char *filter) { if (!collection || !filter) { set_last_error("Invalid arguments: collection,filter cannot be null"); @@ -5893,12 +5869,12 @@ ZVecErrorCode zvec_collection_delete_by_filter(ZVecCollection *collection, // ============================================================================= // Helper function to convert document results to C API format -ZVecErrorCode convert_document_results( +zvec_error_code_t convert_document_results( const std::vector> &query_results, - ZVecDoc ***results, size_t *result_count) { + zvec_doc_t ***results, size_t *result_count) { *result_count = query_results.size(); *results = - static_cast(malloc(*result_count * sizeof(ZVecDoc *))); + static_cast(malloc(*result_count * sizeof(zvec_doc_t *))); if (!*results) { set_last_error("Failed to allocate memory for query results"); @@ -5908,7 +5884,7 @@ ZVecErrorCode convert_document_results( for (size_t i = 0; i < *result_count; ++i) { const auto &internal_doc = query_results[i]; // Create new document wrapper - ZVecDoc *c_doc = zvec_doc_create(); + zvec_doc_t *c_doc = zvec_doc_create(); if (!c_doc) { // Clean up previously allocated documents for (size_t j = 0; j < i; ++j) { @@ -5959,8 +5935,8 @@ static void normalize_nullable_fields_for_fetch( } } -ZVecErrorCode convert_fetched_document_results(const zvec::DocPtrMap &doc_map, - ZVecDoc ***results, +zvec_error_code_t convert_fetched_document_results(const zvec::DocPtrMap &doc_map, + zvec_doc_t ***results, size_t *doc_count) { // Calculate actual document count (some PKs might not exist) size_t actual_count = 0; @@ -5977,18 +5953,18 @@ ZVecErrorCode convert_fetched_document_results(const zvec::DocPtrMap &doc_map, return ZVEC_OK; } - *results = static_cast(malloc(*doc_count * sizeof(ZVecDoc *))); + *results = static_cast(malloc(*doc_count * sizeof(zvec_doc_t *))); if (!*results) { set_last_error("Failed to allocate memory for document pointers"); return ZVEC_ERROR_INTERNAL_ERROR; } - // Convert C++ DocPtrMap to C ZVecDoc pointer array + // Convert C++ DocPtrMap to C zvec_doc_t pointer array size_t index = 0; for (const auto &[pk, doc_ptr] : doc_map) { if (doc_ptr && index < *doc_count) { // Create new document wrapper - ZVecDoc *c_doc = zvec_doc_create(); + zvec_doc_t *c_doc = zvec_doc_create(); if (!c_doc) { // Clean up previously allocated documents for (size_t j = 0; j < index; ++j) { @@ -6016,9 +5992,9 @@ ZVecErrorCode convert_fetched_document_results(const zvec::DocPtrMap &doc_map, return ZVEC_OK; } -ZVecErrorCode zvec_collection_query(const ZVecCollection *collection, - const ZVecVectorQuery *query, - ZVecDoc ***results, +zvec_error_code_t zvec_collection_query(const zvec_collection_t *collection, + const zvec_vector_query_t *query, + zvec_doc_t ***results, size_t *result_count) { if (!collection || !query || !results || !result_count) { set_last_error( @@ -6034,12 +6010,12 @@ ZVecErrorCode zvec_collection_query(const ZVecCollection *collection, reinterpret_cast *>( collection); - // Cast ZVecVectorQuery* to zvec::VectorQuery* directly + // Cast zvec_vector_query_t* to zvec::VectorQuery* directly auto *internal_query = reinterpret_cast(query); auto result = (*coll_ptr)->Query(*internal_query); - ZVecErrorCode error_code = handle_expected_result(result); + zvec_error_code_t error_code = handle_expected_result(result); if (error_code == ZVEC_OK) { const auto &query_results = result.value(); @@ -6053,9 +6029,9 @@ ZVecErrorCode zvec_collection_query(const ZVecCollection *collection, return error_code;) } -ZVecErrorCode zvec_collection_fetch(ZVecCollection *collection, +zvec_error_code_t zvec_collection_fetch(zvec_collection_t *collection, const char *const *pks, size_t pk_count, - ZVecDoc ***results, size_t *doc_count) { + zvec_doc_t ***results, size_t *doc_count) { if (!collection || !pks || !results || !doc_count) { set_last_error( "Invalid arguments: collection, pks, results and doc_count cannot " diff --git a/src/include/zvec/c_api.h b/src/include/zvec/c_api.h index 75eba70..af21729 100644 --- a/src/include/zvec/c_api.h +++ b/src/include/zvec/c_api.h @@ -117,34 +117,34 @@ typedef enum { ZVEC_ERROR_INTERNAL_ERROR = 8, /**< Internal error */ ZVEC_ERROR_NOT_SUPPORTED = 9, /**< Unsupported operation */ ZVEC_ERROR_UNKNOWN = 10 /**< Unknown error */ -} ZVecErrorCode; +} zvec_error_code_t; /** * @brief Error details structure */ typedef struct { - ZVecErrorCode code; /**< Error code */ - const char *message; /**< Error message */ - const char *file; /**< File where error occurred */ - int line; /**< Line number where error occurred */ - const char *function; /**< Function where error occurred */ -} ZVecErrorDetails; + zvec_error_code_t code; /**< Error code */ + const char *message; /**< Error message */ + const char *file; /**< File where error occurred */ + int line; /**< Line number where error occurred */ + const char *function; /**< Function where error occurred */ +} zvec_error_details_t; /** * @brief Get detailed information of the last error * @param[out] error_details Pointer to error details structure - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_get_last_error_details(ZVecErrorDetails *error_details); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_get_last_error_details(zvec_error_details_t *error_details); /** * @brief Get last error message * @param[out] error_msg Returned error message string (needs to be freed by * calling free) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_get_last_error(char **error_msg); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_get_last_error(char **error_msg); /** * @brief Clear error status @@ -162,7 +162,7 @@ ZVEC_EXPORT void ZVEC_CALL zvec_clear_error(void); typedef struct { const char *data; /**< String data pointer */ size_t length; /**< String length */ -} ZVecStringView; +} zvec_string_view_t; /** * @brief Mutable string structure (owns memory) @@ -171,15 +171,15 @@ typedef struct { char *data; /**< String data pointer */ size_t length; /**< String length */ size_t capacity; /**< Allocated capacity */ -} ZVecString; +} zvec_string_t; /** * @brief String array structure */ typedef struct { - ZVecString *strings; /**< String array */ - size_t count; /**< String count */ -} ZVecStringArray; + zvec_string_t *strings; /**< String array */ + size_t count; /**< String count */ +} zvec_string_array_t; /** * @brief Float array structure @@ -187,7 +187,7 @@ typedef struct { typedef struct { const float *data; size_t length; -} ZVecFloatArray; +} zvec_float_array_t; /** * @brief Integer array structure @@ -195,7 +195,7 @@ typedef struct { typedef struct { const int64_t *data; size_t length; -} ZVecInt64Array; +} zvec_int64_array_t; /** * @brief Byte array structure @@ -203,7 +203,7 @@ typedef struct { typedef struct { const uint8_t *data; /**< Byte data pointer */ size_t length; /**< Array length */ -} ZVecByteArray; +} zvec_byte_array_t; /** * @brief Mutable byte array structure @@ -212,7 +212,7 @@ typedef struct { uint8_t *data; /**< Byte data pointer */ size_t length; /**< Current length */ size_t capacity; /**< Allocated capacity */ -} ZVecMutableByteArray; +} zvec_mutable_byte_array_t; // ============================================================================= // String management functions @@ -221,65 +221,65 @@ typedef struct { /** * @brief Create string from C string * @param str C string - * @return ZVecString* Pointer to the newly created string + * @return zvec_string_t* Pointer to the newly created string */ -ZVEC_EXPORT ZVecString *ZVEC_CALL zvec_string_create(const char *str); +ZVEC_EXPORT zvec_string_t *ZVEC_CALL zvec_string_create(const char *str); /** * @brief Create string from string view * - * Creates a new ZVecString by copying data from a ZVecStringView. + * Creates a new zvec_string_t by copying data from a zvec_string_view_t. * The created string owns its memory and must be freed with zvec_free_string(). * * @param view Pointer to source string view (must not be NULL) - * @return ZVecString* New string instance on success, NULL on error + * @return zvec_string_t* New string instance on success, NULL on error * @note Caller is responsible for freeing the returned string */ -ZVEC_EXPORT ZVecString *ZVEC_CALL -zvec_string_create_from_view(const ZVecStringView *view); +ZVEC_EXPORT zvec_string_t *ZVEC_CALL +zvec_string_create_from_view(const zvec_string_view_t *view); /** * @brief Create binary-safe string from raw data * - * Creates a new ZVecString from raw binary data that may contain null bytes. + * Creates a new zvec_string_t from raw binary data that may contain null bytes. * Unlike zvec_string_create(), this function takes explicit length parameter * and doesn't rely on null-termination. * The created string owns its memory and must be freed with zvec_free_string(). * * @param data Raw binary data pointer (must not be NULL) * @param length Length of data in bytes - * @return ZVecString* New string instance on success, NULL on error + * @return zvec_string_t* New string instance on success, NULL on error * @note Caller is responsible for freeing the returned string * @note This function is suitable for binary data containing null bytes */ -ZVEC_EXPORT ZVecString *ZVEC_CALL zvec_bin_create(const uint8_t *data, - size_t length); +ZVEC_EXPORT zvec_string_t *ZVEC_CALL zvec_bin_create(const uint8_t *data, + size_t length); /** * @brief Copy string * - * Creates a new ZVecString by copying an existing string. + * Creates a new zvec_string_t by copying an existing string. * The created string owns its memory and must be freed with zvec_free_string(). * * @param str Pointer to source string (must not be NULL) - * @return ZVecString* New string instance on success, NULL on error + * @return zvec_string_t* New string instance on success, NULL on error * @note Caller is responsible for freeing the returned string */ -ZVEC_EXPORT ZVecString *ZVEC_CALL zvec_string_copy(const ZVecString *str); +ZVEC_EXPORT zvec_string_t *ZVEC_CALL zvec_string_copy(const zvec_string_t *str); /** - * @brief Get C string from ZVecString - * @param str ZVecString pointer + * @brief Get C string from zvec_string_t + * @param str zvec_string_t pointer * @return const char* C string */ -ZVEC_EXPORT const char *ZVEC_CALL zvec_string_c_str(const ZVecString *str); +ZVEC_EXPORT const char *ZVEC_CALL zvec_string_c_str(const zvec_string_t *str); /** * @brief Get string length - * @param str ZVecString pointer + * @param str zvec_string_t pointer * @return size_t String length */ -ZVEC_EXPORT size_t ZVEC_CALL zvec_string_length(const ZVecString *str); +ZVEC_EXPORT size_t ZVEC_CALL zvec_string_length(const zvec_string_t *str); /** * @brief Compare two strings @@ -287,14 +287,14 @@ ZVEC_EXPORT size_t ZVEC_CALL zvec_string_length(const ZVecString *str); * @param str2 Second string * @return int Comparison result (-1, 0, or 1) */ -ZVEC_EXPORT int ZVEC_CALL zvec_string_compare(const ZVecString *str1, - const ZVecString *str2); +ZVEC_EXPORT int ZVEC_CALL zvec_string_compare(const zvec_string_t *str1, + const zvec_string_t *str2); /** * @brief Free string memory * @param str String pointer to free */ -ZVEC_EXPORT void ZVEC_CALL zvec_free_string(ZVecString *str); +ZVEC_EXPORT void ZVEC_CALL zvec_free_string(zvec_string_t *str); // ============================================================================= @@ -306,7 +306,8 @@ ZVEC_EXPORT void ZVEC_CALL zvec_free_string(ZVecString *str); * @param count Initial number of strings to allocate space for * @return Pointer to the newly created string array, or NULL on failure */ -ZVEC_EXPORT ZVecStringArray *ZVEC_CALL zvec_string_array_create(size_t count); +ZVEC_EXPORT zvec_string_array_t *ZVEC_CALL +zvec_string_array_create(size_t count); /** * @brief Add a string to the string array at specified index @@ -314,21 +315,22 @@ ZVEC_EXPORT ZVecStringArray *ZVEC_CALL zvec_string_array_create(size_t count); * @param idx Index position where the string should be added * @param str Null-terminated C string to add */ -ZVEC_EXPORT void ZVEC_CALL zvec_string_array_add(ZVecStringArray *array, +ZVEC_EXPORT void ZVEC_CALL zvec_string_array_add(zvec_string_array_t *array, size_t idx, const char *str); /** * @brief Destroy string array and free all associated memory * @param array String array pointer to destroy */ -ZVEC_EXPORT void ZVEC_CALL zvec_string_array_destroy(ZVecStringArray *array); +ZVEC_EXPORT void ZVEC_CALL +zvec_string_array_destroy(zvec_string_array_t *array); /** * @brief Create a new mutable byte array * @param capacity Initial capacity in bytes * @return Pointer to the newly created byte array, or NULL on failure */ -ZVEC_EXPORT ZVecMutableByteArray *ZVEC_CALL +ZVEC_EXPORT zvec_mutable_byte_array_t *ZVEC_CALL zvec_byte_array_create(size_t capacity); @@ -336,33 +338,34 @@ zvec_byte_array_create(size_t capacity); * @brief Destroy byte array and free all associated memory * @param array Byte array pointer to destroy */ -ZVEC_EXPORT void ZVEC_CALL zvec_byte_array_destroy(ZVecMutableByteArray *array); +ZVEC_EXPORT void ZVEC_CALL +zvec_byte_array_destroy(zvec_mutable_byte_array_t *array); /** * @brief Create a new float array * @param count Number of floats to allocate space for * @return Pointer to the newly created float array, or NULL on failure */ -ZVEC_EXPORT ZVecFloatArray *ZVEC_CALL zvec_float_array_create(size_t count); +ZVEC_EXPORT zvec_float_array_t *ZVEC_CALL zvec_float_array_create(size_t count); /** * @brief Destroy float array and free all associated memory * @param array Float array pointer to destroy */ -ZVEC_EXPORT void ZVEC_CALL zvec_float_array_destroy(ZVecFloatArray *array); +ZVEC_EXPORT void ZVEC_CALL zvec_float_array_destroy(zvec_float_array_t *array); /** * @brief Create a new int64 array * @param count Number of int64 values to allocate space for * @return Pointer to the newly created int64 array, or NULL on failure */ -ZVEC_EXPORT ZVecInt64Array *ZVEC_CALL zvec_int64_array_create(size_t count); +ZVEC_EXPORT zvec_int64_array_t *ZVEC_CALL zvec_int64_array_create(size_t count); /** * @brief Destroy int64 array and free all associated memory * @param array Int64 array pointer to destroy */ -ZVEC_EXPORT void ZVEC_CALL zvec_int64_array_destroy(ZVecInt64Array *array); +ZVEC_EXPORT void ZVEC_CALL zvec_int64_array_destroy(zvec_int64_array_t *array); /** * @brief Release uint8_t array memory @@ -413,12 +416,15 @@ typedef enum { ZVEC_LOG_LEVEL_WARN = 2, ZVEC_LOG_LEVEL_ERROR = 3, ZVEC_LOG_LEVEL_FATAL = 4 -} ZVecLogLevel; +} zvec_log_level_t; /** * @brief Log type enumeration */ -typedef enum { ZVEC_LOG_TYPE_CONSOLE = 0, ZVEC_LOG_TYPE_FILE = 1 } ZVecLogType; +typedef enum { + ZVEC_LOG_TYPE_CONSOLE = 0, + ZVEC_LOG_TYPE_FILE = 1 +} zvec_log_type_t; // ============================================================================= // Configuration Structures (Opaque Pointer Pattern) @@ -431,7 +437,7 @@ typedef enum { ZVEC_LOG_TYPE_CONSOLE = 0, ZVEC_LOG_TYPE_FILE = 1 } ZVecLogType; * - zvec_config_log_create_console() for console logging * - zvec_config_log_create_file() for file logging */ -typedef struct ZVecLogConfig ZVecLogConfig; +typedef struct zvec_log_config_t zvec_log_config_t; /** * @brief Configuration data (opaque pointer) @@ -439,7 +445,7 @@ typedef struct ZVecLogConfig ZVecLogConfig; * Use zvec_config_data_create() to create and * zvec_config_data_destroy() to destroy */ -typedef struct ZVecConfigData ZVecConfigData; +typedef struct zvec_config_data_t zvec_config_data_t; // ============================================================================= // Log Configuration Management Functions @@ -448,10 +454,10 @@ typedef struct ZVecConfigData ZVecConfigData; /** * @brief Create console log configuration * @param level Log level - * @return ZVecLogConfig* Pointer to the newly created log configuration + * @return zvec_log_config_t* Pointer to the newly created log configuration */ -ZVEC_EXPORT ZVecLogConfig *ZVEC_CALL -zvec_config_log_create_console(ZVecLogLevel level); +ZVEC_EXPORT zvec_log_config_t *ZVEC_CALL +zvec_config_log_create_console(zvec_log_level_t level); /** * @brief Create file log configuration @@ -460,34 +466,34 @@ zvec_config_log_create_console(ZVecLogLevel level); * @param basename Log file base name * @param file_size Log file size (MB) * @param overdue_days Log expiration days - * @return ZVecLogConfig* Pointer to the newly created log configuration + * @return zvec_log_config_t* Pointer to the newly created log configuration */ -ZVEC_EXPORT ZVecLogConfig *ZVEC_CALL zvec_config_log_create_file( - ZVecLogLevel level, const char *dir, const char *basename, +ZVEC_EXPORT zvec_log_config_t *ZVEC_CALL zvec_config_log_create_file( + zvec_log_level_t level, const char *dir, const char *basename, uint32_t file_size, uint32_t overdue_days); /** * @brief Destroy log configuration * @param config Log configuration pointer */ -ZVEC_EXPORT void ZVEC_CALL zvec_config_log_destroy(ZVecLogConfig *config); +ZVEC_EXPORT void ZVEC_CALL zvec_config_log_destroy(zvec_log_config_t *config); /** * @brief Get log level from log config * @param config Log configuration pointer - * @return ZVecLogLevel Log level + * @return zvec_log_level_t Log level */ -ZVEC_EXPORT ZVecLogLevel ZVEC_CALL -zvec_config_log_get_level(const ZVecLogConfig *config); +ZVEC_EXPORT zvec_log_level_t ZVEC_CALL +zvec_config_log_get_level(const zvec_log_config_t *config); /** * @brief Set log level in log config * @param config Log configuration pointer * @param level Log level - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_log_set_level(ZVecLogConfig *config, ZVecLogLevel level); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_log_set_level(zvec_log_config_t *config, zvec_log_level_t level); /** * @brief Check if log config is file type @@ -495,7 +501,7 @@ zvec_config_log_set_level(ZVecLogConfig *config, ZVecLogLevel level); * @return true if file type, false if console type */ ZVEC_EXPORT bool ZVEC_CALL -zvec_config_log_is_file_type(const ZVecLogConfig *config); +zvec_config_log_is_file_type(const zvec_log_config_t *config); /** * @brief Get log directory from file log config @@ -504,16 +510,16 @@ zvec_config_log_is_file_type(const ZVecLogConfig *config); * @note Only valid for file log config, returns NULL for console config */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_config_log_get_dir(const ZVecLogConfig *config); +zvec_config_log_get_dir(const zvec_log_config_t *config); /** * @brief Set log directory in file log config * @param config Log configuration pointer (must be file type) * @param dir Log directory - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_log_set_dir(ZVecLogConfig *config, const char *dir); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_log_set_dir(zvec_log_config_t *config, const char *dir); /** * @brief Get log file basename from file log config @@ -522,16 +528,16 @@ zvec_config_log_set_dir(ZVecLogConfig *config, const char *dir); * @note Only valid for file log config, returns NULL for console config */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_config_log_get_basename(const ZVecLogConfig *config); +zvec_config_log_get_basename(const zvec_log_config_t *config); /** * @brief Set log file basename in file log config * @param config Log configuration pointer (must be file type) * @param basename Log file basename - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_log_set_basename(ZVecLogConfig *config, const char *basename); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_log_set_basename(zvec_log_config_t *config, const char *basename); /** * @brief Get log file size from file log config @@ -540,16 +546,16 @@ zvec_config_log_set_basename(ZVecLogConfig *config, const char *basename); * @note Only valid for file log config, returns 0 for console config */ ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_config_log_get_file_size(const ZVecLogConfig *config); +zvec_config_log_get_file_size(const zvec_log_config_t *config); /** * @brief Set log file size in file log config * @param config Log configuration pointer (must be file type) * @param file_size Log file size in MB - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_log_set_file_size(ZVecLogConfig *config, uint32_t file_size); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_log_set_file_size(zvec_log_config_t *config, uint32_t file_size); /** * @brief Get log overdue days from file log config @@ -558,16 +564,16 @@ zvec_config_log_set_file_size(ZVecLogConfig *config, uint32_t file_size); * @note Only valid for file log config, returns 0 for console config */ ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_config_log_get_overdue_days(const ZVecLogConfig *config); +zvec_config_log_get_overdue_days(const zvec_log_config_t *config); /** * @brief Set log overdue days in file log config * @param config Log configuration pointer (must be file type) * @param days Log overdue days - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_log_set_overdue_days(ZVecLogConfig *config, uint32_t days); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_log_set_overdue_days(zvec_log_config_t *config, uint32_t days); // ============================================================================= // Configuration Data Management Functions @@ -575,24 +581,24 @@ zvec_config_log_set_overdue_days(ZVecLogConfig *config, uint32_t days); /** * @brief Create configuration data - * @return ZVecConfigData* Pointer to the newly created configuration data + * @return zvec_config_data_t* Pointer to the newly created configuration data */ -ZVEC_EXPORT ZVecConfigData *ZVEC_CALL zvec_config_data_create(void); +ZVEC_EXPORT zvec_config_data_t *ZVEC_CALL zvec_config_data_create(void); /** * @brief Destroy configuration data * @param config Configuration data pointer */ -ZVEC_EXPORT void ZVEC_CALL zvec_config_data_destroy(ZVecConfigData *config); +ZVEC_EXPORT void ZVEC_CALL zvec_config_data_destroy(zvec_config_data_t *config); /** * @brief Set memory limit in configuration data * @param config Configuration data pointer * @param memory_limit_bytes Memory limit in bytes - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_memory_limit( - ZVecConfigData *config, uint64_t memory_limit_bytes); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_config_data_set_memory_limit( + zvec_config_data_t *config, uint64_t memory_limit_bytes); /** * @brief Get memory limit from configuration data @@ -600,34 +606,34 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_memory_limit( * @return uint64_t Memory limit in bytes */ ZVEC_EXPORT uint64_t ZVEC_CALL -zvec_config_data_get_memory_limit(const ZVecConfigData *config); +zvec_config_data_get_memory_limit(const zvec_config_data_t *config); /** * @brief Set log configuration in configuration data * @param config Configuration data pointer * @param log_config Log configuration pointer (ownership is transferred to * config, do not free separately) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_log_config( - ZVecConfigData *config, ZVecLogConfig *log_config); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_config_data_set_log_config( + zvec_config_data_t *config, zvec_log_config_t *log_config); /** * @brief Get log type from configuration data * @param config Configuration data pointer - * @return ZVecLogType Log type + * @return zvec_log_type_t Log type */ -ZVEC_EXPORT ZVecLogType ZVEC_CALL -zvec_config_data_get_log_type(const ZVecConfigData *config); +ZVEC_EXPORT zvec_log_type_t ZVEC_CALL +zvec_config_data_get_log_type(const zvec_config_data_t *config); /** * @brief Set query thread count in configuration data * @param config Configuration data pointer * @param thread_count Query thread count - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_query_thread_count( - ZVecConfigData *config, uint32_t thread_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_config_data_set_query_thread_count( + zvec_config_data_t *config, uint32_t thread_count); /** * @brief Get query thread count from configuration data @@ -635,16 +641,16 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_query_thread_count( * @return uint32_t Query thread count */ ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_config_data_get_query_thread_count(const ZVecConfigData *config); +zvec_config_data_get_query_thread_count(const zvec_config_data_t *config); /** * @brief Set invert to forward scan ratio in configuration data * @param config Configuration data pointer * @param ratio Invert to forward scan ratio - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_data_set_invert_to_forward_scan_ratio(ZVecConfigData *config, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_data_set_invert_to_forward_scan_ratio(zvec_config_data_t *config, float ratio); /** @@ -652,17 +658,17 @@ zvec_config_data_set_invert_to_forward_scan_ratio(ZVecConfigData *config, * @param config Configuration data pointer * @return float Invert to forward scan ratio */ -ZVEC_EXPORT float ZVEC_CALL -zvec_config_data_get_invert_to_forward_scan_ratio(const ZVecConfigData *config); +ZVEC_EXPORT float ZVEC_CALL zvec_config_data_get_invert_to_forward_scan_ratio( + const zvec_config_data_t *config); /** * @brief Set brute force by keys ratio in configuration data * @param config Configuration data pointer * @param ratio Brute force by keys ratio - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_config_data_set_brute_force_by_keys_ratio(ZVecConfigData *config, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_data_set_brute_force_by_keys_ratio(zvec_config_data_t *config, float ratio); /** @@ -670,17 +676,18 @@ zvec_config_data_set_brute_force_by_keys_ratio(ZVecConfigData *config, * @param config Configuration data pointer * @return float Brute force by keys ratio */ -ZVEC_EXPORT float ZVEC_CALL -zvec_config_data_get_brute_force_by_keys_ratio(const ZVecConfigData *config); +ZVEC_EXPORT float ZVEC_CALL zvec_config_data_get_brute_force_by_keys_ratio( + const zvec_config_data_t *config); /** * @brief Set optimize thread count in configuration data * @param config Configuration data pointer * @param thread_count Optimize thread count - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_optimize_thread_count( - ZVecConfigData *config, uint32_t thread_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_config_data_set_optimize_thread_count(zvec_config_data_t *config, + uint32_t thread_count); /** * @brief Get optimize thread count from configuration data @@ -688,7 +695,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_config_data_set_optimize_thread_count( * @return uint32_t Optimize thread count */ ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_config_data_get_optimize_thread_count(const ZVecConfigData *config); +zvec_config_data_get_optimize_thread_count(const zvec_config_data_t *config); // ============================================================================= // Initialization and Cleanup Interface @@ -698,16 +705,16 @@ zvec_config_data_get_optimize_thread_count(const ZVecConfigData *config); * @brief Initialize ZVec library * @param config Configuration data (optional, NULL means using default * configuration) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_initialize(const ZVecConfigData *config); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_initialize(const zvec_config_data_t *config); /** * @brief Clean up ZVec library resources - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_shutdown(void); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_shutdown(void); /** * @brief Check if library is initialized @@ -725,7 +732,7 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_is_initialized(void); * These are defined as uint32_t constants instead of C enums to ensure * consistent binary representation across C and C++ boundaries. */ -typedef uint32_t ZVecDataType; +typedef uint32_t zvec_data_type_t; #define ZVEC_DATA_TYPE_UNDEFINED 0 #define ZVEC_DATA_TYPE_BINARY 1 #define ZVEC_DATA_TYPE_STRING 2 @@ -762,7 +769,7 @@ typedef uint32_t ZVecDataType; * These are defined as uint32_t constants instead of C enums to ensure * consistent binary representation across C and C++ boundaries. */ -typedef uint32_t ZVecIndexType; +typedef uint32_t zvec_index_type_t; #define ZVEC_INDEX_TYPE_UNDEFINED 0 #define ZVEC_INDEX_TYPE_HNSW 1 #define ZVEC_INDEX_TYPE_IVF 2 @@ -776,7 +783,7 @@ typedef uint32_t ZVecIndexType; * These are defined as uint32_t constants instead of C enums to ensure * consistent binary representation across C and C++ boundaries. */ -typedef uint32_t ZVecMetricType; +typedef uint32_t zvec_metric_type_t; #define ZVEC_METRIC_TYPE_UNDEFINED 0 #define ZVEC_METRIC_TYPE_L2 1 #define ZVEC_METRIC_TYPE_IP 2 @@ -790,7 +797,7 @@ typedef uint32_t ZVecMetricType; * These are defined as uint32_t constants instead of C enums to ensure * consistent binary representation across C and C++ boundaries. */ -typedef uint32_t ZVecQuantizeType; +typedef uint32_t zvec_quantize_type_t; #define ZVEC_QUANTIZE_TYPE_UNDEFINED 0 #define ZVEC_QUANTIZE_TYPE_FP16 1 #define ZVEC_QUANTIZE_TYPE_INT8 2 @@ -806,7 +813,7 @@ typedef uint32_t ZVecQuantizeType; * Internally maps to std::shared_ptr*. * Managed by zvec_collection_create/open() and zvec_collection_close(). */ -typedef struct ZVecCollection ZVecCollection; +typedef struct zvec_collection_t zvec_collection_t; // ============================================================================= // Index Parameters Structures (Opaque Pointer Pattern) @@ -818,7 +825,7 @@ typedef struct ZVecCollection ZVecCollection; * Use zvec_index_params_create() to create and zvec_index_params_destroy() to * destroy. Specific parameters are set via type-specific setter functions. */ -typedef struct ZVecIndexParams ZVecIndexParams; +typedef struct zvec_index_params_t zvec_index_params_t; // ============================================================================= // Field Schema Structures (Opaque Pointer Pattern) @@ -832,7 +839,7 @@ typedef struct ZVecIndexParams ZVecIndexParams; * zvec_field_schema_destroy(). Caller owns the pointer and must explicitly * destroy it. */ -typedef struct ZVecFieldSchema ZVecFieldSchema; +typedef struct zvec_field_schema_t zvec_field_schema_t; // ============================================================================= @@ -842,16 +849,17 @@ typedef struct ZVecFieldSchema ZVecFieldSchema; /** * @brief Create index parameters * @param index_type Index type - * @return Pointer to newly created ZVecIndexParams, or NULL on error + * @return Pointer to newly created zvec_index_params_t, or NULL on error */ -ZVEC_EXPORT ZVecIndexParams *ZVEC_CALL -zvec_index_params_create(ZVecIndexType index_type); +ZVEC_EXPORT zvec_index_params_t *ZVEC_CALL +zvec_index_params_create(zvec_index_type_t index_type); /** * @brief Destroy index parameters * @param params Index parameters to destroy */ -ZVEC_EXPORT void ZVEC_CALL zvec_index_params_destroy(ZVecIndexParams *params); +ZVEC_EXPORT void ZVEC_CALL +zvec_index_params_destroy(zvec_index_params_t *params); // ============================================================================= // Collection Schema Structures (Opaque Pointer Pattern) @@ -862,8 +870,8 @@ ZVEC_EXPORT void ZVEC_CALL zvec_index_params_destroy(ZVecIndexParams *params); * @param params Index parameters (must not be NULL) * @return Index type */ -ZVEC_EXPORT ZVecIndexType ZVEC_CALL -zvec_index_params_get_type(const ZVecIndexParams *params); +ZVEC_EXPORT zvec_index_type_t ZVEC_CALL +zvec_index_params_get_type(const zvec_index_params_t *params); /** * @brief Set metric type (for vector indexes) @@ -871,16 +879,16 @@ zvec_index_params_get_type(const ZVecIndexParams *params); * @param metric_type Metric type * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_metric_type( - ZVecIndexParams *params, ZVecMetricType metric_type); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_set_metric_type( + zvec_index_params_t *params, zvec_metric_type_t metric_type); /** * @brief Get metric type * @param params Index parameters (must not be NULL) * @return Metric type */ -ZVEC_EXPORT ZVecMetricType ZVEC_CALL -zvec_index_params_get_metric_type(const ZVecIndexParams *params); +ZVEC_EXPORT zvec_metric_type_t ZVEC_CALL +zvec_index_params_get_metric_type(const zvec_index_params_t *params); /** * @brief Set quantize type (for vector indexes) @@ -888,16 +896,16 @@ zvec_index_params_get_metric_type(const ZVecIndexParams *params); * @param quantize_type Quantize type * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_quantize_type( - ZVecIndexParams *params, ZVecQuantizeType quantize_type); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_set_quantize_type( + zvec_index_params_t *params, zvec_quantize_type_t quantize_type); /** * @brief Get quantize type * @param params Index parameters (must not be NULL) * @return Quantize type */ -ZVEC_EXPORT ZVecQuantizeType ZVEC_CALL -zvec_index_params_get_quantize_type(const ZVecIndexParams *params); +ZVEC_EXPORT zvec_quantize_type_t ZVEC_CALL +zvec_index_params_get_quantize_type(const zvec_index_params_t *params); /** * @brief Set HNSW specific parameters @@ -906,8 +914,8 @@ zvec_index_params_get_quantize_type(const ZVecIndexParams *params); * @param ef_construction Construction exploration factor * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_hnsw_params( - ZVecIndexParams *params, int m, int ef_construction); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_set_hnsw_params( + zvec_index_params_t *params, int m, int ef_construction); /** * @brief Get HNSW m parameter @@ -915,7 +923,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_hnsw_params( * @return m parameter */ ZVEC_EXPORT int ZVEC_CALL -zvec_index_params_get_hnsw_m(const ZVecIndexParams *params); +zvec_index_params_get_hnsw_m(const zvec_index_params_t *params); /** * @brief Get HNSW ef_construction parameter @@ -923,7 +931,7 @@ zvec_index_params_get_hnsw_m(const ZVecIndexParams *params); * @return ef_construction parameter */ ZVEC_EXPORT int ZVEC_CALL -zvec_index_params_get_hnsw_ef_construction(const ZVecIndexParams *params); +zvec_index_params_get_hnsw_ef_construction(const zvec_index_params_t *params); /** * @brief Set IVF specific parameters @@ -933,8 +941,8 @@ zvec_index_params_get_hnsw_ef_construction(const ZVecIndexParams *params); * @param use_soar Whether to use SOAR algorithm * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_ivf_params( - ZVecIndexParams *params, int n_list, int n_iters, bool use_soar); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_set_ivf_params( + zvec_index_params_t *params, int n_list, int n_iters, bool use_soar); /** * @brief Get IVF parameters (all at once) @@ -944,9 +952,9 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_ivf_params( * @param out_use_soar Output parameter for use_soar * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_index_params_get_ivf_params(const ZVecIndexParams *params, int *out_n_list, - int *out_n_iters, bool *out_use_soar); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_get_ivf_params( + const zvec_index_params_t *params, int *out_n_list, int *out_n_iters, + bool *out_use_soar); /** * @brief Get invert index parameters (all at once) @@ -955,8 +963,8 @@ zvec_index_params_get_ivf_params(const ZVecIndexParams *params, int *out_n_list, * @param out_enable_wildcard Output parameter for enable_extended_wildcard * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_get_invert_params( - const ZVecIndexParams *params, bool *out_enable_range_opt, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_get_invert_params( + const zvec_index_params_t *params, bool *out_enable_range_opt, bool *out_enable_wildcard); /** @@ -966,8 +974,8 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_get_invert_params( * @param enable_wildcard Whether to enable extended wildcard * @return ZVEC_OK on success, error code on failure */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_invert_params( - ZVecIndexParams *params, bool enable_range_opt, bool enable_wildcard); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_index_params_set_invert_params( + zvec_index_params_t *params, bool enable_range_opt, bool enable_wildcard); // ============================================================================= // Query Parameters Structures (Opaque Pointer Pattern) @@ -981,7 +989,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_index_params_set_invert_params( * zvec_query_params_hnsw_destroy(). Caller owns the pointer and must explicitly * destroy it. */ -typedef struct ZVecHnswQueryParams ZVecHnswQueryParams; +typedef struct zvec_hnsw_query_params_t zvec_hnsw_query_params_t; /** * @brief IVF query parameters handle (opaque pointer) @@ -991,7 +999,7 @@ typedef struct ZVecHnswQueryParams ZVecHnswQueryParams; * zvec_query_params_ivf_destroy(). Caller owns the pointer and must explicitly * destroy it. */ -typedef struct ZVecIVFQueryParams ZVecIVFQueryParams; +typedef struct zvec_ivf_query_params_t zvec_ivf_query_params_t; /** * @brief Flat query parameters handle (opaque pointer) @@ -1001,7 +1009,7 @@ typedef struct ZVecIVFQueryParams ZVecIVFQueryParams; * zvec_query_params_flat_destroy(). Caller owns the pointer and must explicitly * destroy it. */ -typedef struct ZVecFlatQueryParams ZVecFlatQueryParams; +typedef struct zvec_flat_query_params_t zvec_flat_query_params_t; // ============================================================================= @@ -1014,7 +1022,7 @@ typedef struct ZVecFlatQueryParams ZVecFlatQueryParams; * Use zvec_vector_query_create() to create and zvec_vector_query_destroy() to * destroy */ -typedef struct ZVecVectorQuery ZVecVectorQuery; +typedef struct zvec_vector_query_t zvec_vector_query_t; /** * @brief Grouped vector query structure (opaque pointer) @@ -1022,7 +1030,7 @@ typedef struct ZVecVectorQuery ZVecVectorQuery; * Use zvec_group_by_vector_query_create() to create and * zvec_group_by_vector_query_destroy() to destroy */ -typedef struct ZVecGroupByVectorQuery ZVecGroupByVectorQuery; +typedef struct zvec_group_by_vector_query_t zvec_group_by_vector_query_t; // ============================================================================= @@ -1030,7 +1038,7 @@ typedef struct ZVecGroupByVectorQuery ZVecGroupByVectorQuery; // ============================================================================= // ----------------------------------------------------------------------------- -// ZVecHnswQueryParams (HNSW Query Parameters) +// zvec_hnsw_query_params_t (HNSW Query Parameters) // ----------------------------------------------------------------------------- /** @@ -1039,10 +1047,10 @@ typedef struct ZVecGroupByVectorQuery ZVecGroupByVectorQuery; * @param radius Search radius (default: 0.0) * @param is_linear Whether linear search (default: false) * @param is_using_refiner Whether using refiner (default: false) - * @return ZVecHnswQueryParams* Pointer to the newly created HNSW query + * @return zvec_hnsw_query_params_t* Pointer to the newly created HNSW query * parameters */ -ZVEC_EXPORT ZVecHnswQueryParams *ZVEC_CALL zvec_query_params_hnsw_create( +ZVEC_EXPORT zvec_hnsw_query_params_t *ZVEC_CALL zvec_query_params_hnsw_create( int ef, float radius, bool is_linear, bool is_using_refiner); /** @@ -1050,16 +1058,16 @@ ZVEC_EXPORT ZVecHnswQueryParams *ZVEC_CALL zvec_query_params_hnsw_create( * @param params HNSW query parameters pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_query_params_hnsw_destroy(ZVecHnswQueryParams *params); +zvec_query_params_hnsw_destroy(zvec_hnsw_query_params_t *params); /** * @brief Set exploration factor * @param params HNSW query parameters pointer * @param ef Exploration factor - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_hnsw_set_ef(ZVecHnswQueryParams *params, int ef); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_hnsw_set_ef(zvec_hnsw_query_params_t *params, int ef); /** * @brief Get exploration factor @@ -1067,16 +1075,16 @@ zvec_query_params_hnsw_set_ef(ZVecHnswQueryParams *params, int ef); * @return int Exploration factor */ ZVEC_EXPORT int ZVEC_CALL -zvec_query_params_hnsw_get_ef(const ZVecHnswQueryParams *params); +zvec_query_params_hnsw_get_ef(const zvec_hnsw_query_params_t *params); /** * @brief Set search radius (common parameter from QueryParams base) * @param params HNSW query parameters pointer * @param radius Search radius - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_hnsw_set_radius(ZVecHnswQueryParams *params, float radius); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_hnsw_set_radius( + zvec_hnsw_query_params_t *params, float radius); /** * @brief Get search radius (common parameter from QueryParams base) @@ -1084,16 +1092,16 @@ zvec_query_params_hnsw_set_radius(ZVecHnswQueryParams *params, float radius); * @return float Search radius */ ZVEC_EXPORT float ZVEC_CALL -zvec_query_params_hnsw_get_radius(const ZVecHnswQueryParams *params); +zvec_query_params_hnsw_get_radius(const zvec_hnsw_query_params_t *params); /** * @brief Set linear search mode (common parameter from QueryParams base) * @param params HNSW query parameters pointer * @param is_linear Whether linear search - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_hnsw_set_is_linear( - ZVecHnswQueryParams *params, bool is_linear); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_hnsw_set_is_linear( + zvec_hnsw_query_params_t *params, bool is_linear); /** * @brief Get linear search mode (common parameter from QueryParams base) @@ -1101,27 +1109,28 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_hnsw_set_is_linear( * @return bool Whether linear search */ ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_hnsw_get_is_linear(const ZVecHnswQueryParams *params); +zvec_query_params_hnsw_get_is_linear(const zvec_hnsw_query_params_t *params); /** * @brief Set whether to use refiner (common parameter from QueryParams base) * @param params HNSW query parameters pointer * @param is_using_refiner Whether to use refiner - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_hnsw_set_is_using_refiner( - ZVecHnswQueryParams *params, bool is_using_refiner); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_hnsw_set_is_using_refiner(zvec_hnsw_query_params_t *params, + bool is_using_refiner); /** * @brief Get whether to use refiner (common parameter from QueryParams base) * @param params HNSW query parameters pointer * @return bool Whether to use refiner */ -ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_hnsw_get_is_using_refiner(const ZVecHnswQueryParams *params); +ZVEC_EXPORT bool ZVEC_CALL zvec_query_params_hnsw_get_is_using_refiner( + const zvec_hnsw_query_params_t *params); // ----------------------------------------------------------------------------- -// ZVecIVFQueryParams (IVF Query Parameters) +// zvec_ivf_query_params_t (IVF Query Parameters) // ----------------------------------------------------------------------------- /** @@ -1129,9 +1138,10 @@ zvec_query_params_hnsw_get_is_using_refiner(const ZVecHnswQueryParams *params); * @param nprobe Number of clusters to probe (default: 10) * @param is_using_refiner Whether using refiner (default: false) * @param scale_factor Scale factor (default: 10.0) - * @return ZVecIVFQueryParams* Pointer to the newly created IVF query parameters + * @return zvec_ivf_query_params_t* Pointer to the newly created IVF query + * parameters */ -ZVEC_EXPORT ZVecIVFQueryParams *ZVEC_CALL zvec_query_params_ivf_create( +ZVEC_EXPORT zvec_ivf_query_params_t *ZVEC_CALL zvec_query_params_ivf_create( int nprobe, bool is_using_refiner, float scale_factor); /** @@ -1139,16 +1149,16 @@ ZVEC_EXPORT ZVecIVFQueryParams *ZVEC_CALL zvec_query_params_ivf_create( * @param params IVF query parameters pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_query_params_ivf_destroy(ZVecIVFQueryParams *params); +zvec_query_params_ivf_destroy(zvec_ivf_query_params_t *params); /** * @brief Set number of probe clusters * @param params IVF query parameters pointer * @param nprobe Number of probe clusters - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_ivf_set_nprobe(ZVecIVFQueryParams *params, int nprobe); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_ivf_set_nprobe(zvec_ivf_query_params_t *params, int nprobe); /** * @brief Get number of probe clusters @@ -1156,16 +1166,16 @@ zvec_query_params_ivf_set_nprobe(ZVecIVFQueryParams *params, int nprobe); * @return int Number of probe clusters */ ZVEC_EXPORT int ZVEC_CALL -zvec_query_params_ivf_get_nprobe(const ZVecIVFQueryParams *params); +zvec_query_params_ivf_get_nprobe(const zvec_ivf_query_params_t *params); /** * @brief Set scale factor * @param params IVF query parameters pointer * @param scale_factor Scale factor - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_ivf_set_scale_factor( - ZVecIVFQueryParams *params, float scale_factor); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_ivf_set_scale_factor( + zvec_ivf_query_params_t *params, float scale_factor); /** * @brief Get scale factor @@ -1173,16 +1183,16 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_ivf_set_scale_factor( * @return float Scale factor */ ZVEC_EXPORT float ZVEC_CALL -zvec_query_params_ivf_get_scale_factor(const ZVecIVFQueryParams *params); +zvec_query_params_ivf_get_scale_factor(const zvec_ivf_query_params_t *params); /** * @brief Set search radius (common parameter from QueryParams base) * @param params IVF query parameters pointer * @param radius Search radius - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_ivf_set_radius(ZVecIVFQueryParams *params, float radius); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_ivf_set_radius(zvec_ivf_query_params_t *params, float radius); /** * @brief Get search radius (common parameter from QueryParams base) @@ -1190,16 +1200,16 @@ zvec_query_params_ivf_set_radius(ZVecIVFQueryParams *params, float radius); * @return float Search radius */ ZVEC_EXPORT float ZVEC_CALL -zvec_query_params_ivf_get_radius(const ZVecIVFQueryParams *params); +zvec_query_params_ivf_get_radius(const zvec_ivf_query_params_t *params); /** * @brief Set linear search mode (common parameter from QueryParams base) * @param params IVF query parameters pointer * @param is_linear Whether linear search - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_ivf_set_is_linear(ZVecIVFQueryParams *params, bool is_linear); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_ivf_set_is_linear( + zvec_ivf_query_params_t *params, bool is_linear); /** * @brief Get linear search mode (common parameter from QueryParams base) @@ -1207,37 +1217,38 @@ zvec_query_params_ivf_set_is_linear(ZVecIVFQueryParams *params, bool is_linear); * @return bool Whether linear search */ ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_ivf_get_is_linear(const ZVecIVFQueryParams *params); +zvec_query_params_ivf_get_is_linear(const zvec_ivf_query_params_t *params); /** * @brief Set whether to use refiner (common parameter from QueryParams base) * @param params IVF query parameters pointer * @param is_using_refiner Whether to use refiner - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_ivf_set_is_using_refiner( - ZVecIVFQueryParams *params, bool is_using_refiner); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_ivf_set_is_using_refiner(zvec_ivf_query_params_t *params, + bool is_using_refiner); /** * @brief Get whether to use refiner (common parameter from QueryParams base) * @param params IVF query parameters pointer * @return bool Whether to use refiner */ -ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_ivf_get_is_using_refiner(const ZVecIVFQueryParams *params); +ZVEC_EXPORT bool ZVEC_CALL zvec_query_params_ivf_get_is_using_refiner( + const zvec_ivf_query_params_t *params); // ----------------------------------------------------------------------------- -// ZVecFlatQueryParams (Flat Query Parameters) +// zvec_flat_query_params_t (Flat Query Parameters) // ----------------------------------------------------------------------------- /** * @brief Create Flat query parameters * @param is_using_refiner Whether using refiner (default: false) * @param scale_factor Scale factor (default: 10.0) - * @return ZVecFlatQueryParams* Pointer to the newly created Flat query + * @return zvec_flat_query_params_t* Pointer to the newly created Flat query * parameters */ -ZVEC_EXPORT ZVecFlatQueryParams *ZVEC_CALL +ZVEC_EXPORT zvec_flat_query_params_t *ZVEC_CALL zvec_query_params_flat_create(bool is_using_refiner, float scale_factor); /** @@ -1245,16 +1256,16 @@ zvec_query_params_flat_create(bool is_using_refiner, float scale_factor); * @param params Flat query parameters pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_query_params_flat_destroy(ZVecFlatQueryParams *params); +zvec_query_params_flat_destroy(zvec_flat_query_params_t *params); /** * @brief Set scale factor * @param params Flat query parameters pointer * @param scale_factor Scale factor - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_flat_set_scale_factor( - ZVecFlatQueryParams *params, float scale_factor); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_flat_set_scale_factor( + zvec_flat_query_params_t *params, float scale_factor); /** * @brief Get scale factor @@ -1262,16 +1273,16 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_flat_set_scale_factor( * @return float Scale factor */ ZVEC_EXPORT float ZVEC_CALL -zvec_query_params_flat_get_scale_factor(const ZVecFlatQueryParams *params); +zvec_query_params_flat_get_scale_factor(const zvec_flat_query_params_t *params); /** * @brief Set search radius (common parameter from QueryParams base) * @param params Flat query parameters pointer * @param radius Search radius - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_query_params_flat_set_radius(ZVecFlatQueryParams *params, float radius); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_flat_set_radius( + zvec_flat_query_params_t *params, float radius); /** * @brief Get search radius (common parameter from QueryParams base) @@ -1279,16 +1290,16 @@ zvec_query_params_flat_set_radius(ZVecFlatQueryParams *params, float radius); * @return float Search radius */ ZVEC_EXPORT float ZVEC_CALL -zvec_query_params_flat_get_radius(const ZVecFlatQueryParams *params); +zvec_query_params_flat_get_radius(const zvec_flat_query_params_t *params); /** * @brief Set linear search mode (common parameter from QueryParams base) * @param params Flat query parameters pointer * @param is_linear Whether linear search - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_flat_set_is_linear( - ZVecFlatQueryParams *params, bool is_linear); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_query_params_flat_set_is_linear( + zvec_flat_query_params_t *params, bool is_linear); /** * @brief Get linear search mode (common parameter from QueryParams base) @@ -1296,49 +1307,51 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_flat_set_is_linear( * @return bool Whether linear search */ ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_flat_get_is_linear(const ZVecFlatQueryParams *params); +zvec_query_params_flat_get_is_linear(const zvec_flat_query_params_t *params); /** * @brief Set whether to use refiner (common parameter from QueryParams base) * @param params Flat query parameters pointer * @param is_using_refiner Whether to use refiner - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_query_params_flat_set_is_using_refiner( - ZVecFlatQueryParams *params, bool is_using_refiner); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_query_params_flat_set_is_using_refiner(zvec_flat_query_params_t *params, + bool is_using_refiner); /** * @brief Get whether to use refiner (common parameter from QueryParams base) * @param params Flat query parameters pointer * @return bool Whether to use refiner */ -ZVEC_EXPORT bool ZVEC_CALL -zvec_query_params_flat_get_is_using_refiner(const ZVecFlatQueryParams *params); +ZVEC_EXPORT bool ZVEC_CALL zvec_query_params_flat_get_is_using_refiner( + const zvec_flat_query_params_t *params); // ----------------------------------------------------------------------------- -// ZVecVectorQuery (Vector Query) +// zvec_vector_query_t (Vector Query) // ----------------------------------------------------------------------------- /** * @brief Create vector query - * @return ZVecVectorQuery* Pointer to the newly created vector query + * @return zvec_vector_query_t* Pointer to the newly created vector query */ -ZVEC_EXPORT ZVecVectorQuery *ZVEC_CALL zvec_vector_query_create(void); +ZVEC_EXPORT zvec_vector_query_t *ZVEC_CALL zvec_vector_query_create(void); /** * @brief Destroy vector query * @param query Vector query pointer */ -ZVEC_EXPORT void ZVEC_CALL zvec_vector_query_destroy(ZVecVectorQuery *query); +ZVEC_EXPORT void ZVEC_CALL +zvec_vector_query_destroy(zvec_vector_query_t *query); /** * @brief Set topk (number of results to return) * @param query Vector query pointer * @param topk Number of results - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_vector_query_set_topk(ZVecVectorQuery *query, int topk); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_vector_query_set_topk(zvec_vector_query_t *query, int topk); /** * @brief Get topk @@ -1346,16 +1359,16 @@ zvec_vector_query_set_topk(ZVecVectorQuery *query, int topk); * @return int Number of results */ ZVEC_EXPORT int ZVEC_CALL -zvec_vector_query_get_topk(const ZVecVectorQuery *query); +zvec_vector_query_get_topk(const zvec_vector_query_t *query); /** * @brief Set field name * @param query Vector query pointer * @param field_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_field_name( - ZVecVectorQuery *query, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_field_name( + zvec_vector_query_t *query, const char *field_name); /** * @brief Get field name @@ -1363,26 +1376,26 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_field_name( * @return const char* Field name (owned by query, do not free) */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_vector_query_get_field_name(const ZVecVectorQuery *query); +zvec_vector_query_get_field_name(const zvec_vector_query_t *query); /** * @brief Set query vector data * @param query Vector query pointer * @param data Vector data pointer * @param size Data size in bytes - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_query_vector( - ZVecVectorQuery *query, const void *data, size_t size); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_query_vector( + zvec_vector_query_t *query, const void *data, size_t size); /** * @brief Set filter expression * @param query Vector query pointer * @param filter Filter expression string - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_vector_query_set_filter(ZVecVectorQuery *query, const char *filter); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_vector_query_set_filter(zvec_vector_query_t *query, const char *filter); /** * @brief Get filter expression @@ -1390,16 +1403,16 @@ zvec_vector_query_set_filter(ZVecVectorQuery *query, const char *filter); * @return const char* Filter expression (owned by query, do not free) */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_vector_query_get_filter(const ZVecVectorQuery *query); +zvec_vector_query_get_filter(const zvec_vector_query_t *query); /** * @brief Set whether to include vector data in results * @param query Vector query pointer * @param include Whether to include vector - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_vector_query_set_include_vector(ZVecVectorQuery *query, bool include); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_vector_query_set_include_vector(zvec_vector_query_t *query, bool include); /** * @brief Get whether to include vector data in results @@ -1407,16 +1420,16 @@ zvec_vector_query_set_include_vector(ZVecVectorQuery *query, bool include); * @return bool Whether to include vector */ ZVEC_EXPORT bool ZVEC_CALL -zvec_vector_query_get_include_vector(const ZVecVectorQuery *query); +zvec_vector_query_get_include_vector(const zvec_vector_query_t *query); /** * @brief Set whether to include doc ID in results * @param query Vector query pointer * @param include Whether to include doc ID - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_vector_query_set_include_doc_id(ZVecVectorQuery *query, bool include); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_vector_query_set_include_doc_id(zvec_vector_query_t *query, bool include); /** * @brief Get whether to include doc ID in results @@ -1424,79 +1437,79 @@ zvec_vector_query_set_include_doc_id(ZVecVectorQuery *query, bool include); * @return bool Whether to include doc ID */ ZVEC_EXPORT bool ZVEC_CALL -zvec_vector_query_get_include_doc_id(const ZVecVectorQuery *query); +zvec_vector_query_get_include_doc_id(const zvec_vector_query_t *query); /** * @brief Set output fields * @param query Vector query pointer * @param fields Array of field names * @param count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_output_fields( - ZVecVectorQuery *query, const char **fields, size_t count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_output_fields( + zvec_vector_query_t *query, const char **fields, size_t count); /** * @brief Get output fields * @param query Vector query pointer * @param[out] fields Output array of field names (allocated by library) * @param[out] count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual string pointers * are owned by the query and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_get_output_fields( - const ZVecVectorQuery *query, const char ***fields, size_t *count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_get_output_fields( + const zvec_vector_query_t *query, const char ***fields, size_t *count); /** * @brief Set query parameters (takes ownership) * @param query Vector query pointer - * @param params Query parameters pointer (type-specific: ZVecHnswQueryParams*, - * etc.) - * @return ZVecErrorCode Error code + * @param params Query parameters pointer (type-specific: + * zvec_hnsw_query_params_t*, etc.) + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_vector_query_set_query_params(ZVecVectorQuery *query, void *params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_vector_query_set_query_params(zvec_vector_query_t *query, void *params); /** * @brief Set HNSW query parameters (takes ownership) * @param query Vector query pointer * @param hnsw_params HNSW query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_hnsw_params( - ZVecVectorQuery *query, ZVecHnswQueryParams *hnsw_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_hnsw_params( + zvec_vector_query_t *query, zvec_hnsw_query_params_t *hnsw_params); /** * @brief Set IVF query parameters (takes ownership) * @param query Vector query pointer * @param ivf_params IVF query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_ivf_params( - ZVecVectorQuery *query, ZVecIVFQueryParams *ivf_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_ivf_params( + zvec_vector_query_t *query, zvec_ivf_query_params_t *ivf_params); /** * @brief Set Flat query parameters (takes ownership) * @param query Vector query pointer * @param flat_params Flat query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_vector_query_set_flat_params( - ZVecVectorQuery *query, ZVecFlatQueryParams *flat_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_vector_query_set_flat_params( + zvec_vector_query_t *query, zvec_flat_query_params_t *flat_params); // ----------------------------------------------------------------------------- -// ZVecGroupByVectorQuery (Group By Vector Query) +// zvec_group_by_vector_query_t (Group By Vector Query) // ----------------------------------------------------------------------------- /** * @brief Create group by vector query - * @return ZVecGroupByVectorQuery* Pointer to the newly created group by vector - * query + * @return zvec_group_by_vector_query_t* Pointer to the newly created group by + * vector query */ -ZVEC_EXPORT ZVecGroupByVectorQuery *ZVEC_CALL +ZVEC_EXPORT zvec_group_by_vector_query_t *ZVEC_CALL zvec_group_by_vector_query_create(void); /** @@ -1504,34 +1517,35 @@ zvec_group_by_vector_query_create(void); * @param query Group by vector query pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_group_by_vector_query_destroy(ZVecGroupByVectorQuery *query); +zvec_group_by_vector_query_destroy(zvec_group_by_vector_query_t *query); /** * @brief Set field name * @param query Group by vector query pointer * @param field_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_field_name( - ZVecGroupByVectorQuery *query, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_field_name(zvec_group_by_vector_query_t *query, + const char *field_name); /** * @brief Get field name * @param query Group by vector query pointer * @return const char* Field name (owned by query, do not free) */ -ZVEC_EXPORT const char *ZVEC_CALL -zvec_group_by_vector_query_get_field_name(const ZVecGroupByVectorQuery *query); +ZVEC_EXPORT const char *ZVEC_CALL zvec_group_by_vector_query_get_field_name( + const zvec_group_by_vector_query_t *query); /** * @brief Set group by field name * @param query Group by vector query pointer * @param field_name Group by field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_group_by_vector_query_set_group_by_field_name( - ZVecGroupByVectorQuery *query, const char *field_name); + zvec_group_by_vector_query_t *query, const char *field_name); /** * @brief Get group by field name @@ -1540,78 +1554,81 @@ zvec_group_by_vector_query_set_group_by_field_name( */ ZVEC_EXPORT const char *ZVEC_CALL zvec_group_by_vector_query_get_group_by_field_name( - const ZVecGroupByVectorQuery *query); + const zvec_group_by_vector_query_t *query); /** * @brief Set group count * @param query Group by vector query pointer * @param count Number of groups - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_group_count( - ZVecGroupByVectorQuery *query, uint32_t count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_group_count(zvec_group_by_vector_query_t *query, + uint32_t count); /** * @brief Get group count * @param query Group by vector query pointer * @return uint32_t Number of groups */ -ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_group_by_vector_query_get_group_count(const ZVecGroupByVectorQuery *query); +ZVEC_EXPORT uint32_t ZVEC_CALL zvec_group_by_vector_query_get_group_count( + const zvec_group_by_vector_query_t *query); /** * @brief Set group topk * @param query Group by vector query pointer * @param topk Number of results per group - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_group_topk( - ZVecGroupByVectorQuery *query, uint32_t topk); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_group_topk(zvec_group_by_vector_query_t *query, + uint32_t topk); /** * @brief Get group topk * @param query Group by vector query pointer * @return uint32_t Number of results per group */ -ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_group_by_vector_query_get_group_topk(const ZVecGroupByVectorQuery *query); +ZVEC_EXPORT uint32_t ZVEC_CALL zvec_group_by_vector_query_get_group_topk( + const zvec_group_by_vector_query_t *query); /** * @brief Set query vector data * @param query Group by vector query pointer * @param data Vector data pointer * @param size Data size in bytes - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_query_vector( - ZVecGroupByVectorQuery *query, const void *data, size_t size); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_query_vector(zvec_group_by_vector_query_t *query, + const void *data, size_t size); /** * @brief Set filter expression * @param query Group by vector query pointer * @param filter Filter expression string - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_filter( - ZVecGroupByVectorQuery *query, const char *filter); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_group_by_vector_query_set_filter( + zvec_group_by_vector_query_t *query, const char *filter); /** * @brief Get filter expression * @param query Group by vector query pointer * @return const char* Filter expression (owned by query, do not free) */ -ZVEC_EXPORT const char *ZVEC_CALL -zvec_group_by_vector_query_get_filter(const ZVecGroupByVectorQuery *query); +ZVEC_EXPORT const char *ZVEC_CALL zvec_group_by_vector_query_get_filter( + const zvec_group_by_vector_query_t *query); /** * @brief Set whether to include vector data in results * @param query Group by vector query pointer * @param include Whether to include vectors - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_group_by_vector_query_set_include_vector(ZVecGroupByVectorQuery *query, - bool include); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_include_vector( + zvec_group_by_vector_query_t *query, bool include); /** * @brief Get whether to include vector data in results @@ -1619,70 +1636,73 @@ zvec_group_by_vector_query_set_include_vector(ZVecGroupByVectorQuery *query, * @return bool Whether to include vectors */ ZVEC_EXPORT bool ZVEC_CALL zvec_group_by_vector_query_get_include_vector( - const ZVecGroupByVectorQuery *query); + const zvec_group_by_vector_query_t *query); /** * @brief Set output fields * @param query Group by vector query pointer * @param fields Array of field names * @param count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_group_by_vector_query_set_output_fields(ZVecGroupByVectorQuery *query, - const char **fields, size_t count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_output_fields( + zvec_group_by_vector_query_t *query, const char **fields, size_t count); /** * @brief Get output fields * @param query Group by vector query pointer * @param[out] fields Output array of field names (allocated by library) * @param[out] count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual string pointers * are owned by the query and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_group_by_vector_query_get_output_fields(ZVecGroupByVectorQuery *query, - const char ***fields, - size_t *count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_get_output_fields( + zvec_group_by_vector_query_t *query, const char ***fields, size_t *count); /** * @brief Set query parameters (takes ownership) * @param query Group by vector query pointer * @param params Query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_query_params( - ZVecGroupByVectorQuery *query, void *params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_query_params(zvec_group_by_vector_query_t *query, + void *params); /** * @brief Set HNSW query parameters (takes ownership) * @param query Group by vector query pointer * @param hnsw_params HNSW query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_hnsw_params( - ZVecGroupByVectorQuery *query, ZVecHnswQueryParams *hnsw_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_hnsw_params( + zvec_group_by_vector_query_t *query, zvec_hnsw_query_params_t *hnsw_params); /** * @brief Set IVF query parameters (takes ownership) * @param query Group by vector query pointer * @param ivf_params IVF query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_ivf_params( - ZVecGroupByVectorQuery *query, ZVecIVFQueryParams *ivf_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_ivf_params(zvec_group_by_vector_query_t *query, + zvec_ivf_query_params_t *ivf_params); /** * @brief Set Flat query parameters (takes ownership) * @param query Group by vector query pointer * @param flat_params Flat query parameters pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_flat_params( - ZVecGroupByVectorQuery *query, ZVecFlatQueryParams *flat_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_group_by_vector_query_set_flat_params( + zvec_group_by_vector_query_t *query, zvec_flat_query_params_t *flat_params); // ============================================================================= // Collection Options and Statistics (Opaque Pointer Pattern) @@ -1693,13 +1713,13 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_group_by_vector_query_set_flat_params( * Use zvec_collection_options_create() to create and * zvec_collection_options_destroy() to destroy */ -typedef struct ZVecCollectionOptions ZVecCollectionOptions; +typedef struct zvec_collection_options_t zvec_collection_options_t; /** * @brief Collection statistics (opaque pointer) * Use zvec_collection_stats_get functions to access fields */ -typedef struct ZVecCollectionStats ZVecCollectionStats; +typedef struct zvec_collection_stats_t zvec_collection_stats_t; // ============================================================================= // Collection Options Management Functions @@ -1707,10 +1727,10 @@ typedef struct ZVecCollectionStats ZVecCollectionStats; /** * @brief Create collection options - * @return ZVecCollectionOptions* Pointer to the newly created collection + * @return zvec_collection_options_t* Pointer to the newly created collection * options */ -ZVEC_EXPORT ZVecCollectionOptions *ZVEC_CALL +ZVEC_EXPORT zvec_collection_options_t *ZVEC_CALL zvec_collection_options_create(void); /** @@ -1718,33 +1738,34 @@ zvec_collection_options_create(void); * @param options Collection options pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_collection_options_destroy(ZVecCollectionOptions *options); +zvec_collection_options_destroy(zvec_collection_options_t *options); /** * @brief Set whether to enable memory mapping * @param options Collection options pointer * @param enable Whether to enable mmap - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_options_set_enable_mmap( - ZVecCollectionOptions *options, bool enable); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_options_set_enable_mmap( + zvec_collection_options_t *options, bool enable); /** * @brief Get whether to enable memory mapping * @param options Collection options pointer * @return bool Whether mmap is enabled */ -ZVEC_EXPORT bool ZVEC_CALL -zvec_collection_options_get_enable_mmap(const ZVecCollectionOptions *options); +ZVEC_EXPORT bool ZVEC_CALL zvec_collection_options_get_enable_mmap( + const zvec_collection_options_t *options); /** * @brief Set maximum buffer size * @param options Collection options pointer * @param size Maximum buffer size in bytes - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_options_set_max_buffer_size( - ZVecCollectionOptions *options, size_t size); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_options_set_max_buffer_size(zvec_collection_options_t *options, + size_t size); /** * @brief Get maximum buffer size @@ -1752,16 +1773,16 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_options_set_max_buffer_size( * @return size_t Maximum buffer size in bytes */ ZVEC_EXPORT size_t ZVEC_CALL zvec_collection_options_get_max_buffer_size( - const ZVecCollectionOptions *options); + const zvec_collection_options_t *options); /** * @brief Set whether read-only mode * @param options Collection options pointer * @param read_only Whether read-only - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_options_set_read_only( - ZVecCollectionOptions *options, bool read_only); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_options_set_read_only( + zvec_collection_options_t *options, bool read_only); /** * @brief Get whether read-only mode @@ -1769,26 +1790,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_options_set_read_only( * @return bool Whether read-only mode */ ZVEC_EXPORT bool ZVEC_CALL -zvec_collection_options_get_read_only(const ZVecCollectionOptions *options); - -/** - * @brief Set maximum document count per segment - * @param options Collection options pointer - * @param count Maximum document count - * @return ZVecErrorCode Error code - */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_options_set_max_doc_count_per_segment( - ZVecCollectionOptions *options, uint64_t count); - -/** - * @brief Get maximum document count per segment - * @param options Collection options pointer - * @return uint64_t Maximum document count per segment - */ -ZVEC_EXPORT uint64_t ZVEC_CALL -zvec_collection_options_get_max_doc_count_per_segment( - const ZVecCollectionOptions *options); +zvec_collection_options_get_read_only(const zvec_collection_options_t *options); // ============================================================================= // Collection Statistics Management Functions @@ -1800,7 +1802,7 @@ zvec_collection_options_get_max_doc_count_per_segment( * @return uint64_t Document count */ ZVEC_EXPORT uint64_t ZVEC_CALL -zvec_collection_stats_get_doc_count(const ZVecCollectionStats *stats); +zvec_collection_stats_get_doc_count(const zvec_collection_stats_t *stats); /** * @brief Get index count from collection stats @@ -1808,7 +1810,7 @@ zvec_collection_stats_get_doc_count(const ZVecCollectionStats *stats); * @return size_t Number of indexes */ ZVEC_EXPORT size_t ZVEC_CALL -zvec_collection_stats_get_index_count(const ZVecCollectionStats *stats); +zvec_collection_stats_get_index_count(const zvec_collection_stats_t *stats); /** * @brief Get index name at specified index @@ -1817,7 +1819,7 @@ zvec_collection_stats_get_index_count(const ZVecCollectionStats *stats); * @return const char* Index name (owned by stats, do not free) */ ZVEC_EXPORT const char *ZVEC_CALL zvec_collection_stats_get_index_name( - const ZVecCollectionStats *stats, size_t index); + const zvec_collection_stats_t *stats, size_t index); /** * @brief Get index completeness at specified index @@ -1826,7 +1828,7 @@ ZVEC_EXPORT const char *ZVEC_CALL zvec_collection_stats_get_index_name( * @return float Index completeness */ ZVEC_EXPORT float ZVEC_CALL zvec_collection_stats_get_index_completeness( - const ZVecCollectionStats *stats, size_t index); + const zvec_collection_stats_t *stats, size_t index); /** * @brief Create field schema @@ -1834,26 +1836,27 @@ ZVEC_EXPORT float ZVEC_CALL zvec_collection_stats_get_index_completeness( * @param data_type Data type * @param nullable Whether nullable * @param dimension Vector dimension - * @return ZVecFieldSchema* Pointer to the newly created field schema + * @return zvec_field_schema_t* Pointer to the newly created field schema */ -ZVEC_EXPORT ZVecFieldSchema *ZVEC_CALL -zvec_field_schema_create(const char *name, ZVecDataType data_type, +ZVEC_EXPORT zvec_field_schema_t *ZVEC_CALL +zvec_field_schema_create(const char *name, zvec_data_type_t data_type, bool nullable, uint32_t dimension); /** * @brief Destroy field schema * @param schema Field schema pointer */ -ZVEC_EXPORT void ZVEC_CALL zvec_field_schema_destroy(ZVecFieldSchema *schema); +ZVEC_EXPORT void ZVEC_CALL +zvec_field_schema_destroy(zvec_field_schema_t *schema); /** * @brief Set field name * @param schema Field schema pointer * @param name New field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_field_schema_set_name(ZVecFieldSchema *schema, const char *name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_field_schema_set_name(zvec_field_schema_t *schema, const char *name); /** * @brief Get field name @@ -1861,32 +1864,32 @@ zvec_field_schema_set_name(ZVecFieldSchema *schema, const char *name); * @return const char* Field name (owned by schema, do not free) */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_field_schema_get_name(const ZVecFieldSchema *schema); +zvec_field_schema_get_name(const zvec_field_schema_t *schema); /** * @brief Get field data type * @param schema Field schema pointer (must not be NULL) - * @return ZVecDataType Data type + * @return zvec_data_type_t Data type */ -ZVEC_EXPORT ZVecDataType ZVEC_CALL -zvec_field_schema_get_data_type(const ZVecFieldSchema *schema); +ZVEC_EXPORT zvec_data_type_t ZVEC_CALL +zvec_field_schema_get_data_type(const zvec_field_schema_t *schema); /** * @brief Set field data type * @param schema Field schema pointer * @param data_type New data type - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_field_schema_set_data_type( - ZVecFieldSchema *schema, ZVecDataType data_type); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_field_schema_set_data_type( + zvec_field_schema_t *schema, zvec_data_type_t data_type); /** * @brief Get element data type for array fields * @param schema Field schema pointer (must not be NULL) - * @return ZVecDataType Element data type, or original type if not array + * @return zvec_data_type_t Element data type, or original type if not array */ -ZVEC_EXPORT ZVecDataType ZVEC_CALL -zvec_field_schema_get_element_data_type(const ZVecFieldSchema *schema); +ZVEC_EXPORT zvec_data_type_t ZVEC_CALL +zvec_field_schema_get_element_data_type(const zvec_field_schema_t *schema); /** * @brief Get element data size for the field @@ -1894,7 +1897,7 @@ zvec_field_schema_get_element_data_type(const ZVecFieldSchema *schema); * @return size_t Element data size in bytes, or 0 for variable-size types */ ZVEC_EXPORT size_t ZVEC_CALL -zvec_field_schema_get_element_data_size(const ZVecFieldSchema *schema); +zvec_field_schema_get_element_data_size(const zvec_field_schema_t *schema); /** * @brief Check if field is a vector field (dense or sparse) @@ -1902,7 +1905,7 @@ zvec_field_schema_get_element_data_size(const ZVecFieldSchema *schema); * @return bool true if vector field, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_is_vector_field(const ZVecFieldSchema *schema); +zvec_field_schema_is_vector_field(const zvec_field_schema_t *schema); /** * @brief Check if field is a dense vector field @@ -1910,7 +1913,7 @@ zvec_field_schema_is_vector_field(const ZVecFieldSchema *schema); * @return bool true if dense vector field, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_is_dense_vector(const ZVecFieldSchema *schema); +zvec_field_schema_is_dense_vector(const zvec_field_schema_t *schema); /** * @brief Check if field is a sparse vector field @@ -1918,7 +1921,7 @@ zvec_field_schema_is_dense_vector(const ZVecFieldSchema *schema); * @return bool true if sparse vector field, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_is_sparse_vector(const ZVecFieldSchema *schema); +zvec_field_schema_is_sparse_vector(const zvec_field_schema_t *schema); /** * @brief Check if field is nullable @@ -1926,16 +1929,16 @@ zvec_field_schema_is_sparse_vector(const ZVecFieldSchema *schema); * @return bool true if nullable, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_is_nullable(const ZVecFieldSchema *schema); +zvec_field_schema_is_nullable(const zvec_field_schema_t *schema); /** * @brief Set field nullable * @param schema Field schema pointer * @param nullable Whether nullable - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_field_schema_set_nullable(ZVecFieldSchema *schema, bool nullable); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_field_schema_set_nullable(zvec_field_schema_t *schema, bool nullable); /** * @brief Check if field has inverted index (for scalar fields) @@ -1943,7 +1946,7 @@ zvec_field_schema_set_nullable(ZVecFieldSchema *schema, bool nullable); * @return bool true if has inverted index, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_has_invert_index(const ZVecFieldSchema *schema); +zvec_field_schema_has_invert_index(const zvec_field_schema_t *schema); /** * @brief Check if field is an array type @@ -1951,7 +1954,7 @@ zvec_field_schema_has_invert_index(const ZVecFieldSchema *schema); * @return bool true if array type, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_is_array_type(const ZVecFieldSchema *schema); +zvec_field_schema_is_array_type(const zvec_field_schema_t *schema); /** * @brief Get field dimension (for vector fields) @@ -1959,24 +1962,24 @@ zvec_field_schema_is_array_type(const ZVecFieldSchema *schema); * @return uint32_t Dimension value */ ZVEC_EXPORT uint32_t ZVEC_CALL -zvec_field_schema_get_dimension(const ZVecFieldSchema *schema); +zvec_field_schema_get_dimension(const zvec_field_schema_t *schema); /** * @brief Set field dimension (for vector fields) * @param schema Field schema pointer * @param dimension Dimension value - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_field_schema_set_dimension(ZVecFieldSchema *schema, uint32_t dimension); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_field_schema_set_dimension( + zvec_field_schema_t *schema, uint32_t dimension); /** * @brief Get index type of the field * @param schema Field schema pointer (must not be NULL) - * @return ZVecIndexType Index type, ZVEC_INDEX_TYPE_UNDEFINED if no index + * @return zvec_index_type_t Index type, ZVEC_INDEX_TYPE_UNDEFINED if no index */ -ZVEC_EXPORT ZVecIndexType ZVEC_CALL -zvec_field_schema_get_index_type(const ZVecFieldSchema *schema); +ZVEC_EXPORT zvec_index_type_t ZVEC_CALL +zvec_field_schema_get_index_type(const zvec_field_schema_t *schema); /** * @brief Check if field has index @@ -1984,17 +1987,17 @@ zvec_field_schema_get_index_type(const ZVecFieldSchema *schema); * @return bool true if field has index, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL -zvec_field_schema_has_index(const ZVecFieldSchema *schema); +zvec_field_schema_has_index(const zvec_field_schema_t *schema); /** * @brief Get index params of the field (returns pointer owned by the field * schema, do not destroy. Pointer becomes invalid if schema is modified or * destroyed) * @param schema Field schema pointer (must not be NULL) - * @return ZVecIndexParams* Index params pointer, NULL if no index + * @return zvec_index_params_t* Index params pointer, NULL if no index */ -ZVEC_EXPORT const ZVecIndexParams *ZVEC_CALL -zvec_field_schema_get_index_params(const ZVecFieldSchema *schema); +ZVEC_EXPORT const zvec_index_params_t *ZVEC_CALL +zvec_field_schema_get_index_params(const zvec_field_schema_t *schema); /** * @brief Set index parameters for field @@ -2002,20 +2005,20 @@ zvec_field_schema_get_index_params(const ZVecFieldSchema *schema); * @param index_params Index parameters pointer (deep-copied internally, caller * retains ownership and must call zvec_index_params_destroy * after the call) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_field_schema_set_index_params( - ZVecFieldSchema *schema, const ZVecIndexParams *index_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_field_schema_set_index_params( + zvec_field_schema_t *schema, const zvec_index_params_t *index_params); /** * @brief Validate field schema * @param schema Field schema pointer * @param[out] error_msg Error message (needs to be freed by calling * zvec_free_string) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_field_schema_validate( - const ZVecFieldSchema *schema, ZVecString **error_msg); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_field_schema_validate( + const zvec_field_schema_t *schema, zvec_string_t **error_msg); // ============================================================================= // Collection Schema Structures (Opaque Pointer Pattern) @@ -2029,14 +2032,15 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_field_schema_validate( * zvec_collection_schema_destroy(). Caller owns the pointer and must explicitly * destroy it. */ -typedef struct ZVecCollectionSchema ZVecCollectionSchema; +typedef struct zvec_collection_schema_t zvec_collection_schema_t; /** * @brief Create collection schema * @param name Collection name - * @return ZVecCollectionSchema* Pointer to the newly created collection schema + * @return zvec_collection_schema_t* Pointer to the newly created collection + * schema */ -ZVEC_EXPORT ZVecCollectionSchema *ZVEC_CALL +ZVEC_EXPORT zvec_collection_schema_t *ZVEC_CALL zvec_collection_schema_create(const char *name); /** @@ -2044,7 +2048,7 @@ zvec_collection_schema_create(const char *name); * @param schema Collection schema pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_collection_schema_destroy(ZVecCollectionSchema *schema); +zvec_collection_schema_destroy(zvec_collection_schema_t *schema); /** * @brief Get collection schema name @@ -2056,45 +2060,45 @@ zvec_collection_schema_destroy(ZVecCollectionSchema *schema); * exists. */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_collection_schema_get_name(const ZVecCollectionSchema *schema); +zvec_collection_schema_get_name(const zvec_collection_schema_t *schema); /** * @brief Set collection schema name * @param schema Collection schema pointer * @param name New collection name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_schema_set_name(ZVecCollectionSchema *schema, const char *name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_set_name( + zvec_collection_schema_t *schema, const char *name); /** * @brief Add field to collection schema * @param schema Collection schema pointer * @param field Field schema pointer (will be cloned, caller retains ownership) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_add_field( - ZVecCollectionSchema *schema, const ZVecFieldSchema *field); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_add_field( + zvec_collection_schema_t *schema, const zvec_field_schema_t *field); /** * @brief Alter field schema * @param schema Collection schema pointer * @param field_name Name of field to alter * @param new_field New field schema with updated properties - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_alter_field( - ZVecCollectionSchema *schema, const char *field_name, - const ZVecFieldSchema *new_field); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_alter_field( + zvec_collection_schema_t *schema, const char *field_name, + const zvec_field_schema_t *new_field); /** * @brief Drop field from schema * @param schema Collection schema pointer * @param field_name Field name to drop - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_drop_field( - ZVecCollectionSchema *schema, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_drop_field( + zvec_collection_schema_t *schema, const char *field_name); /** * @brief Check if field exists in schema @@ -2103,37 +2107,39 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_drop_field( * @return true if field exists, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL zvec_collection_schema_has_field( - const ZVecCollectionSchema *schema, const char *field_name); + const zvec_collection_schema_t *schema, const char *field_name); /** * @brief Get field by name * @param schema Collection schema pointer * @param field_name Field name - * @return ZVecFieldSchema* Field schema pointer (non-owning, do not destroy), - * NULL if not found + * @return zvec_field_schema_t* Field schema pointer (non-owning, do not + * destroy), NULL if not found */ -ZVEC_EXPORT ZVecFieldSchema *ZVEC_CALL zvec_collection_schema_get_field( - const ZVecCollectionSchema *schema, const char *field_name); +ZVEC_EXPORT zvec_field_schema_t *ZVEC_CALL zvec_collection_schema_get_field( + const zvec_collection_schema_t *schema, const char *field_name); /** * @brief Get forward (scalar) field by name * @param schema Collection schema pointer * @param field_name Field name - * @return ZVecFieldSchema* Field schema pointer (non-owning, do not destroy), - * NULL if not found or not scalar + * @return zvec_field_schema_t* Field schema pointer (non-owning, do not + * destroy), NULL if not found or not scalar */ -ZVEC_EXPORT ZVecFieldSchema *ZVEC_CALL zvec_collection_schema_get_forward_field( - const ZVecCollectionSchema *schema, const char *field_name); +ZVEC_EXPORT zvec_field_schema_t *ZVEC_CALL +zvec_collection_schema_get_forward_field(const zvec_collection_schema_t *schema, + const char *field_name); /** * @brief Get vector field by name * @param schema Collection schema pointer * @param field_name Field name - * @return ZVecFieldSchema* Field schema pointer (non-owning, do not destroy), - * NULL if not found or not vector + * @return zvec_field_schema_t* Field schema pointer (non-owning, do not + * destroy), NULL if not found or not vector */ -ZVEC_EXPORT ZVecFieldSchema *ZVEC_CALL zvec_collection_schema_get_vector_field( - const ZVecCollectionSchema *schema, const char *field_name); +ZVEC_EXPORT zvec_field_schema_t *ZVEC_CALL +zvec_collection_schema_get_vector_field(const zvec_collection_schema_t *schema, + const char *field_name); /** * @brief Get all forward (scalar) fields @@ -2142,14 +2148,15 @@ ZVEC_EXPORT ZVecFieldSchema *ZVEC_CALL zvec_collection_schema_get_vector_field( * schemas. The array is allocated by the library and should be * freed using zvec_free() when no longer needed. * @param[out] count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual field pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_forward_fields( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_schema_get_forward_fields( + const zvec_collection_schema_t *schema, zvec_field_schema_t ***fields, size_t *count); /** @@ -2159,15 +2166,15 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_forward_fields( * schemas. The array is allocated by the library and should be * freed using zvec_free() when no longer needed. * @param[out] count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual field pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_get_forward_fields_with_index( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, + const zvec_collection_schema_t *schema, zvec_field_schema_t ***fields, size_t *count); /** @@ -2175,44 +2182,45 @@ zvec_collection_schema_get_forward_fields_with_index( * @param schema Collection schema pointer * @param[out] names Output array of field names (allocated by library) * @param[out] count Number of field names - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual string pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_get_forward_field_names( - const ZVecCollectionSchema *schema, const char ***names, size_t *count); + const zvec_collection_schema_t *schema, const char ***names, size_t *count); /** * @brief Get all forward field names with index * @param schema Collection schema pointer * @param[out] names Output array of field names (allocated by library) * @param[out] count Number of field names - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual string pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_get_forward_field_names_with_index( - const ZVecCollectionSchema *schema, const char ***names, size_t *count); + const zvec_collection_schema_t *schema, const char ***names, size_t *count); /** * @brief Get all field names * @param schema Collection schema pointer * @param[out] names Output array of field names (allocated by library) * @param[out] count Number of field names - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual string pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_all_field_names( - const ZVecCollectionSchema *schema, const char ***names, size_t *count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_schema_get_all_field_names( + const zvec_collection_schema_t *schema, const char ***names, size_t *count); /** * @brief Get all vector fields @@ -2221,15 +2229,16 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_all_field_names( * schemas. The array is allocated by the library and should be * freed using zvec_free() when no longer needed. * @param[out] count Number of fields - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code * * @note The returned array is allocated by the library and should be freed * using zvec_free() when no longer needed. The individual field pointers * are owned by the schema and must NOT be freed. */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_vector_fields( - const ZVecCollectionSchema *schema, ZVecFieldSchema ***fields, - size_t *count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_schema_get_vector_fields(const zvec_collection_schema_t *schema, + zvec_field_schema_t ***fields, + size_t *count); /** * @brief Get maximum document count per segment of collection schema @@ -2239,47 +2248,47 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_get_vector_fields( */ ZVEC_EXPORT uint64_t ZVEC_CALL zvec_collection_schema_get_max_doc_count_per_segment( - const ZVecCollectionSchema *schema); + const zvec_collection_schema_t *schema); /** * @brief Set maximum document count per segment * @param schema Collection schema pointer * @param max_doc_count Maximum document count - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_set_max_doc_count_per_segment( - ZVecCollectionSchema *schema, uint64_t max_doc_count); + zvec_collection_schema_t *schema, uint64_t max_doc_count); /** * @brief Validate collection schema * @param schema Collection schema pointer * @param[out] error_msg Error message (needs to be freed by calling * zvec_free_string) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_validate( - const ZVecCollectionSchema *schema, ZVecString **error_msg); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_validate( + const zvec_collection_schema_t *schema, zvec_string_t **error_msg); /** * @brief Add index to field * @param schema Collection schema pointer * @param field_name Field name to add index to * @param index_params Index parameters - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_add_index( - ZVecCollectionSchema *schema, const char *field_name, - const ZVecIndexParams *index_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_add_index( + zvec_collection_schema_t *schema, const char *field_name, + const zvec_index_params_t *index_params); /** * @brief Drop index from field * @param schema Collection schema pointer * @param field_name Field name to drop index from - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_drop_index( - ZVecCollectionSchema *schema, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_schema_drop_index( + zvec_collection_schema_t *schema, const char *field_name); /** * @brief Check if field has index @@ -2288,7 +2297,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_schema_drop_index( * @return true if field has index, false otherwise */ ZVEC_EXPORT bool ZVEC_CALL zvec_collection_schema_has_index( - const ZVecCollectionSchema *schema, const char *field_name); + const zvec_collection_schema_t *schema, const char *field_name); // ============================================================================= // Collection Management Functions @@ -2300,11 +2309,11 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_collection_schema_has_index( * @param schema Collection schema pointer * @param options Collection options pointer (NULL uses default options) * @param[out] collection Returned collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_create_and_open( - const char *path, const ZVecCollectionSchema *schema, - const ZVecCollectionOptions *options, ZVecCollection **collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_create_and_open( + const char *path, const zvec_collection_schema_t *schema, + const zvec_collection_options_t *options, zvec_collection_t **collection); /** @@ -2312,36 +2321,36 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_create_and_open( * @param path Collection path * @param options Collection options pointer (NULL uses default options) * @param[out] collection Returned collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_open(const char *path, const ZVecCollectionOptions *options, - ZVecCollection **collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_open(const char *path, const zvec_collection_options_t *options, + zvec_collection_t **collection); /** * @brief Close collection * @param collection Collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_close(ZVecCollection *collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_close(zvec_collection_t *collection); /** * @brief Destroy collection * * @param collection Collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_destroy(ZVecCollection *collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_destroy(zvec_collection_t *collection); /** * @brief Flush collection data to disk * @param collection Collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_flush(ZVecCollection *collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_flush(zvec_collection_t *collection); /** * @brief Get collection schema @@ -2349,10 +2358,10 @@ zvec_collection_flush(ZVecCollection *collection); * @param[out] schema * Returned collection schema pointer (needs to be freed by calling * zvec_collection_schema_destroy) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_get_schema( - const ZVecCollection *collection, ZVecCollectionSchema **schema); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_get_schema( + const zvec_collection_t *collection, zvec_collection_schema_t **schema); /** * @brief Get collection options @@ -2360,10 +2369,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_get_schema( * @param[out] options * Returned collection options pointer (needs to be freed by calling * zvec_collection_options_destroy) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_get_options( - const ZVecCollection *collection, ZVecCollectionOptions **options); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_get_options( + const zvec_collection_t *collection, zvec_collection_options_t **options); /** * @brief Get collection statistics @@ -2371,17 +2380,17 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_get_options( * @param[out] stats * Returned statistics pointer (needs to be freed by calling * zvec_collection_stats_destroy) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_get_stats( - const ZVecCollection *collection, ZVecCollectionStats **stats); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_get_stats( + const zvec_collection_t *collection, zvec_collection_stats_t **stats); /** * @brief Destroy collection statistics * @param stats Statistics pointer */ ZVEC_EXPORT void ZVEC_CALL -zvec_collection_stats_destroy(ZVecCollectionStats *stats); +zvec_collection_stats_destroy(zvec_collection_stats_t *stats); /** * @brief Free field schema memory @@ -2389,7 +2398,7 @@ zvec_collection_stats_destroy(ZVecCollectionStats *stats); * @param field_schema Field schema pointer to be freed */ ZVEC_EXPORT void ZVEC_CALL -zvec_free_field_schema(ZVecFieldSchema *field_schema); +zvec_free_field_schema(zvec_field_schema_t *field_schema); // ============================================================================= // Index Management Interface @@ -2403,28 +2412,28 @@ zvec_free_field_schema(ZVecFieldSchema *field_schema); * @param index_params Index parameters. The function will make an internal copy * of the parameters, so the caller retains ownership and * should call zvec_index_params_destroy() after the call. - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_create_index(ZVecCollection *collection, const char *field_name, - const ZVecIndexParams *index_params); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_create_index( + zvec_collection_t *collection, const char *field_name, + const zvec_index_params_t *index_params); /** * @brief Drop index * @param collection Collection handle * @param field_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_drop_index(ZVecCollection *collection, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_drop_index( + zvec_collection_t *collection, const char *field_name); /** * @brief Optimize collection (rebuild indexes, merge segments, etc.) * @param collection Collection handle - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_collection_optimize(ZVecCollection *collection); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_collection_optimize(zvec_collection_t *collection); // ============================================================================= // Column Management Interface (DDL) @@ -2437,20 +2446,20 @@ zvec_collection_optimize(ZVecCollection *collection); * retains ownership and must call zvec_field_schema_destroy * after the call) * @param expression Default value expression (can be NULL) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_add_column( - ZVecCollection *collection, const ZVecFieldSchema *field_schema, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_add_column( + zvec_collection_t *collection, const zvec_field_schema_t *field_schema, const char *expression); /** * @brief Drop column * @param collection Collection handle * @param column_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_drop_column( - ZVecCollection *collection, const char *column_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_drop_column( + zvec_collection_t *collection, const char *column_name); /** * @brief Alter column @@ -2461,18 +2470,18 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_drop_column( * modification). The schema is deep-copied internally, caller retains * ownership and must call zvec_field_schema_destroy after the * call. - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_alter_column( - ZVecCollection *collection, const char *column_name, const char *new_name, - const ZVecFieldSchema *new_schema); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_alter_column( + zvec_collection_t *collection, const char *column_name, + const char *new_name, const zvec_field_schema_t *new_schema); /** * @brief Document structure (opaque pointer mode) * Internal implementation details are not visible to the outside, and * operations are performed through API functions */ -typedef struct ZVecDoc ZVecDoc; +typedef struct zvec_doc_t zvec_doc_t; /** * @brief Per-document status returned by detailed DML APIs. @@ -2480,9 +2489,9 @@ typedef struct ZVecDoc ZVecDoc; * Caller should access pk by index from the original input array. */ typedef struct { - ZVecErrorCode code; /**< Per-document status code */ - const char *message; /**< Per-document status message (allocated by API) */ -} ZVecWriteResult; + zvec_error_code_t code; /**< Per-document status code */ + const char *message; /**< Per-document status message (allocated by API) */ +} zvec_write_result_t; // ============================================================================= // Data Manipulation Interface (DML) @@ -2495,10 +2504,10 @@ typedef struct { * @param doc_count Document count * @param[out] success_count Number of successfully inserted documents * @param[out] error_count Number of failed insertions - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_insert( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_insert( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count); /** @@ -2510,11 +2519,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_insert( * @param[out] results Per-document result array (free with * zvec_write_results_free) * @param[out] result_count Number of result entries - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_insert_with_results( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, - ZVecWriteResult **results, size_t *result_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_insert_with_results( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, + zvec_write_result_t **results, size_t *result_count); /** * @brief Update documents in collection @@ -2523,10 +2532,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_insert_with_results( * @param doc_count Document count * @param[out] success_count Number of successfully updated documents * @param[out] error_count Number of failed updates - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_update( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_update( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count); /** @@ -2538,11 +2547,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_update( * @param[out] results Per-document result array (free with * zvec_write_results_free) * @param[out] result_count Number of result entries - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_update_with_results( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, - ZVecWriteResult **results, size_t *result_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_update_with_results( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, + zvec_write_result_t **results, size_t *result_count); /** * @brief Insert or update documents in collection (upsert operation) @@ -2551,10 +2560,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_update_with_results( * @param doc_count Document count * @param[out] success_count Number of successful operations * @param[out] error_count Number of failed operations - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_upsert( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_upsert( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, size_t *success_count, size_t *error_count); /** @@ -2566,11 +2575,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_upsert( * @param[out] results Per-document result array (free with * zvec_write_results_free) * @param[out] result_count Number of result entries - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_upsert_with_results( - ZVecCollection *collection, const ZVecDoc **docs, size_t doc_count, - ZVecWriteResult **results, size_t *result_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_upsert_with_results( + zvec_collection_t *collection, const zvec_doc_t **docs, size_t doc_count, + zvec_write_result_t **results, size_t *result_count); /** * @brief Delete documents from collection @@ -2579,10 +2588,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_upsert_with_results( * @param pk_count Primary key count * @param[out] success_count Number of successfully deleted documents * @param[out] error_count Number of failed deletions - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete( - ZVecCollection *collection, const char *const *pks, size_t pk_count, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_delete( + zvec_collection_t *collection, const char *const *pks, size_t pk_count, size_t *success_count, size_t *error_count); /** @@ -2594,11 +2603,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete( * @param[out] results Per-document result array (free with * zvec_write_results_free) * @param[out] result_count Number of result entries - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete_with_results( - ZVecCollection *collection, const char *const *pks, size_t pk_count, - ZVecWriteResult **results, size_t *result_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_delete_with_results( + zvec_collection_t *collection, const char *const *pks, size_t pk_count, + zvec_write_result_t **results, size_t *result_count); /** * @brief Free result arrays returned by detailed DML APIs. @@ -2606,7 +2615,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete_with_results( * @param results Result array pointer * @param result_count Number of entries in result array */ -ZVEC_EXPORT void ZVEC_CALL zvec_write_results_free(ZVecWriteResult *results, +ZVEC_EXPORT void ZVEC_CALL zvec_write_results_free(zvec_write_result_t *results, size_t result_count); /** @@ -2614,10 +2623,10 @@ ZVEC_EXPORT void ZVEC_CALL zvec_write_results_free(ZVecWriteResult *results, * @param collection Collection handle * @param filter Filter expression * @param[out] deleted_count Number of deleted documents - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete_by_filter( - ZVecCollection *collection, const char *filter); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_delete_by_filter( + zvec_collection_t *collection, const char *filter); // ============================================================================= // Data Query Interface (DQL) @@ -2630,11 +2639,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_delete_by_filter( * @param[out] results Returned document array (needs to be freed by calling * zvec_docs_free) * @param[out] result_count Number of returned results - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_query( - const ZVecCollection *collection, const ZVecVectorQuery *query, - ZVecDoc ***results, size_t *result_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_query( + const zvec_collection_t *collection, const zvec_vector_query_t *query, + zvec_doc_t ***results, size_t *result_count); /** * @brief Fetch documents by primary keys @@ -2644,11 +2653,11 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_query( * @param[out] documents Returned document array (needs to be freed by calling * zvec_docs_free) * @param[out] found_count Number of found documents - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_collection_fetch( - ZVecCollection *collection, const char *const *primary_keys, size_t count, - ZVecDoc ***documents, size_t *found_count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_collection_fetch( + zvec_collection_t *collection, const char *const *primary_keys, + size_t count, zvec_doc_t ***documents, size_t *found_count); // ============================================================================= // Document Related Structures @@ -2665,19 +2674,19 @@ typedef union { uint64_t uint64_value; float float_value; double double_value; - ZVecString string_value; - ZVecFloatArray vector_value; - ZVecByteArray binary_value; /**< Binary data value */ -} ZVecFieldValue; + zvec_string_t string_value; + zvec_float_array_t vector_value; + zvec_byte_array_t binary_value; /**< Binary data value */ +} zvec_field_value_t; /** * @brief Document field structure */ typedef struct { - ZVecString name; ///< Field name - ZVecDataType data_type; ///< Data type - ZVecFieldValue value; ///< Field value -} ZVecDocField; + zvec_string_t name; ///< Field name + zvec_data_type_t data_type; ///< Data type + zvec_field_value_t value; ///< Field value +} zvec_doc_field_t; /** * @brief Document operator enumeration @@ -2687,7 +2696,7 @@ typedef enum { ZVEC_DOC_OP_UPDATE = 1, ///< Update operation ZVEC_DOC_OP_UPSERT = 2, ///< Insert or update operation ZVEC_DOC_OP_DELETE = 3 ///< Delete operation -} ZVecDocOperator; +} zvec_doc_operator_t; // ============================================================================= // Data Manipulation Interface (DML) @@ -2696,24 +2705,24 @@ typedef enum { /** * @brief Create a new document object * - * @return ZVecDoc* Pointer to the newly created document object, returns NULL - * on failure + * @return zvec_doc_t* Pointer to the newly created document object, returns + * NULL on failure */ -ZVEC_EXPORT ZVecDoc *ZVEC_CALL zvec_doc_create(void); +ZVEC_EXPORT zvec_doc_t *ZVEC_CALL zvec_doc_create(void); /** * @brief Destroy the document object and release all resources * * @param doc Pointer to the document object */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_destroy(ZVecDoc *doc); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_destroy(zvec_doc_t *doc); /** * @brief Clear the document object * * @param doc Pointer to the document object */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_clear(ZVecDoc *doc); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_clear(zvec_doc_t *doc); /** * @brief Add field to document by value @@ -2723,10 +2732,10 @@ ZVEC_EXPORT void ZVEC_CALL zvec_doc_clear(ZVecDoc *doc); * @param data_type Data type * @param value Value pointer * @param value_size Value size - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_add_field_by_value( - ZVecDoc *doc, const char *field_name, ZVecDataType data_type, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_doc_add_field_by_value( + zvec_doc_t *doc, const char *field_name, zvec_data_type_t data_type, const void *value, size_t value_size); /** @@ -2734,20 +2743,20 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_add_field_by_value( * * @param doc Document object pointer * @param field Field structure pointer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_doc_add_field_by_struct(ZVecDoc *doc, const ZVecDocField *field); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_add_field_by_struct(zvec_doc_t *doc, const zvec_doc_field_t *field); /** * @brief Remove field from document * * @param doc Document structure pointer * @param field_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_doc_remove_field(ZVecDoc *doc, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_remove_field(zvec_doc_t *doc, const char *field_name); /** * @brief Batch release document array @@ -2755,7 +2764,7 @@ zvec_doc_remove_field(ZVecDoc *doc, const char *field_name); * @param documents Document pointer array * @param count Document count */ -ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(ZVecDoc **documents, size_t count); +ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(zvec_doc_t **documents, size_t count); /** * @brief Set document primary key @@ -2763,7 +2772,7 @@ ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(ZVecDoc **documents, size_t count); * @param doc Pointer to the document structure * @param pk Primary key string */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_pk(ZVecDoc *doc, const char *pk); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_pk(zvec_doc_t *doc, const char *pk); /** * @brief Set document ID @@ -2771,7 +2780,8 @@ ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_pk(ZVecDoc *doc, const char *pk); * @param doc Document structure pointer * @param doc_id Document ID */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_doc_id(ZVecDoc *doc, uint64_t doc_id); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_doc_id(zvec_doc_t *doc, + uint64_t doc_id); /** * @brief Set document score @@ -2779,7 +2789,7 @@ ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_doc_id(ZVecDoc *doc, uint64_t doc_id); * @param doc Document structure pointer * @param score Score value */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_score(ZVecDoc *doc, float score); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_score(zvec_doc_t *doc, float score); /** * @brief Set document operator @@ -2787,18 +2797,18 @@ ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_score(ZVecDoc *doc, float score); * @param doc Document structure pointer * @param op Operator */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_operator(ZVecDoc *doc, - ZVecDocOperator op); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_set_operator(zvec_doc_t *doc, + zvec_doc_operator_t op); /** * @brief Explicitly mark a document field as null. * * @param doc Document structure pointer * @param field_name Field name - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_doc_set_field_null(ZVecDoc *doc, const char *field_name); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_set_field_null(zvec_doc_t *doc, const char *field_name); /** * @brief Get document ID @@ -2806,7 +2816,7 @@ zvec_doc_set_field_null(ZVecDoc *doc, const char *field_name); * @param doc Document structure pointer * @return uint64_t Document ID */ -ZVEC_EXPORT uint64_t ZVEC_CALL zvec_doc_get_doc_id(const ZVecDoc *doc); +ZVEC_EXPORT uint64_t ZVEC_CALL zvec_doc_get_doc_id(const zvec_doc_t *doc); /** * @brief Get document score @@ -2814,15 +2824,16 @@ ZVEC_EXPORT uint64_t ZVEC_CALL zvec_doc_get_doc_id(const ZVecDoc *doc); * @param doc Document structure pointer * @return float Score value */ -ZVEC_EXPORT float ZVEC_CALL zvec_doc_get_score(const ZVecDoc *doc); +ZVEC_EXPORT float ZVEC_CALL zvec_doc_get_score(const zvec_doc_t *doc); /** * @brief Get document operator * * @param doc Document structure pointer - * @return ZVecDocOperator Operator + * @return zvec_doc_operator_t Operator */ -ZVEC_EXPORT ZVecDocOperator ZVEC_CALL zvec_doc_get_operator(const ZVecDoc *doc); +ZVEC_EXPORT zvec_doc_operator_t ZVEC_CALL +zvec_doc_get_operator(const zvec_doc_t *doc); /** * @brief Get document field count @@ -2830,7 +2841,7 @@ ZVEC_EXPORT ZVecDocOperator ZVEC_CALL zvec_doc_get_operator(const ZVecDoc *doc); * @param doc Document structure pointer * @return size_t Field count */ -ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_get_field_count(const ZVecDoc *doc); +ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_get_field_count(const zvec_doc_t *doc); /** * @brief Get document primary key pointer (no copy) @@ -2838,7 +2849,8 @@ ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_get_field_count(const ZVecDoc *doc); * @param doc Document object pointer * @return const char* Primary key string pointer, returns NULL if not set */ -ZVEC_EXPORT const char *ZVEC_CALL zvec_doc_get_pk_pointer(const ZVecDoc *doc); +ZVEC_EXPORT const char *ZVEC_CALL +zvec_doc_get_pk_pointer(const zvec_doc_t *doc); /** * @brief Get document primary key copy (needs manual release) @@ -2850,7 +2862,7 @@ ZVEC_EXPORT const char *ZVEC_CALL zvec_doc_get_pk_pointer(const ZVecDoc *doc); * @note The returned string is allocated by the library and must be freed * using zvec_free() when no longer needed. */ -ZVEC_EXPORT const char *ZVEC_CALL zvec_doc_get_pk_copy(const ZVecDoc *doc); +ZVEC_EXPORT const char *ZVEC_CALL zvec_doc_get_pk_copy(const zvec_doc_t *doc); /** * @brief Get field value (basic type returned directly) @@ -2865,10 +2877,10 @@ ZVEC_EXPORT const char *ZVEC_CALL zvec_doc_get_pk_copy(const ZVecDoc *doc); * @param field_type Field type (must be a basic numeric type) * @param value_buffer Output buffer to receive the value * @param buffer_size Size of the output buffer - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_basic( - const ZVecDoc *doc, const char *field_name, ZVecDataType field_type, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_doc_get_field_value_basic( + const zvec_doc_t *doc, const char *field_name, zvec_data_type_t field_type, void *value_buffer, size_t buffer_size); /** @@ -2892,10 +2904,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_basic( * @param field_type Field type * @param[out] value Returned value pointer (needs manual release) * @param[out] value_size Returned value size - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_copy( - const ZVecDoc *doc, const char *field_name, ZVecDataType field_type, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_doc_get_field_value_copy( + const zvec_doc_t *doc, const char *field_name, zvec_data_type_t field_type, void **value, size_t *value_size); /** @@ -2918,10 +2930,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_copy( * @param field_type Field type * @param[out] value Returned value pointer (points to document-internal data) * @param[out] value_size Returned value size - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_pointer( - const ZVecDoc *doc, const char *field_name, ZVecDataType field_type, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_doc_get_field_value_pointer( + const zvec_doc_t *doc, const char *field_name, zvec_data_type_t field_type, const void **value, size_t *value_size); /** @@ -2930,7 +2942,7 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_value_pointer( * @param doc Document object pointer * @return bool Returns true if document is empty, otherwise returns false */ -ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_empty(const ZVecDoc *doc); +ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_empty(const zvec_doc_t *doc); /** * @brief Check if document contains specified field @@ -2939,7 +2951,7 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_empty(const ZVecDoc *doc); * @param field_name Field name * @return bool Returns true if field exists, otherwise returns false */ -ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field(const ZVecDoc *doc, +ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field(const zvec_doc_t *doc, const char *field_name); /** @@ -2949,7 +2961,7 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field(const ZVecDoc *doc, * @param field_name Field name * @return bool Returns true if field has value, otherwise returns false */ -ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field_value(const ZVecDoc *doc, +ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field_value(const zvec_doc_t *doc, const char *field_name); /** @@ -2959,7 +2971,7 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_doc_has_field_value(const ZVecDoc *doc, * @param field_name Field name * @return bool Returns true if field is null, otherwise returns false */ -ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_field_null(const ZVecDoc *doc, +ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_field_null(const zvec_doc_t *doc, const char *field_name); /** @@ -2969,10 +2981,10 @@ ZVEC_EXPORT bool ZVEC_CALL zvec_doc_is_field_null(const ZVecDoc *doc, * @param[out] field_names * Returned field name array (needs to call zvec_free_str_array to release) * @param[out] count Returned field count - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_get_field_names( - const ZVecDoc *doc, char ***field_names, size_t *count); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL zvec_doc_get_field_names( + const zvec_doc_t *doc, char ***field_names, size_t *count); /** * @brief Release string array memory @@ -2989,11 +3001,10 @@ ZVEC_EXPORT void ZVEC_CALL zvec_free_str_array(char **array, size_t count); * @param[out] data Returned serialized data (needs to call * zvec_free_uint8_array to release) * @param[out] size Returned data size - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_serialize(const ZVecDoc *doc, - uint8_t **data, - size_t *size); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_serialize(const zvec_doc_t *doc, uint8_t **data, size_t *size); /** * @brief Deserialize document @@ -3002,11 +3013,10 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_serialize(const ZVecDoc *doc, * @param size Data size * @param[out] doc Returned document object pointer (needs to call * zvec_doc_destroy to release) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_deserialize(const uint8_t *data, - size_t size, - ZVecDoc **doc); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_deserialize(const uint8_t *data, size_t size, zvec_doc_t **doc); /** * @brief Merge two documents @@ -3014,7 +3024,8 @@ ZVEC_EXPORT ZVecErrorCode ZVEC_CALL zvec_doc_deserialize(const uint8_t *data, * @param doc Target document object pointer * @param other Source document object pointer */ -ZVEC_EXPORT void ZVEC_CALL zvec_doc_merge(ZVecDoc *doc, const ZVecDoc *other); +ZVEC_EXPORT void ZVEC_CALL zvec_doc_merge(zvec_doc_t *doc, + const zvec_doc_t *other); /** * @brief Get document memory usage @@ -3022,7 +3033,7 @@ ZVEC_EXPORT void ZVEC_CALL zvec_doc_merge(ZVecDoc *doc, const ZVecDoc *other); * @param doc Document object pointer * @return size_t Memory usage (bytes) */ -ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_memory_usage(const ZVecDoc *doc); +ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_memory_usage(const zvec_doc_t *doc); /** * @brief Validate document against Schema @@ -3031,10 +3042,10 @@ ZVEC_EXPORT size_t ZVEC_CALL zvec_doc_memory_usage(const ZVecDoc *doc); * @param schema Schema object pointer * @param is_update Whether it's an update operation * @param[out] error_msg Error message (needs manual release) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_doc_validate(const ZVecDoc *doc, const ZVecCollectionSchema *schema, +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_validate(const zvec_doc_t *doc, const zvec_collection_schema_t *schema, bool is_update, char **error_msg); /** @@ -3042,17 +3053,17 @@ zvec_doc_validate(const ZVecDoc *doc, const ZVecCollectionSchema *schema, * * @param doc Document object pointer * @param[out] detail_str Returned detailed string (needs manual release) - * @return ZVecErrorCode Error code + * @return zvec_error_code_t Error code */ -ZVEC_EXPORT ZVecErrorCode ZVEC_CALL -zvec_doc_to_detail_string(const ZVecDoc *doc, char **detail_str); +ZVEC_EXPORT zvec_error_code_t ZVEC_CALL +zvec_doc_to_detail_string(const zvec_doc_t *doc, char **detail_str); /** * @brief Free docs array memory * @param docs Document array pointer * @param count Document count */ -ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(ZVecDoc **docs, size_t count); +ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(zvec_doc_t **docs, size_t count); // ============================================================================= // Utility Functions @@ -3064,7 +3075,7 @@ ZVEC_EXPORT void ZVEC_CALL zvec_docs_free(ZVecDoc **docs, size_t count); * @return const char* Error description string */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_error_code_to_string(ZVecErrorCode error_code); +zvec_error_code_to_string(zvec_error_code_t error_code); /** * @brief Convert data type to string @@ -3072,7 +3083,7 @@ zvec_error_code_to_string(ZVecErrorCode error_code); * @return const char* Data type string */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_data_type_to_string(ZVecDataType data_type); +zvec_data_type_to_string(zvec_data_type_t data_type); /** * @brief Convert index type to string @@ -3080,14 +3091,14 @@ zvec_data_type_to_string(ZVecDataType data_type); * @return const char* Index type string */ ZVEC_EXPORT const char *ZVEC_CALL -zvec_index_type_to_string(ZVecIndexType index_type); +zvec_index_type_to_string(zvec_index_type_t index_type); /** * @brief Convert metric type to string * @param metric_type Metric type * @return const char* Metric type string */ -const char *zvec_metric_type_to_string(ZVecMetricType metric_type); +const char *zvec_metric_type_to_string(zvec_metric_type_t metric_type); // ============================================================================= // Helper Functions @@ -3103,13 +3114,13 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * * Usage example: * @code - * ZVecIndexParams params = ZVEC_HNSW_PARAMS( + * zvec_index_params_t params = ZVEC_HNSW_PARAMS( * ZVEC_METRIC_TYPE_COSINE, 16, 200, 50, ZVEC_QUANTIZE_TYPE_UNDEFINED); * @endcode */ // clang-format off #define ZVEC_HNSW_PARAMS(_metric, _m, _ef_construction, _ef_search, _quant) \ - ((ZVecIndexParams){ \ + ((zvec_index_params_t){ \ .index_type = ZVEC_INDEX_TYPE_HNSW, \ .metric_type = (_metric), \ .quantize_type = (_quant), \ @@ -3124,11 +3135,11 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * @param wildcard Whether to enable wildcard expansion * * Usage example: - * ZVecIndexParams params = ZVEC_INVERT_PARAMS(true, false); + * zvec_index_params_t params = ZVEC_INVERT_PARAMS(true, false); */ // clang-format off #define ZVEC_INVERT_PARAMS(_range_opt, _wildcard) \ - ((ZVecIndexParams){ \ + ((zvec_index_params_t){ \ .index_type = ZVEC_INDEX_TYPE_INVERT, \ .invert.enable_range_optimization = (_range_opt), \ .invert.enable_extended_wildcard = (_wildcard) }) @@ -3141,7 +3152,7 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); */ // clang-format off #define ZVEC_FLAT_PARAMS(_metric, _quant) \ - ((ZVecIndexParams){ \ + ((zvec_index_params_t){ \ .index_type = ZVEC_INDEX_TYPE_FLAT, \ .metric_type = (_metric), \ .quantize_type = (_quant) }) @@ -3158,7 +3169,7 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); */ // clang-format off #define ZVEC_IVF_PARAMS(_metric, _nlist, _niters, _soar, _nprobe, _quant) \ - ((ZVecIndexParams){ \ + ((zvec_index_params_t){ \ .index_type = ZVEC_INDEX_TYPE_IVF, \ .metric_type = (_metric), \ .quantize_type = (_quant), \ @@ -3173,10 +3184,10 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * @param str String content * * Usage example: - * ZVecString name = ZVEC_STRING("my_collection"); + * zvec_string_t name = ZVEC_STRING("my_collection"); */ #define ZVEC_STRING(str) \ - (ZVecString) { \ + (zvec_string_t) { \ .data = str, .length = strlen(str) \ } @@ -3185,10 +3196,10 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * @param str String content * * Usage example: - * ZVecStringView name = ZVEC_STRING_VIEW("my_collection"); + * zvec_string_view_t name = ZVEC_STRING_VIEW("my_collection"); */ #define ZVEC_STRING_VIEW(str) \ - (ZVecStringView) { \ + (zvec_string_view_t) { \ .data = str, .length = strlen(str) \ } @@ -3201,10 +3212,10 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * * Usage example: * float vectors[] = {0.1f, 0.2f, 0.3f}; - * ZVecFloatArray vec_array = ZVEC_FLOAT_ARRAY(vectors, 3); + * zvec_float_array_t vec_array = ZVEC_FLOAT_ARRAY(vectors, 3); */ #define ZVEC_FLOAT_ARRAY(data_ptr, len) \ - (ZVecFloatArray) { \ + (zvec_float_array_t) { \ .data = data_ptr, .length = len \ } @@ -3214,7 +3225,7 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * @param len Array length */ #define ZVEC_INT64_ARRAY(data_ptr, len) \ - (ZVecInt64Array) { \ + (zvec_int64_array_t) { \ .data = data_ptr, .length = len \ } @@ -3225,11 +3236,11 @@ const char *zvec_metric_type_to_string(ZVecMetricType metric_type); * @param value_union Field value union * * Usage example: - * ZVecDocField field = ZVEC_DOC_FIELD("id", ZVEC_DATA_TYPE_STRING, + * zvec_doc_field_t field = ZVEC_DOC_FIELD("id", ZVEC_DATA_TYPE_STRING, * {.string_value = ZVEC_STRING("doc1")}); */ #define ZVEC_DOC_FIELD(name_str, type, value_union) \ - (ZVecDocField) { \ + (zvec_doc_field_t) { \ .name = ZVEC_STRING(name_str), .data_type = type, .value = value_union \ } diff --git a/tests/c/c_api_test.c b/tests/c/c_api_test.c index ca9acb5..ec13227 100644 --- a/tests/c/c_api_test.c +++ b/tests/c/c_api_test.c @@ -36,10 +36,10 @@ // Helper function to get field count (replaces GCC-specific statement // expression) -static size_t get_field_count(ZVecCollectionSchema *schema) { +static size_t get_field_count(zvec_collection_schema_t *schema) { const char **names = NULL; size_t count = 0; - ZVecErrorCode err = + zvec_error_code_t err = zvec_collection_schema_get_all_field_names(schema, &names, &count); if (err == ZVEC_OK && names) { size_t i; @@ -141,7 +141,7 @@ void test_error_handling_functions(void) { TEST_START(); char *error_msg = NULL; - ZVecErrorCode err = zvec_get_last_error(&error_msg); + zvec_error_code_t err = zvec_get_last_error(&error_msg); TEST_ASSERT(err == ZVEC_OK); if (error_msg) { @@ -152,7 +152,7 @@ void test_error_handling_functions(void) { zvec_clear_error(); // Test error details retrieval - ZVecErrorDetails error_details = {0}; + zvec_error_details_t error_details = {0}; err = zvec_get_last_error_details(&error_details); TEST_ASSERT(err == ZVEC_OK); @@ -163,7 +163,7 @@ void test_zvec_config() { TEST_START(); // Test 1: Console log config creation and destruction - ZVecLogConfig *console_config = + zvec_log_config_t *console_config = zvec_config_log_create_console(ZVEC_LOG_LEVEL_INFO); TEST_ASSERT(console_config != NULL); if (console_config) { @@ -173,7 +173,7 @@ void test_zvec_config() { } // Test 2: File log config creation and destruction - ZVecLogConfig *file_config = zvec_config_log_create_file( + zvec_log_config_t *file_config = zvec_config_log_create_file( ZVEC_LOG_LEVEL_WARN, "./logs", "test_log", 100, 7); TEST_ASSERT(file_config != NULL); if (file_config) { @@ -187,7 +187,7 @@ void test_zvec_config() { } // Test 3: File log config edge cases - ZVecLogConfig *empty_file_config = + zvec_log_config_t *empty_file_config = zvec_config_log_create_file(ZVEC_LOG_LEVEL_INFO, "", "", 0, 0); TEST_ASSERT(empty_file_config != NULL); if (empty_file_config) { @@ -202,7 +202,7 @@ void test_zvec_config() { } // Test 4: Log config creation with console type - ZVecLogConfig *temp_console = + zvec_log_config_t *temp_console = zvec_config_log_create_console(ZVEC_LOG_LEVEL_ERROR); TEST_ASSERT(temp_console != NULL); if (temp_console) { @@ -210,7 +210,7 @@ void test_zvec_config() { } // Test 5: Log config creation with file type - ZVecLogConfig *temp_file = zvec_config_log_create_file( + zvec_log_config_t *temp_file = zvec_config_log_create_file( ZVEC_LOG_LEVEL_DEBUG, "./logs", "app", 50, 30); TEST_ASSERT(temp_file != NULL); TEST_ASSERT(zvec_config_log_get_level(temp_file) == ZVEC_LOG_LEVEL_DEBUG); @@ -222,7 +222,7 @@ void test_zvec_config() { zvec_config_log_destroy(temp_file); // Test 6: Config data creation and basic operations - ZVecConfigData *config_data = zvec_config_data_create(); + zvec_config_data_t *config_data = zvec_config_data_create(); TEST_ASSERT(config_data != NULL); if (config_data) { // Test initial values @@ -230,7 +230,7 @@ void test_zvec_config() { ZVEC_LOG_TYPE_CONSOLE); // Test memory limit setting - ZVecErrorCode err = + zvec_error_code_t err = zvec_config_data_set_memory_limit(config_data, 1024 * 1024 * 1024); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(zvec_config_data_get_memory_limit(config_data) == @@ -249,7 +249,7 @@ void test_zvec_config() { TEST_ASSERT(zvec_config_data_get_log_type(config_data) == ZVEC_LOG_TYPE_CONSOLE); - ZVecLogConfig *new_file = zvec_config_log_create_file( + zvec_log_config_t *new_file = zvec_config_log_create_file( ZVEC_LOG_LEVEL_DEBUG, "./logs", "app", 50, 30); TEST_ASSERT(new_file != NULL); zvec_config_data_set_log_config(config_data, new_file); @@ -261,7 +261,7 @@ void test_zvec_config() { // Test 7: Edge cases and error conditions // Test NULL pointer handling - ZVecErrorCode err = zvec_config_data_set_memory_limit(NULL, 1024); + zvec_error_code_t err = zvec_config_data_set_memory_limit(NULL, 1024); TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); err = zvec_config_data_set_log_config(NULL, NULL); @@ -274,7 +274,7 @@ void test_zvec_config() { TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); // Test boundary values - ZVecConfigData *boundary_config = zvec_config_data_create(); + zvec_config_data_t *boundary_config = zvec_config_data_create(); if (boundary_config) { // Test zero values err = zvec_config_data_set_memory_limit(boundary_config, 0); @@ -301,7 +301,7 @@ void test_zvec_config() { } // Test 8: Memory leak prevention - double destroy safety - ZVecConfigData *double_destroy_test = zvec_config_data_create(); + zvec_config_data_t *double_destroy_test = zvec_config_data_create(); if (double_destroy_test) { zvec_config_data_destroy(double_destroy_test); } @@ -312,12 +312,12 @@ void test_zvec_config() { void test_zvec_initialize() { TEST_START(); - ZVecConfigData *config = zvec_config_data_create(); + zvec_config_data_t *config = zvec_config_data_create(); TEST_ASSERT(config != NULL); if (config) { TEST_ASSERT(zvec_config_data_get_log_type(config) == ZVEC_LOG_TYPE_CONSOLE); } - ZVecErrorCode err = zvec_initialize(config); + zvec_error_code_t err = zvec_initialize(config); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(zvec_is_initialized()); @@ -332,7 +332,7 @@ void test_schema_basic_operations(void) { TEST_START(); // Test 1: Basic Schema creation and destruction - ZVecCollectionSchema *schema = zvec_collection_schema_create("demo"); + zvec_collection_schema_t *schema = zvec_collection_schema_create("demo"); TEST_ASSERT(schema != NULL); TEST_ASSERT(zvec_collection_schema_get_name(schema) != NULL); TEST_ASSERT(strcmp(zvec_collection_schema_get_name(schema), "demo") == 0); @@ -344,16 +344,16 @@ void test_schema_basic_operations(void) { TEST_ASSERT(initial_count == 0); // Test 3: Adding fields to schema - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT64, false, 0); - ZVecErrorCode err = zvec_collection_schema_add_field(schema, id_field); + zvec_error_code_t err = zvec_collection_schema_add_field(schema, id_field); TEST_ASSERT(err == ZVEC_OK); size_t count_after_add = get_field_count(schema); TEST_ASSERT(count_after_add == 1); // Test 4: Finding fields in schema - const ZVecFieldSchema *found_field = + const zvec_field_schema_t *found_field = zvec_collection_schema_get_field(schema, "id"); TEST_ASSERT(found_field != NULL); TEST_ASSERT(strcmp(zvec_field_schema_get_name(found_field), "id") == 0); @@ -366,7 +366,7 @@ void test_schema_basic_operations(void) { err = zvec_collection_schema_get_all_field_names(schema, &field_names, &field_count); TEST_ASSERT(err == ZVEC_OK && field_count > 0); - const ZVecFieldSchema *indexed_field = NULL; + const zvec_field_schema_t *indexed_field = NULL; if (field_count > 0) { indexed_field = zvec_collection_schema_get_field(schema, field_names[0]); } @@ -377,9 +377,9 @@ void test_schema_basic_operations(void) { zvec_free(field_names); // Test 6: Adding multiple fields (use individual add_field calls) - ZVecFieldSchema *name_field = + zvec_field_schema_t *name_field = zvec_field_schema_create("name", ZVEC_DATA_TYPE_STRING, false, 0); - ZVecFieldSchema *age_field = + zvec_field_schema_t *age_field = zvec_field_schema_create("age", ZVEC_DATA_TYPE_INT32, true, 0); err = zvec_collection_schema_add_field(schema, name_field); @@ -388,7 +388,7 @@ void test_schema_basic_operations(void) { TEST_ASSERT(err == ZVEC_OK); // Add a vector field (required for validation) - ZVecFieldSchema *vec_field = zvec_field_schema_create( + zvec_field_schema_t *vec_field = zvec_field_schema_create( "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); err = zvec_collection_schema_add_field(schema, vec_field); TEST_ASSERT(err == ZVEC_OK); @@ -397,12 +397,12 @@ void test_schema_basic_operations(void) { TEST_ASSERT(count_after_multi_add == 4); // id, name, age, embedding // Test 7: Finding newly added fields - const ZVecFieldSchema *name_found = + const zvec_field_schema_t *name_found = zvec_collection_schema_get_field(schema, "name"); TEST_ASSERT(name_found != NULL); TEST_ASSERT(strcmp(zvec_field_schema_get_name(name_found), "name") == 0); - const ZVecFieldSchema *age_found = + const zvec_field_schema_t *age_found = zvec_collection_schema_get_field(schema, "age"); TEST_ASSERT(age_found != NULL); TEST_ASSERT(strcmp(zvec_field_schema_get_name(age_found), "age") == 0); @@ -421,7 +421,7 @@ void test_schema_basic_operations(void) { TEST_ASSERT(max_doc_count == 10000); // Test 9: Schema validation - ZVecString *validation_error = NULL; + zvec_string_t *validation_error = NULL; err = zvec_collection_schema_validate(schema, &validation_error); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(validation_error == NULL); @@ -433,7 +433,7 @@ void test_schema_basic_operations(void) { size_t count_after_remove = get_field_count(schema); TEST_ASSERT(count_after_remove == 3); // id, name, embedding - const ZVecFieldSchema *removed_field = + const zvec_field_schema_t *removed_field = zvec_collection_schema_get_field(schema, "age"); TEST_ASSERT(removed_field == NULL); @@ -457,11 +457,11 @@ void test_schema_edge_cases(void) { TEST_START(); // Test 1: NULL parameter handling for schema creation - ZVecCollectionSchema *null_schema = zvec_collection_schema_create(NULL); + zvec_collection_schema_t *null_schema = zvec_collection_schema_create(NULL); TEST_ASSERT(null_schema == NULL); // Test 2: Empty string schema name - ZVecCollectionSchema *empty_schema = zvec_collection_schema_create(""); + zvec_collection_schema_t *empty_schema = zvec_collection_schema_create(""); TEST_ASSERT(empty_schema != NULL); TEST_ASSERT(zvec_collection_schema_get_name(empty_schema) != NULL); TEST_ASSERT(strcmp(zvec_collection_schema_get_name(empty_schema), "") == 0); @@ -471,14 +471,15 @@ void test_schema_edge_cases(void) { char long_name[1024]; memset(long_name, 'a', 1023); long_name[1023] = '\0'; - ZVecCollectionSchema *long_schema = zvec_collection_schema_create(long_name); + zvec_collection_schema_t *long_schema = + zvec_collection_schema_create(long_name); TEST_ASSERT(long_schema != NULL); TEST_ASSERT(zvec_collection_schema_get_name(long_schema) != NULL); TEST_ASSERT(strlen(zvec_collection_schema_get_name(long_schema)) == 1023); zvec_collection_schema_destroy(long_schema); // Test 4: NULL schema parameter handling for all functions - ZVecErrorCode err; + zvec_error_code_t err; const char **test_names = NULL; size_t test_count = 0; err = zvec_collection_schema_get_all_field_names(NULL, &test_names, @@ -486,11 +487,11 @@ void test_schema_edge_cases(void) { TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); TEST_ASSERT(test_count == 0); - const ZVecFieldSchema *null_field = + const zvec_field_schema_t *null_field = zvec_collection_schema_get_field(NULL, "test"); TEST_ASSERT(null_field == NULL); - ZVecFieldSchema *null_indexed_field = + zvec_field_schema_t *null_indexed_field = zvec_collection_schema_get_field(NULL, "test"); TEST_ASSERT(null_indexed_field == NULL); @@ -501,7 +502,7 @@ void test_schema_edge_cases(void) { err = zvec_collection_schema_set_max_doc_count_per_segment(NULL, 1000); TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); - ZVecString *null_validation_error = NULL; + zvec_string_t *null_validation_error = NULL; err = zvec_collection_schema_validate(NULL, &null_validation_error); TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); TEST_ASSERT(null_validation_error == NULL); @@ -522,7 +523,7 @@ void test_schema_edge_cases(void) { } // Test 5: Working with valid schema for edge cases - ZVecCollectionSchema *schema = zvec_collection_schema_create("edge_test"); + zvec_collection_schema_t *schema = zvec_collection_schema_create("edge_test"); TEST_ASSERT(schema != NULL); // Test 6: Adding NULL field to schema @@ -530,19 +531,19 @@ void test_schema_edge_cases(void) { TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); // Test 7: Adding field with NULL name - ZVecFieldSchema *null_name_field_schema = + zvec_field_schema_t *null_name_field_schema = zvec_field_schema_create(NULL, ZVEC_DATA_TYPE_INT32, false, 0); err = zvec_collection_schema_add_field(schema, null_name_field_schema); TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); zvec_field_schema_destroy(null_name_field_schema); // Test 8: Finding field with NULL name - const ZVecFieldSchema *null_name_field = + const zvec_field_schema_t *null_name_field = zvec_collection_schema_get_field(schema, NULL); TEST_ASSERT(null_name_field == NULL); // Test 9: Finding non-existent field - const ZVecFieldSchema *nonexistent_field = + const zvec_field_schema_t *nonexistent_field = zvec_collection_schema_get_field(schema, "nonexistent"); TEST_ASSERT(nonexistent_field == NULL); @@ -592,14 +593,14 @@ void test_schema_edge_cases(void) { TEST_ASSERT(zero_max_count == 0); // Test 19: Schema validation with empty schema - ZVecString *empty_validation_error = NULL; + zvec_string_t *empty_validation_error = NULL; err = zvec_collection_schema_validate(schema, &empty_validation_error); TEST_ASSERT(err == ZVEC_ERROR_INVALID_ARGUMENT); // Test 20: Add duplicate field names - ZVecFieldSchema *first_id = + zvec_field_schema_t *first_id = zvec_field_schema_create("duplicate_id", ZVEC_DATA_TYPE_INT64, false, 0); - ZVecFieldSchema *second_id = + zvec_field_schema_t *second_id = zvec_field_schema_create("duplicate_id", ZVEC_DATA_TYPE_STRING, false, 0); err = zvec_collection_schema_add_field(schema, first_id); @@ -622,7 +623,7 @@ void test_schema_edge_cases(void) { void test_schema_field_operations(void) { TEST_START(); - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { @@ -631,12 +632,12 @@ void test_schema_field_operations(void) { TEST_ASSERT(initial_count == 5); // Test finding non-existent field - const ZVecFieldSchema *nonexistent = + const zvec_field_schema_t *nonexistent = zvec_collection_schema_get_field(schema, "nonexistent"); TEST_ASSERT(nonexistent == NULL); // Test finding existing field - const ZVecFieldSchema *id_field = + const zvec_field_schema_t *id_field = zvec_collection_schema_get_field(schema, "id"); TEST_ASSERT(id_field != NULL); if (id_field) { @@ -654,7 +655,7 @@ void test_schema_field_operations(void) { void test_normal_schema_creation(void) { TEST_START(); - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_test_create_normal_schema(false, "test_normal", NULL, NULL, 1000); TEST_ASSERT(schema != NULL); @@ -676,7 +677,7 @@ void test_schema_with_indexes(void) { TEST_START(); // Test Schema with scalar index - ZVecCollectionSchema *scalar_index_schema = + zvec_collection_schema_t *scalar_index_schema = zvec_test_create_schema_with_scalar_index(true, true, "scalar_index_test"); TEST_ASSERT(scalar_index_schema != NULL); @@ -685,7 +686,7 @@ void test_schema_with_indexes(void) { } // Test Schema with vector index - ZVecCollectionSchema *vector_index_schema = + zvec_collection_schema_t *vector_index_schema = zvec_test_create_schema_with_vector_index(false, "vector_index_test", NULL); TEST_ASSERT(vector_index_schema != NULL); @@ -700,10 +701,11 @@ void test_schema_max_doc_count(void) { TEST_START(); // Test 1: Setting max doc count to a valid value - ZVecCollectionSchema *schema = zvec_collection_schema_create("max_doc_test"); + zvec_collection_schema_t *schema = + zvec_collection_schema_create("max_doc_test"); TEST_ASSERT(schema != NULL); - ZVecErrorCode err = + zvec_error_code_t err = zvec_collection_schema_set_max_doc_count_per_segment(schema, 1000); TEST_ASSERT(err == ZVEC_OK); @@ -745,18 +747,19 @@ void test_collection_schema_helpers(void) { TEST_START(); // Create schema with various field types - ZVecCollectionSchema *schema = zvec_collection_schema_create("helper_test"); + zvec_collection_schema_t *schema = + zvec_collection_schema_create("helper_test"); TEST_ASSERT(schema != NULL); if (schema) { // Add scalar fields - ZVecFieldSchema *int_field = + zvec_field_schema_t *int_field = zvec_field_schema_create("int_field", ZVEC_DATA_TYPE_INT32, false, 0); - ZVecFieldSchema *str_field = + zvec_field_schema_t *str_field = zvec_field_schema_create("str_field", ZVEC_DATA_TYPE_STRING, true, 0); // Add vector field - ZVecFieldSchema *vec_field = zvec_field_schema_create( + zvec_field_schema_t *vec_field = zvec_field_schema_create( "vec_field", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); zvec_collection_schema_add_field(schema, int_field); @@ -771,32 +774,32 @@ void test_collection_schema_helpers(void) { false); // Test get_forward_field (scalar field) - ZVecFieldSchema *found_int = + zvec_field_schema_t *found_int = zvec_collection_schema_get_forward_field(schema, "int_field"); TEST_ASSERT(found_int != NULL); TEST_ASSERT(zvec_field_schema_get_data_type(found_int) == ZVEC_DATA_TYPE_INT32); // get_forward_field should return NULL for vector field - ZVecFieldSchema *vec_as_forward = + zvec_field_schema_t *vec_as_forward = zvec_collection_schema_get_forward_field(schema, "vec_field"); TEST_ASSERT(vec_as_forward == NULL); // Test get_vector_field - ZVecFieldSchema *found_vec = + zvec_field_schema_t *found_vec = zvec_collection_schema_get_vector_field(schema, "vec_field"); TEST_ASSERT(found_vec != NULL); TEST_ASSERT(zvec_field_schema_is_vector_field(found_vec) == true); // get_vector_field should return NULL for scalar field - ZVecFieldSchema *int_as_vec = + zvec_field_schema_t *int_as_vec = zvec_collection_schema_get_vector_field(schema, "int_field"); TEST_ASSERT(int_as_vec == NULL); // Test get_all_field_names const char **names = NULL; size_t name_count = 0; - ZVecErrorCode err = + zvec_error_code_t err = zvec_collection_schema_get_all_field_names(schema, &names, &name_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(name_count == 3); @@ -807,7 +810,7 @@ void test_collection_schema_helpers(void) { zvec_free(names); // Test get_forward_fields - ZVecFieldSchema **forward_fields = NULL; + zvec_field_schema_t **forward_fields = NULL; size_t forward_count = 0; err = zvec_collection_schema_get_forward_fields(schema, &forward_fields, &forward_count); @@ -817,7 +820,7 @@ void test_collection_schema_helpers(void) { zvec_free(forward_fields); // Test get_vector_fields - ZVecFieldSchema **vector_fields = NULL; + zvec_field_schema_t **vector_fields = NULL; size_t vector_count = 0; err = zvec_collection_schema_get_vector_fields(schema, &vector_fields, &vector_count); @@ -832,7 +835,7 @@ void test_collection_schema_helpers(void) { TEST_ASSERT(zvec_collection_schema_has_index(schema, "vec_field") == false); // Test add_index - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); TEST_ASSERT(invert_params != NULL); @@ -855,26 +858,27 @@ void test_collection_schema_helpers(void) { void test_collection_schema_alter_field(void) { TEST_START(); - ZVecCollectionSchema *schema = zvec_collection_schema_create("alter_test"); + zvec_collection_schema_t *schema = + zvec_collection_schema_create("alter_test"); TEST_ASSERT(schema != NULL); if (schema) { // Create initial field - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create("test_field", ZVEC_DATA_TYPE_INT32, false, 0); TEST_ASSERT(field != NULL); - ZVecErrorCode err = zvec_collection_schema_add_field(schema, field); + zvec_error_code_t err = zvec_collection_schema_add_field(schema, field); TEST_ASSERT(err == ZVEC_OK); // Verify initial state - const ZVecFieldSchema *found = + const zvec_field_schema_t *found = zvec_collection_schema_get_field(schema, "test_field"); TEST_ASSERT(found != NULL); TEST_ASSERT(zvec_field_schema_is_nullable(found) == false); // Alter the field to make it nullable - ZVecFieldSchema *new_field = + zvec_field_schema_t *new_field = zvec_field_schema_create("test_field", ZVEC_DATA_TYPE_INT32, true, 0); TEST_ASSERT(new_field != NULL); @@ -907,32 +911,32 @@ void test_collection_basic_operations(void) { // Create temporary directory char temp_dir[] = "/tmp/zvec_test_collection_basic_operations"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); if (collection) { // Test collection operations - ZVecDoc *doc1 = zvec_test_create_doc(1, schema, NULL); - ZVecDoc *doc2 = zvec_test_create_doc(2, schema, NULL); - ZVecDoc *doc3 = zvec_test_create_doc(3, schema, NULL); + zvec_doc_t *doc1 = zvec_test_create_doc(1, schema, NULL); + zvec_doc_t *doc2 = zvec_test_create_doc(2, schema, NULL); + zvec_doc_t *doc3 = zvec_test_create_doc(3, schema, NULL); TEST_ASSERT(doc1 != NULL); TEST_ASSERT(doc2 != NULL); TEST_ASSERT(doc3 != NULL); if (doc1 && doc2 && doc3) { - ZVecDoc *docs[] = {doc1, doc2, doc3}; + zvec_doc_t *docs[] = {doc1, doc2, doc3}; size_t success_count, error_count; // Test insert operation - err = zvec_collection_insert(collection, (const ZVecDoc **)docs, 3, + err = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 3, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == 3); @@ -940,18 +944,20 @@ void test_collection_basic_operations(void) { // Test update operation zvec_doc_set_score(doc1, 0.95f); - ZVecDoc *update_docs[] = {doc1}; - err = zvec_collection_update(collection, (const ZVecDoc **)update_docs, - 1, &success_count, &error_count); + zvec_doc_t *update_docs[] = {doc1}; + err = + zvec_collection_update(collection, (const zvec_doc_t **)update_docs, + 1, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == 1); TEST_ASSERT(error_count == 0); // Test upsert operation zvec_doc_set_pk(doc3, "pk_3_modified"); - ZVecDoc *upsert_docs[] = {doc3}; - err = zvec_collection_upsert(collection, (const ZVecDoc **)upsert_docs, - 1, &success_count, &error_count); + zvec_doc_t *upsert_docs[] = {doc3}; + err = + zvec_collection_upsert(collection, (const zvec_doc_t **)upsert_docs, + 1, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == 1); TEST_ASSERT(error_count == 0); @@ -999,14 +1005,14 @@ void test_collection_edge_cases(void) { char temp_dir[] = "/tmp/zvec_test_collection_edge_cases"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; // Test empty name collection - ZVecErrorCode err = + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { @@ -1048,12 +1054,12 @@ void test_collection_delete_by_filter(void) { char temp_dir[] = "/tmp/zvec_test_collection_delete_by_filter"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); @@ -1087,17 +1093,17 @@ void test_collection_stats(void) { char temp_dir[] = "/tmp/zvec_test_collection_stats"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { - ZVecCollectionStats *stats = NULL; + zvec_collection_stats_t *stats = NULL; err = zvec_collection_get_stats(collection, &stats); TEST_ASSERT(err == ZVEC_OK); @@ -1128,7 +1134,7 @@ void test_field_schema_functions(void) { TEST_START(); // Test scalar field creation using API - ZVecFieldSchema *scalar_field = + zvec_field_schema_t *scalar_field = zvec_field_schema_create("test_field", ZVEC_DATA_TYPE_STRING, true, 0); TEST_ASSERT(scalar_field != NULL); if (scalar_field) { @@ -1154,7 +1160,7 @@ void test_field_schema_functions(void) { } // Test vector field creation using API - ZVecFieldSchema *vector_field = zvec_field_schema_create( + zvec_field_schema_t *vector_field = zvec_field_schema_create( "vec_field", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); TEST_ASSERT(vector_field != NULL); if (vector_field) { @@ -1175,7 +1181,7 @@ void test_field_schema_functions(void) { } // Test sparse vector field creation using API - ZVecFieldSchema *sparse_field = zvec_field_schema_create( + zvec_field_schema_t *sparse_field = zvec_field_schema_create( "sparse_field", ZVEC_DATA_TYPE_SPARSE_VECTOR_FP32, false, 0); TEST_ASSERT(sparse_field != NULL); if (sparse_field) { @@ -1193,7 +1199,7 @@ void test_field_schema_functions(void) { } // Test array field - ZVecFieldSchema *array_field = zvec_field_schema_create( + zvec_field_schema_t *array_field = zvec_field_schema_create( "array_field", ZVEC_DATA_TYPE_ARRAY_INT32, false, 0); TEST_ASSERT(array_field != NULL); if (array_field) { @@ -1206,12 +1212,12 @@ void test_field_schema_functions(void) { } // Test field with invert index - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); zvec_index_params_set_metric_type(invert_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_invert_params(invert_params, true, false); - ZVecFieldSchema *indexed_field = + zvec_field_schema_t *indexed_field = zvec_field_schema_create("indexed_field", ZVEC_DATA_TYPE_INT64, false, 0); TEST_ASSERT(indexed_field != NULL); if (indexed_field) { @@ -1226,11 +1232,12 @@ void test_field_schema_functions(void) { zvec_index_params_destroy(invert_params); // Test field with HNSW index - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 200); - ZVecFieldSchema *hnsw_field = zvec_field_schema_create( + zvec_field_schema_t *hnsw_field = zvec_field_schema_create( "hnsw_field", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); TEST_ASSERT(hnsw_field != NULL); if (hnsw_field) { @@ -1252,8 +1259,9 @@ void test_field_helper_functions(void) { TEST_START(); // Test scalar field helper functions - ZVecIndexParams *invert_params = zvec_test_create_default_invert_params(true); - ZVecFieldSchema *scalar_field = zvec_test_create_scalar_field( + zvec_index_params_t *invert_params = + zvec_test_create_default_invert_params(true); + zvec_field_schema_t *scalar_field = zvec_test_create_scalar_field( "test_scalar", ZVEC_DATA_TYPE_INT32, true, invert_params); TEST_ASSERT(scalar_field != NULL); if (scalar_field) { @@ -1266,8 +1274,8 @@ void test_field_helper_functions(void) { zvec_index_params_destroy(invert_params); // Test vector field helper functions - ZVecIndexParams *hnsw_params = zvec_test_create_default_hnsw_params(); - ZVecFieldSchema *vector_field = zvec_test_create_vector_field( + zvec_index_params_t *hnsw_params = zvec_test_create_default_hnsw_params(); + zvec_field_schema_t *vector_field = zvec_test_create_vector_field( "test_vector", ZVEC_DATA_TYPE_VECTOR_FP32, 128, false, hnsw_params); TEST_ASSERT(vector_field != NULL); if (vector_field) { @@ -1290,19 +1298,19 @@ void test_field_helper_functions(void) { void test_doc_creation(void) { TEST_START(); - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { // Test complete document creation - ZVecDoc *doc = zvec_test_create_doc(1, schema, NULL); + zvec_doc_t *doc = zvec_test_create_doc(1, schema, NULL); TEST_ASSERT(doc != NULL); if (doc) { zvec_doc_destroy(doc); } // Test null value document creation - ZVecDoc *null_doc = zvec_test_create_doc_null(2, schema, NULL); + zvec_doc_t *null_doc = zvec_test_create_doc_null(2, schema, NULL); TEST_ASSERT(null_doc != NULL); if (null_doc) { zvec_doc_destroy(null_doc); @@ -1332,7 +1340,7 @@ void test_doc_primary_key(void) { void test_doc_add_field_by_value(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); if (!doc) { @@ -1343,7 +1351,7 @@ void test_doc_add_field_by_value(void) { // Scalar types // BINARY const char *binary_data = "binary"; - ZVecErrorCode err = + zvec_error_code_t err = zvec_doc_add_field_by_value(doc, "binary_field", ZVEC_DATA_TYPE_BINARY, binary_data, strlen(binary_data)); TEST_ASSERT(err == ZVEC_OK); @@ -1508,7 +1516,7 @@ void test_doc_add_field_by_value(void) { // ARRAY_STRING - null-terminated strings const char *array_str_data[] = {"str1", "str2", "str3"}; - ZVecString *array_zvec_str[3]; + zvec_string_t *array_zvec_str[3]; for (int i = 0; i < 3; i++) { array_zvec_str[i] = zvec_string_create(array_str_data[i]); } @@ -1593,7 +1601,7 @@ void test_doc_add_field_by_value(void) { void test_doc_add_field_by_struct(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); if (!doc) { @@ -1601,8 +1609,8 @@ void test_doc_add_field_by_struct(void) { return; } - ZVecErrorCode err; - ZVecDocField field; + zvec_error_code_t err; + zvec_doc_field_t field; // Scalar types // BINARY @@ -1959,7 +1967,7 @@ void test_doc_basic_operations(void) { TEST_START(); // Create test document - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); // Test primary key operations @@ -1979,7 +1987,7 @@ void test_doc_basic_operations(void) { // Test operator operations zvec_doc_set_operator(doc, ZVEC_DOC_OP_INSERT); - ZVecDocOperator op = zvec_doc_get_operator(doc); + zvec_doc_operator_t op = zvec_doc_get_operator(doc); TEST_ASSERT(op == ZVEC_DOC_OP_INSERT); zvec_doc_destroy(doc); @@ -1990,14 +1998,14 @@ void test_doc_basic_operations(void) { void test_doc_null_field_api(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); if (!doc) { TEST_END(); return; } - ZVecErrorCode err = zvec_doc_set_field_null(doc, "nullable_field"); + zvec_error_code_t err = zvec_doc_set_field_null(doc, "nullable_field"); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(zvec_doc_has_field(doc, "nullable_field") == true); TEST_ASSERT(zvec_doc_has_field_value(doc, "nullable_field") == false); @@ -2015,17 +2023,17 @@ void test_doc_null_field_api(void) { void test_doc_get_field_value_basic(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); - ZVecErrorCode err; + zvec_error_code_t err; printf( "=== Testing zvec_doc_get_field_value_basic with all supported types " "===\n"); // BOOL type - ZVecDocField bool_field; + zvec_doc_field_t bool_field; bool_field.name.data = "bool_field"; bool_field.name.length = strlen("bool_field"); bool_field.data_type = ZVEC_DATA_TYPE_BOOL; @@ -2040,7 +2048,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(bool_result == true); // INT32 type - ZVecDocField int32_field; + zvec_doc_field_t int32_field; int32_field.name.data = "int32_field"; int32_field.name.length = strlen("int32_field"); int32_field.data_type = ZVEC_DATA_TYPE_INT32; @@ -2055,7 +2063,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(int32_result == -2147483648); // INT64 type - ZVecDocField int64_field; + zvec_doc_field_t int64_field; int64_field.name.data = "int64_field"; int64_field.name.length = strlen("int64_field"); int64_field.data_type = ZVEC_DATA_TYPE_INT64; @@ -2070,7 +2078,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(int64_result == 9223372036854775807LL); // UINT32 type - ZVecDocField uint32_field; + zvec_doc_field_t uint32_field; uint32_field.name.data = "uint32_field"; uint32_field.name.length = strlen("uint32_field"); uint32_field.data_type = ZVEC_DATA_TYPE_UINT32; @@ -2086,7 +2094,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(uint32_result == 4294967295U); // UINT64 type - ZVecDocField uint64_field; + zvec_doc_field_t uint64_field; uint64_field.name.data = "uint64_field"; uint64_field.name.length = strlen("uint64_field"); uint64_field.data_type = ZVEC_DATA_TYPE_UINT64; @@ -2102,7 +2110,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(uint64_result == 18446744073709551615ULL); // FLOAT type - ZVecDocField float_field; + zvec_doc_field_t float_field; float_field.name.data = "float_field"; float_field.name.length = strlen("float_field"); float_field.data_type = ZVEC_DATA_TYPE_FLOAT; @@ -2117,7 +2125,7 @@ void test_doc_get_field_value_basic(void) { TEST_ASSERT(fabsf(float_result - 3.14159265359f) < 1e-6f); // DOUBLE type - ZVecDocField double_field; + zvec_doc_field_t double_field; double_field.name.data = "double_field"; double_field.name.length = strlen("double_field"); double_field.data_type = ZVEC_DATA_TYPE_DOUBLE; @@ -2140,10 +2148,10 @@ void test_doc_get_field_value_basic(void) { void test_doc_get_field_value_copy(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); - ZVecErrorCode err; + zvec_error_code_t err; printf( "=== Testing zvec_doc_get_field_value_copy with all supported types " @@ -2259,7 +2267,7 @@ void test_doc_get_field_value_copy(void) { zvec_free(double_copy_result); // String and binary types - ZVecDocField string_field; + zvec_doc_field_t string_field; string_field.name.data = "string_field"; string_field.name.length = strlen("string_field"); string_field.data_type = ZVEC_DATA_TYPE_STRING; @@ -2277,7 +2285,7 @@ void test_doc_get_field_value_copy(void) { TEST_ASSERT(memcmp(string_result, "Hello, 世界!", string_size) == 0); zvec_free(string_result); - ZVecDocField binary_field; + zvec_doc_field_t binary_field; binary_field.name.data = "binary_field"; binary_field.name.length = strlen("binary_field"); binary_field.data_type = ZVEC_DATA_TYPE_BINARY; @@ -2300,7 +2308,7 @@ void test_doc_get_field_value_copy(void) { // VECTOR_FP32 type float test_vector[] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; - ZVecDocField fp32_vec_field; + zvec_doc_field_t fp32_vec_field; fp32_vec_field.name.data = "fp32_vec_field"; fp32_vec_field.name.length = strlen("fp32_vec_field"); fp32_vec_field.data_type = ZVEC_DATA_TYPE_VECTOR_FP32; @@ -2557,7 +2565,7 @@ void test_doc_get_field_value_copy(void) { // ARRAY_STRING type const char *array_str_data[] = {"str1", "str2", "str3"}; - ZVecString *array_zvec_str[3]; + zvec_string_t *array_zvec_str[3]; for (int i = 0; i < 3; i++) { array_zvec_str[i] = zvec_string_create(array_str_data[i]); } @@ -2735,13 +2743,13 @@ void test_doc_get_field_value_copy(void) { void test_doc_get_field_value_pointer(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); - ZVecErrorCode err; + zvec_error_code_t err; // Add fields for pointer testing - ZVecDocField bool_field; + zvec_doc_field_t bool_field; bool_field.name.data = "bool_field"; bool_field.name.length = strlen("bool_field"); bool_field.data_type = ZVEC_DATA_TYPE_BOOL; @@ -2749,7 +2757,7 @@ void test_doc_get_field_value_pointer(void) { err = zvec_doc_add_field_by_struct(doc, &bool_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField int32_field; + zvec_doc_field_t int32_field; int32_field.name.data = "int32_field"; int32_field.name.length = strlen("int32_field"); int32_field.data_type = ZVEC_DATA_TYPE_INT32; @@ -2757,7 +2765,7 @@ void test_doc_get_field_value_pointer(void) { err = zvec_doc_add_field_by_struct(doc, &int32_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField string_field; + zvec_doc_field_t string_field; string_field.name.data = "string_field"; string_field.name.length = strlen("string_field"); string_field.data_type = ZVEC_DATA_TYPE_STRING; @@ -2765,7 +2773,7 @@ void test_doc_get_field_value_pointer(void) { err = zvec_doc_add_field_by_struct(doc, &string_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField binary_field; + zvec_doc_field_t binary_field; binary_field.name.data = "binary_field"; binary_field.name.length = strlen("binary_field"); binary_field.data_type = ZVEC_DATA_TYPE_BINARY; @@ -2776,7 +2784,7 @@ void test_doc_get_field_value_pointer(void) { TEST_ASSERT(err == ZVEC_OK); float test_vector[] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; - ZVecDocField fp32_vec_field; + zvec_doc_field_t fp32_vec_field; fp32_vec_field.name.data = "fp32_vec_field"; fp32_vec_field.name.length = strlen("fp32_vec_field"); fp32_vec_field.data_type = ZVEC_DATA_TYPE_VECTOR_FP32; @@ -3152,13 +3160,13 @@ void test_doc_get_field_value_pointer(void) { void test_doc_field_operations(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); - ZVecErrorCode err; + zvec_error_code_t err; // Add some fields - ZVecDocField bool_field; + zvec_doc_field_t bool_field; bool_field.name.data = "bool_field"; bool_field.name.length = strlen("bool_field"); bool_field.data_type = ZVEC_DATA_TYPE_BOOL; @@ -3166,7 +3174,7 @@ void test_doc_field_operations(void) { err = zvec_doc_add_field_by_struct(doc, &bool_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField int32_field; + zvec_doc_field_t int32_field; int32_field.name.data = "int32_field"; int32_field.name.length = strlen("int32_field"); int32_field.data_type = ZVEC_DATA_TYPE_INT32; @@ -3174,7 +3182,7 @@ void test_doc_field_operations(void) { err = zvec_doc_add_field_by_struct(doc, &int32_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField string_field; + zvec_doc_field_t string_field; string_field.name.data = "string_field"; string_field.name.length = strlen("string_field"); string_field.data_type = ZVEC_DATA_TYPE_STRING; @@ -3226,18 +3234,18 @@ void test_doc_field_operations(void) { void test_doc_error_conditions(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); // Add a field for error testing - ZVecDocField bool_field; + zvec_doc_field_t bool_field; bool_field.name.data = "bool_field"; bool_field.name.length = strlen("bool_field"); bool_field.data_type = ZVEC_DATA_TYPE_BOOL; bool_field.value.bool_value = true; zvec_doc_add_field_by_struct(doc, &bool_field); - ZVecErrorCode err; + zvec_error_code_t err; const void *dummy_ptr; size_t dummy_ptr_size; int32_t int32_result; @@ -3282,13 +3290,13 @@ void test_doc_error_conditions(void) { void test_doc_serialization(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); - ZVecErrorCode err; + zvec_error_code_t err; // Add fields for serialization testing - ZVecDocField int32_field; + zvec_doc_field_t int32_field; int32_field.name.data = "int32_field"; int32_field.name.length = strlen("int32_field"); int32_field.data_type = ZVEC_DATA_TYPE_INT32; @@ -3296,7 +3304,7 @@ void test_doc_serialization(void) { err = zvec_doc_add_field_by_struct(doc, &int32_field); TEST_ASSERT(err == ZVEC_OK); - ZVecDocField string_field; + zvec_doc_field_t string_field; string_field.name.data = "string_field"; string_field.name.length = strlen("string_field"); string_field.data_type = ZVEC_DATA_TYPE_STRING; @@ -3313,7 +3321,7 @@ void test_doc_serialization(void) { TEST_ASSERT(serialized_data != NULL); TEST_ASSERT(data_size > 0); - ZVecDoc *deserialized_doc; + zvec_doc_t *deserialized_doc; err = zvec_doc_deserialize(serialized_data, data_size, &deserialized_doc); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(deserialized_doc != NULL); @@ -3347,21 +3355,22 @@ void test_index_params(void) { TEST_START(); // Test HNSW parameter creation - ZVecIndexParams *hnsw_params = zvec_test_create_default_hnsw_params(); + zvec_index_params_t *hnsw_params = zvec_test_create_default_hnsw_params(); TEST_ASSERT(hnsw_params != NULL); if (hnsw_params) { zvec_free(hnsw_params); } // Test Flat parameter creation - ZVecIndexParams *flat_params = zvec_test_create_default_flat_params(); + zvec_index_params_t *flat_params = zvec_test_create_default_flat_params(); TEST_ASSERT(flat_params != NULL); if (flat_params) { zvec_free(flat_params); } // Test scalar index parameter creation - ZVecIndexParams *invert_params = zvec_test_create_default_invert_params(true); + zvec_index_params_t *invert_params = + zvec_test_create_default_invert_params(true); TEST_ASSERT(invert_params != NULL); if (invert_params) { zvec_free(invert_params); @@ -3377,13 +3386,13 @@ void test_zvec_string_functions(void) { TEST_START(); // Test string creation and basic operations - ZVecString *str1 = zvec_string_create("Hello World"); + zvec_string_t *str1 = zvec_string_create("Hello World"); TEST_ASSERT(str1 != NULL); TEST_ASSERT(zvec_string_length(str1) == 11); TEST_ASSERT(strcmp(zvec_string_c_str(str1), "Hello World") == 0); // Test string copy - ZVecString *str2 = zvec_string_copy(str1); + zvec_string_t *str2 = zvec_string_copy(str1); TEST_ASSERT(str2 != NULL); TEST_ASSERT(zvec_string_length(str2) == 11); TEST_ASSERT(strcmp(zvec_string_c_str(str2), "Hello World") == 0); @@ -3392,20 +3401,20 @@ void test_zvec_string_functions(void) { int cmp_result = zvec_string_compare(str1, str2); TEST_ASSERT(cmp_result == 0); - ZVecString *str3 = zvec_string_create("Hello"); + zvec_string_t *str3 = zvec_string_create("Hello"); TEST_ASSERT(zvec_string_compare(str1, str3) > 0); // Test string creation from view - ZVecStringView view = {"Hello View", 10}; - ZVecString *str4 = zvec_string_create_from_view(&view); + zvec_string_view_t view = {"Hello View", 10}; + zvec_string_t *str4 = zvec_string_create_from_view(&view); TEST_ASSERT(str4 != NULL); TEST_ASSERT(zvec_string_length(str4) == 10); TEST_ASSERT(strcmp(zvec_string_c_str(str4), "Hello View") == 0); // Test string view with embedded null bytes char binary_data[] = {'H', 'e', 'l', 'l', 'o', '\0', 'W', 'o', 'r', 'l', 'd'}; - ZVecStringView binary_view = {binary_data, 11}; - ZVecString *str5 = zvec_string_create_from_view(&binary_view); + zvec_string_view_t binary_view = {binary_data, 11}; + zvec_string_t *str5 = zvec_string_create_from_view(&binary_view); TEST_ASSERT(str5 != NULL); TEST_ASSERT(zvec_string_length(str5) == 11); // Note: strcmp will stop at first null byte, so we need to compare manually @@ -3426,7 +3435,8 @@ void test_index_params_functions(void) { // Test index params with new opaque pointer API // Test HNSW params - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); TEST_ASSERT(zvec_index_params_get_type(hnsw_params) == ZVEC_INDEX_TYPE_HNSW); // Default metric type is L2, need to set it explicitly @@ -3441,7 +3451,7 @@ void test_index_params_functions(void) { TEST_ASSERT(ef_construction == 500); // Test invert index params - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); TEST_ASSERT(invert_params != NULL); TEST_ASSERT(zvec_index_params_get_type(invert_params) == @@ -3454,7 +3464,8 @@ void test_index_params_functions(void) { TEST_ASSERT(enable_wildcard == false); // Default is false // Test flat index params - ZVecIndexParams *flat_params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); + zvec_index_params_t *flat_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); TEST_ASSERT(flat_params != NULL); TEST_ASSERT(zvec_index_params_get_type(flat_params) == ZVEC_INDEX_TYPE_FLAT); // Default metric type is L2, need to set it explicitly @@ -3463,7 +3474,8 @@ void test_index_params_functions(void) { ZVEC_METRIC_TYPE_IP); // Test IVF index params - ZVecIndexParams *ivf_params = zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); + zvec_index_params_t *ivf_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(ivf_params != NULL); TEST_ASSERT(zvec_index_params_get_type(ivf_params) == ZVEC_INDEX_TYPE_IVF); // Default metric type is L2 @@ -3490,7 +3502,8 @@ void test_index_params_api_functions(void) { TEST_START(); // Test zvec_index_params_create for HNSW - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); TEST_ASSERT(zvec_index_params_get_type(hnsw_params) == ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(zvec_index_params_get_metric_type(hnsw_params) == @@ -3510,7 +3523,8 @@ void test_index_params_api_functions(void) { TEST_ASSERT(ef_construction == 300); // Test zvec_index_params_create for IVF - ZVecIndexParams *ivf_params = zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); + zvec_index_params_t *ivf_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(ivf_params != NULL); TEST_ASSERT(zvec_index_params_get_type(ivf_params) == ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(zvec_index_params_get_metric_type(ivf_params) == @@ -3526,7 +3540,7 @@ void test_index_params_api_functions(void) { TEST_ASSERT(use_soar == true); // Test zvec_index_params_create for INVERT - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); TEST_ASSERT(invert_params != NULL); TEST_ASSERT(zvec_index_params_get_type(invert_params) == @@ -3541,7 +3555,8 @@ void test_index_params_api_functions(void) { TEST_ASSERT(enable_wildcard == true); // Test zvec_index_params_create for FLAT - ZVecIndexParams *flat_params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); + zvec_index_params_t *flat_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); TEST_ASSERT(flat_params != NULL); TEST_ASSERT(zvec_index_params_get_type(flat_params) == ZVEC_INDEX_TYPE_FLAT); zvec_index_params_set_metric_type(flat_params, ZVEC_METRIC_TYPE_IP); @@ -3591,7 +3606,7 @@ void test_memory_management_functions(void) { TEST_START(); // Test string allocation and deallocation - ZVecString *str = zvec_string_create("Test String"); + zvec_string_t *str = zvec_string_create("Test String"); TEST_ASSERT(str != NULL); zvec_free_string(str); @@ -3606,19 +3621,21 @@ void test_query_params_functions(void) { TEST_START(); // Test HNSW query parameters - ZVecHnswQueryParams *hnsw_params = + zvec_hnsw_query_params_t *hnsw_params = zvec_query_params_hnsw_create(50, 0.5f, false, true); TEST_ASSERT(hnsw_params != NULL); // Test IVF query parameters - ZVecIVFQueryParams *ivf_params = zvec_query_params_ivf_create(10, true, 1.5f); + zvec_ivf_query_params_t *ivf_params = + zvec_query_params_ivf_create(10, true, 1.5f); TEST_ASSERT(ivf_params != NULL); // Test Flat query parameters - ZVecFlatQueryParams *flat_params = zvec_query_params_flat_create(false, 2.0f); + zvec_flat_query_params_t *flat_params = + zvec_query_params_flat_create(false, 2.0f); TEST_ASSERT(flat_params != NULL); - ZVecErrorCode err; + zvec_error_code_t err; // Test HNSW-specific parameters err = zvec_query_params_hnsw_set_ef(hnsw_params, 75); @@ -3723,17 +3740,17 @@ void test_collection_stats_functions(void) { char temp_dir[] = "/tmp/zvec_test_collection_stats_functions"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { - ZVecCollectionStats *stats = NULL; + zvec_collection_stats_t *stats = NULL; // Test normal statistics retrieval err = zvec_collection_get_stats(collection, &stats); @@ -3770,12 +3787,12 @@ void test_collection_dml_functions(void) { char temp_dir[] = "/tmp/zvec_test_collection_dml"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); @@ -3794,14 +3811,14 @@ void test_collection_dml_functions(void) { TEST_ASSERT(err != ZVEC_OK); // Test zero document count - ZVecDoc *empty_docs[1]; - err = zvec_collection_insert(collection, (const ZVecDoc **)empty_docs, 0, - &success_count, &error_count); + zvec_doc_t *empty_docs[1]; + err = zvec_collection_insert(collection, (const zvec_doc_t **)empty_docs, + 0, &success_count, &error_count); TEST_ASSERT(err != ZVEC_OK); // Test NULL count pointer - err = zvec_collection_insert(collection, (const ZVecDoc **)empty_docs, 1, - NULL, &error_count); + err = zvec_collection_insert(collection, (const zvec_doc_t **)empty_docs, + 1, NULL, &error_count); TEST_ASSERT(err != ZVEC_OK); // Test update function boundary cases @@ -3812,8 +3829,8 @@ void test_collection_dml_functions(void) { &error_count); TEST_ASSERT(err != ZVEC_OK); - err = zvec_collection_update(collection, (const ZVecDoc **)empty_docs, 0, - NULL, &error_count); + err = zvec_collection_update(collection, (const zvec_doc_t **)empty_docs, + 0, NULL, &error_count); TEST_ASSERT(err != ZVEC_OK); // Test upsert function boundary cases @@ -3824,8 +3841,8 @@ void test_collection_dml_functions(void) { &error_count); TEST_ASSERT(err != ZVEC_OK); - err = zvec_collection_upsert(collection, (const ZVecDoc **)empty_docs, 0, - NULL, &error_count); + err = zvec_collection_upsert(collection, (const zvec_doc_t **)empty_docs, + 0, NULL, &error_count); TEST_ASSERT(err != ZVEC_OK); // Test deletion function boundary cases @@ -3848,16 +3865,16 @@ void test_collection_dml_functions(void) { TEST_ASSERT(err != ZVEC_OK); // Test detailed DML result APIs - ZVecDoc *result_doc = zvec_test_create_doc(101, schema, NULL); + zvec_doc_t *result_doc = zvec_test_create_doc(101, schema, NULL); TEST_ASSERT(result_doc != NULL); if (result_doc) { - ZVecDoc *result_docs[] = {result_doc}; - ZVecWriteResult *results = NULL; + zvec_doc_t *result_docs[] = {result_doc}; + zvec_write_result_t *results = NULL; size_t result_count = 0; - err = zvec_collection_upsert_with_results(collection, - (const ZVecDoc **)result_docs, - 1, &results, &result_count); + err = zvec_collection_upsert_with_results( + collection, (const zvec_doc_t **)result_docs, 1, &results, + &result_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(result_count == 1); if (results && result_count == 1) { @@ -3897,21 +3914,21 @@ void test_collection_nullable_roundtrip(void) { char temp_dir[] = "/tmp/zvec_test_collection_nullable_roundtrip"; zvec_test_delete_dir(temp_dir); - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (!schema) { TEST_END(); return; } - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); if (collection) { - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); if (doc) { zvec_doc_set_pk(doc, "pk_nullable"); @@ -3953,17 +3970,17 @@ void test_collection_nullable_roundtrip(void) { sparse_buffer, sizeof(sparse_buffer)); TEST_ASSERT(err == ZVEC_OK); - ZVecDoc *docs[] = {doc}; + zvec_doc_t *docs[] = {doc}; size_t success_count = 0; size_t error_count = 0; - err = zvec_collection_upsert(collection, (const ZVecDoc **)docs, 1, + err = zvec_collection_upsert(collection, (const zvec_doc_t **)docs, 1, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == 1); TEST_ASSERT(error_count == 0); const char *pks[] = {"pk_nullable"}; - ZVecDoc **fetched = NULL; + zvec_doc_t **fetched = NULL; size_t fetched_count = 0; err = zvec_collection_fetch(collection, pks, 1, &fetched, &fetched_count); TEST_ASSERT(err == ZVEC_OK); @@ -3996,29 +4013,30 @@ void test_actual_vector_queries(void) { char temp_dir[] = "/tmp/zvec_test_actual_queries"; // Create schema with vector field - ZVecCollectionSchema *schema = zvec_collection_schema_create("query_test"); + zvec_collection_schema_t *schema = + zvec_collection_schema_create("query_test"); TEST_ASSERT(schema != NULL); if (schema) { // Add ID field - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT64, false, 0); zvec_collection_schema_add_field(schema, id_field); // Add vector field with HNSW index - ZVecIndexParams *hnsw_params = + zvec_index_params_t *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 100); - ZVecFieldSchema *vec_field = zvec_field_schema_create( + zvec_field_schema_t *vec_field = zvec_field_schema_create( "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, false, 4); zvec_field_schema_set_index_params(vec_field, hnsw_params); zvec_collection_schema_add_field(schema, vec_field); zvec_index_params_destroy(hnsw_params); - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); @@ -4030,7 +4048,7 @@ void test_actual_vector_queries(void) { float vec3[] = {0.0f, 0.0f, 1.0f, 0.0f}; float vec4[] = {0.7f, 0.7f, 0.0f, 0.0f}; // Similar to vec1 and vec2 - ZVecDoc *docs[4]; + zvec_doc_t *docs[4]; for (int i = 0; i < 4; i++) { docs[i] = zvec_doc_create(); zvec_doc_set_pk(docs[i], zvec_test_make_pk(i + 1)); @@ -4048,7 +4066,7 @@ void test_actual_vector_queries(void) { docs[3], "embedding", ZVEC_DATA_TYPE_VECTOR_FP32, vec4, sizeof(vec4)); size_t success_count, error_count; - err = zvec_collection_insert(collection, (const ZVecDoc **)docs, 4, + err = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 4, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == 4); @@ -4058,7 +4076,7 @@ void test_actual_vector_queries(void) { zvec_collection_flush(collection); // Test 1: Basic vector search - ZVecVectorQuery *query1 = zvec_vector_query_create(); + zvec_vector_query_t *query1 = zvec_vector_query_create(); TEST_ASSERT(query1 != NULL); zvec_vector_query_set_field_name(query1, "embedding"); zvec_vector_query_set_query_vector(query1, vec1, sizeof(vec1)); @@ -4066,7 +4084,7 @@ void test_actual_vector_queries(void) { zvec_vector_query_set_include_vector(query1, true); zvec_vector_query_set_include_doc_id(query1, true); - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; err = zvec_collection_query(collection, query1, &results, &result_count); TEST_ASSERT(err == ZVEC_OK); @@ -4120,19 +4138,19 @@ void test_index_creation_and_management(void) { char temp_dir[] = "/tmp/zvec_test_index_management"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); if (collection) { // Test 1: Create HNSW index - ZVecIndexParams *hnsw_params = + zvec_index_params_t *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_COSINE); @@ -4142,7 +4160,7 @@ void test_index_creation_and_management(void) { TEST_ASSERT(err == ZVEC_OK); // Test 2: Create scalar index - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); TEST_ASSERT(invert_params != NULL); zvec_index_params_set_invert_params(invert_params, true, false); @@ -4176,21 +4194,21 @@ void test_collection_ddl_operations(void) { char temp_dir[] = "/tmp/zvec_test_collection_ddl"; - ZVecCollectionSchema *schema = zvec_test_create_temp_schema(); + zvec_collection_schema_t *schema = zvec_test_create_temp_schema(); TEST_ASSERT(schema != NULL); size_t field_count = get_field_count(schema); if (schema) { - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); if (collection) { // Test 1: Add new column - ZVecFieldSchema *new_field = + zvec_field_schema_t *new_field = zvec_field_schema_create("new_int32", ZVEC_DATA_TYPE_INT32, true, 0); TEST_ASSERT(new_field != NULL); @@ -4198,7 +4216,7 @@ void test_collection_ddl_operations(void) { TEST_ASSERT(err == ZVEC_OK); // Test 2: Get collection schema and verify field count - ZVecCollectionSchema *retrieved_schema = NULL; + zvec_collection_schema_t *retrieved_schema = NULL; err = zvec_collection_get_schema(collection, &retrieved_schema); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(retrieved_schema != NULL); @@ -4207,7 +4225,7 @@ void test_collection_ddl_operations(void) { TEST_ASSERT((field_count + 1) == new_field_count); // Test 3: Alter column - ZVecFieldSchema *alter_field = + zvec_field_schema_t *alter_field = zvec_field_schema_create("new_float", ZVEC_DATA_TYPE_FLOAT, true, 0); TEST_ASSERT(alter_field != NULL); @@ -4245,7 +4263,7 @@ void test_field_ddl_operations(void) { TEST_START(); // Test field schema creation with various configurations - ZVecFieldSchema *field1 = + zvec_field_schema_t *field1 = zvec_field_schema_create("test_field1", ZVEC_DATA_TYPE_STRING, false, 0); TEST_ASSERT(field1 != NULL); TEST_ASSERT(strcmp(zvec_field_schema_get_name(field1), "test_field1") == 0); @@ -4253,7 +4271,7 @@ void test_field_ddl_operations(void) { TEST_ASSERT(zvec_field_schema_is_nullable(field1) == false); TEST_ASSERT(zvec_field_schema_get_dimension(field1) == 0); - ZVecFieldSchema *field2 = zvec_field_schema_create( + zvec_field_schema_t *field2 = zvec_field_schema_create( "test_field2", ZVEC_DATA_TYPE_VECTOR_FP32, true, 128); TEST_ASSERT(field2 != NULL); TEST_ASSERT(zvec_field_schema_get_data_type(field2) == @@ -4262,12 +4280,14 @@ void test_field_ddl_operations(void) { TEST_ASSERT(zvec_field_schema_get_dimension(field2) == 128); // Test index parameter setting - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 100); - ZVecErrorCode err = zvec_field_schema_set_index_params(field2, hnsw_params); + zvec_error_code_t err = + zvec_field_schema_set_index_params(field2, hnsw_params); TEST_ASSERT(err == ZVEC_OK); // Cleanup @@ -4283,26 +4303,26 @@ void test_performance_benchmarks(void) { char temp_dir[] = "/tmp/zvec_test_performance"; - ZVecCollectionSchema *schema = zvec_collection_schema_create("perf_test"); + zvec_collection_schema_t *schema = zvec_collection_schema_create("perf_test"); TEST_ASSERT(schema != NULL); if (schema) { // Create simple schema for performance testing - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT64, false, 0); zvec_collection_schema_add_field(schema, id_field); - ZVecFieldSchema *vec_field = + zvec_field_schema_t *vec_field = zvec_field_schema_create("vec", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); - ZVecIndexParams *hnsw_params = + zvec_index_params_t *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 100); zvec_field_schema_set_index_params(vec_field, hnsw_params); zvec_collection_schema_add_field(schema, vec_field); - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); @@ -4323,8 +4343,8 @@ void test_performance_benchmarks(void) { for (size_t batch_start = 0; batch_start < TOTAL_DOCS; batch_start += BATCH_SIZE) { // Use dynamic allocation for MSVC compatibility (no VLA support) - ZVecDoc **batch_docs = - (ZVecDoc **)malloc(BATCH_SIZE * sizeof(ZVecDoc *)); + zvec_doc_t **batch_docs = + (zvec_doc_t **)malloc(BATCH_SIZE * sizeof(zvec_doc_t *)); if (!batch_docs) { fprintf(stderr, "Failed to allocate batch documents\n"); break; @@ -4354,9 +4374,9 @@ void test_performance_benchmarks(void) { // Insert batch size_t success_count, error_count; - err = zvec_collection_insert(collection, (const ZVecDoc **)batch_docs, - current_batch_size, &success_count, - &error_count); + err = zvec_collection_insert( + collection, (const zvec_doc_t **)batch_docs, current_batch_size, + &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(success_count == current_batch_size); TEST_ASSERT(error_count == 0); @@ -4389,7 +4409,7 @@ void test_performance_benchmarks(void) { query_vec[i] = (float)rand() / RAND_MAX; } - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); TEST_ASSERT(query != NULL); zvec_vector_query_set_field_name(query, "vec"); zvec_vector_query_set_query_vector(query, query_vec, sizeof(query_vec)); @@ -4406,7 +4426,7 @@ void test_performance_benchmarks(void) { #endif for (int q = 0; q < QUERY_COUNT; q++) { - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; err = zvec_collection_query(collection, query, &results, &result_count); @@ -4451,11 +4471,11 @@ void test_zvec_shutdown(void) { TEST_START(); // Test shutdown - ZVecErrorCode err = zvec_shutdown(); + zvec_error_code_t err = zvec_shutdown(); TEST_ASSERT(err == ZVEC_OK); // Re-initialize for other tests - ZVecConfigData *config = zvec_config_data_create(); + zvec_config_data_t *config = zvec_config_data_create(); TEST_ASSERT(config != NULL); err = zvec_initialize(config); TEST_ASSERT(err == ZVEC_OK); @@ -4468,7 +4488,8 @@ void test_index_params_creation_functions(void) { TEST_START(); // Test HNSW parameters using new API - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); TEST_ASSERT(zvec_index_params_get_type(hnsw_params) == ZVEC_INDEX_TYPE_HNSW); // Default metric type is L2 @@ -4484,7 +4505,8 @@ void test_index_params_creation_functions(void) { TEST_ASSERT(ef_construction == 100); // Test IVF parameters using new API - ZVecIndexParams *ivf_params = zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); + zvec_index_params_t *ivf_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(ivf_params != NULL); TEST_ASSERT(zvec_index_params_get_type(ivf_params) == ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(zvec_index_params_get_metric_type(ivf_params) == @@ -4499,7 +4521,8 @@ void test_index_params_creation_functions(void) { TEST_ASSERT(use_soar == true); // Test Flat parameters using new API - ZVecIndexParams *flat_params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); + zvec_index_params_t *flat_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); TEST_ASSERT(flat_params != NULL); TEST_ASSERT(zvec_index_params_get_type(flat_params) == ZVEC_INDEX_TYPE_FLAT); zvec_index_params_set_metric_type(flat_params, ZVEC_METRIC_TYPE_IP); @@ -4507,7 +4530,7 @@ void test_index_params_creation_functions(void) { ZVEC_METRIC_TYPE_IP); // Test Invert parameters using new API - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); TEST_ASSERT(invert_params != NULL); TEST_ASSERT(zvec_index_params_get_type(invert_params) == @@ -4535,31 +4558,30 @@ void test_collection_advanced_index_functions(void) { zvec_test_delete_dir(temp_dir); // Create schema - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("test_collection"); TEST_ASSERT(schema != NULL); if (schema) { // Add fields - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT64, false, 0); - ZVecFieldSchema *vec_field = + zvec_field_schema_t *vec_field = zvec_field_schema_create("vec", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); zvec_collection_schema_add_field(schema, id_field); zvec_collection_schema_add_field(schema, vec_field); - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); TEST_ASSERT(options != NULL); - zvec_collection_options_set_max_doc_count_per_segment(options, 1000); - ZVecCollection *collection = NULL; + zvec_collection_t *collection = NULL; - ZVecErrorCode err = + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, options, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { // Test zvec_collection_create_index with FLAT type - ZVecIndexParams *flat_params = + zvec_index_params_t *flat_params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); TEST_ASSERT(flat_params != NULL); zvec_index_params_set_metric_type(flat_params, ZVEC_METRIC_TYPE_L2); @@ -4567,7 +4589,7 @@ void test_collection_advanced_index_functions(void) { TEST_ASSERT(err == ZVEC_OK); // Test zvec_collection_create_index with IVF type - ZVecIndexParams *ivf_params = + zvec_index_params_t *ivf_params = zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(ivf_params != NULL); zvec_index_params_set_metric_type(ivf_params, ZVEC_METRIC_TYPE_L2); @@ -4579,7 +4601,7 @@ void test_collection_advanced_index_functions(void) { TEST_ASSERT(err == ZVEC_OK); // Test zvec_collection_create_index with HNSW type - ZVecIndexParams *hnsw_params = + zvec_index_params_t *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_COSINE); @@ -4591,10 +4613,10 @@ void test_collection_advanced_index_functions(void) { TEST_ASSERT(err == ZVEC_OK); // Test zvec_field_schema_set_index_params - ZVecFieldSchema *new_vec_field = zvec_field_schema_create( + zvec_field_schema_t *new_vec_field = zvec_field_schema_create( "vec2", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); TEST_ASSERT(new_vec_field != NULL); - ZVecIndexParams *ivf_params2 = + zvec_index_params_t *ivf_params2 = zvec_index_params_create(ZVEC_INDEX_TYPE_IVF); TEST_ASSERT(ivf_params2 != NULL); zvec_index_params_set_metric_type(ivf_params2, ZVEC_METRIC_TYPE_IP); @@ -4624,15 +4646,17 @@ void test_collection_query_functions(void) { zvec_test_delete_dir(temp_dir); // Create schema and collection - ZVecCollectionSchema *schema = zvec_collection_schema_create("query_test"); - ZVecIndexParams *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); + zvec_collection_schema_t *schema = + zvec_collection_schema_create("query_test"); + zvec_index_params_t *hnsw_params = + zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); TEST_ASSERT(hnsw_params != NULL); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 100); - ZVecFieldSchema *name_field = + zvec_field_schema_t *name_field = zvec_field_schema_create("name", ZVEC_DATA_TYPE_STRING, false, 0); - ZVecFieldSchema *vec_field = + zvec_field_schema_t *vec_field = zvec_field_schema_create("vec", ZVEC_DATA_TYPE_VECTOR_FP32, false, 4); zvec_field_schema_set_index_params(vec_field, hnsw_params); zvec_index_params_destroy(hnsw_params); @@ -4640,14 +4664,14 @@ void test_collection_query_functions(void) { zvec_collection_schema_add_field(schema, name_field); zvec_collection_schema_add_field(schema, vec_field); - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { // Insert test documents - ZVecDoc *doc1 = zvec_doc_create(); + zvec_doc_t *doc1 = zvec_doc_create(); zvec_doc_set_pk(doc1, "doc1"); float vec1[4] = {1.0f, 0.0f, 0.0f, 0.0f}; zvec_doc_add_field_by_value(doc1, "vec", ZVEC_DATA_TYPE_VECTOR_FP32, vec1, @@ -4655,7 +4679,7 @@ void test_collection_query_functions(void) { zvec_doc_add_field_by_value(doc1, "name", ZVEC_DATA_TYPE_STRING, "document1", 9); - ZVecDoc *doc2 = zvec_doc_create(); + zvec_doc_t *doc2 = zvec_doc_create(); zvec_doc_set_pk(doc2, "doc2"); float vec2[4] = {0.0f, 1.0f, 0.0f, 0.0f}; zvec_doc_add_field_by_value(doc2, "vec", ZVEC_DATA_TYPE_VECTOR_FP32, vec2, @@ -4663,9 +4687,9 @@ void test_collection_query_functions(void) { zvec_doc_add_field_by_value(doc2, "name", ZVEC_DATA_TYPE_STRING, "document2", 9); - ZVecDoc *docs[] = {doc1, doc2}; + zvec_doc_t *docs[] = {doc1, doc2}; size_t success_count, error_count; - err = zvec_collection_insert(collection, (const ZVecDoc **)docs, 2, + err = zvec_collection_insert(collection, (const zvec_doc_t **)docs, 2, &success_count, &error_count); TEST_ASSERT(err == ZVEC_OK); @@ -4674,7 +4698,7 @@ void test_collection_query_functions(void) { // Test zvec_collection_fetch const char *pks[] = {"doc1", "doc2"}; - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t found_count = 0; err = zvec_collection_fetch(collection, pks, 2, &results, &found_count); TEST_ASSERT(err == ZVEC_OK); @@ -4682,7 +4706,7 @@ void test_collection_query_functions(void) { zvec_docs_free(results, found_count); // Test zvec_collection_get_options - ZVecCollectionOptions *options = NULL; + zvec_collection_options_t *options = NULL; err = zvec_collection_get_options(collection, &options); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(options != NULL); @@ -4703,7 +4727,7 @@ void test_doc_advanced_functions(void) { TEST_START(); // Test zvec_doc_clear - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); zvec_doc_set_pk(doc, "test_pk"); zvec_doc_add_field_by_value(doc, "field1", ZVEC_DATA_TYPE_INT32, &(int32_t){100}, sizeof(int32_t)); @@ -4719,7 +4743,7 @@ void test_doc_advanced_functions(void) { zvec_free((void *)pk_copy); // Test zvec_doc_is_empty - ZVecDoc *empty_doc = zvec_doc_create(); + zvec_doc_t *empty_doc = zvec_doc_create(); TEST_ASSERT(zvec_doc_is_empty(empty_doc) == true); zvec_doc_add_field_by_value(empty_doc, "test", ZVEC_DATA_TYPE_INT32, &(int32_t){1}, sizeof(int32_t)); @@ -4727,7 +4751,7 @@ void test_doc_advanced_functions(void) { zvec_doc_destroy(empty_doc); // Test zvec_doc_memory_usage - ZVecDoc *mem_doc = zvec_doc_create(); + zvec_doc_t *mem_doc = zvec_doc_create(); zvec_doc_set_pk(mem_doc, "memory_test"); char large_data[1024]; memset(large_data, 'A', sizeof(large_data)); @@ -4738,12 +4762,12 @@ void test_doc_advanced_functions(void) { zvec_doc_destroy(mem_doc); // Test zvec_doc_merge - ZVecDoc *doc1 = zvec_doc_create(); + zvec_doc_t *doc1 = zvec_doc_create(); zvec_doc_set_pk(doc1, "merge_test"); zvec_doc_add_field_by_value(doc1, "field1", ZVEC_DATA_TYPE_INT32, &(int32_t){100}, sizeof(int32_t)); - ZVecDoc *doc2 = zvec_doc_create(); + zvec_doc_t *doc2 = zvec_doc_create(); zvec_doc_add_field_by_value(doc2, "field2", ZVEC_DATA_TYPE_STRING, "merged", 6); @@ -4755,18 +4779,19 @@ void test_doc_advanced_functions(void) { zvec_doc_destroy(doc2); // Test zvec_doc_validate - ZVecCollectionSchema *schema = zvec_collection_schema_create("validate_test"); - ZVecFieldSchema *val_field = + zvec_collection_schema_t *schema = + zvec_collection_schema_create("validate_test"); + zvec_field_schema_t *val_field = zvec_field_schema_create("test_field", ZVEC_DATA_TYPE_INT32, false, 0); zvec_collection_schema_add_field(schema, val_field); - ZVecDoc *val_doc = zvec_doc_create(); + zvec_doc_t *val_doc = zvec_doc_create(); zvec_doc_set_pk(val_doc, "test_pk"); zvec_doc_add_field_by_value(val_doc, "test_field", ZVEC_DATA_TYPE_INT32, &(int32_t){42}, sizeof(int32_t)); char *error_msg = NULL; - ZVecErrorCode err = zvec_doc_validate(val_doc, schema, false, &error_msg); + zvec_error_code_t err = zvec_doc_validate(val_doc, schema, false, &error_msg); TEST_ASSERT(err == ZVEC_OK); if (error_msg) { zvec_free(error_msg); @@ -4777,7 +4802,7 @@ void test_doc_advanced_functions(void) { zvec_doc_destroy(doc); // Test zvec_doc_to_detail_string - ZVecDoc *detail_doc = zvec_doc_create(); + zvec_doc_t *detail_doc = zvec_doc_create(); zvec_doc_set_pk(detail_doc, "detail_test"); zvec_doc_add_field_by_value(detail_doc, "int_field", ZVEC_DATA_TYPE_INT32, &(int32_t){12345}, sizeof(int32_t)); @@ -4799,8 +4824,8 @@ void test_doc_advanced_functions(void) { void test_array_memory_functions(void) { TEST_START(); - // Test ZVecStringArray - ZVecStringArray *str_array = zvec_string_array_create(3); + // Test zvec_string_array_t + zvec_string_array_t *str_array = zvec_string_array_create(3); TEST_ASSERT(str_array != NULL); if (str_array) { TEST_ASSERT(str_array->count == 3); @@ -4818,8 +4843,8 @@ void test_array_memory_functions(void) { zvec_string_array_destroy(str_array); } - // Test ZVecMutableByteArray - ZVecMutableByteArray *byte_array = zvec_byte_array_create(1024); + // Test zvec_mutable_byte_array_t + zvec_mutable_byte_array_t *byte_array = zvec_byte_array_create(1024); TEST_ASSERT(byte_array != NULL); if (byte_array) { TEST_ASSERT(byte_array->capacity == 1024); @@ -4840,8 +4865,8 @@ void test_array_memory_functions(void) { zvec_byte_array_destroy(byte_array); } - // Test ZVecFloatArray - ZVecFloatArray *float_array = zvec_float_array_create(10); + // Test zvec_float_array_t + zvec_float_array_t *float_array = zvec_float_array_create(10); TEST_ASSERT(float_array != NULL); if (float_array) { TEST_ASSERT(float_array->length == 10); @@ -4856,8 +4881,8 @@ void test_array_memory_functions(void) { zvec_float_array_destroy(float_array); } - // Test ZVecInt64Array - ZVecInt64Array *int64_array = zvec_int64_array_create(5); + // Test zvec_int64_array_t + zvec_int64_array_t *int64_array = zvec_int64_array_create(5); TEST_ASSERT(int64_array != NULL); if (int64_array) { TEST_ASSERT(int64_array->length == 5); @@ -4872,7 +4897,7 @@ void test_array_memory_functions(void) { } // Test edge case: create with zero size - ZVecMutableByteArray *zero_array = zvec_byte_array_create(0); + zvec_mutable_byte_array_t *zero_array = zvec_byte_array_create(0); TEST_ASSERT(zero_array != NULL); if (zero_array) { zvec_byte_array_destroy(zero_array); @@ -4892,29 +4917,28 @@ void test_collection_open_close(void) { zvec_test_delete_dir(temp_dir); // First create a collection - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("open_close_test"); TEST_ASSERT(schema != NULL); - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT32, false, 0); - ZVecFieldSchema *vec_field = + zvec_field_schema_t *vec_field = zvec_field_schema_create("vec", ZVEC_DATA_TYPE_VECTOR_FP32, false, 4); zvec_collection_schema_add_field(schema, id_field); zvec_collection_schema_add_field(schema, vec_field); - ZVecCollectionOptions *options = zvec_collection_options_create(); - zvec_collection_options_set_max_doc_count_per_segment(options, 1000); + zvec_collection_options_t *options = zvec_collection_options_create(); - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, options, &collection); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(collection != NULL); // Insert some data before closing if (collection) { - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); zvec_doc_set_pk(doc, "doc1"); int32_t id_val = 1; float vec_data[] = {1.0f, 2.0f, 3.0f, 4.0f}; @@ -4922,7 +4946,7 @@ void test_collection_open_close(void) { sizeof(int32_t)); zvec_doc_add_field_by_value(doc, "vec", ZVEC_DATA_TYPE_VECTOR_FP32, vec_data, sizeof(vec_data)); - const ZVecDoc *docs[] = {doc}; + const zvec_doc_t *docs[] = {doc}; size_t success_count = 0; size_t error_count = 0; err = zvec_collection_insert(collection, docs, 1, &success_count, @@ -4944,7 +4968,7 @@ void test_collection_open_close(void) { TEST_ASSERT(err == ZVEC_OK); // Re-open the existing collection using zvec_collection_open - ZVecCollection *reopened_collection = NULL; + zvec_collection_t *reopened_collection = NULL; err = zvec_collection_open(temp_dir, options, &reopened_collection); if (err != ZVEC_OK) { char *error_msg = NULL; @@ -4959,13 +4983,13 @@ void test_collection_open_close(void) { // Verify data is still accessible after re-open if (reopened_collection) { // Use query API instead of filter - ZVecVectorQuery *query = zvec_vector_query_create(); + zvec_vector_query_t *query = zvec_vector_query_create(); zvec_vector_query_set_topk(query, 10); zvec_vector_query_set_field_name(query, "vec"); float query_vec[] = {1.0f, 1.0f, 1.0f, 1.0f}; zvec_vector_query_set_query_vector(query, query_vec, sizeof(query_vec)); - ZVecDoc **results = NULL; + zvec_doc_t **results = NULL; size_t result_count = 0; err = zvec_collection_query(reopened_collection, query, &results, &result_count); @@ -5019,33 +5043,16 @@ void test_collection_options_getters(void) { TEST_START(); // Test default values - ZVecCollectionOptions *options = zvec_collection_options_create(); + zvec_collection_options_t *options = zvec_collection_options_create(); TEST_ASSERT(options != NULL); - // Test max_doc_count_per_segment getter - // Note: This function now returns a constant default value - // (MAX_DOC_COUNT_PER_SEGMENT) as the actual setting is stored in - // CollectionSchema, not CollectionOptions - size_t max_doc_count = - zvec_collection_options_get_max_doc_count_per_segment(options); - TEST_ASSERT(max_doc_count > 0); // Should have a default value - - // Set call succeeds but doesn't actually change the value (deprecated - // behavior) - ZVecErrorCode err = - zvec_collection_options_set_max_doc_count_per_segment(options, 5000); - TEST_ASSERT(err == ZVEC_OK); - // Value still returns the constant default - max_doc_count = - zvec_collection_options_get_max_doc_count_per_segment(options); - TEST_ASSERT(max_doc_count > 0); - // Test enable_mmap getter bool enable_mmap = zvec_collection_options_get_enable_mmap(options); TEST_ASSERT(enable_mmap == true || enable_mmap == false); // Set and verify - err = zvec_collection_options_set_enable_mmap(options, false); + zvec_error_code_t err = + zvec_collection_options_set_enable_mmap(options, false); TEST_ASSERT(err == ZVEC_OK); enable_mmap = zvec_collection_options_get_enable_mmap(options); TEST_ASSERT(enable_mmap == false); @@ -5061,7 +5068,6 @@ void test_collection_options_getters(void) { TEST_ASSERT(max_buffer_size == 1024 * 1024); // Test NULL pointer handling - these return defaults, not 0 - TEST_ASSERT(zvec_collection_options_get_max_doc_count_per_segment(NULL) > 0); TEST_ASSERT(zvec_collection_options_get_enable_mmap(NULL) == true); // Default is true TEST_ASSERT(zvec_collection_options_get_max_buffer_size(NULL) > @@ -5078,20 +5084,20 @@ void test_collection_stats_index_info(void) { const char *temp_dir = "/tmp/zvec_test_stats_index"; zvec_test_delete_dir(temp_dir); - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("stats_index_test"); - ZVecFieldSchema *vec_field = + zvec_field_schema_t *vec_field = zvec_field_schema_create("vec", ZVEC_DATA_TYPE_VECTOR_FP32, false, 4); zvec_collection_schema_add_field(schema, vec_field); - ZVecCollection *collection = NULL; - ZVecErrorCode err = + zvec_collection_t *collection = NULL; + zvec_error_code_t err = zvec_collection_create_and_open(temp_dir, schema, NULL, &collection); TEST_ASSERT(err == ZVEC_OK); if (collection) { // Create an index first - ZVecIndexParams *hnsw_params = + zvec_index_params_t *hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(hnsw_params, 16, 100); @@ -5100,7 +5106,7 @@ void test_collection_stats_index_info(void) { zvec_index_params_destroy(hnsw_params); // Get collection stats - ZVecCollectionStats *stats = NULL; + zvec_collection_stats_t *stats = NULL; err = zvec_collection_get_stats(collection, &stats); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(stats != NULL); @@ -5144,21 +5150,21 @@ void test_field_schema_validate(void) { TEST_START(); // Test valid field schema - ZVecFieldSchema *valid_field = + zvec_field_schema_t *valid_field = zvec_field_schema_create("valid_field", ZVEC_DATA_TYPE_INT32, false, 0); TEST_ASSERT(valid_field != NULL); - ZVecString *error_msg = NULL; - ZVecErrorCode err = zvec_field_schema_validate(valid_field, &error_msg); + zvec_string_t *error_msg = NULL; + zvec_error_code_t err = zvec_field_schema_validate(valid_field, &error_msg); TEST_ASSERT(err == ZVEC_OK); if (error_msg) { zvec_free_string(error_msg); } // Test field with index params - ZVecFieldSchema *field_with_index = zvec_field_schema_create( + zvec_field_schema_t *field_with_index = zvec_field_schema_create( "vec_field", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); - ZVecIndexParams *index_params = + zvec_index_params_t *index_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(index_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(index_params, 16, 100); @@ -5191,7 +5197,7 @@ void test_field_schema_validate(void) { void test_doc_remove_field(void) { TEST_START(); - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); TEST_ASSERT(doc != NULL); // Add some fields @@ -5209,7 +5215,7 @@ void test_doc_remove_field(void) { TEST_ASSERT(zvec_doc_get_field_count(doc) == 2); // Remove field1 - ZVecErrorCode err = zvec_doc_remove_field(doc, "field1"); + zvec_error_code_t err = zvec_doc_remove_field(doc, "field1"); TEST_ASSERT(err == ZVEC_OK); // Verify field1 is removed @@ -5237,16 +5243,16 @@ void test_doc_remove_field(void) { void test_collection_schema_getters(void) { TEST_START(); - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create("schema_getter_test"); TEST_ASSERT(schema != NULL); // Add multiple fields - ZVecFieldSchema *field1 = + zvec_field_schema_t *field1 = zvec_field_schema_create("field1", ZVEC_DATA_TYPE_INT32, false, 0); - ZVecFieldSchema *field2 = + zvec_field_schema_t *field2 = zvec_field_schema_create("field2", ZVEC_DATA_TYPE_STRING, true, 0); - ZVecFieldSchema *field3 = zvec_field_schema_create( + zvec_field_schema_t *field3 = zvec_field_schema_create( "field3", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); zvec_collection_schema_add_field(schema, field1); @@ -5261,7 +5267,7 @@ void test_collection_schema_getters(void) { false); // Test get_field by name - ZVecFieldSchema *retrieved_field = + zvec_field_schema_t *retrieved_field = zvec_collection_schema_get_field(schema, "field2"); TEST_ASSERT(retrieved_field != NULL); TEST_ASSERT(zvec_field_schema_get_data_type(retrieved_field) == @@ -5290,7 +5296,7 @@ void test_collection_schema_getters(void) { // Test get_all_field_names const char **field_names = NULL; size_t field_count = 0; - ZVecErrorCode err = zvec_collection_schema_get_all_field_names( + zvec_error_code_t err = zvec_collection_schema_get_all_field_names( schema, &field_names, &field_count); TEST_ASSERT(err == ZVEC_OK); TEST_ASSERT(field_names != NULL); @@ -5303,7 +5309,7 @@ void test_collection_schema_getters(void) { zvec_free(field_names); // Test get_forward_fields - ZVecFieldSchema **forward_fields = NULL; + zvec_field_schema_t **forward_fields = NULL; size_t forward_count = 0; err = zvec_collection_schema_get_forward_fields(schema, &forward_fields, &forward_count); @@ -5315,7 +5321,7 @@ void test_collection_schema_getters(void) { zvec_free(forward_fields); // Test get_vector_fields - ZVecFieldSchema **vector_fields = NULL; + zvec_field_schema_t **vector_fields = NULL; size_t vector_count = 0; err = zvec_collection_schema_get_vector_fields(schema, &vector_fields, &vector_count); diff --git a/tests/c/utils.c b/tests/c/utils.c index 2962311..6d45feb 100644 --- a/tests/c/utils.c +++ b/tests/c/utils.c @@ -36,55 +36,55 @@ static char *strdup_safe(const char *str) { // Schema Creation Helper Functions Implementation // ============================================================================= -ZVecCollectionSchema *zvec_test_create_temp_schema(void) { +zvec_collection_schema_t *zvec_test_create_temp_schema(void) { // Create collection schema using C API - ZVecCollectionSchema *schema = zvec_collection_schema_create("demo"); + zvec_collection_schema_t *schema = zvec_collection_schema_create("demo"); zvec_collection_schema_set_max_doc_count_per_segment(schema, 1000); // Create index parameters using new opaque pointer API - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); zvec_index_params_set_invert_params(invert_params, true, true); - ZVecIndexParams *dense_hnsw_params = + zvec_index_params_t *dense_hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(dense_hnsw_params, ZVEC_METRIC_TYPE_L2); zvec_index_params_set_hnsw_params(dense_hnsw_params, 16, 100); - ZVecIndexParams *sparse_hnsw_params = + zvec_index_params_t *sparse_hnsw_params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); zvec_index_params_set_metric_type(sparse_hnsw_params, ZVEC_METRIC_TYPE_IP); zvec_index_params_set_hnsw_params(sparse_hnsw_params, 16, 100); - ZVecIndexParams *name_invert_params = + zvec_index_params_t *name_invert_params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); zvec_index_params_set_invert_params(name_invert_params, false, false); // Create and add fields - ZVecFieldSchema *id_field = + zvec_field_schema_t *id_field = zvec_field_schema_create("id", ZVEC_DATA_TYPE_INT64, false, 0); zvec_field_schema_set_index_params(id_field, invert_params); zvec_collection_schema_add_field(schema, id_field); // Create name field (inverted index without optimization) - ZVecFieldSchema *name_field = + zvec_field_schema_t *name_field = zvec_field_schema_create("name", ZVEC_DATA_TYPE_STRING, false, 0); zvec_field_schema_set_index_params(name_field, name_invert_params); zvec_collection_schema_add_field(schema, name_field); // Create weight field (no index) - ZVecFieldSchema *weight_field = + zvec_field_schema_t *weight_field = zvec_field_schema_create("weight", ZVEC_DATA_TYPE_FLOAT, true, 0); zvec_collection_schema_add_field(schema, weight_field); // Create dense field (HNSW index) - ZVecFieldSchema *dense_field = + zvec_field_schema_t *dense_field = zvec_field_schema_create("dense", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); zvec_field_schema_set_index_params(dense_field, dense_hnsw_params); zvec_collection_schema_add_field(schema, dense_field); // Create sparse field (HNSW index) - ZVecFieldSchema *sparse_field = zvec_field_schema_create( + zvec_field_schema_t *sparse_field = zvec_field_schema_create( "sparse", ZVEC_DATA_TYPE_SPARSE_VECTOR_FP32, false, 0); zvec_field_schema_set_index_params(sparse_field, sparse_hnsw_params); zvec_collection_schema_add_field(schema, sparse_field); @@ -98,40 +98,41 @@ ZVecCollectionSchema *zvec_test_create_temp_schema(void) { return schema; } -ZVecCollectionSchema *zvec_test_create_scalar_schema(void) { +zvec_collection_schema_t *zvec_test_create_scalar_schema(void) { // Create collection schema using C API - ZVecCollectionSchema *schema = zvec_collection_schema_create("demo"); + zvec_collection_schema_t *schema = zvec_collection_schema_create("demo"); // Create fields - ZVecFieldSchema *int32_field = + zvec_field_schema_t *int32_field = zvec_field_schema_create("int32", ZVEC_DATA_TYPE_INT32, false, 0); zvec_collection_schema_add_field(schema, int32_field); - ZVecFieldSchema *string_field = + zvec_field_schema_t *string_field = zvec_field_schema_create("string", ZVEC_DATA_TYPE_STRING, false, 0); zvec_collection_schema_add_field(schema, string_field); return schema; } -ZVecCollectionSchema *zvec_test_create_normal_schema( - bool nullable, const char *name, const ZVecIndexParams *scalar_index_params, - const ZVecIndexParams *vector_index_params, uint64_t max_doc_count) { +zvec_collection_schema_t *zvec_test_create_normal_schema( + bool nullable, const char *name, + const zvec_index_params_t *scalar_index_params, + const zvec_index_params_t *vector_index_params, uint64_t max_doc_count) { // Create collection schema using C API - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_collection_schema_create(name ? name : "demo"); zvec_collection_schema_set_max_doc_count_per_segment(schema, max_doc_count); // Create scalar fields (8) const char *scalar_names[] = {"int32", "string", "uint32", "bool", "float", "double", "int64", "uint64"}; - ZVecDataType scalar_types[] = {ZVEC_DATA_TYPE_INT32, ZVEC_DATA_TYPE_STRING, - ZVEC_DATA_TYPE_UINT32, ZVEC_DATA_TYPE_BOOL, - ZVEC_DATA_TYPE_FLOAT, ZVEC_DATA_TYPE_DOUBLE, - ZVEC_DATA_TYPE_INT64, ZVEC_DATA_TYPE_UINT64}; + zvec_data_type_t scalar_types[] = { + ZVEC_DATA_TYPE_INT32, ZVEC_DATA_TYPE_STRING, ZVEC_DATA_TYPE_UINT32, + ZVEC_DATA_TYPE_BOOL, ZVEC_DATA_TYPE_FLOAT, ZVEC_DATA_TYPE_DOUBLE, + ZVEC_DATA_TYPE_INT64, ZVEC_DATA_TYPE_UINT64}; for (int i = 0; i < 8; i++) { - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create(scalar_names[i], scalar_types[i], nullable, 0); if (scalar_index_params) { zvec_field_schema_set_index_params(field, scalar_index_params); @@ -143,14 +144,14 @@ ZVecCollectionSchema *zvec_test_create_normal_schema( const char *array_names[] = {"array_int32", "array_string", "array_uint32", "array_bool", "array_float", "array_double", "array_int64", "array_uint64"}; - ZVecDataType array_types[] = { + zvec_data_type_t array_types[] = { ZVEC_DATA_TYPE_ARRAY_INT32, ZVEC_DATA_TYPE_ARRAY_STRING, ZVEC_DATA_TYPE_ARRAY_UINT32, ZVEC_DATA_TYPE_ARRAY_BOOL, ZVEC_DATA_TYPE_ARRAY_FLOAT, ZVEC_DATA_TYPE_ARRAY_DOUBLE, ZVEC_DATA_TYPE_ARRAY_INT64, ZVEC_DATA_TYPE_ARRAY_UINT64}; for (int i = 0; i < 8; i++) { - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create(array_names[i], array_types[i], nullable, 0); if (scalar_index_params) { zvec_field_schema_set_index_params(field, scalar_index_params); @@ -160,38 +161,38 @@ ZVecCollectionSchema *zvec_test_create_normal_schema( // Create vector fields (5) // dense vectors - ZVecFieldSchema *dense_fp32 = zvec_field_schema_create( + zvec_field_schema_t *dense_fp32 = zvec_field_schema_create( "dense_fp32", ZVEC_DATA_TYPE_VECTOR_FP32, false, 128); if (vector_index_params) { zvec_field_schema_set_index_params(dense_fp32, vector_index_params); } zvec_collection_schema_add_field(schema, dense_fp32); - ZVecFieldSchema *dense_fp16 = zvec_field_schema_create( + zvec_field_schema_t *dense_fp16 = zvec_field_schema_create( "dense_fp16", ZVEC_DATA_TYPE_VECTOR_FP16, false, 128); - ZVecIndexParams *flat_params1 = zvec_test_create_default_flat_params(); + zvec_index_params_t *flat_params1 = zvec_test_create_default_flat_params(); zvec_field_schema_set_index_params(dense_fp16, flat_params1); zvec_index_params_destroy(flat_params1); zvec_collection_schema_add_field(schema, dense_fp16); - ZVecFieldSchema *dense_int8 = zvec_field_schema_create( + zvec_field_schema_t *dense_int8 = zvec_field_schema_create( "dense_int8", ZVEC_DATA_TYPE_VECTOR_INT8, false, 128); - ZVecIndexParams *flat_params2 = zvec_test_create_default_flat_params(); + zvec_index_params_t *flat_params2 = zvec_test_create_default_flat_params(); zvec_field_schema_set_index_params(dense_int8, flat_params2); zvec_index_params_destroy(flat_params2); zvec_collection_schema_add_field(schema, dense_int8); // sparse vectors - ZVecFieldSchema *sparse_fp32 = zvec_field_schema_create( + zvec_field_schema_t *sparse_fp32 = zvec_field_schema_create( "sparse_fp32", ZVEC_DATA_TYPE_SPARSE_VECTOR_FP32, false, 0); if (vector_index_params) { zvec_field_schema_set_index_params(sparse_fp32, vector_index_params); } zvec_collection_schema_add_field(schema, sparse_fp32); - ZVecFieldSchema *sparse_fp16 = zvec_field_schema_create( + zvec_field_schema_t *sparse_fp16 = zvec_field_schema_create( "sparse_fp16", ZVEC_DATA_TYPE_SPARSE_VECTOR_FP16, false, 0); - ZVecIndexParams *flat_params3 = zvec_test_create_default_flat_params(); + zvec_index_params_t *flat_params3 = zvec_test_create_default_flat_params(); zvec_field_schema_set_index_params(sparse_fp16, flat_params3); zvec_index_params_destroy(flat_params3); zvec_collection_schema_add_field(schema, sparse_fp16); @@ -199,25 +200,25 @@ ZVecCollectionSchema *zvec_test_create_normal_schema( return schema; } -ZVecCollectionSchema *zvec_test_create_schema_with_scalar_index( +zvec_collection_schema_t *zvec_test_create_schema_with_scalar_index( bool nullable, bool enable_optimize, const char *name) { - ZVecIndexParams *invert_params = + zvec_index_params_t *invert_params = zvec_test_create_default_invert_params(enable_optimize); - ZVecCollectionSchema *schema = + zvec_collection_schema_t *schema = zvec_test_create_normal_schema(nullable, name, invert_params, NULL, 1000); free(invert_params); return schema; } -ZVecCollectionSchema *zvec_test_create_schema_with_vector_index( +zvec_collection_schema_t *zvec_test_create_schema_with_vector_index( bool nullable, const char *name, - const ZVecIndexParams *vector_index_params) { - ZVecIndexParams *default_params = NULL; + const zvec_index_params_t *vector_index_params) { + zvec_index_params_t *default_params = NULL; if (!vector_index_params) { default_params = zvec_test_create_default_hnsw_params(); } - ZVecCollectionSchema *schema = zvec_test_create_normal_schema( + zvec_collection_schema_t *schema = zvec_test_create_normal_schema( nullable, name, NULL, vector_index_params ? vector_index_params : default_params, 1000); @@ -228,7 +229,7 @@ ZVecCollectionSchema *zvec_test_create_schema_with_vector_index( return schema; } -ZVecCollectionSchema *zvec_test_create_schema_with_max_doc_count( +zvec_collection_schema_t *zvec_test_create_schema_with_max_doc_count( uint64_t doc_count) { return zvec_test_create_normal_schema(false, "demo", NULL, NULL, doc_count); } @@ -250,11 +251,11 @@ uint64_t zvec_test_extract_doc_id(const char *pk) { return strtoull(pk + 3, NULL, 10); } -ZVecDoc *zvec_test_create_doc(uint64_t doc_id, - const ZVecCollectionSchema *schema, - const char *pk) { +zvec_doc_t *zvec_test_create_doc(uint64_t doc_id, + const zvec_collection_schema_t *schema, + const char *pk) { if (!schema) return NULL; - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); if (!doc) return NULL; // Set primary key @@ -267,7 +268,7 @@ ZVecDoc *zvec_test_create_doc(uint64_t doc_id, // Create test data for each field const char **field_names = NULL; size_t field_count = 0; - ZVecErrorCode ret = zvec_collection_schema_get_all_field_names( + zvec_error_code_t ret = zvec_collection_schema_get_all_field_names( schema, &field_names, &field_count); if (ret != ZVEC_OK || !field_names) { zvec_doc_destroy(doc); @@ -276,10 +277,10 @@ ZVecDoc *zvec_test_create_doc(uint64_t doc_id, for (size_t i = 0; i < field_count; i++) { const char *field_name = field_names[i]; - const ZVecFieldSchema *field = + const zvec_field_schema_t *field = zvec_collection_schema_get_field(schema, field_name); if (!field) continue; - ZVecDataType field_type = zvec_field_schema_get_data_type(field); + zvec_data_type_t field_type = zvec_field_schema_get_data_type(field); uint32_t field_dimension = zvec_field_schema_get_dimension(field); switch (field_type) { @@ -579,11 +580,11 @@ ZVecDoc *zvec_test_create_doc(uint64_t doc_id, return doc; } -ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, - const ZVecCollectionSchema *schema, - const char *pk) { +zvec_doc_t *zvec_test_create_doc_null(uint64_t doc_id, + const zvec_collection_schema_t *schema, + const char *pk) { // Reuse create_doc function, but only process vector fields - ZVecDoc *doc = zvec_doc_create(); + zvec_doc_t *doc = zvec_doc_create(); if (!doc) return NULL; // Set primary key @@ -596,7 +597,7 @@ ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, // Only create data for vector fields const char **field_names = NULL; size_t field_count = 0; - ZVecErrorCode ret = zvec_collection_schema_get_all_field_names( + zvec_error_code_t ret = zvec_collection_schema_get_all_field_names( schema, &field_names, &field_count); if (ret != ZVEC_OK || !field_names) { zvec_doc_destroy(doc); @@ -605,10 +606,10 @@ ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, for (size_t i = 0; i < field_count; i++) { const char *field_name = field_names[i]; - const ZVecFieldSchema *field = + const zvec_field_schema_t *field = zvec_collection_schema_get_field(schema, field_name); if (!field) continue; - ZVecDataType field_type = zvec_field_schema_get_data_type(field); + zvec_data_type_t field_type = zvec_field_schema_get_data_type(field); uint32_t field_dimension = zvec_field_schema_get_dimension(field); // Only process specific vector type fields @@ -620,7 +621,7 @@ ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, continue; } - ZVecErrorCode err = ZVEC_OK; + zvec_error_code_t err = ZVEC_OK; switch (field_type) { case ZVEC_DATA_TYPE_VECTOR_FP32: { @@ -743,11 +744,10 @@ ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, return doc; } -ZVecDoc *zvec_test_create_doc_with_fields(uint64_t doc_id, - const char **field_names, - const ZVecDataType *field_types, - size_t field_count, const char *pk) { - ZVecDoc *doc = zvec_doc_create(); +zvec_doc_t *zvec_test_create_doc_with_fields( + uint64_t doc_id, const char **field_names, + const zvec_data_type_t *field_types, size_t field_count, const char *pk) { + zvec_doc_t *doc = zvec_doc_create(); if (!doc) return NULL; // Set primary key @@ -759,7 +759,7 @@ ZVecDoc *zvec_test_create_doc_with_fields(uint64_t doc_id, // Create data for specified fields for (size_t i = 0; i < field_count; i++) { - ZVecErrorCode err = ZVEC_OK; + zvec_error_code_t err = ZVEC_OK; switch (field_types[i]) { case ZVEC_DATA_TYPE_INT32: @@ -807,8 +807,8 @@ ZVecDoc *zvec_test_create_doc_with_fields(uint64_t doc_id, // Index Parameter Creation Helper Functions Implementation // ============================================================================= -ZVecIndexParams *zvec_test_create_default_hnsw_params(void) { - ZVecIndexParams *params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); +zvec_index_params_t *zvec_test_create_default_hnsw_params(void) { + zvec_index_params_t *params = zvec_index_params_create(ZVEC_INDEX_TYPE_HNSW); if (!params) return NULL; zvec_index_params_set_metric_type(params, ZVEC_METRIC_TYPE_IP); @@ -817,8 +817,8 @@ ZVecIndexParams *zvec_test_create_default_hnsw_params(void) { return params; } -ZVecIndexParams *zvec_test_create_default_flat_params(void) { - ZVecIndexParams *params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); +zvec_index_params_t *zvec_test_create_default_flat_params(void) { + zvec_index_params_t *params = zvec_index_params_create(ZVEC_INDEX_TYPE_FLAT); if (!params) return NULL; zvec_index_params_set_metric_type(params, ZVEC_METRIC_TYPE_IP); @@ -826,8 +826,10 @@ ZVecIndexParams *zvec_test_create_default_flat_params(void) { return params; } -ZVecIndexParams *zvec_test_create_default_invert_params(bool enable_optimize) { - ZVecIndexParams *params = zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); +zvec_index_params_t *zvec_test_create_default_invert_params( + bool enable_optimize) { + zvec_index_params_t *params = + zvec_index_params_create(ZVEC_INDEX_TYPE_INVERT); if (!params) return NULL; zvec_index_params_set_invert_params(params, enable_optimize, enable_optimize); @@ -839,18 +841,18 @@ ZVecIndexParams *zvec_test_create_default_invert_params(bool enable_optimize) { // Field Schema Creation Helper Functions Implementation // ============================================================================= -ZVecFieldSchema *zvec_test_create_scalar_field( - const char *name, ZVecDataType data_type, bool nullable, - const ZVecIndexParams *invert_params) { +zvec_field_schema_t *zvec_test_create_scalar_field( + const char *name, zvec_data_type_t data_type, bool nullable, + const zvec_index_params_t *invert_params) { // Use the public API to create the field - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create(name, data_type, nullable, 0); if (!field) return NULL; if (invert_params) { // Clone the index params using setter API - ZVecIndexType type = zvec_index_params_get_type(invert_params); - ZVecIndexParams *cloned_params = zvec_index_params_create(type); + zvec_index_type_t type = zvec_index_params_get_type(invert_params); + zvec_index_params_t *cloned_params = zvec_index_params_create(type); if (cloned_params) { bool enable_range_opt, enable_wildcard; zvec_index_params_get_invert_params(invert_params, &enable_range_opt, @@ -865,18 +867,18 @@ ZVecFieldSchema *zvec_test_create_scalar_field( return field; } -ZVecFieldSchema *zvec_test_create_vector_field( - const char *name, ZVecDataType data_type, uint32_t dimension, bool nullable, - const ZVecIndexParams *vector_index_params) { +zvec_field_schema_t *zvec_test_create_vector_field( + const char *name, zvec_data_type_t data_type, uint32_t dimension, + bool nullable, const zvec_index_params_t *vector_index_params) { // Use the public API to create the field - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create(name, data_type, nullable, dimension); if (!field) return NULL; if (vector_index_params) { // Clone the index params using setter API - ZVecIndexType type = zvec_index_params_get_type(vector_index_params); - ZVecIndexParams *cloned_params = zvec_index_params_create(type); + zvec_index_type_t type = zvec_index_params_get_type(vector_index_params); + zvec_index_params_t *cloned_params = zvec_index_params_create(type); if (cloned_params) { int m, ef_construction; m = zvec_index_params_get_hnsw_m(vector_index_params); @@ -891,18 +893,18 @@ ZVecFieldSchema *zvec_test_create_vector_field( return field; } -ZVecFieldSchema *zvec_test_create_sparse_vector_field( - const char *name, ZVecDataType data_type, bool nullable, - const ZVecIndexParams *vector_index_params) { +zvec_field_schema_t *zvec_test_create_sparse_vector_field( + const char *name, zvec_data_type_t data_type, bool nullable, + const zvec_index_params_t *vector_index_params) { // Use the public API to create the field - ZVecFieldSchema *field = + zvec_field_schema_t *field = zvec_field_schema_create(name, data_type, nullable, 0); if (!field) return NULL; if (vector_index_params) { // Clone the index params using setter API - ZVecIndexType type = zvec_index_params_get_type(vector_index_params); - ZVecIndexParams *cloned_params = zvec_index_params_create(type); + zvec_index_type_t type = zvec_index_params_get_type(vector_index_params); + zvec_index_params_t *cloned_params = zvec_index_params_create(type); if (cloned_params) { int m, ef_construction; m = zvec_index_params_get_hnsw_m(vector_index_params); diff --git a/tests/c/utils.h b/tests/c/utils.h index 202bc95..e965596 100644 --- a/tests/c/utils.h +++ b/tests/c/utils.h @@ -32,18 +32,18 @@ extern "C" { * @brief Create temporary test schema * Contains basic scalar fields and vector fields * - * @return ZVecCollectionSchema* Created schema pointer, needs to be released by - * calling zvec_collection_schema_cleanup + * @return zvec_collection_schema_t* Created schema pointer, needs to be + * released by calling zvec_collection_schema_cleanup */ -ZVecCollectionSchema *zvec_test_create_temp_schema(void); +zvec_collection_schema_t *zvec_test_create_temp_schema(void); /** * @brief Create pure scalar schema * Contains only scalar fields (int32, string) * - * @return ZVecCollectionSchema* Created schema pointer + * @return zvec_collection_schema_t* Created schema pointer */ -ZVecCollectionSchema *zvec_test_create_scalar_schema(void); +zvec_collection_schema_t *zvec_test_create_scalar_schema(void); /** * @brief Create full-featured schema @@ -54,11 +54,12 @@ ZVecCollectionSchema *zvec_test_create_scalar_schema(void); * @param scalar_index_params Scalar index parameters (can be NULL) * @param vector_index_params Vector index parameters (can be NULL) * @param max_doc_count Maximum documents per segment - * @return ZVecCollectionSchema* Created schema pointer + * @return zvec_collection_schema_t* Created schema pointer */ -ZVecCollectionSchema *zvec_test_create_normal_schema( - bool nullable, const char *name, const ZVecIndexParams *scalar_index_params, - const ZVecIndexParams *vector_index_params, uint64_t max_doc_count); +zvec_collection_schema_t *zvec_test_create_normal_schema( + bool nullable, const char *name, + const zvec_index_params_t *scalar_index_params, + const zvec_index_params_t *vector_index_params, uint64_t max_doc_count); /** * @brief Create schema with scalar index @@ -66,9 +67,9 @@ ZVecCollectionSchema *zvec_test_create_normal_schema( * @param nullable Whether to allow null values * @param enable_optimize Whether to enable optimization * @param name Schema name - * @return ZVecCollectionSchema* Created schema pointer + * @return zvec_collection_schema_t* Created schema pointer */ -ZVecCollectionSchema *zvec_test_create_schema_with_scalar_index( +zvec_collection_schema_t *zvec_test_create_schema_with_scalar_index( bool nullable, bool enable_optimize, const char *name); /** @@ -78,19 +79,19 @@ ZVecCollectionSchema *zvec_test_create_schema_with_scalar_index( * @param name Schema name * @param vector_index_params Vector index parameters (can be NULL, uses default * HNSW parameters) - * @return ZVecCollectionSchema* Created schema pointer + * @return zvec_collection_schema_t* Created schema pointer */ -ZVecCollectionSchema *zvec_test_create_schema_with_vector_index( +zvec_collection_schema_t *zvec_test_create_schema_with_vector_index( bool nullable, const char *name, - const ZVecIndexParams *vector_index_params); + const zvec_index_params_t *vector_index_params); /** * @brief Create schema with specified maximum document count * * @param doc_count Maximum documents per segment - * @return ZVecCollectionSchema* Created schema pointer + * @return zvec_collection_schema_t* Created schema pointer */ -ZVecCollectionSchema *zvec_test_create_schema_with_max_doc_count( +zvec_collection_schema_t *zvec_test_create_schema_with_max_doc_count( uint64_t doc_count); // ============================================================================= @@ -113,12 +114,12 @@ char *zvec_test_make_pk(uint64_t doc_id); * @param doc_id Document ID * @param schema Schema pointer * @param pk Primary key (can be NULL, auto-generated) - * @return ZVecDoc* Created document pointer, needs to be released by calling + * @return zvec_doc_t* Created document pointer, needs to be released by calling * zvec_doc_destroy */ -ZVecDoc *zvec_test_create_doc(uint64_t doc_id, - const ZVecCollectionSchema *schema, - const char *pk); +zvec_doc_t *zvec_test_create_doc(uint64_t doc_id, + const zvec_collection_schema_t *schema, + const char *pk); /** * @brief Create partial null document @@ -127,11 +128,11 @@ ZVecDoc *zvec_test_create_doc(uint64_t doc_id, * @param doc_id Document ID * @param schema Schema pointer * @param pk Primary key (can be NULL, auto-generated) - * @return ZVecDoc* Created document pointer + * @return zvec_doc_t* Created document pointer */ -ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, - const ZVecCollectionSchema *schema, - const char *pk); +zvec_doc_t *zvec_test_create_doc_null(uint64_t doc_id, + const zvec_collection_schema_t *schema, + const char *pk); /** * @brief Create document with specified fields @@ -142,12 +143,11 @@ ZVecDoc *zvec_test_create_doc_null(uint64_t doc_id, * @param field_types Field type array * @param field_count Number of fields * @param pk Primary key (can be NULL, auto-generated) - * @return ZVecDoc* Created document pointer + * @return zvec_doc_t* Created document pointer */ -ZVecDoc *zvec_test_create_doc_with_fields(uint64_t doc_id, - const char **field_names, - const ZVecDataType *field_types, - size_t field_count, const char *pk); +zvec_doc_t *zvec_test_create_doc_with_fields( + uint64_t doc_id, const char **field_names, + const zvec_data_type_t *field_types, size_t field_count, const char *pk); // ============================================================================= // Index Parameter Creation Helper Functions @@ -156,24 +156,25 @@ ZVecDoc *zvec_test_create_doc_with_fields(uint64_t doc_id, /** * @brief Create default HNSW index parameters * - * @return ZVecIndexParams* Created parameter pointer + * @return zvec_index_params_t* Created parameter pointer */ -ZVecIndexParams *zvec_test_create_default_hnsw_params(void); +zvec_index_params_t *zvec_test_create_default_hnsw_params(void); /** * @brief Create default Flat index parameters * - * @return ZVecIndexParams* Created parameter pointer + * @return zvec_index_params_t* Created parameter pointer */ -ZVecIndexParams *zvec_test_create_default_flat_params(void); +zvec_index_params_t *zvec_test_create_default_flat_params(void); /** * @brief Create default scalar index parameters * * @param enable_optimize Whether to enable optimization - * @return ZVecIndexParams* Created parameter pointer + * @return zvec_index_params_t* Created parameter pointer */ -ZVecIndexParams *zvec_test_create_default_invert_params(bool enable_optimize); +zvec_index_params_t *zvec_test_create_default_invert_params( + bool enable_optimize); // ============================================================================= // Field Schema Creation Helper Functions @@ -186,12 +187,12 @@ ZVecIndexParams *zvec_test_create_default_invert_params(bool enable_optimize); * @param data_type Data type * @param nullable Whether to allow null values * @param invert_params Scalar index parameters (can be NULL) - * @return ZVecFieldSchema* Created field schema pointer, needs to be released - * by calling free() + * @return zvec_field_schema_t* Created field schema pointer, needs to be + * released by calling free() */ -ZVecFieldSchema *zvec_test_create_scalar_field( - const char *name, ZVecDataType data_type, bool nullable, - const ZVecIndexParams *invert_params); +zvec_field_schema_t *zvec_test_create_scalar_field( + const char *name, zvec_data_type_t data_type, bool nullable, + const zvec_index_params_t *invert_params); /** * @brief Create vector field schema @@ -201,11 +202,11 @@ ZVecFieldSchema *zvec_test_create_scalar_field( * @param dimension Vector dimension * @param nullable Whether to allow null values * @param vector_index_params Vector index parameters (can be NULL) - * @return ZVecFieldSchema* Created field schema pointer + * @return zvec_field_schema_t* Created field schema pointer */ -ZVecFieldSchema *zvec_test_create_vector_field( - const char *name, ZVecDataType data_type, uint32_t dimension, bool nullable, - const ZVecIndexParams *vector_index_params); +zvec_field_schema_t *zvec_test_create_vector_field( + const char *name, zvec_data_type_t data_type, uint32_t dimension, + bool nullable, const zvec_index_params_t *vector_index_params); /** * @brief Create sparse vector field schema @@ -214,11 +215,11 @@ ZVecFieldSchema *zvec_test_create_vector_field( * @param data_type Data type * @param nullable Whether to allow null values * @param vector_index_params Vector index parameters (can be NULL) - * @return ZVecFieldSchema* Created field schema pointer + * @return zvec_field_schema_t* Created field schema pointer */ -ZVecFieldSchema *zvec_test_create_sparse_vector_field( - const char *name, ZVecDataType data_type, bool nullable, - const ZVecIndexParams *vector_index_params); +zvec_field_schema_t *zvec_test_create_sparse_vector_field( + const char *name, zvec_data_type_t data_type, bool nullable, + const zvec_index_params_t *vector_index_params); // ============================================================================= // Memory Management Helper Functions