Class: Aerospike::Exp

Inherits:
Object
  • Object
show all
Defined in:
lib/aerospike/exp/exp.rb

Direct Known Subclasses

Bin, Blob, Bool, Cmd, CmdExp, CmdInt, CmdStr, Def, ExpBytes, Float, Geo, Int, Let, ListVal, MapVal, Module, Nil, Regex, Str

Defined Under Namespace

Modules: ReadFlags, RegexFlags, Type, WriteFlags Classes: Bin, Bit, Blob, Bool, Cmd, CmdExp, CmdInt, CmdStr, Def, ExpBytes, Float, Geo, HLL, Int, Let, List, ListVal, Map, MapVal, Module, Nil, Operation, Regex, Str

Constant Summary collapse

MODIFY =

Internal

0x40

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.abs(value) ⇒ Object

Create operator that returns absolute value of a number. All arguments must resolve to integer or float. Requires server version 5.6.0+.

Examples

# abs(a) == 1
Exp.eq(
  Exp.abs(Exp.int_bin("a")),
  Exp.int_val(1))



642
643
644
 
# File 'lib/aerospike/exp/exp.rb', line 642

def self.abs(value)
  CmdExp.new(ABS, value)
end

.add(*exps) ⇒ Object

Create “add” (+) operator that applies to a variable number of expressions. Return sum of all arguments. All arguments must resolve to the same type (or float). Requires server version 5.6.0+.

Examples

# a + b + c == 10
Exp.eq(
  Exp.add(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.int_val(10))



546
547
548
 
# File 'lib/aerospike/exp/exp.rb', line 546

def self.add(*exps)
  CmdExp.new(ADD, *exps)
end

.and(*exps) ⇒ Object

Create “and” (&&) operator that applies to a variable number of expressions.

Examples

# (a > 5 || a == 0) && b < 3
Exp.and(
  Exp.or(
    Exp.gt(Exp.int_bin("a"), Exp.val(5)),
    Exp.eq(Exp.int_bin("a"), Exp.val(0))),
  Exp.lt(Exp.int_bin("b"), Exp.val(3)))



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

def self.and(*exps)
  CmdExp.new(AND, *exps)
end

.arshift(value, shift) ⇒ Object

Create integer “arithmetic right shift” (>>) operator. Requires server version 5.6.0+.

Examples

# a >> 8 > 0xff
Exp.gt(
  Exp.arshift(Exp.int_bin("a"), Exp.val(8)),
  Exp.val(0xff))



777
778
779
 
# File 'lib/aerospike/exp/exp.rb', line 777

def self.arshift(value, shift)
  CmdExp.new(INT_ARSHIFT, value, shift)
end

.bin(name, type) ⇒ Object

Create bin expression of specified type.

Examples

# String bin "a" == "views"
Exp.eq(Exp.bin("a", Type::STRING), Exp.str_val("views"))



119
120
121
 
# File 'lib/aerospike/exp/exp.rb', line 119

def self.bin(name, type)
  Bin.new(name, type)
end

.bin_exists(name) ⇒ Object

Create expression that returns if bin of specified name exists.

Examples

# Bin "a" exists in record
Exp.bin_exists("a")



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

def self.bin_exists(name)
  Exp.ne(Exp.bin_type(name), Exp.int_val(0))
end

.bin_type(name) ⇒ Object

Create expression that returns bin’s integer particle type

See ParticleType.

Examples

# Bin "a" particle type is a list
Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))



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

def self.bin_type(name)
  CmdStr.new(BIN_TYPE, name)
end

.blob_bin(name) ⇒ Object

Create bin expression.

Examples

# Blob bin "a" == [1,2,3]
Exp.eq(Exp.blob_bin("a"), Exp.val(new {1, 2, 3}))



164
165
166
 
# File 'lib/aerospike/exp/exp.rb', line 164

def self.blob_bin(name)
  Bin.new(name, Type::BLOB)
end

.blob_val(val) ⇒ Object

Create blob byte value.



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

def self.blob_val(val)
  Blob.new(val)
end

.bool_bin(name) ⇒ Object

Create boolean bin expression.

Examples

