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

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWVmNzk2M2MxNGJlNmE1OTVmZDMyOGJmN2U4ODc3MzI5MDNjZDA5MQ==
+    YTFhMzk5ZGFjZWJhYTQzZDFhYjA5ZGM3Mzk0YjY1MWMwODdjMDUyNA==
   data.tar.gz: !binary |-
-    NjJmOGJmYmQ4ZWYwMDRkNGNiNWJlNDg2ODhlOGFiOTBhOTRlYWJiOQ==
+    NGE5OTQ1YjYyNjA1ZTVhNDI4OGQzNmJiMmFlMzJlNzRlMzNiMTkyMw==
 SHA512:
   metadata.gz: !binary |-
-    ZmRmNzJlMTQ5NzMxOTRiNTY3YzEzNzJmZjNkZjA0ZDZiNTg2YTNlOTEzZTM4
-    ZTgyNDY0ZWFmNDA4ZDc4ZjJhOTkxZjA4MTBiNWJhZTU0N2YwMWNhYzQ5M2Y2
-    NjE4MzEzYWE5NzFhMzI3Mzc0NDIxNzg0Mzc3NjAzNzVlYTg2NWM=
+    MWZiZmZiOWNkMzFkMDM3NzE3ZTQxMzUzZWM5NjU1MjA1ODI2ODFkNDkxNzI4
+    YjlmNmJhZGE2OTEyNWY1ZmIyOWQwNjhlNTQyNjdiN2U2Njk3ZDYyMzNhYTg4
+    NmZjYjY5YmZiMDRlNTA2Njg4ZTQ2YTJlZWQ3YjVhY2MwNGE0NjA=
   data.tar.gz: !binary |-
-    ODA0MDRkMTBiMDhlYzViYzI1MWE1MjMxMThlMzIyZWRmZTg1MTEwNzU3NWNj
-    MWYyMWVhYzZmZjFhOThhYzQ4Y2UxNzMwNDQzY2I3NTM0YmQxZDY4YTJkNzg2
-    MTQzZmVkN2M1ZGQ3NTk1ODIyZTBjNjI0MWQ5ZGY0NThiODU0Y2Y=
+    NDJiNzQ1ZTgzN2VkOTBmYWZjOGFmN2QwMDc4OWU3YmQxMjdlYmFjZGQ0OTM5
+    NDlmYmQxMDE1YjczZmNmZjg4MGRjNDY1ODRhZjNlYzBkODE2YTQ5YmM0Njlm
+    N2IyYjhkM2JhZmUwMjUyM2I4ODhlM2VmY2Q5YmNkZTUzZmM1ZGE=

data/README.md

