aerospike 2.7.0 → 2.8.0

data/lib/aerospike/cdt/list_order.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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
+  module CDT
+    module ListOrder
+
+      ##
+      # List is not ordered. This is the default.
+      UNORDERED = 0
+
+      ##
+      # List is ordered
+      ORDERED = 1
+
+      ##
+      # Default order
+      DEFAULT = UNORDERED
+    end
+  end
+end

data/lib/aerospike/cdt/list_policy.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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
+  module CDT
+    class ListPolicy
+
+      attr_accessor :order, :flags
+
+      def initialize(order: ListOrder::DEFAULT, write_flags: ListWriteFlags::DEFAULT)
+        @order = order
+        @flags = write_flags
+      end
+
+      DEFAULT = ListPolicy.new
+
+    end
+  end
+end

data/lib/aerospike/cdt/list_return_type.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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
+  module CDT
+    module ListReturnType
+
+      ##
+      # Do not return a result.
+      NONE = 0
+
+      ##
+      # Return key index order.
+      # 0 = first key
+      # N = Nth key
+      # -1 = last key
+      INDEX = 1
+
+      ##
+      # Return reverse key order.
+      # 0 = last key
+      # -1 = first key
+      REVERSE_INDEX = 2
+
+      ##
+      # Return value order.
+      # 0 = smalles value
+      # N = Nth smalles value
+      # -1 = largest value
+      RANK = 3
+
+      ##
+      # Return reverse value order.
+      # 0 = largest value
+      # N = Nth largest value
+      # -1 = smallest values
+      REVERSE_RANK = 4
+
+      ##
+      # Return count of items selected.
+      COUNT = 5
+
+      ##
+      # Return value for single key read and value list for range read.
+      VALUE = 7
+
+      ##
+      # :private
+      #
+      # See ListOperation#invert_selection
+      INVERTED = 0x10000
+
+      ##
+      # Default return type: NONE
+      DEFAULT = NONE
+
+    end
+  end
+end

data/lib/aerospike/cdt/list_sort_flags.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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
+  module CDT
+    module ListSortFlags
+
+      ##
+      # Default. Preserve duplicate values when sorting list.
+      DEFAULT = 0
+
+      ##
+      # Drop duplicate values when sorting list.
+      DROP_DUPLICATES = 2
+    end
+  end
+end

data/lib/aerospike/cdt/list_write_flags.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Copyright 2018 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
+  module CDT
+    module ListWriteFlags
+
+      ##
+      # Default. Allow duplicate values and insertion at any index.
+      DEFAULT = 0
+
+      ##
+      # Only add unique values.
+      ADD_UNIQUE = 1
+
+      ##
+      # Enforce list boundaries when inserting. Do not allow values to be
+      # inserted at index outside current list boundaries.
+      INSERT_BOUNED = 2
+
+      ##
+      # Do not raise error if a list item fails due to write flag constraints.
+      NO_FAIL = 4
+
+      ##
+      # Allow other valid list items to be committed if a list item fails due
+      # to write flag constraints.
+      PARTIAL = 8
+    end
+  end
+end

data/lib/aerospike/cdt/map_operation.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2016-2017 Aerospike, Inc.
+# Copyright 2016-2018 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -19,45 +19,50 @@ module Aerospike
 
     class MapOperation < Operation
 
