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

data/lib/cassandra/cluster/metadata.rb

@@ -39,9 +39,7 @@ module Cassandra
       end
 
       def find_replicas(keyspace, statement)
-        unless statement.respond_to?(:partition_key) && statement.respond_to?(:keyspace)
-          return EMPTY_LIST
-        end
+        return EMPTY_LIST unless statement.respond_to?(:partition_key) && statement.respond_to?(:keyspace)
 
         keyspace      = String(statement.keyspace || keyspace)
         partition_key = statement.partition_key

data/lib/cassandra/cluster/options.rb

@@ -20,9 +20,12 @@ module Cassandra
   class Cluster
     # @private
     class Options
+      extend AttrBoolean
+
       attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
                   :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
                   :schema_refresh_timeout, :ssl
+      attr_boolean :protocol_negotiable, :synchronize_schema, :client_timestamps, :nodelay
 
       attr_accessor :protocol_version
 
@@ -63,18 +66,14 @@ 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?
-        @synchronize_schema
-      end
-
-      def client_timestamps?
-        @client_timestamps
-      end
+        # If @protocol_version is nil, it means we want the driver to negotiate the
+        # protocol starting with our known max (4). If @protocol_version is not nil,
+        # it means the user wants us to use a particular version, so we should not
+        # support negotiation.
 
-      def nodelay?
-        @nodelay
+        @protocol_negotiable = @protocol_version.nil?
+        @protocol_version ||= 4
       end
 
       def compression

data/lib/cassandra/cluster/registry.rb

@@ -76,7 +76,9 @@ module Cassandra
           if host.id              == data['host_id']         &&
              host.release_version == data['release_version'] &&
              host.rack            == data['rack']            &&
-             host.datacenter      == data['data_center']
+             host.datacenter      == data['data_center']     &&
+             host.broadcast_address == data['broadcast_address'] &&
+             host.listen_address == data['listen_address']
 
             return self if host.up?
 
@@ -166,7 +168,10 @@ module Cassandra
                  data['data_center'],
                  data['release_version'],
                  Array(data['tokens']).freeze,
-                 :up)
+                 :up,
+                 data['broadcast_address'],
+                 data['listen_address']
+                )
       end
 
       def toggle_up(host)
@@ -176,7 +181,9 @@ module Cassandra
                         host.datacenter,
                         host.release_version,
                         host.tokens,
-                        :up)
+                        :up,
+                        host.broadcast_address,
+                        host.listen_address)
         @logger.debug("Host #{host.ip} is up")
         @listeners.each do |listener|
           begin
@@ -195,7 +202,9 @@ module Cassandra
                         host.datacenter,
                         host.release_version,
                         host.tokens,
-                        :down)
+                        :down,
+                        host.broadcast_address,
+                        host.listen_address)
         @logger.debug("Host #{host.ip} is down")
         @listeners.reverse_each do |listener|
           begin
@@ -216,7 +225,9 @@ module Cassandra
                           host.datacenter,
                           host.release_version,
                           host.tokens,
-                          :down)
+                          :down,
+                          host.broadcast_address,
+                          host.listen_address)
           @listeners.reverse_each do |listener|
             begin
               listener.host_down(host)

data/lib/cassandra/cluster/schema.rb

@@ -126,7 +126,7 @@ module Cassandra
       end
 
       def replace_table(table)
-        keyspace = @keyspaces[table.keyspace]
+        keyspace = table.keyspace
 
         return self unless keyspace
 
@@ -169,6 +169,50 @@ module Cassandra
         self
       end
 
+      def replace_materialized_view(view)
+        keyspace = view.keyspace
+
+        return self unless keyspace
+
+        old_view = keyspace.materialized_view(view.name)
+
+        return self if old_view == view
+
+        keyspace = keyspace.update_materialized_view(view)
+
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace.name] = keyspace
+          @keyspaces = keyspaces
+        end
+
+        keyspace_changed(keyspace)
+
+        self
+      end
+
+      def delete_materialized_view(keyspace_name, view_name)
+        keyspace = @keyspaces[keyspace_name]
+
+        return self unless keyspace
+
+        view = keyspace.materialized_view(view_name)
+
+        return self unless view
+
+        keyspace = keyspace.delete_materialized_view(view_name)
+
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace_name] = keyspace
+          @keyspaces = keyspaces
+        end
+
+        keyspace_changed(keyspace)
+
+        self
+      end
+
       def replace_type(type)
         keyspace = @keyspaces[type.keyspace]
 

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

@@ -26,20 +26,23 @@ module Cassandra
         COMPRESSION_PACKAGE_PREFIX = 'org.apache.cassandra.io.compress.'.freeze
 
         def fetch(connection)
+          # rubocop:disable Metrics/LineLength
           Ione::Future.all(select_keyspaces(connection),
                            select_tables(connection),
                            select_columns(connection),
                            select_types(connection),
                            select_functions(connection),
-                           select_aggregates(connection))
-                      .map do |(rows_keyspaces, rows_tables, rows_columns,
-                                rows_types, rows_functions, rows_aggregates)|
-
+                           select_aggregates(connection),
+                           select_materialized_views(connection),
+                           select_indexes(connection))
+                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes|
                         lookup_tables     = map_rows_by(rows_tables, 'keyspace_name')
                         lookup_columns    = map_rows_by(rows_columns, 'keyspace_name')
                         lookup_types      = map_rows_by(rows_types, 'keyspace_name')
                         lookup_functions  = map_rows_by(rows_functions, 'keyspace_name')
                         lookup_aggregates = map_rows_by(rows_aggregates, 'keyspace_name')
