cassandra-driver 3.0.3-java → 3.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd12699ee5345d58839cfaf6ebc7e9f39529f835
-  data.tar.gz: 05efbd46f2dbef7ff4669c79c88e3671629a898f
+  metadata.gz: ac761253a986cd88350b04de1d3ee90bf1f355c3
+  data.tar.gz: 6c9bbff04510173fd06518c7592d7c326534b081
 SHA512:
-  metadata.gz: b8c4bc332b1cdd24dda360c19a564a4af64e865b04a139ac04208768949622fedc4bb83d421d1c1a7450d9bb089e14ba6c24e7b8238b562d349ba88d24980c10
-  data.tar.gz: c99658b87ff4197aedd1c7d0f719be36720252b025797beaefd0a0e0ba718dfdcba17d20c705acd39785e1f9344b0679095aadae9f35217d4c22a561088de403
+  metadata.gz: ddf9b426f9f3e2934f1dc705657af049472ef68474ce1458a80d3a5e7a33b07b75fa34ab27bfb71617e2f4b111f8c774ca96e45c98b495e0cf06cc25606d3757
+  data.tar.gz: 526e8a7fae76a17635ecadc369b62f1a175aef694a9d0d8488262e90722de6363f8243081e0e5d18c4b6c05305932c59bbf3b369511cce1fbef91746f25ebff4

data/README.md

@@ -1,6 +1,8 @@
 # Datastax Ruby Driver for Apache Cassandra
 
