aerospike 2.24.0 → 2.25.0

data/lib/aerospike/exp/exp.rb

@@ -17,8 +17,26 @@
 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
+    module Type #:nodoc:
       NIL = 0
       BOOL = 1
       INT = 2
@@ -31,6 +49,7 @@ module Aerospike
       HLL = 9
     end # module type
 
+    # Expression write flags.
     module WriteFlags
       # Default. Allow create or update.
       DEFAULT = 0
@@ -58,6 +77,7 @@ module Aerospike
       EVAL_NO_FAIL = 16
     end # module WriteFlags
 
+    # Expression write flags.
     module ReadFlags
       # Default.
       DEFAULT = 0
@@ -70,13 +90,13 @@ module Aerospike
     #
     # ==== Examples
     # # Integer record key >= 100000
-    # Exp.ge(Exp.key(Type::INT), Exp.val(100000))
+    # Exp.ge(Exp.key(Type::INT), Exp.int_val(100000))
     def self.key(type)
-      new CmdInt.new(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 com.aerospike.client.policy.Policy#sendKey}
+    # 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.
     #
@@ -84,7 +104,7 @@ module Aerospike
     #   # Key exists in record meta data
     #   Exp.key_exists
     def self.key_exists
-      new Cmd.new(KEY_EXISTS)
+      Cmd.new(KEY_EXISTS)
     end
 
     #--------------------------------------------------
@@ -94,85 +114,85 @@ module Aerospike
     # Create bin expression of specified type.
     #
     # ==== Examples
-    # # String bin "a" == "views"
-    # Exp.eq(Exp.bin("a", Type::STRING), Exp.val("views"))
+    #   # String bin "a" == "views"
+    #   Exp.eq(Exp.bin("a", Type::STRING), Exp.str_val("views"))
     def self.bin(name, type)
-      new Bin.new(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))
+    #   # Integer bin "a" == 200
+    #   Exp.eq(Exp.int_bin("a"), Exp.val(200))
     def self.int_bin(name)
-      new Bin.new(name, Type::INT)
+      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.val(1.5))
+    #   # Float bin "a" >= 1.5
+    #   Exp.ge(Exp.float_bin("a"), Exp.int_val(1.5))
     def self.float_bin(name)
-      new Bin.new(name, Type::FLOAT)
+      Bin.new(name, Type::FLOAT)
     end
 
     # Create string bin expression.
     #
     # ==== Examples
-    # # String bin "a" == "views"
-    # Exp.eq(Exp.string_bin("a"), Exp.val("views"))
-    def self.string_bin(name)
-      new Bin.new(name, Type::STRING)
+    #   # 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))
+    #   # Boolean bin "a" == true
+    #   Exp.eq(Exp.bool_bin("a"), Exp.val(true))
     def self.bool_bin(name)
-      new Bin.new(name, Type::BOOL)
+      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}))
+    #   # Blob bin "a" == [1,2,3]
+    #   Exp.eq(Exp.blob_bin("a"), Exp.val(new {1, 2, 3}))
     def self.blob_bin(name)
-      new Bin.new(name, Type::BLOB)
+      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))
+    #   # 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)
-      new Bin.new(name, Type::GEO)
+      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))
+    #   # 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)
-      new Bin.new(name, Type::LIST)
+      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.val("key"), Exp.map_bin("a")),
-    #     Exp.val("value"))
+    #   # 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)
-      new Bin.new(name, Type::MAP)
+      Bin.new(name, Type::MAP)
     end
 
     # Create hll bin expression.
@@ -181,26 +201,26 @@ module Aerospike
     # # HLL bin "a" count > 7
     # Exp.gt(HLLExp.get_count(Exp.hll_bin("a")), Exp.val(7))
     def self.hll_bin(name)
-      new Bin.new(name, Type::HLL)
+      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")
+    #   # Bin "a" exists in record
+    #   Exp.bin_exists("a")
     def self.bin_exists(name)
