Couchbase C Client  3.1.2
Asynchronous C Client for Couchbase
couchbase.h File Reference

Main header file for Couchbase. More...

#include <stddef.h>
#include <time.h>
#include <stdarg.h>
#include <stdio.h>
#include <libcouchbase/sysdefs.h>
#include <libcouchbase/assert.h>
#include <libcouchbase/visibility.h>
#include <libcouchbase/error.h>
#include <libcouchbase/iops.h>
#include <libcouchbase/configuration.h>
#include <libcouchbase/kvbuf.h>
#include <libcouchbase/auth.h>
#include <libcouchbase/tracing.h>
#include <libcouchbase/logger.h>
#include <libcouchbase/cntl.h>

Go to the source code of this file.


 Callback type for views (cannot be used for lcb_install_callback3())
 Callback type for N1QL (cannot be used for lcb_install_callback3())
 Callback type for N1QL index management (cannot be used for lcb_install_callback3())
 Callback type for Analytics (cannot be used for lcb_install_callback3())
 Callback type for Search (cannot be used for lcb_install_callback3())
 libcouchbase version string
 libcouchbase hex version More...
 The SCM revision ID. More...
 Whether the library has SSL support.
 Whether the library has experimental compression support.
 Whether the library has experimental tracing support.
 Create intermediate paths.
 Access document XATTR path.
 Access document virtual/materialized path. More...
 Access Xattrs of deleted documents.


typedef struct lcb_st lcb_INSTANCE
 Library handle representing a connection to a cluster and its data buckets. More...
typedef struct lcb_HTTP_HANDLE_ lcb_HTTP_HANDLE
typedef struct lcb_CREATEOPTS_ lcb_CREATEOPTS
typedef void(* lcb_bootstrap_callback) (lcb_INSTANCE *instance, lcb_STATUS err)
Bootstrap callback. More...
typedef struct lcb_CMDBASE_ lcb_CMDBASE
typedef struct lcb_RESPBASE_ lcb_RESPBASE
typedef void(* lcb_RESPCALLBACK) (lcb_INSTANCE *instance, int cbtype, const lcb_RESPBASE *resp)
 Callback invoked for responses. More...
typedef struct lcb_RESPGET_ lcb_RESPGET
 Command for retrieving a single item. More...
typedef struct lcb_CMDGET_ lcb_CMDGET
typedef struct lcb_RESPEXISTS_ lcb_RESPEXISTS
typedef struct lcb_CMDEXISTS_ lcb_CMDEXISTS
typedef struct lcb_RESPSTORE_ lcb_RESPSTORE
Schedule a single storage request More...
typedef struct lcb_CMDSTORE_ lcb_CMDSTORE
typedef void(* lcb_open_callback) (lcb_INSTANCE *instance, lcb_STATUS err)
typedef struct lcb_RESPREMOVE_ lcb_RESPREMOVE
 Spool a removal of an item. More...
typedef struct lcb_CMDREMOVE_ lcb_CMDREMOVE
typedef struct lcb_RESPCOUNTER_ lcb_RESPCOUNTER
 Schedule single counter operation. More...
typedef struct lcb_CMDCOUNTER_ lcb_CMDCOUNTER
typedef struct lcb_RESPUNLOCK_ lcb_RESPUNLOCK
Unlock a previously locked item using lcb_cmdunlock More...
typedef struct lcb_CMDUNLOCK_ lcb_CMDUNLOCK
typedef struct lcb_RESPTOUCH_ lcb_RESPTOUCH
 Spool a touch request. More...
typedef struct lcb_CMDTOUCH_ lcb_CMDTOUCH
typedef struct lcb_RESPPING_ lcb_RESPPING
typedef struct lcb_CMDPING_ lcb_CMDPING
typedef struct lcb_RESPDIAG_ lcb_RESPDIAG
typedef struct lcb_CMDDIAG_ lcb_CMDDIAG
typedef struct lcb_RESPHTTP_ lcb_RESPHTTP
typedef struct lcb_CMDHTTP_ lcb_CMDHTTP
typedef void(* lcb_destroy_callback) (const void *cookie)
 Callback received when instance is about to be destroyed. More...
 Response for a Analytics query. More...
typedef void(* lcb_ANALYTICS_CALLBACK) (lcb_INSTANCE *, int, const lcb_RESPANALYTICS *)
 Callback to be invoked for each row. More...
typedef struct lcb_CMDANALYTICS_ lcb_CMDANALYTICS
typedef struct lcb_INGEST_OPTIONS_ lcb_INGEST_OPTIONS
typedef struct lcb_INGEST_PARAM_ lcb_INGEST_PARAM
typedef struct lcb_SEARCH_HANDLE_ lcb_SEARCH_HANDLE
typedef struct lcb_RESPSEARCH_ lcb_RESPSEARCH
typedef struct lcb_CMDSEARCH_ lcb_CMDSEARCH
typedef void(* lcb_SEARCH_CALLBACK) (lcb_INSTANCE *, int, const lcb_RESPSEARCH *)
typedef struct lcb_RESPQUERY_ lcb_RESPQUERY
 Opaque query response structure.
typedef struct lcb_CMDQUERY_ lcb_CMDQUERY
 Opaque query command structure.
typedef struct lcb_QUERY_HANDLE_ lcb_QUERY_HANDLE
 Pointer for request instance.
typedef void(* lcb_QUERY_CALLBACK) (lcb_INSTANCE *, int, const lcb_RESPQUERY *)
 Callback to be invoked for each row. More...
typedef struct lcb_RESPVIEW_ lcb_RESPVIEW
typedef struct lcb_CMDVIEW_ lcb_CMDVIEW
typedef struct lcb_VIEW_HANDLE_ lcb_VIEW_HANDLE
 Pointer for request instance.
typedef void(* lcb_VIEW_CALLBACK) (lcb_INSTANCE *instance, int cbtype, const lcb_RESPVIEW *row)
 Callback function invoked for each row returned from the view. More...
typedef struct lcb_RESPSUBDOC_ lcb_RESPSUBDOC
typedef struct lcb_SUBDOCSPECS_ lcb_SUBDOCSPECS
typedef struct lcb_CMDSUBDOC_ lcb_CMDSUBDOC


enum  lcb_BTYPE
 Type of the bucket. More...
 Handle types. More...
enum  lcb_RESPFLAGS
 Response flags. More...
 The type of response passed to the callback. More...
enum  lcb_REPLICA_MODE
 Spool a single get-with-replica request. More...
 Values for lcb_CMDSTORE::operation. More...
enum  lcb_PING_STATUS
Status of the service More...
enum  lcb_PING_SERVICE
Type of the service. More...
enum  lcb_HTTP_TYPE
 The type of HTTP request to execute. More...
enum  lcb_HTTP_METHOD
 HTTP Request method enumeration These just enumerate the various types of HTTP request methods supported. More...
enum  lcb_WAITFLAGS
 Flags for lcb_wait() More...
enum  lcb_VALUEFLAGS