+                        lookup_views      = map_rows_by(rows_views, 'keyspace_name')
+                        lookup_indexes    = map_rows_by(rows_indexes, 'keyspace_name')
 
                         rows_keyspaces.map do |keyspace_data|
                           name = keyspace_data['keyspace_name']
@@ -49,7 +52,9 @@ module Cassandra
                                           lookup_columns[name],
                                           lookup_types[name],
                                           lookup_functions[name],
-                                          lookup_aggregates[name])
+                                          lookup_aggregates[name],
+                                          lookup_views[name],
+                                          lookup_indexes[name])
                         end
                       end
         end
@@ -60,9 +65,10 @@ module Cassandra
                            select_keyspace_columns(connection, keyspace_name),
                            select_keyspace_types(connection, keyspace_name),
                            select_keyspace_functions(connection, keyspace_name),
-                           select_keyspace_aggregates(connection, keyspace_name))
-                      .map do |(rows_keyspaces, rows_tables, rows_columns,
-                                rows_types, rows_functions, rows_aggregates)|
+                           select_keyspace_aggregates(connection, keyspace_name),
+                           select_keyspace_materialized_views(connection, keyspace_name),
+                           select_keyspace_indexes(connection, keyspace_name))
+                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes|
                         if rows_keyspaces.empty?
                           nil
                         else
@@ -71,20 +77,40 @@ module Cassandra
                                           rows_columns,
                                           rows_types,
                                           rows_functions,
-                                          rows_aggregates)
+                                          rows_aggregates,
+                                          rows_views,
+                                          rows_indexes)
                         end
                       end
         end
 
         def fetch_table(connection, keyspace_name, table_name)
           Ione::Future.all(select_table(connection, keyspace_name, table_name),
-                           select_table_columns(connection, keyspace_name, table_name))
-                      .map do |(rows_tables, rows_columns)|
+                           select_table_columns(connection, keyspace_name, table_name),
+                           select_table_indexes(connection, keyspace_name, table_name))
+                      .map do |(rows_tables, rows_columns, rows_indexes)|
             if rows_tables.empty?
               nil
             else
               create_table(rows_tables.first,
-                           rows_columns)
+                           rows_columns,
+                           rows_indexes)
+            end
+          end
+        end
+
+        def fetch_materialized_view(connection, keyspace_name, view_name)
+          Ione::Future.all(select_materialized_view(connection, keyspace_name, view_name),
+                           select_table_columns(connection, keyspace_name, view_name))
+                      .map do |rows_views, rows_columns|
+            if rows_views.empty?
+              nil
+            else
+              view_row = rows_views.first
+              base_table = @schema.keyspace(keyspace_name).table(view_row['base_table_name'])
+              create_materialized_view(view_row,
+                                       rows_columns,
+                                       base_table)
             end
           end
         end
@@ -100,8 +126,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
@@ -111,13 +137,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
@@ -132,10 +158,18 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_materialized_views(connection)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_columns(connection)
           FUTURE_EMPTY_LIST
         end
 
+        def select_indexes(connection)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_types(connection)
           FUTURE_EMPTY_LIST
         end
