Class: Aerospike::CDT::MapOperation

Inherits:
Operation
  • Object
show all
Defined in:
lib/aerospike/cdt/map_operation.rb

Overview

Unique key map bin operations. Create map operations used by the client operate command. The default unique key map is unordered.

All maps maintain an index and a rank. The index is the item offset from the start of the map, for both unordered and ordered maps. The rank is the sorted index of the value component. Map supports negative indexing for index and rank.

Index examples:

Index 0: First item in map. Index 4: Fifth item in map. Index -1: Last item in map. Index -3: Third to last item in map. Index 1 Count 2: Second and third items in map. Index -3 Count 3: Last three items in map. Index -5 Count 4: Range between fifth to last item to second to last item inclusive.

Rank examples:

Rank 0: Item with lowest value rank in map. Rank 4: Fifth lowest ranked item in map. Rank -1: Item with highest ranked value in map. Rank -3: Item with third highest ranked value in map. Rank 1 Count 2: Second and third lowest ranked items in map. Rank -3 Count 3: Top three ranked items in map.

Nested CDT operations are supported by optional CTX context arguments. Examples:

bin = key1:{key11:9,key12:4, key2:key21:3,key22:5} Set map value to 11 for map key “key21” inside of map key “key2”. MapOperation.put(“bin”, “key21”, 11, ctx: [Context.map_key(“key2”)]) bin result = key1:{key11:9,key12:4,key2:key21:11,key22:5}

bin : key1:{key11:{key111:1,key12:key121:5}, key2:key21:{“key211”:7}} Set map value to 11 in map key “key121” for highest ranked map (“key12”) inside of map key “key1”. MapOperation.put(“bin”, “key121”, 11, ctx: [Context.map_key(“key1”), Context.map_rank(-1)]) bin result = key1:{key11:{key111:1,key12:key121:11}, key2:key21:{“key211”:7}}

Constant Summary collapse

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

Constants inherited from Operation

Operation::APPEND, Operation::BIT_MODIFY, Operation::BIT_READ, Operation::CDT_MODIFY, Operation::CDT_READ, Operation::DELETE, Operation::EXP_MODIFY, Operation::EXP_READ, Operation::HLL_MODIFY, Operation::HLL_READ, Operation::PREPEND, Operation::READ, Operation::READ_HEADER, Operation::TOUCH, Operation::WRITE

Instance Attribute Summary collapse

Attributes inherited from Operation

#bin_name, #op_type

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Operation

add, append, #bin, delete, get, get_header, prepend, touch

Constructor Details

#initialize(op_type, map_op, bin_name, *arguments, ctx: nil, return_type: nil, flag: nil) ⇒ MapOperation

Returns a new instance of MapOperation.



101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/aerospike/cdt/map_operation.rb', line 101

def initialize(op_type, map_op, bin_name, *arguments, ctx: nil, return_type: nil, flag: nil)
  @op_type = op_type
  @bin_name = bin_name
  @bin_value = nil
  @map_op = map_op
  @ctx = ctx
  @flag = flag
  @arguments = arguments
  @return_type = return_type
  self
end

Instance Attribute Details

#arguments ⇒ Object (readonly)

Returns the value of attribute arguments.



99
100
101
 
# File 'lib/aerospike/cdt/map_operation.rb', line 99

def arguments
  @arguments
end

#ctx ⇒ Object (readonly)

Returns the value of attribute ctx.



99
100
101
 
# File 'lib/aerospike/cdt/map_operation.rb', line 99

def ctx
  @ctx
end

#flag ⇒ Object (readonly)

Returns the value of attribute flag.



99
100
101
 
# File 'lib/aerospike/cdt/map_operation.rb', line 99

def flag
  @flag
end

#map_op ⇒ Object (readonly)

Returns the value of attribute map_op.



99
100
101
 
# File 'lib/aerospike/cdt/map_operation.rb', line 99

def map_op
  @map_op
end

#return_type ⇒ Object (readonly)

Returns the value of attribute return_type.



99
100
101
 
# File 'lib/aerospike/cdt/map_operation.rb', line 99

def return_type
  @return_type
end

Class Method Details

