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

data/lib/cassandra/cluster/failed_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.

data/lib/cassandra/cluster/metadata.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -24,7 +24,11 @@ module Cassandra
 
       attr_reader :name
 
-      def initialize(cluster_registry, cluster_schema, schema_partitioners, replication_strategies, default_replication_strategy)
+      def initialize(cluster_registry,
+                     cluster_schema,
+                     schema_partitioners,
+                     replication_strategies,
+                     default_replication_strategy)
         @registry         = cluster_registry
         @schema           = cluster_schema
         @partitioners     = schema_partitioners
@@ -74,7 +78,11 @@ module Cassandra
 
         @registry.each_host do |host|
           host.tokens.each do |token|
-            token = partitioner.parse_token(token) rescue next
+            token = begin
+                      partitioner.parse_token(token)
+                    rescue
+                      next
+                    end
             tokens.add(token)
             token_to_host[token] = host
           end
@@ -116,7 +124,7 @@ module Cassandra
         min = 0
         max = list.size - 1
 
-        while min <= max do
+        while min <= max
           idx = (min + max) / 2
           val = list[idx]
 

data/lib/cassandra/cluster/options.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.
@@ -20,12 +20,31 @@ module Cassandra
   class Cluster
     # @private
     class Options
-      attr_reader :credentials, :auth_provider, :compressor, :port,
-                  :connect_timeout, :ssl, :heartbeat_interval, :idle_timeout,
-                  :schema_refresh_delay, :schema_refresh_timeout
+      attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
+                  :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
+                  :schema_refresh_timeout, :ssl
+
       attr_accessor :protocol_version
 
-      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout, synchronize_schema, schema_refresh_delay, schema_refresh_timeout, client_timestamps, nodelay)
+      def initialize(logger,
+                     protocol_version,
+                     credentials,
+                     auth_provider,
+                     compressor,
+                     port,
+                     connect_timeout,
+                     ssl,
+                     connections_per_local_node,
+                     connections_per_remote_node,
+                     heartbeat_interval,
+                     idle_timeout,
+                     synchronize_schema,
+                     schema_refresh_delay,
+                     schema_refresh_timeout,
+                     client_timestamps,
+                     nodelay,
+                     requests_per_connection)
+        @logger                 = logger
         @protocol_version       = protocol_version
         @credentials            = credentials
         @auth_provider          = auth_provider
@@ -43,6 +62,7 @@ module Cassandra
 
         @connections_per_local_node  = connections_per_local_node
         @connections_per_remote_node = connections_per_remote_node
+        @requests_per_connection = requests_per_connection
       end
 
       def synchronize_schema?
@@ -65,16 +85,45 @@ module Cassandra
         @auth_provider && @auth_provider.create_authenticator(authentication_class)
       end
 
-      # increased number of streams in native protocol v3 allow for one
-      # connections to be sufficient
       def connections_per_local_node
-        (@protocol_version > 2) ? 1 : @connections_per_local_node
+        # Return the option if set.
+        return @connections_per_local_node if @connections_per_local_node
+
+        # For v3 and later, default is 1 local connection.
+        # For v2 and earlier, default is 2 local connections.
+        # Return the default
+        (@protocol_version > 2) ? 1 : 2
       end
 
-      # increased number of streams in native protocol v3 allow for one
-      # connections to be sufficient
       def connections_per_remote_node
-        (@protocol_version > 2) ? 1 : @connections_per_remote_node
+        # Return the option if set; otherwise return the default (1).
+        @connections_per_remote_node || 1
+      end
+
+      def requests_per_connection
+        # There are a few possibilities here based on @requests_per_connection:
+        # nil: default to 1024 for protocol 3 and later, 128 for < 3.
+        # we're in v2 and value too high: return 128. We don't worry
+        #   about this case for v3+ because option validation in
+        #   Cassandra::cluster_async takes care of that.
+        # good value: return it.
+        #
+        # NOTE: We can't compute and cache the result because protocol_version
+        # can change over time in theory (if all nodes are upgraded to a new
+        # version of Cassandra)
+
+        # Return the default if option wasn't specified.
+        default_requests_per_connection = @protocol_version > 2 ? 1024 : 128
+        return default_requests_per_connection unless @requests_per_connection
+
+        if @requests_per_connection > 128 && @protocol_version < 3
+          @logger.warn(
+            ":requests_per_connection setting of #{@requests_per_connection} is more " \
+                'than the max of 128 for protocol v2. Falling back to 128.'
+          )
+          return 128
+        end
+        @requests_per_connection
       end
     end
   end

data/lib/cassandra/cluster/registry.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.
@@ -58,14 +58,14 @@ module Cassandra
           @hosts.values
         end
       end
-      alias :hosts :each_host
+      alias hosts each_host
 
       def host(address)
         @hosts[address.to_s]
       end
 
       def has_host?(address)