@@ -156,10 +190,18 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_keyspace_materialized_views(connection, keyspace_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_keyspace_columns(connection, keyspace_name)
           FUTURE_EMPTY_LIST
         end
 
+        def select_keyspace_indexes(connection, keyspace_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_keyspace_types(connection, keyspace_name)
           FUTURE_EMPTY_LIST
         end
@@ -176,10 +218,18 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_materialized_view(connection, keyspace_name, view_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_table_columns(connection, keyspace_name, table_name)
           FUTURE_EMPTY_LIST
         end
 
+        def select_table_indexes(connection, keyspace_name, table_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_type(connection, keyspace_name, type_name)
           FUTURE_EMPTY_LIST
         end
@@ -195,7 +245,7 @@ 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|
+            Protocol::QueryRequest.new(cql, params, types, :one)).map do |r|
             case r
             when Protocol::RowsResultResponse
               r.rows
@@ -212,43 +262,44 @@ module Cassandra
         def map_rows_by(rows, key_name, &block)
           rows.each_with_object(::Hash.new { EMPTY_LIST }) do |row, map|
             key = row[key_name]
-            map[key] = [] unless map.has_key?(key)
+            map[key] = [] unless map.key?(key)
 
-            if block
-              map[key] << yield(row)
-            else
-              map[key] << row
-            end
+            map[key] << if block
+                          yield(row)
+                        else
+                          row
+                        end
           end
         end
       end
 
       # @private
       module Fetchers
+        # rubocop:disable Style/ClassAndModuleCamelCase
         class V1_2_x
           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 * ' \
+            'FROM system.schema_keyspaces ' \
+            'WHERE keyspace_name = \'%s\''.freeze
           SELECT_KEYSPACE_TABLES  =
-              'SELECT * ' \
-              'FROM system.schema_columnfamilies ' \
-              'WHERE keyspace_name = \'%s\''.freeze
+            'SELECT * ' \
+            'FROM system.schema_columnfamilies ' \
+            'WHERE keyspace_name = \'%s\''.freeze
           SELECT_KEYSPACE_COLUMNS =
-              'SELECT * FROM system.schema_columns WHERE keyspace_name = \'%s\''.freeze
+            '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 * ' \
+            '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 * ' \
+            'FROM system.schema_columns ' \
+            'WHERE keyspace_name = \'%s\' AND columnfamily_name = \'%s\''.freeze
 
-          include Fetcher
+          include Cassandra::Cluster::Schema::Fetcher
 
           def initialize(type_parser, schema)
             @type_parser = type_parser
@@ -274,20 +325,20 @@ module Cassandra
           end
 
           def select_keyspace_tables(connection, keyspace_name)
-            send_select_request(connection, SELECT_KEYSPACE_TABLES % keyspace_name)
+            send_select_request(connection, format(SELECT_KEYSPACE_TABLES, keyspace_name))
           end
 
           def select_keyspace_columns(connection, keyspace_name)
-            send_select_request(connection, SELECT_KEYSPACE_COLUMNS % keyspace_name)
+            send_select_request(connection, format(SELECT_KEYSPACE_COLUMNS, keyspace_name))
           end
 
           def select_table(connection, keyspace_name, table_name)
-            send_select_request(connection, SELECT_TABLE % [keyspace_name, table_name])
+            send_select_request(connection, format(SELECT_TABLE, keyspace_name, table_name))
           end
 
           def select_table_columns(connection, keyspace_name, table_name)
             send_select_request(connection,
-                                SELECT_TABLE_COLUMNS % [keyspace_name, table_name])
+                                format(SELECT_TABLE_COLUMNS, keyspace_name, table_name))
           end
 
           def create_replication(keyspace_data)
@@ -298,12 +349,13 @@ module Cassandra
           end
 
           def create_keyspace(keyspace_data, rows_tables, rows_columns,
-                              rows_types, rows_functions, rows_aggregates)
+                              rows_types, rows_functions, rows_aggregates,
+                              rows_views, rows_indexes)
             keyspace_name = keyspace_data['keyspace_name']
             replication   = create_replication(keyspace_data)
-            types = rows_types.each_with_object({}) do |row, types|
-                      types[row['type_name']] = create_type(row)
-                    end
+            types = rows_types.each_with_object({}) do |row, h|
+              h[row['type_name']] = create_type(row)
+            end
 
             # Create a FunctionCollection for the functions and aggregates.
             functions = Cassandra::FunctionCollection.new
@@ -317,9 +369,10 @@ module Cassandra
             end
 
             lookup_columns = map_rows_by(rows_columns, 'columnfamily_name')
-            tables = rows_tables.each_with_object({}) do |row, tables|
+            tables = rows_tables.each_with_object({}) do |row, h|
               table_name = row['columnfamily_name']
-              tables[table_name] = create_table(row, lookup_columns[table_name])
+              # rows_indexes is nil for C* < 3.0.
+              h[table_name] = create_table(row, lookup_columns[table_name], nil)
             end
 
             Keyspace.new(keyspace_name,
@@ -328,24 +381,34 @@ module Cassandra
                          tables,
                          types,
                          functions,
-                         aggregates)
+                         aggregates,
+                         {})
           end
 
-          def create_table(table_data, rows_columns)
+          def create_table(table_data, rows_columns, rows_indexes)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['columnfamily_name']
             key_validator   = @type_parser.parse(table_data['key_validator'])
             comparator      = @type_parser.parse(table_data['comparator'])
             column_aliases  = ::JSON.load(table_data['column_aliases'])
 
-            if !comparator.collections.nil?
+            if comparator.collections.nil?
+              is_compact = true
+              if !column_aliases.empty? || rows_columns.empty?
+                has_value = true
+                clustering_size = comparator.results.size
+              else
+                has_value = false
+                clustering_size = 0
+              end
+            else
               size = comparator.results.size
               if !comparator.collections.empty?
                 is_compact = false
                 has_value  = false
                 clustering_size = size - 2
               elsif column_aliases.size == size - 1 &&
-                  comparator.results.last.first == Cassandra::Types.varchar
+                    comparator.results.last.first == Cassandra::Types.varchar
                 is_compact = false
                 has_value  = false
                 clustering_size = size - 1
@@ -354,33 +417,24 @@ module Cassandra
                 has_value  = (!column_aliases.empty? || rows_columns.empty?)
                 clustering_size = size
               end
-            else
-              is_compact = true
-              if (!column_aliases.empty? || rows_columns.empty?)
-                has_value = true
-                clustering_size = comparator.results.size
-              else
-                has_value = false
-                clustering_size = 0
-              end
             end
 
+            # Separate out the partition-key, clustering-columns, and other-columns
             partition_key      = []
             clustering_columns = []
             clustering_order   = []