-*If you're reading this on GitHub, please note that this is the readme for the development version and that some features described here might not yet have been released. You can [find the documentation for the latest version through ruby driver docs](http://docs.datastax.com/en/latest-ruby-driver/ruby-driver/whatsNew.html) or via the release tags, [e.g. v3.0.3](https://github.com/datastax/ruby-driver/tree/v3.0.3).*
+*If you're reading this on GitHub, please note that this is the readme for the development version and that some
+features described here might not yet have been released. You can view the documentation for the latest released
+version [here](http://docs.datastax.com/en/developer/ruby-driver/latest).*
 
 [![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
 
@@ -8,22 +10,22 @@ A Ruby client driver for Apache Cassandra. This driver works exclusively with
 the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 
 - Code: https://github.com/datastax/ruby-driver
-- Docs: http://docs.datastax.com/en/latest-ruby-driver/ruby-driver/whatsNew.html
+- Docs: http://docs.datastax.com/en/developer/ruby-driver
 - Jira: https://datastax-oss.atlassian.net/browse/RUBY
 - Mailing List: https://groups.google.com/a/lists.datastax.com/forum/#!forum/ruby-driver-user
 - IRC: #datastax-drivers on [irc.freenode.net](http://freenode.net>)
-- Twitter: Follow the latest news about DataStax Drivers - [@avalanche123](http://twitter.com/avalanche123), [@stamhankar999](http://twitter.com/stamhankar999), [@al3xandru](https://twitter.com/al3xandru)
+- Twitter: Follow the latest news about DataStax Drivers - [@stamhankar999](http://twitter.com/stamhankar999), [@avalanche123](http://twitter.com/avalanche123), [@al3xandru](https://twitter.com/al3xandru)
 
 This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we added support for:
 
-* [Asynchronous execution](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/asynchronous_io/)
-* One-off, [prepared](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/basics/prepared_statements/) and [batch statements](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/basics/batch_statements/)
-* Automatic peer discovery and cluster metadata with [support for change notifications](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/state_listeners/)
-* Various [load-balancing](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/load_balancing/), [retry](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/retry_policies/) and [reconnection](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/reconnection/) policies with [ability to write your own](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/load_balancing/implementing_a_policy/)
-* [SSL encryption](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/security/ssl_encryption/)
-* [Flexible and robust error handling](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/error_handling/)
-* [Per-request execution information and tracing](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/debugging/)
-* [Configurable address resolution](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/address_resolution/)
+* [Asynchronous execution](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/asynchronous_io/)
+* One-off, [prepared](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/basics/prepared_statements/) and [batch statements](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/basics/batch_statements/)
+* Automatic peer discovery and cluster metadata with [support for change notifications](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/state_listeners/)
+* Various [load-balancing](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/load_balancing/), [retry](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/retry_policies/) and [reconnection](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/reconnection/) policies with [ability to write your own](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/load_balancing/implementing_a_policy/)
+* [SSL encryption](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/security/ssl_encryption/)
+* [Flexible and robust error handling](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/error_handling/)
+* [Per-request execution information and tracing](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/debugging/)
+* [Configurable address resolution](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/address_resolution/)
 
 [Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
 
@@ -36,10 +38,14 @@ This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Ca
 * Ruby (MRI) 2.2, 2.3
 * JRuby 1.7
 
-__Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work. Similarly,
-MRI 2.0 and 2.1 are not officially supported, but they should work. 1.9.3 is deprecated
+__Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work. Rubinius is not supported.
+MRI 2.0, 2.1, and JRuby 9k are not officially supported, but they should work. 1.9.3 is deprecated
 and is likely to break in the release following 3.0.
 
+## Feedback Requested
+
+*Help us focus our efforts!* [Provide your input](http://goo.gl/forms/pCs8PTpHLf) on the Ruby Driver Platform and Runtime Survey (we kept it short).
+
 ## Quick start
 
 ```ruby
@@ -51,10 +57,10 @@ cluster.each_host do |host| # automatically discovers all peers
   puts "Host #{host.ip}: id=#{host.id} datacenter=#{host.datacenter} rack=#{host.rack}"
 end
 
-keyspace = 'system'
+keyspace = 'system_schema'
 session  = cluster.connect(keyspace) # create session, optionally scoped to a keyspace, to execute queries
 
-future = session.execute_async('SELECT keyspace_name, table_name FROM system_schema.tables') # fully asynchronous api
+future = session.execute_async('SELECT keyspace_name, table_name FROM tables') # fully asynchronous api
 future.on_success do |rows|
   rows.each do |row|
     puts "The keyspace #{row['keyspace_name']} has a table called #{row['table_name']}"
@@ -67,9 +73,9 @@ __Note__: The host you specify is just a seed node, the driver will automaticall
 
 Read more:
 
-* [`Cassandra.cluster` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api/cassandra/#cluster-class_method)
-* [`Session#execute_async` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api/cassandra/session/#execute_async-instance_method)
-* [Usage documentation](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features)
+* [`Cassandra.cluster` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/api/cassandra/#cluster-class_method)
+* [`Session#execute_async` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/api/cassandra/session/#execute_async-instance_method)
+* [Usage documentation](http://docs.datastax.com/en/developer/ruby-driver/3.0/features)
 
 ## Installation
 
@@ -85,16 +91,29 @@ Install via Gemfile
 gem 'cassandra-driver'
 ```
 
-__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/#compression)
+__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/#compression)
 
 
 ## Upgrading from cql-rb
 
-Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/v3.0.3/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
+Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API.
+In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete
+interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/v3.1.0/examples/cql-rb-wrapper.rb)
+to assist you with gradual upgrade.
 
-## What's new in v3.0
+## What's new in v3.1
+
+This minor release introduces features and fixes around resiliency, schema metadata, usability, and performance. One
+of the most user-impacting of these is the introduction of
+[execution profiles](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/execution_profiles).
+Execution profiles allow you to group various execution options into a 'profile' and you reference the desired
+profile at execution time. Get the scoop
+[here](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/execution_profiles).
 
-See the [changelog](https://github.com/datastax/ruby-driver/blob/v3.0.3/CHANGELOG.md) for details on patch versions.
+See the [changelog](https://github.com/datastax/ruby-driver/blob/v3.1.0/CHANGELOG.md) for more information on all
+changes in this version and past versions.
+
+## What's new in v3.0
 
 ### Features:
 
@@ -150,10 +169,6 @@ batch.add(query, arguments: {p1: 'val1'})
 * [[RUBY-161](https://datastax-oss.atlassian.net/browse/RUBY-161)] Protocol version negotiation in mixed version clusters should not fall back to v1 unless it is truly warranted.
 * [[RUBY-214](https://datastax-oss.atlassian.net/browse/RUBY-214)] Ensure client timestamps have microsecond precision in JRuby. Previously, some row updates would get lost in high transaction environments.
 
-## Feedback Requested
-
-*Help us focus our efforts!* [Provide your input](http://goo.gl/forms/pCs8PTpHLf) on the Ruby Driver Platform and Runtime Survey (we kept it short).
-
 ## Code examples
 
 The DataStax Ruby Driver uses the awesome [Cucumber Framework](http://cukes.info/) for
@@ -164,7 +179,7 @@ examples in the `features/` directory.
 ## Running tests
 
 If you don't feel like reading through the following instructions on how to run
-ruby-driver tests, feel free to [check out .travis.yml for the entire build code](https://github.com/datastax/ruby-driver/blob/v3.0.3/.travis.yml).
+ruby-driver tests, feel free to [check out .travis.yml for the entire build code](https://github.com/datastax/ruby-driver/blob/v3.1.0/.travis.yml).
 
 * Check out the driver codebase and install test dependencies:
 
@@ -188,7 +203,7 @@ CASSANDRA_VERSION=2.0.17 bundle exec rake test # run both as well as integration
 ## Changelog & versioning
 
 Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases) and
-[changelog](https://github.com/datastax/ruby-driver/blob/v3.0.3/CHANGELOG.md). Version
+[changelog](https://github.com/datastax/ruby-driver/blob/v3.1.0/CHANGELOG.md). Version
 numbering follows the [semantic versioning](http://semver.org/) scheme.
 
 Private and experimental APIs, defined as whatever is not in the
@@ -212,7 +227,7 @@ the release.
 * Because the driver reactor is using `IO.select`, the maximum number of tcp connections allowed is 1024.
 * Because the driver uses `IO#write_nonblock`, Windows is not supported.
 
-Please [refer to the usage documentation for more information on common pitfalls](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/)
+Please [refer to the usage documentation for more information on common pitfalls](http://docs.datastax.com/en/developer/ruby-driver/3.0/features/)
 
 ## Contributing
 
@@ -226,7 +241,7 @@ that are common across all other DataStax drivers for Apache Cassandra.
 
 The development effort to provide an up to date, high performance, fully featured Ruby
 Driver for Apache Cassandra will continue on this project, while
-[cql-rb](https://github.com/iconara/cql-rb/) will be discontinued.
+[cql-rb](https://github.com/iconara/cql-rb/) has been discontinued.
 
 ## Copyright
 
@@ -242,4 +257,4 @@ License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 either express or implied. See the License for the specific language governing permissions
 and limitations under the License.
 
-  [1]: http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api
+  [1]: http://docs.datastax.com/en/developer/ruby-driver/3.0/api

data/lib/cassandra.rb

@@ -56,6 +56,7 @@ module Cassandra
   CLUSTER_OPTIONS = [
     :address_resolution,
     :address_resolution_policy,
+    :allow_beta_protocol,
     :auth_provider,
     :client_cert,
     :client_timestamps,
@@ -68,6 +69,7 @@ module Cassandra
     :credentials,
     :custom_types,
     :datacenter,
+    :execution_profiles,
     :futures_factory,
     :heartbeat_interval,
     :hosts,
@@ -117,10 +119,14 @@ module Cassandra
   #   found by the default Token-Aware Load Balancing Policy should be
   #   shuffled. See {Cassandra::LoadBalancing::Policies::TokenAware#initialize Token-Aware Load Balancing Policy}.
   #
+  # @option options [Hash<String|Symbol, ExecutionProfile>] :execution_profiles (nil)
+  #   Hash of {Cassandra::Execution::Profile}s that are available for client use (e.g.
+  #   {Session#execute}, {Session#execute_async}, {Session#prepare}, and {Session#prepare_async}).
+  #
   # @option options [Numeric] :connect_timeout (10) connection timeout in
   #   seconds. Setting value to `nil` will reset it to 5 seconds.
   #
-  # @option options [Numeric] :timeout (10) request execution timeout in
+  # @option options [Numeric] :timeout (12) request execution timeout in
   #   seconds. Setting value to `nil` will remove request timeout.
   #
   # @option options [Numeric] :heartbeat_interval (30) how often should a
@@ -191,6 +197,9 @@ module Cassandra
   #   nodes. By default, this is auto-negotiated to the highest common protocol version
   #   that all nodes in `:hosts` speak.
   #
+  # @option options [Boolean] :allow_beta_protocol (false) whether the driver should attempt to speak to nodes
+  #   with a beta version of the newest protocol (which is still under development). USE WITH CAUTION!
+  #
   # @option options [Boolean, Cassandra::TimestampGenerator] :client_timestamps (false) whether the driver
   #   should send timestamps for each executed statement and possibly which timestamp generator to use. Enabling this
   #   setting helps mitigate Cassandra cluster clock skew because the timestamp of the client machine will be used.
@@ -315,6 +324,12 @@ module Cassandra
       CLUSTER_OPTIONS.include?(key)
     end
 
+    if options.key?(:execution_profiles)
+      [:load_balancing_policy, :retry_policy, :timeout, :consistency].each do |opt|
+        raise ::ArgumentError, "#{opt} is not allowed when execution profiles are used" if options.key?(opt)
+      end
+    end
+
     has_username = options.key?(:username)
     has_password = options.key?(:password)
     if has_username || has_password
@@ -503,15 +518,9 @@ module Cassandra
       end
     end
 
-    if options.key?(:timeout)
-      timeout = options[:timeout]
-
-      unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) do
-          ":timeout must be a number of seconds, #{timeout.inspect} given"
-        end
-        Util.assert(timeout > 0) { ":timeout must be greater than 0, #{timeout} given" }
-      end
+    if options.key?(:execution_profiles)
+      Util.assert_instance_of(::Hash, options[:execution_profiles],
+                              ':execution_profiles must be a hash of <name,ExecutionProfile> entries.')
     end
 
     if options.key?(:heartbeat_interval)
@@ -562,17 +571,6 @@ module Cassandra
       end
     end
 
-    if options.key?(:load_balancing_policy)
-      load_balancing_policy = options[:load_balancing_policy]
-      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
-                 :distance, :plan]
-
-      Util.assert_responds_to_all(methods, load_balancing_policy) do
-        ":load_balancing_policy #{load_balancing_policy.inspect} must respond " \
-            "to #{methods.inspect}, but doesn't"
-      end
-    end
-
     if options.key?(:reconnection_policy)
       reconnection_policy = options[:reconnection_policy]
 
@@ -582,30 +580,15 @@ module Cassandra
       end
     end
 
-    if options.key?(:retry_policy)
-      retry_policy = options[:retry_policy]
-      methods = [:read_timeout, :write_timeout, :unavailable]
-
-      Util.assert_responds_to_all(methods, retry_policy) do
-        ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, " \
-            "but doesn't"
-      end
-    end
+    # Validate options that go in an execution profile. Instantiating one
+    # causes validation automatically.
+    Cassandra::Execution::Profile.new(options)
 
     options[:listeners] = Array(options[:listeners]) if options.key?(:listeners)
-
-    if options.key?(:consistency)
-      consistency = options[:consistency]
-
-      Util.assert_one_of(CONSISTENCIES, consistency) do
-        ":consistency must be one of #{CONSISTENCIES.inspect}, " \
-            "#{consistency.inspect} given"
-      end
-    end
-
     options[:nodelay] = !!options[:nodelay] if options.key?(:nodelay)
     options[:trace] = !!options[:trace] if options.key?(:trace)
     options[:shuffle_replicas] = !!options[:shuffle_replicas] if options.key?(:shuffle_replicas)
+    options[:allow_beta_protocol] = !!options[:allow_beta_protocol] if options.key?(:allow_beta_protocol)
 
     if options.key?(:page_size)
       page_size = options[:page_size]
@@ -623,12 +606,15 @@ module Cassandra
       protocol_version = options[:protocol_version]
       unless protocol_version.nil?
         Util.assert_instance_of(::Integer, protocol_version)
-        Util.assert_one_of(1..4, protocol_version) do
-          ":protocol_version must be a positive integer, #{protocol_version.inspect} given"
-        end
+        Util.assert_one_of(1..Cassandra::Protocol::Versions::MAX_SUPPORTED_VERSION, protocol_version,
+                           ':protocol_version must be a positive integer between 1 and ' \
+                           "#{Cassandra::Protocol::Versions::MAX_SUPPORTED_VERSION}, #{protocol_version.inspect} given")
       end
     end
 
+    Util.assert(!(options[:allow_beta_protocol] && options[:protocol_version]),
+                'only one of :allow_beta_protocol and :protocol_version may be specified, both given')
+
     if options.key?(:futures_factory)
       futures_factory = options[:futures_factory]
       methods = [:error, :value, :promise, :all]
@@ -820,9 +806,12 @@ require 'cassandra/table'
 require 'cassandra/materialized_view'
 require 'cassandra/keyspace'
 require 'cassandra/index'
+require 'cassandra/trigger'
 
 require 'cassandra/execution/info'
 require 'cassandra/execution/options'
+require 'cassandra/execution/profile_manager'
+require 'cassandra/execution/profile'
 require 'cassandra/execution/trace'
 
 require 'cassandra/load_balancing'
@@ -845,7 +834,9 @@ module Cassandra
   # @private
   VOID_STATEMENT = Statements::Void.new
   # @private
-  VOID_OPTIONS   = Execution::Options.new(consistency: :one)
+  VOID_OPTIONS   = Execution::Options.new(consistency: :one,
+                                          load_balancing_policy: LoadBalancing::Policies::RoundRobin.new,
+                                          retry_policy: Retry::Policies::Default.new)
   # @private
   NO_HOSTS       = Errors::NoHostsAvailable.new
 end

data/lib/cassandra/cluster.rb

@@ -36,9 +36,8 @@ module Cassandra
                    cluster_metadata,
                    execution_options,
                    connection_options,
-                   load_balancing_policy,
+                   profile_manager,
                    reconnection_policy,
-                   retry_policy,
                    address_resolution_policy,
                    connector,
                    futures_factory,
@@ -52,9 +51,8 @@ module Cassandra
       @metadata              = cluster_metadata
       @execution_options     = execution_options
       @connection_options    = connection_options
-      @load_balancing_policy = load_balancing_policy
+      @profile_manager       = profile_manager
       @reconnection_policy   = reconnection_policy
-      @retry_policy          = retry_policy
       @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
@@ -62,7 +60,7 @@ module Cassandra
 
       @control_connection.on_close do |_cause|
         begin
-          @load_balancing_policy.teardown(self)
+          @profile_manager.teardown(self)
         rescue
           nil
         end
@@ -153,6 +151,40 @@ module Cassandra
     #   @return [Boolean] true or false
     def_delegators :@schema, :keyspace, :has_keyspace?
 
+    # @return [Integer] Cassandra native protocol port
+    def port
+      @connection_options.port
+    end
+
+    # @return [Integer] the version of the native protocol used in communication with nodes
+    def protocol_version
+      @connection_options.protocol_version
+    end
+
+    # @param name [String] Name of profile to retrieve
+    # @return [Cassandra::Execution::Profile] execution profile of the given name
+    def execution_profile(name)
+      @profile_manager.profiles[name]
+    end
+
+    # Yield or enumerate each execution profile defined in this cluster
+    # @overload each_execution_profile
+    #   @yieldparam name [String, Symbol] name of current profile
+    #   @yieldparam profile [Cassandra::Execution::Profile] current profile
+    #   @return [Cassandra::Cluster] self
+    # @overload each_execution_profile
+    #   @return [Hash<String, Cassandra::Execution::Profile>] a hash of profiles keyed on name
+    def each_execution_profile(&block)
+      if block_given?
+        @profile_manager.profiles.each_pair(&block)
+        self
+      else
+        # Return a dup of the hash to prevent the user from adding/removing profiles from the profile-manager.
+        @profile_manager.profiles.dup
+      end
+    end
+    alias execution_profiles each_execution_profile
+
     # @!method refresh_schema_async
     #   Trigger an asynchronous schema metadata refresh
     #   @return [Cassandra::Future<nil>] a future that will be fulfilled when
@@ -201,14 +233,13 @@ module Cassandra
                            @schema,
                            @io_reactor,
                            @connector,
-                           @load_balancing_policy,
+                           @profile_manager,
                            @reconnection_policy,
-                           @retry_policy,
                            @address_resolver,
                            @connection_options,
                            @futures,
                            @timestamp_generator)
-      session = Session.new(client, @execution_options, @futures)
+      session = Session.new(client, @execution_options, @futures, @profile_manager)
       promise = @futures.promise
 
       client.connect.on_complete do |f|
@@ -282,9 +313,7 @@ module Cassandra
       "name=#{name.inspect}, " \
       "port=#{@connection_options.port}, " \
       "protocol_version=#{@connection_options.protocol_version}, " \
-      "load_balancing_policy=#{@load_balancing_policy.inspect}, " \
-      "consistency=#{@execution_options.consistency.inspect}, " \
-      "timeout=#{@execution_options.timeout.inspect}, " \
+      "execution_profiles=#{@profile_manager.profiles.inspect}, " \
       "hosts=#{hosts.inspect}, " \
       "keyspaces=#{keyspaces.inspect}>"
     end

data/lib/cassandra/cluster/client.rb

@@ -29,9 +29,8 @@ module Cassandra
                      cluster_schema,
                      io_reactor,
                      connector,
-                     load_balancing_policy,
+                     profile_manager,
                      reconnection_policy,
-                     retry_policy,
                      address_resolution_policy,
                      connection_options,
                      futures_factory,
@@ -41,15 +40,14 @@ module Cassandra
         @schema                      = cluster_schema
         @reactor                     = io_reactor
         @connector                   = connector
-        @load_balancing_policy       = load_balancing_policy
+        @profile_manager             = profile_manager
         @reconnection_policy         = reconnection_policy
-        @retry_policy                = retry_policy
         @address_resolver            = address_resolution_policy
         @connection_options          = connection_options
         @futures                     = futures_factory
         @connections                 = ::Hash.new
         @prepared_statements         = ::Hash.new
-        @preparing_statements        = ::Hash.new
+        @preparing_statements        = ::Hash.new {|hash, host| hash[host] = {}}
         @pending_connections         = ::Hash.new
         @keyspace                    = nil
         @state                       = :idle
@@ -67,7 +65,7 @@ module Cassandra
 
           @state = :connecting
           @registry.each_host do |host|
-            distance = @load_balancing_policy.distance(host)
+            distance = @profile_manager.distance(host)
 
             case distance
             when :ignore
@@ -85,7 +83,6 @@ module Cassandra
 
             connecting_hosts[host] = pool_size
             @pending_connections[host] = 0
-            @prepared_statements[host] = {}
             @preparing_statements[host] = {}
             @connections[host] = ConnectionPool.new
           end
@@ -168,7 +165,7 @@ module Cassandra
         pool_size = 0
 
         synchronize do
-          distance = @load_balancing_policy.distance(host)
+          distance = @profile_manager.distance(host)
           case distance
           when :ignore
             return Ione::Future.resolved
@@ -184,7 +181,6 @@ module Cassandra
           end
 
           @pending_connections[host] ||= 0
-          @prepared_statements[host] = {}
           @preparing_statements[host] = {}
           @connections[host] = ConnectionPool.new
         end
@@ -199,7 +195,6 @@ module Cassandra
           return Ione::Future.resolved unless @connections.key?(host)
 
           @pending_connections.delete(host) unless @pending_connections[host] > 0
-          @prepared_statements.delete(host)
           @preparing_statements.delete(host)
           pool = @connections.delete(host)
         end
@@ -227,7 +222,9 @@ module Cassandra
           return @futures.error(
             Errors::ClientError.new(
               'Positional arguments are not supported by the current version of ' \
-              'Apache Cassandra'))
+              'Apache Cassandra'
+            )
+          )
         end
 
         timestamp = @timestamp_generator.next if @timestamp_generator && @connection_options.protocol_version > 2
@@ -248,7 +245,7 @@ module Cassandra
         promise   = @futures.promise
 
         keyspace = @keyspace
-        plan     = @load_balancing_policy.plan(keyspace, statement, options)
+        plan = options.load_balancing_policy.plan(keyspace, statement, options)
 
         send_request_by_plan(promise,
                              keyspace,
@@ -270,7 +267,7 @@ module Cassandra
 
         keyspace  = @keyspace
         statement = VOID_STATEMENT
-        plan      = @load_balancing_policy.plan(keyspace, statement, options)
+        plan      = options.load_balancing_policy.plan(keyspace, statement, options)
 
         send_request_by_plan(promise,
                              keyspace,
@@ -303,7 +300,7 @@ module Cassandra
         promise         = @futures.promise
 
         keyspace = @keyspace
-        plan     = @load_balancing_policy.plan(keyspace, statement, options)
+        plan     = options.load_balancing_policy.plan(keyspace, statement, options)
 
         execute_by_plan(promise, keyspace, statement, options, request, plan, timeout)
 
@@ -315,7 +312,9 @@ module Cassandra
           return @futures.error(
             Errors::ClientError.new(
               'Batch statements are not supported by the current version of ' \
-              'Apache Cassandra'))
+              'Apache Cassandra'
+            )
+          )
         end
 
         timestamp = @timestamp_generator.next if @timestamp_generator && @connection_options.protocol_version > 2
@@ -329,7 +328,7 @@ module Cassandra
                                                timestamp,
                                                payload)
         keyspace  = @keyspace
-        plan      = @load_balancing_policy.plan(keyspace, statement, options)
+        plan      = options.load_balancing_policy.plan(keyspace, statement, options)
         promise   = @futures.promise
 
         batch_by_plan(promise, keyspace, statement, options, request, plan, timeout)
@@ -366,13 +365,15 @@ module Cassandra
           'SELECT peer, rpc_address, schema_version FROM system.peers',
           EMPTY_LIST,
           EMPTY_LIST,
-          :one)
+          :one
+        )
       SELECT_SCHEMA_LOCAL =
         Protocol::QueryRequest.new(
           "SELECT schema_version FROM system.local WHERE key='local'",
           EMPTY_LIST,
           EMPTY_LIST,
-          :one)
+          :one
+        )
 
       def connected(f)
         if f.resolved?
@@ -472,7 +473,7 @@ module Cassandra
           @pending_connections[host] += size
         end
 
-        @logger.debug("Creating #{size} connections to #{host.ip}")
+        @logger.debug("Creating #{size} request connections to #{host.ip}")
         futures = size.times.map do
           @connector.connect(host).recover do |e|
             FailedConnection.new(e, host)
@@ -491,7 +492,7 @@ module Cassandra
             end
           end
 
-          @logger.debug("Created #{connections.size} connections to #{host.ip}")
+          @logger.debug("Created #{connections.size} request connections to #{host.ip}")
 
           pool = nil
 
@@ -510,6 +511,12 @@ module Cassandra
 
             connections.each do |connection|
               connection.on_closed do |cause|
+                if cause
+                  @logger.info('Request connection closed ' \
+                      "(#{cause.class.name}: #{cause.message})")
+                else
+                  @logger.info('Request connection closed')
+                end
                 connect_to_host_maybe_retry(host, pool_size) if cause
               end
             end
@@ -533,13 +540,16 @@ module Cassandra
                           plan,
                           timeout,
                           errors = nil,
-                          hosts = [])
+                          hosts = [],
+                          retries = -1)
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
         hosts << host = plan.next
+        retries += 1
+
         pool = nil
         synchronize { pool = @connections[host] }
 
@@ -554,7 +564,8 @@ module Cassandra
                                  plan,
                                  timeout,
                                  errors,
-                                 hosts)
+                                 hosts,
+                                 retries)
         end
 
         connection = pool.random_connection
@@ -573,7 +584,8 @@ module Cassandra
                                                plan,
                                                timeout,
                                                errors,
-                                               hosts)
+                                               hosts,
+                                               retries)
             else
               s.on_failure do |e|
                 if e.is_a?(Errors::HostError) ||
