aerospike_native 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ac94d9b34b064822cc15dd0976ed7ced4b76c27
-  data.tar.gz: 085fe5f23cb779c0ff29a7cb74d82ecef51de905
+  metadata.gz: cb0270c96b7bd4fa49f251d9b5fd406a21ae109b
+  data.tar.gz: 92c3cdb727dafa076735b779eb198011cb028058
 SHA512:
-  metadata.gz: 95e3ce1b3fb8a94c61a88bb839790769f1f9112abc1ed7526c464e1c9cfb1195b13d8e4c0bdb40fa09d84c3dab6b289cc119f0f95b53d4f58b463409b2e18a9a
-  data.tar.gz: 9384e2914162cbcc79aa1bb0e2bd850685e158c0617c59c0b8ab338da4d50782a794715779a69d113b8fc13ccb1d55c835593813fedc2b9752d67b7a3545a27f
+  metadata.gz: 27c8668efda00c0a467844f5f840fce63223dbbab69d71e53d8c9177c1bf6a4c23f69fb5366a3092a6b20eb90be95c372126fa1b4de1653533e3596a4957dcdf
+  data.tar.gz: 9d4fde1a9e2942ac4bfbe108cbc6babd807fdf37eef6d67e079cb797297458ab8404971716f7613d2bf1542c2c08ed3bbfdaf4df5b035be96521b492167dfde5

data/examples/batch.rb

@@ -0,0 +1,27 @@
+require './common/common'
+
+def main
+  Common::Common.run_example do |client, namespace, set, logger|
+    20.times do |i|
+      client.put(AerospikeNative::Key.new(namespace, set, i), {'number' => i, 'key' => 'number', 'testbin' => i.to_s})
+      client.put(AerospikeNative::Key.new(namespace, set, "key#{i}"), {'number' => i, 'key' => 'string', 'testbin' => i.to_s})
+    end
+
+    keys = []
+    keys << AerospikeNative::Key.new(namespace, set, 1)
+    keys << AerospikeNative::Key.new(namespace, set, 10)
+    keys << AerospikeNative::Key.new(namespace, set, "key5")
+    keys << AerospikeNative::Key.new(namespace, set, "key26")
+
+    records = client.batch.get_exists(keys)
+    logger.info "fetched records metadata: #{records.inspect}"
+
+    records = client.batch.get(keys)
+    logger.info "fetched records with specified bins: #{records.inspect}"
+
+    records = client.batch.get(keys, bins)
+    logger.info "fetched records with all bins: #{records.inspect}"
+  end
+end
+
+main

data/ext/aerospike_native/aerospike_native.c

@@ -5,6 +5,7 @@
 #include "record.h"
 #include "policy.h"
 #include "query.h"
+#include "batch.h"
 
 VALUE AerospikeNativeClass;
 
@@ -14,6 +15,7 @@ void Init_aerospike_native()
     define_exception();
     define_logger();
     define_query();
+    define_batch();
     define_native_key();
     define_record();
     define_operation();

data/ext/aerospike_native/batch.c

