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

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTFhMzk5ZGFjZWJhYTQzZDFhYjA5ZGM3Mzk0YjY1MWMwODdjMDUyNA==
+    ZTBiZDQ4YTM2MDliN2U0N2VlNmJjY2RiYjQyOWVlOWI4MzlhNjNkZg==
   data.tar.gz: !binary |-
-    NGE5OTQ1YjYyNjA1ZTVhNDI4OGQzNmJiMmFlMzJlNzRlMzNiMTkyMw==
+    OGY1MDNjN2Y5ZmFjYmY2YWY0ZWI0ZGNjZjViMTA1ZDdkYzQyOTg0Yg==
 SHA512:
   metadata.gz: !binary |-
-    MWZiZmZiOWNkMzFkMDM3NzE3ZTQxMzUzZWM5NjU1MjA1ODI2ODFkNDkxNzI4
-    YjlmNmJhZGE2OTEyNWY1ZmIyOWQwNjhlNTQyNjdiN2U2Njk3ZDYyMzNhYTg4
-    NmZjYjY5YmZiMDRlNTA2Njg4ZTQ2YTJlZWQ3YjVhY2MwNGE0NjA=
+    MTIzOTk1Nzk0NDI2NWNkZWNiZmUyMmIzZjk4YjQ2YmRjZDkwODc4YjUxY2Fj
+    N2FmYjRlOGZiMjBlNTAzY2RmOGM4OGNlZmZkZWVjN2RjNDU1ZjY4MjYxODE3
+    YWU1MTZiNWMyMjViOTVhODExODlkNmQwMzc1ODZlMjkwYWU0NDQ=
   data.tar.gz: !binary |-
-    NDJiNzQ1ZTgzN2VkOTBmYWZjOGFmN2QwMDc4OWU3YmQxMjdlYmFjZGQ0OTM5
-    NDlmYmQxMDE1YjczZmNmZjg4MGRjNDY1ODRhZjNlYzBkODE2YTQ5YmM0Njlm
-    N2IyYjhkM2JhZmUwMjUyM2I4ODhlM2VmY2Q5YmNkZTUzZmM1ZGE=
+    ZDI1ZDVmMWQyNzJiMGRiYzc5NTgxYjE4ZGEwNjVmZWM0Nzc0Yzk4MGJjODcx
+    YjEzYjNlNTZhOTU1YWY2M2JlZGUxZDA1YWU3NjRlMGE4ZmM4ODUyMTgyNmVj
+    NjU3NWUzYzFiMDNmOGJlZDg1ODJiYzJkMDQ3OGZhNjU3MWZlMTY=

data/README.md