-      SET_TYPE                  = 64
-      ADD                       = 65
-      ADD_ITEMS                 = 66
-      PUT                       = 67
-      PUT_ITEMS                 = 68
-      REPLACE                   = 69
-      REPLACE_ITEMS             = 70
-      INCREMENT                 = 73
-      DECREMENT                 = 74
-      CLEAR                     = 75
-      REMOVE_BY_KEY             = 76
-      REMOVE_BY_INDEX           = 77
-      REMOVE_BY_RANK            = 79
-      REMOVE_BY_KEY_LIST        = 81
-      REMOVE_BY_VALUE           = 82
-      REMOVE_BY_VALUE_LIST      = 83
-      REMOVE_BY_KEY_INTERVAL    = 84
-      REMOVE_BY_INDEX_RANGE     = 85
-      REMOVE_BY_VALUE_INTERVAL  = 86
-      REMOVE_BY_RANK_RANGE      = 87
-      SIZE                      = 96
-      GET_BY_KEY                = 97
-      GET_BY_INDEX              = 98
-      GET_BY_RANK               = 100
-      GET_BY_VALUE              = 102
-      GET_BY_KEY_INTERVAL       = 103
-      GET_BY_INDEX_RANGE        = 104
-      GET_BY_VALUE_INTERVAL     = 105
-      GET_BY_RANK_RANGE         = 106
-
-      attr_reader :map_op, :arguments, :policy, :return_type
-
-      def initialize(op_type, map_op, bin_name, *arguments, policy: nil, return_type: nil)
+      SET_TYPE = 64
+      ADD = 65
+      ADD_ITEMS = 66
+      PUT = 67
+      PUT_ITEMS = 68
+      REPLACE = 69
+      REPLACE_ITEMS = 70
+      INCREMENT = 73
+      DECREMENT = 74
+      CLEAR = 75
+      REMOVE_BY_KEY = 76
+      REMOVE_BY_INDEX = 77
+      REMOVE_BY_RANK = 79
+      REMOVE_BY_KEY_LIST = 81
+      REMOVE_BY_VALUE = 82
+      REMOVE_BY_VALUE_LIST = 83
+      REMOVE_BY_KEY_INTERVAL = 84
+      REMOVE_BY_INDEX_RANGE = 85
+      REMOVE_BY_VALUE_INTERVAL = 86
+      REMOVE_BY_RANK_RANGE = 87
+      REMOVE_BY_KEY_REL_INDEX_RANGE = 88
+      REMOVE_BY_VALUE_REL_RANK_RANGE = 89
+      SIZE = 96
+      GET_BY_KEY = 97
+      GET_BY_INDEX = 98
+      GET_BY_RANK = 100
+      GET_BY_VALUE = 102
+      GET_BY_KEY_INTERVAL = 103
+      GET_BY_INDEX_RANGE = 104
+      GET_BY_VALUE_INTERVAL = 105
+      GET_BY_RANK_RANGE = 106
+      GET_BY_KEY_LIST = 107
+      GET_BY_VALUE_LIST = 108
+      GET_BY_KEY_REL_INDEX_RANGE = 109
+      GET_BY_VALUE_REL_RANK_RANGE = 110
+
+      attr_reader :map_op, :arguments, :return_type
+
+      def initialize(op_type, map_op, bin_name, *arguments, return_type: nil)
         @op_type = op_type
         @bin_name = bin_name
         @bin_value = nil
         @map_op = map_op
         @arguments = arguments
-        @policy = policy
         @return_type = return_type
         self
       end
@@ -68,7 +73,7 @@ module Aerospike
       #
       # The required map policy attributes can be changed after the map is created.
       def self.set_policy(bin_name, policy)
-        MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, policy: policy)
+        MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, policy.order)
       end
 
       ##
@@ -76,16 +81,21 @@ module Aerospike
       # Server writes key/value item to map bin and returns map size.
       #
       # The map policy dictates the type of map to create when it does not exist.
-      # The map policy also specifies the mode used when writing items to the map.
+      # The map policy also specifies the flags used when writing items to the map.
       def self.put(bin_name, key, value, policy: MapPolicy::DEFAULT)
-        cmd =
+        if policy.flags != MapWriteFlags::DEFAULT
+          MapOperation.new(Operation::CDT_MODIFY, PUT, bin_name, key, value, policy.order, policy.flags)
+        else
           case policy.write_mode
-          when MapWriteMode::UPDATE then PUT
-          when MapWriteMode::UPDATE_ONLY then REPLACE
-          when MapWriteMode::CREATE_ONLY then ADD
-          else PUT
+          when MapWriteMode::UPDATE_ONLY
+            # Replace doesn't allow map order because it does not create on non-existing key.
+            MapOperation.new(Operation::CDT_MODIFY, REPLACE, bin_name, key, value)
+          when MapWriteMode::CREATE_ONLY
+            MapOperation.new(Operation::CDT_MODIFY, ADD, bin_name, key, value, policy.order)
+          else
+            MapOperation.new(Operation::CDT_MODIFY, PUT, bin_name, key, value, policy.order)
           end
