couchbase 1.2.0.beta-x86-mingw32 → 1.2.0-x86-mingw32

data/couchbase.gemspec

@@ -46,6 +46,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'yard-xml'
   s.add_development_dependency 'mini_portile'
   s.add_development_dependency 'yajl-ruby', '~> 1.1.0'
-  s.add_development_dependency RUBY_VERSION =~ /^1\.9/ ? 'debugger' : 'ruby-debug'
   s.add_development_dependency 'active_support'
 end

data/ext/couchbase_ext/arguments.c

@@ -17,32 +17,45 @@
 
 #include "couchbase_ext.h"
 
-
 /* TOUCH */
 
+#define _alloc_data_for_s(type, _type, size, items, ptr) do {\
+    lcb_size_t ii; \
+    \
+    params->cmd.type.num = size; \
+    params->cmd.type.items = calloc(size, sizeof(_type)); \
+    if (params->cmd.type.items == NULL) { \
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments"); \
+    } \
+    params->cmd.type.ptr = calloc(size, sizeof(_type *)); \
+    if (params->cmd.type.ptr == NULL) { \
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments"); \
+    } \
+    for (ii = 0; ii < size; ++ii) { \
+        params->cmd.type.ptr[ii] = params->cmd.type.items + ii; \
+    } \
+} while(0)
+
+#define _alloc_data_for(type, _type) _alloc_data_for_s(type, _type, size, items, ptr)
+
+
+#define _release_data_for_s(type, items, ptr) \
+    free(params->cmd.type.items); \
+    free(params->cmd.type.ptr);
+
+#define _release_data_for(type) _release_data_for_s(type, items, ptr)
+
+
     static void
-cb_params_touch_alloc(struct params_st *params, lcb_size_t size)
+cb_params_touch_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.touch.num = size;
-    params->cmd.touch.items = xcalloc(size, sizeof(lcb_touch_cmd_t));
-    if (params->cmd.touch.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.touch.ptr = xcalloc(size, sizeof(lcb_touch_cmd_t *));
-    if (params->cmd.touch.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.touch.ptr[ii] = params->cmd.touch.items + ii;
-    }
+    _alloc_data_for(touch, lcb_touch_cmd_t);
 }
 
     static void
-cb_params_touch_init_item(struct params_st *params, lcb_size_t idx, VALUE key_obj, lcb_time_t exptime)
+cb_params_touch_init_item(struct cb_params_st *params, lcb_size_t idx, VALUE key_obj, lcb_time_t exptime)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.touch.items[idx].v.v0.key = RSTRING_PTR(key_obj);
     params->cmd.touch.items[idx].v.v0.nkey = RSTRING_LEN(key_obj);
     params->cmd.touch.items[idx].v.v0.exptime = exptime;
@@ -52,30 +65,31 @@ cb_params_touch_init_item(struct params_st *params, lcb_size_t idx, VALUE key_ob
     static int
 cb_params_touch_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     cb_params_touch_init_item(params, params->idx++, key, NUM2ULONG(value));
     return ST_CONTINUE;
 }
 
     static void
-cb_params_touch_parse_options(struct params_st *params, VALUE options)
+cb_params_touch_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    tmp = rb_hash_aref(options, sym_ttl);
+    tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
         params->cmd.touch.ttl = NUM2ULONG(tmp);
     }
