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

data/lib/cassandra/cluster/connection_pool.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.
@@ -72,7 +72,7 @@ module Cassandra
           @connections.each(&callback)
         end
       end
-      alias_method :each, :each_connection
+      alias each each_connection
     end
   end
 end

data/lib/cassandra/cluster/connector.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.
@@ -22,7 +22,11 @@ module Cassandra
     class Connector
       include MonitorMixin
 
-      def initialize(logger, io_reactor, cluster_registry, connection_options, execution_options)
+      def initialize(logger,
+                     io_reactor,
+                     cluster_registry,
+                     connection_options,
+                     execution_options)
         @logger             = logger
         @reactor            = io_reactor
         @registry           = cluster_registry
@@ -82,7 +86,7 @@ module Cassandra
 
           synchronize do
             @open_connections[host] ||= []
-            @open_connections[host]  << connection
+            @open_connections[host] << connection
           end
 
           timer = @reactor.schedule_timer(UNCLAIMED_TIMEOUT)
@@ -112,7 +116,10 @@ module Cassandra
       UNCLAIMED_TIMEOUT = 5 # close unclaimed connections in five seconds
 
       def do_connect(host)
-        @reactor.connect(host.ip.to_s, @connection_options.port, {:timeout => @connection_options.connect_timeout, :ssl => @connection_options.ssl}) do |connection|
+        @reactor.connect(host.ip.to_s,
+                         @connection_options.port,
+                         timeout: @connection_options.connect_timeout,
+                         ssl: @connection_options.ssl) do |connection|
           raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
 
           if @connection_options.nodelay?
@@ -121,20 +128,31 @@ module Cassandra
             connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 0)
           end
 
