// ----------------------------------------------------------------------------------
//
// def touch(key, options = {})
//
// params:
// key - AeropsikeC::Key object
// options - hash of options:
// ttl: time to live record (default: 0)
// policy: AerospikeC::Policy for operate
//
// ------
// RETURN:
// 1. hash representing record header
// 2. nil when AEROSPIKE_ERR_RECORD_NOT_FOUND
//
// @TODO options policy
//
static VALUE touch(int argc, VALUE * argv, VALUE self) {
rb_aero_TIMED(tm);
as_error err;
as_status status;
aerospike * as = rb_aero_CLIENT;
VALUE key;
VALUE options;
rb_scan_args(argc, argv, "11", &key, &options);
// default values for optional arguments
if ( NIL_P(options) ) {
options = rb_hash_new();
rb_hash_aset(options, ttl_sym, rb_zero);
}
else {
if ( TYPE(rb_hash_aref(options, ttl_sym)) != T_FIXNUM ) { // check ttl option
rb_raise(rb_aero_OptionError, "[AerospikeC::Client][put] ttl must be an integer");
}
}
as_key * k = rb_aero_KEY;
as_record * rec = NULL;
as_operations ops;
as_operations_inita(&ops, 1);
as_operations_add_touch(&ops);
ops.ttl = FIX2INT( rb_hash_aref(options, ttl_sym) );
as_policy_operate * policy = get_policy(options);
if ( ( status = aerospike_key_operate(as, &err, policy, k, &ops, &rec) ) != AEROSPIKE_OK ) {
as_operations_destroy(&ops);
if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) {
rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 2, rb_str_new2("[Client][touch] AEROSPIKE_ERR_RECORD_NOT_FOUND"), rb_aero_KEY_INFO);
return Qnil;
}
raise_as_error(err);
}
VALUE header = rb_hash_new();
rb_hash_aset(header, rb_str_new2("gen"), INT2FIX(rec->gen));
rb_hash_aset(header, rb_str_new2("expire_in"), INT2FIX(rec->ttl));
as_record_destroy(rec);
as_operations_destroy(&ops);
rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 2, rb_str_new2("[Client][touch] success"), rb_aero_KEY_INFO);
return header;
}
// ----------------------------------------------------------------------------------
//
// perform given operations on record in one call
//
// def operate(key, operations, options = {})
//
// params:
// key - AeropsikeC::Key object
// operations - AeropsikeC::Operation object
// options:
// policy: AerospikeC::Policy for operate
//
// ------
// RETURN:
// 1. hash representing record
// 2. nil when AEROSPIKE_ERR_RECORD_NOT_FOUND
//
//
static VALUE operate(int argc, VALUE * argv, VALUE self) {
rb_aero_TIMED(tm);
as_error err;
as_status status;
aerospike * as = rb_aero_CLIENT;
VALUE key;
VALUE operations;
VALUE options;
rb_scan_args(argc, argv, "21", &key, &operations, &options);
if ( NIL_P(options) ) {
options = rb_hash_new();
}
as_key * k = rb_aero_KEY;
VALUE is_aerospike_c_operation = rb_funcall(operations, rb_intern("is_a?"), 1, rb_aero_OPERATION);
if ( is_aerospike_c_operation != Qtrue ) {
rb_raise(rb_aero_OptionError, "[AerospikeC::Client][operate] use AerospikeC::Operation class to perform operations");
}
as_operations * ops = rb_operations2as_operations(operations);
as_record * rec = NULL;
as_policy_operate * policy = get_policy(options);
if ( ( status = aerospike_key_operate(as, &err, policy, k, ops, &rec) ) != AEROSPIKE_OK ) {
as_operations_destroy(ops);
if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) {
rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 2, rb_str_new2("[Client][operate] AEROSPIKE_ERR_RECORD_NOT_FOUND"), rb_aero_KEY_INFO);
return Qnil;
}
raise_as_error(err);
}
VALUE record = record2hash(rec);
as_record_destroy(rec);
as_operations_destroy(ops);
rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 2, rb_str_new2("[Client][operate] success"), rb_aero_KEY_INFO);
return record;
}
static int increment(lua_State *L){
as_error err;
aerospike* as = lua_touserdata(L, 1);
const char* nameSpace = luaL_checkstring(L, 2);
const char* set = luaL_checkstring(L, 3);
const char* keyString = luaL_checkstring(L, 4);
const int numBins = lua_tointeger(L, 5);
as_operations ops = add_bins_to_increment(L, 6, numBins);
as_key key;
as_key_init(&key, nameSpace, set, keyString);
// Apply the operations. Since the record does not exist, it will be created
// and the bins initialized with the ops' integer values.
aerospike_key_operate(as, &err, NULL, &key, &ops, NULL);
as_operations_destroy(&ops);
as_key_destroy(&key);
lua_pushnumber(L, err.code);
lua_pushstring(L, err.message);
return 2;
}
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_error err;
as_operations ops;
LOG("append 10 values from 0 to 9");
// The first append will create the record and bin.
for (int i = 0; i < 10; i++) {
as_operations_inita(&ops, 1);
as_operations_add_list_append_int64(&ops, "test-bin-1", i);
if (aerospike_key_operate(&as, &err, NULL, &g_key, &ops, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_key_operate() returned %d - %s", err.code,
err.message);
example_cleanup(&as);
exit(-1);
}
as_operations_destroy(&ops);
}
if (! example_read_test_record(&as)) {
example_cleanup(&as);
exit(-1);
}
LOG("append operations succeeded");
LOG("pop from the tail (index -1)");
as_operations_inita(&ops, 1);
as_operations_add_list_pop(&ops, "test-bin-1", -1);
as_record *p_rec = NULL;
if (aerospike_key_operate(&as, &err, NULL, &g_key, &ops, &p_rec) !=
AEROSPIKE_OK) {
LOG("aerospike_key_operate() returned %d - %s", err.code, err.message);
as_operations_destroy(&ops);
example_cleanup(&as);
exit(-1);
}
as_operations_destroy(&ops);
LOG("pop operation succeeded");
LOG("insert popped value at the head (index 0)");
as_val *val = (as_val *)as_record_get(p_rec, "test-bin-1");
as_operations_inita(&ops, 1);
as_operations_add_list_insert(&ops, "test-bin-1", 0, val);
if (aerospike_key_operate(&as, &err, NULL, &g_key, &ops, NULL) !=
AEROSPIKE_OK) {
LOG("aerospike_key_operate() returned %d - %s", err.code, err.message);
as_operations_destroy(&ops);
example_cleanup(&as);
exit(-1);
}
as_record_destroy(p_rec);
as_operations_destroy(&ops);
LOG("insert operation succeeded");
if (! example_read_test_record(&as)) {
example_cleanup(&as);
exit(-1);
}
// Cleanup and disconnect from the database cluster.
example_cleanup(&as);
LOG("list 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;
}
