aerospike 2.29.0 → 4.0.0

data/lib/aerospike/exp/exp_map.rb

@@ -4,7 +4,7 @@
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
 #
-# Licensed under the Apache License, Version 2.0 (the "License"); you may no
+# Licensed under the Apache License, Version 2.0 (the "License") you may no
 # use this file except in compliance with the License. You may obtain a copy of
 # the License at http:#www.apache.org/licenses/LICENSE-2.0
 #
@@ -15,7 +15,7 @@
 # the License.
 
 module Aerospike
-  # Map expression generator. See {@link Exp}.
+  # Map expression generator. See {Exp}.
   #
   # The bin expression argument in these methods can be a reference to a bin or the
   # result of another expression. Expressions that modify bin values are only used
@@ -80,24 +80,22 @@ module Aerospike
           value.pack(packer)
           packer.write(policy.attributes)
           packer.write(policy.flags)
+        elsif policy.item_command == REPLACE
+          Exp.pack_ctx(packer, ctx)
+          packer.write_array_header(3)
+          packer.write(policy.item_command)
+          key.pack(packer)
+          value.pack(packer)
+        # Replace doesn't allow map attributes because it does not create on non-existing key.
         else
-          if policy.item_command == REPLACE
-            # Replace doesn't allow map attributes because it does not create on non-existing key.
-            Exp.pack_ctx(packer, ctx)
-            packer.write_array_header(3)
-            packer.write(policy.item_command)
-            key.pack(packer)
-            value.pack(packer)
-          else
             Exp.pack_ctx(packer, ctx)
             packer.write_array_header(4)
             packer.write(policy.item_command)
             key.pack(packer)
             value.pack(packer)
             packer.write(policy.attributes)
-          end
         end
-        self.add_write(bin, packer.bytes, ctx)
+        add_write(bin, packer.bytes, ctx)
       end
     end
 
@@ -111,22 +109,20 @@ module Aerospike
           map.pack(packer)
           packer.write(policy.attributes)
           packer.write(policy.flags)
+        elsif policy.items_command == REPLACE_ITEMS
+          Exp.pack_ctx(packer, ctx)
+          packer.write_array_header(2)
+          packer.write(policy.items_command)
+          map.pack(packer)
+        # Replace doesn't allow map attributes because it does not create on non-existing key.
         else
-          if policy.items_command == REPLACE_ITEMS
-            # Replace doesn't allow map attributes because it does not create on non-existing key.
-            Exp.pack_ctx(packer, ctx)
-            packer.write_array_header(2)
-            packer.write(policy.items_command)
-            map.pack(packer)
-          else
             Exp.pack_ctx(packer, ctx)
             packer.write_array_header(3)
             packer.write(policy.items_command)
             map.pack(packer)
             packer.write(policy.attributes)
-          end
         end
-        self.add_write(bin, packer.bytes, ctx)
+        add_write(bin, packer.bytes, ctx)
       end
     end
 
@@ -134,25 +130,25 @@ module Aerospike
     # Valid only for numbers.
     def self.increment(key, incr, bin, ctx: nil, policy: CDT::MapPolicy::DEFAULT)
       bytes = Exp.pack(ctx, INCREMENT, key, incr, policy.attributes)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes all items in map.
     def self.clear(bin, ctx: nil)
       bytes = Exp.pack(ctx, CLEAR)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map item identified by key.
     def self.remove_by_key(key, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_KEY, CDT::MapReturnType::NONE, key)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items identified by keys.
     def self.remove_by_key_list(keys, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_KEY_LIST, CDT::MapReturnType::NONE, keys)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items identified by key range (key_begin inclusive, key_end exclusive).
@@ -160,7 +156,7 @@ module Aerospike
     # If key_end is nil, the range is greater than equal to key_begin.
     def self.remove_by_key_range(key_begin, key_end, bin, ctx: nil)
       bytes = Exp::List.pack_range_operation(REMOVE_BY_KEY_INTERVAL, CDT::MapReturnType::NONE, key_begin, key_end, ctx)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items nearest to key and greater by index with a count limit if provided.