-      return Exp.ne(Exp.bin_type(name), Exp.val(0))
+      return Exp.ne(Exp.bin_type(name), Exp.int_val(0))
     end
 
     # Create expression that returns bin's integer particle type::
-    # See {@link com.aerospike.client.command.ParticleType}.
+    # See {@link ParticleType}.
     #
     # ==== Examples
-    # # Bin "a" particle type is a list
-    # Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))
+    #   # Bin "a" particle type is a list
+    #   Exp.eq(Exp.bin_type("a"), Exp.val(ParticleType::LIST))
     def self.bin_type(name)
-      new CmdStr.new(BIN_TYPE, name)
+      CmdStr.new(BIN_TYPE, name)
     end
 
     #--------------------------------------------------
@@ -211,10 +231,10 @@ module Aerospike
     # evaluates quickly because record meta data is cached in memory.
     #
     # ==== Examples
-    # # Record set name == "myset"
-    # Exp.eq(Exp.set_name, Exp.val("myset"))
+    #   # Record set name == "myset"
+    #   Exp.eq(Exp.set_name, Exp.str_val("myset"))
     def self.set_name
-      new Cmd.new(SET_NAME)
+      Cmd.new(SET_NAME)
     end
 
     # Create expression that returns record size on disk. If server storage-engine is
@@ -222,23 +242,23 @@ module Aerospike
     # record meta data is cached in memory.
     #
     # ==== Examples
-    # # Record device size >= 100 KB
-    # Exp.ge(Exp.device_size, Exp.val(100 * 1024))
+    #   # Record device size >= 100 KB
+    #   Exp.ge(Exp.device_size, Exp.int_val(100 * 1024))
     def self.device_size
-      new Cmd.new(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.
-    # <p>
+    #
     # Requires server version 5.3.0+
     #
     # ==== Examples
-    # # Record memory size >= 100 KB
-    # Exp.ge(Exp.memory_size, Exp.val(100 * 1024))
+    #   # Record memory size >= 100 KB
+    #   Exp.ge(Exp.memory_size, Exp.int_val(100 * 1024))
     def self.memory_size
-      new Cmd.new(MEMORY_SIZE)
+      Cmd.new(MEMORY_SIZE)
     end
 
     # Create expression that returns record last update time expressed as 64 bit integer
@@ -246,20 +266,20 @@ module Aerospike
     # 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)))
+    #   # Record last update time >= 2020-01-15
+    #   Exp.ge(Exp.last_update, Exp.val(new GregorianCalendar(2020, 0, 15)))
     def self.last_update
-      new Cmd.new(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))
+    #   # Record last updated more than 2 hours ago
+    #   Exp.gt(Exp.since_update, Exp.val(2 * 60 * 60 * 1000))
     def self.since_update
-      new Cmd.new(SINCE_UPDATE)
+      Cmd.new(SINCE_UPDATE)
     end
 
     # Create expression that returns record expiration time expressed as 64 bit integer
@@ -267,42 +287,42 @@ module Aerospike
     # 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))))
+    #   # 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
-      new Cmd.new(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))
+    #   # Record expires in less than 1 hour
+    #   Exp.lt(Exp.ttl, Exp.val(60 * 60))
     def self.ttl