-          Protocol::CqlProtocolHandler.new(connection, @reactor, @connection_options.protocol_version, @connection_options.compressor, @connection_options.heartbeat_interval, @connection_options.idle_timeout)
+          Protocol::CqlProtocolHandler.new(connection,
+                                           @reactor,
+                                           @connection_options.protocol_version,
+                                           @connection_options.compressor,
+                                           @connection_options.heartbeat_interval,
+                                           @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
             supported_algorithms = options['COMPRESSION']
 
             if compression && !supported_algorithms.include?(compression)
-              @logger.warn("Compression with #{compression.inspect} is not supported by host at #{host.ip}, supported algorithms are #{supported_algorithms.inspect}")
+              @logger.warn("Compression with #{compression.inspect} is not supported " \
+                "by host at #{host.ip}, supported algorithms are " \
+                "#{supported_algorithms.inspect}")
               compression = nil
             end
 
             supported_cql_versions = options['CQL_VERSION']
-            cql_version = (supported_cql_versions && !supported_cql_versions.empty?) ? supported_cql_versions.first : '3.1.0'
+            cql_version = (supported_cql_versions && !supported_cql_versions.empty?) ?
+                supported_cql_versions.first :
+                '3.1.0'
 
             startup_connection(connection, cql_version, compression)
           end
@@ -142,9 +160,19 @@ module Cassandra
             case error
             when Errors::ProtocolError
               synchronize do
-                if @connection_options.protocol_version > 1
-                  @logger.info("Host #{host.ip} doesn't support protocol version #{@connection_options.protocol_version}, downgrading")
-                  @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 " \
+                    "#{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)
@@ -152,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
@@ -173,7 +201,8 @@ module Cassandra
       end
 
       def startup_connection(connection, cql_version, compression)
-        connection.send_request(Protocol::StartupRequest.new(cql_version, compression), @execution_options.timeout).flat_map do |r|
+        connection.send_request(Protocol::StartupRequest.new(cql_version, compression),
+                                @execution_options.timeout).flat_map do |r|
           case r
           when Protocol::AuthenticateResponse
             if @connection_options.protocol_version == 1
@@ -181,28 +210,48 @@ module Cassandra
               if credentials
                 send_credentials(connection, credentials)
               else
-                Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate', nil, nil, nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+                Ione::Future.failed(cannot_authenticate_error)
               end
             else
-              authenticator = @connection_options.create_authenticator(r.authentication_class)
+              authenticator = @connection_options.create_authenticator(
+                r.authentication_class)
               if authenticator
-                challenge_response_cycle(connection, authenticator, authenticator.initial_response)
+                challenge_response_cycle(connection,
+                                         authenticator,
+                                         authenticator.initial_response)
               else
-                Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate', nil, nil, nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+                Ione::Future.failed(cannot_authenticate_error)
               end
             end
           when Protocol::ReadyResponse
             ::Ione::Future.resolved(connection)
           when Protocol::ErrorResponse
-            ::Ione::Future.failed(r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+            ::Ione::Future.failed(
+              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
           else
-            ::Ione::Future.failed(Errors::InternalError.new("Unexpected response #{r.inspect}"))
+            ::Ione::Future.failed(
+              Errors::InternalError.new("Unexpected response #{r.inspect}"))
           end
         end
       end
 
+      def cannot_authenticate_error
+        Errors::AuthenticationError.new(
+          'Server requested authentication, but client was not configured to ' \
+            'authenticate',
+          nil,
+          nil,
+          nil,
+          VOID_STATEMENT,
+          VOID_OPTIONS,
+          EMPTY_LIST,
+          :one,
+          0)
+      end
+
       def request_options(connection)
-        connection.send_request(Protocol::OptionsRequest.new, @execution_options.timeout).map do |r|
+        connection.send_request(Protocol::OptionsRequest.new,
+                                @execution_options.timeout).map do |r|
           case r
           when Protocol::SupportedResponse
             r.options
@@ -215,7 +264,8 @@ module Cassandra
       end
 
       def send_credentials(connection, credentials)
-        connection.send_request(Protocol::CredentialsRequest.new(credentials), @execution_options.timeout).map do |r|
+        connection.send_request(Protocol::CredentialsRequest.new(credentials),
+                                @execution_options.timeout).map do |r|
           case r
           when Protocol::ReadyResponse
             connection
@@ -228,18 +278,25 @@ module Cassandra
       end
 
       def challenge_response_cycle(connection, authenticator, token)
-        connection.send_request(Protocol::AuthResponseRequest.new(token), @execution_options.timeout).flat_map do |r|
+        connection.send_request(Protocol::AuthResponseRequest.new(token),
+                                @execution_options.timeout).flat_map do |r|
           case r
           when Protocol::AuthChallengeResponse
             token = authenticator.challenge_response(r.token)
             challenge_response_cycle(pending_connection, authenticator, token)
           when Protocol::AuthSuccessResponse
-            authenticator.authentication_successful(r.token) rescue nil
+            begin
+              authenticator.authentication_successful(r.token)
+            rescue
+              nil
+            end
             ::Ione::Future.resolved(connection)
           when Protocol::ErrorResponse
-            ::Ione::Future.failed(r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+            ::Ione::Future.failed(
+              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
           else
-            ::Ione::Future.failed(Errors::InternalError.new("Unexpected response #{r.inspect}"))
+            ::Ione::Future.failed(
+              Errors::InternalError.new("Unexpected response #{r.inspect}"))
           end
         end
       end
@@ -282,7 +339,8 @@ module Cassandra
           end
         end
 
-        @logger.debug("Host #{host.ip} closed connection (#{error.class.name}: #{error.message})") if error
+        @logger.debug("Host #{host.ip} closed connection (#{error.class.name}: " \
+          "#{error.message})") if error
 
         if notify
           @logger.warn("Host #{host.ip} closed all connections")
@@ -296,10 +354,11 @@ module Cassandra
         notify = false
 
         synchronize do
-          notify = !error.nil? && !@connections.has_key?(host)
+          notify = !error.nil? && !@connections.key?(host)
         end
 
-        @logger.debug("Host #{host.ip} refused connection (#{error.class.name}: #{error.message})")
+        @logger.debug("Host #{host.ip} refused connection (#{error.class.name}: " \
+          "#{error.message})")
 
         if notify
           @logger.warn("Host #{host.ip} refused all connections")

data/lib/cassandra/cluster/control_connection.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.
@@ -84,8 +84,11 @@ module Cassandra
           timer = @refreshing_statuses.delete(host)
           @io_reactor.cancel_timer(timer) if timer
 
-          unless @connection || (@status == :closing || @status == :closed) || @load_balancing_policy.distance(host) == :ignore
-            return connect_to_first_available(@load_balancing_policy.plan(nil, VOID_STATEMENT, VOID_OPTIONS))
+          unless @connection ||
+                 (@status == :closing || @status == :closed) ||
+                 @load_balancing_policy.distance(host) == :ignore
+            return connect_to_first_available(
+              @load_balancing_policy.plan(nil, VOID_STATEMENT, VOID_OPTIONS))
           end
         end
 
@@ -97,18 +100,22 @@ module Cassandra
         timer    = nil
 
         synchronize do
-          return Ione::Future.resolved if @refreshing_statuses[host] || @load_balancing_policy.distance(host) == :ignore
+          if @refreshing_statuses[host] ||
+             @load_balancing_policy.distance(host) == :ignore
+            return Ione::Future.resolved
+          end
 
           schedule = @reconnection_policy.schedule
           timeout  = schedule.next
 
-          @logger.debug("Starting to continuously refresh status of #{host.ip} in #{timeout} seconds")
+          @logger.debug("Starting to continuously refresh status of #{host.ip} in " \
+            "#{timeout} seconds")
 
           @refreshing_statuses[host] = timer = @io_reactor.schedule_timer(timeout)
         end
 
         timer.on_value do
-          refresh_host_status(host).fallback do |e|
+          refresh_host_status(host).fallback do |_e|
             refresh_host_status_with_retry(timer, host, schedule)
           end
         end
@@ -134,13 +141,28 @@ module Cassandra
       end
 
       def inspect
-        "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
       end
 
       private
 
-      SELECT_LOCAL  = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, release_version, tokens, partitioner 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 FROM system.peers', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_LOCAL  = Protocol::QueryRequest.new(
+        'SELECT * ' \
+          'FROM system.local',
+        EMPTY_LIST,
+        EMPTY_LIST,
+        :one)
+      SELECT_PEERS  = Protocol::QueryRequest.new(
+        'SELECT * ' \
+          'FROM system.peers',
+        EMPTY_LIST,
+        EMPTY_LIST,
+        :one)
+
+      SELECT_PEER_QUERY =
+        'SELECT * ' \
+        'FROM system.peers ' \
+        "WHERE peer = '%s'".freeze
 
       def reconnect_async(schedule)
         timeout = schedule.next
@@ -159,11 +181,10 @@ module Cassandra
         f.fallback do |e|
           @logger.error("Control connection failed (#{e.class.name}: #{e.message})")
 
-          if synchronize { @status == :reconnecting }
-            reconnect_async(schedule)
-          else
-            return Ione::Future.resolved
-          end
+          return Ione::Future.resolved unless synchronize { @status == :reconnecting }
+
+          # We're reconnecting...
+          reconnect_async(schedule)
         end
       end
 
@@ -190,7 +211,7 @@ module Cassandra
             raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
         end
-        f = f.map do
+        f.map do
           connection.on_event do |event|
             @logger.debug("Event received #{event}")
 
@@ -205,7 +226,7 @@ module Cassandra
                   @registry.host_up(address)
                 else
                   refresh_host_async_maybe_retry(address)
-                  refresh_maybe_retry(:schema)
+                  refresh_schema_async_wrapper
                 end
               when 'DOWN'
                 @registry.host_down(event.address)
@@ -214,11 +235,11 @@ module Cassandra
 
                 unless @registry.has_host?(address)
                   refresh_host_async_maybe_retry(address)
-                  refresh_maybe_retry(:schema)
+                  refresh_schema_async_wrapper
                 end
               when 'REMOVED_NODE'
                 @registry.host_lost(event.address)
-                refresh_maybe_retry(:schema)
+                refresh_schema_async_wrapper
               end
             end
           end
@@ -230,14 +251,14 @@ module Cassandra
       def refresh_schema_async
         connection = @connection
 
-        @logger.info("Refreshing schema")
+        @logger.info('Refreshing schema')
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         @schema_fetcher.fetch(connection).map do |keyspaces|
           @schema.replace(keyspaces)
           @metadata.rebuild_token_map
-          @logger.info("Schema refreshed")
+          @logger.info('Schema refreshed')
         end
       end
 
@@ -255,7 +276,7 @@ module Cassandra
             @schema.delete_keyspace(keyspace_name)
           end
 
-          @logger.info("Refreshed keyspace \"#{keyspace_name}\"")
+          @logger.info("Completed refreshing keyspace \"#{keyspace_name}\"")
         end
       end
 
@@ -273,7 +294,25 @@ 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_materialized_view_async(keyspace_name, view_name)
+        connection = @connection
+
+        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
 
@@ -291,7 +330,7 @@ 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
 
@@ -300,18 +339,24 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        @logger.info("Refreshing user-defined function \"#{keyspace_name}.#{function_name}\"")
+        @logger.info('Refreshing user-defined function ' \
+          "\"#{keyspace_name}.#{function_name}\"")
 
         # function_args is an array of string, and we need an array of parsed types.
-        parsed_function_args = @schema_fetcher.parse_argument_types(connection, keyspace_name, function_args)
-        @schema_fetcher.fetch_function(connection, keyspace_name, function_name, parsed_function_args).map do |function|
+        parsed_function_args =
+          @schema_fetcher.parse_argument_types(connection, keyspace_name, function_args)
+        @schema_fetcher.fetch_function(connection,
+                                       keyspace_name,
+                                       function_name,
+                                       parsed_function_args).map do |function|
           if function
             @schema.replace_function(function)
           else
             @schema.delete_function(keyspace_name, function_name, parsed_function_args)
           end
 
-          @logger.info("Refreshed user-defined function \"#{keyspace_name}.#{function_name}(#{function_args.join(',')})\"")
+          @logger.info('Completed refreshing user-defined function ' \
+            "\"#{keyspace_name}.#{function_name}(#{function_args.join(',')})\"")
         end
       end
 
@@ -320,18 +365,25 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        @logger.info("Refreshing user-defined aggregate \"#{keyspace_name}.#{aggregate_name}\"")
+        @logger.info('Refreshing user-defined aggregate ' \
+          "\"#{keyspace_name}.#{aggregate_name}\"")
 
         # aggregate_args is an array of string, and we need an array of parsed types.
-        parsed_aggregate_args = @schema_fetcher.parse_argument_types(connection, keyspace_name, aggregate_args)
-        @schema_fetcher.fetch_aggregate(connection, keyspace_name, aggregate_name, parsed_aggregate_args).map do |aggregate|
+        parsed_aggregate_args = @schema_fetcher.parse_argument_types(connection,
+                                                                     keyspace_name,
+                                                                     aggregate_args)
+        @schema_fetcher.fetch_aggregate(connection,
+                                        keyspace_name,
+                                        aggregate_name,
+                                        parsed_aggregate_args).map do |aggregate|
           if aggregate
             @schema.replace_aggregate(aggregate)
           else
             @schema.delete_aggregate(keyspace_name, aggregate_name, parsed_aggregate_args)
           end
 
-          @logger.info("Refreshed user-defined aggregate \"#{keyspace_name}.#{aggregate_name}(#{aggregate_args.join(',')})\"")
+          @logger.info('Completed refreshing user-defined aggregate ' \
+            "\"#{keyspace_name}.#{aggregate_name}(#{aggregate_args.join(',')})\"")
         end
       end
 
@@ -360,7 +412,8 @@ module Cassandra
 
       def refresh_peers_async_retry(error, schedule)
         timeout = schedule.next
-        @logger.info("Failed to refresh hosts (#{error.class.name}: #{error.message}), retrying in #{timeout}")
+        @logger.info("Failed to refresh hosts (#{error.class.name}: " \
+          "#{error.message}), retrying in #{timeout}")
 
         timer = @io_reactor.schedule_timer(timeout)
         timer.flat_map do
@@ -383,7 +436,7 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        @logger.info("Refreshing peers metadata")
+        @logger.info('Refreshing peers metadata')
 
         send_select_request(connection, SELECT_PEERS).map do |peers|
           @logger.debug("#{peers.size} peer(s) found")
@@ -403,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
@@ -417,15 +470,13 @@ module Cassandra
         @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
@@ -452,7 +503,7 @@ module Cassandra
         end
 
         timer.on_value do
-          refresh_host_status(host).fallback do |e|
+          refresh_host_status(host).fallback do |_e|
             refresh_host_status_with_retry(timer, host, schedule)
           end
         end
@@ -483,7 +534,8 @@ module Cassandra
 
       def refresh_host_async_retry(address, error, schedule)
         timeout = schedule.next
-        @logger.info("Failed to refresh host #{address.to_s} (#{error.class.name}: #{error.message}), retrying in #{timeout}")
+        @logger.info("Failed to refresh host #{address} (#{error.class.name}: " \
+          "#{error.message}), retrying in #{timeout}")
 
         timer = @io_reactor.schedule_timer(timeout)
         timer.flat_map do
@@ -509,19 +561,20 @@ module Cassandra
 
         @logger.info("Refreshing host metadata: #{ip}")
 
-        if ip == connection.host
-          request = SELECT_LOCAL
-        else
-          request = Protocol::QueryRequest.new("SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = '%s'" % ip, EMPTY_LIST, EMPTY_LIST, :one)
-        end
+        request = if ip == connection.host
+                    SELECT_LOCAL
+                  else
+                    Protocol::QueryRequest.new(SELECT_PEER_QUERY % ip,
+                                               EMPTY_LIST,
+                                               EMPTY_LIST,
+                                               :one)
+                  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
@@ -568,9 +621,10 @@ Control connection failed and is unlikely to recover.
                   end
 
                   if cause
-                    @logger.info("Control connection closed (#{cause.class.name}: #{cause.message})")
+                    @logger.info('Control connection closed ' \
+                      "(#{cause.class.name}: #{cause.message})")
                   else
-                    @logger.info("Control connection closed")
+                    @logger.info('Control connection closed')
                   end
 
                   @connection = nil
@@ -587,7 +641,8 @@ Control connection failed and is unlikely to recover.
         f = f.flat_map { refresh_peers_async_maybe_retry }
         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})")
+          @logger.debug("Connection to #{host.ip} failed " \
+            "(#{error.class.name}: #{error.message})")
 
           case error
           when Errors::HostError, Errors::TimeoutError
@@ -599,8 +654,8 @@ Control connection failed and is unlikely to recover.
           end
         end
 
-        f.on_complete do |f|
-          @logger.info('Control connection established') if f.resolved?
+        f.on_complete do |connection_future|
+          @logger.info('Control connection established') if connection_future.resolved?
         end
 
         f
@@ -618,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)]>
@@ -631,18 +686,19 @@ Control connection failed and is unlikely to recover.
         schema_changes.each do |change|
           keyspace = change.keyspace
 