@@ -174,24 +170,24 @@ module Aerospike
     # (3,2,1) = [{9=10}]
     # (3,-2,2) = [{0=17}]
     def self.remove_by_key_relative_index_range(key, index, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, REMOVE_BY_KEY_REL_INDEX_RANGE, CDT::MapReturnType::NONE, key, index, count)
-      else
-        bytes = Exp.pack(ctx, REMOVE_BY_KEY_REL_INDEX_RANGE, CDT::MapReturnType::NONE, key, index)
-      end
-      return self.add_write(bin, bytes, ctx)
+      bytes = if count.nil?
+        Exp.pack(ctx, REMOVE_BY_KEY_REL_INDEX_RANGE, CDT::MapReturnType::NONE, key, index)
+              else
+        Exp.pack(ctx, REMOVE_BY_KEY_REL_INDEX_RANGE, CDT::MapReturnType::NONE, key, index, count)
+              end
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items identified by value.
     def self.remove_by_value(value, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_VALUE, CDT::MapReturnType::NONE, value)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items identified by values.
     def self.remove_by_value_list(values, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_VALUE_LIST, CDT::MapReturnType::NONE, values)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items identified by value range (valueBegin inclusive, valueEnd exclusive).
@@ -199,7 +195,7 @@ module Aerospike
     # If valueEnd is nil, the range is greater than equal to valueBegin.
     def self.remove_by_value_range(valueBegin, valueEnd, bin, ctx: nil)
       bytes = Exp::List.pack_range_operation(REMOVE_BY_VALUE_INTERVAL, CDT::MapReturnType::NONE, valueBegin, valueEnd, ctx)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items nearest to value and greater by relative rank.
@@ -211,7 +207,7 @@ module Aerospike
     # (11,-1) = [{9=10},{5=15},{0=17}]
     def self.remove_by_value_relative_rank_range(value, rank, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_VALUE_REL_RANK_RANGE, CDT::MapReturnType::NONE, value, rank)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map items nearest to value and greater by relative rank with a count limit.
@@ -223,40 +219,40 @@ module Aerospike
     # (11,-1,1) = [{9=10}]
     def self.remove_by_value_relative_rank_range(value, rank, count, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_VALUE_REL_RANK_RANGE, CDT::MapReturnType::NONE, value, rank, count)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map item identified by index.
     def self.remove_by_index(index, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_INDEX, CDT::MapReturnType::NONE, index)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes "count" map items starting at specified index limited by count if provided.
     def self.remove_by_index_range(index, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, REMOVE_BY_INDEX_RANGE, CDT::MapReturnType::NONE, index, count)
-      else
-        bytes = Exp.pack(ctx, REMOVE_BY_INDEX_RANGE, CDT::MapReturnType::NONE, index)
-      end
-      return self.add_write(bin, bytes, ctx)
+      bytes = if count.nil?
+        Exp.pack(ctx, REMOVE_BY_INDEX_RANGE, CDT::MapReturnType::NONE, index)
+              else
+        Exp.pack(ctx, REMOVE_BY_INDEX_RANGE, CDT::MapReturnType::NONE, index, count)
+              end
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes map item identified by rank.
     def self.remove_by_rank(rank, bin, ctx: nil)
       bytes = Exp.pack(ctx, REMOVE_BY_RANK, CDT::MapReturnType::NONE, rank)
-      return self.add_write(bin, bytes, ctx)
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that removes "count" map items starting at specified rank. If count is not provided,
     # all items until the last ranked item will be removed
     def self.remove_by_rank_range(rank, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, REMOVE_BY_RANK_RANGE, CDT::MapReturnType::NONE, rank, count)
