aerospike_native 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c51c0e08ade86fe6ee4a30dc9e7013601f4fd500
-  data.tar.gz: 613a8f40a4f5953a52ec7bf58868d12329a61485
+  metadata.gz: c3a4c1501ed65384aa0a0d8dd90db474e0ff72de
+  data.tar.gz: 04e3a37359e96e9a753fb2dd88ab1251d68d9290
 SHA512:
-  metadata.gz: d0e496f4a413e7c14aac31c9603aecbdd7fc33446928be8087d956e4bb1ec70fd72e909305feb0de3863b4e593f065bbad769e7a482b21f7f68480465fa96373
-  data.tar.gz: 11fe87341e7d90de314dab1d0369ab931d5e4ce84be95b9fbca1ec1cffb3067a7ed0e2e331540452d7b7adf4ff82c689718347d702a5fc7bd3f3b1f9341114be
+  metadata.gz: 9ceaf60e6dbe985eee662d96f931af9caf2a95573f3612a0b53411cf38fd57da4f0e9713092883eaf41301b665ea1bd29e8c1f9792356b62773d2978c54aa3d6
+  data.tar.gz: b962db5ee9f2f2d394424c3a7eeaee3f36ff14f613d727337e3251abbb4518881f3e4077fd5ba2591d5543cd5ae81332eb325dd39d9ee6500d5c30beb5e7f34d

data/README.md

@@ -28,9 +28,9 @@ Or install it yourself as:
 * `exixts?` command
 * `where` command (query support)
 * :disappointed: Raw (bytes) type is not supported
-* Supported timeout for policies
+* Supported policies with all parameters for described commands
 * Supported digest keys
-* Supported exceptions (`AerospikeNative::Exception`) with several error codes constants like `AerospikeNative::Exception::ERR_CLIENT`
+* Supported exceptions (`AerospikeNative::Exception`) with several error codes constants `AerospikeNative::Exception.constants`
 * Index management (`create_index` and `drop_index`)
 
 ## Usage

data/ext/aerospike_native/aerospike_native.c

@@ -4,6 +4,7 @@
 #include "operation.h"
 #include "record.h"
 #include "condition.h"
+#include "policy.h"
 
 VALUE AerospikeNativeClass;
 
@@ -16,6 +17,7 @@ void Init_aerospike_native()
     define_record();
     define_operation();
     define_condition();
+    define_policy();
 
     rb_define_const(AerospikeNativeClass, "INDEX_NUMERIC", INT2FIX(INDEX_NUMERIC));
     rb_define_const(AerospikeNativeClass, "INDEX_STRING", INT2FIX(INDEX_STRING));

data/ext/aerospike_native/client.c

@@ -30,6 +30,13 @@ static VALUE client_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * call-seq:
+ *   new() -> AerospikeNative::Client
+ *   new(hosts) -> AerospikeNative::Client
+ *
+ * initialize new client, use {'host' => ..., 'port' => ...} for each hosts element
+ */
 VALUE client_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE ary = Qnil;
@@ -82,6 +89,13 @@ VALUE client_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq:
+ *   put(key, bins) -> true or false
+ *   put(key, bins, policy_settings) -> true or false
+ *
+ * put bins to specified key, bins are hash
+ */
 VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
@@ -108,8 +122,8 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
 
     as_policy_write_init(&policy);
 
-    if (argc == 3) {
-        SET_POLICY(policy, vArgs[2]);
+    if (argc == 3 && TYPE(vArgs[2]) != T_NIL) {
+        SET_WRITE_POLICY(policy, vArgs[2]);
     }
 
     idx = RHASH_SIZE(vBins);
@@ -135,7 +149,7 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
             as_record_set_int64(&record, StringValueCStr(bin_name), NUM2LONG(bin_value));
             break;
         default:
-            rb_raise(rb_eArgError, "Incorrect input type (expected string or fixnum)");
+            rb_raise(rb_eTypeError, "wrong argument type for bin value (expected Fixnum or String)");
             break;
         }
      }
@@ -151,19 +165,22 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
     return Qtrue;
 }
 
+/*
+ * call-seq:
+ *   get(key) -> AerospikeNative::Record
+ *   get(key, policy_settings) -> AerospikeNative::Record
+ *
+ * get record
+ */
 VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