-        MapOperation.new(Operation::CDT_MODIFY, cmd, bin_name, key, value, policy: policy)
+        end
       end
 
       ##
@@ -93,16 +103,21 @@ module Aerospike
       # Server writes each map item to map bin and returns map size.
       #
       # The map policy dictates the type of map to create when it does not exist.
-      # The map policy also specifies the mode used when writing items to the map.
+      # The map policy also specifies the flags used when writing items to the map.
       def self.put_items(bin_name, values, policy: MapPolicy::DEFAULT)
-        cmd =
+        if policy.flags != MapWriteFlags::DEFAULT
+          MapOperation.new(Operation::CDT_MODIFY, PUT_ITEMS, bin_name, values, policy.order, policy.flags)
+        else
           case policy.write_mode
-          when MapWriteMode::UPDATE then PUT_ITEMS
-          when MapWriteMode::UPDATE_ONLY then REPLACE_ITEMS
-          when MapWriteMode::CREATE_ONLY then ADD_ITEMS
-          else PUT_ITEMS
+          when MapWriteMode::UPDATE_ONLY
+            # Replace doesn't allow map order because it does not create on non-existing key.
+            MapOperation.new(Operation::CDT_MODIFY, REPLACE_ITEMS, bin_name, values)
+          when MapWriteMode::CREATE_ONLY
+            MapOperation.new(Operation::CDT_MODIFY, ADD_ITEMS, bin_name, values, policy.order)
+          else
+            MapOperation.new(Operation::CDT_MODIFY, PUT_ITEMS, bin_name, values, policy.order)
           end
-        MapOperation.new(Operation::CDT_MODIFY, cmd, bin_name, values, policy: policy)
+        end
       end
 
       ##
@@ -113,7 +128,7 @@ module Aerospike
       # The map policy dictates the type of map to create when it does not exist.
       # The map policy also specifies the mode used when writing items to the map.
       def self.increment(bin_name, key, incr, policy: MapPolicy::DEFAULT)
-        MapOperation.new(Operation::CDT_MODIFY, INCREMENT, bin_name, key, incr, policy: policy)
+        MapOperation.new(Operation::CDT_MODIFY, INCREMENT, bin_name, key, incr, policy.order)
       end
 
       ##
@@ -124,7 +139,7 @@ module Aerospike
       # The map policy dictates the type of map to create when it does not exist.
       # The map policy also specifies the mode used when writing items to the map.
       def self.decrement(bin_name, key, decr, policy: MapPolicy::DEFAULT)
-        MapOperation.new(Operation::CDT_MODIFY, DECREMENT, bin_name, key, decr, policy: policy)
+        MapOperation.new(Operation::CDT_MODIFY, DECREMENT, bin_name, key, decr, policy.order)
       end
 
       ##
@@ -136,89 +151,217 @@ module Aerospike
 
       ##
       # Create map remove operation.
-      # Server removes map item identified by key and returns removed data specified by return_type.
+      #
+      # Server removes map item identified by key and returns removed data
+      # specified by return_type.
+      def self.remove_by_key(bin_name, key, return_type: nil)
+        MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY, bin_name, key, return_type: return_type)
+      end
+
+      ##
+      # Create map remove operation.
+      #
+      # Server removes map items identified by keys.
+      #
+      # Server returns removed data specified by return_type.
+      def self.remove_by_key_list(bin_name, keys, return_type: MapReturnType::NONE)
+        MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_LIST, bin_name, keys, return_type: return_type)
+      end
+
+      ##
+      # Create map remove operation.
+      #
+      # Server removes map items identified by keys.
+      #
+      # Server returns removed data specified by return_type.
+      #
+      # Deprecated. Use remove_by_key / remove_by_key_list instead.
       def self.remove_keys(bin_name, *keys, return_type: MapReturnType::NONE)
         if keys.length > 1
-          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_LIST, bin_name, keys, return_type: return_type)
+          remove_by_key_list(bin_name, keys, return_type: return_type)
         else