-      else
-        bytes = Exp.pack(ctx, REMOVE_BY_RANK_RANGE, CDT::MapReturnType::NONE, rank)
-      end
-      return self.add_write(bin, bytes, ctx)
+      bytes = if count.nil?
+        Exp.pack(ctx, REMOVE_BY_RANK_RANGE, CDT::MapReturnType::NONE, rank)
+              else
+        Exp.pack(ctx, REMOVE_BY_RANK_RANGE, CDT::MapReturnType::NONE, rank, count)
+              end
+      add_write(bin, bytes, ctx)
     end
 
     # Create expression that returns list size.
@@ -266,7 +262,7 @@ module Aerospike
     # Exp.gt(MapExp.size(mapBin("a")), Exp.val(7))
     def self.size(bin, ctx: nil)
       bytes = Exp.pack(ctx, SIZE)
-      return self.add_read(bin, bytes, Exp::Type::INT)
+      add_read(bin, bytes, Exp::Type::INT)
     end
 
     # Create expression that selects map item identified by key and returns selected data
@@ -278,35 +274,35 @@ module Aerospike
     #   MapExp.getByKey(CDT::MapReturnType::COUNT, Exp::Type::INT, Exp.val("B"), Exp.mapBin("a")),
     #   Exp.val(0))
     #
-    # @param return_type	metadata attributes to return. See {@link MapReturnType}
+    # @param return_type	metadata attributes to return. See {MapReturnType}
     # @param value_type		expected type of return value
     # @param key			map key expression
     # @param bin			bin or map value expression
     # @param ctx			optional context path for nested CDT
     def self.get_by_key(return_type, value_type, key, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_KEY, return_type, key)
-      return self.add_read(bin, bytes, value_type)
+      add_read(bin, bytes, value_type)
     end
 
     # Create expression that selects map items identified by key range (key_begin inclusive, key_end exclusive).
     # If key_begin is nil, the range is less than key_end.
     # If key_end is nil, the range is greater than equal to key_begin.
     #
-    # Expression returns selected data specified by return_type (See {@link MapReturnType}).
+    # Expression returns selected data specified by return_type (See {MapReturnType}).
     def self.get_by_key_range(return_type, key_begin, key_end, bin, ctx: nil)
       bytes = Exp::List.pack_range_operation(GET_BY_KEY_INTERVAL, return_type, key_begin, key_end, ctx)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items identified by keys and returns selected data specified by
-    # return_type (See {@link MapReturnType}).
+    # return_type (See {MapReturnType}).
     def self.get_by_key_list(return_type, keys, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_KEY_LIST, return_type, keys)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items nearest to key and greater by index with a coun.
-    # Expression returns selected data specified by return_type (See {@link MapReturnType}).
+    # Expression returns selected data specified by return_type (See {MapReturnType}).
     #
     # Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]:
     #
@@ -318,11 +314,11 @@ module Aerospike
     # (3,-2) = [{0=17},{4=2},{5=15},{9=10}]
     def self.get_by_key_relative_index_range(return_type, key, index, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_KEY_REL_INDEX_RANGE, return_type, key, index)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items nearest to key and greater by index with a count limit if provided.
-    # Expression returns selected data specified by return_type (See {@link MapReturnType}).
+    # Expression returns selected data specified by return_type (See {MapReturnType}).
     #
     # Examples for ordered map [{0=17},{4=2},{5=15},{9=10}]:
     #
@@ -333,12 +329,12 @@ module Aerospike
     # (3,2,1) = [{9=10}]
     # (3,-2,2) = [{0=17}]
     def self.get_by_key_relative_index_range(return_type, key, index, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, GET_BY_KEY_REL_INDEX_RANGE, return_type, key, index, count)
-      else
-        bytes = Exp.pack(ctx, GET_BY_KEY_REL_INDEX_RANGE, return_type, key, index)
-      end
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      bytes = if count.nil?
+        Exp.pack(ctx, GET_BY_KEY_REL_INDEX_RANGE, return_type, key, index)
+              else
+        Exp.pack(ctx, GET_BY_KEY_REL_INDEX_RANGE, return_type, key, index, count)
+              end
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items identified by value and returns selected data
@@ -350,34 +346,34 @@ module Aerospike
     #   MapExp.getByValue(CDT::MapReturnType::COUNT, Exp.val("BBB"), Exp.mapBin("a")),
     #   Exp.val(0))
     #
