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

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.
@@ -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,7 +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
@@ -110,11 +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
@@ -129,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
@@ -153,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
@@ -173,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
@@ -191,7 +244,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
@@ -208,30 +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_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
+          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 Cassandra::Cluster::Schema::Fetcher
 
           def initialize(type_parser, schema)
             @type_parser = type_parser
@@ -257,19 +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])
+            send_select_request(connection,
+                                format(SELECT_TABLE_COLUMNS, keyspace_name, table_name))
           end
 
           def create_replication(keyspace_data)
@@ -280,50 +349,66 @@ 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
-
-            # We want the functions hash to be keyed on [name, arg-types-list].
-            # Similarly for the aggregates hash.
+            types = rows_types.each_with_object({}) do |row, h|
+              h[row['type_name']] = create_type(row)
+            end
 
-            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|
+            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, 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)
+          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
+              elsif column_aliases.size == size - 1 &&
+                    comparator.results.last.first == Cassandra::Types.varchar
                 is_compact = false
                 has_value  = false
                 clustering_size = size - 1
@@ -332,39 +417,32 @@ 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 = []
+            table_options =
+              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|
               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, false, is_frozen)
               clustering_order[i]   = order
             end
 
@@ -373,59 +451,87 @@ 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, 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, order, 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'])
-            compression_parameters['sstable_compression'].slice!(COMPRESSION_PACKAGE_PREFIX) if compression_parameters['sstable_compression']
-            Table::Options.new(
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -442,72 +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_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
 
-          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
-            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)
+            is_compact    = (clustering_size != comparator.results.size - 1) ||
+                            !comparator.collections
+            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'])
+
+            # 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)
@@ -542,8 +663,11 @@ 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']
-            Table::Options.new(
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -560,15 +684,21 @@ module Cassandra
               nil,
               compaction_strategy,
               compression_parameters,
-              is_compact
+              is_compact,
+              table_data['crc_check_chance'],
+              table_data['extensions']
             )
           end
         end
 
         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,8 +737,11 @@ 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']
-            Table::Options.new(
+            if compression_parameters['sstable_compression']
+              compression_parameters['sstable_compression']
+                .slice!(COMPRESSION_PACKAGE_PREFIX)
+            end
+            Cassandra::ColumnContainer::Options.new(
               table_data['comment'],
               table_data['read_repair_chance'],
               table_data['local_read_repair_chance'],
@@ -625,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
@@ -633,12 +768,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 +801,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)
+            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
-            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)
@@ -720,32 +890,69 @@ 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_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_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_KEYSPACE_TABLES     =
+            '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_KEYSPACE_VIEWS =
+            'SELECT * FROM system_schema.views 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_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_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.
@@ -767,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
@@ -801,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]
@@ -826,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]
@@ -860,29 +1102,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)
+            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)
             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)
@@ -914,43 +1177,60 @@ 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)
 
             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 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
 
-            Keyspace.new(keyspace_name, keyspace_data['durable_writes'],
-                         replication, tables, types, functions, aggregates)
+            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,
+                         keyspace_data['durable_writes'],
+                         replication,
+                         tables,
+                         types,
+                         functions,
+                         aggregates,
+                         views)
           end
 
           def create_replication(keyspace_data)
@@ -964,14 +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']
             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'],
@@ -988,76 +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']
+
+            # 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
 
-            other_columns.each do |column|
-              table_columns[column.name] = column
+              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
 
@@ -1109,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)
@@ -1130,13 +1487,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
@@ -1147,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