-        @hosts.has_key?(address.to_s)
+        @hosts.key?(address.to_s)
       end
 
       def host_found(address, data = {})
@@ -82,7 +82,8 @@ module Cassandra
 
             host = toggle_up(host)
           else
-            @logger.debug("Host #{host.ip} metadata has been updated, it will be considered lost and found")
+            @logger.debug("Host #{host.ip} metadata has been updated, it will be " \
+                'considered lost and found')
 
             notify_lost(host)
 
@@ -143,7 +144,7 @@ module Cassandra
         ip   = address.to_s
         host = nil
 
-        return self unless @hosts.has_key?(ip)
+        return self unless @hosts.key?(ip)
 
         synchronize do
           hosts  = @hosts.dup
@@ -159,23 +160,49 @@ module Cassandra
       private
 
       def create_host(ip, data)
-        Host.new(ip, data['host_id'], data['rack'], data['data_center'], data['release_version'], Array(data['tokens']).freeze, :up)
+        Host.new(ip,
+                 data['host_id'],
+                 data['rack'],
+                 data['data_center'],
+                 data['release_version'],
+                 Array(data['tokens']).freeze,
+                 :up)
       end
 
       def toggle_up(host)
-        host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :up)
+        host = Host.new(host.ip,
+                        host.id,
+                        host.rack,
+                        host.datacenter,
+                        host.release_version,
+                        host.tokens,
+                        :up)
         @logger.debug("Host #{host.ip} is up")
         @listeners.each do |listener|
-          listener.host_up(host) rescue nil
+          begin
+            listener.host_up(host)
+          rescue
+            nil
+          end
         end
         host
       end
 
       def toggle_down(host)
-        host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
+        host = Host.new(host.ip,
+                        host.id,
+                        host.rack,
+                        host.datacenter,
+                        host.release_version,
+                        host.tokens,
+                        :down)
         @logger.debug("Host #{host.ip} is down")
         @listeners.reverse_each do |listener|
-          listener.host_down(host) rescue nil
+          begin
+            listener.host_down(host)
+          rescue
+            nil
+          end
         end
         host
       end
@@ -183,15 +210,33 @@ module Cassandra
       def notify_lost(host)
         if host.up?
           @logger.debug("Host #{host.ip} is down and lost")
-          host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
+          host = Host.new(host.ip,
+                          host.id,
+                          host.rack,
+                          host.datacenter,
+                          host.release_version,
+                          host.tokens,
+                          :down)
           @listeners.reverse_each do |listener|
-            listener.host_down(host) rescue nil
-            listener.host_lost(host) rescue nil
+            begin
+              listener.host_down(host)
+            rescue
+              nil
+            end
+            begin
+              listener.host_lost(host)
+            rescue
+              nil
+            end
           end
         else
           @logger.debug("Host #{host.ip} is lost")
           @listeners.reverse_each do |listener|
-            listener.host_lost(host) rescue nil
+            begin
+              listener.host_lost(host)
+            rescue
+              nil
+            end
           end
         end
       end
@@ -199,8 +244,16 @@ module Cassandra
       def notify_found(host)
         @logger.debug("Host #{host.ip} is found and up")
         @listeners.each do |listener|
-          listener.host_found(host) rescue nil
-          listener.host_up(host) rescue nil
+          begin
+            listener.host_found(host)
+          rescue
+            nil
+          end
+          begin
+            listener.host_up(host)
+          rescue
+            nil
+          end
         end
       end
     end

data/lib/cassandra/cluster/schema.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.
@@ -32,7 +32,13 @@ module Cassandra
       def get_pk_idx(metadata)
         return EMPTY_LIST unless metadata
 
-        keyspace_name, table_name, _ = metadata.first
+        # metadata is an array of column-specs; each column-spec is an array
+        # of keyspace_name, tablename, other stuff. We only care about the first two.
+        # See read_prepared_metadata_v4 in coder.rb for more details.
+        # NB: sandman: I think all of the column specs have the same keyspace and
+        # table name in this context, so we can safely grab the first.
+
+        keyspace_name, table_name = metadata.first
         return EMPTY_LIST unless keyspace_name && table_name
 
         keyspace = @keyspaces[keyspace_name]
@@ -76,7 +82,7 @@ module Cassandra
           replace_keyspace(keyspace)
         end
 
-        @keyspaces.each do |name, keyspace|
+        @keyspaces.each do |name, _keyspace|
           delete_keyspace(name) unless current_keyspaces.include?(name)
         end
 
@@ -311,25 +317,37 @@ module Cassandra
           @keyspaces.values
         end
       end
-      alias :keyspaces :each_keyspace
+      alias keyspaces each_keyspace
 
       private
 
       def keyspace_created(keyspace)
         @listeners.each do |listener|
