aerospike 3.0.0 → 4.0.0

data/lib/aerospike/batch_udf.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+# Copyright 2014-2024 Aerospike, Inc.
+#
+# 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 not
+# 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
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# Batch key and read only operations with default policy.
+# Used in batch read commands where different bins are needed for each key.
+
+module Aerospike
+
+ # Batch user defined functions.
+ class BatchUDF < BatchRecord
+
+    # Optional UDF policy.
+    attr_accessor :policy
+
+    # Package or lua module name.
+    attr_accessor :package_name
+
+    # Lua function name.
+    attr_accessor :function_name
+
+    # Optional arguments to lua function.
+    attr_accessor :function_args
+
+    # Wire protocol bytes for function args. For internal use only.
+    attr_reader :arg_bytes
+
+    # Constructor using default policy.
+    def initialize(key, package_name, function_name, function_args, opt = {})
+      super(key, has_write: true)
+      @policy = BatchRecord.create_policy(opt, BatchUDFPolicy, DEFAULT_BATCH_UDF_POLICY)
+      @package_name = package_name
+      @function_name = function_name
+      @function_args = ListValue.new(function_args)
+      # Do not set arg_bytes here because may not be necessary if batch repeat flag is used.
+    end
+
+    # Optimized reference equality check to determine batch wire protocol repeat flag.
+    # For internal use only.
+    def ==(other) # :nodoc:
+        other && other.instance_of?(self.class) &&
+          @function_name == other.function_name && @function_args == other.function_args &&
+          @package_name == other.package_name && @policy == other.policy
+    end
+
+    DEFAULT_BATCH_UDF_POLICY = BatchUDFPolicy.new
+
+    # Return wire protocol size. For internal use only.
+    def size # :nodoc:
+     size = 6 # gen(2) + exp(4) = 6
+
+     size += @policy&.filter_exp&.size if @policy&.filter_exp
+
+     if @policy&.send_key
+       size += @key.user_key.estimate_size + Aerospike::FIELD_HEADER_SIZE + 1
+     end
+     size += @package_name.bytesize + Aerospike::FIELD_HEADER_SIZE
+     size += @function_name.bytesize + Aerospike::FIELD_HEADER_SIZE
+     @arg_bytes = @function_args.to_bytes
+     size += @arg_bytes.bytesize + Aerospike::FIELD_HEADER_SIZE
+     size
+    end
+ end
+end

data/lib/aerospike/batch_write.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# Copyright 2014-2024 Aerospike, Inc.
+#
+# 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 not
+# 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
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# Batch key and read only operations with default policy.
+# Used in batch read commands where different bins are needed for each key.
+
+module Aerospike
+
+  private
+
+  # Batch key and read/write operations with write policy.
+  class BatchWrite < BatchRecord
+    # Optional write policy.
+    attr_accessor :policy
+
+    # Required operations for this key.
+    attr_accessor :ops
+
+    # Initialize batch key and read/write operations.
+    #
+    # {Operation#get()} is not allowed because it returns a variable number of bins and
+    # makes it difficult (sometimes impossible) to lineup operations with results. Instead,
+    # use {Operation#get(bin_name)} for each bin name.
+    def initialize(key, ops, opt = {})
+      super(key, has_write: true)
+      @policy = BatchRecord.create_policy(opt, BatchWritePolicy, DEFAULT_BATCH_WRITE_POLICY)
+      @ops = ops
+    end
+
+    # Optimized reference equality check to determine batch wire protocol repeat flag.
+    # For internal use only.
+    def ==(other) # :nodoc:
+      other && other.instance_of?(self.class) &&
+        @ops == other.ops && @policy == other.policy && (@policy.nil? || !@policy.send_key)
+    end
+
+    DEFAULT_BATCH_WRITE_POLICY = BatchWritePolicy.new
+
+    # Return wire protocol size. For internal use only.
+    def size # :nodoc:
+      size = 6 # gen(2) + exp(4) = 6
+
+      size += @policy&.filter_exp&.size if @policy&.filter_exp
+
+      if @policy&.send_key
+        size += @key.user_key.estimate_size + Aerospike::FIELD_HEADER_SIZE + 1
+      end
+
+      has_write = false
+      @ops&.each do |op|
+        if op.is_write?
+          has_write = true
+        end
+
+        size += op.bin_name.bytesize + Aerospike::OPERATION_HEADER_SIZE if op.bin_name
+        size += op.bin_value.estimate_size if op.bin_value
+      end
+
+      unless has_write
+        raise AerospikeException.new(ResultCode::PARAMETER_ERROR, "Batch write operations do not contain a write")
+      end
+
+      size
+    end
+  end
+end