-    # @param return_type	metadata attributes to return. See {@link MapReturnType}
+    # @param return_type	metadata attributes to return. See {MapReturnType}
     # @param value			value expression
     # @param bin			bin or map value expression
     # @param ctx			optional context path for nested CDT
     def self.get_by_value(return_type, value, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_VALUE, return_type, value)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items identified by value range (valueBegin inclusive, valueEnd exclusive)
     # If valueBegin is nil, the range is less than valueEnd.
     # If valueEnd is nil, the range is greater than equal to valueBegin.
     #
-    # Expression returns selected data specified by return_type (See {@link MapReturnType}).
+    # Expression returns selected data specified by return_type (See {MapReturnType}).
     def self.get_by_value_range(return_type, valueBegin, valueEnd, bin, ctx: nil)
       bytes = Exp::List.pack_range_operation(GET_BY_VALUE_INTERVAL, return_type, valueBegin, valueEnd, ctx)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items identified by values and returns selected data specified by
-    # return_type (See {@link MapReturnType}).
+    # return_type (See {MapReturnType}).
     def self.get_by_value_list(return_type, values, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_VALUE_LIST, return_type, values)
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map items nearest to value and greater by relative rank (with a count limit if passed).
-    # Expression returns selected data specified by return_type (See {@link MapReturnType}).
+    # Expression returns selected data specified by return_type (See {MapReturnType}).
     #
     # Examples for map [{4=2},{9=10},{5=15},{0=17}]:
     #
@@ -385,48 +381,48 @@ module Aerospike
     # (11,1) = [{0=17}]
     # (11,-1) = [{9=10},{5=15},{0=17}]
     def self.get_by_value_relative_rank_range(return_type, value, rank, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, GET_BY_VALUE_REL_RANK_RANGE, return_type, value, rank, count)
-      else
-        bytes = Exp.pack(ctx, GET_BY_VALUE_REL_RANK_RANGE, return_type, value, rank)
-      end
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      bytes = if count.nil?
+        Exp.pack(ctx, GET_BY_VALUE_REL_RANK_RANGE, return_type, value, rank)
+              else
+        Exp.pack(ctx, GET_BY_VALUE_REL_RANK_RANGE, return_type, value, rank, count)
+              end
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map item identified by index and returns selected data specified by
-    # return_type (See {@link MapReturnType}).
+    # return_type (See {MapReturnType}).
     def self.get_by_index(return_type, value_type, index, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_INDEX, return_type, index)
-      return self.add_read(bin, bytes, value_type)
+      add_read(bin, bytes, value_type)
     end
 
     # Create expression that selects map items starting at specified index to the end of map and returns selected
-    # data specified by return_type (See {@link MapReturnType}) limited by count if provided.
+    # data specified by return_type (See {MapReturnType}) limited by count if provided.
     def self.get_by_index_range(return_type, index, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, GET_BY_INDEX_RANGE, return_type, index, count)
-      else
-        bytes = Exp.pack(ctx, GET_BY_INDEX_RANGE, return_type, index)
-      end
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      bytes = if count.nil?
+        Exp.pack(ctx, GET_BY_INDEX_RANGE, return_type, index)
+              else
+        Exp.pack(ctx, GET_BY_INDEX_RANGE, return_type, index, count)
+              end
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     # Create expression that selects map item identified by rank and returns selected data specified by
-    # return_type (See {@link MapReturnType}).
+    # return_type (See {MapReturnType}).
     def self.get_by_rank(return_type, value_type, rank, bin, ctx: nil)
       bytes = Exp.pack(ctx, GET_BY_RANK, return_type, rank)
