aerospike 2.24.0 → 2.26.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -17,8 +17,26 @@
17
17
  module Aerospike
18
18
  class Exp
19
19
 
20
+ # Regex bit flags
21
+ module RegexFlags
22
+ # Regex defaults
23
+ NONE = 0
24
+
25
+ # Use POSIX Extended Regular Expression syntax when interpreting regex.
26
+ EXTENDED = 1
27
+
28
+ # Do not differentiate case.
29
+ ICASE = 2
30
+
31
+ # Do not report position of matches.
32
+ NOSUB = 4
33
+
34
+ # Match-any-character operators don't match a newline.
35
+ NEWLINE = 8
36
+ end
37
+
20
38
  # Expression type.
21
- module Type
39
+ module Type #:nodoc:
22
40
  NIL = 0
23
41
  BOOL = 1
24
42
  INT = 2
@@ -31,6 +49,7 @@ module Aerospike
31
49
  HLL = 9
32
50
  end # module type
33
51
 
52
+ # Expression write flags.
34
53
  module WriteFlags
35
54
  # Default. Allow create or update.
36
55
  DEFAULT = 0
@@ -58,6 +77,7 @@ module Aerospike
58
77
  EVAL_NO_FAIL = 16
59
78
  end # module WriteFlags
60
79
 
80
+ # Expression write flags.
61
81
  module ReadFlags
62
82
  # Default.
63
83
  DEFAULT = 0
@@ -70,13 +90,13 @@ module Aerospike
70
90
  #
71
91
  # ==== Examples
72
92
  # # Integer record key >= 100000
73
- # Exp.ge(Exp.key(Type::INT), Exp.val(100000))
93
+ # Exp.ge(Exp.key(Type::INT), Exp.int_val(100000))
74
94
  def self.key(type)
75
- new CmdInt.new(KEY, type)
95
+ CmdInt.new(KEY, type)
76
96
  end
77
97
 
78
98
  # Create expression that returns if the primary key is stored in the record meta data
79
- # as a boolean expression. This would occur when {@link com.aerospike.client.policy.Policy#sendKey}
99
+ # as a boolean expression. This would occur when {@link Policy#send_key}
80
100
  # is true on record write. This expression usually evaluates quickly because record
81
101
  # meta data is cached in memory.
82
102
  #
@@ -84,7 +104,7 @@ module Aerospike
84
104
  # # Key exists in record meta data
85
105
  # Exp.key_exists
86
106
  def self.key_exists
87
- new Cmd.new(KEY_EXISTS)
107
+ Cmd.new(KEY_EXISTS)
88
108
  end
89
109
 
90
110
  #--------------------------------------------------
@@ -94,85 +114,85 @@ module Aerospike
94
114
  # Create bin expression of specified type.
95
115
  #
96
116
  # ==== Examples
97
- # # String bin "a" == "views"
98
- # Exp.eq(Exp.bin("a", Type::STRING), Exp.val("views"))
117
+ # # String bin "a" == "views"
118
+ # Exp.eq(Exp.bin("a", Type::STRING), Exp.str_val("views"))
99
119
  def self.bin(name, type)
100
- new Bin.new(name, type)
120
+ Bin.new(name, type)
101
121
  end
102
122
 
103
123
  # Create 64 bit integer bin expression.
104
124
  #
105
125
  # ==== Examples
106
- # # Integer bin "a" == 200
107
- # Exp.eq(Exp.int_bin("a"), Exp.val(200))
126
+ # # Integer bin "a" == 200
127
+ # Exp.eq(Exp.int_bin("a"), Exp.val(200))
108
128
  def self.int_bin(name)
109
- new Bin.new(name, Type::INT)
129
+ Bin.new(name, Type::INT)
110
130
  end
111
131
 
112
132
  # Create 64 bit float bin expression.
113
133
  #
114
134
  # ==== Examples
115
- # # Float bin "a" >= 1.5
116
- # Exp.ge(Exp.float_bin("a"), Exp.val(1.5))
135
+ # # Float bin "a" >= 1.5
136
+ # Exp.ge(Exp.float_bin("a"), Exp.int_val(1.5))
117
137
  def self.float_bin(name)
118
- new Bin.new(name, Type::FLOAT)
138
+ Bin.new(name, Type::FLOAT)
119
139
  end
120
140
 
121
141
  # Create string bin expression.
122
142
  #
123
143
  # ==== Examples
124
- # # String bin "a" == "views"
125
- # Exp.eq(Exp.string_bin("a"), Exp.val("views"))
126
- def self.string_bin(name)
127
- new Bin.new(name, Type::STRING)
144
+ # # String bin "a" == "views"
145
+ # Exp.eq(Exp.str_bin("a"), Exp.str_val("views"))
146
+ def self.str_bin(name)
147
+ Bin.new(name, Type::STRING)
128
148
  end
129
149
 
130
150
  # Create boolean bin expression.
131
151
  #
132
152
  # ==== Examples
133
- # # Boolean bin "a" == true
134
- # Exp.eq(Exp.bool_bin("a"), Exp.val(true))
153
+ # # Boolean bin "a" == true
154
+ # Exp.eq(Exp.bool_bin("a"), Exp.val(true))
135
155
  def self.bool_bin(name)
136
- new Bin.new(name, Type::BOOL)
156
+ Bin.new(name, Type::BOOL)
137
157
  end
138
158
 
139
159
  # Create bin expression.
140
160
  #
141
161
  # ==== Examples
142
- # # Blob bin "a" == [1,2,3]
143
- # Exp.eq(Exp.blob_bin("a"), Exp.val(new {1, 2, 3}))
162
+ # # Blob bin "a" == [1,2,3]
163
+ # Exp.eq(Exp.blob_bin("a"), Exp.val(new {1, 2, 3}))
144
164
  def self.blob_bin(name)
145
- new Bin.new(name, Type::BLOB)
165
+ Bin.new(name, Type::BLOB)
146
166
  end
147
167
 
148
168
  # Create geospatial bin expression.
149
169
  #
150
170
  # ==== Examples
151
- # # Geo bin "a" == region
152
- # String region = "{ \"type\": \"AeroCircle\", \"coordinates\": [[-122.0, 37.5], 50000.0] }"
153
- # Exp.geo_compare(Exp.geo_bin("loc"), Exp.geo(region))
171
+ # # Geo bin "a" == region
172
+ # String region = "{ \"type\": \"AeroCircle\", \"coordinates\": [[-122.0, 37.5], 50000.0] }"
173
+ # Exp.geo_compare(Exp.geo_bin("loc"), Exp.geo(region))
154
174
  def self.geo_bin(name)
155
- new Bin.new(name, Type::GEO)
175
+ Bin.new(name, Type::GEO)
156
176
  end
157
177
 
158
178
  # Create list bin expression.
159
179
  #
160
180
  # ==== Examples
161
- # # Bin a[2] == 3
162
- # Exp.eq(ListExp.get_by_index(ListReturnType::VALUE, Type::INT, Exp.val(2), Exp.list_bin("a")), Exp.val(3))
181
+ # # Bin a[2] == 3
182
+ # Exp.eq(ListExp.get_by_index(ListReturnType::VALUE, Type::INT, Exp.val(2), Exp.list_bin("a")), Exp.val(3))
163
183
  def self.list_bin(name)
164
- new Bin.new(name, Type::LIST)
184
+ Bin.new(name, Type::LIST)
165
185
  end
166
186
 
167
187
  # Create map bin expression.
168
188
  #
169
189
  # ==== Examples