data/lib/aerospike/cdt/bit_operation.rb

@@ -65,9 +65,8 @@ module Aerospike
         @arguments = arguments
       end
 
-
       # BitResizeOp creates byte "resize" operation.
-      # Server resizes byte[] to byte_size according to resize_flags (See {@link BitResizeFlags}).
+      # Server resizes byte[] to byte_size according to resize_flags (See {BitResizeFlags}).
       # Server does not return a value.
       # Example:
       # bin = [0b00000001, 0b01000010]
@@ -195,7 +194,7 @@ module Aerospike
       # BitAddOp creates bit "add" operation.
       # Server adds value to byte[] bin starting at bit_offset for bit_size. Bit_size must be <= 64.
       # Signed indicates if bits should be treated as a signed number.
-      # If add overflows/underflows, {@link BitOverflowAction} is used.
+      # If add overflows/underflows, {BitOverflowAction} is used.
       # Server does not return a value.
       # Example:
       # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
@@ -223,7 +222,7 @@ module Aerospike
       # BitSubtractOp creates bit "subtract" operation.
       # Server subtracts value from byte[] bin starting at bit_offset for bit_size. Bit_size must be <= 64.
       # Signed indicates if bits should be treated as a signed number.
-      # If add overflows/underflows, {@link BitOverflowAction} is used.
+      # If add overflows/underflows, {BitOverflowAction} is used.
       # Server does not return a value.
       # Example:
       # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
@@ -351,7 +350,7 @@ module Aerospike
         bytes = nil
         args = arguments.dup
         Packer.use do |packer|
-          if @ctx != nil && @ctx.length > 0
+          if !@ctx.nil? && @ctx.length > 0
             packer.write_array_header(3)
             Value.of(0xff).pack(packer)
 

data/lib/aerospike/cdt/map_return_type.rb

@@ -69,6 +69,14 @@ module Aerospike
       # Return true if count > 0.
       EXISTS = 13
 
+      ##
+      # Return an unordered map.
+      UNORDERED_MAP = 16
+
+      ##
+      # Return an ordered map.
+      ORDERED_MAP = 17
+
       ##
       #  :private
       #

data/lib/aerospike/client.rb

@@ -36,15 +36,7 @@ module Aerospike
   # +:fail_if_not_connected+ set to true
 
   class Client
-    attr_accessor :default_admin_policy
-    attr_accessor :default_batch_policy
-    attr_accessor :default_info_policy
-    attr_accessor :default_query_policy
-    attr_accessor :default_read_policy
-    attr_accessor :default_scan_policy
-    attr_accessor :default_write_policy
-    attr_accessor :default_operate_policy
-    attr_accessor :cluster
+    attr_accessor :default_admin_policy, :default_batch_policy, :default_info_policy, :default_query_policy, :default_read_policy, :default_scan_policy, :default_write_policy, :default_operate_policy, :cluster
 
     def initialize(hosts = nil, policy: ClientPolicy.new, connect: true)
       hosts = ::Aerospike::Host::Parse.(hosts || ENV["AEROSPIKE_HOSTS"] || "localhost")
@@ -230,11 +222,11 @@ module Aerospike
         str_cmd = "truncate:namespace=#{namespace}"
         str_cmd << ";set=#{set_name}" unless set_name.to_s.strip.empty?
       else
-        if node.supports_feature?(Aerospike::Features::TRUNCATE_NAMESPACE)
-          str_cmd = "truncate-namespace:namespace=#{namespace}"
-        else
-          str_cmd = "truncate:namespace=#{namespace}"
-        end
+        str_cmd = if node.supports_feature?(Aerospike::Features::TRUNCATE_NAMESPACE)
+          "truncate-namespace:namespace=#{namespace}"
+                  else
+          "truncate:namespace=#{namespace}"
+                  end
       end
 
       if before_last_update
@@ -329,15 +321,8 @@ module Aerospike
         bin_names = nil
       end
 
-      if policy.use_batch_direct
-        key_map = BatchItem.generate_map(keys)
-        execute_batch_direct_commands(policy, keys) do |node, batch|
-          BatchDirectCommand.new(node, batch, policy, key_map, bin_names, results, info_flags)
-        end
-      else
-        execute_batch_index_commands(policy, keys) do |node, batch|
-          BatchIndexCommand.new(node, batch, policy, bin_names, results, info_flags)
-        end
+      execute_batch_index_commands(policy, keys) do |node, batch|
+        BatchIndexCommand.new(node, batch, policy, bin_names, results, info_flags)
       end
 
       results
