aerospike_native 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9adbd76e01717770aa172758d38a3e9340abbec
-  data.tar.gz: 5f95658e8a79c57d2021a5ae041c69300989372e
+  metadata.gz: bb3d554ba14a9cdc3064e7f710e1fd8e2f5303c9
+  data.tar.gz: 06b57fc85d271be4c845838f0918daf4e334a771
 SHA512:
-  metadata.gz: f27395cdf1605ca3fb553f77220951adecd99b124ce28570948f3e46e063f17c50b6b8ccd7fb7e858a8abec94a6042c0e3f2325946833f621293fe574b3f2e4e
-  data.tar.gz: 5220d3cc0b14b6c4f033e5831f092e9e485bddce1be9bd277fb9159ed47a322fd131e67c0abeecfb282b545ebb447f0b25d9e912f0a5e5d94134d634b4c66006
+  metadata.gz: 71bcee1166282f8a9cfb6a4df0ecb04f91ab86abc78f988c45fcee6c42f018b2b410a028b6ea74b4975c6bbe975d5a4db2c84b4a65933fe2ab43727a9798fa46
+  data.tar.gz: 688f5da01520a1686952f2f376bb093dd5b1450a181fdc7d5c727a955692b6ef56aadbff20b6440e6f718884bdff84e946beec9c1437bf59f72861dc19a9baf5

data/README.md

