aerospike 2.25.0 → 2.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12a4c3d56df63146053710f4438b8030672d76d9fa01cf4ddf5453429d275e11
-  data.tar.gz: '025678955679feb936123140c4bce14117a85ac954eb0e3d294960269cfa9b92'
+  metadata.gz: 3fe67950bfa737ce26a8a0e823cd84424219c6ce41720e0202ca93d4dcab2c1d
+  data.tar.gz: 83976d88565599f00136967bd86fe832a88783518c51be2789c1463fa06e795e
 SHA512:
-  metadata.gz: 2e5d828c912aaa9a189de8c7d1441bb255b4ae73a6075d262b75b3cb10f8315b4afc2d5853cf015cfd829f9fd4cbc14014bd007a76f2e2de2426aad6e489ae62
-  data.tar.gz: 53d8e293b39e14b99ce747c06f125b2cdc695c7654ea7d21cbce927e2f8f1064eab0ab2f0b585308353a36a8f345eeafb4c21854b0184ebe652a32a83afddf19
+  metadata.gz: e018d80b673081cdbf229aa5c48dd7ebbeb9a127492cc04c651a4e56bab92d7764aba82ffb3e3783f6a6f34755ded66be58c3bf5a9e110be61c0c21e20128932
+  data.tar.gz: 8e02a4d37b620f838dde53b63d4af3fe20146905dd4f3a30c14f97a83453c69f0dccfbaf1f44a777bf4ab53e89583cc7a6e4343204e6749b1d4fb888f0a7200f

data/CHANGELOG.md

@@ -2,10 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.27.0] 2023-05-18
+- **New Features**
+  - [CLIENT-1176] Support write operations in background query
+
+
+## [2.26.0] 2022-12-02
+
+- **New Features**
+  - [CLIENT-1808] Support creating a secondary index on elements within a CDT using `Context`.
+  - [CLIENT-1991] Add base64 encoding methods to `Context`.
+  - [CLIENT-2007] Support using `Context` in query filters.
+
 ## [2.25.0] 2022-11-28
 
 - **New Features**
 
+  - [CLIENT-1984] Support scan-show and query-show info commands.
+
   - [CLIENT-1362] Adds support Aerospike Expression filters. Expression filters are now supported on all commands, including `Client#get`, `Client#put`, `Client#delete`, `Client#operate`, `Client#scan`, `Client#query`, `Client#execute_udf`, etc.
 
     - Adds `Policy#filter_exp` and `Policy#fail_on_filtered_out`

data/lib/aerospike/cdt/context.rb

@@ -17,16 +17,17 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
+require "base64"
+
 module Aerospike
   module CDT
 
-  	##
-	# Nested CDT context. Identifies the location of nested list/map to apply the operation.
-	# for the current level.
-	# An array of CTX identifies location of the list/map on multiple
-	# levels on nesting.
+    ##
+    # Nested CDT context. Identifies the location of nested list/map to apply the operation.
+    # for the current level.
+    # An array of CTX identifies location of the list/map on multiple
+    # levels on nesting.
     class Context
-
       attr_accessor :id, :value
 
       def initialize(id, value)
@@ -37,64 +38,64 @@ module Aerospike
       ##
       # Create list with given type at index offset, given an order and pad.
       def self.list_index_create(index, order, pad)
