// =======================================================================
static as_status aerospike_lstack_push_internal(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
const char *operation)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !val) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, ldt->module[0] == 0 ? 2 : 3);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val );
as_arraylist_append(&arglist, (as_val *) val);
if (ldt->module[0] != 0) {
as_string ldt_module;
as_string_init(&ldt_module, (char *)ldt->module, false);
as_arraylist_append_string(&arglist, &ldt_module);
}
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, operation,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
// return value is the input
if (p_return_val) {
as_val_destroy(p_return_val);
}
return err->code;
} // end aerospike_lstack_push_internal()
// Creates a message, internally calling cl_compile to pass to the server
static int scan_compile(const cl_scan * scan, uint8_t ** buf_r, size_t * buf_sz_r) {
if (!scan) return CITRUSLEAF_FAIL_CLIENT;
// Prepare udf call to send to the server
as_call call;
as_serializer ser;
as_buffer argbuffer;
as_buffer_init(&argbuffer);
if ( scan->udf.type != CL_SCAN_UDF_NONE) {
as_string file;
as_string_init(&file, (char *) scan->udf.filename, true /*ismalloc*/);
as_string func;
as_string_init(&func, (char *) scan->udf.function, true /*ismalloc*/);
if (scan->udf.arglist != NULL) {
/**
* If the query has a udf w/ arglist,
* then serialize it.
*/
as_msgpack_init(&ser);
as_serializer_serialize(&ser, (as_val *) scan->udf.arglist, &argbuffer);
}
call.file = &file;
call.func = &func;
call.args = &argbuffer;
}
// Prepare to send scan parameters
cl_scan_param_field scan_param_field;
cl_scan_params params = scan->params;
scan_param_field.scan_pct = params.pct > 100 ? 100 : params.pct;
scan_param_field.byte1 = (params.priority << 4) | (params.fail_on_cluster_change << 3);
// Prepare the msg type to be sent
uint info;
info = CL_MSG_INFO1_READ;
// Pass on to the cl_compile to create the msg
cl_compile(info /*info1*/, 0, 0, scan->ns /*namespace*/, scan->setname /*setname*/, 0 /*key*/, 0/*digest*/, NULL /*bins*/, 0/*op*/, 0/*operations*/, 0/*n_values*/, buf_r, buf_sz_r, 0 /*w_p*/, NULL /*d_ret*/, scan->job_id, &scan_param_field, scan->udf.type != CL_SCAN_UDF_NONE ? &call : NULL/*udf call*/, scan->udf.type);
if (scan->udf.arglist) {
as_serializer_destroy(&ser);
}
as_buffer_destroy(&argbuffer);
return CITRUSLEAF_OK;
}
/**
* Initialize a stack allocated `as_key` to a NULL-terminated string value.
*/
as_key * as_key_init_strp(as_key * key, const as_namespace ns, const as_set set, const char * value, bool free)
{
if ( !key ) return key;
as_string_init((as_string *) &key->value, (char *) value, free);
return as_key_cons(key, false, ns, set, &key->value, NULL);
}
static as_val * map_rec_get(const as_rec * r, const char * name) {
as_map * m = (as_map *) r->data;
as_string s;
as_string_init(&s, (char *) name, false);
as_val * v = as_map_get(m, (as_val *) &s);
as_string_destroy(&s);
return v;
}
/**
* Creates and initializes a heap allocated `as_key` to a NULL-terminated string value.
*/
as_key * as_key_new_strp(const as_namespace ns, const as_set set, const char * value, bool free)
{
as_key * key = (as_key *) malloc(sizeof(as_key));
if ( !key ) return key;
as_string_init((as_string *) &key->value, (char *) value, free);
return as_key_cons(key, true, ns, set, &key->value, NULL);
}
as_status aerospike_lset_exists(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
as_boolean *exists)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !exists) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSET) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not lset type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val ); // bump the ref count
as_arraylist_append(&arglist, (as_val *)val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSET_PACKAGE, LDT_SET_OP_EXISTS,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
as_boolean_init(exists, ival==1 ? true: false);
return err->code;
} // aerospike_lset_exists()
// =======================================================================
// Pass in a value into the UDF -- and then get it back. Simple.
// This is used to measure the performance of the end to end
// call infrastructure.
// Pass in LDT Bin and Value.
// Return Value.
// =======================================================================
as_status aerospike_lstack_same(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t in_val,
uint32_t * out_valp)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !out_valp) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/out_valp cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not LSTACK type");
}
// stack allocate the arg list.
// Pass in the LDT Bin and the IN VALUE.
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_arraylist_append_int64(&arglist, in_val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, LDT_STACK_OP_SAME,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
if (ival !=0 ) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"same() Function Failed");
}
*out_valp = (uint32_t)ival;
return err->code;
} // end as_status aerospike_lstack_same()
// =======================================================================
as_status aerospike_lstack_set_capacity(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t elements_capacity
)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !elements_capacity) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/capacity cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_arraylist_append_int64(&arglist, elements_capacity);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, LDT_STACK_OP_CAPACITY_SET,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
if (ival !=0 ) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"capacity setting failed");
}
return err->code;
}
// =======================================================================
// Internal function to handle all of the functions that get an int back
// from a call.
// size()
// one()
// =======================================================================
as_status aerospike_lstack_ask_internal(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t *n, const char *operation )
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !n) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
// All we need to pass in is the LDT Bin Name
as_arraylist arglist;
as_arraylist_inita(&arglist, 1);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, operation,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
*n = (uint32_t)ival;
return err->code;
} // end as_status aerospike_lstack_ask_internal()
as_status aerospike_llist_find(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * search_val,
as_list ** elements )
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !search_val || !elements) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/search_val/elements cannot be null");
}
if (ldt->type != AS_LDT_LLIST) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not llist type");
}
int list_argc = 2;
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, list_argc);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( search_val ); // bump the ref count so the arraylist_destroy will not reset the search_val
as_arraylist_append(&arglist, (as_val *) search_val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LLIST_PACKAGE, LDT_LIST_OP_FIND,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
*elements = (as_list *)p_return_val;
return err->code;
} // aerospike_llist_find()
as_status aerospike_llist_remove(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val *val
)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/capacity cannot be null");
}
if (ldt->type != AS_LDT_LLIST) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not llist type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val );
as_arraylist_append(&arglist, (as_val *) val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LLIST_PACKAGE, LDT_LIST_OP_REMOVE,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (p_return_val != NULL) {
as_val_destroy(p_return_val);
}
return err->code;
}
as_status aerospike_lset_get(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
as_val **pp_return_val)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !pp_return_val) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/return cannot be null");
}
if (ldt->type != AS_LDT_LSET) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not lset type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val ); // bump the ref count
as_arraylist_append(&arglist, (as_val *)val);
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSET_PACKAGE, LDT_SET_OP_GET,
(as_list *)&arglist, pp_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (! *pp_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
return err->code;
} // aerospike_lset_get()
int
main(int argc, char* argv[])
{
aerospike as;
as_error err;
as_boolean ldt_exists;
as_ldt lstack, lstack2;
as_integer ival;
as_string sval;
as_bytes bval;
uint32_t n_elements, cap_size;
as_arraylist_iterator it;
as_list* p_list = NULL;
// Parse command line arguments.
if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) {
exit(-1);
}
// Connect to the aerospike database cluster.
example_connect_to_aerospike(&as);
// Start clean.
example_remove_test_record(&as);
// Create a large stack object to use. No need to destroy lstack if using
// as_ldt_init() on stack object.
as_ldt_init(&lstack, "mystack", AS_LDT_LSTACK, NULL);
// Verify that the LDT is not already there.
as_boolean_init(&ldt_exists, false);
assert (aerospike_lstack_ldt_exists(&as, &err, NULL, &g_key, &lstack, &ldt_exists) == AEROSPIKE_OK);
assert (as_boolean_get(&ldt_exists) == false);
LOG("verified that lstack ldt is not present");
// Push a few values onto the stack.
// No need to destroy sval if using as_string_init() on stack object.
// Push an integer
as_integer_init(&ival, 123);
assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&ival) == AEROSPIKE_OK);
// Push a string
as_string_init(&sval, "string stack value", false);
assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&sval) == AEROSPIKE_OK);
// Push bytes
uint8_t buf[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
as_bytes_init_wrap(&bval, buf, 16, false);
assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&bval) == AEROSPIKE_OK);
// Look at the stack size right now.
assert (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) == AEROSPIKE_OK);
LOG("%d values pushed", n_elements);
// Peek a few values back.
as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL);
assert (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, 3, &p_list) == AEROSPIKE_OK);
// See if the elements match what we expect.
as_arraylist_iterator_init(&it, (const as_arraylist*)p_list);
while (as_arraylist_iterator_has_next(&it)) {
const as_val* p_val = as_arraylist_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
as_list_destroy(p_list);
p_list = NULL;
// Push 3 more items onto the stack. By using as_arraylist_inita() we avoid
// some but not all internal heap usage, so we must call
// as_arraylist_destroy().
as_arraylist vals;
as_arraylist_inita(&vals, 3);
as_arraylist_append_int64(&vals, 1000);
as_arraylist_append_int64(&vals, 2000);
as_arraylist_append_int64(&vals, 3000);
assert (aerospike_lstack_push_all(&as, &err, NULL, &g_key, &lstack, (const as_list*)&vals) == AEROSPIKE_OK);
as_arraylist_destroy(&vals);
LOG("3 more values pushed");
// Peek all the values back again.
as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL);
assert (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, 10, &p_list) == AEROSPIKE_OK);
// See if the elements match what we expect.
#if 0
as_arraylist_iterator_init(&it, (const as_arraylist*)p_list);
while (as_arraylist_iterator_has_next(&it)) {
const as_val* p_val = as_arraylist_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
#else
const as_arraylist* p_array = (const as_arraylist*)p_list;
int i;
for (i = 0; i < p_array->size; i++) {
const as_val* p_val = p_array->elements[i];
char* p_str = as_val_tostring(p_val);
LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
#endif
as_list_destroy(p_list);
p_list = NULL;
// Set capacity for the lstack.
assert (aerospike_lstack_set_capacity(&as, &err, NULL, &g_key, &lstack, 10000) == AEROSPIKE_OK);
// Get capacity from the lstack.
assert (aerospike_lstack_get_capacity(&as, &err, NULL, &g_key, &lstack, &cap_size) == AEROSPIKE_OK);
assert (cap_size == 10000);
// Verify that the LDT is now present.
as_boolean_init(&ldt_exists, false);
assert (aerospike_lstack_ldt_exists(&as, &err, NULL, &g_key, &lstack, &ldt_exists) == AEROSPIKE_OK);
assert (as_boolean_get(&ldt_exists) == true);
LOG("verified that lstack ldt is present");
// Destroy the lstack.
assert (aerospike_lstack_destroy(&as, &err, NULL, &g_key, &lstack) == AEROSPIKE_OK);
// See if we can still do any lstack operations.
assert (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) != AEROSPIKE_OK);
// Cleanup and disconnect from the database cluster.
example_cleanup(&as);
LOG("lstack example successfully completed");
return 0;
}
as_status aerospike_llist_filter(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt,
const as_udf_function_name filter, const as_list *filter_args,
as_list ** elements )
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (filter_args && !filter) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"filter arguments without filter name specification");
}
if (!as || !key || !ldt || !elements) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/peek_count/elements cannot be null");
}
if (ldt->type != AS_LDT_LLIST) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not llist type");
}
int list_argc = filter ? 3 : 1;
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, list_argc);
as_arraylist_append_string(&arglist, &ldt_bin);
if (filter){
as_string filter_name;
as_string_init(&filter_name, (char *)filter, false);
as_arraylist_append_string(&arglist, &filter_name );
as_val_reserve( filter_args ); // bump the ref count
as_arraylist_append(&arglist, (as_val *) filter_args );
}
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LLIST_PACKAGE, filter ? LDT_LIST_OP_FILTER : LDT_LIST_OP_SCAN,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
*elements = (as_list *)p_return_val;
return err->code;
} // aerospike_llist_filter()
int
main(int argc, char* argv[])
{
// Parse command line arguments.
if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) {
exit(-1);
}
// Connect to the aerospike database cluster.
aerospike as;
example_connect_to_aerospike(&as);
// Start clean.
example_remove_test_record(&as);
as_ldt lstack;
// Create a large stack bin to use. No need to destroy as_ldt if using
// as_ldt_init() on stack object.
if (! as_ldt_init(&lstack, "mystack", AS_LDT_LSTACK, NULL)) {
LOG("unable to initialize ldt");
example_cleanup(&as);
exit(-1);
}
as_error err;
// No need to destroy as_integer if using as_integer_init() on stack object.
as_integer ival;
as_integer_init(&ival, 123);
// Push a few values onto the stack.
if (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack,
(const as_val*)&ival) != AEROSPIKE_OK) {
LOG("first aerospike_lstack_push() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
// No need to destroy as_string if using as_string_init() on stack object.
as_string sval;
as_string_init(&sval, "string stack value", false);
if (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack,
(const as_val*)&sval) != AEROSPIKE_OK) {
LOG("second aerospike_lstack_push() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
LOG("2 values pushed");
uint32_t n_elements = 0;
// Look at the stack size right now.
if (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) !=
AEROSPIKE_OK) {
LOG("aerospike_lstack_size() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
if (n_elements != 2) {
LOG("unexpected stack size %u", n_elements);
example_cleanup(&as);
exit(-1);
}
LOG("stack size confirmed to be %u", n_elements);
as_ldt lstack2;
as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL);
uint32_t peek_count = 3;
as_list* p_list = NULL;
// Peek a few values back.
if (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, peek_count,
&p_list) != AEROSPIKE_OK) {
LOG("first aerospike_lstack_peek() returned %d - %s", err.code,
err.message);
as_list_destroy(p_list);
example_cleanup(&as);
exit(-1);
}
as_arraylist_iterator it;
as_arraylist_iterator_init(&it, (const as_arraylist*)p_list);
// See if the elements match what we expect.
while (as_arraylist_iterator_has_next(&it)) {
const as_val* p_val = as_arraylist_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
as_list_destroy(p_list);
p_list = NULL;
// Push 3 more items onto the stack. By using as_arraylist_inita() we avoid
// some but not all internal heap usage, so we must call
// as_arraylist_destroy().
as_arraylist vals;
as_arraylist_inita(&vals, 3);
as_arraylist_append_int64(&vals, 1000);
as_arraylist_append_int64(&vals, 2000);
as_arraylist_append_int64(&vals, 3000);
if (aerospike_lstack_push_all(&as, &err, NULL, &g_key, &lstack,
(const as_list*)&vals) != AEROSPIKE_OK) {
LOG("aerospike_lstack_pushall() returned %d - %s", err.code,
err.message);
as_arraylist_destroy(&vals);
example_cleanup(&as);
exit(-1);
}
as_arraylist_destroy(&vals);
LOG("3 more values pushed");
as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL);
peek_count = 10;
// Peek all the values back again.
if (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, peek_count,
&p_list) != AEROSPIKE_OK) {
LOG("second aerospike_lstack_peek() returned %d - %s", err.code,
err.message);
as_list_destroy(p_list);
example_cleanup(&as);
exit(-1);
}
// See if the elements match what we expect.
as_arraylist_iterator_init(&it, (const as_arraylist*)p_list);
while (as_arraylist_iterator_has_next(&it)) {
const as_val* p_val = as_arraylist_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
as_list_destroy(p_list);
// Set capacity for the lstack.
if (aerospike_lstack_set_capacity(&as, &err, NULL, &g_key, &lstack,
10000) != AEROSPIKE_OK) {
LOG("aerospike_lstack_set_capacity() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
uint32_t cap_size = 0;
// Get capacity from the lstack.
if (aerospike_lstack_get_capacity(&as, &err, NULL, &g_key, &lstack,
&cap_size) != AEROSPIKE_OK) {
LOG("aerospike_lstack_get_capacity() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
if (cap_size != 10000) {
LOG("unexpected capacity size %u", cap_size);
example_cleanup(&as);
exit(-1);
}
// Destroy the lstack.
if (aerospike_lstack_destroy(&as, &err, NULL, &g_key, &lstack) !=
AEROSPIKE_OK) {
LOG("aerospike_lstack_destroy() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
n_elements = 0;
// See if we can still do any lstack operations.
if (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) ==
AEROSPIKE_OK) {
LOG("aerospike_lstack_size() did not return error");
example_cleanup(&as);
exit(-1);
}
// Cleanup and disconnect from the database cluster.
example_cleanup(&as);
LOG("lstack example successfully completed");
return 0;
}
bool as_operations_add_list_append_strp(as_operations *ops, const as_bin_name name, const char *value, bool free)
{
as_string v;
as_string_init(&v, (char *)value, free);
return AS_OPERATIONS_CDT_OP(ops, name, AS_CDT_OP_LIST_APPEND, &v);
}
static void initialize_bin_for_strictypes(AerospikeClient *self, as_error *err, PyObject *py_value, as_binop *binop, char *bin, as_static_pool *static_pool) {
as_bin *binop_bin = &binop->bin;
if (PyInt_Check(py_value)) {
int val = PyInt_AsLong(py_value);
as_integer_init((as_integer *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else if (PyLong_Check(py_value)) {
long val = PyLong_AsLong(py_value);
as_integer_init((as_integer *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else if (PyString_Check(py_value)) {
char * val = PyString_AsString(py_value);
as_string_init((as_string *) &binop_bin->value, val, false);
binop_bin->valuep = &binop_bin->value;
} else if (PyUnicode_Check(py_value)) {
PyObject *py_ustr1 = PyUnicode_AsUTF8String(py_value);
char * val = PyString_AsString(py_ustr1);
as_string_init((as_string *) &binop_bin->value, val, false);
binop_bin->valuep = &binop_bin->value;
} else if (PyFloat_Check(py_value)) {
int64_t val = PyFloat_AsDouble(py_value);
if (aerospike_has_double(self->as)) {
as_double_init((as_double *) &binop_bin->value, val);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
} else if (PyList_Check(py_value)) {
as_list * list = NULL;
pyobject_to_list(self, err, py_value, &list, static_pool, SERIALIZER_PYTHON);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) list;
} else if (PyDict_Check(py_value)) {
as_map * map = NULL;
pyobject_to_map(self, err, py_value, &map, static_pool, SERIALIZER_PYTHON);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) map;
} else if (!strcmp(py_value->ob_type->tp_name, "aerospike.Geospatial")) {
PyObject* py_data = PyObject_GenericGetAttr(py_value, PyString_FromString("geo_data"));
char *geo_value = PyString_AsString(AerospikeGeospatial_DoDumps(py_data, err));
if (aerospike_has_geo(self->as)) {
as_geojson_init((as_geojson *) &binop_bin->value, geo_value, false);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_data, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
} else if (!strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) &as_nil;
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_bytes_init_wrap((as_bytes *) &binop_bin->value, bytes->value, bytes->size, false);
binop_bin->valuep = &binop_bin->value;
} else {
as_bytes *bytes;
GET_BYTES_POOL(bytes, static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
((as_val *) &binop_bin->value)->type = AS_UNKNOWN;
binop_bin->valuep = (as_bin_value *) bytes;
}
strcpy(binop_bin->name, bin);
}
/**
* Lookup a record by key, then apply the UDF.
*
* ~~~~~~~~~~{.c}
* as_key key;
* as_key_init(&key, "ns", "set", "key");
*
* as_arraylist args;
* as_arraylist_init(&args, 2, 0);
* as_arraylist_append_int64(&args, 1);
* as_arraylist_append_int64(&args, 2);
*
* as_val * res = NULL;
*
* if ( aerospike_key_apply(&as, &err, NULL, &key, "math", "add", &args, &res) != AEROSPIKE_OK ) {
* fprintf(stderr, "error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
* }
* else {
* as_val_destroy(res);
* }
*
* as_arraylist_destroy(&args);
* ~~~~~~~~~~
*
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param key The key of the record.
* @param module The module containing the function to execute.
* @param function The function to execute.
* @param arglist The arguments for the function.
* @param result The return value from the function.
*
* @return AEROSPIKE_OK if successful. Otherwise an error.
*/
as_status aerospike_key_apply(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key,
const char * module, const char * function, as_list * arglist,
as_val ** result)
{
// we want to reset the error so, we have a clean state
as_error_reset(err);
// resolve policies
as_policy_apply p;
as_policy_apply_resolve(&p, &as->config.policies, policy);
cl_write_parameters wp;
cl_write_parameters_set_default(&wp);
wp.timeout_ms = p.timeout == UINT32_MAX ? 0 : p.timeout;
cl_object okey;
asval_to_clobject((as_val *) key->valuep, &okey);
as_serializer ser;
as_msgpack_init(&ser);
as_string file;
as_string_init(&file, (char *) module, true /*ismalloc*/);
as_string func;
as_string_init(&func, (char *) function, true /*ismalloc*/);
as_buffer args;
as_buffer_init(&args);
as_serializer_serialize(&ser, (as_val *) arglist, &args);
as_call call = {
.file = &file,
.func = &func,
.args = &args
};
uint64_t trid = 0;
cl_bin * bins = 0;
int n_bins = 0;
cl_rv rc = CITRUSLEAF_OK;
switch ( p.key ) {
case AS_POLICY_KEY_DIGEST: {
as_digest * digest = as_key_digest((as_key *) key);
rc = do_the_full_monte(
as->cluster, 0, CL_MSG_INFO2_WRITE, 0,
key->ns, key->set, 0, (cf_digest *) digest->value, &bins, CL_OP_WRITE, 0, &n_bins,
NULL, &wp, &trid, NULL, &call, NULL
);
break;
}
case AS_POLICY_KEY_SEND: {
cl_object okey;
asval_to_clobject((as_val *) key->valuep, &okey);
as_digest * digest = as_key_digest((as_key *) key);
rc = do_the_full_monte(
as->cluster, 0, CL_MSG_INFO2_WRITE, 0,
key->ns, key->set, &okey, (cf_digest*)digest->value, &bins, CL_OP_WRITE, 0, &n_bins,
NULL, &wp, &trid, NULL, &call, NULL
);
break;
}
default: {
// ERROR CASE
break;
}
}
as_buffer_destroy(&args);
if (! (rc == CITRUSLEAF_OK || rc == CITRUSLEAF_FAIL_UDF_BAD_RESPONSE)) {
as_error_fromrc(err, rc);
}
else {
// Begin processing the data returned from the server,
// IFF `result` argument is not NULL.
// The reason is if `result` is NULL, then it implies the end user
// does not care about the data returned from the server.
if ( n_bins == 1 ) {
cl_bin * bin = &bins[0];
if ( strcmp(bin->bin_name,"SUCCESS") == 0 ) {
if ( result ) {
as_val * val = NULL;
clbin_to_asval(bin, &ser, &val);
*result = val;
}
}
else if ( strcmp(bin->bin_name,"FAILURE") == 0 ) {
as_val * val = NULL;
clbin_to_asval(bin, &ser, &val);
if ( val->type == AS_STRING ) {
as_string * s = as_string_fromval(val);
as_error_update(err, AEROSPIKE_ERR_UDF, as_string_tostring(s));
}
else {
as_error_update(err, AEROSPIKE_ERR_SERVER, "unexpected failure bin type");
}
as_val_destroy(val);
}
else {
as_error_update(err, AEROSPIKE_ERR_SERVER, "unexpected bin name");
}
}
else {
as_error_update(err, AEROSPIKE_ERR_SERVER, "unexpected number of bins");
}
}
if ( bins ) {
citrusleaf_bins_free(bins, n_bins);
free(bins);
}
as_serializer_destroy(&ser);
return err->code;
}
int
main(int argc, char* argv[])
{
// Parse command line arguments.
if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) {
exit(-1);
}
// Connect to the aerospike database cluster.
aerospike as;
example_connect_to_aerospike(&as);
// Start clean.
example_remove_test_record(&as);
// Create a large map object to use. No need to destroy lmap if using
// as_ldt_init() on stack object.
as_ldt lmap;
if (! as_ldt_init(&lmap, "mylmap", AS_LDT_LMAP, NULL)) {
LOG("unable to initialize ldt");
example_cleanup(&as);
exit(-1);
}
as_error err;
as_boolean ldt_exists;
as_boolean_init(&ldt_exists, false);
// Verify that the LDT is not already there.
if (aerospike_lmap_ldt_exists(&as, &err, NULL, &g_key, &lmap,
&ldt_exists) != AEROSPIKE_OK) {
int rc = example_handle_udf_error(&err, "first aerospike_lmap_ldt_exists()");
example_cleanup(&as);
exit(rc);
}
if (as_boolean_get(&ldt_exists)) {
LOG("found ldt that should not be present");
example_cleanup(&as);
exit(-1);
}
LOG("verified that lmap ldt is not present");
// No need to destroy ikey if using as_integer_init() on stack object.
as_integer ikey;
as_integer_init(&ikey, 12345);
// No need to destroy sval if using as_string_init() on stack object with
// free parameter false.
as_string sval;
as_string_init(&sval, "lmap value", false);
// Put a string entry to the lmap.
if (aerospike_lmap_put(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, (as_val *)&sval) != AEROSPIKE_OK) {
LOG("first aerospike_lmap_put() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
// Ok to reuse.
as_integer_init(&ikey, 345);
as_integer ival;
as_integer_init(&ival, 1000);
// Put an integer entry to the lmap.
if (aerospike_lmap_put(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, (as_val*)&ival) != AEROSPIKE_OK) {
LOG("second aerospike_lmap_put() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
LOG("2 entries added to map");
uint32_t n_elements = 0;
// See how many elements we have in the lmap now.
if (aerospike_lmap_size(&as, &err, NULL, &g_key, &lmap, &n_elements) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_size() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
if (n_elements != 2) {
LOG("unexpected lmap size %u", n_elements);
example_cleanup(&as);
exit(-1);
}
LOG("lmap size confirmed to be %u", n_elements);
as_boolean_init(&ldt_exists, false);
// Verify that the LDT is now present.
if (aerospike_lmap_ldt_exists(&as, &err, NULL, &g_key, &lmap,
&ldt_exists) != AEROSPIKE_OK) {
LOG("first aerospike_lmap_ldt_exists() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
if (! as_boolean_get(&ldt_exists)) {
LOG("did not find ldt that should be be present");
example_cleanup(&as);
exit(-1);
}
LOG("verified that lmap ldt is present");
as_map* p_map = NULL;
// Get all the entries back.
if (aerospike_lmap_get_all(&as, &err, NULL, &g_key, &lmap, &p_map) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_filter() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
as_hashmap_iterator it;
as_hashmap_iterator_init(&it, (const as_hashmap*)p_map);
// See if the elements match what we expect.
while (as_hashmap_iterator_has_next(&it)) {
const as_val* p_val = as_hashmap_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" element type %d, value %s", as_val_type(p_val), p_str);
free(p_str);
}
as_map_destroy(p_map);
p_map = NULL;
as_integer_init(&ikey, 12345);
// Remove an entry from the map.
if (aerospike_lmap_remove(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey) != AEROSPIKE_OK) {
LOG("aerospike_lmap_remove() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
as_val* p_val = NULL;
// Make sure we can't get the value any more.
as_status result = aerospike_lmap_get(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, &p_val);
if (result == AEROSPIKE_OK) {
// Server version >= 3.4.1 returns empty map if element doesn't exist.
if (p_val && (as_val_type(p_val) != AS_MAP ||
as_map_size((as_map*)p_val) != 0)) {
char* p_str = as_val_tostring(p_val);
LOG("entry was not successfully removed");
LOG(" element type %d, value %s", as_val_type(p_val), p_str);
free(p_str);
as_val_destroy(p_val);
example_cleanup(&as);
exit(-1);
}
}
else if (result != AEROSPIKE_ERR_LARGE_ITEM_NOT_FOUND) {
LOG("aerospike_lmap_get() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
LOG("entry successfully removed");
// Destroy the lmap.
if (aerospike_lmap_destroy(&as, &err, NULL, &g_key, &lmap) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_destroy() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
n_elements = 0;
// See if we can still do any lmap operations.
if (aerospike_lmap_size(&as, &err, NULL, &g_key, &lmap, &n_elements) ==
AEROSPIKE_OK) {
LOG("aerospike_lmap_size() did not return error");
example_cleanup(&as);
exit(-1);
}
LOG("lmap successfully destroyed");
// Cleanup and disconnect from the database cluster.
example_cleanup(&as);
LOG("lmap example successfully completed");
return 0;
}
int
main(int argc, char* argv[])
{
// Parse command line arguments.
if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) {
exit(-1);
}
// Connect to the aerospike database cluster.
aerospike as;
example_connect_to_aerospike(&as);
// Start clean.
example_remove_test_record(&as);
as_ldt lmap;
// Create a lmap bin to use. No need to destroy as_ldt if using
// as_ldt_init() on stack object.
if (! as_ldt_init(&lmap, "mylmap", AS_LDT_LMAP, NULL)) {
LOG("unable to initialize ldt");
example_cleanup(&as);
exit(-1);
}
as_error err;
// No need to destroy as_integer if using as_integer_init() on stack object.
as_integer ikey;
as_integer_init(&ikey, 12345);
// No need to destroy as_string if using as_string_init() on stack object
// with free parameter false.
as_string sval;
as_string_init(&sval, "lmap value", false);
// Put a string entry to the lmap.
if (aerospike_lmap_put(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, (as_val *)&sval) != AEROSPIKE_OK) {
LOG("first aerospike_lmap_put() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
as_integer ival;
as_integer_init(&ival, 1000);
// It's ok to reset the as_integer.
as_integer_init(&ikey, 345);
// Put an integer entry to the lmap.
if (aerospike_lmap_put(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, (as_val*)&ival) != AEROSPIKE_OK) {
LOG("second aerospike_lmap_put() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
LOG("2 entries added to map");
uint32_t n_elements = 0;
// See how many elements we have in the lmap now.
if (aerospike_lmap_size(&as, &err, NULL, &g_key, &lmap, &n_elements) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_size() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
if (n_elements != 2) {
LOG("unexpected lmap size %u", n_elements);
example_cleanup(&as);
exit(-1);
}
LOG("lmap size confirmed to be %u", n_elements);
as_ldt lmap2;
as_ldt_init(&lmap2, "mylmap", AS_LDT_LMAP, NULL);
as_map* p_map = NULL;
// Get all the entries back.
if (aerospike_lmap_get_all(&as, &err, NULL, &g_key, &lmap, &p_map) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_filter() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
// See if the elements match what we expect.
as_hashmap_iterator it;
as_hashmap_iterator_init(&it, (const as_hashmap*)p_map);
while (as_hashmap_iterator_has_next(&it)) {
const as_val* p_val = as_hashmap_iterator_next(&it);
char* p_str = as_val_tostring(p_val);
LOG(" element - type = %d, value = %s", as_val_type(p_val), p_str);
free(p_str);
}
as_map_destroy(p_map);
p_map = NULL;
as_integer_init(&ikey, 345);
as_integer_init(&ival, 2000);
// Remove an entry from the map.
as_integer_init(&ikey, 12345);
if (aerospike_lmap_remove(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey) != AEROSPIKE_OK) {
LOG("aerospike_lmap_remove() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
as_val* p_val = NULL;
// Make sure we cannot get the value any more.
if (aerospike_lmap_get(&as, &err, NULL, &g_key, &lmap,
(const as_val*)&ikey, &p_val) == AEROSPIKE_OK) {
LOG("unexpected success getting a removed entry");
as_val_destroy(p_val);
example_cleanup(&as);
exit(-1);
}
LOG("entry successfully removed");
// Destroy the lmap.
if (aerospike_lmap_destroy(&as, &err, NULL, &g_key, &lmap) !=
AEROSPIKE_OK) {
LOG("aerospike_lmap_destroy() returned %d - %s", err.code, err.message);
example_cleanup(&as);
exit(-1);
}
n_elements = 0;
// See if we can still do any lmap operations.
if (aerospike_lmap_size(&as, &err, NULL, &g_key, &lmap, &n_elements) ==
AEROSPIKE_OK) {
LOG("aerospike_lmap_size() did not return error");
example_cleanup(&as);
exit(-1);
}
LOG("lmap successfully destroyed");
// Cleanup and disconnect from the database cluster.
example_cleanup(&as);
LOG("lmap example successfully completed");
return 0;
}
bool as_operations_add_list_set_strp(as_operations *ops, const as_bin_name name, int64_t index, const char *value, bool free)
{
as_string v;
as_string_init(&v, (char *)value, free);
return AS_OPERATIONS_CDT_OP(ops, name, AS_CDT_OP_LIST_SET, index, &v);
}