@@ -351,6 +336,21 @@ module Aerospike
       batch_get(keys, :none, options)
     end
 
+    # Operate on multiple records for specified batch keys in one batch call.
+    # This method allows different namespaces/bins for each key in the batch.
+    # The returned records are located in the same list.
+    #
+    # records can be BatchRead, BatchWrite, BatchDelete or BatchUDF.
+    #
+    # Requires server version 6.0+
+    def batch_operate(records, options = nil)
+      policy = create_policy(options, BatchPolicy, default_batch_policy)
+
+      execute_batch_operate_commands(policy, records) do |node, batch|
+        BatchOperateCommand.new(node, batch, policy, records)
+      end
+    end
+
     #  Check if multiple record keys exist in one batch call.
     #  The returned boolean array is in positional order with the original key array order.
     #  The policy can be used to specify timeouts and protocol type.
@@ -358,15 +358,8 @@ module Aerospike
       policy = create_policy(options, BatchPolicy, default_batch_policy)
       results = Array.new(keys.length)
 
-      if policy.use_batch_direct
-        key_map = BatchItem.generate_map(keys)
-        execute_batch_direct_commands(policy, keys) do |node, batch|
-          BatchDirectExistsCommand.new(node, batch, policy, key_map, results)
-        end
-      else
-        execute_batch_index_commands(policy, keys) do |node, batch|
-          BatchIndexExistsCommand.new(node, batch, policy, results)
-        end
+      execute_batch_index_commands(policy, keys) do |node, batch|
+        BatchIndexExistsCommand.new(node, batch, policy, results)
       end
 
       results
@@ -430,7 +423,7 @@ module Aerospike
       end
 
       if res["error"]
-        raise Aerospike::Exceptions::CommandRejected.new("Registration failed: #{res["error"]}\nFile: #{res["file"]}\nLine: #{res["line"]}\nMessage: #{res["message"]}")
+        raise Aerospike::Exceptions::CommandRejected.new("Registration failed: #{res['error']}\nFile: #{res['file']}\nLine: #{res['line']}\nMessage: #{res['message']}")
       end
 
       UdfRegisterTask.new(@cluster, server_path)
@@ -566,7 +559,8 @@ module Aerospike
     #  ctx is an optional list of context. Supported on server v6.1+.
     def create_index(namespace, set_name, index_name, bin_name, index_type, collection_type = nil, options = nil, ctx: nil)
       if options.nil? && collection_type.is_a?(Hash)
-        options, collection_type = collection_type, nil
+        options = collection_type
+        collection_type = nil
       end
       policy = create_policy(options, Policy, default_info_policy)
 
@@ -943,13 +937,11 @@ module Aerospike
       when Hash
         policy_klass.new(policy)
       else
-        fail TypeError, "policy should be a #{policy_klass.name} instance or a Hash"
+        raise TypeError, "policy should be a #{policy_klass.name} instance or a Hash"
       end
     end
 
-    def cluster=(cluster)
-      @cluster = cluster
-    end
+    attr_writer :cluster
 
     def cluster_config_changed(cluster)
       Aerospike.logger.debug { "Cluster config change detected; active nodes: #{cluster.nodes.map(&:name)}" }
@@ -999,24 +991,18 @@ module Aerospike
       threads.each(&:join)
     end
 
-    def execute_batch_direct_commands(policy, keys)
+    def execute_batch_operate_commands(policy, records)
       if @cluster.nodes.empty?
-        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Executing Batch Direct command failed because cluster is empty.")
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Executing Batch Index command failed because cluster is empty.")
       end
 
-      batch_nodes = BatchDirectNode.generate_list(@cluster, policy.replica, keys)
+      batch_nodes = BatchOperateNode.generate_list(@cluster, policy.replica, records)
       threads = []
 
-      # Use a thread per namespace per node
-      batch_nodes.each do |batch_node|
-        # copy to avoid race condition
-        bn = batch_node
-        bn.batch_namespaces.each do |batch|
-          threads << Thread.new do
-            Thread.current.abort_on_exception = true
-            command = yield batch_node.node, batch
-            execute_command(command)
-          end
+      batch_nodes.each do |batch|
+        threads << Thread.new do
+          command = yield batch.node, batch
+          execute_command(command)
         end
       end
 

data/lib/aerospike/cluster.rb