# Boolean bin "a" == true
Exp.eq(Exp.bool_bin("a"), Exp.val(true))



155
156
157
 
# File 'lib/aerospike/exp/exp.rb', line 155

def self.bool_bin(name)
  Bin.new(name, Type::BOOL)
end

.bool_val(val) ⇒ Object

Create boolean value.



388
389
390
 
# File 'lib/aerospike/exp/exp.rb', line 388

def self.bool_val(val)
  Bool.new(val)
end

.build(exp) ⇒ Object

Create final expression that contains packed byte instructions used in the wire protocol.



924
925
926
927
928
929
 
# File 'lib/aerospike/exp/exp.rb', line 924

def self.build(exp)
  Packer.use do |packer|
    exp.pack(packer)
    @bytes = packer.bytes
  end
end

.ceil(num) ⇒ Object

Create expression that rounds a floating point number up to the closest integer value. The return type is float. Requires server version 5.6.0+.

Examples

# ceil(2.15) >= 3.0
Exp.ge(
  Exp.ceil(Exp.val(2.15)),
  Exp.val(3.0))



666
667
668
 
# File 'lib/aerospike/exp/exp.rb', line 666

def self.ceil(num)
  CmdExp.new(CEIL, num)
end

.cond(*exps) ⇒ Object

Conditionally select an expression from a variable number of expression pairs followed by default expression action. Requires server version 5.6.0+.

Examples

Args Format: bool exp1, action exp1, bool exp2, action exp2, …, action-default

# Apply operator based on type

Exp.cond(

Exp.eq(Exp.int_bin("type"), Exp.val(0)), Exp.add(Exp.int_bin("val1"), Exp.int_bin("val2")),
Exp.eq(Exp.int_bin("type"), Exp.int_val(1)), Exp.sub(Exp.int_bin("val1"), Exp.int_bin("val2")),
Exp.eq(Exp.int_bin("type"), Exp.val(2)), Exp.mul(Exp.int_bin("val1"), Exp.int_bin("val2")),
Exp.val(-1))



867
868
869
 
# File 'lib/aerospike/exp/exp.rb', line 867

def self.cond(*exps)
  CmdExp.new(COND, *exps)
end

.count(exp) ⇒ Object

Create expression that returns count of integer bits that are set to 1. Requires server version 5.6.0+.

Examples

# count(a) == 4
Exp.eq(
  Exp.count(Exp.int_bin("a")),
  Exp.val(4))



789
790
791
 
# File 'lib/aerospike/exp/exp.rb', line 789

def self.count(exp)
  CmdExp.new(INT_COUNT, exp)
end

.def(name, value) ⇒ Object

Assign variable to a Exp#let(Exp…) expression that can be accessed later. Requires server version 5.6.0+.

Examples

# 5 < a < 10 Exp.let(

Exp.def("x", Exp.int_bin("a")),
Exp.and(
  Exp.lt(Exp.val(5), Exp.var("x")),
  Exp.lt(Exp.var("x"), Exp.int_val(10))))



900
901
902
 
# File 'lib/aerospike/exp/exp.rb', line 900

def(name, value)
  Def.new(name, value)
end

.device_size ⇒ Object

Create expression that returns record size on disk. If server storage-engine is memory, then zero is returned. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record device size >= 100 KB
Exp.ge(Exp.device_size, Exp.int_val(100 * 1024))



261
262
263
 
# File 'lib/aerospike/exp/exp.rb', line 261

def self.device_size
  Cmd.new(DEVICE_SIZE)
end

.digest_modulo(mod) ⇒ Object

Create expression that returns record digest modulo as integer. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Records that have digest(key) % 3 == 1
Exp.eq(Exp.digest_modulo(3), Exp.int_val(1))



338
339
340
 
# File 'lib/aerospike/exp/exp.rb', line 338

def self.digest_modulo(mod)
  CmdInt.new(DIGEST_MODULO, mod)
end

.div(*exps) ⇒ Object

Create “divide” (/) operator that applies to a variable number of expressions. If there is only one argument, returns the reciprocal for that argument. Otherwise, return the first argument divided by the product of the rest. All arguments must resolve to the same type (or float). Requires server version 5.6.0+.

