cassandra-driver 1.0.0.beta.3 → 1.0.0.rc.1

data/lib/cassandra/auth/providers/password.rb

@@ -22,7 +22,7 @@ module Cassandra
       # Auth provider used for Cassandra's built in authentication.
       #
       # @note No need to instantiate this class manually, use `:username` and
-      #   `:password` options when calling {Cassandra.connect} and one will be
+      #   `:password` options when calling {Cassandra.cluster} and one will be
       #   created automatically for you.
       class Password < Provider
         # Authenticator used for Cassandra's built in authentication,

data/lib/cassandra/client.rb

@@ -118,9 +118,9 @@ module Cassandra
     #   significant events pass an object implementing the standard Ruby logger
     #   interface (e.g. quacks like `Logger` from the standard library) with
     #   this option.
-    # @raise Cassandra::Io::ConnectionError when a connection couldn't be established
+    # @raise [Cassandra::Errors::IOError] when a connection couldn't be established
     #   to any node
-    # @raise Cassandra::Errors::QueryError when the specified keyspace does not exist
+    # @raise [Cassandra::Errors::ExecutionError] when the specified keyspace does not exist
     #   or when the specifed CQL version is not supported.
     # @return [Cassandra::Client::Client]
     def self.connect(options={})

data/lib/cassandra/client/batch.rb

@@ -54,7 +54,7 @@ module Cassandra
       # @param [Hash] options an options hash or a symbol (as a shortcut for
       #   specifying the consistency), see {Cassandra::Client::Client#execute} for
       #   full details about how this value is interpreted.
-      # @raise [Cassandra::Errors::QueryError] raised when there is an error on the server side
+      # @raise [Cassandra::Errors::ExecutionError] raised when there is an error on the server side
       # @raise [Cassandra::Errors::NotPreparedError] raised in the unlikely event that a
       #   prepared statement was not prepared on the chosen connection
       # @return [Cassandra::Client::VoidResult] a batch always returns a void result
@@ -77,7 +77,7 @@ module Cassandra
       #
       # Execute the batch and return the result.
       #
-      # @raise [Cassandra::Errors::QueryError] raised when there is an error on the server side
+      # @raise [Cassandra::Errors::ExecutionError] raised when there is an error on the server side
       # @raise [Cassandra::Errors::NotPreparedError] raised in the unlikely event that a
       #   prepared statement was not prepared on the chosen connection
       # @return [Cassandra::Client::VoidResult] a batch always returns a void result
@@ -86,7 +86,7 @@ module Cassandra
     # @private
     class AsynchronousBatch < Batch
       def initialize(type, execute_options_decoder, connection_manager, options=nil)
-        raise ArgumentError, "Unknown batch type: #{type}" unless BATCH_TYPES.include?(type)
+        raise ::ArgumentError, "Unknown batch type: #{type}" unless BATCH_TYPES.include?(type)
         @type = type
         @execute_options_decoder = execute_options_decoder
         @connection_manager = connection_manager

data/lib/cassandra/client/client.rb

@@ -67,7 +67,7 @@ module Cassandra
       # The the second parameter is meant for internal use only.
       #
       # @param [String] keyspace
-      # @raise [Cassandra::Errors::NotConnectedError] raised when the client is not connected
+      # @raise [Cassandra::Errors::ClientError] raised when the client is not connected
       # @return [nil]
 
       # @!method execute(cql, *values, options={})
@@ -135,7 +135,7 @@ module Cassandra
       #   to be `:serial` by the server if none is specified. Ignored for non-
       #   conditional queries.
       # @option options [Integer] :timeout (nil) How long to wait
-      #   for a response. If this timeout expires a {Cassandra::TimeoutError} will
+      #   for a response. If this timeout expires a {Cassandra::Errors::TimeoutError} will
       #   be raised.
       # @option options [Boolean] :trace (false) Request tracing
       #   for this request. See {Cassandra::Client::QueryResult} and
@@ -152,10 +152,10 @@ module Cassandra
       #   element should be the type of the corresponding value, or nil if you
       #   prefer the encoder to guess. The types should be provided as lower
       #   case symbols, e.g. `:int`, `:time_uuid`, etc.
-      # @raise [Cassandra::Errors::NotConnectedError] raised when the client is not connected
-      # @raise [Cassandra::TimeoutError] raised when a timeout was specified and no
+      # @raise [Cassandra::Errors::ClientError] raised when the client is not connected
+      # @raise [Cassandra::Errors::TimeoutError] raised when a timeout was specified and no
       #   response was received within the timeout.