-      Context.new(0x10 | ListOrder.flag(order, pad), index)
-      end
-
-	  ##
-	  # Lookup list by index offset.
-	  # If the index is negative, the resolved index starts backwards from end of list.
-	  # If an index is out of bounds, a parameter error will be returned.
-	  # Examples:
-	  # 0: First item.
-	  # 4: Fifth item.
-	  # -1: Last item.
-	  # -3: Third to last item.
-	  def self.list_index(index)
-	  	Context.new(0x10, index)
-	  end
-
-	  ##
-	  # Lookup list by rank.
-	  # 0 = smallest value
-	  # N = Nth smallest value
-	  # -1 = largest value
-	  def self.list_rank(rank)
-	  	Context.new(0x11, rank)
-	  end
-
-	  ##
-	  # Lookup list by value.
-	  def self.list_value(key)
-	  	Context.new(0x13, key)
-	  end
-
-	  ##
-	  # Lookup map by index offset.
-	  # If the index is negative, the resolved index starts backwards from end of list.
-	  # If an index is out of bounds, a parameter error will be returned.
-	  # Examples:
-	  # 0: First item.
-	  # 4: Fifth item.
-	  # -1: Last item.
-	  # -3: Third to last item.
-	  def self.map_index(index)
-	  	Context.new(0x20, index)
-	  end
-
-	  ##
-	  # Lookup map by rank.
-	  # 0 = smallest value
-	  # N = Nth smallest value
-	  # -1 = largest value
-	  def self.map_rank(rank)
-	  	Context.new(0x21, rank)
-	  end
-
-	  ##
-	  # Lookup map by key.
-	  def self.map_key(key)
-	  	Context.new(0x22, key)
-	  end
+        Context.new(0x10 | ListOrder.flag(order, pad), index)
+      end
+
+      ##
+      # Lookup list by index offset.
+      # If the index is negative, the resolved index starts backwards from end of list.
+      # If an index is out of bounds, a parameter error will be returned.
+      # Examples:
+      # 0: First item.
+      # 4: Fifth item.
+      # -1: Last item.
+      # -3: Third to last item.
+      def self.list_index(index)
+        Context.new(0x10, index)
+      end
+
+      ##
+      # Lookup list by rank.
+      # 0 = smallest value
+      # N = Nth smallest value
+      # -1 = largest value
+      def self.list_rank(rank)
+        Context.new(0x11, rank)
+      end
+
+      ##
+      # Lookup list by value.
+      def self.list_value(key)
+        Context.new(0x13, key)
+      end
+
+      ##
+      # Lookup map by index offset.
+      # If the index is negative, the resolved index starts backwards from end of list.
+      # If an index is out of bounds, a parameter error will be returned.
+      # Examples:
+      # 0: First item.
+      # 4: Fifth item.
+      # -1: Last item.
+      # -3: Third to last item.
+      def self.map_index(index)
+        Context.new(0x20, index)
+      end
+
+      ##
+      # Lookup map by rank.
+      # 0 = smallest value
+      # N = Nth smallest value
+      # -1 = largest value
+      def self.map_rank(rank)
+        Context.new(0x21, rank)
+      end
+
+      ##
+      # Lookup map by key.
+      def self.map_key(key)
+        Context.new(0x22, key)
+      end
 
       ##
       # Create map with given type at map key.
@@ -102,12 +103,78 @@ module Aerospike
         Context.new(0x22 | order[:flag], key)
       end
 
-	  ##
-	  # Lookup map by value.
-	  def self.map_value(key)
-	  	Context.new(0x23, key)
-	  end
+      ##
+      # Lookup map by value.
+      def self.map_value(key)
+        Context.new(0x23, key)
+      end
+
+      ##
+      # Encodes the context via message pack.
+      def self.pack(packer, ctx)
+        unless ctx.to_a.empty?
+          packer.write_array_header(2)
+          ctx.each do |c|
+            packer.write(c.id)
+            Value.of(c.value)
+          end
+        end
+      end
+
+      ##
+      # Encodes the context via message pack and return the results.
+      def self.bytes(ctx)
+        unless ctx.to_a.empty?
+          Packer.use do |packer|
+            packer.write_array_header(ctx.length * 2)
+            ctx.each do |c|
+              packer.write(c.id)
+              Value.of(c.value).pack(packer)
+            end
+            return packer.bytes
+          end
+        end
+        nil
+      end
+
+      def ==(other)
+        self.id == other.id && self.value == other.value
+      end
 
+      ##
+      # decodes the base64 encoded messagepack byte array
+      # and converts it to an array of Context.
+      def self.from_bytes(buf)
+        list = nil
+        Unpacker.use do |unpacker|
+          list = unpacker.unpack(buf)
+        end
+
+        unless list.length % 2 == 0
+          raise Exceptions::Aerospike.new(Aerospike::ResultCode::PARAMETER_ERROR, "Invalid buffer")
+        end
+
+        list.each_slice(2).map { |id, value| Context.new(id, value) }
+      end
+
+      ##
+      # Encodes the context array to messagepack and then encodes
+      # the resulting byte array to base64.
+      def self.base64(ctx)
+        unless ctx.to_a.empty?
+          data = self.bytes(ctx)
+          return Base64.strict_encode64(data).force_encoding("binary")
+        end
+        ""
+      end
+
+      ##
+      # Decodes the byte array to messagepack and then decodes
+      # the resulting byte array to an array of Context.
+      def self.from_base64(buf)
+        bytes = Base64.strict_decode64(buf)
+        self.from_bytes(bytes)
+      end
     end
   end
 end

