cql-rb 1.0.0.pre7 → 1.0.0.pre8

data/lib/cql/byte_buffer.rb

@@ -105,6 +105,28 @@ module Cql
       b
     end
 
+    def update(location, bytes)
+      absolute_offset = @offset + location
+      bytes_length = bytes.bytesize
+      if absolute_offset >= @read_buffer.bytesize
+        @write_buffer[absolute_offset - @read_buffer.bytesize, bytes_length] = bytes
+      else
+        overflow = absolute_offset + bytes_length - @read_buffer.bytesize
+        read_buffer_portion = bytes_length - overflow
+        @read_buffer[absolute_offset, read_buffer_portion] = bytes[0, read_buffer_portion]
+        if overflow > 0
+          @write_buffer[0, overflow] = bytes[read_buffer_portion, bytes_length - 1]
+        end
+      end
+    end
+
+    def cheap_peek
+      if @offset >= @read_buffer.bytesize
+        swap_buffers
+      end
+      @read_buffer[@offset, @read_buffer.bytesize - @offset]
+    end
+
     def eql?(other)
       self.to_str.eql?(other.to_str)
     end

data/lib/cql/client.rb

@@ -2,11 +2,12 @@
 
 module Cql
   class QueryError < CqlError
-    attr_reader :code
+    attr_reader :code, :cql
 
-    def initialize(code, message)
+    def initialize(code, message, cql=nil)
       super(message)
       @code = code
+      @cql = cql
     end
   end
 
@@ -39,15 +40,13 @@ module Cql
   #
   # Client instances are threadsafe.
   #
-  class Client
+  # See {Cql::Client::Client} for the full client API.
+  #
+  module Client
     NotConnectedError = Class.new(ClientError)
     InvalidKeyspaceNameError = Class.new(ClientError)
 
-    # Create a new client.
-    #
-    # Creating a client does not automatically connect to Cassandra, you need to
-    # call {#connect} to connect, or use {Client.connect}. `#connect` returns
-    # `self` so you can chain that call after `new`.
+    # Create a new client and connects to Cassandra.
     #
     # @param [Hash] options
     # @option options [String] :host ('localhost') One or more (comma separated)
@@ -57,237 +56,83 @@ module Cql
     #   connection, in seconds
     # @option options [String] :keyspace The keyspace to change to immediately
     #   after all connections have been established, this is optional.
