aerospike_native 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb0270c96b7bd4fa49f251d9b5fd406a21ae109b
-  data.tar.gz: 92c3cdb727dafa076735b779eb198011cb028058
+  metadata.gz: c1d71f1edfd8c586f26365cc3d4164e82bd3edf7
+  data.tar.gz: c3a672ce0944477a43dae020b55e5656b438e933
 SHA512:
-  metadata.gz: 27c8668efda00c0a467844f5f840fce63223dbbab69d71e53d8c9177c1bf6a4c23f69fb5366a3092a6b20eb90be95c372126fa1b4de1653533e3596a4957dcdf
-  data.tar.gz: 9d4fde1a9e2942ac4bfbe108cbc6babd807fdf37eef6d67e079cb797297458ab8404971716f7613d2bf1542c2c08ed3bbfdaf4df5b035be96521b492167dfde5
+  metadata.gz: 2f47a757e7d62cc85edec99c5912b581892d286b9fea1b630d4bd95f55e3d7d34159877304aa9d858995e176e23b23fe463bb2d401ebd79ba71ca1dd69af9430
+  data.tar.gz: ded5c49c747f022322ddd58c3a4cdf257f0a01195e31315cd7759d87fb7c5cfd16da4b1fae529d0c6b84043d86cfb3b5852bbffa7c34706704ce54e2296ed0af

data/examples/batch.rb

@@ -1,4 +1,8 @@
-require './common/common'
+require_relative './common/common'
+
+def keys(namespace, set, *values)
+  values.map{ |value| AerospikeNative::Key.new(namespace, set, value) }
+end
 
 def main
   Common::Common.run_example do |client, namespace, set, logger|
@@ -7,20 +11,16 @@ def main
       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")
+    bins = [:number, :key]
 
-    records = client.batch.get_exists(keys)
+    records = client.batch.exists(keys(namespace, set, 1, 10, "key5", "key26"))
     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)
+    records = client.batch.get(keys(namespace, set, 1, 10, "key5", "key26"))
     logger.info "fetched records with all bins: #{records.inspect}"
+
+    records = client.batch.get(keys(namespace, set, 1, 10, "key5", "key26"), bins)
+    logger.info "fetched records with specified bins: #{records.inspect}"
   end
 end
 

data/examples/operate.rb

@@ -1,4 +1,4 @@
-require './common/common'
+require_relative './common/common'
 
 def main
   Common::Common.run_example do |client, namespace, set, logger|
@@ -28,4 +28,4 @@ def main
   end
 end
 
-main
+main

data/examples/put_get_remove.rb

@@ -0,0 +1,21 @@
+require_relative './common/common'
+
+def main
+  Common::Common.run_example do |client, namespace, set, logger|
+    keys = []
+    keys << AerospikeNative::Key.new(namespace, set, 1)
+    keys << AerospikeNative::Key.new(namespace, set, "hello")
+    keys << AerospikeNative::Key.new(namespace, set, 2.5)
+
+    keys.each do |key|
+      next if client.exists?(key)
+
+      client.put(key, {'testbin' => 1, 'testbin2' => 2.5, 'testbin3' => "string", 'testbin4' => [1, 2, 3]})
+      logger.info "GET #{key.inspect} - #{client.get(key).inspect}"
+      client.remove key
+    end
+  end
+end
+
+main
+

data/examples/query_and_index.rb

@@ -1,4 +1,4 @@
-require './common/common'
+require_relative './common/common'
 
 def main
   Common::Common.run_example do |client, namespace, set, logger|
@@ -16,4 +16,4 @@ def main
   end
 end
 
-main
+main

data/examples/scan.rb

@@ -0,0 +1,17 @@
+require_relative './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})
+    end
+
+    records = client.scan(namespace, set).exec
+    logger.info "scan records with all bins: #{records.inspect}"
+
+    records = client.scan(namespace, set).select(:number, :testbin).exec
+    logger.info "scan records with specified bins: #{records.inspect}"
+  end
+end
+
+main