@@ -588,7 +600,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
                 else
                   promise.break(e)
                 end
@@ -606,7 +619,8 @@ module Cassandra
                                            plan,
                                            timeout,
                                            errors,
-                                           hosts)
+                                           hosts,
+                                           retries)
         end
       rescue => e
         errors ||= {}
@@ -619,7 +633,8 @@ module Cassandra
                         plan,
                         timeout,
                         errors,
-                        hosts)
+                        hosts,
+                        retries)
       end
 
       def prepare_and_send_request_by_plan(host,
@@ -632,17 +647,16 @@ module Cassandra
                                            plan,
                                            timeout,
                                            errors,
-                                           hosts)
+                                           hosts,
+                                           retries)
         cql = statement.cql
-        id = nil
-        host_is_up = true
-        synchronize do
-          if @prepared_statements[host].nil?
-            host_is_up = false
-          else
-            id = @prepared_statements[host][cql]
-          end
-        end
+
+        # Get the prepared statement id for this statement from our cache if possible. We are optimistic
+        # that the statement has previously been prepared on all hosts, so the id will be valid. However, if
+        # we're in the midst of preparing the statement on the given host, we know that executing with the id
+        # will fail. So, act like we don't have the prepared-statement id in that case.
+
+        id = synchronize { @preparing_statements[host][cql] ? nil : @prepared_statements[cql] }
 
         if id
           request.id = id
