/**
* Initialize a stack allocated `as_key` to a int64_t value.
*/
as_key * as_key_init_int64(as_key * key, const as_namespace ns, const as_set set, int64_t value)
{
if ( !key ) return key;
as_integer_init((as_integer *) &key->value, value);
return as_key_cons(key, false, ns, set, &key->value, NULL);
}
/**
* Initialize a stack allocated `as_key` to a int64_t value.
*/
as_key * as_key_new_int64(const as_namespace ns, const as_set set, int64_t value)
{
as_key * key = (as_key *) malloc(sizeof(as_key));
if ( !key ) return key;
as_integer_init((as_integer *) &key->value, value);
return as_key_cons(key, true, ns, set, &key->value, NULL);
}
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;
}
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;
}
uint8_t*
as_command_parse_bins(as_record* rec, uint8_t* p, uint32_t n_bins, bool deserialize)
{
as_bin* bin = rec->bins.entries;
// Parse bins
for (uint32_t i = 0; i < n_bins; i++, bin++) {
uint32_t op_size = cf_swap_from_be32(*(uint32_t*)p);
p += 5;
uint8_t type = *p;
p += 2;
uint8_t name_size = *p++;
uint8_t name_len = (name_size <= AS_BIN_NAME_MAX_LEN)? name_size : AS_BIN_NAME_MAX_LEN;
memcpy(bin->name, p, name_len);
bin->name[name_len] = 0;
p += name_size;
uint32_t value_size = (op_size - (name_size + 4));
switch (type) {
case AS_BYTES_UNDEF: {
bin->valuep = (as_bin_value*)&as_nil;
break;
}
case AS_BYTES_INTEGER: {
int64_t value;
if (as_command_bytes_to_int(p, value_size, &value) == 0) {
as_integer_init((as_integer*)&bin->value, value);
bin->valuep = &bin->value;
}
break;
}
case AS_BYTES_DOUBLE: {
double value = cf_swap_from_big_float64(*(double*)p);
as_double_init((as_double*)&bin->value, value);
bin->valuep = &bin->value;
break;
}
case AS_BYTES_STRING: {
char* value = malloc(value_size + 1);
memcpy(value, p, value_size);
value[value_size] = 0;
as_string_init_wlen((as_string*)&bin->value, (char*)value, value_size, true);
bin->valuep = &bin->value;
break;
}
case AS_BYTES_LIST:
case AS_BYTES_MAP: {
if (deserialize) {
as_val* value = 0;
as_buffer buffer;
buffer.data = p;
buffer.size = value_size;
as_serializer ser;
as_msgpack_init(&ser);
as_serializer_deserialize(&ser, &buffer, &value);
as_serializer_destroy(&ser);
bin->valuep = (as_bin_value*)value;
}
else {
void* value = malloc(value_size);
memcpy(value, p, value_size);
as_bytes_init_wrap((as_bytes*)&bin->value, value, value_size, true);
bin->value.bytes.type = (as_bytes_type)type;
bin->valuep = &bin->value;
}
break;
}
default: {
void* value = malloc(value_size);
memcpy(value, p, value_size);
as_bytes_init_wrap((as_bytes*)&bin->value, value, value_size, true);
bin->value.bytes.type = (as_bytes_type)type;
bin->valuep = &bin->value;
break;
}
}
rec->bins.size++;
p += value_size;
}
return p;
}
uint8_t*
as_command_parse_key(uint8_t* p, uint32_t n_fields, as_key* key)
{
uint32_t len;
uint32_t size;
for (uint32_t i = 0; i < n_fields; i++) {
len = cf_swap_from_be32(*(uint32_t*)p) - 1;
p += 4;
switch (*p++) {
case AS_FIELD_DIGEST:
size = (len < AS_DIGEST_VALUE_SIZE) ? len : AS_DIGEST_VALUE_SIZE;
key->digest.init = true;
memcpy(key->digest.value, p, size);
break;
case AS_FIELD_NAMESPACE:
size = (len < (AS_NAMESPACE_MAX_SIZE-1)) ? len : (AS_NAMESPACE_MAX_SIZE-1);
memcpy(key->ns, p, size);
key->ns[size] = 0;
break;
case AS_FIELD_SETNAME:
size = (len < (AS_SET_MAX_SIZE-1)) ? len : (AS_SET_MAX_SIZE-1);
memcpy(key->set, p, size);
key->set[size] = 0;
break;
case AS_FIELD_KEY:
len--;
uint8_t type = *p++;
switch (type) {
case AS_BYTES_INTEGER: {
int64_t value;
if (as_command_bytes_to_int(p, len, &value) == 0) {
as_integer_init((as_integer*)&key->value, value);
key->valuep = &key->value;
}
break;
}
case AS_BYTES_DOUBLE: {
double value = cf_swap_from_big_float64(*(double*)p);
as_double_init((as_double*)&key->value, value);
key->valuep = &key->value;
break;
}
case AS_BYTES_STRING: {
char* value = malloc(len+1);
memcpy(value, p, len);
value[len] = 0;
as_string_init_wlen((as_string*)&key->value, value, len, true);
key->valuep = &key->value;
break;
}
case AS_BYTES_BLOB: {
void* value = malloc(len);
memcpy(value, p, len);
as_bytes_init_wrap((as_bytes*)&key->value, (uint8_t*)value, len, true);
key->valuep = &key->value;
break;
}
default: {
as_log_error("Invalid key type: %d", type);
break;
}
}
break;
}
p += len;
}
return p;
}
bool as_operations_add_list_set_int64(as_operations *ops, const as_bin_name name, int64_t index, int64_t value)
{
as_integer v;
as_integer_init(&v, value);
return AS_OPERATIONS_CDT_OP(ops, name, AS_CDT_OP_LIST_SET, index, &v);
}
bool as_operations_add_list_append_int64(as_operations *ops, const as_bin_name name, int64_t value)
{
as_integer v;
as_integer_init(&v, value);
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);
}
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;
}
/*
*******************************************************************************************************
* Wrapper function to perform an aerospike_key_oeprate within the C client.
*
* @param as_object_p The C client's aerospike object.
* @param as_key_p The C client's as_key that identifies the record.
* @param options_p The user's optional policy options to be used if set, else defaults.
* @param error_p The as_error to be populated by the function
* with the encountered error if any.
* @param bin_name_p The bin name to perform operation upon.
* @param str The string to be appended in case of operation: append.
* @param offset The offset to be incremented by in case of operation: increment.
* @param initial_value The initial value to be set if record is absent
* in case of operation: increment.
* @param time_to_live The ttl for the record in case of operation: touch.
* @param operation The operation type.
*
*******************************************************************************************************
*/
extern as_status
aerospike_record_operations_ops(aerospike* as_object_p,
as_key* as_key_p,
zval* options_p,
as_error* error_p,
int8_t* bin_name_p,
int8_t* str,
u_int64_t offset,
u_int64_t initial_value,
u_int64_t time_to_live,
u_int64_t operation)
{
as_status status = AEROSPIKE_OK;
as_policy_operate operate_policy;
uint32_t serializer_policy;
as_record* get_rec = NULL;
as_operations ops;
as_val* value_p = NULL;
as_integer initial_int_val;
int16_t initialize_int = 0;
const char *select[] = {bin_name_p, NULL};
as_operations_inita(&ops, 1);
as_policy_operate_init(&operate_policy);
if ((!as_object_p) || (!error_p) || (!as_key_p)) {
status = AEROSPIKE_ERR;
goto exit;
}
set_policy(NULL, NULL, &operate_policy, NULL, NULL, &serializer_policy,
options_p, error_p);
if (AEROSPIKE_OK != (status = (error_p->code))) {
DEBUG_PHP_EXT_DEBUG("Unable to set policy");
goto exit;
}
switch(operation) {
case AS_OPERATOR_APPEND:
as_operations_add_append_str(&ops, bin_name_p, str);
break;
case AS_OPERATOR_PREPEND:
as_operations_add_prepend_str(&ops, bin_name_p, str);
break;
case AS_OPERATOR_INCR:
if (AEROSPIKE_OK != (status = aerospike_key_select(as_object_p,
error_p, NULL, as_key_p, select, &get_rec))) {
goto exit;
} else {
if (NULL != (value_p = (as_val *) as_record_get (get_rec, bin_name_p))) {
if (AS_NIL == value_p->type) {
as_integer_init(&initial_int_val, initial_value);
initialize_int = 1;
if (!as_operations_add_write(&ops, bin_name_p,
(as_bin_value*) &initial_int_val)) {
status = AEROSPIKE_ERR;
goto exit;
}
} else {
as_operations_add_incr(&ops, bin_name_p, offset);
}
} else {
status = AEROSPIKE_ERR;
goto exit;
}
}
break;
case AS_OPERATOR_TOUCH:
ops.ttl = time_to_live;
as_operations_add_touch(&ops);
break;
default:
status = AEROSPIKE_ERR;
goto exit;
break;
}
if (AEROSPIKE_OK != (status = aerospike_key_operate(as_object_p, error_p,
&operate_policy, as_key_p, &ops, &get_rec))) {
goto exit;
}
exit:
as_operations_destroy(&ops);
if (get_rec) {
as_record_destroy(get_rec);
}
if (initialize_int) {
as_integer_destroy(&initial_int_val);
}
return status;
}