-    VALUE vParams[4];
 
     aerospike *ptr;
     as_key* key;
     as_error err;
     as_record* record = NULL;
     as_policy_read policy;
-    as_bin bin;
-
-    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);
@@ -174,8 +191,8 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
 
     as_policy_read_init(&policy);
 
-    if (argc == 2) {
-        SET_POLICY(policy, vArgs[1]);
+    if (argc == 2 && TYPE(vArgs[1]) != T_NIL) {
+        SET_READ_POLICY(policy, vArgs[1]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -186,35 +203,20 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
         raise_aerospike_exception(err.code, err.message);
     }
 
-    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);
+    return rb_record_from_c(record, key);
 }
 
+/*
+ * call-seq:
+ *   operate(key, operations) -> true, false or AerospikeNative::Record
+ *   operate(key, operations, policy_settings) -> true, false or AerospikeNative::Record
+ *
+ * perform multiple operations in one transaction, operations are array of AerospikeNative::Operation
+ */
 VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
     VALUE vOperations;
-    VALUE vParams[4];
     long idx = 0, n = 0;
     bool isset_read = false;
 
@@ -224,7 +226,6 @@ VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
     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);
@@ -237,8 +238,8 @@ VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
     Check_Type(vOperations, T_ARRAY);
     as_policy_operate_init(&policy);
 
-    if (argc == 3) {
-        SET_POLICY(policy, vArgs[2]);
+    if (argc == 3 && TYPE(vArgs[2]) != T_NIL) {
+        SET_OPERATE_POLICY(policy, vArgs[2]);
     }
 
     idx = RARRAY_LEN(vOperations);
@@ -303,28 +304,7 @@ VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
 
         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);
+        return rb_record_from_c(record, key);
     } else {
         if (aerospike_key_operate(ptr, &err, &policy, key, &ops, NULL) != AEROSPIKE_OK) {
             as_operations_destroy(&ops);
@@ -336,6 +316,13 @@ VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
     }
 }
 