170
- # # Bin a["key"] == "value"
171
- # Exp.eq(
172
- # MapExp.get_by_key(MapReturnType::VALUE, Type::STRING, Exp.val("key"), Exp.map_bin("a")),
173
- # Exp.val("value"))
190
+ # # Bin a["key"] == "value"
191
+ # Exp.eq(
192
+ # MapExp.get_by_key(MapReturnType::VALUE, Type::STRING, Exp.str_val("key"), Exp.map_bin("a")),
193
+ # Exp.str_val("value"))
174
194
  def self.map_bin(name)
175
- new Bin.new(name, Type::MAP)
195
+ Bin.new(name, Type::MAP)
176
196
  end
177
197
 
178
198
  # Create hll bin expression.
@@ -181,26 +201,26 @@ module Aerospike
181
201
  # # HLL bin "a" count > 7
182
202
  # Exp.gt(HLLExp.get_count(Exp.hll_bin("a")), Exp.val(7))
183
203
  def self.hll_bin(name)
184
- new Bin.new(name, Type::HLL)
204
+ Bin.new(name, Type::HLL)
185
205
  end
186
206
 
187
207
  # Create expression that returns if bin of specified name exists.
188
208
  #
189
209
  # ==== Examples
190
- # # Bin "a" exists in record
191
- # Exp.bin_exists("a")
210
+ # # Bin "a" exists in record
211
+ # Exp.bin_exists("a")
192
212
  def self.bin_exists(name)
193
- return Exp.ne(Exp.bin_type(name), Exp.val(0))
213
+ return Exp.ne(Exp.bin_type(name), Exp.int_val(0))
194
214
  end
195
215
 
196
216
  # Create expression that returns bin's integer particle type::
197
- # See {@link com.aerospike.client.command.ParticleType}.
217
+ # See {@link ParticleType}.
198
218
  #
199
219
  # ==== Examples
200
- # # Bin "a" particle type is a list
201
- # Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))
220
+ # # Bin "a" particle type is a list
221
+ # Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))
202
222
  def self.bin_type(name)
203
- new CmdStr.new(BIN_TYPE, name)
223
+ CmdStr.new(BIN_TYPE, name)
204
224
  end
205
225
 
206
226
  #--------------------------------------------------
@@ -211,10 +231,10 @@ module Aerospike
211
231
  # evaluates quickly because record meta data is cached in memory.
212
232
  #
213
233
  # ==== Examples
214
- # # Record set name == "myset"
215
- # Exp.eq(Exp.set_name, Exp.val("myset"))
234
+ # # Record set name == "myset"
235
+ # Exp.eq(Exp.set_name, Exp.str_val("myset"))
216
236
  def self.set_name
217
- new Cmd.new(SET_NAME)
237
+ Cmd.new(SET_NAME)
218
238
  end
219
239
 
220
240
  # Create expression that returns record size on disk. If server storage-engine is
@@ -222,23 +242,23 @@ module Aerospike
222
242
  # record meta data is cached in memory.
223
243
  #
224
244
  # ==== Examples
225
- # # Record device size >= 100 KB
226
- # Exp.ge(Exp.device_size, Exp.val(100 * 1024))
245
+ # # Record device size >= 100 KB
246
+ # Exp.ge(Exp.device_size, Exp.int_val(100 * 1024))
227
247
  def self.device_size
228
- new Cmd.new(DEVICE_SIZE)
248
+ Cmd.new(DEVICE_SIZE)
229
249
  end
230
250
 
231
251
  # Create expression that returns record size in memory. If server storage-engine is
232
252
  # not memory nor data-in-memory, then zero is returned. This expression usually evaluates
233
253
  # quickly because record meta data is cached in memory.
234
- # <p>
254
+ #
235
255
  # Requires server version 5.3.0+
236
256
  #
237
257
  # ==== Examples
238
- # # Record memory size >= 100 KB
239
- # Exp.ge(Exp.memory_size, Exp.val(100 * 1024))
258
+ # # Record memory size >= 100 KB
259
+ # Exp.ge(Exp.memory_size, Exp.int_val(100 * 1024))
240
260
  def self.memory_size
241
- new Cmd.new(MEMORY_SIZE)
261
+ Cmd.new(MEMORY_SIZE)
242
262
  end
243
263
 
244
264
  # Create expression that returns record last update time expressed as 64 bit integer
@@ -246,20 +266,20 @@ module Aerospike
246
266
  # record meta data is cached in memory.
247
267
  #
248
268
  # ==== Examples
249
- # # Record last update time >= 2020-01-15
250
- # Exp.ge(Exp.last_update, Exp.val(new GregorianCalendar(2020, 0, 15)))
269
+ # # Record last update time >= 2020-01-15
270
+ # Exp.ge(Exp.last_update, Exp.val(new GregorianCalendar(2020, 0, 15)))
251
271
  def self.last_update
252
- new Cmd.new(LAST_UPDATE)
272
+ Cmd.new(LAST_UPDATE)
253
273
  end
254
274
 
255
275
  # Create expression that returns milliseconds since the record was last updated.
256
276
  # This expression usually evaluates quickly because record meta data is cached in memory.
257
277
  #
258
278
  # ==== Examples
259
- # # Record last updated more than 2 hours ago
260
- # Exp.gt(Exp.since_update, Exp.val(2 * 60 * 60 * 1000))
279
+ # # Record last updated more than 2 hours ago
280
+ # Exp.gt(Exp.since_update, Exp.val(2 * 60 * 60 * 1000))
261
281
  def self.since_update
262
- new Cmd.new(SINCE_UPDATE)
282
+ Cmd.new(SINCE_UPDATE)
263
283
  end
264
284
 
265
285
  # Create expression that returns record expiration time expressed as 64 bit integer
@@ -267,42 +287,42 @@ module Aerospike
267
287
  # record meta data is cached in memory.
268
288
  #
269
289
  # ==== Examples
270
- # # Record expires on 2021-01-01
271
- # Exp.and(
272
- # Exp.ge(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 1))),
273
- # Exp.lt(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 2))))
290
+ # # Record expires on 2021-01-01
291
+ # Exp.and(
292
+ # Exp.ge(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 1))),
293
+ # Exp.lt(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 2))))
274
294
  def self.void_time
275
- new Cmd.new(VOID_TIME)
295
+ Cmd.new(VOID_TIME)
276
296
  end
277
297
 
278
298
  # Create expression that returns record expiration time (time to live) in integer seconds.
279
299
  # This expression usually evaluates quickly because record meta data is cached in memory.
280
300
  #
281
301
  # ==== Examples
282
- # # Record expires in less than 1 hour
283
- # Exp.lt(Exp.ttl, Exp.val(60 * 60))
302
+ # # Record expires in less than 1 hour
303
+ # Exp.lt(Exp.ttl, Exp.val(60 * 60))
284
304
  def self.ttl
285
- new Cmd.new(TTL)
305
+ Cmd.new(TTL)
286
306
  end
287
307
 
288
308
  # Create expression that returns if record has been deleted and is still in tombstone state.
289
309
  # This expression usually evaluates quickly because record meta data is cached in memory.
290
310
  #
291
311
  # ==== Examples
292
- # # Deleted records that are in tombstone state.
293
- # Exp.is_tombstone
312
+ # # Deleted records that are in tombstone state.
313
+ # Exp.is_tombstone
294
314
  def self.is_tombstone
295
- new Cmd.new(IS_TOMBSTONE)
315
+ Cmd.new(IS_TOMBSTONE)
296
316
  end
297
317
 