data/ext/aerospike_native/aerospike_native.c

@@ -6,15 +6,19 @@
 #include "policy.h"
 #include "query.h"
 #include "batch.h"
+#include "scan.h"
 
 VALUE AerospikeNativeClass;
+VALUE MsgPackClass;
 
 void Init_aerospike_native()
 {
+    MsgPackClass = rb_const_get(rb_cObject, rb_intern("MessagePack"));
     AerospikeNativeClass = rb_define_module("AerospikeNative");
     define_exception();
     define_logger();
     define_query();
+    define_scan();
     define_batch();
     define_native_key();
     define_record();

data/ext/aerospike_native/aerospike_native.h

@@ -6,6 +6,7 @@
 #include <aerospike/aerospike_index.h>
 
 RUBY_EXTERN VALUE AerospikeNativeClass;
+RUBY_EXTERN VALUE MsgPackClass;
 
 enum IndexType {
     INDEX_STRING = AS_INDEX_STRING,

data/ext/aerospike_native/batch.c

@@ -15,11 +15,8 @@ VALUE batch_initialize(VALUE vSelf, VALUE vClient)
 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: {
@@ -35,11 +32,11 @@ bool batch_read_callback(const as_batch_read* results, uint32_t n, void* udata)
         }
         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));
+            rb_funcall(LoggerInstance, 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));
+            rb_funcall(LoggerInstance, rb_intern("error"), 1, rb_str_new2(sMsg));
         }
     }
 