data/lib/aerospike/client.rb

@@ -1,4 +1,4 @@
-# Copyright 2014-2020 Aerospike, Inc.
+# Copyright 2014-2023 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -225,7 +225,6 @@ module Aerospike
       policy = create_policy(options, Policy, default_info_policy)
 
       node = @cluster.random_node
-      conn = node.get_connection(policy.timeout)
 
       if set_name && !set_name.to_s.strip.empty?
         str_cmd = "truncate:namespace=#{namespace}"
@@ -566,7 +565,8 @@ module Aerospike
     #  This method is only supported by Aerospike 3 servers.
     #  index_type should be :string, :numeric or :geo2dsphere (requires server version 3.7 or later)
     #  collection_type should be :list, :mapkeys or :mapvalues
-    def create_index(namespace, set_name, index_name, bin_name, index_type, collection_type = nil, options = nil)
+    #  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
       end
@@ -575,6 +575,7 @@ module Aerospike
       str_cmd = "sindex-create:ns=#{namespace}"
       str_cmd << ";set=#{set_name}" unless set_name.to_s.strip.empty?
       str_cmd << ";indexname=#{index_name};numbins=1"
+      str_cmd << ";context=#{CDT::Context.base64(ctx)}" unless ctx.to_a.empty?
       str_cmd << ";indextype=#{collection_type.to_s.upcase}" if collection_type
       str_cmd << ";indexdata=#{bin_name},#{index_type.to_s.upcase}"
       str_cmd << ";priority=normal"
@@ -729,6 +730,59 @@ module Aerospike
       query_partitions(Aerospike::PartitionFilter.all, statement, options)
     end
 
+    #----------------------------------------------------------
+    # Query/Execute (Supported by Aerospike 3+ servers only)
+    #----------------------------------------------------------
+
+    # QueryExecute applies operations on records that match the statement filter.
+    # Records are not returned to the client.
+    # This asynchronous server call will return before the command is complete.
+    # The user can optionally wait for command completion by using the returned
+    # ExecuteTask instance.
+    #
+    # This method is only supported by Aerospike 3+ servers.
+    # If the policy is nil, the default relevant policy will be used.
+    #
+    # @param statement [Aerospike::Statement] The query or batch read statement.
+    # @param operations [Array<Aerospike::Operation>] An optional list of operations.
+    # @param options [Hash] An optional hash of policy options.
+    # @return [Aerospike::ExecuteTask] An ExecuteTask instance that can be used to wait for command completion.
+    #
+    # @raise [Aerospike::Exceptions::Aerospike] if an error occurs during the operation.
+    def query_execute(statement, operations = [], options = nil)
+      policy = create_policy(options, WritePolicy, default_write_policy)
+
+      if statement.nil?
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::INVALID_COMMAND, "Query failed of invalid statement.")
+      end
+
+      statement = statement.clone
+      unless operations.empty?
+        statement.operations = operations
+      end
+
+      task_id = statement.task_id
+      nodes = @cluster.nodes
+      if nodes.empty?
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Query failed because cluster is empty.")
+      end
+
+      # Use a thread per node
+      nodes.each do |node|
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          begin
+            command = ServerCommand.new(@cluster, node, policy, statement, true, task_id)
+            execute_command(command)
+          rescue => e
+            Aerospike.logger.error(e)
+            raise e
+          end
+        end
+      end
+      ExecuteTask.new(@cluster, statement)
+    end
+
     #-------------------------------------------------------
     # User administration
     #-------------------------------------------------------

data/lib/aerospike/command/command.rb

@@ -1,4 +1,4 @@
-# Copyright 2014-2020 Aerospike, Inc.
+# Copyright 2014-2024 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -465,6 +465,254 @@ module Aerospike
       end_cmd
     end
 