-          next if refresh_keyspaces.has_key?(keyspace)
+          next if refresh_keyspaces.key?(keyspace)
 
           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
@@ -661,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
 
@@ -675,13 +732,15 @@ Control connection failed and is unlikely to recover.
 
         refresh_functions.each do |(keyspace, function_changes)|
           function_changes.each do |change|
-            futures << refresh_maybe_retry(:function, keyspace, change.name, change.arguments)
+            futures <<
+              refresh_maybe_retry(:function, keyspace, change.name, change.arguments)
           end
         end
 
         refresh_aggregates.each do |(keyspace, aggregate_changes)|
           aggregate_changes.each do |change|
-            futures << refresh_maybe_retry(:aggregate, keyspace, change.name, change.arguments)
+            futures <<
+              refresh_maybe_retry(:aggregate, keyspace, change.name, change.arguments)
           end
         end
 
@@ -704,7 +763,8 @@ Control connection failed and is unlikely to recover.
 
       def refresh_retry(what, error, schedule, *args)
         timeout = schedule.next
-        @logger.info("Failed to refresh #{what} #{args.inspect} (#{error.class.name}: #{error.message}), retrying in #{timeout}")
+        @logger.info("Failed to refresh #{what} #{args.inspect} " \
+          "(#{error.class.name}: #{error.message}), retrying in #{timeout}")
 
         timer = @io_reactor.schedule_timer(timeout)
         timer.flat_map do
