cassandra-driver 1.2.0 → 2.0.0

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -19,6 +19,10 @@
 module Cassandra
   module Protocol
     class CqlByteBuffer < Ione::ByteBuffer
+      def inspect
+        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} #{to_str.inspect}>"
+      end
+
       def read_unsigned_byte
         read_byte
       rescue RangeError => e

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -30,7 +30,6 @@ module Cassandra
     #   future = protocol_handler.send_request(Cassandra::Protocol::OptionsRequest.new)
     #   response = future.get
     #   puts "These options are supported: #{response.options}"
-    #
     class CqlProtocolHandler
       # @return [String] the current keyspace for the underlying connection
       attr_reader :keyspace
@@ -42,10 +41,8 @@ module Cassandra
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
-        @read_buffer = CqlByteBuffer.new
-        @frame_encoder = FrameEncoder.new(protocol_version, @compressor)
-        @frame_decoder = FrameDecoder.new(@compressor)
-        @current_frame = FrameDecoder::NULL_FRAME
+        @frame_encoder = V1::Encoder.new(@compressor, protocol_version)
+        @frame_decoder = V1::Decoder.new(self, @compressor)
         @request_queue_in = []
         @request_queue_out = []
         @event_listeners = []
@@ -145,7 +142,7 @@ module Cassandra
       def send_request(request, timeout=nil, with_heartbeat = true)
         return Ione::Future.failed(Errors::IOError.new('Connection closed')) if closed?
         schedule_heartbeat if with_heartbeat
-        promise = RequestPromise.new(request, @frame_encoder)
+        promise = RequestPromise.new(request)
         id = nil
         @lock.lock
         begin
@@ -157,12 +154,11 @@ module Cassandra
         end
         if id
           @connection.write do |buffer|
-            @frame_encoder.encode_frame(request, id, buffer)
+            @frame_encoder.encode(buffer, request, id)
           end
         else
           @lock.lock
           begin
-            promise.encode_frame
             @request_queue_in << promise
           ensure
             @lock.unlock
@@ -197,50 +193,6 @@ module Cassandra
         @closed_promise.future
       end
 
-      private
-
-      # @private
-      class RequestPromise < Ione::Promise
-        attr_reader :request, :frame
-
-        def initialize(request, frame_encoder)
-          @request = request
-          @frame_encoder = frame_encoder
-          @timed_out = false
-          super()
-        end
-
-        def timed_out?
-          @timed_out
-        end
-
-        def time_out!
-          unless future.completed?
-            @timed_out = true
-            fail(Errors::TimeoutError.new('Timed out'))
-          end
-        end
-
-        def encode_frame
-          @frame = @frame_encoder.encode_frame(@request)
-        end
-      end
-
-      def receive_data(data)
-        reschedule_termination
-        @read_buffer << data
-        @current_frame = @frame_decoder.decode_frame(@read_buffer, @current_frame)
-        while @current_frame.complete?
-          id = @current_frame.stream_id
-          if id == -1
-            notify_event_listeners(@current_frame.body)
-          else
-            complete_request(id, @current_frame.body)
-          end
-          @current_frame = @frame_decoder.decode_frame(@read_buffer)
-        end
-      end
-
       def notify_event_listeners(event_response)
         event_listeners = nil
         @lock.lock
@@ -251,7 +203,7 @@ module Cassandra
           @lock.unlock
         end
         event_listeners.each do |listener|
-          listener.call(@current_frame.body) rescue nil
+          listener.call(event_response)
         end
       end
 
@@ -276,6 +228,35 @@ module Cassandra
         end
       end
 
+      private
+
+      # @private
+      class RequestPromise < Ione::Promise
+        attr_reader :request
+
+        def initialize(request)
+          @request = request
+          @timed_out = false
+          super()
+        end
+
+        def timed_out?
+          @timed_out
+        end
+
+        def time_out!
+          unless future.completed?
+            @timed_out = true
+            fail(Errors::TimeoutError.new('Timed out'))
+          end
+        end
+      end
+
+      def receive_data(data)
+        reschedule_termination
+        @frame_decoder << data
+      end
+
       def flush_request_queue
         @lock.lock
         begin
@@ -288,7 +269,7 @@ module Cassandra
         end
         while true
           id = nil
-          frame = nil
+          promise = nil
           @lock.lock
           begin
             if @request_queue_out.any? && (id = next_stream_id)
@@ -296,7 +277,6 @@ module Cassandra
               if promise.timed_out?
                 next
               else
-                frame = promise.frame
                 @promises[id] = promise
               end
             end
@@ -304,8 +284,9 @@ module Cassandra
             @lock.unlock
           end
           if id
-            @frame_encoder.change_stream_id(id, frame)
-            @connection.write(frame)
+            @connection.write do |buffer|
+              @frame_encoder.encode(buffer, promise.request, id)
+            end
           else
             break
           end

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

@@ -26,7 +26,7 @@ module Cassandra
         @token = token
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_bytes(@token)
       end
 

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

@@ -23,38 +23,43 @@ module Cassandra
       UNLOGGED_TYPE = 1
       COUNTER_TYPE = 2
 
-      attr_reader :type, :part_count
+      attr_reader :type
       attr_accessor :consistency, :retries
 
       def initialize(type, consistency, trace=false)
         super(0x0D, trace)
-        @type = type
-        @part_count = 0
-        @encoded_queries = CqlByteBuffer.new
+        @type  = type
+        @parts = []
         @consistency = consistency
       end
 