-      # @raise [Cassandra::Errors::QueryError] raised when the CQL has syntax errors or for
+      # @raise [Cassandra::Errors::ExecutionError] raised when the CQL has syntax errors or for
       #   other situations when the server complains.
       # @return [nil, Cassandra::Client::QueryResult, Cassandra::Client::VoidResult] Some
       #   queries have no result and return `nil`, but `SELECT` statements
@@ -170,10 +170,10 @@ module Cassandra
       #
       # @see Cassandra::Client::PreparedStatement
       # @param [String] cql The CQL to prepare
-      # @raise [Cassandra::Errors::NotConnectedError] raised when the client is not connected
+      # @raise [Cassandra::Errors::ClientError] raised when the client is not connected
       # @raise [Cassandra::Errors::IoError] raised when there is an IO error, for example
       #   if the server suddenly closes the connection
-      # @raise [Cassandra::Errors::QueryError] raised when there is an error on the server
+      # @raise [Cassandra::Errors::ExecutionError] raised when there is an error on the server
       #   side, for example when you specify a malformed CQL query
       # @return [Cassandra::Client::PreparedStatement] an object encapsulating the
       #   prepared statement
@@ -230,7 +230,7 @@ module Cassandra
         @cql_version = options[:cql_version]
         @logger = options[:logger] || NullLogger.new
         @protocol_version = options[:protocol_version] || 2
-        @io_reactor = options[:io_reactor] || Io::IoReactor.new
+        @io_reactor = options[:io_reactor] || Ione::Io::IoReactor.new
         @hosts = extract_hosts(options)
         @initial_keyspace = options[:keyspace]
         @connections_per_node = options[:connections_per_node] || 1
@@ -380,12 +380,12 @@ module Cassandra
       def connect_with_protocol_version_fallback
         f = create_cluster_connector.connect_all(@hosts, @connections_per_node)
         f.fallback do |error|
-          if error.is_a?(Errors::QueryError) && error.code == 0x0a && @protocol_version > 1
+          if error.is_a?(Errors::ProtocolError) && @protocol_version > 1
             @logger.warn('Could not connect using protocol version %d (will try again with %d): %s' % [@protocol_version, @protocol_version - 1, error.message])
             @protocol_version -= 1
             connect_with_protocol_version_fallback
           else
-            raise error
+            raise(error, error.message, error.backtrace)
           end
         end
       end
@@ -447,7 +447,7 @@ module Cassandra
       end
 
       def with_failure_handler
-        return Ione::Future.failed(Errors::NotConnectedError.new) unless can_execute?
+        return Ione::Future.failed(Errors::ClientError.new) unless can_execute?
         yield
       rescue => e
         Ione::Future.failed(e)
@@ -472,7 +472,7 @@ module Cassandra
             if connected?
               begin
                 register_event_listener(@connection_manager.random_connection)
-              rescue Errors::NotConnectedError
+              rescue Errors::IOError
                 # we had started closing down after the connection check
               end
             end

data/lib/cassandra/client/connection_manager.rb

@@ -53,7 +53,7 @@ module Cassandra
       end
 
       def random_connection
-        raise Errors::NotConnectedError unless connected?
+        raise Errors::IOError, 'Not connected' unless connected?
         @lock.synchronize do
           @connections.sample
         end
@@ -61,7 +61,7 @@ module Cassandra
 
       def each_connection(&callback)
         return self unless block_given?
-        raise Errors::NotConnectedError unless connected?
+        raise Errors::IOError, 'Not connected' unless connected?
         @lock.synchronize do
           @connections.each(&callback)
         end

data/lib/cassandra/client/connector.rb

@@ -39,11 +39,8 @@ module Cassandra
         Ione::Future.all(*connections).map do |connections|
           connected_connections = connections.select(&:connected?)
           if connected_connections.empty?
-            e = connections.first.error
-            if e.is_a?(Cassandra::Errors::QueryError) && e.code == 0x100
-              e = Errors::AuthenticationError.new(e.message)
-            end
-            raise e
+            error = connections.first.error
+            raise(error, error.message, error.backtrace)
           end
           connected_connections
         end