+            other_columns = []
 
             compaction_strategy = create_compaction_strategy(table_data)
             table_options =
-                create_table_options(table_data, compaction_strategy, is_compact)
-            table_columns = {}
-            other_columns = []
+              create_table_options(table_data, compaction_strategy, is_compact)
 
             key_aliases = ::JSON.load(table_data['key_aliases'])
 
             key_validator.results.each_with_index do |(type, order, is_frozen), i|
-              key_alias = key_aliases.fetch(i) { i.zero? ? "key" : "key#{i + 1}" }
+              key_alias = key_aliases.fetch(i) { i.zero? ? 'key' : "key#{i + 1}" }
 
-              partition_key[i] = Column.new(key_alias, type, order, nil, false, is_frozen)
+              partition_key[i] = Column.new(key_alias, type, order, false, is_frozen)
             end
 
             clustering_size.times do |i|
@@ -388,7 +442,7 @@ module Cassandra
               type, order, is_frozen = comparator.results.fetch(i)
 
               clustering_columns[i] =
-                  Column.new(column_alias, type, order, nil, false, is_frozen)
+                Column.new(column_alias, type, order, false, is_frozen)
               clustering_order[i]   = order
             end
 
@@ -398,71 +452,86 @@ module Cassandra
 
               unless value_alias.empty?
                 type, order, is_frozen =
-                    @type_parser.parse(table_data['default_validator']).results.first
+                  @type_parser.parse(table_data['default_validator']).results.first
                 other_columns <<
-                    Column.new(value_alias, type, order, nil, false, is_frozen)
+                  Column.new(value_alias, type, order, false, is_frozen)
               end
             end
 
+            index_rows = []
             rows_columns.each do |row|
-              other_columns << create_column(row)
-            end
+              column = create_column(row)
+              other_columns << column
 
-            partition_key.each do |column|
-              table_columns[column.name] = column
+              # In C* 1.2.x, index info is in the column metadata; rows_indexes is nil.
+              index_rows << [column, row] unless row['index_type'].nil?
             end
 
-            clustering_columns.each do |column|
-              table_columns[column.name] = column
+            table = Cassandra::Table.new(@schema.keyspace(keyspace_name),
+                                         table_name,
+                                         partition_key,
+                                         clustering_columns,
+                                         other_columns,
+                                         table_options,
+                                         clustering_order,
+                                         table_data['id'])
+
+            # Create Index objects and add them to the table.
+            index_rows.each do |column, row|
+              create_index(table, column, row)
             end
+            table
+          end
 
-            other_columns.each do |column|
-              table_columns[column.name] = column
+          def create_index(table, column, row_column)
+            # Most of this logic was taken from the Java driver.
+            options = {}
+            # For some versions of C*, this field could have a literal string 'null' value.
+            if !row_column['index_options'].nil? && row_column['index_options'] != 'null' && !row_column['index_options'].empty?
+              options = ::JSON.load(row_column['index_options'])
             end
-
-            Table.new(keyspace_name,
-                      table_name,
-                      partition_key,
-                      clustering_columns,
-                      table_columns,
-                      table_options,
-                      clustering_order)
+            column_name = Util.escape_name(column.name)
+            target = if options.key?('index_keys')
+                       "keys(#{column_name})"
+                     elsif options.key?('index_keys_and_values')
+                       "entries(#{column_name})"
+                     elsif column.frozen? && (column.type == Cassandra::Types::Set ||
+                         column.type == Cassandra::Types::List ||
+                         column.type == Cassandra::Types::Map)
+                       "full(#{column_name})"
+                     else
+                       column_name
+                     end
+
+            table.add_index(Cassandra::Index.new(table,
+                                                 row_column['index_name'],
+                                                 row_column['index_type'].downcase.to_sym,
+                                                 target,
+                                                 options))
           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
-
-            if column_data['index_type'].nil?
-              index = nil
-            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'])
-            end
-
-            Column.new(name, type, order, index, is_static, is_frozen)
+              @type_parser.parse(column_data['validator']).results.first
+            Column.new(name, type, order, is_static, is_frozen)
           end
 
           def create_compaction_strategy(table_data)
             klass = table_data['compaction_strategy_class']
             klass.slice!('org.apache.cassandra.db.compaction.')
             options = ::JSON.load(table_data['compaction_strategy_options'])
-            Table::Compaction.new(klass, options)
+            ColumnContainer::Compaction.new(klass, options)
           end
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
             if compression_parameters['sstable_compression']
-              compression_parameters['sstable_compression'].
-                  slice!(COMPRESSION_PACKAGE_PREFIX)
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
             end
-            Table::Options.new(
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -479,88 +548,87 @@ module Cassandra
               nil,
               compaction_strategy,
               compression_parameters,
-              is_compact
+              is_compact,
+              table_data['crc_check_chance'],
+              table_data['extensions']
             )
           end
         end
 
         class V2_0_x < V1_2_x
           SELECT_KEYSPACE           =
-              'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_TABLES    =
-              'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_COLUMNS   =
-              'SELECT * FROM system.schema_columns WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system.schema_columns WHERE keyspace_name = ?'.freeze
           SELECT_TABLE              =