@@ -656,20 +670,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
-        elsif !host_is_up
-          # We've hit a race condition where the plan says we can query this host, but the host has gone
-          # down in the mean time. Just execute the plan again on the next host.
-          @logger.debug("#{host} is down; executing plan on next host")
-          execute_by_plan(promise,
-                          keyspace,
-                          statement,
-                          options,
-                          request,
-                          plan,
-                          timeout,
-                          errors,
-                          hosts)
+                                  hosts,
+                                  retries)
         else
           prepare = prepare_statement(host, connection, cql, timeout)
           prepare.on_complete do |_|
@@ -685,7 +687,8 @@ module Cassandra
                                       plan,
                                       timeout,
                                       errors,
-                                      hosts)
+                                      hosts,
+                                      retries)
             else
               prepare.on_failure do |e|
                 if e.is_a?(Errors::HostError) ||
@@ -700,7 +703,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
                 else
                   promise.break(e)
                 end
@@ -720,13 +724,15 @@ module Cassandra
                         plan,
                         timeout,
                         errors = nil,
-                        hosts = [])
+                        hosts = [],
+                        retries = -1)
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
         hosts << host = plan.next
+        retries += 1
         pool = nil
         synchronize { pool = @connections[host] }
 
@@ -741,7 +747,8 @@ module Cassandra
                                plan,
                                timeout,
                                errors,