-      new Cmd.new(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
+    #   # Deleted records that are in tombstone state.
+    #   Exp.is_tombstone
     def self.is_tombstone
-      new Cmd.new(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.val(1))
+    #   # Records that have digest(key) % 3 == 1
+    #   Exp.eq(Exp.digest_modulo(3), Exp.int_val(1))
     def self.digest_modulo(mod)
-      new CmdInt.new(DIGEST_MODULO, mod)
+      CmdInt.new(DIGEST_MODULO, mod)
     end
 
     # Create expression that performs a regex match on a string bin or string value expression.
@@ -310,13 +330,13 @@ module Aerospike
     # ==== 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", RegexFlag.ICASE | RegexFlag.NEWLINE, Exp.string_bin("a"))
+    # 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 com.aerospike.client.query.RegexFlag}
+    # @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)
-      new Regex.new(bin, regex, flags)
+      Regex.new(bin, regex, flags)
     end
 
     #--------------------------------------------------
@@ -327,23 +347,23 @@ module Aerospike
     #
     # ==== Examples
     # # Query region within coordinates.
-    # String 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))
+    #   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)
-      new CmdExp.new(GEO, left, right)
+      CmdExp.new(GEO, left, right)
     end
 
     # Create geospatial json string value.
     def self.geo(val)
-      new Geo.new(val)
+      Geo.new(val)
     end
 
     #--------------------------------------------------
@@ -351,43 +371,43 @@ module Aerospike
     #--------------------------------------------------
 
     # Create boolean value.
-    def self.val(val)
-      new Bool.new(val)
+    def self.bool_val(val)
+      Bool.new(val)
     end
 
     # Create 64 bit integer value.
-    def self.val(val)
-      new Int.new(val)
+    def self.int_val(val)
+      Int.new(val)
     end
 
     # Create 64 bit floating point value.
-    def self.val(val)
-      new Float.new(val)
+    def self.float_val(val)
+      Float.new(val)
     end
 
     # Create string value.
-    def self.val(val)
-      new Str.new(val)
+    def self.str_val(val)
+      Str.new(val)
     end
 
     # Create blob byte value.
-    def self.val(val)
-      new Blob.new(val)
+    def self.blob_val(val)
+      Blob.new(val)
     end
 
     # Create list value.
-    def self.val(list)
-      new ListVal.new(list)
+    def self.list_val(*list)
+      ListVal.new(list)
     end
 
     # Create map value.
-    def self.val(map)
-      new MapVal.new(map)
+    def self.map_val(map)
+      MapVal.new(map)
     end
 
     # Create nil value.
-    def self.nil
-      new Nil.new
+    def self.nil_val
+      Nil.new
     end
 
     #--------------------------------------------------
@@ -397,103 +417,103 @@ module Aerospike
     # 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.val(10))))
+    #   # ! (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)
-      new CmdExp.new(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)))
+    #   # (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)
-      new CmdExp.new(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)))
+    #   # 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)
-      new CmdExp.new(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)))
+    #   # 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)
-      new CmdExp.new(EXCLUSIVE, exps)
+      CmdExp.new(EXCLUSIVE, *exps)
     end
 
     # Create equal (==) expression.
     #
     # ==== Examples
-    # # a == 11
-    # Exp.eq(Exp.int_bin("a"), Exp.val(11))
+    #   # a == 11
+    #   Exp.eq(Exp.int_bin("a"), Exp.int_val(11))
     def self.eq(left, right)
-      new CmdExp.new(EQ, left, right)
+      CmdExp.new(EQ, left, right)
     end
 
     # Create not equal (!=) expression
     #
     # ==== Examples
-    # # a != 13
-    # Exp.ne(Exp.int_bin("a"), Exp.val(13))
+    #   # a != 13
+    #   Exp.ne(Exp.int_bin("a"), Exp.int_val(13))
     def self.ne(left, right)
-      new CmdExp.new(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))
+    #   # a > 8
+    #   Exp.gt(Exp.int_bin("a"), Exp.val(8))
     def self.gt(left, right)
-      new CmdExp.new(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))
+    #   # a >= 88
+    #   Exp.ge(Exp.int_bin("a"), Exp.val(88))
     def self.ge(left, right)
-      new CmdExp.new(GE, left, right)
+      CmdExp.new(GE, left, right)
     end
 
     # Create less than (<) operation.
     #
     # ==== Examples
-    # # a < 1000
-    # Exp.lt(Exp.int_bin("a"), Exp.val(1000))
+    #   # a < 1000
+    #   Exp.lt(Exp.int_bin("a"), Exp.int_val(1000))
     def self.lt(left, right)
-      new CmdExp.new(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.val(1))
+    #   # a <= 1
+    #   Exp.le(Exp.int_bin("a"), Exp.int_val(1))
     def self.le(left, right)
-      new CmdExp.new(LE, left, right)
+      CmdExp.new(LE, left, right)
     end
 
     #--------------------------------------------------