+    def set_query(policy, statement, background, node_partitions)
+      function_arg_buffer = nil
+      field_count = 0
+      filter_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 statement.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
+
+      operations = statement.operations
+      operation_count = 0
+
+      if !operations.empty?
+
+        unless background
+          raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::PARAMETER_ERROR)
+        end
+
+        operations.each do |operation|
+          estimate_operation_size_for_operation(operation)
+        end
+        operation_count = operations.size
+      elsif !bin_names.empty?
+        bin_names.each do |bin_name|
+          estimate_operation_size_for_bin_name(bin_name)
+        end
+        operation_count = bin_names.length
+        # Estimate size for selected bin names (query bin names already handled for old servers).
+      end
+
+      size_buffer
+
+      if background
+        write_header_with_policy(policy, 0, INFO2_WRITE, field_count, operation_count)
+      else
+        read_attr = INFO1_READ
+        read_attr |= INFO1_NOBINDATA unless policy.include_bin_data
+        read_attr |= INFO1_SHORT_QUERY if policy.short_query
+        write_header(policy, read_attr, 0, field_count, operation_count)
+      end
+
+      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(statement.records_per_second, FieldType::RECORDS_PER_SECOND) if statement.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
+
+      if operations.empty?
+        if bin_names.empty?
+          bin_names.each do |bin_name|
+            write_operation_for_bin_name(bin_name, Operation::READ)
+          end
+        end
+      else
+        operations.each do |operation|
+          write_operation_for_operation(operation)
+        end
+      end
+
+      end_cmd
+
+      nil
+    end
+
     def execute
       iterations = 0
 
@@ -537,7 +785,7 @@ module Aerospike
             parse_result
           rescue => e
             case e
-            # do not log the following exceptions
+              # do not log the following exceptions
             when Aerospike::Exceptions::ScanTerminated
             when Aerospike::Exceptions::QueryTerminated
             else
@@ -703,9 +951,8 @@ module Aerospike
       read_attr |= INFO1_CONSISTENCY_ALL if policy.consistency_level == Aerospike::ConsistencyLevel::CONSISTENCY_ALL
       write_attr |= INFO2_DURABLE_DELETE if policy.durable_delete
       read_attr |= INFO1_COMPRESS_RESPONSE if policy.use_compression
-
       # Write all header data except total size which must be written last.
-      @data_buffer.write_byte(MSG_REMAINING_HEADER_SIZE, 8) # Message heade.length.
+      @data_buffer.write_byte(MSG_REMAINING_HEADER_SIZE, 8) # Message header.length.
       @data_buffer.write_byte(read_attr, 9)
       @data_buffer.write_byte(write_attr, 10)
       @data_buffer.write_byte(info_attr, 11)

data/lib/aerospike/policy/policy.rb

@@ -22,7 +22,7 @@ module Aerospike
   # Container object for client policy command.
   class Policy
     attr_accessor :filter_exp, :priority, :timeout, :max_retries, :sleep_between_retries, :consistency_level,
-                  :predexp, :fail_on_filtered_out, :replica, :use_compression
+                  :predexp, :fail_on_filtered_out, :replica, :use_compression, :socket_timeout
 
     alias total_timeout timeout
     alias total_timeout= timeout=
@@ -133,6 +133,16 @@ module Aerospike
       # Duration to sleep between retries if a transaction fails and the
       # timeout was not exceeded. Enter zero to skip sleep.
       @sleep_between_retries = opt[:sleep_between_retries] || 0.5
+
+      # Determines network timeout for each attempt.
+      #
+      # If socket_timeout is not zero and socket_timeout is reached before an attempt completes,
+      # the Timeout above is checked. If Timeout is not exceeded, the transaction
+      # is retried. If both socket_timeout and Timeout are non-zero, socket_timeout must be less
+      # than or equal to Timeout, otherwise Timeout will also be used for socket_timeout.
+      #
+      # Default: 30s
+      @socket_timeout = opt[:socket_timeout] || 30000
     end
   end # class
 end # module

data/lib/aerospike/policy/write_policy.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2020 Aerospike, Inc.
+# Copyright 2014-2023 Aerospike, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -24,8 +24,8 @@ module Aerospike
   class WritePolicy < Policy
 
     attr_accessor :record_exists_action, :generation_policy,
