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



203
204
205
 
# File 'lib/aerospike/cdt/map_operation.rb', line 203

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

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

Creates a map create operation. Server creates map at given context level.



116
117
118
119
120
121
122
123
 
# File 'lib/aerospike/cdt/map_operation.rb', line 116

def self.create(bin_name, order, ctx: nil)
  if !ctx || ctx.length == 0
    # If context not defined, the set order for top-level bin map.
    self.set_policy(MapPolicy.new(order: order, flag: 0), bin_name)
  else
    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.



196
197
198
 
# File 'lib/aerospike/cdt/map_operation.rb', line 196

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.



574
575
576
 
# File 'lib/aerospike/cdt/map_operation.rb', line 574

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.



586
587
588
589
590
591
592
 
# File 'lib/aerospike/cdt/map_operation.rb', line 586

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.



438
439
440
 
# File 'lib/aerospike/cdt/map_operation.rb', line 438

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.



449
450
451
 
# File 'lib/aerospike/cdt/map_operation.rb', line 449

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.



461
462
463
464
465
466
467
 
# File 'lib/aerospike/cdt/map_operation.rb', line 461

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]



496
497
498
499
500
501
502
 
# File 'lib/aerospike/cdt/map_operation.rb', line 496

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.



600
601
602
 
# File 'lib/aerospike/cdt/map_operation.rb', line 600

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.



611
612
613
614
615
616
617
 
# File 'lib/aerospike/cdt/map_operation.rb', line 611

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.



509
510
511
 
# File 'lib/aerospike/cdt/map_operation.rb', line 509

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.



519
520
521
 
# File 'lib/aerospike/cdt/map_operation.rb', line 519

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.



531
532
533
534
535
536
537
 
# File 'lib/aerospike/cdt/map_operation.rb', line 531

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]



560
561
562
563
564
565
566
 
# File 'lib/aerospike/cdt/map_operation.rb', line 560

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.



185
186
187
 
# File 'lib/aerospike/cdt/map_operation.rb', line 185

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.



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/aerospike/cdt/map_operation.rb', line 140

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



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/aerospike/cdt/map_operation.rb', line 162

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



380
381
382
 
# File 'lib/aerospike/cdt/map_operation.rb', line 380

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.



393
394
395
396
397
398
399
 
# File 'lib/aerospike/cdt/map_operation.rb', line 393

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.



212
213
214
 
# File 'lib/aerospike/cdt/map_operation.rb', line 212

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.



222
223
224
 
# File 'lib/aerospike/cdt/map_operation.rb', line 222

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.



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

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]



284
285
286
287
288
289
290
 
# File 'lib/aerospike/cdt/map_operation.rb', line 284

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.



408
409
410
 
# File 'lib/aerospike/cdt/map_operation.rb', line 408

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.



420
421
422
423
424
425
426
 
# File 'lib/aerospike/cdt/map_operation.rb', line 420

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.



298
299
300
 
# File 'lib/aerospike/cdt/map_operation.rb', line 298

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.



308
309
310
 
# File 'lib/aerospike/cdt/map_operation.rb', line 308

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.



337
338
339
340
341
342
343
 
# File 'lib/aerospike/cdt/map_operation.rb', line 337

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]



366
367
368
369
370
371
372
 
# File 'lib/aerospike/cdt/map_operation.rb', line 366

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.



234
235
236
237
238
239
240
 
# File 'lib/aerospike/cdt/map_operation.rb', line 234

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.



320
321
322
323
324
325
326
 
# File 'lib/aerospike/cdt/map_operation.rb', line 320

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.



130
131
132
 
# File 'lib/aerospike/cdt/map_operation.rb', line 130

def self.set_policy(bin_name, policy, ctx: nil)
  MapOperation.new(Operation::CDT_MODIFY, SET_TYPE, bin_name, policy.order[:attr], ctx: ctx)
end

.size(bin_name, ctx: nil) ⇒ Object

Create map size operation. Server returns size of map.



431
432
433
 
# File 'lib/aerospike/cdt/map_operation.rb', line 431

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 



619
620
621
622
623
 
# File 'lib/aerospike/cdt/map_operation.rb', line 619

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

#bin_value ⇒ Object 



625
626
627
 
# File 'lib/aerospike/cdt/map_operation.rb', line 625

def bin_value
  @bin_value ||= pack_bin_value
end