.clear(bin_name, ctx: nil) ⇒ Object

Create map clear operation. Server removes all items in map. Server returns null.



217
218
219
 
# File 'lib/aerospike/cdt/map_operation.rb', line 217

def self.clear(bin_name, ctx: nil)
  MapOperation.new(Operation::CDT_MODIFY, CLEAR, bin_name, ctx: ctx)
end

.create(bin_name, order, persistent_index, ctx: nil) ⇒ Object

Create map create operation. Server creates a map at the given context level.

Parameters:

  • bin_name (String) —

    The bin name.

  • order (Integer) —

    The map order.

  • persist_index (Boolean) —

    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.

  • ctx (String) (defaults to: nil) —

    Optional path to a nested map. If not defined, the top-level map is used.



122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/aerospike/cdt/map_operation.rb', line 122

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.
    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

.decrement(bin_name, key, decr, ctx: nil, policy: MapPolicy::DEFAULT) ⇒ Object

Create map decrement operation. Server decrements values by decr for all items identified by key and returns final result. Valid only for numbers.

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.



210
211
212
 
# File 'lib/aerospike/cdt/map_operation.rb', line 210

def self.decrement(bin_name, key, decr, ctx: nil, policy: MapPolicy::DEFAULT)
  MapOperation.new(Operation::CDT_MODIFY, DECREMENT, bin_name, key, decr, policy.order[:attr], ctx: ctx)
end

