lbug.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 LBUG_HELPER_DLL_IMPORT __declspec(dllimport)
#define LBUG_HELPER_DLL_EXPORT __declspec(dllexport)
#define LBUG_HELPER_DLL_LOCAL
#define LBUG_HELPER_DEPRECATED __declspec(deprecated)
#else
#define LBUG_HELPER_DLL_IMPORT __attribute__((visibility("default")))
#define LBUG_HELPER_DLL_EXPORT __attribute__((visibility("default")))
#define LBUG_HELPER_DLL_LOCAL __attribute__((visibility("hidden")))
#define LBUG_HELPER_DEPRECATED __attribute__((__deprecated__))
#endif
 
#ifdef LBUG_STATIC_DEFINE
#define LBUG_API
#define LBUG_NO_EXPORT
#else
#ifndef LBUG_API
#ifdef LBUG_EXPORTS
/* We are building this library */
#define LBUG_API LBUG_HELPER_DLL_EXPORT
#else
/* We are using this library */
#define LBUG_API LBUG_HELPER_DLL_IMPORT
#endif
#endif
 
#endif
 
#ifndef LBUG_DEPRECATED
#define LBUG_DEPRECATED LBUG_HELPER_DEPRECATED
#endif
 
#ifndef LBUG_DEPRECATED_EXPORT
#define LBUG_DEPRECATED_EXPORT LBUG_API LBUG_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 LBUG_C_API extern "C" LBUG_API
#else
#define LBUG_C_API LBUG_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;
 
#if defined(__APPLE__)
    // The thread quality of service (QoS) for the worker threads.
    // This works for Swift bindings on Apple platforms only.
    uint32_t thread_qos;
#endif
} lbug_system_config;

typedef struct {
    void* _database;
} lbug_database;

typedef struct {
    void* _connection;
} lbug_connection;

typedef struct {
    void* _prepared_statement;
    void* _bound_values;
} lbug_prepared_statement;

typedef struct {
    void* _query_result;
    bool _is_owned_by_cpp;
} lbug_query_result;

typedef struct {
    void* _flat_tuple;
    bool _is_owned_by_cpp;
} lbug_flat_tuple;

typedef struct {
    void* _data_type;
} lbug_logical_type;

typedef struct {
    void* _value;
    bool _is_owned_by_cpp;
} lbug_value;

typedef struct {
    uint64_t table_id;
    uint64_t offset;
} lbug_internal_id_t;

typedef struct {
    // Days since 1970-01-01 00:00:00 UTC.
    int32_t days;
} lbug_date_t;

