kvstore.h

Go to the documentation of this file.

/*-
 *
 *  This file is part of Oracle NoSQL Database
 *  Copyright (C) 2014, 2018 Oracle and/or its affiliates.  All rights reserved.
 *
 * If you have received this file as part of Oracle NoSQL Database the
 * following applies to the work as a whole:
 *
 *   Oracle NoSQL Database server software is free software: you can
 *   redistribute it and/or modify it under the terms of the GNU Affero
 *   General Public License as published by the Free Software Foundation,
 *   version 3.
 *
 *   Oracle NoSQL Database is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *   Affero General Public License for more details.
 *
 * If you have received this file as part of Oracle NoSQL Database Client or
 * distributed separately the following applies:
 *
 *   Oracle NoSQL Database client software is free software: you can
 *   redistribute it and/or modify it under the terms of the Apache License
 *   as published by the Apache Software Foundation, version 2.0.
 *
 * You should have received a copy of the GNU Affero General Public License
 * and/or the Apache License in the LICENSE file along with Oracle NoSQL
 * Database client or server distribution.  If not, see
 * <http://www.gnu.org/licenses/>
 * or
 * <http://www.apache.org/licenses/LICENSE-2.0>.
 *
 * An active Oracle commercial licensing agreement for this product supersedes
 * these licenses and in such case the license notices, but not the copyright
 * notice, may be removed by you in connection with your distribution that is
 * in accordance with the commercial licensing terms.
 *
 * For more information please contact:
 *
 * berkeleydb-info_us@oracle.com
 *
 */

#ifndef _KVSTORE_H_
#define _KVSTORE_H_

