kuzu.h

Go to the documentation of this file.

#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
#ifdef _WIN32
#include <windows.h>
#endif
 
/* Export header from common/api.h */
// Helpers
#if defined _WIN32 || defined __CYGWIN__
#define KUZU_HELPER_DLL_IMPORT __declspec(dllimport)
#define KUZU_HELPER_DLL_EXPORT __declspec(dllexport)
#define KUZU_HELPER_DLL_LOCAL
#define KUZU_HELPER_DEPRECATED __declspec(deprecated)
#else
#define KUZU_HELPER_DLL_IMPORT __attribute__((visibility("default")))
#define KUZU_HELPER_DLL_EXPORT __attribute__((visibility("default")))
#define KUZU_HELPER_DLL_LOCAL __attribute__((visibility("hidden")))
#define KUZU_HELPER_DEPRECATED __attribute__((__deprecated__))
#endif
 
#ifdef KUZU_STATIC_DEFINE
#define KUZU_API
#define KUZU_NO_EXPORT
#else
#ifndef KUZU_API
#ifdef KUZU_EXPORTS
/* We are building this library */
#define KUZU_API KUZU_HELPER_DLL_EXPORT
#else
/* We are using this library */
#define KUZU_API KUZU_HELPER_DLL_IMPORT
#endif
#endif
 
#endif
 
#ifndef KUZU_DEPRECATED
#define KUZU_DEPRECATED KUZU_HELPER_DEPRECATED
#endif
 
#ifndef KUZU_DEPRECATED_EXPORT
#define KUZU_DEPRECATED_EXPORT KUZU_API KUZU_DEPRECATED
#endif
/* end export header */
 
// The Arrow C data interface.
// https://arrow.apache.org/docs/format/CDataInterface.html
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef ARROW_C_DATA_INTERFACE
#define ARROW_C_DATA_INTERFACE
 
#define ARROW_FLAG_DICTIONARY_ORDERED 1
#define ARROW_FLAG_NULLABLE 2
#define ARROW_FLAG_MAP_KEYS_SORTED 4
 
struct ArrowSchema {
    // Array type description
    const char* format;
    const char* name;
    const char* metadata;
    int64_t flags;
    int64_t n_children;
    struct ArrowSchema** children;
    struct ArrowSchema* dictionary;
 
    // Release callback
    void (*release)(struct ArrowSchema*);
    // Opaque producer-specific data
    void* private_data;
};
 
struct ArrowArray {
    // Array data description
    int64_t length;
    int64_t null_count;
    int64_t offset;
    int64_t n_buffers;
    int64_t n_children;
    const void** buffers;
    struct ArrowArray** children;
    struct ArrowArray* dictionary;
 
    // Release callback
    void (*release)(struct ArrowArray*);
    // Opaque producer-specific data
    void* private_data;
};
 
#endif // ARROW_C_DATA_INTERFACE
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
#define KUZU_C_API extern "C" KUZU_API
#else
#define KUZU_C_API KUZU_API
#endif
 
typedef struct {
    // bufferPoolSize Max size of the buffer pool in bytes.
    // The larger the buffer pool, the more data from the database files is kept in memory,
    // reducing the amount of File I/O
    uint64_t buffer_pool_size;
    // The maximum number of threads to use during query execution
    uint64_t max_num_threads;
    // Whether or not to compress data on-disk for supported types
    bool enable_compression;
    // If true, open the database in read-only mode. No write transaction is allowed on the Database
    // object. If false, open the database read-write.
    bool read_only;
    //  The maximum size of the database in bytes. Note that this is introduced temporarily for now
    //  to get around with the default 8TB mmap address space limit under some environment. This
    //  will be removed once we implemente a better solution later. The value is default to 1 << 43
    //  (8TB) under 64-bit environment and 1GB under 32-bit one (see `DEFAULT_VM_REGION_MAX_SIZE`).
    uint64_t max_db_size;
    // If true, the database will automatically checkpoint when the size of
    // the WAL file exceeds the checkpoint threshold.
    bool auto_checkpoint;
    // The threshold of the WAL file size in bytes. When the size of the
    // WAL file exceeds this threshold, the database will checkpoint if auto_checkpoint is true.
    uint64_t checkpoint_threshold;
} kuzu_system_config;
 