typedef struct {
    // Nanoseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} lbug_timestamp_ns_t;

typedef struct {
    // Milliseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} lbug_timestamp_ms_t;

typedef struct {
    // Seconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} lbug_timestamp_sec_t;

typedef struct {
    // Microseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} lbug_timestamp_tz_t;

typedef struct {
    // Microseconds since 1970-01-01 00:00:00 UTC.
    int64_t value;
} lbug_timestamp_t;

typedef struct {
    int32_t months;
    int32_t days;
    int64_t micros;
} lbug_interval_t;

typedef struct {
    void* _query_summary;
} lbug_query_summary;
 
typedef struct {
    uint64_t low;
    int64_t high;
} lbug_int128_t;

typedef enum {
    LBUG_ANY = 0,
    LBUG_NODE = 10,
    LBUG_REL = 11,
    LBUG_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.
    LBUG_SERIAL = 13,
    // fixed size types
    LBUG_BOOL = 22,
    LBUG_INT64 = 23,
    LBUG_INT32 = 24,
    LBUG_INT16 = 25,
    LBUG_INT8 = 26,
    LBUG_UINT64 = 27,
    LBUG_UINT32 = 28,
    LBUG_UINT16 = 29,
    LBUG_UINT8 = 30,
    LBUG_INT128 = 31,
    LBUG_DOUBLE = 32,
    LBUG_FLOAT = 33,
    LBUG_DATE = 34,
    LBUG_TIMESTAMP = 35,
    LBUG_TIMESTAMP_SEC = 36,
    LBUG_TIMESTAMP_MS = 37,
    LBUG_TIMESTAMP_NS = 38,
    LBUG_TIMESTAMP_TZ = 39,
    LBUG_INTERVAL = 40,
    LBUG_DECIMAL = 41,
    LBUG_INTERNAL_ID = 42,
    // variable size types
    LBUG_STRING = 50,
    LBUG_BLOB = 51,
    LBUG_LIST = 52,
    LBUG_ARRAY = 53,
    LBUG_STRUCT = 54,
    LBUG_MAP = 55,
    LBUG_UNION = 56,
    LBUG_POINTER = 58,
    LBUG_UUID = 59
} lbug_data_type_id;

typedef enum { LbugSuccess = 0, LbugError = 1 } lbug_state;
 
// Database
LBUG_C_API lbug_state lbug_database_init(const char* database_path,
    lbug_system_config system_config, lbug_database* out_database);
LBUG_C_API void lbug_database_destroy(lbug_database* database);
 
LBUG_C_API lbug_system_config lbug_default_system_config();
 
// Connection
LBUG_C_API lbug_state lbug_connection_init(lbug_database* database,
    lbug_connection* out_connection);
LBUG_C_API void lbug_connection_destroy(lbug_connection* connection);
LBUG_C_API lbug_state lbug_connection_set_max_num_thread_for_exec(lbug_connection* connection,
    uint64_t num_threads);

LBUG_C_API lbug_state lbug_connection_get_max_num_thread_for_exec(lbug_connection* connection,
    uint64_t* out_result);
LBUG_C_API lbug_state lbug_connection_query(lbug_connection* connection, const char* query,
    lbug_query_result* out_query_result);
LBUG_C_API lbug_state lbug_connection_prepare(lbug_connection* connection, const char* query,
    lbug_prepared_statement* out_prepared_statement);
LBUG_C_API lbug_state lbug_connection_execute(lbug_connection* connection,
    lbug_prepared_statement* prepared_statement, lbug_query_result* out_query_result);
LBUG_C_API void lbug_connection_interrupt(lbug_connection* connection);
LBUG_C_API lbug_state lbug_connection_set_query_timeout(lbug_connection* connection,
    uint64_t timeout_in_ms);
 
// PreparedStatement
LBUG_C_API void lbug_prepared_statement_destroy(lbug_prepared_statement* prepared_statement);
LBUG_C_API bool lbug_prepared_statement_is_success(lbug_prepared_statement* prepared_statement);
LBUG_C_API char* lbug_prepared_statement_get_error_message(
    lbug_prepared_statement* prepared_statement);
LBUG_C_API lbug_state lbug_prepared_statement_bind_bool(lbug_prepared_statement* prepared_statement,
    const char* param_name, bool value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_int64(
    lbug_prepared_statement* prepared_statement, const char* param_name, int64_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_int32(
    lbug_prepared_statement* prepared_statement, const char* param_name, int32_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_int16(
    lbug_prepared_statement* prepared_statement, const char* param_name, int16_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_int8(lbug_prepared_statement* prepared_statement,
    const char* param_name, int8_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_uint64(
    lbug_prepared_statement* prepared_statement, const char* param_name, uint64_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_uint32(
    lbug_prepared_statement* prepared_statement, const char* param_name, uint32_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_uint16(
    lbug_prepared_statement* prepared_statement, const char* param_name, uint16_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_uint8(
    lbug_prepared_statement* prepared_statement, const char* param_name, uint8_t value);

LBUG_C_API lbug_state lbug_prepared_statement_bind_double(
    lbug_prepared_statement* prepared_statement, const char* param_name, double value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_float(
    lbug_prepared_statement* prepared_statement, const char* param_name, float value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_date(lbug_prepared_statement* prepared_statement,
    const char* param_name, lbug_date_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_timestamp_ns(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_timestamp_ns_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_timestamp_sec(
    lbug_prepared_statement* prepared_statement, const char* param_name,
    lbug_timestamp_sec_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_timestamp_tz(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_timestamp_tz_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_timestamp_ms(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_timestamp_ms_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_timestamp(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_timestamp_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_interval(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_interval_t value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_string(
    lbug_prepared_statement* prepared_statement, const char* param_name, const char* value);
LBUG_C_API lbug_state lbug_prepared_statement_bind_value(
    lbug_prepared_statement* prepared_statement, const char* param_name, lbug_value* value);
 
// QueryResult
LBUG_C_API void lbug_query_result_destroy(lbug_query_result* query_result);
LBUG_C_API bool lbug_query_result_is_success(lbug_query_result* query_result);
LBUG_C_API char* lbug_query_result_get_error_message(lbug_query_result* query_result);
LBUG_C_API uint64_t lbug_query_result_get_num_columns(lbug_query_result* query_result);
LBUG_C_API lbug_state lbug_query_result_get_column_name(lbug_query_result* query_result,
    uint64_t index, char** out_column_name);
LBUG_C_API lbug_state lbug_query_result_get_column_data_type(lbug_query_result* query_result,
    uint64_t index, lbug_logical_type* out_column_data_type);
LBUG_C_API uint64_t lbug_query_result_get_num_tuples(lbug_query_result* query_result);
LBUG_C_API lbug_state lbug_query_result_get_query_summary(lbug_query_result* query_result,
    lbug_query_summary* out_query_summary);
LBUG_C_API bool lbug_query_result_has_next(lbug_query_result* query_result);
LBUG_C_API lbug_state lbug_query_result_get_next(lbug_query_result* query_result,
    lbug_flat_tuple* out_flat_tuple);
LBUG_C_API bool lbug_query_result_has_next_query_result(lbug_query_result* query_result);
LBUG_C_API lbug_state lbug_query_result_get_next_query_result(lbug_query_result* query_result,
    lbug_query_result* out_next_query_result);

LBUG_C_API char* lbug_query_result_to_string(lbug_query_result* query_result);
LBUG_C_API void lbug_query_result_reset_iterator(lbug_query_result* query_result);

LBUG_C_API lbug_state lbug_query_result_get_arrow_schema(lbug_query_result* query_result,
    struct ArrowSchema* out_schema);

LBUG_C_API lbug_state lbug_query_result_get_next_arrow_chunk(lbug_query_result* query_result,
    int64_t chunk_size, struct ArrowArray* out_arrow_array);
 
// FlatTuple
LBUG_C_API void lbug_flat_tuple_destroy(lbug_flat_tuple* flat_tuple);
LBUG_C_API lbug_state lbug_flat_tuple_get_value(lbug_flat_tuple* flat_tuple, uint64_t index,
    lbug_value* out_value);
LBUG_C_API char* lbug_flat_tuple_to_string(lbug_flat_tuple* flat_tuple);
 
// DataType
// TODO(Chang): Refactor the datatype constructor to follow the cpp way of creating dataTypes.
LBUG_C_API void lbug_data_type_create(lbug_data_type_id id, lbug_logical_type* child_type,
    uint64_t num_elements_in_array, lbug_logical_type* out_type);
LBUG_C_API void lbug_data_type_clone(lbug_logical_type* data_type, lbug_logical_type* out_type);
LBUG_C_API void lbug_data_type_destroy(lbug_logical_type* data_type);
LBUG_C_API bool lbug_data_type_equals(lbug_logical_type* data_type1, lbug_logical_type* data_type2);
LBUG_C_API lbug_data_type_id lbug_data_type_get_id(lbug_logical_type* data_type);
LBUG_C_API lbug_state lbug_data_type_get_num_elements_in_array(lbug_logical_type* data_type,
    uint64_t* out_result);
 
// Value
LBUG_C_API lbug_value* lbug_value_create_null();
LBUG_C_API lbug_value* lbug_value_create_null_with_data_type(lbug_logical_type* data_type);
LBUG_C_API bool lbug_value_is_null(lbug_value* value);
LBUG_C_API void lbug_value_set_null(lbug_value* value, bool is_null);
LBUG_C_API lbug_value* lbug_value_create_default(lbug_logical_type* data_type);
LBUG_C_API lbug_value* lbug_value_create_bool(bool val_);
LBUG_C_API lbug_value* lbug_value_create_int8(int8_t val_);
LBUG_C_API lbug_value* lbug_value_create_int16(int16_t val_);
LBUG_C_API lbug_value* lbug_value_create_int32(int32_t val_);
LBUG_C_API lbug_value* lbug_value_create_int64(int64_t val_);
LBUG_C_API lbug_value* lbug_value_create_uint8(uint8_t val_);
LBUG_C_API lbug_value* lbug_value_create_uint16(uint16_t val_);
LBUG_C_API lbug_value* lbug_value_create_uint32(uint32_t val_);
LBUG_C_API lbug_value* lbug_value_create_uint64(uint64_t val_);
LBUG_C_API lbug_value* lbug_value_create_int128(lbug_int128_t val_);
LBUG_C_API lbug_value* lbug_value_create_float(float val_);
LBUG_C_API lbug_value* lbug_value_create_double(double val_);
LBUG_C_API lbug_value* lbug_value_create_internal_id(lbug_internal_id_t val_);
LBUG_C_API lbug_value* lbug_value_create_date(lbug_date_t val_);
LBUG_C_API lbug_value* lbug_value_create_timestamp_ns(lbug_timestamp_ns_t val_);
LBUG_C_API lbug_value* lbug_value_create_timestamp_ms(lbug_timestamp_ms_t val_);
LBUG_C_API lbug_value* lbug_value_create_timestamp_sec(lbug_timestamp_sec_t val_);
LBUG_C_API lbug_value* lbug_value_create_timestamp_tz(lbug_timestamp_tz_t val_);
LBUG_C_API lbug_value* lbug_value_create_timestamp(lbug_timestamp_t val_);
LBUG_C_API lbug_value* lbug_value_create_interval(lbug_interval_t val_);
LBUG_C_API lbug_value* lbug_value_create_string(const char* val_);
LBUG_C_API lbug_state lbug_value_create_list(uint64_t num_elements, lbug_value** elements,
    lbug_value** out_value);
LBUG_C_API lbug_state lbug_value_create_struct(uint64_t num_fields, const char** field_names,
    lbug_value** field_values, lbug_value** out_value);
LBUG_C_API lbug_state lbug_value_create_map(uint64_t num_fields, lbug_value** keys,
    lbug_value** values, lbug_value** out_value);
LBUG_C_API lbug_value* lbug_value_clone(lbug_value* value);
LBUG_C_API void lbug_value_copy(lbug_value* value, lbug_value* other);
LBUG_C_API void lbug_value_destroy(lbug_value* value);
LBUG_C_API lbug_state lbug_value_get_list_size(lbug_value* value, uint64_t* out_result);
LBUG_C_API lbug_state lbug_value_get_list_element(lbug_value* value, uint64_t index,
    lbug_value* out_value);
LBUG_C_API lbug_state lbug_value_get_struct_num_fields(lbug_value* value, uint64_t* out_result);
LBUG_C_API lbug_state lbug_value_get_struct_field_name(lbug_value* value, uint64_t index,
    char** out_result);
LBUG_C_API lbug_state lbug_value_get_struct_field_value(lbug_value* value, uint64_t index,
    lbug_value* out_value);

LBUG_C_API lbug_state lbug_value_get_map_size(lbug_value* value, uint64_t* out_result);
LBUG_C_API lbug_state lbug_value_get_map_key(lbug_value* value, uint64_t index,
    lbug_value* out_key);
LBUG_C_API lbug_state lbug_value_get_map_value(lbug_value* value, uint64_t index,
    lbug_value* out_value);
LBUG_C_API lbug_state lbug_value_get_recursive_rel_node_list(lbug_value* value,
    lbug_value* out_value);

LBUG_C_API lbug_state lbug_value_get_recursive_rel_rel_list(lbug_value* value,
    lbug_value* out_value);
LBUG_C_API void lbug_value_get_data_type(lbug_value* value, lbug_logical_type* out_type);
LBUG_C_API lbug_state lbug_value_get_bool(lbug_value* value, bool* out_result);
LBUG_C_API lbug_state lbug_value_get_int8(lbug_value* value, int8_t* out_result);
LBUG_C_API lbug_state lbug_value_get_int16(lbug_value* value, int16_t* out_result);
LBUG_C_API lbug_state lbug_value_get_int32(lbug_value* value, int32_t* out_result);
LBUG_C_API lbug_state lbug_value_get_int64(lbug_value* value, int64_t* out_result);
LBUG_C_API lbug_state lbug_value_get_uint8(lbug_value* value, uint8_t* out_result);
LBUG_C_API lbug_state lbug_value_get_uint16(lbug_value* value, uint16_t* out_result);
LBUG_C_API lbug_state lbug_value_get_uint32(lbug_value* value, uint32_t* out_result);
LBUG_C_API lbug_state lbug_value_get_uint64(lbug_value* value, uint64_t* out_result);
LBUG_C_API lbug_state lbug_value_get_int128(lbug_value* value, lbug_int128_t* out_result);
LBUG_C_API lbug_state lbug_int128_t_from_string(const char* str, lbug_int128_t* out_result);
LBUG_C_API lbug_state lbug_int128_t_to_string(lbug_int128_t val, char** out_result);
LBUG_C_API lbug_state lbug_value_get_float(lbug_value* value, float* out_result);
LBUG_C_API lbug_state lbug_value_get_double(lbug_value* value, double* out_result);
LBUG_C_API lbug_state lbug_value_get_internal_id(lbug_value* value, lbug_internal_id_t* out_result);
LBUG_C_API lbug_state lbug_value_get_date(lbug_value* value, lbug_date_t* out_result);
LBUG_C_API lbug_state lbug_value_get_timestamp(lbug_value* value, lbug_timestamp_t* out_result);
LBUG_C_API lbug_state lbug_value_get_timestamp_ns(lbug_value* value,
    lbug_timestamp_ns_t* out_result);
LBUG_C_API lbug_state lbug_value_get_timestamp_ms(lbug_value* value,
    lbug_timestamp_ms_t* out_result);
LBUG_C_API lbug_state lbug_value_get_timestamp_sec(lbug_value* value,
    lbug_timestamp_sec_t* out_result);
LBUG_C_API lbug_state lbug_value_get_timestamp_tz(lbug_value* value,
    lbug_timestamp_tz_t* out_result);
LBUG_C_API lbug_state lbug_value_get_interval(lbug_value* value, lbug_interval_t* out_result);
LBUG_C_API lbug_state lbug_value_get_decimal_as_string(lbug_value* value, char** out_result);
LBUG_C_API lbug_state lbug_value_get_string(lbug_value* value, char** out_result);
LBUG_C_API lbug_state lbug_value_get_blob(lbug_value* value, uint8_t** out_result);
LBUG_C_API lbug_state lbug_value_get_uuid(lbug_value* value, char** out_result);
LBUG_C_API char* lbug_value_to_string(lbug_value* value);
LBUG_C_API lbug_state lbug_node_val_get_id_val(lbug_value* node_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_node_val_get_label_val(lbug_value* node_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_node_val_get_property_size(lbug_value* node_val, uint64_t* out_value);
LBUG_C_API lbug_state lbug_node_val_get_property_name_at(lbug_value* node_val, uint64_t index,
    char** out_result);
LBUG_C_API lbug_state lbug_node_val_get_property_value_at(lbug_value* node_val, uint64_t index,
    lbug_value* out_value);
LBUG_C_API lbug_state lbug_node_val_to_string(lbug_value* node_val, char** out_result);
LBUG_C_API lbug_state lbug_rel_val_get_id_val(lbug_value* rel_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_rel_val_get_src_id_val(lbug_value* rel_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_rel_val_get_dst_id_val(lbug_value* rel_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_rel_val_get_label_val(lbug_value* rel_val, lbug_value* out_value);
LBUG_C_API lbug_state lbug_rel_val_get_property_size(lbug_value* rel_val, uint64_t* out_value);
LBUG_C_API lbug_state lbug_rel_val_get_property_name_at(lbug_value* rel_val, uint64_t index,
    char** out_result);
LBUG_C_API lbug_state lbug_rel_val_get_property_value_at(lbug_value* rel_val, uint64_t index,
    lbug_value* out_value);
LBUG_C_API lbug_state lbug_rel_val_to_string(lbug_value* rel_val, char** out_result);
LBUG_C_API void lbug_destroy_string(char* str);
LBUG_C_API void lbug_destroy_blob(uint8_t* blob);
 
// QuerySummary
LBUG_C_API void lbug_query_summary_destroy(lbug_query_summary* query_summary);
LBUG_C_API double lbug_query_summary_get_compiling_time(lbug_query_summary* query_summary);
LBUG_C_API double lbug_query_summary_get_execution_time(lbug_query_summary* query_summary);
 
// Utility functions
LBUG_C_API lbug_state lbug_timestamp_ns_to_tm(lbug_timestamp_ns_t timestamp, struct tm* out_result);
LBUG_C_API lbug_state lbug_timestamp_ms_to_tm(lbug_timestamp_ms_t timestamp, struct tm* out_result);
LBUG_C_API lbug_state lbug_timestamp_sec_to_tm(lbug_timestamp_sec_t timestamp,
    struct tm* out_result);
LBUG_C_API lbug_state lbug_timestamp_tz_to_tm(lbug_timestamp_tz_t timestamp, struct tm* out_result);
LBUG_C_API lbug_state lbug_timestamp_to_tm(lbug_timestamp_t timestamp, struct tm* out_result);
LBUG_C_API lbug_state lbug_timestamp_ns_from_tm(struct tm tm, lbug_timestamp_ns_t* out_result);
LBUG_C_API lbug_state lbug_timestamp_ms_from_tm(struct tm tm, lbug_timestamp_ms_t* out_result);
LBUG_C_API lbug_state lbug_timestamp_sec_from_tm(struct tm tm, lbug_timestamp_sec_t* out_result);
LBUG_C_API lbug_state lbug_timestamp_tz_from_tm(struct tm tm, lbug_timestamp_tz_t* out_result);
LBUG_C_API lbug_state lbug_timestamp_from_tm(struct tm tm, lbug_timestamp_t* out_result);
LBUG_C_API lbug_state lbug_date_to_string(lbug_date_t date, char** out_result);
LBUG_C_API lbug_state lbug_date_from_string(const char* str, lbug_date_t* out_result);
LBUG_C_API lbug_state lbug_date_to_tm(lbug_date_t date, struct tm* out_result);
LBUG_C_API lbug_state lbug_date_from_tm(struct tm tm, lbug_date_t* out_result);
LBUG_C_API void lbug_interval_to_difftime(lbug_interval_t interval, double* out_result);
LBUG_C_API void lbug_interval_from_difftime(double difftime, lbug_interval_t* out_result);
 
// Version
LBUG_C_API char* lbug_get_version();

LBUG_C_API uint64_t lbug_get_storage_version();
#undef LBUG_C_API