-              'SELECT * ' \
-              'FROM system.schema_columnfamilies ' \
-              'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
+            '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 * ' \
+            'FROM system.schema_columns ' \
+            'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
 
           private
 
-          def create_table(table_data, rows_columns)
+          def create_table(table_data, rows_columns, rows_indexes)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['columnfamily_name']
             comparator      = @type_parser.parse(table_data['comparator'])
-            table_columns   = {}
-            other_columns   = []
             clustering_size = 0
 
+            # Separate out partition-key, clustering columns, other columns.
             partition_key      = []
             clustering_columns = []
             clustering_order   = []
+            other_columns = []
 
+            index_rows = []
             rows_columns.each do |row|
               next if row['column_name'].empty?
 
               column = create_column(row)
               type   = row['type'].to_s
-              index  = row['component_index'] || 0
+              ind = row['component_index'] || 0
 
               case type.upcase
               when 'PARTITION_KEY'
-                partition_key[index] = column
+                partition_key[ind] = column
               when 'CLUSTERING_KEY'
-                clustering_columns[index] = column
-                clustering_order[index]   = column.order
+                clustering_columns[ind] = column
+                clustering_order[ind]   = column.order
 
-                if clustering_size.zero? || index == clustering_size
-                  clustering_size = index + 1
-                end
+                clustering_size = ind + 1 if clustering_size.zero? || ind == clustering_size
               else
                 other_columns << column
               end
-            end
 
-            partition_key.each do |column|
-              table_columns[column.name] = column
-            end
-
-            clustering_columns.each do |column|
-              table_columns[column.name] = column
-            end
-
-            other_columns.each do |column|
-              table_columns[column.name] = column
+              # In C* 2.0.x, index info is in the column metadata; rows_indexes is nil.
+              index_rows << [column, row] unless row['index_type'].nil?
             end
 
             compaction_strategy = create_compaction_strategy(table_data)
             is_compact    = (clustering_size != comparator.results.size - 1) ||
-                !comparator.collections
+                            !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)
+              create_table_options(table_data, compaction_strategy, is_compact)
+
+            table = Cassandra::Table.new(@schema.keyspace(keyspace_name),
+                                         table_name,
+                                         partition_key,
+                                         clustering_columns,
+                                         other_columns,
+                                         table_options,
+                                         clustering_order,
+                                         table_data['id'])
+
+            # Create Index objects and add them to the table.
+            index_rows.each do |column, row|
+              create_index(table, column, row)
+            end
+            table
           end
 
           def select_keyspace(connection, keyspace_name)
@@ -596,10 +664,10 @@ module Cassandra
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
             if compression_parameters['sstable_compression']
-              compression_parameters['sstable_compression'].
-                  slice!(COMPRESSION_PACKAGE_PREFIX)
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
             end
-            Table::Options.new(
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -616,7 +684,9 @@ module Cassandra
               nil,
               compaction_strategy,
               compression_parameters,
-              is_compact
+              is_compact,
+              table_data['crc_check_chance'],
+              table_data['extensions']
             )
           end
         end
@@ -624,11 +694,11 @@ 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 * FROM system.schema_usertypes WHERE keyspace_name = ?'.freeze
           SELECT_TYPE           =
-              'SELECT * ' \
-              'FROM system.schema_usertypes ' \
-              'WHERE keyspace_name = ? AND type_name = ?'.freeze
+            'SELECT * ' \
+            'FROM system.schema_usertypes ' \
+            'WHERE keyspace_name = ? AND type_name = ?'.freeze
 
           private
 
@@ -668,10 +738,10 @@ module Cassandra
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
             if compression_parameters['sstable_compression']
-              compression_parameters['sstable_compression'].
-                  slice!(COMPRESSION_PACKAGE_PREFIX)
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
             end
-            Table::Options.new(
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -688,7 +758,9 @@ module Cassandra
               table_data['max_index_interval'],
               compaction_strategy,
               compression_parameters,
-              is_compact
+              is_compact,
+              table_data['crc_check_chance'],
+              table_data['extensions']
             )
           end
         end
@@ -697,19 +769,19 @@ module Cassandra
           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 * FROM system.schema_functions WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_AGGREGATES =
-              'SELECT * FROM system.schema_aggregates WHERE keyspace_name = ?'.freeze
+            '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 * ' \
+            '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
+            '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.
@@ -730,41 +802,41 @@ module Cassandra
             function_name  = function_data['function_name']
             function_lang  = function_data['language']
             function_type  =