Examples

# a / b / c > 1
Exp.gt(
  Exp.div(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.int_val(1))



590
591
592
 
# File 'lib/aerospike/exp/exp.rb', line 590

def self.div(*exps)
  CmdExp.new(DIV, *exps)
end

.eq(left, right) ⇒ Object

Create equal (==) expression.

Examples

# a == 11
Exp.eq(Exp.int_bin("a"), Exp.int_val(11))



484
485
486
 
# File 'lib/aerospike/exp/exp.rb', line 484

def self.eq(left, right)
  CmdExp.new(EQ, left, right)
end

.exclusive(*exps) ⇒ Object

Create expression that returns true if only one of the expressions are true. Requires server version 5.6.0+.

Examples

# exclusive(a == 0, b == 0)
Exp.exclusive(
  Exp.eq(Exp.int_bin("a"), Exp.val(0)),
  Exp.eq(Exp.int_bin("b"), Exp.val(0)))



475
476
477
 
# File 'lib/aerospike/exp/exp.rb', line 475

def self.exclusive(*exps)
  CmdExp.new(EXCLUSIVE, *exps)
end

.float_bin(name) ⇒ Object

Create 64 bit float bin expression.

Examples

# Float bin "a" >= 1.5
Exp.ge(Exp.float_bin("a"), Exp.int_val(1.5))



137
138
139
 
# File 'lib/aerospike/exp/exp.rb', line 137

def self.float_bin(name)
  Bin.new(name, Type::FLOAT)
end

.float_val(val) ⇒ Object

Create 64 bit floating point value.



398
399
400
 
# File 'lib/aerospike/exp/exp.rb', line 398

def self.float_val(val)
  Float.new(val)
end

.floor(num) ⇒ Object

Create expression that rounds a floating point number down to the closest integer value. The return type is float. Requires server version 5.6.0+.

Examples

# floor(2.95) == 2.0
Exp.eq(
  Exp.floor(Exp.val(2.95)),
  Exp.val(2.0))



654
655
656
 
# File 'lib/aerospike/exp/exp.rb', line 654

def self.floor(num)
  CmdExp.new(FLOOR, num)
end

.ge(left, right) ⇒ Object

Create greater than or equal (>=) operation.

Examples

# a >= 88
Exp.ge(Exp.int_bin("a"), Exp.val(88))



511
512
513
 
# File 'lib/aerospike/exp/exp.rb', line 511

def self.ge(left, right)
  CmdExp.new(GE, left, right)
end

.geo(val) ⇒ Object

Create geospatial json string value.



379
380
381
 
# File 'lib/aerospike/exp/exp.rb', line 379

def self.geo(val)
  Geo.new(val)
end

.geo_bin(name) ⇒ Object

Create geospatial bin expression.

Examples

# Geo bin "a" == region
String region = "{ \"type\": \"AeroCircle\", \"coordinates\": [[-122.0, 37.5], 50000.0] }"
Exp.geo_compare(Exp.geo_bin("loc"), Exp.geo(region))



174
175
176
 
# File 'lib/aerospike/exp/exp.rb', line 174

def self.geo_bin(name)
  Bin.new(name, Type::GEO)
end

.geo_compare(left, right) ⇒ Object

Create compare geospatial operation.

Examples

# Query region within coordinates.

region =
   "{ " +
   "  \"type\": \"Polygon\", " +
   "  \"coordinates\": [ " +
   "    [[-122.500000, 37.000000],[-121.000000, 37.000000], " +
   "     [-121.000000, 38.080000],[-122.500000, 38.080000], " +
   "     [-122.500000, 37.000000]] " +
   "    ] " +
   "}"
   Exp.geo_compare(Exp.geo_bin("a"), Exp.geo(region))



374
375
376
 
# File 'lib/aerospike/exp/exp.rb', line 374

def self.geo_compare(left, right)
  CmdExp.new(GEO, left, right)
end

.gt(left, right) ⇒ Object

Create greater than (>) operation.

Examples

# a > 8
Exp.gt(Exp.int_bin("a"), Exp.val(8))



502
503
504
 
# File 'lib/aerospike/exp/exp.rb', line 502

def self.gt(left, right)
  CmdExp.new(GT, left, right)
end

.hll_bin(name) ⇒ Object

Create hll bin expression.

Examples

# HLL bin “a” count > 7 Exp.gt(HLLExp.get_count(Exp.hll_bin(“a”)), Exp.val(7))



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

def self.hll_bin(name)
  Bin.new(name, Type::HLL)
end

.int_and(*exps) ⇒ Object

Create integer “and” (&) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

Examples

# a & 0xff == 0x11
Exp.eq(
  Exp.int_and(Exp.int_bin("a"), Exp.val(0xff)),
  Exp.val(0x11))



703
704
705
 
# File 'lib/aerospike/exp/exp.rb', line 703

def self.int_and(*exps)
  CmdExp.new(INT_AND, *exps)
end

.int_bin(name) ⇒ Object

Create 64 bit integer bin expression.

Examples

# Integer bin "a" == 200
Exp.eq(Exp.int_bin("a"), Exp.val(200))



128
129
130
 
# File 'lib/aerospike/exp/exp.rb', line 128

def self.int_bin(name)
  Bin.new(name, Type::INT)
end

.int_not(exp) ⇒ Object

Create integer “not” (~) operator. Requires server version 5.6.0+.

Examples

# ~a == 7
Exp.eq(
  Exp.int_not(Exp.int_bin("a")),
  Exp.val(7))



741
742
743
 
# File 'lib/aerospike/exp/exp.rb', line 741

def self.int_not(exp)
  CmdExp.new(INT_NOT, exp)
end

.int_or(*exps) ⇒ Object

Create integer “or” (|) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

Examples

# a | 0x10 != 0
Exp.ne(
  Exp.int_or(Exp.int_bin("a"), Exp.val(0x10)),
  Exp.val(0))



716
717
718
 
# File 'lib/aerospike/exp/exp.rb', line 716

def self.int_or(*exps)
  CmdExp.new(INT_OR, *exps)
end

.int_val(val) ⇒ Object

Create 64 bit integer value.



393
394
395
 
# File 'lib/aerospike/exp/exp.rb', line 393

def self.int_val(val)
  Int.new(val)
end

.int_xor(*exps) ⇒ Object

Create integer “xor” (^) operator that is applied to two or more integers. All arguments must resolve to integers. Requires server version 5.6.0+.

Examples

# a ^ b == 16
Exp.eq(
  Exp.int_xor(Exp.int_bin("a"), Exp.int_bin("b")),
  Exp.int_val(16))



729
730
731
 
# File 'lib/aerospike/exp/exp.rb', line 729

def self.int_xor(*exps)
  CmdExp.new(INT_XOR, *exps)
end

.is_tombstone ⇒ Object

Create expression that returns if record has been deleted and is still in tombstone state. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Deleted records that are in tombstone state.
Exp.is_tombstone



328
329
330
 
# File 'lib/aerospike/exp/exp.rb', line 328

def self.is_tombstone
  Cmd.new(IS_TOMBSTONE)
end

.key(type) ⇒ Object

Create record key expression of specified type.

Examples

# Integer record key >= 100000 Exp.ge(Exp.key(Type::INT), Exp.int_val(100000))



94
95
96
 
# File 'lib/aerospike/exp/exp.rb', line 94

def self.key(type)
  CmdInt.new(KEY, type)
end

.key_exists ⇒ Object

Create expression that returns if the primary key is stored in the record meta data as a boolean expression. This would occur when Policy#send_key is true on record write. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Key exists in record meta data
Exp.key_exists



106
107
108
 
# File 'lib/aerospike/exp/exp.rb', line 106

def self.key_exists
  Cmd.new(KEY_EXISTS)
end

.last_update ⇒ Object

Create expression that returns record last update time expressed as 64 bit integer nanoseconds since 1970-01-01 epoch. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record last update time >= 2020-01-15
Exp.ge(Exp.last_update, Exp.val(new GregorianCalendar(2020, 0, 15)))



285
286
287
 
# File 'lib/aerospike/exp/exp.rb', line 285

def self.last_update
  Cmd.new(LAST_UPDATE)
end

.le(left, right) ⇒ Object

Create less than or equals (<=) operation.

Examples

# a <= 1
Exp.le(Exp.int_bin("a"), Exp.int_val(1))



529
530
531
 
# File 'lib/aerospike/exp/exp.rb', line 529

def self.le(left, right)
  CmdExp.new(LE, left, right)
end

.let(*exps) ⇒ Object

Define variables and expressions in scope. Requires server version 5.6.0+.

Examples

Args Format: <def1>, <def2>, …, <exp> def: Exp#def(String, Exp) exp: Scoped expression

Examples

# 5 < a < 10 Exp.let(

Exp.def("x", Exp.int_bin("a")),
Exp.and(
  Exp.lt(Exp.val(5), Exp.var("x")),
  Exp.lt(Exp.var("x"), Exp.int_val(10))))



