aerospike 2.28.0 → 3.0.0

data/lib/aerospike/exp/exp.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2022 Aerospike, Inc.
+# Copyright 2014-2023 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -210,7 +210,7 @@ module Aerospike
     #   # Bin "a" exists in record
     #   Exp.bin_exists("a")
     def self.bin_exists(name)
-      return Exp.ne(Exp.bin_type(name), Exp.int_val(0))
+      Exp.ne(Exp.bin_type(name), Exp.int_val(0))
     end
 
     # Create expression that returns bin's integer particle type::
@@ -223,6 +223,20 @@ module Aerospike
       CmdStr.new(BIN_TYPE, name)
     end
 
+    # Create expression that returns the record size. This expression usually evaluates
+    # quickly because record meta data is cached in memory.
+    # Requires server version 7.0+. This expression replaces {@link #deviceSize()} and
+    # {@link #memorySize()} since those older expressions are equivalent on server version 7.0+.
+    #
+    # {@code
+    # // Record size >= 100 KB
+    # Exp.ge(Exp.record_size(), Exp.val(100 * 1024))
+    # }
+    def self.record_size
+      Cmd.new(RECORD_SIZE)
+    end
+
+
     #--------------------------------------------------
     # Misc
     #--------------------------------------------------
@@ -900,6 +914,19 @@ module Aerospike
     def self.var(name)
       CmdStr.new(VAR, name)
     end
+    #--------------------------------------------------
+    # Build
+    #--------------------------------------------------
+
+    #
+    # Create final expression that contains packed byte instructions used in the wire protocol.
+
+    def self.build(exp)
+      Packer.use do |packer|
+        exp.pack(packer)
+        @bytes = packer.bytes
+      end
+    end
 
     #--------------------------------------------------
     # Miscellaneous
@@ -922,6 +949,7 @@ module Aerospike
       Cmd.new(UNKNOWN)
     end
 
+
     # # Merge precompiled expression into a new expression tree.
     # # Useful for storing common precompiled expressions and then reusing
     # # these expressions as part of a greater expression.
@@ -1010,6 +1038,7 @@ module Aerospike
     KEY_EXISTS = 71
     IS_TOMBSTONE = 72
     MEMORY_SIZE = 73
+    RECORD_SIZE = 74
     KEY = 80
     BIN = 81
     BIN_TYPE = 82

data/lib/aerospike/exp/exp_list.rb

@@ -193,7 +193,7 @@ module Aerospike
     #   Exp.val(0))
     # end</pre>
     #
-    # @param return_type	metadata attributes to return. See {@link CDT::ListReturnTypeend
+    # @param return_type	metadata attributes to return. See {@link CDT::ListReturnType
     # @param value			search expression
     # @param bin			list bin or list value expression
     # @param ctx			optional context path for nested CDT
@@ -210,7 +210,7 @@ module Aerospike
     # ListExp.getByValueRange(CDT::ListReturnType::VALUE, Exp.val(10), Exp.val(20), Exp.listBin("a"))
     # end</pre>
     #
-    # @param return_type	metadata attributes to return. See {@link CDT::ListReturnTypeend
+    # @param return_type	metadata attributes to return. See {@link CDT::ListReturnType}
     # @param value_begin	begin expression inclusive. If nil, range is less than value_end.
     # @param value_end		end expression exclusive. If nil, range is greater than equal to value_begin.
     # @param bin			bin or list value expression
@@ -228,7 +228,7 @@ module Aerospike
     end
 
     # Create expression that selects list items nearest to value and greater by relative rank with a count limit
-    # and returns selected data specified by return_type (See {@link CDT::ListReturnTypeend).
+    # and returns selected data specified by return_type (See {@link CDT::ListReturnType).
     #
     # Examples for ordered list [0,4,5,9,11,15]:
     #
@@ -365,11 +365,17 @@ module Aerospike
     end
 
     def self.get_value_type(return_type)
