cql-rb 1.2.2 → 2.0.0.pre0

data/lib/cql/client/request_runner.rb

@@ -4,11 +4,13 @@ module Cql
   module Client
     # @private
     class RequestRunner
-      def execute(connection, request, timeout=nil)
+      def execute(connection, request, timeout=nil, raw_metadata=nil)
         connection.send_request(request, timeout).map do |response|
           case response
+          when Protocol::RawRowsResultResponse
+            LazyQueryResult.new(raw_metadata, response, response.trace_id, response.paging_state)
           when Protocol::RowsResultResponse
-            QueryResult.new(response.metadata, response.rows, response.trace_id)
+            QueryResult.new(response.metadata, response.rows, response.trace_id, response.paging_state)
           when Protocol::VoidResultResponse
             response.trace_id ? VoidResult.new(response.trace_id) : VoidResult::INSTANCE
           when Protocol::ErrorResponse

data/lib/cql/client/synchronous_client.rb

@@ -50,8 +50,12 @@ module Cql
         synchronous_backtrace { @async_client.use(keyspace).value }
       end
 
-      def execute(cql, consistency=nil)
-        synchronous_backtrace { @async_client.execute(cql, consistency).value }
+      def execute(cql, *args)
+        synchronous_backtrace do
+          result = @async_client.execute(cql, *args).value
+          result = SynchronousPagedQueryResult.new(result) if result.is_a?(PagedQueryResult)
+          result
+        end
       end
 
       def prepare(cql)
@@ -59,6 +63,14 @@ module Cql
         SynchronousPreparedStatement.new(async_statement)
       end
 
+      def batch(type=:logged, options={}, &block)
+        if block_given?
+          synchronous_backtrace { @async_client.batch(type, options, &block).value }
+        else
+          SynchronousBatch.new(@async_client.batch(type, options))
+        end
+      end
+
       def async
         @async_client
       end

data/lib/cql/client/synchronous_prepared_statement.rb

@@ -9,10 +9,23 @@ module Cql
       def initialize(async_statement)
         @async_statement = async_statement
         @metadata = async_statement.metadata
+        @result_metadata = async_statement.result_metadata
       end
 
       def execute(*args)
-        synchronous_backtrace { @async_statement.execute(*args).value }
+        synchronous_backtrace do
+          result = @async_statement.execute(*args).value
+          result = SynchronousPagedQueryResult.new(result) if result.is_a?(PagedQueryResult)
+          result
+        end
+      end
+
+      def batch(type=:logged, options=nil, &block)
+        if block_given?
+          synchronous_backtrace { @async_statement.batch(type, options, &block).value }
+        else
+          SynchronousPreparedStatementBatch.new(@async_statement.batch(type, options))
+        end
       end
 
       def pipeline
@@ -24,6 +37,11 @@ module Cql
       def async
         @async_statement
       end
+
+      # @private
+      def add_to_batch(batch, connection, bound_arguments)
+        @async_statement.add_to_batch(batch, connection, bound_arguments)
+      end
     end
 
     # @private

data/lib/cql/future.rb

@@ -88,11 +88,8 @@ module Cql
     # @return [Cql::Future<Array>] an array of the values of the constituent
     #   futures
     def all(*futures)
-      if futures.any?
-        CombinedFuture.new(futures)
-      else
-        resolved([])
-      end
+      return resolved([]) if futures.empty?
+      CombinedFuture.new(futures)
     end
 
     # Returns a future which will be resolved with the value of the first
@@ -102,11 +99,8 @@ module Cql
     # @param [Array<Cql::Future>] futures the futures to monitor
     # @return [Cql::Future] a future which represents the first completing future
     def first(*futures)
-      if futures.any?
-        FirstFuture.new(futures)
-      else
-        resolved
-      end
+      return resolved if futures.empty?
+      FirstFuture.new(futures)
     end
 
     # Creates a new pre-resolved future.
@@ -133,16 +127,15 @@ module Cql
     # @example
     #   future2 = future1.map { |value| value * 2 }
     #
+    # @param [Object] value the value of this future (when no block is given)
     # @yieldparam [Object] value the value of this future
     # @yieldreturn [Object] the transformed value
     # @return [Cql::Future] a new future representing the transformed value
-    def map(&block)
-      p = Promise.new
-      on_failure { |e| p.fail(e) }
-      on_value do |v|
-        p.try(v, &block)
+    def map(value=nil, &block)
+      CompletableFuture.new.tap do |f|
+        on_failure { |e| f.fail(e) }
+        on_value { |v| run(f, value, block, v) }
       end
-      p.future
     end
 
     # Returns a new future representing a transformation of this future's value,
@@ -157,17 +150,10 @@ module Cql
     # @yieldreturn [Cql::Future] a future representing the transformed value
     # @return [Cql::Future] a new future representing the transformed value
     def flat_map(&block)
-      p = Promise.new
-      on_failure { |e| p.fail(e) }
-      on_value do |v|
-        begin
-          f = block.call(v)
-          p.observe(f)
-        rescue => e
-          p.fail(e)
-        end
+      CompletableFuture.new.tap do |f|
+        on_failure { |e| f.fail(e) }
+        on_value { |v| chain(f, block, v) }
       end