@@ -505,12 +525,12 @@ module Aerospike
     # 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.val(10))
+    #   # 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)
-      new CmdExp.new(ADD, exps)
+      CmdExp.new(ADD, *exps)
     end
 
     # Create "subtract" (-) operator that applies to a variable number of expressions.
@@ -520,12 +540,12 @@ module Aerospike
     # 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.val(10))
+    #   # 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)
-      new CmdExp.new(SUB, exps)
+      CmdExp.new(SUB, *exps)
     end
 
     # Create "multiply" (*) operator that applies to a variable number of expressions.
@@ -534,12 +554,12 @@ module Aerospike
     # 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.val(100))
+    #   # 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)
-      new CmdExp.new(MUL, exps)
+      CmdExp.new(MUL, *exps)
     end
 
     # Create "divide" (/) operator that applies to a variable number of expressions.
@@ -549,12 +569,12 @@ module Aerospike
     # 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.val(1))
+    #   # 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)
-      new CmdExp.new(DIV, exps)
+      CmdExp.new(DIV, *exps)
     end
 
     # Create "power" operator that raises a "base" to the "exponent" power.
@@ -562,12 +582,12 @@ module Aerospike
     # 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))
+    #   # 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)
-      new CmdExp.new(POW, base, exponent)
+      CmdExp.new(POW, base, exponent)
     end
 
     # Create "log" operator for logarithm of "num" with base "base".
@@ -575,12 +595,12 @@ module Aerospike
     # 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))
+    #   # 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)
-      new CmdExp.new(LOG, num, base)
+      CmdExp.new(LOG, num, base)
     end
 
     # Create "modulo" (%) operator that determines the remainder of "numerator"
@@ -588,12 +608,12 @@ module Aerospike
     # Requires server version 5.6.0+.
     #
     # ==== Examples
-    # # a % 10 == 0
-    # Exp.eq(
-    #   Exp.mod(Exp.int_bin("a"), Exp.val(10)),
-    #   Exp.val(0))
+    #   # a % 10 == 0
+    #   Exp.eq(
+    #     Exp.mod(Exp.int_bin("a"), Exp.int_val(10)),
+    #     Exp.val(0))
     def self.mod(numerator, denominator)
-      new CmdExp.new(MOD, numerator, denominator)
+      CmdExp.new(MOD, numerator, denominator)
     end
 
     # Create operator that returns absolute value of a number.
@@ -601,60 +621,60 @@ module Aerospike
     # Requires server version 5.6.0+.
     #
     # ==== Examples
-    # # abs(a) == 1
-    # Exp.eq(
-    #   Exp.abs(Exp.int_bin("a")),
-    #   Exp.val(1))
+    #   # abs(a) == 1
+    #   Exp.eq(
+    #     Exp.abs(Exp.int_bin("a")),
+    #     Exp.int_val(1))
     def self.abs(value)
-      new CmdExp.new(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))
+    #   # floor(2.95) == 2.0
+    #   Exp.eq(
+    #     Exp.floor(Exp.val(2.95)),
+    #     Exp.val(2.0))
     def self.floor(num)
-      new CmdExp.new(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))
+    #   # ceil(2.15) >= 3.0
+    #   Exp.ge(
+    #     Exp.ceil(Exp.val(2.15)),
+    #     Exp.val(3.0))
     def self.ceil(num)
-      new CmdExp.new(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))
+    #   # int(2.5) == 2
+    #   Exp.eq(
+    #     Exp.to_int(Exp.val(2.5)),
+    #     Exp.val(2))
     def self.to_int(num)
-      new CmdExp.new(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))
+    #   # float(2) == 2.0
+    #   Exp.eq(
+    #     Exp.to_float(Exp.val(2))),
+    #     Exp.val(2.0))
     def self.to_float(num)
-      new CmdExp.new(TO_FLOAT, num)
+      CmdExp.new(TO_FLOAT, num)
     end
 
     # Create integer "and" (&) operator that is applied to two or more integers.