298
318
  # Create expression that returns record digest modulo as integer. This expression usually
299
319
  # evaluates quickly because record meta data is cached in memory.
300
320
  #
301
321
  # ==== Examples
302
- # # Records that have digest(key) % 3 == 1
303
- # Exp.eq(Exp.digest_modulo(3), Exp.val(1))
322
+ # # Records that have digest(key) % 3 == 1
323
+ # Exp.eq(Exp.digest_modulo(3), Exp.int_val(1))
304
324
  def self.digest_modulo(mod)
305
- new CmdInt.new(DIGEST_MODULO, mod)
325
+ CmdInt.new(DIGEST_MODULO, mod)
306
326
  end
307
327
 
308
328
  # Create expression that performs a regex match on a string bin or string value expression.
@@ -310,13 +330,13 @@ module Aerospike
310
330
  # ==== Examples
311
331
  # # Select string bin "a" that starts with "prefix" and ends with "suffix".
312
332
  # # Ignore case and do not match newline.
313
- # Exp.regex_compare("prefix.*suffix", RegexFlag.ICASE | RegexFlag.NEWLINE, Exp.string_bin("a"))
333
+ # Exp.regex_compare("prefix.*suffix", RegexFlags.ICASE | RegexFlags.NEWLINE, Exp.str_bin("a"))
314
334
  #
315
335
  # @param regex regular expression string
316
- # @param flags regular expression bit flags. See {@link com.aerospike.client.query.RegexFlag}
336
+ # @param flags regular expression bit flags. See {@link Exp::RegexFlags}
317
337
  # @param bin string bin or string value expression
318
338
  def self.regex_compare(regex, flags, bin)
319
- new Regex.new(bin, regex, flags)
339
+ Regex.new(bin, regex, flags)
320
340
  end
321
341
 
322
342
  #--------------------------------------------------
@@ -327,23 +347,23 @@ module Aerospike
327
347
  #
328
348
  # ==== Examples
329
349
  # # Query region within coordinates.
330
- # String region =
331
- # "{ " +
332
- # " \"type\": \"Polygon\", " +
333
- # " \"coordinates\": [ " +
334
- # " [[-122.500000, 37.000000],[-121.000000, 37.000000], " +
335
- # " [-121.000000, 38.080000],[-122.500000, 38.080000], " +
336
- # " [-122.500000, 37.000000]] " +
337
- # " ] " +
338
- # "}"
339
- # Exp.geo_compare(Exp.geo_bin("a"), Exp.geo(region))
350
+ # region =
351
+ # "{ " +
352
+ # " \"type\": \"Polygon\", " +
353
+ # " \"coordinates\": [ " +
354
+ # " [[-122.500000, 37.000000],[-121.000000, 37.000000], " +
355
+ # " [-121.000000, 38.080000],[-122.500000, 38.080000], " +
356
+ # " [-122.500000, 37.000000]] " +
357
+ # " ] " +
358
+ # "}"
359
+ # Exp.geo_compare(Exp.geo_bin("a"), Exp.geo(region))
340
360
  def self.geo_compare(left, right)
341
- new CmdExp.new(GEO, left, right)
361
+ CmdExp.new(GEO, left, right)
342
362
  end
343
363
 
344
364
  # Create geospatial json string value.
345
365
  def self.geo(val)
346
- new Geo.new(val)
366
+ Geo.new(val)
347
367
  end
348
368
 
349
369
  #--------------------------------------------------
@@ -351,43 +371,43 @@ module Aerospike
351
371
  #--------------------------------------------------
352
372
 
353
373
  # Create boolean value.
354
- def self.val(val)
355
- new Bool.new(val)
374
+ def self.bool_val(val)
375
+ Bool.new(val)
356
376
  end
357
377
 
358
378
  # Create 64 bit integer value.
359
- def self.val(val)
360
- new Int.new(val)
379
+ def self.int_val(val)
380
+ Int.new(val)
361
381
  end
362
382
 
363
383
  # Create 64 bit floating point value.
364
- def self.val(val)
365
- new Float.new(val)
384
+ def self.float_val(val)
385
+ Float.new(val)
366
386
  end
367
387
 
368
388
  # Create string value.
369
- def self.val(val)
370
- new Str.new(val)
389
+ def self.str_val(val)
390
+ Str.new(val)
371
391
  end
372
392
 
373
393
  # Create blob byte value.
374
- def self.val(val)
375
- new Blob.new(val)
394
+ def self.blob_val(val)
395
+ Blob.new(val)
376
396
  end
377
397
 
378
398
  # Create list value.
379
- def self.val(list)
380
- new ListVal.new(list)
399
+ def self.list_val(*list)
400
+ ListVal.new(list)
381
401
  end
382
402
 
383
403
  # Create map value.
384
- def self.val(map)
385
- new MapVal.new(map)
404
+ def self.map_val(map)
405
+ MapVal.new(map)
386
406
  end
387
407
 
388
408
  # Create nil value.
389
- def self.nil
390
- new Nil.new
409
+ def self.nil_val
410
+ Nil.new
391
411
  end
392
412
 
393
413
  #--------------------------------------------------
@@ -397,103 +417,103 @@ module Aerospike
397
417
  # Create "not" operator expression.
398
418
  #
399
419
  # ==== Examples
400
- # # ! (a == 0 || a == 10)
401
- # Exp.not(
402
- # Exp.or(
403
- # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
404
- # Exp.eq(Exp.int_bin("a"), Exp.val(10))))
420
+ # # ! (a == 0 || a == 10)
421
+ # Exp.not(
422
+ # Exp.or(
423
+ # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
424
+ # Exp.eq(Exp.int_bin("a"), Exp.int_val(10))))
405
425
  def self.not(exp)
406
- new CmdExp.new(NOT, exp)
426
+ CmdExp.new(NOT, exp)
407
427
  end
408
428
 
409
429
  # Create "and" (&&) operator that applies to a variable number of expressions.
410
430
  #
411
431
  # ==== Examples
412
- # # (a > 5 || a == 0) && b < 3
413
- # Exp.and(
414
- # Exp.or(
415
- # Exp.gt(Exp.int_bin("a"), Exp.val(5)),
416
- # Exp.eq(Exp.int_bin("a"), Exp.val(0))),
417
- # Exp.lt(Exp.int_bin("b"), Exp.val(3)))
432
+ # # (a > 5 || a == 0) && b < 3
433
+ # Exp.and(
434
+ # Exp.or(
435
+ # Exp.gt(Exp.int_bin("a"), Exp.val(5)),
436
+ # Exp.eq(Exp.int_bin("a"), Exp.val(0))),
437
+ # Exp.lt(Exp.int_bin("b"), Exp.val(3)))
418
438
  def self.and(*exps)
419
- new CmdExp.new(AND, exps)
439
+ CmdExp.new(AND, *exps)
420
440
  end
421
441
 
422
442
  # Create "or" (||) operator that applies to a variable number of expressions.
423
443
  #
424
444
  # ==== Examples
425
- # # a == 0 || b == 0
426
- # Exp.or(
427
- # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
428
- # Exp.eq(Exp.int_bin("b"), Exp.val(0)))
445
+ # # a == 0 || b == 0
446
+ # Exp.or(
447
+ # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
448
+ # Exp.eq(Exp.int_bin("b"), Exp.val(0)))
429
449
  def self.or(*exps)
430
- new CmdExp.new(OR, exps)
450
+ CmdExp.new(OR, *exps)
431
451
  end
432
452
 
433
453
  # Create expression that returns true if only one of the expressions are true.
