cassandra-driver 3.0.0.beta.1 → 3.0.0.rc.1

data/lib/cassandra/address_resolution.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cassandra/address_resolution/policies/ec2_multi_region.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cassandra/address_resolution/policies/none.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cassandra/aggregate.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -40,7 +40,14 @@ module Cassandra
     attr_reader :final_function
 
     # @private
-    def initialize(keyspace, name, type, argument_types, state_type, initial_state, state_function, final_function)
+    def initialize(keyspace,
+                   name,
+                   type,
+                   argument_types,
+                   state_type,
+                   initial_state,
+                   state_function,
+                   final_function)
       @keyspace       = keyspace
       @name           = name
       @type           = type
@@ -63,7 +70,7 @@ module Cassandra
         @state_function == other.state_function && \
         @final_function == other.final_function
     end
-    alias :== :eql?
+    alias == eql?
 
     # @private
     def hash
@@ -83,12 +90,19 @@ module Cassandra
 
     # @private
     def inspect
-      "#<Cassandra::Aggregate:0x#{self.object_id.to_s(16)} @keyspace=#{@keyspace.inspect}, @name=#{@name.inspect}, @type=#{@type.inspect}, @argument_types=#{@argument_types.inspect}, @initial_state=#{@initial_state.inspect}, @state_function=#{@state_function.inspect}, @final_function=#{@final_function.inspect}>"
+      "#<Cassandra::Aggregate:0x#{object_id.to_s(16)} " \
+          "@keyspace=#{@keyspace.inspect}, " \
+          "@name=#{@name.inspect}, " \
+          "@type=#{@type.inspect}, " \
+          "@argument_types=#{@argument_types.inspect}, " \
+          "@initial_state=#{@initial_state.inspect}, " \
+          "@state_function=#{@state_function.inspect}, " \
+          "@final_function=#{@final_function.inspect}>"
     end
 
     # @return [String] a cql representation of this aggregate
     def to_cql
-      cql = "CREATE AGGREGATE simplex.average("
+      cql = 'CREATE AGGREGATE simplex.average('
       first = true
       @argument_types.each do |type|
         if first
@@ -98,12 +112,12 @@ module Cassandra
         end
         cql << type.to_s
       end
-      cql << ")"
+      cql << ')'
       cql << "\n  SFUNC #{@state_function.name}"
       cql << "\n  STYPE #{@state_type}"
       cql << "\n  FINALFUNC #{@final_function.name}" if @final_function
       cql << "\n  INITCOND #{@initial_state}"
-      cql << ";"
+      cql << ';'
     end
   end
 end

data/lib/cassandra/argument.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -36,7 +36,7 @@ module Cassandra
         @name == other.name && \
         @type == other.type
     end
-    alias :== :eql?
+    alias == eql?
 
     # @private
     def hash

data/lib/cassandra/auth.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,9 +18,9 @@
 
 module Cassandra
   module Auth
-    # An auth provider is a factory for {Cassandra::Auth::Authenticator authenticator} instances (or objects matching that interface). Its
-    # {#create_authenticator} will be called once for each connection that
-    # requires authentication.
+    # An auth provider is a factory for {Cassandra::Auth::Authenticator authenticator}
+    # instances (or objects matching that interface). Its {#create_authenticator} will
+    # be called once for each connection that requires authentication.
     #
     # If the authentication requires keeping state, keep that in the
     # authenticator instances, not in the auth provider.

data/lib/cassandra/auth/providers.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -53,9 +53,12 @@ module Cassandra
           @password = password
         end
 
-        # Returns a Password Authenticator only if `org.apache.cassandra.auth.PasswordAuthenticator` is given.
-        # @param authentication_class [String] must equal to `org.apache.cassandra.auth.PasswordAuthenticator`
-        # @return [Cassandra::Auth::Authenticator] when `authentication_class == "org.apache.cassandra.auth.PasswordAuthenticator"`
+        # Returns a Password Authenticator only if
+        # `org.apache.cassandra.auth.PasswordAuthenticator` is given.
+        # @param authentication_class [String] must equal to
+        #   `org.apache.cassandra.auth.PasswordAuthenticator`
+        # @return [Cassandra::Auth::Authenticator] when `authentication_class ==
+        #    "org.apache.cassandra.auth.PasswordAuthenticator"`
         # @return [nil] for all other values of `authentication_class`
         def create_authenticator(authentication_class)
           if authentication_class == PASSWORD_AUTHENTICATOR_FQCN
@@ -66,7 +69,8 @@ module Cassandra
         private
 
         # @private
-        PASSWORD_AUTHENTICATOR_FQCN = 'org.apache.cassandra.auth.PasswordAuthenticator'.freeze
+        PASSWORD_AUTHENTICATOR_FQCN =
+          'org.apache.cassandra.auth.PasswordAuthenticator'.freeze
       end
     end
   end