-          listener.keyspace_created(keyspace) rescue nil
+          begin
+            listener.keyspace_created(keyspace)
+          rescue
+            nil
+          end
         end
       end
 
       def keyspace_changed(keyspace)
         @listeners.each do |listener|
-          listener.keyspace_changed(keyspace) rescue nil
+          begin
+            listener.keyspace_changed(keyspace)
+          rescue
+            nil
+          end
         end
       end
 
       def keyspace_dropped(keyspace)
         @listeners.each do |listener|
-          listener.keyspace_dropped(keyspace) rescue nil
+          begin
+            listener.keyspace_dropped(keyspace)
+          rescue
+            nil
+          end
         end
       end
     end

data/lib/cassandra/cluster/schema/cql_type_parser.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -40,9 +40,7 @@ module Cassandra
         private
 
         def lookup_type(node, types)
-          if node.name == 'frozen'
-            return lookup_type(node.children.first, types)
-          end
+          return lookup_type(node.children.first, types) if node.name == 'frozen'
 
           case node.name
           when 'text'              then Cassandra::Types.text
@@ -64,13 +62,20 @@ module Cassandra
           when 'smallint'          then Cassandra::Types.smallint
           when 'time'              then Cassandra::Types.time
           when 'tinyint'           then Cassandra::Types.tinyint
-          when 'map'               then Cassandra::Types.map(*node.children.map { |t| lookup_type(t, types)})
-          when 'set'               then Cassandra::Types.set(lookup_type(node.children.first, types))
-          when 'list'              then Cassandra::Types.list(lookup_type(node.children.first, types))
-          when 'tuple'             then Cassandra::Types.tuple(*node.children.map { |t| lookup_type(t, types)})
-          when 'empty'             then Cassandra::Types.custom('org.apache.cassandra.db.marshal.EmptyType')
+          when 'map'               then
+            Cassandra::Types.map(*node.children.map { |t| lookup_type(t, types)})
+          when 'set'               then
+            Cassandra::Types.set(lookup_type(node.children.first, types))
+          when 'list'              then
+            Cassandra::Types.list(lookup_type(node.children.first, types))
+          when 'tuple'             then
+            Cassandra::Types.tuple(*node.children.map { |t| lookup_type(t, types)})
+          when 'empty'             then
+            Cassandra::Types.custom('org.apache.cassandra.db.marshal.EmptyType')
           else
-            types.fetch(node.name) { raise IncompleteTypeError, "unable to lookup type #{node.name.inspect}" }
+            types.fetch(node.name) do
+              raise IncompleteTypeError, "unable to lookup type #{node.name.inspect}"
+            end
           end
         end
 

data/lib/cassandra/cluster/schema/fetchers.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.
@@ -100,7 +100,8 @@ module Cassandra
         end
 
         def fetch_function(connection, keyspace_name, function_name, function_args)
-          select_function(connection, keyspace_name, function_name, function_args).map do |rows_functions|
+          select_function(connection, keyspace_name, function_name, function_args).
+              map do |rows_functions|
             if rows_functions.empty?
               nil
             else
@@ -110,11 +111,13 @@ module Cassandra
         end
 
         def fetch_aggregate(connection, keyspace_name, aggregate_name, aggregate_args)
-          select_aggregate(connection, keyspace_name, aggregate_name, aggregate_args).map do |rows_aggregates|
+          select_aggregate(connection, keyspace_name, aggregate_name, aggregate_args).
+              map do |rows_aggregates|
             if rows_aggregates.empty?
               nil
             else
-              create_aggregate(rows_aggregates.first, @schema.keyspace(keyspace_name).send(:raw_functions))
+              create_aggregate(rows_aggregates.first, @schema.keyspace(keyspace_name).
+                  send(:raw_functions))
             end
           end
         end
@@ -191,7 +194,8 @@ module Cassandra
 
         def send_select_request(connection, cql, params = EMPTY_LIST, types = EMPTY_LIST)
           backtrace = caller
-          connection.send_request(Protocol::QueryRequest.new(cql, params, types, :one)).map do |r|
+          connection.send_request(
+              Protocol::QueryRequest.new(cql, params, types, :one)).map do |r|
             case r
             when Protocol::RowsResultResponse
               r.rows
@@ -225,11 +229,24 @@ module Cassandra
           SELECT_KEYSPACES        = 'SELECT * FROM system.schema_keyspaces'.freeze
           SELECT_TABLES           = 'SELECT * FROM system.schema_columnfamilies'.freeze
           SELECT_COLUMNS          = 'SELECT * FROM system.schema_columns'.freeze