886
887
888
 
# File 'lib/aerospike/exp/exp.rb', line 886

def self.let(*exps)
  Let.new(exps)
end

.list_bin(name) ⇒ Object

Create list bin expression.

Examples

# Bin a[2] == 3
Exp.eq(ListExp.get_by_index(ListReturnType::VALUE, Type::INT, Exp.val(2), Exp.list_bin("a")), Exp.val(3))



183
184
185
 
# File 'lib/aerospike/exp/exp.rb', line 183

def self.list_bin(name)
  Bin.new(name, Type::LIST)
end

.list_val(*list) ⇒ Object

Create list value.



413
414
415
 
# File 'lib/aerospike/exp/exp.rb', line 413

def self.list_val(*list)
  ListVal.new(list)
end

.log(num, base) ⇒ Object

Create “log” operator for logarithm of “num” with base “base”. All arguments must resolve to floats. Requires server version 5.6.0+.

Examples

# log(a, 2.0) == 4.0
Exp.eq(
  Exp.log(Exp.float_bin("a"), Exp.val(2.0)),
  Exp.val(4.0))



616
617
618
 
# File 'lib/aerospike/exp/exp.rb', line 616

def self.log(num, base)
  CmdExp.new(LOG, num, base)
end

.lscan(value, search) ⇒ Object