-                               hosts)
+                               hosts,
+                               retries)
         end
 
         connection = pool.random_connection
@@ -760,7 +767,8 @@ module Cassandra
                                              plan,
                                              timeout,
                                              errors,
-                                             hosts)
+                                             hosts,
+                                             retries)
             else
               s.on_failure do |e|
                 if e.is_a?(Errors::HostError) ||
@@ -775,7 +783,8 @@ module Cassandra
                                 plan,
                                 timeout,
                                 errors,
-                                hosts)
+                                hosts,
+                                retries)
                 else
                   promise.break(e)
                 end
@@ -793,7 +802,8 @@ module Cassandra
                                          plan,
                                          timeout,
                                          errors,
-                                         hosts)
+                                         hosts,
+                                         retries)
         end
       rescue => e
         errors ||= {}
@@ -806,7 +816,8 @@ module Cassandra
                       plan,
                       timeout,
                       errors,
-                      hosts)
+                      hosts,
+                      retries)
       end
 
       def batch_and_send_request_by_plan(host,
@@ -819,7 +830,8 @@ module Cassandra
                                          plan,
                                          timeout,
                                          errors,
-                                         hosts)
+                                         hosts,
+                                         retries)
         request.clear
         unprepared = Hash.new {|hash, cql| hash[cql] = []}
 
