cql-rb 1.0.0.pre7 → 1.0.0.pre8

data/lib/cql/future.rb

@@ -26,7 +26,11 @@ module Cql
     # @return [Future<Array>] an array of the values of the constituent futures
     #
     def self.combine(*futures)
-      CombinedFuture.new(*futures)
+      if futures.any?
+        CombinedFuture.new(*futures)
+      else
+        completed([])
+      end
     end
 
     # Creates a new future which is completed.
@@ -40,7 +44,7 @@ module Cql
 
     # Creates a new future which is failed.
     #
-    # @param [Error] the error of the created future
+    # @param [Error] error the error of the created future
     # @return [Future] a failed future
     #
     def self.failed(error)
@@ -91,7 +95,7 @@ module Cql
     #
     # If the future fails this method will raise the error that failed the future.
     #
-    # @returns [Object] the value of this future
+    # @return [Object] the value of this future
     #
     def value
       raise @error if @error

data/lib/cql/io.rb

@@ -5,6 +5,7 @@ module Cql
 
   module Io
     ConnectionError = Class.new(IoError)
+    ConnectionClosedError = Class.new(IoError)
     ConnectionTimeoutError = Class.new(ConnectionError)
     NotRunningError = Class.new(CqlError)
     ConnectionNotFoundError = Class.new(CqlError)

data/lib/cql/io/io_reactor.rb

@@ -81,6 +81,12 @@ module Cql
         connection.on_close do
           @lock.synchronize do
             @connections.delete(connection)
+            connection_commands, @command_queue = @command_queue.partition do |command|
+              command.is_a?(TargetedRequestCommand) && command.connection_id == connection.connection_id
+            end
+            connection_commands.each do |command|
+              command.future.fail!(ConnectionClosedError.new)
+            end
           end
         end
         f = connection.open
@@ -93,7 +99,7 @@ module Cql
 
       # Sends a request over a random, or specific connection.
       #
-      # @param [Cql::Protocol::RequestBody] request the request to send
+      # @param [Cql::Protocol::Request] request the request to send
       # @param [Object] connection_id the ID of the connection which should be
       #   used to send the request
       # @return [Future<ResultResponse>] a future representing the result of the request
@@ -163,7 +169,7 @@ module Cql
               if connection && connection.connected? && connection.has_capacity?
                 connection.perform_request(command.request, command.future)
               elsif connection && connection.connected?
-                command.future.fail!(ConnectionBusyError.new("Connection ##{command.connection_id} is busy"))
+                unexecuted_commands << command
               else
                 command.future.fail!(ConnectionNotFoundError.new("Connection ##{command.connection_id} does not exist"))
               end
@@ -176,7 +182,7 @@ module Cql
               end
             end
           end
-          @command_queue.unshift(*unexecuted_commands) if unexecuted_commands.any?
+          @command_queue = unexecuted_commands
         end
       end
     end

data/lib/cql/io/node_connection.rb

@@ -92,7 +92,7 @@ module Cql
 
       def perform_request(request, future)
         stream_id = next_stream_id
-        Protocol::RequestFrame.new(request, stream_id).write(@write_buffer)
+        @write_buffer << request.encode_frame(stream_id)
         @response_tasks[stream_id] = future
       rescue => e
         case e
@@ -111,7 +111,7 @@ module Cql
           handle_connecting
         else
           if !@write_buffer.empty?
-            bytes_written = @io.write_nonblock(@write_buffer)
+            bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
             @write_buffer.discard(bytes_written)
           end
         end

data/lib/cql/protocol.rb

@@ -26,12 +26,14 @@ module Cql
 
       BYTES_FORMAT = 'C*'.freeze
       TWO_INTS_FORMAT = 'NN'.freeze
-      HEADER_FORMAT = 'c4'.freeze
+      HEADER_FORMAT = 'c4N'.freeze
     end
 
     module Constants
       TRUE_BYTE = "\x01".freeze
       FALSE_BYTE = "\x00".freeze
+      PROTOCOL_VERSION = "\x01".freeze
+      COMPRESSION_OFF = "\x00".freeze
     end
   end
 end
@@ -39,7 +41,7 @@ end
 require 'cql/protocol/encoding'
 require 'cql/protocol/decoding'
 require 'cql/protocol/type_converter'
-require 'cql/protocol/response_body'
+require 'cql/protocol/response'
 require 'cql/protocol/responses/error_response'
 require 'cql/protocol/responses/detailed_error_response'
 require 'cql/protocol/responses/ready_response'