-          SELECT_KEYSPACE         = 'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = \'%s\''.freeze
-          SELECT_KEYSPACE_TABLES  = 'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = \'%s\''.freeze
-          SELECT_KEYSPACE_COLUMNS = 'SELECT * FROM system.schema_columns WHERE keyspace_name = \'%s\''.freeze
-          SELECT_TABLE            = 'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = \'%s\' AND columnfamily_name = \'%s\''.freeze
-          SELECT_TABLE_COLUMNS    = 'SELECT * FROM system.schema_columns WHERE keyspace_name = \'%s\' AND columnfamily_name = \'%s\''.freeze
+          SELECT_KEYSPACE         =
+              'SELECT * ' \
+              'FROM system.schema_keyspaces ' \
+              'WHERE keyspace_name = \'%s\''.freeze
+          SELECT_KEYSPACE_TABLES  =
+              'SELECT * ' \
+              'FROM system.schema_columnfamilies ' \
+              'WHERE keyspace_name = \'%s\''.freeze
+          SELECT_KEYSPACE_COLUMNS =
+              'SELECT * FROM system.schema_columns WHERE keyspace_name = \'%s\''.freeze
+          SELECT_TABLE            =
+              'SELECT * ' \
+              'FROM system.schema_columnfamilies ' \
+              'WHERE keyspace_name = \'%s\' AND columnfamily_name = \'%s\''.freeze
+          SELECT_TABLE_COLUMNS    =
+              'SELECT * ' \
+              'FROM system.schema_columns ' \
+              'WHERE keyspace_name = \'%s\' AND columnfamily_name = \'%s\''.freeze
 
           include Fetcher
 
@@ -269,7 +286,8 @@ module Cassandra
           end
 
           def select_table_columns(connection, keyspace_name, table_name)
-            send_select_request(connection, SELECT_TABLE_COLUMNS % [keyspace_name, table_name])
+            send_select_request(connection,
+                                SELECT_TABLE_COLUMNS % [keyspace_name, table_name])
           end
 
           def create_replication(keyspace_data)
@@ -287,18 +305,16 @@ module Cassandra
                       types[row['type_name']] = create_type(row)
                     end
 
-            # We want the functions hash to be keyed on [name, arg-types-list].
-            # Similarly for the aggregates hash.
-
-            functions = rows_functions.each_with_object({}) do |row, collector|
-                          func = create_function(row)
-                          collector[[func.name, func.argument_types]] = func
+            # Create a FunctionCollection for the functions and aggregates.
+            functions = Cassandra::FunctionCollection.new
+            rows_functions.each do |row|
+              functions.add_or_update(create_function(row))
             end
 
-            aggregates = rows_aggregates.each_with_object({}) do |row, collector|
-                           agg = create_aggregate(row, functions)
-                           collector[[agg.name, agg.argument_types]] = agg
-                         end
+            aggregates = Cassandra::FunctionCollection.new
+            rows_aggregates.each do |row|
+              aggregates.add_or_update(create_aggregate(row, functions))
+            end
 
             lookup_columns = map_rows_by(rows_columns, 'columnfamily_name')
             tables = rows_tables.each_with_object({}) do |row, tables|
@@ -306,8 +322,13 @@ module Cassandra
               tables[table_name] = create_table(row, lookup_columns[table_name])
             end
 
-            Keyspace.new(keyspace_name, keyspace_data['durable_writes'],
-                         replication, tables, types, functions, aggregates)
+            Keyspace.new(keyspace_name,
+                         keyspace_data['durable_writes'],
+                         replication,
+                         tables,
+                         types,
+                         functions,
+                         aggregates)
           end
 
           def create_table(table_data, rows_columns)
@@ -323,7 +344,8 @@ module Cassandra
                 is_compact = false
                 has_value  = false
                 clustering_size = size - 2
-              elsif column_aliases.size == size - 1 && comparator.results.last.first == Cassandra::Types.varchar
+              elsif column_aliases.size == size - 1 &&
+                  comparator.results.last.first == Cassandra::Types.varchar
                 is_compact = false
                 has_value  = false
                 clustering_size = size - 1
@@ -348,7 +370,8 @@ module Cassandra
             clustering_order   = []
 
             compaction_strategy = create_compaction_strategy(table_data)
-            table_options = create_table_options(table_data, compaction_strategy, is_compact)
+            table_options =
+                create_table_options(table_data, compaction_strategy, is_compact)
             table_columns = {}
             other_columns = []
 
@@ -364,7 +387,8 @@ module Cassandra
               column_alias = column_aliases.fetch(i) { "column#{i + 1}" }
               type, order, is_frozen = comparator.results.fetch(i)
 
-              clustering_columns[i] = Column.new(column_alias, type, order, nil, false, is_frozen)
+              clustering_columns[i] =
+                  Column.new(column_alias, type, order, nil, false, is_frozen)
               clustering_order[i]   = order
             end
 
@@ -373,8 +397,10 @@ module Cassandra
               value_alias ||= 'value'
 
               unless value_alias.empty?