434
454
  # Requires server version 5.6.0+.
435
455
  #
436
456
  # ==== Examples
437
- # # exclusive(a == 0, b == 0)
438
- # Exp.exclusive(
439
- # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
440
- # Exp.eq(Exp.int_bin("b"), Exp.val(0)))
457
+ # # exclusive(a == 0, b == 0)
458
+ # Exp.exclusive(
459
+ # Exp.eq(Exp.int_bin("a"), Exp.val(0)),
460
+ # Exp.eq(Exp.int_bin("b"), Exp.val(0)))
441
461
  def self.exclusive(*exps)
442
- new CmdExp.new(EXCLUSIVE, exps)
462
+ CmdExp.new(EXCLUSIVE, *exps)
443
463
  end
444
464
 
445
465
  # Create equal (==) expression.
446
466
  #
447
467
  # ==== Examples
448
- # # a == 11
449
- # Exp.eq(Exp.int_bin("a"), Exp.val(11))
468
+ # # a == 11
469
+ # Exp.eq(Exp.int_bin("a"), Exp.int_val(11))
450
470
  def self.eq(left, right)
451
- new CmdExp.new(EQ, left, right)
471
+ CmdExp.new(EQ, left, right)
452
472
  end
453
473
 
454
474
  # Create not equal (!=) expression
455
475
  #
456
476
  # ==== Examples
457
- # # a != 13
458
- # Exp.ne(Exp.int_bin("a"), Exp.val(13))
477
+ # # a != 13
478
+ # Exp.ne(Exp.int_bin("a"), Exp.int_val(13))
459
479
  def self.ne(left, right)
460
- new CmdExp.new(NE, left, right)
480
+ CmdExp.new(NE, left, right)
461
481
  end
462
482
 
463
483
  # Create greater than (>) operation.
464
484
  #
465
485
  # ==== Examples
466
- # # a > 8
467
- # Exp.gt(Exp.int_bin("a"), Exp.val(8))
486
+ # # a > 8
487
+ # Exp.gt(Exp.int_bin("a"), Exp.val(8))
468
488
  def self.gt(left, right)
469
- new CmdExp.new(GT, left, right)
489
+ CmdExp.new(GT, left, right)
470
490
  end
471
491
 
472
492
  # Create greater than or equal (>=) operation.
473
493
  #
474
494
  # ==== Examples
475
- # # a >= 88
476
- # Exp.ge(Exp.int_bin("a"), Exp.val(88))
495
+ # # a >= 88
496
+ # Exp.ge(Exp.int_bin("a"), Exp.val(88))
477
497
  def self.ge(left, right)
478
- new CmdExp.new(GE, left, right)
498
+ CmdExp.new(GE, left, right)
479
499
  end
480
500
 
481
501
  # Create less than (<) operation.
482
502
  #
483
503
  # ==== Examples
484
- # # a < 1000
485
- # Exp.lt(Exp.int_bin("a"), Exp.val(1000))
504
+ # # a < 1000
505
+ # Exp.lt(Exp.int_bin("a"), Exp.int_val(1000))
486
506
  def self.lt(left, right)
487
- new CmdExp.new(LT, left, right)
507
+ CmdExp.new(LT, left, right)
488
508
  end
489
509
 
490
510
  # Create less than or equals (<=) operation.
491
511
  #
492
512
  # ==== Examples
493
- # # a <= 1
494
- # Exp.le(Exp.int_bin("a"), Exp.val(1))
513
+ # # a <= 1
514
+ # Exp.le(Exp.int_bin("a"), Exp.int_val(1))
495
515
  def self.le(left, right)
496
- new CmdExp.new(LE, left, right)
516
+ CmdExp.new(LE, left, right)
497
517
  end
498
518
 
499
519
  #--------------------------------------------------
@@ -505,12 +525,12 @@ module Aerospike
505
525
  # Requires server version 5.6.0+.
506
526
  #
507
527
  # ==== Examples
508
- # # a + b + c == 10
509
- # Exp.eq(
510
- # Exp.add(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
511
- # Exp.val(10))
528
+ # # a + b + c == 10
529
+ # Exp.eq(
530
+ # Exp.add(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
531
+ # Exp.int_val(10))
512
532
  def self.add(*exps)
513
- new CmdExp.new(ADD, exps)
533
+ CmdExp.new(ADD, *exps)
514
534
  end
515
535
 
516
536
  # Create "subtract" (-) operator that applies to a variable number of expressions.
@@ -520,12 +540,12 @@ module Aerospike
520
540
  # Requires server version 5.6.0+.
521
541
  #
522
542
  # ==== Examples
523
- # # a - b - c > 10
524
- # Exp.gt(
525
- # Exp.sub(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
526
- # Exp.val(10))
543
+ # # a - b - c > 10
544
+ # Exp.gt(
545
+ # Exp.sub(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
546
+ # Exp.int_val(10))
527
547
  def self.sub(*exps)
528
- new CmdExp.new(SUB, exps)
548
+ CmdExp.new(SUB, *exps)
529
549
  end
530
550
 
531
551
  # Create "multiply" (*) operator that applies to a variable number of expressions.
@@ -534,12 +554,12 @@ module Aerospike
534
554
  # Requires server version 5.6.0+.
535
555
  #
536
556
  # ==== Examples
537
- # # a * b * c < 100
538
- # Exp.lt(
539
- # Exp.mul(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
540
- # Exp.val(100))
557
+ # # a * b * c < 100
558
+ # Exp.lt(
559
+ # Exp.mul(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
560
+ # Exp.int_val(100))
541
561
  def self.mul(*exps)
542
- new CmdExp.new(MUL, exps)
562
+ CmdExp.new(MUL, *exps)
543
563
  end
544
564
 
545
565
  # Create "divide" (/) operator that applies to a variable number of expressions.
@@ -549,12 +569,12 @@ module Aerospike
549
569
  # Requires server version 5.6.0+.
550
570
  #
551
571
  # ==== Examples
552
- # # a / b / c > 1
553
- # Exp.gt(
554
- # Exp.div(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
555
- # Exp.val(1))
572
+ # # a / b / c > 1
573
+ # Exp.gt(
574
+ # Exp.div(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
575
+ # Exp.int_val(1))
556
576
  def self.div(*exps)
557
- new CmdExp.new(DIV, exps)
577
+ CmdExp.new(DIV, *exps)
558
578
  end
559
579
 
560
580
  # Create "power" operator that raises a "base" to the "exponent" power.
@@ -562,12 +582,12 @@ module Aerospike
562
582
  # Requires server version 5.6.0+.
563
583
  #
564
584
  # ==== Examples
565
- # # pow(a, 2.0) == 4.0
566
- # Exp.eq(
567
- # Exp.pow(Exp.float_bin("a"), Exp.val(2.0)),
568
- # Exp.val(4.0))
585
+ # # pow(a, 2.0) == 4.0
586
+ # Exp.eq(
587
+ # Exp.pow(Exp.float_bin("a"), Exp.val(2.0)),
588
+ # Exp.val(4.0))
569
589
  def self.pow(base, exponent)
570
- new CmdExp.new(POW, base, exponent)
590
+ CmdExp.new(POW, base, exponent)
571
591
  end
572
592
 
573
593
  # Create "log" operator for logarithm of "num" with base "base".
@@ -575,12 +595,12 @@ module Aerospike
575
595
  # Requires server version 5.6.0+.
576
596
  #
577
597
  # ==== Examples