@@ -662,12 +682,12 @@ module Aerospike
     # 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))
+    #   # a & 0xff == 0x11
+    #   Exp.eq(
+    #     Exp.int_and(Exp.int_bin("a"), Exp.val(0xff)),
+    #     Exp.val(0x11))
     def self.int_and(*exps)
-      new CmdExp.new(exps)
+      CmdExp.new(INT_AND, *exps)
     end
 
     # Create integer "or" (|) operator that is applied to two or more integers.
@@ -675,12 +695,12 @@ module Aerospike
     # 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))
+    #   # a | 0x10 != 0
+    #   Exp.ne(
+    #     Exp.int_or(Exp.int_bin("a"), Exp.val(0x10)),
+    #     Exp.val(0))
     def self.int_or(*exps)
-      new CmdExp.new(exps)
+      CmdExp.new(INT_OR, *exps)
     end
 
     # Create integer "xor" (^) operator that is applied to two or more integers.
@@ -688,72 +708,72 @@ module Aerospike
     # Requires server version 5.6.0+.
     #
     # ==== Examples
-    # # a ^ b == 16
-    # Exp.eq(
-    #   Exp.int_xor(Exp.int_bin("a"), Exp.int_bin("b")),
-    #   Exp.val(16))
+    #   # 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)
-      new CmdExp.new(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))
+    #   # ~a == 7
+    #   Exp.eq(
+    #     Exp.int_not(Exp.int_bin("a")),
+    #     Exp.val(7))
     def self.int_not(exp)
-      new CmdExp.new(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))
+    #   # a << 8 > 0xff
+    #   Exp.gt(
+    #     Exp.lshift(Exp.int_bin("a"), Exp.val(8)),
+    #     Exp.val(0xff))
     def self.lshift(value, shift)
-      new CmdExp.new(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))
+    #   # a >>> 8 > 0xff
+    #   Exp.gt(
+    #     Exp.rshift(Exp.int_bin("a"), Exp.val(8)),
+    #     Exp.val(0xff))
     def self.rshift(value, shift)
-      new CmdExp.new(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))
+    #   # a >> 8 > 0xff
+    #   Exp.gt(
+    #     Exp.arshift(Exp.int_bin("a"), Exp.val(8)),
+    #     Exp.val(0xff))
     def self.arshift(value, shift)
-      new CmdExp.new(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))
+    #   # count(a) == 4
+    #   Exp.eq(
+    #     Exp.count(Exp.int_bin("a")),
+    #     Exp.val(4))
     def self.count(exp)
-      new CmdExp.new(exp)
+      CmdExp.new(INT_COUNT, exp)
     end
 
     # Create expression that scans integer bits from left (most significant bit) to
@@ -764,12 +784,12 @@ module Aerospike
     # 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))
+    #   # lscan(a, true) == 4
+    #   Exp.eq(
+    #     Exp.lscan(Exp.int_bin("a"), Exp.val(true)),
+    #     Exp.val(4))
     def self.lscan(value, search)
-      new CmdExp.new(value, search)
+      CmdExp.new(INT_LSCAN, value, search)
     end
 
     # Create expression that scans integer bits from right (least significant bit) to
@@ -780,12 +800,12 @@ module Aerospike
     # 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))
+    #   # rscan(a, true) == 4
+    #   Exp.eq(
+    #     Exp.rscan(Exp.int_bin("a"), Exp.val(true)),
+    #     Exp.val(4))
     def self.rscan(value, search)
-      new CmdExp.new(value, search)
+      CmdExp.new(INT_RSCAN, value, search)
     end
 
     # Create expression that returns the minimum value in a variable number of expressions.
@@ -793,12 +813,12 @@ module Aerospike
     # 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))
+    #   # 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)
-      new CmdExp.new(MIN, exps)
+      CmdExp.new(MIN, *exps)
     end
 
     # Create expression that returns the maximum value in a variable number of expressions.
@@ -806,12 +826,12 @@ module Aerospike
     # 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.val(100))
