aerospike_native 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 296cfb9cc494979027c364feb4637e48ddece680
-  data.tar.gz: fce6ce9af517cfe235f3c9e387ecb9816d38ba39
+  metadata.gz: db77dc977496b4ace18450a71245fe8dcd0cf4aa
+  data.tar.gz: 535112b2da7532923df5281f0a02d1b3e90e72be
 SHA512:
-  metadata.gz: 8ce57e918e11980f5fbc9bc33d2db296f271be0f0d6043575d0ca1bf3cd4ba2893d416357fd1593e3269121a543868d277761787be3ee8d03493081e0fbdbef8
-  data.tar.gz: 4ff43fc3ec7bf72679014cce05a30efa09d5444c1c8a32ebc61122a43dd3c113eaa1aaef238fcd2e51b8678ff43dd236e7740c0e6ff74a998cfef8b27758a753
+  metadata.gz: 2757d76132519aa9c2abde4735bbab81d350f803cc538a524009bbceced035ed9543066ef2e98db627c8d1a267a2413098d82e13cae9c8058fdeee034121d1d0
+  data.tar.gz: 2c0b993989b2acbc8239fa745086b6dcdaca396cbcb51ada4b6d528519bf768ca41e8920137453f202cf664d3235590d881ae65cf439dbe93c90389799a41046

data/README.md

@@ -1,6 +1,6 @@
 # AerospikeNative
 