@@ -827,29 +839,15 @@ module Cassandra
           cql = statement.cql
 
           if statement.is_a?(Statements::Bound)
-            host_is_up = true
-            id = nil
-            synchronize do
-              if @prepared_statements[host].nil?
-                host_is_up = false
-              else
-                id = @prepared_statements[host][cql]
-              end
-            end
+            # Get the prepared statement id for this statement from our cache if possible. We are optimistic
+            # that the statement has previously been prepared on all hosts, so the id will be valid. However, if
+            # we're in the midst of preparing the statement on the given host, we know that executing with the id
+            # will fail. So, act like we don't have the prepared-statement id in that case.
+
+            id = synchronize { @preparing_statements[host][cql] ? nil : @prepared_statements[cql] }
 
             if id
               request.add_prepared(id, statement.params, statement.params_types)
-            elsif !host_is_up
-              @logger.debug("#{host} is down; executing on next host in plan")
-              return batch_by_plan(promise,
-                                   keyspace,
-                                   batch_statement,
-                                   options,
-                                   request,
-                                   plan,
-                                   timeout,
-                                   errors,
-                                   hosts)
             else
               unprepared[cql] << statement
             end
@@ -869,7 +867,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
         else
           to_prepare = unprepared.to_a
           futures    = to_prepare.map do |cql, _|