typedef struct {
    void* _database;
} kuzu_database;
 
typedef struct {
    void* _connection;
} kuzu_connection;
 
typedef struct {
    void* _prepared_statement;
    void* _bound_values;
} kuzu_prepared_statement;
 
typedef struct {
    void* _query_result;
    bool _is_owned_by_cpp;
} kuzu_query_result;
 
typedef struct {
    void* _flat_tuple;
    bool _is_owned_by_cpp;
} kuzu_flat_tuple;
 
typedef struct {
    void* _data_type;
} kuzu_logical_type;
 
typedef struct {
    void* _value;
    bool _is_owned_by_cpp;
} kuzu_value;
 
typedef struct {
    uint64_t table_id;
    uint64_t offset;
} kuzu_internal_id_t;
 
typedef struct {
    // Days since 1970-01-01 00:00:00 UTC.
    int32_t days;
} kuzu_date_t;
 
typedef struct {
    // Nanoseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} kuzu_timestamp_ns_t;
 
typedef struct {
    // Milliseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} kuzu_timestamp_ms_t;
 
typedef struct {
    // Seconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} kuzu_timestamp_sec_t;
 
typedef struct {
    // Microseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} kuzu_timestamp_tz_t;
 
typedef struct {
    // Microseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} kuzu_timestamp_t;
 
typedef struct {
    int32_t months;
    int32_t days;
    int64_t micros;
} kuzu_interval_t;
 
typedef struct {
    void* _query_summary;
} kuzu_query_summary;
 
typedef struct {
    uint64_t low;
    int64_t high;
} kuzu_int128_t;
 
typedef enum {
    KUZU_ANY = 0,
    KUZU_NODE = 10,
    KUZU_REL = 11,
    KUZU_RECURSIVE_REL = 12,
    // SERIAL is a special data type that is used to represent a sequence of INT64 values that are
    // incremented by 1 starting from 0.
    KUZU_SERIAL = 13,
    // fixed size types
    KUZU_BOOL = 22,
    KUZU_INT64 = 23,
    KUZU_INT32 = 24,
    KUZU_INT16 = 25,
    KUZU_INT8 = 26,
    KUZU_UINT64 = 27,
    KUZU_UINT32 = 28,
    KUZU_UINT16 = 29,
    KUZU_UINT8 = 30,
    KUZU_INT128 = 31,
    KUZU_DOUBLE = 32,
    KUZU_FLOAT = 33,
    KUZU_DATE = 34,
    KUZU_TIMESTAMP = 35,
    KUZU_TIMESTAMP_SEC = 36,
    KUZU_TIMESTAMP_MS = 37,
    KUZU_TIMESTAMP_NS = 38,
    KUZU_TIMESTAMP_TZ = 39,
    KUZU_INTERVAL = 40,
    KUZU_DECIMAL = 41,
    KUZU_INTERNAL_ID = 42,
    // variable size types
    KUZU_STRING = 50,
    KUZU_BLOB = 51,
    KUZU_LIST = 52,
    KUZU_ARRAY = 53,
    KUZU_STRUCT = 54,
    KUZU_MAP = 55,
    KUZU_UNION = 56,
    KUZU_POINTER = 58,
    KUZU_UUID = 59
} kuzu_data_type_id;
 
typedef enum { KuzuSuccess = 0, KuzuError = 1 } kuzu_state;
 
// Database
KUZU_C_API kuzu_state kuzu_database_init(const char* database_path,
    kuzu_system_config system_config, kuzu_database* out_database);
KUZU_C_API void kuzu_database_destroy(kuzu_database* database);
 
KUZU_C_API kuzu_system_config kuzu_default_system_config();
 
// Connection
KUZU_C_API kuzu_state kuzu_connection_init(kuzu_database* database,
    kuzu_connection* out_connection);
KUZU_C_API void kuzu_connection_destroy(kuzu_connection* connection);
KUZU_C_API kuzu_state kuzu_connection_set_max_num_thread_for_exec(kuzu_connection* connection,
    uint64_t num_threads);
 
KUZU_C_API kuzu_state kuzu_connection_get_max_num_thread_for_exec(kuzu_connection* connection,
    uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_connection_query(kuzu_connection* connection, const char* query,
    kuzu_query_result* out_query_result);
KUZU_C_API kuzu_state kuzu_connection_prepare(kuzu_connection* connection, const char* query,
    kuzu_prepared_statement* out_prepared_statement);
KUZU_C_API kuzu_state kuzu_connection_execute(kuzu_connection* connection,
    kuzu_prepared_statement* prepared_statement, kuzu_query_result* out_query_result);
KUZU_C_API void kuzu_connection_interrupt(kuzu_connection* connection);
KUZU_C_API kuzu_state kuzu_connection_set_query_timeout(kuzu_connection* connection,
    uint64_t timeout_in_ms);
 
// PreparedStatement
KUZU_C_API void kuzu_prepared_statement_destroy(kuzu_prepared_statement* prepared_statement);
KUZU_C_API bool kuzu_prepared_statement_is_success(kuzu_prepared_statement* prepared_statement);
KUZU_C_API char* kuzu_prepared_statement_get_error_message(
    kuzu_prepared_statement* prepared_statement);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_bool(kuzu_prepared_statement* prepared_statement,
    const char* param_name, bool value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_int64(
    kuzu_prepared_statement* prepared_statement, const char* param_name, int64_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_int32(
    kuzu_prepared_statement* prepared_statement, const char* param_name, int32_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_int16(
    kuzu_prepared_statement* prepared_statement, const char* param_name, int16_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_int8(kuzu_prepared_statement* prepared_statement,
    const char* param_name, int8_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_uint64(
    kuzu_prepared_statement* prepared_statement, const char* param_name, uint64_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_uint32(
    kuzu_prepared_statement* prepared_statement, const char* param_name, uint32_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_uint16(
    kuzu_prepared_statement* prepared_statement, const char* param_name, uint16_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_uint8(
    kuzu_prepared_statement* prepared_statement, const char* param_name, uint8_t value);
 
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_double(
    kuzu_prepared_statement* prepared_statement, const char* param_name, double value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_float(
    kuzu_prepared_statement* prepared_statement, const char* param_name, float value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_date(kuzu_prepared_statement* prepared_statement,
    const char* param_name, kuzu_date_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_timestamp_ns(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_timestamp_ns_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_timestamp_sec(
    kuzu_prepared_statement* prepared_statement, const char* param_name,
    kuzu_timestamp_sec_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_timestamp_tz(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_timestamp_tz_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_timestamp_ms(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_timestamp_ms_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_timestamp(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_timestamp_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_interval(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_interval_t value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_string(
    kuzu_prepared_statement* prepared_statement, const char* param_name, const char* value);
KUZU_C_API kuzu_state kuzu_prepared_statement_bind_value(
    kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_value* value);
 
// QueryResult
KUZU_C_API void kuzu_query_result_destroy(kuzu_query_result* query_result);
KUZU_C_API bool kuzu_query_result_is_success(kuzu_query_result* query_result);
KUZU_C_API char* kuzu_query_result_get_error_message(kuzu_query_result* query_result);
KUZU_C_API uint64_t kuzu_query_result_get_num_columns(kuzu_query_result* query_result);
KUZU_C_API kuzu_state kuzu_query_result_get_column_name(kuzu_query_result* query_result,
    uint64_t index, char** out_column_name);
KUZU_C_API kuzu_state kuzu_query_result_get_column_data_type(kuzu_query_result* query_result,
    uint64_t index, kuzu_logical_type* out_column_data_type);
KUZU_C_API uint64_t kuzu_query_result_get_num_tuples(kuzu_query_result* query_result);
KUZU_C_API kuzu_state kuzu_query_result_get_query_summary(kuzu_query_result* query_result,
    kuzu_query_summary* out_query_summary);
KUZU_C_API bool kuzu_query_result_has_next(kuzu_query_result* query_result);
KUZU_C_API kuzu_state kuzu_query_result_get_next(kuzu_query_result* query_result,
    kuzu_flat_tuple* out_flat_tuple);
KUZU_C_API bool kuzu_query_result_has_next_query_result(kuzu_query_result* query_result);
KUZU_C_API kuzu_state kuzu_query_result_get_next_query_result(kuzu_query_result* query_result,
    kuzu_query_result* out_next_query_result);
 
KUZU_C_API char* kuzu_query_result_to_string(kuzu_query_result* query_result);
KUZU_C_API void kuzu_query_result_reset_iterator(kuzu_query_result* query_result);
 
KUZU_C_API kuzu_state kuzu_query_result_get_arrow_schema(kuzu_query_result* query_result,
    struct ArrowSchema* out_schema);
 
KUZU_C_API kuzu_state kuzu_query_result_get_next_arrow_chunk(kuzu_query_result* query_result,
    int64_t chunk_size, struct ArrowArray* out_arrow_array);
 
// FlatTuple
KUZU_C_API void kuzu_flat_tuple_destroy(kuzu_flat_tuple* flat_tuple);
KUZU_C_API kuzu_state kuzu_flat_tuple_get_value(kuzu_flat_tuple* flat_tuple, uint64_t index,
    kuzu_value* out_value);
KUZU_C_API char* kuzu_flat_tuple_to_string(kuzu_flat_tuple* flat_tuple);
 
// DataType
// TODO(Chang): Refactor the datatype constructor to follow the cpp way of creating dataTypes.
KUZU_C_API void kuzu_data_type_create(kuzu_data_type_id id, kuzu_logical_type* child_type,
    uint64_t num_elements_in_array, kuzu_logical_type* out_type);
KUZU_C_API void kuzu_data_type_clone(kuzu_logical_type* data_type, kuzu_logical_type* out_type);
KUZU_C_API void kuzu_data_type_destroy(kuzu_logical_type* data_type);
KUZU_C_API bool kuzu_data_type_equals(kuzu_logical_type* data_type1, kuzu_logical_type* data_type2);
KUZU_C_API kuzu_data_type_id kuzu_data_type_get_id(kuzu_logical_type* data_type);
KUZU_C_API kuzu_state kuzu_data_type_get_num_elements_in_array(kuzu_logical_type* data_type,
    uint64_t* out_result);
 
// Value
KUZU_C_API kuzu_value* kuzu_value_create_null();
KUZU_C_API kuzu_value* kuzu_value_create_null_with_data_type(kuzu_logical_type* data_type);
KUZU_C_API bool kuzu_value_is_null(kuzu_value* value);
KUZU_C_API void kuzu_value_set_null(kuzu_value* value, bool is_null);
KUZU_C_API kuzu_value* kuzu_value_create_default(kuzu_logical_type* data_type);
KUZU_C_API kuzu_value* kuzu_value_create_bool(bool val_);
KUZU_C_API kuzu_value* kuzu_value_create_int8(int8_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_int16(int16_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_int32(int32_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_int64(int64_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_uint8(uint8_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_uint16(uint16_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_uint32(uint32_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_uint64(uint64_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_int128(kuzu_int128_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_float(float val_);
KUZU_C_API kuzu_value* kuzu_value_create_double(double val_);
KUZU_C_API kuzu_value* kuzu_value_create_internal_id(kuzu_internal_id_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_date(kuzu_date_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_timestamp_ns(kuzu_timestamp_ns_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_timestamp_ms(kuzu_timestamp_ms_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_timestamp_sec(kuzu_timestamp_sec_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_timestamp_tz(kuzu_timestamp_tz_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_timestamp(kuzu_timestamp_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_interval(kuzu_interval_t val_);
KUZU_C_API kuzu_value* kuzu_value_create_string(const char* val_);
KUZU_C_API kuzu_state kuzu_value_create_list(uint64_t num_elements, kuzu_value** elements,
    kuzu_value** out_value);
KUZU_C_API kuzu_state kuzu_value_create_struct(uint64_t num_fields, const char** field_names,
    kuzu_value** field_values, kuzu_value** out_value);
KUZU_C_API kuzu_state kuzu_value_create_map(uint64_t num_fields, kuzu_value** keys,
    kuzu_value** values, kuzu_value** out_value);
KUZU_C_API kuzu_value* kuzu_value_clone(kuzu_value* value);
KUZU_C_API void kuzu_value_copy(kuzu_value* value, kuzu_value* other);
KUZU_C_API void kuzu_value_destroy(kuzu_value* value);
KUZU_C_API kuzu_state kuzu_value_get_list_size(kuzu_value* value, uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_list_element(kuzu_value* value, uint64_t index,
    kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_value_get_struct_num_fields(kuzu_value* value, uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_struct_field_name(kuzu_value* value, uint64_t index,
    char** out_result);
KUZU_C_API kuzu_state kuzu_value_get_struct_field_value(kuzu_value* value, uint64_t index,
    kuzu_value* out_value);
 
KUZU_C_API kuzu_state kuzu_value_get_map_size(kuzu_value* value, uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_map_key(kuzu_value* value, uint64_t index,
    kuzu_value* out_key);
KUZU_C_API kuzu_state kuzu_value_get_map_value(kuzu_value* value, uint64_t index,
    kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_value_get_recursive_rel_node_list(kuzu_value* value,
    kuzu_value* out_value);
 
KUZU_C_API kuzu_state kuzu_value_get_recursive_rel_rel_list(kuzu_value* value,
    kuzu_value* out_value);
KUZU_C_API void kuzu_value_get_data_type(kuzu_value* value, kuzu_logical_type* out_type);
KUZU_C_API kuzu_state kuzu_value_get_bool(kuzu_value* value, bool* out_result);
KUZU_C_API kuzu_state kuzu_value_get_int8(kuzu_value* value, int8_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_int16(kuzu_value* value, int16_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_int32(kuzu_value* value, int32_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_int64(kuzu_value* value, int64_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_uint8(kuzu_value* value, uint8_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_uint16(kuzu_value* value, uint16_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_uint32(kuzu_value* value, uint32_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_uint64(kuzu_value* value, uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_int128(kuzu_value* value, kuzu_int128_t* out_result);
KUZU_C_API kuzu_state kuzu_int128_t_from_string(const char* str, kuzu_int128_t* out_result);
KUZU_C_API kuzu_state kuzu_int128_t_to_string(kuzu_int128_t val, char** out_result);
KUZU_C_API kuzu_state kuzu_value_get_float(kuzu_value* value, float* out_result);
KUZU_C_API kuzu_state kuzu_value_get_double(kuzu_value* value, double* out_result);
KUZU_C_API kuzu_state kuzu_value_get_internal_id(kuzu_value* value, kuzu_internal_id_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_date(kuzu_value* value, kuzu_date_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_timestamp(kuzu_value* value, kuzu_timestamp_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_timestamp_ns(kuzu_value* value,
    kuzu_timestamp_ns_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_timestamp_ms(kuzu_value* value,
    kuzu_timestamp_ms_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_timestamp_sec(kuzu_value* value,
    kuzu_timestamp_sec_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_timestamp_tz(kuzu_value* value,
    kuzu_timestamp_tz_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_interval(kuzu_value* value, kuzu_interval_t* out_result);
KUZU_C_API kuzu_state kuzu_value_get_decimal_as_string(kuzu_value* value, char** out_result);
KUZU_C_API kuzu_state kuzu_value_get_string(kuzu_value* value, char** out_result);
KUZU_C_API kuzu_state kuzu_value_get_blob(kuzu_value* value, uint8_t** out_result);
KUZU_C_API kuzu_state kuzu_value_get_uuid(kuzu_value* value, char** out_result);
KUZU_C_API char* kuzu_value_to_string(kuzu_value* value);
KUZU_C_API kuzu_state kuzu_node_val_get_id_val(kuzu_value* node_val, kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_node_val_get_label_val(kuzu_value* node_val, kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_node_val_get_property_size(kuzu_value* node_val, uint64_t* out_value);
KUZU_C_API kuzu_state kuzu_node_val_get_property_name_at(kuzu_value* node_val, uint64_t index,
    char** out_result);
KUZU_C_API kuzu_state kuzu_node_val_get_property_value_at(kuzu_value* node_val, uint64_t index,
    kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_node_val_to_string(kuzu_value* node_val, char** out_result);
KUZU_C_API kuzu_state kuzu_rel_val_get_src_id_val(kuzu_value* rel_val, kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_rel_val_get_dst_id_val(kuzu_value* rel_val, kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_rel_val_get_label_val(kuzu_value* rel_val, kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_rel_val_get_property_size(kuzu_value* rel_val, uint64_t* out_value);
KUZU_C_API kuzu_state kuzu_rel_val_get_property_name_at(kuzu_value* rel_val, uint64_t index,
    char** out_result);
KUZU_C_API kuzu_state kuzu_rel_val_get_property_value_at(kuzu_value* rel_val, uint64_t index,
    kuzu_value* out_value);
KUZU_C_API kuzu_state kuzu_rel_val_to_string(kuzu_value* rel_val, char** out_result);
KUZU_C_API void kuzu_destroy_string(char* str);
KUZU_C_API void kuzu_destroy_blob(uint8_t* blob);
 
// QuerySummary
KUZU_C_API void kuzu_query_summary_destroy(kuzu_query_summary* query_summary);
KUZU_C_API double kuzu_query_summary_get_compiling_time(kuzu_query_summary* query_summary);
KUZU_C_API double kuzu_query_summary_get_execution_time(kuzu_query_summary* query_summary);
 
// Utility functions
KUZU_C_API kuzu_state kuzu_timestamp_ns_to_tm(kuzu_timestamp_ns_t timestamp, struct tm* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_ms_to_tm(kuzu_timestamp_ms_t timestamp, struct tm* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_sec_to_tm(kuzu_timestamp_sec_t timestamp,
    struct tm* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_tz_to_tm(kuzu_timestamp_tz_t timestamp, struct tm* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_to_tm(kuzu_timestamp_t timestamp, struct tm* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_ns_from_tm(struct tm tm, kuzu_timestamp_ns_t* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_ms_from_tm(struct tm tm, kuzu_timestamp_ms_t* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_sec_from_tm(struct tm tm, kuzu_timestamp_sec_t* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_tz_from_tm(struct tm tm, kuzu_timestamp_tz_t* out_result);
KUZU_C_API kuzu_state kuzu_timestamp_from_tm(struct tm tm, kuzu_timestamp_t* out_result);
KUZU_C_API kuzu_state kuzu_date_to_string(kuzu_date_t date, char** out_result);
KUZU_C_API kuzu_state kuzu_date_from_string(const char* str, kuzu_date_t* out_result);
KUZU_C_API kuzu_state kuzu_date_to_tm(kuzu_date_t date, struct tm* out_result);
KUZU_C_API kuzu_state kuzu_date_from_tm(struct tm tm, kuzu_date_t* out_result);
KUZU_C_API void kuzu_interval_to_difftime(kuzu_interval_t interval, double* out_result);
KUZU_C_API void kuzu_interval_from_difftime(double difftime, kuzu_interval_t* out_result);
 
// Version
KUZU_C_API char* kuzu_get_version();
 
KUZU_C_API uint64_t kuzu_get_storage_version();
#undef KUZU_C_API