+    #   # 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)
-      new CmdExp.new(MAX, exps)
+      CmdExp.new(MAX, *exps)
     end
 
     #--------------------------------------------------
@@ -825,13 +845,13 @@ module Aerospike
     # 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.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))
+    #   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)
-      new CmdExp.new(COND, exps)
+      CmdExp.new(COND, *exps)
     end
 
     # Define variables and expressions in scope.
@@ -848,9 +868,9 @@ module Aerospike
     #   Exp.def("x", Exp.int_bin("a")),
     #   Exp.and(
     #     Exp.lt(Exp.val(5), Exp.var("x")),
-    #     Exp.lt(Exp.var("x"), Exp.val(10))))
+    #     Exp.lt(Exp.var("x"), Exp.int_val(10))))
     def self.let(*exps)
-      new Let.new(exps)
+      Let.new(exps)
     end
 
     # Assign variable to a {@link Exp#let(Exp...)} expression that can be accessed later.
@@ -862,9 +882,9 @@ module Aerospike
     #   Exp.def("x", Exp.int_bin("a")),
     #   Exp.and(
     #     Exp.lt(Exp.val(5), Exp.var("x")),
-    #     Exp.lt(Exp.var("x"), Exp.val(10))))
+    #     Exp.lt(Exp.var("x"), Exp.int_val(10))))
     def self.def(name, value)
-      new Def.new(name, value)
+      Def.new(name, value)
     end
 
     # Retrieve expression value from a variable.
@@ -876,9 +896,9 @@ module Aerospike
     #   Exp.def("x", Exp.int_bin("a")),
     #   Exp.and(
     #     Exp.lt(Exp.val(5), Exp.var("x")),
-    #     Exp.lt(Exp.var("x"), Exp.val(10))))
+    #     Exp.lt(Exp.var("x"), Exp.int_val(10))))
     def self.var(name)
-      new CmdStr.new(VAR, name)
+      CmdStr.new(VAR, name)
     end
 
     #--------------------------------------------------
@@ -886,20 +906,20 @@ module Aerospike
     #--------------------------------------------------
 
     # Create unknown value. Used to intentionally fail an expression.
-    # The failure can be ignored with {@link com.aerospike.client.exp.exp_write_flags#EVAL_NO_FAIL}
-    # or {@link com.aerospike.client.exp.exp_read_flags#EVAL_NO_FAIL}.
+    # 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.val(100.0))),
+    #   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
-      new Cmd.new(UNKNOWN)
+      Cmd.new(UNKNOWN)
     end
 
     # # Merge precompiled expression into a new expression tree.
@@ -909,7 +929,7 @@ module Aerospike
     # # ==== 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.val(100))))
+    # # 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
@@ -919,6 +939,28 @@ module Aerospike
     #--------------------------------------------------
     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
@@ -978,8 +1020,33 @@ module Aerospike
     CALL = 127
     NANOS_PER_MILLIS = 1000000
 
-    def pack(packer)
-      raise "Unreachable"
+    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.
@@ -997,12 +1064,13 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(5)
-        packer.pack_int(Exp::CALL)
-        packer.pack_int(ret_type)
-        packer.pack_int(modul)
-        packer.pack_byte_array(bytes, 0, bytes.length)
-        bin.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
 
@@ -1016,10 +1084,10 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(3)
-        packer.pack_int(BIN)
-        packer.pack_int(type.code)
-        packer.pack_string(name)
+        packer.write_array_header(3)
+        packer.write(BIN)
+        packer.write(@type)
+        packer.write(@name)
       end
     end
 
@@ -1035,11 +1103,11 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(4)
-        packer.pack_int(REGEX)
-        packer.pack_int(flags)
-        packer.pack_string(regex)
-        bin.pack(packer)
+        packer.write_array_header(4)
+        packer.write(REGEX)
+        packer.write(@flags)
+        packer.write(@regex)
+        @bin.pack(packer)
       end
     end
 
@@ -1052,11 +1120,11 @@ module Aerospike
 
       def pack(packer)
         # Let wire format: LET <defname1>, <defexp1>, <defname2>, <defexp2>, ..., <scope exp>