@@ -82,7 +79,7 @@ VALUE batch_get(int argc, VALUE* vArgs, VALUE vSelf)
         bins_idx = RARRAY_LEN(vBins);
 
         if (TYPE(vArgs[2]) != T_NIL) {
-            SET_POLICY(policy, vArgs[2]);
+            SET_BATCH_POLICY(policy, vArgs[2]);
         }
     } else {
         switch(TYPE(vArgs[1])) {
@@ -173,7 +170,7 @@ VALUE batch_exists(int argc, VALUE* vArgs, VALUE vSelf)
 
     as_policy_batch_init(&policy);
     if (argc == 2 && TYPE(vArgs[1]) != T_NIL) {
-        SET_POLICY(policy, vArgs[1]);
+        SET_BATCH_POLICY(policy, vArgs[1]);
     }
 
     idx = RARRAY_LEN(vKeys);

data/ext/aerospike_native/client.c

@@ -4,6 +4,7 @@
 #include "record.h"
 #include "query.h"
 #include "batch.h"
+#include "scan.h"
 #include <aerospike/as_key.h>
 #include <aerospike/as_operations.h>
 #include <aerospike/aerospike_key.h>
@@ -11,12 +12,13 @@
 #include <aerospike/aerospike_query.h>
 
 VALUE ClientClass;
+VALUE LoggerInstance;
 
-void check_aerospike_client(VALUE vKey)
+void check_aerospike_client(VALUE vClient)
 {
     char sName[] = "AerospikeNative::Client";
 
-    if (strcmp(sName, rb_obj_classname(vKey)) != 0) {
+    if (strcmp(sName, rb_obj_classname(vClient)) != 0) {
         rb_raise(rb_eArgError, "Incorrect type (expected %s)", sName);
     }
 }
@@ -45,7 +47,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)
 {
@@ -641,20 +643,22 @@ VALUE client_query(VALUE vSelf, VALUE vNamespace, VALUE vSet)
 
 VALUE client_set_logger(VALUE vSelf, VALUE vNewLogger)
 {
-    VALUE vLogger = rb_cv_get(vSelf, "@@logger");
-    rb_iv_set(vLogger, "@internal", vNewLogger);
-
-    return vLogger;
+    rb_iv_set(LoggerInstance, "@internal", vNewLogger);
+    return LoggerInstance;
 }
 
 VALUE client_set_log_level(VALUE vSelf, VALUE vLevel)
 {
-    VALUE vLogger = rb_cv_get(vSelf, "@@logger");
     Check_Type(vLevel, T_SYMBOL);
-
-    return rb_funcall(vLogger, rb_intern("set_level"), 1, vLevel);
+    return rb_funcall(LoggerInstance, rb_intern("set_level"), 1, vLevel);
 }
 
+/*
+ * call-seq:
+ *   batch -> AerospikeNative::Batch
+ *
+ * Instantiate new batch
+ */
 VALUE client_batch(VALUE vSelf)
 {
     VALUE vParams[1];
@@ -663,6 +667,47 @@ VALUE client_batch(VALUE vSelf)
     return rb_class_new_instance(1, vParams, BatchClass);
 }
 
+/*
+ * call-seq:
+ *   scan(namespace, set) -> AerospikeNative::Scan
+ *
+ * Instantiate new scan
+ */
+VALUE client_scan(VALUE vSelf, VALUE vNamespace, VALUE vSet)
+{
+    VALUE vParams[3];
+
+    vParams[0] = vSelf;
+    vParams[1] = vNamespace;
+    vParams[2] = vSet;
+
+    return rb_class_new_instance(3, vParams, ScanClass);
+}
+
+/*
+ * call-seq:
+ *   scan_info(scan_id) -> Hash
+ *   scan_info(scan_id, scan_policy) -> Hash
+ *
+ * return scan info
+ */
+VALUE client_scan_info(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vParams[3];
+    if (argc > 1) {  // there should only be 1 or 2 argument
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
+
+    vParams[0] = vSelf;
+    vParams[1] = vArgs[0];
+    vParams[2] = Qnil;
+    if (argc == 2) {
+        vParams[2] = vArgs[1];
+    }
+
+    return rb_funcall2(ScanClass, rb_intern("info"), 3, vParams);
+}
+
 void define_client()
 {
     ClientClass = rb_define_class_under(AerospikeNativeClass, "Client", rb_cObject);
@@ -678,8 +723,11 @@ void define_client()
     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_define_method(ClientClass, "scan", client_scan, 2);
+    rb_define_method(ClientClass, "scan_info", client_scan_info, -1);
 
-    rb_cv_set(ClientClass, "@@logger", rb_class_new_instance(0, NULL, LoggerClass));
+    LoggerInstance = rb_class_new_instance(0, NULL, LoggerClass);
+    rb_cv_set(ClientClass, "@@logger", LoggerInstance);
     rb_define_singleton_method(ClientClass, "set_logger", client_set_logger, 1);
     rb_define_singleton_method(ClientClass, "set_log_level", client_set_log_level, 1);
 }

data/ext/aerospike_native/client.h

@@ -4,7 +4,8 @@
 #include "aerospike_native.h"
 
 RUBY_EXTERN VALUE ClientClass;
+RUBY_EXTERN VALUE LoggerInstance;
 void define_client();
-void check_aerospike_client(VALUE vKey);
+void check_aerospike_client(VALUE vClient);
 
 #endif // CLIENT_H

data/ext/aerospike_native/common.h

@@ -180,5 +180,29 @@ VALUE rb_hash_keys(VALUE hash);
         policy.check_bounds = RTEST(vCheckBounds);                         \
     }
 
+#define SET_SCAN_POLICY(policy, vSettings)                                 \
+    VALUE vFailOnClusterChange;                                            \
+    SET_POLICY(policy, vSettings);                                         \
+    vFailOnClusterChange = rb_hash_aref(vSettings, rb_str_new2("fail_on_cluster_change")); \
+    if (TYPE(vFailOnClusterChange) != T_NIL) {                             \
+        policy.fail_on_cluster_change = RTEST(vFailOnClusterChange);       \
+    }
+
+#define SET_BATCH_POLICY(policy, vSettings)                                \
+    VALUE vConcurrent, vAllowInline, vUseBatchDirect;                      \
+    SET_POLICY(policy, vSettings);                                         \
+    vConcurrent = rb_hash_aref(vSettings, rb_str_new2("concurrent"));      \
+    if (TYPE(vConcurrent) != T_NIL) {                                      \
+        policy.concurrent = RTEST(vConcurrent);                            \
+    }                                                                      \
+    vUseBatchDirect = rb_hash_aref(vSettings, rb_str_new2("use_batch_direct"));\
+    if (TYPE(vUseBatchDirect) != T_NIL) {                                  \
+        policy.use_batch_direct = RTEST(vUseBatchDirect);                  \
+    }                                                                      \
+    vAllowInline = rb_hash_aref(vSettings, rb_str_new2("allow_inline"));   \
+    if (TYPE(vAllowInline) != T_NIL) {                                     \
+        policy.allow_inline = RTEST(vAllowInline);                         \
+    }
+
 #endif // COMMON_H
 

data/ext/aerospike_native/key.c

@@ -50,7 +50,7 @@ VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
 
     Data_Get_Struct(vSelf, as_key, ptr);
 
-    if(TYPE(vValue) == T_STRING || TYPE(vValue) == T_FIXNUM) {
+    if(TYPE(vValue) != T_NIL) {
         switch(TYPE(vValue)) {
         case T_FIXNUM:
             as_key_init_int64(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), FIX2LONG( vValue ));
@@ -58,8 +58,10 @@ VALUE key_initialize(int argc, VALUE* vArgs, VALUE vSelf)
         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");
+        default: {
+            VALUE vBytes = rb_funcall(vValue, rb_intern("to_msgpack"), 0);
+            as_key_init_raw(ptr, StringValueCStr( vNamespace ), StringValueCStr( vSet ), StringValuePtr(vBytes), RSTRING_LEN(vBytes));
+        }
         }
     } else {
         Check_Type(vValue, T_NIL);

data/ext/aerospike_native/logger.c

@@ -8,15 +8,14 @@ bool aerospike_log_callback(as_log_level level, const char *func, const char *fi
 {
     char msg[1024] = {0};
     va_list ap;
-    VALUE vLogger = rb_cv_get(ClientClass, "@@logger");
 
     va_start(ap, fmt);
     vsnprintf(msg, 1024, fmt, ap);
     msg[1023] = '\0';
     va_end(ap);
 
-    if(TYPE(vLogger) != T_NIL) {
-        rb_funcall(vLogger, rb_intern("write"), 2, INT2FIX(level), rb_str_new2(msg));
+    if(TYPE(LoggerInstance) != T_NIL) {
+        rb_funcall(LoggerInstance, rb_intern("write"), 2, INT2FIX(level), rb_str_new2(msg));
     }
 
     return true;

data/ext/aerospike_native/query.c

@@ -18,6 +18,13 @@ VALUE query_initialize(VALUE vSelf, VALUE vClient, VALUE vNamespace, VALUE vSet)
     return vSelf;
 }
 
+/*
+ * call-seq:
+ *   select(bins) -> AerospikeNative::Query
+ *   select(bin1, bin2, bin3, ...) -> AerospikeNative::Query
+ *
+ * set specified bins
+ */
 VALUE query_select(int argc, VALUE* vArgs, VALUE vSelf)
 {
     VALUE vBins;

data/ext/aerospike_native/query.h

@@ -5,6 +5,7 @@
 
 RUBY_EXTERN VALUE QueryClass;
 void define_query();
+bool query_callback(const as_val *value, void *udata);
 
 #endif // QUERY_H
 

data/ext/aerospike_native/record.c

@@ -28,8 +28,6 @@ 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;
-    VALUE vMsgPackClass;
     as_key current_key;
     as_bin bin;
     int n;
@@ -55,6 +53,11 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
                 vKeyParams[2] = rb_str_new2(as_string_get(current_key.valuep));
             }
             break;
+        case AS_BYTES: {
+            VALUE vString = rb_str_new(as_bytes_get(current_key.valuep), as_bytes_size(current_key.valuep));
+            vKeyParams[2] = rb_funcall(MsgPackClass, rb_intern("unpack"), 1, vString);
+            break;
+        }
         }
     }
     vKeyParams[3] = rb_str_new(current_key.digest.value, AS_DIGEST_VALUE_SIZE);
@@ -64,7 +67,7 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
     vParams[2] = UINT2NUM(record->gen);
     vParams[3] = UINT2NUM(record->ttl);
 
-    vMsgPackClass = rb_const_get(rb_cObject, rb_intern("MessagePack"));
+    MsgPackClass = rb_const_get(rb_cObject, rb_intern("MessagePack"));
     for(n = 0; n < record->bins.size; n++) {
         bin = record->bins.entries[n];
         switch( as_val_type(bin.valuep) ) {
@@ -78,16 +81,14 @@ VALUE rb_record_from_c(as_record* record, as_key* key)
             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));
+            VALUE vString = rb_str_new(as_bytes_get(bin.valuep), as_bytes_size(bin.valuep));
+            rb_hash_aset(vParams[1], rb_str_new2(bin.name), rb_funcall(MsgPackClass, rb_intern("unpack"), 1, vString));
             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));
+            rb_funcall(LoggerInstance, rb_intern("warn"), 1, rb_str_new2(msg));
             break;
         }
     }