-      return self.add_read(bin, bytes, value_type)
+      add_read(bin, bytes, value_type)
     end
 
     # Create expression that selects map items starting at specified rank to the last ranked item and
-    # returns selected data specified by return_type (See {@link MapReturnType}).
+    # returns selected data specified by return_type (See {MapReturnType}).
     def self.get_by_rank_range(return_type, rank, bin, ctx: nil, count: nil)
-      unless count.nil?
-        bytes = Exp.pack(ctx, GET_BY_RANK_RANGE, return_type, rank, count)
-      else
-        bytes = Exp.pack(ctx, GET_BY_RANK_RANGE, return_type, rank)
-      end
-      return self.add_read(bin, bytes, get_value_type(return_type))
+      bytes = if count.nil?
+        Exp.pack(ctx, GET_BY_RANK_RANGE, return_type, rank)
+              else
+        Exp.pack(ctx, GET_BY_RANK_RANGE, return_type, rank, count)
+              end
+      add_read(bin, bytes, get_value_type(return_type))
     end
 
     private
@@ -454,7 +450,7 @@ module Aerospike
     GET_BY_KEY = 97
     GET_BY_INDEX = 98
     GET_BY_RANK = 100
-    GET_BY_VALUE = 102;  # GET_ALL_BY_VALUE on server
+    GET_BY_VALUE = 102 # GET_ALL_BY_VALUE on server
     GET_BY_KEY_INTERVAL = 103
     GET_BY_INDEX_RANGE = 104
     GET_BY_VALUE_INTERVAL = 105
@@ -465,11 +461,11 @@ module Aerospike
     GET_BY_VALUE_REL_RANK_RANGE = 110
 
     def self.add_write(bin, bytes, ctx)
-      if ctx.to_a.empty?
-        ret_type = Exp::Type::MAP
-      else
-        ret_type = ((ctx[0].id & 0x10) == 0) ? Exp::Type::MAP : Exp::Type::LIST
-      end
+      ret_type = if ctx.to_a.empty?
+        Exp::Type::MAP
+                 else
+        (ctx[0].id & 0x10) == 0 ? Exp::Type::MAP : Exp::Type::LIST
+                 end
       Exp::Module.new(bin, bytes, ret_type, MODULE | Exp::MODIFY)
     end
 
@@ -479,15 +475,27 @@ module Aerospike
 
     def self.get_value_type(return_type)
       t = return_type & ~CDT::MapReturnType::INVERTED
+      case t
+      when MapReturnType::INDEX, MapReturnType::REVERSE_INDEX, MapReturnType::RANK, MapReturnType::REVERSE_RANK
+          # This method only called from expressions that can return multiple integers (ie list).
+          Exp::Type::LIST
 
-      if t <= CDT::MapReturnType::COUNT
-        return Exp::Type::INT
-      end
+      when MapReturnType::COUNT
+          Exp::Type::INT
 
-      if t == CDT::MapReturnType::KEY_VALUE
-        return Exp::Type::MAP
+      when MapReturnType::KEY, MapReturnType::VALUE
+          # This method only called from expressions that can return multiple objects (ie list).
+          Exp::Type::LIST
+
+      when MapReturnType::KEY_VALUE, MapReturnType::ORDERED_MAP, MapReturnType::UNORDERED_MAP
+          Exp::Type::MAP
+
+      when MapReturnType::EXISTS
+          Exp::Type::BOOL
+
+      else
+          raise Exceptions::Aerospike.new(Aerospike::ResultCode::PARAMETER_ERROR, "Invalid MapReturnType: #{return_type}")
       end
-      return Exp::Type::LIST
     end
   end # class MapExp
 end # module Aerospike

data/lib/aerospike/exp/operation.rb

@@ -24,7 +24,7 @@ module Aerospike
     #
     # @param bin_name	name of bin to store expression result
     # @param exp		expression to evaluate