-    def initialize(options={})
-      connection_timeout = options[:connection_timeout]
-      @host = options[:host] || 'localhost'
-      @port = options[:port] || 9042
-      @io_reactor = options[:io_reactor] || Io::IoReactor.new(connection_timeout: connection_timeout)
-      @lock = Mutex.new
-      @started = false
-      @shut_down = false
-      @initial_keyspace = options[:keyspace]
-      @credentials = options[:credentials]
-      @connection_keyspaces = {}
-    end
-
-    def self.connect(options={})
-      new(options).connect
-    end
-
-    # Connect to all nodes.
-    #
-    # You must call this method before you call any of the other methods of a
-    # client. Calling it again will have no effect.
-    #
-    # If `:keyspace` was specified when the client was created the current
-    # keyspace will also be changed (otherwise the current keyspace will not
-    # be set).
-    #
-    # @return self
-    #
-    def connect
-      @lock.synchronize do
-        return if @started
-        @started = true
-        @io_reactor.start
-        hosts = @host.split(',')
-        connection_futures = hosts.map { |host| connect_to_host(host) }
-        @connection_ids = Future.combine(*connection_futures).get
-      end
-      use(@initial_keyspace) if @initial_keyspace
-      self
-    rescue => e
-      close
-      if e.is_a?(Cql::QueryError) && e.code == 0x100
-        raise AuthenticationError, e.message, e.backtrace
-      else
-        raise
-      end
-    end
-
-    # @deprecated Use {#connect} or {.connect}
-    def start!
-      $stderr.puts('Client#start! is deprecated, use Client#connect, or Client.connect')
-      connect
-    end
-
-    # Disconnect from all nodes.
-    #
-    # @return self
-    #
-    def close
-      @lock.synchronize do
-        return if @shut_down || !@started
-        @shut_down = true
-        @started = false
-      end
-      @io_reactor.stop.get
-      self
-    end
-
-    # @deprecated Use {#close}
-    def shutdown!
-      $stderr.puts('Client#shutdown! is deprecated, use Client#close')
-      close
-    end
-
-    # Returns whether or not the client is connected.
-    #
-    def connected?
-      @started
-    end
-
-    # Returns the name of the current keyspace, or `nil` if no keyspace has been
-    # set yet.
-    #
-    def keyspace
-      @lock.synchronize do
-        return @connection_ids.map { |id| @connection_keyspaces[id] }.first
-      end
-    end
-
-    # Changes keyspace by sending a `USE` statement to all connections.
-    #
-    # The the second parameter is meant for internal use only.
-    #
-    # @raise [Cql::NotConnectedError] raised when the client is not connected
-    #
-    def use(keyspace, connection_ids=@connection_ids)
-      raise NotConnectedError unless connected?
-      if check_keyspace_name!(keyspace)
-        @lock.synchronize do
-          connection_ids = connection_ids.select { |id| @connection_keyspaces[id] != keyspace }
-        end
-        if connection_ids.any?
-          futures = connection_ids.map do |connection_id|
-            execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection_id)
-          end
-          futures.compact!
-          Future.combine(*futures).get
-        end
-        nil
-      end
-    end
-
-    # Execute a CQL statement
-    #
-    # @raise [Cql::NotConnectedError] raised when the client is not connected
-    # @raise [Cql::QueryError] raised when the CQL has syntax errors or for
-    #   other situations when the server complains.
-    # @return [nil, Enumerable<Hash>] Most statements have no result and return
-    #   `nil`, but `SELECT` statements return an `Enumerable` of rows
-    #   (see {QueryResult}).
-    #
-    def execute(cql, consistency=DEFAULT_CONSISTENCY_LEVEL)
-      raise NotConnectedError unless connected?
-      result = execute_request(Protocol::QueryRequest.new(cql, consistency)).value
-      ensure_keyspace!
-      result
-    end
-
-    # @private
-    def execute_statement(connection_id, statement_id, metadata, values, consistency)
-      raise NotConnectedError unless connected?
-      execute_request(Protocol::ExecuteRequest.new(statement_id, metadata, values, consistency || DEFAULT_CONSISTENCY_LEVEL), connection_id).value
-    end
-
-    # Returns a prepared statement that can be run over and over again with
-    # different values.
-    #
-    # @raise [Cql::NotConnectedError] raised when the client is not connected
-    # @return [Cql::PreparedStatement] an object encapsulating the prepared statement
+    # @return [Cql::Client::Client]
     #
-    def prepare(cql)
-      raise NotConnectedError unless connected?
-      execute_request(Protocol::PrepareRequest.new(cql)).value
+    def self.connect(options={})
+      SynchronousClient.new(AsynchronousClient.new(options)).connect
     end
 
-    private
-
-    KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
-    DEFAULT_CONSISTENCY_LEVEL = :quorum
-
-    def check_keyspace_name!(name)
-      if name !~ KEYSPACE_NAME_PATTERN
-        raise InvalidKeyspaceNameError, %("#{name}" is not a valid keyspace name)
-      end
-      true
-    end
+    class Client
+      # @!method connect
+      #
+      # Connect to all nodes.
+      #
+      # You must call this method before you call any of the other methods of a
+      # client. Calling it again will have no effect.
+      #
+      # If `:keyspace` was specified when the client was created the current
+      # keyspace will also be changed (otherwise the current keyspace will not
+      # be set).
+      #
+      # @return self
 
-    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) }
-      end
-    end
+      # @!method close
+      #
+      # Disconnect from all nodes.
+      #
+      # @return self
 
-    def maybe_authenticate(response, connection_id)
-      case response
-      when AuthenticationRequired
-        if @credentials
-          credentials_request = Protocol::CredentialsRequest.new(@credentials)
-          execute_request(credentials_request, connection_id).map { connection_id }
-        else
-          Future.failed(AuthenticationError.new('Server requested authentication, but no credentials given'))
-        end
-      else
-        Future.completed(connection_id)
-      end
-    end
+      # @!method connected?
+      #
+      # Returns whether or not the client is connected.
+      #
+      # @return [true, false]
 
-    def execute_request(request, connection_id=nil)
-      @io_reactor.queue_request(request, connection_id).map do |response, connection_id|
-        interpret_response!(response, connection_id)
-      end
-    end
+      # @!method keyspace
+      #
+      # Returns the name of the current keyspace, or `nil` if no keyspace has been
+      # set yet.
+      #
+      # @param [String] keyspace
+      # @return [nil]
 