-      p.future
     end
 
     # Returns a new future which represents either the value of the original
@@ -185,18 +171,15 @@ module Cql
     #   future1.fail(error)
     #   future2.value # => 'foo'
     #
+    # @param [Object] value the value when no block is given
     # @yieldparam [Object] error the error from the original future
     # @yieldreturn [Object] the value of the new future
     # @return [Cql::Future] a new future representing a value recovered from the error
-    def recover(&block)
-      p = Promise.new
-      on_failure do |e|
-        p.try(e, &block)
-      end
-      on_value do |v|
-        p.fulfill(v)
+    def recover(value=nil, &block)
+      CompletableFuture.new.tap do |f|
+        on_failure { |e| run(f, value, block, e) }
+        on_value { |v| f.resolve(v) }
       end
-      p.future
     end
 
     # Returns a new future which represents either the value of the original
@@ -222,19 +205,27 @@ module Cql
     # @return [Cql::Future] a new future representing a value recovered from the
     #   error
     def fallback(&block)
-      p = Promise.new
-      on_failure do |e|
-        begin
-          f = block.call(e)
-          p.observe(f)
-        rescue => e
-          p.fail(e)
-        end
-      end
-      on_value do |v|
-        p.fulfill(v)
+      CompletableFuture.new.tap do |f|
+        on_failure { |e| chain(f, block, e) }
+        on_value { |v| f.resolve(v) }
       end
-      p.future
+    end
+
+    private
+
+    def run(f, value, producer, arg)
+      value = producer ? producer.call(arg) : value
+      f.resolve(value)
+    rescue => e
+      f.fail(e)
+    end
+
+    def chain(f, constructor, arg)
+      ff = constructor.call(arg)
+      ff.on_failure { |e| f.fail(e) }
+      ff.on_value { |v| f.resolve(v) }
+    rescue => e
+      f.fail(e)
     end
   end
 
@@ -451,18 +442,74 @@ module Cql
   # @private
   class ResolvedFuture < Future
     def initialize(value=nil)
-      super()
-      @value = value
       @resolved = true
+      @failed = false
+      @value = value
+      @error = nil
+    end
+
+    def value
+      @value
+    end
+
+    def completed?
+      true
+    end
+
+    def resolved?
+      true
+    end
+
+    def failed?
+      false
+    end
+
+    def on_complete(&listener)
+      listener.call(self) rescue nil
+    end
+
+    def on_value(&listener)
+      listener.call(value) rescue nil
+    end
+
+    def on_failure
     end
   end
 
   # @private
   class FailedFuture < Future
     def initialize(error)
-      super()
-      @error = error
+      @resolved = false
       @failed = true
+      @value = nil
+      @error = error
+    end
+
+    def value
+      raise @error
+    end
+
+    def completed?
+      true
+    end
+
+    def resolved?
+      false
+    end
+
+    def failed?
+      true
+    end
+
+    def on_complete(&listener)
+      listener.call(self) rescue nil
+    end
+
+    def on_value
+    end
+
+    def on_failure(&listener)
+      listener.call(@error) rescue nil
     end
   end
 end

data/lib/cql/io/connection.rb

@@ -167,7 +167,6 @@ module Cql
       def flush
         if writable?
           @lock.synchronize do
-            s = @write_buffer.cheap_peek.dup
             bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
             @write_buffer.discard(bytes_written)
           end

data/lib/cql/io/io_reactor.rb

@@ -192,7 +192,7 @@ module Cql
         protocol_handler = @protocol_handler_factory.call(connection, self)
         @io_loop.add_socket(connection)
         @unblocker.unblock!
-        f.map { protocol_handler }
+        f.map(protocol_handler)
       end
 
       # Returns a future that completes after the specified number of seconds.

data/lib/cql/protocol.rb

@@ -14,9 +14,11 @@ module Cql
     UnsupportedResultKindError = Class.new(ProtocolError)
     UnsupportedColumnTypeError = Class.new(ProtocolError)
     UnsupportedEventTypeError = Class.new(ProtocolError)
+    UnsupportedFeatureError = Class.new(ProtocolError)
     UnexpectedCompressionError = Class.new(ProtocolError)
+    UnmaterializedRowsError = Class.new(ProtocolError)
 
-    CONSISTENCIES = [:any, :one, :two, :three, :quorum, :all, :local_quorum, :each_quorum, nil, nil, nil, nil, nil, nil, nil, nil, :local_one].freeze
+    CONSISTENCIES = [:any, :one, :two, :three, :quorum, :all, :local_quorum, :each_quorum, :serial, :local_serial, :local_one].freeze
 
     module Formats
       CHAR_FORMAT = 'c'.freeze
@@ -43,6 +45,8 @@ require 'cql/protocol/encoding'
 require 'cql/protocol/decoding'
 require 'cql/protocol/type_converter'
 require 'cql/protocol/response'