-Ruby [aerospike](http://www.aerospike.com/) client with c extension (unstable)
+Ruby [aerospike](http://www.aerospike.com/) client with c extension
 
 ## Installation
 
@@ -20,11 +20,16 @@ Or install it yourself as:
     
 ## Current status
 
-* `operate` command with _write_, _increment_, _append_, _prepend_
+* `operate` command with all operation types
 * `put` command
-* `get` command without digest keys support
-* Raw (bytes) type is not supported
+* `get` command
+* `remove` command
+* `select` command
+* `exixts?` command
+* :disappointed: Raw (bytes) type is not supported
 * Supported timeout for policies
+* Supported digest keys
+* Supported exceptions (`AerospikeNative::Exception`) with several error codes constants like `AerospikeNative::Exception::ERR_CLIENT`
 
 ## Usage
 
@@ -36,7 +41,10 @@ key = AerospikeNative::Key.new('test', 'test', 'sample')
 client.put(key, {'bin1' => 1, 'bin2' => 'test'}, {'timeout' => 1})
 client.operate(key, [AerospikeNative::Operation.write('bin3', 25), AerospikeNative::Operation.increment('bin1', 2), AerospikeNative::Operation.append('bin1', '_aerospike')], {'timeout' => 1})
 
+client.exists?(key)
 record = client.get(key)
+record = client.select(key, ['bin2', 'bin1'])
+client.remove(key)
 ```
 
 ## Contributing

data/ext/aerospike_native/client.c

@@ -157,9 +157,11 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
     Data_Get_Struct(vKey, as_key, key);
 
     if (aerospike_key_put(ptr, &err, &policy, key, &record) != AEROSPIKE_OK) {
+        as_record_destroy(&record);
         raise_aerospike_exception(err.code, err.message);
     }
 
+    as_record_destroy(&record);
     return Qtrue;
 }
 
@@ -211,6 +213,7 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
     Data_Get_Struct(vKey, as_key, key);
 
     if (aerospike_key_get(ptr, &err, &policy, key, &record) != AEROSPIKE_OK) {
+        as_record_destroy(record);
         raise_aerospike_exception(err.code, err.message);
     }
 
@@ -234,6 +237,7 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
         }
     }
 
+    as_record_destroy(record);
     return rb_class_new_instance(4, vParams, RecordClass);
 }
 
@@ -242,13 +246,17 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
     VALUE vKey;
     VALUE vOperations;
     VALUE vSettings = Qnil;
+    VALUE vParams[4];
     long idx = 0, n = 0;
+    bool isset_read = false;
 
     aerospike *ptr;
     as_operations ops;
     as_key* key;
     as_error err;
     as_policy_operate policy;
+    as_record* record = NULL;
+    as_bin bin;
 
     if (argc > 3 || argc < 2) {  // there should only be 2 or 3 arguments
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
@@ -308,6 +316,8 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
 
             break;
         case OPERATION_READ:
+            isset_read = true;
+            as_operations_add_read(&ops, StringValueCStr( bin_name ));
             break;
         case OPERATION_INCREMENT:
             as_operations_add_incr(&ops, StringValueCStr( bin_name ), NUM2INT( bin_value ));
@@ -331,15 +341,252 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
 
     Data_Get_Struct(vKey, as_key, key);
 
-    if (aerospike_key_operate(ptr, &err, &policy, key, &ops, NULL) != AEROSPIKE_OK) {
+    if (isset_read) {
+        if (aerospike_key_operate(ptr, &err, &policy, key, &ops, &record) != AEROSPIKE_OK) {
+            as_operations_destroy(&ops);
+            as_record_destroy(record);
+            raise_aerospike_exception(err.code, err.message);
+        }
+
+        as_operations_destroy(&ops);
+
+        vParams[0] = vKey;
+        vParams[1] = rb_hash_new();
+        vParams[2] = UINT2NUM(record->gen);
+        vParams[3] = UINT2NUM(record->ttl);
+
+        for(n = 0; n < record->bins.size; n++) {
+            bin = record->bins.entries[n];
+            switch( as_val_type(bin.valuep) ) {
+            case AS_INTEGER:
+                rb_hash_aset(vParams[1], rb_str_new2(bin.name), LONG2NUM(bin.valuep->integer.value));
+                break;
+            case AS_STRING:
+                rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_str_new2(bin.valuep->string.value));
+                break;
+            case AS_UNDEF:
+            default:
+                break;
+            }
+        }
+
+        as_record_destroy(record);
+        return rb_class_new_instance(4, vParams, RecordClass);
+    } else {
+        if (aerospike_key_operate(ptr, &err, &policy, key, &ops, NULL) != AEROSPIKE_OK) {
+            as_operations_destroy(&ops);
+            raise_aerospike_exception(err.code, err.message);
+        }
+
+        as_operations_destroy(&ops);
+        return Qtrue;
+    }
+}
+
+VALUE client_remove(int argc, VALUE* argv, VALUE vSelf)
+{
+    VALUE vKey;
+    VALUE vSettings = Qnil;
+
+    aerospike *ptr;
+    as_key* key;
+    as_error err;
+    as_policy_remove policy;
+
+    if (argc > 2 || argc < 1) {  // there should only be 1 or 2 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
+
+    vKey = argv[0];
+    check_aerospike_key(vKey);
+
+    if (argc == 2) {
+        vSettings = argv[1];
+
+        switch (TYPE(vSettings)) {
+        case T_NIL:
+            break;
+        case T_HASH: {
+            VALUE vTimeout = rb_hash_aref(vSettings, rb_str_new2("timeout"));
+            if (TYPE(vTimeout) == T_FIXNUM) {
+                policy.timeout = NUM2UINT( vTimeout );
+            }
+            break;
+        }
+        default:
+            /* raise exception */
+            Check_Type(vSettings, T_HASH);
+            break;
+        }
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+    Data_Get_Struct(vKey, as_key, key);
+
+    if (aerospike_key_remove(ptr, &err, &policy, key) != AEROSPIKE_OK) {
         raise_aerospike_exception(err.code, err.message);
     }
 
-    as_operations_destroy(&ops);
+    return Qtrue;
+}
+
+VALUE client_exists(int argc, VALUE* argv, VALUE vSelf)
+{
+    VALUE vKey;
+    VALUE vSettings = Qnil;
+    VALUE vParams[4];
+
+    aerospike *ptr;
+    as_key* key;
+    as_error err;
+    as_policy_read policy;
+    as_record* record = NULL;
+    as_bin bin;
+    as_status status;
+    long n = 0;
+
+    if (argc > 2 || argc < 1) {  // there should only be 1 or 2 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
+
+    vKey = argv[0];
+    check_aerospike_key(vKey);
+
+    if (argc == 2) {
+        vSettings = argv[1];
+
+        switch (TYPE(vSettings)) {
+        case T_NIL:
+            break;
+        case T_HASH: {
+            VALUE vTimeout = rb_hash_aref(vSettings, rb_str_new2("timeout"));
+            if (TYPE(vTimeout) == T_FIXNUM) {
+                policy.timeout = NUM2UINT( vTimeout );
+            }
+            break;
+        }
+        default:
+            /* raise exception */
+            Check_Type(vSettings, T_HASH);
+            break;
+        }
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+    Data_Get_Struct(vKey, as_key, key);
+
+    status = aerospike_key_exists(ptr, &err, &policy, key, &record);
+    if (status != AEROSPIKE_OK && status != AEROSPIKE_ERR_RECORD_NOT_FOUND) {
+        as_record_destroy(record);
+        raise_aerospike_exception(err.code, err.message);
+    }
+    as_record_destroy(record);
+
+    if (status == AEROSPIKE_ERR_RECORD_NOT_FOUND) {
+        return Qfalse;
+    }
 
     return Qtrue;
 }
 
+VALUE client_select(int argc, VALUE* argv, VALUE vSelf)
+{
+    VALUE vKey;
+    VALUE vArray;
+    VALUE vSettings = Qnil;
+    VALUE vParams[4];
+
+    aerospike *ptr;
+    as_key* key;
+    as_error err;
+    as_policy_read policy;
+    as_record* record = NULL;
+    as_bin bin;
+    long n = 0, idx = 0;
+
+    if (argc > 3 || argc < 2) {  // there should only be 2 or 3 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
+    }
+
+    vKey = argv[0];
+    check_aerospike_key(vKey);
+    vArray = argv[1];
+
+    Check_Type(vArray, T_ARRAY);
+    idx = RARRAY_LEN(vArray);
+    if (idx == 0) {
+        return Qfalse;
+    }
+
+    if (argc == 3) {
+        vSettings = argv[2];
+
+        switch (TYPE(vSettings)) {
+        case T_NIL:
+            break;
+        case T_HASH: {
+            VALUE vTimeout = rb_hash_aref(vSettings, rb_str_new2("timeout"));
+            if (TYPE(vTimeout) == T_FIXNUM) {
+                policy.timeout = NUM2UINT( vTimeout );
+            }
+            break;
+        }
+        default:
+            /* raise exception */
+            Check_Type(vSettings, T_HASH);
+            break;
+        }
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+    Data_Get_Struct(vKey, as_key, key);
+    const char* bins[idx];
+
+    for(n = 0; n < idx; n++) {
+        VALUE bin_name = rb_ary_entry(vArray, n);
+
+        Check_Type(bin_name, T_STRING);
+        char* name = StringValueCStr( bin_name );
+        bins[n] = malloc(strlen(name) * sizeof(char) + 1);
+        memset(bins[n], '\0', strlen(name) + 1);
+        strcpy(bins[n], name);
+    }
+
+    if (aerospike_key_select(ptr, &err, &policy, key, bins, &record) != AEROSPIKE_OK) {
+        for(n = 0; n < idx; n++) {
+            free(bins[n]);
+        }
+        as_record_destroy(record);
+        raise_aerospike_exception(err.code, err.message);
+    }
+    for(n = 0; n < idx; n++) {
+        free(bins[n]);
+    }
+
+    vParams[0] = vKey;
+    vParams[1] = rb_hash_new();
+    vParams[2] = UINT2NUM(record->gen);
+    vParams[3] = UINT2NUM(record->ttl);
+
+    for(n = 0; n < record->bins.size; n++) {
+        bin = record->bins.entries[n];
+        switch( as_val_type(bin.valuep) ) {
+        case AS_INTEGER:
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), LONG2NUM(bin.valuep->integer.value));
+            break;
+        case AS_STRING:
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_str_new2(bin.valuep->string.value));
+            break;
+        case AS_UNDEF:
+        default:
+            break;
+        }
+    }
+
+    as_record_destroy(record);
+    return rb_class_new_instance(4, vParams, RecordClass);
+}
+
 void define_client()
 {
     ClientClass = rb_define_class_under(AerospikeNativeClass, "Client", rb_cObject);
@@ -348,4 +595,7 @@ void define_client()
     rb_define_method(ClientClass, "operate", client_operate, -1);
     rb_define_method(ClientClass, "put", client_put, -1);
     rb_define_method(ClientClass, "get", client_get, -1);
+    rb_define_method(ClientClass, "remove", client_remove, -1);
+    rb_define_method(ClientClass, "exists?", client_exists, -1);
+    rb_define_method(ClientClass, "select", client_select, -1);
 }

data/ext/aerospike_native/exception.c

@@ -40,6 +40,6 @@ void raise_aerospike_exception(int iCode, char* sMessage)
     VALUE vException;
 
     vException = rb_exc_new2(ExceptionClass, sMessage);
-    rb_iv_set(vException, "@code", iCode);
+    rb_iv_set(vException, "@code", INT2FIX(iCode));
     rb_exc_raise(vException);
 }

data/ext/aerospike_native/operation.c

@@ -4,8 +4,16 @@ VALUE OperationClass;
 
 VALUE operation_initialize(VALUE vSelf, VALUE vOpType, VALUE vBinName, VALUE vBinValue)
 {
+    int op_type = 0;
+
     Check_Type(vOpType, T_FIXNUM);
-    Check_Type(vBinName, T_STRING);
+    op_type = NUM2INT(vOpType);
+
+    if (op_type != OPERATION_TOUCH) {
+        Check_Type(vBinName, T_STRING);
+    } else {
+        Check_Type(vBinName, T_NIL);
+    }
 
     rb_iv_set(vSelf, "@op_type", vOpType);
     rb_iv_set(vSelf, "@bin_name", vBinName);
@@ -59,6 +67,26 @@ VALUE operation_increment(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+VALUE operation_touch(VALUE vSelf)
+{
+    VALUE vArgs[3];
+
+    vArgs[0] = INT2NUM(OPERATION_TOUCH);
+    vArgs[1] = Qnil;
+    vArgs[2] = Qnil;
+    return rb_class_new_instance(3, vArgs, vSelf);
+}
+
+VALUE operation_read(VALUE vSelf, VALUE vBinName)
+{
+    VALUE vArgs[3];
+
+    vArgs[0] = INT2NUM(OPERATION_READ);
+    vArgs[1] = vBinName;
+    vArgs[2] = Qnil;
+    return rb_class_new_instance(3, vArgs, vSelf);
+}
+
 void define_operation()
 {
     OperationClass = rb_define_class_under(AerospikeNativeClass, "Operation", rb_cObject);
@@ -67,6 +95,8 @@ void define_operation()
     rb_define_singleton_method(OperationClass, "append", operation_append, 2);
     rb_define_singleton_method(OperationClass, "prepend", operation_prepend, 2);
     rb_define_singleton_method(OperationClass, "increment", operation_increment, 2);
+    rb_define_singleton_method(OperationClass, "touch", operation_touch, 0);
+    rb_define_singleton_method(OperationClass, "read", operation_read, 1);
     rb_define_attr(OperationClass, "op_type", 1, 0);
     rb_define_attr(OperationClass, "bin_name", 1, 0);
     rb_define_attr(OperationClass, "bin_value", 1, 0);

data/lib/aerospike_native/version.rb

@@ -1,3 +1,3 @@
 module AerospikeNative
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Vladimir Ziablitskii