aerospike 2.29.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_operation.rb

@@ -110,14 +110,23 @@ module Aerospike
         self
       end
 
-      ##
-      # Creates a map create operation.
-      # Server creates map at given context level.
-      def self.create(bin_name, order, ctx: nil)
-        if !ctx || ctx.length == 0
+      # Create map create operation.
+      # Server creates a map at the given context level.
+      #
+      # @param [String] bin_name The bin name.
+      # @param [Integer] order The map order.
+      # @param [Boolean] persist_index If true, persist map index. A map index improves lookup performance,
+      #   but requires more storage. A map index can be created for a top-level
+      #   ordered map only. Nested and unordered map indexes are not supported.
+      # @param [String] ctx Optional path to a nested map. If not defined, the top-level map is used.
+      def self.create(bin_name, order, persistent_index, ctx: nil)
+        if !ctx || ctx.empty?
           # If context not defined, the set order for top-level bin map.
-          self.set_policy(MapPolicy.new(order: order, flag: 0), bin_name)
+          attr = order[:attr]
+          attr += 0x10 if persistent_index
+          MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, attr, ctx: ctx, flag: order[:flag])
         else
+          # Create nested map. persistIndex does not apply here, so ignore it
           MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, order[:attr], ctx: ctx, flag: order[:flag])
         end
       end
@@ -128,7 +137,12 @@ module Aerospike
       #
       # The required map policy attributes can be changed after the map is created.
       def self.set_policy(bin_name, policy, ctx: nil)
-        MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, policy.order[:attr], ctx: ctx)
+        attr = policy.attributes
+        # Remove persistIndex flag for nested maps.
+        if !ctx.nil? && !ctx.empty? && (attr & 0x10) != 0
+          attr &= ~0x10
+        end
+        MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, attr, ctx: ctx)
       end
 
       ##
@@ -635,7 +649,7 @@ module Aerospike
         args.unshift(return_type) if return_type
 
         Packer.use do |packer|
-          if @ctx != nil && @ctx.length > 0
+          if @ctx != nil && !@ctx.empty?
             packer.write_array_header(3)
             Value.of(0xff).pack(packer)
 
@@ -645,12 +659,12 @@ module Aerospike
             Value.of(@map_op).pack(packer)
           else
             packer.write_raw_short(@map_op)
-            if args.length > 0
+            if !args.empty?
               packer.write_array_header(args.length)
             end
           end
 
-          if args.length > 0
+          if !args.empty?
             args.each do |value|
               Value.of(value).pack(packer)
             end

data/lib/aerospike/cdt/map_policy.rb

@@ -17,10 +17,9 @@
 module Aerospike
   module CDT
     class MapPolicy
-      attr_accessor :order, :write_mode, :flags
-      attr_accessor :item_command, :items_command, :attributes
+      attr_accessor :order, :write_mode, :flags, :item_command, :items_command, :attributes, :persist_index
 
-      def initialize(order: nil, write_mode: nil, flags: nil)
+      def initialize(order: nil, write_mode: nil, persist_index: false, flags: nil)
         if write_mode && flags
           raise ArgumentError, "Use write mode for server versions < 4.3; use write flags for server versions >= 4.3."
         end
@@ -30,6 +29,10 @@ module Aerospike
         @flags = flags || MapWriteFlags::DEFAULT
         @attributes = order ? order[:attr] : 0
 
+        if @persist_index
+          @attributes |= 0x10
+        end
+
         case @write_mode
         when CDT::MapWriteMode::DEFAULT
           @item_command = CDT::MapOperation::PUT

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)
@@ -529,7 +522,7 @@ module Aerospike
     # This method is only supported by Aerospike 3 servers.
     # If the policy is nil, the default relevant policy will be used.
     def execute_udf_on_query(statement, package_name, function_name, function_args = [], options = nil)
-      policy = create_policy(options, QueryPolicy, default_query_policy)
+      policy = create_policy(options, WritePolicy, default_write_policy)
 
       nodes = @cluster.nodes
       if nodes.empty?
@@ -538,14 +531,12 @@ module Aerospike
 
       statement = statement.clone
       statement.set_aggregate_function(package_name, function_name, function_args, false)
-
       # Use a thread per node
       nodes.each do |node|
-        partitions = node.cluster.node_partitions(node, statement.namespace)
         Thread.new do
           Thread.current.abort_on_exception = true
           begin
-            command = QueryCommand.new(node, policy, statement, nil, partitions)
+            command = ServerCommand.new(@cluster, node, policy, statement, true, statement.task_id)
             execute_command(command)
           rescue => e
             Aerospike.logger.error(e)
@@ -568,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)
 
@@ -701,7 +693,6 @@ module Aerospike
     # If the policy is nil, the default relevant policy will be used.
     def query_partitions(partition_filter, statement, options = nil)
       policy = create_policy(options, QueryPolicy, default_query_policy)
-      new_policy = policy.clone
 
       nodes = @cluster.nodes
       if nodes.empty?
@@ -946,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)}" }
@@ -1002,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