578
- # # log(a, 2.0) == 4.0
579
- # Exp.eq(
580
- # Exp.log(Exp.float_bin("a"), Exp.val(2.0)),
581
- # Exp.val(4.0))
598
+ # # log(a, 2.0) == 4.0
599
+ # Exp.eq(
600
+ # Exp.log(Exp.float_bin("a"), Exp.val(2.0)),
601
+ # Exp.val(4.0))
582
602
  def self.log(num, base)
583
- new CmdExp.new(LOG, num, base)
603
+ CmdExp.new(LOG, num, base)
584
604
  end
585
605
 
586
606
  # Create "modulo" (%) operator that determines the remainder of "numerator"
@@ -588,12 +608,12 @@ module Aerospike
588
608
  # Requires server version 5.6.0+.
589
609
  #
590
610
  # ==== Examples
591
- # # a % 10 == 0
592
- # Exp.eq(
593
- # Exp.mod(Exp.int_bin("a"), Exp.val(10)),
594
- # Exp.val(0))
611
+ # # a % 10 == 0
612
+ # Exp.eq(
613
+ # Exp.mod(Exp.int_bin("a"), Exp.int_val(10)),
614
+ # Exp.val(0))
595
615
  def self.mod(numerator, denominator)
596
- new CmdExp.new(MOD, numerator, denominator)
616
+ CmdExp.new(MOD, numerator, denominator)
597
617
  end
598
618
 
599
619
  # Create operator that returns absolute value of a number.
@@ -601,60 +621,60 @@ module Aerospike
601
621
  # Requires server version 5.6.0+.
602
622
  #
603
623
  # ==== Examples
604
- # # abs(a) == 1
605
- # Exp.eq(
606
- # Exp.abs(Exp.int_bin("a")),
607
- # Exp.val(1))
624
+ # # abs(a) == 1
625
+ # Exp.eq(
626
+ # Exp.abs(Exp.int_bin("a")),
627
+ # Exp.int_val(1))
608
628
  def self.abs(value)
609
- new CmdExp.new(ABS, value)
629
+ CmdExp.new(ABS, value)
610
630
  end
611
631
 
612
632
  # Create expression that rounds a floating point number down to the closest integer value.
613
633
  # The return type is float. Requires server version 5.6.0+.
614
634
  #
615
635
  # ==== Examples
616
- # # floor(2.95) == 2.0
617
- # Exp.eq(
618
- # Exp.floor(Exp.val(2.95)),
619
- # Exp.val(2.0))
636
+ # # floor(2.95) == 2.0
637
+ # Exp.eq(
638
+ # Exp.floor(Exp.val(2.95)),
639
+ # Exp.val(2.0))
620
640
  def self.floor(num)
621
- new CmdExp.new(FLOOR, num)
641
+ CmdExp.new(FLOOR, num)
622
642
  end
623
643
 
624
644
  # Create expression that rounds a floating point number up to the closest integer value.
625
645
  # The return type is float. Requires server version 5.6.0+.
626
646
  #
627
647
  # ==== Examples
628
- # # ceil(2.15) >= 3.0
629
- # Exp.ge(
630
- # Exp.ceil(Exp.val(2.15)),
631
- # Exp.val(3.0))
648
+ # # ceil(2.15) >= 3.0
649
+ # Exp.ge(
650
+ # Exp.ceil(Exp.val(2.15)),
651
+ # Exp.val(3.0))
632
652
  def self.ceil(num)
633
- new CmdExp.new(CEIL, num)
653
+ CmdExp.new(CEIL, num)
634
654
  end
635
655
 
636
656
  # Create expression that converts a float to an integer.
637
657
  # Requires server version 5.6.0+.
638
658
  #
639
659
  # ==== Examples
640
- # # int(2.5) == 2
641
- # Exp.eq(
642
- # Exp.to_int(Exp.val(2.5)),
643
- # Exp.val(2))
660
+ # # int(2.5) == 2
661
+ # Exp.eq(
662
+ # Exp.to_int(Exp.val(2.5)),
663
+ # Exp.val(2))
644
664
  def self.to_int(num)
645
- new CmdExp.new(TO_INT, num)
665
+ CmdExp.new(TO_INT, num)
646
666
  end
647
667
 
648
668
  # Create expression that converts an integer to a float.
649
669
  # Requires server version 5.6.0+.
650
670
  #
651
671
  # ==== Examples
652
- # # float(2) == 2.0
653
- # Exp.eq(
654
- # Exp.to_float(Exp.val(2))),
655
- # Exp.val(2.0))
672
+ # # float(2) == 2.0
673
+ # Exp.eq(
674
+ # Exp.to_float(Exp.val(2))),
675
+ # Exp.val(2.0))
656
676
  def self.to_float(num)
657
- new CmdExp.new(TO_FLOAT, num)
677
+ CmdExp.new(TO_FLOAT, num)
658
678
  end
659
679
 
660
680
  # Create integer "and" (&) operator that is applied to two or more integers.
@@ -662,12 +682,12 @@ module Aerospike
662
682
  # Requires server version 5.6.0+.
663
683
  #
664
684
  # ==== Examples
665
- # # a & 0xff == 0x11
666
- # Exp.eq(
667
- # Exp.int_and(Exp.int_bin("a"), Exp.val(0xff)),
668
- # Exp.val(0x11))
685
+ # # a & 0xff == 0x11
686
+ # Exp.eq(
687
+ # Exp.int_and(Exp.int_bin("a"), Exp.val(0xff)),
688
+ # Exp.val(0x11))
669
689
  def self.int_and(*exps)
670
- new CmdExp.new(exps)
690
+ CmdExp.new(INT_AND, *exps)
671
691
  end
672
692
 
673
693
  # Create integer "or" (|) operator that is applied to two or more integers.
@@ -675,12 +695,12 @@ module Aerospike
675
695
  # Requires server version 5.6.0+.
676
696
  #
677
697
  # ==== Examples
678
- # # a | 0x10 != 0
679
- # Exp.ne(
680
- # Exp.int_or(Exp.int_bin("a"), Exp.val(0x10)),
681
- # Exp.val(0))
698
+ # # a | 0x10 != 0
699
+ # Exp.ne(
700
+ # Exp.int_or(Exp.int_bin("a"), Exp.val(0x10)),
701
+ # Exp.val(0))
682
702
  def self.int_or(*exps)
683
- new CmdExp.new(exps)
703
+ CmdExp.new(INT_OR, *exps)
684
704
  end
685
705
 
686
706
  # Create integer "xor" (^) operator that is applied to two or more integers.
@@ -688,72 +708,72 @@ module Aerospike
688
708
  # Requires server version 5.6.0+.
689
709
  #
690
710
  # ==== Examples
691
- # # a ^ b == 16
692
- # Exp.eq(
693
- # Exp.int_xor(Exp.int_bin("a"), Exp.int_bin("b")),
694
- # Exp.val(16))
711
+ # # a ^ b == 16
712
+ # Exp.eq(
713
+ # Exp.int_xor(Exp.int_bin("a"), Exp.int_bin("b")),
714
+ # Exp.int_val(16))
695
715
  def self.int_xor(*exps)
696
- new CmdExp.new(exps)
716
+ CmdExp.new(INT_XOR, *exps)
697
717
  end
698
718
 
699
719
  # Create integer "not" (~) operator.
700
720
  # Requires server version 5.6.0+.
701
721
  #
702
722
  # ==== Examples
703
- # # ~a == 7
704
- # Exp.eq(
705
- # Exp.int_not(Exp.int_bin("a")),
706
- # Exp.val(7))
723
+ # # ~a == 7
724
+ # Exp.eq(
725
+ # Exp.int_not(Exp.int_bin("a")),
726
+ # Exp.val(7))
707
727
  def self.int_not(exp)