@@ -0,0 +1,213 @@
+#include "batch.h"
+#include "client.h"
+#include "record.h"
+#include <aerospike/aerospike_batch.h>
+
+VALUE BatchClass;
+
+VALUE batch_initialize(VALUE vSelf, VALUE vClient)
+{
+    check_aerospike_client(vClient);
+    rb_iv_set(vSelf, "@client", vClient);
+    return vSelf;
+}
+
+bool batch_read_callback(const as_batch_read* results, uint32_t n, void* udata)
+{
+    uint32_t i = 0;
+    VALUE vLogger;
+    char sMsg[1000];
+
+    vLogger = rb_cv_get(ClientClass, "@@logger");
+
+    for(i = 0; i < n; i++) {
+        switch(results[i].result) {
+        case AEROSPIKE_OK: {
+            VALUE vRecord = rb_record_from_c(&results[i].record, results[i].key);
+
+            if ( rb_block_given_p() ) {
+                rb_yield(vRecord);
+            } else {
+                VALUE *vArray = (VALUE*) udata;
+                rb_ary_push(*vArray, vRecord);
+            }
+            break;
+        }
+        case AEROSPIKE_ERR_RECORD_NOT_FOUND:
+            sprintf(sMsg, "Aerospike batch read record not found %d", i);
+            rb_funcall(vLogger, rb_intern("warn"), 1, rb_str_new2(sMsg));
+            break;
+        default:
+            sprintf(sMsg, "Aerospike batch read error %d", results[i].result);
+            rb_funcall(vLogger, rb_intern("error"), 1, rb_str_new2(sMsg));
+        }
+    }
+
+    return true;
+}
+
+/*
+ * call-seq:
+ *   get(keys) -> Array
+ *   get(keys, bins) -> Array
+ *   get(keys, bins, policy_settings) -> Array
+ *   get(keys, policy_settings) -> Array
+ *   get(keys, ...) { |record| ... } -> Nil
+ *
+ * batch get records by keys with specified bins
+ */
+VALUE batch_get(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vKeys, vClient, vArray, vBins;
+
+    as_batch batch;
+    as_policy_batch policy;
+    as_key* key;
+    aerospike* ptr;
+    as_error err;
+
+    uint32_t n = 0, idx = 0, bins_idx = 0;
+
+    if (argc > 3 || argc < 1) {  // there should only be 1, 2 or 3 arguments
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+    }
+
+    vKeys = vArgs[0];
+    Check_Type(vKeys, T_ARRAY);
+    as_policy_batch_init(&policy);
+
+    if (argc == 3) {
+        vBins = vArgs[1];
+        Check_Type(vBins, T_ARRAY);
+        bins_idx = RARRAY_LEN(vBins);
+
+        if (TYPE(vArgs[2]) != T_NIL) {
+            SET_POLICY(policy, vArgs[2]);
+        }
+    } else {
+        switch(TYPE(vArgs[1])) {
+        case T_NIL:
+            break;
+        case T_ARRAY:
+            vBins = vArgs[1];
+            bins_idx = RARRAY_LEN(vBins);
+            break;
+        case T_HASH: {
+            SET_POLICY(policy, vArgs[1]);
+            break;
+        }
+        default:
+            rb_raise(rb_eTypeError, "wrong argument type (expected Array or Hash)");
+        }
+    }
+
+    idx = RARRAY_LEN(vKeys);
+    as_batch_inita(&batch, idx);
+
+    for(n = 0; n < idx; n++) {
+        VALUE vKey = rb_ary_entry(vKeys, n);
+        Data_Get_Struct(vKey, as_key, key);
+        as_key_init_value(as_batch_keyat(&batch, n), key->ns, key->set, key->valuep);
+    }
+
+    vClient = rb_iv_get(vSelf, "@client");
+    Data_Get_Struct(vClient, aerospike, ptr);
+
+    vArray = rb_ary_new();
+    if (bins_idx > 0) {
+        char* sBins[bins_idx];
+        for(n = 0; n < bins_idx; n++) {
+            VALUE vEl = rb_ary_entry(vBins, n);
+            GET_STRING(vEl);
+            sBins[n] = StringValueCStr(vEl);
+        }
+        if (aerospike_batch_get_bins(ptr, &err, &policy, &batch, sBins, bins_idx, batch_read_callback, &vArray) != AEROSPIKE_OK) {
+            as_batch_destroy(&batch);
+            raise_aerospike_exception(err.code, err.message);
+        }
+    } else {
+        if (aerospike_batch_get(ptr, &err, &policy, &batch, batch_read_callback, &vArray) != AEROSPIKE_OK) {
+            as_batch_destroy(&batch);
+            raise_aerospike_exception(err.code, err.message);
+        }
+    }
+
+    as_batch_destroy(&batch);
+    if ( rb_block_given_p() ) {
+        return Qnil;
+    }
+
+    return vArray;
+}
+
+// TODO: implement batch read to customize bins for each key
+// VALUE batch_read(int argc, VALUE* vArgs, VALUE vSelf);
+
+/*
+ * call-seq:
+ *   exists(keys) -> Array
+ *   exists(keys, policy_settings) -> Array
+ *   exists(keys, ...) { |record| ... } -> Nil
+ *   exists(keys, policy_settings) { |record| ... } -> Nil
+ *
+ * batch get metatdata of records (ttl, gen)
+ */
+VALUE batch_exists(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vKeys, vClient, vArray;
+
+    as_batch batch;
+    as_policy_batch policy;
+    as_key* key;
+    aerospike* ptr;
+    as_error err;
+
+    uint32_t n = 0, idx = 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);
+    }
+
+    vKeys = vArgs[0];
+    Check_Type(vKeys, T_ARRAY);
+
+    as_policy_batch_init(&policy);
+    if (argc == 2 && TYPE(vArgs[1]) != T_NIL) {
+        SET_POLICY(policy, vArgs[1]);
+    }
+
+    idx = RARRAY_LEN(vKeys);
+    as_batch_inita(&batch, idx);
+
+    for(n = 0; n < idx; n++) {
+        VALUE vKey = rb_ary_entry(vKeys, n);
+        Data_Get_Struct(vKey, as_key, key);
+        as_key_init_value(as_batch_keyat(&batch, n), key->ns, key->set, key->valuep);
+    }
+
+    vClient = rb_iv_get(vSelf, "@client");
+    Data_Get_Struct(vClient, aerospike, ptr);
+
+    vArray = rb_ary_new();
+    if (aerospike_batch_exists(ptr, &err, &policy, &batch, batch_read_callback, &vArray) != AEROSPIKE_OK) {
+        as_batch_destroy(&batch);
+        raise_aerospike_exception(err.code, err.message);
+    }
+    as_batch_destroy(&batch);
+
+    if ( rb_block_given_p() ) {
+        return Qnil;
+    }
+
+    return vArray;
+}
+
+void define_batch()
+{
+    BatchClass = rb_define_class_under(AerospikeNativeClass, "Batch", rb_cObject);
+    rb_define_method(BatchClass, "initialize", batch_initialize, 1);
+    rb_define_method(BatchClass, "get", batch_get, -1);
+    rb_define_method(BatchClass, "exists", batch_exists, -1);
+
+    rb_define_attr(BatchClass, "client", 1, 0);
+}