-          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY, bin_name, keys.first, return_type: return_type)
+          remove_by_key(bin_name, keys.first, return_type: return_type)
         end
       end
 
       ##
       # Create map remove operation.
+      #
       # Server removes map items identified by key range (key_begin inclusive, key_end exclusive).
       # If key_begin is null, the range is less than key_end.
       # If key_end is null, the range is greater than equal to key_begin.
       #
       # Server returns removed data specified by return_type.
-      def self.remove_key_range(bin_name, key_begin, key_end = nil, return_type: MapReturnType::NONE)
+      def self.remove_by_key_range(bin_name, key_begin, key_end = nil, return_type: MapReturnType::NONE)
         if key_end
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_INTERVAL, bin_name, key_begin, key_end, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_INTERVAL, bin_name, key_begin, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :remove_key_range, :remove_by_key_range)
+
+      ##
+      # Create map remove by key relative to index range operation.
+      #
+      # Server removes map items nearest to key and greater by relative index,
+      # with a count limit.
+      #
+      # Server returns removed data specified by return_type.
+      #
+      # Examples for map [{0=17},{4=2},{5=15},{9=10}]:
+      #
+      # * (value, index, count) = [removed items]
+      # * (5, 0, 1) = [{5=15}]
+      # * (5, 1, 2) = [{9=10}]
+      # * (5, -1, 1) = [{4=2}]
+      # * (3, 2, 1) = [{9=10}]
+      # * (3, -2, 2) = [{0=17}]
+      #
+      # Without count:
+      #
+      # * (value, index) = [removed items]
+      # * (5, 0) = [{5=15}, {9=10}]
+      # * (5, 1) = [{9=10}]
+      # * (5, -1) = [{4=2}, {5=15}, {9=10}]
+      # * (3, 2) = [{9=10}]
+      # * (3, -2) = [{0=17}, {4=2}, {5=15}, {9=10}]
+      def self.remove_by_key_rel_index_range(bin_name, key, index, count = nil, return_type: nil)
+        if count
+          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, count, return_type: return_type)
+        else
+          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, return_type: return_type)
+        end
+      end
+
+      ##
+      # Create map remove operation.
+      #
+      # Server removes map item identified by value.
+      #
+      # Server returns removed data specified by return_type.
+      def self.remove_by_value(bin_name, value, return_type: MapReturnType::NONE)
+        MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE, bin_name, value, return_type: return_type)
+      end
+
+      ##
+      # Create map remove operation.
+      #
+      # Server removes map items identified by value.
+      #
+      # Server returns removed data specified by return_type.
+      def self.remove_by_value_list(bin_name, values, return_type: MapReturnType::NONE)
+        MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_LIST, bin_name, values, return_type: return_type)
+      end
 
       ##
       # Create map remove operation.
-      # Server removes map items identified by value and returns removed data specified by return_type.
+      #
+      # Server removes map items identified by value.
+      #
+      # Server returns removed data specified by return_type.
+      #
+      # Deprecated. Use remove_by_value / remove_by_value_list instead.
       def self.remove_values(bin_name, *values, return_type: MapReturnType::NONE)
         if values.length > 1
-          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_LIST, bin_name, values, return_type: return_type)
+          remove_by_value_list(bin_name, values, return_type: return_type)
         else
-          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE, bin_name, values.first, return_type: return_type)
+          remove_by_value(bin_name, values.first, return_type: return_type)
         end
       end
 
       ##
       # Create map remove operation.
-      # Server removes map items identified by value range (value_begin inclusive, value_end exclusive).
-      # If value_begin is null, the range is less than value_end.
-      # If value_end is null, the range is greater than equal to value_begin.
+      #
+      # Server removes map items identified by value range (value_begin
+      # inclusive, value_end exclusive). If value_begin is null, the range is
+      # less than value_end. If value_end is null, the range is greater than
+      # equal to value_begin.
       #
       # Server returns removed data specified by return_type.
