aerospike_native 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61a277355cea7b57701e87d449cc21d05d933f17
-  data.tar.gz: b7e0a9780c63ac5b07ab380da0cfbadef654bbe5
+  metadata.gz: 55fd092a56f2b28d9fff6ab918d7aae3f19324e3
+  data.tar.gz: 687914c31d0f71e661d0453434136ef1b75f33ab
 SHA512:
-  metadata.gz: 16f5e09b60d5e74ab9a4438575f38c00953d728e147f96d7b6d8726a59dc8b597e6fb506a7e5fba68061d8a4567c66157f9e753765f5e8f218148a1c7fd1c580
-  data.tar.gz: 1662b1718efc07a1c93859a734f5e114dddfb9def810a306a78485acdaf4d1c16ac53f2ed9f6953bc66d8a9f5f4d896ec1207bc563b85f6a0a3e21e61b92110e
+  metadata.gz: 0e0b41edd06ad7599ed15866119471672f080358dab8346c94fe3bdabe5dad75eac914aa8026c0c406255582780565242f8aabb275eb3e6c27856ce0ac1e24f3
+  data.tar.gz: 15595c8b755ba4d88ef78342d4d277060c93f8c5ae78fc37b09087332f194f1e85f1649b54e4259f59da30ee278db79c5c3ce7188fbc5c22a1daa8d56cb13f68

data/ext/aerospike_native/aerospike_native.c

@@ -1,8 +1,8 @@
-//#include <iostream>
 #include "aerospike_native.h"
 #include "client.h"
 #include "key.h"
 #include "operation.h"
+#include "record.h"
 
 VALUE AerospikeNativeClass;
 
@@ -11,5 +11,6 @@ void Init_aerospike_native()
     AerospikeNativeClass = rb_define_module("AerospikeNative");
     define_client();
     define_native_key();
+    define_record();
     define_operation();
 }

data/ext/aerospike_native/client.c

@@ -1,5 +1,7 @@
 #include "client.h"
 #include "operation.h"
+#include "key.h"
+#include "record.h"
 #include <aerospike/as_key.h>
 #include <aerospike/as_operations.h>
 #include <aerospike/aerospike_key.h>
@@ -25,6 +27,23 @@ static VALUE client_allocate(VALUE klass)
     return obj;
 }
 
+static int keys_i(VALUE key, VALUE value, VALUE ary)
+{
+    rb_ary_push(ary, key);
+    return ST_CONTINUE;
+}
+
+static VALUE
+rb_hash_keys(VALUE hash)
+{
+    VALUE ary;
+
+    ary = rb_ary_new_capa(RHASH_SIZE(hash));
+    rb_hash_foreach(hash, keys_i, ary);
+
+    return ary;
+}
+
 VALUE client_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE ary = Qnil;