@@ -722,38 +782,105 @@ Control connection failed and is unlikely to recover.
         end
       end
 
-      def handle_schema_change(change)
-        timer = nil
-        expiration_timer = nil
-
+      def refresh_schema_async_wrapper
+        # This is kinda tricky. We want to start refreshing the schema asynchronously.
+        # However, if we're already in the process of doing so, return the future
+        # representing that result rather than starting another schema refresh.
+        #
+        # A few other nuances while a refresh is in progress:
+        # * if a new attempt is made to refresh, keep track of that and schedule another
+        #   refresh after the current one completes.
+        # * we don't want schema_change events to be processed since the full refresh
+        #   may overwrite the results of handling the schema_change events with older
+        #   data. That said, we don't want to lose track of schema_change events; just
+        #   delay processing them until after the full refresh is done.
+        #
+        # Finally, when a full refresh begins, clear out any pending changes in
+        # @schema_changes because the full refresh subsumes them. This has two benefits:
+        # 1. avoid round trips to Cassandra to get details related to those schema
+        #    changes.
+        # 2. avoid race conditions where those updates may return older data than our
+        #    full refresh and might win as last writer with that potentially older data.
         synchronize do
-          @schema_changes << change
+          if @refresh_schema_future
+            @pending_schema_refresh = true
+            return @refresh_schema_future
+          end
+
+          # Fresh refresh; prep this connection!
 