-    # @param flags		expression write flags.  See {@link Exp::WriteFlags}
+    # @param flags		expression write flags.  See {Exp::WriteFlags}
     def self.write(bin_name, exp, flags = Aerospike::Exp::WriteFlags::DEFAULT)
       create_operation(Aerospike::Operation::EXP_MODIFY, bin_name, exp, flags)
     end
@@ -36,7 +36,7 @@ module Aerospike
     # @param name		variable name of read expression result. This name can be used as the
     # 					bin name when retrieving bin results from the record.
     # @param exp		expression to evaluate
-    # @param flags		expression read flags.  See {@link Exp::ExpReadFlags}
+    # @param flags		expression read flags.  See {Exp::ExpReadFlags}
     def self.read(name, exp, flags = Aerospike::Exp::ReadFlags::DEFAULT)
       create_operation(Aerospike::Operation::EXP_READ, name, exp, flags)
     end

data/lib/aerospike/info.rb

@@ -66,7 +66,6 @@ module Aerospike
     private
 
     def self.send_command(conn, offset, buffer)
-      begin
         # Write size field.
         size = (offset - 8) | (2 << 56) | (1 << 48)
 
@@ -82,12 +81,11 @@ module Aerospike
         buffer.resize(length)
 
         conn.read(buffer, length)
-        return length
-      rescue => e
+        length
+    rescue => e
         Aerospike.logger.error(e)
         conn.close if conn
         raise e
-      end
     end
 
   end

data/lib/aerospike/node.rb

@@ -26,6 +26,11 @@ module Aerospike
 
     PARTITIONS = 4096
     FULL_HEALTH = 100
+    HAS_PARTITION_SCAN = 1 << 0
+    HAS_QUERY_SHOW = 1 << 1
+    HAS_BATCH_ANY = 1 << 2
+    HAS_PARTITION_QUERY = 1 << 3
+
 
     # Initialize server node with connection parameters.
     def initialize(cluster, nv)
@@ -58,6 +63,18 @@ module Aerospike
       @connections = ::Aerospike::ConnectionPool.new(cluster, host)
     end
 
+    def partition_query?
+      (@features & HAS_PARTITION_QUERY) != 0
+    end
+
+    def query_show?
+      (@features & HAS_QUERY_SHOW) != 0
+    end
+
+    def batch_any?
+      (@features & HAS_BATCH_ANY) != 0
+    end
+
     def update_racks(parser)
       new_racks = parser.update_racks
       @racks.value = new_racks if new_racks
@@ -65,7 +82,7 @@ module Aerospike
 
     def has_rack(ns, rack_id)
       racks = @racks.value
-      return false if !racks
+      return false unless racks
       racks[ns] == rack_id
     end
 
@@ -95,7 +112,7 @@ module Aerospike
     # Put back a connection to the cache. If cache is full, the connection will be
     # closed and discarded
     def put_connection(conn)
-      conn.close if !active?
+      conn.close unless active?
       @connections.offer(conn)
     end
 
@@ -223,7 +240,7 @@ module Aerospike
       Node::Refresh::Partitions.(self, peers)
     end
 
-    def refresh_racks()
+    def refresh_racks
       Node::Refresh::Racks.(self)
     end
 

data/lib/aerospike/operation.rb

@@ -80,5 +80,43 @@ module Aerospike
     def self.delete
       Operation.new(DELETE)
     end
+
+    # :nodoc:
+    def is_write?
+      case @op_type
+      when READ
+        false
+      when READ_HEADER
+        false
+      when WRITE
+        true
+      when CDT_READ
+        false
+      when CDT_MODIFY
+        true
+      when ADD
+        true
+      when EXP_READ
+        false
+      when EXP_MODIFY
+        true
+      when APPEND
+        true
+      when PREPEND
+        true
+      when TOUCH
+        true
+      when BIT_READ
+        false
+      when BIT_MODIFY
+        true
+      when DELETE
+        true
+      when HLL_READ
+        false
+      when HLL_MODIFY
+        true
+      end
+    end
   end
 end # module