-                @type_parser.parse(function_data['return_type']).results.first.first
+              @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)
+            Cassandra::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
+              @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
+              @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))
+              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.get(aggregate_data['state_func'],
@@ -818,53 +890,66 @@ module Cassandra
         end
 
         class V3_0_x < V2_2_x
-          SELECT_KEYSPACES  = "SELECT * FROM system_schema.keyspaces".freeze
-          SELECT_TABLES     = "SELECT * FROM system_schema.tables".freeze
-          SELECT_COLUMNS    = "SELECT * FROM system_schema.columns".freeze
-          SELECT_TYPES      = "SELECT * FROM system_schema.types".freeze
-          SELECT_FUNCTIONS  = "SELECT * FROM system_schema.functions".freeze
-          SELECT_AGGREGATES = "SELECT * FROM system_schema.aggregates".freeze
-          SELECT_INDEXES    = "SELECT * FROM system_schema.indexes".freeze
-          SELECT_VIEWS      = "SELECT * FROM system_schema.materialized_views".freeze
+          SELECT_KEYSPACES  = 'SELECT * FROM system_schema.keyspaces'.freeze
+          SELECT_TABLES     = 'SELECT * FROM system_schema.tables'.freeze
+          SELECT_COLUMNS    = 'SELECT * FROM system_schema.columns'.freeze
+          SELECT_TYPES      = 'SELECT * FROM system_schema.types'.freeze
+          SELECT_FUNCTIONS  = 'SELECT * FROM system_schema.functions'.freeze
+          SELECT_AGGREGATES = 'SELECT * FROM system_schema.aggregates'.freeze
+          SELECT_INDEXES    = 'SELECT * FROM system_schema.indexes'.freeze
+          SELECT_VIEWS      = 'SELECT * FROM system_schema.views'.freeze
 
           SELECT_KEYSPACE            =
-              'SELECT * FROM system_schema.keyspaces WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system_schema.keyspaces WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_TABLES     =
-              'SELECT * FROM system_schema.tables WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system_schema.tables WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_INDEXES    =
+            'SELECT * FROM system_schema.indexes WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_COLUMNS    =
-              'SELECT * FROM system_schema.columns WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system_schema.columns WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_VIEWS =
+            'SELECT * FROM system_schema.views WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_TYPES      =
-              "SELECT * FROM system_schema.types WHERE keyspace_name = ?".freeze
+            'SELECT * FROM system_schema.types WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_FUNCTIONS  =
-              'SELECT * FROM system_schema.functions WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system_schema.functions WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_AGGREGATES =
-              'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ?'.freeze
+            'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ?'.freeze
 
           SELECT_TABLE         =
-              'SELECT * ' \
-              'FROM system_schema.tables ' \
-              'WHERE keyspace_name = ? AND table_name = ?'.freeze
+            '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 * ' \
+            'FROM system_schema.columns ' \
+            'WHERE keyspace_name = ? AND table_name = ?'.freeze
+          SELECT_TABLE_INDEXES =
+            'SELECT * ' \
+            'FROM system_schema.indexes ' \
+            'WHERE keyspace_name = ? AND table_name = ?'.freeze
+
+          SELECT_VIEW =
+            'SELECT * ' \
+            'FROM system_schema.views ' \
+            'WHERE keyspace_name = ? AND view_name = ?'.freeze
 
           SELECT_TYPE =
-              'SELECT * ' \
-              'FROM system_schema.types ' \
-              'WHERE keyspace_name = ? AND type_name = ?'.freeze
+            '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 * ' \
+            '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
+            '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.
@@ -889,6 +974,14 @@ module Cassandra
             send_select_request(connection, SELECT_TABLES)
           end
 
+          def select_indexes(connection)
+            send_select_request(connection, SELECT_INDEXES)
+          end
+
+          def select_materialized_views(connection)
+            send_select_request(connection, SELECT_VIEWS)
+          end
+
           def select_columns(connection)
             send_select_request(connection, SELECT_COLUMNS)
           end
@@ -923,6 +1016,18 @@ module Cassandra
             send_select_request(connection, SELECT_KEYSPACE_COLUMNS, params, hints)
           end
 
+          def select_keyspace_indexes(connection, keyspace_name)
+            params = [keyspace_name]
+            hints  = [Types.varchar]
+            send_select_request(connection, SELECT_KEYSPACE_INDEXES, params, hints)
+          end
+
+          def select_keyspace_materialized_views(connection, keyspace_name)
+            params = [keyspace_name]
+            hints  = [Types.varchar]
+            send_select_request(connection, SELECT_KEYSPACE_VIEWS, params, hints)
+          end
+
           def select_keyspace_types(connection, keyspace_name)
             params = [keyspace_name]
             hints  = [Types.varchar]
@@ -948,11 +1053,26 @@ module Cassandra
           end
 
           def select_table_columns(connection, keyspace_name, table_name)
+            # This is identical to the 2.0 impl, but the SELECT_TABLE_COLUMNS query
+            # is different between the two, so we need two impls. :(
+            # Also, this method works fine for finding view columns as well.
             params         = [keyspace_name, table_name]
             hints          = [Types.varchar, Types.varchar]
             send_select_request(connection, SELECT_TABLE_COLUMNS, params, hints)
           end
 
+          def select_table_indexes(connection, keyspace_name, table_name)
+            params         = [keyspace_name, table_name]
+            hints          = [Types.varchar, Types.varchar]
+            send_select_request(connection, SELECT_TABLE_INDEXES, params, hints)
+          end
+
+          def select_materialized_view(connection, keyspace_name, view_name)
+            params         = [keyspace_name, view_name]
+            hints          = [Types.varchar, Types.varchar]
+            send_select_request(connection, SELECT_VIEW, params, hints)
+          end
+
           def select_type(connection, keyspace_name, type_name)
             params = [keyspace_name, type_name]
             hints  = [Types.varchar, Types.varchar]
@@ -982,19 +1102,19 @@ module Cassandra
 
             arguments = []
 
-            function_data['argument_names'].
-                zip(function_data['argument_types']) do |argument_name, argument_type|
+            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)
+            Cassandra::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)
@@ -1002,7 +1122,7 @@ module Cassandra
             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
