Couchbase C Client  3.3.6
Asynchronous C Client for Couchbase
couchbase.h
Go to the documentation of this file.
1/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright 2010-2020 Couchbase, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#ifndef LIBCOUCHBASE_COUCHBASE_H
19#define LIBCOUCHBASE_COUCHBASE_H 1
20
26struct lcb_st;
27
35typedef struct lcb_st lcb_INSTANCE;
36typedef struct lcb_HTTP_HANDLE_ lcb_HTTP_HANDLE;
37
38#include <stddef.h>
39#include <time.h>
40#include <stdarg.h>
41#include <stdio.h>
42#include <libcouchbase/sysdefs.h>
43#include <libcouchbase/assert.h>
44#include <libcouchbase/visibility.h>
45#include <libcouchbase/error.h>
46#include <libcouchbase/iops.h>
47#include <libcouchbase/configuration.h>
48#include <libcouchbase/kvbuf.h>
49#include <libcouchbase/auth.h>
50#include <libcouchbase/metrics.h>
51#include <libcouchbase/tracing.h>
52#include <libcouchbase/logger.h>
53#include <libcouchbase/cntl.h>
54
55#ifdef __cplusplus
56extern "C" {
57#endif
58
59/******************************************************************************
60 ******************************************************************************
61 ******************************************************************************
62 ** INITIALIZATION **
63 ******************************************************************************
64 ******************************************************************************
65 ******************************************************************************/
66
240typedef enum {
241 LCB_BTYPE_UNSPEC = 0x00,
242 LCB_BTYPE_COUCHBASE = 0x01,
243 LCB_BTYPE_EPHEMERAL = 0x02,
244 LCB_BTYPE_MEMCACHED = 0x03
245} lcb_BTYPE;
246
247typedef enum {
248 LCB_CONFIG_TRANSPORT_LIST_END = 0,
249 LCB_CONFIG_TRANSPORT_HTTP = 1,
250 LCB_CONFIG_TRANSPORT_CCCP,
251 LCB_CONFIG_TRANSPORT_MAX
252} lcb_BOOTSTRAP_TRANSPORT;
253
255typedef enum {
256 LCB_TYPE_BUCKET = 0x00,
257 LCB_TYPE_CLUSTER = 0x01
258} lcb_INSTANCE_TYPE;
259
260typedef struct lcb_CREATEOPTS_ lcb_CREATEOPTS;
261
262LIBCOUCHBASE_API lcb_STATUS lcb_createopts_create(lcb_CREATEOPTS **options, lcb_INSTANCE_TYPE type);
263LIBCOUCHBASE_API lcb_STATUS lcb_createopts_destroy(lcb_CREATEOPTS *options);
264LIBCOUCHBASE_API lcb_STATUS lcb_createopts_connstr(lcb_CREATEOPTS *options, const char *connstr, size_t connstr_len);
265LIBCOUCHBASE_API lcb_STATUS lcb_createopts_bucket(lcb_CREATEOPTS *options, const char *bucket, size_t bucket_len);
266LIBCOUCHBASE_API lcb_STATUS lcb_createopts_logger(lcb_CREATEOPTS *options, const lcb_LOGGER *logger);
267LIBCOUCHBASE_API lcb_STATUS lcb_createopts_credentials(lcb_CREATEOPTS *options, const char *username,
268 size_t username_len, const char *password, size_t password_len);
269LIBCOUCHBASE_API lcb_STATUS lcb_createopts_authenticator(lcb_CREATEOPTS *options, lcb_AUTHENTICATOR *auth);
270LIBCOUCHBASE_API lcb_STATUS lcb_createopts_io(lcb_CREATEOPTS *options, struct lcb_io_opt_st *io);
271LIBCOUCHBASE_API lcb_STATUS lcb_createopts_meter(lcb_CREATEOPTS *options, const lcbmetrics_METER *metrics);
272
273LIBCOUCHBASE_API lcb_STATUS lcb_createopts_tracer(lcb_CREATEOPTS *options, lcbtrace_TRACER *tracer);
317LIBCOUCHBASE_API
318lcb_STATUS lcb_create(lcb_INSTANCE **instance, const lcb_CREATEOPTS *options);
319
342LIBCOUCHBASE_API
343lcb_STATUS lcb_connect(lcb_INSTANCE *instance);
344
354typedef void (*lcb_bootstrap_callback)(lcb_INSTANCE *instance, lcb_STATUS err);
355
366LIBCOUCHBASE_API
367lcb_bootstrap_callback lcb_set_bootstrap_callback(lcb_INSTANCE *instance, lcb_bootstrap_callback callback);
368
381LIBCOUCHBASE_API
382lcb_STATUS lcb_get_bootstrap_status(lcb_INSTANCE *instance);
383
392LIBCOUCHBASE_API
393void lcb_set_auth(lcb_INSTANCE *instance, lcb_AUTHENTICATOR *auth);
413typedef struct {
414 uint64_t uuid_;
415 uint64_t seqno_;
416 uint16_t vbid_;
417} lcb_MUTATION_TOKEN;
418
419LIBCOUCHBASE_API int lcb_mutation_token_is_valid(const lcb_MUTATION_TOKEN *token);
420
430typedef enum {
432 LCB_RESP_F_FINAL = 0x01,
433
439 LCB_RESP_F_CLIENTGEN = 0x02,
440
442 LCB_RESP_F_NMVGEN = 0x04,
443
446 LCB_RESP_F_EXTDATA = 0x08,
447
450 LCB_RESP_F_SDSINGLE = 0x10,
451
453 LCB_RESP_F_ERRINFO = 0x20
454} lcb_RESPFLAGS;
455
469typedef enum {
470 LCB_CALLBACK_DEFAULT = 0,
471 LCB_CALLBACK_GET,
472 LCB_CALLBACK_STORE,
473 LCB_CALLBACK_COUNTER,
474 LCB_CALLBACK_TOUCH,
475 LCB_CALLBACK_REMOVE,
476 LCB_CALLBACK_UNLOCK,
477 LCB_CALLBACK_STATS,
478 LCB_CALLBACK_VERSIONS,
479 LCB_CALLBACK_VERBOSITY,
480 LCB_CALLBACK_OBSERVE,
481 LCB_CALLBACK_GETREPLICA,
482 LCB_CALLBACK_ENDURE,
483 LCB_CALLBACK_HTTP,
484 LCB_CALLBACK_CBFLUSH,
485 LCB_CALLBACK_OBSEQNO,
486 LCB_CALLBACK_STOREDUR,
487 LCB_CALLBACK_SDLOOKUP,
488 LCB_CALLBACK_SDMUTATE,
489 LCB_CALLBACK_NOOP,
490 LCB_CALLBACK_PING,
491 LCB_CALLBACK_DIAG,
492 LCB_CALLBACK_COLLECTIONS_GET_MANIFEST,
493 LCB_CALLBACK_GETCID,
494 LCB_CALLBACK_EXISTS,
495 LCB_CALLBACK__MAX /* Number of callbacks */
496} lcb_CALLBACK_TYPE;
497
498/* The following callback types cannot be set using lcb_install_callback(),
499 * however, their value is passed along as the second argument of their
500 * respective callbacks. This allows you to still use the same callback,
501 * differentiating their meaning by the type. */
502
504#define LCB_CALLBACK_VIEWQUERY -1
505
507#define LCB_CALLBACK_QUERY -2
508
510#define LCB_CALLBACK_IXMGMT -3
511
513#define LCB_CALLBACK_ANALYTICS -4
514
516#define LCB_CALLBACK_SEARCH -5
517
518#define LCB_CALLBACK_OPEN -6
519
524typedef enum {
525 LCB_DURABILITYLEVEL_NONE = 0x00,
531 LCB_DURABILITYLEVEL_MAJORITY = 0x01,
535 LCB_DURABILITYLEVEL_MAJORITY_AND_PERSIST_TO_ACTIVE = 0x02,
540 LCB_DURABILITYLEVEL_PERSIST_TO_MAJORITY = 0x03
541} lcb_DURABILITY_LEVEL;
542
543typedef void lcb_CMDBASE;
544typedef void lcb_RESPBASE;
545
554typedef void (*lcb_RESPCALLBACK)(lcb_INSTANCE *instance, int cbtype, const lcb_RESPBASE *resp);
555
577LIBCOUCHBASE_API
578lcb_RESPCALLBACK lcb_install_callback(lcb_INSTANCE *instance, int cbtype, lcb_RESPCALLBACK cb);
579
592LIBCOUCHBASE_API
593lcb_RESPCALLBACK lcb_get_callback(lcb_INSTANCE *instance, int cbtype);
594
601LIBCOUCHBASE_API
602const char *lcb_strcbtype(int cbtype);
603
687typedef struct lcb_RESPGET_ lcb_RESPGET;
688
689LIBCOUCHBASE_API lcb_STATUS lcb_respget_status(const lcb_RESPGET *resp);
690LIBCOUCHBASE_API lcb_STATUS lcb_respget_error_context(const lcb_RESPGET *resp, const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
691LIBCOUCHBASE_API lcb_STATUS lcb_respget_cookie(const lcb_RESPGET *resp, void **cookie);
692LIBCOUCHBASE_API lcb_STATUS lcb_respget_cas(const lcb_RESPGET *resp, uint64_t *cas);
693LIBCOUCHBASE_API lcb_STATUS lcb_respget_datatype(const lcb_RESPGET *resp, uint8_t *datatype);
694LIBCOUCHBASE_API lcb_STATUS lcb_respget_flags(const lcb_RESPGET *resp, uint32_t *flags);
695LIBCOUCHBASE_API lcb_STATUS lcb_respget_key(const lcb_RESPGET *resp, const char **key, size_t *key_len);
696LIBCOUCHBASE_API lcb_STATUS lcb_respget_value(const lcb_RESPGET *resp, const char **value, size_t *value_len);
697
698typedef struct lcb_CMDGET_ lcb_CMDGET;
699
700LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_create(lcb_CMDGET **cmd);
701LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_destroy(lcb_CMDGET *cmd);
702LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_parent_span(lcb_CMDGET *cmd, lcbtrace_SPAN *span);
703LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_collection(lcb_CMDGET *cmd, const char *scope, size_t scope_len,
704 const char *collection, size_t collection_len);
705LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_key(lcb_CMDGET *cmd, const char *key, size_t key_len);
706LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_expiry(lcb_CMDGET *cmd, uint32_t expiration);
707LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_locktime(lcb_CMDGET *cmd, uint32_t duration);
708LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_timeout(lcb_CMDGET *cmd, uint32_t timeout);
712LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of(lcb_CMDGET *cmd, const char *data, size_t data_len);
716LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of_extra_privilege(lcb_CMDGET *cmd, const char *privilege,
717 size_t privilege_len);
718
719LIBCOUCHBASE_API lcb_STATUS lcb_get(lcb_INSTANCE *instance, void *cookie, const lcb_CMDGET *cmd);
787typedef enum {
788 LCB_REPLICA_MODE_ANY = 0x00,
789 LCB_REPLICA_MODE_ALL = 0x01,
790 LCB_REPLICA_MODE_IDX0 = 0x02,
791 LCB_REPLICA_MODE_IDX1 = 0x03,
792 LCB_REPLICA_MODE_IDX2 = 0x04,
793 LCB_REPLICA_MODE__MAX
794} lcb_REPLICA_MODE;
795
796typedef struct lcb_RESPGETREPLICA_ lcb_RESPGETREPLICA;
797
798LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_status(const lcb_RESPGETREPLICA *resp);
799LIBCOUCHBASE_API int lcb_respgetreplica_is_active(const lcb_RESPGETREPLICA *resp);
800LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_error_context(const lcb_RESPGETREPLICA *resp,
801 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
802LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_cookie(const lcb_RESPGETREPLICA *resp, void **cookie);
803LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_cas(const lcb_RESPGETREPLICA *resp, uint64_t *cas);
804LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_datatype(const lcb_RESPGETREPLICA *resp, uint8_t *datatype);
805LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_flags(const lcb_RESPGETREPLICA *resp, uint32_t *flags);
806LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_key(const lcb_RESPGETREPLICA *resp, const char **key, size_t *key_len);
807LIBCOUCHBASE_API lcb_STATUS lcb_respgetreplica_value(const lcb_RESPGETREPLICA *resp, const char **value,
808 size_t *value_len);
809LIBCOUCHBASE_API int lcb_respgetreplica_is_final(const lcb_RESPGETREPLICA *resp);
810
811typedef struct lcb_CMDGETREPLICA_ lcb_CMDGETREPLICA;
812
813LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_create(lcb_CMDGETREPLICA **cmd, lcb_REPLICA_MODE mode);
814LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_destroy(lcb_CMDGETREPLICA *cmd);
815LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_parent_span(lcb_CMDGETREPLICA *cmd, lcbtrace_SPAN *span);
816LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_collection(lcb_CMDGETREPLICA *cmd, const char *scope, size_t scope_len,
817 const char *collection, size_t collection_len);
818LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_key(lcb_CMDGETREPLICA *cmd, const char *key, size_t key_len);
819LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_timeout(lcb_CMDGETREPLICA *cmd, uint32_t timeout);
823LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of(lcb_CMDGETREPLICA *cmd, const char *data, size_t data_len);
827LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of_extra_privilege(lcb_CMDGETREPLICA *cmd,
828 const char *privilege, size_t privilege_len);
829LIBCOUCHBASE_API lcb_STATUS lcb_getreplica(lcb_INSTANCE *instance, void *cookie, const lcb_CMDGETREPLICA *cmd);
830
833typedef struct lcb_RESPEXISTS_ lcb_RESPEXISTS;
834
835LIBCOUCHBASE_API lcb_STATUS lcb_respexists_status(const lcb_RESPEXISTS *resp);
836LIBCOUCHBASE_API int lcb_respexists_is_found(const lcb_RESPEXISTS *resp);
837LIBCOUCHBASE_API lcb_STATUS lcb_respexists_error_context(const lcb_RESPEXISTS *resp,
838 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
839LIBCOUCHBASE_API lcb_STATUS lcb_respexists_cookie(const lcb_RESPEXISTS *resp, void **cookie);
840LIBCOUCHBASE_API lcb_STATUS lcb_respexists_cas(const lcb_RESPEXISTS *resp, uint64_t *cas);
841LIBCOUCHBASE_API lcb_STATUS lcb_respexists_key(const lcb_RESPEXISTS *resp, const char **key, size_t *key_len);
842
843typedef struct lcb_CMDEXISTS_ lcb_CMDEXISTS;
844
845LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_create(lcb_CMDEXISTS **cmd);
846LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_destroy(lcb_CMDEXISTS *cmd);
847LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_parent_span(lcb_CMDEXISTS *cmd, lcbtrace_SPAN *span);
848LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_collection(lcb_CMDEXISTS *cmd, const char *scope, size_t scope_len,
849 const char *collection, size_t collection_len);
850LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_key(lcb_CMDEXISTS *cmd, const char *key, size_t key_len);
851LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_timeout(lcb_CMDEXISTS *cmd, uint32_t timeout);
855LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of(lcb_CMDEXISTS *cmd, const char *data, size_t data_len);
859LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of_extra_privilege(lcb_CMDEXISTS *cmd, const char *privilege,
860 size_t privilege_len);
861
862LIBCOUCHBASE_API lcb_STATUS lcb_exists(lcb_INSTANCE *instance, void *cookie, const lcb_CMDEXISTS *cmd);
863
878typedef enum {
887 LCB_STORE_UPSERT = 0x00,
888
893 LCB_STORE_INSERT = 0x01,
894
899 LCB_STORE_REPLACE = 0x02,
900
906 LCB_STORE_APPEND = 0x04,
907
911 LCB_STORE_PREPEND = 0x05
912} lcb_STORE_OPERATION;
913
971typedef struct lcb_RESPSTORE_ lcb_RESPSTORE;
972
973LIBCOUCHBASE_API lcb_STATUS lcb_respstore_status(const lcb_RESPSTORE *resp);
974LIBCOUCHBASE_API lcb_STATUS lcb_respstore_error_context(const lcb_RESPSTORE *resp,
975 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
976LIBCOUCHBASE_API lcb_STATUS lcb_respstore_cookie(const lcb_RESPSTORE *resp, void **cookie);
977LIBCOUCHBASE_API lcb_STATUS lcb_respstore_cas(const lcb_RESPSTORE *resp, uint64_t *cas);
978LIBCOUCHBASE_API lcb_STATUS lcb_respstore_key(const lcb_RESPSTORE *resp, const char **key, size_t *key_len);
979LIBCOUCHBASE_API lcb_STATUS lcb_respstore_operation(const lcb_RESPSTORE *resp, lcb_STORE_OPERATION *operation);
980LIBCOUCHBASE_API lcb_STATUS lcb_respstore_mutation_token(const lcb_RESPSTORE *resp, lcb_MUTATION_TOKEN *token);
981
982LIBCOUCHBASE_API int lcb_respstore_observe_attached(const lcb_RESPSTORE *resp);
983LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_stored(const lcb_RESPSTORE *resp, int *store_ok);
984LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_master_exists(const lcb_RESPSTORE *resp, int *master_exists);
985LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_master_persisted(const lcb_RESPSTORE *resp, int *master_persisted);
986LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_num_responses(const lcb_RESPSTORE *resp, uint16_t *num_responses);
987LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_num_persisted(const lcb_RESPSTORE *resp, uint16_t *num_persisted);
988LIBCOUCHBASE_API lcb_STATUS lcb_respstore_observe_num_replicated(const lcb_RESPSTORE *resp, uint16_t *num_replicated);
989
990typedef struct lcb_CMDSTORE_ lcb_CMDSTORE;
991
992LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_create(lcb_CMDSTORE **cmd, lcb_STORE_OPERATION operation);
993LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_destroy(lcb_CMDSTORE *cmd);
994LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_parent_span(lcb_CMDSTORE *cmd, lcbtrace_SPAN *span);
995LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_collection(lcb_CMDSTORE *cmd, const char *scope, size_t scope_len,
996 const char *collection, size_t collection_len);
997LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_key(lcb_CMDSTORE *cmd, const char *key, size_t key_len);
998LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_value(lcb_CMDSTORE *cmd, const char *value, size_t value_len);
999LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_value_iov(lcb_CMDSTORE *cmd, const lcb_IOV *value, size_t value_len);
1000LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_expiry(lcb_CMDSTORE *cmd, uint32_t expiration);
1001LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_preserve_expiry(lcb_CMDSTORE *cmd, int should_preserve);
1002LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_cas(lcb_CMDSTORE *cmd, uint64_t cas);
1003LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_flags(lcb_CMDSTORE *cmd, uint32_t flags);
1004LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_datatype(lcb_CMDSTORE *cmd, uint8_t datatype);
1005LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_durability(lcb_CMDSTORE *cmd, lcb_DURABILITY_LEVEL level);
1006LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_durability_observe(lcb_CMDSTORE *cmd, int persist_to, int replicate_to);
1007LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_timeout(lcb_CMDSTORE *cmd, uint32_t timeout);
1011LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of(lcb_CMDSTORE *cmd, const char *data, size_t data_len);
1015LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of_extra_privilege(lcb_CMDSTORE *cmd, const char *privilege,
1016 size_t privilege_len);
1017LIBCOUCHBASE_API lcb_STATUS lcb_store(lcb_INSTANCE *instance, void *cookie, const lcb_CMDSTORE *cmd);
1028typedef void (*lcb_open_callback)(lcb_INSTANCE *instance, lcb_STATUS err);
1035LIBCOUCHBASE_API lcb_open_callback lcb_set_open_callback(lcb_INSTANCE *instance, lcb_open_callback callback);
1036
1046LIBCOUCHBASE_API lcb_STATUS lcb_open(lcb_INSTANCE *instance, const char *bucket, size_t bucket_len);
1101typedef struct lcb_RESPREMOVE_ lcb_RESPREMOVE;
1102
1103LIBCOUCHBASE_API lcb_STATUS lcb_respremove_status(const lcb_RESPREMOVE *resp);
1104LIBCOUCHBASE_API lcb_STATUS lcb_respremove_error_context(const lcb_RESPREMOVE *resp,
1105 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
1106LIBCOUCHBASE_API lcb_STATUS lcb_respremove_cookie(const lcb_RESPREMOVE *resp, void **cookie);
1107LIBCOUCHBASE_API lcb_STATUS lcb_respremove_cas(const lcb_RESPREMOVE *resp, uint64_t *cas);
1108LIBCOUCHBASE_API lcb_STATUS lcb_respremove_key(const lcb_RESPREMOVE *resp, const char **key, size_t *key_len);
1109LIBCOUCHBASE_API lcb_STATUS lcb_respremove_mutation_token(const lcb_RESPREMOVE *resp, lcb_MUTATION_TOKEN *token);
1110
1111typedef struct lcb_CMDREMOVE_ lcb_CMDREMOVE;
1112
1113LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_create(lcb_CMDREMOVE **cmd);
1114LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_destroy(lcb_CMDREMOVE *cmd);
1115LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_parent_span(lcb_CMDREMOVE *cmd, lcbtrace_SPAN *span);
1116LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_collection(lcb_CMDREMOVE *cmd, const char *scope, size_t scope_len,
1117 const char *collection, size_t collection_len);
1118LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_key(lcb_CMDREMOVE *cmd, const char *key, size_t key_len);
1119LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_cas(lcb_CMDREMOVE *cmd, uint64_t cas);
1120LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_durability(lcb_CMDREMOVE *cmd, lcb_DURABILITY_LEVEL level);
1121LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_timeout(lcb_CMDREMOVE *cmd, uint32_t timeout);
1125LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of(lcb_CMDREMOVE *cmd, const char *data, size_t data_len);
1129LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of_extra_privilege(lcb_CMDREMOVE *cmd, const char *privilege,
1130 size_t privilege_len);
1131LIBCOUCHBASE_API lcb_STATUS lcb_remove(lcb_INSTANCE *instance, void *cookie, const lcb_CMDREMOVE *cmd);
1132
1194typedef struct lcb_RESPCOUNTER_ lcb_RESPCOUNTER;
1195
1196LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_status(const lcb_RESPCOUNTER *resp);
1197LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_error_context(const lcb_RESPCOUNTER *resp,
1198 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
1199LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_cookie(const lcb_RESPCOUNTER *resp, void **cookie);
1200LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_cas(const lcb_RESPCOUNTER *resp, uint64_t *cas);
1201LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_key(const lcb_RESPCOUNTER *resp, const char **key, size_t *key_len);
1202LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_mutation_token(const lcb_RESPCOUNTER *resp, lcb_MUTATION_TOKEN *token);
1203LIBCOUCHBASE_API lcb_STATUS lcb_respcounter_value(const lcb_RESPCOUNTER *resp, uint64_t *value);
1204
1205typedef struct lcb_CMDCOUNTER_ lcb_CMDCOUNTER;
1206
1207LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_create(lcb_CMDCOUNTER **cmd);
1208LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_destroy(lcb_CMDCOUNTER *cmd);
1209LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_parent_span(lcb_CMDCOUNTER *cmd, lcbtrace_SPAN *span);
1210LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_collection(lcb_CMDCOUNTER *cmd, const char *scope, size_t scope_len,
1211 const char *collection, size_t collection_len);
1212LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_key(lcb_CMDCOUNTER *cmd, const char *key, size_t key_len);
1213LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_expiry(lcb_CMDCOUNTER *cmd, uint32_t expiration);
1214LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_delta(lcb_CMDCOUNTER *cmd, int64_t number);
1215LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_initial(lcb_CMDCOUNTER *cmd, uint64_t number);
1216LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_durability(lcb_CMDCOUNTER *cmd, lcb_DURABILITY_LEVEL level);
1217LCB_DEPRECATED2(LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_cas(lcb_CMDCOUNTER *cmd, uint64_t cas),
1218 "CAS is not applicable to arithmetic operations");
1219LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_timeout(lcb_CMDCOUNTER *cmd, uint32_t timeout);
1223LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of(lcb_CMDCOUNTER *cmd, const char *data, size_t data_len);
1227LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of_extra_privilege(lcb_CMDCOUNTER *cmd, const char *privilege,
1228 size_t privilege_len);
1229LIBCOUCHBASE_API lcb_STATUS lcb_counter(lcb_INSTANCE *instance, void *cookie, const lcb_CMDCOUNTER *cmd);
1230
1233/* @ingroup lcb-kv-api
1234 * @defgroup lcb-lock Lock/Unlock
1235 * @details Documents may be locked and unlocked on the server. While a document
1236 * is locked, any attempt to modify it (or lock it again) will fail.
1237 *
1238 * @note Locks are not persistent across nodes (if a node fails over, the lock
1239 * is not transferred to a replica).
1240 * @note The recommended way to manage access and concurrency control for
1241 * documents in Couchbase is through the CAS, which can also be considered
1242 * a form of opportunistic locking.
1243 *
1244 * @par Locking an item
1245 * There is no exclusive function to lock an item. Locking an item is done
1246 * using @ref lcb_get(), by setting the lcb_cmdget_locktime.
1247 *
1248 * @addtogroup lcb-lock
1249 * @{
1250 */
1251
1287typedef struct lcb_RESPUNLOCK_ lcb_RESPUNLOCK;
1288
1289LIBCOUCHBASE_API lcb_STATUS lcb_respunlock_status(const lcb_RESPUNLOCK *resp);
1290LIBCOUCHBASE_API lcb_STATUS lcb_respunlock_error_context(const lcb_RESPUNLOCK *resp,
1291 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
1292LIBCOUCHBASE_API lcb_STATUS lcb_respunlock_cookie(const lcb_RESPUNLOCK *resp, void **cookie);
1293LIBCOUCHBASE_API lcb_STATUS lcb_respunlock_cas(const lcb_RESPUNLOCK *resp, uint64_t *cas);
1294LIBCOUCHBASE_API lcb_STATUS lcb_respunlock_key(const lcb_RESPUNLOCK *resp, const char **key, size_t *key_len);
1295
1296typedef struct lcb_CMDUNLOCK_ lcb_CMDUNLOCK;
1297
1298LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_create(lcb_CMDUNLOCK **cmd);
1299LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_destroy(lcb_CMDUNLOCK *cmd);
1300LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_parent_span(lcb_CMDUNLOCK *cmd, lcbtrace_SPAN *span);
1301LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_collection(lcb_CMDUNLOCK *cmd, const char *scope, size_t scope_len,
1302 const char *collection, size_t collection_len);
1303LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_key(lcb_CMDUNLOCK *cmd, const char *key, size_t key_len);
1304LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_cas(lcb_CMDUNLOCK *cmd, uint64_t cas);
1305LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_timeout(lcb_CMDUNLOCK *cmd, uint32_t timeout);
1309LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of(lcb_CMDUNLOCK *cmd, const char *data, size_t data_len);
1313LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of_extra_privilege(lcb_CMDUNLOCK *cmd, const char *privilege,
1314 size_t privilege_len);
1315LIBCOUCHBASE_API lcb_STATUS lcb_unlock(lcb_INSTANCE *instance, void *cookie, const lcb_CMDUNLOCK *cmd);
1316
1319/* @ingroup lcb-kv-api
1320 * @defgroup lcb-touch Touch/Expiry
1321 * @brief Modify or clear a document's expiration time
1322 * @details Couchbase allows documents to contain expiration times
1323 * (see lcb_CMDBASE::exptime). Most operations allow the expiry time to be
1324 * updated, however lcb_touch3() allows the exclusive update of the expiration
1325 * time without additional network overhead.
1326 *
1327 * @addtogroup lcb-touch
1328 * @{
1329 */
1330
1361typedef struct lcb_RESPTOUCH_ lcb_RESPTOUCH;
1362
1363LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_status(const lcb_RESPTOUCH *resp);
1364LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_error_context(const lcb_RESPTOUCH *resp,
1365 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
1366LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_cookie(const lcb_RESPTOUCH *resp, void **cookie);
1367LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_cas(const lcb_RESPTOUCH *resp, uint64_t *cas);
1368LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_key(const lcb_RESPTOUCH *resp, const char **key, size_t *key_len);
1369LIBCOUCHBASE_API lcb_STATUS lcb_resptouch_mutation_token(const lcb_RESPTOUCH *resp, lcb_MUTATION_TOKEN *token);
1370
1371typedef struct lcb_CMDTOUCH_ lcb_CMDTOUCH;
1372
1373LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_create(lcb_CMDTOUCH **cmd);
1374LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_destroy(lcb_CMDTOUCH *cmd);
1375LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_parent_span(lcb_CMDTOUCH *cmd, lcbtrace_SPAN *span);
1376LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_collection(lcb_CMDTOUCH *cmd, const char *scope, size_t scope_len,
1377 const char *collection, size_t collection_len);
1378LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_key(lcb_CMDTOUCH *cmd, const char *key, size_t key_len);
1379LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_expiry(lcb_CMDTOUCH *cmd, uint32_t expiration);
1380LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_durability(lcb_CMDTOUCH *cmd, lcb_DURABILITY_LEVEL level);
1381LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_timeout(lcb_CMDTOUCH *cmd, uint32_t timeout);
1385LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of(lcb_CMDTOUCH *cmd, const char *data, size_t data_len);
1389LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of_extra_privilege(lcb_CMDTOUCH *cmd, const char *privilege,
1390 size_t privilege_len);
1391LIBCOUCHBASE_API lcb_STATUS lcb_touch(lcb_INSTANCE *instance, void *cookie, const lcb_CMDTOUCH *cmd);
1392
1410typedef enum {
1411 LCB_PING_STATUS_OK = 0,
1412 LCB_PING_STATUS_TIMEOUT,
1413 LCB_PING_STATUS_ERROR,
1414 LCB_PING_STATUS_INVALID, /* bad index or argument */
1415 LCB_PING_STATUS__MAX
1416} lcb_PING_STATUS;
1417
1423typedef enum {
1424 LCB_PING_SERVICE_KV = 0,
1425 LCB_PING_SERVICE_VIEWS,
1426 LCB_PING_SERVICE_QUERY,
1427 LCB_PING_SERVICE_SEARCH,
1428 LCB_PING_SERVICE_ANALYTICS,
1429 LCB_PING_SERVICE__MAX
1430} lcb_PING_SERVICE;
1431
1432typedef struct lcb_RESPPING_ lcb_RESPPING;
1433
1434LIBCOUCHBASE_API lcb_STATUS lcb_respping_status(const lcb_RESPPING *resp);
1435LIBCOUCHBASE_API lcb_STATUS lcb_respping_cookie(const lcb_RESPPING *resp, void **cookie);
1436LIBCOUCHBASE_API lcb_STATUS lcb_respping_value(const lcb_RESPPING *resp, const char **json, size_t *json_len);
1437LIBCOUCHBASE_API lcb_STATUS lcb_respping_report_id(const lcb_RESPPING *resp, const char **report_id,
1438 size_t *report_id_len);
1439LIBCOUCHBASE_API size_t lcb_respping_result_size(const lcb_RESPPING *resp);
1440LIBCOUCHBASE_API lcb_PING_STATUS lcb_respping_result_status(const lcb_RESPPING *resp, size_t index);
1441LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_id(const lcb_RESPPING *resp, size_t index, const char **endpoint_id,
1442 size_t *endpoint_id_len);
1443LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_service(const lcb_RESPPING *resp, size_t index, lcb_PING_SERVICE *type);
1444LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_remote(const lcb_RESPPING *resp, size_t index, const char **address,
1445 size_t *address_len);
1446LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_local(const lcb_RESPPING *resp, size_t index, const char **address,
1447 size_t *address_len);
1448LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_latency(const lcb_RESPPING *resp, size_t index, uint64_t *latency);
1449
1450LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_namespace(const lcb_RESPPING *resp, size_t index, const char **name,
1451 size_t *name_len);
1452
1453LCB_DEPRECATED2(LIBCOUCHBASE_API lcb_STATUS lcb_respping_result_scope(const lcb_RESPPING *resp, size_t index,
1454 const char **name, size_t *name_len),
1455 "Use lcb_respping_result_namespace");
1456
1457typedef struct lcb_CMDPING_ lcb_CMDPING;
1458
1459LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_create(lcb_CMDPING **cmd);
1460LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_destroy(lcb_CMDPING *cmd);
1461LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_parent_span(lcb_CMDPING *cmd, lcbtrace_SPAN *span);
1462LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_report_id(lcb_CMDPING *cmd, const char *report_id, size_t report_id_len);
1463LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_all(lcb_CMDPING *cmd);
1464LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_kv(lcb_CMDPING *cmd, int enable);
1465LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_query(lcb_CMDPING *cmd, int enable);
1466LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_views(lcb_CMDPING *cmd, int enable);
1467LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_search(lcb_CMDPING *cmd, int enable);
1468LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_analytics(lcb_CMDPING *cmd, int enable);
1469LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_no_metrics(lcb_CMDPING *cmd, int enable);
1470LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_encode_json(lcb_CMDPING *cmd, int enable, int pretty, int with_details);
1471LIBCOUCHBASE_API lcb_STATUS lcb_cmdping_timeout(lcb_CMDPING *cmd, uint32_t timeout);
1472LIBCOUCHBASE_API lcb_STATUS lcb_ping(lcb_INSTANCE *instance, void *cookie, const lcb_CMDPING *cmd);
1473
1474typedef struct lcb_RESPDIAG_ lcb_RESPDIAG;
1475
1476LIBCOUCHBASE_API lcb_STATUS lcb_respdiag_status(const lcb_RESPDIAG *resp);
1477LIBCOUCHBASE_API lcb_STATUS lcb_respdiag_cookie(const lcb_RESPDIAG *resp, void **cookie);
1478LIBCOUCHBASE_API lcb_STATUS lcb_respdiag_value(const lcb_RESPDIAG *resp, const char **json, size_t *json_len);
1479
1480typedef struct lcb_CMDDIAG_ lcb_CMDDIAG;
1481
1482LIBCOUCHBASE_API lcb_STATUS lcb_cmddiag_create(lcb_CMDDIAG **cmd);
1483LIBCOUCHBASE_API lcb_STATUS lcb_cmddiag_destroy(lcb_CMDDIAG *cmd);
1484LIBCOUCHBASE_API lcb_STATUS lcb_cmddiag_report_id(lcb_CMDDIAG *cmd, const char *report_id, size_t report_id_len);
1485LIBCOUCHBASE_API lcb_STATUS lcb_cmddiag_prettify(lcb_CMDDIAG *cmd, int enable);
1523LIBCOUCHBASE_API lcb_STATUS lcb_diag(lcb_INSTANCE *instance, void *cookie, const lcb_CMDDIAG *cmd);
1524
1527/* @ingroup lcb-public-api
1528 * @defgroup lcb-http HTTP Client
1529 * @brief Access Couchbase HTTP APIs
1530 * @details The low-level HTTP client may be used to access various HTTP-based
1531 * Couchbase APIs.
1532 *
1533 * Note that existing higher level APIs can be used for N1QL queries (see
1534 * @ref lcb-n1ql-api) and MapReduce view queries (see @ref lcb-view-api)
1535 *
1536 * @addtogroup lcb-http
1537 * @{
1538 */
1539
1543typedef enum {
1548 LCB_HTTP_TYPE_VIEW = 0,
1549
1556 LCB_HTTP_TYPE_MANAGEMENT = 1,
1557
1561 LCB_HTTP_TYPE_RAW = 2,
1562
1564 LCB_HTTP_TYPE_QUERY = 3,
1565
1567 LCB_HTTP_TYPE_SEARCH = 4,
1568
1570 LCB_HTTP_TYPE_ANALYTICS = 5,
1571
1577 LCB_HTTP_TYPE_PING = 6,
1578
1579 LCB_HTTP_TYPE_EVENTING = 7,
1580
1581 LCB_HTTP_TYPE_MAX
1582} lcb_HTTP_TYPE;
1583
1590typedef enum {
1591 LCB_HTTP_METHOD_GET = 0,
1592 LCB_HTTP_METHOD_POST = 1,
1593 LCB_HTTP_METHOD_PUT = 2,
1594 LCB_HTTP_METHOD_DELETE = 3,
1595 LCB_HTTP_METHOD_MAX = 4
1596} lcb_HTTP_METHOD;
1597
1667typedef struct lcb_RESPHTTP_ lcb_RESPHTTP;
1668
1669LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_status(const lcb_RESPHTTP *resp);
1670LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_cookie(const lcb_RESPHTTP *resp, void **cookie);
1671LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_http_status(const lcb_RESPHTTP *resp, uint16_t *status);
1672LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_path(const lcb_RESPHTTP *resp, const char **path, size_t *path_len);
1673LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_body(const lcb_RESPHTTP *resp, const char **body, size_t *body_len);
1674LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_handle(const lcb_RESPHTTP *resp, lcb_HTTP_HANDLE **handle);
1675LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_error_context(const lcb_RESPHTTP *resp, const lcb_HTTP_ERROR_CONTEXT **ctx);
1676
1677LIBCOUCHBASE_API int lcb_resphttp_is_final(const lcb_RESPHTTP *resp);
1682LIBCOUCHBASE_API lcb_STATUS lcb_resphttp_headers(const lcb_RESPHTTP *resp, const char *const **headers);
1683
1684typedef struct lcb_CMDHTTP_ lcb_CMDHTTP;
1685
1686LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_create(lcb_CMDHTTP **cmd, lcb_HTTP_TYPE type);
1687LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_destroy(lcb_CMDHTTP *cmd);
1688LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_parent_span(lcb_CMDHTTP *cmd, lcbtrace_SPAN *span);
1689LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_method(lcb_CMDHTTP *cmd, lcb_HTTP_METHOD method);
1690LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_path(lcb_CMDHTTP *cmd, const char *path, size_t path_len);
1691LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_content_type(lcb_CMDHTTP *cmd, const char *content_type,
1692 size_t content_type_len);
1693LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_body(lcb_CMDHTTP *cmd, const char *body, size_t body_len);
1694LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_handle(lcb_CMDHTTP *cmd, lcb_HTTP_HANDLE **handle);
1695LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_username(lcb_CMDHTTP *cmd, const char *username, size_t username_len);
1696LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_password(lcb_CMDHTTP *cmd, const char *password, size_t password_len);
1697LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_host(lcb_CMDHTTP *cmd, const char *host, size_t host_len);
1698LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_streaming(lcb_CMDHTTP *cmd, int streaming);
1699LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_skip_auth_header(lcb_CMDHTTP *cmd, int skip_auth);
1700LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_timeout(lcb_CMDHTTP *cmd, uint32_t timeout);
1701LIBCOUCHBASE_API lcb_STATUS lcb_http(lcb_INSTANCE *instance, void *cookie, const lcb_CMDHTTP *cmd);
1702
1728LIBCOUCHBASE_API lcb_STATUS lcb_http_cancel(lcb_INSTANCE *instance, lcb_HTTP_HANDLE *handle);
1729
1795LIBCOUCHBASE_API
1796void lcb_set_cookie(lcb_INSTANCE *instance, const void *cookie);
1797
1805LIBCOUCHBASE_API
1806const void *lcb_get_cookie(lcb_INSTANCE *instance);
1848LIBCOUCHBASE_API
1849lcb_STATUS lcb_tick_nowait(lcb_INSTANCE *instance);
1850
1852typedef enum {
1854 LCB_WAIT_DEFAULT = 0x00,
1855
1863 LCB_WAIT_NOCHECK = 0x01
1864} lcb_WAITFLAGS;
1865
1873LIBCOUCHBASE_API
1874lcb_STATUS lcb_wait(lcb_INSTANCE *instance, lcb_WAITFLAGS flags);
1875
1887LIBCOUCHBASE_API
1888void lcb_breakout(lcb_INSTANCE *instance);
1889
1896LIBCOUCHBASE_API
1897int lcb_is_waiting(lcb_INSTANCE *instance);
1974LIBCOUCHBASE_API
1975void lcb_sched_enter(lcb_INSTANCE *instance);
1976
1995LIBCOUCHBASE_API
1996void lcb_sched_leave(lcb_INSTANCE *instance);
1997
2021LIBCOUCHBASE_API
2022void lcb_sched_fail(lcb_INSTANCE *instance);
2023
2041LIBCOUCHBASE_API
2042void lcb_sched_flush(lcb_INSTANCE *instance);
2043
2046/* @ingroup lcb-public-api
2047 * @defgroup lcb-destroy Destroying
2048 * @brief Library destruction routines
2049 * @addtogroup lcb-destroy
2050 * @{
2051 */
2062LIBCOUCHBASE_API
2063void lcb_destroy(lcb_INSTANCE *instance);
2064
2069typedef void (*lcb_destroy_callback)(const void *cookie);
2070
2076LIBCOUCHBASE_API
2077lcb_destroy_callback lcb_set_destroy_callback(lcb_INSTANCE *instance, lcb_destroy_callback);
2104LIBCOUCHBASE_API
2105void lcb_destroy_async(lcb_INSTANCE *instance, const void *arg);
2109#define LCB_DATATYPE_JSON 0x01
2110
2112typedef enum { LCB_VALUE_RAW = 0x00, LCB_VALUE_F_JSON = 0x01, LCB_VALUE_F_SNAPPYCOMP = 0x02 } lcb_VALUEFLAGS;
2113
2173LIBCOUCHBASE_API
2174lcb_STATUS lcb_cntl(lcb_INSTANCE *instance, int mode, int cmd, void *arg);
2175
2239LIBCOUCHBASE_API
2240lcb_STATUS lcb_cntl_string(lcb_INSTANCE *instance, const char *key, const char *value);
2241
2250LIBCOUCHBASE_API
2251lcb_STATUS lcb_cntl_setu32(lcb_INSTANCE *instance, int cmd, lcb_U32 arg);
2252
2262LIBCOUCHBASE_API
2263lcb_U32 lcb_cntl_getu32(lcb_INSTANCE *instance, int cmd);
2264
2270LIBCOUCHBASE_API
2271int lcb_cntl_exists(int ctl);
2272
2330LIBCOUCHBASE_API
2331void lcb_refresh_config(lcb_INSTANCE *instance);
2332
2348#if !defined(LCB_VERSION_STRING) || defined(__LCB_DOXYGEN__)
2350#define LCB_VERSION_STRING "unknown"
2351#endif
2352
2353#if !defined(LCB_VERSION) || defined(__LCB_DOXYGEN__)
2369#define LCB_VERSION 0x000000
2370#endif
2371
2372#if !defined(LCB_VERSION_CHANGESET) || defined(__LCB_DOXYGEN__)
2374#define LCB_VERSION_CHANGESET "0xdeadbeef"
2375#endif
2376
2387LIBCOUCHBASE_API
2388const char *lcb_get_version(lcb_U32 *version);
2389
2391LIBCOUCHBASE_API LCB_EXTERN_VAR const lcb_U32 lcb_version_g;
2392
2394#define LCB_SUPPORTS_SSL 1
2396#define LCB_SUPPORTS_SNAPPY 2
2398#define LCB_SUPPORTS_TRACING 3
2399
2406LIBCOUCHBASE_API
2407int lcb_supports_feature(int n);
2408
2423LIBCOUCHBASE_API
2424int lcb_is_redacting_logs(lcb_INSTANCE *instance);
2425
2436typedef struct lcb_ANALYTICS_HANDLE_ lcb_ANALYTICS_HANDLE;
2437typedef struct lcb_DEFERRED_HANDLE_ lcb_DEFERRED_HANDLE;
2438
2444typedef struct lcb_RESPANALYTICS_ lcb_RESPANALYTICS;
2445
2452typedef void (*lcb_ANALYTICS_CALLBACK)(lcb_INSTANCE *, int, const lcb_RESPANALYTICS *);
2453
2454LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_status(const lcb_RESPANALYTICS *resp);
2455LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_cookie(const lcb_RESPANALYTICS *resp, void **cookie);
2456LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_row(const lcb_RESPANALYTICS *resp, const char **row, size_t *row_len);
2457LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_http_response(const lcb_RESPANALYTICS *resp, const lcb_RESPHTTP **http);
2465LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_handle(const lcb_RESPANALYTICS *resp, lcb_ANALYTICS_HANDLE **handle);
2466LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_error_context(const lcb_RESPANALYTICS *resp,
2467 const lcb_ANALYTICS_ERROR_CONTEXT **ctx);
2468LIBCOUCHBASE_API int lcb_respanalytics_is_final(const lcb_RESPANALYTICS *resp);
2469LIBCOUCHBASE_API lcb_STATUS lcb_respanalytics_deferred_handle_extract(const lcb_RESPANALYTICS *resp,
2470 lcb_DEFERRED_HANDLE **handle);
2471LIBCOUCHBASE_API lcb_STATUS lcb_deferred_handle_destroy(lcb_DEFERRED_HANDLE *handle);
2472LIBCOUCHBASE_API lcb_STATUS lcb_deferred_handle_status(lcb_DEFERRED_HANDLE *handle, const char **status,
2473 size_t *status_len);
2474LIBCOUCHBASE_API lcb_STATUS lcb_deferred_handle_callback(lcb_DEFERRED_HANDLE *handle, lcb_ANALYTICS_CALLBACK callback);
2475LIBCOUCHBASE_API lcb_STATUS lcb_deferred_handle_poll(lcb_INSTANCE *instance, void *cookie, lcb_DEFERRED_HANDLE *handle);
2476
2477typedef struct lcb_CMDANALYTICS_ lcb_CMDANALYTICS;
2478
2479typedef struct lcb_INGEST_OPTIONS_ lcb_INGEST_OPTIONS;
2480typedef enum {
2481 LCB_INGEST_METHOD_NONE = 0,
2482 LCB_INGEST_METHOD_UPSERT,
2483 LCB_INGEST_METHOD_INSERT,
2484 LCB_INGEST_METHOD_REPLACE,
2485 LCB_INGEST_METHOD__MAX
2486} lcb_INGEST_METHOD;
2487
2488typedef enum {
2489
2494 LCB_ANALYTICS_CONSISTENCY_NOT_BOUNDED = 0,
2499 LCB_ANALYTICS_CONSISTENCY_REQUEST_PLUS = 1
2500} lcb_ANALYTICS_CONSISTENCY;
2501
2502typedef enum { LCB_INGEST_STATUS_OK = 0, LCB_INGEST_STATUS_IGNORE, LCB_INGEST_STATUS__MAX } lcb_INGEST_STATUS;
2503
2504typedef struct lcb_INGEST_PARAM_ lcb_INGEST_PARAM;
2505
2506typedef lcb_INGEST_STATUS (*lcb_INGEST_DATACONVERTER_CALLBACK)(lcb_INSTANCE *instance, lcb_INGEST_PARAM *param);
2507
2508LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_create(lcb_INGEST_OPTIONS **options);
2509LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_destroy(lcb_INGEST_OPTIONS *options);
2510LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_method(lcb_INGEST_OPTIONS *options, lcb_INGEST_METHOD method);
2511LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_expiry(lcb_INGEST_OPTIONS *options, uint32_t expiration);
2512LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_ignore_error(lcb_INGEST_OPTIONS *options, int flag);
2513LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_data_converter(lcb_INGEST_OPTIONS *options,
2514 lcb_INGEST_DATACONVERTER_CALLBACK callback);
2515
2516LIBCOUCHBASE_API lcb_STATUS lcb_ingest_dataconverter_param_cookie(lcb_INGEST_PARAM *param, void **cookie);
2517LIBCOUCHBASE_API lcb_STATUS lcb_ingest_dataconverter_param_row(lcb_INGEST_PARAM *param, const char **row,
2518 size_t *row_len);
2519LIBCOUCHBASE_API lcb_STATUS lcb_ingest_dataconverter_param_method(lcb_INGEST_PARAM *param, lcb_INGEST_METHOD *method);
2520LIBCOUCHBASE_API lcb_STATUS lcb_ingest_dataconverter_param_set_id(lcb_INGEST_PARAM *param, const char *id,
2521 size_t id_len, void (*id_dtor)(const char *));
2522LIBCOUCHBASE_API lcb_STATUS lcb_ingest_dataconverter_param_set_out(lcb_INGEST_PARAM *param, const char *out,
2523 size_t out_len, void (*out_dtor)(const char *));
2524
2525LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_create(lcb_CMDANALYTICS **cmd);
2526LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_destroy(lcb_CMDANALYTICS *cmd);
2527LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_reset(lcb_CMDANALYTICS *cmd);
2551LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_parent_span(lcb_CMDANALYTICS *cmd, lcbtrace_SPAN *span);
2558LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_callback(lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_CALLBACK callback);
2559LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_encoded_payload(lcb_CMDANALYTICS *cmd, const char **query,
2560 size_t *query_len);
2561LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_payload(lcb_CMDANALYTICS *cmd, const char *query, size_t query_len);
2562LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_statement(lcb_CMDANALYTICS *cmd, const char *statement,
2563 size_t statement_len);
2564LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_named_param(lcb_CMDANALYTICS *cmd, const char *name, size_t name_len,
2565 const char *value, size_t value_len);
2573LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_positional_params(lcb_CMDANALYTICS *cmd, const char *value,
2574 size_t value_len);
2582LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_positional_param(lcb_CMDANALYTICS *cmd, const char *value,
2583 size_t value_len);
2584LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_ingest_options(lcb_CMDANALYTICS *cmd, lcb_INGEST_OPTIONS *options);
2585LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_deferred(lcb_CMDANALYTICS *cmd, int deferred);
2586LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_client_context_id(lcb_CMDANALYTICS *cmd, const char *value,
2587 size_t value_len);
2588LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_readonly(lcb_CMDANALYTICS *cmd, int readonly);
2589LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_priority(lcb_CMDANALYTICS *cmd, int priority);
2590LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_consistency(lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_CONSISTENCY level);
2591LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_option(lcb_CMDANALYTICS *cmd, const char *name, size_t name_len,
2592 const char *value, size_t value_len);
2599LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_scope_name(lcb_CMDANALYTICS *cmd, const char *scope, size_t scope_len);
2613LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_scope_qualifier(lcb_CMDANALYTICS *cmd, const char *qualifier,
2614 size_t qualifier_len);
2622LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_handle(lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_HANDLE **handle);
2623LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_timeout(lcb_CMDANALYTICS *cmd, uint32_t timeout);
2627LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_on_behalf_of(lcb_CMDANALYTICS *cmd, const char *data, size_t data_len);
2640LIBCOUCHBASE_API lcb_STATUS lcb_analytics(lcb_INSTANCE *instance, void *cookie, const lcb_CMDANALYTICS *cmd);
2674LIBCOUCHBASE_API lcb_STATUS lcb_analytics_cancel(lcb_INSTANCE *instance, lcb_ANALYTICS_HANDLE *handle);
2675
2688typedef struct lcb_SEARCH_HANDLE_ lcb_SEARCH_HANDLE;
2689typedef struct lcb_RESPSEARCH_ lcb_RESPSEARCH;
2690
2691LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_status(const lcb_RESPSEARCH *resp);
2692LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_cookie(const lcb_RESPSEARCH *resp, void **cookie);
2693LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_row(const lcb_RESPSEARCH *resp, const char **row, size_t *row_len);
2694LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_http_response(const lcb_RESPSEARCH *resp, const lcb_RESPHTTP **http);
2702LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_handle(const lcb_RESPSEARCH *resp, lcb_SEARCH_HANDLE **handle);
2703LIBCOUCHBASE_API lcb_STATUS lcb_respsearch_error_context(const lcb_RESPSEARCH *resp,
2704 const lcb_SEARCH_ERROR_CONTEXT **ctx);
2705LIBCOUCHBASE_API int lcb_respsearch_is_final(const lcb_RESPSEARCH *resp);
2706
2707typedef struct lcb_CMDSEARCH_ lcb_CMDSEARCH;
2708typedef void (*lcb_SEARCH_CALLBACK)(lcb_INSTANCE *, int, const lcb_RESPSEARCH *);
2709
2710LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_create(lcb_CMDSEARCH **cmd);
2711LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_destroy(lcb_CMDSEARCH *cmd);
2738LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_parent_span(lcb_CMDSEARCH *cmd, lcbtrace_SPAN *span);
2745LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_callback(lcb_CMDSEARCH *cmd, lcb_SEARCH_CALLBACK callback);
2746LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_payload(lcb_CMDSEARCH *cmd, const char *payload, size_t payload_len);
2753LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_handle(lcb_CMDSEARCH *cmd, lcb_SEARCH_HANDLE **handle);
2754LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_timeout(lcb_CMDSEARCH *cmd, uint32_t timeout);
2758LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_on_behalf_of(lcb_CMDSEARCH *cmd, const char *data, size_t data_len);
2759
2771LIBCOUCHBASE_API lcb_STATUS lcb_search(lcb_INSTANCE *instance, void *cookie, const lcb_CMDSEARCH *cmd);
2779LIBCOUCHBASE_API lcb_STATUS lcb_search_cancel(lcb_INSTANCE *instance, lcb_SEARCH_HANDLE *handle);
2838typedef struct lcb_RESPQUERY_ lcb_RESPQUERY;
2839
2843typedef struct lcb_CMDQUERY_ lcb_CMDQUERY;
2847typedef struct lcb_QUERY_HANDLE_ lcb_QUERY_HANDLE;
2848
2855typedef void (*lcb_QUERY_CALLBACK)(lcb_INSTANCE *, int, const lcb_RESPQUERY *);
2856
2857typedef enum {
2859 LCB_QUERY_CONSISTENCY_NONE = 0,
2860
2866 LCB_QUERY_CONSISTENCY_RYOW = 1,
2867
2869 LCB_QUERY_CONSISTENCY_REQUEST = 2,
2870
2872 LCB_QUERY_CONSISTENCY_STATEMENT = 3
2873} lcb_QUERY_CONSISTENCY;
2874
2875typedef enum {
2876 LCB_QUERY_PROFILE_OFF = 0,
2877 LCB_QUERY_PROFILE_PHASES = 1,
2878 LCB_QUERY_PROFILE_TIMINGS = 2
2879} lcb_QUERY_PROFILE;
2880
2881LIBCOUCHBASE_API lcb_STATUS lcb_respquery_status(const lcb_RESPQUERY *resp);
2882LIBCOUCHBASE_API lcb_STATUS lcb_respquery_cookie(const lcb_RESPQUERY *resp, void **cookie);
2883LIBCOUCHBASE_API lcb_STATUS lcb_respquery_row(const lcb_RESPQUERY *resp, const char **row, size_t *row_len);
2884LIBCOUCHBASE_API lcb_STATUS lcb_respquery_http_response(const lcb_RESPQUERY *resp, const lcb_RESPHTTP **http);
2885LIBCOUCHBASE_API lcb_STATUS lcb_respquery_handle(const lcb_RESPQUERY *resp, lcb_QUERY_HANDLE **handle);
2886LIBCOUCHBASE_API lcb_STATUS lcb_respquery_error_context(const lcb_RESPQUERY *resp, const lcb_QUERY_ERROR_CONTEXT **ctx);
2887LIBCOUCHBASE_API int lcb_respquery_is_final(const lcb_RESPQUERY *resp);
2896LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_create(lcb_CMDQUERY **cmd);
2902LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_destroy(lcb_CMDQUERY *cmd);
2911LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_reset(lcb_CMDQUERY *cmd);
2920LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_encoded_payload(lcb_CMDQUERY *cmd, const char **payload, size_t *payload_len);
2947LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_parent_span(lcb_CMDQUERY *cmd, lcbtrace_SPAN *span);
2955LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_callback(lcb_CMDQUERY *cmd, lcb_QUERY_CALLBACK callback);
2962LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_payload(lcb_CMDQUERY *cmd, const char *query, size_t query_len);
2969LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_statement(lcb_CMDQUERY *cmd, const char *statement, size_t statement_len);
2976LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_scope_name(lcb_CMDQUERY *cmd, const char *scope, size_t scope_len);
2988LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_scope_qualifier(lcb_CMDQUERY *cmd, const char *qualifier,
2989 size_t qualifier_len);
2998LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_named_param(lcb_CMDQUERY *cmd, const char *name, size_t name_len,
2999 const char *value, size_t value_len);
3007LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_positional_params(lcb_CMDQUERY *cmd, const char *value, size_t value_len);
3015LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_positional_param(lcb_CMDQUERY *cmd, const char *value, size_t value_len);
3016LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_adhoc(lcb_CMDQUERY *cmd, int adhoc);
3017LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_client_context_id(lcb_CMDQUERY *cmd, const char *value, size_t value_len);
3018LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_pretty(lcb_CMDQUERY *cmd, int pretty);
3038LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_readonly(lcb_CMDQUERY *cmd, int readonly);
3039LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_metrics(lcb_CMDQUERY *cmd, int metrics);
3050LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_scan_cap(lcb_CMDQUERY *cmd, int value);
3051LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_scan_wait(lcb_CMDQUERY *cmd, uint32_t us);
3060LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_flex_index(lcb_CMDQUERY *cmd, int value);
3061LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_profile(lcb_CMDQUERY *cmd, lcb_QUERY_PROFILE mode);
3069LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_pipeline_cap(lcb_CMDQUERY *cmd, int value);
3077LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_pipeline_batch(lcb_CMDQUERY *cmd, int value);
3078LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_max_parallelism(lcb_CMDQUERY *cmd, int value);
3087LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_consistency(lcb_CMDQUERY *cmd, lcb_QUERY_CONSISTENCY mode);
3097LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_consistency_token_for_keyspace(lcb_CMDQUERY *cmd, const char *keyspace,
3098 size_t keyspace_len,
3099 const lcb_MUTATION_TOKEN *token);
3100LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_consistency_tokens(lcb_CMDQUERY *cmd, lcb_INSTANCE *instance);
3109LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_option(lcb_CMDQUERY *cmd, const char *name, size_t name_len, const char *value,
3110 size_t value_len);
3111LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_handle(lcb_CMDQUERY *cmd, lcb_QUERY_HANDLE **handle);
3112LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_timeout(lcb_CMDQUERY *cmd, uint32_t timeout);
3122LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_preserve_expiry(lcb_CMDQUERY *cmd, int preserve_expiry);
3123
3127LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_on_behalf_of(lcb_CMDQUERY *cmd, const char *data, size_t data_len);
3128
3140LIBCOUCHBASE_API lcb_STATUS lcb_query(lcb_INSTANCE *instance, void *cookie, const lcb_CMDQUERY *cmd);
3169LIBCOUCHBASE_API lcb_STATUS lcb_query_cancel(lcb_INSTANCE *instance, lcb_QUERY_HANDLE *handle);
3183typedef struct lcb_RESPVIEW_ lcb_RESPVIEW;
3184typedef struct lcb_CMDVIEW_ lcb_CMDVIEW;
3185
3189typedef struct lcb_VIEW_HANDLE_ lcb_VIEW_HANDLE;
3190
3202typedef void (*lcb_VIEW_CALLBACK)(lcb_INSTANCE *instance, int cbtype, const lcb_RESPVIEW *row);
3203
3204LIBCOUCHBASE_API lcb_STATUS lcb_respview_status(const lcb_RESPVIEW *resp);
3205LIBCOUCHBASE_API lcb_STATUS lcb_respview_cookie(const lcb_RESPVIEW *resp, void **cookie);
3206LIBCOUCHBASE_API lcb_STATUS lcb_respview_key(const lcb_RESPVIEW *resp, const char **key, size_t *key_len);
3207LIBCOUCHBASE_API lcb_STATUS lcb_respview_doc_id(const lcb_RESPVIEW *resp, const char **doc_id, size_t *doc_id_len);
3208LIBCOUCHBASE_API lcb_STATUS lcb_respview_row(const lcb_RESPVIEW *resp, const char **row, size_t *row_len);
3209LIBCOUCHBASE_API lcb_STATUS lcb_respview_document(const lcb_RESPVIEW *resp, const lcb_RESPGET **doc);
3210LIBCOUCHBASE_API lcb_STATUS lcb_respview_http_response(const lcb_RESPVIEW *resp, const lcb_RESPHTTP **http);
3211LIBCOUCHBASE_API lcb_STATUS lcb_respview_handle(const lcb_RESPVIEW *resp, lcb_VIEW_HANDLE **handle);
3212LIBCOUCHBASE_API lcb_STATUS lcb_respview_error_context(const lcb_RESPVIEW *resp, const lcb_VIEW_ERROR_CONTEXT **ctx);
3213LIBCOUCHBASE_API int lcb_respview_is_final(const lcb_RESPVIEW *resp);
3214
3215LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_create(lcb_CMDVIEW **cmd);
3216LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_destroy(lcb_CMDVIEW *cmd);
3217LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_parent_span(lcb_CMDVIEW *cmd, lcbtrace_SPAN *span);
3218LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_callback(lcb_CMDVIEW *cmd, lcb_VIEW_CALLBACK callback);
3219LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_design_document(lcb_CMDVIEW *cmd, const char *ddoc, size_t ddoc_len);
3220LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_view_name(lcb_CMDVIEW *cmd, const char *view, size_t view_len);
3221LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_option_string(lcb_CMDVIEW *cmd, const char *optstr, size_t optstr_len);
3222LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_post_data(lcb_CMDVIEW *cmd, const char *data, size_t data_len);
3223LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_include_docs(lcb_CMDVIEW *cmd, int include_docs);
3224LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_max_concurrent_docs(lcb_CMDVIEW *cmd, uint32_t num);
3225LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_no_row_parse(lcb_CMDVIEW *cmd, int flag);
3226LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_handle(lcb_CMDVIEW *cmd, lcb_VIEW_HANDLE **handle);
3227LIBCOUCHBASE_API lcb_STATUS lcb_cmdview_timeout(lcb_CMDVIEW *cmd, uint32_t timeout);
3228LIBCOUCHBASE_API lcb_STATUS lcb_view(lcb_INSTANCE *instance, void *cookie, const lcb_CMDVIEW *cmd);
3229LIBCOUCHBASE_API lcb_STATUS lcb_view_cancel(lcb_INSTANCE *instance, lcb_VIEW_HANDLE *handle);
3232/* @ingroup lcb-public-api
3233 * @defgroup lcb-subdoc Sub-Document API
3234 * @brief Experimental in-document API access
3235 * @details The sub-document API uses features from the upcoming Couchbase
3236 * 4.5 release which allows access to parts of the document. These parts are
3237 * called _sub-documents_ and can be accessed using the sub-document API
3238 *
3239 * @addtogroup lcb-subdoc
3240 * @{
3241 */
3242
3243typedef struct lcb_RESPSUBDOC_ lcb_RESPSUBDOC;
3244
3245LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_status(const lcb_RESPSUBDOC *resp);
3246LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_error_context(const lcb_RESPSUBDOC *resp,
3247 const lcb_KEY_VALUE_ERROR_CONTEXT **ctx);
3248LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_cookie(const lcb_RESPSUBDOC *resp, void **cookie);
3249LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_cas(const lcb_RESPSUBDOC *resp, uint64_t *cas);
3250LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_key(const lcb_RESPSUBDOC *resp, const char **key, size_t *key_len);
3251LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_mutation_token(const lcb_RESPSUBDOC *resp, lcb_MUTATION_TOKEN *token);
3252
3253LIBCOUCHBASE_API size_t lcb_respsubdoc_result_size(const lcb_RESPSUBDOC *resp);
3254LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_result_status(const lcb_RESPSUBDOC *resp, size_t index);
3255LIBCOUCHBASE_API lcb_STATUS lcb_respsubdoc_result_value(const lcb_RESPSUBDOC *resp, size_t index, const char **value,
3256 size_t *value_len);
3257
3262LIBCOUCHBASE_API int lcb_respsubdoc_is_deleted(const lcb_RESPSUBDOC *resp);
3263
3264typedef struct lcb_SUBDOCSPECS_ lcb_SUBDOCSPECS;
3265
3267#define LCB_SUBDOCSPECS_F_MKINTERMEDIATES (1u << 16u)
3268
3270#define LCB_SUBDOCSPECS_F_XATTRPATH (1u << 18u)
3271
3273#define LCB_SUBDOCSPECS_F_XATTR_MACROVALUES (1u << 19u)
3274
3276#define LCB_SUBDOCSPECS_F_XATTR_DELETED_OK (1u << 20u)
3277
3278LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_create(lcb_SUBDOCSPECS **operations, size_t capacity);
3279LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_destroy(lcb_SUBDOCSPECS *operations);
3280LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_get(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3281 const char *path, size_t path_len);
3282LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_exists(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3283 const char *path, size_t path_len);
3284LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_replace(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3285 const char *path, size_t path_len, const char *value,
3286 size_t value_len);
3287LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_dict_add(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3288 const char *path, size_t path_len, const char *value,
3289 size_t value_len);
3290LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_dict_upsert(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3291 const char *path, size_t path_len, const char *value,
3292 size_t value_len);
3293LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_array_add_first(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3294 const char *path, size_t path_len, const char *value,
3295 size_t value_len);
3296LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_array_add_last(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3297 const char *path, size_t path_len, const char *value,
3298 size_t value_len);
3299LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_array_add_unique(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3300 const char *path, size_t path_len, const char *value,
3301 size_t value_len);
3302LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_array_insert(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3303 const char *path, size_t path_len, const char *value,
3304 size_t value_len);
3305LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_counter(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3306 const char *path, size_t path_len, int64_t delta);
3307LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_remove(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3308 const char *path, size_t path_len);
3309LIBCOUCHBASE_API lcb_STATUS lcb_subdocspecs_get_count(lcb_SUBDOCSPECS *operations, size_t index, uint32_t flags,
3310 const char *path, size_t path_len);
3311
3312typedef struct lcb_CMDSUBDOC_ lcb_CMDSUBDOC;
3313
3314LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_create(lcb_CMDSUBDOC **cmd);
3315LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_destroy(lcb_CMDSUBDOC *cmd);
3316LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_parent_span(lcb_CMDSUBDOC *cmd, lcbtrace_SPAN *span);
3317LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_collection(lcb_CMDSUBDOC *cmd, const char *scope, size_t scope_len,
3318 const char *collection, size_t collection_len);
3319LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_key(lcb_CMDSUBDOC *cmd, const char *key, size_t key_len);
3320LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_cas(lcb_CMDSUBDOC *cmd, uint64_t cas);
3321LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_specs(lcb_CMDSUBDOC *cmd, const lcb_SUBDOCSPECS *operations);
3322LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_expiry(lcb_CMDSUBDOC *cmd, uint32_t expiration);
3323LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_preserve_expiry(lcb_CMDSUBDOC *cmd, int should_preserve);
3324LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_durability(lcb_CMDSUBDOC *cmd, lcb_DURABILITY_LEVEL level);
3325typedef enum {
3326 LCB_SUBDOC_STORE_REPLACE = 0,
3327 LCB_SUBDOC_STORE_UPSERT,
3328 LCB_SUBDOC_STORE_INSERT
3329} lcb_SUBDOC_STORE_SEMANTICS;
3330LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_store_semantics(lcb_CMDSUBDOC *cmd, lcb_SUBDOC_STORE_SEMANTICS mode);
3331LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_access_deleted(lcb_CMDSUBDOC *cmd, int flag);
3332
3337LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_create_as_deleted(lcb_CMDSUBDOC *cmd, int flag);
3338LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_timeout(lcb_CMDSUBDOC *cmd, uint32_t timeout);
3342LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of(lcb_CMDSUBDOC *cmd, const char *data, size_t data_len);
3343LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of_extra_privilege(lcb_CMDSUBDOC *cmd, const char *privilege,
3344 size_t privilege_len);
3345
3346LIBCOUCHBASE_API lcb_STATUS lcb_subdoc(lcb_INSTANCE *instance, void *cookie, const lcb_CMDSUBDOC *cmd);
3349/* Post-include some other headers */
3350#ifdef __cplusplus
3351}
3352#endif /* __cplusplus */
3353#endif /* LIBCOUCHBASE_COUCHBASE_H */
auth.h
Credentials store for Couchbase.
cntl.h
Command codes for libcouchbase.
lcb_http_cancel
lcb_STATUS lcb_http_cancel(lcb_INSTANCE *instance, lcb_HTTP_HANDLE *handle)
Cancel ongoing HTTP request.
lcb_destroy_async
void lcb_destroy_async(lcb_INSTANCE *instance, const void *arg)
Asynchronously schedule the destruction of an instance.
lcb_cmdsubdoc_on_behalf_of
lcb_STATUS lcb_cmdsubdoc_on_behalf_of(lcb_CMDSUBDOC *cmd, const char *data, size_t data_len)
lcb_VALUEFLAGS
lcb_VALUEFLAGS
Definition: couchbase.h:2112
lcb_cmdtouch_on_behalf_of
lcb_STATUS lcb_cmdtouch_on_behalf_of(lcb_CMDTOUCH *cmd, const char *data, size_t data_len)
lcb_HTTP_METHOD
lcb_HTTP_METHOD
HTTP Request method enumeration These just enumerate the various types of HTTP request methods suppor...
Definition: couchbase.h:1590
lcb_destroy_callback
void(* lcb_destroy_callback)(const void *cookie)
Callback received when instance is about to be destroyed.
Definition: couchbase.h:2069
lcb_RESPTOUCH
struct lcb_RESPTOUCH_ lcb_RESPTOUCH
Spool a touch request.
Definition: couchbase.h:1361
lcb_set_destroy_callback
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.
lcb_resphttp_headers
lcb_STATUS lcb_resphttp_headers(const lcb_RESPHTTP *resp, const char *const **headers)
List of key-value headers.
lcb_RESPHTTP
struct lcb_RESPHTTP_ lcb_RESPHTTP
Definition: couchbase.h:1667
lcb_cmdtouch_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdtouch_on_behalf_of_extra_privilege(lcb_CMDTOUCH *cmd, const char *privilege, size_t privilege_len)
lcb_HTTP_TYPE
lcb_HTTP_TYPE
The type of HTTP request to execute.
Definition: couchbase.h:1543
LCB_HTTP_TYPE_PING
@ LCB_HTTP_TYPE_PING
Special pseudo-type, for ping endpoints in various services.
Definition: couchbase.h:1577
LCB_HTTP_TYPE_MANAGEMENT
@ LCB_HTTP_TYPE_MANAGEMENT
Execute a management API request.
Definition: couchbase.h:1556
LCB_HTTP_TYPE_QUERY
@ LCB_HTTP_TYPE_QUERY
Execute an N1QL Query.
Definition: couchbase.h:1564
LCB_HTTP_TYPE_ANALYTICS
@ LCB_HTTP_TYPE_ANALYTICS
Execute an Analytics Query.
Definition: couchbase.h:1570
LCB_HTTP_TYPE_RAW
@ LCB_HTTP_TYPE_RAW
Execute an arbitrary request against a host and port.
Definition: couchbase.h:1561
LCB_HTTP_TYPE_SEARCH
@ LCB_HTTP_TYPE_SEARCH
Search a fulltext index.
Definition: couchbase.h:1567
LCB_HTTP_TYPE_VIEW
@ LCB_HTTP_TYPE_VIEW
Execute a request against the bucket.
Definition: couchbase.h:1548
lcb_destroy
void lcb_destroy(lcb_INSTANCE *instance)
Destroy (and release all allocated resources) an instance of lcb.
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.
error.h
Definition of all of the error codes used by libcouchbase.
lcb_analytics_cancel
lcb_STATUS lcb_analytics_cancel(lcb_INSTANCE *instance, lcb_ANALYTICS_HANDLE *handle)
Cancels an in-progress request.
lcb_cmdanalytics_handle
lcb_STATUS lcb_cmdanalytics_handle(lcb_CMDANALYTICS *cmd, lcb_ANALYTICS_HANDLE **handle)
Get handle to analytics query.
lcb_respanalytics_handle
lcb_STATUS lcb_respanalytics_handle(const lcb_RESPANALYTICS *resp, lcb_ANALYTICS_HANDLE **handle)
Get handle to analytics query.
lcb_ANALYTICS_CONSISTENCY
lcb_ANALYTICS_CONSISTENCY
Definition: couchbase.h:2488
lcb_cmdanalytics_on_behalf_of
lcb_STATUS lcb_cmdanalytics_on_behalf_of(lcb_CMDANALYTICS *cmd, const char *data, size_t data_len)
lcb_analytics
lcb_STATUS lcb_analytics(lcb_INSTANCE *instance, void *cookie, const lcb_CMDANALYTICS *cmd)
Execute a Analytics query.
lcb_cmdanalytics_positional_param
lcb_STATUS lcb_cmdanalytics_positional_param(lcb_CMDANALYTICS *cmd, const char *value, size_t value_len)
lcb_cmdanalytics_positional_params
lcb_STATUS lcb_cmdanalytics_positional_params(lcb_CMDANALYTICS *cmd, const char *value, size_t value_len)
Sets the positional arguments for the query.
lcb_ANALYTICS_CALLBACK
void(* lcb_ANALYTICS_CALLBACK)(lcb_INSTANCE *, int, const lcb_RESPANALYTICS *)
Callback to be invoked for each row.
Definition: couchbase.h:2452
lcb_cmdanalytics_scope_qualifier
lcb_STATUS lcb_cmdanalytics_scope_qualifier(lcb_CMDANALYTICS *cmd, const char *qualifier, size_t qualifier_len)
lcb_RESPANALYTICS
struct lcb_RESPANALYTICS_ lcb_RESPANALYTICS
Response for a Analytics query.
Definition: couchbase.h:2444
lcb_cmdanalytics_scope_name
lcb_STATUS lcb_cmdanalytics_scope_name(lcb_CMDANALYTICS *cmd, const char *scope, size_t scope_len)
Associate scope name with the query.
LCB_ANALYTICS_CONSISTENCY_NOT_BOUNDED
@ LCB_ANALYTICS_CONSISTENCY_NOT_BOUNDED
No consistency constraints.
Definition: couchbase.h:2494
LCB_ANALYTICS_CONSISTENCY_REQUEST_PLUS
@ LCB_ANALYTICS_CONSISTENCY_REQUEST_PLUS
Strong consistency.
Definition: couchbase.h:2499
lcb_AUTHENTICATOR
Opaque pointer containing credentials for the library.
lcb_get_version
const char * lcb_get_version(lcb_U32 *version)
Get the version of the library.
lcb_supports_feature
int lcb_supports_feature(int n)
lcb_version_g
LCB_EXTERN_VAR const lcb_U32 lcb_version_g
Global/extern variable containing the version of the library.
Definition: couchbase.h:2391
lcb_respsearch_handle
lcb_STATUS lcb_respsearch_handle(const lcb_RESPSEARCH *resp, lcb_SEARCH_HANDLE **handle)
Get search handle from search response.
lcb_cmdsearch_on_behalf_of
lcb_STATUS lcb_cmdsearch_on_behalf_of(lcb_CMDSEARCH *cmd, const char *data, size_t data_len)
lcb_search
lcb_STATUS lcb_search(lcb_INSTANCE *instance, void *cookie, const lcb_CMDSEARCH *cmd)
Issue a full-text query.
lcb_cmdsearch_handle
lcb_STATUS lcb_cmdsearch_handle(lcb_CMDSEARCH *cmd, lcb_SEARCH_HANDLE **handle)
Obtain handle to search.
lcb_search_cancel
lcb_STATUS lcb_search_cancel(lcb_INSTANCE *instance, lcb_SEARCH_HANDLE *handle)
Cancel a full-text query in progress.
lcb_cntl_string
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.
lcb_refresh_config
void lcb_refresh_config(lcb_INSTANCE *instance)
Force the library to refetch the cluster configuration.
lcb_cntl
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 propertie...
lcb_cntl_setu32
lcb_STATUS lcb_cntl_setu32(lcb_INSTANCE *instance, int cmd, lcb_U32 arg)
Convenience function to set a value as an lcb_U32.
lcb_cntl_getu32
lcb_U32 lcb_cntl_getu32(lcb_INSTANCE *instance, int cmd)
Retrieve an lcb_U32 setting.
lcb_cntl_exists
int lcb_cntl_exists(int ctl)
Determine if a specific control code exists.
lcb_set_cookie
void lcb_set_cookie(lcb_INSTANCE *instance, const void *cookie)
Associate a cookie with an instance of lcb.
lcb_get_cookie
const void * lcb_get_cookie(lcb_INSTANCE *instance)
Retrieve the cookie associated with this instance.
lcb_cmdcounter_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdcounter_on_behalf_of_extra_privilege(lcb_CMDCOUNTER *cmd, const char *privilege, size_t privilege_len)
lcb_RESPCOUNTER
struct lcb_RESPCOUNTER_ lcb_RESPCOUNTER
Schedule single counter operation.
Definition: couchbase.h:1194
lcb_cmdcounter_on_behalf_of
lcb_STATUS lcb_cmdcounter_on_behalf_of(lcb_CMDCOUNTER *cmd, const char *data, size_t data_len)
lcb_STATUS
lcb_STATUS
Error codes returned by the library.
Definition: error.h:212
lcb_cmdgetreplica_on_behalf_of
lcb_STATUS lcb_cmdgetreplica_on_behalf_of(lcb_CMDGETREPLICA *cmd, const char *data, size_t data_len)
lcb_REPLICA_MODE
lcb_REPLICA_MODE
Spool a single get-with-replica request.
Definition: couchbase.h:787
lcb_cmdgetreplica_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdgetreplica_on_behalf_of_extra_privilege(lcb_CMDGETREPLICA *cmd, const char *privilege, size_t privilege_len)
lcb_cmdget_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdget_on_behalf_of_extra_privilege(lcb_CMDGET *cmd, const char *privilege, size_t privilege_len)
lcb_RESPGET
struct lcb_RESPGET_ lcb_RESPGET
Command for retrieving a single item.
Definition: couchbase.h:687
lcb_cmdget_on_behalf_of
lcb_STATUS lcb_cmdget_on_behalf_of(lcb_CMDGET *cmd, const char *data, size_t data_len)
lcb_get_bootstrap_status
lcb_STATUS lcb_get_bootstrap_status(lcb_INSTANCE *instance)
Gets the initial bootstrap status.
lcb_set_auth
void lcb_set_auth(lcb_INSTANCE *instance, lcb_AUTHENTICATOR *auth)
Sets the authenticator object for the instance.
lcb_BTYPE
lcb_BTYPE
Type of the bucket.
Definition: couchbase.h:240
lcb_set_bootstrap_callback
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.
lcb_create
lcb_STATUS lcb_create(lcb_INSTANCE **instance, const lcb_CREATEOPTS *options)
Create an instance of lcb.
lcb_INSTANCE_TYPE
lcb_INSTANCE_TYPE
Handle types.
Definition: couchbase.h:255
lcb_INSTANCE
struct lcb_st lcb_INSTANCE
Library handle representing a connection to a cluster and its data buckets.
Definition: couchbase.h:35
lcb_connect
lcb_STATUS lcb_connect(lcb_INSTANCE *instance)
Schedule the initial connection This function will schedule the initial connection for the handle.
lcb_bootstrap_callback
void(* lcb_bootstrap_callback)(lcb_INSTANCE *instance, lcb_STATUS err)
Bootstrap callback.
Definition: couchbase.h:354
LCB_BTYPE_UNSPEC
@ LCB_BTYPE_UNSPEC
Unknown or unspecified.
Definition: couchbase.h:241
LCB_BTYPE_COUCHBASE
@ LCB_BTYPE_COUCHBASE
Data persisted and replicated.
Definition: couchbase.h:242
LCB_BTYPE_EPHEMERAL
@ LCB_BTYPE_EPHEMERAL
Data not persisted, but replicated.
Definition: couchbase.h:243
LCB_BTYPE_MEMCACHED
@ LCB_BTYPE_MEMCACHED
Data not persisted and not replicated.
Definition: couchbase.h:244
LCB_TYPE_CLUSTER
@ LCB_TYPE_CLUSTER
Handle for administrative access.
Definition: couchbase.h:257
LCB_TYPE_BUCKET
@ LCB_TYPE_BUCKET
Handle for data access (default)
Definition: couchbase.h:256
lcb_IOV
structure indicating a buffer and its size
Definition: iops.h:78
lcb_install_callback
lcb_RESPCALLBACK lcb_install_callback(lcb_INSTANCE *instance, int cbtype, lcb_RESPCALLBACK cb)
lcb_cmdunlock_on_behalf_of
lcb_STATUS lcb_cmdunlock_on_behalf_of(lcb_CMDUNLOCK *cmd, const char *data, size_t data_len)
lcb_CALLBACK_TYPE
lcb_CALLBACK_TYPE
The type of response passed to the callback.
Definition: couchbase.h:469
lcb_cmdexists_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdexists_on_behalf_of_extra_privilege(lcb_CMDEXISTS *cmd, const char *privilege, size_t privilege_len)
lcb_DURABILITY_LEVEL
lcb_DURABILITY_LEVEL
Definition: couchbase.h:524
lcb_RESPCALLBACK
void(* lcb_RESPCALLBACK)(lcb_INSTANCE *instance, int cbtype, const lcb_RESPBASE *resp)
Callback invoked for responses.
Definition: couchbase.h:554
lcb_cmdexists_on_behalf_of
lcb_STATUS lcb_cmdexists_on_behalf_of(lcb_CMDEXISTS *cmd, const char *data, size_t data_len)
lcb_RESPFLAGS
lcb_RESPFLAGS
Response flags.
Definition: couchbase.h:430
lcb_get_callback
lcb_RESPCALLBACK lcb_get_callback(lcb_INSTANCE *instance, int cbtype)
lcb_strcbtype
const char * lcb_strcbtype(int cbtype)
Returns the type of the callback as a string.
lcb_RESPUNLOCK
struct lcb_RESPUNLOCK_ lcb_RESPUNLOCK
Unlock a previously locked item using lcb_cmdunlock.
Definition: couchbase.h:1287
lcb_cmdunlock_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdunlock_on_behalf_of_extra_privilege(lcb_CMDUNLOCK *cmd, const char *privilege, size_t privilege_len)
LCB_CALLBACK_ENDURE
@ LCB_CALLBACK_ENDURE
lcb_endure3_ctxnew()
Definition: couchbase.h:482
LCB_CALLBACK_VERSIONS
@ LCB_CALLBACK_VERSIONS
lcb_server_versions()
Definition: couchbase.h:478
LCB_CALLBACK_GETCID
@ LCB_CALLBACK_GETCID
lcb_getcid()
Definition: couchbase.h:493
LCB_CALLBACK_VERBOSITY
@ LCB_CALLBACK_VERBOSITY
lcb_server_verbosity()
Definition: couchbase.h:479
LCB_CALLBACK_EXISTS
@ LCB_CALLBACK_EXISTS
lcb_exists()
Definition: couchbase.h:494
LCB_CALLBACK_PING
@ LCB_CALLBACK_PING
lcb_ping3()
Definition: couchbase.h:490
LCB_CALLBACK_REMOVE
@ LCB_CALLBACK_REMOVE
lcb_remove()
Definition: couchbase.h:475
LCB_CALLBACK_TOUCH
@ LCB_CALLBACK_TOUCH
lcb_touch()
Definition: couchbase.h:474
LCB_CALLBACK_COLLECTIONS_GET_MANIFEST
@ LCB_CALLBACK_COLLECTIONS_GET_MANIFEST
lcb_getmanifest()
Definition: couchbase.h:492
LCB_CALLBACK_NOOP
@ LCB_CALLBACK_NOOP
lcb_noop3()
Definition: couchbase.h:489
LCB_CALLBACK_STATS
@ LCB_CALLBACK_STATS
lcb_stats3()
Definition: couchbase.h:477
LCB_CALLBACK_GET
@ LCB_CALLBACK_GET
lcb_get()
Definition: couchbase.h:471
LCB_CALLBACK_COUNTER
@ LCB_CALLBACK_COUNTER
lcb_counter()
Definition: couchbase.h:473
LCB_CALLBACK_HTTP
@ LCB_CALLBACK_HTTP
lcb_http()
Definition: couchbase.h:483
LCB_CALLBACK_STORE
@ LCB_CALLBACK_STORE
lcb_store()
Definition: couchbase.h:472
LCB_CALLBACK_GETREPLICA
@ LCB_CALLBACK_GETREPLICA
lcb_getreplica()
Definition: couchbase.h:481
LCB_CALLBACK_UNLOCK
@ LCB_CALLBACK_UNLOCK
lcb_unlock()
Definition: couchbase.h:476
LCB_CALLBACK_CBFLUSH
@ LCB_CALLBACK_CBFLUSH
lcb_cbflush3()
Definition: couchbase.h:484
LCB_CALLBACK_DIAG
@ LCB_CALLBACK_DIAG
lcb_diag()
Definition: couchbase.h:491
LCB_CALLBACK_SDLOOKUP
@ LCB_CALLBACK_SDLOOKUP
<for lcb_storedur3()
Definition: couchbase.h:487
LCB_CALLBACK_DEFAULT
@ LCB_CALLBACK_DEFAULT
Default callback invoked as a fallback.
Definition: couchbase.h:470
LCB_CALLBACK_OBSEQNO
@ LCB_CALLBACK_OBSEQNO
For lcb_observe_seqno3()
Definition: couchbase.h:485
LCB_CALLBACK_OBSERVE
@ LCB_CALLBACK_OBSERVE
lcb_observe3_ctxnew()
Definition: couchbase.h:480
LCB_DURABILITYLEVEL_MAJORITY
@ LCB_DURABILITYLEVEL_MAJORITY
Mutation must be replicated to (i.e.
Definition: couchbase.h:531
LCB_DURABILITYLEVEL_MAJORITY_AND_PERSIST_TO_ACTIVE
@ LCB_DURABILITYLEVEL_MAJORITY_AND_PERSIST_TO_ACTIVE
As majority, but additionally persisted to the active node.
Definition: couchbase.h:535
LCB_DURABILITYLEVEL_PERSIST_TO_MAJORITY
@ LCB_DURABILITYLEVEL_PERSIST_TO_MAJORITY
Mutation must be persisted to (i.e.
Definition: couchbase.h:540
LCB_RESP_F_NMVGEN
@ LCB_RESP_F_NMVGEN
The response was a result of a not-my-vbucket error.
Definition: couchbase.h:442
LCB_RESP_F_FINAL
@ LCB_RESP_F_FINAL
No more responses are to be received for this request.
Definition: couchbase.h:432
LCB_RESP_F_CLIENTGEN
@ LCB_RESP_F_CLIENTGEN
The response was artificially generated inside the client.
Definition: couchbase.h:439
LCB_RESP_F_ERRINFO
@ LCB_RESP_F_ERRINFO
The response has extra error information as value (see SDK-RFC-28).
Definition: couchbase.h:453
LCB_RESP_F_SDSINGLE
@ LCB_RESP_F_SDSINGLE
Flag, only valid for subdoc responses, indicates that the response was processed using the single-ope...
Definition: couchbase.h:450
LCB_RESP_F_EXTDATA
@ LCB_RESP_F_EXTDATA
The response has additional internal data.
Definition: couchbase.h:446
lcb_is_redacting_logs
int lcb_is_redacting_logs(lcb_INSTANCE *instance)
Returns whether the library redacting logs for this connection instance.
lcb_query
lcb_STATUS lcb_query(lcb_INSTANCE *instance, void *cookie, const lcb_CMDQUERY *cmd)
Execute a N1QL query.
lcb_cmdquery_statement
lcb_STATUS lcb_cmdquery_statement(lcb_CMDQUERY *cmd, const char *statement, size_t statement_len)
Sets the actual statement to be executed.
lcb_query_cancel
lcb_STATUS lcb_query_cancel(lcb_INSTANCE *instance, lcb_QUERY_HANDLE *handle)
Cancels an in-progress request.
lcb_cmdquery_option
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.
lcb_cmdquery_named_param
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.
lcb_cmdquery_reset
lcb_STATUS lcb_cmdquery_reset(lcb_CMDQUERY *cmd)
Reset the lcb_CMDQUERY structure so that it may be reused for a subsequent query.
lcb_RESPQUERY
struct lcb_RESPQUERY_ lcb_RESPQUERY
Opaque query response structure.
Definition: couchbase.h:2838
lcb_cmdquery_create
lcb_STATUS lcb_cmdquery_create(lcb_CMDQUERY **cmd)
Create a new lcb_CMDQUERY object.
lcb_cmdquery_pipeline_cap
lcb_STATUS lcb_cmdquery_pipeline_cap(lcb_CMDQUERY *cmd, int value)
Sets maximum number of items each execution operator can buffer between various operators.
lcb_CMDQUERY
struct lcb_CMDQUERY_ lcb_CMDQUERY
Opaque query command structure.
Definition: couchbase.h:2843
lcb_cmdquery_consistency
lcb_STATUS lcb_cmdquery_consistency(lcb_CMDQUERY *cmd, lcb_QUERY_CONSISTENCY mode)
Sets the consistency mode for the request.
lcb_QUERY_CONSISTENCY
lcb_QUERY_CONSISTENCY
Definition: couchbase.h:2857
lcb_QUERY_CALLBACK
void(* lcb_QUERY_CALLBACK)(lcb_INSTANCE *, int, const lcb_RESPQUERY *)
Callback to be invoked for each row.
Definition: couchbase.h:2855
lcb_cmdquery_flex_index
lcb_STATUS lcb_cmdquery_flex_index(lcb_CMDQUERY *cmd, int value)
lcb_cmdquery_positional_param
lcb_STATUS lcb_cmdquery_positional_param(lcb_CMDQUERY *cmd, const char *value, size_t value_len)
lcb_cmdquery_scope_qualifier
lcb_STATUS lcb_cmdquery_scope_qualifier(lcb_CMDQUERY *cmd, const char *qualifier, size_t qualifier_len)
lcb_cmdquery_pipeline_batch
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.
lcb_cmdquery_destroy
lcb_STATUS lcb_cmdquery_destroy(lcb_CMDQUERY *cmd)
Free the command structure.
lcb_cmdquery_positional_params
lcb_STATUS lcb_cmdquery_positional_params(lcb_CMDQUERY *cmd, const char *value, size_t value_len)
Sets the positional arguments for the query.
lcb_cmdquery_readonly
lcb_STATUS lcb_cmdquery_readonly(lcb_CMDQUERY *cmd, int readonly)
Marks query as read-only.
lcb_cmdquery_consistency_token_for_keyspace
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 ...
lcb_cmdquery_on_behalf_of
lcb_STATUS lcb_cmdquery_on_behalf_of(lcb_CMDQUERY *cmd, const char *data, size_t data_len)
lcb_cmdquery_encoded_payload
lcb_STATUS lcb_cmdquery_encoded_payload(lcb_CMDQUERY *cmd, const char **payload, size_t *payload_len)
Get the JSON-encoded query payload.
lcb_cmdquery_payload
lcb_STATUS lcb_cmdquery_payload(lcb_CMDQUERY *cmd, const char *query, size_t query_len)
Sets the JSON-encodes query payload to be executed.
lcb_cmdquery_scope_name
lcb_STATUS lcb_cmdquery_scope_name(lcb_CMDQUERY *cmd, const char *scope, size_t scope_len)
Associate scope name with the query.
lcb_QUERY_HANDLE
struct lcb_QUERY_HANDLE_ lcb_QUERY_HANDLE
Pointer for request instance.
Definition: couchbase.h:2847
lcb_cmdquery_preserve_expiry
lcb_STATUS lcb_cmdquery_preserve_expiry(lcb_CMDQUERY *cmd, int preserve_expiry)
lcb_cmdquery_scan_cap
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.
LCB_QUERY_CONSISTENCY_NONE
@ LCB_QUERY_CONSISTENCY_NONE
No consistency constraints.
Definition: couchbase.h:2859
LCB_QUERY_CONSISTENCY_RYOW
@ LCB_QUERY_CONSISTENCY_RYOW
This is implicitly set by lcb_cmdquery_consistency_token_for_keyspace.
Definition: couchbase.h:2866
LCB_QUERY_CONSISTENCY_STATEMENT
@ LCB_QUERY_CONSISTENCY_STATEMENT
Refresh the snapshot for each statement.
Definition: couchbase.h:2872
LCB_QUERY_CONSISTENCY_REQUEST
@ LCB_QUERY_CONSISTENCY_REQUEST
Refresh the snapshot for each request.
Definition: couchbase.h:2869
lcb_open
lcb_STATUS lcb_open(lcb_INSTANCE *instance, const char *bucket, size_t bucket_len)
Opens bucket.
lcb_set_open_callback
lcb_open_callback lcb_set_open_callback(lcb_INSTANCE *instance, lcb_open_callback callback)
Callback to be called when bucket is opened.
lcb_diag
lcb_STATUS lcb_diag(lcb_INSTANCE *instance, void *cookie, const lcb_CMDDIAG *cmd)
Returns diagnostics report about network connections.
lcb_PING_SERVICE
lcb_PING_SERVICE
Type of the service.
Definition: couchbase.h:1423
lcb_PING_STATUS
lcb_PING_STATUS
Status of the service.
Definition: couchbase.h:1410
lcb_RESPREMOVE
struct lcb_RESPREMOVE_ lcb_RESPREMOVE
Spool a removal of an item.
Definition: couchbase.h:1101
lcb_cmdremove_on_behalf_of
lcb_STATUS lcb_cmdremove_on_behalf_of(lcb_CMDREMOVE *cmd, const char *data, size_t data_len)
lcb_cmdremove_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdremove_on_behalf_of_extra_privilege(lcb_CMDREMOVE *cmd, const char *privilege, size_t privilege_len)
lcb_sched_leave
void lcb_sched_leave(lcb_INSTANCE *instance)
Leave the current scheduling context, scheduling the commands within the context to be flushed to the...
lcb_sched_fail
void lcb_sched_fail(lcb_INSTANCE *instance)
Fail all commands in the current scheduling context.
lcb_sched_enter
void lcb_sched_enter(lcb_INSTANCE *instance)
Enter a scheduling context.
lcb_sched_flush
void lcb_sched_flush(lcb_INSTANCE *instance)
Request commands to be flushed to the network.
lcb_cmdstore_on_behalf_of
lcb_STATUS lcb_cmdstore_on_behalf_of(lcb_CMDSTORE *cmd, const char *data, size_t data_len)
lcb_STORE_OPERATION
lcb_STORE_OPERATION
Values for lcb_CMDSTORE::operation.
Definition: couchbase.h:878
lcb_cmdstore_on_behalf_of_extra_privilege
lcb_STATUS lcb_cmdstore_on_behalf_of_extra_privilege(lcb_CMDSTORE *cmd, const char *privilege, size_t privilege_len)
lcb_RESPSTORE
struct lcb_RESPSTORE_ lcb_RESPSTORE
Schedule a single storage request.
Definition: couchbase.h:971
LCB_STORE_APPEND
@ LCB_STORE_APPEND
Rather than setting the contents of the entire document, take the value specified in lcb_CMDSTORE::va...
Definition: couchbase.h:906
LCB_STORE_INSERT
@ LCB_STORE_INSERT
Will cause the operation to fail if the key already exists in the cluster.
Definition: couchbase.h:893
LCB_STORE_REPLACE
@ LCB_STORE_REPLACE
Will cause the operation to fail unless the key already exists in the cluster.
Definition: couchbase.h:899
LCB_STORE_UPSERT
@ LCB_STORE_UPSERT
The default storage mode.
Definition: couchbase.h:887
LCB_STORE_PREPEND
@ LCB_STORE_PREPEND
Like LCB_STORE_APPEND, but prepends the new value to the existing value.
Definition: couchbase.h:911
lcb_cmdanalytics_parent_span
lcb_STATUS lcb_cmdanalytics_parent_span(lcb_CMDANALYTICS *cmd, lcbtrace_SPAN *span)
Associate parent tracing span with the Analytics request.
lcb_cmdquery_parent_span
lcb_STATUS lcb_cmdquery_parent_span(lcb_CMDQUERY *cmd, lcbtrace_SPAN *span)
Associate parent tracing span with the N1QL request.
lcb_cmdsearch_parent_span
lcb_STATUS lcb_cmdsearch_parent_span(lcb_CMDSEARCH *cmd, lcbtrace_SPAN *span)
Associate parent tracing span with the FTS request.
lcbtrace_TRACER
Tracer interface.
Definition: tracing.h:73
lcb_VIEW_CALLBACK
void(* lcb_VIEW_CALLBACK)(lcb_INSTANCE *instance, int cbtype, const lcb_RESPVIEW *row)
Callback function invoked for each row returned from the view.
Definition: couchbase.h:3202
lcb_VIEW_HANDLE
struct lcb_VIEW_HANDLE_ lcb_VIEW_HANDLE
Pointer for request instance.
Definition: couchbase.h:3189
lcb_wait
lcb_STATUS lcb_wait(lcb_INSTANCE *instance, lcb_WAITFLAGS flags)
Wait for completion of scheduled operations.
lcb_is_waiting
int lcb_is_waiting(lcb_INSTANCE *instance)
Check if instance is blocked in the event loop.
lcb_WAITFLAGS
lcb_WAITFLAGS
Flags for lcb_wait()
Definition: couchbase.h:1852
lcb_tick_nowait
lcb_STATUS lcb_tick_nowait(lcb_INSTANCE *instance)
lcb_breakout
void lcb_breakout(lcb_INSTANCE *instance)
Forcefully break from the event loop.
LCB_WAIT_DEFAULT
@ LCB_WAIT_DEFAULT
Behave like the old lcb_wait()
Definition: couchbase.h:1854
LCB_WAIT_NOCHECK
@ LCB_WAIT_NOCHECK
Do not check pending operations before running the event loop.
Definition: couchbase.h:1863
iops.h
Public I/O integration interface.
kvbuf.h
Low level structures used by commands for buffers.