-                type, order, is_frozen = @type_parser.parse(table_data['default_validator']).results.first
-                other_columns << Column.new(value_alias, type, order, nil, false, is_frozen)
+                type, order, is_frozen =
+                    @type_parser.parse(table_data['default_validator']).results.first
+                other_columns <<
+                    Column.new(value_alias, type, order, nil, false, is_frozen)
               end
             end
 
@@ -394,22 +420,30 @@ module Cassandra
               table_columns[column.name] = column
             end
 
-            Table.new(keyspace_name, table_name, partition_key, clustering_columns,
-                      table_columns, table_options, clustering_order)
+            Table.new(keyspace_name,
+                      table_name,
+                      partition_key,
+                      clustering_columns,
+                      table_columns,
+                      table_options,
+                      clustering_order)
           end
 
           def create_column(column_data)
             name      = column_data['column_name']
             is_static = (column_data['type'] == 'STATIC')
-            type, order, is_frozen = @type_parser.parse(column_data['validator']).results.first
+            type, order, is_frozen =
+                @type_parser.parse(column_data['validator']).results.first
 
             if column_data['index_type'].nil?
               index = nil
-            elsif column_data['index_type'].to_s.upcase == 'CUSTOM' || !column_data['index_options']
+            elsif column_data['index_type'].to_s.upcase == 'CUSTOM' ||
+                !column_data['index_options']
               index = Column::Index.new(column_data['index_name'])
             else
               options = ::JSON.load(column_data['index_options'])
-              index   = Column::Index.new(column_data['index_name'], options && options['class_name'])
+              index   = Column::Index.new(column_data['index_name'],
+                                          options && options['class_name'])
             end
 
             Column.new(name, type, order, index, is_static, is_frozen)