data/ext/aerospike_native/batch.h

@@ -0,0 +1,10 @@
+#ifndef BATCH_H
+#define BATCH_H
+
+#include "aerospike_native.h"
+
+RUBY_EXTERN VALUE BatchClass;
+void define_batch();
+
+#endif // BATCH_H
+

data/ext/aerospike_native/client.c

@@ -3,6 +3,7 @@
 #include "key.h"
 #include "record.h"
 #include "query.h"
+#include "batch.h"
 #include <aerospike/as_key.h>
 #include <aerospike/as_operations.h>
 #include <aerospike/aerospike_key.h>
@@ -654,6 +655,14 @@ VALUE client_set_log_level(VALUE vSelf, VALUE vLevel)
     return rb_funcall(vLogger, rb_intern("set_level"), 1, vLevel);
 }
 
+VALUE client_batch(VALUE vSelf)
+{
+    VALUE vParams[1];
+
+    vParams[0] = vSelf;
+    return rb_class_new_instance(1, vParams, BatchClass);
+}
+
 void define_client()
 {
     ClientClass = rb_define_class_under(AerospikeNativeClass, "Client", rb_cObject);
@@ -668,6 +677,7 @@ void define_client()
     rb_define_method(ClientClass, "create_index", client_create_index, -1);
     rb_define_method(ClientClass, "drop_index", client_drop_index, -1);
     rb_define_method(ClientClass, "query", client_query, 2);
+    rb_define_method(ClientClass, "batch", client_batch, 0);
 
     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/common.h

@@ -21,6 +21,9 @@ VALUE rb_hash_keys(VALUE hash);
     VALUE vTimeout;                                                        \
     Check_Type(vSettings, T_HASH);                                         \
     vTimeout = rb_hash_aref(vSettings, rb_str_new2("timeout"));            \
+    if (TYPE(vTimeout) == T_NIL) {                                         \
+        vTimeout = rb_hash_aref(vSettings, ID2SYM(rb_intern("timeout")));  \
+    }                                                                      \
     if (TYPE(vTimeout) == T_FIXNUM) {                                      \
         policy.timeout = NUM2UINT( vTimeout );                             \
     }

data/ext/aerospike_native/exception.c

@@ -10,10 +10,23 @@ VALUE exception_initialize(VALUE vSelf, VALUE vMessage)
     return vSelf;
 }
 