@@ -55,7 +57,7 @@ require 'cql/protocol/responses/event_response'
 require 'cql/protocol/responses/schema_change_event_result_response'
 require 'cql/protocol/responses/status_change_event_result_response'
 require 'cql/protocol/responses/topology_change_event_result_response'
-require 'cql/protocol/request_body'
+require 'cql/protocol/request'
 require 'cql/protocol/requests/startup_request'
 require 'cql/protocol/requests/credentials_request'
 require 'cql/protocol/requests/options_request'
@@ -64,4 +66,3 @@ require 'cql/protocol/requests/query_request'
 require 'cql/protocol/requests/prepare_request'
 require 'cql/protocol/requests/execute_request'
 require 'cql/protocol/response_frame'
-require 'cql/protocol/request_frame'

data/lib/cql/protocol/request.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class Request
+      include Encoding
+
+      attr_reader :opcode
+
+      def initialize(opcode)
+        @opcode = opcode
+      end
+
+      def encode_frame(stream_id=0, buffer=ByteBuffer.new)
+        raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
+        buffer << [1, 0, stream_id, opcode, 0].pack(Formats::HEADER_FORMAT)
+        write(buffer)
+        buffer.update(4, [(buffer.bytesize - 8)].pack(Formats::INT_FORMAT))
+        buffer
+      end
+    end
+  end
+end

data/lib/cql/protocol/requests/credentials_request.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class CredentialsRequest < RequestBody
+    class CredentialsRequest < Request
       attr_reader :credentials
 
       def initialize(credentials)

data/lib/cql/protocol/requests/execute_request.rb

@@ -2,25 +2,21 @@
 
 module Cql
   module Protocol
-    class ExecuteRequest < RequestBody
+    class ExecuteRequest < Request
       attr_reader :id, :metadata, :values, :consistency
 
       def initialize(id, metadata, values, consistency)
-        super(10)
         raise ArgumentError, "Metadata for #{metadata.size} columns, but #{values.size} values given" if metadata.size != values.size
+        super(10)
         @id = id
         @metadata = metadata
         @values = values
         @consistency = consistency
+        @bytes = encode_body
       end
 
       def write(io)
-        write_short_bytes(io, @id)
-        write_short(io, @metadata.size)
-        @metadata.each_with_index do |(_, _, _, type), index|
-          write_value(io, @values[index], type)
-        end
-        write_consistency(io, @consistency)
+        io << @bytes
       end
 
       def to_s
@@ -46,83 +42,16 @@ module Cql
 
       private
 
-      def write_value(io, value, type)
-        if Array === type
-          raise InvalidValueError, 'Value for collection must be enumerable' unless value.is_a?(Enumerable)
-          case type.first
-          when :list, :set
-            _, sub_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |element|
-              rr = ''
-              write_value(rr, element, sub_type)
-              raw << rr[2, rr.length - 2]
-            end
-            write_bytes(io, raw)
-          when :map
-            _, key_type, value_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |key, value|
-              rr = ''
-              write_value(rr, key, key_type)
-              raw << rr[2, rr.length - 2]
-              rr = ''
-              write_value(rr, value, value_type)
-              raw << rr[2, rr.length - 2]
-            end
-            write_bytes(io, raw)
-          else
-            raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
-          end
-        else
-          case type
-          when :ascii
-            write_bytes(io, value.encode(::Encoding::ASCII))
-          when :bigint
-            write_int(io, 8)
-            write_long(io, value)
-          when :blob
-            write_bytes(io, value.encode(::Encoding::BINARY))
-          when :boolean
-            write_int(io, 1)
-            io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
-          when :decimal
-            raw = write_decimal('', value)
-            write_int(io, raw.size)
-            io << raw
-          when :double
-            write_int(io, 8)
-            write_double(io, value)
-          when :float
-            write_int(io, 4)
-            write_float(io, value)
-          when :inet
-            write_int(io, value.ipv6? ? 16 : 4)
-            io << value.hton
-          when :int
-            write_int(io, 4)
-            write_int(io, value)
-          when :text, :varchar
-            write_bytes(io, value.encode(::Encoding::UTF_8))
-          when :timestamp
-            ms = (value.to_f * 1000).to_i
-            write_int(io, 8)
-            write_long(io, ms)
-          when :timeuuid, :uuid
-            write_int(io, 16)
-            write_uuid(io, value)
-          when :varint
-            raw = write_varint('', value)
-            write_int(io, raw.length)
-            io << raw
-          else
-            raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
-          end
+      def encode_body
+        buffer = ByteBuffer.new
+        type_converter = TypeConverter.new
+        write_short_bytes(buffer, @id)
+        write_short(buffer, @metadata.size)
+        @metadata.each_with_index do |(_, _, _, type), index|
+          type_converter.to_bytes(buffer, type, @values[index])
         end