-      if (return_type & ~CDT::ListReturnType::INVERTED) == CDT::ListReturnType::VALUE
-        Exp::Type::LIST
-      else
-        Exp::Type::INT
-      end
+        t = return_type & ~CDT::ListReturnType::INVERTED
+        case t
+        when CDT::ListReturnType::INDEX, CDT::ListReturnType::REVERSE_INDEX, CDT::ListReturnType::RANK, CDT::ListReturnType::REVERSE_RANK, CDT::ListReturnType::VALUE
+          Exp::Type::LIST
+        when CDT::ListReturnType::COUNT
+          Exp::Type::INT
+        when CDT::ListReturnType::EXISTS
+          Exp::Type::BOOL
+        else
+          raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_ERROR, "Invalid MapReturnType: #{return_type}")
+        end
     end
 
     def self.pack_range_operation(command, return_type, value_begin, value_end, ctx)

data/lib/aerospike/exp/exp_map.rb

@@ -479,15 +479,26 @@ module Aerospike
 
     def self.get_value_type(return_type)
       t = return_type & ~CDT::MapReturnType::INVERTED
-
-      if t <= CDT::MapReturnType::COUNT
-        return Exp::Type::INT
-      end
-
-      if t == CDT::MapReturnType::KEY_VALUE
-        return Exp::Type::MAP
+      case t
+      when CDT::MapReturnType::INDEX, CDT::MapReturnType::REVERSE_INDEX, CDT::MapReturnType::RANK, CDT::MapReturnType::REVERSE_RANK, CDT::MapReturnType::KEY, CDT::MapReturnType::VALUE
+        Exp::Type::LIST
+      when CDT::MapReturnType::COUNT
+        Aerospike::Exp::Type::INT
+      when CDT::MapReturnType::KEY_VALUE
+        Exp::Type::MAP
+      when CDT::MapReturnType::EXISTS
+        Exp::Type::BOOL
+      else
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_ERROR, "Invalid MapReturnType: #{return_type}")
       end
-      return Exp::Type::LIST
+      # if t <= CDT::MapReturnType::COUNT
+      #   return Exp::Type::INT
+      # end
+      #
+      # if t == CDT::MapReturnType::KEY_VALUE
+      #   return Exp::Type::MAP
+      # end
+      # return Exp::Type::LIST
     end
   end # class MapExp
 end # module Aerospike

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,14 @@ 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 update_racks(parser)
       new_racks = parser.update_racks
       @racks.value = new_racks if new_racks

data/lib/aerospike/query/query_command.rb

@@ -23,9 +23,9 @@ module Aerospike
 
   class QueryCommand < StreamCommand #:nodoc:
 
-    def initialize(node, policy, statement, recordset, partitions)
+    def initialize(cluster, node, policy, statement, recordset, partitions)
       super(node)
-
+      @cluster = cluster
       @policy = policy
       @statement = statement
       @recordset = recordset
@@ -33,209 +33,7 @@ module Aerospike
     end
 
     def write_buffer
