aerospike_native 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db77dc977496b4ace18450a71245fe8dcd0cf4aa
-  data.tar.gz: 535112b2da7532923df5281f0a02d1b3e90e72be
+  metadata.gz: c51c0e08ade86fe6ee4a30dc9e7013601f4fd500
+  data.tar.gz: 613a8f40a4f5953a52ec7bf58868d12329a61485
 SHA512:
-  metadata.gz: 2757d76132519aa9c2abde4735bbab81d350f803cc538a524009bbceced035ed9543066ef2e98db627c8d1a267a2413098d82e13cae9c8058fdeee034121d1d0
-  data.tar.gz: 2c0b993989b2acbc8239fa745086b6dcdaca396cbcb51ada4b6d528519bf768ca41e8920137453f202cf664d3235590d881ae65cf439dbe93c90389799a41046
+  metadata.gz: d0e496f4a413e7c14aac31c9603aecbdd7fc33446928be8087d956e4bb1ec70fd72e909305feb0de3863b4e593f065bbad769e7a482b21f7f68480465fa96373
+  data.tar.gz: 11fe87341e7d90de314dab1d0369ab931d5e4ce84be95b9fbca1ec1cffb3067a7ed0e2e331540452d7b7adf4ff82c689718347d702a5fc7bd3f3b1f9341114be

data/README.md

@@ -26,10 +26,12 @@ Or install it yourself as:
 * `remove` command
 * `select` command
 * `exixts?` command
+* `where` command (query support)
 * :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`
+* Index management (`create_index` and `drop_index`)
 
 ## Usage
 
@@ -45,6 +47,15 @@ client.exists?(key)
 record = client.get(key)
 record = client.select(key, ['bin2', 'bin1'])
 client.remove(key)
+
+10.times do |i|
+  client.put(AerospikeNative::Key.new('test', 'test', "key#{i}"), {'number' => i, 'name' => 'key'})
+end
+client.create_index('test', 'test', 'number', 'number_idx');
+
+records = []
+client.where('test', 'test', [AerospikeNative::Condition.range("number", 1, 7)]) { |record| records << record }
+records
 ```
 
 ## Contributing

data/ext/aerospike_native/aerospike_native.c

@@ -3,6 +3,7 @@
 #include "key.h"
 #include "operation.h"
 #include "record.h"
+#include "condition.h"
 
 VALUE AerospikeNativeClass;
 
@@ -14,4 +15,8 @@ void Init_aerospike_native()
     define_native_key();
     define_record();
     define_operation();
+    define_condition();
+
+    rb_define_const(AerospikeNativeClass, "INDEX_NUMERIC", INT2FIX(INDEX_NUMERIC));
+    rb_define_const(AerospikeNativeClass, "INDEX_STRING", INT2FIX(INDEX_STRING));
 }

data/ext/aerospike_native/aerospike_native.h

@@ -3,8 +3,14 @@
 
 #include "common.h"
 #include <aerospike/aerospike.h>
+#include <aerospike/aerospike_index.h>
 
 RUBY_EXTERN VALUE AerospikeNativeClass;
 
+enum IndexType {
+    INDEX_STRING = AS_INDEX_STRING,
+    INDEX_NUMERIC = AS_INDEX_NUMERIC
+};
+
 #endif // AEROSPIKE_NATIVE_H
 

data/ext/aerospike_native/client.c

@@ -2,9 +2,12 @@
 #include "operation.h"
 #include "key.h"
 #include "record.h"
+#include "condition.h"
 #include <aerospike/as_key.h>
 #include <aerospike/as_operations.h>
 #include <aerospike/aerospike_key.h>
+#include <aerospike/aerospike_index.h>
+#include <aerospike/aerospike_query.h>
 
 VALUE ClientClass;
 
@@ -83,7 +86,6 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
     VALUE vBins;
-    VALUE vSettings;
     VALUE vHashKeys;
 
     aerospike *ptr;
@@ -107,23 +109,7 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
     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;
-        }
+        SET_POLICY(policy, vArgs[2]);
     }
 
     idx = RHASH_SIZE(vBins);
@@ -168,7 +154,6 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
 VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
-    VALUE vSettings;
     VALUE vParams[4];
 
     aerospike *ptr;
@@ -190,23 +175,7 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
     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;