@@ -120,15 +120,15 @@ module Aerospike
     # Returns a node on the cluster for read operations
     def batch_read_node(partition, replica_policy)
       case replica_policy
-        when Aerospike::Replica::MASTER, Aerospike::Replica::SEQUENCE
-          return master_node(partition)
-        when Aerospike::Replica::MASTER_PROLES
-          return master_proles_node(partition)
-        when Aerospike::Replica::PREFER_RACK
-          return rack_node(partition, seq)
-        when Aerospike::Replica::RANDOM
-          return random_node
-        else
+      when Aerospike::Replica::MASTER, Aerospike::Replica::SEQUENCE
+          master_node(partition)
+      when Aerospike::Replica::MASTER_PROLES
+          master_proles_node(partition)
+      when Aerospike::Replica::PREFER_RACK
+          rack_node(partition, seq)
+      when Aerospike::Replica::RANDOM
+          random_node
+      else
           raise Aerospike::Exceptions::InvalidNode("invalid policy.replica value")
       end
     end
@@ -136,17 +136,17 @@ module Aerospike
     # Returns a node on the cluster for read operations
     def read_node(partition, replica_policy, seq)
       case replica_policy
-        when Aerospike::Replica::MASTER
-          return master_node(partition)
-        when Aerospike::Replica::MASTER_PROLES
-          return master_proles_node(partition)
-        when Aerospike::Replica::PREFER_RACK
-          return rack_node(partition, seq)
-        when Aerospike::Replica::SEQUENCE
-          return sequence_node(partition, seq)
-        when Aerospike::Replica::RANDOM
-          return random_node
-        else
+      when Aerospike::Replica::MASTER
+          master_node(partition)
+      when Aerospike::Replica::MASTER_PROLES
+          master_proles_node(partition)
+      when Aerospike::Replica::PREFER_RACK
+          rack_node(partition, seq)
+      when Aerospike::Replica::SEQUENCE
+          sequence_node(partition, seq)
+      when Aerospike::Replica::RANDOM
+          random_node
+      else
           raise Aerospike::Exceptions::InvalidNode("invalid policy.replica value")
       end
     end
@@ -155,12 +155,12 @@ module Aerospike
     def master_node(partition)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
-      node_array = (replica_array.get)[0]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !node_array
+      node_array = replica_array.get[0]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless node_array
 
-      node = (node_array.get)[partition.partition_id]
+      node = node_array.get[partition.partition_id]
       raise Aerospike::Exceptions::InvalidNode if !node || !node.active?
 
       node
@@ -170,7 +170,7 @@ module Aerospike
     def rack_node(partition, seq)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
@@ -179,10 +179,10 @@ module Aerospike
       node = nil
       fallback = nil
       for i in 1..replica_array.length