@@ -897,7 +896,8 @@ module Cassandra
                                       plan,
                                       timeout,
                                       errors,
-                                      hosts)
+                                      hosts,
+                                      retries)
             else
               f.on_failure do |e|
                 if e.is_a?(Errors::HostError) ||
@@ -912,7 +912,8 @@ module Cassandra
                                 plan,
                                 timeout,
                                 errors,
-                                hosts)
+                                hosts,
+                                retries)
                 else
                   promise.break(e)
                 end
@@ -930,13 +931,15 @@ module Cassandra
                                plan,
                                timeout,
                                errors = nil,
-                               hosts = [])
+                               hosts = [],
+                               retries = -1)
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
         hosts << host = plan.next
+        retries += 1
         pool = nil
         synchronize { pool = @connections[host] }
 
@@ -951,7 +954,8 @@ module Cassandra
                                       plan,
                                       timeout,
                                       errors,
-                                      hosts)
+                                      hosts,
+                                      retries)
         end
 
         connection = pool.random_connection
@@ -970,7 +974,8 @@ module Cassandra
                                       plan,
                                       timeout,
                                       errors,
-                                      hosts)
+                                      hosts,
+                                      retries)
             else
               s.on_failure do |e|
                 if e.is_a?(Errors::HostError) ||
@@ -985,7 +990,8 @@ module Cassandra
                                        plan,
                                        timeout,
                                        errors,
-                                       hosts)
+                                       hosts,
+                                       retries)
                 else
                   promise.break(e)
                 end
@@ -1003,7 +1009,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
         end
       rescue => e
         errors ||= {}
@@ -1016,7 +1023,8 @@ module Cassandra
                              plan,
                              timeout,
                              errors,
-                             hosts)
+                             hosts,
+                             retries)
       end
 
       def do_send_request_by_plan(host,
@@ -1030,7 +1038,7 @@ module Cassandra
                                   timeout,
                                   errors,
                                   hosts,
-                                  retries = 0)
+                                  retries)
         request.retries = retries
 
         f = connection.send_request(request, timeout)
@@ -1075,37 +1083,43 @@ module Cassandra
 
             case r
             when Protocol::UnavailableErrorResponse
-              decision = @retry_policy.unavailable(statement,
-                                                   r.consistency,
-                                                   r.required,
-                                                   r.alive,
-                                                   retries)
+              decision = options.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)
+              decision = options.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)
+              decision = options.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)
+              cql = nil
+              if statement.is_a?(Cassandra::Statements::Batch)
+                # Find the prepared statement with the prepared-statement-id reported by the node.
+                unprepared_child = statement.statements.select do |s|
+                  (s.is_a?(Cassandra::Statements::Prepared) || s.is_a?(Cassandra::Statements::Bound)) && s.id == r.id
+                end.first
+                cql = unprepared_child ? unprepared_child.cql : nil
+              else
+                # This is a normal statement, so we have everything we need.
+                cql = statement.cql
+                synchronize { @preparing_statements[host].delete(cql) }
               end
 
               prepare = prepare_statement(host, connection, cql, timeout)
               prepare.on_complete do |_|
                 if prepare.resolved?
-                  request.id = prepare.value
+                  request.id = prepare.value unless request.is_a?(Cassandra::Protocol::BatchRequest)
                   do_send_request_by_plan(host,
                                           connection,
                                           promise,
@@ -1116,7 +1130,8 @@ module Cassandra
                                           plan,
                                           timeout,
                                           errors,
-                                          hosts)
+                                          hosts,
+                                          retries)
                 else
                   prepare.on_failure do |e|
                     if e.is_a?(Errors::HostError) ||
@@ -1130,7 +1145,8 @@ module Cassandra
                                       plan,
                                       timeout,
                                       errors,
-                                      hosts)
+                                      hosts,
+                                      retries)
                     else
                       promise.break(e)
                     end
@@ -1159,7 +1175,8 @@ module Cassandra
                                        plan,
                                        timeout,
                                        errors,
-                                       hosts)
+                                       hosts,
+                                       retries)
                 when Protocol::ExecuteRequest
                   execute_by_plan(promise,
                                   keyspace,
@@ -1169,7 +1186,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
                 when Protocol::BatchRequest
                   batch_by_plan(promise,
                                 keyspace,
@@ -1179,7 +1197,8 @@ module Cassandra
                                 plan,
                                 timeout,
                                 errors,
-                                hosts)
+                                hosts,
+                                retries)
                 end
               else
                 promise.break(error)
@@ -1200,7 +1219,7 @@ module Cassandra
             when Protocol::PreparedResultResponse
               cql = request.cql
               synchronize do
-                @prepared_statements[host][cql] = r.id
+                @prepared_statements[cql] = r.id
                 @preparing_statements[host].delete(cql)
               end
 
