aerospike 2.11.0 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e8ccb3f64b4605bc10b58af760e35373209b7323b2c06cc04f133dd12c4b7d
-  data.tar.gz: 2b396aec824a2057daef8a6bd054c00bb103e2afd32f2d4c30de6e97853997f3
+  metadata.gz: 71a4730468bf7f38257303515a01945e1221d25f98b35f28d7aa9c0d74e06e3b
+  data.tar.gz: 1bf1fd2c18697d5e7adda3cc5df5b5fdea7ecd2c7f6c81950c7a4f9dbba06ead
 SHA512:
-  metadata.gz: 6eb54355ef98807e3523c93bce1b5c2b440a1340387d351da5fb310f11c513d69622f60e309129ac4ea8897d26f5f3bf38362b3c6995a8241d023e383e17a887
-  data.tar.gz: 217f6f2a2a0b782d0309e7a487416bf47be2e9225dce5899d1d9e54b2b7578a26e9e0535d9ce5dc1a53bf3b1be87c865218482a59ba4e216a68803328c7608ba
+  metadata.gz: 4aeaddd24ad85bc4178973cfe865410536b8aaa2030486715d1495c380438a7e9b5980a36f953623f9da85b4f6ef497273797baad99e0e1af259faf1a6d64c6a
+  data.tar.gz: 899f9ff5ddf4be0085dd6783f382278948f9e466778590e939a8f097b91432745001c65b6bf7ed3494056296a1c80ce1bbba5a9a6473b982101a99c839ea1168

data/CHANGELOG.md