-      :generation, :ttl, :send_key, :commit_level,
-      :durable_delete
+                  :generation, :ttl, :send_key, :commit_level,
+                  :durable_delete
 
     alias expiration ttl
     alias expiration= ttl=
@@ -74,6 +74,11 @@ module Aerospike
       # Valid for Aerospike Server Enterprise Edition 3.10+ only.
       @durable_delete = opt.fetch(:durable_delete, false)
 
+      # Transaction timeout.
+      # This timeout is used to set the socket timeout and is also sent to the
+      # server along with the transaction in the wire protocol.
+      # Default for write policy is 1.
+      @timeout = opt[:timeout] || 1
       self
     end
 

data/lib/aerospike/query/filter.rb

@@ -15,39 +15,51 @@
 # the License.
 
 module Aerospike
-
   class Filter
+    attr_reader :packed_ctx
 
-    def self.Equal(bin_name, value)
-      Filter.new(bin_name, value, value)
-    end
+    # open up the class to alias the class methods for naming consistency
+    class << self
+      def equal(bin_name, value, ctx: nil)
+        Filter.new(bin_name, value, value, nil, nil, ctx)
+      end
 
-    def self.Contains(bin_name, value, col_type)
-      Filter.new(bin_name, value, value, nil, col_type)
-    end
+      def contains(bin_name, value, col_type, ctx: nil)
+        Filter.new(bin_name, value, value, nil, col_type, ctx)
+      end
 
-    def self.Range(bin_name, from, to, col_type = nil)
-      Filter.new(bin_name, from, to, nil, col_type)
-    end
+      def range(bin_name, from, to, col_type = nil, ctx: nil)
+        Filter.new(bin_name, from, to, nil, col_type, ctx)
+      end
 
-    def self.geoWithinGeoJSONRegion(bin_name, region, col_type = nil)
-      region = region.to_json
-      Filter.new(bin_name, region, region, ParticleType::GEOJSON, col_type)
-    end
+      def geo_within_geo_region(bin_name, region, col_type = nil, ctx: nil)
+        region = region.to_json
+        Filter.new(bin_name, region, region, ParticleType::GEOJSON, col_type, ctx)
+      end
 
-    def self.geoWithinRadius(bin_name, lon, lat, radius_meter, col_type = nil)
-      region = GeoJSON.new({type: "AeroCircle", coordinates: [[lon, lat], radius_meter]})
-      geoWithinGeoJSONRegion(bin_name, region, col_type)
-    end
+      def geo_within_radius(bin_name, lon, lat, radius_meter, col_type = nil, ctx: nil)
+        region = GeoJSON.new({ type: "AeroCircle", coordinates: [[lon, lat], radius_meter] })
+        geo_within_geo_region(bin_name, region, col_type, ctx: ctx)
+      end
 
-    def self.geoContainsGeoJSONPoint(bin_name, point, col_type = nil)
-      point = point.to_json
-      Filter.new(bin_name, point, point, ParticleType::GEOJSON, col_type)
-    end
+      def geo_contains_geo_point(bin_name, point, col_type = nil, ctx: nil)
+        point = point.to_json
+        Filter.new(bin_name, point, point, ParticleType::GEOJSON, col_type, ctx)
+      end
 
-    def self.geoContainsPoint(bin_name, lon, lat, col_type = nil)
-      point = GeoJSON.new({type: "Point", coordinates: [lon, lat]})
-      geoContainsGeoJSONPoint(bin_name, point, col_type)
+      def geo_contains_point(bin_name, lon, lat, col_type = nil, ctx: nil)
+        point = GeoJSON.new({ type: "Point", coordinates: [lon, lat] })
+        geo_contains_geo_point(bin_name, point, col_type, ctx: ctx)
+      end
+
+      # alias the old names for compatibility
+      alias :Equal :equal
+      alias :Contains :contains
+      alias :Range :range
+      alias :geoWithinGeoJSONRegion :geo_within_geo_region
+      alias :geoWithinRadius :geo_within_radius
+      alias :geoContainsGeoJSONPoint :geo_contains_geo_point
+      alias :geoContainsPoint :geo_contains_point
     end
 
     def estimate_size
@@ -56,21 +68,21 @@ module Aerospike
 
     def write(buf, offset)
       # Write name.