-        }
+        SET_POLICY(policy, vArgs[1]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -241,11 +210,10 @@ VALUE client_get(int argc, VALUE* vArgs, VALUE vSelf)
     return rb_class_new_instance(4, vParams, RecordClass);
 }
 
-VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
+VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
     VALUE vOperations;
-    VALUE vSettings = Qnil;
     VALUE vParams[4];
     long idx = 0, n = 0;
     bool isset_read = false;
@@ -262,31 +230,15 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
     }
 
-    vKey = argv[0];
+    vKey = vArgs[0];
     check_aerospike_key(vKey);
 
-    vOperations = argv[1];
+    vOperations = vArgs[1];
     Check_Type(vOperations, T_ARRAY);
     as_policy_operate_init(&policy);
 
     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;
-        }
+        SET_POLICY(policy, vArgs[2]);
     }
 
     idx = RARRAY_LEN(vOperations);
@@ -331,6 +283,7 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
             as_operations_add_prepend_str(&ops, StringValueCStr( bin_name ), StringValueCStr( bin_value ));
             break;
         case OPERATION_TOUCH:
+            isset_read = true;
             as_operations_add_touch(&ops);
             break;
         default:
@@ -383,10 +336,9 @@ VALUE client_operate(int argc, VALUE* argv, VALUE vSelf)
     }
 }
 
-VALUE client_remove(int argc, VALUE* argv, VALUE vSelf)
+VALUE client_remove(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
-    VALUE vSettings = Qnil;
 
     aerospike *ptr;
     as_key* key;
@@ -397,27 +349,11 @@ VALUE client_remove(int argc, VALUE* argv, VALUE vSelf)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
     }
 
-    vKey = argv[0];
+    vKey = vArgs[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;
-        }
+        SET_POLICY(policy, vArgs[2]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -430,46 +366,26 @@ VALUE client_remove(int argc, VALUE* argv, VALUE vSelf)
     return Qtrue;
 }
 
-VALUE client_exists(int argc, VALUE* argv, VALUE vSelf)
+VALUE client_exists(int argc, VALUE* vArgs, 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];
+    vKey = vArgs[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;
-        }
+        SET_POLICY(policy, vArgs[1]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -489,11 +405,10 @@ VALUE client_exists(int argc, VALUE* argv, VALUE vSelf)
     return Qtrue;
 }
 
-VALUE client_select(int argc, VALUE* argv, VALUE vSelf)
+VALUE client_select(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vKey;
     VALUE vArray;
-    VALUE vSettings = Qnil;
     VALUE vParams[4];
 
     aerospike *ptr;
@@ -508,9 +423,9 @@ VALUE client_select(int argc, VALUE* argv, VALUE vSelf)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
     }
 
-    vKey = argv[0];
+    vKey = vArgs[0];
     check_aerospike_key(vKey);
-    vArray = argv[1];
+    vArray = vArgs[1];
 
     Check_Type(vArray, T_ARRAY);
     idx = RARRAY_LEN(vArray);
@@ -519,23 +434,7 @@ VALUE client_select(int argc, VALUE* argv, VALUE vSelf)
     }
 
     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;
-        }
+        SET_POLICY(policy, vArgs[2]);
     }
 
     Data_Get_Struct(vSelf, aerospike, ptr);
@@ -587,6 +486,246 @@ VALUE client_select(int argc, VALUE* argv, VALUE vSelf)
     return rb_class_new_instance(4, vParams, RecordClass);
 }
 