+/*
+ * call-seq:
+ *   remove(key) -> true or false
+ *   remove(key, policy_settings) -> true or false
+ *
+ * remove record
+ */
 VALUE client_remove(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
@@ -352,8 +339,8 @@ VALUE client_remove(int argc, VALUE* vArgs, VALUE vSelf)
     vKey = vArgs[0];
     check_aerospike_key(vKey);
 
-    if (argc == 2) {
-        SET_POLICY(policy, vArgs[2]);
+    if (argc == 2 && TYPE(vArgs[2]) != T_NIL) {
+        SET_REMOVE_POLICY(policy, vArgs[2]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -366,6 +353,13 @@ VALUE client_remove(int argc, VALUE* vArgs, VALUE vSelf)
     return Qtrue;
 }
 
+/*
+ * call-seq:
+ *   exists?(key) -> true or false
+ *   exists?(key, policy_settings) -> true or false
+ *
+ * check existing record by key
+ */
 VALUE client_exists(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
@@ -384,8 +378,8 @@ VALUE client_exists(int argc, VALUE* vArgs, VALUE vSelf)
     vKey = vArgs[0];
     check_aerospike_key(vKey);
 
-    if (argc == 2) {
-        SET_POLICY(policy, vArgs[1]);
+    if (argc == 2 && TYPE(vArgs[1]) != T_NIL) {
+        SET_READ_POLICY(policy, vArgs[1]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -405,18 +399,23 @@ VALUE client_exists(int argc, VALUE* vArgs, VALUE vSelf)
     return Qtrue;
 }
 
+/*
+ * call-seq:
+ *   select(key, bins) -> AerospikeNative::Record
+ *   select(key, bins, policy_settings) -> AerospikeNative::Record
+ *
+ * select specified bins by key
+ */
 VALUE client_select(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
     VALUE vArray;
-    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
@@ -433,8 +432,8 @@ VALUE client_select(int argc, VALUE* vArgs, VALUE vSelf)
         return Qfalse;
     }
 
-    if (argc == 3) {
-        SET_POLICY(policy, vArgs[2]);
+    if (argc == 3 && TYPE(vArgs[2]) != T_NIL) {
+        SET_READ_POLICY(policy, vArgs[2]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -462,30 +461,16 @@ VALUE client_select(int argc, VALUE* vArgs, VALUE vSelf)
         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);
+    return rb_record_from_c(record, key);
 }
 
+/*
+ * call-seq:
+ *   create_index(namespace, set, bin_name, index_name) -> true or false
+ *   create_index(namespace, set, bin_name, index_name, policy_settings) -> true or false
+ *
+ * Create new index, use {'type' => AerospikeNative::INDEX_NUMERIC or AerospikeNative::INDEX_STRING} as policy_settings to define index type
+ */
 VALUE client_create_index(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vNamespace, vSet, vBinName, vIndexName;
@@ -512,9 +497,9 @@ VALUE client_create_index(int argc, VALUE* vArgs, VALUE vSelf)
     vIndexName = vArgs[3];
     Check_Type(vIndexName, T_STRING);
 
-    if (argc == 5) {
+    if (argc == 5 && TYPE(vArgs[4]) != T_NIL) {
         VALUE vType = Qnil;
-        SET_POLICY(policy, vArgs[4]);
+        SET_INFO_POLICY(policy, vArgs[4]);
         vType = rb_hash_aref(vArgs[4], rb_str_new2("type"));
         if (TYPE(vType) == T_FIXNUM) {
             switch(FIX2INT(vType)) {
@@ -544,13 +529,22 @@ VALUE client_create_index(int argc, VALUE* vArgs, VALUE vSelf)
 
     task.as = ptr;
     strcpy(task.ns, StringValueCStr(vNamespace));
-    strcpy(task.name, StringValueCStr(vBinName));
+    strcpy(task.name, StringValueCStr(vIndexName));
     task.done = false;
-    aerospike_index_create_wait(&err, &task, 1000);
+    if (aerospike_index_create_wait(&err, &task, 1000) != AEROSPIKE_OK) {
+        raise_aerospike_exception(err.code, err.message);
+    }
 
     return (task.done ? Qtrue : Qfalse);
 }
 
+/*
+ * call-seq:
+ *   drop_index(namespace, index_name) -> true or false
+ *   drop_index(namespace, index_name, policy_settings) -> true or false
+ *
+ * Remove specified index from node
+ */
 VALUE client_drop_index(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vNamespace, vIndexName;
@@ -569,8 +563,8 @@ VALUE client_drop_index(int argc, VALUE* vArgs, VALUE vSelf)
     vIndexName = vArgs[1];
     Check_Type(vIndexName, T_STRING);
 
-    if (argc == 3) {
-        SET_POLICY(policy, vArgs[2]);
+    if (argc == 3 && TYPE(vArgs[2]) != T_NIL) {
+        SET_INFO_POLICY(policy, vArgs[2]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -583,12 +577,8 @@ VALUE client_drop_index(int argc, VALUE* vArgs, VALUE vSelf)
 }
 
 bool query_callback(const as_val *value, void *udata) {
-    VALUE vParams[4], vKeyParams[4];
     VALUE vRecord;
-
     as_record *record;
-    as_bin bin;
-    int n;
 
     if (value == NULL) {
         // query is complete
@@ -598,54 +588,36 @@ bool query_callback(const as_val *value, void *udata) {
     record = as_record_fromval(value);
 
     if (record != NULL) {
-        vKeyParams[0] = rb_str_new2(record->key.ns);
-        vKeyParams[1] = rb_str_new2(record->key.set);
-
-        if (record->key.valuep == NULL) {
-            vKeyParams[2] = Qnil;
-        } else {
-            vKeyParams[2] = rb_str_new2(record->key.value.string.value);
-        }
-        vKeyParams[3] = rb_str_new(record->key.digest.value, AS_DIGEST_VALUE_SIZE);
-
-        vParams[0] = rb_class_new_instance(4, vKeyParams, KeyClass);
-        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);
-        vRecord = rb_class_new_instance(4, vParams, RecordClass);
+        vRecord = rb_record_from_c(record, NULL);
 
         if ( rb_block_given_p() ) {
             rb_yield(vRecord);
         } else {
-            // TODO: write default aggregate block
+            VALUE *vArray = (VALUE*) udata;
+            rb_ary_push(*vArray, vRecord);
         }
     }
 
     return true;
 }
 
+/*
+ * call-seq:
+ *   where(namespace, set) -> array
+ *   where(namespace, set, conditions) -> array
+ *   where(namespace, set, conditions, policy_settings) -> array
+ *   where(namespace, set) { |record| ... } -> nil
+ *   where(namespace, set, conditions) { |record| ... } -> nil
+ *   where(namespace, set, conditions, policy_settings) { |record| ... } -> nil
+ *
+ * Perform a query with where clause
+ */
 VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vNamespace;
     VALUE vSet;
     VALUE vConditions;
+    VALUE vArray;
 
     aerospike *ptr;
     as_error err;
@@ -654,13 +626,8 @@ VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
 
     int idx = 0, n = 0;
 
-    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);
-    }
-
-    // TODO: write default aggregate block
-    if ( !rb_block_given_p() ) {
-        rb_raise(rb_eArgError, "no block given");
+    if (argc > 4 || argc < 2) {  // there should only be 2, 3 or 4 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..4)", argc);
     }
 
     vNamespace = vArgs[0];
@@ -670,18 +637,21 @@ VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
     Check_Type(vSet, T_STRING);
 
     vConditions = vArgs[2];
-    Check_Type(vConditions, T_ARRAY);
+    switch(TYPE(vConditions)) {
+    case T_NIL:
+        break;
+    case T_ARRAY:
+        idx = RARRAY_LEN(vConditions);
+        break;
+    default:
+        rb_raise(rb_eTypeError, "wrong argument type for condition (expected Array or Nil)");
+    }
 
     as_policy_query_init(&policy);
-    if (argc == 4) {
+    if (argc == 4 && TYPE(vArgs[3]) != T_NIL) {
         SET_POLICY(policy, vArgs[3]);
     }
 
-    idx = RARRAY_LEN(vConditions);
-    if (idx == 0) {
-        return Qnil;
-    }
-
     Data_Get_Struct(vSelf, aerospike, ptr);
 
     as_query_init(&query, StringValueCStr(vNamespace), StringValueCStr(vSet));
@@ -717,13 +687,18 @@ VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
         }
     }
 
-    if (aerospike_query_foreach(ptr, &err, &policy, &query, query_callback, NULL) != AEROSPIKE_OK) {
+    vArray = rb_ary_new();
+    if (aerospike_query_foreach(ptr, &err, &policy, &query, query_callback, &vArray) != AEROSPIKE_OK) {
         as_query_destroy(&query);
         raise_aerospike_exception(err.code, err.message);
     }
     as_query_destroy(&query);
 
-    return Qnil;
+    if ( rb_block_given_p() ) {
+        return Qnil;
+    }
+
+    return vArray;
 }
 
 void define_client()

data/ext/aerospike_native/common.h

@@ -7,20 +7,163 @@
 VALUE rb_hash_keys(VALUE hash);
 
 #define SET_POLICY(policy, vSettings)                                      \
-    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 );                         \
+    VALUE vTimeout;                                                        \
+    Check_Type(vSettings, T_HASH);                                         \
+    vTimeout = rb_hash_aref(vSettings, rb_str_new2("timeout"));            \
+    if (TYPE(vTimeout) == T_FIXNUM) {                                      \
+        policy.timeout = NUM2UINT( vTimeout );                             \
+    }
+
+#define SET_RETRY_POLICY(policy, vSettings)                                \
+    vRetry = rb_hash_aref(vSettings, rb_str_new2("retry"));                \
+    if (TYPE(vRetry) == T_FIXNUM) {                                        \
+        int policy_retry = FIX2INT(vRetry);                                \
+        switch(policy_retry) {                                             \
+        case AS_POLICY_RETRY_NONE:                                         \
+        case AS_POLICY_RETRY_ONCE:                                         \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"retry\" policy value");    \
+        }                                                                  \
+        policy.retry = policy_retry;                                       \
+    }
+
+#define SET_KEY_POLICY(policy, vSettings)                                  \
+    vKey = rb_hash_aref(vSettings, rb_str_new2("key"));                    \
+    if (TYPE(vKey) == T_FIXNUM) {                                          \
+        int policy_key = FIX2INT(vKey);                                    \
+        switch(policy_key) {                                               \
+        case AS_POLICY_KEY_DIGEST:                                         \
+        case AS_POLICY_KEY_SEND:                                           \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"key\" policy value");      \
+        }                                                                  \
+        policy.key = policy_key;                                           \
+    }
+
+#define SET_GEN_POLICY(policy, vSettings)                                  \
+    vGen = rb_hash_aref(vSettings, rb_str_new2("gen"));                    \
+    if (TYPE(vGen) == T_FIXNUM) {                                          \
+        int policy_gen = FIX2INT(vGen);                                    \
+        switch(policy_gen) {                                               \
+        case AS_POLICY_GEN_IGNORE:                                         \
+        case AS_POLICY_GEN_EQ:                                             \
+        case AS_POLICY_GEN_GT:                                             \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"gen\" policy value");      \
+        }                                                                  \
+        policy.gen = policy_gen;                                           \
+    }
+
+#define SET_EXISTS_POLICY(policy, vSettings)                               \
+    vExists = rb_hash_aref(vSettings, rb_str_new2("exists"));              \
+    if (TYPE(vExists) == T_FIXNUM) {                                       \
+        int policy_exists = FIX2INT(vExists);                              \
+        switch(policy_exists) {                                            \
+        case AS_POLICY_EXISTS_CREATE:                                      \
+        case AS_POLICY_EXISTS_CREATE_OR_REPLACE:                           \
+        case AS_POLICY_EXISTS_IGNORE:                                      \
+        case AS_POLICY_EXISTS_REPLACE:                                     \
+        case AS_POLICY_EXISTS_UPDATE:                                      \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"exists\" policy value");   \
+        }                                                                  \
+        policy.exists = policy_exists;                                     \
+    }
+
+#define SET_COMMIT_LEVEL_POLICY(policy, vSettings)                         \
+    vCommitLevel = rb_hash_aref(vSettings, rb_str_new2("commit_level"));   \
+    if (TYPE(vCommitLevel) == T_FIXNUM) {                                  \
+        int policy_commit = FIX2INT(vCommitLevel);                         \
+        switch(policy_commit) {                                            \
+        case AS_POLICY_COMMIT_LEVEL_ALL:                                   \
+        case AS_POLICY_COMMIT_LEVEL_MASTER:                                \
+            break;                                                         \
+        default:                                                           \
+         rb_raise(rb_eArgError, "Incorrect \"commit_level\" policy value");\
         }                                                                  \
-        break;                                                             \
+        policy.commit_level = policy_commit;                               \
+    }
+
+#define SET_REPLICA_POLICY(policy, vSettings)                              \
+    vReplica = rb_hash_aref(vSettings, rb_str_new2("replica"));            \
+    if (TYPE(vReplica) == T_FIXNUM) {                                      \
+        int policy_replica = FIX2INT(vReplica);                            \
+        switch(policy_replica) {                                           \
+        case AS_POLICY_REPLICA_ANY:                                        \
+        case AS_POLICY_REPLICA_MASTER:                                     \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"replica\" policy value");  \
+        }                                                                  \
+        policy.replica = policy_replica;                                   \
+    }
+
+#define SET_CONSISTENCY_LEVEL_POLICY(policy, vSettings)                    \
+    vConsistencyLevel = rb_hash_aref(vSettings, rb_str_new2("consistency_level")); \
+    if (TYPE(vConsistencyLevel) == T_FIXNUM) {                             \
+        int policy_consistency_level = FIX2INT(vConsistencyLevel);         \
+        switch(policy_consistency_level) {                                 \
+        case AS_POLICY_CONSISTENCY_LEVEL_ALL:                              \
+        case AS_POLICY_CONSISTENCY_LEVEL_ONE:                              \
+            break;                                                         \
+        default:                                                           \
+            rb_raise(rb_eArgError, "Incorrect \"consistency_level\" policy value"); \
+        }                                                                  \
+        policy.consistency_level = policy_consistency_level;               \
+    }
+
+#define SET_WRITE_POLICY(policy, vSettings)                                \
+    VALUE vRetry, vKey, vGen, vExists, vCommitLevel;                       \
+    SET_POLICY(policy, vSettings);                                         \
+    SET_RETRY_POLICY(policy, vSettings);                                   \
+    SET_KEY_POLICY(policy, vSettings);                                     \
+    SET_GEN_POLICY(policy, vSettings);                                     \
+    SET_EXISTS_POLICY(policy, vSettings);                                  \
+    SET_COMMIT_LEVEL_POLICY(policy, vSettings);
+
+#define SET_READ_POLICY(policy, vSettings)                                 \
+    VALUE vKey, vReplica, vConsistencyLevel;                               \
+    SET_POLICY(policy, vSettings);                                         \
+    SET_KEY_POLICY(policy, vSettings);                                     \
+    SET_REPLICA_POLICY(policy, vSettings);                                 \
+    SET_CONSISTENCY_LEVEL_POLICY(policy, vSettings);
+
+#define SET_OPERATE_POLICY(policy, vSettings)                              \
+    VALUE vRetry, vKey, vGen, vReplica, vConsistencyLevel, vCommitLevel;   \
+    SET_POLICY(policy, vSettings);                                         \
+    SET_RETRY_POLICY(policy, vSettings);                                   \
+    SET_KEY_POLICY(policy, vSettings);                                     \
+    SET_GEN_POLICY(policy, vSettings);                                     \
+    SET_REPLICA_POLICY(policy, vSettings);                                 \
+    SET_CONSISTENCY_LEVEL_POLICY(policy, vSettings);                       \
+    SET_COMMIT_LEVEL_POLICY(policy, vSettings);
+
+#define SET_REMOVE_POLICY(policy, vSettings)                               \
+    VALUE vRetry, vKey, vGen, vCommitLevel, vGeneration;                   \
+    SET_POLICY(policy, vSettings);                                         \
+    SET_RETRY_POLICY(policy, vSettings);                                   \
+    SET_KEY_POLICY(policy, vSettings);                                     \
+    SET_GEN_POLICY(policy, vSettings);                                     \
+    SET_COMMIT_LEVEL_POLICY(policy, vSettings);                            \
+    vGeneration = rb_hash_aref(vSettings, rb_str_new2("generation"));      \
+    if (TYPE(vGeneration) == T_FIXNUM) {                                   \
+        policy.generation = FIX2UINT(vGeneration);                         \
+    }
+
+#define SET_INFO_POLICY(policy, vSettings)                                 \
+    VALUE vSendAsIs, vCheckBounds;                                         \
+    SET_POLICY(policy, vSettings);                                         \
+    vSendAsIs = rb_hash_aref(vSettings, rb_str_new2("send_as_is"));        \
+    if (TYPE(vSendAsIs) != T_NIL) {                                        \
+        policy.send_as_is = RTEST(vSendAsIs);                              \
     }                                                                      \
-    default:                                                               \
-        /* raise exception */                                              \
-        Check_Type(vSettings, T_HASH);                                     \
-        break;                                                             \
+    vCheckBounds = rb_hash_aref(vSettings, rb_str_new2("check_bounds"));   \
+    if (TYPE(vCheckBounds) != T_NIL) {                                     \
+        policy.check_bounds = RTEST(vCheckBounds);                         \
     }
 
 #endif // COMMON_H

data/ext/aerospike_native/condition.c

@@ -29,7 +29,7 @@ VALUE condition_initialize(VALUE vSelf, VALUE vBinName, VALUE vIndexType, VALUE
         case T_FIXNUM:
             break;
         default:
-            rb_raise(rb_eArgError, "Expected FIXNUM or NIL value");
+            rb_raise(rb_eTypeError, "wrong argument type for max value (expected Fixnum or Nil)");
         }
         break;
     case INDEX_STRING:
@@ -39,7 +39,7 @@ VALUE condition_initialize(VALUE vSelf, VALUE vBinName, VALUE vIndexType, VALUE
         case T_STRING:
             break;
         default:
-            rb_raise(rb_eArgError, "Expected STRING or NIL value");
+            rb_raise(rb_eTypeError, "wrong argument type for max value (expected String or Nil)");
         }
         break;
     default:
@@ -80,7 +80,7 @@ VALUE condition_equal(VALUE vSelf, VALUE vBinName, VALUE vVal)
         index_type = INDEX_STRING;
         break;
     default:
-        rb_raise(rb_eArgError, "Expected only FIXNUM or STRING types");
+        rb_raise(rb_eTypeError, "wrong argument type for value (expected Fixnum or String)");
     }
 
     vArgs[0] = vBinName;

data/ext/aerospike_native/key.c

@@ -19,6 +19,13 @@ static VALUE key_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * 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;
@@ -43,7 +50,7 @@ VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
 
     Data_Get_Struct(vSelf, as_key, ptr);
 
-    if(TYPE(vDigest) == T_NIL) {
+    if(TYPE(vValue) == T_STRING) {
         switch(TYPE(vValue)) {
         case T_FIXNUM:
             as_key_init_int64(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), FIX2LONG( vValue ));

data/ext/aerospike_native/operation.c

@@ -2,6 +2,12 @@
 
 VALUE OperationClass;
 
+/*
+ * call-seq:
+ *   new(operation_type, bin_name, bin_value) -> AerospikeNative::Operation
+ *
+ * initialize new operation for client.operate command
+ */
 VALUE operation_initialize(VALUE vSelf, VALUE vOpType, VALUE vBinName, VALUE vBinValue)
 {
     int op_type = 0;
@@ -22,6 +28,12 @@ VALUE operation_initialize(VALUE vSelf, VALUE vOpType, VALUE vBinName, VALUE vBi
     return vSelf;
 }
 
+/*
+ * call-seq:
+ *   write(bin_name, bin_value) -> AerospikeNative::Operation
+ *
+ * initialize new write operation
+ */
 VALUE operation_write(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
 {
     VALUE vArgs[3];
@@ -31,6 +43,12 @@ VALUE operation_write(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+/*
+ * call-seq:
+ *   append(bin_name, bin_value) -> AerospikeNative::Operation
+ *
+ * initialize new append operation
+ */
 VALUE operation_append(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
 {
     VALUE vArgs[3];
@@ -43,6 +61,12 @@ VALUE operation_append(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+/*
+ * call-seq:
+ *   prepend(bin_name, bin_value) -> AerospikeNative::Operation
+ *
+ * initialize new prepend operation
+ */
 VALUE operation_prepend(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
 {
     VALUE vArgs[3];
@@ -55,6 +79,12 @@ VALUE operation_prepend(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+/*
+ * call-seq:
+ *   increment(bin_name, bin_value) -> AerospikeNative::Operation
+ *
+ * initialize new increment operation
+ */
 VALUE operation_increment(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
 {
     VALUE vArgs[3];
@@ -67,6 +97,12 @@ VALUE operation_increment(VALUE vSelf, VALUE vBinName, VALUE vBinValue)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+/*
+ * call-seq:
+ *   touch() -> AerospikeNative::Operation
+ *
+ * initialize new touch operation
+ */
 VALUE operation_touch(VALUE vSelf)
 {
     VALUE vArgs[3];
@@ -77,6 +113,12 @@ VALUE operation_touch(VALUE vSelf)
     return rb_class_new_instance(3, vArgs, vSelf);
 }
 
+/*
+ * call-seq:
+ *   read(bin_name) -> AerospikeNative::Operation
+ *
+ * initialize new read operation
+ */
 VALUE operation_read(VALUE vSelf, VALUE vBinName)
 {
     VALUE vArgs[3];

data/ext/aerospike_native/policy.c

@@ -0,0 +1,34 @@
+#include "policy.h"
+#include <aerospike/as_policy.h>
+
+VALUE PolicyClass;
+
+void define_policy()
+{
+    PolicyClass = rb_define_class_under(AerospikeNativeClass, "Policy", rb_cObject);
+
+    rb_define_const(PolicyClass, "RETRY_NONE", INT2FIX(AS_POLICY_RETRY_NONE));
+    rb_define_const(PolicyClass, "RETRY_ONCE", INT2FIX(AS_POLICY_RETRY_ONCE));
+
+    rb_define_const(PolicyClass, "KEY_DIGEST", INT2FIX(AS_POLICY_KEY_DIGEST));
+    rb_define_const(PolicyClass, "KEY_SEND", INT2FIX(AS_POLICY_KEY_SEND));
+
+    rb_define_const(PolicyClass, "GEN_IGNORE", INT2FIX(AS_POLICY_GEN_IGNORE));
+    rb_define_const(PolicyClass, "GEN_EQ", INT2FIX(AS_POLICY_GEN_EQ));
+    rb_define_const(PolicyClass, "GEN_GT", INT2FIX(AS_POLICY_GEN_GT));
+
+    rb_define_const(PolicyClass, "EXISTS_CREATE", INT2FIX(AS_POLICY_EXISTS_CREATE));
+    rb_define_const(PolicyClass, "EXISTS_CREATE_OR_REPLACE", INT2FIX(AS_POLICY_EXISTS_CREATE_OR_REPLACE));
+    rb_define_const(PolicyClass, "EXISTS_IGNORE", INT2FIX(AS_POLICY_EXISTS_IGNORE));
+    rb_define_const(PolicyClass, "EXISTS_REPLACE", INT2FIX(AS_POLICY_EXISTS_REPLACE));
+    rb_define_const(PolicyClass, "EXISTS_UPDATE", INT2FIX(AS_POLICY_EXISTS_UPDATE));
+
+    rb_define_const(PolicyClass, "COMMIT_LEVEL_ALL", INT2FIX(AS_POLICY_COMMIT_LEVEL_ALL));
+    rb_define_const(PolicyClass, "COMMIT_LEVEL_MASTER", INT2FIX(AS_POLICY_COMMIT_LEVEL_MASTER));
+
+    rb_define_const(PolicyClass, "REPLICA_ANY", INT2FIX(AS_POLICY_REPLICA_ANY));
+    rb_define_const(PolicyClass, "REPLICA_MASTER", INT2FIX(AS_POLICY_REPLICA_MASTER));
+
+    rb_define_const(PolicyClass, "CONSISTENCY_LEVEL_ALL", INT2FIX(AS_POLICY_CONSISTENCY_LEVEL_ALL));
+    rb_define_const(PolicyClass, "CONSISTENCY_LEVEL_ONE", INT2FIX(AS_POLICY_CONSISTENCY_LEVEL_ONE));
+}

data/ext/aerospike_native/policy.h

@@ -0,0 +1,10 @@
+#ifndef POLICY_H
+#define POLICY_H
+
+#include "aerospike_native.h"
+
+RUBY_EXTERN VALUE PolicyClass;
+void define_policy();
+
+#endif // POLICY_H
+

data/ext/aerospike_native/record.c

@@ -3,6 +3,12 @@
 
 VALUE RecordClass;
 
+/*
+ * call-seq:
+ *   new(key, bins, gen, ttl) -> AerospikeNative::Record
+ *
+ * initialize new record
+ */
 VALUE record_initialize(VALUE vSelf, VALUE vKey, VALUE vBins, VALUE vGen, VALUE vTtl)
 {
     check_aerospike_key(vKey);
@@ -18,6 +24,52 @@ VALUE record_initialize(VALUE vSelf, VALUE vKey, VALUE vBins, VALUE vGen, VALUE
     return vSelf;
 }
 
+VALUE rb_record_from_c(as_record* record, as_key* key)
+{
+    VALUE vKeyParams[5], vParams[4];
+    as_key current_key;
+    as_bin bin;
+    int n;
+
+    if (key == NULL) {
+        current_key = record->key;
+    } else {
+        current_key = *key;
+    }
+
+    vKeyParams[0] = rb_str_new2(current_key.ns);
+    vKeyParams[1] = rb_str_new2(current_key.set);
+
+    if (current_key.valuep == NULL) {
+        vKeyParams[2] = Qnil;
+    } else {
+        vKeyParams[2] = rb_str_new2(current_key.value.string.value);
+    }
+    vKeyParams[3] = rb_str_new(current_key.digest.value, AS_DIGEST_VALUE_SIZE);
+
+    vParams[0] = rb_class_new_instance(4, vKeyParams, KeyClass);
+    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_record()
 {

data/ext/aerospike_native/record.h

@@ -2,9 +2,12 @@
 #define RECORD_H
 
 #include "aerospike_native.h"
+#include <aerospike/as_record.h>
 
 RUBY_EXTERN VALUE RecordClass;
 void define_record();
 
+VALUE rb_record_from_c(as_record* record, as_key* key);
+
 #endif // RECORD_H
 

data/lib/aerospike_native/version.rb

@@ -1,3 +1,3 @@
 module AerospikeNative
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Vladimir Ziablitskii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-11 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,6 +97,8 @@ files:
 - ext/aerospike_native/lib/.keep
 - ext/aerospike_native/operation.c
 - ext/aerospike_native/operation.h
+- ext/aerospike_native/policy.c
+- ext/aerospike_native/policy.h
 - ext/aerospike_native/record.c
 - ext/aerospike_native/record.h
 - lib/aerospike_native.rb