+          # Since we're starting a new refresh, there can be no pending refresh request.
+          @pending_schema_refresh = false
+
+          # Clear outstanding schema changes and timers.
+          @schema_changes = []
           @io_reactor.cancel_timer(@schema_refresh_timer) if @schema_refresh_timer
-          timer = @schema_refresh_timer = @io_reactor.schedule_timer(@connection_options.schema_refresh_delay)
+          @schema_refresh_timer = nil
+          @io_reactor.cancel_timer(@schema_refresh_window) if @schema_refresh_window
+          @schema_refresh_window = nil
+
+          # Start refreshing..
+          @refresh_schema_future = refresh_maybe_retry(:schema)
+          @refresh_schema_future.on_complete do
+            pending = false
+            synchronize do
+              # We're done refreshing. If we have a pending refresh, launch it now.
+              @refresh_schema_future = nil
+              pending = @pending_schema_refresh
+              @pending_schema_refresh = false
+              unless pending
+                # Restore timers if there are pending schema changes.
+                handle_schema_change(nil)
+              end
+            end
 
-          unless @schema_refresh_window
-            expiration_timer = @schema_refresh_window = @io_reactor.schedule_timer(@connection_options.schema_refresh_timeout)
+            refresh_schema_async_wrapper if pending
           end
+
+          # Return the (now cached) future
+          @refresh_schema_future
         end