@@ -131,10 +128,9 @@ module Cassandra
         compression = @compressor && @compressor.algorithm
         supported_algorithms = pending_connection[:compression]
         if compression && !supported_algorithms.include?(compression)
-          @logger.warn(%[Compression algorithm "#{compression}" not supported (server supports "#{supported_algorithms.join('", "')}")])
+          @logger.info("Compression with #{compression.inspect} is not supported by host at #{pending_connection.host}, supported algorithms are #{supported_algorithms.inspect}")
           compression = nil
         end
-        @logger.debug('Using "%s" compression' % compression) if compression
         supported_cql_versions = pending_connection[:cql_version]
         cql_version = (supported_cql_versions && !supported_cql_versions.empty?) ? supported_cql_versions.first : '3.1.0'
 
@@ -165,10 +161,10 @@ module Cassandra
             elsif @auth_provider
               Ione::Future.failed(Errors::AuthenticationError.new('Auth provider does not support the required authentication class "%s" and/or protocol version %d' % [pending_connection.authentication_class, @protocol_version]))
             else
-              Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but no auth provider found'))
+              Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
             end
           rescue => e
-            Ione::Future.failed(Errors::AuthenticationError.new('Auth provider raised an error: %s' % e.message))
+            Ione::Future.failed(Errors::AuthenticationError.new('Auth provider error (%s: %s)' % [e.class.name, e.message]))
           end
         else
           Ione::Future.resolved(pending_connection)
@@ -205,7 +201,7 @@ module Cassandra
             request = Protocol::CredentialsRequest.new(@credentials)
             pending_connection.execute(request).map(pending_connection)
           else
-            Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but no credentials provided'))
+            Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
           end
         else
           Ione::Future.resolved(pending_connection)

data/lib/cassandra/client/prepared_statement.rb

@@ -90,7 +90,7 @@ module Cassandra
       #   for details on which options are available.
       # @raise [ArgumentError] raised when number of argument does not match
       #   the number of parameters needed to be bound to the statement.
-      # @raise [Cassandra::Errors::NotConnectedError] raised when the client is not connected
+      # @raise [Cassandra::Errors::ClientError] raised when the client is not connected
       # @raise [Cassandra::Errors::IoError] raised when there is an IO error, for example
       #   if the server suddenly closes the connection
       # @raise [Cassandra::Errors::QueryError] raised when there is an error on the server side
@@ -221,10 +221,10 @@ module Cassandra
       def add_to_batch(batch, connection, bound_args)
         statement_id = connection[self]
         unless statement_id
-          raise Errors::NotPreparedError
+          raise ::ArgumentError, "Statement was not prepared"
         end
         unless bound_args.size == @raw_metadata.size
-          raise ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
+          raise ::ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
         end
         batch.add_prepared(statement_id, @raw_metadata, bound_args)
       end
@@ -234,7 +234,7 @@ module Cassandra
       def run(args, connection)
         bound_args = args.shift(@raw_metadata.size)
         unless bound_args.size == @raw_metadata.size && args.size <= 1
-          raise ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
+          raise ::ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
         end
         options = @execute_options_decoder.decode_options(args.last)
         statement_id = connection[self]

data/lib/cassandra/client/request_runner.rb

@@ -31,8 +31,7 @@ module Cassandra
             response.trace_id ? VoidResult.new(response.trace_id) : VoidResult::INSTANCE
           when Protocol::ErrorResponse
             cql = request.is_a?(Protocol::QueryRequest) ? request.cql : nil
-            details = response.respond_to?(:details) ? response.details : nil
-            raise Errors::QueryError.new(response.code, response.message, cql, details)
+            raise response.to_error(cql)
           when Protocol::SetKeyspaceResultResponse
             KeyspaceChanged.new(response.keyspace)
           when Protocol::AuthenticateResponse

data/lib/cassandra/cluster.rb

@@ -63,7 +63,7 @@ module Cassandra
     def_delegators :@metadata, :name, :find_replicas
 
     # @private
-    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory)
+    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connector, futures_factory)
       @logger                = logger
       @io_reactor            = io_reactor
       @control_connection    = control_connection
@@ -75,6 +75,7 @@ module Cassandra
       @load_balancing_policy = load_balancing_policy
       @reconnection_policy   = reconnection_policy
       @retry_policy          = retry_policy
+      @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
     end
@@ -133,19 +134,22 @@ module Cassandra
     #
     # @return [Cassandra::Future<Cassandra::Session>] a future new session that
     #   can prepare and execute statements