+VALUE client_create_index(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vNamespace, vSet, vBinName, vIndexName;
+
+    aerospike *ptr;
+    as_error err;
+    as_policy_info policy;
+    as_index_task task;
+    bool is_integer = true;
+
+    if (argc > 5 || argc < 4) {  // there should only be 4 or 5 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 4..5)", argc);
+    }
+
+    vNamespace = vArgs[0];
+    Check_Type(vNamespace, T_STRING);
+
+    vSet = vArgs[1];
+    Check_Type(vSet, T_STRING);
+
+    vBinName = vArgs[2];
+    Check_Type(vBinName, T_STRING);
+
+    vIndexName = vArgs[3];
+    Check_Type(vIndexName, T_STRING);
+
+    if (argc == 5) {
+        VALUE vType = Qnil;
+        SET_POLICY(policy, vArgs[4]);
+        vType = rb_hash_aref(vArgs[4], rb_str_new2("type"));
+        if (TYPE(vType) == T_FIXNUM) {
+            switch(FIX2INT(vType)) {
+            case INDEX_NUMERIC:
+                is_integer = true;
+                break;
+            case INDEX_STRING:
+                is_integer = false;
+                break;
+            default:
+                rb_raise(rb_eArgError, "Incorrect index type");
+            }
+        }
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+
+    if (is_integer) {
+        if (aerospike_index_integer_create(ptr, &err, &policy, StringValueCStr(vNamespace), StringValueCStr(vSet), StringValueCStr(vBinName), StringValueCStr(vIndexName)) != AEROSPIKE_OK) {
+            raise_aerospike_exception(err.code, err.message);
+        }
+    } else {
+        if (aerospike_index_string_create(ptr, &err, &policy, StringValueCStr(vNamespace), StringValueCStr(vSet), StringValueCStr(vBinName), StringValueCStr(vIndexName)) != AEROSPIKE_OK) {
+            raise_aerospike_exception(err.code, err.message);
+        }
+    }
+
+    task.as = ptr;
+    strcpy(task.ns, StringValueCStr(vNamespace));
+    strcpy(task.name, StringValueCStr(vBinName));
+    task.done = false;
+    aerospike_index_create_wait(&err, &task, 1000);
+
+    return (task.done ? Qtrue : Qfalse);
+}
+
+VALUE client_drop_index(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vNamespace, vIndexName;
+
+    aerospike *ptr;
+    as_error err;
+    as_policy_info policy;
+
+    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);
+    }
+
+    vNamespace = vArgs[0];
+    Check_Type(vNamespace, T_STRING);
+
+    vIndexName = vArgs[1];
+    Check_Type(vIndexName, T_STRING);
+
+    if (argc == 3) {
+        SET_POLICY(policy, vArgs[2]);
+    }
+
+    Data_Get_Struct(vSelf, aerospike, ptr);
+
+    if (aerospike_index_remove(ptr, &err, &policy, StringValueCStr(vNamespace), StringValueCStr(vIndexName)) != AEROSPIKE_OK) {
+        raise_aerospike_exception(err.code, err.message);
+    }
+
+    return Qtrue;
+}
+
+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
+        return true;
+    }
+
+    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);
+
+        if ( rb_block_given_p() ) {
+            rb_yield(vRecord);
+        } else {
+            // TODO: write default aggregate block
+        }
+    }
+
+    return true;
+}
+
+VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vNamespace;
+    VALUE vSet;
+    VALUE vConditions;
+
+    aerospike *ptr;
+    as_error err;
+    as_policy_query policy;
+    as_query query;
+
+    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");
+    }
+
+    vNamespace = vArgs[0];
+    Check_Type(vNamespace, T_STRING);
+
+    vSet = vArgs[1];
+    Check_Type(vSet, T_STRING);
+
+    vConditions = vArgs[2];
+    Check_Type(vConditions, T_ARRAY);
+
+    as_policy_query_init(&policy);
+    if (argc == 4) {
+        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));
+    as_query_where_inita(&query, idx);
+    for(n = 0; n < idx; n++) {
+        VALUE vMin, vMax, vBinName;
+        VALUE vCondition = rb_ary_entry(vConditions, n);
+        check_aerospike_condition(vCondition);
+        vMin = rb_iv_get(vCondition, "@min");
+        vMax = rb_iv_get(vCondition, "@max");
+        vBinName = rb_iv_get(vCondition, "@bin_name");
+
+        switch(TYPE(vMin)) {
+        case T_FIXNUM:
+            switch(TYPE(vMax)) {
+            case T_NIL:
+                as_query_where(&query, StringValueCStr(vBinName), as_integer_equals(FIX2LONG(vMin)));
+                break;
+            case T_FIXNUM:
+                as_query_where(&query, StringValueCStr(vBinName), as_integer_range(FIX2LONG(vMin), FIX2LONG(vMax)));
+                break;
+            default:
+                rb_raise(rb_eArgError, "Incorrect condition");
+            }
+
+            break;
+        case T_STRING:
+            Check_Type(vMax, T_NIL);
+            as_query_where(&query, StringValueCStr(vBinName), as_string_equals(StringValueCStr(vMin)));
+            break;
+        default:
+            rb_raise(rb_eArgError, "Incorrect condition");
+        }
+    }
+
+    if (aerospike_query_foreach(ptr, &err, &policy, &query, query_callback, NULL) != AEROSPIKE_OK) {
+        as_query_destroy(&query);
+        raise_aerospike_exception(err.code, err.message);
+    }
+    as_query_destroy(&query);
+
+    return Qnil;
+}
+
 void define_client()
 {
     ClientClass = rb_define_class_under(AerospikeNativeClass, "Client", rb_cObject);
@@ -598,4 +737,7 @@ void define_client()
     rb_define_method(ClientClass, "remove", client_remove, -1);
     rb_define_method(ClientClass, "exists?", client_exists, -1);
     rb_define_method(ClientClass, "select", client_select, -1);
+    rb_define_method(ClientClass, "create_index", client_create_index, -1);
+    rb_define_method(ClientClass, "drop_index", client_drop_index, -1);
+    rb_define_method(ClientClass, "where", client_exec_query, -1);
 }

