bool
insert_records(aerospike* p_as)
{
// Create an as_record object with one (integer value) bin. By using
// as_record_inita(), we won't need to destroy the record if we only set
// bins using as_record_set_int64().
as_record rec;
as_record_inita(&rec, 1);
// Re-using rec, write records into the database such that each record's key
// and (test-bin) value is based on the loop index.
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
// In general it's ok to reset a bin value - all as_record_set_... calls
// destroy any previous value.
as_record_set_int64(&rec, "test-bin", (int64_t)i);
// Write a record to the database.
if (aerospike_key_put(p_as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
LOG("aerospike_key_put() returned %d - %s", err.code, err.message);
return false;
}
}
LOG("insert succeeded");
return true;
}
bool
insert_records(aerospike* p_as)
{
// Create an as_record object with up to three integer value bins. By using
// as_record_inita(), we won't need to destroy the record if we only set
// bins using as_record_set_int64().
as_record rec;
as_record_inita(&rec, 3);
// Re-using rec, write records into the database such that each record's key
// and (test-bin) value is based on the loop index.
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// Set up a default as_policy_write object.
as_policy_write wpol;
as_policy_write_init(&wpol);
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
// In general it's ok to reset a bin value - all as_record_set_... calls
// destroy any previous value.
if (i < 10) {
// Only write one bin in the first ten records.
as_record_set_int64(&rec, "test-bin-1", (int64_t)i);
// By default, we don't store the key with the record in the
// database. For these records, the key will not be returned in the
// scan callback.
}
else {
// Write three bins in all remaining records.
as_record_set_int64(&rec, "test-bin-1", (int64_t)i);
as_record_set_int64(&rec, "test-bin-2", (int64_t)(100 + i));
as_record_set_int64(&rec, "test-bin-3", (int64_t)(1000 + i));
// If we want the key to be returned in the scan callback, we must
// store it with the record in the database. AS_POLICY_KEY_SEND
// causes the key to be stored.
wpol.key = AS_POLICY_KEY_SEND;
}
// Write a record to the database.
if (aerospike_key_put(p_as, &err, &wpol, &key, &rec) != AEROSPIKE_OK) {
LOG("aerospike_key_put() returned %d - %s", err.code, err.message);
return false;
}
}
LOG("insert succeeded");
return true;
}
/*
* call-seq:
* new(namespace, set, value) -> AerospikeNative::Key
* new(namespace, set, value, digest) -> AerospikeNative::Key
*
* initialize new key
*/
VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
{
VALUE vNamespace, vSet, vValue, vDigest = Qnil;
as_key *ptr;
as_digest* digest = NULL;
if (argc > 4 || argc < 3) { // there should only be 3 or 4 arguments
rb_raise(rb_eArgError, "wrong number of arguments (%d for 3..4)", argc);
}
vNamespace = vArgs[0];
Check_Type(vNamespace, T_STRING);
vSet = vArgs[1];
Check_Type(vSet, T_STRING);
vValue = vArgs[2];
if (argc == 4) {
vDigest = vArgs[3];
}
Data_Get_Struct(vSelf, as_key, ptr);
if(TYPE(vValue) != T_NIL) {
switch(TYPE(vValue)) {
case T_FIXNUM:
as_key_init_int64(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), FIX2LONG( vValue ));
break;
case T_STRING:
as_key_init_str(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValueCStr( vValue ));
break;
default: {
VALUE vBytes = rb_funcall(vValue, rb_intern("to_msgpack"), 0);
as_key_init_raw(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValuePtr(vBytes), RSTRING_LEN(vBytes));
}
}
} else {
Check_Type(vValue, T_NIL);
Check_Type(vDigest, T_STRING);
as_key_init_digest(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValuePtr( vDigest ));
}
if (digest == NULL) {
digest = as_key_digest(ptr);
}
rb_iv_set(vSelf, "@namespace", vNamespace);
rb_iv_set(vSelf, "@set", vSet);
rb_iv_set(vSelf, "@value", vValue);
rb_iv_set(vSelf, "@digest", rb_str_new( digest->value, AS_DIGEST_VALUE_SIZE));
return vSelf;
}
/**
* @brief Test whether multiple records exist in the cluster.
*
* @param[in] argc The argc
* @param argv The argv
* @param[in] self The object
*
* @return { description_of_the_return_value }
*/
static VALUE batch_read(int argc, VALUE * argv, VALUE self) {
rb_aero_TIMED(tm);
as_error err;
as_status status;
aerospike * as = rb_aero_CLIENT;
VALUE keys;
VALUE options;
rb_scan_args(argc, argv, "11", &keys, &options);
long keys_len = rb_ary_len_long(keys);
as_batch batch;
as_batch_inita(&batch, keys_len);
VALUE return_data = rb_hash_new();
for (long i = 0; i < keys_len; ++i) {
VALUE element = rb_ary_entry(keys, i);
// set into hash for return values
rb_hash_aset(return_data, element, Qfalse);
VALUE tmp = rb_funcall(element, rb_intern("namespace"), 0);
char * c_namespace = StringValueCStr( tmp );
tmp = rb_funcall(element, rb_intern("set"), 0);
char * c_set = StringValueCStr( tmp );
tmp = rb_funcall(element, rb_intern("key"), 0);
if ( TYPE(tmp) != T_FIXNUM ) {
char * c_key = StringValueCStr( tmp );
as_key_init(as_batch_keyat(&batch,i), c_namespace, c_set, c_key);
}
else {
as_key_init_int64(as_batch_keyat(&batch,i), c_namespace, c_set, FIX2LONG(tmp));
}
}
if ( aerospike_batch_get(as, &err, NULL, &batch, batch_read_callback, return_data) != AEROSPIKE_OK ) {
as_batch_destroy(&batch);
raise_as_error(err);
}
as_batch_destroy(&batch);
rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 1, rb_str_new2("[Client][batch_read] success"));
return return_data;
}
//------------------------------------------------
// Remove multiple-record examples' test records
// from the database.
//
void
example_remove_test_records(aerospike* p_as)
{
// Multiple-record examples insert g_n_keys records, using integer keys from
// 0 to (g_n_keys - 1).
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
// Ignore errors - just trying to leave the database as we found it.
aerospike_key_remove(p_as, &err, NULL, &key);
}
}
bool
insert_records(aerospike* p_as)
{
srand((unsigned int)time(0));
// Create an as_record object with an integer value bin, and a string value
// bin, where the string is a list of comma-separated numbers. By using
// as_record_inita(), we won't need to destroy the record if we only set
// bins using as_record_set_int64() and as_record_set_str().
as_record rec;
as_record_inita(&rec, 2);
// Re-using rec, write records into the database such that each record's key
// and test-bin value is based on the loop index.
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
// In general it's ok to reset a bin value - all as_record_set_... calls
// destroy any previous value.
as_record_set_int64(&rec, "test-bin", (int64_t)i);
char numbers[(TOKENS_PER_BIN * 3) + 1];
as_record_set_str(&rec, "numbers-bin", generate_numbers(numbers));
// Write a record to the database.
if (aerospike_key_put(p_as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
LOG("aerospike_key_put() returned %d - %s", err.code, err.message);
return false;
}
}
LOG("insert succeeded");
return true;
}
void askey_from_clkey(as_key * key, const as_namespace ns, const as_set set, cl_object * clkey)
{
if (! (key && clkey)) {
return;
}
switch (clkey->type) {
case CL_NULL:
as_key_init_value(key, ns, set, NULL);
break;
case CL_INT:
as_key_init_int64(key, ns, set, clkey->u.i64);
break;
case CL_STR: {
// Must null-terminate here.
char* s = (char*)malloc(clkey->sz + 1);
memcpy(s, clkey->u.str, clkey->sz);
s[clkey->sz] = 0;
as_key_init_strp(key, ns, set, s, true);
break;
}
case CL_BLOB:
case CL_JAVA_BLOB:
case CL_CSHARP_BLOB:
case CL_PYTHON_BLOB:
case CL_RUBY_BLOB:
case CL_ERLANG_BLOB: {
// obj value points into recv buf - don't free it.
as_key_init_raw(key, ns, set, (const uint8_t*)clkey->u.blob, (uint32_t)clkey->sz);
break;
}
// Unsupported as key types for now:
case CL_LIST:
case CL_MAP:
default:
as_key_init_value(key, ns, set, NULL);
break;
}
}
bool
insert_records(aerospike* p_as)
{
// Create an as_record object with one (GeoJSON value) bin. By using
// as_record_inita(), we won't need to destroy the record if we only set
// bins using as_record_set_geojson().
as_record rec;
as_record_inita(&rec, 1);
// Re-using rec, write records into the database such that each record's key
// and (test-bin) value is based on the loop index.
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
double lng = -122 + (0.1 * i);
double lat = 37.5 + (0.1 * i);
char buff[1024];
snprintf(buff, sizeof(buff),
"{ \"type\": \"Point\", \"coordinates\": [%f, %f] }", lng, lat);
as_record_set_geojson_str(&rec, TEST_BIN_NAME, buff);
// Write a record to the database.
if (aerospike_key_put(p_as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
LOG("aerospike_key_put() returned %d - %s", err.code, err.message);
return false;
}
}
LOG("insert succeeded");
return true;
}
//------------------------------------------------
// Read multiple-record examples' test records
// from the database.
//
bool
example_read_test_records(aerospike* p_as)
{
// Multiple-record examples insert g_n_keys records, using integer keys from
// 0 to (g_n_keys - 1).
for (uint32_t i = 0; i < g_n_keys; i++) {
as_error err;
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
as_record* p_rec = NULL;
// Read a test record from the database.
if (aerospike_key_get(p_as, &err, NULL, &key, &p_rec) != AEROSPIKE_OK) {
LOG("aerospike_key_get() returned %d - %s", err.code, err.message);
return false;
}
// If we didn't get an as_record object back, something's wrong.
if (! p_rec) {
LOG("aerospike_key_get() retrieved null as_record object");
return false;
}
// Log the result.
LOG("read record with key %u from database:", i);
example_dump_record(p_rec);
// Destroy the as_record object.
as_record_destroy(p_rec);
}
return true;
}
// ----------------------------------------------------------------------------------
//
// getting batch of records in one call
// batch size is limited on aerospike server (default: 5000)
//
// def batch_get(keys, specific_bins = nil, options = {})
//
// params:
// keys - Array of AerospikeC::Key objects
// specific bins - Array of strings representing bin names
// options - hash of options:
// with_header: returns also generation and expire_in field (default: false)
//
// ------
// RETURN: Array of hashes where each hash represents record bins
//
// @TODO options policy
//
static VALUE batch_get(int argc, VALUE * argv, VALUE self) {
rb_aero_TIMED(tm);
as_error err;
as_status status;
aerospike * as = rb_aero_CLIENT;
char ** bin_names;
long n_bin_names;
VALUE keys;
VALUE specific_bins;
VALUE options;
rb_scan_args(argc, argv, "12", &keys, &specific_bins, &options);
// default values for optional arguments
if ( NIL_P(specific_bins) ) {
specific_bins = Qnil;
}
else {
if ( TYPE(specific_bins) != T_ARRAY ) rb_raise(rb_aero_OptionError, "[AerospikeC::Client][batch_get] specific_bins must be an Array");
bin_names = rb_array2bin_names(specific_bins);
n_bin_names = rb_ary_len_long(specific_bins);
}
if ( NIL_P(options) ) {
options = rb_hash_new();
rb_hash_aset(options, with_header_sym, Qfalse);
}
long keys_len = rb_ary_len_long(keys);
VALUE records_bins = rb_ary_new();
as_batch_read_records records;
as_batch_read_inita(&records, keys_len);
// map array into as_batch_read_record * record
for (int i = 0; i < keys_len; ++i) {
VALUE element = rb_ary_entry(keys, i);
VALUE tmp;
tmp = rb_funcall(element, rb_intern("namespace"), 0);
char * c_namespace = StringValueCStr( tmp );
tmp = rb_funcall(element, rb_intern("set"), 0);
char * c_set = StringValueCStr( tmp );
as_batch_read_record * record = as_batch_read_reserve(&records);
tmp = rb_funcall(element, rb_intern("key"), 0);
if ( TYPE(tmp) != T_FIXNUM ) {
char * c_key = StringValueCStr( tmp );
as_key_init(&record->key, c_namespace, c_set, c_key);
}
else {
as_key_init_int64(&record->key, c_namespace, c_set, FIX2LONG(tmp));
}
if ( specific_bins == Qnil ) {
record->read_all_bins = true;
}
else {
record->bin_names = bin_names;
record->n_bin_names = n_bin_names;
}
}
// read here!
if ( ( status = aerospike_batch_read(as, &err, NULL, &records) ) != AEROSPIKE_OK ) {
if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) {
rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 1, rb_str_new2("[Client][batch_get] AEROSPIKE_ERR_RECORD_NOT_FOUND"));
return Qnil;
}
as_batch_read_destroy(&records);
raise_as_error(err);
}
as_vector list = records.list;
// map records into array of hashes
for (long i = 0; i < list.size; ++i) {
as_batch_read_record * record = as_vector_get(&list, i);
as_record rec = record->record;
VALUE bins = record2hash(&rec);
bins = check_with_header(bins, options, &rec);
rb_ary_push(records_bins, bins);
}
as_batch_read_destroy(&records);
if ( specific_bins != Qnil ) bin_names_destroy(bin_names, n_bin_names);
rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 1, rb_str_new2("[Client][batch_get] success"));
return records_bins;
}
int
main(int argc, char* argv[])
{
// Parse command line arguments.
if (! example_get_opts(argc, argv, EXAMPLE_MULTI_KEY_OPTS)) {
exit(-1);
}
// Connect to the aerospike database cluster.
aerospike as;
example_connect_to_aerospike(&as);
// Start clean.
example_remove_test_records(&as);
if (! insert_records(&as)) {
cleanup(&as);
exit(-1);
}
as_error err;
// Make a batch of all the keys we inserted.
as_batch batch;
as_batch_inita(&batch, g_n_keys);
uint32_t i;
for (i = 0; i < g_n_keys; i++) {
as_key_init_int64(as_batch_keyat(&batch, i), g_namespace, g_set,
(int64_t)i);
}
// Check existence of these keys - they should all be there.
if (aerospike_batch_exists(&as, &err, NULL, &batch, batch_read_cb, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_batch_exists() returned %d - %s", err.code, err.message);
cleanup(&as);
exit(-1);
}
LOG("batch exists call completed");
// Get all of these keys - they should all be there.
if (aerospike_batch_get(&as, &err, NULL, &batch, batch_read_cb, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_batch_get() returned %d - %s", err.code, err.message);
cleanup(&as);
exit(-1);
}
LOG("batch get call completed");
// Delete some records in the middle.
uint32_t n_to_delete = g_n_keys / 5;
if (n_to_delete == 0) {
n_to_delete = 1;
}
uint32_t n_start = g_n_keys / 2;
if (n_start + n_to_delete > g_n_keys) {
n_start = 0;
}
uint32_t n_end = n_start + n_to_delete;
for (i = n_start; i < n_end; i++) {
// No need to destroy a stack as_key object, if we only use
// as_key_init_int64().
as_key key;
as_key_init_int64(&key, g_namespace, g_set, (int64_t)i);
if (aerospike_key_remove(&as, &err, NULL, &key) != AEROSPIKE_OK) {
LOG("aerospike_key_remove() returned %d - %s", err.code,
err.message);
cleanup(&as);
exit(-1);
}
}
LOG("deleted records %u ... %u", n_start, n_end - 1);
// Check existence of these keys - some should not be found.
if (aerospike_batch_exists(&as, &err, NULL, &batch, batch_read_cb, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_batch_exists() returned %d - %s", err.code, err.message);
cleanup(&as);
exit(-1);
}
LOG("second batch exists call completed");
// Get all of these keys - some should not be found.
if (aerospike_batch_get(&as, &err, NULL, &batch, batch_read_cb, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_batch_get() returned %d - %s", err.code, err.message);
cleanup(&as);
exit(-1);
}
LOG("second batch get call completed");
// Cleanup and disconnect from the database cluster.
cleanup(&as);
LOG("batch get example successfully completed");
return 0;
}