@@ -2,7 +2,56 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [2.16.0] - 2020-10-12
+
+* **New Features**
+  * [CLIENT-1173], [CLIENT-1246] Support Nested CDT operations with Context.
+  * [CLIENT-1179], Support Bitwise operations.
+
+* **Changes**
+  * `ListSortFlags` now has an `ASCENDING` option, with `DEFAULT` mapping to it.
+
+## [2.15.0] - 2020-10-05
+
+* **New Features**
+  * [CLIENT-1254] Adds support for HyperLogLog.
+
+* **Changes**
+  * `Client#operate` now uses `OperatePolicy` by default.
+
+## [2.14.0] - 2020-08-06
+
+* **New Features**
+  * Adds support for rack-aware reads.
+  * Adds support for client-server compression.
+
+* **Improvements**
+  * Adds support for `truncate-namespace` command.
+
+## [2.13.0] - 2020-07-17
+
+* **New Features**
+  * Adds support for replica policies.
+
+* **Improvements**
+  * Remove support for "old" partition tokenizer.
+  * Refactor how partition parser is initialized and called.
+  * Adds support for 'replicas' and remove the old partition table queries from the server.
+
+## [2.12.0] - 2019-04-21
+
+* **New Features**
+  * Support for predicate expressions in all transaction.
+  * Support for `operation.delete` in `client#operate`.
+
+* **Improvements**
+  * Optimize serialization for nested structures. Thanks to [@Kacper Madej](https://github.com/madejejej)! [[#94](https://github.com/aerospike/aerospike-client-ruby/pull/94)]
+  * Remove `Thread#abort_on_exception` from `batch_index_command`. Thanks to [@Kacper Madej](https://github.com/madejejej)! [[#94](https://github.com/aerospike/aerospike-client-ruby/pull/92)]
+  * Does not allow values other than Integer, Float, String, Symbol and nil to be used as keys in Maps.
+
+* **Bug Fixes**
+  * Fixes tests that weren't using ENV variables for connections. This will allow the tests to be run on any server.
+
 
 ## [2.11.0] - 2019-05-17
 

data/README.md

@@ -97,7 +97,7 @@ This library is packaged with a number of tests.
 
 To run all the test cases:
 
-    $ bundle exec rspec
+    $ AEROSPIKE_HOSTS="<host:port>[,<hoist:port>]" AEROSPIKE_USER="<user>" AEROSPIKE_PASSWORD="<pass>" bundle exec rspec
 
 <a name="Examples"></a>
 ## Examples

data/lib/aerospike.rb

@@ -1,4 +1,4 @@
-# Copyright 2014-2018 Aerospike, Inc.
+# Copyright 2014-2020 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -22,6 +22,7 @@ require "timeout"
 require 'resolv'
 require 'msgpack'
 require 'bcrypt'
+require 'zlib'
 
 require 'aerospike/atomic/atomic'
 
@@ -64,6 +65,7 @@ require 'aerospike/command/admin_command'
 require 'aerospike/command/unsupported_particle_type_validator'
 require 'aerospike/key'
 require 'aerospike/operation'
+require 'aerospike/cdt/context'
 require 'aerospike/cdt/list_operation'
 require 'aerospike/cdt/list_order'
 require 'aerospike/cdt/list_return_type'
@@ -76,6 +78,14 @@ require 'aerospike/cdt/map_return_type'
 require 'aerospike/cdt/map_write_flags'
 require 'aerospike/cdt/map_write_mode'
 require 'aerospike/cdt/map_policy'
+require 'aerospike/cdt/hll_operation'
+require 'aerospike/cdt/hll_write_flags'
+require 'aerospike/cdt/hll_policy'
+require 'aerospike/cdt/bit_operation'
+require 'aerospike/cdt/bit_overflow_action'
+require 'aerospike/cdt/bit_resize_flags'
+require 'aerospike/cdt/bit_write_flags'
+require 'aerospike/cdt/bit_policy'
 require 'aerospike/geo_json'
 require 'aerospike/ttl'
 
@@ -101,22 +111,25 @@ require 'aerospike/connection/create'
 
 require 'aerospike/cluster'
 require 'aerospike/cluster/create_connection'
-require 'aerospike/cluster/partition'
 require 'aerospike/cluster/find_nodes_to_remove'
 require 'aerospike/cluster/find_node'
-require 'aerospike/cluster/partition_tokenizer_new'
-require 'aerospike/cluster/partition_tokenizer_old'
+require 'aerospike/cluster/partition'
+require 'aerospike/cluster/partition_parser'
+require 'aerospike/cluster/rack_parser'
 require 'aerospike/node'
 require 'aerospike/node/generation'
+require 'aerospike/node/rebalance'
 require 'aerospike/node/refresh/failed'
 require 'aerospike/node/refresh/friends'
 require 'aerospike/node/refresh/info'
 require 'aerospike/node/refresh/partitions'
+require 'aerospike/node/refresh/racks'
 require 'aerospike/node/refresh/peers'
 require 'aerospike/node/refresh/reset'
 require 'aerospike/node/verify/cluster_name'
 require 'aerospike/node/verify/name'
 require 'aerospike/node/verify/partition_generation'
+require 'aerospike/node/verify/rebalance_generation'
 require 'aerospike/node/verify/peers_generation'
 require 'aerospike/node_validator'
 require 'aerospike/peer'

data/lib/aerospike/aerospike_exception.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2018 Aerospike, Inc.
+# Copyright 2014-2020 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.
@@ -90,5 +90,11 @@ module Aerospike
         super(ResultCode::COMMAND_REJECTED, msg)
       end
     end
+
+    class InvalidNamespace < Aerospike
+      def initialize(msg=nil)
+        super(ResultCode::INVALID_NAMESPACE, msg)
+      end
+    end
   end
 end

data/lib/aerospike/atomic/atomic.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2017 Aerospike, Inc.
+# Copyright 2014-2020 Aerospike, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/aerospike/bin.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# Copyright 2014-2017 Aerospike, Inc.
+# Copyright 2014-2020 Aerospike, Inc.
 #
 # Portions may be licensed to Aerospike, Inc. under one or more contributor
 # license agreements.

data/lib/aerospike/cdt/bit_operation.rb

@@ -0,0 +1,376 @@
+# frozen_string_literal: true
+
+# Copyright 2016-2020 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 not
+# 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
+  module CDT
+
+    ##
+    # Bit operations. Create bit operations used by client operate command.
+    # Offset orientation is left-to-right.  Negative offsets are supported.
+    # If the offset is negative, the offset starts backwards from end of the bitmap.
+    # If an offset is out of bounds, a parameter error will be returned.
+    #
+    # Nested CDT operations are supported by optional context arguments.  Example:
+    # bin = [[0b00000001, 0b01000010],[0b01011010]]
+    # Resize first bitmap (in a list of bitmaps) to 3 bytes.
+    # BitOperation.resize("bin", 3, BitResizeFlags::DEFAULT, ctx: [Context.list_index(0)])
+    # bin result = [[0b00000001, 0b01000010, 0b00000000],[0b01011010]]
+    class BitOperation < Operation
+
+      RESIZE   = 0
+      INSERT   = 1
+      REMOVE   = 2
+      SET      = 3
+      OR       = 4
+      XOR      = 5
+      AND      = 6
+      NOT      = 7
+      LSHIFT   = 8
+      RSHIFT   = 9
+      ADD      = 10
+      SUBTRACT = 11
+      SET_INT  = 12
+      GET      = 50
+      COUNT    = 51
+      LSCAN    = 52
+      RSCAN    = 53
+      GET_INT  = 54
+
+      INT_FLAGS_SIGNED = 1
+
+      attr_reader :bit_op, :arguments, :policy, :ctx
+
+      def initialize(op_type, bit_op, bin_name, *arguments, ctx: nil, policy: nil)
+        @op_type = op_type
+        @bin_name = bin_name
+        @bin_value = nil
+        @bit_op = bit_op
+        @ctx = ctx
+        @arguments = arguments
+      end
+
+
+      # BitResizeOp creates byte "resize" operation.
+      # Server resizes byte[] to byte_size according to resize_flags (See {@link BitResizeFlags}).
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010]
+      # byte_size = 4
+      # resize_flags = 0
+      # bin result = [0b00000001, 0b01000010, 0b00000000, 0b00000000]
+      def self.resize(bin_name, byte_size, resize_flags, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, RESIZE, bin_name, byte_size, policy.flags, resize_flags, ctx: ctx, policy: policy)
+      end
+
+      # BitInsertOp creates byte "insert" operation.
+      # Server inserts value bytes into byte[] bin at byte_offset.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # byte_offset = 1
+      # value = [0b11111111, 0b11000111]
+      # bin result = [0b00000001, 0b11111111, 0b11000111, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      def self.insert(bin_name, byte_offset, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, INSERT, bin_name, byte_offset, value_to_bytes(value), policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitRemoveOp creates byte "remove" operation.
+      # Server removes bytes from byte[] bin at byte_offset for byte_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # byte_offset = 2
+      # byte_size = 3
+      # bin result = [0b00000001, 0b01000010]
+      def self.remove(bin_name, byte_offset, byte_size, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, REMOVE, bin_name, byte_offset, byte_size, policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitSetOp creates bit "set" operation.
+      # Server sets value on byte[] bin at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 13
+      # bit_size = 3
+      # value = [0b11100000]
+      # bin result = [0b00000001, 0b01000111, 0b00000011, 0b00000100, 0b00000101]
+      def self.set(bin_name, bit_offset, bit_size, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, SET, bin_name, bit_offset, bit_size, value_to_bytes(value), policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitOrOp creates bit "or" operation.
+      # Server performs bitwise "or" on value and byte[] bin at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 17
+      # bit_size = 6
+      # value = [0b10101000]
+      # bin result = [0b00000001, 0b01000010, 0b01010111, 0b00000100, 0b00000101]
+      def self.or(bin_name, bit_offset, bit_size, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, OR, bin_name, bit_offset, bit_size, value_to_bytes(value), policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitXorOp creates bit "exclusive or" operation.
+      # Server performs bitwise "xor" on value and byte[] bin at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 17
+      # bit_size = 6
+      # value = [0b10101100]
+      # bin result = [0b00000001, 0b01000010, 0b01010101, 0b00000100, 0b00000101]
+      def self.xor(bin_name, bit_offset, bit_size, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, XOR, bin_name, bit_offset, bit_size, value_to_bytes(value), policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitAndOp creates bit "and" operation.
+      # Server performs bitwise "and" on value and byte[] bin at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 23
+      # bit_size = 9
+      # value = [0b00111100, 0b10000000]
+      # bin result = [0b00000001, 0b01000010, 0b00000010, 0b00000000, 0b00000101]
+      def self.and(bin_name, bit_offset, bit_size, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, AND, bin_name, bit_offset, bit_size, value_to_bytes(value), policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitNotOp creates bit "not" operation.
+      # Server negates byte[] bin starting at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 25
+      # bit_size = 6
+      # bin result = [0b00000001, 0b01000010, 0b00000011, 0b01111010, 0b00000101]
+      def self.not(bin_name, bit_offset, bit_size, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, NOT, bin_name, bit_offset, bit_size, policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitLShiftOp creates bit "left shift" operation.
+      # Server shifts left byte[] bin starting at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 32
+      # bit_size = 8
+      # shift = 3
+      # bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00101000]
+      def self.lshift(bin_name, bit_offset, bit_size, shift, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, LSHIFT, bin_name, bit_offset, bit_size, shift, policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitRShiftOp creates bit "right shift" operation.
+      # Server shifts right byte[] bin starting at bit_offset for bit_size.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 0
+      # bit_size = 9
+      # shift = 1
+      # bin result = [0b00000000, 0b11000010, 0b00000011, 0b00000100, 0b00000101]
+      def self.rshift(bin_name, bit_offset, bit_size, shift, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, RSHIFT, bin_name, bit_offset, bit_size, shift, policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitAddOp creates bit "add" operation.
+      # Server adds value to byte[] bin starting at bit_offset for bit_size. Bit_size must be <= 64.
+      # Signed indicates if bits should be treated as a signed number.
+      # If add overflows/underflows, {@link BitOverflowAction} is used.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 24
+      # bit_size = 16
+      # value = 128
+      # signed = false
+      # bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b10000101]
+      def self.add(
+        bin_name,
+        bit_offset,
+        bit_size,
+        value,
+        signed,
+        action,
+        ctx: nil,
+        policy: BitPolicy::DEFAULT
+      )
+        actionFlags = action
+        actionFlags |= INT_FLAGS_SIGNED if signed
+
+        BitOperation.new(Operation::BIT_MODIFY, ADD, bin_name, bit_offset, bit_size, value, policy.flags, actionFlags, ctx: ctx, policy: policy)
+      end
+
+      # BitSubtractOp creates bit "subtract" operation.
+      # Server subtracts value from byte[] bin starting at bit_offset for bit_size. Bit_size must be <= 64.
+      # Signed indicates if bits should be treated as a signed number.
+      # If add overflows/underflows, {@link BitOverflowAction} is used.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 24
+      # bit_size = 16
+      # value = 128
+      # signed = false
+      # bin result = [0b00000001, 0b01000010, 0b00000011, 0b0000011, 0b10000101]
+      def self.subtract(
+        bin_name,
+        bit_offset,
+        bit_size,
+        value,
+        signed,
+        action,
+        ctx: nil,
+        policy: BitPolicy::DEFAULT
+      )
+        actionFlags = action
+        actionFlags |= INT_FLAGS_SIGNED if signed
+
+        BitOperation.new(Operation::BIT_MODIFY, SUBTRACT, bin_name, bit_offset, bit_size, value, policy.flags, actionFlags, ctx: ctx, policy: policy)
+      end
+
+      # BitSetIntOp creates bit "setInt" operation.
+      # Server sets value to byte[] bin starting at bit_offset for bit_size. Size must be <= 64.
+      # Server does not return a value.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 1
+      # bit_size = 8
+      # value = 127
+      # bin result = [0b00111111, 0b11000010, 0b00000011, 0b0000100, 0b00000101]
+      def self.set_int(bin_name, bit_offset, bit_size, value, ctx: nil, policy: BitPolicy::DEFAULT)
+        BitOperation.new(Operation::BIT_MODIFY, SET_INT, bin_name, bit_offset, bit_size, value, policy.flags, ctx: ctx, policy: policy)
+      end
+
+      # BitGetOp creates bit "get" operation.
+      # Server returns bits from byte[] bin starting at bit_offset for bit_size.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 9
+      # bit_size = 5
+      # returns [0b1000000]
+      def self.get(bin_name, bit_offset, bit_size, ctx: nil)
+        BitOperation.new(Operation::BIT_READ, GET, bin_name, bit_offset, bit_size, ctx: ctx)
+      end
+
+      # BitCountOp creates bit "count" operation.
+      # Server returns integer count of set bits from byte[] bin starting at bit_offset for bit_size.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 20
+      # bit_size = 4
+      # returns 2
+      def self.count(bin_name, bit_offset, bit_size, ctx: nil)
+        BitOperation.new(Operation::BIT_READ, COUNT, bin_name, bit_offset, bit_size, ctx: ctx)
+      end
+
+      # BitLScanOp creates bit "left scan" operation.
+      # Server returns integer bit offset of the first specified value bit in byte[] bin
+      # starting at bit_offset for bit_size.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 24
+      # bit_size = 8
+      # value = true
+      # returns 5
+      def self.lscan(bin_name, bit_offset, bit_size, value, ctx: nil)
+        BitOperation.new(Operation::BIT_READ, LSCAN, bin_name, bit_offset, bit_size, value && true, ctx: ctx)
+      end
+
+      # BitRScanOp creates bit "right scan" operation.
+      # Server returns integer bit offset of the last specified value bit in byte[] bin
+      # starting at bit_offset for bit_size.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 32
+      # bit_size = 8
+      # value = true
+      # returns 7
+      def self.rscan(bin_name, bit_offset, bit_size, value, ctx: nil)
+        BitOperation.new(Operation::BIT_READ, RSCAN, bin_name, bit_offset, bit_size, value && true, ctx: ctx)
+      end
+
+      # BitGetIntOp creates bit "get integer" operation.
+      # Server returns integer from byte[] bin starting at bit_offset for bit_size.
+      # Signed indicates if bits should be treated as a signed number.
+      # Example:
+      # bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
+      # bit_offset = 8
+      # bit_size = 16
+      # signed = false
+      # returns 16899
+      def self.get_int(bin_name, bit_offset, bit_size, signed, ctx: nil)
+        if signed
+          BitOperation.new(Operation::BIT_READ, GET_INT, bin_name, bit_offset, bit_size, INT_FLAGS_SIGNED, ctx: ctx)
+        else
+          BitOperation.new(Operation::BIT_READ, GET_INT, bin_name, bit_offset, bit_size, ctx: ctx)
+        end
+      end
+
+      def bin_value
+        @bin_value ||= pack_bin_value
+      end
+
+      private
+
+      def self.value_to_bytes(value)
+        case value
+        when Integer
+          [value].pack('C*')
+        when Array
+          value.pack('C*')
+        when String
+          BytesValue.new(value)
+        when StringValue
+          BytesValue.new(value.get)
+        else
+          value
+        end
+      end
+
+      def pack_bin_value
+        bytes = nil
+        args = arguments.dup
+        Packer.use do |packer|
+          if @ctx != nil && @ctx.length > 0
+            packer.write_array_header(3)
+            Value.of(0xff).pack(packer)
+
+            packer.write_array_header(@ctx.length*2)
+            @ctx.each do |ctx|
+              Value.of(ctx.id).pack(packer)
+              Value.of(ctx.value, true).pack(packer)
+            end
+          end
+
+          packer.write_array_header(args.length+1)
+          Value.of(@bit_op, true).pack(packer)
+          args.each do |value|
+            Value.of(value, true).pack(packer)
+          end
+          bytes = packer.bytes
+        end
+        BytesValue.new(bytes)
+      end
+    end
+  end
+end