data/ext/aerospike_native/common.h

@@ -6,5 +6,22 @@
 
 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 );                         \
+        }                                                                  \
+        break;                                                             \
+    }                                                                      \
+    default:                                                               \
+        /* raise exception */                                              \
+        Check_Type(vSettings, T_HASH);                                     \
+        break;                                                             \
+    }
+
 #endif // COMMON_H
 

data/ext/aerospike_native/condition.c

@@ -0,0 +1,125 @@
+#include "condition.h"
+
+VALUE ConditionClass;
+
+void check_aerospike_condition(VALUE vKey)
+{
+    char sName[] = "AerospikeNative::Condition";
+
+    if (strcmp(sName, rb_obj_classname(vKey)) != 0) {
+        rb_raise(rb_eArgError, "Incorrect type (expected %s)", sName);
+    }
+}
+
+VALUE condition_initialize(VALUE vSelf, VALUE vBinName, VALUE vIndexType, VALUE vDataType, VALUE vMin, VALUE vMax)
+{
+    int index_type = 0, data_type = 0;
+    Check_Type(vBinName, T_STRING);
+    Check_Type(vIndexType, T_FIXNUM);
+    Check_Type(vDataType, T_FIXNUM);
+
+    index_type = NUM2INT(vIndexType);
+    data_type = NUM2INT(vDataType);
+
+    switch(index_type) {
+    case INDEX_NUMERIC:
+        Check_Type(vMin, T_FIXNUM);
+        switch(TYPE(vMax)) {
+        case T_NIL:
+        case T_FIXNUM:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Expected FIXNUM or NIL value");
+        }
+        break;
+    case INDEX_STRING:
+        Check_Type(vMin, T_STRING);
+        switch(TYPE(vMax)) {
+        case T_NIL:
+        case T_STRING:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Expected STRING or NIL value");
+        }
+        break;
+    default:
+        rb_raise(rb_eArgError, "Incorrect index type");
+    }
+
+    switch(data_type) {
+    case CONDITION_TYPE_DEFAULT:
+    case CONDITION_TYPE_LIST:
+    case CONDITION_TYPE_MAPKEYS:
+    case CONDITION_TYPE_MAPVALUES:
+        break;
+    default:
+        rb_raise(rb_eArgError, "Incorrect data type");
+    }
+
+    rb_iv_set(vSelf, "@bin_name", vBinName);
+    rb_iv_set(vSelf, "@index_type", vIndexType);
+    rb_iv_set(vSelf, "@data_type", vDataType);
+    rb_iv_set(vSelf, "@min", vMin);
+    rb_iv_set(vSelf, "@max", vMax);
+
+    return vSelf;
+}
+
+VALUE condition_equal(VALUE vSelf, VALUE vBinName, VALUE vVal)
+{
+    VALUE vArgs[5];
+    int index_type;
+
+    Check_Type(vBinName, T_STRING);
+
+    switch(TYPE(vVal)) {
+    case T_FIXNUM:
+        index_type = INDEX_NUMERIC;
+        break;
+    case T_STRING:
+        index_type = INDEX_STRING;
+        break;
+    default:
+        rb_raise(rb_eArgError, "Expected only FIXNUM or STRING types");
+    }
+
+    vArgs[0] = vBinName;
+    vArgs[1] = INT2FIX(index_type);
+    vArgs[2] = INT2FIX(CONDITION_TYPE_DEFAULT);
+    vArgs[3] = vVal;
+    vArgs[4] = Qnil;
+    return rb_class_new_instance(5, vArgs, vSelf);
+}
+
+VALUE condition_range(VALUE vSelf, VALUE vBinName, VALUE vMin, VALUE vMax)
+{
+    VALUE vArgs[5];
+
+    Check_Type(vBinName, T_STRING);
+    Check_Type(vMin, T_FIXNUM);
+    Check_Type(vMax, T_FIXNUM);
+
+    vArgs[0] = vBinName;
+    vArgs[1] = INT2FIX(INDEX_NUMERIC);
+    vArgs[2] = INT2FIX(CONDITION_TYPE_DEFAULT);
+    vArgs[3] = vMin;
+    vArgs[4] = vMax;
+    return rb_class_new_instance(5, vArgs, vSelf);
+}
+
+void define_condition()
+{
+    ConditionClass = rb_define_class_under(AerospikeNativeClass, "Condition", rb_cObject);
+    rb_define_method(ConditionClass, "initialize", condition_initialize, 5);
+    rb_define_singleton_method(ConditionClass, "equal", condition_equal, 2);
+    rb_define_singleton_method(ConditionClass, "range", condition_range, 3);
+
+    rb_define_attr(ConditionClass, "bin_name", 1, 0);
+    rb_define_attr(ConditionClass, "index_type", 1, 0);
+    rb_define_attr(ConditionClass, "data_type", 1, 0);
+    rb_define_attr(ConditionClass, "min", 1, 0);
+    rb_define_attr(ConditionClass, "max", 1, 0);
+}
+
+
+