-        idx = (seq.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (seq.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
-        next if !node
+        next unless node
 
         fallback = node
 
@@ -202,14 +202,14 @@ module Aerospike
     def master_proles_node(partition)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
       node = nil
       for replica in replica_array
-        idx = (@replica_index.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (@replica_index.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
         return node if node && node.active?
       end
@@ -221,14 +221,14 @@ module Aerospike
     def sequence_node(partition, seq)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
       node = nil
       for replica in replica_array
-        idx = (seq.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (seq.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
         return node if node && node.active?
       end
@@ -236,9 +236,13 @@ module Aerospike
       raise Aerospike::Exceptions::InvalidNode
     end
 
-    def get_node_for_key(replica_policy, key)
+    def get_node_for_key(replica_policy, key, is_write: false)
       partition = Partition.new_by_key(key)
-      batch_read_node(partition, replica_policy)
+      if is_write
+        master_node(partition)
+      else
+        batch_read_node(partition, replica_policy)
+      end
     end
 
     # Returns partitions pertaining to a node
@@ -247,10 +251,10 @@ module Aerospike
 
       partition_map = partitions
       replica_array = partition_map[namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
-      node_array = (replica_array.get)[0]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !node_array
+      node_array = replica_array.get[0]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless node_array
 
 
       pid = 0
@@ -270,7 +274,7 @@ module Aerospike
       i = 0
       while i < length
         # Must handle concurrency with other non-tending threads, so node_index is consistent.
-        idx = (@node_index.update{ |v| v.succ } % node_array.length).abs
+        idx = (@node_index.update { |v| v.succ } % node_array.length).abs
         node = node_array[idx]
 
         return node if node.active?
@@ -366,13 +370,13 @@ module Aerospike
       @tend_thread = Thread.new do
         Thread.current.abort_on_exception = false
         loop do
-          begin
+
             tend
             sleep(@tend_interval / 1000.0)
-          rescue => e
+        rescue => e
             Aerospike.logger.error("Exception occured during tend: #{e}")
             Aerospike.logger.debug { e.backtrace.join("\n") }
-          end
+
         end
       end
     end
@@ -453,7 +457,7 @@ module Aerospike
 
     def log_tend_stats(nodes)
       diff = nodes.size - @old_node_count
-      action = "#{diff.abs} #{diff.abs == 1 ? "node has" : "nodes have"} #{diff > 0 ? "joined" : "left"} the cluster."
+      action = "#{diff.abs} #{diff.abs == 1 ? 'node has' : 'nodes have'} #{diff > 0 ? 'joined' : 'left'} the cluster."
       Aerospike.logger.info("Tend finished. #{action} Old node count: #{@old_node_count}, New node count: #{nodes.size}")
       @old_node_count = nodes.size
     end
@@ -689,11 +693,11 @@ module Aerospike
     end
 
     def node_exists(search, node_list)
-      node_list.any? {|node| node == search }
+      node_list.any? { |node| node == search }
     end
 
     def find_node_by_name(node_name)
-      nodes.detect{|node| node.name == node_name }
+      nodes.detect { |node| node.name == node_name }
     end
   end
 end

data/lib/aerospike/command/batch_index_command.rb

@@ -21,11 +21,7 @@ module Aerospike
 
   class BatchIndexCommand < MultiCommand #:nodoc:
 
-    attr_accessor :batch
-    attr_accessor :policy
-    attr_accessor :bin_names
-    attr_accessor :results
-    attr_accessor :read_attr
+    attr_accessor :batch, :policy, :bin_names, :results, :read_attr
 
     def initialize(node, batch, policy, bin_names, results, read_attr)
       super(node)
@@ -42,8 +38,8 @@ module Aerospike
       field_count_row = 1
       field_count = 1
 
-      predexp_size = estimate_predexp(@policy.predexp)
-      field_count += 1 if predexp_size > 0
+      exp_size = estimate_expression_size(@policy.filter_exp)
+      field_count += 1 if exp_size > 0
 
       if bin_names
         bin_names.each do |bin_name|
@@ -58,7 +54,7 @@ module Aerospike
       batch.keys.each do |key|
         @data_offset += key.digest.length + 4 # 4 byte batch offset
 
-        if prev != nil && prev.namespace == key.namespace
+        if !prev.nil? && prev.namespace == key.namespace
           @data_offset += 1
         else
           @data_offset += key.namespace.bytesize + FIELD_HEADER_SIZE + 1 + 1 + 2 + 2 # repeat/no-repeat flag + read_attr flags + field_count + operation_count
@@ -68,7 +64,7 @@ module Aerospike
       size_buffer
       write_header_read(policy, read_attr | INFO1_BATCH, 0, field_count, 0)
 
-      write_predexp(@policy.predexp, predexp_size)
+      write_filter_exp(@policy.filter_exp, exp_size)
 
       write_field_header(0, Aerospike::FieldType::BATCH_INDEX)
       @data_offset += @data_buffer.write_int32(batch.keys.length, @data_offset)
@@ -80,7 +76,7 @@ module Aerospike
         @data_offset += @data_buffer.write_int32(index, @data_offset)
         @data_offset += @data_buffer.write_binary(key.digest, @data_offset)
 
-        if (prev != nil && prev.namespace == key.namespace)
+        if !prev.nil? && prev.namespace == key.namespace
           @data_offset += @data_buffer.write_byte(1, @data_offset)
         else
           @data_offset += @data_buffer.write_byte(0, @data_offset)

data/lib/aerospike/command/batch_index_node.rb

@@ -19,13 +19,12 @@ module Aerospike
 
   class BatchIndexNode #:nodoc:
 
-    attr_accessor :node
-    attr_accessor :keys_by_idx
+    attr_accessor :node, :keys_by_idx
 
     def self.generate_list(cluster, replica_policy, keys)
       keys.each_with_index
-        .group_by { |key, _| cluster.get_node_for_key(replica_policy, key) }
-        .map { |node, keys_with_idx| BatchIndexNode.new(node, keys_with_idx) }
+          .group_by { |key, _| cluster.get_node_for_key(replica_policy, key) }
+          .map { |node, keys_with_idx| BatchIndexNode.new(node, keys_with_idx) }
     end
 
     def initialize(node, keys_with_idx)