-      len = buf.write_binary(@name, offset+1)
+      len = buf.write_binary(@name, offset + 1)
       buf.write_byte(len, offset)
       offset += len + 1
 
       # Write particle type.
       buf.write_byte(@val_type, offset)
-      offset+=1
+      offset += 1
 
       # Write filter begin.
-      len = @begin.write(buf, offset+4)
+      len = @begin.write(buf, offset + 4)
       buf.write_int32(len, offset)
       offset += len + 4
 
       # Write filter end.
-      len = @end.write(buf, offset+4)
+      len = @end.write(buf, offset + 4)
       buf.write_int32(len, offset)
       offset += len + 4
 
@@ -98,7 +110,7 @@ module Aerospike
 
     private
 
-    def initialize(bin_name, begin_value, end_value, val_type = nil, col_type = nil)
+    def initialize(bin_name, begin_value, end_value, val_type = nil, col_type = nil, ctx = nil)
       @name = bin_name
       @begin = Aerospike::Value.of(begin_value)
       @end = Aerospike::Value.of(end_value)
@@ -107,8 +119,8 @@ module Aerospike
       # but in certain cases caller can override the type.
       @val_type = val_type || @begin.type
       @col_type = col_type
-    end
 
+      @packed_ctx = CDT::Context.bytes(ctx)
+    end
   end # class
-
 end

data/lib/aerospike/query/query_partition_command.rb

@@ -82,12 +82,11 @@ module Aerospike
         @data_offset += filter_size
         field_count += 1
 
-        # TODO: Implement
-        # packed_ctx = filter.packed_ctx
-        # if packed_ctx
-        #   @data_offset += FIELD_HEADER_SIZE + packed_ctx.length
-        #   field_count+=1
-        # end
+        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
@@ -210,11 +209,10 @@ module Aerospike
         @data_offset += @data_buffer.write_byte(1, @data_offset)
         @data_offset = filter.write(@data_buffer, @data_offset)
 
-        # TODO: Implement
-        # if packed_ctx
-        #   write_field_header(packed_ctx.length, FieldType::INDEX_CONTEXT)
-        #   @data_buffer.write_binary(packed_ctx, @data_offset)
-        # end
+        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

data/lib/aerospike/query/server_command.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+# Copyright 2014-2023 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.
+
+
+module Aerospike
+  class ServerCommand < MultiCommand
+    attr_accessor :statement, :task_id, :cluster, :write_policy, :background
+
+    def initialize(cluster, node, policy, statement, background, task_id)
+      super(node)
+      @statement = statement
+      @task_id = task_id
+      @cluster = cluster
+      @policy = policy
+      @background = background
+    end
+
+    def write?
+      true
+    end
+
+    def write_buffer
+      set_query(@policy, @statement, background, nil)
+    end
+
+    def parse_row
+      field_count = @data_buffer.read_int16(18)
+      result_code = @data_buffer.read(5).ord & 0xFF
+      skip_key(field_count)
+
+      if result_code != 0
+        if result_code == Aerospike::ResultCode::KEY_NOT_FOUND_ERROR
+          return false
+        end
+        raise Aerospike::Exceptions::Aerospike.new(result_code)
+      end
+      op_count = @data_buffer.read_int16(20)
+      if op_count <= 0
+        return Record.new(@node, key, bins, generation, expiration)
+      end
+
+      unless valid?
+        raise Aerospike::Exceptions::QueryTerminated
+      end
+    end
+  end
+end

data/lib/aerospike/query/statement.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2020 Aerospike, Inc.
+# Copyright 2014-2023 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -16,11 +16,14 @@
 
 module Aerospike
 
+  # The Aerospike::Statement class represents a query or scan statement to be executed on the database.
+  # It provides a set of properties that define the query or scan, including namespace, set name, bin names,
+  # index name, filters, and operations.
   class Statement
 
     attr_accessor :namespace, :set_name, :index_name, :bin_names, :task_id
-    attr_accessor :filters, :package_name, :function_name, :function_args
-    attr_accessor :predexp, :return_data
+    attr_accessor :filters, :package_name, :function_name, :function_args, :operations
+    attr_accessor :predexp, :return_data, :records_per_second
 
     def initialize(namespace, set_name, bin_names=[])
       # Namespace determines query Namespace