data/ext/aerospike_native/condition.h

@@ -0,0 +1,18 @@
+#ifndef CONDITION_H
+#define CONDITION_H
+
+#include "aerospike_native.h"
+
+RUBY_EXTERN VALUE ConditionClass;
+void define_condition();
+void check_aerospike_condition(VALUE vKey);
+
+enum ConditionType {
+    CONDITION_TYPE_DEFAULT = AS_INDEX_TYPE_DEFAULT,
+    CONDITION_TYPE_LIST = AS_INDEX_TYPE_LIST,
+    CONDITION_TYPE_MAPKEYS = AS_INDEX_TYPE_MAPKEYS,
+    CONDITION_TYPE_MAPVALUES = AS_INDEX_TYPE_MAPVALUES
+};
+
+#endif // CONDITION_H
+

data/ext/aerospike_native/key.c

@@ -19,18 +19,50 @@ static VALUE key_allocate(VALUE klass)
     return obj;
 }
 
-VALUE key_initialize(VALUE vSelf, VALUE vNamespace, VALUE vSet, VALUE vValue)
+VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
 {
+    VALUE vNamespace, vSet, vValue, vDigest = Qnil;
     as_key *ptr;
-    as_digest* digest;
+    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);
-    Check_Type(vValue, T_STRING);
+
+    vValue = vArgs[2];
+
+    if (argc == 4) {
+        vDigest = vArgs[3];
+    }
 
     Data_Get_Struct(vSelf, as_key, ptr);
-    as_key_init_str(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValueCStr( vValue ));
-    digest = as_key_digest(ptr);
+
+    if(TYPE(vDigest) == 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:
+            rb_raise(rb_eArgError, "Expected FIXNUM or STRING as value");
+        }
+    } 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);
@@ -53,7 +85,7 @@ void define_native_key()
 {
     KeyClass = rb_define_class_under(AerospikeNativeClass, "Key", rb_cObject);
     rb_define_alloc_func(KeyClass, key_allocate);
-    rb_define_method(KeyClass, "initialize", key_initialize, 3);
+    rb_define_method(KeyClass, "initialize", key_initialize, -1);
     rb_define_attr(KeyClass, "namespace", 1, 0);
     rb_define_attr(KeyClass, "set", 1, 0);
     rb_define_attr(KeyClass, "value", 1, 0);

data/lib/aerospike_native/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Ziablitskii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-05 00:00:00.000000000 Z
+date: 2015-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,7 +77,6 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
 - aerospike_native.gemspec
@@ -87,6 +86,8 @@ files:
 - ext/aerospike_native/client.h
 - ext/aerospike_native/common.c
 - ext/aerospike_native/common.h
+- ext/aerospike_native/condition.c
+- ext/aerospike_native/condition.h
 - ext/aerospike_native/exception.c
 - ext/aerospike_native/exception.h
 - ext/aerospike_native/extconf.rb

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2015 Vladimir Zyablitskiy
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.