@@ -12,7 +12,7 @@ the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 - 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), [@mfiguiere](http://twitter.com/mfiguiere), [@al3xandru](https://twitter.com/al3xandru)
+- Twitter: Follow the latest news about DataStax Drivers - [@avalanche123](http://twitter.com/avalanche123), [@stamhankar999](http://twitter.com/stamhankar999), [@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:
 
@@ -27,17 +27,18 @@ This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [
 
 [Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
 
-## Compability
+## Compatibility
 
 This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Cassandra's native protocol. The current version works with:
 
-* Apache Cassandra versions 1.2, 2.0 and 2.1
-* DataStax Enterprise 3.1, 3.2, 4.0 and 4.5
-* Ruby (MRI) 1.9.3, 2.0, 2.1 and 2.2
+* Apache Cassandra versions 1.2, 2.0, 2.1, and 3.x
+* DataStax Enterprise 4.0, 4.5, 4.6, 4.7, and 4.8
+* Ruby (MRI) 2.2, 2.3
 * JRuby 1.7
-* Rubinius 2.2
 
-__Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work.
+__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
+and is likely to break in the release following 3.0.
 
 ## Quick start
 
@@ -53,10 +54,10 @@ end
 keyspace = 'system'
 session  = cluster.connect(keyspace) # create session, optionally scoped to a keyspace, to execute queries
 
-future = session.execute_async('SELECT keyspace_name, columnfamily_name FROM schema_columnfamilies') # fully asynchronous api
+future = session.execute_async('SELECT keyspace_name, table_name FROM system_schema.tables') # fully asynchronous api
 future.on_success do |rows|
   rows.each do |row|
-    puts "The keyspace #{row['keyspace_name']} has a table called #{row['columnfamily_name']}"
+    puts "The keyspace #{row['keyspace_name']} has a table called #{row['table_name']}"
   end
 end
 future.join
@@ -91,31 +92,64 @@ __Note__: if you want to use compression you should also install [snappy](http:/
 
 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/master/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
 
-## What's new in v2.1.3
-
-Features:
+## What's new in v3.0.0
+
+### Features:
+
+* Apache Cassandra native protocol v4
+* Add support for smallint, tinyint, date (Cassandra::Date) and time (Cassandra::Time) data types.
+* Include schema metadata for User Defined Functions and User Defined Aggregates.
+* Include client ip addresses in request traces, only on Cassandra 3.x.
+* Add new retry policy decision Cassandra::Retry::Policy#try_next_host.
+* Support specifying statement idempotence with the new :idempotent option when executing.
+* Support sending custom payloads when preparing or executing statements using the new :payload option.
+* Expose custom payloads received with responses on server exceptions and Cassandra::Execution::Info instances.
+* Expose server warnings on server exceptions and Cassandra::Execution::Info instances.
+* Add connections_per_local_node, connections_per_remote_node, requests_per_connection cluster configuration options to tune parallel query execution and resource usage.
+* Add Cassandra::Logger class to make it easy for users to enable debug logging in the client.
+
+### Breaking Changes:
+
+* Cassandra::Future#join is now an alias to Cassandra::Future#get and will raise an error if the future is resolved with one.
+* Default consistency level is now LOCAL_ONE.
+* Enable tcp no-delay by default.
+* Unavailable errors are retried on the next host in the load balancing plan by default.
+* Statement execution no longer retried on timeouts, unless :idempotent => true has been specified when executing.
+* Cassandra::Statements::Batch#add signature has changed in how one specifies query parameters. Specify the query parameters array as the value of the arguments key:
+ 
+```ruby
+batch.add(query, ['val1', 'val2'])
+# becomes
+batch.add(query, arguments: ['val1', 'val2'])
 
-* Apache Cassandra native protocol v3
-* [User-defined types](http://datastax.github.io/ruby-driver/features/basics/user_defined_types/) and [tuples](http://datastax.github.io/ruby-driver/features/basics/datatypes/#using-tuples)
-* [Schema metadata includes user-defined types](http://datastax.github.io/ruby-driver/api/keyspace/#type-instance_method)
-* [Named arguments](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/#an-insert-statement-is-prepared-with-named-parameters)
-* [Public types api for type definition and introspection](http://datastax.github.io/ruby-driver/api/types/)
+batch.add(query, {p1: 'val1'})
+# becomes
+batch.add(query, arguments: {p1: 'val1'})
+```
 
-Breaking Changes:
+### Bug Fixes:
 
-* Splat style positional arguments support, deprecated in 2.0.0, has been dropped
+* [[RUBY-120](https://datastax-oss.atlassian.net/browse/RUBY-120)] Tuples and UDTs can be used in sets and hash keys.
+* [[RUBY-143](https://datastax-oss.atlassian.net/browse/RUBY-143)] Retry querying system table for metadata of new hosts when prior attempts fail, ultimately enabling use of new hosts.
+* [[RUBY-150](https://datastax-oss.atlassian.net/browse/RUBY-150)] Fixed a protocol decoding error that occurred when multiple messages are available in a stream.
+* [[RUBY-151](https://datastax-oss.atlassian.net/browse/RUBY-151)] Decode incomplete UDTs properly.
 
-Bug Fixes:
+## Feedback Requested
 
-* [[RUBY-93](https://datastax-oss.atlassian.net/browse/RUBY-93)] Reconnection can overflow the stack
+*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 both end-to-end, or acceptance, testing and constructing documentation. All of the features supported by the driver have appropriate acceptance tests with easy-to-copy code examples in the `features/` directory.
+The DataStax Ruby Driver uses the awesome [Cucumber Framework](http://cukes.info/) for
+both end-to-end, or acceptance, testing and constructing documentation. All of the
+features supported by the driver have appropriate acceptance tests with easy-to-copy code
+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/master/.travis.yml).
+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/master/.travis.yml).
 
 * Check out the driver codebase and install test dependencies:
 
@@ -127,26 +161,37 @@ bundle install --without docs
 
 * [Install ccm](http://www.datastax.com/dev/blog/ccm-a-development-tool-for-creating-local-cassandra-clusters)
 
-* Run tests:
+* Run tests against different versions of Cassandra:
 
 ```bash
-bundle exec cucumber # runs end-to-end tests (or bundle exec rake cucumber)
-bundle exec rspec # runs unit tests (or bundle exec rake rspec)
-bundle exec rake integration # run integration tests
-bundle exec rake test # run both as well as integration tests
+CASSANDRA_VERSION=3.1.1 bundle exec cucumber # runs end-to-end tests (or bundle exec rake cucumber)
+CASSANDRA_VERSION=3.0.0 bundle exec rspec # runs unit tests (or bundle exec rake rspec)
+CASSANDRA_VERSION=2.1.12 bundle exec rake integration # run integration tests
+CASSANDRA_VERSION=2.0.17 bundle exec rake test # run both as well as integration tests
 ```
 
 ## Changelog & versioning
 
-Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases) and [changelog](https://github.com/datastax/ruby-driver/blob/master/CHANGELOG.md). Version numbering follows the [semantic versioning](http://semver.org/) scheme.
+Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases) and
+[changelog](https://github.com/datastax/ruby-driver/blob/master/CHANGELOG.md). Version
+numbering follows the [semantic versioning](http://semver.org/) scheme.
 
-Private and experimental APIs, defined as whatever is not in the [public API documentation][1], i.e. classes and methods marked as `@private`, will change without warning. If you've been recommended to try an experimental API by the maintainers, please let them know if you depend on that API. Experimental APIs will eventually become public, and knowing how they are used helps in determining their maturity.
+Private and experimental APIs, defined as whatever is not in the
+[public API documentation][1], i.e. classes and methods marked as `@private`, will change
+without warning. If you've been recommended to try an experimental API by the maintainers,
+please let them know if you depend on that API. Experimental APIs will eventually become
+public, and knowing how they are used helps in determining their maturity.
 
-Prereleases will be stable, in the sense that they will have finished and properly tested features only, but may introduce APIs that will change before the final release. Please use the prereleases and report bugs, but don't deploy them to production without consulting the maintainers, or doing extensive testing yourself. If you do deploy to production please let the maintainers know as this helps determining the maturity of the release.
+Prereleases will be stable, in the sense that they will have finished and properly tested
+features only, but may introduce APIs that will change before the final release. Please
+use the prereleases and report bugs, but don't deploy them to production without
+consulting the maintainers, or doing extensive testing yourself. If you do deploy to
+production please let the maintainers know as this helps in determining the maturity of
+the release.
 
 ## Known bugs & limitations
 
-* JRuby 1.6 is not officially supported, although 1.6.8 should work, if you're stuck in JRuby 1.6.8 try and see if it works for you.
+* JRuby 1.6 is not officially supported, although 1.6.8 should work.
 * 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.
 
@@ -158,19 +203,26 @@ For contributing read [CONTRIBUTING.md](https://github.com/datastax/ruby-driver/
 
 ## Credits
 
-This driver is based on the original work of [Theo Hultberg](https://github.com/iconara) on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features 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.
+This driver is based on the original work of [Theo Hultberg](https://github.com/iconara)
+on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features
+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.
 
 ## Copyright
 
-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. You may obtain a copy of the License at
+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](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.
+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.
 
   [1]: http://datastax.github.io/ruby-driver/api

data/ext/cassandra_murmur3/cassandra_murmur3.c

@@ -1,4 +1,4 @@
-// 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.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.
@@ -16,7 +16,6 @@
 # limitations under the License.
 #++
 
-
 require 'ione'
 require 'json'
 
@@ -38,8 +37,8 @@ module Cassandra
   # @see http://www.datastax.com/documentation/cassandra/2.0/cassandra/dml/dml_config_consistency_c.html Consistency levels in Apache Cassandra 2.0
   # @see http://www.datastax.com/documentation/cassandra/1.2/cassandra/dml/dml_config_consistency_c.html Consistency levels in Apache Cassandra 1.2
   # @see Cassandra::Session#execute_async
-  CONSISTENCIES = [ :any, :one, :two, :three, :quorum, :all, :local_quorum,
-                    :each_quorum, :serial, :local_serial, :local_one ].freeze
+  CONSISTENCIES = [:any, :one, :two, :three, :quorum, :all, :local_quorum,
+                   :each_quorum, :serial, :local_serial, :local_one].freeze
 
   # A list of all supported serial consistencies
   # @see Cassandra::Session#execute_async
@@ -126,6 +125,22 @@ module Cassandra
   #   address resolver to use. Must be one of `:none` or
   #   `:ec2_multi_region`.
   #
+  # @option options [Integer] :connections_per_local_node (nil) Number of connections to
+  #   open to each local node; the value of this option directly correlates to the number
+  #   of requests the client can make to the local node concurrently. When `nil`, the
+  #   setting is `1` for nodes that use the v3 or later protocol, and `2` for nodes that
+  #   use the v2 or earlier protocol.
+  #
+  # @option options [Integer] :connections_per_remote_node (1) Number of connections to
+  #   open to each remote node; the value of this option directly correlates to the
+  #   number of requests the client can make to the remote node concurrently.
+  #
+  # @option options [Integer] :requests_per_connection (nil) Number of outstanding
+  #   requests to support on one connection. Depending on the types of requests, some may
+  #   get processed in parallel in the Cassandra node. When `nil`, the setting is `1024`
+  #   for nodes that use the v3 or later protocol, and `128` for nodes that use the
+  #   v2 or earlier protocol.
+  #
   # @option options [Boolean] :client_timestamps (false) whether the driver
   #   should send timestamps for each executed statement. Enabling this setting
   #   allows mitigating Cassandra cluster clock skew because the timestamp of
@@ -139,7 +154,8 @@ module Cassandra
   #   automatic schema updates. Schema metadata is used by the driver to
   #   determine cluster partitioners as well as to find partition keys and
   #   replicas of prepared statements, this information makes token aware load
-  #   balancing possible. One can still {Cassandra::Cluster#refresh_schema refresh schema manually}.
+  #   balancing possible. One can still
+  #   {Cassandra::Cluster#refresh_schema refresh schema manually}.
   #
   # @option options [Numeric] :schema_refresh_delay (1) the driver will wait
   #   for `:schema_refresh_delay` before fetching metadata after receiving a
@@ -177,9 +193,15 @@ module Cassandra
   # @option options [Integer] :page_size (10000) default page size for all
   #   select queries. Set this value to `nil` to disable paging.
   #
-  # @option options [Hash{String => String}] :credentials (none) a hash of credentials - to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v1.spec#L238-L250). Note that if you specified `:username` and `:password` options, those credentials are configured automatically.
+  # @option options [Hash{String => String}] :credentials (none) a hash of credentials -
+  #   to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v1.spec#L238-L250).
+  #   Note that if you specified `:username` and `:password` options, those credentials
+  #   are configured automatically.
   #
-  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password Password Provider} will be used automatically.
+  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth
+  #   provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273).
+  #   Note that if you have specified `:username` and `:password`, then a
+  #   {Cassandra::Auth::Providers::Password Password Provider} will be used automatically.
   #
   # @option options [Cassandra::Compression::Compressor] :compressor (none) a
   #   custom compressor. Note that if you have specified `:compression`, an
@@ -187,8 +209,8 @@ module Cassandra
   #
   # @option options [Cassandra::AddressResolution::Policy]
   #   :address_resolution_policy default:
-  #   {Cassandra::AddressResolution::Policies::None No Resolution Policy} a custom address resolution
-  #   policy. Note that if you have specified `:address_resolution`, an
+  #   {Cassandra::AddressResolution::Policies::None No Resolution Policy} a custom address
+  #   resolution policy. Note that if you have specified `:address_resolution`, an
   #   appropriate address resolution policy will be provided automatically.
   #
   # @option options [Object<#all, #error, #value, #promise>] :futures_factory
@@ -219,78 +241,176 @@ module Cassandra
   # @return [Cassandra::Future<Cassandra::Cluster>] a future resolving to the
   #   cluster instance.
   def self.cluster_async(options = {})
-    options = options.select do |key, value|
-      [ :credentials, :auth_provider, :compression, :hosts, :logger, :port,
-        :load_balancing_policy, :reconnection_policy, :retry_policy, :listeners,
-        :consistency, :trace, :page_size, :compressor, :username, :password,
-        :ssl, :server_cert, :client_cert, :private_key, :passphrase,
-        :connect_timeout, :futures_factory, :datacenter, :address_resolution,
-        :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout,
-        :synchronize_schema, :schema_refresh_delay, :schema_refresh_timeout,
-        :shuffle_replicas, :client_timestamps
+    options = validate_and_massage_options(options)
+    hosts = []
+
+    Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
+      case host
+      when ::IPAddr
+        hosts << host
+      when ::String # ip address or hostname
+        Resolv.each_address(host) do |ip|
+          hosts << ::IPAddr.new(ip)
+        end
+      else
+        raise ::ArgumentError, ":hosts must be String or IPAddr, #{host.inspect} given"
+      end
+    end
+
+    if hosts.empty?
+      raise ::ArgumentError,
+            ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
+    end
+
+    hosts.shuffle!
+  rescue => e
+    futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
+    futures.error(e)
+  else
+    driver = Driver.new(options)
+    driver.connect(hosts)
+  end
+
+  # @private
+  SSL_CLASSES = [::TrueClass, ::FalseClass, ::OpenSSL::SSL::SSLContext].freeze
+
+  # @private
+  def self.validate_and_massage_options(options)
+    options = options.select do |key, _|
+      [
+        :address_resolution,
+        :address_resolution_policy,
+        :auth_provider,
+        :client_cert,
+        :client_timestamps,
+        :compression,
+        :compressor,
+        :connect_timeout,
+        :connections_per_local_node,
+        :connections_per_remote_node,
+        :consistency,
+        :credentials,
+        :datacenter,
+        :futures_factory,
+        :heartbeat_interval,
+        :hosts,
+        :idle_timeout,
+        :listeners,
+        :load_balancing_policy,
+        :logger,
+        :nodelay,
+        :reconnection_policy,
+        :retry_policy,
+        :page_size,
+        :passphrase,
+        :password,
+        :port,
+        :private_key,
+        :requests_per_connection,
+        :schema_refresh_delay,
+        :schema_refresh_timeout,
+        :server_cert,
+        :shuffle_replicas,
+        :ssl,
+        :synchronize_schema,
+        :timeout,
+        :trace,
+        :username
       ].include?(key)
     end
 
-    has_username = options.has_key?(:username)
-    has_password = options.has_key?(:password)
+    has_username = options.key?(:username)
+    has_password = options.key?(:password)
     if has_username || has_password
       if has_username && !has_password
-        raise ::ArgumentError, "both :username and :password options must be specified, but only :username given"
+        raise ::ArgumentError,
+              'both :username and :password options must be specified, ' \
+                  'but only :username given'
       end
 
       if !has_username && has_password
-        raise ::ArgumentError, "both :username and :password options must be specified, but only :password given"
+        raise ::ArgumentError,
+              'both :username and :password options must be specified, ' \
+                  'but only :password given'
       end
 
       username = options.delete(:username)
       password = options.delete(:password)
 
-      Util.assert_instance_of(::String, username) { ":username must be a String, #{username.inspect} given" }
-      Util.assert_instance_of(::String, password) { ":password must be a String, #{password.inspect} given" }
-      Util.assert_not_empty(username) { ":username cannot be empty" }
-      Util.assert_not_empty(password) { ":password cannot be empty" }
+      Util.assert_instance_of(::String, username) do
+        ":username must be a String, #{username.inspect} given"
+      end
+      Util.assert_instance_of(::String, password) do
+        ":password must be a String, #{password.inspect} given"
+      end
+      Util.assert_not_empty(username) { ':username cannot be empty' }
+      Util.assert_not_empty(password) { ':password cannot be empty' }
 
-      options[:credentials]   = {:username => username, :password => password}
+      options[:credentials]   = {username: username, password: password}
       options[:auth_provider] = Auth::Providers::Password.new(username, password)
     end
 
-    if options.has_key?(:credentials)
+    if options.key?(:credentials)
       credentials = options[:credentials]
 
-      Util.assert_instance_of(::Hash, credentials) { ":credentials must be a hash, #{credentials.inspect} given" }
+      Util.assert_instance_of(::Hash, credentials) do
+        ":credentials must be a hash, #{credentials.inspect} given"
+      end
     end
 
-    if options.has_key?(:auth_provider)
+    if options.key?(:auth_provider)
       auth_provider = options[:auth_provider]
 
-      Util.assert_responds_to(:create_authenticator, auth_provider) { ":auth_provider #{auth_provider.inspect} must respond to :create_authenticator, but doesn't" }
+      Util.assert_responds_to(:create_authenticator, auth_provider) do
+        ":auth_provider #{auth_provider.inspect} must respond to " \
+            ":create_authenticator, but doesn't"
+      end
     end
 
-    has_client_cert = options.has_key?(:client_cert)
-    has_private_key = options.has_key?(:private_key)
+    has_client_cert = options.key?(:client_cert)
+    has_private_key = options.key?(:private_key)
 
     if has_client_cert || has_private_key
       if has_client_cert && !has_private_key
-        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :client_cert given"
+        raise ::ArgumentError,
+              'both :client_cert and :private_key options must be specified, ' \
+                  'but only :client_cert given'
       end
 
       if !has_client_cert && has_private_key
-        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :private_key given"
+        raise ::ArgumentError,
+              'both :client_cert and :private_key options must be specified, ' \
+                  'but only :private_key given'
       end
 
+      Util.assert_instance_of(::String, options[:client_cert]) do
+        ":client_cert must be a string, #{options[:client_cert].inspect} given"
+      end
+      Util.assert_instance_of(::String, options[:private_key]) do
+        ":client_cert must be a string, #{options[:private_key].inspect} given"
+      end
       client_cert = ::File.expand_path(options[:client_cert])
       private_key = ::File.expand_path(options[:private_key])
 
-      Util.assert_file_exists(client_cert) { ":client_cert #{client_cert.inspect} doesn't exist" }
-      Util.assert_file_exists(private_key) { ":private_key #{private_key.inspect} doesn't exist" }
+      Util.assert_file_exists(client_cert) do
+        ":client_cert #{client_cert.inspect} doesn't exist"
+      end
+      Util.assert_file_exists(private_key) do
+        ":private_key #{private_key.inspect} doesn't exist"
+      end
     end
 
-    has_server_cert = options.has_key?(:server_cert)
+    has_server_cert = options.key?(:server_cert)
 
     if has_server_cert
+      Util.assert_instance_of(::String, options[:server_cert]) do
+        ":server_cert must be a string, #{options[:server_cert].inspect} given"
+      end
       server_cert = ::File.expand_path(options[:server_cert])
 
-      Util.assert_file_exists(server_cert) { ":server_cert #{server_cert.inspect} doesn't exist" }
+      Util.assert_file_exists(server_cert) do
+        ":server_cert #{server_cert.inspect} doesn't exist"
+      end
     end
 
     if has_client_cert || has_server_cert
@@ -304,23 +424,26 @@ module Cassandra
       if has_client_cert
         context.cert = ::OpenSSL::X509::Certificate.new(File.read(client_cert))
 
-        if options.has_key?(:passphrase)
-          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key), options[:passphrase])
-        else
-          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key))
-        end
+        context.key = if options.key?(:passphrase)
+                        ::OpenSSL::PKey::RSA.new(File.read(private_key),
+                                                 options[:passphrase])
+                      else
+                        ::OpenSSL::PKey::RSA.new(File.read(private_key))
+                      end
       end
 
       options[:ssl] = context
     end
 
-    if options.has_key?(:ssl)
+    if options.key?(:ssl)
       ssl = options[:ssl]
 
-      Util.assert_instance_of_one_of([::TrueClass, ::FalseClass, ::OpenSSL::SSL::SSLContext], ssl) { ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given" }
+      Util.assert_instance_of_one_of(SSL_CLASSES, ssl) do
+        ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given"
+      end
     end
 
-    if options.has_key?(:compression)
+    if options.key?(:compression)
       compression = options.delete(:compression)
 
       case compression
@@ -329,195 +452,267 @@ module Cassandra
       when :lz4
         options[:compressor] = Compression::Compressors::Lz4.new
       else
-        raise ::ArgumentError, ":compression must be either :snappy or :lz4, #{compression.inspect} given"
+        raise ::ArgumentError,
+              ":compression must be either :snappy or :lz4, #{compression.inspect} given"
       end
     end
 
-    if options.has_key?(:compressor)
+    if options.key?(:compressor)
       compressor = options[:compressor]
       methods    = [:algorithm, :compress?, :compress, :decompress]
 
-      Util.assert_responds_to_all(methods, compressor) { ":compressor #{compressor.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, compressor) do
+        ":compressor #{compressor.inspect} must respond to #{methods.inspect}, " \
+            "but doesn't"
+      end
     end
 
-    if options.has_key?(:logger)
-      logger  = options[:logger]
-      methods = [:debug, :info, :warn, :error, :fatal]
+    if options.key?(:logger)
+      if options[:logger].nil?
+        # Delete the key because we want to fallback to the default logger in Driver.
+        options.delete(:logger)
+      else
+        # Validate
+        logger = options[:logger]
+        methods = [:debug, :info, :warn, :error, :fatal]
 
-      Util.assert_responds_to_all(methods, logger) { ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't" }
+        Util.assert_responds_to_all(methods, logger) do
+          ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't"
+        end
+      end
     end
 
-    if options.has_key?(:port)
-      port = options[:port] = Integer(options[:port])
-
-      Util.assert_one_of(0..65536, port) { ":port must be a valid ip port, #{port} given" }
+    if options.key?(:port)
+      unless options[:port].nil?
+        port = options[:port]
+        Util.assert_instance_of(::Integer, port)
+        Util.assert_one_of(1...2**16, port) do
+          ":port must be a valid ip port, #{port} given"
+        end
+      end
     end
 
-    if options.has_key?(:datacenter)
-      options[:datacenter] = String(options[:datacenter])
-    end
+    options[:datacenter] = String(options[:datacenter]) if options.key?(:datacenter)
 
-    if options.has_key?(:connect_timeout)
+    if options.key?(:connect_timeout)
       timeout = options[:connect_timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":connect_timeout must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":connect_timeout must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":connect_timeout must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":connect_timeout must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:timeout)
+    if options.key?(:timeout)
       timeout = options[:timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":timeout must be a number of seconds, #{timeout} given" }
+        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
     end
 
-    if options.has_key?(:heartbeat_interval)
+    if options.key?(:heartbeat_interval)
       timeout = options[:heartbeat_interval]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":heartbeat_interval must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":heartbeat_interval must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":heartbeat_interval must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":heartbeat_interval must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:idle_timeout)
+    if options.key?(:idle_timeout)
       timeout = options[:idle_timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":idle_timeout must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":idle_timeout must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":idle_timeout must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":idle_timeout must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:schema_refresh_delay)
+    if options.key?(:schema_refresh_delay)
       timeout = options[:schema_refresh_delay]
 
-      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_delay must be a number of seconds, #{timeout} given" }
-      Util.assert(timeout > 0) { ":schema_refresh_delay must be greater than 0, #{timeout} given" }
+      Util.assert_instance_of(::Numeric, timeout) do
+        ":schema_refresh_delay must be a number of seconds, #{timeout.inspect} given"
+      end
+      Util.assert(timeout > 0) do
+        ":schema_refresh_delay must be greater than 0, #{timeout} given"
+      end
     end
 
-    if options.has_key?(:schema_refresh_timeout)
+    if options.key?(:schema_refresh_timeout)
       timeout = options[:schema_refresh_timeout]
 
-      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_timeout must be a number of seconds, #{timeout} given" }
-      Util.assert(timeout > 0) { ":schema_refresh_timeout must be greater than 0, #{timeout} given" }
+      Util.assert_instance_of(::Numeric, timeout) do
+        ":schema_refresh_timeout must be a number of seconds, #{timeout.inspect} given"
+      end
+      Util.assert(timeout > 0) do
+        ":schema_refresh_timeout must be greater than 0, #{timeout} given"
+      end
     end
 
-    if options.has_key?(:load_balancing_policy)
+    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]
+      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                 :distance, :plan]
 
-      Util.assert_responds_to_all(methods, load_balancing_policy) { ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
+      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.has_key?(:reconnection_policy)
+    if options.key?(:reconnection_policy)
       reconnection_policy = options[:reconnection_policy]
 
-      Util.assert_responds_to(:schedule, reconnection_policy) { ":reconnection_policy #{reconnection_policy.inspect} must respond to :schedule, but doesn't" }
+      Util.assert_responds_to(:schedule, reconnection_policy) do
+        ":reconnection_policy #{reconnection_policy.inspect} must respond to " \
+            ":schedule, but doesn't"
+      end
     end
 
-    if options.has_key?(:retry_policy)
+    if options.key?(:retry_policy)
       retry_policy = options[:retry_policy]
       methods = [:read_timeout, :write_timeout, :unavailable]
 
-      Util.assert_responds_to_all(methods, retry_policy) { ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, retry_policy) do
+        ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, " \
+            "but doesn't"
+      end
     end
 
-    if options.has_key?(:listeners)
-      options[:listeners] = Array(options[:listeners])
-    end
+    options[:listeners] = Array(options[:listeners]) if options.key?(:listeners)
 
-    if options.has_key?(:consistency)
+    if options.key?(:consistency)
       consistency = options[:consistency]
 
-      Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
+      Util.assert_one_of(CONSISTENCIES, consistency) do
+        ":consistency must be one of #{CONSISTENCIES.inspect}, " \
+            "#{consistency.inspect} given"
+      end
     end
 
-    if options.has_key?(:nodelay)
-      options[:nodelay] = !!options[:nodelay]
-    end
+    options[:nodelay] = !!options[:nodelay] if options.key?(:nodelay)
 
-    if options.has_key?(:trace)
-      options[:trace] = !!options[:trace]
-    end
+    options[:trace] = !!options[:trace] if options.key?(:trace)
 
-    if options.has_key?(:shuffle_replicas)
+    if options.key?(:shuffle_replicas)
       options[:shuffle_replicas] = !!options[:shuffle_replicas]
     end
 
-    if options.has_key?(:page_size)
+    if options.key?(:page_size)
       page_size = options[:page_size]
 
       unless page_size.nil?
-        page_size = options[:page_size] = Integer(page_size)
-        Util.assert(page_size > 0) { ":page_size must be a positive integer, #{page_size.inspect} given" }
+        page_size = options[:page_size]
+        Util.assert_instance_of(::Integer, page_size)
+        Util.assert_one_of(1...2**32, page_size) do
+          ":page_size must be a positive integer, #{page_size.inspect} given"
+        end
       end
     end
 
-    if options.has_key?(:futures_factory)
+    if options.key?(:futures_factory)
       futures_factory = options[:futures_factory]
       methods = [:error, :value, :promise, :all]
 
-      Util.assert_responds_to_all(methods, futures_factory) { ":futures_factory #{futures_factory.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, futures_factory) do
+        ":futures_factory #{futures_factory.inspect} must respond to " \
+            "#{methods.inspect}, but doesn't"
+      end
     end
 
-    if options.has_key?(:address_resolution)
+    if options.key?(:address_resolution)
       address_resolution = options.delete(:address_resolution)
 
       case address_resolution
       when :none
         # do nothing
       when :ec2_multi_region
-        options[:address_resolution_policy] = AddressResolution::Policies::EC2MultiRegion.new
+        options[:address_resolution_policy] =
+          AddressResolution::Policies::EC2MultiRegion.new
       else
-        raise ::ArgumentError, ":address_resolution must be either :none or :ec2_multi_region, #{address_resolution.inspect} given"
+        raise ::ArgumentError,
+              ':address_resolution must be either :none or :ec2_multi_region, ' \
+                  "#{address_resolution.inspect} given"
       end
     end
 
-    if options.has_key?(:address_resolution_policy)
+    if options.key?(:address_resolution_policy)
       address_resolver = options[:address_resolution_policy]
 
-      Util.assert_responds_to(:resolve, address_resolver) { ":address_resolution_policy must respond to :resolve, #{address_resolver.inspect} but doesn't" }
+      Util.assert_responds_to(:resolve, address_resolver) do
+        ':address_resolution_policy must respond to :resolve, ' \
+            "#{address_resolver.inspect} but doesn't"
+      end
     end
 
-    if options.has_key?(:synchronize_schema)
+    if options.key?(:synchronize_schema)
       options[:synchronize_schema] = !!options[:synchronize_schema]
     end
 
-    if options.has_key?(:client_timestamps)
+    if options.key?(:client_timestamps)
       options[:client_timestamps] = !!options[:client_timestamps]
     end
 
-    hosts = []
+    if options.key?(:connections_per_local_node)
+      connections_per_node = options[:connections_per_local_node]
 
-    Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
-      case host
-      when ::IPAddr
-        hosts << host
-      when ::String # ip address or hostname
-        Resolv.each_address(host) do |ip|
-          hosts << ::IPAddr.new(ip)
+      unless connections_per_node.nil?
+        connections_per_node = options[:connections_per_local_node]
+        Util.assert_instance_of(::Integer, connections_per_node)
+        Util.assert_one_of(1...2**16, connections_per_node) do
+          ':connections_per_local_node must be a positive integer between ' \
+              "1 and 65535, #{connections_per_node.inspect} given"
         end
-      else
-        raise ::ArgumentError, ":hosts must be String or IPAddr, #{host.inspect} given"
       end
     end
 
-    if hosts.empty?
-      raise ::ArgumentError, ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
+    if options.key?(:connections_per_remote_node)
+      connections_per_node = options[:connections_per_remote_node]
+
+      unless connections_per_node.nil?
+        connections_per_node = options[:connections_per_remote_node]
+        Util.assert_instance_of(::Integer, connections_per_node)
+        Util.assert_one_of(1...2**16, connections_per_node) do
+          ':connections_per_remote_node must be a positive integer between ' \
+              "1 and 65535, #{connections_per_node.inspect} given"
+        end
+      end
     end
 
-    hosts.shuffle!
-  rescue => e
-    futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
-    futures.error(e)
-  else
-    driver = Driver.new(options)
-    driver.connect(hosts)
+    if options.key?(:requests_per_connection)
+      requests_per_connection = options[:requests_per_connection]
+
+      unless requests_per_connection.nil?
+        requests_per_connection = options[:requests_per_connection]
+        Util.assert_instance_of(::Integer, requests_per_connection)
+
+        # v3 protocol says that max stream-id is 32767 (2^15-1). This setting might be
+        # used to talk to a v2 (or less) node, but then we'll adjust it down.
+
+        Util.assert_one_of(1...2**15, requests_per_connection) do
+          ':requests_per_connection must be a positive integer, ' \
+              "#{requests_per_connection.inspect} given"
+        end
+      end
+    end
+    options
   end
 
   # @private
@@ -535,7 +730,7 @@ module Cassandra
   # => 1970-1-1
   # ::Date.jd(DATE_OFFSET + 2 ** 32, ::Date::GREGORIAN)
   # => 5881580-07-12
-  DATE_OFFSET = (::Time.utc(1970, 1, 1).to_date.jd - 2 ** 31)
+  DATE_OFFSET = (::Time.utc(1970, 1, 1).to_date.jd - 2**31)
 end
 
 require 'cassandra/uuid'
@@ -550,6 +745,7 @@ require 'cassandra/errors'
 require 'cassandra/compression'
 require 'cassandra/protocol'
 require 'cassandra/auth'
+require 'cassandra/cassandra_logger'
 require 'cassandra/null_logger'
 
 require 'cassandra/executors'
@@ -565,6 +761,7 @@ require 'cassandra/statements'
 require 'cassandra/aggregate'
 require 'cassandra/argument'
 require 'cassandra/function'
+require 'cassandra/function_collection'
 require 'cassandra/column'
 require 'cassandra/table'
 require 'cassandra/keyspace'
@@ -587,7 +784,7 @@ module Cassandra
   # @private
   VOID_STATEMENT = Statements::Void.new
   # @private
-  VOID_OPTIONS   = Execution::Options.new({:consistency => :one})
+  VOID_OPTIONS   = Execution::Options.new(consistency: :one)
   # @private
   NO_HOSTS       = Errors::NoHostsAvailable.new
 end