@@ -1,6 +1,6 @@
 # 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 latest version through ruby driver docs](http://datastax.github.io/ruby-driver/) or via the release tags, [e.g. v1.0.0-beta.3](https://github.com/datastax/ruby-driver/tree/v1.0.0-beta.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 [find the documentation for latest version through ruby driver docs](http://datastax.github.io/ruby-driver/) or via the release tags, [e.g. v3.0.0-rc.2](https://github.com/datastax/ruby-driver/tree/v3.0.0-rc.2).*
 
 [![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
 
@@ -107,6 +107,8 @@ Some of the new features added to the driver have unfortunately led to changes i
 * 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.
+* Add protocol_version configuration option to allow the user to force the protocol version to use for communication with nodes.
+* Add support for materialized views and indexes in the schema metadata.
 
 ### Breaking Changes:
 
@@ -133,6 +135,7 @@ batch.add(query, arguments: {p1: 'val1'})
 * [[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.
+* [[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.    
 
 ## Feedback Requested
 
@@ -191,6 +194,8 @@ the release.
 
 ## Known bugs & limitations
 
+* Specifying a `protocol_version` option of 1 or 2 in cluster options will fail with a
+  `NoHostsAvailable` error rather than a `ProtocolError` against Cassandra node versions 3.0-3.4.
 * 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.

data/lib/cassandra.rb

@@ -34,8 +34,10 @@ require 'date'
 
 module Cassandra
   # A list of all supported request consistencies
-  # @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 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
@@ -47,9 +49,52 @@ module Cassandra
   # A list of all possible write types that a
   # {Cassandra::Errors::WriteTimeoutError} can have.
   #
-  # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L872-L887 Description of possible types of writes in Apache Cassandra native protocol spec v1
+  # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L872-L887 Description of
+  #   possible types of writes in Apache Cassandra native protocol spec v1
   WRITE_TYPES = [:simple, :batch, :unlogged_batch, :counter, :batch_log].freeze
 
+  CLUSTER_OPTIONS = [
+    :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,
+    :protocol_version,
+    :requests_per_connection,
+    :schema_refresh_delay,
+    :schema_refresh_timeout,
+    :server_cert,
+    :shuffle_replicas,
+    :ssl,
+    :synchronize_schema,
+    :timeout,
+    :trace,
+    :username
+  ].freeze
+
   # Creates a {Cassandra::Cluster Cluster instance}.
   #
   # @option options [Array<String, IPAddr>] :hosts (['127.0.0.1']) a list of
@@ -141,6 +186,10 @@ module Cassandra
   #   for nodes that use the v3 or later protocol, and `128` for nodes that use the
   #   v2 or earlier protocol.
   #
+  # @option options [Integer] :protocol_version (nil) Version of protocol to speak to
+  #   nodes. By default, this is auto-negotiated to the lowest common protocol version
+  #   that all nodes in `:hosts` speak.
+  #
   # @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
@@ -274,49 +323,13 @@ module Cassandra
   # @private
   SSL_CLASSES = [::TrueClass, ::FalseClass, ::OpenSSL::SSL::SSLContext].freeze
 
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
   # @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)
+      CLUSTER_OPTIONS.include?(key)
     end
 
     has_username = options.key?(:username)
@@ -608,12 +621,8 @@ module Cassandra
     end
 
     options[:nodelay] = !!options[:nodelay] if options.key?(:nodelay)
-
     options[:trace] = !!options[:trace] if options.key?(:trace)
-
-    if options.key?(:shuffle_replicas)
-      options[:shuffle_replicas] = !!options[:shuffle_replicas]
-    end
+    options[:shuffle_replicas] = !!options[:shuffle_replicas] if options.key?(:shuffle_replicas)
 
     if options.key?(:page_size)
       page_size = options[:page_size]
@@ -627,6 +636,16 @@ module Cassandra
       end
     end
 
+    if options.key?(:protocol_version)
+      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
+      end
+    end
+
     if options.key?(:futures_factory)
       futures_factory = options[:futures_factory]
       methods = [:error, :value, :promise, :all]
@@ -662,13 +681,8 @@ module Cassandra
       end
     end
 
-    if options.key?(:synchronize_schema)
-      options[:synchronize_schema] = !!options[:synchronize_schema]
-    end
-
-    if options.key?(:client_timestamps)
-      options[:client_timestamps] = !!options[:client_timestamps]
-    end
+    options[:synchronize_schema] = !!options[:synchronize_schema] if options.key?(:synchronize_schema)
+    options[:client_timestamps] = !!options[:client_timestamps] if options.key?(:client_timestamps)
 
     if options.key?(:connections_per_local_node)
       connections_per_node = options[:connections_per_local_node]
@@ -733,6 +747,8 @@ module Cassandra
   DATE_OFFSET = (::Time.utc(1970, 1, 1).to_date.jd - 2**31)
 end
 
+require 'cassandra/attr_boolean'
+require 'cassandra/version'
 require 'cassandra/uuid'
 require 'cassandra/time_uuid'
 require 'cassandra/tuple'
@@ -763,8 +779,11 @@ require 'cassandra/argument'
 require 'cassandra/function'
 require 'cassandra/function_collection'
 require 'cassandra/column'
+require 'cassandra/column_container'
 require 'cassandra/table'
+require 'cassandra/materialized_view'
 require 'cassandra/keyspace'
+require 'cassandra/index'
 
 require 'cassandra/execution/info'
 require 'cassandra/execution/options'

data/lib/cassandra/attr_boolean.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2016 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+# This file monkey-patches Module to have an attr_boolean method to make it easy
+# for classes to define boolean instance variables with "foo?" reader methods.
+# Inspired by http://stackoverflow.com/questions/4013591/attr-reader-with-question-mark-in-a-name
+module Cassandra
+  module AttrBoolean
+    def attr_boolean(*names)
+      names.each do |name|
+        define_method(:"#{name}?") do
+          res = instance_variable_get(:"@#{name}")
+          !res.nil? && res != false
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/auth.rb

@@ -59,7 +59,8 @@ module Cassandra
     #   subclasses of this class, but need to implement the same methods. This
     #   class exists only for documentation purposes.
     #
-    # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273 Cassandra native protocol v2 SASL authentication
+    # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273 Cassandra
+    #   native protocol v2 SASL authentication
     # @see Cassandra::Auth::Provider#create_authenticator
     class Authenticator
       # @!method initial_response

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

@@ -53,24 +53,12 @@ module Cassandra
           @password = password
         end
 
-        # Returns a Password Authenticator only if
-        # `org.apache.cassandra.auth.PasswordAuthenticator` is given.
-        # @param authentication_class [String] must equal to
-        #   `org.apache.cassandra.auth.PasswordAuthenticator`
-        # @return [Cassandra::Auth::Authenticator] when `authentication_class ==
-        #    "org.apache.cassandra.auth.PasswordAuthenticator"`
-        # @return [nil] for all other values of `authentication_class`
+        # Returns a Password Authenticator
+        # @param authentication_class [String] ignored
+        # @return [Cassandra::Auth::Authenticator]
         def create_authenticator(authentication_class)
-          if authentication_class == PASSWORD_AUTHENTICATOR_FQCN
-            Authenticator.new(@username, @password)
-          end
+          Authenticator.new(@username, @password)
         end
-
-        private
-
-        # @private
-        PASSWORD_AUTHENTICATOR_FQCN =
-          'org.apache.cassandra.auth.PasswordAuthenticator'.freeze
       end
     end
   end

data/lib/cassandra/cluster/connector.rb

@@ -136,6 +136,7 @@ module Cassandra
                                            @connection_options.idle_timeout,
                                            @connection_options.requests_per_connection)
         end.flat_map do |connection|
+          # connection is a CqlProtocolHandler
           f = request_options(connection)
           f = f.flat_map do |options|
             compression = @connection_options.compression
@@ -159,10 +160,19 @@ module Cassandra
             case error
             when Errors::ProtocolError
               synchronize do
-                if @connection_options.protocol_version > 1
+                current_version = connection.protocol_version
+                if current_version > 1 && @connection_options.protocol_negotiable?
                   @logger.info("Host #{host.ip} doesn't support protocol version " \
-                    "#{@connection_options.protocol_version}, downgrading")
-                  @connection_options.protocol_version -= 1
+                    "#{current_version}, downgrading")
+
+                  # This is tricky. We want to try with the next lower protocol version.
+                  # However, the connection_options used for all connections may have
+                  # already been updated due to other node connection failures. So,
+                  # it may already have a lower protocol-version than our current-1. We
+                  # don't want to accidentally raise it, so we update it to the min
+                  # of itself and current-1.
+                  @connection_options.protocol_version =
+                    [@connection_options.protocol_version, current_version - 1].min
                   do_connect(host)
                 else
                   Ione::Future.failed(error)
@@ -170,7 +180,7 @@ module Cassandra
               end
             when Errors::TimeoutError
               future = Ione::CompletableFuture.new
-              connection.close(error).on_complete do |_f|
+              connection.close(error).on_complete do |_|
                 future.fail(error)
               end
               future

data/lib/cassandra/cluster/control_connection.rb

@@ -147,20 +147,20 @@ module Cassandra
       private
 
       SELECT_LOCAL  = Protocol::QueryRequest.new(
-        'SELECT rack, data_center, host_id, release_version, tokens, partitioner ' \
+        'SELECT * ' \
           'FROM system.local',
         EMPTY_LIST,
         EMPTY_LIST,
         :one)
       SELECT_PEERS  = Protocol::QueryRequest.new(
-        'SELECT peer, rack, data_center, host_id, rpc_address, release_version, tokens ' \
+        'SELECT * ' \
           'FROM system.peers',
         EMPTY_LIST,
         EMPTY_LIST,
         :one)
 
       SELECT_PEER_QUERY =
-        'SELECT rack, data_center, host_id, rpc_address, release_version, tokens ' \
+        'SELECT * ' \
         'FROM system.peers ' \
         "WHERE peer = '%s'".freeze
 
@@ -191,18 +191,14 @@ module Cassandra
       def register_async
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         request = Protocol::RegisterRequest.new(
           Protocol::TopologyChangeEventResponse::TYPE,
           Protocol::StatusChangeEventResponse::TYPE
         )
 
-        if @connection_options.synchronize_schema?
-          request.events << Protocol::SchemaChangeEventResponse::TYPE
-        end
+        request.events << Protocol::SchemaChangeEventResponse::TYPE if @connection_options.synchronize_schema?
 
         f = connection.send_request(request)
         f = f.map do |r|
@@ -257,9 +253,7 @@ module Cassandra
 
         @logger.info('Refreshing schema')
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @schema_fetcher.fetch(connection).map do |keyspaces|
           @schema.replace(keyspaces)
@@ -271,9 +265,7 @@ module Cassandra
       def refresh_keyspace_async(keyspace_name)
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info("Refreshing keyspace \"#{keyspace_name}\"")
 
@@ -284,16 +276,14 @@ module Cassandra
             @schema.delete_keyspace(keyspace_name)
           end
 
-          @logger.info("Refreshed keyspace \"#{keyspace_name}\"")
+          @logger.info("Completed refreshing keyspace \"#{keyspace_name}\"")
         end
       end
 
       def refresh_table_async(keyspace_name, table_name)
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info("Refreshing table \"#{keyspace_name}.#{table_name}\"")
 
@@ -304,16 +294,32 @@ module Cassandra
             @schema.delete_table(keyspace_name, table_name)
           end
 
-          @logger.info("Refreshed table \"#{keyspace_name}.#{table_name}\"")
+          @logger.info("Completed refreshing table \"#{keyspace_name}.#{table_name}\"")
         end
       end
 
-      def refresh_type_async(keyspace_name, type_name)
+      def refresh_materialized_view_async(keyspace_name, view_name)
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
+
+        @logger.info("Refreshing materialized view \"#{keyspace_name}.#{view_name}\"")
+
+        @schema_fetcher.fetch_materialized_view(connection, keyspace_name, view_name).map do |view|
+          if view
+            @schema.replace_materialized_view(view)
+          else
+            @schema.delete_materialized_view(keyspace_name, view_name)
+          end
+
+          @logger.info("Completed refreshing materialized view \"#{keyspace_name}.#{view_name}\"")
         end
+      end
+
+      def refresh_type_async(keyspace_name, type_name)
+        connection = @connection
+
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info("Refreshing user-defined type \"#{keyspace_name}.#{type_name}\"")
 
@@ -324,16 +330,14 @@ module Cassandra
             @schema.delete_type(keyspace_name, type_name)
           end
 
-          @logger.info("Refreshed user-defined type \"#{keyspace_name}.#{type_name}\"")
+          @logger.info("Completed refreshing user-defined type \"#{keyspace_name}.#{type_name}\"")
         end
       end
 
       def refresh_function_async(keyspace_name, function_name, function_args)
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info('Refreshing user-defined function ' \
           "\"#{keyspace_name}.#{function_name}\"")
@@ -351,7 +355,7 @@ module Cassandra
             @schema.delete_function(keyspace_name, function_name, parsed_function_args)
           end
 
-          @logger.info('Refreshed user-defined function ' \
+          @logger.info('Completed refreshing user-defined function ' \
             "\"#{keyspace_name}.#{function_name}(#{function_args.join(',')})\"")
         end
       end
@@ -359,9 +363,7 @@ module Cassandra
       def refresh_aggregate_async(keyspace_name, aggregate_name, aggregate_args)
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info('Refreshing user-defined aggregate ' \
           "\"#{keyspace_name}.#{aggregate_name}\"")
@@ -380,7 +382,7 @@ module Cassandra
             @schema.delete_aggregate(keyspace_name, aggregate_name, parsed_aggregate_args)
           end
 
-          @logger.info('Refreshed user-defined aggregate ' \
+          @logger.info('Completed refreshing user-defined aggregate ' \
             "\"#{keyspace_name}.#{aggregate_name}(#{aggregate_args.join(',')})\"")
         end
       end
@@ -432,9 +434,7 @@ module Cassandra
       def refresh_peers_async
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info('Refreshing peers metadata')
 
@@ -456,7 +456,7 @@ module Cassandra
             @registry.host_lost(host.ip) unless ips.include?(host.ip)
           end
 
-          @logger.info('Refreshed peers metadata')
+          @logger.info('Completed refreshing peers metadata')
 
           nil
         end
@@ -465,22 +465,18 @@ module Cassandra
       def refresh_metadata_async
         connection = @connection
 
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @logger.info("Refreshing connected host's metadata")
 
         send_select_request(connection, SELECT_LOCAL).map do |local|
-          if local.empty?
-            raise Errors::InternalError, "Unable to fetch connected host's metadata"
-          else
-            data = local.first
-            @registry.host_found(IPAddr.new(connection.host), data)
-            @metadata.update(data)
-          end
+          raise Errors::InternalError, "Unable to fetch connected host's metadata" if local.empty?
+
+          data = local.first
+          @registry.host_found(IPAddr.new(connection.host), data)
+          @metadata.update(data)
 
-          @logger.info("Refreshed connected host's metadata")
+          @logger.info("Completed refreshing connected host's metadata")
 
           nil
         end
@@ -559,9 +555,7 @@ module Cassandra
 
       def refresh_host_async(address)
         connection = @connection
-        if connection.nil?
-          return Ione::Future.failed(Errors::ClientError.new('Not connected'))
-        end
+        return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         ip = address.to_s
 
@@ -577,12 +571,10 @@ module Cassandra
                   end
 
         send_select_request(connection, request).map do |rows|
-          if rows.empty?
-            raise Errors::InternalError, "Unable to find host metadata: #{ip}"
-          else
-            @logger.info("Refreshed host metadata: #{ip}")
-            @registry.host_found(address, rows.first)
-          end
+          raise Errors::InternalError, "Unable to find host metadata: #{ip}" if rows.empty?
+
+          @logger.info("Completed refreshing host metadata: #{ip}")
+          @registry.host_found(address, rows.first)
 
           self
         end
@@ -647,9 +639,7 @@ Control connection failed and is unlikely to recover.
         end
         f = f.flat_map { register_async }
         f = f.flat_map { refresh_peers_async_maybe_retry }
-        if @connection_options.synchronize_schema?
-          f = f.flat_map { refresh_maybe_retry(:schema) }
-        end
+        f = f.flat_map { refresh_maybe_retry(:schema) } if @connection_options.synchronize_schema?
         f = f.fallback do |error|
           @logger.debug("Connection to #{host.ip} failed " \
             "(#{error.class.name}: #{error.message})")
@@ -683,8 +673,8 @@ Control connection failed and is unlikely to recover.
       end
 
       def process_schema_changes(schema_changes)
-        refresh_keyspaces  = ::Hash.new
-        refresh_tables     = ::Hash.new
+        refresh_keyspaces = ::Hash.new
+        refresh_tables_and_views = ::Hash.new
         refresh_types      = ::Hash.new
 
         # This hash is of the form <keyspace, [Change (for function changes)]>
@@ -700,14 +690,15 @@ Control connection failed and is unlikely to recover.
 
           case change.target
           when Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
-            refresh_tables.delete(keyspace)
+            refresh_tables_and_views.delete(keyspace)
             refresh_types.delete(keyspace)
             refresh_functions.delete(keyspace)
             refresh_aggregates.delete(keyspace)
             refresh_keyspaces[keyspace] = true
           when Protocol::Constants::SCHEMA_CHANGE_TARGET_TABLE
-            tables = refresh_tables[keyspace] ||= ::Hash.new
-            tables[change.name] = true
+            # We can't distinguish between table and view change events, so refresh both.
+            tables_and_views = refresh_tables_and_views[keyspace] ||= ::Hash.new
+            tables_and_views[change.name] = true
           when Protocol::Constants::SCHEMA_CHANGE_TARGET_UDT
             types = refresh_types[keyspace] ||= ::Hash.new
             types[change.name] = true
@@ -726,9 +717,10 @@ Control connection failed and is unlikely to recover.
           futures << refresh_maybe_retry(:keyspace, keyspace)
         end
 
-        refresh_tables.each do |(keyspace, tables)|
-          tables.each_key do |table|
-            futures << refresh_maybe_retry(:table, keyspace, table)
+        refresh_tables_and_views.each do |(keyspace, tables_and_views)|
+          tables_and_views.each_key do |table_or_view|
+            futures << refresh_maybe_retry(:table, keyspace, table_or_view)
+            futures << refresh_maybe_retry(:materialized_view, keyspace, table_or_view)
           end
         end