708
- new CmdExp.new(exp)
728
+ CmdExp.new(INT_NOT, exp)
709
729
  end
710
730
 
711
731
  # Create integer "left shift" (<<) operator.
712
732
  # Requires server version 5.6.0+.
713
733
  #
714
734
  # ==== Examples
715
- # # a << 8 > 0xff
716
- # Exp.gt(
717
- # Exp.lshift(Exp.int_bin("a"), Exp.val(8)),
718
- # Exp.val(0xff))
735
+ # # a << 8 > 0xff
736
+ # Exp.gt(
737
+ # Exp.lshift(Exp.int_bin("a"), Exp.val(8)),
738
+ # Exp.val(0xff))
719
739
  def self.lshift(value, shift)
720
- new CmdExp.new(value, shift)
740
+ CmdExp.new(INT_LSHIFT, value, shift)
721
741
  end
722
742
 
723
743
  # Create integer "logical right shift" (>>>) operator.
724
744
  # Requires server version 5.6.0+.
725
745
  #
726
746
  # ==== Examples
727
- # # a >>> 8 > 0xff
728
- # Exp.gt(
729
- # Exp.rshift(Exp.int_bin("a"), Exp.val(8)),
730
- # Exp.val(0xff))
747
+ # # a >>> 8 > 0xff
748
+ # Exp.gt(
749
+ # Exp.rshift(Exp.int_bin("a"), Exp.val(8)),
750
+ # Exp.val(0xff))
731
751
  def self.rshift(value, shift)
732
- new CmdExp.new(value, shift)
752
+ CmdExp.new(INT_RSHIFT, value, shift)
733
753
  end
734
754
 
735
755
  # Create integer "arithmetic right shift" (>>) operator.
736
756
  # Requires server version 5.6.0+.
737
757
  #
738
758
  # ==== Examples
739
- # # a >> 8 > 0xff
740
- # Exp.gt(
741
- # Exp.arshift(Exp.int_bin("a"), Exp.val(8)),
742
- # Exp.val(0xff))
759
+ # # a >> 8 > 0xff
760
+ # Exp.gt(
761
+ # Exp.arshift(Exp.int_bin("a"), Exp.val(8)),
762
+ # Exp.val(0xff))
743
763
  def self.arshift(value, shift)
744
- new CmdExp.new(value, shift)
764
+ CmdExp.new(INT_ARSHIFT, value, shift)
745
765
  end
746
766
 
747
767
  # Create expression that returns count of integer bits that are set to 1.
748
768
  # Requires server version 5.6.0+.
749
769
  #
750
770
  # ==== Examples
751
- # # count(a) == 4
752
- # Exp.eq(
753
- # Exp.count(Exp.int_bin("a")),
754
- # Exp.val(4))
771
+ # # count(a) == 4
772
+ # Exp.eq(
773
+ # Exp.count(Exp.int_bin("a")),
774
+ # Exp.val(4))
755
775
  def self.count(exp)
756
- new CmdExp.new(exp)
776
+ CmdExp.new(INT_COUNT, exp)
757
777
  end
758
778
 
759
779
  # Create expression that scans integer bits from left (most significant bit) to
@@ -764,12 +784,12 @@ module Aerospike
764
784
  # Requires server version 5.6.0+.
765
785
  #
766
786
  # ==== Examples
767
- # # lscan(a, true) == 4
768
- # Exp.eq(
769
- # Exp.lscan(Exp.int_bin("a"), Exp.val(true)),
770
- # Exp.val(4))
787
+ # # lscan(a, true) == 4
788
+ # Exp.eq(
789
+ # Exp.lscan(Exp.int_bin("a"), Exp.val(true)),
790
+ # Exp.val(4))
771
791
  def self.lscan(value, search)
772
- new CmdExp.new(value, search)
792
+ CmdExp.new(INT_LSCAN, value, search)
773
793
  end
774
794
 
775
795
  # Create expression that scans integer bits from right (least significant bit) to
@@ -780,12 +800,12 @@ module Aerospike
780
800
  # Requires server version 5.6.0+.
781
801
  #
782
802
  # ==== Examples
783
- # # rscan(a, true) == 4
784
- # Exp.eq(
785
- # Exp.rscan(Exp.int_bin("a"), Exp.val(true)),
786
- # Exp.val(4))
803
+ # # rscan(a, true) == 4
804
+ # Exp.eq(
805
+ # Exp.rscan(Exp.int_bin("a"), Exp.val(true)),
806
+ # Exp.val(4))
787
807
  def self.rscan(value, search)
788
- new CmdExp.new(value, search)
808
+ CmdExp.new(INT_RSCAN, value, search)
789
809
  end
790
810
 
791
811
  # Create expression that returns the minimum value in a variable number of expressions.
@@ -793,12 +813,12 @@ module Aerospike
793
813
  # Requires server version 5.6.0+.
794
814
  #
795
815
  # ==== Examples
796
- # # min(a, b, c) > 0
797
- # Exp.gt(
798
- # Exp.min(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
799
- # Exp.val(0))
816
+ # # min(a, b, c) > 0
817
+ # Exp.gt(
818
+ # Exp.min(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
819
+ # Exp.val(0))
800
820
  def self.min(*exps)
801
- new CmdExp.new(MIN, exps)
821
+ CmdExp.new(MIN, *exps)
802
822
  end
803
823
 
804
824
  # Create expression that returns the maximum value in a variable number of expressions.
@@ -806,12 +826,12 @@ module Aerospike
806
826
  # Requires server version 5.6.0+.
807
827
  #
808
828
  # ==== Examples
809
- # # max(a, b, c) > 100
810
- # Exp.gt(
811
- # Exp.max(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
812
- # Exp.val(100))
829
+ # # max(a, b, c) > 100
830
+ # Exp.gt(
831
+ # Exp.max(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
832
+ # Exp.int_val(100))
813
833
  def self.max(*exps)
814
- new CmdExp.new(MAX, exps)
834
+ CmdExp.new(MAX, *exps)
815
835
  end
816
836
 
817
837
  #--------------------------------------------------
@@ -825,13 +845,13 @@ module Aerospike
825
845
  # Args Format: bool exp1, action exp1, bool exp2, action exp2, ..., action-default
826
846
  #
827
847
  # # Apply operator based on type::
828
- # Exp.cond(
829
- # Exp.eq(Exp.int_bin("type"), Exp.val(0)), Exp.add(Exp.int_bin("val1"), Exp.int_bin("val2")),
830
- # Exp.eq(Exp.int_bin("type"), Exp.val(1)), Exp.sub(Exp.int_bin("val1"), Exp.int_bin("val2")),
831
- # Exp.eq(Exp.int_bin("type"), Exp.val(2)), Exp.mul(Exp.int_bin("val1"), Exp.int_bin("val2")),
832
- # Exp.val(-1))
848
+ # Exp.cond(
849
+ # Exp.eq(Exp.int_bin("type"), Exp.val(0)), Exp.add(Exp.int_bin("val1"), Exp.int_bin("val2")),
850
+ # Exp.eq(Exp.int_bin("type"), Exp.int_val(1)), Exp.sub(Exp.int_bin("val1"), Exp.int_bin("val2")),
851
+ # Exp.eq(Exp.int_bin("type"), Exp.val(2)), Exp.mul(Exp.int_bin("val1"), Exp.int_bin("val2")),
852
+ # Exp.val(-1))
833
853
  def self.cond(*exps)