+    #
+    # @see Cassandra::Cluster#connect A list of possible exceptions that this
+    #   future can be resolved with
     def connect_async(keyspace = nil)
       if !keyspace.nil? && !keyspace.is_a?(::String)
         return @futures.error(::ArgumentError.new("keyspace must be a string, #{keyspace.inspect} given"))
       end
 
-      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @connection_options, @futures)
+      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @address_resolver, @connection_options, @futures)
       session = Session.new(client, @execution_options, @futures)
       promise = @futures.promise
 
       client.connect.on_complete do |f|
         if f.resolved?
           if keyspace
-            f = session.execute_async("USE #{keyspace}")
+            f = session.execute_async("USE #{Util.escape_name(keyspace)}")
 
             f.on_success {promise.fulfill(session)}
             f.on_failure {|e| promise.break(e)}
@@ -162,8 +166,14 @@ module Cassandra
 
     # Synchronously create a new session, optionally scoped to a keyspace
     #
-    # @param keyspace [String] optional keyspace to scope session to
-    # @raise  [ArgumentError] if keyspace is not a String
+    # @param keyspace [String] optional keyspace to scope the session to
+    #
+    # @raise [ArgumentError] if keyspace is not a String
+    # @raise [Cassandra::Errors::NoHostsAvailable] when all hosts failed
+    # @raise [Cassandra::Errors::AuthenticationError] when authentication fails
+    # @raise [Cassandra::Errors::ProtocolError] when protocol negotiation fails
+    # @raise [Cassandra::Error] other unexpected errors
+    #
     # @return [Cassandra::Session] a new session that can prepare and execute
     #   statements
     #

data/lib/cassandra/cluster/client.rb

@@ -24,7 +24,7 @@ module Cassandra
 
       attr_reader :keyspace
 
-      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, connection_options, futures_factory)
+      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connection_options, futures_factory)
         @logger                      = logger
         @registry                    = cluster_registry
         @schema                      = cluster_schema
@@ -33,9 +33,10 @@ module Cassandra
         @load_balancing_policy       = load_balancing_policy
         @reconnection_policy         = reconnection_policy
         @retry_policy                = retry_policy
+        @address_resolver            = address_resolution_policy
         @connection_options          = connection_options
         @futures                     = futures_factory
-        @connecting_hosts            = ::Set.new
+        @connecting_hosts            = ::Hash.new
         @connections                 = ::Hash.new
         @prepared_statements         = ::Hash.new
         @preparing_statements        = ::Hash.new
@@ -51,14 +52,20 @@ module Cassandra
           return @connected_future if @state == :connecting || @state == :connected
 
           @state = :connecting
-          @connecting_hosts.merge(@registry.hosts)
+          @registry.each_host do |host|
+            distance = @load_balancing_policy.distance(host)
+            next if distance == :ignore
+
+            @connecting_hosts[host] = distance
+          end
         end
 
         @connected_future = begin
+          @logger.info('Creating session')
           @registry.add_listener(self)
 
-          futures = @connecting_hosts.map do |host|
-            f = connect_to_host_maybe_retry(host, @load_balancing_policy.distance(host))
+          futures = @connecting_hosts.map do |(host, distance)|
+            f = connect_to_host(host, distance)
             f.recover do |error|
               Cassandra::Client::FailedConnection.new(error, host)
             end
@@ -116,12 +123,18 @@ module Cassandra
       end
 
       def host_up(host)
+        distance = nil
+
         synchronize do
           return Ione::Future.resolved if @connecting_hosts.include?(host)
-          @connecting_hosts << host
+
+          distance = @load_balancing_policy.distance(host)
+          return Ione::Future.resolved if distance == :ignore
+
+          @connecting_hosts[host] = distance
         end
 
-        connect_to_host_maybe_retry(host, @load_balancing_policy.distance(host)).map(nil)
+        connect_to_host_maybe_retry(host, distance).map(nil)
       end
 
       def host_down(host)
@@ -130,7 +143,6 @@ module Cassandra
         synchronize do
           return Ione::Future.resolved if !@connections.has_key?(host) && !@connecting_hosts.include?(host)
 
-          @logger.info("Session disconnecting from ip=#{host.ip}")
           @connecting_hosts.delete(host)
           @prepared_statements.delete(host)
           @preparing_statements.delete(host)