Create expression that scans integer bits from left (most significant bit) to right (least significant bit), looking for a search bit value. When the search value is found, the index of that bit (where the most significant bit is index 0) is returned. If “search” is true, the scan will search for the bit value 1. If “search” is false it will search for bit value 0. Requires server version 5.6.0+.

Examples

# lscan(a, true) == 4
Exp.eq(
  Exp.lscan(Exp.int_bin("a"), Exp.val(true)),
  Exp.val(4))



805
806
807
 
# File 'lib/aerospike/exp/exp.rb', line 805

def self.lscan(value, search)
  CmdExp.new(INT_LSCAN, value, search)
end

.lshift(value, shift) ⇒ Object

Create integer “left shift” (<<) operator. Requires server version 5.6.0+.

Examples

# a << 8 > 0xff
Exp.gt(
  Exp.lshift(Exp.int_bin("a"), Exp.val(8)),
  Exp.val(0xff))



753
754
755
 
# File 'lib/aerospike/exp/exp.rb', line 753

def self.lshift(value, shift)
  CmdExp.new(INT_LSHIFT, value, shift)
end

.lt(left, right) ⇒ Object

Create less than (<) operation.

Examples

# a < 1000
Exp.lt(Exp.int_bin("a"), Exp.int_val(1000))



520
521
522
 
# File 'lib/aerospike/exp/exp.rb', line 520

def self.lt(left, right)
  CmdExp.new(LT, left, right)
end

.map_bin(name) ⇒ Object

Create map bin expression.

Examples

# Bin a["key"] == "value"
Exp.eq(
  MapExp.get_by_key(MapReturnType::VALUE, Type::STRING, Exp.str_val("key"), Exp.map_bin("a")),
  Exp.str_val("value"))



194
195
196
 
# File 'lib/aerospike/exp/exp.rb', line 194

def self.map_bin(name)
  Bin.new(name, Type::MAP)
end