data/lib/cassandra/cassandra_logger.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2016 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require 'logger'
+module Cassandra
+  # This class is a logger that may be used by the client to log the driver's actions.
+  # It is a subclass of the standard Ruby Logger class, so it is instantiated the
+  # same way.
+  #
+  # The format of log output is set to include the timestamp, thread-id, log severity,
+  # and message. <b>This format may change in newer versions of the driver to account
+  # for new/deprecated metadata.</b>
+  #
+  # @example Configuring {Cassandra::Cluster} to use a logger.
+  #   cluster = Cassandra.cluster(logger: Cassandra::Logger.new($stderr))
+  #
+  # @example The log format may be changed the same way as in the standard Ruby Logger class
+  #   logger = Cassandra::Logger.new($stderr)
+  #   logger.formatter = proc { |severity, time, program_name, message|
+  #     "[%s]: %s\n" % [severity, message]
+  #   }
+  #
+  # @example Create a logger and use it in your own business logic
+  #   logger = Cassandra::Logger.new($stderr)
+  #   cluster = Cassandra.cluster(logger: logger)
+  #   <various logic>
+  #   logger.debug("something interesting happened.")
+
+  class Logger < ::Logger
+    # @private
+    # This class is mostly copied from the Ruby Logger::Format class.
+    class Formatter
+      Format = "[%s#%d] %5s: %s\n".freeze
+
+      def call(severity, time, _, msg)
+        format(Format,
+               format_datetime(time),
+               Thread.current.object_id,
+               severity,
+               msg2str(msg))
+      end
+
+      def format_datetime(time)
+        time.strftime('%H:%M:%S.') << format('%06d ', time.usec)
+      end
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" <<
+            (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+
+    def initialize(*args)
+      super(*args)
+      self.formatter = Formatter.new
+    end
+  end
+end

data/lib/cassandra/cluster.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,7 +17,8 @@
 #++
 
 module Cassandra
-  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session session factory} factory and a collection of metadata.
+  # Cluster represents a cassandra cluster. It serves as a
+  # {Cassandra::Session session factory} factory and a collection of metadata.
   #
   # @see Cassandra::Cluster#connect Creating a new session
   # @see Cassandra::Cluster#each_host Getting all peers in the cluster
@@ -26,7 +27,21 @@ module Cassandra
     extend Forwardable
 
     # @private