+VALUE exception_inspect(VALUE vSelf)
+{
+    VALUE vCode, vMsg;
+    char sMsg[200];
+
+    vCode = rb_iv_get(vSelf, "@code");
+    vMsg = rb_iv_get(vSelf, "@message");
+    sprintf(sMsg, "#<AerospikeNative::Exception: @code=%d, @message=\"%s\">", NUM2INT(vCode), StringValueCStr(vMsg));
+
+    return rb_str_new2(sMsg);
+}
+
 void define_exception()
 {
     ExceptionClass = rb_define_class_under(AerospikeNativeClass, "Exception", rb_eStandardError);
     rb_define_method(ExceptionClass, "initialize", exception_initialize, 1);
+    rb_define_method(ExceptionClass, "inspect", exception_inspect, 0);
     rb_define_attr(ExceptionClass, "code", 1, 0);
     rb_define_attr(ExceptionClass, "message", 1, 0);
 

data/ext/aerospike_native/record.c

@@ -43,15 +43,18 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
 
     vKeyParams[0] = rb_str_new2(current_key.ns);
     vKeyParams[1] = rb_str_new2(current_key.set);
+    vKeyParams[2] = Qnil;
 
-    if (current_key.valuep == NULL) {
-        vKeyParams[2] = Qnil;
-    } else {
-        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);
+    if (current_key.valuep != NULL) {
+        switch( as_val_type(current_key.valuep) ) {
+        case AS_INTEGER:
+            vKeyParams[2] = INT2NUM(as_integer_get(current_key.valuep));
+            break;
+        case AS_STRING:
+            if (current_key.value.string.len > 0) {
+                vKeyParams[2] = rb_str_new2(as_string_get(current_key.valuep));
+            }
+            break;
         }
     }
     vKeyParams[3] = rb_str_new(current_key.digest.value, AS_DIGEST_VALUE_SIZE);
@@ -69,12 +72,13 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
             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));
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), LONG2NUM(as_integer_get(bin.valuep)));
             break;
         case AS_STRING:
-            rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_str_new2(bin.valuep->string.value));
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_str_new2(as_string_get(bin.valuep)));
             break;
         case AS_BYTES: {
+//            as_bytes_get();
             VALUE vString = rb_str_new(bin.valuep->bytes.value, bin.valuep->bytes.size);
             rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_funcall(vMsgPackClass, rb_intern("unpack"), 1, vString));
             break;

data/lib/aerospike_native/version.rb

@@ -1,3 +1,3 @@
 module AerospikeNative
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Vladimir Ziablitskii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -95,11 +95,14 @@ files:
 - README.md
 - Rakefile
 - aerospike_native.gemspec
+- examples/batch.rb
 - examples/common/common.rb
 - examples/operate.rb
 - examples/query_and_index.rb
 - ext/aerospike_native/aerospike_native.c
 - ext/aerospike_native/aerospike_native.h
+- ext/aerospike_native/batch.c
+- ext/aerospike_native/batch.h
 - ext/aerospike_native/client.c
 - ext/aerospike_native/client.h
 - ext/aerospike_native/common.c