@@ -209,13 +221,17 @@ module Cassandra
         :unlogged => Protocol::BatchRequest::UNLOGGED_TYPE,
         :counter  => Protocol::BatchRequest::COUNTER_TYPE,
       }.freeze
-      CLIENT_CLOSED        = Ione::Future.failed(Errors::ClientError.new('Cannot connect a closed client'))
-      CLIENT_NOT_CONNECTED = Ione::Future.failed(Errors::ClientError.new('Cannot close a not connected client'))
-      NOT_CONNECTED        = Errors::NotConnectedError.new
+      CLIENT_CLOSED        = Ione::Future.failed(Errors::ClientError.new('Client closed'))
+      NOT_CONNECTED        = Errors::ClientError.new('Client not connected')
+      CLIENT_NOT_CONNECTED = Ione::Future.failed(NOT_CONNECTED)
 
       UNAVAILABLE_ERROR_CODE   = 0x1000
       WRITE_TIMEOUT_ERROR_CODE = 0x1100
       READ_TIMEOUT_ERROR_CODE  = 0x1200
+      OVERLOADED_ERROR_CODE    = 0x1001
+      SERVER_ERROR_CODE        = 0x0000
+      BOOTSTRAPPING_ERROR_CODE = 0x1002
+      UNPREPARED_ERROR_CODE    = 0x2500
 
       SELECT_SCHEMA_PEERS = Protocol::QueryRequest.new("SELECT peer, rpc_address, schema_version FROM system.peers", nil, nil, :one)
       SELECT_SCHEMA_LOCAL = Protocol::QueryRequest.new("SELECT schema_version FROM system.local WHERE key='local'", nil, nil, :one)
@@ -226,14 +242,14 @@ module Cassandra
             @state = :connected
           end
 
-          @logger.info('Session connected')
+          @logger.info('Session created')
         else
           synchronize do
             @state = :defunct
           end
 
           f.on_failure do |e|
-            @logger.error('Session connect failed: %s' % e.message)
+            @logger.error("Session failed to connect (#{e.class.name}: #{e.message})")
           end
 
           close
@@ -248,20 +264,17 @@ module Cassandra
             @logger.info('Session closed')
           else
             f.on_failure do |e|
-              @logger.error('Session close failed: %s' % e.message)
+              @logger.error("Session failed to close (#{e.class.name}: #{e.message})")
             end
           end
         end
       end
 
       def close_connections
-        @logger.info('Session closing')
-
         futures = []
         synchronize do
           @connections.each do |host, connections|
             connections.snapshot.each do |c|
-              @logger.info("Disconnecting ip=#{c.host}")
               futures << c.close
             end
           end.clear
@@ -274,7 +287,7 @@ module Cassandra
         f = connect_to_host(host, distance)
 
         f.on_failure do |e|
-          connect_to_host_with_retry(host, @reconnection_policy.schedule) if e.is_a?(Io::ConnectionError) || e.is_a?(::SystemCallError) || e.is_a?(::SocketError)
+          connect_to_host_with_retry(host, @reconnection_policy.schedule)
         end
 
         f
@@ -283,21 +296,23 @@ module Cassandra
       def connect_to_host_with_retry(host, schedule)
         interval = schedule.next
 
-        @logger.info("Session started reconnecting to ip=#{host.ip} delay=#{interval}")
+        @logger.debug("Reconnecting to #{host.ip} in #{interval} seconds")
 
         f = @reactor.schedule_timer(interval)
         f.flat_map do
-          if synchronize { @connecting_hosts.include?(host) }
-            connect_to_host(host, @load_balancing_policy.distance(host)).fallback do |e|
-              if e.is_a?(Io::ConnectionError) || e.is_a?(::SystemCallError) || e.is_a?(::SocketError)
-                connect_to_host_with_retry(host, schedule)
-              else
-                Ione::Future.failed(e)
-              end
+          distance = nil
+
+          synchronize do
+            if @connecting_hosts.include?(host)
+              distance = @load_balancing_policy.distance(host)
             end
-          else
-            @logger.info("Session reconnection to ip=#{host.ip} cancelled")
+          end
 
+          if distance && distance != :ignore
+            connect_to_host(host, distance).fallback do |e|
+              connect_to_host_with_retry(host, schedule)
+            end
+          else
             NO_CONNECTIONS
           end
         end