@@ -55,8 +55,7 @@ client.remove(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 = client.query('test', 'test').where(number: [1, 7])
 puts records.inspect
 records.each { |record| client.remove(record.key) }
 ```

data/ext/aerospike_native/aerospike_native.c

@@ -3,8 +3,8 @@
 #include "key.h"
 #include "operation.h"
 #include "record.h"
-#include "condition.h"
 #include "policy.h"
+#include "query.h"
 
 VALUE AerospikeNativeClass;
 
@@ -13,12 +13,12 @@ void Init_aerospike_native()
     AerospikeNativeClass = rb_define_module("AerospikeNative");
     define_exception();
     define_logger();
-    define_client();
+    define_query();
     define_native_key();
     define_record();
     define_operation();
-    define_condition();
     define_policy();
+    define_client();
 
     rb_define_const(AerospikeNativeClass, "INDEX_NUMERIC", INT2FIX(INDEX_NUMERIC));
     rb_define_const(AerospikeNativeClass, "INDEX_STRING", INT2FIX(INDEX_STRING));

data/ext/aerospike_native/client.c

@@ -2,7 +2,7 @@
 #include "operation.h"
 #include "key.h"
 #include "record.h"
-#include "condition.h"
+#include "query.h"
 #include <aerospike/as_key.h>
 #include <aerospike/as_operations.h>
 #include <aerospike/aerospike_key.h>
@@ -11,6 +11,15 @@
 
 VALUE ClientClass;
 
+void check_aerospike_client(VALUE vKey)
+{
+    char sName[] = "AerospikeNative::Client";
+
+    if (strcmp(sName, rb_obj_classname(vKey)) != 0) {
+        rb_raise(rb_eArgError, "Incorrect type (expected %s)", sName);
+    }
+}
+
 static void client_deallocate(void *p)
 {
     aerospike* ptr = p;
@@ -35,7 +44,7 @@ static VALUE client_allocate(VALUE klass)
  *   new() -> AerospikeNative::Client
  *   new(hosts) -> AerospikeNative::Client
  *
- * initialize new client, use {'host' => ..., 'port' => ...} for each hosts element
+ * initialize new client, use \{'host' => ..., 'port' => ...\} for each hosts element
  */
 VALUE client_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -141,6 +150,9 @@ VALUE client_put(int argc, VALUE* vArgs, VALUE vSelf)
         Check_Type(bin_name, T_STRING);
 
         switch( TYPE(bin_value) ) {
+        case T_NIL:
+            as_record_set_nil(&record, StringValueCStr(bin_name));
+            break;
         case T_STRING:
             as_record_set_str(&record, StringValueCStr(bin_name), StringValueCStr(bin_value));
             break;
@@ -148,7 +160,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_eTypeError, "wrong argument type for bin value (expected Fixnum or String)");
+            rb_raise(rb_eTypeError, "wrong argument type for bin value (expected Nil, Fixnum or String)");
             break;
         }
      }
@@ -258,12 +270,24 @@ VALUE client_operate(int argc, VALUE* vArgs, VALUE vSelf)
         switch( op_type ) {
         case OPERATION_WRITE:
             switch( TYPE(bin_value) ) {
+            case T_NIL: {
+                as_record rec;
+                as_record_inita(&rec, 1);
+                as_record_set_nil(&rec, StringValueCStr( bin_name ));
+                ops.binops.entries[ops.binops.size].op = AS_OPERATOR_WRITE;
+                ops.binops.entries[ops.binops.size].bin = rec.bins.entries[0];
+                ops.binops.size++;
+                break;
+            }
             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;
+            default:
+                rb_raise(rb_eTypeError, "wrong argument type for bin value (expected Nil, Fixnum or String)");
+                break;
             }
 
             break;
@@ -468,7 +492,7 @@ VALUE client_select(int argc, VALUE* vArgs, VALUE vSelf)
  *   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
+ * 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)
 {
@@ -575,129 +599,22 @@ VALUE client_drop_index(int argc, VALUE* vArgs, VALUE vSelf)
     return Qtrue;
 }
 
-bool query_callback(const as_val *value, void *udata) {
-    VALUE vRecord;
-    as_record *record;
-
-    if (value == NULL) {
-        // query is complete
-        return true;
-    }
-
-    record = as_record_fromval(value);
-
-    if (record != NULL) {
-        vRecord = rb_record_from_c(record, NULL);
-
-        if ( rb_block_given_p() ) {
-            rb_yield(vRecord);
-        } else {
-            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
+ *   where(namespace, set) -> AerospikeNative::Query
  *
- * Perform a query with where clause
+ * Instanciate new query
  */
-VALUE client_exec_query(int argc, VALUE* vArgs, VALUE vSelf)
+VALUE client_query(VALUE vSelf, VALUE vNamespace, VALUE vSet)
 {
-    VALUE vNamespace;
-    VALUE vSet;
-    VALUE vConditions;
-    VALUE vArray;
-
-    aerospike *ptr;
-    as_error err;
-    as_policy_query policy;
-    as_query query;
-
-    int idx = 0, n = 0;
-
-    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];
-    Check_Type(vNamespace, T_STRING);
+    VALUE vParams[3];
 
-    vSet = vArgs[1];
-    Check_Type(vSet, T_STRING);
-
-    vConditions = vArgs[2];
-    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 && TYPE(vArgs[3]) != T_NIL) {
-        SET_POLICY(policy, vArgs[3]);
-    }
-
-    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");
-        }
-    }
-
-    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);
-
-    if ( rb_block_given_p() ) {
-        return Qnil;
-    }
+    vParams[0] = vSelf;
+    vParams[1] = vNamespace;
+    vParams[2] = vSet;
 
-    return vArray;
+    return rb_class_new_instance(3, vParams, QueryClass);
 }
 
 VALUE client_set_logger(VALUE vSelf, VALUE vNewLogger)
@@ -729,7 +646,7 @@ void define_client()
     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);
+    rb_define_method(ClientClass, "query", client_query, 2);
 
     rb_cv_set(ClientClass, "@@logger", rb_class_new_instance(0, NULL, LoggerClass));
     rb_define_singleton_method(ClientClass, "set_logger", client_set_logger, 1);

data/ext/aerospike_native/client.h

@@ -5,5 +5,6 @@
 
 RUBY_EXTERN VALUE ClientClass;
 void define_client();
+void check_aerospike_client(VALUE vKey);
 
 #endif // CLIENT_H

data/ext/aerospike_native/common.h

@@ -7,6 +7,16 @@
 
 VALUE rb_hash_keys(VALUE hash);
 
+#define GET_STRING(vString)                                                \
+    switch(TYPE(vString)) {                                                \
+    case T_SYMBOL:                                                         \
+        vString = rb_sym_to_s(vString);                                    \
+    case T_STRING:                                                         \
+        break;                                                             \
+    default:                                                               \
+        rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)"); \
+    }
+
 #define SET_POLICY(policy, vSettings)                                      \
     VALUE vTimeout;                                                        \
     Check_Type(vSettings, T_HASH);                                         \

data/ext/aerospike_native/key.c

@@ -81,10 +81,10 @@ VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
 
 void check_aerospike_key(VALUE vKey)
 {
-    char sKeyName[] = "AerospikeNative::Key";
+    char sName[] = "AerospikeNative::Key";
 
-    if (strcmp(sKeyName, rb_obj_classname(vKey)) != 0) {
-        rb_raise(rb_eArgError, "Incorrect type (expected %s)", sKeyName);
+    if (strcmp(sName, rb_obj_classname(vKey)) != 0) {
+        rb_raise(rb_eArgError, "Incorrect type (expected %s)", sName);
     }
 }
 

data/ext/aerospike_native/logger.c

@@ -7,7 +7,6 @@ bool aerospike_log_callback(as_log_level level, const char *func, const char *fi
     uint32_t line, const char *fmt, ...)
 {
     char msg[1024] = {0};
-    char log_msg[1500] = {0};
     va_list ap;
     VALUE vLogger = rb_cv_get(ClientClass, "@@logger");
 
@@ -16,10 +15,8 @@ bool aerospike_log_callback(as_log_level level, const char *func, const char *fi
     msg[1023] = '\0';
     va_end(ap);
 
-    sprintf(log_msg, "%d (Aerospike) - %s", level, msg);
-
     if(TYPE(vLogger) != T_NIL) {
-        rb_funcall(vLogger, rb_intern("write"), 2, INT2FIX(level), rb_str_new2(log_msg));
+        rb_funcall(vLogger, rb_intern("write"), 2, INT2FIX(level), rb_str_new2(msg));
     }
 
     return true;
@@ -86,6 +83,26 @@ VALUE logger_write(VALUE vSelf, VALUE vLevel, VALUE vMsg)
     switch(TYPE(vInternalLogger)) {
     case T_NIL:
         if (level <= FIX2INT(vInternalLevel)) {
+            switch(level) {
+            case AS_LOG_LEVEL_ERROR:
+                vMsg = rb_str_plus(rb_str_new2("ERROR (AEROSPIKE): "), vMsg);
+                break;
+            case AS_LOG_LEVEL_WARN:
+                vMsg = rb_str_plus(rb_str_new2("WARN  (AEROSPIKE): "), vMsg);
+                break;
+            case AS_LOG_LEVEL_INFO:
+                vMsg = rb_str_plus(rb_str_new2("INFO  (AEROSPIKE): "), vMsg);
+                break;
+            case AS_LOG_LEVEL_DEBUG:
+                vMsg = rb_str_plus(rb_str_new2("DEBUG (AEROSPIKE): "), vMsg);
+                break;
+            case AS_LOG_LEVEL_TRACE:
+                vMsg = rb_str_plus(rb_str_new2("DEBUG (AEROSPIKE): "), vMsg);
+                break;
+            default:
+                vMsg = rb_str_plus(rb_str_new2("UNKNOWN (AEROSPIKE): "), vMsg);
+                break;
+            }
             // TODO: add default behavior with write into file
             fprintf(stdout, "%s\n", StringValueCStr(vMsg));
             return vMsg;

data/ext/aerospike_native/query.c

@@ -0,0 +1,318 @@
+#include "query.h"
+#include "client.h"
+#include "record.h"
+#include <aerospike/aerospike_query.h>
+
+VALUE QueryClass;
+
+VALUE query_initialize(VALUE vSelf, VALUE vClient, VALUE vNamespace, VALUE vSet)
+{
+    Check_Type(vNamespace, T_STRING);
+    Check_Type(vSet, T_STRING);
+    check_aerospike_client(vClient);
+
+    rb_iv_set(vSelf, "@client", vClient);
+    rb_iv_set(vSelf, "@namespace", vNamespace);
+    rb_iv_set(vSelf, "@set", vSet);
+
+    return vSelf;
+}
+
+VALUE query_select(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vBins;
+    int i;
+
+    if (argc == 0) {  // there should be greater than 0
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..n)", argc);
+    }
+
+    vBins = rb_iv_get(vSelf, "@select_bins");
+    if(TYPE(vBins) == T_NIL) {
+        vBins = rb_ary_new();
+    }
+    if (argc == 1) {
+        int idx;
+        VALUE vArray = vArgs[0];
+        Check_Type(vArray, T_ARRAY);
+        idx = RARRAY_LEN(vArray);
+        for(i = 0; i < idx; i++) {
+            VALUE vString = rb_ary_entry(vArray, i);
+            GET_STRING(vString);
+            rb_ary_push(vBins, vString);
+        }
+    } else {
+        for(i = 0; i < argc; i++) {
+            VALUE vString = vArgs[i];
+            GET_STRING(vString);
+            rb_ary_push(vBins, vString);
+        }
+    }
+
+    rb_iv_set(vSelf, "@select_bins", vBins);
+    return vSelf;
+}
+
+int query_order_hash_foreach(VALUE vKey, VALUE vValue, VALUE vHash)
+{
+    VALUE vHashKey, vHashValue;
+    VALUE vAsc, vDesc;
+
+    vAsc = ID2SYM( rb_intern("asc") );
+    vDesc = ID2SYM( rb_intern("desc") );
+
+    Check_Type(vValue, T_SYMBOL);
+    vHashKey = vKey;
+    GET_STRING(vHashKey);
+    if(vValue != vAsc && vValue != vDesc) {
+        rb_raise(rb_eArgError, "expected :asc or :desc for value");
+    }
+
+    if(vValue == vAsc) {
+        vHashValue = INT2NUM(AS_ORDER_ASCENDING);
+    } else {
+        vHashValue = INT2NUM(AS_ORDER_DESCENDING);
+    }
+
+    rb_hash_aset(vHash, vHashKey, vHashValue);
+
+    return ST_CONTINUE;
+}
+
+VALUE query_order(VALUE vSelf, VALUE vHash)
+{
+    VALUE vBins;
+    Check_Type(vHash, T_HASH);
+
+    vBins = rb_iv_get(vSelf, "@order_bins");
+    if(TYPE(vBins) == T_NIL) {
+        vBins = rb_hash_new();
+    }
+    rb_hash_foreach(vHash, query_order_hash_foreach, vBins);
+    rb_iv_set(vSelf, "@order_bins", vBins);
+    return vSelf;
+}
+
+int query_where_hash_foreach(VALUE vKey, VALUE vValue, VALUE vHash)
+{
+    VALUE vHashKey, vHashValue;
+    int idx;
+
+    vHashKey = vKey;
+    GET_STRING(vHashKey);
+
+    switch(TYPE(vValue)) {
+    case T_ARRAY:
+        idx = RARRAY_LEN(vValue);
+        if (idx != 2) {
+            rb_raise(rb_eArgError, "wrong array length (expected 2 elements)");
+        }
+        vHashValue = vValue;
+        break;
+    case T_FIXNUM:
+    case T_STRING:
+        vHashValue = vValue;
+        break;
+    default:
+        rb_raise(rb_eTypeError, "wrong argument type for (expected Array, String or Fixnum)");
+    }
+
+    rb_hash_aset(vHash, vHashKey, vHashValue);
+
+    return ST_CONTINUE;
+}
+
+VALUE query_where(VALUE vSelf, VALUE vHash)
+{
+    VALUE vBins;
+    Check_Type(vHash, T_HASH);
+
+    vBins = rb_iv_get(vSelf, "@where_bins");
+    if(TYPE(vBins) == T_NIL) {
+        vBins = rb_hash_new();
+    }
+    rb_hash_foreach(vHash, query_where_hash_foreach, vBins);
+    rb_iv_set(vSelf, "@where_bins", vBins);
+    return vSelf;
+}
+
+bool query_callback(const as_val *value, void *udata) {
+    VALUE vRecord;
+    as_record *record;
+
+    if (value == NULL) {
+        // query is complete
+        return true;
+    }
+
+    record = as_record_fromval(value);
+
+    if (record != NULL) {
+        vRecord = rb_record_from_c(record, NULL);
+
+        if ( rb_block_given_p() ) {
+            rb_yield(vRecord);
+        } else {
+            VALUE *vArray = (VALUE*) udata;
+            rb_ary_push(*vArray, vRecord);
+        }
+    }
+
+    return true;
+}
+
+VALUE query_exec(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vNamespace;
+    VALUE vSet;
+    VALUE vArray;
+    VALUE vClient;
+    VALUE vWhere, vSelect, vOrder;
+    VALUE vWhereKeys, vOrderKeys;
+
+    aerospike *ptr;
+    as_error err;
+    as_policy_query policy;
+    as_query query;
+
+    int n = 0;
+    int where_idx = 0, select_idx = 0, order_idx = 0;
+
+    if (argc > 1) {  // there should only be 0 or 1 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+
+    vNamespace = rb_iv_get(vSelf, "@namespace");
+    vSet = rb_iv_get(vSelf, "@set");
+
+    vWhere = rb_iv_get(vSelf, "@where_bins");
+    switch(TYPE(vWhere)) {
+    case T_NIL:
+        break;
+    case T_HASH:
+        vWhereKeys = rb_hash_keys(vWhere);
+        where_idx = RARRAY_LEN(vWhereKeys);
+        break;
+    default:
+        rb_raise(rb_eTypeError, "wrong argument type for where (expected Hash or Nil)");
+    }
+
+    vSelect = rb_iv_get(vSelf, "@select_bins");
+    switch(TYPE(vSelect)) {
+    case T_NIL:
+        break;
+    case T_ARRAY:
+        select_idx = RARRAY_LEN(vSelect);
+        break;
+    default:
+        rb_raise(rb_eTypeError, "wrong argument type for select (expected Array or Nil)");
+    }
+
+    vOrder = rb_iv_get(vSelf, "@order_bins");
+    switch(TYPE(vOrder)) {
+    case T_NIL:
+        break;
+    case T_HASH:
+        vOrderKeys = rb_hash_keys(vOrder);
+        order_idx = RARRAY_LEN(vOrderKeys);
+        break;
+    default:
+        rb_raise(rb_eTypeError, "wrong argument type for order (expected Hash or Nil)");
+    }
+
+    as_policy_query_init(&policy);
+    if (argc == 1 && TYPE(vArgs[0]) != T_NIL) {
+        SET_POLICY(policy, vArgs[0]);
+    }
+
+    vClient = rb_iv_get(vSelf, "@client");
+    Data_Get_Struct(vClient, aerospike, ptr);
+
+    as_query_init(&query, StringValueCStr(vNamespace), StringValueCStr(vSet));
+
+    as_query_select_inita(&query, select_idx);
+    for(n = 0; n < select_idx; n++) {
+        VALUE vBinName;
+        vBinName = rb_ary_entry(vSelect, n);
+
+        as_query_select(&query, StringValueCStr(vBinName));
+    }
+
+    as_query_orderby_inita(&query, order_idx);
+    for(n = 0; n < order_idx; n++) {
+        VALUE vBinName;
+        VALUE vCondition;
+        vBinName = rb_ary_entry(vOrderKeys, n);
+        vCondition = rb_hash_aref(vOrder, vBinName);
+
+        as_query_orderby(&query, StringValueCStr(vBinName), NUM2INT(vCondition));
+    }
+
+    as_query_where_inita(&query, where_idx);
+    for(n = 0; n < where_idx; n++) {
+        VALUE vMin = Qnil, vMax = Qnil, vBinName;
+        VALUE vCondition;
+        vBinName = rb_ary_entry(vWhereKeys, n);
+        vCondition = rb_hash_aref(vWhere, vBinName);
+        switch(TYPE(vCondition)) {
+        case T_ARRAY:
+            vMin = rb_ary_entry(vCondition, 0);
+            vMax = rb_ary_entry(vCondition, 1);
+            break;
+        default:
+            vMin = vCondition;
+        }
+
+        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");
+        }
+    }
+
+    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);
+
+    if ( rb_block_given_p() ) {
+        return Qnil;
+    }
+
+    return vArray;
+}
+
+void define_query()
+{
+    QueryClass = rb_define_class_under(AerospikeNativeClass, "Query", rb_cObject);
+    rb_define_method(QueryClass, "initialize", query_initialize, 3);
+    rb_define_method(QueryClass, "select", query_select, -1);
+    rb_define_method(QueryClass, "order", query_order, 1);
+    rb_define_method(QueryClass, "where", query_where, 1);
+    rb_define_method(QueryClass, "exec", query_exec, -1);
+
+    rb_define_attr(QueryClass, "client", 1, 0);
+    rb_define_attr(QueryClass, "namespace", 1, 0);
+    rb_define_attr(QueryClass, "set", 1, 0);
+    rb_define_attr(QueryClass, "select_bins", 1, 0);
+    rb_define_attr(QueryClass, "where_bins", 1, 0);
+    rb_define_attr(QueryClass, "order_bins", 1, 0);
+}

data/ext/aerospike_native/query.h

@@ -0,0 +1,10 @@
+#ifndef QUERY_H
+#define QUERY_H
+
+#include "aerospike_native.h"
+
+RUBY_EXTERN VALUE QueryClass;
+void define_query();
+
+#endif // QUERY_H
+

data/ext/aerospike_native/record.c

@@ -1,5 +1,6 @@
 #include "record.h"
 #include "key.h"
+#include "client.h"
 
 VALUE RecordClass;
 
@@ -27,9 +28,11 @@ VALUE record_initialize(VALUE vSelf, VALUE vKey, VALUE vBins, VALUE vGen, VALUE
 VALUE rb_record_from_c(as_record* record, as_key* key)
 {
     VALUE vKeyParams[5], vParams[4];
+    VALUE vLogger;
     as_key current_key;
     as_bin bin;
     int n;
+    char msg[200];
 
     if (key == NULL) {
         current_key = record->key;
@@ -43,7 +46,12 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
     if (current_key.valuep == NULL) {
         vKeyParams[2] = Qnil;
     } else {
-        vKeyParams[2] = rb_str_new2(current_key.value.string.value);
+        char *str = current_key.value.string.value;
+        if (str == NULL) {
+            vKeyParams[2] = INT2NUM(current_key.value.integer.value);
+        } else {
+            vKeyParams[2] = rb_str_new2(str);
+        }
     }
     vKeyParams[3] = rb_str_new(current_key.digest.value, AS_DIGEST_VALUE_SIZE);
 
@@ -55,6 +63,9 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
     for(n = 0; n < record->bins.size; n++) {
         bin = record->bins.entries[n];
         switch( as_val_type(bin.valuep) ) {
+        case AS_NIL:
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), Qnil);
+            break;
         case AS_INTEGER:
             rb_hash_aset(vParams[1], rb_str_new2(bin.name), LONG2NUM(bin.valuep->integer.value));
             break;
@@ -63,6 +74,9 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
             break;
         case AS_UNDEF:
         default:
+            vLogger = rb_cv_get(ClientClass, "@@logger");
+            sprintf(msg, "unhandled val type: %d\n", as_val_type(bin.valuep));
+            rb_funcall(vLogger, rb_intern("warn"), 1, rb_str_new2(msg));
             break;
         }
     }

data/lib/aerospike_native/version.rb

@@ -1,3 +1,3 @@
 module AerospikeNative
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Vladimir Ziablitskii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-14 00:00:00.000000000 Z
+date: 2015-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,8 +87,6 @@ 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
@@ -102,6 +100,8 @@ files:
 - ext/aerospike_native/operation.h
 - ext/aerospike_native/policy.c
 - ext/aerospike_native/policy.h
+- ext/aerospike_native/query.c
+- ext/aerospike_native/query.h
 - ext/aerospike_native/record.c
 - ext/aerospike_native/record.h
 - lib/aerospike_native.rb

data/ext/aerospike_native/condition.c

@@ -1,125 +0,0 @@
-#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_eTypeError, "wrong argument type for max value (expected Fixnum or Nil)");
-        }
-        break;
-    case INDEX_STRING:
-        Check_Type(vMin, T_STRING);
-        switch(TYPE(vMax)) {
-        case T_NIL:
-        case T_STRING:
-            break;
-        default:
-            rb_raise(rb_eTypeError, "wrong argument type for max value (expected String or Nil)");
-        }
-        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_eTypeError, "wrong argument type for value (expected Fixnum or String)");
-    }
-
-    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

@@ -1,18 +0,0 @@
-#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
-