@@ -56,6 +59,14 @@ module Aerospike
       @package_name  = nil
       @function_name = nil
       @function_args = nil
+      @operations = nil
+
+
+      # Limit returned records per second (rps) rate for each server.
+      # Will not apply rps limit if records_per_second is zero.
+      # Currently only applicable to a query without a defined filter (scan).
+      # Default is 0
+      @records_per_second = 0
 
       # TaskId determines query task id. (Optional)
       @task_id = rand(RAND_MAX)
@@ -64,33 +75,35 @@ module Aerospike
       @return_data = true
     end
 
-  def set_aggregate_function(package_name, function_name, function_args=[], return_data=true)
+    def set_aggregate_function(package_name, function_name, function_args=[], return_data=true)
       @package_name  = package_name
       @function_name = function_name
       @function_args = function_args
       @return_data = return_data
-  end
+    end
 
-  def is_scan?
-    return (filters.nil? || (filters.empty?))
-  end
+    def is_scan?
+      return (filters.nil? || (filters.empty?))
+    end
 
-  def set_task_id
-    while @task_id == 0
-      @task_id = rand(RAND_MAX)
+    def set_task_id
+      while @task_id == 0
+        @task_id = rand(RAND_MAX)
+      end
     end
-  end
 
-  def reset_task_id
-    @task_id = rand(RAND_MAX)
-    while @task_id == 0
+    def reset_task_id
       @task_id = rand(RAND_MAX)
+      while @task_id == 0
+        @task_id = rand(RAND_MAX)
+      end
     end
-  end
 
-  private
 
-  RAND_MAX = 2**63
+
+    private
+
+    RAND_MAX = 2**63 - 1
 
   end # class
 end

data/lib/aerospike/record.rb

@@ -1,4 +1,4 @@
-# Copyright 2014-2020 Aerospike, Inc.
+# Copyright 2014-2023 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -33,6 +33,8 @@ module Aerospike
       @node = node
     end
 
+
+
     def to_s
       "key: `#{key}` bins: `#{bins}` generation: `#{generation}`, ttl: `#{ttl}`"
     end
@@ -41,6 +43,18 @@ module Aerospike
 
     CITRUSLEAF_EPOCH = 1262304000
 
+    # Arguments:
+    #   value: the key to retrieve the value for
+    #
+    # Returns:
+    #   the value of the specified key, or `nil` if `@bins` is `nil`
+    def get_value(value)
+      unless @bins.nil?
+        return @bins[value]
+      end
+      nil
+    end
+
     # Converts an absolute expiration time (in seconds from citrusleaf epoch)
     # to relative time-to-live (TTL) in seconds
     def expiration_to_ttl(secs_from_epoc)

data/lib/aerospike/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Aerospike
-  VERSION = "2.25.0"
+  VERSION = "2.27.0"
 end

data/lib/aerospike.rb

@@ -169,6 +169,7 @@ require "aerospike/query/scan_executor"
 require "aerospike/query/scan_partition_command"
 require "aerospike/query/query_executor"
 require "aerospike/query/query_partition_command"
+require "aerospike/query/server_command"
 
 require "aerospike/exp/exp"
 require "aerospike/exp/exp_map"

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: aerospike
 version: !ruby/object:Gem::Version
-  version: 2.25.0
+  version: 2.27.0
 platform: ruby
 authors:
 - Khosrow Afroozeh
 - Jan Hecking
-autorequire: 
+- Sachin Venkatesha Murthy
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-28 00:00:00.000000000 Z
+date: 2023-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -44,6 +45,7 @@ description: Official Aerospike Client for ruby. Access your Aerospike cluster w
 email:
 - khosrow@aerospike.com
 - jhecking@aerospike.com
+- smurthy@aerospike.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -181,6 +183,7 @@ files:
 - lib/aerospike/query/scan_command.rb
 - lib/aerospike/query/scan_executor.rb
 - lib/aerospike/query/scan_partition_command.rb
+- lib/aerospike/query/server_command.rb
 - lib/aerospike/query/statement.rb
 - lib/aerospike/query/stream_command.rb
 - lib/aerospike/record.rb
@@ -227,8 +230,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: An Aerospike driver for Ruby.
 test_files: []