-      fieldCount = 0
-      filterSize = 0
-      binNameSize = 0
-      predSize = 0
-
-      begin_cmd
-
-      if @statement.namespace
-        @data_offset += @statement.namespace.bytesize + FIELD_HEADER_SIZE
-        fieldCount+=1
-      end
-
-      if @statement.index_name
-        @data_offset += @statement.index_name.bytesize + FIELD_HEADER_SIZE
-        fieldCount+=1
-      end
-
-      if @statement.set_name
-        @data_offset += @statement.set_name.bytesize + FIELD_HEADER_SIZE
-        fieldCount+=1
-      end
-
-      if !is_scan?
-        col_type = @statement.filters[0].collection_type
-        if col_type > 0
-          @data_offset += FIELD_HEADER_SIZE + 1
-          fieldCount += 1
-        end
-
-        @data_offset += FIELD_HEADER_SIZE
-        filterSize+=1 # num filters
-
-        @statement.filters.each do |filter|
-          sz = filter.estimate_size
-          filterSize += sz
-        end
-        @data_offset += filterSize
-        fieldCount+=1
-
-        if @statement.bin_names && @statement.bin_names.length > 0
-          @data_offset += FIELD_HEADER_SIZE
-          binNameSize+=1 # num bin names
-
-          @statement.bin_names.each do |bin_name|
-            binNameSize += bin_name.bytesize + 1
-          end
-          @data_offset += binNameSize
-          fieldCount+=1
-        end
-      else
-        @data_offset += @partitions.length * 2 + FIELD_HEADER_SIZE
-        fieldCount += 1
-
-        if @policy.records_per_second > 0
-          @data_offset += 4 + FIELD_HEADER_SIZE
-          fieldCount += 1
-        end
-
-        # Calling query with no filters is more efficiently handled by a primary index scan.
-        # Estimate scan options size.
-        # @data_offset += (2 + FIELD_HEADER_SIZE)
-        # fieldCount+=1
-      end
-
-      @statement.set_task_id
-
-      @data_offset += 8 + FIELD_HEADER_SIZE
-      fieldCount+=1
-
-      predexp = @policy.predexp || @statement.predexp
-
-      if predexp
-        @data_offset += FIELD_HEADER_SIZE
-        predSize = Aerospike::PredExp.estimate_size(predexp)
-        @data_offset += predSize
-        fieldCount += 1
-      end
-
-      if @statement.function_name
-        @data_offset += FIELD_HEADER_SIZE + 1 # udf type
-        @data_offset += @statement.package_name.bytesize + FIELD_HEADER_SIZE
-        @data_offset += @statement.function_name.bytesize + FIELD_HEADER_SIZE
-
-        if @statement.function_args && @statement.function_args.length > 0
-          functionArgBuffer = Value.of(@statement.function_args).to_bytes
-        else
-          functionArgBuffer = ''
-        end
-        @data_offset += FIELD_HEADER_SIZE + functionArgBuffer.bytesize
-        fieldCount += 4
-      end
-
-      if @statement.filters.nil? || @statement.filters.empty?
-        if @statement.bin_names && @statement.bin_names.length > 0
-          @statement.bin_names.each do |bin_name|
-            estimate_operation_size_for_bin_name(bin_name)
-          end
-        end
-      end
-
-      size_buffer
-
-      readAttr = @policy.include_bin_data ? INFO1_READ : INFO1_READ | INFO1_NOBINDATA
-      operation_count = (is_scan? && !@statement.bin_names.nil?) ? @statement.bin_names.length : 0
-
-      write_header(@policy, readAttr, 0, fieldCount, operation_count)
-
-      if @statement.namespace
-        write_field_string(@statement.namespace, Aerospike::FieldType::NAMESPACE)
-      end
-
-      unless @statement.index_name.nil?
-        write_field_string(@statement.index_name, Aerospike::FieldType::INDEX_NAME)
-      end
-
-      if @statement.set_name
-        write_field_string(@statement.set_name, Aerospike::FieldType::TABLE)
-      end
-
-      if !is_scan?
-        col_type = @statement.filters[0].collection_type
-        if col_type > 0
-          write_field_header(1, Aerospike::FieldType::INDEX_TYPE)
-          @data_buffer.write_byte(col_type, @data_offset)
-          @data_offset+=1
-        end
-
-        write_field_header(filterSize, Aerospike::FieldType::INDEX_RANGE)
-        @data_buffer.write_byte(@statement.filters.length, @data_offset)
-        @data_offset+=1
-
-        @statement.filters.each do |filter|
-          @data_offset = filter.write(@data_buffer, @data_offset)
-        end
-
-        # Query bin names are specified as a field (Scan bin names are specified later as operations)
-        if @statement.bin_names && @statement.bin_names.length > 0
-          write_field_header(binNameSize, Aerospike::FieldType::QUERY_BINLIST)
-          @data_buffer.write_byte(@statement.bin_names.length, @data_offset)
-          @data_offset += 1
-
-          @statement.bin_names.each do |bin_name|
-            len = @data_buffer.write_binary(bin_name, @data_offset + 1)
-            @data_buffer.write_byte(len, @data_offset)
-            @data_offset += len + 1;
-          end
-        end
-      else
-        write_field_header(@partitions.length * 2, Aerospike::FieldType::PID_ARRAY)
-        for pid in @partitions
-          @data_buffer.write_uint16_little_endian(pid, @data_offset)
-          @data_offset += 2
-        end
-
-        if @policy.records_per_second > 0
-          write_field_int(@policy.records_per_second, Aerospike::FieldType::RECORDS_PER_SECOND)
-        end
-
-        # Calling query with no filters is more efficiently handled by a primary index scan.
-        # write_field_header(2, Aerospike::FieldType::SCAN_OPTIONS)
-        # priority = @policy.priority.ord
-        # priority = priority << 4
-        # @data_buffer.write_byte(priority, @data_offset)
-        # @data_offset+=1
-        # @data_buffer.write_byte(100.ord, @data_offset)
-        # @data_offset+=1
-      end
-
-      write_field_header(8, Aerospike::FieldType::TRAN_ID)
-      @data_buffer.write_int64(@statement.task_id, @data_offset)
-      @data_offset += 8
-
-      if predexp
-        write_field_header(predSize, Aerospike::FieldType::PREDEXP)
-        @data_offset = Aerospike::PredExp.write(
-          predexp, @data_buffer, @data_offset
-        )
-      end
-
-      if @statement.function_name
-        write_field_header(1, Aerospike::FieldType::UDF_OP)
-        if @statement.return_data
-          @data_buffer.write_byte(1, @data_offset)
-          @data_offset+=1
-        else
-          @data_buffer.write_byte(2, @data_offset)
-          @data_offset+=1
-        end
-
-        write_field_string(@statement.package_name, Aerospike::FieldType::UDF_PACKAGE_NAME)
-        write_field_string(@statement.function_name, Aerospike::FieldType::UDF_FUNCTION)
-        write_field_bytes(functionArgBuffer, Aerospike::FieldType::UDF_ARGLIST)
-      end
-
-      if is_scan? && !@statement.bin_names.nil?
-        @statement.bin_names.each do |bin_name|
-          write_operation_for_bin_name(bin_name, Aerospike::Operation::READ)
-        end
-      end
-
-      end_cmd
-
-      return nil
+      set_query(@cluster, @policy, @statement, false, @partitions)
     end
 
     def is_scan?