-      def add_query(cql, values=nil, type_hints=nil)
-        @encoded_queries.append(QUERY_KIND)
-        @encoded_queries.append_long_string(cql)
-        QueryRequest.encode_values(@encoded_queries, values, type_hints)
-        @part_count += 1
+      def add_query(cql, values, types)
+        @parts << [:simple, cql, values, types]
         nil
       end
 
-      def add_prepared(id, metadata, values)
-        @encoded_queries.append(PREPARED_KIND)
-        @encoded_queries.append_short_bytes(id)
-        ExecuteRequest.encode_values(@encoded_queries, metadata, values)
-        @part_count += 1
+      def add_prepared(id, values, types)
+        @parts << [:prepared, id, values, types]
         nil
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append(@type.chr)
-        buffer.append_short(@part_count)
-        buffer.append(@encoded_queries)
+        buffer.append_short(@parts.size)
+
+        @parts.each do |(statement_kind, *arguments)|
+          __send__(:"write_#{statement_kind}", buffer, protocol_version, encoder, *arguments)
+        end
+
         buffer.append_consistency(@consistency)
+
+        if protocol_version > 2
+          flags = 0
+
+          buffer.append(flags.chr)
+        end
+
+        buffer
       end
 
       def to_s
@@ -63,14 +68,25 @@ module Cassandra
           when UNLOGGED_TYPE then 'UNLOGGED'
           when COUNTER_TYPE then 'COUNTER'
         end
-        %(BATCH #{type_str} #{@part_count} #{@consistency.to_s.upcase})
+        %(BATCH #{type_str} #{@parts.size} #{@consistency.to_s.upcase})
       end
 
       private
 
-      TYPE_CONVERTER = TypeConverter.new
       QUERY_KIND = "\x00".freeze
       PREPARED_KIND = "\x01".freeze
+
+      def write_simple(buffer, protocol_version, encoder, cql, values, types)
+        buffer.append(QUERY_KIND)
+        buffer.append_long_string(cql)
+        encoder.write_parameters(buffer, values, types)
+      end
+
+      def write_prepared(buffer, protocol_version, encoder, id, values, types)
+        buffer.append(PREPARED_KIND)
+        buffer.append_short_bytes(id)
+        encoder.write_parameters(buffer, values, types)
+      end
     end
   end
 end

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

@@ -26,7 +26,7 @@ module Cassandra
         @credentials = credentials.dup.freeze
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_string_map(@credentials)
       end
 

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

@@ -36,10 +36,9 @@ module Cassandra
         @serial_consistency = serial_consistency
         @page_size = page_size
         @paging_state = paging_state
-        @encoded_values = self.class.encode_values(CqlByteBuffer.new, @metadata, @values)
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_short_bytes(@id)
         if protocol_version > 1
           buffer.append_consistency(@consistency)
@@ -51,13 +50,13 @@ module Cassandra
           flags |= 0x10 if @serial_consistency
           buffer.append(flags.chr)
           if @values.size > 0
-            buffer.append(@encoded_values)
+            encoder.write_parameters(buffer, @values, @metadata)
           end
           buffer.append_int(@page_size) if @page_size
           buffer.append_bytes(@paging_state) if @paging_state
           buffer.append_consistency(@serial_consistency) if @serial_consistency
         else
-          buffer.append(@encoded_values)
+          encoder.write_parameters(buffer, @values, @metadata)
           buffer.append_consistency(@consistency)
         end
         buffer
@@ -86,18 +85,6 @@ module Cassandra
           h
         end
       end
-
-      def self.encode_values(buffer, metadata, values)
-        buffer.append_short(metadata.size)
-        metadata.each_with_index do |(_, _, _, type), index|
-          TYPE_CONVERTER.to_bytes(buffer, type, values[index])
-        end
-        buffer
-      end
-
-      private
-
-      TYPE_CONVERTER = TypeConverter.new
     end
   end
 end

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

@@ -27,7 +27,7 @@ module Cassandra
         false
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer
       end
 

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

@@ -29,7 +29,7 @@ module Cassandra
         @consistency = :one
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_long_string(@cql)
       end
 

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

@@ -22,23 +22,18 @@ module Cassandra
       attr_reader :cql, :values, :type_hints, :serial_consistency, :page_size, :paging_state
       attr_accessor :consistency, :retries
 
-      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
+      def initialize(cql, values, type_hints, consistency, serial_consistency = nil, page_size = nil, paging_state = nil, trace = false)
         super(7, trace)
         @cql = cql
-        @values = values || EMPTY_LIST
-        @type_hints = type_hints || EMPTY_LIST
+        @values = values
+        @type_hints = type_hints
         @consistency = consistency
         @serial_consistency = serial_consistency
         @page_size = page_size
         @paging_state = paging_state
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_long_string(@cql)
         buffer.append_consistency(@consistency)
         if protocol_version > 1
@@ -49,7 +44,7 @@ module Cassandra
           if @values && @values.size > 0
             flags |= 0x01
             buffer.append(flags.chr)
-            self.class.encode_values(buffer, @values, @type_hints)
+            encoder.write_parameters(buffer, @values, @type_hints)
           else
             buffer.append(flags.chr)
           end
@@ -87,57 +82,6 @@ module Cassandra
         h = 0xffffffffffffffff & (0x100000001b3 * (h ^ @paging_state.hash))
         h
       end
-
-      def self.encode_values(buffer, values, hints)
-        if values && values.size > 0
-          buffer.append_short(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
-          buffer.append_short(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/cassandra/protocol/requests/register_request.rb

@@ -26,7 +26,7 @@ module Cassandra
         @events = events
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_string_list(@events)
       end