@@ -424,7 +458,10 @@ module Cassandra
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
-            compression_parameters['sstable_compression'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression_parameters['sstable_compression']
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression'].
+                  slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
             Table::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
@@ -448,11 +485,20 @@ module Cassandra
         end
 
         class V2_0_x < V1_2_x
-          SELECT_KEYSPACE           = 'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_TABLES    = 'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_COLUMNS   = 'SELECT * FROM system.schema_columns WHERE keyspace_name = ?'.freeze
-          SELECT_TABLE              = 'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
-          SELECT_TABLE_COLUMNS      = 'SELECT * FROM system.schema_columns WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
+          SELECT_KEYSPACE           =
+              'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_TABLES    =
+              'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_COLUMNS   =
+              'SELECT * FROM system.schema_columns WHERE keyspace_name = ?'.freeze
+          SELECT_TABLE              =
+              'SELECT * ' \
+              'FROM system.schema_columnfamilies ' \
+              'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
+          SELECT_TABLE_COLUMNS      =
+              'SELECT * ' \
+              'FROM system.schema_columns ' \
+              'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
 
           private
 
@@ -503,11 +549,18 @@ module Cassandra
             end
 
             compaction_strategy = create_compaction_strategy(table_data)
-            is_compact    = (clustering_size != comparator.results.size - 1) || !comparator.collections
-            table_options = create_table_options(table_data, compaction_strategy, is_compact)
+            is_compact    = (clustering_size != comparator.results.size - 1) ||
+                !comparator.collections
+            table_options =
+                create_table_options(table_data, compaction_strategy, is_compact)
 
-            Table.new(keyspace_name, table_name, partition_key, clustering_columns,
-                      table_columns, table_options, clustering_order)
+            Table.new(keyspace_name,
+                      table_name,
+                      partition_key,
+                      clustering_columns,
+                      table_columns,
+                      table_options,
+                      clustering_order)
           end
 
           def select_keyspace(connection, keyspace_name)
@@ -542,7 +595,10 @@ module Cassandra
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
-            compression_parameters['sstable_compression'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression_parameters['sstable_compression']
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression'].
+                  slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
             Table::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
@@ -567,8 +623,12 @@ module Cassandra
 
         class V2_1_x < V2_0_x
           SELECT_TYPES          = 'SELECT * FROM system.schema_usertypes'.freeze
-          SELECT_KEYSPACE_TYPES = 'SELECT * FROM system.schema_usertypes WHERE keyspace_name = ?'.freeze
-          SELECT_TYPE           = 'SELECT * FROM system.schema_usertypes WHERE keyspace_name = ? AND type_name = ?'.freeze
+          SELECT_KEYSPACE_TYPES =
+              'SELECT * FROM system.schema_usertypes WHERE keyspace_name = ?'.freeze
+          SELECT_TYPE           =
+              'SELECT * ' \
+              'FROM system.schema_usertypes ' \
+              'WHERE keyspace_name = ? AND type_name = ?'.freeze
 
           private
 
@@ -607,7 +667,10 @@ module Cassandra
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
-            compression_parameters['sstable_compression'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression_parameters['sstable_compression']
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression'].
+                  slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
             Table::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
@@ -633,12 +696,23 @@ module Cassandra
         class V2_2_x < V2_1_x
           SELECT_FUNCTIONS           = 'SELECT * FROM system.schema_functions'.freeze
           SELECT_AGGREGATES          = 'SELECT * FROM system.schema_aggregates'.freeze
-          SELECT_KEYSPACE_FUNCTIONS  = 'SELECT * FROM system.schema_functions WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_AGGREGATES = 'SELECT * FROM system.schema_aggregates WHERE keyspace_name = ?'.freeze
-          SELECT_FUNCTION            = 'SELECT * FROM system.schema_functions WHERE keyspace_name = ? AND function_name = ? AND argument_types = ?'.freeze
-          SELECT_AGGREGATE           = 'SELECT * FROM system.schema_aggregates WHERE keyspace_name = ? AND aggregate_name = ? AND argument_types = ?'.freeze
-
-          # parse an array of string argument types and return an array of [Cassandra::Type]s.
+          SELECT_KEYSPACE_FUNCTIONS  =
+              'SELECT * FROM system.schema_functions WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_AGGREGATES =
+              'SELECT * FROM system.schema_aggregates WHERE keyspace_name = ?'.freeze
+          SELECT_FUNCTION            =
+              'SELECT * ' \
+              'FROM system.schema_functions ' \
+              'WHERE keyspace_name = ? AND function_name = ? ' \
+              'AND argument_types = ?'.freeze
+          SELECT_AGGREGATE           =
+              'SELECT * ' \
+              'FROM system.schema_aggregates ' \
+              'WHERE keyspace_name = ? AND aggregate_name = ? ' \
+              'AND argument_types = ?'.freeze
+
+          # parse an array of string argument types and return an array of
+          # [Cassandra::Type]s.
           # @param connection a connection to a Cassandra node.
           # @param keyspace_name [String] name of the keyspace.
           # @param argument_types [Array<String>] array of argument types.
@@ -655,35 +729,59 @@ module Cassandra
             keyspace_name  = function_data['keyspace_name']
             function_name  = function_data['function_name']
             function_lang  = function_data['language']
-            function_type  = @type_parser.parse(function_data['return_type']).results.first.first
+            function_type  =
+                @type_parser.parse(function_data['return_type']).results.first.first
             function_body  = function_data['body']
             called_on_null = function_data['called_on_null_input']
 
             arguments = []
 
-            Array(function_data['argument_names']).zip(Array(function_data['argument_types'])) do |argument_name, fqcn|
+            Array(function_data['argument_names']).
+                zip(Array(function_data['argument_types'])) do |argument_name, fqcn|
               argument_type = @type_parser.parse(fqcn).results.first.first
               arguments << Argument.new(argument_name, argument_type)
             end
 
-            Function.new(keyspace_name, function_name, function_lang, function_type, arguments, function_body, called_on_null)
+            Function.new(keyspace_name,
+                         function_name,
+                         function_lang,
+                         function_type,
+                         arguments,
+                         function_body,
+                         called_on_null)
           end
 
           def create_aggregate(aggregate_data, functions)
             keyspace_name  = aggregate_data['keyspace_name']
             aggregate_name = aggregate_data['aggregate_name']
-            aggregate_type = @type_parser.parse(aggregate_data['return_type']).results.first.first
-            argument_types = aggregate_data['argument_types'].map {|fqcn| @type_parser.parse(fqcn).results.first.first}.freeze
-            state_type     = @type_parser.parse(aggregate_data['state_type']).results.first.first
-            initial_state  = Util.encode_object(Protocol::Coder.read_value_v4(Protocol::CqlByteBuffer.new.append_bytes(aggregate_data['initcond']), state_type))
+            aggregate_type =
+                @type_parser.parse(aggregate_data['return_type']).results.first.first
+            argument_types = aggregate_data['argument_types'].map do |fqcn|
+              @type_parser.parse(fqcn).results.first.first
+            end.freeze
+            state_type     =
+                @type_parser.parse(aggregate_data['state_type']).results.first.first
+            initial_state  = Util.encode_object(
+                Protocol::Coder.read_value_v4(
+                    Protocol::CqlByteBuffer.new.append_bytes(aggregate_data['initcond']),
+                    state_type))
 
             # The state-function takes arguments: first the stype, then the args of the aggregate.
-            state_function = functions[[aggregate_data['state_func'], [state_type].concat(argument_types)]]
+            state_function = functions.get(aggregate_data['state_func'],
+                                           [state_type].concat(argument_types))
 
             # The final-function takes an stype argument.
-            final_function = functions[[aggregate_data['final_func'], [state_type]]]
+            final_function = functions.get(aggregate_data['final_func'],
+                                           [state_type])
 
-            Aggregate.new(keyspace_name, aggregate_name, aggregate_type, argument_types, state_type, initial_state, state_function, final_function)
+            Aggregate.new(keyspace_name,
+                          aggregate_name,
+                          aggregate_type,
+                          argument_types,
+                          state_type,
+                          initial_state,
+                          state_function,
+                          final_function)
           end
 
           def select_functions(connection)
@@ -729,23 +827,47 @@ module Cassandra
           SELECT_INDEXES    = "SELECT * FROM system_schema.indexes".freeze
           SELECT_VIEWS      = "SELECT * FROM system_schema.materialized_views".freeze
 
-          SELECT_KEYSPACE            = 'SELECT * FROM system_schema.keyspaces WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_TABLES     = 'SELECT * FROM system_schema.tables WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_COLUMNS    = 'SELECT * FROM system_schema.columns WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_TYPES      = "SELECT * FROM system_schema.types WHERE keyspace_name = ?".freeze
-          SELECT_KEYSPACE_FUNCTIONS  = 'SELECT * FROM system_schema.functions WHERE keyspace_name = ?'.freeze
-          SELECT_KEYSPACE_AGGREGATES = 'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ?'.freeze
-
-          SELECT_TABLE         = 'SELECT * FROM system_schema.tables WHERE keyspace_name = ? AND table_name = ?'.freeze
-          SELECT_TABLE_COLUMNS = 'SELECT * FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ?'.freeze
-
-          SELECT_TYPE = 'SELECT * FROM system_schema.types WHERE keyspace_name = ? AND type_name = ?'.freeze
-
-          SELECT_FUNCTION = 'SELECT * FROM system_schema.functions WHERE keyspace_name = ? AND function_name = ? AND argument_types = ?'.freeze
-
-          SELECT_AGGREGATE = 'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ? AND aggregate_name = ? AND argument_types = ?'.freeze
-
-          # parse an array of string argument types and return an array of [Cassandra::Type]s.
+          SELECT_KEYSPACE            =
+              'SELECT * FROM system_schema.keyspaces WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_TABLES     =
+              'SELECT * FROM system_schema.tables WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_COLUMNS    =
+              'SELECT * FROM system_schema.columns WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_TYPES      =
+              "SELECT * FROM system_schema.types WHERE keyspace_name = ?".freeze
+          SELECT_KEYSPACE_FUNCTIONS  =
+              'SELECT * FROM system_schema.functions WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_AGGREGATES =
+              'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ?'.freeze
+
+          SELECT_TABLE         =
+              'SELECT * ' \
+              'FROM system_schema.tables ' \
+              'WHERE keyspace_name = ? AND table_name = ?'.freeze
+          SELECT_TABLE_COLUMNS =
+              'SELECT * ' \
+              'FROM system_schema.columns ' \
+              'WHERE keyspace_name = ? AND table_name = ?'.freeze
+
+          SELECT_TYPE =
+              'SELECT * ' \
+              'FROM system_schema.types ' \
+              'WHERE keyspace_name = ? AND type_name = ?'.freeze
+
+          SELECT_FUNCTION =
+              'SELECT * ' \
+              'FROM system_schema.functions ' \
+              'WHERE keyspace_name = ? AND function_name = ? ' \
+              'AND argument_types = ?'.freeze
+
+          SELECT_AGGREGATE =
+              'SELECT * ' \
+              'FROM system_schema.aggregates ' \
+              'WHERE keyspace_name = ? AND aggregate_name = ? ' \
+              'AND argument_types = ?'.freeze
+
+          # parse an array of string argument types and return an array of
+          # [Cassandra::Type]s.
           # @param connection a connection to a Cassandra node.
           # @param keyspace_name [String] name of the keyspace.
           # @param argument_types [Array<String>] array of argument types.
@@ -860,29 +982,50 @@ module Cassandra
 
             arguments = []
 
-            function_data['argument_names'].zip(function_data['argument_types']) do |argument_name, argument_type|
-              arguments << Argument.new(argument_name, @type_parser.parse(argument_type, types).first)
+            function_data['argument_names'].
+                zip(function_data['argument_types']) do |argument_name, argument_type|
+              arguments << Argument.new(argument_name,
+                                        @type_parser.parse(argument_type, types).first)
             end
 
-            Function.new(keyspace_name, function_name, function_lang, function_type, arguments, function_body, called_on_null)
+            Function.new(keyspace_name,
+                         function_name,
+                         function_lang,
+                         function_type,
+                         arguments,
+                         function_body,
+                         called_on_null)
           end
 
           def create_aggregate(aggregate_data, functions, types = nil)
             keyspace_name  = aggregate_data['keyspace_name']
             aggregate_name = aggregate_data['aggregate_name']
             types        ||= @schema.keyspace(keyspace_name).send(:raw_types)
-            aggregate_type = @type_parser.parse(aggregate_data['return_type'], types).first
-            argument_types = aggregate_data['argument_types'].map {|argument_type| @type_parser.parse(argument_type, types).first}.freeze
+            aggregate_type =
+                @type_parser.parse(aggregate_data['return_type'], types).first
+            argument_types = aggregate_data['argument_types'].map do |argument_type|
+              @type_parser.parse(argument_type, types).first
+            end.freeze
             state_type     = @type_parser.parse(aggregate_data['state_type'], types).first
             initial_state  = aggregate_data['initcond'] || 'null'
 
-            # The state-function takes arguments: first the stype, then the args of the aggregate.
-            state_function = functions[[aggregate_data['state_func'], [state_type].concat(argument_types)]]
+            # The state-function takes arguments: first the stype, then the args of the
+            # aggregate.
+            state_function = functions.get(aggregate_data['state_func'],
+                                           [state_type].concat(argument_types))
 
             # The final-function takes an stype argument.
-            final_function = functions[[aggregate_data['final_func'], [state_type]]]
+            final_function = functions.get(aggregate_data['final_func'],
+                                           [state_type])
 
-            Aggregate.new(keyspace_name, aggregate_name, aggregate_type, argument_types, state_type, initial_state, state_function, final_function)
+            Aggregate.new(keyspace_name,
+                          aggregate_name,
+                          aggregate_type,
+                          argument_types,
+                          state_type,
+                          initial_state,
+                          state_function,
+                          final_function)
           end
 
           def create_types(rows_types, types)
@@ -930,17 +1073,15 @@ module Cassandra
             types = ::Hash.new
             create_types(rows_types, types)
 
-            # We want the functions hash to be keyed on [name, arg-types-list].
-            # Similarly for the aggregates hash.
-
-            functions = rows_functions.each_with_object({}) do |row, collector|
-              func = create_function(row, types)
-              collector[[func.name, func.argument_types]] = func
+            # Create a FunctionCollection for the functions and aggregates.
+            functions = Cassandra::FunctionCollection.new
+            rows_functions.each do |row|
+              functions.add_or_update(create_function(row, types))
             end
 
-            aggregates = rows_aggregates.each_with_object({}) do |row, collector|
-              agg = create_aggregate(row, functions, types)
-              collector[[agg.name, agg.argument_types]] = agg
+            aggregates = Cassandra::FunctionCollection.new
+            rows_aggregates.each do |row|
+              aggregates.add_or_update(create_aggregate(row, functions, types))
             end
 
             lookup_columns = map_rows_by(rows_columns, 'table_name')
@@ -949,8 +1090,13 @@ module Cassandra
               tables[table_name] = create_table(row, lookup_columns[table_name], types)
             end
 
-            Keyspace.new(keyspace_name, keyspace_data['durable_writes'],
-                         replication, tables, types, functions, aggregates)
+            Keyspace.new(keyspace_name,
+                         keyspace_data['durable_writes'],
+                         replication,
+                         tables,
+                         types,
+                         functions,
+                         aggregates)
           end
 
           def create_replication(keyspace_data)
@@ -969,7 +1115,9 @@ module Cassandra
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression = table_data['compression']
-            compression['class'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression['class']
+            if compression['class']
+              compression['class'].slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
 
             Table::Options.new(
               table_data['comment'],
@@ -1054,10 +1202,16 @@ module Cassandra
             end
 
             compaction_strategy = create_compaction_strategy(table_data)
-            table_options = create_table_options(table_data, compaction_strategy, is_compact)
+            table_options =
+                create_table_options(table_data, compaction_strategy, is_compact)
 
-            Table.new(keyspace_name, table_name, partition_key, clustering_columns,
-                      table_columns, table_options, clustering_order)
+            Table.new(keyspace_name,
+                      table_name,
+                      partition_key,
+                      clustering_columns,
+                      table_columns,
+                      table_options,
+                      clustering_order)
           end
         end
 
@@ -1130,13 +1284,16 @@ module Cassandra
             return Ione::Future.failed(e)
           end
 
-          # parse an array of string argument types and return an array of [Cassandra::Type]s.
+          # parse an array of string argument types and return an array of
+          # [Cassandra::Type]s.
           # @param connection a connection to a Cassandra node.
           # @param keyspace_name [String] name of the keyspace.
           # @param argument_types [Array<String>] array of argument types.
           # @return [Array<Cassandra::Type>] array of parsed types.
           def parse_argument_types(connection, keyspace_name, argument_types)
-            find_fetcher(connection).parse_argument_types(connection, keyspace_name, argument_types)
+            find_fetcher(connection).parse_argument_types(connection,
+                                                          keyspace_name,
+                                                          argument_types)
           end
 
           private