834
- new CmdExp.new(COND, exps)
854
+ CmdExp.new(COND, *exps)
835
855
  end
836
856
 
837
857
  # Define variables and expressions in scope.
@@ -848,9 +868,9 @@ module Aerospike
848
868
  # Exp.def("x", Exp.int_bin("a")),
849
869
  # Exp.and(
850
870
  # Exp.lt(Exp.val(5), Exp.var("x")),
851
- # Exp.lt(Exp.var("x"), Exp.val(10))))
871
+ # Exp.lt(Exp.var("x"), Exp.int_val(10))))
852
872
  def self.let(*exps)
853
- new Let.new(exps)
873
+ Let.new(exps)
854
874
  end
855
875
 
856
876
  # Assign variable to a {@link Exp#let(Exp...)} expression that can be accessed later.
@@ -862,9 +882,9 @@ module Aerospike
862
882
  # Exp.def("x", Exp.int_bin("a")),
863
883
  # Exp.and(
864
884
  # Exp.lt(Exp.val(5), Exp.var("x")),
865
- # Exp.lt(Exp.var("x"), Exp.val(10))))
885
+ # Exp.lt(Exp.var("x"), Exp.int_val(10))))
866
886
  def self.def(name, value)
867
- new Def.new(name, value)
887
+ Def.new(name, value)
868
888
  end
869
889
 
870
890
  # Retrieve expression value from a variable.
@@ -876,9 +896,9 @@ module Aerospike
876
896
  # Exp.def("x", Exp.int_bin("a")),
877
897
  # Exp.and(
878
898
  # Exp.lt(Exp.val(5), Exp.var("x")),
879
- # Exp.lt(Exp.var("x"), Exp.val(10))))
899
+ # Exp.lt(Exp.var("x"), Exp.int_val(10))))
880
900
  def self.var(name)
881
- new CmdStr.new(VAR, name)
901
+ CmdStr.new(VAR, name)
882
902
  end
883
903
 
884
904
  #--------------------------------------------------
@@ -886,20 +906,20 @@ module Aerospike
886
906
  #--------------------------------------------------
887
907
 
888
908
  # Create unknown value. Used to intentionally fail an expression.
889
- # The failure can be ignored with {@link com.aerospike.client.exp.exp_write_flags#EVAL_NO_FAIL}
890
- # or {@link com.aerospike.client.exp.exp_read_flags#EVAL_NO_FAIL}.
909
+ # The failure can be ignored with {@link Exp::WriteFlags#EVAL_NO_FAIL}
910
+ # or {@link Exp::ReadFlags#EVAL_NO_FAIL}.
891
911
  # Requires server version 5.6.0+.
892
912
  #
893
913
  # ==== Examples
894
914
  # # double v = balance - 100.0
895
915
  # # return (v > 0.0)? v : unknown
896
916
  # Exp.let(
897
- # Exp.def("v", Exp.sub(Exp.float_bin("balance"), Exp.val(100.0))),
917
+ # Exp.def("v", Exp.sub(Exp.float_bin("balance"), Exp.int_val(100.0))),
898
918
  # Exp.cond(
899
919
  # Exp.ge(Exp.var("v"), Exp.val(0.0)), Exp.var("v"),
900
920
  # Exp.unknown))
901
921
  def self.unknown
902
- new Cmd.new(UNKNOWN)
922
+ Cmd.new(UNKNOWN)
903
923
  end
904
924
 
905
925
  # # Merge precompiled expression into a new expression tree.
@@ -909,7 +929,7 @@ module Aerospike
909
929
  # # ==== Examples
910
930
  # # # Merge precompiled expression into new expression.
911
931
  # # Expression e = Exp.build(Exp.eq(Exp.int_bin("a"), Exp.val(200)))
912
- # # Expression merged = Exp.build(Exp.and(Exp.expr(e), Exp.eq(Exp.int_bin("b"), Exp.val(100))))
932
+ # # Expression merged = Exp.build(Exp.and(Exp.expr(e), Exp.eq(Exp.int_bin("b"), Exp.int_val(100))))
913
933
  # def self.expr(Expression e)
914
934
  # new ExpBytes.new(e)
915
935
  # end
@@ -919,6 +939,28 @@ module Aerospike
919
939
  #--------------------------------------------------
920
940
  MODIFY = 0x40
921
941
 
942
+ def bytes
943
+ if @bytes.nil?
944
+ Packer.use do |packer|
945
+ pack(packer)
946
+ @bytes = packer.bytes
947
+ end
948
+ end
949
+ @bytes
950
+ end
951
+
952
+ # Estimate expression size in wire protocol.
953
+ # For internal use only.
954
+ def size
955
+ bytes.length
956
+ end
957
+
958
+ # Write expression in wire protocol.
959
+ # For internal use only.
960
+ def write(buf, offset)
961
+ buf.write_binary(bytes, offset)
962
+ end
963
+
922
964
  private
923
965
 
924
966
  UNKNOWN = 0
@@ -978,8 +1020,33 @@ module Aerospike
978
1020
  CALL = 127
979
1021
  NANOS_PER_MILLIS = 1000000
980
1022
 
981
- def pack(packer)
982
- raise "Unreachable"
1023
+ def self.pack(ctx, command, *vals)
1024
+ Packer.use do |packer|
1025
+ # ctx is not support for bit commands
1026
+ packer.write_array_header(vals.to_a.length + 1)
1027
+ packer.write(command)
1028
+ vals.each do |v|
1029
+ if v.is_a?(Exp)
1030
+ v.pack(packer)
1031
+ else
1032
+ Value.of(v).pack(packer)
1033
+ end
1034
+ end
1035
+ return packer.bytes
1036
+ end
1037
+ end
1038
+
1039
+ def self.pack_ctx(packer, ctx)
1040
+ unless ctx.to_a.empty?
1041
+ packer.write_array_header(3)
1042
+ packer.write(0xff)
1043
+ packer.write_array_header(ctx.length * 2)
1044
+
1045
+ ctx.each do |c|
1046
+ packer.write(c.id)
1047
+ c.value.pack(packer)
1048
+ end
1049
+ end
983
1050
  end
984
1051
 
985
1052
  # For internal use only.
@@ -997,12 +1064,13 @@ module Aerospike
997
1064
  end
998
1065
 
999
1066
  def pack(packer)
1000
- packer.pack_array_begin(5)
1001
- packer.pack_int(Exp::CALL)
1002
- packer.pack_int(ret_type)
1003
- packer.pack_int(modul)
1004
- packer.pack_byte_array(bytes, 0, bytes.length)
1005
- bin.pack(packer)
1067
+ packer.write_array_header(5)
1068
+ packer.write(Exp::CALL)
1069
+ packer.write(@ret_type)
1070
+ packer.write(@module)
1071
+ # packer.pack_byte_array(@bytes, 0, @bytes.length)
1072
+ packer.write_raw(@bytes)
1073
+ @bin.pack(packer)
1006
1074
  end
1007
1075
  end
1008
1076
 
@@ -1016,10 +1084,10 @@ module Aerospike
1016
1084
  end
1017
1085
 
1018
1086
  def pack(packer)
1019
- packer.pack_array_begin(3)
1020
- packer.pack_int(BIN)
1021
- packer.pack_int(type.code)
1022
- packer.pack_string(name)
1087
+ packer.write_array_header(3)
1088
+ packer.write(BIN)
1089
+ packer.write(@type)
1090
+ packer.write(@name)
1023
1091
  end
1024
1092
  end