-      def self.remove_value_range(bin_name, value_begin, value_end = nil, return_type: MapReturnType::NONE)
+      def self.remove_by_value_range(bin_name, value_begin, value_end = nil, return_type: MapReturnType::NONE)
         if value_end
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_INTERVAL, bin_name, value_begin, value_end, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_INTERVAL, bin_name, value_begin, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :remove_value_range, :remove_by_value_range)
+
+      ##
+      # Create map remove by value relative to rank range operation.
+      #
+      # Server removes "count" map items nearest to value and greater by relative rank.
+      # If "count" is not specified, server removes map items nearest to value
+      # and greater by relative rank, until the end of the map.
+      #
+      # Server returns removed data specified by return_type.
+      #
+      # Examples for map [{4=2},{9=10},{5=15},{0=17}]:
+      #
+      # * (value, rank, count) = [removed items]
+      # * (11, 1, 1) = [{0=17}]
+      # * (11, -1, 1) = [{9=10}]
+      #
+      # Without count:
+      #
+      # * (value, rank) = [removed items]
+      # * (11, 1) = [{0=17}]
+      # * (11, -1) = [{9=10}, {5=15}, {0=17}]
+      def self.remove_by_value_rel_rank_range(bin_name, value, rank, count = nil, return_type: nil)
+        if count
+          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, count, return_type: return_type)
+        else
+          MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, return_type: return_type)
+        end
+      end
 
       ##
       # Create map remove operation.
-      # Server removes map item identified by index and returns removed data specified by return_type.
-      def self.remove_index(bin_name, index, return_type: MapReturnType::NONE)
+      #
+      # Server removes map item identified by index.
+      #
+      # Server returns removed data specified by return_type.
+      def self.remove_by_index(bin_name, index, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX, bin_name, index, return_type: return_type)
       end
+      singleton_class.send(:alias_method, :remove_index, :remove_by_index)
 
       ##
       # Create map remove operation.
-      # Server removes "count" map items starting at specified index and
-      # returns removed data specified by return_type. If "count" is not
-      # specified, the server selects map items starting at specified index to
-      # the end of map.
-      def self.remove_index_range(bin_name, index, count = nil, return_type: MapReturnType::NONE)
+      #
+      # Server removes "count" map items starting at specified index. If
+      # "count" is not specified, the server selects map items starting at
+      # specified index to the end of map.
+      #
+      # Server returns removed data specified by return_type.
+      def self.remove_by_index_range(bin_name, index, count = nil, return_type: MapReturnType::NONE)
         if count
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX_RANGE, bin_name, index, count, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX_RANGE, bin_name, index, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :remove_index_range, :remove_by_index_range)
 
       ##
       # Create map remove operation.
-      # Server removes map item identified by rank and returns removed data specified by return_type.
+      #
+      # Server removes map item identified by rank.
+      #
+      # Server returns removed data specified by return_type.
       def self.remove_by_rank(bin_name, rank, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_RANK, bin_name, rank, return_type: return_type)
       end
 
       ##
       # Create map remove operation.
-      # Server selects "count" map items starting at specified rank and returns
-      # selected data specified by return_type. If "count" is not specified,
-      # server removes map items starting at specified rank to the last ranked.
+      #
+      # Server selects "count" map items starting at specified rank. If "count"
+      # is not specified, server removes map items starting at specified rank
+      # to the last ranked.
+      #
+      # Server returns removed data specified by return_type.
       def self.remove_by_rank_range(bin_name, rank, count = nil, return_type: MapReturnType::NONE)
         if count
           MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_RANK_RANGE, bin_name, rank, count, return_type: return_type)
@@ -237,75 +380,179 @@ module Aerospike
       ##
       # Create map get by key operation.
       # Server selects map item identified by key and returns selected data specified by return_type.
-      def self.get_key(bin_name, key, return_type: MapReturnType::NONE)
+      def self.get_by_key(bin_name, key, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_READ, GET_BY_KEY, bin_name, key, return_type: return_type)
       end
+      singleton_class.send(:alias_method, :get_key, :get_by_key)
+
+      ##
+      # Create map get by key list operation.
+      #
+      # Server selects map items identified by keys.
+      #
+      # Server returns selected data specified by return_type.
+      def self.get_by_key_list(bin_name, keys, return_type: MapReturnType::NONE)
+        MapOperation.new(Operation::CDT_READ, GET_BY_KEY_LIST, bin_name, keys, return_type: return_type)
+      end
 
       # Create map get by key range operation.
