Couchbase C Client  3.2.4
Asynchronous C Client for Couchbase
example/minimal/minimal.c

Shows how to connect to the cluster and perform operations

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright 2012-2020 Couchbase, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* strlen */
#ifdef _WIN32
#define PRIx64 "I64x"
#else
#include <inttypes.h>
#endif
static void die(lcb_INSTANCE *instance, const char *msg, lcb_STATUS err)
{
fprintf(stderr, "%s. Received code 0x%X (%s)\n", msg, err, lcb_strerror_short(err));
exit(EXIT_FAILURE);
}
static void store_callback(lcb_INSTANCE *instance, int cbtype, const lcb_RESPSTORE *resp)
{
lcb_STATUS rc = lcb_respstore_status(resp);
fprintf(stderr, "=== %s ===\n", lcb_strcbtype(cbtype));
if (rc == LCB_SUCCESS) {
const char *key;
size_t nkey;
uint64_t cas;
lcb_respstore_key(resp, &key, &nkey);
fprintf(stderr, "KEY: %.*s\n", (int)nkey, key);
lcb_respstore_cas(resp, &cas);
fprintf(stderr, "CAS: 0x%" PRIx64 "\n", cas);
} else {
die(instance, lcb_strcbtype(cbtype), rc);
}
}
static void get_callback(lcb_INSTANCE *instance, int cbtype, const lcb_RESPGET *resp)
{
lcb_STATUS rc = lcb_respget_status(resp);
fprintf(stderr, "=== %s ===\n", lcb_strcbtype(cbtype));
if (rc == LCB_SUCCESS) {
const char *key, *value;
size_t nkey, nvalue;
uint64_t cas;
uint32_t flags;
lcb_respget_key(resp, &key, &nkey);
fprintf(stderr, "KEY: %.*s\n", (int)nkey, key);
lcb_respget_cas(resp, &cas);
fprintf(stderr, "CAS: 0x%" PRIx64 "\n", cas);
lcb_respget_value(resp, &value, &nvalue);
lcb_respget_flags(resp, &flags);
fprintf(stderr, "VALUE: %.*s\n", (int)nvalue, value);
fprintf(stderr, "FLAGS: 0x%x\n", flags);
} else {
die(instance, lcb_strcbtype(cbtype), rc);
}
}
int main(int argc, char *argv[])
{
lcb_INSTANCE *instance;
lcb_CREATEOPTS *create_options = NULL;
lcb_CMDSTORE *scmd;
lcb_CMDGET *gcmd;
if (argc < 2) {
fprintf(stderr, "Usage: %s couchbase://host/bucket [ password [ username ] ]\n", argv[0]);
exit(EXIT_FAILURE);
}
lcb_createopts_create(&create_options, LCB_TYPE_BUCKET);
lcb_createopts_connstr(create_options, argv[1], strlen(argv[1]));
if (argc > 3) {
lcb_createopts_credentials(create_options, argv[2], strlen(argv[2]), argv[3], strlen(argv[3]));
}
err = lcb_create(&instance, create_options);
lcb_createopts_destroy(create_options);
if (err != LCB_SUCCESS) {
die(NULL, "Couldn't create couchbase handle", err);
}
err = lcb_connect(instance);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't schedule connection", err);
}
err = lcb_get_bootstrap_status(instance);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't bootstrap from cluster", err);
}
/* Assign the handlers to be called for the operation types */
lcb_cmdstore_create(&scmd, LCB_STORE_UPSERT);
lcb_cmdstore_key(scmd, "key", strlen("key"));
lcb_cmdstore_value(scmd, "value", strlen("value"));
err = lcb_store(instance, NULL, scmd);
lcb_cmdstore_destroy(scmd);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't schedule storage operation", err);
}
/* The store_callback is invoked from lcb_wait() */
fprintf(stderr, "Will wait for storage operation to complete..\n");
/* Now fetch the item back */
lcb_cmdget_create(&gcmd);
lcb_cmdget_key(gcmd, "key", strlen("key"));
err = lcb_get(instance, NULL, gcmd);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't schedule retrieval operation", err);
}
lcb_cmdget_destroy(gcmd);
/* Likewise, the get_callback is invoked from here */
fprintf(stderr, "Will wait to retrieve item..\n");
/* Now that we're all done, close down the connection handle */
lcb_destroy(instance);
return 0;
}
Main header file for Couchbase.
void lcb_destroy(lcb_INSTANCE *instance)
Destroy (and release all allocated resources) an instance of lcb.
LCB_INTERNAL_API const char * lcb_strerror_short(lcb_STATUS error)
Get a shorter textual description of an error message.
lcb_STATUS
Error codes returned by the library.
Definition: error.h:212
struct lcb_RESPGET_ lcb_RESPGET
Command for retrieving a single item.
Definition: couchbase.h:687
lcb_STATUS lcb_get_bootstrap_status(lcb_INSTANCE *instance)
Gets the initial bootstrap status.
lcb_STATUS lcb_create(lcb_INSTANCE **instance, const lcb_CREATEOPTS *options)
Create an instance of lcb.
struct lcb_st lcb_INSTANCE
Library handle representing a connection to a cluster and its data buckets.
Definition: couchbase.h:35
lcb_STATUS lcb_connect(lcb_INSTANCE *instance)
Schedule the initial connection This function will schedule the initial connection for the handle.
@ LCB_TYPE_BUCKET
Handle for data access (default)
Definition: couchbase.h:256
lcb_RESPCALLBACK lcb_install_callback(lcb_INSTANCE *instance, int cbtype, lcb_RESPCALLBACK cb)
const char * lcb_strcbtype(int cbtype)
Returns the type of the callback as a string.
void(* lcb_RESPCALLBACK)(lcb_INSTANCE *instance, int cbtype, const lcb_RESPBASE *resp)
Callback invoked for responses.
Definition: couchbase.h:554
@ LCB_CALLBACK_GET
lcb_get()
Definition: couchbase.h:471
@ LCB_CALLBACK_STORE
lcb_store()
Definition: couchbase.h:472
struct lcb_RESPSTORE_ lcb_RESPSTORE
Schedule a single storage request.
Definition: couchbase.h:956
@ LCB_STORE_UPSERT
The default storage mode.
Definition: couchbase.h:872
lcb_STATUS lcb_wait(lcb_INSTANCE *instance, lcb_WAITFLAGS flags)
Wait for completion of scheduled operations.
@ LCB_WAIT_DEFAULT
Behave like the old lcb_wait()
Definition: couchbase.h:1814