data/lib/aerospike/query/query_executor.rb

@@ -34,7 +34,7 @@ module Aerospike
           list.each do |node_partition|
             threads << Thread.new do
               Thread.current.abort_on_exception = true
-              command = QueryPartitionCommand.new(node_partition.node, tracker, policy, statement, recordset, node_partition)
+              command = QueryPartitionCommand.new(cluster, node_partition.node, tracker, policy, statement, recordset, node_partition)
               begin
                 command.execute
               rescue => e
@@ -48,7 +48,7 @@ module Aerospike
         else
           # Use a single thread for all nodes for all node
           list.each do |node_partition|
-            command = QueryPartitionCommand.new(node_partition.node, tracker, policy, statement, recordset, node_partition)
+            command = QueryPartitionCommand.new(cluster, node_partition.node, tracker, policy, statement, recordset, node_partition)
             begin
               command.execute
             rescue => e

data/lib/aerospike/query/query_partition_command.rb

@@ -21,243 +21,17 @@ module Aerospike
   private
 
   class QueryPartitionCommand < QueryCommand #:nodoc:
-    def initialize(node, tracker, policy, statement, recordset, node_partitions)
-      super(node, policy, statement, recordset, @node_partitions)
+    def initialize(cluster, node, tracker, policy, statement, recordset, node_partitions)
+      super(cluster, node, policy, statement, recordset, @node_partitions)
       @node_partitions = node_partitions
       @tracker = tracker
     end
 
     def write_buffer