-    def initialize(logger, io_reactor, executor, 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)
+    def initialize(logger,
+                   io_reactor,
+                   executor,
+                   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
       @executor              = executor
@@ -43,8 +58,12 @@ module Cassandra
       @connector             = connector
       @futures               = futures_factory
 
-      @control_connection.on_close do |cause|
-        @load_balancing_policy.teardown(self) rescue nil
+      @control_connection.on_close do |_cause|
+        begin
+          @load_balancing_policy.teardown(self)
+        rescue
+          nil
+        end
       end
     end
 
@@ -95,7 +114,7 @@ module Cassandra
       return self if r == @registry
       r
     end
-    alias :hosts :each_host
+    alias hosts each_host
 
     # @!method host(address)
     #   Find a host by its address
@@ -119,7 +138,7 @@ module Cassandra
       return self if r == @schema
       r
     end
-    alias :keyspaces :each_keyspace
+    alias keyspaces each_keyspace
 
     # @!method keyspace(name)
     #   Find a keyspace by name
@@ -175,7 +194,17 @@ module Cassandra
         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, @address_resolver, @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
 
@@ -246,7 +275,7 @@ module Cassandra
 
     # @private
     def inspect
-      "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
+      "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
     end
   end
 end

data/lib/cassandra/cluster/client.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -24,7 +24,17 @@ module Cassandra
 
       attr_reader :keyspace
 
-      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_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
@@ -65,7 +75,9 @@ module Cassandra
             when :remote
               pool_size = @connection_options.connections_per_remote_node
             else
-              @logger.error("Not connecting to #{host.ip} - invalid load balancing distance. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+              @logger.error("Not connecting to #{host.ip} - invalid load balancing " \
+                'distance. Distance must be one of ' \
+                "#{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
               next
             end
 
@@ -101,7 +113,9 @@ module Cassandra
               raise Errors::NoHostsAvailable.new(errors)
             else
               failed_connections.each do |f|
-                connect_to_host_with_retry(f.host, connecting_hosts[f.host], @reconnection_policy.schedule)
+                connect_to_host_with_retry(f.host,
+                                           connecting_hosts[f.host],
+                                           @reconnection_policy.schedule)
               end
             end
 
@@ -119,18 +133,19 @@ module Cassandra
           return CLIENT_NOT_CONNECTED if @state == :idle
           return @closed_future if @state == :closed || @state == :closing
 
-          state, @state = @state, :closing
+          state = @state
+          @state = :closing
         end
 
         @closed_future = begin
           @registry.remove_listener(self)
           @schema.remove_listener(self)
 
-          if state == :connecting
-            f = @connected_future.recover.flat_map { close_connections }
-          else
-            f = close_connections
-          end
+          f = if state == :connecting
+                @connected_future.recover.flat_map { close_connections }
+              else
+                close_connections
+              end
 
           f.map(self)
         end
@@ -160,7 +175,9 @@ module Cassandra
           when :remote
             pool_size = @connection_options.connections_per_remote_node
           else
-            @logger.error("Not connecting to #{host.ip} - invalid load balancing distance. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+            @logger.error("Not connecting to #{host.ip} - " \
+              'invalid load balancing distance. Distance must be one of ' \
+              "#{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
             return Ione::Future.resolved
           end
 
@@ -177,7 +194,7 @@ module Cassandra
         pool = nil
 
         synchronize do
-          return Ione::Future.resolved unless @connections.has_key?(host)
+          return Ione::Future.resolved unless @connections.key?(host)
 
           @pending_connections.delete(host) unless @pending_connections[host] > 0
           @prepared_statements.delete(host)
@@ -186,7 +203,7 @@ module Cassandra
         end
 
         if pool
-          Ione::Future.all(*pool.snapshot.map! {|c| c.close}).map(nil)
+          Ione::Future.all(*pool.snapshot.map!(&:close)).map(nil)
         else
           Ione::Future.resolved
         end
@@ -203,29 +220,52 @@ module Cassandra
         nil
       end
 
-
       def query(statement, options)
-        return @futures.error(Errors::ClientError.new("Positional arguments are not supported by the current version of Apache Cassandra")) if !statement.params.empty? && @connection_options.protocol_version == 1
+        if !statement.params.empty? && @connection_options.protocol_version == 1
+          return @futures.error(
+            Errors::ClientError.new(
+              'Positional arguments are not supported by the current version of ' \
+              'Apache Cassandra'))
+        end
 
         timestamp = nil
-        timestamp = ::Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
+        if @connection_options.client_timestamps? &&
+           @connection_options.protocol_version > 2
+          timestamp = ::Time.now
+        end
         payload   = nil
-        payload   = options.payload if  @connection_options.protocol_version >= 4
-        request   = Protocol::QueryRequest.new(statement.cql, statement.params, statement.params_types, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?, statement.params_names, timestamp, payload)
+        payload   = options.payload if @connection_options.protocol_version >= 4
+        request   = Protocol::QueryRequest.new(statement.cql,
+                                               statement.params,
+                                               statement.params_types,
+                                               options.consistency,
+                                               options.serial_consistency,
+                                               options.page_size,
+                                               options.paging_state,
+                                               options.trace?,
+                                               statement.params_names,
+                                               timestamp,
+                                               payload)
         timeout   = options.timeout
         promise   = @futures.promise
 
         keyspace = @keyspace
         plan     = @load_balancing_policy.plan(keyspace, statement, options)
 
-        send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout)
+        send_request_by_plan(promise,
+                             keyspace,
+                             statement,
+                             options,
+                             request,
+                             plan,
+                             timeout)
 
         promise.future
       end
 
       def prepare(cql, options)
         payload = nil
-        payload = options.payload if  @connection_options.protocol_version >= 4
+        payload = options.payload if @connection_options.protocol_version >= 4
         request = Protocol::PrepareRequest.new(cql, options.trace?, payload)
         timeout = options.timeout
         promise = @futures.promise
@@ -234,19 +274,38 @@ module Cassandra
         statement = VOID_STATEMENT
         plan      = @load_balancing_policy.plan(keyspace, statement, options)
 
-        send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout)
+        send_request_by_plan(promise,
+                             keyspace,
+                             statement,
+                             options,
+                             request,
+                             plan,
+                             timeout)
 
         promise.future
       end
 
       def execute(statement, options)
-        timestamp       = nil
-        timestamp       = ::Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
+        timestamp = nil
+        if @connection_options.client_timestamps? &&
+           @connection_options.protocol_version > 2
+          timestamp = ::Time.now
+        end
         payload         = nil
-        payload         = options.payload if  @connection_options.protocol_version >= 4
+        payload         = options.payload if @connection_options.protocol_version >= 4
         timeout         = options.timeout
         result_metadata = statement.result_metadata
-        request         = Protocol::ExecuteRequest.new(nil, statement.params_types, statement.params, result_metadata.nil?, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?, timestamp, payload)
+        request         = Protocol::ExecuteRequest.new(nil,
+                                                       statement.params_types,
+                                                       statement.params,
+                                                       result_metadata.nil?,
+                                                       options.consistency,
+                                                       options.serial_consistency,
+                                                       options.page_size,
+                                                       options.paging_state,
+                                                       options.trace?,
+                                                       timestamp,
+                                                       payload)
         promise         = @futures.promise
 
         keyspace = @keyspace
@@ -258,14 +317,27 @@ module Cassandra
       end
 
       def batch(statement, options)
-        return @futures.error(Errors::ClientError.new("Batch statements are not supported by the current version of Apache Cassandra")) if @connection_options.protocol_version < 2
+        if @connection_options.protocol_version < 2
+          return @futures.error(
+            Errors::ClientError.new(
+              'Batch statements are not supported by the current version of ' \
+              'Apache Cassandra'))
+        end
 
         timestamp = nil
-        timestamp = ::Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
+        if @connection_options.client_timestamps? &&
+           @connection_options.protocol_version > 2
+          timestamp = ::Time.now
+        end
         payload   = nil
-        payload   = options.payload if  @connection_options.protocol_version >= 4
+        payload   = options.payload if @connection_options.protocol_version >= 4
         timeout   = options.timeout
-        request   = Protocol::BatchRequest.new(BATCH_TYPES[statement.type], options.consistency, options.trace?, options.serial_consistency, timestamp, payload)
+        request   = Protocol::BatchRequest.new(BATCH_TYPES[statement.type],
+                                               options.consistency,
+                                               options.trace?,
+                                               options.serial_consistency,
+                                               timestamp,
+                                               payload)
         keyspace  = @keyspace
         plan      = @load_balancing_policy.plan(keyspace, statement, options)
         promise   = @futures.promise
@@ -276,16 +348,16 @@ module Cassandra
       end
 
       def inspect
-        "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
       end
 
       private
 
       NO_CONNECTIONS = Ione::Future.resolved([])
       BATCH_TYPES    = {
-        :logged   => Protocol::BatchRequest::LOGGED_TYPE,
-        :unlogged => Protocol::BatchRequest::UNLOGGED_TYPE,
-        :counter  => Protocol::BatchRequest::COUNTER_TYPE,
+        logged: Protocol::BatchRequest::LOGGED_TYPE,
+        unlogged: Protocol::BatchRequest::UNLOGGED_TYPE,
+        counter: Protocol::BatchRequest::COUNTER_TYPE
       }.freeze
       CLIENT_CLOSED        = Ione::Future.failed(Errors::ClientError.new('Client closed'))
       NOT_CONNECTED        = Errors::ClientError.new('Client not connected')
@@ -299,8 +371,18 @@ module Cassandra
       BOOTSTRAPPING_ERROR_CODE = 0x1002
       UNPREPARED_ERROR_CODE    = 0x2500
 
-      SELECT_SCHEMA_PEERS = Protocol::QueryRequest.new("SELECT peer, rpc_address, schema_version FROM system.peers", EMPTY_LIST, EMPTY_LIST, :one)
-      SELECT_SCHEMA_LOCAL = Protocol::QueryRequest.new("SELECT schema_version FROM system.local WHERE key='local'", EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_SCHEMA_PEERS =
+        Protocol::QueryRequest.new(
+          'SELECT peer, rpc_address, schema_version FROM system.peers',
+          EMPTY_LIST,
+          EMPTY_LIST,
+          :one)
+      SELECT_SCHEMA_LOCAL =
+        Protocol::QueryRequest.new(
+          "SELECT schema_version FROM system.local WHERE key='local'",
+          EMPTY_LIST,
+          EMPTY_LIST,
+          :one)
 
       def connected(f)
         if f.resolved?
@@ -339,7 +421,7 @@ module Cassandra
       def close_connections
         futures = []
         synchronize do
-          @connections.each do |host, connections|
+          @connections.each do |_host, connections|
             connections.snapshot.each do |c|
               futures << c.close
             end
@@ -351,7 +433,8 @@ module Cassandra
 
       def connect_to_host_maybe_retry(host, pool_size)
         connect_to_host(host, pool_size).fallback do |e|
-          @logger.error("Scheduling initial connection retry to #{host.ip} (#{e.class.name}: #{e.message})")
+          @logger.error('Scheduling initial connection retry to ' \
+            "#{host.ip} (#{e.class.name}: #{e.message})")
           connect_to_host_with_retry(host, pool_size, @reconnection_policy.schedule)
         end.map(nil)
       end
@@ -364,7 +447,8 @@ module Cassandra
         f = @reactor.schedule_timer(interval)
         f.flat_map do
           connect_to_host(host, pool_size).fallback do |e|
-            @logger.error("Scheduling connection retry to #{host.ip} (#{e.class.name}: #{e.message})")
+            @logger.error('Scheduling connection retry to ' \
+              "#{host.ip} (#{e.class.name}: #{e.message})")
             connect_to_host_with_retry(host, pool_size, schedule)
           end
         end
@@ -390,7 +474,8 @@ module Cassandra
           size -= @pending_connections[host]
 
           if size <= 0
-            @logger.info("Not connecting to #{host.ip} - host is already pending connections")
+            @logger.info("Not connecting to #{host.ip} - " \
+              'host is already pending connections')
             return NO_CONNECTIONS
           end
 
@@ -439,7 +524,7 @@ module Cassandra
               end
             end
           else
-            connections.each {|c| c.close}
+            connections.each(&:close)
           end
 
           if error
@@ -450,7 +535,15 @@ module Cassandra
         end
       end
 
-      def execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
+      def execute_by_plan(promise,
+                          keyspace,
+                          statement,
+                          options,
+                          request,
+                          plan,
+                          timeout,
+                          errors = nil,
+                          hosts = [])
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
@@ -463,7 +556,15 @@ module Cassandra
         unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
-          return execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          return execute_by_plan(promise,
+                                 keyspace,
+                                 statement,
+                                 options,
+                                 request,
+                                 plan,
+                                 timeout,
+                                 errors,
+                                 hosts)
         end
 
         connection = pool.random_connection
@@ -472,13 +573,32 @@ module Cassandra
           switch = switch_keyspace(connection, keyspace, timeout)
           switch.on_complete do |s|
             if s.resolved?
-              prepare_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+              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::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                if e.is_a?(Errors::HostError) ||
+                   (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
                   errors ||= {}
                   errors[host] = e
-                  execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  execute_by_plan(promise,
+                                  keyspace,
+                                  statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts)
                 else
                   promise.break(e)
                 end
@@ -486,33 +606,90 @@ module Cassandra
             end
           end
         else
-          prepare_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          prepare_and_send_request_by_plan(host,
+                                           connection,
+                                           promise,
+                                           keyspace,
+                                           statement,
+                                           options,
+                                           request,
+                                           plan,
+                                           timeout,
+                                           errors,
+                                           hosts)
         end
       rescue => e
         errors ||= {}
         errors[host] = e
-        execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+        execute_by_plan(promise,
+                        keyspace,
+                        statement,
+                        options,
+                        request,
+                        plan,
+                        timeout,
+                        errors,
+                        hosts)
       end
 
-      def prepare_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+      def prepare_and_send_request_by_plan(host,
+                                           connection,
+                                           promise,
+                                           keyspace,
+                                           statement,
+                                           options,
+                                           request,
+                                           plan,
+                                           timeout,
+                                           errors,
+                                           hosts)
         cql = statement.cql
         id  = synchronize { @prepared_statements[host][cql] }
 
         if id
           request.id = id
-          do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          do_send_request_by_plan(host,
+                                  connection,
+                                  promise,
+                                  keyspace,
+                                  statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts)
         else
           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)
+              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::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                if e.is_a?(Errors::HostError) ||
+                   (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
                   errors ||= {}
                   errors[host] = e
-                  execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  execute_by_plan(promise,
+                                  keyspace,
+                                  statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts)
                 else
                   promise.break(e)
                 end
@@ -524,7 +701,15 @@ module Cassandra
         promise.break(e)
       end
 
-      def batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
+      def batch_by_plan(promise,
+                        keyspace,
+                        statement,
+                        options,
+                        request,
+                        plan,
+                        timeout,
+                        errors = nil,
+                        hosts = [])
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
@@ -537,7 +722,15 @@ module Cassandra
         unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
-          return batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          return batch_by_plan(promise,
+                               keyspace,
+                               statement,
+                               options,
+                               request,
+                               plan,
+                               timeout,
+                               errors,
+                               hosts)
         end
 
         connection = pool.random_connection
@@ -546,13 +739,32 @@ module Cassandra
           switch = switch_keyspace(connection, keyspace, timeout)
           switch.on_complete do |s|
             if s.resolved?
-              batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
+              batch_and_send_request_by_plan(host,
+                                             connection,
+                                             promise,
+                                             keyspace,
+                                             statement,
+                                             request,
+                                             options,
+                                             plan,
+                                             timeout,
+                                             errors,
+                                             hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                if e.is_a?(Errors::HostError) ||
+                   (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
                   errors ||= {}
                   errors[host] = e
-                  batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  batch_by_plan(promise,
+                                keyspace,
+                                statement,
+                                options,
+                                request,
+                                plan,
+                                timeout,
+                                errors,
+                                hosts)
                 else
                   promise.break(e)
                 end
@@ -560,19 +772,47 @@ module Cassandra
             end
           end
         else
-          batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
+          batch_and_send_request_by_plan(host,
+                                         connection,
+                                         promise,
+                                         keyspace,
+                                         statement,
+                                         request,
+                                         options,
+                                         plan,
+                                         timeout,
+                                         errors,
+                                         hosts)
         end
       rescue => e
         errors ||= {}
         errors[host] = e
-        batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+        batch_by_plan(promise,
+                      keyspace,
+                      statement,
+                      options,
+                      request,
+                      plan,
+                      timeout,
+                      errors,
+                      hosts)
       end
 
-      def batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
+      def batch_and_send_request_by_plan(host,
+                                         connection,
+                                         promise,
+                                         keyspace,
+                                         batch_statement,
+                                         request,
+                                         options,
+                                         plan,
+                                         timeout,
+                                         errors,
+                                         hosts)
         request.clear
         unprepared = Hash.new {|hash, cql| hash[cql] = []}
 
-        statement.statements.each do |statement|
+        batch_statement.statements.each do |statement|
           cql = statement.cql
 
           if statement.is_a?(Statements::Bound)
@@ -589,7 +829,17 @@ module Cassandra
         end
 
         if unprepared.empty?
-          do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          do_send_request_by_plan(host,
+                                  connection,
+                                  promise,
+                                  keyspace,
+                                  batch_statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts)
         else
           to_prepare = unprepared.to_a
           futures    = to_prepare.map do |cql, _|
@@ -601,17 +851,38 @@ module Cassandra
               prepared_ids = f.value
               to_prepare.each_with_index do |(_, statements), i|
                 statements.each do |statement|
-                  request.add_prepared(prepared_ids[i], statement.params, statement.params_types)
+                  request.add_prepared(prepared_ids[i],
+                                       statement.params,
+                                       statement.params_types)
                 end
               end
 
-              do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+              do_send_request_by_plan(host,
+                                      connection,
+                                      promise,
+                                      keyspace,
+                                      batch_statement,
+                                      options,
+                                      request,
+                                      plan,
+                                      timeout,
+                                      errors,
+                                      hosts)
             else
               f.on_failure do |e|
-                if e.is_a?(Errors::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                if e.is_a?(Errors::HostError) ||
+                   (e.is_a?(Errors::TimeoutError) && batch_statement.idempotent?)
                   errors ||= {}
                   errors[host] = e
-                  batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  batch_by_plan(promise,
+                                keyspace,
+                                batch_statement,
+                                options,
+                                request,
+                                plan,
+                                timeout,
+                                errors,
+                                hosts)
                 else
                   promise.break(e)
                 end
@@ -621,7 +892,15 @@ module Cassandra
         end
       end
 
-      def send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
+      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))
           return
@@ -634,7 +913,15 @@ module Cassandra
         unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
-          return send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          return send_request_by_plan(promise,
+                                      keyspace,
+                                      statement,
+                                      options,
+                                      request,
+                                      plan,
+                                      timeout,
+                                      errors,
+                                      hosts)
         end
 
         connection = pool.random_connection
@@ -643,13 +930,32 @@ module Cassandra
           switch = switch_keyspace(connection, keyspace, timeout)
           switch.on_complete do |s|
             if s.resolved?
-              do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+              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::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                if e.is_a?(Errors::HostError) ||
+                   (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
                   errors ||= {}
                   errors[host] = e
-                  send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  send_request_by_plan(promise,
+                                       keyspace,
+                                       statement,
+                                       options,
+                                       request,
+                                       plan,
+                                       timeout,
+                                       errors,
+                                       hosts)
                 else
                   promise.break(e)
                 end
@@ -657,166 +963,447 @@ module Cassandra
             end
           end
         else
-          do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+          do_send_request_by_plan(host,
+                                  connection,
+                                  promise,
+                                  keyspace,
+                                  statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts)
         end
       rescue => e
         errors ||= {}
         errors[host] = e
-        send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+        send_request_by_plan(promise,
+                             keyspace,
+                             statement,
+                             options,
+                             request,
+                             plan,
+                             timeout,
+                             errors,
+                             hosts)
       end
 
-      def do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts, retries = 0)
+      def do_send_request_by_plan(host,
+                                  connection,
+                                  promise,
+                                  keyspace,
+                                  statement,
+                                  options,
+                                  request,
+                                  plan,
+                                  timeout,
+                                  errors,
+                                  hosts,
+                                  retries = 0)
         request.retries = retries
 
         f = connection.send_request(request, timeout)
-        f.on_complete do |f|
-          if f.resolved?
-            r = f.value
-
-            begin
-              decision = nil
-
-              case r
-              when Protocol::UnavailableErrorResponse
-                decision = @retry_policy.unavailable(statement, r.consistency, r.required, r.alive, retries)
-              when Protocol::WriteTimeoutErrorResponse
-                decision = @retry_policy.write_timeout(statement, r.consistency, r.write_type, r.blockfor, r.received, retries)
-              when Protocol::ReadTimeoutErrorResponse
-                decision = @retry_policy.read_timeout(statement, r.consistency, r.blockfor, r.received, r.data_present, retries)
-              when Protocol::UnpreparedErrorResponse
-                cql = statement.cql
-
-                synchronize do
-                  @preparing_statements[host].delete(cql)
-                  @prepared_statements[host].delete(cql)
-                end
+        f.on_complete do |response_future|
+          errors ||= {}
+          handle_response(response_future,
+                          host,
+                          connection,
+                          promise,
+                          keyspace,
+                          statement,
+                          options,
+                          request,
+                          plan,
+                          timeout,
+                          errors,
+                          hosts,
+                          retries)
+        end
+      rescue => e
+        promise.break(e)
+      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|
-                      if e.is_a?(Errors::HostError) || (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
-                        errors ||= {}
-                        errors[host] = e
-                        execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
-                      else
-                        promise.break(e)
-                      end
-                    end
-                  end
-                end
-              when Protocol::ErrorResponse
-                error = r.to_error(keyspace, statement, options, hosts, request.consistency, retries)
+      def handle_response(response_future,
+                          host,
+                          connection,
+                          promise,
+                          keyspace,
+                          statement,
+                          options,
+                          request,
+                          plan,
+                          timeout,
+                          errors,
+                          hosts,
+                          retries)
+        if response_future.resolved?
+          r = response_future.value
+
+          begin
+            decision = nil
+
+            case r
+            when Protocol::UnavailableErrorResponse
+              decision = @retry_policy.unavailable(statement,
+                                                   r.consistency,
+                                                   r.required,
+                                                   r.alive,
+                                                   retries)
+            when Protocol::WriteTimeoutErrorResponse
+              decision = @retry_policy.write_timeout(statement,
+                                                     r.consistency,
+                                                     r.write_type,
+                                                     r.blockfor,
+                                                     r.received,
+                                                     retries)
+            when Protocol::ReadTimeoutErrorResponse
+              decision = @retry_policy.read_timeout(statement,
+                                                    r.consistency,
+                                                    r.blockfor,
+                                                    r.received,
+                                                    r.data_present,
+                                                    retries)
+            when Protocol::UnpreparedErrorResponse
+              cql = statement.cql
+
+              synchronize do
+                @preparing_statements[host].delete(cql)
+                @prepared_statements[host].delete(cql)
+              end
 
-                if error.is_a?(Errors::HostError) || (error.is_a?(Errors::TimeoutError) && statement.idempotent?)
-                  errors ||= {}
-                  errors[host] = error
-
-                  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, request, plan, timeout, errors, hosts)
-                  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
-                  promise.break(error)
-                end
-              when Protocol::SetKeyspaceResultResponse
-                @keyspace = r.keyspace
-                promise.fulfill(Results::Void.new(r.custom_payload, r.warnings, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              when Protocol::PreparedResultResponse
-                cql = request.cql
-                synchronize do
-                  @prepared_statements[host][cql] = r.id
-                  @preparing_statements[host].delete(cql)
-                end
-
-                metadata = r.metadata
-                pk_idx   = r.pk_idx
-                pk_idx ||= @schema.get_pk_idx(metadata)
-
-                promise.fulfill(Statements::Prepared.new(r.custom_payload, r.warnings, cql, metadata, r.result_metadata, pk_idx, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @connection_options))
-              when Protocol::RawRowsResultResponse
-                r.materialize(statement.result_metadata)
-                promise.fulfill(Results::Paged.new(r.custom_payload, r.warnings, r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              when Protocol::RowsResultResponse
-                promise.fulfill(Results::Paged.new(r.custom_payload, r.warnings, r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              when Protocol::SchemaChangeResultResponse
-                @schema.delete_keyspace(r.keyspace) if r.change == 'DROPPED' && r.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
-
-                @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 failure (#{e.class.name}: #{e.message})")
+                  prepare.on_failure do |e|
+                    if e.is_a?(Errors::HostError) ||
+                       (e.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                      errors[host] = e
+                      execute_by_plan(promise,
+                                      keyspace,
+                                      statement,
+                                      options,
+                                      request,
+                                      plan,
+                                      timeout,
+                                      errors,
+                                      hosts)
+                    else
+                      promise.break(e)
                     end
                   end
-                  promise.fulfill(Results::Void.new(r.custom_payload, r.warnings, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+                end
+              end
+            when Protocol::ErrorResponse
+              error = r.to_error(keyspace,
+                                 statement,
+                                 options,
+                                 hosts,
+                                 request.consistency,
+                                 retries)
+
+              if error.is_a?(Errors::HostError) ||
+                 (error.is_a?(Errors::TimeoutError) && statement.idempotent?)
+                errors[host] = error
+
+                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,
+                                request,
+                                plan,
+                                timeout,
+                                errors,
+                                hosts)
                 end
               else
-                promise.fulfill(Results::Void.new(r.custom_payload, r.warnings, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+                promise.break(error)
+              end
+            when Protocol::SetKeyspaceResultResponse
+              @keyspace = r.keyspace
+              promise.fulfill(Results::Void.new(r.custom_payload,
+                                                r.warnings,
+                                                r.trace_id,
+                                                keyspace,
+                                                statement,
+                                                options,
+                                                hosts,
+                                                request.consistency,
+                                                retries,
+                                                self,
+                                                @futures))
+            when Protocol::PreparedResultResponse
+              cql = request.cql
+              synchronize do
+                @prepared_statements[host][cql] = r.id
+                @preparing_statements[host].delete(cql)
               end
 
-              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::TryNextHost
-                  errors ||= {}
-                  errors[host] = r.to_error(keyspace, statement, options, hosts, request.consistency, retries)
-                  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, request, plan, timeout, errors, hosts)
-                  else
-                    promise.break(e)
+              metadata = r.metadata
+              pk_idx = r.pk_idx
+              pk_idx ||= @schema.get_pk_idx(metadata)
+
+              promise.fulfill(
+                Statements::Prepared.new(r.custom_payload,
+                                         r.warnings,
+                                         cql,
+                                         metadata,
+                                         r.result_metadata,
+                                         pk_idx,
+                                         r.trace_id,
+                                         keyspace,
+                                         statement,
+                                         options,
+                                         hosts,
+                                         request.consistency,
+                                         retries,
+                                         self,
+                                         @connection_options))
+            when Protocol::RawRowsResultResponse
+              r.materialize(statement.result_metadata)
+              promise.fulfill(
+                Results::Paged.new(r.custom_payload,
+                                   r.warnings,
+                                   r.rows,
+                                   r.paging_state,
+                                   r.trace_id,
+                                   keyspace,
+                                   statement,
+                                   options,
+                                   hosts,
+                                   request.consistency,
+                                   retries,
+                                   self,
+                                   @futures))
+            when Protocol::RowsResultResponse
+              promise.fulfill(
+                Results::Paged.new(r.custom_payload,
+                                   r.warnings,
+                                   r.rows,
+                                   r.paging_state,
+                                   r.trace_id,
+                                   keyspace,
+                                   statement,
+                                   options,
+                                   hosts,
+                                   request.consistency,
+                                   retries,
+                                   self,
+                                   @futures))
+            when Protocol::SchemaChangeResultResponse
+              if r.change == 'DROPPED' &&
+                 r.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
+                @schema.delete_keyspace(r.keyspace)
+              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 failure (#{e.class.name}: #{e.message})")
                   end
-                when Retry::Decisions::Ignore
-                  promise.fulfill(Results::Void.new(r.custom_payload, r.warnings, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-                when Retry::Decisions::Reraise
-                  promise.break(r.to_error(keyspace, statement, options, hosts, request.consistency, retries))
-                else
-                  promise.break(r.to_error(keyspace, statement, options, hosts, request.consistency, retries))
                 end
+                promise.fulfill(
+                  Results::Void.new(r.custom_payload,
+                                    r.warnings,
+                                    r.trace_id,
+                                    keyspace,
+                                    statement,
+                                    options,
+                                    hosts,
+                                    request.consistency,
+                                    retries,
+                                    self,
+                                    @futures))
               end
-            rescue => e
-              promise.break(e)
+            else
+              promise.fulfill(Results::Void.new(r.custom_payload,
+                                                r.warnings,
+                                                r.trace_id,
+                                                keyspace,
+                                                statement,
+                                                options,
+                                                hosts,
+                                                request.consistency,
+                                                retries,
+                                                self,
+                                                @futures))
             end
-          else
-            f.on_failure do |e|
-              errors ||= {}
-              errors[host] = e
-              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, request, plan, timeout, errors, hosts)
+
+            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::TryNextHost
+                errors[host] = r.to_error(keyspace,
+                                          statement,
+                                          options,
+                                          hosts,
+                                          request.consistency,
+                                          retries)
+                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,
+                                request,
+                                plan,
+                                timeout,
+                                errors,
+                                hosts)
+                else
+                  promise.break(e)
+                end
+              when Retry::Decisions::Ignore
+                promise.fulfill(
+                  Results::Void.new(r.custom_payload,
+                                    r.warnings,
+                                    r.trace_id,
+                                    keyspace,
+                                    statement,
+                                    options,
+                                    hosts,
+                                    request.consistency,
+                                    retries,
+                                    self,
+                                    @futures))
+              when Retry::Decisions::Reraise
+                promise.break(
+                  r.to_error(keyspace,
+                             statement,
+                             options,
+                             hosts,
+                             request.consistency,
+                             retries))
               else
-                promise.break(e)
+                promise.break(
+                  r.to_error(keyspace,
+                             statement,
+                             options,
+                             hosts,
+                             request.consistency,
+                             retries))
               end
             end
+          rescue => e
+            promise.break(e)
+          end
+        else
+          response_future.on_failure do |ex|
+            errors[host] = ex
+            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,
+                            request,
+                            plan,
+                            timeout,
+                            errors,
+                            hosts)
+            else
+              promise.break(ex)
+            end
           end
         end
-      rescue => e
-        promise.break(e)
       end
 
       def wait_for_schema_agreement(connection, schedule)
-        peers = send_select_request(connection, SELECT_SCHEMA_PEERS)
-        local = send_select_request(connection, SELECT_SCHEMA_LOCAL)
+        peers_future = send_select_request(connection, SELECT_SCHEMA_PEERS)
+        local_future = send_select_request(connection, SELECT_SCHEMA_LOCAL)
 
-        Ione::Future.all(peers, local).flat_map do |(peers, local)|
+        Ione::Future.all(peers_future, local_future).flat_map do |(peers, local)|
           versions = ::Set.new
 
           unless local.empty?
@@ -841,7 +1428,8 @@ module Cassandra
             Ione::Future.resolved
           else
             interval = schedule.next
-            @logger.info("Hosts have different schema versions: #{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
@@ -862,7 +1450,10 @@ module Cassandra
 
         return pending_switch || Ione::Future.resolved if pending_keyspace == keyspace
 
-        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}", EMPTY_LIST, EMPTY_LIST, :one)
+        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}",
+                                             EMPTY_LIST,
+                                             EMPTY_LIST,
+                                             :one)
 
         f = connection.send_request(request, timeout).map do |r|
           case r
@@ -870,7 +1461,12 @@ module Cassandra
             @keyspace = r.keyspace
             nil
           when Protocol::ErrorResponse
-            raise r.to_error(nil, Statements::Simple.new("USE #{Util.escape_name(keyspace)}"), VOID_OPTIONS, EMPTY_LIST, :one, 0)
+            raise r.to_error(nil,
+                             Statements::Simple.new("USE #{Util.escape_name(keyspace)}"),
+                             VOID_OPTIONS,
+                             EMPTY_LIST,
+                             :one,
+                             0)
           else
             raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
@@ -879,7 +1475,7 @@ module Cassandra
         connection[:pending_keyspace] = keyspace
         connection[:pending_switch]   = f
 
-        f.on_complete do |f|
+        f.on_complete do |_f|
           connection[:pending_switch]   = nil
           connection[:pending_keyspace] = nil
         end
@@ -891,7 +1487,7 @@ module Cassandra
         synchronize do
           pending = @preparing_statements[host]
 
-          return pending[cql] if pending.has_key?(cql)
+          return pending[cql] if pending.key?(cql)
         end
 
         request = Protocol::PrepareRequest.new(cql, false)