-        count = (exps.length - 1) * 2 + 2
-        packer.pack_array_begin(count)
-        packer.pack_int(LET)
+        count = (@exps.length - 1) * 2 + 2
+        packer.write_array_header(count)
+        packer.write(LET)
 
-        exps.each do |exp|
+        @exps.each do |exp|
           exp.pack(packer)
         end
       end
@@ -1072,8 +1140,8 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_string(name)
-        exp::pack(packer)
+        packer.write(@name)
+        @exp.pack(packer)
       end
     end
 
@@ -1081,16 +1149,15 @@ module Aerospike
       attr_reader :exps
       attr_reader :cmd
 
-      def initialize(cmd, exps)
+      def initialize(cmd, *exps)
         @exps = exps
         @cmd = cmd
       end
 
       def pack(packer)
-        packer.pack_array_begin(exps.length + 1)
-        packer.pack_int(cmd)
-
-        exps.each do |exp|
+        packer.write_array_header(@exps.length + 1)
+        packer.write(@cmd)
+        @exps.each do |exp|
           exp.pack(packer)
         end
       end
@@ -1106,9 +1173,9 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(2)
-        packer.pack_int(cmd)
-        packer.pack_int(val)
+        packer.write_array_header(2)
+        Value.of(@cmd).pack(packer)
+        Value.of(@val).pack(packer)
       end
     end
 
@@ -1122,9 +1189,9 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(2)
-        packer.pack_int(cmd)
-        packer.pack_string(str)
+        packer.write_array_header(2)
+        Value.of(@cmd).pack(packer)
+        packer.write(@str)
       end
     end
 
@@ -1136,8 +1203,8 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_array_begin(1)
-        packer.pack_int(cmd)
+        packer.write_array_header(1)
+        packer.write(@cmd)
       end
     end
 
@@ -1149,7 +1216,7 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_boolean(val)
+        BoolValue.new(@val).pack(packer)
       end
     end
 
@@ -1157,11 +1224,11 @@ module Aerospike
       attr_reader :val
 
       def initialize(val)
-        @val = val
+        @val = val.to_i
       end
 
       def pack(packer)
-        packer.pack_long(val)
+        IntegerValue.new(@val).pack(packer)
       end
     end
 
@@ -1169,11 +1236,11 @@ module Aerospike
       attr_reader :val
 
       def initialize(val)
-        @val = val
+        @val = val.to_f
       end
 
       def pack(packer)
-        packer.pack_double(val)
+        FloatValue.new(@val).pack(packer)
       end
     end
 
@@ -1185,7 +1252,7 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_particle_string(val)
+        StringValue.new(@val).pack(packer)
       end
     end
 
@@ -1197,7 +1264,7 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_geo_json(val)
+        Value.of(@val).pack(packer)
       end
     end
 
@@ -1209,7 +1276,7 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_particle_bytes(val)
+        BytesValue.new(@val).pack(packer)
       end
     end
 
@@ -1223,9 +1290,9 @@ module Aerospike
       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.pack_array_begin(2)
-        packer.pack_int(QUOTED)
-        packer.pack_list(list)
+        packer.write_array_header(2)
+        packer.write(QUOTED)
+        Value.of(@list).pack(packer)
       end
     end
 
@@ -1237,13 +1304,13 @@ module Aerospike
       end
 
       def pack(packer)
-        packer.pack_map(map)
+        Value.of(@map).pack(packer)
       end
     end
 
     class Nil < Exp
       def pack(packer)
-        packer.pack_nil
+        Value.of(nil).pack(packer)
       end
     end
 
@@ -1251,11 +1318,11 @@ module Aerospike
       attr_reader :bytes
 
       def initialize(e)
-        @bytes = e.getBytes
+        @bytes = e.bytes
       end
 
       def pack(packer)
-        packer.pack_byte_array(bytes, 0, bytes.length)
+        Value.of(@bytes).pack(packer)
       end
     end
   end # class Exp