+      end
 
-        if expiration_timer
-          expiration_timer.on_value do
-            schema_changes = nil
+      def handle_schema_change(change)
+        timer = nil
+        expiration_timer = nil
 
-            synchronize do
-              @io_reactor.cancel_timer(@schema_refresh_timer)
+        synchronize do
+          # If change is nil, it means we want to set up timers (if there are pending
+          # changes). Otherwise, we definitely have a change and want to set up timers.
+          # Also, we only want to set up timers if we're not in the middle of a full
+          # refresh.
+          @schema_changes << change if change
+
+          unless @schema_changes.empty? || @refresh_schema_future
+            @io_reactor.cancel_timer(@schema_refresh_timer) if @schema_refresh_timer
+            timer = @schema_refresh_timer =
+                      @io_reactor.schedule_timer(@connection_options.schema_refresh_delay)
+
+            unless @schema_refresh_window
+              @schema_refresh_window =
+                @io_reactor.schedule_timer(@connection_options.schema_refresh_timeout)
+              expiration_timer = @schema_refresh_window
+            end
+          end
+        end
 
-              @schema_refresh_window = nil
-              @schema_refresh_timer  = nil
+        expiration_timer.on_value do
+          schema_changes = nil
 
-              schema_changes  = @schema_changes
-              @schema_changes = ::Array.new
-            end
+          synchronize do
+            @io_reactor.cancel_timer(@schema_refresh_timer)
 
-            process_schema_changes(schema_changes)
+            @schema_refresh_window = nil
+            @schema_refresh_timer = nil
+
+            schema_changes = @schema_changes
+            @schema_changes = ::Array.new
           end
-        end
+
+          process_schema_changes(schema_changes)
+        end if expiration_timer
 
         timer.on_value do
           schema_changes = nil
@@ -762,14 +889,14 @@ Control connection failed and is unlikely to recover.
             @io_reactor.cancel_timer(@schema_refresh_window)
 
             @schema_refresh_window = nil
-            @schema_refresh_timer  = nil
+            @schema_refresh_timer = nil
 
-            schema_changes  = @schema_changes
+            schema_changes = @schema_changes
             @schema_changes = ::Array.new
           end
 
           process_schema_changes(schema_changes)
-        end
+        end if timer
 
         nil
       end