-      rescue TypeError => e
-        raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace
+        write_consistency(buffer, @consistency)
+        buffer.to_s
       end
     end
   end

data/lib/cql/protocol/requests/options_request.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class OptionsRequest < RequestBody
+    class OptionsRequest < Request
       def initialize
         super(5)
       end

data/lib/cql/protocol/requests/prepare_request.rb

@@ -2,10 +2,11 @@
 
 module Cql
   module Protocol
-    class PrepareRequest < RequestBody
+    class PrepareRequest < Request
       attr_reader :cql
 
       def initialize(cql)
+        raise ArgumentError, 'No CQL given!' unless cql
         super(9)
         @cql = cql
       end

data/lib/cql/protocol/requests/query_request.rb

@@ -2,10 +2,12 @@
 
 module Cql
   module Protocol
-    class QueryRequest < RequestBody
+    class QueryRequest < Request
       attr_reader :cql, :consistency
 
       def initialize(cql, consistency)
+        raise ArgumentError, %(No CQL given!) unless cql
+        raise ArgumentError, %(No such consistency: #{consistency.inspect}) unless CONSISTENCIES.include?(consistency)
         super(7)
         @cql = cql
         @consistency = consistency

data/lib/cql/protocol/requests/register_request.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class RegisterRequest < RequestBody
+    class RegisterRequest < Request
       def initialize(*events)
         super(11)
         @events = events

data/lib/cql/protocol/requests/startup_request.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class StartupRequest < RequestBody
+    class StartupRequest < Request
       def initialize(cql_version='3.0.0', compression=nil)
         super(1)
         @arguments = {CQL_VERSION => cql_version}
@@ -11,7 +11,6 @@ module Cql
 
       def write(io)
         write_string_map(io, @arguments)
-        io
       end
 
       def to_s

data/lib/cql/protocol/{response_body.rb → response.rb}

@@ -3,7 +3,7 @@
 
 module Cql
   module Protocol
-    class ResponseBody
+    class Response
       extend Decoding
 
       def self.decode!(buffer)

data/lib/cql/protocol/responses/authenticate_response.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class AuthenticateResponse < ResponseBody
+    class AuthenticateResponse < Response
       attr_reader :authentication_class
 
       def self.decode!(buffer)

data/lib/cql/protocol/responses/error_response.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class ErrorResponse < ResponseBody
+    class ErrorResponse < Response
       attr_reader :code, :message
 
       def initialize(*args)

data/lib/cql/protocol/responses/ready_response.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class ReadyResponse < ResponseBody
+    class ReadyResponse < Response
       def self.decode!(buffer)
         new
       end

data/lib/cql/protocol/responses/result_response.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class ResultResponse < ResponseBody
+    class ResultResponse < Response
       def self.decode!(buffer)
         kind = read_int!(buffer)
         case kind

data/lib/cql/protocol/responses/rows_result_response.rb

@@ -89,7 +89,7 @@ module Cql
         rows_count.times do |row_index|
           row = {}
           column_specs.each do |column_spec|
-            row[column_spec[2]] = type_converter.convert_type(buffer, column_spec[3])
+            row[column_spec[2]] = type_converter.from_bytes(buffer, column_spec[3])
           end
           rows << row
         end

data/lib/cql/protocol/responses/supported_response.rb

@@ -2,7 +2,7 @@
 
 module Cql
   module Protocol
-    class SupportedResponse < ResponseBody
+    class SupportedResponse < Response
       attr_reader :options
 
       def initialize(options)

data/lib/cql/protocol/type_converter.rb

@@ -8,120 +8,193 @@ module Cql
   module Protocol
     class TypeConverter
       include Decoding
+      include Encoding
 
       def initialize
-        @conversions = conversions
+        @from_bytes_converters = from_bytes_converters
+        @to_bytes_converters = to_bytes_converters
       end
 
-      def convert_type(buffer, type, size_bytes=4)
+      def from_bytes(buffer, type, size_bytes=4)
         return nil if buffer.empty?
         case type
         when Array
           return nil unless read_size(buffer, size_bytes)
           case type.first
           when :list
-            convert_list(buffer, @conversions[type[1]])
+            bytes_to_list(buffer, @from_bytes_converters[type[1]])
           when :map
-            convert_map(buffer, @conversions[type[1]], @conversions[type[2]])
+            bytes_to_map(buffer, @from_bytes_converters[type[1]], @from_bytes_converters[type[2]])
           when :set
-            convert_set(buffer, @conversions[type[1]])
+            bytes_to_set(buffer, @from_bytes_converters[type[1]])
           end
         else
-          @conversions[type].call(buffer, size_bytes)
+          @from_bytes_converters[type].call(buffer, size_bytes)
         end
       end
 
-      def conversions
+      def to_bytes(io, type, value, size_bytes=4)
+        case type
+        when Array
+          unless value.is_a?(Enumerable)
+            raise InvalidValueError, 'Value for collection must be enumerable'
+          end
+          case type.first
+          when :list, :set
+            _, sub_type = type
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |element|
+              to_bytes(raw, sub_type, element, 2)
+            end
+            write_bytes(io, raw)
+          when :map
+            _, key_type, value_type = type
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |key, value|
+              to_bytes(raw, key_type, key, 2)
+              to_bytes(raw, value_type, value, 2)
+            end
+            write_bytes(io, raw)
+          else
+            raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
+          end
+        else
+          converter = @to_bytes_converters[type]
+          unless converter
+            raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
+          end
+          converter.call(io, value, size_bytes)
+        end
+      rescue TypeError => e
+        raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace
+      end
+
+      private
+
+      def from_bytes_converters
+        {
+          :ascii => method(:bytes_to_ascii),
+          :bigint => method(:bytes_to_bigint),
+          :blob => method(:bytes_to_blob),
+          :boolean => method(:bytes_to_boolean),
+          :counter => method(:bytes_to_bigint),
+          :decimal => method(:bytes_to_decimal),
+          :double => method(:bytes_to_double),
+          :float => method(:bytes_to_float),
+          :int => method(:bytes_to_int),
+          :timestamp => method(:bytes_to_timestamp),
+          :varchar => method(:bytes_to_varchar),
+          :text => method(:bytes_to_varchar),
+          :varint => method(:bytes_to_varint),
+          :timeuuid => method(:bytes_to_uuid),
+          :uuid => method(:bytes_to_uuid),
+          :inet => method(:bytes_to_inet),
+        }
+      end
+
+      def to_bytes_converters
         {
-          :ascii => method(:convert_ascii),
-          :bigint => method(:convert_bigint),
-          :blob => method(:convert_blob),
-          :boolean => method(:convert_boolean),
-          :counter => method(:convert_bigint),
-          :decimal => method(:convert_decimal),
-          :double => method(:convert_double),
-          :float => method(:convert_float),
-          :int => method(:convert_int),
-          :timestamp => method(:convert_timestamp),
-          :varchar => method(:convert_varchar),
-          :text => method(:convert_varchar),
-          :varint => method(:convert_varint),
-          :timeuuid => method(:convert_uuid),
-          :uuid => method(:convert_uuid),
-          :inet => method(:convert_inet),
+          :ascii => method(:ascii_to_bytes),
+          :bigint => method(:bigint_to_bytes),
+          :blob => method(:blob_to_bytes),
+          :boolean => method(:boolean_to_bytes),
+          :decimal => method(:decimal_to_bytes),
+          :double => method(:double_to_bytes),
+          :float => method(:float_to_bytes),
+          :inet => method(:inet_to_bytes),
+          :int => method(:int_to_bytes),
+          :text => method(:varchar_to_bytes),
+          :varchar => method(:varchar_to_bytes),
+          :timestamp => method(:timestamp_to_bytes),
+          :timeuuid => method(:uuid_to_bytes),
+          :uuid => method(:uuid_to_bytes),
+          :varint => method(:varint_to_bytes),
         }
       end
 
-      def convert_ascii(buffer, size_bytes)
+      def read_size(buffer, size_bytes)
+        if size_bytes == 2
+          size = buffer.read_short
+          return nil if size & 0x8000 == 0x8000
+        else
+          size = buffer.read_int
+          return nil if size & 0x80000000 == 0x80000000
+        end
+        size
+      end
+
+      def bytes_to_ascii(buffer, size_bytes)
         bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
         bytes ? bytes.force_encoding(::Encoding::ASCII) : nil
       end
 
-      def convert_bigint(buffer, size_bytes)
+      def bytes_to_bigint(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         read_long!(buffer)
       end
 
-      def convert_blob(buffer, size_bytes)
+      def bytes_to_blob(buffer, size_bytes)
         bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
         bytes ? bytes : nil
       end
 
-      def convert_boolean(buffer, size_bytes)
+      def bytes_to_boolean(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         buffer.read(1) == Constants::TRUE_BYTE
       end
 
-      def convert_decimal(buffer, size_bytes)
+      def bytes_to_decimal(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
         read_decimal!(buffer, size)
       end
 
-      def convert_double(buffer, size_bytes)
+      def bytes_to_double(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         read_double!(buffer)
       end
 
-      def convert_float(buffer, size_bytes)
+      def bytes_to_float(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         read_float!(buffer)
       end
 
-      def convert_int(buffer, size_bytes)
+      def bytes_to_int(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         read_int!(buffer)
       end
 
-      def convert_timestamp(buffer, size_bytes)
+      def bytes_to_timestamp(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         timestamp = read_long!(buffer)
         Time.at(timestamp/1000.0)
       end
 
-      def convert_varchar(buffer, size_bytes)
+      def bytes_to_varchar(buffer, size_bytes)
         bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
         bytes ? bytes.force_encoding(::Encoding::UTF_8) : nil
       end
 
-      def convert_varint(buffer, size_bytes)
+      def bytes_to_varint(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
         read_varint!(buffer, size)
       end
 
-      def convert_uuid(buffer, size_bytes)
+      def bytes_to_uuid(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         read_uuid!(buffer)
       end
 
-      def convert_inet(buffer, size_bytes)
+      def bytes_to_inet(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
         IPAddr.new_ntoh(buffer.read(size))
       end
 
-      def convert_list(buffer, value_converter)
+      def bytes_to_list(buffer, value_converter)
         list = []
         size = buffer.read_short
         size.times do
@@ -130,7 +203,7 @@ module Cql
         list
       end
 
-      def convert_map(buffer, key_converter, value_converter)
+      def bytes_to_map(buffer, key_converter, value_converter)
         map = {}
         size = buffer.read_short
         size.times do
@@ -141,7 +214,7 @@ module Cql
         map
       end
 
-      def convert_set(buffer, value_converter)
+      def bytes_to_set(buffer, value_converter)
         set = Set.new
         size = buffer.read_short
         size.times do
@@ -150,15 +223,122 @@ module Cql
         set
       end
 
-      def read_size(buffer, size_bytes)
-        if size_bytes == 2
-          size = buffer.read_short
-          return nil if size & 0x8000 == 0x8000
+      def ascii_to_bytes(io, value, size_bytes)
+        v = value.encode(::Encoding::ASCII)
+        if size_bytes == 4
+          write_bytes(io, v)
         else
-          size = buffer.read_int
-          return nil if size & 0x80000000 == 0x80000000
+          write_short_bytes(io, v)
+        end
+      end
+
+      def bigint_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 8)
+        else
+          write_short(io, 8)
+        end
+        write_long(io, value)
+      end
+
+      def blob_to_bytes(io, value, size_bytes)
+        v = value.encode(::Encoding::BINARY)
+        if size_bytes == 4
+          write_bytes(io, v)
+        else
+          write_short_bytes(io, v)
+        end
+      end
+
+      def boolean_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 1)
+        else
+          write_short(io, 1)
+        end
+        io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
+      end
+
+      def decimal_to_bytes(io, value, size_bytes)
+        raw = write_decimal('', value)
+        if size_bytes == 4
+          write_bytes(io, raw)
+        else
+          write_short_bytes(io, raw)
+        end
+      end
+
+      def double_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 8)
+        else
+          write_short(io, 8)
+        end
+        write_double(io, value)
+      end
+
+      def float_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 4)
+        else
+          write_short(io, 4)
+        end
+        write_float(io, value)
+      end
+
+      def inet_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, value.ipv6? ? 16 : 4)
+        else
+          write_short(io, value.ipv6? ? 16 : 4)
+        end
+        io << value.hton
+      end
+
+      def int_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 4)
+        else
+          write_short(io, 4)
+        end
+        write_int(io, value)
+      end
+
+      def varchar_to_bytes(io, value, size_bytes)
+        v = value.encode(::Encoding::UTF_8)
+        if size_bytes == 4
+          write_bytes(io, v)
+        else
+          write_short_bytes(io, v)
+        end
+      end
+
+      def timestamp_to_bytes(io, value, size_bytes)
+        ms = (value.to_f * 1000).to_i
+        if size_bytes == 4
+          write_int(io, 8)
+        else
+          write_short(io, 8)
+        end
+        write_long(io, ms)
+      end
+
+      def uuid_to_bytes(io, value, size_bytes)
+        if size_bytes == 4
+          write_int(io, 16)
+        else
+          write_short(io, 16)
+        end
+        write_uuid(io, value)
+      end
+
+      def varint_to_bytes(io, value, size_bytes)
+        raw = write_varint('', value)
+        if size_bytes == 4
+          write_bytes(io, raw)
+        else
+          write_short_bytes(io, raw)
         end
-        size
       end
     end
   end