+require 'cql/protocol/responses/auth_challenge_response'
+require 'cql/protocol/responses/auth_success_response'
 require 'cql/protocol/responses/error_response'
 require 'cql/protocol/responses/detailed_error_response'
 require 'cql/protocol/responses/ready_response'
@@ -51,6 +55,7 @@ require 'cql/protocol/responses/supported_response'
 require 'cql/protocol/responses/result_response'
 require 'cql/protocol/responses/void_result_response'
 require 'cql/protocol/responses/rows_result_response'
+require 'cql/protocol/responses/raw_rows_result_response'
 require 'cql/protocol/responses/set_keyspace_result_response'
 require 'cql/protocol/responses/prepared_result_response'
 require 'cql/protocol/responses/schema_change_result_response'
@@ -59,6 +64,8 @@ require 'cql/protocol/responses/schema_change_event_response'
 require 'cql/protocol/responses/status_change_event_response'
 require 'cql/protocol/responses/topology_change_event_response'
 require 'cql/protocol/request'
+require 'cql/protocol/requests/auth_response_request'
+require 'cql/protocol/requests/batch_request'
 require 'cql/protocol/requests/startup_request'
 require 'cql/protocol/requests/credentials_request'
 require 'cql/protocol/requests/options_request'

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -19,7 +19,7 @@ module Cql
       # @return [String] the current keyspace for the underlying connection
       attr_reader :keyspace
 
-      def initialize(connection, scheduler, compressor=nil)
+      def initialize(connection, scheduler, protocol_version, compressor=nil)
         @connection = connection
         @scheduler = scheduler
         @compressor = compressor
@@ -27,7 +27,7 @@ module Cql
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
         @read_buffer = ByteBuffer.new
-        @frame_encoder = FrameEncoder.new(@compressor)
+        @frame_encoder = FrameEncoder.new(protocol_version, @compressor)
         @frame_decoder = FrameDecoder.new(@compressor)
         @current_frame = FrameDecoder::NULL_FRAME
         @request_queue_in = []

data/lib/cql/protocol/decoding.rb

@@ -46,19 +46,16 @@ module Cql
           fraction_string << number_string[number_string.length - size, number_string.length]
         end
         BigDecimal.new(fraction_string)
-      rescue RangeError => e
+      rescue DecodingError => e
         raise DecodingError, e.message, e.backtrace
       end
 
       def read_long!(buffer)
-        hi, lo = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
-        if (hi > 0x7fffffff)
-          hi ^= 0xffffffff
-          lo ^= 0xffffffff
-          0 - (hi << 32) - lo - 1
-        else
-          (hi << 32) + lo
-        end
+        top, bottom = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
+        return (top << 32) | bottom if top <= 0x7fffffff
+        top ^= 0xffffffff
+        bottom ^= 0xffffffff
+        -((top << 32) | bottom) - 1
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
       end
@@ -76,11 +73,9 @@ module Cql
       end
 
       def read_int!(buffer)
-        val = buffer.read_int
-        if (val > 0x7fffffff)
-          val = 0 - ((val - 1) ^ 0xffffffff)
-        end
-        val
+        n = buffer.read_int
+        return n if n <= 0x7fffffff
+        n - 0xffffffff - 1
       rescue RangeError => e
         raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
@@ -111,7 +106,7 @@ module Cql
 
       def read_uuid!(buffer, impl=Uuid)
         impl.new(read_varint!(buffer, 16, false))
-      rescue RangeError => e
+      rescue DecodingError => e
         raise DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
       end
 

data/lib/cql/protocol/frame_decoder.rb

@@ -2,6 +2,7 @@
 
 module Cql
   module Protocol
+    # @private
     class FrameDecoder
       def initialize(compressor=nil)
         @compressor = compressor
@@ -44,7 +45,7 @@ module Cql
         end
         extra_length = buffer.length - size 
         trace_id = tracing == 2 ? Decoding.read_uuid!(buffer) : nil
-        response = Response.decode!(opcode, buffer, trace_id)
+        response = Response.decode!(opcode, protocol_version, buffer, size, trace_id)
         if buffer.length > extra_length
           buffer.discard(buffer.length - extra_length)
         end

data/lib/cql/protocol/frame_encoder.rb

@@ -2,22 +2,23 @@
 
 module Cql
   module Protocol
+    # @private
     class FrameEncoder
-      def initialize(compressor=nil)
+      def initialize(protocol_version=1, compressor=nil)
+        @protocol_version = protocol_version
         @compressor = compressor
       end
 
       def encode_frame(request, stream_id=0, buffer=nil)
         raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
         buffer ||= ByteBuffer.new
-        offset = buffer.bytesize
         flags = request.trace? ? 2 : 0
-        body = request.write(ByteBuffer.new)
+        body = request.write(@protocol_version, ByteBuffer.new)
         if @compressor && request.compressable? && @compressor.compress?(body)
           flags |= 1
           body = @compressor.compress(body)
         end
-        header = [1, flags, stream_id, request.opcode, body.bytesize]
+        header = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
         buffer << header.pack(Formats::HEADER_FORMAT)
         buffer << body
         buffer