@@ -34,7 +53,7 @@ VALUE client_initialize(int argc, VALUE* argv, VALUE self)
     long idx = 0, n = 0;
 
     if (argc > 1) {  // there should only be 0 or 1 arguments
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
     }
 
     if (argc == 1) {
@@ -78,6 +97,176 @@ VALUE client_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vKey;
+    VALUE vBins;
+    VALUE vSettings;
+    VALUE vHashKeys;
+
+    aerospike *ptr;
+    as_key key;
+    as_error err;
+    as_record record;
+    as_policy_write policy;
+
+    VALUE vNamespace, vSet, vKeyValue;
+
+    int idx = 0, n = 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 = vArgs[0];
+    check_aerospike_key(vKey);
+
+    vBins = vArgs[1];
+    Check_Type(vBins, T_HASH);
+
+    as_policy_write_init(&policy);
+
+    if (argc == 3) {
+        vSettings = vArgs[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;
+        }
+    }
+
+    idx = RHASH_SIZE(vBins);
+    if (idx == 0) {
+        return Qfalse;
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+    as_record_inita(&record, idx);
+    vHashKeys = rb_hash_keys(vBins);
+
+    for(n = 0; n < idx; n++) {
+        VALUE bin_name = rb_ary_entry(vHashKeys, n);
+        VALUE bin_value = rb_hash_aref(vBins, bin_name);
+
+        Check_Type(bin_name, T_STRING);
+
+        switch( TYPE(bin_value) ) {
+        case T_STRING:
+            as_record_set_str(&record, StringValueCStr(bin_name), StringValueCStr(bin_value));
+            break;
+        case T_FIXNUM:
+            as_record_set_int64(&record, StringValueCStr(bin_name), NUM2LONG(bin_value));
+            break;
+        default:
+            rb_raise(rb_eArgError, "Incorrect input type");
+            break;
+        }
+     }
+
+    vNamespace = rb_iv_get(vKey, "@namespace");
+    vSet = rb_iv_get(vKey, "@set");
+    vKeyValue = rb_iv_get(vKey, "@value");
+    as_key_init_str(&key, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValueCStr( vKeyValue ));
+
+    if (aerospike_key_put(ptr, &err, &policy, &key, &record) != AEROSPIKE_OK) {
+        printf("error\n");
+        fprintf(stderr, "err(%d) %s at [%s:%d]\n", err.code, err.message, err.file, err.line);
+    }
+
+    return Qtrue;
+}
+
+VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vKey;
+    VALUE vSettings;
+    VALUE vParams[4];
+
+    aerospike *ptr;
+    as_key key;
+    as_error err;
+    as_record* record = NULL;
+    as_policy_read policy;
+    as_bin bin;
+
+    VALUE vNamespace, vSet, vKeyValue;
+    int 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 = vArgs[0];
+    check_aerospike_key(vKey);
+
+    as_policy_read_init(&policy);
+
+    if (argc == 2) {
+        vSettings = vArgs[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);
+    vNamespace = rb_iv_get(vKey, "@namespace");
+    vSet = rb_iv_get(vKey, "@set");
+    vKeyValue = rb_iv_get(vKey, "@value");
+    as_key_init_str(&key, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValueCStr( vKeyValue ));
+
+    if (aerospike_key_get(ptr, &err, &policy, &key, &record) != AEROSPIKE_OK) {
+        printf("error\n");
+        fprintf(stderr, "err(%d) %s at [%s:%d]\n", err.code, err.message, err.file, err.line);
+    }
+    rb_iv_set(vKey, "@digest", rb_str_new( record->key.digest.value, AS_DIGEST_VALUE_SIZE));
+
+    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;
+        }
+    }
+
+    return rb_class_new_instance(4, vParams, RecordClass);
+}
+
 VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
 {
     VALUE vKey;
@@ -89,27 +278,34 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
     as_operations ops;
     as_key key;
     as_error err;
+    as_policy_operate policy;
 
     VALUE vNamespace, vSet, vKeyValue;
 
     if (argc > 3 || argc < 2) {  // there should only be 2 or 3 arguments
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc);
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
     }
 
     vKey = argv[0];
-//    char* name = rb_obj_classname(vKey);
-    printf("class name: %s\n", rb_obj_classname(vKey));
+    check_aerospike_key(vKey);
 
     vOperations = argv[1];
     Check_Type(vOperations, T_ARRAY);
