cql-rb 1.2.2 → 2.0.0.pre0

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class AuthResponseRequest < Request
+      attr_reader :token
+
+      def initialize(token)
+        super(0x0f)
+        @token = token
+      end
+
+      def write(protocol_version, io)
+        write_bytes(io, @token)
+      end
+
+      def to_s
+        %(AUTH_RESPONSE #{@token.bytesize})
+      end
+
+      def eql?(other)
+        self.token == other.token
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @token.hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class BatchRequest < Request
+      LOGGED_TYPE = 0
+      UNLOGGED_TYPE = 1
+      COUNTER_TYPE = 2
+
+      attr_reader :type, :consistency, :part_count
+
+      def initialize(type, consistency, trace=false)
+        super(0x0D, trace)
+        @type = type
+        @part_count = 0
+        @encoded_queries = ByteBuffer.new
+        @consistency = consistency
+      end
+
+      def add_query(cql, values=nil, type_hints=nil)
+        @encoded_queries << QUERY_KIND
+        write_long_string(@encoded_queries, cql)
+        QueryRequest.encode_values(@encoded_queries, values, type_hints)
+        @part_count += 1
+        nil
+      end
+
+      def add_prepared(id, metadata, values)
+        @encoded_queries << PREPARED_KIND
+        write_short_bytes(@encoded_queries, id)
+        ExecuteRequest.encode_values(@encoded_queries, metadata, values)
+        @part_count += 1
+        nil
+      end
+
+      def write(protocol_version, io)
+        io << @type.chr
+        write_short(io, @part_count)
+        io << @encoded_queries
+        write_consistency(io, @consistency)
+      end
+
+      def to_s
+        type_str = case @type
+          when LOGGED_TYPE then 'LOGGED'
+          when UNLOGGED_TYPE then 'UNLOGGED'
+          when COUNTER_TYPE then 'COUNTER'
+        end
+        %(BATCH #{type_str} #{@part_count} #{@consistency.to_s.upcase})
+      end
+
+      private
+
+      TYPE_CONVERTER = TypeConverter.new
+      QUERY_KIND = "\x00".freeze
+      PREPARED_KIND = "\x01".freeze
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Cql
         @credentials = credentials.dup.freeze
       end
 
-      def write(io)
+      def write(protocol_version, io)
         write_string_map(io, @credentials)
       end
 

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

@@ -3,20 +3,47 @@
 module Cql
   module Protocol
     class ExecuteRequest < Request
-      attr_reader :id, :metadata, :values, :consistency
+      attr_reader :id, :metadata, :values, :request_metadata, :consistency, :serial_consistency, :page_size, :paging_state
 
-      def initialize(id, metadata, values, consistency, trace=false)
+      def initialize(id, metadata, values, request_metadata, consistency, serial_consistency=nil, page_size=nil, paging_state=nil, trace=false)
         raise ArgumentError, "Metadata for #{metadata.size} columns, but #{values.size} values given" if metadata.size != values.size
+        raise ArgumentError, %(No such consistency: #{consistency.inspect}) if consistency.nil? || !CONSISTENCIES.include?(consistency)
+        raise ArgumentError, %(No such consistency: #{serial_consistency.inspect}) unless serial_consistency.nil? || CONSISTENCIES.include?(serial_consistency)
+        raise ArgumentError, %(Paging state given but no page size) if paging_state && !page_size
         super(10, trace)
         @id = id
         @metadata = metadata
         @values = values
+        @request_metadata = request_metadata
         @consistency = consistency
-        @bytes = encode_body
+        @serial_consistency = serial_consistency
+        @page_size = page_size
+        @paging_state = paging_state
+        @encoded_values = self.class.encode_values('', @metadata, @values)
       end
 
-      def write(io)
-        io << @bytes
+      def write(protocol_version, io)
+        write_short_bytes(io, @id)
+        if protocol_version > 1
+          write_consistency(io, @consistency)
+          flags  = 0
+          flags |= 0x01 if @values.size > 0
+          flags |= 0x02 unless @request_metadata
+          flags |= 0x04 if @page_size
+          flags |= 0x08 if @paging_state
+          flags |= 0x10 if @serial_consistency
+          io << flags.chr
+          if @values.size > 0
+            io << @encoded_values
+          end
+          write_int(io, @page_size) if @page_size
+          write_bytes(io, @paging_state) if @paging_state
+          write_consistency(io, @serial_consistency) if @serial_consistency
+          io
+        else
+          io << @encoded_values
+          write_consistency(io, @consistency)
+        end
       end
 
       def to_s
@@ -25,7 +52,7 @@ module Cql
       end
 
       def eql?(rq)
-        self.class === rq && rq.id == self.id && rq.metadata == self.metadata && rq.values == self.values && rq.consistency == self.consistency
+        self.class === rq && rq.id == self.id && rq.metadata == self.metadata && rq.values == self.values && rq.consistency == self.consistency && rq.serial_consistency == self.serial_consistency && rq.page_size == self.page_size && rq.paging_state == self.paging_state
       end
       alias_method :==, :eql?
 
@@ -36,23 +63,24 @@ module Cql
           h = ((h & 33554431) * 31) ^ @metadata.hash
           h = ((h & 33554431) * 31) ^ @values.hash
           h = ((h & 33554431) * 31) ^ @consistency.hash
+          h = ((h & 33554431) * 31) ^ @serial_consistency.hash
+          h = ((h & 33554431) * 31) ^ @page_size.hash
+          h = ((h & 33554431) * 31) ^ @paging_state.hash
           h
         end
       end
 
-      private
-
-      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])
+      def self.encode_values(buffer, metadata, values)
+        Encoding.write_short(buffer, metadata.size)
+        metadata.each_with_index do |(_, _, _, type), index|
+          TYPE_CONVERTER.to_bytes(buffer, type, values[index])
         end
-        write_consistency(buffer, @consistency)
-        buffer.to_s
+        buffer
       end
+
+      private
+
+      TYPE_CONVERTER = TypeConverter.new
     end
   end
 end

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

@@ -11,7 +11,7 @@ module Cql
         false
       end
 
-      def write(io)
+      def write(protocol_version, io)
         io
       end
 

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

@@ -11,7 +11,7 @@ module Cql
         @cql = cql
       end
 
-      def write(io)
+      def write(protocol_version, io)
         write_long_string(io, @cql)
       end
 

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

@@ -3,19 +3,45 @@
 module Cql
   module Protocol
     class QueryRequest < Request
-      attr_reader :cql, :consistency
+      attr_reader :cql, :values, :type_hints, :consistency, :serial_consistency, :page_size, :paging_state
 
-      def initialize(cql, consistency, trace=false)
+      def initialize(cql, values, type_hints, consistency, serial_consistency=nil, page_size=nil, paging_state=nil, trace=false)
         raise ArgumentError, %(No CQL given!) unless cql
         raise ArgumentError, %(No such consistency: #{consistency.inspect}) if consistency.nil? || !CONSISTENCIES.include?(consistency)
+        raise ArgumentError, %(No such consistency: #{serial_consistency.inspect}) unless serial_consistency.nil? || CONSISTENCIES.include?(serial_consistency)
+        raise ArgumentError, %(Bound values and type hints must have the same number of elements (got #{values.size} values and #{type_hints.size} hints)) if values && type_hints && values.size != type_hints.size
+        raise ArgumentError, %(Paging state given but no page size) if paging_state && !page_size
         super(7, trace)
         @cql = cql
+        @values = values || EMPTY_LIST
+        @type_hints = type_hints || EMPTY_LIST
+        @encoded_values = self.class.encode_values('', @values, @type_hints)
         @consistency = consistency
+        @serial_consistency = serial_consistency
+        @page_size = page_size
+        @paging_state = paging_state
       end
 
-      def write(io)
+      def write(protocol_version, io)
         write_long_string(io, @cql)
         write_consistency(io, @consistency)
+        if protocol_version > 1
+          flags  = 0
+          flags |= 0x04 if @page_size
+          flags |= 0x08 if @paging_state
+          flags |= 0x10 if @serial_consistency
+          if @values && @values.size > 0
+            flags |= 0x01
+            io << flags.chr
+            io << @encoded_values
+          else
+            io << flags.chr
+          end
+          write_int(io, @page_size) if @page_size
+          write_bytes(io, @paging_state) if @paging_state
+          write_consistency(io, @serial_consistency) if @serial_consistency
+        end
+        io
       end
 
       def to_s
@@ -23,13 +49,79 @@ module Cql
       end
 
       def eql?(rq)
-        self.class === rq && rq.cql.eql?(self.cql) && rq.consistency.eql?(self.consistency)
+        self.class === rq &&
+          rq.cql == self.cql &&
+          rq.values == self.values &&
+          rq.type_hints == self.type_hints &&
+          rq.consistency == self.consistency &&
+          rq.serial_consistency == self.serial_consistency &&
+          rq.page_size == self.page_size &&
+          rq.paging_state == self.paging_state
       end
       alias_method :==, :eql?
 
       def hash
-        @h ||= (@cql.hash * 31) ^ consistency.hash
+        h = 0xcbf29ce484222325
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @cql.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @values.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @type_hints.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @consistency.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @serial_consistency.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @page_size.hash))
+        h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @paging_state.hash))
+        h
       end
+
+      def self.encode_values(buffer, values, hints)
+        if values && values.size > 0
+          Encoding.write_short(buffer, values.size)
+          values.each_with_index do |value, index|
+            type = (hints && hints[index]) || guess_type(value)
+            raise EncodingError, "Could not guess a suitable type for #{value.inspect}" unless type
+            TYPE_CONVERTER.to_bytes(buffer, type, value)
+          end
+          buffer
+        else
+          Encoding.write_short(buffer, 0)
+        end
+      end
+
+      private
+
+      def self.guess_type(value)
+        type = TYPE_GUESSES[value.class]
+        if type == :map
+          pair = value.first
+          [type, guess_type(pair[0]), guess_type(pair[1])]
+        elsif type == :list
+          [type, guess_type(value.first)]
+        elsif type == :set
+          [type, guess_type(value.first)]
+        else
+          type
+        end
+      end
+
+      TYPE_GUESSES = {
+        String => :varchar,
+        Fixnum => :bigint,
+        Float => :double,
+        Bignum => :varint,
+        BigDecimal => :decimal,
+        TrueClass => :boolean,
+        FalseClass => :boolean,
+        NilClass => :bigint,
+        Uuid => :uuid,
+        TimeUuid => :uuid,
+        IPAddr => :inet,
+        Time => :timestamp,
+        Hash => :map,
+        Array => :list,
+        Set => :set,
+      }.freeze
+      TYPE_CONVERTER = TypeConverter.new
+      EMPTY_LIST = [].freeze
+      NO_FLAGS = "\x00".freeze
     end
   end
 end

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

@@ -10,7 +10,7 @@ module Cql
         @events = events
       end
 
-      def write(io)
+      def write(protocol_version, io)
         write_string_list(io, @events)
       end
 

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

@@ -5,9 +5,10 @@ module Cql
     class StartupRequest < Request
       attr_reader :options
 
-      def initialize(cql_version=nil, compression=nil)
+      def initialize(cql_version, compression=nil)
         super(1)
-        @options = {CQL_VERSION => cql_version || DEFAULT_CQL_VERSION}
+        raise ArgumentError, "Invalid CQL version: #{cql_version.inspect}" unless cql_version
+        @options = {CQL_VERSION => cql_version}
         @options[COMPRESSION] = compression if compression
       end
 
@@ -15,7 +16,7 @@ module Cql
         false
       end
 
-      def write(io)
+      def write(protocol_version, io)
         write_string_map(io, @options)
       end
 
@@ -25,7 +26,6 @@ module Cql
 
       private
 
-      DEFAULT_CQL_VERSION = '3.0.0'.freeze
       CQL_VERSION = 'CQL_VERSION'.freeze
       COMPRESSION = 'COMPRESSION'.freeze
     end

data/lib/cql/protocol/response.rb

@@ -5,10 +5,10 @@ module Cql
     class Response
       extend Decoding
 
-      def self.decode!(opcode, buffer, trace_id)
+      def self.decode!(opcode, protocol_version, buffer, length, trace_id)
         response_class = RESPONSE_TYPES[opcode]
         if response_class
-          response_class.decode!(buffer, trace_id)
+          response_class.decode!(protocol_version, buffer, length, trace_id)
         else
           raise UnsupportedOperationError, "The operation #{opcode} is not supported"
         end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class AuthChallengeResponse < Response
+      attr_reader :token
+
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+        new(read_bytes!(buffer))
+      end
+
+      def initialize(token)
+        @token = token
+      end
+
+      def to_s
+        %(AUTH_CHALLENGE #{@token.bytesize})
+      end
+
+      private
+
+      RESPONSE_TYPES[0x0e] = self
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class AuthSuccessResponse < Response
+      attr_reader :token
+
+      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+        new(read_bytes!(buffer))
+      end
+
+      def initialize(token)
+        @token = token
+      end
+
+      def to_s
+        %(AUTH_SUCCESS #{@token.bytesize})
+      end
+
+      private
+
+      RESPONSE_TYPES[0x10] = self
+    end
+  end
+end