+              @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
@@ -1057,16 +1177,14 @@ module Cassandra
 
               break if skipped_rows.empty?
 
-              if rows_size == skipped_rows.size
-                raise "Unable to resolve circular references among UDTs when parsing"
-              else
-                rows_types, skipped_rows = skipped_rows, rows_types
-              end
+              raise 'Unable to resolve circular references among UDTs when parsing' if rows_size == skipped_rows.size
+
+              rows_types, skipped_rows = skipped_rows, rows_types
             end
           end
 
-          def create_keyspace(keyspace_data, rows_tables, rows_columns,
-                              rows_types, rows_functions, rows_aggregates)
+          def create_keyspace(keyspace_data, rows_tables, rows_columns, rows_types,
+                              rows_functions, rows_aggregates, rows_views, rows_indexes)
             keyspace_name = keyspace_data['keyspace_name']
             replication   = create_replication(keyspace_data)
 
@@ -1084,10 +1202,25 @@ module Cassandra
               aggregates.add_or_update(create_aggregate(row, functions, types))
             end
 
+            # lookup_columns is a hash of <table-name, rows_columns for that table>.
+            # However, views are analogous to tables in this context, so we get
+            # view columns organized by view-name also.
+
             lookup_columns = map_rows_by(rows_columns, 'table_name')
-            tables = rows_tables.each_with_object({}) do |row, tables|
+            lookup_indexes = map_rows_by(rows_indexes, 'table_name')
+            tables = rows_tables.each_with_object({}) do |row, h|
               table_name = row['table_name']
-              tables[table_name] = create_table(row, lookup_columns[table_name], types)
+              h[table_name] = create_table(row, lookup_columns[table_name],
+                                           lookup_indexes[table_name], types)
+            end
+
+            views = rows_views.each_with_object({}) do |row, h|
+              view_name = row['view_name']
+              base_table = tables[row['base_table_name']]
+              h[view_name] = create_materialized_view(row,
+                                                      lookup_columns[view_name],
+                                                      base_table,
+                                                      types)
             end
 
             Keyspace.new(keyspace_name,
@@ -1096,7 +1229,8 @@ module Cassandra
                          tables,
                          types,
                          functions,
-                         aggregates)
+                         aggregates,
+                         views)
           end
 
           def create_replication(keyspace_data)
@@ -1110,16 +1244,14 @@ module Cassandra
             options = table_data['compaction']
             klass   = options.delete('class')
             klass.slice!('org.apache.cassandra.db.compaction.')