data/ext/aerospike_native/scan.c

@@ -0,0 +1,271 @@
+#include "scan.h"
+#include "query.h"
+#include "client.h"
+#include <aerospike/aerospike_scan.h>
+
+VALUE ScanClass;
+
+static void scan_deallocate(void *p)
+{
+    as_scan* ptr = p;
+    as_scan_destroy(ptr);
+}
+
+VALUE scan_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;
+}
+
+/*
+ * call-seq:
+ *   select(bins) -> AerospikeNative::Scan
+ *   select(bin1, bin2, bin3, ...) -> AerospikeNative::Scan
+ *
+ * set specified bins
+ */
+VALUE scan_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;
+}
+
+VALUE scan_concurrent(VALUE vSelf, VALUE vValue)
+{
+    rb_iv_set(vSelf, "@concurrent", vValue);
+    return vSelf;
+}
+
+VALUE scan_percent(VALUE vSelf, VALUE vValue)
+{
+    rb_iv_set(vSelf, "@percent", vValue);
+    return vSelf;
+}
+
+VALUE scan_priority(VALUE vSelf, VALUE vValue)
+{
+    rb_iv_set(vSelf, "@priority", vValue);
+    return vSelf;
+}
+
+VALUE scan_no_bins(VALUE vSelf, VALUE vValue)
+{
+    rb_iv_set(vSelf, "@no_bins", vValue);
+    return vSelf;
+}
+
+VALUE scan_background(VALUE vSelf, VALUE vValue)
+{
+    rb_iv_set(vSelf, "@background", vValue);
+    return vSelf;
+}
+
+/*
+ * call-seq:
+ *   exec -> records
+ *   exec(scan_policy) -> records
+ *   exec { |record| ... } -> Nil
+ *   exec(scan_policy) { |record| ... } -> Nil
+ *
+ * perform scan
+ */
+VALUE scan_exec(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vClient, vNamespace, vSet;
+    VALUE vArray;
+    VALUE vConcurrent, vPercent, vPriority, vBins, vNoBins, vBackground;
+    as_scan scan;
+    as_policy_scan policy;
+    as_error err;
+    aerospike* ptr;
+
+    int n, idx = 0;
+    bool is_background = false;
+
+    if (argc > 1) {  // there should only be 0 or 1 argument
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+
+    as_policy_scan_init(&policy);
+    if(argc == 1) {
+        SET_SCAN_POLICY(policy, vArgs[0]);
+    }
+
+    vClient = rb_iv_get(vSelf, "@client");
+    vNamespace = rb_iv_get(vSelf, "@namespace");
+    vSet = rb_iv_get(vSelf, "@set");
+    vConcurrent = rb_iv_get(vSelf, "@concurrent");
+    vPercent = rb_iv_get(vSelf, "@percent");
+    vPriority = rb_iv_get(vSelf, "@priority");
+    vNoBins = rb_iv_get(vSelf, "@no_bins");
+    vBins = rb_iv_get(vSelf, "@select_bins");
+    vBackground = rb_iv_get(vSelf, "@background");
+    as_scan_init(&scan, StringValueCStr(vNamespace), StringValueCStr(vSet));
+
+    if (TYPE(vPercent) == T_FIXNUM) {
+        as_scan_set_percent(&scan, FIX2INT(vPercent));
+    }
+
+    if (TYPE(vPriority) == T_FIXNUM) {
+        as_scan_set_priority(&scan, FIX2INT(vPriority));
+    }
+
+    if (TYPE(vConcurrent) != T_NIL) {
+        as_scan_set_priority(&scan, RTEST(vConcurrent));
+    }
+
+    if (TYPE(vNoBins) != T_NIL) {
+        as_scan_set_nobins(&scan, RTEST(vNoBins));
+    }
+
+    if (TYPE(vBackground) != T_NIL) {
+        is_background = RTEST(vBackground);
+    }
+
+    if (TYPE(vBins) == T_ARRAY && (idx = RARRAY_LEN(vBins)) > 0) {
+        as_scan_select_inita(&scan, idx);
+        for(n = 0; n < idx; n++) {
+            VALUE vEntry = rb_ary_entry(vBins, n);
+            as_scan_select(&scan, StringValueCStr(vEntry));
+        }
+    }
+
+    Data_Get_Struct(vClient, aerospike, ptr);
+
+    vArray = rb_ary_new();
+    if(is_background) {
+        uint64_t scan_id = 0;
+        if (aerospike_scan_background(ptr, &err, &policy, &scan, &scan_id) != AEROSPIKE_OK) {
+            as_scan_destroy(&scan);
+            raise_aerospike_exception(err.code, err.message);
+        }
+        as_scan_destroy(&scan);
+        return ULONG2NUM(scan_id);
+    }
+
+    if (aerospike_scan_foreach(ptr, &err, &policy, &scan, query_callback, &vArray) != AEROSPIKE_OK) {
+        as_scan_destroy(&scan);
+        raise_aerospike_exception(err.code, err.message);
+    }
+
+    as_scan_destroy(&scan);
+    if ( rb_block_given_p() ) {
+        return Qnil;
+    }
+
+    return vArray;
+}
+
+
+/*
+ * call-seq:
+ *   info(client, scan_id) -> Hash
+ *   info(client, scan_id, scan_policy) -> Hash
+ *
+ * return scan info
+ */
+VALUE scan_info(int argc, VALUE* vArgs, VALUE vSelf)
+{
+    VALUE vClient, vHash;
+    as_scan_info info;
+    as_policy_scan policy;
+    as_error err;
+    aerospike* ptr;
+    uint64_t scan_id;
+
+    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);
+    }
+
+    vClient = vArgs[0];
+    check_aerospike_client(vClient);
+
+    Check_Type(vArgs[1], T_FIXNUM);
+    scan_id = FIX2ULONG(vArgs[1]);
+
+    as_policy_scan_init(&policy);
+    if(argc == 3 && TYPE(vArgs[2]) != T_NIL) {
+        SET_SCAN_POLICY(policy, vArgs[2]);
+    }
+
+    Data_Get_Struct(vClient, aerospike, ptr);
+
+    if (aerospike_scan_info(ptr, &err, &policy, scan_id, &info) != AEROSPIKE_OK) {
+        raise_aerospike_exception(err.code, err.message);
+    }
+
+    vHash = rb_hash_new();
+    rb_hash_aset(vHash, rb_str_new2("progress_percent"), ULONG2NUM(info.progress_pct));
+    rb_hash_aset(vHash, rb_str_new2("records_scanned"), ULONG2NUM(info.records_scanned));
+    rb_hash_aset(vHash, rb_str_new2("status"), INT2NUM(info.status));
+
+    return vHash;
+}
+
+void define_scan()
+{
+    ScanClass = rb_define_class_under(AerospikeNativeClass, "Scan", rb_cObject);
+    rb_define_method(ScanClass, "initialize", scan_initialize, 3);
+    rb_define_method(ScanClass, "exec", scan_exec, -1);
+    rb_define_method(ScanClass, "select", scan_select, -1);
+    rb_define_method(ScanClass, "set_concurrent", scan_concurrent, 1);
+    rb_define_method(ScanClass, "set_percent", scan_percent, 1);
+    rb_define_method(ScanClass, "set_priority", scan_priority, 1);
+    rb_define_method(ScanClass, "set_no_bins", scan_no_bins, 1);
+//    rb_define_method(ScanClass, "set_background", scan_background, 1);
+    rb_define_singleton_method(ScanClass, "info", scan_info, -1);
+
+    rb_define_attr(ScanClass, "client", 1, 0);
+    rb_define_attr(ScanClass, "select_bins", 1, 0);
+    rb_define_attr(ScanClass, "concurrent", 1, 0);
+    rb_define_attr(ScanClass, "percent", 1, 0);
+    rb_define_attr(ScanClass, "priority", 1, 0);
+    rb_define_attr(ScanClass, "no_bins", 1, 0);
+    rb_define_attr(ScanClass, "background", 1, 0);
+
+    rb_define_const(ScanClass, "STATUS_UNDEFINED", INT2FIX(AS_SCAN_STATUS_UNDEF));
+    rb_define_const(ScanClass, "STATUS_INPROGRESS", INT2FIX(AS_SCAN_STATUS_INPROGRESS));
+    rb_define_const(ScanClass, "STATUS_ABORTED", INT2FIX(AS_SCAN_STATUS_ABORTED));
+    rb_define_const(ScanClass, "STATUS_COMPLETED", INT2FIX(AS_SCAN_STATUS_COMPLETED));
+
+    rb_define_const(ScanClass, "PRIORITY_AUTO", INT2FIX(AS_SCAN_PRIORITY_AUTO));
+    rb_define_const(ScanClass, "PRIORITY_HIGH", INT2FIX(AS_SCAN_PRIORITY_HIGH));
+    rb_define_const(ScanClass, "PRIORITY_MEDIUM", INT2FIX(AS_SCAN_PRIORITY_MEDIUM));
+    rb_define_const(ScanClass, "PRIORITY_LOW", INT2FIX(AS_SCAN_PRIORITY_LOW));
+}

data/ext/aerospike_native/scan.h

@@ -0,0 +1,10 @@
+#ifndef SCAN_H
+#define SCAN_H
+
+#include "aerospike_native.h"
+
+RUBY_EXTERN VALUE ScanClass;
+void define_scan();
+
+#endif // SCAN_H
+

data/lib/aerospike_native/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aerospike_native
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Vladimir Ziablitskii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-23 00:00:00.000000000 Z
+date: 2015-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -98,7 +98,9 @@ files:
 - examples/batch.rb
 - examples/common/common.rb
 - examples/operate.rb
+- examples/put_get_remove.rb
 - examples/query_and_index.rb
+- examples/scan.rb
 - ext/aerospike_native/aerospike_native.c
 - ext/aerospike_native/aerospike_native.h
 - ext/aerospike_native/batch.c
@@ -124,6 +126,8 @@ files:
 - ext/aerospike_native/query.h
 - ext/aerospike_native/record.c
 - ext/aerospike_native/record.h
+- ext/aerospike_native/scan.c
+- ext/aerospike_native/scan.h
 - lib/aerospike_native.rb
 - lib/aerospike_native/version.rb
 homepage: https://github.com/rainlabs/aerospike_native