@@ -312,18 +327,16 @@ module Cassandra
         when :remote
           pool_size = @connection_options.connections_per_remote_node
         else
-          raise ::ArgumentError, "distance must be one of :ignore, :local or :remote, #{distance.inspect} given"
+          @logger.error("Invalid load balancing distance, not connecting to #{host.ip}. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+          return NO_CONNECTIONS
         end
 
-        @logger.info("Session connecting to ip=#{host.ip}")
-
         f = @connector.connect_many(host, pool_size)
 
         f.on_value do |connections|
           manager = nil
 
           synchronize do
-            @logger.info("Session connected to ip=#{host.ip}")
             @connecting_hosts.delete(host)
             @prepared_statements[host] = {}
             @preparing_statements[host] = {}
@@ -338,7 +351,7 @@ module Cassandra
 
       def execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -361,12 +374,13 @@ module Cassandra
               prepare_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -395,12 +409,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               prepare.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -410,7 +425,7 @@ module Cassandra
 
       def batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -433,12 +448,13 @@ module Cassandra
               batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -492,12 +508,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               f.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -507,7 +524,7 @@ module Cassandra
 
       def send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -530,12 +547,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -564,32 +582,78 @@ module Cassandra
                 when UNAVAILABLE_ERROR_CODE
                   @retry_policy.unavailable(statement, details[:cl], details[:required], details[:alive], retries)
                 when WRITE_TIMEOUT_ERROR_CODE
-                  details[:write_type] = write_type = details[:write_type].downcase!.to_sym
-                  @retry_policy.write_timeout(statement, details[:cl], write_type, details[:blockfor], details[:received], retries)
+                  @retry_policy.write_timeout(statement, details[:cl], details[:write_type], details[:blockfor], details[:received], retries)
                 when READ_TIMEOUT_ERROR_CODE
                   @retry_policy.read_timeout(statement, details[:cl], details[:blockfor], details[:received], details[:data_present], retries)
+                when UNPREPARED_ERROR_CODE
+                  cql = statement.cql
+
+                  synchronize do
+                    @preparing_statements[host].delete(cql)
+                    @prepared_statements[host].delete(cql)
+                  end
+
+                  prepare = prepare_statement(host, connection, cql, timeout)
+                  prepare.on_complete do |_|
+                    if prepare.resolved?
+                      request.id = prepare.value
+                      do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                    else
+                      prepare.on_failure do |e|
+                        case e
+                        when Errors::HostError
+                          errors ||= {}
+                          errors[host] = e
+                          execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                        else
+                          promise.break(e)
+                        end
+                      end
+                    end
+                  end
+
+                  nil
                 else
-                  promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, details))
-                  break
+                  promise.break(r.to_error(statement))
+
+                  nil
                 end
               rescue => e
                 promise.break(e)
-                break
+
+                nil
               end
 
-              case decision
-              when Retry::Decisions::Retry
-                request.consistency = decision.consistency
-                do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts, retries + 1)
-              when Retry::Decisions::Ignore
-                promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              when Retry::Decisions::Reraise
-                promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, r.details))
-              else
-                promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, r.details))
+              if decision
+                case decision
+                when Retry::Decisions::Retry
+                  request.consistency = decision.consistency
+                  do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts, retries + 1)
+                when Retry::Decisions::Ignore
+                  promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+                when Retry::Decisions::Reraise
+                  promise.break(r.to_error(statement))
+                else
+                  promise.break(r.to_error(statement))
+                end
               end
             when Protocol::ErrorResponse
-              promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, nil))
+              case r.code
+              when OVERLOADED_ERROR_CODE, SERVER_ERROR_CODE, BOOTSTRAPPING_ERROR_CODE
+                errors ||= {}
+                errors[host] = r.to_error(statement)
+
+                case request
+                when Protocol::QueryRequest, Protocol::PrepareRequest
+                  send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                when Protocol::ExecuteRequest
+                  execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                when Protocol::BatchRequest
+                  batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                end
+              else
+                promise.break(r.to_error(statement))
+              end
             when Protocol::SetKeyspaceResultResponse
               @keyspace = r.keyspace
               promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
@@ -611,10 +675,11 @@ module Cassandra
                 @keyspace = nil
               end
 