#if defined(__cplusplus)
extern "C" {
#endif

typedef enum {
    KV_CONSISTENCY_ABSOLUTE = 0,    
    KV_CONSISTENCY_NONE,            
    KV_CONSISTENCY_TIME,            
    KV_CONSISTENCY_VERSION,         
    KV_CONSISTENCY_NONE_NO_MASTER,  
} kv_consistency_enum;

typedef enum {
    KV_SYNC_NONE = 1,           
    KV_SYNC_FLUSH = 2,          
    KV_SYNC_WRITE_NO_SYNC = 3   
} kv_sync_policy_enum;

typedef enum {
    KV_ACK_ALL = 1,     
    KV_ACK_NONE = 2,    
    KV_ACK_MAJORITY = 3 
} kv_ack_policy_enum;

#define KV_DURABILITY_COMMIT_NO_SYNC  \
    (KV_SYNC_NONE | (KV_SYNC_NONE << 8) | (KV_ACK_MAJORITY << 16))

#define KV_DURABILITY_COMMIT_SYNC   \
    (KV_SYNC_FLUSH | (KV_SYNC_NONE << 8) | (KV_ACK_MAJORITY << 16))

#define KV_DURABILITY_COMMIT_WRITE_NO_SYNC                              \
    (KV_SYNC_WRITE_NO_SYNC | (KV_SYNC_NONE << 8) | (KV_ACK_MAJORITY << 16))

typedef enum {
    KV_RETURN_ROW_NONE = 0,     
    KV_RETURN_ROW_ALL,          
    KV_RETURN_ROW_VALUE,        
    KV_RETURN_ROW_VERSION       
} kv_return_row_version_enum;

typedef enum {
    FIELD_TYPE_INT = 0,      
    FIELD_TYPE_LONG,         
    FIELD_TYPE_FLOAT,        
    FIELD_TYPE_DOUBLE,       
    FIELD_TYPE_STRING,       
    FIELD_TYPE_BOOLEAN,      
    FIELD_TYPE_BYTES,        
    FIELD_TYPE_ARRAY,        
    FIELD_TYPE_MAP,          
    FIELD_TYPE_RECORD,       
    FIELD_TYPE_NULL          
} kv_field_type_enum;

typedef enum {
    KV_DIRECTION_FORWARD,   
    KV_DIRECTION_REVERSE,   
    KV_DIRECTION_UNORDERED  
} kv_direction_enum;

typedef enum {
    KV_OP_DELETE = 0,           
    KV_OP_DELETE_IF_VERSION,    
    KV_OP_PUT,                  
    KV_OP_PUT_IF_ABSENT,        
    KV_OP_PUT_IF_PRESENT,       
    KV_OP_PUT_IF_VERSION,       
} kv_operation_enum;

typedef enum {
    KV_SUCCESS = 0,                 
    KV_ROW_ALREADY_EXISTS = 1,      
    KV_ROW_NOT_FOUND = 2,           
    KV_VERSION_NOT_MATCH = 3,       
    KV_ERROR_OPEN_STORE = -1,       
    KV_INVALID_ARGUMENT = -2,       
    KV_INVALID_STORE = -3,          
    KV_NO_MEMORY = -4,              
    KV_NO_SUCH_OBJECT = -5,         
    KV_FIELD_CAST_INCOMPATIBLE = -6,
    KV_FIELD_INVALID_TYPE = -7,     
    KV_FIELD_NOT_EXISTS = -8,       
    KV_ERROR_JSON_PARSE = -9,       
    KV_CANCELLATION = -20,          
    KV_CONSISTENCY = -21,           
    KV_DURABILITY = -22,            
    KV_ERROR_THRIFT = -23,          
    KV_EXECUTION = -24,             
    KV_FAULT = -25,                 
    KV_ILLEGAL_ARGUMENT = -26,      
    KV_INTERRUPTTED = -27,          
    KV_INTERRUPTED = -27,           
    KV_ITERATOR_TIMEOUT = -28,      
    KV_TABLE_OP_EXECUTION = -29,    
    KV_PROXY = -30,                 
    KV_REQUEST_TIMEOUT = -31,       
    KV_TIMEOUT = -32,               
    KV_ERROR_START_PROXY = -50,     
    KV_ERROR_SHUTDOWN_PROXY = -51,  
    KV_ERROR_UNKNOWN = -100         
} kv_error_t;

typedef enum {
    KV_FALSE = 0,   
    KV_TRUE         
} kv_boolean_t;

typedef enum {
    HOURS = 0,    
    DAYS          
} kv_ttl_timeunit_enum;

typedef int kv_int_t;
typedef long long kv_long_t;
typedef float kv_float_t;
typedef double kv_double_t;
typedef long long kv_timeout_t;
typedef int kv_durability_t;

typedef struct store_impl kv_store_t;

typedef struct config_impl kv_config_t;

typedef struct proxy_config_impl kv_proxy_config_t;

typedef struct consistency_impl kv_consistency_t;

typedef struct iterator_impl kv_iterator_t;

typedef struct field_range_impl kv_field_range_t;

typedef struct result_impl kv_result_t;

typedef struct statement_result_impl kv_statement_result_t;

typedef struct future_impl kv_future_t;

typedef struct {
  const unsigned char *future_bytes;    
  kv_int_t size;                        
} kv_execution_id_t;

typedef struct operations_impl kv_operations_t;

typedef struct operation_results_impl kv_operation_results_t;

typedef struct field_impl kv_field_t;

typedef struct read_options_impl kv_read_options_t;

typedef struct write_options_impl kv_write_options_t;

typedef struct version_impl kv_version_t;

typedef struct row_impl kv_row_t;

typedef struct arraylist_impl kv_array_t;

typedef struct hashmap_impl kv_map_t;

typedef struct hashmap_impl kv_record_t;

typedef void (*kv_output_func)(const char *);

#define KV_ANONYMOUS "[]"

void kv_driver_version(kv_int_t *major, kv_int_t *minor, kv_int_t *patch);

const char *kv_driver_package_version();

kv_error_t kv_proxy_version(kv_store_t *store, const char **versionp);

kv_error_t kv_open_store(kv_store_t **storep,
                         const char *host,
                         int port,
                         const kv_config_t *config);

kv_error_t kv_open_store_with_proxy(kv_store_t **storep,
                                    const char *host, int port,
                                    const kv_config_t *config,
                                    const kv_proxy_config_t *proxy_config);

void kv_close_store(kv_store_t **storep);


kv_error_t kv_shutdown_proxy(kv_store_t *store);

kv_error_t kv_create_config(const char *store_name,
                            const char *host,
                            int port,
                            kv_config_t **configp);
kv_error_t kv_config_add_host_port(kv_config_t *config,
                                   const char *host,
                                   int port);
kv_error_t kv_config_set_consistency(kv_config_t *config,
                                     kv_consistency_t *consistency);
kv_error_t kv_config_set_durability(kv_config_t *config,
                                    kv_durability_t durability);

kv_error_t kv_config_set_request_timeout(kv_config_t *config,
                                         kv_timeout_t timeout);

kv_error_t kv_config_set_iterator_max_results(kv_config_t *config,
                                              kv_long_t max_results_num);
kv_error_t kv_config_set_auth_user(kv_config_t *config, const char *user_name);

kv_error_t kv_config_add_read_zone(kv_config_t *config,
                                   const char *read_zone);

const char * kv_config_get_store_name(const kv_config_t *config);

kv_consistency_t * kv_config_get_consistency(const kv_config_t *config);

kv_durability_t kv_config_get_durability(const kv_config_t *config);

kv_timeout_t kv_config_get_request_timeout(const kv_config_t *config);

kv_long_t kv_config_get_iterator_max_results(const kv_config_t *config);

kv_int_t kv_config_helper_hosts_size(const kv_config_t *config);

const char * kv_config_get_helper_host(const kv_config_t *config,
                                       kv_int_t index);
const char *kv_config_get_auth_user(const kv_config_t *config);

kv_int_t kv_config_read_zones_size(const kv_config_t *config);

const char *
kv_config_get_read_zone(const kv_config_t *config, kv_int_t index);


void kv_release_config(kv_config_t **configp);

kv_error_t kv_create_proxy_config(const char *kvproxy_path_to_jar,
                                  const char *kvclient_path_to_jar,
                                  kv_proxy_config_t **configp);

kv_error_t kv_proxy_config_set_iterator_max_results(kv_proxy_config_t *config,
                                                    kv_long_t max_results_num);

kv_error_t
kv_proxy_config_set_iterator_max_concurrent_requests(kv_proxy_config_t *config,
                                              kv_int_t max_concurrent_requests);

kv_error_t
kv_proxy_config_set_iterator_max_results_batches(kv_proxy_config_t *config,
                                                 kv_int_t max_results_batches);

kv_error_t
kv_proxy_config_set_iterator_expiration_timeout(kv_proxy_config_t *config,
                                                kv_timeout_t timeout_ms);

kv_error_t
kv_proxy_config_set_max_open_iterators(kv_proxy_config_t *config,
                                       kv_int_t max_opened_iterators);
kv_error_t kv_proxy_config_set_num_threads(kv_proxy_config_t *config,
                                           kv_int_t num_threads);

kv_error_t
kv_proxy_config_set_request_limits(kv_proxy_config_t *config,
                                   kv_int_t max_active_requests,
                                   kv_int_t request_threshold_percent,
                                   kv_int_t node_limit_percent);

kv_error_t kv_proxy_config_set_timeouts(kv_proxy_config_t *config,
                                        kv_timeout_t read_timeout,
                                        kv_timeout_t request_timeout,
                                        kv_timeout_t socket_open_timeout);

kv_error_t
kv_proxy_config_set_sec_prop_file(kv_proxy_config_t *config,
                                  const char *security_property_file);

kv_long_t
kv_proxy_config_get_iterator_max_results(const kv_proxy_config_t *config);

kv_int_t kv_proxy_config_get_iterator_max_concurrent_requests(
            const kv_proxy_config_t *config);

kv_int_t kv_proxy_config_get_iterator_max_results_batches(
            const kv_proxy_config_t *config);

kv_timeout_t
kv_proxy_config_get_iterator_expiration_timeout(
    const kv_proxy_config_t *config);

kv_int_t
kv_proxy_config_get_max_open_iterators(const kv_proxy_config_t *config);

kv_int_t kv_proxy_config_get_num_threads(const kv_proxy_config_t *config);


void kv_proxy_config_get_request_limits(const kv_proxy_config_t *config,
                                        kv_int_t *max_active_requests,
                                        kv_int_t *request_threshold_percent,
                                        kv_int_t *node_limit_percent);

void kv_proxy_config_get_timeouts(const kv_proxy_config_t *config,
                                  kv_timeout_t *read_timeout,
                                  kv_timeout_t *request_timeout,
                                  kv_timeout_t *socket_open_timeout);

const char *kv_proxy_config_get_sec_prop_file(const kv_proxy_config_t *config);

void kv_release_proxy_config(kv_proxy_config_t **configp);
kv_error_t kv_table_put(kv_store_t *store,
                        const char *table_name,
                        const kv_row_t *row,
                        kv_version_t **new_version);

kv_error_t kv_table_put_with_options(kv_store_t *store,
                                     const char *table_name,
                                     const kv_row_t *row,
                                     const kv_write_options_t *options,
                                     kv_return_row_version_enum choice,
                                     kv_result_t **resultp);

kv_error_t kv_table_put_if_absent(kv_store_t *store,
                                  const char *table_name,
                                  const kv_row_t *row,
                                  kv_version_t **new_version);

kv_error_t
kv_table_put_if_absent_with_options(kv_store_t *store,
                                    const char *table_name,
                                    const kv_row_t *row,
                                    const kv_write_options_t *options,
                                    kv_return_row_version_enum choice,
                                    kv_result_t **resultp);

kv_error_t kv_table_put_if_present(kv_store_t *store,
                                   const char *table_name,
                                   const kv_row_t *row,
                                   kv_version_t **new_version);

kv_error_t
kv_table_put_if_present_with_options(kv_store_t *store,
                                     const char *table_name,
                                     const kv_row_t *row,
                                     const kv_write_options_t *options,
                                     kv_return_row_version_enum choice,
                                     kv_result_t **resultp);

kv_error_t kv_table_put_if_version(kv_store_t *store,
                                   const char *table_name,
                                   const kv_row_t *row,
                                   const kv_version_t *if_version,
                                   kv_version_t **new_version);

kv_error_t
kv_table_put_if_version_with_options(kv_store_t *store,
                                     const char *table_name,
                                     const kv_row_t *row,
                                     const kv_version_t *if_version,
                                     const kv_write_options_t *options,
                                     kv_return_row_version_enum choice,
                                     kv_result_t **resultp);

kv_error_t kv_table_get(kv_store_t *store,
                        const char *table_name,
                        const kv_row_t *key,
                        kv_row_t **rowp);

kv_error_t kv_table_get_with_options(kv_store_t *store,
                                     const char *table_name,
                                     const kv_row_t *key,
                                     const kv_read_options_t *options,
                                     kv_result_t **resultp);

kv_int_t kv_table_delete(kv_store_t *store,
                         const char * table_name,
                         const kv_row_t *key);

kv_int_t
kv_table_delete_with_options(kv_store_t *store,
                             const char * table_name,
                             const kv_row_t *key,
                             const kv_write_options_t *options,
                             kv_return_row_version_enum choice,
                             kv_result_t **resultp);

kv_int_t kv_table_delete_if_version(kv_store_t *store,
                                    const char * table_name,
                                    const kv_row_t *key,
                                    const kv_version_t *if_version);

kv_int_t
kv_table_delete_if_version_with_options(kv_store_t *store,
                                        const char * table_name,
                                        const kv_row_t *key,
                                        const kv_version_t *if_version,
                                        const kv_write_options_t *options,
                                        kv_return_row_version_enum choice,
                                        kv_result_t **resultp);


kv_error_t kv_table_multi_get(kv_store_t *store,
                              const char *table_name,
                              const kv_row_t *key,
                              kv_boolean_t keyonly,
                              const kv_field_range_t *range,
                              const char **included_tables,
                              const kv_read_options_t *options,
                              kv_iterator_t ** iteratorp);

kv_int_t kv_table_multi_delete(kv_store_t *store,
                               const char *table_name,
                               const kv_row_t *key,
                               const kv_field_range_t *range,
                               const char **included_tables,
                               const kv_write_options_t *options);

kv_error_t kv_table_iterator(kv_store_t *store,
                             const char *table_name,
                             const kv_row_t *key,
                             kv_boolean_t keyonly,
                             const kv_field_range_t *range,
                             const char **included_tables,
                             kv_direction_enum direction,
                             const kv_read_options_t *options,
                             kv_long_t max_results,
                             kv_iterator_t ** iteratorp);

kv_error_t kv_table_iterator_multi(kv_store_t *store,
                             const char *table_name,
                             kv_row_t **keys,
                             kv_boolean_t keyonly,
                             const kv_field_range_t *range,
                             const char **included_tables,
                             kv_direction_enum direction,
                             const kv_read_options_t *options,
                             kv_long_t max_results,
                             kv_iterator_t ** iteratorp);

kv_error_t kv_index_iterator(kv_store_t *store,
                             const char *table_name,
                             const char *index_name,
                             const kv_row_t *key,
                             kv_boolean_t keyonly,
                             const kv_field_range_t *range,
                             const char **included_tables,
                             kv_direction_enum direction,
                             const kv_read_options_t *options,
                             kv_long_t batch_size,
                             kv_iterator_t ** iteratorp);

kv_error_t kv_iterator_next(kv_iterator_t *iterator);

const kv_result_t * kv_iterator_get_result(kv_iterator_t *iterator);

kv_int_t kv_iterator_size(const kv_iterator_t *iterator);

void kv_release_iterator(kv_iterator_t **iteratorp);

kv_error_t kv_table_execute_operations(kv_store_t *store,
                                       const kv_operations_t *list,
                                       const kv_write_options_t *options,
                                       kv_operation_results_t **resultsp);
kv_error_t kv_table_execute_sync(kv_store_t *store,
                                 const char *statement,
                                 kv_statement_result_t **resultp);
kv_error_t kv_table_execute(kv_store_t *store,
                            const char *statement,
                            kv_future_t **futurep);

kv_error_t kv_get_future(kv_store_t *store,
                         const kv_execution_id_t *id,
                         kv_future_t **futurep);

kv_error_t kv_refresh_tables(kv_store_t *store);
kv_operations_t *kv_create_operations();

kv_error_t kv_operations_set_copy(kv_operations_t *operations);

kv_error_t kv_operations_set_donate(kv_operations_t *operations);

kv_error_t kv_create_table_put_op(kv_operations_t *operations,
                                  const char *table_name,
                                  const kv_row_t *row,
                                  kv_return_row_version_enum choice,
                                  kv_boolean_t abort_on_failure);

kv_error_t kv_create_table_put_if_absent_op(kv_operations_t *operations,
                                            const char *table_name,
                                            const kv_row_t *row,
                                            kv_return_row_version_enum choice,
                                            kv_boolean_t abort_on_failure);

kv_error_t kv_create_table_put_if_present_op(kv_operations_t *operations,
                                             const char *table_name,
                                             const kv_row_t *row,
                                             kv_return_row_version_enum choice,
                                             kv_boolean_t abort_on_failure);
kv_error_t kv_create_table_put_if_version_op(kv_operations_t *operations,
                                             const char *table_name,
                                             const kv_row_t *row,
                                             const kv_version_t *if_version,
                                             kv_return_row_version_enum choice,
                                             kv_boolean_t abort_on_failure);
kv_error_t kv_create_table_delete_op(kv_operations_t *operations,
                                     const char *table_name,
                                     const kv_row_t *key,
                                     kv_return_row_version_enum choice,
                                     kv_boolean_t abort_on_failure);

kv_error_t
kv_create_table_delete_if_version_op(kv_operations_t *operations,
                                     const char *table_name,
                                     const kv_row_t *key,
                                     const kv_version_t *if_version,
                                     kv_return_row_version_enum choice,
                                     kv_boolean_t abort_on_failure);
kv_int_t kv_operations_size(const kv_operations_t *operations);

kv_operation_enum kv_operation_get_type(const kv_operations_t *operations,
                                        kv_int_t index);

kv_boolean_t
kv_operation_get_abort_on_failure(const kv_operations_t *operations,
                                  kv_int_t index);

void kv_release_operations(kv_operations_t **listp);

kv_int_t kv_operation_results_size(const kv_operation_results_t *results);

kv_result_t *
kv_table_operation_results_get(const kv_operation_results_t *results,
                               kv_int_t index);

void kv_release_operation_results(kv_operation_results_t **resultsp);

const char *kv_result_get_table_name(const kv_result_t *result);

kv_row_t *kv_result_get_row(const kv_result_t *result);

kv_version_t *kv_result_get_version(const kv_result_t *result);

kv_row_t *kv_result_get_index_key(const kv_result_t *result);

kv_row_t *kv_result_get_prev_row(const kv_result_t *result);

kv_version_t *kv_result_get_prev_row_version(const kv_result_t *result);

kv_boolean_t kv_result_get_success(const kv_result_t *result);

kv_long_t kv_result_get_expiration(const kv_result_t *result);

void kv_release_result(kv_result_t ** resultp);

kv_error_t kv_copy_version(const kv_version_t *from, kv_version_t **to);

void kv_release_version(kv_version_t **versionp);
kv_durability_t kv_create_durability(kv_sync_policy_enum master,
                                     kv_sync_policy_enum replica,
                                     kv_ack_policy_enum ack);

kv_sync_policy_enum kv_get_durability_master_sync(kv_durability_t durability);

kv_sync_policy_enum kv_get_durability_replica_sync(kv_durability_t durability);

kv_ack_policy_enum kv_get_durability_replica_ack(kv_durability_t durability);
kv_error_t kv_create_simple_consistency(kv_consistency_enum type,
                                        kv_consistency_t **consistencyp);

kv_error_t kv_create_time_consistency(kv_timeout_t time_lag,
                                      kv_timeout_t timeout_ms,
                                      kv_consistency_t **consistencyp);

kv_error_t kv_create_version_consistency(const kv_version_t *version,
                                         kv_timeout_t timeout_ms,
                                         kv_consistency_t **consistencyp);


kv_consistency_enum
kv_get_consistency_type(const kv_consistency_t *consistency);

void kv_release_consistency(kv_consistency_t **consistencyp);
kv_error_t kv_create_field_range(const char *field_name,
                                 const char *start,
                                 kv_boolean_t start_inclusive,
                                 const char *end,
                                 kv_boolean_t end_inclusive,
                                 kv_field_range_t **rangep);

void kv_release_field_range(kv_field_range_t **rangep);
kv_error_t kv_create_read_options(const kv_consistency_t * consistency,
                                  kv_long_t timeout_ms,
                                  kv_read_options_t **optionsp);
void kv_release_read_options(kv_read_options_t **optionsp);
kv_error_t kv_create_write_options(kv_durability_t durability,
                                   kv_long_t timeout_ms,
                                   kv_write_options_t **optionsp);

void kv_release_write_options(kv_write_options_t **optionsp);
kv_row_t *kv_create_row();

kv_error_t kv_row_put_int(kv_row_t *row,
                          const char *name,
                          kv_int_t value);

kv_error_t kv_row_put_long(kv_row_t *row,
                           const char *name,
                           kv_long_t value);

kv_error_t kv_row_put_float(kv_row_t *row,
                            const char *name,
                            kv_float_t value);

kv_error_t kv_row_put_double(kv_row_t *row,
                             const char *name,
                             kv_double_t value);
kv_error_t kv_row_put_boolean(kv_row_t *row,
                              const char *name,
                              kv_boolean_t value);
kv_error_t kv_row_put_string(kv_row_t *row,
                             const char *name,
                             const char *value);
kv_error_t kv_row_put_bytes(kv_row_t *row,
                            const char *name,
                            const unsigned char *bytes,
                            kv_int_t size);

kv_error_t kv_row_put_bytes_copy(kv_row_t *row,
                                 const char *name,
                                 const unsigned char *bytes,
                                 kv_int_t size);
kv_array_t *kv_row_put_array(kv_row_t *row, const char *name);

kv_array_t *kv_row_put_sized_array(kv_row_t *row,
                                   const char *name,
                                   kv_int_t size);

kv_map_t *kv_row_put_map(kv_row_t *row, const char *name);

kv_record_t *kv_row_put_record(kv_row_t *row, const char *name);

kv_error_t kv_row_put_null(kv_row_t *row, const char *name);

kv_field_t ** kv_row_get_fields(const kv_row_t *row, kv_int_t *num);

kv_field_t *kv_row_get_field(const kv_row_t *row, const char *name);

const char *kv_field_get_name(const kv_field_t *field);

kv_field_type_enum kv_field_get_type(const kv_field_t *field);

kv_boolean_t kv_field_is_null(const kv_field_t *field);

kv_error_t kv_field_as_int(const kv_field_t *field, kv_int_t *value);

kv_error_t kv_field_as_long(const kv_field_t *field, kv_long_t *value);

kv_error_t kv_field_as_float(const kv_field_t *field, kv_float_t *value);

kv_error_t kv_field_as_double(const kv_field_t *field, kv_double_t *value);

kv_error_t kv_field_as_boolean(const kv_field_t *field, kv_boolean_t *value);

kv_error_t kv_field_as_string(const kv_field_t *field, const char **value);

kv_error_t kv_field_as_bytes(const kv_field_t *field,
                             unsigned char **bytes,
                             kv_int_t *size);

kv_error_t kv_field_as_array(const kv_field_t *field,
                             kv_array_t **value);

kv_error_t kv_field_as_map(const kv_field_t *field,
                           kv_map_t **value);

kv_error_t kv_field_as_record(const kv_field_t *field,
                              kv_record_t **value);

kv_error_t kv_row_get_int(const kv_row_t *row,
                          const char *name,
                          kv_int_t *value);

kv_error_t kv_row_get_long(const kv_row_t *row,
                           const char *name,
                           kv_long_t *value);

kv_error_t kv_row_get_float(const kv_row_t *row,
                            const char *name,
                            kv_float_t *value);

kv_error_t kv_row_get_double(const kv_row_t *row,
                             const char *name,
                             kv_double_t *value);

kv_error_t kv_row_get_boolean(const kv_row_t *row,
                              const char *name,
                              kv_boolean_t *value);

kv_error_t kv_row_get_string(const kv_row_t *row,
                             const char *name,
                             const char **value);

kv_error_t kv_row_get_bytes(const kv_row_t *row,
                            const char *name,
                            const unsigned char **bytes,
                            kv_int_t *size);

kv_error_t kv_row_get_array(const kv_row_t *row,
                            const char *name,
                            kv_array_t **value);

kv_error_t kv_row_get_map(const kv_row_t *row,
                          const char *name,
                          kv_map_t **value);

kv_error_t kv_row_get_record(const kv_row_t *row,
                             const char *name,
                             kv_record_t **value);

kv_error_t kv_row_set_ttl_of_hours(kv_row_t *row, kv_long_t hours);

kv_error_t kv_row_set_ttl_of_days(kv_row_t *row, kv_long_t days);

kv_error_t kv_row_set_use_table_ttl(kv_row_t *row, kv_boolean_t flag);

kv_long_t kv_row_get_ttl_value(const kv_row_t *row);

kv_ttl_timeunit_enum kv_row_get_ttl_timeunit(const kv_row_t * row);

kv_boolean_t kv_row_get_use_table_ttl(const kv_row_t *row);

kv_error_t kv_copy_row(const kv_row_t *from, kv_row_t **to);

void kv_release_row(kv_row_t **rowp);
kv_error_t kv_array_append_int(kv_array_t *array, kv_int_t value);

kv_error_t kv_array_append_long(kv_array_t *array, kv_long_t value);

kv_error_t kv_array_append_float(kv_array_t *array, kv_float_t value);

kv_error_t kv_array_append_double(kv_array_t *array, kv_double_t value);

kv_error_t kv_array_append_boolean(kv_array_t *array, kv_boolean_t value);

kv_error_t kv_array_append_string(kv_array_t *array, const char *value);

kv_error_t kv_array_append_bytes(kv_array_t *array,
                                 const unsigned char *bytes,
                                 kv_int_t size);

kv_error_t kv_array_append_bytes_copy(kv_array_t *array,
                                      const unsigned char *bytes,
                                      kv_int_t size);

kv_array_t *kv_array_append_array(kv_array_t *array);

kv_map_t *kv_array_append_map(kv_array_t *array);

kv_record_t *kv_array_append_record(kv_array_t *array);

kv_error_t kv_array_add_int(kv_array_t *array, kv_int_t index, kv_int_t value);

kv_error_t kv_array_add_long(kv_array_t *array,
                             kv_int_t index,
                             kv_long_t value);

kv_error_t kv_array_add_float(kv_array_t *array,
                              kv_int_t index,
                              kv_float_t value);
kv_error_t kv_array_add_double(kv_array_t *array,
                               kv_int_t index,
                               kv_double_t value);

kv_error_t kv_array_add_boolean(kv_array_t *array,
                                kv_int_t index,
                                kv_boolean_t value);
kv_error_t kv_array_add_string(kv_array_t *array,
                               kv_int_t index,
                               const char *value);
kv_error_t kv_array_add_bytes(kv_array_t *array,
                              kv_int_t index,
                              const unsigned char *bytes,
                              kv_int_t size);

kv_error_t kv_array_add_bytes_copy(kv_array_t *array,
                                   kv_int_t index,
                                   const unsigned char *bytes,
                                   kv_int_t size);

kv_array_t *kv_array_add_array(kv_array_t *array, kv_int_t index);

kv_array_t *kv_array_add_sized_array(kv_array_t *array,
                                     kv_int_t index,
                                     kv_int_t size);

kv_map_t *kv_array_add_map(kv_array_t *array, kv_int_t index);

kv_record_t *kv_array_add_record(kv_array_t *array, kv_int_t index);

kv_int_t kv_array_get_size(const kv_array_t *array);

kv_error_t kv_array_get_int(const kv_array_t *array,
                            kv_int_t index,
                            kv_int_t *value);
kv_error_t kv_array_get_long(const kv_array_t *array,
                             kv_int_t index,
                             kv_long_t *value);

kv_error_t kv_array_get_float(const kv_array_t *array,
                              kv_int_t index,
                              kv_float_t *value);
kv_error_t kv_array_get_double(const kv_array_t *array,
                               kv_int_t index,
                               kv_double_t *value);
kv_error_t kv_array_get_boolean(const kv_array_t *array,
                                kv_int_t index,
                                kv_boolean_t *value);
kv_error_t kv_array_get_bytes(const kv_array_t *array,
                              kv_int_t index,
                              const unsigned char **bytes,
                              kv_int_t *size);
kv_error_t kv_array_get_string(const kv_array_t *array,
                               kv_int_t index,
                               const char **value);

kv_error_t kv_array_get_array(const kv_array_t *array,
                              kv_int_t index,
                              kv_array_t **value);
kv_error_t kv_array_get_map(const kv_array_t *array,
                            kv_int_t index,
                            kv_map_t **value);

kv_error_t kv_array_get_record(const kv_array_t *array,
                               kv_int_t index,
                               kv_record_t **value);

kv_error_t kv_array_get_field(const kv_array_t *array,
                              kv_int_t index,
                              kv_field_t **fieldp);
kv_error_t kv_map_put_int(kv_map_t *map, const char *name, kv_int_t value);

kv_error_t kv_map_put_long(kv_map_t *map, const char *name, kv_long_t value);

kv_error_t kv_map_put_float(kv_map_t *map, const char *name, kv_float_t value);

kv_error_t kv_map_put_double(kv_map_t *map,
                             const char *name,
                             kv_double_t value);

kv_error_t kv_map_put_boolean(kv_map_t *map,
                              const char *name,
                              kv_boolean_t value);

kv_error_t kv_map_put_string(kv_map_t *map,
                             const char *name,
                             const char *value);

kv_error_t kv_map_put_bytes(kv_map_t *map,
                            const char *name,
                            const unsigned char *bytes,
                            kv_int_t size);

kv_error_t kv_map_put_bytes_copy(kv_map_t *map,
                                 const char *name,
                                 const unsigned char *bytes,
                                 kv_int_t size);

kv_array_t *kv_map_put_array(kv_map_t *map, const char *name);

kv_array_t *kv_map_put_sized_array(kv_map_t *map,
                                   const char *name,
                                   kv_int_t size);

kv_map_t *kv_map_put_map(kv_map_t *map, const char *name);

kv_record_t *kv_map_put_record(kv_map_t *map, const char *name);

kv_error_t kv_map_put_null(kv_map_t *map, const char *name);

const char ** kv_map_get_keys(kv_map_t *map, kv_int_t *num);

kv_error_t kv_map_get_int(const kv_map_t *map,
                          const char *name,
                          kv_int_t *value);

kv_error_t kv_map_get_long(const kv_map_t *map,
                           const char *name,
                           kv_long_t *value);
kv_error_t kv_map_get_float(const kv_map_t *map,
                            const char *name,
                            kv_float_t *value);

kv_error_t kv_map_get_double(const kv_map_t *map,
                             const char *name,
                             kv_double_t *value);

kv_error_t kv_map_get_boolean(const kv_map_t *map,
                              const char *name,
                              kv_boolean_t *value);
kv_error_t kv_map_get_string(const kv_map_t *map,
                             const char *name,
                             const char **value);
kv_error_t kv_map_get_bytes(const kv_map_t *map,
                            const char *name,
                            const unsigned char **bytes,
                            kv_int_t *size);
kv_error_t kv_map_get_array(const kv_map_t *map,
                            const char *name,
                            kv_array_t **value);
kv_error_t kv_map_get_map(const kv_map_t *map,
                          const char *name,
                          kv_map_t **value);
kv_error_t kv_map_get_record(const kv_map_t *map,
                             const char *name,
                             kv_record_t **value);

kv_field_t * kv_map_get_field(const kv_map_t *map, const char *name);

kv_error_t kv_record_put_int(kv_record_t *record,
                             const char *name,
                             kv_int_t value);

kv_error_t kv_record_put_long(kv_record_t *record,
                              const char *name,
                              kv_long_t value);
kv_error_t kv_record_put_float(kv_record_t *record,
                               const char *name,
                               kv_float_t value);

kv_error_t kv_record_put_double(kv_record_t *record,
                                const char *name,
                                kv_double_t value);

kv_error_t kv_record_put_boolean(kv_record_t *record,
                                 const char *name,
                                 kv_boolean_t value);

kv_error_t kv_record_put_string(kv_record_t *record,
                                const char *name,
                                const char *value);
kv_error_t kv_record_put_bytes(kv_record_t *record,
                               const char *name,
                               const unsigned char *bytes,
                               kv_int_t size);

kv_error_t kv_record_put_bytes_copy(kv_record_t *record,
                                    const char *name,
                                    const unsigned char *bytes,
                                    kv_int_t size);

kv_error_t kv_record_put_null(kv_record_t *record, const char *name);

kv_array_t *kv_record_put_array(kv_record_t *record, const char *name);

kv_array_t *kv_record_put_sized_array(kv_record_t *record,
                                      const char *name,
                                      kv_int_t size);

kv_map_t *kv_record_put_map(kv_record_t *record,
                            const char *name);
kv_record_t *kv_record_put_record(kv_record_t *record,
                                  const char *name);

kv_error_t kv_record_get_int(const kv_record_t *record,
                             const char *name,
                             kv_int_t *value);

kv_error_t kv_record_get_long(const kv_record_t *record,
                              const char *name,
                              kv_long_t *value);

kv_error_t kv_record_get_float(const kv_record_t *record,
                               const char *name,
                               kv_float_t *value);

kv_error_t kv_record_get_double(const kv_record_t *record,
                                const char *name,
                                kv_double_t *value);

kv_error_t kv_record_get_boolean(const kv_record_t *record,
                                 const char *name,
                                 kv_boolean_t *value);

kv_error_t kv_record_get_string(const kv_record_t *record,
                                const char *name,
                                const char **value);

kv_error_t kv_record_get_bytes(const kv_record_t *record,
                               const char *name,
                               const unsigned char **bytes,
                               kv_int_t *size);

kv_error_t kv_record_get_array(const kv_record_t *record,
                               const char *name,
                               kv_array_t **value);

kv_error_t kv_record_get_map(const kv_record_t *record,
                             const char *name,
                             kv_map_t **value);
kv_error_t kv_record_get_record(const kv_record_t *record,
                                const char *name,
                                kv_record_t **value);

kv_field_t *kv_record_get_field(const kv_record_t *record,
                                const char *name);

kv_field_t ** kv_record_get_fields(kv_record_t *record, kv_int_t *num);

kv_error_t kv_future_get(kv_future_t *future,
                         const kv_statement_result_t **resultp);

kv_error_t kv_future_get_with_timeout(kv_future_t *future,
                                      kv_timeout_t timeout_ms,
                                      const kv_statement_result_t **resultp);

kv_boolean_t kv_future_cancel(kv_future_t *future,
                              kv_boolean_t may_interrupt_if_running);

kv_error_t kv_future_get_execution_id(kv_future_t *future,
                                      kv_execution_id_t **idp);

kv_boolean_t kv_future_is_cancelled(kv_future_t *future);

kv_boolean_t kv_future_is_done(kv_future_t *future);

const kv_statement_result_t *kv_future_get_last_status(kv_future_t *future);

kv_error_t kv_future_update_status(kv_future_t *future,
                                   const kv_statement_result_t ** resultp);


const char *kv_future_get_statement(kv_future_t *future);

void kv_release_future(kv_future_t **futurep);

void kv_release_execution_id(kv_execution_id_t **idp);

kv_int_t kv_statement_result_get_plan_id(const kv_statement_result_t *result);

const char *
kv_statement_result_get_error_message(const kv_statement_result_t *result);

const char *kv_statement_result_get_info(const kv_statement_result_t *result);

const char *
kv_statement_result_get_info_as_json(const kv_statement_result_t *result);

const char *
kv_statement_result_get_result(const kv_statement_result_t *result);

kv_boolean_t
kv_statement_result_is_successful(const kv_statement_result_t *result);

kv_boolean_t
kv_statement_result_is_cancelled(const kv_statement_result_t *result);

kv_boolean_t kv_statement_result_is_done(const kv_statement_result_t *result);

void kv_release_statement_result(kv_statement_result_t **resultp);
const char *kv_get_last_error(const kv_store_t *store);

const char *kv_get_open_error();

void kv_set_debug_output(kv_output_func func);

#if defined(__cplusplus)
}
#endif

#endif /* _KVSTORE_H_ */