bool batch_get_1_callback(const as_batch_read * results, uint32_t n, void * udata)
{
batch_read_data * data = (batch_read_data *) udata;
data->total = n;
for (uint32_t i = 0; i < n; i++) {
if (results[i].result == AEROSPIKE_OK) {
data->found++;
int64_t key = as_integer_getorelse((as_integer *) results[i].key->valuep, -1);
int64_t val = as_record_get_int64(&results[i].record, "val", -1);
if ( key != val ) {
warn("key(%d) != val(%d)",key,val);
data->errors++;
data->last_error = -2;
}
}
else if (results[i].result != AEROSPIKE_ERR_RECORD_NOT_FOUND) {
data->errors++;
data->last_error = results[i].result;
warn("batch callback thread(%d) error(%d)", data->thread_id, data->last_error);
}
}
info("total: %d, found: %d, errors: %d", data->total, data->found, data->errors);
return true;
}
bool
batch_read_cb(const as_batch_read* results, uint32_t n, void* udata)
{
LOG("batch read callback returned %u/%u record results:", n, g_n_keys);
uint32_t n_found = 0;
uint32_t i;
for (i = 0; i < n; i++) {
LOG("index %u, key %" PRId64 ":", i,
as_integer_getorelse((as_integer*)results[i].key->valuep, -1));
if (results[i].result == AEROSPIKE_OK) {
LOG(" AEROSPIKE_OK");
// For aerospike_batch_exists() calls, there should be record
// metadata but no bins.
example_dump_record(&results[i].record);
n_found++;
}
else if (results[i].result == AEROSPIKE_ERR_RECORD_NOT_FOUND) {
// The transaction succeeded but the record doesn't exist.
LOG(" AEROSPIKE_ERR_RECORD_NOT_FOUND");
}
else {
// The transaction didn't succeed.
LOG(" error %d", results[i].result);
}
}
LOG("... found %u/%u records", n_found, n);
return true;
}
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()
static bool batch_sequence_callback(as_key* key, as_record* record, void* udata)
{
batch_read_data* data = (batch_read_data*)udata;
data->total++;
data->found++;
int64_t k = as_integer_getorelse((as_integer *)key->valuep, -1);
int64_t v = as_record_get_int64(record, "val", -1);
if (k != v) {
warn("key(%d) != val(%d)", k, v);
data->errors++;
data->last_error = -2;
}
return true;
}
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);
// Register the UDF in the database cluster.
if (! example_register_udf(&as, UDF_FILE_PATH)) {
example_cleanup(&as);
exit(-1);
}
// Write a record to the database.
if (! write_record(&as)) {
cleanup(&as);
exit(-1);
}
as_error err;
// Apply a simple UDF, with no arguments and no return value.
if (aerospike_key_apply(&as, &err, NULL, &g_key, UDF_MODULE,
"test_bin_1_add_1000", NULL, NULL) != AEROSPIKE_OK) {
LOG("aerospike_key_apply() returned %d - %s", err.code, err.message);
cleanup(&as);
exit(-1);
}
LOG("test_bin_1_add_1000() was successfully applied");
if (! example_read_test_record(&as)) {
example_cleanup(&as);
exit(-1);
}
// Create an argument list for a (different) UDF. By using
// as_arraylist_inita() we avoid some but not all internal heap usage, so we
// must call as_arraylist_destroy().
as_arraylist args;
as_arraylist_inita(&args, 3);
as_arraylist_append_str(&args, "test-bin-2");
as_arraylist_append_int64(&args, 4);
as_arraylist_append_int64(&args, 400);
// Expect an integer return value.
as_val* p_return_val = NULL;
// Apply a UDF with arguments and a return value.
if (aerospike_key_apply(&as, &err, NULL, &g_key, UDF_MODULE,
"bin_transform", (as_list*)&args, &p_return_val) != AEROSPIKE_OK) {
LOG("aerospike_key_apply() returned %d - %s", err.code, err.message);
as_arraylist_destroy(&args);
cleanup(&as);
exit(-1);
}
as_arraylist_destroy(&args);
if (! p_return_val) {
LOG("aerospike_key_apply() retrieved null as_val object");
cleanup(&as);
exit(-1);
}
// Extract an integer from the as_val returned.
int64_t i_val = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
// Caller's responsibility to destroy as_val returned.
as_val_destroy(p_return_val);
if (i_val == -1) {
LOG("aerospike_key_apply() retrieved non-as_integer object");
cleanup(&as);
exit(-1);
}
LOG("bin_transform() was successfully applied - returned %" PRId64, i_val);
if (! example_read_test_record(&as)) {
example_cleanup(&as);
exit(-1);
}
// Cleanup and disconnect from the database cluster.
cleanup(&as);
LOG("udf example successfully completed");
return 0;
}