-      function_arg_buffer = nil
-      field_count = 0
-      filter_size = 0
-      bin_name_size = 0
-
-      begin_cmd
-
-      if @statement.namespace
-        @data_offset += @statement.namespace.bytesize + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      if @statement.set_name
-        @data_offset += @statement.set_name.bytesize + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      # Estimate recordsPerSecond field size. This field is used in new servers and not used
-      # (but harmless to add) in old servers.
-      if @policy.records_per_second > 0
-        @data_offset += 4 + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      # Estimate socket timeout field size. This field is used in new servers and not used
-      # (but harmless to add) in old servers.
-      @data_offset += 4 + FIELD_HEADER_SIZE
-      field_count += 1
-
-      # Estimate task_id field.
-      @data_offset += 8 + FIELD_HEADER_SIZE
-      field_count += 1
-
-      filter = @statement.filters[0]
-      bin_names = @statement.bin_names
-      packed_ctx = nil
-
-      if filter
-        col_type = filter.collection_type
-
-        # Estimate INDEX_TYPE field.
-        if col_type > 0
-          @data_offset += FIELD_HEADER_SIZE + 1
-          field_count += 1
-        end
-
-        # Estimate INDEX_RANGE field.
-        @data_offset += FIELD_HEADER_SIZE
-        filter_size += 1  # num filters
-        filter_size += filter.estimate_size
-
-        @data_offset += filter_size
-        field_count += 1
-
-        packed_ctx = filter.packed_ctx
-        if packed_ctx
-          @data_offset += FIELD_HEADER_SIZE + packed_ctx.length
-          field_count += 1
-        end
-      end
-
-      @statement.set_task_id
-      predexp = @policy.predexp || @statement.predexp
-
-      if predexp
-        @data_offset += FIELD_HEADER_SIZE
-        pred_size = Aerospike::PredExp.estimate_size(predexp)
-        @data_offset += pred_size
-        field_count += 1
-      end
-
-      unless @policy.filter_exp.nil?
-        exp_size = estimate_expression_size(@policy.filter_exp)
-        field_count += 1 if exp_size > 0
-      end
-
-      # Estimate aggregation/background function size.
-      if @statement.function_name
-        @data_offset += FIELD_HEADER_SIZE + 1 # udf type
-        @data_offset += @statement.package_name.bytesize + FIELD_HEADER_SIZE
-        @data_offset += @statement.function_name.bytesize + FIELD_HEADER_SIZE
-
-        function_arg_buffer = ""
-        if @statement.function_args && @statement.function_args.length > 0
-          function_arg_buffer = Value.of(@statement.function_args).to_bytes
-        end
-        @data_offset += FIELD_HEADER_SIZE + function_arg_buffer.bytesize
-        field_count += 4
-      end
-
-      max_records = 0
-      parts_full_size = 0
-      parts_partial_digest_size = 0
-      parts_partial_bval_size = 0
-
-      unless @node_partitions.nil?
-        parts_full_size = @node_partitions.parts_full.length * 2
-        parts_partial_digest_size = @node_partitions.parts_partial.length * 20
-
-        unless filter.nil?
-          parts_partial_bval_size = @node_partitions.parts_partial.length * 8
-        end
-        max_records = @node_partitions.record_max
-      end
-
-      if parts_full_size > 0
-        @data_offset += parts_full_size + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      if parts_partial_digest_size > 0
-        @data_offset += parts_partial_digest_size + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      if parts_partial_bval_size > 0
-        @data_offset += parts_partial_bval_size + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      # Estimate max records field size. This field is used in new servers and not used
-      # (but harmless to add) in old servers.
-      if max_records > 0
-        @data_offset += 8 + FIELD_HEADER_SIZE
-        field_count += 1
-      end
-
-      operation_count = 0
-      unless bin_names.empty?
-        # Estimate size for selected bin names (query bin names already handled for old servers).
-        bin_names.each do |bin_name|
-          estimate_operation_size_for_bin_name(bin_name)
-        end
-        operation_count = bin_names.length
-      end
-
-      projected_offset = @data_offset
-
-      size_buffer
-
-      read_attr = INFO1_READ
-      read_attr |= INFO1_NOBINDATA if !@policy.include_bin_data
-      read_attr |= INFO1_SHORT_QUERY if @policy.short_query
-
-      infoAttr = INFO3_PARTITION_DONE
-
-      write_header(@policy, read_attr, 0, field_count, operation_count)
-
-      write_field_string(@statement.namespace, FieldType::NAMESPACE) if @statement.namespace
-      write_field_string(@statement.set_name, FieldType::TABLE) if @statement.set_name
-
-      # Write records per second.
-      write_field_int(@policy.records_per_second, FieldType::RECORDS_PER_SECOND) if @policy.records_per_second > 0
-
-      write_filter_exp(@policy.filter_exp, exp_size)
-
-      # Write socket idle timeout.
-      write_field_int(@policy.socket_timeout, FieldType::SOCKET_TIMEOUT)
-
-      # Write task_id field
-      write_field_int64(@statement.task_id, FieldType::TRAN_ID)
-
-      unless predexp.nil?
-        write_field_header(pred_size, Aerospike::FieldType::PREDEXP)
-        @data_offset = Aerospike::PredExp.write(
-          predexp, @data_buffer, @data_offset
-        )
-      end
-
-      if filter
-        type = filter.collection_type
-
-        if type > 0
-          write_field_header(1, FieldType::INDEX_TYPE)
-          @data_offset += @data_buffer.write_byte(type, @data_offset)
-        end
-
-        write_field_header(filter_size, FieldType::INDEX_RANGE)
-        @data_offset += @data_buffer.write_byte(1, @data_offset)
-        @data_offset = filter.write(@data_buffer, @data_offset)
-
-        if packed_ctx
-          write_field_header(packed_ctx.length, FieldType::INDEX_CONTEXT)
-          @data_offset += @data_buffer.write_binary(packed_ctx, @data_offset)
-        end
-      end
-
-      if @statement.function_name
-        write_field_header(1, FieldType::UDF_OP)
-        @data_offset += @data_buffer.write_byte(1, @data_offset)
-        write_field_string(@statement.package_name, FieldType::UDF_PACKAGE_NAME)
-        write_field_string(@statement.function_name, FieldType::UDF_FUNCTION)
-        write_field_string(function_arg_buffer, FieldType::UDF_ARGLIST)
-      end
-
-      if parts_full_size > 0
-        write_field_header(parts_full_size, FieldType::PID_ARRAY)
-        @node_partitions.parts_full.each do |part|
-          @data_offset += @data_buffer.write_uint16_little_endian(part.id, @data_offset)
-        end
-      end
-
-      if parts_partial_digest_size > 0
-        write_field_header(parts_partial_digest_size, FieldType::DIGEST_ARRAY)
-        @node_partitions.parts_partial.each do |part|
-          @data_offset += @data_buffer.write_binary(part.digest, @data_offset)
-        end
-      end
-
-      if parts_partial_bval_size > 0
-        write_field_header(parts_partial_bval_size, FieldType::BVAL_ARRAY)
-        @node_partitions.parts_partial.each do |part|
-          @data_offset += @data_buffer.write_uint64_little_endian(part.bval, @data_offset)
-        end
-      end
-
-      if max_records > 0
-        write_field(max_records, FieldType::MAX_RECORDS)
-      end
-
-      unless bin_names.empty?
-        bin_names.each do |bin_name|
-          write_operation_for_bin_name(bin_name, Operation::READ)
-        end
-      end
+      set_query(@cluster, @policy, @statement, false, @node_partitions)
+    end
 
-      end_cmd
 
-      nil
-    end
 
     def should_retry(e)
       # !! converts nil to false

data/lib/aerospike/query/scan_executor.rb

@@ -34,7 +34,7 @@ module Aerospike
           list.each do |node_partition|
             threads << Thread.new do
               Thread.current.abort_on_exception = true
-              command = ScanPartitionCommand.new(policy, tracker, node_partition, namespace, set_name, bin_names, recordset)
+              command = ScanPartitionCommand.new(cluster, policy, tracker, node_partition, namespace, set_name, bin_names, recordset)
               begin
                 command.execute
               rescue => e
@@ -48,7 +48,7 @@ module Aerospike
         else
           # Use a single thread for all nodes for all node
           list.each do |node_partition|
-            command = ScanPartitionCommand.new(policy, tracker, node_partition, namespace, set_name, bin_names, recordset)
+            command = ScanPartitionCommand.new(cluster, policy, tracker, node_partition, namespace, set_name, bin_names, recordset)
             begin
               command.execute
             rescue => e