cql-rb 1.0.6 → 1.1.0.pre0

data/README.md

@@ -1,8 +1,11 @@
 # Ruby CQL3 driver
 
+[![Build Status](https://travis-ci.org/iconara/cql-rb.png?branch=master)](https://travis-ci.org/iconara/cql-rb)
+[![Coverage Status](https://coveralls.io/repos/iconara/cql-rb/badge.png?branch=io_reactor_rewrite)](https://coveralls.io/r/iconara/cql-rb?branch=io_reactor_rewrite)
+
 # Requirements
 
-Cassandra 1.2 with the native transport protocol turned on and a modern Ruby. Tested with Ruby 1.9.3 and JRuby and 1.7.x.
+Cassandra 1.2 with the native transport protocol turned on and a modern Ruby. It's tested continuously in Travis with Ruby 1.9.3, 2.0.0, and JRuby 1.7.x stable and head.
 
 # Installation
 
@@ -43,12 +46,6 @@ or using CQL:
 client.execute('USE measurements')
 ```
 
-If your keyspace has upper case characters you need to quote the keyspace name _(this is supported in v1.0.2 and later)_:
-
-```ruby
-client.execute('USE "Measurements"')
-```
-
 ## Running queries
 
 You run CQL statements by passing them to `#execute`. Most statements don't have any result and the call will return nil.
@@ -210,8 +207,6 @@ Open an issue and I'll do my best to help you. Please include the gem version, C
 
 # Known bugs & limitations
 
-[![Build Status](https://travis-ci.org/iconara/cql-rb.png?branch=master)](https://travis-ci.org/iconara/cql-rb)
-
 * No automatic peer discovery.
 * No automatic reconnection on connection failures.
 * JRuby 1.6.8 and earlier is not supported, although it probably works fine. The only known issue is that connection failures aren't handled gracefully.

data/lib/cql.rb

@@ -5,6 +5,7 @@ module Cql
 end
 
 require 'cql/uuid'
+require 'cql/time_uuid'
 require 'cql/byte_buffer'
 require 'cql/future'
 require 'cql/io'

data/lib/cql/byte_buffer.rb

@@ -19,14 +19,18 @@ module Cql
     end
 
     def append(bytes)
-      bytes = bytes.to_s
-      unless bytes.ascii_only?
-        bytes = bytes.dup.force_encoding(::Encoding::BINARY)
+      if bytes.is_a?(self.class)
+        bytes.append_to(self)
+      else
+        bytes = bytes.to_s
+        unless bytes.ascii_only?
+          bytes = bytes.dup.force_encoding(::Encoding::BINARY)
+        end
+        retag = @write_buffer.empty?
+        @write_buffer << bytes
+        @write_buffer.force_encoding(::Encoding::BINARY) if retag
+        @length += bytes.bytesize
       end
-      retag = @write_buffer.empty?
-      @write_buffer << bytes
-      @write_buffer.force_encoding(::Encoding::BINARY) if retag
-      @length += bytes.bytesize
       self
     end
     alias_method :<<, :append
@@ -149,6 +153,18 @@ module Cql
       %(#<#{self.class.name}: #{to_str.inspect}>)
     end
 
+    protected
+
+    def append_to(other)
+      other.raw_append(cheap_peek)
+      other.raw_append(@write_buffer) unless @write_buffer.empty?
+    end
+
+    def raw_append(bytes)
+      @write_buffer << bytes
+      @length += bytes.bytesize
+    end
+
     private
 
     def swap_buffers

data/lib/cql/client.rb

@@ -11,6 +11,7 @@ module Cql
     end
   end
 
+  NotConnectedError = Class.new(CqlError)
   ClientError = Class.new(CqlError)
   AuthenticationError = Class.new(ClientError)
 
@@ -43,7 +44,6 @@ module Cql
   # See {Cql::Client::Client} for the full client API.
   #
   module Client
-    NotConnectedError = Class.new(ClientError)
     InvalidKeyspaceNameError = Class.new(ClientError)
 
     # Create a new client and connects to Cassandra.
@@ -74,13 +74,13 @@ module Cql
       # keyspace will also be changed (otherwise the current keyspace will not
       # be set).
       #
-      # @return self
+      # @return [Cql::Client]
 
       # @!method close
       #
       # Disconnect from all nodes.
       #
-      # @return self
+      # @return [Cql::Client]
 
       # @!method connected?
       #
@@ -93,8 +93,7 @@ module Cql
       # Returns the name of the current keyspace, or `nil` if no keyspace has been
       # set yet.
       #
-      # @param [String] keyspace
-      # @return [nil]
+      # @return [String]
 
       # @!method use(keyspace)
       #
@@ -143,6 +142,11 @@ module Cql
       #
       # @param args [Array] the values for the bound parameters, and optionally
       #   the desired consistency level, as a symbol (defaults to :quorum)
+      # @raise [Cql::NotConnectedError] raised when the client is not connected
+      # @raise [Cql::QueryError] raised when there is an error on the server side
+      # @return [nil, Cql::Client::QueryResult] Most statements have no result and return
+      #   `nil`, but `SELECT` statements return an `Enumerable` of rows
+      #   (see {Cql::Client::QueryResult}).
       def execute(*args)
       end
     end
@@ -155,4 +159,5 @@ require 'cql/client/query_result'
 require 'cql/client/asynchronous_prepared_statement'
 require 'cql/client/synchronous_prepared_statement'
 require 'cql/client/synchronous_client'
-require 'cql/client/asynchronous_client'
+require 'cql/client/asynchronous_client'
+require 'cql/client/request_runner'

data/lib/cql/client/asynchronous_client.rb

@@ -5,22 +5,22 @@ module Cql
     # @private
     class AsynchronousClient < Client
       def initialize(options={})
-        connection_timeout = options[:connection_timeout]
+        @connection_timeout = options[:connection_timeout] || 10
         @host = options[:host] || 'localhost'
         @port = options[:port] || 9042
-        @io_reactor = options[:io_reactor] || Io::IoReactor.new(connection_timeout: connection_timeout)
+        @io_reactor = options[:io_reactor] || Io::IoReactor.new(Protocol::CqlProtocolHandler)
         @lock = Mutex.new
         @connected = false
         @connecting = false
         @closing = false
         @initial_keyspace = options[:keyspace]
         @credentials = options[:credentials]
-        @connection_keyspaces = {}
+        @request_runner = RequestRunner.new
       end
 
       def connect
         @lock.synchronize do
-          return @connected_future if @connected || @connecting
+          return @connected_future if can_execute?
           @connecting = true
           @connected_future = Future.new
         end
@@ -74,23 +74,22 @@ module Cql
 
       def keyspace
         @lock.synchronize do
-          return @connection_ids.map { |id| @connection_keyspaces[id] }.first
+          @connections.first.keyspace
         end
       end
 
-      def use(keyspace, connection_ids=nil)
-        return Future.failed(NotConnectedError.new) unless @connected || @connecting
+      def use(keyspace)
+        return Future.failed(NotConnectedError.new) unless can_execute?
         return Future.failed(InvalidKeyspaceNameError.new(%("#{keyspace}" is not a valid keyspace name))) unless valid_keyspace_name?(keyspace)
-        connection_ids ||= @connection_ids
-        @lock.synchronize do
-          connection_ids = connection_ids.select { |id| @connection_keyspaces[id] != keyspace }
+        connections = @lock.synchronize do
+          @connections.select { |c| c.keyspace != keyspace }
         end
-        if connection_ids.any?
-          futures = connection_ids.map do |connection_id|
-            execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection_id)
+        if connections.any?
+          futures = connections.map do |connection|
+            execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection)
           end
           futures.compact!
-          return Future.combine(*futures).map { nil }
+          Future.combine(*futures).map { nil }
         else
           Future.completed(nil)
         end
@@ -98,27 +97,14 @@ module Cql
 
       def execute(cql, consistency=nil)
         consistency ||= DEFAULT_CONSISTENCY_LEVEL
-        return Future.failed(NotConnectedError.new) unless @connected || @connecting
-        f = execute_request(Protocol::QueryRequest.new(cql, consistency))
-        f.on_complete do
-          ensure_keyspace!
-        end
-        f
-      rescue => e
-        Future.failed(e)
-      end
-
-      # @private
-      def execute_statement(connection_id, statement_id, metadata, values, consistency)
-        return Future.failed(NotConnectedError.new) unless @connected || @connecting
-        request = Protocol::ExecuteRequest.new(statement_id, metadata, values, consistency || DEFAULT_CONSISTENCY_LEVEL)
-        execute_request(request, connection_id)
+        return Future.failed(NotConnectedError.new) unless can_execute?
+        execute_request(Protocol::QueryRequest.new(cql, consistency))
       rescue => e
         Future.failed(e)
       end
 
       def prepare(cql)
-        return Future.failed(NotConnectedError.new) unless @connected || @connecting
+        return Future.failed(NotConnectedError.new) unless can_execute?
         execute_request(Protocol::PrepareRequest.new(cql))
       rescue => e
         Future.failed(e)
@@ -126,9 +112,13 @@ module Cql
 
       private
 
-      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$|^"\w[\w\d_]*"$/
+      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
       DEFAULT_CONSISTENCY_LEVEL = :quorum
 
+      def can_execute?
+        @connected || @connecting
+      end
+
       def valid_keyspace_name?(name)
         name =~ KEYSPACE_NAME_PATTERN
       end
@@ -157,8 +147,8 @@ module Cql
           connection_futures = hosts.map { |host| connect_to_host(host) }
           Future.combine(*connection_futures)
         end
-        hosts_connected_future.on_complete do |connection_ids|
-          @connection_ids = connection_ids
+        hosts_connected_future.on_complete do |connections|
+          @connections = connections
         end
         if @initial_keyspace
           initialized_future = hosts_connected_future.flat_map do |*args|
@@ -181,72 +171,36 @@ module Cql
       end
 
       def connect_to_host(host)
-        connected = @io_reactor.add_connection(host, @port)
-        connected.flat_map do |connection_id|
-          started = execute_request(Protocol::StartupRequest.new, connection_id)
-          started.flat_map { |response| maybe_authenticate(response, connection_id) }
+        connected = @io_reactor.connect(host, @port, @connection_timeout)
+        connected.flat_map do |connection|
+          started = execute_request(Protocol::StartupRequest.new, connection)
+          started.flat_map { |response| maybe_authenticate(response, connection) }
         end
       end
 
-      def maybe_authenticate(response, connection_id)
+      def maybe_authenticate(response, connection)
         case response
         when AuthenticationRequired
           if @credentials
             credentials_request = Protocol::CredentialsRequest.new(@credentials)
-            execute_request(credentials_request, connection_id).map { connection_id }
+            execute_request(credentials_request, connection).map { connection }
           else
             Future.failed(AuthenticationError.new('Server requested authentication, but no credentials given'))
           end
         else
-          Future.completed(connection_id)
-        end
-      end
-
-      def execute_request(request, connection_id=nil)
-        @io_reactor.queue_request(request, connection_id).map do |response, connection_id|
-          interpret_response!(request, response, connection_id)
+          Future.completed(connection)
         end
       end
 
-      def interpret_response!(request, response, connection_id)
-        case response
-        when Protocol::ErrorResponse
-          case request
-          when Protocol::QueryRequest
-            raise QueryError.new(response.code, response.message, request.cql)
+      def execute_request(request, connection=nil)
+        f = @request_runner.execute(connection || @connections.sample, request)
+        f.map do |result|
+          if result.is_a?(KeyspaceChanged)
+            use(result.keyspace)
+            nil
           else
-            raise QueryError.new(response.code, response.message)
+            result
           end
-        when Protocol::RowsResultResponse
-          QueryResult.new(response.metadata, response.rows)
-        when Protocol::PreparedResultResponse
-          AsynchronousPreparedStatement.new(self, connection_id, response.id, response.metadata)
-        when Protocol::SetKeyspaceResultResponse
-          @lock.synchronize do
-            @last_keyspace_change = @connection_keyspaces[connection_id] = response.keyspace
-          end
-          nil
-        when Protocol::AuthenticateResponse
-          AuthenticationRequired.new(response.authentication_class)
-        else
-          nil
-        end
-      end
-
-      def ensure_keyspace!
-        ks = nil
-        @lock.synchronize do
-          ks = @last_keyspace_change
-          return unless @last_keyspace_change
-        end
-        use(ks, @connection_ids) if ks
-      end
-
-      class AuthenticationRequired
-        attr_reader :authentication_class
-
-        def initialize(authentication_class)
-          @authentication_class = authentication_class
         end
       end
     end

data/lib/cql/client/asynchronous_prepared_statement.rb

@@ -4,15 +4,21 @@ module Cql
   module Client
     # @private
     class AsynchronousPreparedStatement < PreparedStatement
-      def initialize(*args)
-        @client, @connection_id, @statement_id, @raw_metadata = args
+      def initialize(connection, statement_id, raw_metadata)
+        @connection = connection
+        @statement_id = statement_id
+        @raw_metadata = raw_metadata
         @metadata = ResultMetadata.new(@raw_metadata)
+        @request_runner = RequestRunner.new
       end
 
       def execute(*args)
         bound_args = args.shift(@raw_metadata.size)
-        consistency_level = args.shift
-        @client.execute_statement(@connection_id, @statement_id, @raw_metadata, bound_args, consistency_level)
+        consistency_level = args.shift || :quorum
+        request = Cql::Protocol::ExecuteRequest.new(@statement_id, @raw_metadata, bound_args, consistency_level)
+        @request_runner.execute(@connection, request)
+      rescue => e
+        Future.failed(e)
       end
     end
   end

data/lib/cql/client/column_metadata.rb

@@ -17,6 +17,22 @@ module Cql
       def to_ary
         [@keyspace, @table, @column_name, @type]
       end
+
+      def eql?(other)
+        self.keyspace == other.keyspace && self.table == other.table && self.column_name == other.column_name && self.type == other.type
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= begin
+          h = 0
+          h = ((h & 33554431) * 31) ^ @keyspace.hash
+          h = ((h & 33554431) * 31) ^ @table.hash
+          h = ((h & 33554431) * 31) ^ @column_name.hash
+          h = ((h & 33554431) * 31) ^ @type.hash
+          h
+        end
+      end
     end
   end
 end

data/lib/cql/client/request_runner.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    # @private
+    class RequestRunner
+      def execute(connection, request)
+        connection.send_request(request).map do |response|
+          case response
+          when Protocol::RowsResultResponse
+            QueryResult.new(response.metadata, response.rows)
+          when Protocol::PreparedResultResponse
+            AsynchronousPreparedStatement.new(connection, response.id, response.metadata)
+          when Protocol::ErrorResponse
+            cql = request.is_a?(Protocol::QueryRequest) ? request.cql : nil
+            raise QueryError.new(response.code, response.message, cql)
+          when Protocol::SetKeyspaceResultResponse
+            KeyspaceChanged.new(response.keyspace)
+          when Protocol::AuthenticateResponse
+            AuthenticationRequired.new(response.authentication_class)
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    # @private
+    class AuthenticationRequired
+      attr_reader :authentication_class
+
+      def initialize(authentication_class)
+        @authentication_class = authentication_class
+      end
+    end
+
+    # @private
+    class KeyspaceChanged
+      attr_reader :keyspace
+
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+    end
+  end
+end