-            Table::Compaction.new(klass, options)
+            ColumnContainer::Compaction.new(klass, options)
           end
 
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression = table_data['compression']
-            if compression['class']
-              compression['class'].slice!(COMPRESSION_PACKAGE_PREFIX)
-            end
+            compression['class'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression['class']
 
-            Table::Options.new(
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['dclocal_read_repair_chance'],
@@ -1136,82 +1268,146 @@ module Cassandra
               table_data['max_index_interval'],
               compaction_strategy,
               compression,
-              is_compact
+              is_compact,
+              table_data['crc_check_chance'],
+              table_data['extensions']
             )
           end
 
           def create_column(column_data, types)
             name      = column_data['column_name']
-            is_static = (column_data['kind'].to_s.upcase == 'STATIC')
+            is_static = column_data['kind'].to_s.casecmp('STATIC').zero?
             order     = column_data['clustering_order'] == 'desc' ? :desc : :asc
-            type, is_frozen = @type_parser.parse(column_data['type'], types)
+            if column_data['type'][0] == "'"
+              # This is a custom column type.
+              type = Types.custom(column_data['type'].slice(1, column_data['type'].length - 2))
+              is_frozen = false
+            else
+              type, is_frozen = @type_parser.parse(column_data['type'], types)
+            end
 
-            Column.new(name, type, order, nil, is_static, is_frozen)
+            Column.new(name, type, order, is_static, is_frozen)
           end
 
-          def create_table(table_data, rows_columns, types = nil)
+          def create_table(table_data, rows_columns, rows_indexes, types = nil)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['table_name']
             table_flags     = table_data['flags']
-            table_columns   = {}
-            other_columns   = []
-            clustering_size = 0
 
             is_dense    = table_flags.include?('dense')
             is_super    = table_flags.include?('super')
             is_compound = table_flags.include?('compound')
             is_compact  = is_super || is_dense || !is_compound
+            is_static_compact = !is_super && !is_dense && !is_compound
 
+            # Separate out partition-key, clustering columns, other columns.
             partition_key      = []
             clustering_columns = []
             clustering_order   = []
-            types            ||= @schema.keyspace(keyspace_name).send(:raw_types)
+            other_columns = []
+            types ||= @schema.keyspace(keyspace_name).send(:raw_types)
 
             rows_columns.each do |row|
               next if row['column_name'].empty?
 
-              column = create_column(row, types)
               kind   = row['kind'].to_s
               index  = row['position'] || 0
 
+              if is_static_compact
+                if kind.casecmp('CLUSTERING').zero? || kind.casecmp('REGULAR').zero?
+                  # Skip clustering columns in static-compact tables; they are internal to C*.
+                  # Oddly so are regular columns.
+                  next
+                end
+                if kind.casecmp('STATIC').zero?
+                  # Coerce static type to regular.
+                  kind = 'REGULAR'
+                  row['kind'] = 'regular'
+                end
+              end
+
+              column = create_column(row, types)
               case kind.upcase
               when 'PARTITION_KEY'
                 partition_key[index] = column
               when 'CLUSTERING'
                 clustering_columns[index] = column
                 clustering_order[index]   = column.order
-
-                if clustering_size.zero? || index == clustering_size
-                  clustering_size = index + 1
-                end
               else
                 other_columns << column
               end
             end
 
-            partition_key.each do |column|
-              table_columns[column.name] = column
+            # Default the crc_check_chance to 1.0 (Java driver does this, so we
+            # should, too).
+            table_data['crc_check_chance'] ||= 1.0
+            compaction_strategy = create_compaction_strategy(table_data)
+            table_options =
+              create_table_options(table_data, compaction_strategy, is_compact)
+
+            table = Cassandra::Table.new(@schema.keyspace(keyspace_name),
+                                         table_name,
+                                         partition_key,
+                                         clustering_columns,
+                                         other_columns,
+                                         table_options,
+                                         clustering_order,
+                                         table_data['id'])
+            rows_indexes.each do |row|
+              create_index(table, row)
             end
+            table
+          end
 
-            clustering_columns.each do |column|
-              table_columns[column.name] = column
-            end
+          def create_index(table, row_index)
+            options = row_index['options']
+            table.add_index(Cassandra::Index.new(table, row_index['index_name'],
+                                                 row_index['kind'].downcase.to_sym,
+                                                 options['target'], options))
+          end
+
+          def create_materialized_view(view_data, rows_columns, base_table, types = nil)
+            keyspace_name   = view_data['keyspace_name']
+            view_name       = view_data['view_name']
+            include_all_columns = view_data['include_all_columns']
+            where_clause = view_data['where_clause']
 
-            other_columns.each do |column|
-              table_columns[column.name] = column
+            # Separate out partition key, clustering columns, other columns
+            partition_key      = []
+            clustering_columns = []
+            other_columns = []
+            types ||= @schema.keyspace(keyspace_name).send(:raw_types)
+
+            rows_columns.each do |row|
+              next if row['column_name'].empty?
+
+              column = create_column(row, types)
+              kind   = row['kind'].to_s
+              index  = row['position'] || 0
+
+              case kind.upcase
+              when 'PARTITION_KEY'
+                partition_key[index] = column
+              when 'CLUSTERING'
+                clustering_columns[index] = column
+              else
+                other_columns << column
+              end
             end
 
-            compaction_strategy = create_compaction_strategy(table_data)
-            table_options =
-                create_table_options(table_data, compaction_strategy, is_compact)
+            compaction_strategy = create_compaction_strategy(view_data)
+            view_options = create_table_options(view_data, compaction_strategy, false)
 
-            Table.new(keyspace_name,
-                      table_name,
-                      partition_key,
-                      clustering_columns,
-                      table_columns,
-                      table_options,
-                      clustering_order)
+            MaterializedView.new(@schema.keyspace(keyspace_name),
+                                 view_name,
+                                 partition_key,
+                                 clustering_columns,
+                                 other_columns,
+                                 view_options,
+                                 include_all_columns,
+                                 where_clause,
+                                 base_table,
+                                 view_data['id'])
           end
         end
 
@@ -1263,6 +1459,13 @@ module Cassandra
             return Ione::Future.failed(e)
           end
 
+          def fetch_materialized_view(connection, keyspace_name, view_name)
+            find_fetcher(connection)
+              .fetch_materialized_view(connection, keyspace_name, view_name)
+          rescue => e
+            return Ione::Future.failed(e)
+          end
+
           def fetch_type(connection, keyspace_name, type_name)
             find_fetcher(connection)
               .fetch_type(connection, keyspace_name, type_name)
@@ -1304,21 +1507,21 @@ module Cassandra
             unless host
               ips = @registry.hosts.map(&:ip)
               raise Errors::ClientError,
-                    "unable to find release version for current host, " \
+                    'unable to find release version for current host, ' \
                     "connected to #{connection.host}, but cluster contains " \
                     "#{ips}."
             end
 
             version = host.release_version
             unless version
-              raise Errors::ClientError, "unable to determine release " \
+              raise Errors::ClientError, 'unable to determine release ' \
                                          "version for host: #{host.inspect}"
             end
 
             @fetchers[version] ||= begin
               current = @versions.find {|v| v.matches?(version)}
               unless current
-                raise Errors::ClientError, "unsupported release version " \
+                raise Errors::ClientError, 'unsupported release version ' \
                                            "#{version.inspect}."
               end
               current.fetcher