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;
} 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_RDF_VARIANT = 57,
 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_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_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_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 kuzu_state kuzu_rdf_variant_get_type(kuzu_value* rdf_variant,
 kuzu_data_type_id* out_type);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_string(kuzu_value* rdf_variant, char** out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_blob(kuzu_value* rdf_variant, uint8_t** out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_int64(kuzu_value* rdf_variant, int64_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_int32(kuzu_value* rdf_variant, int32_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_int16(kuzu_value* rdf_variant, int16_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_int8(kuzu_value* rdf_variant, int8_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_uint64(kuzu_value* rdf_variant, uint64_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_uint32(kuzu_value* rdf_variant, uint32_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_uint16(kuzu_value* rdf_variant, uint16_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_uint8(kuzu_value* rdf_variant, uint8_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_float(kuzu_value* rdf_variant, float* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_double(kuzu_value* rdf_variant, double* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_bool(kuzu_value* rdf_variant, bool* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_date(kuzu_value* rdf_variant, kuzu_date_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_timestamp(kuzu_value* rdf_variant,
 kuzu_timestamp_t* out_result);
KUZU_C_API kuzu_state kuzu_rdf_variant_get_interval(kuzu_value* rdf_variant,
 kuzu_interval_t* 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