@@ -1209,7 +1228,8 @@ module Cassandra
               pk_idx ||= @schema.get_pk_idx(metadata)
 
               promise.fulfill(
-                Statements::Prepared.new(r.custom_payload,
+                Statements::Prepared.new(r.id,
+                                         r.custom_payload,
                                          r.warnings,
                                          cql,
                                          metadata,
@@ -1223,7 +1243,8 @@ module Cassandra
                                          request.consistency,
                                          retries,
                                          self,
-                                         @connection_options))
+                                         @connection_options)
+              )
             when Protocol::RawRowsResultResponse
               r.materialize(statement.result_metadata)
               promise.fulfill(
@@ -1239,7 +1260,8 @@ module Cassandra
                                    request.consistency,
                                    retries,
                                    self,
-                                   @futures))
+                                   @futures)
+              )
             when Protocol::RowsResultResponse
               promise.fulfill(
                 Results::Paged.new(r.custom_payload,
@@ -1254,7 +1276,8 @@ module Cassandra
                                    request.consistency,
                                    retries,
                                    self,
-                                   @futures))
+                                   @futures)
+              )
             when Protocol::SchemaChangeResultResponse
               if r.change == 'DROPPED' &&
                  r.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
@@ -1267,7 +1290,8 @@ module Cassandra
                 unless f.resolved?
                   f.on_failure do |e|
                     @logger.error(
-                      "Schema agreement failure (#{e.class.name}: #{e.message})")
+                      "Schema agreement failure (#{e.class.name}: #{e.message})"
+                    )
                   end
                 end
                 promise.fulfill(
@@ -1281,7 +1305,8 @@ module Cassandra
                                     request.consistency,
                                     retries,
                                     self,
-                                    @futures))
+                                    @futures)
+                )
               end
             else
               promise.fulfill(Results::Void.new(r.custom_payload,
@@ -1330,7 +1355,8 @@ module Cassandra
                                        plan,
                                        timeout,
                                        errors,
-                                       hosts)
+                                       hosts,
+                                       retries)
                 when Protocol::ExecuteRequest
                   execute_by_plan(promise,
                                   keyspace,
@@ -1340,7 +1366,8 @@ module Cassandra
                                   plan,
                                   timeout,
                                   errors,
-                                  hosts)
+                                  hosts,
+                                  retries)
                 when Protocol::BatchRequest
                   batch_by_plan(promise,
                                 keyspace,
@@ -1350,7 +1377,8 @@ module Cassandra
                                 plan,
                                 timeout,
                                 errors,
-                                hosts)
+                                hosts,
+                                retries)
                 else
                   promise.break(e)
                 end
@@ -1366,7 +1394,8 @@ module Cassandra
                                     request.consistency,
                                     retries,
                                     self,
-                                    @futures))
+                                    @futures)
+                )
               when Retry::Decisions::Reraise
                 promise.break(
                   r.to_error(keyspace,
@@ -1374,7 +1403,8 @@ module Cassandra
                              options,
                              hosts,
                              request.consistency,
-                             retries))
+                             retries)
+                )
               else
                 promise.break(
                   r.to_error(keyspace,
@@ -1382,7 +1412,8 @@ module Cassandra
                              options,
                              hosts,
                              request.consistency,
-                             retries))
+                             retries)
+                )
               end
             end
           rescue => e
@@ -1391,32 +1422,23 @@ module Cassandra
         else
           response_future.on_failure do |ex|
             if ex.is_a?(Errors::HostError) ||
-                (ex.is_a?(Errors::TimeoutError) && statement.idempotent?)
+               (ex.is_a?(Errors::TimeoutError) && statement.idempotent?)
 
               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,
+              when Protocol::QueryRequest, Protocol::PrepareRequest
+                send_request_by_plan(promise,
+                                     keyspace,
+                                     statement,
+                                     options,
+                                     request,
+                                     plan,
+                                     timeout,
+                                     errors,
+                                     hosts,
+                                     retries)
+              when Protocol::ExecuteRequest
+                execute_by_plan(promise,
                                 keyspace,
                                 statement,
                                 options,
@@ -1424,9 +1446,21 @@ module Cassandra
                                 plan,
                                 timeout,
                                 errors,
-                                hosts)
-                else
-                  promise.break(ex)
+                                hosts,
+                                retries)
+              when Protocol::BatchRequest
+                batch_by_plan(promise,
+                              keyspace,
+                              statement,
+                              options,
+                              request,
+                              plan,
+                              timeout,
+                              errors,
+                              hosts,
+                              retries)
+              else
+                promise.break(ex)
               end
             else
               promise.break(ex)
@@ -1445,7 +1479,7 @@ module Cassandra
           unless local.empty?
             host = @registry.host(connection.host)
 
-            if host && @load_balancing_policy.distance(host) != :ignore
+            if host && @profile_manager.distance(host) != :ignore
               versions << version = local.first['schema_version']
               @logger.debug("Host #{host.ip} schema version is #{version}")
             end
@@ -1453,7 +1487,7 @@ module Cassandra
 
           peers.each do |row|
             host = @registry.host(peer_ip(row))
-            next unless host && @load_balancing_policy.distance(host) != :ignore
+            next unless host && @profile_manager.distance(host) != :ignore
 
             versions << version = row['schema_version']
             @logger.debug("Host #{host.ip} schema version is #{version}")
@@ -1533,7 +1567,7 @@ module Cassandra
           when Protocol::PreparedResultResponse
             id = r.id
             synchronize do
-              @prepared_statements[host][cql] = id
+              @prepared_statements[cql] = id
               @preparing_statements[host].delete(cql)
             end
             id