+              @logger.debug('Waiting for schema to propagate to all hosts after a change')
               wait_for_schema_agreement(connection, @reconnection_policy.schedule).on_complete do |f|
                 unless f.resolved?
                   f.on_failure do |e|
-                    @logger.error("Schema agreement error: #{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}")
+                    @logger.error("Schema agreement failure (#{e.class.name}: #{e.message})")
                   end
                 end
                 promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
@@ -642,42 +707,35 @@ module Cassandra
       end
 
       def wait_for_schema_agreement(connection, schedule)
-        @logger.info('Fetching schema versions')
-
-        peers = connection.send_request(SELECT_SCHEMA_PEERS)
-        local = connection.send_request(SELECT_SCHEMA_LOCAL)
+        peers = send_select_request(connection, SELECT_SCHEMA_PEERS)
+        local = send_select_request(connection, SELECT_SCHEMA_LOCAL)
 
         Ione::Future.all(peers, local).flat_map do |(peers, local)|
-          @logger.info('Fetched schema versions')
-
-          peers = peers.rows
-          local = local.rows
-
           versions = ::Set.new
 
           unless local.empty?
             host = @registry.host(connection.host)
 
-            if host && host.up?
+            if host && @load_balancing_policy.distance(host) != :ignore
               versions << version = local.first['schema_version']
-              @logger.debug("Host #{host.ip} schema version: #{version}")
+              @logger.debug("Host #{host.ip} schema version is #{version}")
             end
           end
 
           peers.each do |row|
             host = @registry.host(peer_ip(row))
-            next unless host && host.up?
+            next unless host && @load_balancing_policy.distance(host) != :ignore
 
             versions << version = row['schema_version']
-            @logger.debug("Host #{host.ip} schema version: #{version}")
+            @logger.debug("Host #{host.ip} schema version is #{version}")
           end
 
           if versions.one?
-            @logger.info('All hosts have the same schema version')
+            @logger.debug('All hosts have the same schema')
             Ione::Future.resolved
           else
             interval = schedule.next
-            @logger.info("Hosts don't yet agree on schema: #{versions.to_a.inspect}, retrying in #{interval} seconds")
+            @logger.info("Hosts have different schema versions: #{versions.to_a.inspect}, retrying in #{interval} seconds")
             @reactor.schedule_timer(interval).flat_map do
               wait_for_schema_agreement(connection, schedule)
             end
@@ -688,7 +746,8 @@ module Cassandra
       def peer_ip(data)
         ip = data['rpc_address']
         ip = data['peer'] if ip == '0.0.0.0'
-        ip
+
+        @address_resolver.resolve(ip)
       end
 
       def switch_keyspace(connection, keyspace, timeout)
@@ -697,19 +756,17 @@ module Cassandra
 
         return pending_switch || Ione::Future.resolved if pending_keyspace == keyspace
 
-        request = Protocol::QueryRequest.new("USE #{keyspace}", nil, nil, :one)
+        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}", nil, nil, :one)
 
         f = connection.send_request(request, timeout).map do |r|
           case r
           when Protocol::SetKeyspaceResultResponse
             @keyspace = r.keyspace
             nil
-          when Protocol::DetailedErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, request.cql, r.details)
           when Protocol::ErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, request.cql, nil)
+            raise r.to_error(Statements::Simple.new("USE #{Util.escape_name(keyspace)}"))
           else
-            raise "unexpected response #{r.inspect}"
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
         end
 
@@ -742,12 +799,10 @@ module Cassandra
               @preparing_statements[host].delete(cql)
             end
             id
-          when Protocol::DetailedErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, cql, r.details)
           when Protocol::ErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, cql, nil)
+            raise r.to_error(VOID_STATEMENT)
           else
-            raise "unexpected response #{r.inspect}"
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
         end
 
@@ -758,10 +813,17 @@ module Cassandra
         f
       end
 
-      def create_execution_info(keyspace, statement, options, request, response, hosts)
-        trace_id = response.trace_id
-        trace    = trace_id ? Execution::Trace.new(trace_id, self) : nil
-        info     = Execution::Info.new(keyspace, statement, options, hosts, request.consistency, request.retries, trace)
+      def send_select_request(connection, request)
+        connection.send_request(request).map do |r|
+          case r
+          when Protocol::RowsResultResponse
+            r.rows
+          when Protocol::ErrorResponse
+            raise r.to_error(VOID_STATEMENT)
+          else
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
+          end
+        end
       end
     end
   end