+    as_policy_operate_init(&policy);
 
     if (argc == 3) {
         vSettings = argv[2];
 
         switch (TYPE(vSettings)) {
         case T_NIL:
-        case T_HASH:
             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);
@@ -125,9 +321,7 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
     Data_Get_Struct(vSelf, aerospike, ptr);
     as_operations_inita(&ops, idx);
 
-    printf("prepare operations\n");
-
-    for(n = 0; n < idx; n++) {
+   for(n = 0; n < idx; n++) {
         VALUE operation = rb_ary_entry(vOperations, n);
         int op_type = NUM2INT( rb_iv_get(operation, "@op_type") );
         VALUE bin_name = rb_iv_get(operation, "@bin_name");
@@ -135,39 +329,47 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
 
         switch( op_type ) {
         case WRITE:
-            printf("write\n");
-            as_operations_add_write_int64(&ops, StringValueCStr( bin_name ), NUM2INT( bin_value ));
-//            switch( TYPE(bin_value) ) {
-//            case T_STRING:
-//                as_operations_add_write_str(&ops, StringValueCStr( bin_name ), StringValueCStr( bin_value ));
-//                break;
-//            case T_FIXNUM:
-//                as_operations_add_write_int64(&ops, StringValueCStr( bin_name ), NUM2INT( bin_value ));
-//                break;
-//            }
+            switch( TYPE(bin_value) ) {
+            case T_STRING:
+                as_operations_add_write_str(&ops, StringValueCStr( bin_name ), StringValueCStr( bin_value ));
+                break;
+            case T_FIXNUM:
+                as_operations_add_write_int64(&ops, StringValueCStr( bin_name ), NUM2LONG( bin_value ));
+                break;
+            }
 
+            break;
+        case READ:
             break;
         case INCREMENT:
-            printf("increment\n");
             as_operations_add_incr(&ops, StringValueCStr( bin_name ), NUM2INT( bin_value ));
             break;
+        case APPEND:
+            Check_Type(bin_value, T_STRING);
+            as_operations_add_append_str(&ops, StringValueCStr( bin_name ), StringValueCStr( bin_value ));
+            break;
+        case PREPEND:
+            Check_Type(bin_value, T_STRING);
+            as_operations_add_prepend_str(&ops, StringValueCStr( bin_name ), StringValueCStr( bin_value ));
+            break;
+        case TOUCH:
+            as_operations_add_touch(&ops);
+            break;
+        default:
+            rb_raise(rb_eArgError, "Incorrect operation type");
+            break;
         }
     }
 
-    printf("test\n");
-    printf("prepare key\n");
-
     vNamespace = rb_iv_get(vKey, "@namespace");
     vSet = rb_iv_get(vKey, "@set");
     vKeyValue = rb_iv_get(vKey, "@value");
     as_key_init_str(&key, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValueCStr( vKeyValue ));
 
-    printf("execute\n");
-    if (aerospike_key_operate(ptr, &err, NULL, &key, &ops, NULL) != AEROSPIKE_OK) {
+    if (aerospike_key_operate(ptr, &err, &policy, &key, &ops, NULL) != AEROSPIKE_OK) {
         printf("error\n");
         fprintf(stderr, "err(%d) %s at [%s:%d]\n", err.code, err.message, err.file, err.line);
     }
-    printf("finish\n");
 
     as_operations_destroy(&ops);
 
@@ -176,12 +378,8 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
 
 // GET
 // PUT
-// OPERATE
 
 // Record
-// Key
-// Bin
-// Policy
 
 void define_client()
 {
@@ -189,4 +387,6 @@ void define_client()
     rb_define_alloc_func(ClientClass, client_allocate);
     rb_define_method(ClientClass, "initialize", client_initialize, -1);
     rb_define_method(ClientClass, "operate", client_operate, -1);
+    rb_define_method(ClientClass, "put", client_put, -1);
+    rb_define_method(ClientClass, "get", client_get, -1);
 }

data/ext/aerospike_native/key.c

@@ -15,6 +15,15 @@ VALUE key_initialize(VALUE vSelf, VALUE vNamespace, VALUE vSet, VALUE vValue)
     return vSelf;
 }
 
+void check_aerospike_key(VALUE vKey)
+{
+    char sKeyName[] = "AerospikeNative::Key";
+
+    if (strcmp(sKeyName, rb_obj_classname(vKey)) != 0) {
+        rb_raise(rb_eArgError, "Incorrect type (expected %s)", sKeyName);
+    }
+}
+
 void define_native_key()
 {
     KeyClass = rb_define_class_under(AerospikeNativeClass, "Key", rb_cObject);

data/ext/aerospike_native/key.h

@@ -5,6 +5,7 @@
 
 extern VALUE KeyClass;
 void define_native_key();
+void check_aerospike_key(VALUE vKey);
 
 #endif // KEY_H
 

data/ext/aerospike_native/operation.c

@@ -23,6 +23,30 @@ VALUE operation_write(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+VALUE operation_append(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
+{
+    VALUE vArgs[3];
+
+    Check_Type(vBinValue, T_STRING);
+
+    vArgs[0] = INT2NUM(APPEND);
+    vArgs[1] = vBinName;
+    vArgs[2] = vBinValue;
+    return rb_class_new_instance(3, vArgs, vSelf);
+}
+
+VALUE operation_prepend(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
+{
+    VALUE vArgs[3];
+
+    Check_Type(vBinValue, T_STRING);
+
+    vArgs[0] = INT2NUM(PREPEND);
+    vArgs[1] = vBinName;
+    vArgs[2] = vBinValue;
+    return rb_class_new_instance(3, vArgs, vSelf);
+}
+
 VALUE operation_increment(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
 {
     VALUE vArgs[3];
@@ -40,6 +64,8 @@ void define_operation()
     OperationClass = rb_define_class_under(AerospikeNativeClass, "Operation", rb_cObject);
     rb_define_method(OperationClass, "initialize", operation_initialize, 3);
     rb_define_singleton_method(OperationClass, "write", operation_write, 2);
+    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_attr(OperationClass, "op_type", 1, 0);
     rb_define_attr(OperationClass, "bin_name", 1, 0);

data/ext/aerospike_native/record.c

@@ -0,0 +1,33 @@
+#include "record.h"
+#include "key.h"
+
+VALUE RecordClass;
+
+VALUE record_initialize(VALUE vSelf, VALUE vKey, VALUE vBins, VALUE vGen, VALUE vTtl)
+{
+    check_aerospike_key(vKey);
+    Check_Type(vBins, T_HASH);
+    Check_Type(vGen, T_FIXNUM);
+    Check_Type(vTtl, T_FIXNUM);
+
+    rb_iv_set(vSelf, "@key", vKey);
+    rb_iv_set(vSelf, "@bins", vBins);
+    rb_iv_set(vSelf, "@gen", vGen);
+    rb_iv_set(vSelf, "@ttl", vTtl);
+
+    return vSelf;
+}
+
+
+void define_record()
+{
+    RecordClass = rb_define_class_under(AerospikeNativeClass, "Record", rb_cObject);
+    rb_define_method(RecordClass, "initialize", record_initialize, 4);
+    rb_define_attr(RecordClass, "key", 1, 0);
+    rb_define_attr(RecordClass, "bins", 1, 0);
+    rb_define_attr(RecordClass, "gen", 1, 0);
+    rb_define_attr(RecordClass, "ttl", 1, 0);
+}
+
+
+

data/ext/aerospike_native/record.h

@@ -0,0 +1,10 @@
+#ifndef RECORD_H
+#define RECORD_H
+
+#include "aerospike_native.h"
+
+extern VALUE RecordClass;
+void define_record();
+
+#endif // RECORD_H
+

data/lib/aerospike_native/version.rb

@@ -1,3 +1,3 @@
 module AerospikeNative
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Vladimir Ziablitskii
@@ -93,6 +93,8 @@ files:
 - ext/aerospike_native/lib/.keep
 - ext/aerospike_native/operation.c
 - ext/aerospike_native/operation.h
+- ext/aerospike_native/record.c
+- ext/aerospike_native/record.h
 - lib/aerospike_native.rb
 - lib/aerospike_native/version.rb
 homepage: https://github.com/rainlabs/aerospike_native