-      # Server selects map items identified by key range (key_begin inclusive, key_end exclusive).
-      # If key_begin is null, the range is less than key_end.
-      # If key_end is null, the range is greater than equal to key_begin.
-      # <p>
+      #
+      # Server selects map items identified by key range (key_begin inclusive,
+      # key_end exclusive). If key_begin is null, the range is less than
+      # key_end. If key_end is null, the range is greater than equal to
+      # key_begin.
+      #
       # Server returns selected data specified by return_type.
-      def self.get_key_range(bin_name, key_begin, key_end = nil, return_type: MapReturnType::NONE)
+      def self.get_by_key_range(bin_name, key_begin, key_end = nil, return_type: MapReturnType::NONE)
         if key_end
           MapOperation.new(Operation::CDT_READ, GET_BY_KEY_INTERVAL, bin_name, key_begin, key_end, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_READ, GET_BY_KEY_INTERVAL, bin_name, key_begin, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :get_key_range, :get_by_key_range)
+
+      ##
+      # Create map get by key relative to index range operation.
+      #
+      # Server selects "count" map items nearest to key and greater by relative
+      # index. If "count" is not specified, server selects map items nearest to
+      # key and greater by relative index, until the end of the map.
+      #
+      # Server returns selected data specified by return_type.
+      #
+      # Examples for map [{0=17},{4=2},{5=15},{9=10}]:
+      #
+      # * (value, index, count) = [selected items]
+      # * (5, 0, 1) = [{5=15}]
+      # * (5, 1, 2) = [{9=10}]
+      # * (5, -1, 1) = [{4=2}]
+      # * (3, 2, 1) = [{9=10}]
+      # * (3, -2, 2) = [{0=17}]
+      #
+      # Without count:
+      #
+      # * (value, index) = [selected items]
+      # * (5, 0) = [{5=15}, {9=10}]
+      # * (5, 1) = [{9=10}]
+      # * (5, -1) = [{4=2}, {5=15}, {9=10}]
+      # * (3, 2) = [{9=10}]
+      # * (3, -2) = [{0=17}, {4=2}, {5=15}, {9=10}]
+      def self.get_by_key_rel_index_range(bin_name, key, index, count = nil, return_type: nil)
+        if count
+          MapOperation.new(Operation::CDT_READ, GET_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, count, return_type: return_type)
+        else
+          MapOperation.new(Operation::CDT_READ, GET_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, return_type: return_type)
+        end
+      end
 
       # Create map get by value operation.
-      # Server selects map items identified by value and returns selected data specified by return_type.
-      def self.get_value(bin_name, value, return_type: MapReturnType::NONE)
+      #
+      # Server selects map items identified by value.
+      #
+      # Server returns selected data specified by return_type.
+      def self.get_by_value(bin_name, value, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_READ, GET_BY_VALUE, bin_name, value, return_type: return_type)
       end
+      singleton_class.send(:alias_method, :get_value, :get_by_value)
+
+      # Create map get by value list operation.
+      #
+      # Server selects map items identified by value list.
+      #
+      # Server returns selected data specified by return_type.
+      def self.get_by_value_list(bin_name, values, return_type: MapReturnType::NONE)
+        MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_LIST, bin_name, values, return_type: return_type)
+      end
 
       # Create map get by value range operation.
-      # Server selects map items identified by value range (value_begin inclusive, value_end exclusive)
-      # If value_begin is null, the range is less than value_end.
-      # If value_end is null, the range is greater than equal to value_begin.
-      # <p>
+      #
+      # Server selects map items identified by value range (value_begin
+      # inclusive, value_end exclusive). If value_begin is null, the range is
+      # less than value_end. If value_end is null, the range is greater than
+      # equal to value_begin.
+      #
       # Server returns selected data specified by return_type.
-      def self.get_value_range(bin_name, value_begin, value_end = nil, return_type: MapReturnType::NONE)
+      def self.get_by_value_range(bin_name, value_begin, value_end = nil, return_type: MapReturnType::NONE)
         if value_end
           MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_INTERVAL, bin_name, value_begin, value_end, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_INTERVAL, bin_name, value_begin, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :get_value_range, :get_by_value_range)