lcb_STATUS lcb_createopts_create (lcb_CREATEOPTS **options, lcb_INSTANCE_TYPE type)
lcb_STATUS lcb_createopts_destroy (lcb_CREATEOPTS *options)
lcb_STATUS lcb_createopts_connstr (lcb_CREATEOPTS *options, const char *connstr, size_t connstr_len)
lcb_STATUS lcb_createopts_bucket (lcb_CREATEOPTS *options, const char *bucket, size_t bucket_len)
lcb_STATUS lcb_createopts_logger (lcb_CREATEOPTS *options, const lcb_LOGGER *logger)
lcb_STATUS lcb_createopts_credentials (lcb_CREATEOPTS *options, const char *username, size_t username_len, const char *password, size_t password_len)
lcb_STATUS lcb_createopts_authenticator (lcb_CREATEOPTS *options, lcb_AUTHENTICATOR *auth)
lcb_STATUS lcb_createopts_io (lcb_CREATEOPTS *options, struct lcb_io_opt_st *io)
lcb_STATUS lcb_create (lcb_INSTANCE **instance, const lcb_CREATEOPTS *options)
Create an instance of lcb. More...
lcb_STATUS lcb_connect (lcb_INSTANCE *instance)
Schedule the initial connection This function will schedule the initial connection for the handle. More...
lcb_bootstrap_callback lcb_set_bootstrap_callback (lcb_INSTANCE *instance, lcb_bootstrap_callback callback)
 Set the callback for notification of success or failure of initial connection. More...
lcb_STATUS lcb_get_bootstrap_status (lcb_INSTANCE *instance)
Gets the initial bootstrap status More...
void lcb_set_auth (lcb_INSTANCE *instance, lcb_AUTHENTICATOR *auth)
 Sets the authenticator object for the instance. More...
int lcb_mutation_token_is_valid (const lcb_MUTATION_TOKEN *token)
lcb_RESPCALLBACK lcb_install_callback (lcb_INSTANCE *instance, int cbtype, lcb_RESPCALLBACK cb)
lcb_RESPCALLBACK lcb_get_callback (lcb_INSTANCE *instance, int cbtype)
const char * lcb_strcbtype (int cbtype)
 Returns the type of the callback as a string. More...