.get_by_index(bin_name, index, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by index operation.

Server selects map item identified by index.

Server returns selected data specified by return_type.



588
589
590
 
# File 'lib/aerospike/cdt/map_operation.rb', line 588

def self.get_by_index(bin_name, index, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_INDEX, bin_name, index, ctx: ctx, return_type: return_type)
end

.get_by_index_range(bin_name, index, count = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by index range operation.

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.



600
601
602
603
604
605
606
 
# File 'lib/aerospike/cdt/map_operation.rb', line 600

def self.get_by_index_range(bin_name, index, count = nil, ctx: nil, return_type: MapReturnType::NONE)
  if count
    MapOperation.new(Operation::CDT_READ, GET_BY_INDEX_RANGE, bin_name, index, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_INDEX_RANGE, bin_name, index, ctx: ctx, return_type: return_type)
  end
end

.get_by_key(bin_name, key, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by key operation. Server selects map item identified by key and returns selected data specified by return_type.



452
453
454
 
# File 'lib/aerospike/cdt/map_operation.rb', line 452

def self.get_by_key(bin_name, key, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_KEY, bin_name, key, ctx: ctx, return_type: return_type)
end

.get_by_key_list(bin_name, keys, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by key list operation.

Server selects map items identified by keys.

Server returns selected data specified by return_type.



463
464
465
 
# File 'lib/aerospike/cdt/map_operation.rb', line 463

def self.get_by_key_list(bin_name, keys, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_KEY_LIST, bin_name, keys, ctx: ctx, return_type: return_type)
end

.get_by_key_range(bin_name, key_begin, key_end = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

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.

Server returns selected data specified by return_type.



475
476
477
478
479
480
481
 
# File 'lib/aerospike/cdt/map_operation.rb', line 475

def self.get_by_key_range(bin_name, key_begin, key_end = nil, ctx: nil, return_type: MapReturnType::NONE)
  if key_end
    MapOperation.new(Operation::CDT_READ, GET_BY_KEY_INTERVAL, bin_name, key_begin, key_end, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_KEY_INTERVAL, bin_name, key_begin, ctx: ctx, return_type: return_type)
  end
end

.get_by_key_rel_index_range(bin_name, key, index, count = nil, ctx: nil, return_type: nil) ⇒ Object

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]



510
511
512
513
514
515
516
 
# File 'lib/aerospike/cdt/map_operation.rb', line 510

def self.get_by_key_rel_index_range(bin_name, key, index, count = nil, ctx: nil, return_type: nil)
  if count
    MapOperation.new(Operation::CDT_READ, GET_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, ctx: ctx, return_type: return_type)
  end
end

.get_by_rank(bin_name, rank, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by rank operation.

Server selects map item identified by rank.

Server returns selected data specified by return_type.



614
615
616
 
# File 'lib/aerospike/cdt/map_operation.rb', line 614

def self.get_by_rank(bin_name, rank, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_RANK, bin_name, rank, ctx: ctx, return_type: return_type)
end

.get_by_rank_range(bin_name, rank, count = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by rank range operation.

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.



625
626
627
628
629
630
631
 
# File 'lib/aerospike/cdt/map_operation.rb', line 625

def self.get_by_rank_range(bin_name, rank, count = nil, ctx: nil, return_type: MapReturnType::NONE)
  if count
    MapOperation.new(Operation::CDT_READ, GET_BY_RANK_RANGE, bin_name, rank, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_RANK_RANGE, bin_name, rank, ctx: ctx, return_type: return_type)
  end
end

.get_by_value(bin_name, value, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by value operation.

Server selects map items identified by value.

Server returns selected data specified by return_type.



523
524
525
 
# File 'lib/aerospike/cdt/map_operation.rb', line 523

def self.get_by_value(bin_name, value, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_VALUE, bin_name, value, ctx: ctx, return_type: return_type)
end

.get_by_value_list(bin_name, values, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map get by value list operation.

Server selects map items identified by value list.

Server returns selected data specified by return_type.



533
534
535
 
# File 'lib/aerospike/cdt/map_operation.rb', line 533

def self.get_by_value_list(bin_name, values, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_LIST, bin_name, values, ctx: ctx, return_type: return_type)
end

.get_by_value_range(bin_name, value_begin, value_end = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

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.

Server returns selected data specified by return_type.



545
546
547
548
549
550
551
 
# File 'lib/aerospike/cdt/map_operation.rb', line 545

def self.get_by_value_range(bin_name, value_begin, value_end = nil, ctx: nil, return_type: MapReturnType::NONE)
  if value_end
    MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_INTERVAL, bin_name, value_begin, value_end, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_INTERVAL, bin_name, value_begin, ctx: ctx, return_type: return_type)
  end
end

.get_by_value_rel_rank_range(bin_name, value, rank, count = nil, ctx: nil, return_type: nil) ⇒ Object

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]



574
575
576
577
578
579
580
 
# File 'lib/aerospike/cdt/map_operation.rb', line 574

def self.get_by_value_rel_rank_range(bin_name, value, rank, count = nil, ctx: nil, return_type: nil)
  if count
    MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_READ, GET_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, ctx: ctx, return_type: return_type)
  end
end

.increment(bin_name, key, incr, ctx: nil, policy: MapPolicy::DEFAULT) ⇒ Object

Create map increment operation. Server increments values by incr for all items identified by key and returns final result. Valid only for numbers.

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.



199
200
201
 
# File 'lib/aerospike/cdt/map_operation.rb', line 199

def self.increment(bin_name, key, incr, ctx: nil, policy: MapPolicy::DEFAULT)
  MapOperation.new(Operation::CDT_MODIFY, INCREMENT, bin_name, key, incr, policy.order[:attr], ctx: ctx)
end

.put(bin_name, key, value, ctx: nil, policy: MapPolicy::DEFAULT) ⇒ Object

Create map put operation. 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 flags used when writing items to the map.



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/aerospike/cdt/map_operation.rb', line 154

def self.put(bin_name, key, value, ctx: nil, policy: MapPolicy::DEFAULT)
  if policy.flags == MapWriteFlags::DEFAULT
    case policy.write_mode
    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, ctx: ctx)
    when MapWriteMode::CREATE_ONLY
      MapOperation.new(Operation::CDT_MODIFY, ADD, bin_name, key, value, policy.order[:attr], ctx: ctx)
    else
      MapOperation.new(Operation::CDT_MODIFY, PUT, bin_name, key, value, policy.order[:attr], ctx: ctx)
    end
  else
    MapOperation.new(Operation::CDT_MODIFY, PUT, bin_name, key, value, policy.order[:attr], policy.flags, ctx: ctx)
  end
end

.put_items(bin_name, values, ctx: nil, policy: MapPolicy::DEFAULT) ⇒ Object

Create map put items operation 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 flags used when writing items to the map.



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/aerospike/cdt/map_operation.rb', line 176

def self.put_items(bin_name, values, ctx: nil, policy: MapPolicy::DEFAULT)
  if policy.flags == MapWriteFlags::DEFAULT
    case policy.write_mode
    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, ctx: ctx)
    when MapWriteMode::CREATE_ONLY
      MapOperation.new(Operation::CDT_MODIFY, ADD_ITEMS, bin_name, values, policy.order[:attr], ctx: ctx)
    else
      MapOperation.new(Operation::CDT_MODIFY, PUT_ITEMS, bin_name, values, policy.order[:attr], ctx: ctx)
    end
  else
    MapOperation.new(Operation::CDT_MODIFY, PUT_ITEMS, bin_name, values, policy.order[:attr], policy.flags, ctx: ctx)
  end
end

.remove_by_index(bin_name, index, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

Server removes map item identified by index.

Server returns removed data specified by return_type.



394
395
396
 
# File 'lib/aerospike/cdt/map_operation.rb', line 394

def self.remove_by_index(bin_name, index, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX, bin_name, index, ctx: ctx, return_type: return_type)
end

.remove_by_index_range(bin_name, index, count = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

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.



407
408
409
410
411
412
413
 
# File 'lib/aerospike/cdt/map_operation.rb', line 407

def self.remove_by_index_range(bin_name, index, count = nil, ctx: nil, return_type: MapReturnType::NONE)
  if count
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX_RANGE, bin_name, index, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_INDEX_RANGE, bin_name, index, ctx: ctx, return_type: return_type)
  end
end

.remove_by_key(bin_name, key, ctx: nil, return_type: nil) ⇒ Object

Create map remove operation.

Server removes map item identified by key and returns removed data specified by return_type.



226
227
228
 
# File 'lib/aerospike/cdt/map_operation.rb', line 226

def self.remove_by_key(bin_name, key, ctx: nil, return_type: nil)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY, bin_name, key, ctx: ctx, return_type: return_type)
end

.remove_by_key_list(bin_name, keys, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

Server removes map items identified by keys.

Server returns removed data specified by return_type.



236
237
238
 
# File 'lib/aerospike/cdt/map_operation.rb', line 236

def self.remove_by_key_list(bin_name, keys, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_LIST, bin_name, keys, ctx: ctx, return_type: return_type)
end

.remove_by_key_range(bin_name, key_begin, key_end = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

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.



264
265
266
267
268
269
270
 
# File 'lib/aerospike/cdt/map_operation.rb', line 264

def self.remove_by_key_range(bin_name, key_begin, key_end = nil, ctx: nil, return_type: MapReturnType::NONE)
  if key_end
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_INTERVAL, bin_name, key_begin, key_end, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_INTERVAL, bin_name, key_begin, ctx: ctx, return_type: return_type)
  end
end

.remove_by_key_rel_index_range(bin_name, key, index, count = nil, ctx: nil, return_type: nil) ⇒ Object

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]



298
299
300
301
302
303
304
 
# File 'lib/aerospike/cdt/map_operation.rb', line 298

def self.remove_by_key_rel_index_range(bin_name, key, index, count = nil, ctx: nil, return_type: nil)
  if count
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_KEY_REL_INDEX_RANGE, bin_name, key, index, ctx: ctx, return_type: return_type)
  end
end

.remove_by_rank(bin_name, rank, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

Server removes map item identified by rank.

Server returns removed data specified by return_type.



422
423
424
 
# File 'lib/aerospike/cdt/map_operation.rb', line 422

def self.remove_by_rank(bin_name, rank, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_RANK, bin_name, rank, ctx: ctx, return_type: return_type)
end

.remove_by_rank_range(bin_name, rank, count = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

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.



434
435
436
437
438
439
440
 
# File 'lib/aerospike/cdt/map_operation.rb', line 434

def self.remove_by_rank_range(bin_name, rank, count = nil, ctx: nil, return_type: MapReturnType::NONE)
  if count
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_RANK_RANGE, bin_name, rank, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_RANK_RANGE, bin_name, rank, ctx: ctx, return_type: return_type)
  end
end

.remove_by_value(bin_name, value, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

Server removes map item identified by value.

Server returns removed data specified by return_type.



312
313
314
 
# File 'lib/aerospike/cdt/map_operation.rb', line 312

def self.remove_by_value(bin_name, value, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE, bin_name, value, ctx: ctx, return_type: return_type)
end

.remove_by_value_list(bin_name, values, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

Server removes map items identified by value.

Server returns removed data specified by return_type.



322
323
324
 
# File 'lib/aerospike/cdt/map_operation.rb', line 322

def self.remove_by_value_list(bin_name, values, ctx: nil, return_type: MapReturnType::NONE)
  MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_LIST, bin_name, values, ctx: ctx, return_type: return_type)
end

.remove_by_value_range(bin_name, value_begin, value_end = nil, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

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 returns removed data specified by return_type.



351
352
353
354
355
356
357
 
# File 'lib/aerospike/cdt/map_operation.rb', line 351

def self.remove_by_value_range(bin_name, value_begin, value_end = nil, ctx: nil, return_type: MapReturnType::NONE)
  if value_end
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_INTERVAL, bin_name, value_begin, value_end, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_INTERVAL, bin_name, value_begin, ctx: ctx, return_type: return_type)
  end
end

.remove_by_value_rel_rank_range(bin_name, value, rank, count = nil, ctx: nil, return_type: nil) ⇒ Object

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]



380
381
382
383
384
385
386
 
# File 'lib/aerospike/cdt/map_operation.rb', line 380

def self.remove_by_value_rel_rank_range(bin_name, value, rank, count = nil, ctx: nil, return_type: nil)
  if count
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, count, ctx: ctx, return_type: return_type)
  else
    MapOperation.new(Operation::CDT_MODIFY, REMOVE_BY_VALUE_REL_RANK_RANGE, bin_name, value, rank, ctx: ctx, return_type: return_type)
  end
end

.remove_keys(bin_name, *keys, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

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.



248
249
250
251
252
253
254
 
# File 'lib/aerospike/cdt/map_operation.rb', line 248

def self.remove_keys(bin_name, *keys, ctx: nil, return_type: MapReturnType::NONE)
  if keys.length > 1
    remove_by_key_list(bin_name, keys, ctx: ctx, return_type: return_type)
  else
    remove_by_key(bin_name, keys.first, ctx: ctx, return_type: return_type)
  end
end

.remove_values(bin_name, *values, ctx: nil, return_type: MapReturnType::NONE) ⇒ Object

Create map remove operation.

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.



334
335
336
337
338
339
340
 
# File 'lib/aerospike/cdt/map_operation.rb', line 334

def self.remove_values(bin_name, *values, ctx: nil, return_type: MapReturnType::NONE)
  if values.length > 1
    remove_by_value_list(bin_name, values, ctx: ctx, return_type: return_type)
  else
    remove_by_value(bin_name, values.first, ctx: ctx, return_type: return_type)
  end
end

.set_policy(bin_name, policy, ctx: nil) ⇒ Object

Create set map policy operation. Server sets map policy attributes. Server returns null.

The required map policy attributes can be changed after the map is created.



139
140
141
142
143
144
145
146
 
# File 'lib/aerospike/cdt/map_operation.rb', line 139

def self.set_policy(bin_name, policy, ctx: nil)
  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

.size(bin_name, ctx: nil) ⇒ Object

Create map size operation. Server returns size of map.



445
446
447
 
# File 'lib/aerospike/cdt/map_operation.rb', line 445

def self.size(bin_name, ctx: nil)
  MapOperation.new(Operation::CDT_READ, SIZE, bin_name, ctx: ctx)
end

Instance Method Details

#and_return(return_type) ⇒ Object 



633
634
635
636
637
 
# File 'lib/aerospike/cdt/map_operation.rb', line 633

def and_return(return_type)
  @return_type = return_type
  @bin_value = nil
  self
end

#bin_value ⇒ Object 



639
640
641
 
# File 'lib/aerospike/cdt/map_operation.rb', line 639

def bin_value
  @bin_value ||= pack_bin_value
end