+
+      ##
+      # Create map get by value relative to rank range operation.
+      #
+      # Server selects "count" map items nearest to value and greater by relative rank.
+      # If "count" is not specified, server selects map items nearest to value
+      # and greater by relative rank, until the end of the map.
+      #
+      # Server returns selected data specified by return_type.
+      #
+      # Examples for map [{4=2},{9=10},{5=15},{0=17}]:
+      #
+      # * (value, rank, count) = [selected items]
+      # * (11, 1, 1) = [{0=17}]
+      # * (11, -1, 1) = [{9=10}]
+      #
+      # Without count:
+      #
+      # * (value, rank) = [selected items]
+      # * (11, 1) = [{0=17}]
+      # * (11, -1) = [{9=10}, {5=15}, {0=17}]
+      def self.get_by_value_rel_rank_range(bin_name, value, rank, count = nil, return_type: nil)
+        if count
+          MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, count, return_type: return_type)
+        else
+          MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, return_type: return_type)
+        end
+      end
+
 
       # Create map get by index operation.
-      # Server selects map item identified by index and returns selected data specified by return_type.
-      def self.get_index(bin_name, index, return_type: MapReturnType::NONE)
+      #
+      # Server selects map item identified by index.
+      #
+      # Server returns selected data specified by return_type.
+      def self.get_by_index(bin_name, index, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_READ, GET_BY_INDEX, bin_name, index, return_type: return_type)
       end
+      singleton_class.send(:alias_method, :get_index, :get_by_index)
 
       # Create map get by index range operation.
-      # Server selects "count" map items starting at specified index and
-      # returns selected data specified by return_type.  If "count" is not
-      # specified, server selects map items starting at specified index to the
-      # end of map.
-      def self.get_index_range(bin_name, index, count = nil, return_type: MapReturnType::NONE)
+      #
+      # Server selects "count" map items starting at specified index. If
+      # "count" is not specified, server selects map items starting at
+      # specified index to the end of map.
+      #
+      # Server returns selected data specified by return_type.
+      def self.get_by_index_range(bin_name, index, count = nil, return_type: MapReturnType::NONE)
         if count
           MapOperation.new(Operation::CDT_READ, GET_BY_INDEX_RANGE, bin_name, index, count, return_type: return_type)
         else
           MapOperation.new(Operation::CDT_READ, GET_BY_INDEX_RANGE, bin_name, index, return_type: return_type)
         end
       end
+      singleton_class.send(:alias_method, :get_index_range, :get_by_index_range)
 
       # Create map get by rank operation.
-      # Server selects map item identified by rank and returns selected data
-      # specified by return_type.
+      #
+      # Server selects map item identified by rank.
+      #
+      # Server returns selected data specified by return_type.
       def self.get_by_rank(bin_name, rank, return_type: MapReturnType::NONE)
         MapOperation.new(Operation::CDT_READ, GET_BY_RANK, bin_name, rank, return_type: return_type)
       end
 
       # Create map get by rank range operation.
-      # Server selects "count" map items starting at specified rank and returns
-      # selected data specified by returnType.  If "count" is not specified,
-      # server selects map items starting at specified rank to the last ranked
-      # item.
+      #
+      # Server selects "count" map items starting at specified rank. If "count"
+      # is not specified, server selects map items starting at specified rank
+      # to the last ranked item.
+      #
+      # Server returns selected data specified by return_type.
       def self.get_by_rank_range(bin_name, rank, count = nil, return_type: MapReturnType::NONE)
         if count
           MapOperation.new(Operation::CDT_READ, GET_BY_RANK_RANGE, bin_name, rank, count, return_type: return_type)
@@ -332,9 +579,6 @@ module Aerospike
           packer.write_raw_short(map_op)
           args = arguments.dup
           args.unshift(return_type) if return_type
-          if policy && policy.write_mode != MapWriteMode::UPDATE_ONLY
-            args << policy.value
-          end
           if args.length > 0
             packer.write_array_header(args.length)
             args.each do |value|