lcb_STATUS lcb_respget_status (const lcb_RESPGET *resp)
lcb_STATUS lcb_respget_error_context (const lcb_RESPGET *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respget_cookie (const lcb_RESPGET *resp, void **cookie)
lcb_STATUS lcb_respget_cas (const lcb_RESPGET *resp, uint64_t *cas)
lcb_STATUS lcb_respget_datatype (const lcb_RESPGET *resp, uint8_t *datatype)
lcb_STATUS lcb_respget_flags (const lcb_RESPGET *resp, uint32_t *flags)
lcb_STATUS lcb_respget_key (const lcb_RESPGET *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respget_value (const lcb_RESPGET *resp, const char **value, size_t *value_len)
lcb_STATUS lcb_cmdget_create (lcb_CMDGET **cmd)
lcb_STATUS lcb_cmdget_destroy (lcb_CMDGET *cmd)
lcb_STATUS lcb_cmdget_parent_span (lcb_CMDGET *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdget_collection (lcb_CMDGET *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdget_key (lcb_CMDGET *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdget_expiry (lcb_CMDGET *cmd, uint32_t expiration)
lcb_STATUS lcb_cmdget_locktime (lcb_CMDGET *cmd, uint32_t duration)
lcb_STATUS lcb_cmdget_timeout (lcb_CMDGET *cmd, uint32_t timeout)
lcb_STATUS lcb_get (lcb_INSTANCE *instance, void *cookie, const lcb_CMDGET *cmd)
lcb_STATUS lcb_respgetreplica_status (const lcb_RESPGETREPLICA *resp)
lcb_STATUS lcb_respgetreplica_error_context (const lcb_RESPGETREPLICA *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respgetreplica_cookie (const lcb_RESPGETREPLICA *resp, void **cookie)
lcb_STATUS lcb_respgetreplica_cas (const lcb_RESPGETREPLICA *resp, uint64_t *cas)
lcb_STATUS lcb_respgetreplica_datatype (const lcb_RESPGETREPLICA *resp, uint8_t *datatype)
lcb_STATUS lcb_respgetreplica_flags (const lcb_RESPGETREPLICA *resp, uint32_t *flags)
lcb_STATUS lcb_respgetreplica_key (const lcb_RESPGETREPLICA *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respgetreplica_value (const lcb_RESPGETREPLICA *resp, const char **value, size_t *value_len)
int lcb_respgetreplica_is_final (const lcb_RESPGETREPLICA *resp)
lcb_STATUS lcb_cmdgetreplica_create (lcb_CMDGETREPLICA **cmd, lcb_REPLICA_MODE mode)
lcb_STATUS lcb_cmdgetreplica_destroy (lcb_CMDGETREPLICA *cmd)
lcb_STATUS lcb_cmdgetreplica_parent_span (lcb_CMDGETREPLICA *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdgetreplica_collection (lcb_CMDGETREPLICA *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdgetreplica_key (lcb_CMDGETREPLICA *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdgetreplica_timeout (lcb_CMDGETREPLICA *cmd, uint32_t timeout)
lcb_STATUS lcb_getreplica (lcb_INSTANCE *instance, void *cookie, const lcb_CMDGETREPLICA *cmd)
lcb_STATUS lcb_respexists_status (const lcb_RESPEXISTS *resp)
int lcb_respexists_is_found (const lcb_RESPEXISTS *resp)
lcb_STATUS lcb_respexists_error_context (const lcb_RESPEXISTS *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respexists_cookie (const lcb_RESPEXISTS *resp, void **cookie)
lcb_STATUS lcb_respexists_cas (const lcb_RESPEXISTS *resp, uint64_t *cas)
lcb_STATUS lcb_respexists_key (const lcb_RESPEXISTS *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_cmdexists_create (lcb_CMDEXISTS **cmd)
lcb_STATUS lcb_cmdexists_destroy (lcb_CMDEXISTS *cmd)
lcb_STATUS lcb_cmdexists_parent_span (lcb_CMDEXISTS *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdexists_collection (lcb_CMDEXISTS *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdexists_key (lcb_CMDEXISTS *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdexists_timeout (lcb_CMDEXISTS *cmd, uint32_t timeout)
lcb_STATUS lcb_exists (lcb_INSTANCE *instance, void *cookie, const lcb_CMDEXISTS *cmd)
lcb_STATUS lcb_respstore_status (const lcb_RESPSTORE *resp)
lcb_STATUS lcb_respstore_error_context (const lcb_RESPSTORE *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respstore_cookie (const lcb_RESPSTORE *resp, void **cookie)
lcb_STATUS lcb_respstore_cas (const lcb_RESPSTORE *resp, uint64_t *cas)
lcb_STATUS lcb_respstore_key (const lcb_RESPSTORE *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respstore_operation (const lcb_RESPSTORE *resp, lcb_STORE_OPERATION *operation)
lcb_STATUS lcb_respstore_mutation_token (const lcb_RESPSTORE *resp, lcb_MUTATION_TOKEN *token)
int lcb_respstore_observe_attached (const lcb_RESPSTORE *resp)
lcb_STATUS lcb_respstore_observe_stored (const lcb_RESPSTORE *resp, int *store_ok)
lcb_STATUS lcb_respstore_observe_master_exists (const lcb_RESPSTORE *resp, int *master_exists)
lcb_STATUS lcb_respstore_observe_master_persisted (const lcb_RESPSTORE *resp, int *master_persisted)
lcb_STATUS lcb_respstore_observe_num_responses (const lcb_RESPSTORE *resp, uint16_t *num_responses)
lcb_STATUS lcb_respstore_observe_num_persisted (const lcb_RESPSTORE *resp, uint16_t *num_persisted)
lcb_STATUS lcb_respstore_observe_num_replicated (const lcb_RESPSTORE *resp, uint16_t *num_replicated)
lcb_STATUS lcb_cmdstore_create (lcb_CMDSTORE **cmd, lcb_STORE_OPERATION operation)
lcb_STATUS lcb_cmdstore_destroy (lcb_CMDSTORE *cmd)
lcb_STATUS lcb_cmdstore_parent_span (lcb_CMDSTORE *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdstore_collection (lcb_CMDSTORE *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdstore_key (lcb_CMDSTORE *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdstore_value (lcb_CMDSTORE *cmd, const char *value, size_t value_len)
lcb_STATUS lcb_cmdstore_value_iov (lcb_CMDSTORE *cmd, const lcb_IOV *value, size_t value_len)
lcb_STATUS lcb_cmdstore_expiry (lcb_CMDSTORE *cmd, uint32_t expiration)
lcb_STATUS lcb_cmdstore_cas (lcb_CMDSTORE *cmd, uint64_t cas)
lcb_STATUS lcb_cmdstore_flags (lcb_CMDSTORE *cmd, uint32_t flags)
lcb_STATUS lcb_cmdstore_datatype (lcb_CMDSTORE *cmd, uint8_t datatype)
lcb_STATUS lcb_cmdstore_durability (lcb_CMDSTORE *cmd, lcb_DURABILITY_LEVEL level)
lcb_STATUS lcb_cmdstore_durability_observe (lcb_CMDSTORE *cmd, int persist_to, int replicate_to)
lcb_STATUS lcb_cmdstore_timeout (lcb_CMDSTORE *cmd, uint32_t timeout)
lcb_STATUS lcb_store (lcb_INSTANCE *instance, void *cookie, const lcb_CMDSTORE *cmd)
lcb_open_callback lcb_set_open_callback (lcb_INSTANCE *instance, lcb_open_callback callback)
 Callback to be called when bucket is opened. More...
lcb_STATUS lcb_open (lcb_INSTANCE *instance, const char *bucket, size_t bucket_len)
 Opens bucket. More...
lcb_STATUS lcb_respremove_status (const lcb_RESPREMOVE *resp)
lcb_STATUS lcb_respremove_error_context (const lcb_RESPREMOVE *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respremove_cookie (const lcb_RESPREMOVE *resp, void **cookie)
lcb_STATUS lcb_respremove_cas (const lcb_RESPREMOVE *resp, uint64_t *cas)
lcb_STATUS lcb_respremove_key (const lcb_RESPREMOVE *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respremove_mutation_token (const lcb_RESPREMOVE *resp, lcb_MUTATION_TOKEN *token)
lcb_STATUS lcb_cmdremove_create (lcb_CMDREMOVE **cmd)
lcb_STATUS lcb_cmdremove_destroy (lcb_CMDREMOVE *cmd)
lcb_STATUS lcb_cmdremove_parent_span (lcb_CMDREMOVE *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdremove_collection (lcb_CMDREMOVE *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdremove_key (lcb_CMDREMOVE *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdremove_cas (lcb_CMDREMOVE *cmd, uint64_t cas)
lcb_STATUS lcb_cmdremove_durability (lcb_CMDREMOVE *cmd, lcb_DURABILITY_LEVEL level)
lcb_STATUS lcb_cmdremove_timeout (lcb_CMDREMOVE *cmd, uint32_t timeout)
lcb_STATUS lcb_remove (lcb_INSTANCE *instance, void *cookie, const lcb_CMDREMOVE *cmd)
lcb_STATUS lcb_respcounter_status (const lcb_RESPCOUNTER *resp)
lcb_STATUS lcb_respcounter_error_context (const lcb_RESPCOUNTER *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respcounter_cookie (const lcb_RESPCOUNTER *resp, void **cookie)
lcb_STATUS lcb_respcounter_cas (const lcb_RESPCOUNTER *resp, uint64_t *cas)
lcb_STATUS lcb_respcounter_key (const lcb_RESPCOUNTER *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respcounter_mutation_token (const lcb_RESPCOUNTER *resp, lcb_MUTATION_TOKEN *token)
lcb_STATUS lcb_respcounter_value (const lcb_RESPCOUNTER *resp, uint64_t *value)
lcb_STATUS lcb_cmdcounter_create (lcb_CMDCOUNTER **cmd)
lcb_STATUS lcb_cmdcounter_destroy (lcb_CMDCOUNTER *cmd)
lcb_STATUS lcb_cmdcounter_parent_span (lcb_CMDCOUNTER *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdcounter_collection (lcb_CMDCOUNTER *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdcounter_key (lcb_CMDCOUNTER *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdcounter_expiry (lcb_CMDCOUNTER *cmd, uint32_t expiration)
lcb_STATUS lcb_cmdcounter_delta (lcb_CMDCOUNTER *cmd, int64_t number)
lcb_STATUS lcb_cmdcounter_initial (lcb_CMDCOUNTER *cmd, uint64_t number)
lcb_STATUS lcb_cmdcounter_durability (lcb_CMDCOUNTER *cmd, lcb_DURABILITY_LEVEL level)
lcb_STATUS lcb_cmdcounter_cas (lcb_CMDCOUNTER *cmd, uint64_t cas)
lcb_STATUS lcb_cmdcounter_timeout (lcb_CMDCOUNTER *cmd, uint32_t timeout)
lcb_STATUS lcb_counter (lcb_INSTANCE *instance, void *cookie, const lcb_CMDCOUNTER *cmd)
lcb_STATUS lcb_respunlock_status (const lcb_RESPUNLOCK *resp)
lcb_STATUS lcb_respunlock_error_context (const lcb_RESPUNLOCK *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respunlock_cookie (const lcb_RESPUNLOCK *resp, void **cookie)
lcb_STATUS lcb_respunlock_cas (const lcb_RESPUNLOCK *resp, uint64_t *cas)
lcb_STATUS lcb_respunlock_key (const lcb_RESPUNLOCK *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_cmdunlock_create (lcb_CMDUNLOCK **cmd)
lcb_STATUS lcb_cmdunlock_destroy (lcb_CMDUNLOCK *cmd)
lcb_STATUS lcb_cmdunlock_parent_span (lcb_CMDUNLOCK *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdunlock_collection (lcb_CMDUNLOCK *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdunlock_key (lcb_CMDUNLOCK *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdunlock_cas (lcb_CMDUNLOCK *cmd, uint64_t cas)
lcb_STATUS lcb_cmdunlock_timeout (lcb_CMDUNLOCK *cmd, uint32_t timeout)
lcb_STATUS lcb_unlock (lcb_INSTANCE *instance, void *cookie, const lcb_CMDUNLOCK *cmd)
lcb_STATUS lcb_resptouch_status (const lcb_RESPTOUCH *resp)
lcb_STATUS lcb_resptouch_error_context (const lcb_RESPTOUCH *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_resptouch_cookie (const lcb_RESPTOUCH *resp, void **cookie)
lcb_STATUS lcb_resptouch_cas (const lcb_RESPTOUCH *resp, uint64_t *cas)
lcb_STATUS lcb_resptouch_key (const lcb_RESPTOUCH *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_resptouch_mutation_token (const lcb_RESPTOUCH *resp, lcb_MUTATION_TOKEN *token)
lcb_STATUS lcb_cmdtouch_create (lcb_CMDTOUCH **cmd)
lcb_STATUS lcb_cmdtouch_destroy (lcb_CMDTOUCH *cmd)
lcb_STATUS lcb_cmdtouch_parent_span (lcb_CMDTOUCH *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdtouch_collection (lcb_CMDTOUCH *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdtouch_key (lcb_CMDTOUCH *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdtouch_expiry (lcb_CMDTOUCH *cmd, uint32_t expiration)
lcb_STATUS lcb_cmdtouch_durability (lcb_CMDTOUCH *cmd, lcb_DURABILITY_LEVEL level)
lcb_STATUS lcb_cmdtouch_timeout (lcb_CMDTOUCH *cmd, uint32_t timeout)
lcb_STATUS lcb_touch (lcb_INSTANCE *instance, void *cookie, const lcb_CMDTOUCH *cmd)
lcb_STATUS lcb_respping_status (const lcb_RESPPING *resp)
lcb_STATUS lcb_respping_cookie (const lcb_RESPPING *resp, void **cookie)
lcb_STATUS lcb_respping_value (const lcb_RESPPING *resp, const char **json, size_t *json_len)
lcb_STATUS lcb_respping_report_id (const lcb_RESPPING *resp, const char **report_id, size_t *report_id_len)
size_t lcb_respping_result_size (const lcb_RESPPING *resp)
lcb_PING_STATUS lcb_respping_result_status (const lcb_RESPPING *resp, size_t index)
lcb_STATUS lcb_respping_result_id (const lcb_RESPPING *resp, size_t index, const char **endpoint_id, size_t *endpoint_id_len)
lcb_STATUS lcb_respping_result_service (const lcb_RESPPING *resp, size_t index, lcb_PING_SERVICE *type)
lcb_STATUS lcb_respping_result_remote (const lcb_RESPPING *resp, size_t index, const char **address, size_t *address_len)
lcb_STATUS lcb_respping_result_local (const lcb_RESPPING *resp, size_t index, const char **address, size_t *address_len)
lcb_STATUS lcb_respping_result_latency (const lcb_RESPPING *resp, size_t index, uint64_t *latency)
lcb_STATUS lcb_respping_result_namespace (const lcb_RESPPING *resp, size_t index, const char **name, size_t *name_len)
 LCB_DEPRECATED2 (1 lcb_STATUS lcb_respping_result_scope(const lcb_RESPPING *resp, size_t index, const char **name, size_t *name_len), "Use lcb_respping_result_namespace")
lcb_STATUS lcb_cmdping_create (lcb_CMDPING **cmd)
lcb_STATUS lcb_cmdping_destroy (lcb_CMDPING *cmd)
lcb_STATUS lcb_cmdping_parent_span (lcb_CMDPING *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdping_report_id (lcb_CMDPING *cmd, const char *report_id, size_t report_id_len)
lcb_STATUS lcb_cmdping_all (lcb_CMDPING *cmd)
lcb_STATUS lcb_cmdping_kv (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_query (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_views (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_search (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_analytics (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_no_metrics (lcb_CMDPING *cmd, int enable)
lcb_STATUS lcb_cmdping_encode_json (lcb_CMDPING *cmd, int enable, int pretty, int with_details)
lcb_STATUS lcb_cmdping_timeout (lcb_CMDPING *cmd, uint32_t timeout)
lcb_STATUS lcb_ping (lcb_INSTANCE *instance, void *cookie, const lcb_CMDPING *cmd)
lcb_STATUS lcb_respdiag_status (const lcb_RESPDIAG *resp)
lcb_STATUS lcb_respdiag_cookie (const lcb_RESPDIAG *resp, void **cookie)
lcb_STATUS lcb_respdiag_value (const lcb_RESPDIAG *resp, const char **json, size_t *json_len)
lcb_STATUS lcb_cmddiag_create (lcb_CMDDIAG **cmd)
lcb_STATUS lcb_cmddiag_destroy (lcb_CMDDIAG *cmd)
lcb_STATUS lcb_cmddiag_report_id (lcb_CMDDIAG *cmd, const char *report_id, size_t report_id_len)
lcb_STATUS lcb_cmddiag_prettify (lcb_CMDDIAG *cmd, int enable)
lcb_STATUS lcb_diag (lcb_INSTANCE *instance, void *cookie, const lcb_CMDDIAG *cmd)
Returns diagnostics report about network connections. More...
lcb_STATUS lcb_resphttp_status (const lcb_RESPHTTP *resp)
lcb_STATUS lcb_resphttp_cookie (const lcb_RESPHTTP *resp, void **cookie)
lcb_STATUS lcb_resphttp_http_status (const lcb_RESPHTTP *resp, uint16_t *status)
lcb_STATUS lcb_resphttp_path (const lcb_RESPHTTP *resp, const char **path, size_t *path_len)
lcb_STATUS lcb_resphttp_body (const lcb_RESPHTTP *resp, const char **body, size_t *body_len)
lcb_STATUS lcb_resphttp_handle (const lcb_RESPHTTP *resp, lcb_HTTP_HANDLE **handle)
lcb_STATUS lcb_resphttp_error_context (const lcb_RESPHTTP *resp, const lcb_HTTP_ERROR_CONTEXT **ctx)
int lcb_resphttp_is_final (const lcb_RESPHTTP *resp)
lcb_STATUS lcb_resphttp_headers (const lcb_RESPHTTP *resp, const char *const **headers)
 List of key-value headers. More...
lcb_STATUS lcb_cmdhttp_create (lcb_CMDHTTP **cmd, lcb_HTTP_TYPE type)
lcb_STATUS lcb_cmdhttp_destroy (lcb_CMDHTTP *cmd)
lcb_STATUS lcb_cmdhttp_parent_span (lcb_CMDHTTP *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdhttp_method (lcb_CMDHTTP *cmd, lcb_HTTP_METHOD method)
lcb_STATUS lcb_cmdhttp_path (lcb_CMDHTTP *cmd, const char *path, size_t path_len)
lcb_STATUS lcb_cmdhttp_content_type (lcb_CMDHTTP *cmd, const char *content_type, size_t content_type_len)
lcb_STATUS lcb_cmdhttp_body (lcb_CMDHTTP *cmd, const char *body, size_t body_len)
lcb_STATUS lcb_cmdhttp_handle (lcb_CMDHTTP *cmd, lcb_HTTP_HANDLE **handle)
lcb_STATUS lcb_cmdhttp_username (lcb_CMDHTTP *cmd, const char *username, size_t username_len)
lcb_STATUS lcb_cmdhttp_password (lcb_CMDHTTP *cmd, const char *password, size_t password_len)
lcb_STATUS lcb_cmdhttp_host (lcb_CMDHTTP *cmd, const char *host, size_t host_len)
lcb_STATUS lcb_cmdhttp_streaming (lcb_CMDHTTP *cmd, int streaming)
lcb_STATUS lcb_cmdhttp_skip_auth_header (lcb_CMDHTTP *cmd, int skip_auth)
lcb_STATUS lcb_cmdhttp_timeout (lcb_CMDHTTP *cmd, uint32_t timeout)
lcb_STATUS lcb_http (lcb_INSTANCE *instance, void *cookie, const lcb_CMDHTTP *cmd)
lcb_STATUS lcb_http_cancel (lcb_INSTANCE *instance, lcb_HTTP_HANDLE *handle)
Cancel ongoing HTTP request More...
void lcb_set_cookie (lcb_INSTANCE *instance, const void *cookie)
Associate a cookie with an instance of lcb. More...
const void * lcb_get_cookie (lcb_INSTANCE *instance)
Retrieve the cookie associated with this instance More...
lcb_STATUS lcb_tick_nowait (lcb_INSTANCE *instance)
lcb_STATUS lcb_wait (lcb_INSTANCE *instance, lcb_WAITFLAGS flags)
Wait for completion of scheduled operations. More...
void lcb_breakout (lcb_INSTANCE *instance)
Forcefully break from the event loop. More...
int lcb_is_waiting (lcb_INSTANCE *instance)
Check if instance is blocked in the event loop More...
void lcb_sched_enter (lcb_INSTANCE *instance)
Enter a scheduling context. More...
void lcb_sched_leave (lcb_INSTANCE *instance)
Leave the current scheduling context, scheduling the commands within the context to be flushed to the network. More...
void lcb_sched_fail (lcb_INSTANCE *instance)
Fail all commands in the current scheduling context. More...
void lcb_sched_flush (lcb_INSTANCE *instance)
Request commands to be flushed to the network More...
void lcb_destroy (lcb_INSTANCE *instance)
Destroy (and release all allocated resources) an instance of lcb. More...
lcb_destroy_callback lcb_set_destroy_callback (lcb_INSTANCE *instance, lcb_destroy_callback)
 Set the callback to be invoked when the instance is destroyed asynchronously. More...
void lcb_destroy_async (lcb_INSTANCE *instance, const void *arg)
Asynchronously schedule the destruction of an instance. More...
lcb_STATUS lcb_cntl (lcb_INSTANCE *instance, int mode, int cmd, void *arg)
This function exposes an ioctl/fcntl-like interface to read and write various configuration properties to and from an lcb_INSTANCE *handle. More...
lcb_STATUS lcb_cntl_string (lcb_INSTANCE *instance, const char *key, const char *value)
Alternatively one may change configuration settings by passing a string key and value. More...
lcb_STATUS lcb_cntl_setu32 (lcb_INSTANCE *instance, int cmd, lcb_U32 arg)
Convenience function to set a value as an lcb_U32 More...
lcb_U32 lcb_cntl_getu32 (lcb_INSTANCE *instance, int cmd)
Retrieve an lcb_U32 setting More...
int lcb_cntl_exists (int ctl)
 Determine if a specific control code exists. More...
void lcb_refresh_config (lcb_INSTANCE *instance)
Force the library to refetch the cluster configuration More...
const char * lcb_get_version (lcb_U32 *version)
 Get the version of the library. More...
int lcb_supports_feature (int n)
int lcb_is_redacting_logs (lcb_INSTANCE *instance)
 Returns whether the library redacting logs for this connection instance. More...
lcb_STATUS lcb_respanalytics_status (const lcb_RESPANALYTICS *resp)
lcb_STATUS lcb_respanalytics_cookie (const lcb_RESPANALYTICS *resp, void **cookie)
lcb_STATUS lcb_respanalytics_row (const lcb_RESPANALYTICS *resp, const char **row, size_t *row_len)
lcb_STATUS lcb_respanalytics_http_response (const lcb_RESPANALYTICS *resp, const lcb_RESPHTTP **http)
lcb_STATUS lcb_respanalytics_handle (const lcb_RESPANALYTICS *resp, lcb_ANALYTICS_HANDLE **handle)
 Get handle to analytics query. More...
lcb_STATUS lcb_respanalytics_error_context (const lcb_RESPANALYTICS *resp, const lcb_ANALYTICS_ERROR_CONTEXT **ctx)
int lcb_respanalytics_is_final (const lcb_RESPANALYTICS *resp)
lcb_STATUS lcb_respanalytics_deferred_handle_extract (const lcb_RESPANALYTICS *resp, lcb_DEFERRED_HANDLE **handle)
lcb_STATUS lcb_deferred_handle_destroy (lcb_DEFERRED_HANDLE *handle)
lcb_STATUS lcb_deferred_handle_status (lcb_DEFERRED_HANDLE *handle, const char **status, size_t *status_len)
lcb_STATUS lcb_deferred_handle_callback (lcb_DEFERRED_HANDLE *handle, lcb_ANALYTICS_CALLBACK callback)
lcb_STATUS lcb_deferred_handle_poll (lcb_INSTANCE *instance, void *cookie, lcb_DEFERRED_HANDLE *handle)
lcb_STATUS lcb_ingest_options_create (lcb_INGEST_OPTIONS **options)
lcb_STATUS lcb_ingest_options_destroy (lcb_INGEST_OPTIONS *options)
lcb_STATUS lcb_ingest_options_method (lcb_INGEST_OPTIONS *options, lcb_INGEST_METHOD method)
lcb_STATUS lcb_ingest_options_expiry (lcb_INGEST_OPTIONS *options, uint32_t expiration)
lcb_STATUS lcb_ingest_options_ignore_error (lcb_INGEST_OPTIONS *options, int flag)
lcb_STATUS lcb_ingest_options_data_converter (lcb_INGEST_OPTIONS *options, lcb_INGEST_DATACONVERTER_CALLBACK callback)
lcb_STATUS lcb_ingest_dataconverter_param_cookie (lcb_INGEST_PARAM *param, void **cookie)
lcb_STATUS lcb_ingest_dataconverter_param_row (lcb_INGEST_PARAM *param, const char **row, size_t *row_len)
lcb_STATUS lcb_ingest_dataconverter_param_method (lcb_INGEST_PARAM *param, lcb_INGEST_METHOD *method)
lcb_STATUS lcb_ingest_dataconverter_param_set_id (lcb_INGEST_PARAM *param, const char *id, size_t id_len, void(*id_dtor)(const char *))
lcb_STATUS lcb_ingest_dataconverter_param_set_out (lcb_INGEST_PARAM *param, const char *out, size_t out_len, void(*out_dtor)(const char *))
lcb_STATUS lcb_cmdanalytics_create (lcb_CMDANALYTICS **cmd)
lcb_STATUS lcb_cmdanalytics_destroy (lcb_CMDANALYTICS *cmd)
lcb_STATUS lcb_cmdanalytics_reset (lcb_CMDANALYTICS *cmd)
lcb_STATUS lcb_cmdanalytics_parent_span (lcb_CMDANALYTICS *cmd, lcbtrace_SPAN *span)
 Associate parent tracing span with the Analytics request. More...
lcb_STATUS lcb_cmdanalytics_callback (lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_CALLBACK callback)
lcb_STATUS lcb_cmdanalytics_encoded_payload (lcb_CMDANALYTICS *cmd, const char **query, size_t *query_len)
lcb_STATUS lcb_cmdanalytics_payload (lcb_CMDANALYTICS *cmd, const char *query, size_t query_len)
lcb_STATUS lcb_cmdanalytics_statement (lcb_CMDANALYTICS *cmd, const char *statement, size_t statement_len)
lcb_STATUS lcb_cmdanalytics_named_param (lcb_CMDANALYTICS *cmd, const char *name, size_t name_len, const char *value, size_t value_len)
lcb_STATUS lcb_cmdanalytics_positional_param (lcb_CMDANALYTICS *cmd, const char *value, size_t value_len)
lcb_STATUS lcb_cmdanalytics_ingest_options (lcb_CMDANALYTICS *cmd, lcb_INGEST_OPTIONS *options)
lcb_STATUS lcb_cmdanalytics_deferred (lcb_CMDANALYTICS *cmd, int deferred)
lcb_STATUS lcb_cmdanalytics_client_context_id (lcb_CMDANALYTICS *cmd, const char *value, size_t value_len)
lcb_STATUS lcb_cmdanalytics_readonly (lcb_CMDANALYTICS *cmd, int readonly)
lcb_STATUS lcb_cmdanalytics_priority (lcb_CMDANALYTICS *cmd, int priority)
lcb_STATUS lcb_cmdanalytics_consistency (lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_CONSISTENCY level)
lcb_STATUS lcb_cmdanalytics_option (lcb_CMDANALYTICS *cmd, const char *name, size_t name_len, const char *value, size_t value_len)
lcb_STATUS lcb_cmdanalytics_scope_name (lcb_CMDANALYTICS *cmd, const char *scope, size_t scope_len)
 Associate scope name with the query. More...
lcb_STATUS lcb_cmdanalytics_scope_qualifier (lcb_CMDANALYTICS *cmd, const char *qualifier, size_t qualifier_len)
lcb_STATUS lcb_cmdanalytics_handle (lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_HANDLE **handle)
 Get handle to analytics query. More...
lcb_STATUS lcb_cmdanalytics_timeout (lcb_CMDANALYTICS *cmd, uint32_t timeout)
lcb_STATUS lcb_analytics (lcb_INSTANCE *instance, void *cookie, const lcb_CMDANALYTICS *cmd)
 Execute a Analytics query. More...
lcb_STATUS lcb_analytics_cancel (lcb_INSTANCE *instance, lcb_ANALYTICS_HANDLE *handle)
 Cancels an in-progress request. More...
lcb_STATUS lcb_respsearch_status (const lcb_RESPSEARCH *resp)
lcb_STATUS lcb_respsearch_cookie (const lcb_RESPSEARCH *resp, void **cookie)
lcb_STATUS lcb_respsearch_row (const lcb_RESPSEARCH *resp, const char **row, size_t *row_len)
lcb_STATUS lcb_respsearch_http_response (const lcb_RESPSEARCH *resp, const lcb_RESPHTTP **http)
lcb_STATUS lcb_respsearch_handle (const lcb_RESPSEARCH *resp, lcb_SEARCH_HANDLE **handle)
 Get search handle from search response. More...
lcb_STATUS lcb_respsearch_error_context (const lcb_RESPSEARCH *resp, const lcb_SEARCH_ERROR_CONTEXT **ctx)
int lcb_respsearch_is_final (const lcb_RESPSEARCH *resp)
lcb_STATUS lcb_cmdsearch_create (lcb_CMDSEARCH **cmd)
lcb_STATUS lcb_cmdsearch_destroy (lcb_CMDSEARCH *cmd)
lcb_STATUS lcb_cmdsearch_parent_span (lcb_CMDSEARCH *cmd, lcbtrace_SPAN *span)
 Associate parent tracing span with the FTS request. More...
lcb_STATUS lcb_cmdsearch_callback (lcb_CMDSEARCH *cmd, lcb_SEARCH_CALLBACK callback)
lcb_STATUS lcb_cmdsearch_payload (lcb_CMDSEARCH *cmd, const char *payload, size_t payload_len)
lcb_STATUS lcb_cmdsearch_handle (lcb_CMDSEARCH *cmd, lcb_SEARCH_HANDLE **handle)
 Obtain handle to search. More...
lcb_STATUS lcb_cmdsearch_timeout (lcb_CMDSEARCH *cmd, uint32_t timeout)
lcb_STATUS lcb_search (lcb_INSTANCE *instance, void *cookie, const lcb_CMDSEARCH *cmd)
 Issue a full-text query. More...
lcb_STATUS lcb_search_cancel (lcb_INSTANCE *instance, lcb_SEARCH_HANDLE *handle)
 Cancel a full-text query in progress. More...
lcb_STATUS lcb_respquery_status (const lcb_RESPQUERY *resp)
lcb_STATUS lcb_respquery_cookie (const lcb_RESPQUERY *resp, void **cookie)
lcb_STATUS lcb_respquery_row (const lcb_RESPQUERY *resp, const char **row, size_t *row_len)
lcb_STATUS lcb_respquery_http_response (const lcb_RESPQUERY *resp, const lcb_RESPHTTP **http)
lcb_STATUS lcb_respquery_handle (const lcb_RESPQUERY *resp, lcb_QUERY_HANDLE **handle)
lcb_STATUS lcb_respquery_error_context (const lcb_RESPQUERY *resp, const lcb_QUERY_ERROR_CONTEXT **ctx)
int lcb_respquery_is_final (const lcb_RESPQUERY *resp)
lcb_STATUS lcb_cmdquery_create (lcb_CMDQUERY **cmd)
 Create a new lcb_CMDQUERY object. More...
lcb_STATUS lcb_cmdquery_destroy (lcb_CMDQUERY *cmd)
 Free the command structure. More...
lcb_STATUS lcb_cmdquery_reset (lcb_CMDQUERY *cmd)
 Reset the lcb_CMDQUERY structure so that it may be reused for a subsequent query. More...
lcb_STATUS lcb_cmdquery_encoded_payload (lcb_CMDQUERY *cmd, const char **payload, size_t *payload_len)
 Get the JSON-encoded query payload. More...
lcb_STATUS lcb_cmdquery_parent_span (lcb_CMDQUERY *cmd, lcbtrace_SPAN *span)
 Associate parent tracing span with the N1QL request. More...
lcb_STATUS lcb_cmdquery_callback (lcb_CMDQUERY *cmd, lcb_QUERY_CALLBACK callback)
lcb_STATUS lcb_cmdquery_payload (lcb_CMDQUERY *cmd, const char *query, size_t query_len)
 Sets the JSON-encodes query payload to be executed. More...
lcb_STATUS lcb_cmdquery_statement (lcb_CMDQUERY *cmd, const char *statement, size_t statement_len)
 Sets the actual statement to be executed. More...
lcb_STATUS lcb_cmdquery_scope_name (lcb_CMDQUERY *cmd, const char *scope, size_t scope_len)
 Associate scope name with the query. More...
lcb_STATUS lcb_cmdquery_scope_qualifier (lcb_CMDQUERY *cmd, const char *qualifier, size_t qualifier_len)
lcb_STATUS lcb_cmdquery_named_param (lcb_CMDQUERY *cmd, const char *name, size_t name_len, const char *value, size_t value_len)
 Sets a named argument for the query. More...
lcb_STATUS lcb_cmdquery_positional_param (lcb_CMDQUERY *cmd, const char *value, size_t value_len)
 Adds a positional argument for the query. More...
lcb_STATUS lcb_cmdquery_adhoc (lcb_CMDQUERY *cmd, int adhoc)
lcb_STATUS lcb_cmdquery_client_context_id (lcb_CMDQUERY *cmd, const char *value, size_t value_len)
lcb_STATUS lcb_cmdquery_pretty (lcb_CMDQUERY *cmd, int pretty)
lcb_STATUS lcb_cmdquery_readonly (lcb_CMDQUERY *cmd, int readonly)
 Marks query as read-only. More...
lcb_STATUS lcb_cmdquery_metrics (lcb_CMDQUERY *cmd, int metrics)
lcb_STATUS lcb_cmdquery_scan_cap (lcb_CMDQUERY *cmd, int value)
 Sets maximum buffered channel size between the indexer client and the query service for index scans. More...
lcb_STATUS lcb_cmdquery_scan_wait (lcb_CMDQUERY *cmd, uint32_t us)
lcb_STATUS lcb_cmdquery_flex_index (lcb_CMDQUERY *cmd, int value)
lcb_STATUS lcb_cmdquery_profile (lcb_CMDQUERY *cmd, lcb_QUERY_PROFILE mode)
lcb_STATUS lcb_cmdquery_pipeline_cap (lcb_CMDQUERY *cmd, int value)
 Sets maximum number of items each execution operator can buffer between various operators. More...
lcb_STATUS lcb_cmdquery_pipeline_batch (lcb_CMDQUERY *cmd, int value)
 Sets the number of items execution operators can batch for fetch from the KV. More...
lcb_STATUS lcb_cmdquery_max_parallelism (lcb_CMDQUERY *cmd, int value)
lcb_STATUS lcb_cmdquery_consistency (lcb_CMDQUERY *cmd, lcb_QUERY_CONSISTENCY mode)
 Sets the consistency mode for the request. More...
lcb_STATUS lcb_cmdquery_consistency_token_for_keyspace (lcb_CMDQUERY *cmd, const char *keyspace, size_t keyspace_len, const lcb_MUTATION_TOKEN *token)
 Indicate that the query should synchronize its internal snapshot to reflect the changes indicated by the given mutation token (ss). More...
lcb_STATUS lcb_cmdquery_consistency_tokens (lcb_CMDQUERY *cmd, lcb_INSTANCE *instance)
lcb_STATUS lcb_cmdquery_option (lcb_CMDQUERY *cmd, const char *name, size_t name_len, const char *value, size_t value_len)
 Set a query option. More...
lcb_STATUS lcb_cmdquery_handle (lcb_CMDQUERY *cmd, lcb_QUERY_HANDLE **handle)
lcb_STATUS lcb_cmdquery_timeout (lcb_CMDQUERY *cmd, uint32_t timeout)
lcb_STATUS lcb_query (lcb_INSTANCE *instance, void *cookie, const lcb_CMDQUERY *cmd)
 Execute a N1QL query. More...
lcb_STATUS lcb_query_cancel (lcb_INSTANCE *instance, lcb_QUERY_HANDLE *handle)
 Cancels an in-progress request. More...
lcb_STATUS lcb_respview_status (const lcb_RESPVIEW *resp)
lcb_STATUS lcb_respview_cookie (const lcb_RESPVIEW *resp, void **cookie)
lcb_STATUS lcb_respview_key (const lcb_RESPVIEW *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respview_doc_id (const lcb_RESPVIEW *resp, const char **doc_id, size_t *doc_id_len)
lcb_STATUS lcb_respview_row (const lcb_RESPVIEW *resp, const char **row, size_t *row_len)
lcb_STATUS lcb_respview_document (const lcb_RESPVIEW *resp, const lcb_RESPGET **doc)
lcb_STATUS lcb_respview_http_response (const lcb_RESPVIEW *resp, const lcb_RESPHTTP **http)
lcb_STATUS lcb_respview_handle (const lcb_RESPVIEW *resp, lcb_VIEW_HANDLE **handle)
lcb_STATUS lcb_respview_error_context (const lcb_RESPVIEW *resp, const lcb_VIEW_ERROR_CONTEXT **ctx)
int lcb_respview_is_final (const lcb_RESPVIEW *resp)
lcb_STATUS lcb_cmdview_create (lcb_CMDVIEW **cmd)
lcb_STATUS lcb_cmdview_destroy (lcb_CMDVIEW *cmd)
lcb_STATUS lcb_cmdview_parent_span (lcb_CMDVIEW *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdview_callback (lcb_CMDVIEW *cmd, lcb_VIEW_CALLBACK callback)
lcb_STATUS lcb_cmdview_design_document (lcb_CMDVIEW *cmd, const char *ddoc, size_t ddoc_len)
lcb_STATUS lcb_cmdview_view_name (lcb_CMDVIEW *cmd, const char *view, size_t view_len)
lcb_STATUS lcb_cmdview_option_string (lcb_CMDVIEW *cmd, const char *optstr, size_t optstr_len)
lcb_STATUS lcb_cmdview_post_data (lcb_CMDVIEW *cmd, const char *data, size_t data_len)
lcb_STATUS lcb_cmdview_include_docs (lcb_CMDVIEW *cmd, int include_docs)
lcb_STATUS lcb_cmdview_max_concurrent_docs (lcb_CMDVIEW *cmd, uint32_t num)
lcb_STATUS lcb_cmdview_no_row_parse (lcb_CMDVIEW *cmd, int flag)
lcb_STATUS lcb_cmdview_handle (lcb_CMDVIEW *cmd, lcb_VIEW_HANDLE **handle)
lcb_STATUS lcb_cmdview_timeout (lcb_CMDVIEW *cmd, uint32_t timeout)
lcb_STATUS lcb_view (lcb_INSTANCE *instance, void *cookie, const lcb_CMDVIEW *cmd)
lcb_STATUS lcb_view_cancel (lcb_INSTANCE *instance, lcb_VIEW_HANDLE *handle)
lcb_STATUS lcb_respsubdoc_status (const lcb_RESPSUBDOC *resp)
lcb_STATUS lcb_respsubdoc_error_context (const lcb_RESPSUBDOC *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx)
lcb_STATUS lcb_respsubdoc_cookie (const lcb_RESPSUBDOC *resp, void **cookie)
lcb_STATUS lcb_respsubdoc_cas (const lcb_RESPSUBDOC *resp, uint64_t *cas)
lcb_STATUS lcb_respsubdoc_key (const lcb_RESPSUBDOC *resp, const char **key, size_t *key_len)
lcb_STATUS lcb_respsubdoc_mutation_token (const lcb_RESPSUBDOC *resp, lcb_MUTATION_TOKEN *token)
size_t lcb_respsubdoc_result_size (const lcb_RESPSUBDOC *resp)
lcb_STATUS lcb_respsubdoc_result_status (const lcb_RESPSUBDOC *resp, size_t index)
lcb_STATUS lcb_respsubdoc_result_value (const lcb_RESPSUBDOC *resp, size_t index, const char **value, size_t *value_len)
lcb_STATUS lcb_subdocspecs_create (lcb_SUBDOCSPECS **operations, size_t capacity)
lcb_STATUS lcb_subdocspecs_destroy (lcb_SUBDOCSPECS *operations)
lcb_STATUS lcb_subdocspecs_get (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len)
lcb_STATUS lcb_subdocspecs_exists (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len)
lcb_STATUS lcb_subdocspecs_replace (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_dict_add (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_dict_upsert (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_array_add_first (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_array_add_last (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_array_add_unique (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_array_insert (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, const char *value, size_t value_len)
lcb_STATUS lcb_subdocspecs_counter (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len, int64_t delta)
lcb_STATUS lcb_subdocspecs_remove (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len)
lcb_STATUS lcb_subdocspecs_get_count (lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags, const char *path, size_t path_len)
lcb_STATUS lcb_cmdsubdoc_create (lcb_CMDSUBDOC **cmd)
lcb_STATUS lcb_cmdsubdoc_destroy (lcb_CMDSUBDOC *cmd)
lcb_STATUS lcb_cmdsubdoc_parent_span (lcb_CMDSUBDOC *cmd, lcbtrace_SPAN *span)
lcb_STATUS lcb_cmdsubdoc_collection (lcb_CMDSUBDOC *cmd, const char *scope, size_t scope_len, const char *collection, size_t collection_len)
lcb_STATUS lcb_cmdsubdoc_key (lcb_CMDSUBDOC *cmd, const char *key, size_t key_len)
lcb_STATUS lcb_cmdsubdoc_cas (lcb_CMDSUBDOC *cmd, uint64_t cas)
lcb_STATUS lcb_cmdsubdoc_specs (lcb_CMDSUBDOC *cmd, const lcb_SUBDOCSPECS *operations)
lcb_STATUS lcb_cmdsubdoc_expiry (lcb_CMDSUBDOC *cmd, uint32_t expiration)
lcb_STATUS lcb_cmdsubdoc_durability (lcb_CMDSUBDOC *cmd, lcb_DURABILITY_LEVEL level)
lcb_STATUS lcb_cmdsubdoc_store_semantics (lcb_CMDSUBDOC *cmd, lcb_SUBDOC_STORE_SEMANTICS mode)
lcb_STATUS lcb_cmdsubdoc_access_deleted (lcb_CMDSUBDOC *cmd, int flag)
lcb_STATUS lcb_cmdsubdoc_create_as_deleted (lcb_CMDSUBDOC *cmd, int flag)
 If new document created, the server will create it as a tombstone. More...
lcb_STATUS lcb_cmdsubdoc_timeout (lcb_CMDSUBDOC *cmd, uint32_t timeout)
lcb_STATUS lcb_subdoc (lcb_INSTANCE *instance, void *cookie, const lcb_CMDSUBDOC *cmd)


LCB_EXTERN_VAR const lcb_U32 lcb_version_g
 Global/extern variable containing the version of the library.

Detailed Description

Main header file for Couchbase.

Macro Definition Documentation





Access document virtual/materialized path.


Typedef Documentation


typedef struct lcb_RESPTOUCH_ lcb_RESPTOUCH

Spool a touch request.

instancethe handle
cookiethe pointer to associate with the request
cmdthe command
LCB_SUCCESS on success, other error code on failure
lcb_CMDTOUCH* cmd;
lcb_cmdtouch_key(cmd, "keep_me", strlen("keep_me"));
lcb_cmdtouch_expiry(cmd, 0); // Clear the expiration
lcb_touch(instance, cookie, cmd);
lcb_install_callback(instance, LCB_CALLBACK_TOUCH, touch_callback);
void touch_callback(lcb_INSTANCE *instance, int cbtype, const lcb_RESPBASE *rb)
const lcb_RESPTOUCH* resp = (const lcb_RESPTOUCH*)rb;
lcb_STATUS = lcb_resptouch_status(resp);
if (rc == LCB_SUCCESS) {
printf("Touch succeeded\n");


typedef struct lcb_RESPHTTP_ lcb_RESPHTTP

Issue an HTTP API request.
instancethe library handle
cookiecookie to be associated with the request
cmdthe command
LCB_SUCCESS if the request was scheduled successfully.
Simple Response
void http_callback(lcb_INSTANCE, int, const lcb_RESPBASE *rb)
const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)rb;
lcb_STATUS rc = lcb_resphttp_status(resp);
uint16_t http_status;
char* body;
size_t body_len;
const char* const* headers;
lcb_resphttp_http_status(resp, &http_status);
lcb_resphttp_body(resp, &body, &body_len);
if (rc != LCB_SUCCESS) {
printf("I/O Error for HTTP: %s\n", lcb_strerror_short(rc));
printf("Got HTTP Status: %d\n", http_status);
printf("Got paylod: %.*s\n", body_len, body);
lcb_resphttp_headers(resp, &headers);
if (headers) {
for(const char* const* cur = headers; *cur; cur+=2) {
printf("%s: %s\n", cur[0], cur[1]);
Streaming Response
If the LCB_CMDHTTP_F_STREAM flag is set in lcb_CMDHTTP::cmdflags then the response callback is invoked multiple times as data arrives off the socket.
void http_strm_callback(lcb_INSTANCE, int, const lcb_RESPBASE *rb)
const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)resp;
char* body;
size_t body_len;
const char* const* headers;
if (lcb_resphttp_is_final(resp)) {
if (lcb_resphttp_status(resp) != LCB_SUCCESS) {
// ....
lcb_resphttp_headers(resp, &headers);
if (headers) {
// ...
} else {
lcb_resphttp_body(resp, &body, &body_len);
handle_body(body, body_len);
Connection Reuse
The library will attempt to reuse connections for frequently contacted hosts. By default the library will keep one idle connection to each host for a maximum of 10 seconds. The number of open idle HTTP connections can be controlled with LCB_CNTL_HTTP_POOLSIZE.

◆ lcb_destroy_callback

typedef void(* lcb_destroy_callback) (const void *cookie)

Callback received when instance is about to be destroyed.

cookiecookie passed to lcb_destroy_async()

Enumeration Type Documentation


The type of HTTP request to execute.


Execute a request against the bucket.

The handle must be of LCB_TYPE_BUCKET and must be connected.


Execute a management API request.

The credentials used will match those passed during the instance creation time. Thus is the instance type is LCB_TYPE_BUCKET then only bucket-level credentials will be used.


Execute an arbitrary request against a host and port.


Execute an N1QL Query.


Search a fulltext index.


Execute an Analytics Query.


Special pseudo-type, for ping endpoints in various services.

Behaves like RAW (the lcb_ping3() function will setup custom path), but supports Keep-Alive


HTTP Request method enumeration These just enumerate the various types of HTTP request methods supported.

Refer to the specific cluster or view API to see which method is appropriate for your request



Function Documentation

◆ lcb_resphttp_headers()

lcb_STATUS lcb_resphttp_headers ( const lcb_RESPHTTP resp,
const char *const **  headers 

List of key-value headers.

This field itself may be NULL. The list is terminated by a NULL pointer to indicate no more headers.


◆ lcb_http_cancel()

lcb_STATUS lcb_http_cancel ( lcb_INSTANCE instance,
lcb_HTTP_HANDLE *  handle 

Cancel ongoing HTTP request

This API will stop the current request. Any pending callbacks will not be invoked any any pending data will not be delivered. Useful for a long running request which is no longer needed

instanceThe handle to lcb
handleThe request handle
lcb_CMDHTTP* cmd;
lcb_HTTP_HANDLE* handle;
// flesh out the actual request...
lcb_http(instance, cookie, cmd);
lcb_cmdhttp_handle(cmd, &handle);
lcb_cancel_http_request(instance, handle);

◆ lcb_destroy()

void lcb_destroy ( lcb_INSTANCE instance)

Destroy (and release all allocated resources) an instance of lcb.

Using instance after calling destroy will most likely cause your application to crash.

Note that any pending operations will not have their callbacks invoked.

instancethe instance to destroy.
example/analytics/analytics.c, example/crypto/openssl_symmetric_decrypt.c, example/crypto/openssl_symmetric_encrypt.c, example/fts/fts.c, example/libeventdirect/main.c, example/minimal/minimal.c, example/minimal/query.c, example/observe/durability.c, example/subdoc/subdoc-xattrs.c, example/tracing/tracing.c, and example/tracing/views.c.

◆ lcb_set_destroy_callback()

lcb_destroy_callback lcb_set_destroy_callback ( lcb_INSTANCE instance,

Set the callback to be invoked when the instance is destroyed asynchronously.

the previous callback.

◆ lcb_destroy_async()

void lcb_destroy_async ( lcb_INSTANCE instance,
const void *  arg 

Asynchronously schedule the destruction of an instance.

This function provides a safe way for asynchronous environments to destroy the lcb_INSTANCE *handle without worrying about reentrancy issues.

arga pointer passed to the callback.

While the callback and cookie are optional, they are very much recommended for testing scenarios where you wish to ensure that all resources allocated by the instance have been closed. Specifically when the callback is invoked, all timers (save for the one actually triggering the destruction) and sockets will have been closed.

As with lcb_destroy() you may call this function only once. You may not call this function together with lcb_destroy as the two are mutually exclusive.

If for whatever reason this function is being called in a synchronous flow, lcb_wait() must be invoked in order for the destruction to take effect

See also

◆ lcb_cmdsubdoc_create_as_deleted()

lcb_STATUS lcb_cmdsubdoc_create_as_deleted ( lcb_CMDSUBDOC *  cmd,
int  flag 

If new document created, the server will create it as a tombstone.

Any system or user XATTRs will be stored, but a document body will not be.