-    if (RTEST(rb_funcall(options, id_has_key_p, 1, sym_quiet))) {
-        params->cmd.touch.quiet = RTEST(rb_hash_aref(options, sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.touch.quiet = RTEST(tmp);
     }
 }
 
     static void
-cb_params_touch_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_touch_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -117,28 +131,15 @@ cb_params_touch_parse_arguments(struct params_st *params, int argc, VALUE argv)
 /* REMOVE */
 
     static void
-cb_params_remove_alloc(struct params_st *params, lcb_size_t size)
+cb_params_remove_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.remove.num = size;
-    params->cmd.remove.items = xcalloc(size, sizeof(lcb_remove_cmd_t));
-    if (params->cmd.remove.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.remove.ptr = xcalloc(size, sizeof(lcb_remove_cmd_t *));
-    if (params->cmd.remove.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.remove.ptr[ii] = params->cmd.remove.items + ii;
-    }
+    _alloc_data_for(remove, lcb_remove_cmd_t);
 }
 
     static void
-cb_params_remove_init_item(struct params_st *params, lcb_size_t idx, VALUE key_obj, lcb_cas_t cas)
+cb_params_remove_init_item(struct cb_params_st *params, lcb_size_t idx, VALUE key_obj, lcb_cas_t cas)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.remove.items[idx].v.v0.key = RSTRING_PTR(key_obj);
     params->cmd.remove.items[idx].v.v0.nkey = RSTRING_LEN(key_obj);
     params->cmd.remove.items[idx].v.v0.cas = cas;
@@ -148,30 +149,31 @@ cb_params_remove_init_item(struct params_st *params, lcb_size_t idx, VALUE key_o
     static int
 cb_params_remove_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     cb_params_remove_init_item(params, params->idx++, key, NUM2ULL(value));
     return ST_CONTINUE;
 }
 
     static void
-cb_params_remove_parse_options(struct params_st *params, VALUE options)
+cb_params_remove_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    if (RTEST(rb_funcall(options, id_has_key_p, 1, sym_quiet))) {
-        params->cmd.remove.quiet = RTEST(rb_hash_aref(options, sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.remove.quiet = RTEST(tmp);
     }
-    tmp = rb_hash_aref(options, sym_cas);
+    tmp = rb_hash_aref(options, cb_sym_cas);
     if (tmp != Qnil) {
         params->cmd.remove.cas = NUM2ULL(tmp);
     }
 }
 
     static void
-cb_params_remove_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_remove_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -212,33 +214,30 @@ cb_params_remove_parse_arguments(struct params_st *params, int argc, VALUE argv)
 
 /* STORE */
     static void
-cb_params_store_alloc(struct params_st *params, lcb_size_t size)
+cb_params_store_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.store.num = size;
-    params->cmd.store.items = xcalloc(size, sizeof(lcb_store_cmd_t));
-    if (params->cmd.store.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.store.ptr = xcalloc(size, sizeof(lcb_store_cmd_t *));
-    if (params->cmd.store.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.store.ptr[ii] = params->cmd.store.items + ii;
-    }
+    _alloc_data_for(store, lcb_store_cmd_t);
 }
 
     static void
-cb_params_store_init_item(struct params_st *params, lcb_size_t idx,
+cb_params_store_init_item(struct cb_params_st *params, lcb_size_t idx,
         VALUE key_obj, VALUE value_obj, lcb_uint32_t flags, lcb_cas_t cas,
         lcb_time_t exptime)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
-    value_obj = encode_value(value_obj, params->cmd.store.flags);
-    if (value_obj == Qundef) {
-        rb_raise(eValueFormatError, "unable to convert value for key '%s'", RSTRING_PTR(key_obj));
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
+    value_obj = cb_encode_value(value_obj, params->cmd.store.flags);
+    if (rb_obj_is_kind_of(value_obj, rb_eStandardError)) {
+        VALUE exc_str = rb_funcall(value_obj, cb_id_to_s, 0);
+        VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
+                rb_str_new2("unable to convert value for key '%s': %s"), key_obj, exc_str);
+        VALUE exc = rb_exc_new3(cb_eValueFormatError, msg);
+        rb_ivar_set(exc, cb_id_iv_inner_exception, value_obj);
+        rb_exc_raise(exc);
+    }
+    /* the value must be string after conversion */
+    if (TYPE(value_obj) != T_STRING) {
+        VALUE val = rb_any_to_s(value_obj);
+        rb_raise(cb_eValueFormatError, "unable to convert value for key '%s' to string: %s", RSTRING_PTR(key_obj), RSTRING_PTR(val));
     }
     params->cmd.store.items[idx].v.v0.datatype = params->cmd.store.datatype;
     params->cmd.store.items[idx].v.v0.operation = params->cmd.store.operation;
@@ -255,50 +254,50 @@ cb_params_store_init_item(struct params_st *params, lcb_size_t idx,
     static int
 cb_params_store_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     cb_params_store_init_item(params, params->idx++, key, value,
             params->cmd.store.flags, 0, params->cmd.store.ttl);
     return ST_CONTINUE;
 }
 
     static void
-cb_params_store_parse_options(struct params_st *params, VALUE options)
+cb_params_store_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    tmp = rb_hash_aref(options, sym_flags);
+    tmp = rb_hash_aref(options, cb_sym_flags);
     if (tmp != Qnil) {
         params->cmd.store.flags = (lcb_uint32_t)NUM2ULONG(tmp);
     }
-    tmp = rb_hash_aref(options, sym_format);
+    tmp = rb_hash_aref(options, cb_sym_format);
     if (tmp != Qnil) { /* rewrite format bits */
-        params->cmd.store.flags = flags_set_format(params->cmd.store.flags, tmp);
+        params->cmd.store.flags = cb_flags_set_format(params->cmd.store.flags, tmp);
     }
-    tmp = rb_hash_aref(options, sym_ttl);
+    tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
         params->cmd.store.ttl = NUM2ULONG(tmp);
     }
-    tmp = rb_hash_aref(options, sym_cas);
+    tmp = rb_hash_aref(options, cb_sym_cas);
     if (tmp != Qnil) {
         params->cmd.store.cas = NUM2ULL(tmp);
     }
-    tmp = rb_hash_aref(options, sym_observe);
+    tmp = rb_hash_aref(options, cb_sym_observe);
     if (tmp != Qnil) {
         Check_Type(tmp, T_HASH);
-        rb_funcall(params->bucket->self, id_verify_observe_options, 1, tmp);
+        rb_funcall(params->bucket->self, cb_id_verify_observe_options, 1, tmp);
         params->cmd.store.observe = tmp;
     }
-    if (flags_get_format(params->cmd.store.flags) == sym_document) {
+    if (cb_flags_get_format(params->cmd.store.flags) == cb_sym_document) {
         /* just amend datatype for now */
         params->cmd.store.datatype = 0x01;
     }
 }
 
     static void
-cb_params_store_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_store_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     VALUE keys;
 
@@ -334,43 +333,20 @@ cb_params_store_parse_arguments(struct params_st *params, int argc, VALUE argv)
 
 /* GET */
     static void
-cb_params_get_alloc(struct params_st *params, lcb_size_t size)
+cb_params_get_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.get.num = size;
     if (params->cmd.get.replica) {
-        params->cmd.get.items = xcalloc(size, sizeof(lcb_get_replica_cmd_t));
-        if (params->cmd.get.items_gr == NULL) {
-            rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        params->cmd.get.ptr = xcalloc(size, sizeof(lcb_get_replica_cmd_t *));
-        if (params->cmd.get.ptr_gr == NULL) {
-            rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        for (ii = 0; ii < size; ++ii) {
-            params->cmd.get.ptr_gr[ii] = params->cmd.get.items_gr + ii;
-        }
+        _alloc_data_for_s(get, lcb_get_replica_cmd_t, size, items_gr, ptr_gr);
     } else {
-        params->cmd.get.items = xcalloc(size, sizeof(lcb_get_cmd_t));
-        if (params->cmd.get.items == NULL) {
-            rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        params->cmd.get.ptr = xcalloc(size, sizeof(lcb_get_cmd_t *));
-        if (params->cmd.get.ptr == NULL) {
-            rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        for (ii = 0; ii < size; ++ii) {
-            params->cmd.get.ptr[ii] = params->cmd.get.items + ii;
-        }
+        _alloc_data_for(get, lcb_get_cmd_t);
     }
 }
 
     static void
-cb_params_get_init_item(struct params_st *params, lcb_size_t idx,
+cb_params_get_init_item(struct cb_params_st *params, lcb_size_t idx,
         VALUE key_obj, lcb_time_t exptime)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     if (params->cmd.get.replica) {
         params->cmd.get.items_gr[idx].v.v0.key = RSTRING_PTR(key_obj);
         params->cmd.get.items_gr[idx].v.v0.nkey = RSTRING_LEN(key_obj);
@@ -387,37 +363,38 @@ cb_params_get_init_item(struct params_st *params, lcb_size_t idx,
     static int
 cb_params_get_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     rb_ary_push(params->cmd.get.keys_ary, key);
     cb_params_get_init_item(params, params->idx++, key, NUM2ULONG(value));
     return ST_CONTINUE;
 }
 
     static void
-cb_params_get_parse_options(struct params_st *params, VALUE options)
+cb_params_get_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    params->cmd.get.replica = RTEST(rb_hash_aref(options, sym_replica));
-    params->cmd.get.extended = RTEST(rb_hash_aref(options, sym_extended));
-    params->cmd.get.assemble_hash = RTEST(rb_hash_aref(options, sym_assemble_hash));
-    if (RTEST(rb_funcall(options, id_has_key_p, 1, sym_quiet))) {
-        params->cmd.get.quiet = RTEST(rb_hash_aref(options, sym_quiet));
+    params->cmd.get.replica = RTEST(rb_hash_aref(options, cb_sym_replica));
+    params->cmd.get.extended = RTEST(rb_hash_aref(options, cb_sym_extended));
+    params->cmd.get.assemble_hash = RTEST(rb_hash_aref(options, cb_sym_assemble_hash));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.get.quiet = RTEST(tmp);
     }
-    tmp = rb_hash_aref(options, sym_format);
+    tmp = rb_hash_aref(options, cb_sym_format);
     if (tmp != Qnil) {
         Check_Type(tmp, T_SYMBOL);
         params->cmd.get.forced_format = tmp;
     }
-    tmp = rb_hash_aref(options, sym_ttl);
+    tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
         params->cmd.get.ttl = NUM2ULONG(tmp);
     }
     /* boolean or number of seconds to lock */
-    tmp = rb_hash_aref(options, sym_lock);
+    tmp = rb_hash_aref(options, cb_sym_lock);
     if (tmp != Qnil) {
         params->cmd.get.lock = RTEST(tmp);
         if (TYPE(tmp) == T_FIXNUM) {
@@ -427,7 +404,7 @@ cb_params_get_parse_options(struct params_st *params, VALUE options)
 }
 
     static void
-cb_params_get_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_get_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -474,29 +451,16 @@ cb_params_get_parse_arguments(struct params_st *params, int argc, VALUE argv)
 
 /* ARITH */
     static void
-cb_params_arith_alloc(struct params_st *params, lcb_size_t size)
+cb_params_arith_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.arith.num = size;
-    params->cmd.arith.items = xcalloc(size, sizeof(lcb_arithmetic_cmd_t));
-    if (params->cmd.arith.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.arith.ptr = xcalloc(size, sizeof(lcb_arithmetic_cmd_t *));
-    if (params->cmd.arith.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.arith.ptr[ii] = params->cmd.arith.items + ii;
-    }
+    _alloc_data_for(arith, lcb_arithmetic_cmd_t);
 }
 
     static void
-cb_params_arith_init_item(struct params_st *params, lcb_size_t idx,
+cb_params_arith_init_item(struct cb_params_st *params, lcb_size_t idx,
         VALUE key_obj, lcb_int64_t delta)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.arith.items[idx].v.v0.key = RSTRING_PTR(key_obj);
     params->cmd.arith.items[idx].v.v0.nkey = RSTRING_LEN(key_obj);
     params->cmd.arith.items[idx].v.v0.delta = delta * params->cmd.arith.sign;
@@ -509,46 +473,49 @@ cb_params_arith_init_item(struct params_st *params, lcb_size_t idx,
     static int
 cb_params_arith_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     cb_params_arith_init_item(params, params->idx++, key, NUM2ULONG(value) & INT64_MAX);
     return ST_CONTINUE;
 }
 
     static void
-cb_params_arith_parse_options(struct params_st *params, VALUE options)
+cb_params_arith_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    params->cmd.arith.create = RTEST(rb_hash_aref(options, sym_create));
-    params->cmd.arith.extended = RTEST(rb_hash_aref(options, sym_extended));
-    tmp = rb_hash_aref(options, sym_ttl);
+    tmp = rb_hash_aref(options, cb_sym_create);
+    if (tmp != Qnil) {
+        params->cmd.arith.create = RTEST(tmp);
+    }
+    params->cmd.arith.extended = RTEST(rb_hash_aref(options, cb_sym_extended));
+    tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
         params->cmd.arith.ttl = NUM2ULONG(tmp);
     }
-    tmp = rb_hash_aref(options, sym_initial);
+    tmp = rb_hash_aref(options, cb_sym_initial);
     if (tmp != Qnil) {
         params->cmd.arith.initial = NUM2ULL(tmp);
         params->cmd.arith.create = 1;
     }
-    tmp = rb_hash_aref(options, sym_delta);
+    tmp = rb_hash_aref(options, cb_sym_delta);
     if (tmp != Qnil) {
         params->cmd.arith.delta = NUM2ULL(tmp) & INT64_MAX;
     }
-    tmp = rb_hash_aref(options, sym_format);
+    tmp = rb_hash_aref(options, cb_sym_format);
     if (tmp != Qnil) { /* rewrite format bits */
         params->cmd.arith.format = tmp;
     }
-    if (params->cmd.arith.format == sym_document) {
+    if (params->cmd.arith.format == cb_sym_document) {
         /* just amend datatype for now */
         params->cmd.arith.datatype = 0x01;
     }
 }
 
     static void
-cb_params_arith_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_arith_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -588,36 +555,23 @@ cb_params_arith_parse_arguments(struct params_st *params, int argc, VALUE argv)
 
 /* STATS */
     static void
-cb_params_stats_alloc(struct params_st *params, lcb_size_t size)
+cb_params_stats_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.stats.num = size;
-    params->cmd.stats.items = xcalloc(size, sizeof(lcb_server_stats_cmd_t));
-    if (params->cmd.stats.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.stats.ptr = xcalloc(size, sizeof(lcb_server_stats_cmd_t *));
-    if (params->cmd.stats.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.stats.ptr[ii] = params->cmd.stats.items + ii;
-    }
+    _alloc_data_for(stats, lcb_server_stats_cmd_t);
 }
 
     static void
-cb_params_stats_init_item(struct params_st *params, lcb_size_t idx,
+cb_params_stats_init_item(struct cb_params_st *params, lcb_size_t idx,
         VALUE key_obj)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.stats.items[idx].v.v0.name = RSTRING_PTR(key_obj);
     params->cmd.stats.items[idx].v.v0.nname = RSTRING_LEN(key_obj);
     params->npayload += RSTRING_LEN(key_obj);
 }
 
     static void
-cb_params_stats_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_stats_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -653,35 +607,22 @@ cb_params_stats_parse_arguments(struct params_st *params, int argc, VALUE argv)
 /* REMOVE */
 
     static void
-cb_params_observe_alloc(struct params_st *params, lcb_size_t size)
+cb_params_observe_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.observe.num = size;
-    params->cmd.observe.items = xcalloc(size, sizeof(lcb_observe_cmd_t));
-    if (params->cmd.observe.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.observe.ptr = xcalloc(size, sizeof(lcb_observe_cmd_t *));
-    if (params->cmd.observe.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.observe.ptr[ii] = params->cmd.observe.items + ii;
-    }
+    _alloc_data_for(observe, lcb_observe_cmd_t);
 }
 
     static void
-cb_params_observe_init_item(struct params_st *params, lcb_size_t idx, VALUE key_obj)
+cb_params_observe_init_item(struct cb_params_st *params, lcb_size_t idx, VALUE key_obj)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.observe.items[idx].v.v0.key = RSTRING_PTR(key_obj);
     params->cmd.observe.items[idx].v.v0.nkey = RSTRING_LEN(key_obj);
     params->npayload += RSTRING_LEN(key_obj);
 }
 
     static void
-cb_params_observe_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_observe_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     lcb_size_t ii;
 
@@ -716,28 +657,15 @@ cb_params_observe_parse_arguments(struct params_st *params, int argc, VALUE argv
 
 /* UNLOCK */
     static void
-cb_params_unlock_alloc(struct params_st *params, lcb_size_t size)
+cb_params_unlock_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.unlock.num = size;
-    params->cmd.unlock.items = xcalloc(size, sizeof(lcb_unlock_cmd_t));
-    if (params->cmd.unlock.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.unlock.ptr = xcalloc(size, sizeof(lcb_unlock_cmd_t *));
-    if (params->cmd.unlock.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.unlock.ptr[ii] = params->cmd.unlock.items + ii;
-    }
+    _alloc_data_for(unlock, lcb_unlock_cmd_t);
 }
 
     static void
-cb_params_unlock_init_item(struct params_st *params, lcb_size_t idx, VALUE key_obj, lcb_cas_t cas)
+cb_params_unlock_init_item(struct cb_params_st *params, lcb_size_t idx, VALUE key_obj, lcb_cas_t cas)
 {
-    key_obj = unify_key(params->bucket, key_obj, 1);
+    key_obj = cb_unify_key(params->bucket, key_obj, 1);
     params->cmd.unlock.items[idx].v.v0.key = RSTRING_PTR(key_obj);
     params->cmd.unlock.items[idx].v.v0.nkey = RSTRING_LEN(key_obj);
     params->cmd.unlock.items[idx].v.v0.cas = cas;
@@ -747,30 +675,31 @@ cb_params_unlock_init_item(struct params_st *params, lcb_size_t idx, VALUE key_o
     static int
 cb_params_unlock_extract_keys_i(VALUE key, VALUE value, VALUE arg)
 {
-    struct params_st *params = (struct params_st *)arg;
+    struct cb_params_st *params = (struct cb_params_st *)arg;
     cb_params_unlock_init_item(params, params->idx++, key, NUM2ULL(value));
     return ST_CONTINUE;
 }
 
     static void
-cb_params_unlock_parse_options(struct params_st *params, VALUE options)
+cb_params_unlock_parse_options(struct cb_params_st *params, VALUE options)
 {
     VALUE tmp;
 
     if (NIL_P(options)) {
         return;
     }
-    tmp = rb_hash_aref(options, sym_cas);
+    tmp = rb_hash_aref(options, cb_sym_cas);
     if (tmp != Qnil) {
         params->cmd.unlock.cas = NUM2ULL(tmp);
     }
-    if (RTEST(rb_funcall(options, id_has_key_p, 1, sym_quiet))) {
-        params->cmd.unlock.quiet = RTEST(rb_hash_aref(options, sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.unlock.quiet = RTEST(tmp);
     }
 }
 
     static void
-cb_params_unlock_parse_arguments(struct params_st *params, int argc, VALUE argv)
+cb_params_unlock_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
 {
     if (argc == 1) {
         VALUE keys = RARRAY_PTR(argv)[0];
@@ -793,66 +722,52 @@ cb_params_unlock_parse_arguments(struct params_st *params, int argc, VALUE argv)
 
 /* VERSION */
     static void
-cb_params_version_alloc(struct params_st *params)
+cb_params_version_alloc(struct cb_params_st *params)
 {
     params->cmd.version.num = 1;
-    params->cmd.version.items = xcalloc(1, sizeof(lcb_server_version_cmd_t));
-    if (params->cmd.version.items == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.version.ptr = xcalloc(1, sizeof(lcb_server_version_cmd_t *));
-    if (params->cmd.version.ptr == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.version.ptr[0] = params->cmd.version.items;
+    _alloc_data_for_s(version, lcb_server_version_cmd_t, 1, items, ptr);
 }
 
 
 /* common stuff */
     void
-cb_params_destroy(struct params_st *params)
+cb_params_destroy(struct cb_params_st *params)
 {
-#define _release_data_for(type) \
-    xfree(params->cmd.type.items); \
-    xfree(params->cmd.type.ptr);
-
     switch (params->type) {
-        case cmd_get:
+        case cb_cmd_get:
             _release_data_for(get);
-            xfree(params->cmd.get.items_gr);
-            xfree(params->cmd.get.ptr_gr);
+            _release_data_for_s(get, items_gr, ptr_gr);
             break;
-        case cmd_touch:
+        case cb_cmd_touch:
             _release_data_for(touch);
             break;
-        case cmd_arith:
+        case cb_cmd_arith:
             _release_data_for(arith);
             break;
-        case cmd_remove:
+        case cb_cmd_remove:
             _release_data_for(remove);
             break;
-        case cmd_store:
+        case cb_cmd_store:
             _release_data_for(store);
             break;
-        case cmd_stats:
+        case cb_cmd_stats:
             _release_data_for(stats);
             break;
-        case cmd_version:
+        case cb_cmd_version:
             _release_data_for(version);
             break;
-        case cmd_observe:
+        case cb_cmd_observe:
             _release_data_for(observe);
             break;
-        case cmd_unlock:
+        case cb_cmd_unlock:
             _release_data_for(unlock);
             break;
     }
-#undef _release_data_for
 }
 
 struct build_params_st
 {
-    struct params_st *params;
+    struct cb_params_st *params;
     int argc;
     VALUE argv;
 };
@@ -863,7 +778,7 @@ do_params_build(VALUE ptr)
     VALUE opts;
     /* unpack arguments */
     struct build_params_st *p = (struct build_params_st *)ptr;
-    struct params_st *params = p->params;
+    struct cb_params_st *params = p->params;
     int argc = p->argc;
     VALUE argv = p->argv;
 
@@ -875,15 +790,15 @@ do_params_build(VALUE ptr)
         opts = Qnil;
     }
 
-    params->npayload = PACKET_HEADER_SIZE; /* size of packet header */
+    params->npayload = CB_PACKET_HEADER_SIZE; /* size of packet header */
     switch (params->type) {
-        case cmd_touch:
+        case cb_cmd_touch:
             params->cmd.touch.quiet = params->bucket->quiet;
             params->cmd.touch.ttl = params->bucket->default_ttl;
             cb_params_touch_parse_options(params, opts);
             cb_params_touch_parse_arguments(params, argc, argv);
             break;
-        case cmd_remove:
+        case cb_cmd_remove:
             params->cmd.remove.quiet = params->bucket->quiet;
             if (argc == 2) {
                 int type = TYPE(RARRAY_PTR(argv)[1]);
@@ -896,7 +811,7 @@ do_params_build(VALUE ptr)
             cb_params_remove_parse_options(params, opts);
             cb_params_remove_parse_arguments(params, argc, argv);
             break;
-        case cmd_store:
+        case cb_cmd_store:
             if (argc == 1 && opts != Qnil) {
                 /* put last hash back because it is the value */
                 rb_ary_push(argv, opts);
@@ -905,18 +820,20 @@ do_params_build(VALUE ptr)
             }
             params->cmd.store.datatype = 0x00;
             params->cmd.store.ttl = params->bucket->default_ttl;
-            params->cmd.store.flags = flags_set_format(params->bucket->default_flags,
+            params->cmd.store.flags = cb_flags_set_format(params->bucket->default_flags,
                     params->bucket->default_format);
             params->cmd.store.observe = Qnil;
             cb_params_store_parse_options(params, opts);
             cb_params_store_parse_arguments(params, argc, argv);
             break;
-        case cmd_get:
+        case cb_cmd_get:
             params->cmd.get.quiet = params->bucket->quiet;
             cb_params_get_parse_options(params, opts);
             cb_params_get_parse_arguments(params, argc, argv);
             break;
-        case cmd_arith:
+        case cb_cmd_arith:
+            params->cmd.arith.create = params->bucket->default_arith_create;
+            params->cmd.arith.initial = params->bucket->default_arith_init;
             params->cmd.arith.delta = 1;
             params->cmd.arith.format = params->bucket->default_format;
             params->cmd.arith.ttl = params->bucket->default_ttl;
@@ -928,16 +845,16 @@ do_params_build(VALUE ptr)
             cb_params_arith_parse_options(params, opts);
             cb_params_arith_parse_arguments(params, argc, argv);
             break;
-        case cmd_stats:
+        case cb_cmd_stats:
             cb_params_stats_parse_arguments(params, argc, argv);
             break;
-        case cmd_version:
+        case cb_cmd_version:
             cb_params_version_alloc(params);
             break;
-        case cmd_observe:
+        case cb_cmd_observe:
             cb_params_observe_parse_arguments(params, argc, argv);
             break;
-        case cmd_unlock:
+        case cb_cmd_unlock:
             params->cmd.unlock.quiet = params->bucket->quiet;
             if (argc == 2) {
                 int type = TYPE(RARRAY_PTR(argv)[1]);
@@ -956,7 +873,7 @@ do_params_build(VALUE ptr)
 }
 
     void
-cb_params_build(struct params_st *params, int argc, VALUE argv)
+cb_params_build(struct cb_params_st *params, int argc, VALUE argv)
 {
     int fail = 0;
     struct build_params_st args;