aerospike 2.19.0 → 2.26.0

data/lib/aerospike/exp/exp.rb

@@ -0,0 +1,1329 @@
+# encoding: utf-8
+# Copyright 2014-2022 Aerospike, Inc.
+#
+# Portions may be licensed to Aerospike, Inc. under one or more contributor
+# license agreements.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may no
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Aerospike
+  class Exp
+
+    # Regex bit flags
+    module RegexFlags
+      # Regex defaults
+      NONE = 0
+
+      # Use POSIX Extended Regular Expression syntax when interpreting regex.
+      EXTENDED = 1
+
+      # Do not differentiate case.
+      ICASE = 2
+
+      # Do not report position of matches.
+      NOSUB = 4
+
+      # Match-any-character operators don't match a newline.
+      NEWLINE = 8
+    end
+
+    # Expression type.
+    module Type #:nodoc:
+      NIL = 0
+      BOOL = 1
+      INT = 2
+      STRING = 3
+      LIST = 4
+      MAP = 5
+      BLOB = 6
+      FLOAT = 7
+      GEO = 8
+      HLL = 9
+    end # module type
+
+    # Expression write flags.
+    module WriteFlags
+      # Default. Allow create or update.
+      DEFAULT = 0
+
+      # If bin does not exist, a new bin will be created.
+      # If bin exists, the operation will be denied.
+      # If bin exists, fail with ResultCode#BIN_EXISTS_ERROR
+      # when #POLICY_NO_FAIL is not set.
+      CREATE_ONLY = 1
+
+      # If bin exists, the bin will be overwritten.
+      # If bin does not exist, the operation will be denied.
+      # If bin does not exist, fail with ResultCode#BIN_NOT_FOUND
+      # when #POLICY_NO_FAIL is not set.
+      UPDATE_ONLY = 2
+
+      # If expression results in nil value, then delete the bin. Otherwise, fail with
+      # ResultCode#OP_NOT_APPLICABLE when #POLICY_NO_FAIL is not set.
+      ALLOW_DELETE = 4
+
+      # Do not raise error if operation is denied.
+      POLICY_NO_FAIL = 8
+
+      # Ignore failures caused by the expression resolving to unknown or a non-bin type.
+      EVAL_NO_FAIL = 16
+    end # module WriteFlags
+
+    # Expression write flags.
+    module ReadFlags
+      # Default.
+      DEFAULT = 0
+
+      # Ignore failures caused by the expression resolving to unknown or a non-bin type.
+      EVAL_NO_FAIL = 16
+    end # module ReadFlags
+
+    # Create record key expression of specified type.
+    #
+    # ==== Examples
+    # # Integer record key >= 100000
+    # Exp.ge(Exp.key(Type::INT), Exp.int_val(100000))
+    def self.key(type)
+      CmdInt.new(KEY, type)
+    end
+
+    # Create expression that returns if the primary key is stored in the record meta data
+    # as a boolean expression. This would occur when {@link 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
+    def self.key_exists
+      Cmd.new(KEY_EXISTS)
+    end
+
+    #--------------------------------------------------
+    # Record Bin
+    #--------------------------------------------------
+
+    # Create bin expression of specified type.
+    #
+    # ==== Examples
+    #   # String bin "a" == "views"
+    #   Exp.eq(Exp.bin("a", Type::STRING), Exp.str_val("views"))
+    def self.bin(name, type)
+      Bin.new(name, type)
+    end
+
+    # Create 64 bit integer bin expression.
+    #
+    # ==== Examples
+    #   # Integer bin "a" == 200
+    #   Exp.eq(Exp.int_bin("a"), Exp.val(200))
+    def self.int_bin(name)
+      Bin.new(name, Type::INT)
+    end
+
+    # Create 64 bit float bin expression.
+    #
+    # ==== Examples
+    #   # Float bin "a" >= 1.5
+    #   Exp.ge(Exp.float_bin("a"), Exp.int_val(1.5))
+    def self.float_bin(name)
+      Bin.new(name, Type::FLOAT)
+    end
+
+    # Create string bin expression.
+    #
+    # ==== Examples
+    #   # String bin "a" == "views"
+    #   Exp.eq(Exp.str_bin("a"), Exp.str_val("views"))
+    def self.str_bin(name)
+      Bin.new(name, Type::STRING)
+    end
+
+    # Create boolean bin expression.
+    #
+    # ==== Examples
+    #   # Boolean bin "a" == true
+    #   Exp.eq(Exp.bool_bin("a"), Exp.val(true))
+    def self.bool_bin(name)
+      Bin.new(name, Type::BOOL)
+    end
+
+    # Create bin expression.
+    #
+    # ==== Examples
+    #   # Blob bin "a" == [1,2,3]
+    #   Exp.eq(Exp.blob_bin("a"), Exp.val(new {1, 2, 3}))
+    def self.blob_bin(name)
+      Bin.new(name, Type::BLOB)
+    end
+
+    # 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))
+    def self.geo_bin(name)
+      Bin.new(name, Type::GEO)
+    end
+
+    # 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))
+    def self.list_bin(name)
+      Bin.new(name, Type::LIST)
+    end
+
+    # 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"))
+    def self.map_bin(name)
+      Bin.new(name, Type::MAP)
+    end
+
+    # Create hll bin expression.
+    #
+    # ==== Examples
+    # # HLL bin "a" count > 7
+    # Exp.gt(HLLExp.get_count(Exp.hll_bin("a")), Exp.val(7))
+    def self.hll_bin(name)
+      Bin.new(name, Type::HLL)
+    end
+
+    # Create expression that returns if bin of specified name exists.
+    #
+    # ==== Examples
+    #   # Bin "a" exists in record
+    #   Exp.bin_exists("a")
+    def self.bin_exists(name)
+      return Exp.ne(Exp.bin_type(name), Exp.int_val(0))
+    end
+
+    # Create expression that returns bin's integer particle type::
+    # See {@link ParticleType}.
+    #
+    # ==== Examples
+    #   # Bin "a" particle type is a list
+    #   Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))
+    def self.bin_type(name)
+      CmdStr.new(BIN_TYPE, name)
+    end
+
+    #--------------------------------------------------
+    # Misc
+    #--------------------------------------------------
+
+    # 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"))
+    def self.set_name
+      Cmd.new(SET_NAME)
+    end
+
+    # 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))
+    def self.device_size
+      Cmd.new(DEVICE_SIZE)
+    end
+
+    # 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))
+    def self.memory_size
+      Cmd.new(MEMORY_SIZE)
+    end
+
+    # 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)))
+    def self.last_update
+      Cmd.new(LAST_UPDATE)
+    end
+
+    # 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))
+    def self.since_update
+      Cmd.new(SINCE_UPDATE)
+    end
+
+    # 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))))
+    def self.void_time
+      Cmd.new(VOID_TIME)
+    end
+
+    # 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))
+    def self.ttl
+      Cmd.new(TTL)
+    end
+
+    # 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
+    def self.is_tombstone
+      Cmd.new(IS_TOMBSTONE)
+    end
+
+    # 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))
+    def self.digest_modulo(mod)
+      CmdInt.new(DIGEST_MODULO, mod)
+    end
+
+    # 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"))
+    #
+    # @param regex		regular expression string
+    # @param flags		regular expression bit flags. See {@link Exp::RegexFlags}
+    # @param bin		string bin or string value expression
+    def self.regex_compare(regex, flags, bin)
+      Regex.new(bin, regex, flags)
+    end
+
+    #--------------------------------------------------
+    # GEO Spatial
+    #--------------------------------------------------
+
+    # 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))
+    def self.geo_compare(left, right)
+      CmdExp.new(GEO, left, right)
+    end
+
+    # Create geospatial json string value.
+    def self.geo(val)
+      Geo.new(val)
+    end
+
+    #--------------------------------------------------
+    # Value
+    #--------------------------------------------------
+
+    # Create boolean value.
+    def self.bool_val(val)
+      Bool.new(val)
+    end
+
+    # Create 64 bit integer value.
+    def self.int_val(val)
+      Int.new(val)
+    end
+
+    # Create 64 bit floating point value.
+    def self.float_val(val)
+      Float.new(val)
+    end
+
+    # Create string value.
+    def self.str_val(val)
+      Str.new(val)
+    end
+
+    # Create blob byte value.
+    def self.blob_val(val)
+      Blob.new(val)
+    end
+
+    # Create list value.
+    def self.list_val(*list)
+      ListVal.new(list)
+    end
+
+    # Create map value.
+    def self.map_val(map)
+      MapVal.new(map)
+    end
+
+    # Create nil value.
+    def self.nil_val
+      Nil.new
+    end
+
+    #--------------------------------------------------
+    # Boolean Operator
+    #--------------------------------------------------
+
+    # 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))))
+    def self.not(exp)
+      CmdExp.new(NOT, exp)
+    end
+
+    # 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)))
+    def self.and(*exps)
+      CmdExp.new(AND, *exps)
+    end
+
+    # 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)))
+    def self.or(*exps)
+      CmdExp.new(OR, *exps)
+    end
+
+    # 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)))
+    def self.exclusive(*exps)
+      CmdExp.new(EXCLUSIVE, *exps)
+    end
+
+    # Create equal (==) expression.
+    #
+    # ==== Examples
+    #   # a == 11
+    #   Exp.eq(Exp.int_bin("a"), Exp.int_val(11))
+    def self.eq(left, right)
+      CmdExp.new(EQ, left, right)
+    end
+
+    # Create not equal (!=) expression
+    #
+    # ==== Examples
+    #   # a != 13
+    #   Exp.ne(Exp.int_bin("a"), Exp.int_val(13))
+    def self.ne(left, right)
+      CmdExp.new(NE, left, right)
+    end
+
+    # Create greater than (>) operation.
+    #
+    # ==== Examples
+    #   # a > 8
+    #   Exp.gt(Exp.int_bin("a"), Exp.val(8))
+    def self.gt(left, right)
+      CmdExp.new(GT, left, right)
+    end
+
+    # Create greater than or equal (>=) operation.
+    #
+    # ==== Examples
+    #   # a >= 88
+    #   Exp.ge(Exp.int_bin("a"), Exp.val(88))
+    def self.ge(left, right)
+      CmdExp.new(GE, left, right)
+    end
+
+    # Create less than (<) operation.
+    #
+    # ==== Examples
+    #   # a < 1000
+    #   Exp.lt(Exp.int_bin("a"), Exp.int_val(1000))
+    def self.lt(left, right)
+      CmdExp.new(LT, left, right)
+    end
+
+    # Create less than or equals (<=) operation.
+    #
+    # ==== Examples
+    #   # a <= 1
+    #   Exp.le(Exp.int_bin("a"), Exp.int_val(1))
+    def self.le(left, right)
+      CmdExp.new(LE, left, right)
+    end
+
+    #--------------------------------------------------
+    # Number Operator
+    #--------------------------------------------------
+
+    # 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))
+    def self.add(*exps)
+      CmdExp.new(ADD, *exps)
+    end
+
+    # 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))
+    def self.sub(*exps)
+      CmdExp.new(SUB, *exps)
+    end
+
+    # 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))
+    def self.mul(*exps)
+      CmdExp.new(MUL, *exps)
+    end
+
+    # 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))
+    def self.div(*exps)
+      CmdExp.new(DIV, *exps)
+    end
+
+    # 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))
+    def self.pow(base, exponent)
+      CmdExp.new(POW, base, exponent)
+    end
+
+    # 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))
+    def self.log(num, base)
+      CmdExp.new(LOG, num, base)
+    end
+
+    # 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))
+    def self.mod(numerator, denominator)
+      CmdExp.new(MOD, numerator, denominator)
+    end
+
+    # 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))
+    def self.abs(value)
+      CmdExp.new(ABS, value)
+    end
+
+    # 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))
+    def self.floor(num)
+      CmdExp.new(FLOOR, num)
+    end
+
+    # 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))
+    def self.ceil(num)
+      CmdExp.new(CEIL, num)
+    end
+
+    # 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))
+    def self.to_int(num)
+      CmdExp.new(TO_INT, num)
+    end
+
+    # 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))
+    def self.to_float(num)
+      CmdExp.new(TO_FLOAT, num)
+    end
+
+    # 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))
+    def self.int_and(*exps)
+      CmdExp.new(INT_AND, *exps)
+    end
+
+    # 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))
+    def self.int_or(*exps)
+      CmdExp.new(INT_OR, *exps)
+    end
+
+    # 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))
+    def self.int_xor(*exps)
+      CmdExp.new(INT_XOR, *exps)
+    end
+
+    # 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))
+    def self.int_not(exp)
+      CmdExp.new(INT_NOT, exp)
+    end
+
+    # 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))
+    def self.lshift(value, shift)
+      CmdExp.new(INT_LSHIFT, value, shift)
+    end
+
+    # 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))
+    def self.rshift(value, shift)
+      CmdExp.new(INT_RSHIFT, value, shift)
+    end
+
+    # 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))
+    def self.arshift(value, shift)
+      CmdExp.new(INT_ARSHIFT, value, shift)
+    end
+
+    # 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))
+    def self.count(exp)
+      CmdExp.new(INT_COUNT, exp)
+    end
+
+    # 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))
+    def self.lscan(value, search)
+      CmdExp.new(INT_LSCAN, value, search)
+    end
+
+    # 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))
+    def self.rscan(value, search)
+      CmdExp.new(INT_RSCAN, value, search)
+    end
+
+    # 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))
+    def self.min(*exps)
+      CmdExp.new(MIN, *exps)
+    end
+
+    # 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))
+    def self.max(*exps)
+      CmdExp.new(MAX, *exps)
+    end
+
+    #--------------------------------------------------
+    # Variables
+    #--------------------------------------------------
+
+    # 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))
+    def self.cond(*exps)
+      CmdExp.new(COND, *exps)
+    end
+
+    # Define variables and expressions in scope.
+    # Requires server version 5.6.0+.
+    #
+    # ==== Examples
+    # Args Format: <def1>, <def2>, ..., <exp>
+    # def: {@link 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))))
+    def self.let(*exps)
+      Let.new(exps)
+    end
+
+    # Assign variable to a {@link 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))))
+    def self.def(name, value)
+      Def.new(name, value)
+    end
+
+    # 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))))
+    def self.var(name)
+      CmdStr.new(VAR, name)
+    end
+
+    #--------------------------------------------------
+    # Miscellaneous
+    #--------------------------------------------------
+
+    # Create unknown value. Used to intentionally fail an expression.
+    # The failure can be ignored with {@link Exp::WriteFlags#EVAL_NO_FAIL}
+    # or {@link 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))
+    def self.unknown
+      Cmd.new(UNKNOWN)
+    end
+
+    # # Merge precompiled expression into a new expression tree.
+    # # Useful for storing common precompiled expressions and then reusing
+    # # these expressions as part of a greater expression.
+    # #
+    # # ==== Examples
+    # # # Merge precompiled expression into new expression.
+    # # Expression e = Exp.build(Exp.eq(Exp.int_bin("a"), Exp.val(200)))
+    # # Expression merged = Exp.build(Exp.and(Exp.expr(e), Exp.eq(Exp.int_bin("b"), Exp.int_val(100))))
+    # def self.expr(Expression e)
+    #   new ExpBytes.new(e)
+    # end
+
+    #--------------------------------------------------
+    # Internal
+    #--------------------------------------------------
+    MODIFY = 0x40
+
+    def bytes
+      if @bytes.nil?
+        Packer.use do |packer|
+          pack(packer)
+          @bytes = packer.bytes
+        end
+      end
+      @bytes
+    end
+
+    # Estimate expression size in wire protocol.
+    # For internal use only.
+    def size
+      bytes.length
+    end
+
+    # Write expression in wire protocol.
+    # For internal use only.
+    def write(buf, offset)
+      buf.write_binary(bytes, offset)
+    end
+
+    private
+
+    UNKNOWN = 0
+    EQ = 1
+    NE = 2
+    GT = 3
+    GE = 4
+    LT = 5
+    LE = 6
+    REGEX = 7
+    GEO = 8
+    AND = 16
+    OR = 17
+    NOT = 18
+    EXCLUSIVE = 19
+    ADD = 20
+    SUB = 21
+    MUL = 22
+    DIV = 23
+    POW = 24
+    LOG = 25
+    MOD = 26
+    ABS = 27
+    FLOOR = 28
+    CEIL = 29
+    TO_INT = 30
+    TO_FLOAT = 31
+    INT_AND = 32
+    INT_OR = 33
+    INT_XOR = 34
+    INT_NOT = 35
+    INT_LSHIFT = 36
+    INT_RSHIFT = 37
+    INT_ARSHIFT = 38
+    INT_COUNT = 39
+    INT_LSCAN = 40
+    INT_RSCAN = 41
+    MIN = 50
+    MAX = 51
+    DIGEST_MODULO = 64
+    DEVICE_SIZE = 65
+    LAST_UPDATE = 66
+    SINCE_UPDATE = 67
+    VOID_TIME = 68
+    TTL = 69
+    SET_NAME = 70
+    KEY_EXISTS = 71
+    IS_TOMBSTONE = 72
+    MEMORY_SIZE = 73
+    KEY = 80
+    BIN = 81
+    BIN_TYPE = 82
+    COND = 123
+    VAR = 124
+    LET = 125
+    QUOTED = 126
+    CALL = 127
+    NANOS_PER_MILLIS = 1000000
+
+    def self.pack(ctx, command, *vals)
+      Packer.use do |packer|
+        # ctx is not support for bit commands
+        packer.write_array_header(vals.to_a.length + 1)
+        packer.write(command)
+        vals.each do |v|
+          if v.is_a?(Exp)
+            v.pack(packer)
+          else
+            Value.of(v).pack(packer)
+          end
+        end
+        return packer.bytes
+      end
+    end
+
+    def self.pack_ctx(packer, ctx)
+      unless ctx.to_a.empty?
+        packer.write_array_header(3)
+        packer.write(0xff)
+        packer.write_array_header(ctx.length * 2)
+
+        ctx.each do |c|
+          packer.write(c.id)
+          c.value.pack(packer)
+        end
+      end
+    end
+
+    # For internal use only.
+    class Module < Exp
+      attr_reader :bin
+      attr_reader :bytes
+      attr_reader :ret_type
+      attr_reader :module
+
+      def initialize(bin, bytes, ret_type, modul)
+        @bin = bin
+        @bytes = bytes
+        @ret_type = ret_type
+        @module = modul
+      end
+
+      def pack(packer)
+        packer.write_array_header(5)
+        packer.write(Exp::CALL)
+        packer.write(@ret_type)
+        packer.write(@module)
+        # packer.pack_byte_array(@bytes, 0, @bytes.length)
+        packer.write_raw(@bytes)
+        @bin.pack(packer)
+      end
+    end
+
+    class Bin < Exp
+      attr_reader :name
+      attr_reader :type
+
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      def pack(packer)
+        packer.write_array_header(3)
+        packer.write(BIN)
+        packer.write(@type)
+        packer.write(@name)
+      end
+    end
+
+    class Regex < Exp
+      attr_reader :bin
+      attr_reader :regex
+      attr_reader :flags
+
+      def initialize(bin, regex, flags)
+        @bin = bin
+        @regex = regex
+        @flags = flags
+      end
+
+      def pack(packer)
+        packer.write_array_header(4)
+        packer.write(REGEX)
+        packer.write(@flags)
+        packer.write(@regex)
+        @bin.pack(packer)
+      end
+    end
+
+    class Let < Exp
+      attr_reader :exps
+
+      def initialize(exps)
+        @exps = exps
+      end
+
+      def pack(packer)
+        # Let wire format: LET <defname1>, <defexp1>, <defname2>, <defexp2>, ..., <scope exp>
+        count = (@exps.length - 1) * 2 + 2
+        packer.write_array_header(count)
+        packer.write(LET)
+
+        @exps.each do |exp|
+          exp.pack(packer)
+        end
+      end
+    end
+
+    class Def < Exp
+      attr_reader :name
+      attr_reader :exp
+
+      def initialize(name, exp)
+        @name = name
+        @exp = exp
+      end
+
+      def pack(packer)
+        packer.write(@name)
+        @exp.pack(packer)
+      end
+    end
+
+    class CmdExp < Exp
+      attr_reader :exps
+      attr_reader :cmd
+
+      def initialize(cmd, *exps)
+        @exps = exps
+        @cmd = cmd
+      end
+
+      def pack(packer)
+        packer.write_array_header(@exps.length + 1)
+        packer.write(@cmd)
+        @exps.each do |exp|
+          exp.pack(packer)
+        end
+      end
+    end
+
+    class CmdInt < Exp
+      attr_reader :cmd
+      attr_reader :val
+
+      def initialize(cmd, val)
+        @cmd = cmd
+        @val = val
+      end
+
+      def pack(packer)
+        packer.write_array_header(2)
+        Value.of(@cmd).pack(packer)
+        Value.of(@val).pack(packer)
+      end
+    end
+
+    class CmdStr < Exp
+      attr_reader :str
+      attr_reader :cmd
+
+      def initialize(cmd, str)
+        @str = str
+        @cmd = cmd
+      end
+
+      def pack(packer)
+        packer.write_array_header(2)
+        Value.of(@cmd).pack(packer)
+        packer.write(@str)
+      end
+    end
+
+    class Cmd < Exp
+      attr_reader :cmd
+
+      def initialize(cmd)
+        @cmd = cmd
+      end
+
+      def pack(packer)
+        packer.write_array_header(1)
+        packer.write(@cmd)
+      end
+    end
+
+    class Bool < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val
+      end
+
+      def pack(packer)
+        BoolValue.new(@val).pack(packer)
+      end
+    end
+
+    class Int < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val.to_i
+      end
+
+      def pack(packer)
+        IntegerValue.new(@val).pack(packer)
+      end
+    end
+
+    class Float < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val.to_f
+      end
+
+      def pack(packer)
+        FloatValue.new(@val).pack(packer)
+      end
+    end
+
+    class Str < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val
+      end
+
+      def pack(packer)
+        StringValue.new(@val).pack(packer)
+      end
+    end
+
+    class Geo < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val
+      end
+
+      def pack(packer)
+        Value.of(@val).pack(packer)
+      end
+    end
+
+    class Blob < Exp
+      attr_reader :val
+
+      def initialize(val)
+        @val = val
+      end
+
+      def pack(packer)
+        BytesValue.new(@val).pack(packer)
+      end
+    end
+
+    class ListVal < Exp
+      attr_reader :list
+
+      def initialize(list)
+        @list = list
+      end
+
+      def pack(packer)
+        # List values need an extra array and QUOTED in order to distinguish
+        # between a multiple argument array call and a local list.
+        packer.write_array_header(2)
+        packer.write(QUOTED)
+        Value.of(@list).pack(packer)
+      end
+    end
+
+    class MapVal < Exp
+      attr_reader :map
+
+      def initialize(map)
+        @map = map
+      end
+
+      def pack(packer)
+        Value.of(@map).pack(packer)
+      end
+    end
+
+    class Nil < Exp
+      def pack(packer)
+        Value.of(nil).pack(packer)
+      end
+    end
+
+    class ExpBytes < Exp
+      attr_reader :bytes
+
+      def initialize(e)
+        @bytes = e.bytes
+      end
+
+      def pack(packer)
+        Value.of(@bytes).pack(packer)
+      end
+    end
+  end # class Exp
+end # module