-    def interpret_response!(response, connection_id)
-      case response
-      when Protocol::ErrorResponse
-        raise QueryError.new(response.code, response.message)
-      when Protocol::RowsResultResponse
-        QueryResult.new(response.metadata, response.rows)
-      when Protocol::PreparedResultResponse
-        PreparedStatement.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
+      # @!method use(keyspace)
+      #
+      # Changes keyspace by sending a `USE` statement to all connections.
+      #
+      # The the second parameter is meant for internal use only.
+      #
+      # @param [String] keyspace
+      # @raise [Cql::NotConnectedError] raised when the client is not connected
+      # @return [nil]
 
-    def ensure_keyspace!
-      ks = nil
-      @lock.synchronize do
-        ks = @last_keyspace_change
-        return unless @last_keyspace_change
-      end
-      use(ks, @connection_ids) if ks
+      # @!method execute(cql, consistency=:quorum)
+      #
+      # Execute a CQL statement
+      #
+      # @param [String] cql
+      # @param [Symbol] consistency
+      # @raise [Cql::NotConnectedError] raised when the client is not connected
+      # @raise [Cql::QueryError] raised when the CQL has syntax errors or for
+      #   other situations when the server complains.
+      # @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}).
+
+      # @!method prepare(cql)
+      #
+      # Returns a prepared statement that can be run over and over again with
+      # different values.
+      #
+      # @param [String] cql
+      # @raise [Cql::NotConnectedError] raised when the client is not connected
+      # @return [Cql::Client::PreparedStatement] an object encapsulating the prepared statement
     end
 
-    public
-
-    # The representation of a prepared statement.
-    #
-    # Prepared statements are parsed once and stored on the server, allowing
-    # you to execute them over and over again but only send values for the bound
-    # parameters.
-    #
     class PreparedStatement
       # @return [ResultMetadata]
       attr_reader :metadata
 
-      def initialize(*args)
-        @client, @connection_id, @statement_id, @raw_metadata = args
-        @metadata = ResultMetadata.new(@raw_metadata)
-      end
-
       # Execute the prepared statement with a list of values for the bound parameters.
       #
       # The number of arguments must equal the number of bound parameters.
@@ -298,92 +143,16 @@ module Cql
       #
       # @param args [Array] the values for the bound parameters, and optionally
       #   the desired consistency level, as a symbol (defaults to :quorum)
-      #
       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)
-      end
-    end
-
-    class AuthenticationRequired
-      attr_reader :authentication_class
-
-      def initialize(authentication_class)
-        @authentication_class = authentication_class
-      end
-    end
-
-    class QueryResult
-      include Enumerable
-
-      # @return [ResultMetadata]
-      attr_reader :metadata
-
-      # @private
-      def initialize(metadata, rows)
-        @metadata = ResultMetadata.new(metadata)
-        @rows = rows
-      end
-
-      # Returns whether or not there are any rows in this result set
-      #
-      def empty?
-        @rows.empty?
-      end
-
-      # Iterates over each row in the result set.
-      #
-      # @yieldparam [Hash] row each row in the result set as a hash
-      # @return [Enumerable<Hash>]
-      #
-      def each(&block)
-        @rows.each(&block)
-      end
-      alias_method :each_row, :each
-    end
-
-    class ResultMetadata
-      include Enumerable
-
-      # @private
-      def initialize(metadata)
-        @metadata = metadata.each_with_object({}) { |m, h| h[m[2]] = ColumnMetadata.new(*m) }
-      end
-
-      # Returns the column metadata
-      #
-      # @return [ColumnMetadata] column_metadata the metadata for the column
-      #
-      def [](column_name)
-        @metadata[column_name]
-      end
-
-      # Iterates over the metadata for each column
-      #
-      # @yieldparam [ColumnMetadata] metadata the metadata for each column
-      # @return [Enumerable<ColumnMetadata>]
-      #
-      def each(&block)
-        @metadata.each_value(&block)
-      end
-    end
-
-    # Represents metadata about a column in a query result set or prepared
-    # statement. Apart from the keyspace, table and column names there's also
-    # the type as a symbol (e.g. `:varchar`, `:int`, `:date`).
-    class ColumnMetadata
-      attr_reader :keyspace, :table, :column_name, :type
-      
-      # @private
-      def initialize(*args)
-        @keyspace, @table, @column_name, @type = args
-      end
-
-      # @private
-      def to_ary
-        [@keyspace, @table, @column_name, @type]
       end
     end
   end
-end
+end
+
+require 'cql/client/column_metadata'
+require 'cql/client/result_metadata'
+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'