.map_val(map) ⇒ Object

Create map value.



418
419
420
 
# File 'lib/aerospike/exp/exp.rb', line 418

def self.map_val(map)
  MapVal.new(map)
end

.max(*exps) ⇒ Object

Create expression that returns the maximum value in a variable number of expressions. All arguments must be the same type (or float). Requires server version 5.6.0+.

Examples

# max(a, b, c) > 100
Exp.gt(
  Exp.max(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.int_val(100))



847
848
849
 
# File 'lib/aerospike/exp/exp.rb', line 847

def self.max(*exps)
  CmdExp.new(MAX, *exps)
end

.memory_size ⇒ Object

Create expression that returns record size in memory. If server storage-engine is not memory nor data-in-memory, then zero is returned. This expression usually evaluates quickly because record meta data is cached in memory.

Requires server version 5.3.0+

Examples

# Record memory size >= 100 KB
Exp.ge(Exp.memory_size, Exp.int_val(100 * 1024))



274
275
276
 
# File 'lib/aerospike/exp/exp.rb', line 274

def self.memory_size
  Cmd.new(MEMORY_SIZE)
end

.min(*exps) ⇒ Object

Create expression that returns the minimum value in a variable number of expressions. All arguments must be the same type (or float). Requires server version 5.6.0+.

Examples

# min(a, b, c) > 0
Exp.gt(
  Exp.min(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.val(0))



834
835
836
 
# File 'lib/aerospike/exp/exp.rb', line 834

def self.min(*exps)
  CmdExp.new(MIN, *exps)
end

.mod(numerator, denominator) ⇒ Object

Create “modulo” (%) operator that determines the remainder of “numerator” divided by “denominator”. All arguments must resolve to integers. Requires server version 5.6.0+.

Examples

# a % 10 == 0
Exp.eq(
  Exp.mod(Exp.int_bin("a"), Exp.int_val(10)),
  Exp.val(0))



629
630
631
 
# File 'lib/aerospike/exp/exp.rb', line 629

def self.mod(numerator, denominator)
  CmdExp.new(MOD, numerator, denominator)
end

.mul(*exps) ⇒ Object

Create “multiply” (*) operator that applies to a variable number of expressions. Return the product of all arguments. If only one argument is supplied, return that argument. All arguments must resolve to the same type (or float). Requires server version 5.6.0+.

Examples

# a * b * c < 100
Exp.lt(
  Exp.mul(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.int_val(100))



575
576
577
 
# File 'lib/aerospike/exp/exp.rb', line 575

def self.mul(*exps)
  CmdExp.new(MUL, *exps)
end

.ne(left, right) ⇒ Object

Create not equal (!=) expression

Examples

# a != 13
Exp.ne(Exp.int_bin("a"), Exp.int_val(13))



493
494
495
 
# File 'lib/aerospike/exp/exp.rb', line 493

def self.ne(left, right)
  CmdExp.new(NE, left, right)
end

.nil_val ⇒ Object

Create nil value.



423
424
425
 
# File 'lib/aerospike/exp/exp.rb', line 423

def self.nil_val
  Nil.new
end

.not(exp) ⇒ Object

Create “not” operator expression.

Examples

# ! (a == 0 || a == 10)
Exp.not(
  Exp.or(
    Exp.eq(Exp.int_bin("a"), Exp.val(0)),
    Exp.eq(Exp.int_bin("a"), Exp.int_val(10))))



439
440
441
 
# File 'lib/aerospike/exp/exp.rb', line 439

def self.not(exp)
  CmdExp.new(NOT, exp)
end

.or(*exps) ⇒ Object

Create “or” (||) operator that applies to a variable number of expressions.

Examples

# a == 0 || b == 0
Exp.or(
  Exp.eq(Exp.int_bin("a"), Exp.val(0)),
  Exp.eq(Exp.int_bin("b"), Exp.val(0)))



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

def self.or(*exps)
  CmdExp.new(OR, *exps)
end

.pow(base, exponent) ⇒ Object

Create “power” operator that raises a “base” to the “exponent” power. All arguments must resolve to floats. Requires server version 5.6.0+.

Examples

# pow(a, 2.0) == 4.0
Exp.eq(
  Exp.pow(Exp.float_bin("a"), Exp.val(2.0)),
  Exp.val(4.0))



603
604
605
 
# File 'lib/aerospike/exp/exp.rb', line 603

def self.pow(base, exponent)
  CmdExp.new(POW, base, exponent)
end

.record_size ⇒ Object

Create expression that returns the record size. This expression usually evaluates quickly because record meta data is cached in memory. Requires server version 7.0+. This expression replaces #deviceSize() and #memorySize() since those older expressions are equivalent on server version 7.0+.

{@code // Record size >= 100 KB Exp.ge(Exp.record_size(), Exp.val(100 * 1024)) }



235
236
237
 
# File 'lib/aerospike/exp/exp.rb', line 235

def self.record_size
  Cmd.new(RECORD_SIZE)
end

.regex_compare(regex, flags, bin) ⇒ Object

Create expression that performs a regex match on a string bin or string value expression.

Examples

# Select string bin “a” that starts with “prefix” and ends with “suffix”. # Ignore case and do not match newline. Exp.regex_compare(“prefix.*suffix”, RegexFlags.ICASE | RegexFlags.NEWLINE, Exp.str_bin(“a”))

Parameters:

  • regex —

    regular expression string

  • flags —

    regular expression bit flags. See Exp::RegexFlags

  • bin —

    string bin or string value expression



352
353
354
 
# File 'lib/aerospike/exp/exp.rb', line 352

def self.regex_compare(regex, flags, bin)
  Regex.new(bin, regex, flags)
end

.rscan(value, search) ⇒ Object

Create expression that scans integer bits from right (least significant bit) to left (most significant bit), looking for a search bit value. When the search value is found, the index of that bit (where the most significant bit is index 0) is returned. If “search” is true, the scan will search for the bit value 1. If “search” is false it will search for bit value 0. Requires server version 5.6.0+.

Examples

# rscan(a, true) == 4
Exp.eq(
  Exp.rscan(Exp.int_bin("a"), Exp.val(true)),
  Exp.val(4))



821
822
823
 
# File 'lib/aerospike/exp/exp.rb', line 821

def self.rscan(value, search)
  CmdExp.new(INT_RSCAN, value, search)
end

.rshift(value, shift) ⇒ Object

Create integer “logical right shift” (>>>) operator. Requires server version 5.6.0+.

Examples

# a >>> 8 > 0xff
Exp.gt(
  Exp.rshift(Exp.int_bin("a"), Exp.val(8)),
  Exp.val(0xff))



765
766
767
 
# File 'lib/aerospike/exp/exp.rb', line 765

def self.rshift(value, shift)
  CmdExp.new(INT_RSHIFT, value, shift)
end

.set_name ⇒ Object

Create expression that returns record set name string. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record set name == "myset"
Exp.eq(Exp.set_name, Exp.str_val("myset"))



250
251
252
 
# File 'lib/aerospike/exp/exp.rb', line 250

def self.set_name
  Cmd.new(SET_NAME)
end

.since_update ⇒ Object

Create expression that returns milliseconds since the record was last updated. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record last updated more than 2 hours ago
Exp.gt(Exp.since_update, Exp.val(2 * 60 * 60 * 1000))



295
296
297
 
# File 'lib/aerospike/exp/exp.rb', line 295

def self.since_update
  Cmd.new(SINCE_UPDATE)
end

.str_bin(name) ⇒ Object

Create string bin expression.

Examples

# String bin "a" == "views"
Exp.eq(Exp.str_bin("a"), Exp.str_val("views"))



146
147
148
 
# File 'lib/aerospike/exp/exp.rb', line 146

def self.str_bin(name)
  Bin.new(name, Type::STRING)
end

.str_val(val) ⇒ Object

Create string value.



403
404
405
 
# File 'lib/aerospike/exp/exp.rb', line 403

def self.str_val(val)
  Str.new(val)
end

.sub(*exps) ⇒ Object

Create “subtract” (-) operator that applies to a variable number of expressions. If only one argument is provided, return the negation of that argument. Otherwise, return the sum of the 2nd to Nth argument subtracted from the 1st argument. All arguments must resolve to the same type (or float). Requires server version 5.6.0+.

Examples

# a - b - c > 10
Exp.gt(
  Exp.sub(Exp.int_bin("a"), Exp.int_bin("b"), Exp.int_bin("c")),
  Exp.int_val(10))



561
562
563
 
# File 'lib/aerospike/exp/exp.rb', line 561

def self.sub(*exps)
  CmdExp.new(SUB, *exps)
end

.to_float(num) ⇒ Object

Create expression that converts an integer to a float. Requires server version 5.6.0+.

Examples

# float(2) == 2.0
Exp.eq(
  Exp.to_float(Exp.val(2))),
  Exp.val(2.0))



690
691
692
 
# File 'lib/aerospike/exp/exp.rb', line 690

def self.to_float(num)
  CmdExp.new(TO_FLOAT, num)
end

.to_int(num) ⇒ Object

Create expression that converts a float to an integer. Requires server version 5.6.0+.

Examples

# int(2.5) == 2
Exp.eq(
  Exp.to_int(Exp.val(2.5)),
  Exp.val(2))



678
679
680
 
# File 'lib/aerospike/exp/exp.rb', line 678

def self.to_int(num)
  CmdExp.new(TO_INT, num)
end

.ttl ⇒ Object

Create expression that returns record expiration time (time to live) in integer seconds. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record expires in less than 1 hour
Exp.lt(Exp.ttl, Exp.val(60 * 60))



318
319
320
 
# File 'lib/aerospike/exp/exp.rb', line 318

def self.ttl
  Cmd.new(TTL)
end

.unknown ⇒ Object

Create unknown value. Used to intentionally fail an expression. The failure can be ignored with Exp::WriteFlags#EVAL_NO_FAIL or Exp::ReadFlags#EVAL_NO_FAIL. Requires server version 5.6.0+.

Examples

# double v = balance - 100.0 # return (v > 0.0)? v : unknown Exp.let(

Exp.def("v", Exp.sub(Exp.float_bin("balance"), Exp.int_val(100.0))),
Exp.cond(
  Exp.ge(Exp.var("v"), Exp.val(0.0)), Exp.var("v"),
  Exp.unknown))



948
949
950
 
# File 'lib/aerospike/exp/exp.rb', line 948

def self.unknown
  Cmd.new(UNKNOWN)
end

.var(name) ⇒ Object

Retrieve expression value from a variable. Requires server version 5.6.0+.

Examples

# 5 < a < 10 Exp.let(

Exp.def("x", Exp.int_bin("a")),
Exp.and(
  Exp.lt(Exp.val(5), Exp.var("x")),
  Exp.lt(Exp.var("x"), Exp.int_val(10))))



914
915
916
 
# File 'lib/aerospike/exp/exp.rb', line 914

def self.var(name)
  CmdStr.new(VAR, name)
end

.void_time ⇒ Object

Create expression that returns record expiration time expressed as 64 bit integer nanoseconds since 1970-01-01 epoch. This expression usually evaluates quickly because record meta data is cached in memory.

Examples

# Record expires on 2021-01-01
Exp.and(
  Exp.ge(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 1))),
  Exp.lt(Exp.void_time, Exp.val(new GregorianCalendar(2021, 0, 2))))



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

def self.void_time
  Cmd.new(VOID_TIME)
end

Instance Method Details

#bytes ⇒ Object 



970
971
972
973
974
975
976
977
978
 
# File 'lib/aerospike/exp/exp.rb', line 970

def bytes
  if @bytes.nil?
    Packer.use do |packer|
      pack(packer)
      @bytes = packer.bytes
    end
  end
  @bytes
end

#size ⇒ Object

Estimate expression size in wire protocol. For internal use only.



982
983
984
 
# File 'lib/aerospike/exp/exp.rb', line 982

def size
  bytes.length
end

#write(buf, offset) ⇒ Object

Write expression in wire protocol. For internal use only.



988
989
990
 
# File 'lib/aerospike/exp/exp.rb', line 988

def write(buf, offset)
  buf.write_binary(bytes, offset)
end