1025
1093
 
@@ -1035,11 +1103,11 @@ module Aerospike
1035
1103
  end
1036
1104
 
1037
1105
  def pack(packer)
1038
- packer.pack_array_begin(4)
1039
- packer.pack_int(REGEX)
1040
- packer.pack_int(flags)
1041
- packer.pack_string(regex)
1042
- bin.pack(packer)
1106
+ packer.write_array_header(4)
1107
+ packer.write(REGEX)
1108
+ packer.write(@flags)
1109
+ packer.write(@regex)
1110
+ @bin.pack(packer)
1043
1111
  end
1044
1112
  end
1045
1113
 
@@ -1052,11 +1120,11 @@ module Aerospike
1052
1120
 
1053
1121
  def pack(packer)
1054
1122
  # Let wire format: LET <defname1>, <defexp1>, <defname2>, <defexp2>, ..., <scope exp>
1055
- count = (exps.length - 1) * 2 + 2
1056
- packer.pack_array_begin(count)
1057
- packer.pack_int(LET)
1123
+ count = (@exps.length - 1) * 2 + 2
1124
+ packer.write_array_header(count)
1125
+ packer.write(LET)
1058
1126
 
1059
- exps.each do |exp|
1127
+ @exps.each do |exp|
1060
1128
  exp.pack(packer)
1061
1129
  end
1062
1130
  end
@@ -1072,8 +1140,8 @@ module Aerospike
1072
1140
  end
1073
1141
 
1074
1142
  def pack(packer)
1075
- packer.pack_string(name)
1076
- exp::pack(packer)
1143
+ packer.write(@name)
1144
+ @exp.pack(packer)
1077
1145
  end
1078
1146
  end
1079
1147
 
@@ -1081,16 +1149,15 @@ module Aerospike
1081
1149
  attr_reader :exps
1082
1150
  attr_reader :cmd
1083
1151
 
1084
- def initialize(cmd, exps)
1152
+ def initialize(cmd, *exps)
1085
1153
  @exps = exps
1086
1154
  @cmd = cmd
1087
1155
  end
1088
1156
 
1089
1157
  def pack(packer)
1090
- packer.pack_array_begin(exps.length + 1)
1091
- packer.pack_int(cmd)
1092
-
1093
- exps.each do |exp|
1158
+ packer.write_array_header(@exps.length + 1)
1159
+ packer.write(@cmd)
1160
+ @exps.each do |exp|
1094
1161
  exp.pack(packer)
1095
1162
  end
1096
1163
  end
@@ -1106,9 +1173,9 @@ module Aerospike
1106
1173
  end
1107
1174
 
1108
1175
  def pack(packer)
1109
- packer.pack_array_begin(2)
1110
- packer.pack_int(cmd)
1111
- packer.pack_int(val)
1176
+ packer.write_array_header(2)
1177
+ Value.of(@cmd).pack(packer)
1178
+ Value.of(@val).pack(packer)
1112
1179
  end
1113
1180
  end
1114
1181
 
@@ -1122,9 +1189,9 @@ module Aerospike
1122
1189
  end
1123
1190
 
1124
1191
  def pack(packer)
1125
- packer.pack_array_begin(2)
1126
- packer.pack_int(cmd)
1127
- packer.pack_string(str)
1192
+ packer.write_array_header(2)
1193
+ Value.of(@cmd).pack(packer)
1194
+ packer.write(@str)
1128
1195
  end
1129
1196
  end
1130
1197
 
@@ -1136,8 +1203,8 @@ module Aerospike
1136
1203
  end
1137
1204
 
1138
1205
  def pack(packer)
1139
- packer.pack_array_begin(1)
1140
- packer.pack_int(cmd)
1206
+ packer.write_array_header(1)
1207
+ packer.write(@cmd)
1141
1208
  end
1142
1209
  end
1143
1210
 
@@ -1149,7 +1216,7 @@ module Aerospike
1149
1216
  end
1150
1217
 
1151
1218
  def pack(packer)
1152
- packer.pack_boolean(val)
1219
+ BoolValue.new(@val).pack(packer)
1153
1220
  end
1154
1221
  end
1155
1222
 
@@ -1157,11 +1224,11 @@ module Aerospike
1157
1224
  attr_reader :val
1158
1225
 
1159
1226
  def initialize(val)
1160
- @val = val
1227
+ @val = val.to_i
1161
1228
  end
1162
1229
 
1163
1230
  def pack(packer)
1164
- packer.pack_long(val)
1231
+ IntegerValue.new(@val).pack(packer)
1165
1232
  end
1166
1233
  end
1167
1234
 
@@ -1169,11 +1236,11 @@ module Aerospike
1169
1236
  attr_reader :val
1170
1237
 
1171
1238
  def initialize(val)
1172
- @val = val
1239
+ @val = val.to_f
1173
1240
  end
1174
1241
 
1175
1242
  def pack(packer)
1176
- packer.pack_double(val)
1243
+ FloatValue.new(@val).pack(packer)
1177
1244
  end
1178
1245
  end
1179
1246
 
@@ -1185,7 +1252,7 @@ module Aerospike
1185
1252
  end
1186
1253
 
1187
1254
  def pack(packer)
1188
- packer.pack_particle_string(val)
1255
+ StringValue.new(@val).pack(packer)
1189
1256
  end
1190
1257
  end
1191
1258
 
@@ -1197,7 +1264,7 @@ module Aerospike
1197
1264
  end
1198
1265
 
1199
1266
  def pack(packer)
1200
- packer.pack_geo_json(val)
1267
+ Value.of(@val).pack(packer)
1201
1268
  end
1202
1269
  end
1203
1270
 
@@ -1209,7 +1276,7 @@ module Aerospike
1209
1276
  end
1210
1277
 
1211
1278
  def pack(packer)
1212
- packer.pack_particle_bytes(val)
1279
+ BytesValue.new(@val).pack(packer)
1213
1280
  end
1214
1281
  end
1215
1282
 
@@ -1223,9 +1290,9 @@ module Aerospike
1223
1290
  def pack(packer)
1224
1291
  # List values need an extra array and QUOTED in order to distinguish
1225
1292
  # between a multiple argument array call and a local list.
1226
- packer.pack_array_begin(2)
1227
- packer.pack_int(QUOTED)
1228
- packer.pack_list(list)
1293
+ packer.write_array_header(2)
1294
+ packer.write(QUOTED)
1295
+ Value.of(@list).pack(packer)
1229
1296
  end
1230
1297
  end
1231
1298
 
@@ -1237,13 +1304,13 @@ module Aerospike
1237
1304
  end
1238
1305
 
1239
1306
  def pack(packer)
1240
- packer.pack_map(map)
1307
+ Value.of(@map).pack(packer)
1241
1308
  end
1242
1309
  end
1243
1310
 
1244
1311
  class Nil < Exp
1245
1312
  def pack(packer)
1246
- packer.pack_nil
1313
+ Value.of(nil).pack(packer)
1247
1314
  end
1248
1315
  end
1249
1316
 
@@ -1251,11 +1318,11 @@ module Aerospike
1251
1318
  attr_reader :bytes
1252
1319
 
1253
1320
  def initialize(e)
1254
- @bytes = e.getBytes
1321
+ @bytes = e.bytes
1255
1322
  end
1256
1323
 
1257
1324
  def pack(packer)
1258
- packer.pack_byte_array(bytes, 0, bytes.length)
1325
+ Value.of(@bytes).pack(packer)
1259
1326
  end
1260
1327
  end
1261
1328
  end # class Exp