cequel 2.1.0 → 3.0.0

data/lib/cequel/schema/table_differ.rb

@@ -0,0 +1,112 @@
+# -*- encoding : utf-8 -*-
+module Cequel
+  module Schema
+    #
+    # Utility object that calculates a `Patch` to transform one `Table`
+    # into another.
+    #
+    # Currently this support adding columns, adding and removing indexes, and
+    # setting properties on the table. Any other changes are prohibited due to
+    # CQL limitation or data integrity concerns. A `InvalidSchemaMigration` will
+    # be raised if unsupported changes are detected.
+    #
+    class TableDiffer
+      protected def initialize(table_a, table_b)
+        @table_a = table_a
+        @table_b = table_b
+      end
+
+      # Returns a Patch that will transform table_a in to table_b.
+      #
+      def call
+        (fail InvalidSchemaMigration, "Table renames are not supported") if
+          table_a.name != table_b.name
+        (fail InvalidSchemaMigration, "Changes to key structure is not allowed") if
+          keys_changed?
+        (fail InvalidSchemaMigration, "Type changes are not allowed") if any_types_changed?
+
+        Patch.new(figure_changes)
+      end
+
+      protected
+
+      attr_reader :table_a, :table_b
+
+      def figure_changes
+        column_changes + property_changes
+      end
+
+      def property_changes
+        if properties_changed? && table_b.properties.any?
+          [Patch::SetTableProperties.new(table_b)]
+        else
+          []
+        end
+      end
+
+      def column_changes
+        renames
+          .map { |old_and_new_c| Patch::RenameColumn.new(table_b, *old_and_new_c) } +
+          added_columns
+            .map { |new_c| Patch::AddColumn.new(table_b, new_c) } +
+          added_indexes
+            .map { |col_with_new_idx| Patch::AddIndex.new(table_b, col_with_new_idx) } +
+          dropped_indexes
+            .map { |col_with_old_idx| Patch::DropIndex.new(table_b, col_with_old_idx) }
+      end
+
+      def renames
+        table_a.clustering_columns
+          .zip(table_b.clustering_columns)
+          .select { |ks| ks[0].name != ks[1].name }
+      end
+
+      def added_columns
+        table_b
+          .data_columns
+          .reject{|c_a| table_a.data_columns.any?{|c_b| c_b.name == c_a.name } }
+      end
+
+      def added_indexes
+        table_b.columns
+          .select(&:indexed?)
+          .reject{|c| table_a.has_column?(c.name) &&
+                    table_a.column(c.name).indexed? } # ignore still indexed columns
+      end
+
+      def dropped_indexes
+        table_a.columns
+          .select(&:indexed?)
+          .reject{|c| !table_b.has_column?(c.name) } # ignore "dropped" columns
+          .reject{|c| table_b.column(c.name).indexed? }
+      end
+
+      def any_types_changed?
+        table_a.columns
+          .select{|c_a| table_b.has_column?(c_a.name) }
+          .any?{|c_a| table_b.column(c_a.name).type != c_a.type}
+      end
+
+      def keys_changed?
+        table_a.partition_key_columns != table_b.partition_key_columns ||
+          table_a.clustering_columns.zip(table_b.clustering_columns)
+            .any? { |ks| !cluster_keys_compatible?(*ks) }
+      end
+
+      def cluster_keys_compatible?(key_a, key_b)
+        return false if key_a.blank? or key_b.blank?
+
+        key_a.type == key_b.type &&
+          key_a.clustering_order == key_b.clustering_order
+      end
+
+      def properties_changed?
+        p_a = table_a.properties.values
+        p_b = table_b.properties.values
+
+        ((p_a | p_b) - (p_a & p_b)).any?
+      end
+
+    end
+  end
+end

data/lib/cequel/schema/table_property.rb

@@ -44,6 +44,20 @@ module Cequel
         "#{@name} = #{value_cql}"
       end
 
+      # Returns true iff `self` and `other` logically equivalent (same value for
+      # same property).
+      #
+      def ==(other)
+        other.name == self.name &&
+          other.value == self.value
+      end
+      alias_method :eql?, :==
+
+      # Returns a hash code for this object
+      def hash
+        [name, value].hash
+      end
+
       protected
 
       def normalized_value=(value)

data/lib/cequel/schema/table_reader.rb

@@ -2,9 +2,8 @@
 module Cequel
   module Schema
     #
-    # A TableReader will query Cassandra's internal representation of a table's
-    # schema, and build a {Table} instance exposing an object representation of
-    # that schema
+    # A TableReader interprets table data from the cassandra driver into a table
+    # descriptor (read: `Table`).
     #
     class TableReader
       COMPOSITE_TYPE_PATTERN =
@@ -18,25 +17,32 @@ module Cequel
       #   database
       attr_reader :table
 
-      #
-      # Read the schema defined in the database for a given table and return a
-      # {Table} instance
-      #
-      # @param (see #initialize)
-      # @return (see #read)
-      #
-      def self.read(keyspace, table_name)
-        new(keyspace, table_name).read
-      end
+      class << self
+        #
+        # Read the schema defined in the database for a given table and return a
+        # {Table} instance
+        #
+        # @param (see #initialize)
+        # @return (see #read)
+        #
+        def read(keyspace, table_name)
+          table_data = fetch_raw_keyspace(keyspace).table(table_name.to_s)
+          (fail NoSuchTableError) if table_data.blank?
+
+          new(table_data).call
+        end
 
-      #
-      # Return a {TableReader} instance
-      #
-      # @param (see #initialize)
-      # @return [TableReader] object
-      #
-      def self.get(keyspace, table_name)
-        new(keyspace, table_name)
+        protected
+
+        def fetch_raw_keyspace(keyspace)
+          cluster = keyspace.cluster
+          cluster.refresh_schema
+
+          (fail NoSuchKeyspaceError, "No such keyspace #{keyspace.name}") unless
+            cluster.has_keyspace?(keyspace.name)
+
+          cluster.keyspace(keyspace.name)
+        end
       end
 
       #
@@ -44,11 +50,11 @@ module Cequel
       # @param table_name [Symbol] name of the table to read
       # @private
       #
-      def initialize(keyspace, table_name)
-        @keyspace, @table_name = keyspace, table_name
-        @table = Table.new(table_name.to_sym)
+      def initialize(table_data)
+        @table_data = table_data
+        @table = Table.new(table_data.name,
+                           Cassandra::MaterializedView === table_data)
       end
-      private_class_method(:new)
 
       #
       # Read table schema from the database
@@ -58,75 +64,70 @@ module Cequel
       #
       # @api private
       #
-      def read
-        if table_data.present?
-          read_partition_keys
-          read_clustering_columns
-          read_data_columns
-          read_properties
-          read_table_settings
-          table
-        end
-      end
+      def call
+        return nil if table_data.blank?
 
-      #
-      # Check if it is materialized view
-      #
-      # @return [boolean] true if it is materialized view
-      #
-      # @api private
-      #
-      def materialized_view?
-        cluster.keyspace(keyspace.name)
-          .has_materialized_view?(table_name.to_s)
+        read_partition_keys
+        read_clustering_columns
+        read_indexes
+        read_data_columns
+        read_properties
+        read_table_settings
+
+        table
       end
 
       protected
 
-      attr_reader :keyspace, :table_name, :table
-
-      private
+      attr_reader :table_data, :table, :indexes
 
       def read_partition_keys
         table_data.partition_key.each do |k|
-          table.add_partition_key(k.name.to_sym, k.type)
+          table.add_column PartitionKey.new(k.name.to_sym, type(k.type))
         end
 
       end
 
       def read_clustering_columns
-        table_data.clustering_columns.zip(table_data.clustering_order)
-          .each do |c,o|
-            table.add_clustering_column(c.name.to_sym, c.type, o)
+        table_data.clustering_columns
+          .each do |c|
+            table.add_column ClusteringColumn.new(c.name.to_sym, type(c.type), c.order)
           end
       end
 
-      def read_data_columns
-        indexes = Hash[table_data.each_index.map{|i| [i.target, i.name]}]
+      def read_indexes
+        @indexes = if table_data.respond_to?(:each_index)
+                     Hash[table_data.each_index.map{|i| [i.target, i.name]}]
+                   else
+                     # materialized view
+                     {}
+                   end
+      end
 
+      def read_data_columns
         ((table_data.each_column - table_data.partition_key) - table_data.clustering_columns)
           .each do |c|
-            next if table.column(c.name.to_sym)
-            case c.type
-            when Cassandra::Types::Simple
-              opts = if indexes[c.name]
-                       {index: indexes[c.name].to_sym}
-                     else
-                       {}
-                     end
-              table.add_data_column(c.name.to_sym, c.type, opts)
-            when Cassandra::Types::List
-              table.add_list(c.name.to_sym, c.type.value_type)
-            when Cassandra::Types::Set
-              table.add_set(c.name.to_sym, c.type.value_type)
-            when Cassandra::Types::Map
-              table.add_map(c.name.to_sym, c.type.key_type, c.type.value_type)
-            else
-              fail "Unsupported type #{c.type.inspect}"
-            end
+            next if table.has_column?(c.name.to_sym)
+
+            table.add_column interpret_column(c)
           end
       end
 
+      def interpret_column(c)
+        case c.type
+        when Cassandra::Types::Simple
+          DataColumn.new(c.name.to_sym, type(c.type), index_name(c))
+        when Cassandra::Types::List
+          List.new(c.name.to_sym, type(c.type.value_type))
+        when Cassandra::Types::Set
+          Set.new(c.name.to_sym, type(c.type.value_type))
+        when Cassandra::Types::Map
+          Map.new(c.name.to_sym, type(c.type.key_type), type(c.type.value_type))
+        else
+          fail "Unsupported type #{c.type.inspect}"
+        end
+      end
+
       @@prop_extractors = []
       def self.def_property(name,
                             option_method = name,
@@ -136,7 +137,7 @@ module Cequel
           raw_prop_val = table_data.options.public_send(option_method)
           prop_val = coercion.call(raw_prop_val,table_data)
 
-          table.add_property(name, prop_val)
+          table.add_property TableProperty.build(name, prop_val)
         }
       end
 
@@ -171,20 +172,15 @@ module Cequel
         table.compact_storage = table_data.options.compact_storage?
       end
 
-      def table_data
-        @table_data ||= cluster.keyspace(keyspace.name)
-          .table(table_name.to_s)
+      def type(type_info)
+        ::Cequel::Type[type_info.kind]
       end
 
-      def cluster
-        @cluster ||= begin
-          cluster = keyspace.cluster
-          cluster.refresh_schema
-
-          fail(NoSuchKeyspaceError, "No such keyspace #{keyspace.name}") if
-            !cluster.has_keyspace?(keyspace.name)
-
-          cluster
+      def index_name(column_info)
+        if idx_name = indexes[column_info.name]
+          idx_name.to_sym
+        else
+          nil
         end
       end
     end

data/lib/cequel/schema/table_updater.rb

@@ -86,23 +86,6 @@ module Cequel
         add_data_column(Map.new(name, type(key_type), type(value_type)))
       end
 
-      #
-      # Change an existing column's type
-      #
-      # @param name [Symbol] the name of the column
-      # @param type [Symbol,Type] the new type of the column
-      # @return [void]
-      #
-      # @note Changing the type of a CQL column does not modify the data
-      #   currently stored in the column. Thus, client-side handling is needed
-      #   to convert old values to the new type at read time. Cequel does not
-      #   currently support this functionality, although it may in the future.
-      #   Altering column types is not recommended.
-      #
-      def change_column(name, type)
-        add_stmt %Q|ALTER TABLE "#{table_name}" ALTER "#{name}" TYPE #{type}|
-      end
-
       #
       # Rename a column
       #

data/lib/cequel/schema/table_writer.rb

@@ -13,18 +13,16 @@ module Cequel
       # @return (see #apply)
       #
       def self.apply(keyspace, table)
-        new(keyspace, table).apply
+        new(table).apply(keyspace)
       end
 
       #
       # @param keyspace [Keyspace] keyspace in which to create the table
       # @param table [Table] object representation of table schema
-      # @private
       #
-      def initialize(keyspace, table)
-        @keyspace, @table = keyspace, table
+      def initialize(table)
+        @table = table
       end
-      private_class_method :new
 
       #
       # Create the table in the keyspace
@@ -33,14 +31,17 @@ module Cequel
       #
       # @api private
       #
-      def apply
-        keyspace.execute(create_statement)
-        index_statements.each { |statement| keyspace.execute(statement) }
+      def apply(keyspace)
+        statements.each { |statement| keyspace.execute(statement) }
+      end
+
+      def statements
+        [create_statement] + index_statements
       end
 
       protected
 
-      attr_reader :keyspace, :table
+      attr_reader :table
 
       private
 

data/lib/cequel/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Cequel
   # The current version of the library
-  VERSION = '2.1.0'
+  VERSION = '3.0.0'
 end

data/spec/examples/metal/data_set_spec.rb

@@ -2,8 +2,11 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe Cequel::Metal::DataSet do
+  posts_tn = "posts_#{SecureRandom.hex(4)}"
+  post_act_tn = "post_activity_#{SecureRandom.hex(4)}" 
+
   before :all do
-    cequel.schema.create_table(:posts) do
+    cequel.schema.create_table(posts_tn) do
       key :blog_subdomain, :text
       key :permalink, :text
       column :title, :text
@@ -13,7 +16,7 @@ describe Cequel::Metal::DataSet do
       set :tags, :text
       map :trackbacks, :timestamp, :text
     end
-    cequel.schema.create_table :post_activity do
+    cequel.schema.create_table post_act_tn do
       key :blog_subdomain, :text
       key :permalink, :text
       column :visits, :counter
@@ -22,14 +25,14 @@ describe Cequel::Metal::DataSet do
   end
 
   after :each do
-    subdomains = cequel[:posts].select(:blog_subdomain).
-      map { |row| row[:blog_subdomain] }
-    cequel[:posts].where(blog_subdomain: subdomains).delete if subdomains.any?
+    subdomains = cequel[posts_tn].select(:blog_subdomain)
+                 .map { |row| row[:blog_subdomain] }
+    cequel[posts_tn].where(blog_subdomain: subdomains).delete if subdomains.any?
   end
 
   after :all do
-    cequel.schema.drop_table(:posts)
-    cequel.schema.drop_table(:post_activity)
+    cequel.schema.drop_table(posts_tn)
+    cequel.schema.drop_table(post_act_tn)
   end
 
   let(:row_keys) { {blog_subdomain: 'cassandra', permalink: 'big-data'} }
@@ -48,53 +51,53 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should insert a row' do
-      cequel[:posts].insert(row)
-      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Fun times')
+      cequel[posts_tn].insert(row)
+      expect(cequel[posts_tn].where(row_keys).first[:title]).to eq('Fun times')
     end
 
     it 'should correctly insert a list' do
-      cequel[:posts].insert(row)
-      expect(cequel[:posts].where(row_keys).first[:categories]).
+      cequel[posts_tn].insert(row)
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).
         to eq(['Fun', 'Profit'])
     end
 
     it 'should correctly insert a set' do
-      cequel[:posts].insert(row)
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      cequel[posts_tn].insert(row)
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['cassandra', 'big-data'])
     end
 
     it 'should correctly insert a map' do
-      cequel[:posts].insert(row)
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      cequel[posts_tn].insert(row)
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq(row[:trackbacks])
     end
 
     it 'should include ttl argument' do
-      cequel[:posts].insert(row, :ttl => 10.minutes)
-      expect(cequel[:posts].select_ttl(:title).where(row_keys).first.ttl(:title)).
+      cequel[posts_tn].insert(row, :ttl => 10.minutes)
+      expect(cequel[posts_tn].select_ttl(:title).where(row_keys).first.ttl(:title)).
         to be_within(5).of(10.minutes)
     end
 
     it 'should include timestamp argument' do
-      cequel.schema.truncate_table(:posts)
+      cequel.schema.truncate_table(posts_tn)
       time = 1.day.ago
-      cequel[:posts].insert(row, :timestamp => time)
-      expect(cequel[:posts].select_writetime(:title).where(row_keys).
+      cequel[posts_tn].insert(row, :timestamp => time)
+      expect(cequel[posts_tn].select_writetime(:title).where(row_keys).
         first.writetime(:title)).to eq((time.to_f * 1_000_000).to_i)
     end
 
     it 'should insert row with given consistency' do
       expect_query_with_consistency(->(s){/INSERT/ === s.cql}, :one) do
-        cequel[:posts].insert(row, consistency: :one)
+        cequel[posts_tn].insert(row, consistency: :one)
       end
     end
 
     it 'should include multiple arguments joined by AND' do
-      cequel.schema.truncate_table(:posts)
+      cequel.schema.truncate_table(posts_tn)
       time = 1.day.ago
-      cequel[:posts].insert(row, :ttl => 600, :timestamp => time)
-      result = cequel[:posts].select_ttl(:title).select_writetime(:title).
+      cequel[posts_tn].insert(row, :ttl => 600, :timestamp => time)
+      result = cequel[posts_tn].select_ttl(:title).select_writetime(:title).
         where(row_keys).first
       expect(result.writetime(:title)).to eq((time.to_f * 1_000_000).to_i)
       expect(result.ttl(:title)).to be_within(5).of(10.minutes)
@@ -103,20 +106,20 @@ describe Cequel::Metal::DataSet do
 
   describe '#update' do
     it 'should send basic update statement' do
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         update(:title => 'Fun times', :body => 'Fun')
-      expect(cequel[:posts].where(row_keys).
+      expect(cequel[posts_tn].where(row_keys).
         first[:title]).to eq('Fun times')
     end
 
     it 'should send update statement with options' do
-      cequel.schema.truncate_table(:posts)
+      cequel.schema.truncate_table(posts_tn)
       time = Time.now - 10.minutes
 
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         update({title: 'Fun times', body: 'Fun'}, ttl: 600, timestamp: time)
 
-      row = cequel[:posts].
+      row = cequel[posts_tn].
         select_ttl(:title).select_writetime(:title).
         where(row_keys).first
 
@@ -126,67 +129,67 @@ describe Cequel::Metal::DataSet do
 
     it 'should send update statement with given consistency' do
       expect_query_with_consistency(->(s){/UPDATE/ === s.cql}, :one) do
-        cequel[:posts].where(row_keys).update(
+        cequel[posts_tn].where(row_keys).update(
           {title: 'Marshmallows'}, consistency: :one)
       end
     end
 
     it 'should overwrite list column' do
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         update(categories: ['Big Data', 'Cassandra'])
-      expect(cequel[:posts].where(row_keys).first[:categories]).
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).
         to eq(['Big Data', 'Cassandra'])
     end
 
     it 'should overwrite set column' do
-      cequel[:posts].where(row_keys).update(tags: Set['big-data', 'nosql'])
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      cequel[posts_tn].where(row_keys).update(tags: Set['big-data', 'nosql'])
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['big-data', 'nosql'])
     end
 
     it 'should overwrite map column' do
       time1 = Time.at(Time.now.to_i)
       time2 = Time.at(10.minutes.ago.to_i)
-      cequel[:posts].where(row_keys).update(
+      cequel[posts_tn].where(row_keys).update(
         trackbacks: {time1 => 'foo', time2 => 'bar'})
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq({time1 => 'foo', time2 => 'bar'})
     end
 
     it 'should perform various types of update in one go' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(title: 'Big Data',
                        body: 'Cassandra',
                        categories: ['Scalability']))
-      cequel[:posts].where(row_keys).update do
+      cequel[posts_tn].where(row_keys).update do
         set(title: 'Bigger Data')
         list_append(:categories, 'Fault-Tolerance')
       end
-      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Bigger Data')
-      expect(cequel[:posts].where(row_keys).first[:categories]).
+      expect(cequel[posts_tn].where(row_keys).first[:title]).to eq('Bigger Data')
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).
         to eq(%w(Scalability Fault-Tolerance))
     end
 
     it 'should use the last value set for a given column' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(title: 'Big Data',
                        body: 'Cassandra',
                        categories: ['Scalability']))
-      cequel[:posts].where(row_keys).update do
+      cequel[posts_tn].where(row_keys).update do
         set(title: 'Bigger Data')
         set(title: 'Even Bigger Data')
       end
-      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Even Bigger Data')
+      expect(cequel[posts_tn].where(row_keys).first[:title]).to eq('Even Bigger Data')
     end
   end
 
   describe '#list_prepend' do
     it 'should prepend a single element to list column' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_prepend(:categories, 'Scalability')
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Scalability', 'Big Data', 'Cassandra']
       )
     end
@@ -194,9 +197,9 @@ describe Cequel::Metal::DataSet do
     # breaks in Cassandra 2.0.13+ or 2.1.3+ because reverse order bug was fixed:
     # https://issues.apache.org/jira/browse/CASSANDRA-8733
     it 'should prepend multiple elements to list column' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_prepend(:categories, ['Scalability', 'Partition Tolerance'])
 
       expected = if cequel.bug8733_version?
@@ -205,27 +208,27 @@ describe Cequel::Metal::DataSet do
         ['Scalability', 'Partition Tolerance', 'Big Data', 'Cassandra']
       end
 
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(expected)
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(expected)
     end
   end
 
   describe '#list_append' do
     it 'should append single element to list column' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_append(:categories, 'Scalability')
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Cassandra', 'Scalability']
       )
     end
 
     it 'should append multiple elements to list column' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_append(:categories, ['Scalability', 'Partition Tolerance'])
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Cassandra', 'Scalability', 'Partition Tolerance']
       )
     end
@@ -233,11 +236,11 @@ describe Cequel::Metal::DataSet do
 
   describe '#list_replace' do
     it 'should add to list at specified index' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_replace(:categories, 1, 'C*')
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'C*', 'Scalability']
       )
     end
@@ -245,21 +248,21 @@ describe Cequel::Metal::DataSet do
 
   describe '#list_remove' do
     it 'should remove from list by specified value' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_remove(:categories, 'Cassandra')
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Big Data', 'Scalability']
       )
     end
 
     it 'should remove from list by multiple values' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra', 'Scalability']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         list_remove(:categories, ['Big Data', 'Cassandra'])
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).to eq(
         ['Scalability']
       )
     end
@@ -267,37 +270,37 @@ describe Cequel::Metal::DataSet do
 
   describe '#set_add' do
     it 'should add one element to set' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(tags: Set['big-data', 'nosql']))
-      cequel[:posts].where(row_keys).set_add(:tags, 'cassandra')
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      cequel[posts_tn].where(row_keys).set_add(:tags, 'cassandra')
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['big-data', 'nosql', 'cassandra'])
     end
 
     it 'should add multiple elements to set' do
-      cequel[:posts].insert(row_keys.merge(tags: Set['big-data', 'nosql']))
-      cequel[:posts].where(row_keys).set_add(:tags, 'cassandra')
+      cequel[posts_tn].insert(row_keys.merge(tags: Set['big-data', 'nosql']))
+      cequel[posts_tn].where(row_keys).set_add(:tags, 'cassandra')
 
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['big-data', 'nosql', 'cassandra'])
     end
   end
 
   describe '#set_remove' do
     it 'should remove elements from set' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(tags: Set['big-data', 'nosql', 'cassandra']))
-      cequel[:posts].where(row_keys).set_remove(:tags, 'cassandra')
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      cequel[posts_tn].where(row_keys).set_remove(:tags, 'cassandra')
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['big-data', 'nosql'])
     end
 
     it 'should remove multiple elements from set' do
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(tags: Set['big-data', 'nosql', 'cassandra']))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         set_remove(:tags, Set['nosql', 'cassandra'])
-      expect(cequel[:posts].where(row_keys).first[:tags]).
+      expect(cequel[posts_tn].where(row_keys).first[:tags]).
         to eq(Set['big-data'])
     end
   end
@@ -307,10 +310,10 @@ describe Cequel::Metal::DataSet do
       time1 = Time.at(Time.now.to_i)
       time2 = Time.at(10.minutes.ago.to_i)
       time3 = Time.at(1.hour.ago.to_i)
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar'}))
-      cequel[:posts].where(row_keys).map_update(:trackbacks, time3 => 'baz')
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      cequel[posts_tn].where(row_keys).map_update(:trackbacks, time3 => 'baz')
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq({time1 => 'foo', time2 => 'bar', time3 => 'baz'})
     end
 
@@ -318,24 +321,24 @@ describe Cequel::Metal::DataSet do
       time1 = Time.at(Time.now.to_i)
       time2 = Time.at(10.minutes.ago.to_i)
       time3 = Time.at(1.hour.ago.to_i)
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar'}))
-      cequel[:posts].where(row_keys).
+      cequel[posts_tn].where(row_keys).
         map_update(:trackbacks, time1 => 'FOO', time3 => 'baz')
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq({time1 => 'FOO', time2 => 'bar', time3 => 'baz'})
     end
   end
 
   describe '#increment' do
-    after { cequel.schema.truncate_table(:post_activity) }
+    after { cequel.schema.truncate_table(post_act_tn) }
 
     it 'should increment counter columns' do
-      cequel[:post_activity].
+      cequel[post_act_tn].
         where(row_keys).
         increment(visits: 1, tweets: 2)
 
-      row = cequel[:post_activity].where(row_keys).first
+      row = cequel[post_act_tn].where(row_keys).first
 
       expect(row[:visits]).to eq(1)
       expect(row[:tweets]).to eq(2)
@@ -343,13 +346,13 @@ describe Cequel::Metal::DataSet do
   end
 
   describe '#decrement' do
-    after { cequel.schema.truncate_table(:post_activity) }
+    after { cequel.schema.truncate_table(post_act_tn) }
 
     it 'should decrement counter columns' do
-      cequel[:post_activity].where(row_keys).
+      cequel[post_act_tn].where(row_keys).
         decrement(visits: 1, tweets: 2)
 
-      row = cequel[:post_activity].where(row_keys).first
+      row = cequel[post_act_tn].where(row_keys).first
       expect(row[:visits]).to eq(-1)
       expect(row[:tweets]).to eq(-2)
     end
@@ -357,18 +360,18 @@ describe Cequel::Metal::DataSet do
 
   describe '#delete' do
     before do
-      cequel[:posts].
+      cequel[posts_tn].
         insert(row_keys.merge(title: 'Big Data', body: 'It\'s big.'))
     end
 
     it 'should send basic delete statement' do
-      cequel[:posts].where(row_keys).delete
-      expect(cequel[:posts].where(row_keys).first).to be_nil
+      cequel[posts_tn].where(row_keys).delete
+      expect(cequel[posts_tn].where(row_keys).first).to be_nil
     end
 
     it 'should send delete statement for specified columns' do
-      cequel[:posts].where(row_keys).delete(:body)
-      row = cequel[:posts].where(row_keys).first
+      cequel[posts_tn].where(row_keys).delete(:body)
+      row = cequel[posts_tn].where(row_keys).first
       expect(row[:body]).to be_nil
       expect(row[:title]).to eq('Big Data')
     end
@@ -376,10 +379,10 @@ describe Cequel::Metal::DataSet do
     it 'should send delete statement with writetime option' do
       time = Time.now - 10.minutes
 
-      cequel[:posts].where(row_keys).delete(
+      cequel[posts_tn].where(row_keys).delete(
         :body, :timestamp => time
       )
-      row = cequel[:posts].select(:body).where(row_keys).first
+      row = cequel[posts_tn].select(:body).where(row_keys).first
       expect(row[:body]).to eq('It\'s big.')
       # This means timestamp is working, since the earlier timestamp would cause
       # Cassandra to ignore the deletion
@@ -387,25 +390,25 @@ describe Cequel::Metal::DataSet do
 
     it 'should send delete with specified consistency' do
       expect_query_with_consistency(->(s){/DELETE/ === s.cql}, :one) do
-        cequel[:posts].where(row_keys).delete(:body, :consistency => :one)
+        cequel[posts_tn].where(row_keys).delete(:body, :consistency => :one)
       end
     end
   end
 
   describe '#list_remove_at' do
     it 'should remove element at specified position from list' do
-      cequel[:posts].
+      cequel[posts_tn].
         insert(row_keys.merge(categories: ['Big Data', 'NoSQL', 'Cassandra']))
-      cequel[:posts].where(row_keys).list_remove_at(:categories, 1)
-      expect(cequel[:posts].where(row_keys).first[:categories]).
+      cequel[posts_tn].where(row_keys).list_remove_at(:categories, 1)
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).
         to eq(['Big Data', 'Cassandra'])
     end
 
     it 'should remove element at specified positions from list' do
-      cequel[:posts].
+      cequel[posts_tn].
         insert(row_keys.merge(categories: ['Big Data', 'NoSQL', 'Cassandra']))
-      cequel[:posts].where(row_keys).list_remove_at(:categories, 0, 2)
-      expect(cequel[:posts].where(row_keys).first[:categories]).
+      cequel[posts_tn].where(row_keys).list_remove_at(:categories, 0, 2)
+      expect(cequel[posts_tn].where(row_keys).first[:categories]).
         to eq(['NoSQL'])
     end
   end
@@ -415,10 +418,10 @@ describe Cequel::Metal::DataSet do
       time1 = Time.at(Time.now.to_i)
       time2 = Time.at(10.minutes.ago.to_i)
       time3 = Time.at(1.hour.ago.to_i)
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar', time3 => 'baz'}))
-      cequel[:posts].where(row_keys).map_remove(:trackbacks, time2)
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      cequel[posts_tn].where(row_keys).map_remove(:trackbacks, time2)
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq({time1 => 'foo', time3 => 'baz'})
     end
 
@@ -426,23 +429,23 @@ describe Cequel::Metal::DataSet do
       time1 = Time.at(Time.now.to_i)
       time2 = Time.at(10.minutes.ago.to_i)
       time3 = Time.at(1.hour.ago.to_i)
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         trackbacks: {time1 => 'foo', time2 => 'bar', time3 => 'baz'}))
-      cequel[:posts].where(row_keys).map_remove(:trackbacks, time1, time3)
-      expect(cequel[:posts].where(row_keys).first[:trackbacks]).
+      cequel[posts_tn].where(row_keys).map_remove(:trackbacks, time1, time3)
+      expect(cequel[posts_tn].where(row_keys).first[:trackbacks]).
         to eq({time2 => 'bar'})
     end
   end
 
   describe '#cql' do
     it 'should generate select statement with all columns' do
-      expect(cequel[:posts].cql.to_s).to eq('SELECT * FROM posts')
+      expect(cequel[posts_tn].cql.to_s).to eq("SELECT * FROM #{posts_tn}")
     end
   end
 
   describe '#select' do
     before do
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         title: 'Big Data',
         body: 'Fault Tolerance',
         published_at: Time.now
@@ -450,24 +453,24 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should generate select statement with given columns' do
-      expect(cequel[:posts].select(:title, :body).where(row_keys).first.
+      expect(cequel[posts_tn].select(:title, :body).where(row_keys).first.
         keys).to eq(%w(title body))
     end
 
     it 'should accept array argument' do
-      expect(cequel[:posts].select([:title, :body]).where(row_keys).first.
+      expect(cequel[posts_tn].select([:title, :body]).where(row_keys).first.
         keys).to eq(%w(title body))
     end
 
     it 'should combine multiple selects' do
-      expect(cequel[:posts].select(:title).select(:body).where(row_keys).first.
+      expect(cequel[posts_tn].select(:title).select(:body).where(row_keys).first.
         keys).to eq(%w(title body))
     end
   end
 
   describe '#select!' do
     before do
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         title: 'Big Data',
         body: 'Fault Tolerance',
         published_at: Time.now
@@ -475,14 +478,14 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should override select statement with given columns' do
-      expect(cequel[:posts].select(:title, :body).select!(:published_at).
+      expect(cequel[posts_tn].select(:title, :body).select!(:published_at).
         where(row_keys).first.keys).to eq(%w(published_at))
     end
   end
 
   describe '#where' do
     before do
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         title: 'Big Data',
         body: 'Fault Tolerance',
         published_at: Time.now
@@ -490,49 +493,49 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should build WHERE statement from hash' do
-      expect(cequel[:posts].where(blog_subdomain: row_keys[:blog_subdomain]).
+      expect(cequel[posts_tn].where(blog_subdomain: row_keys[:blog_subdomain]).
         first[:title]).to eq('Big Data')
-      expect(cequel[:posts].where(blog_subdomain: 'foo').first).to be_nil
+      expect(cequel[posts_tn].where(blog_subdomain: 'foo').first).to be_nil
     end
 
     it 'should build WHERE statement from multi-element hash' do
-      expect(cequel[:posts].where(row_keys).first[:title]).to eq('Big Data')
-      expect(cequel[:posts].where(row_keys.merge(:permalink => 'foo')).
+      expect(cequel[posts_tn].where(row_keys).first[:title]).to eq('Big Data')
+      expect(cequel[posts_tn].where(row_keys.merge(:permalink => 'foo')).
         first).to be_nil
     end
 
     it 'should build WHERE statement with IN' do
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         blog_subdomain: 'big-data-weekly',
         title: 'Cassandra',
       ))
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         blog_subdomain: 'bogus-blog',
         title: 'Bogus Post',
       ))
-      expect(cequel[:posts].where(
+      expect(cequel[posts_tn].where(
         :blog_subdomain => %w(cassandra big-data-weekly)
       ).map { |row| row[:title] }).to match_array(['Big Data', 'Cassandra'])
     end
 
     it 'should use = if provided one-element array' do
-      expect(cequel[:posts].
+      expect(cequel[posts_tn].
         where(row_keys.merge(blog_subdomain: [row_keys[:blog_subdomain]])).
         first[:title]).to eq('Big Data')
     end
 
     it 'should build WHERE statement from CQL string' do
-      expect(cequel[:posts].where("blog_subdomain = '#{row_keys[:blog_subdomain]}'").
+      expect(cequel[posts_tn].where("blog_subdomain = '#{row_keys[:blog_subdomain]}'").
         first[:title]).to eq('Big Data')
     end
 
     it 'should build WHERE statement from CQL string with bind variables' do
-      expect(cequel[:posts].where("blog_subdomain = ?", row_keys[:blog_subdomain]).
+      expect(cequel[posts_tn].where("blog_subdomain = ?", row_keys[:blog_subdomain]).
         first[:title]).to eq('Big Data')
     end
 
     it 'should aggregate multiple WHERE statements' do
-      expect(cequel[:posts].where(:blog_subdomain => row_keys[:blog_subdomain]).
+      expect(cequel[posts_tn].where(:blog_subdomain => row_keys[:blog_subdomain]).
         where('permalink = ?', row_keys[:permalink]).
         first[:title]).to eq('Big Data')
     end
@@ -541,7 +544,7 @@ describe Cequel::Metal::DataSet do
 
   describe '#where!' do
     before do
-      cequel[:posts].insert(row_keys.merge(
+      cequel[posts_tn].insert(row_keys.merge(
         title: 'Big Data',
         body: 'Fault Tolerance',
         published_at: Time.now
@@ -549,7 +552,7 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should override chained conditions' do
-      expect(cequel[:posts].where(:permalink => 'bogus').
+      expect(cequel[posts_tn].where(:permalink => 'bogus').
         where!(:blog_subdomain => row_keys[:blog_subdomain]).
         first[:title]).to eq('Big Data')
     end
@@ -557,37 +560,37 @@ describe Cequel::Metal::DataSet do
 
   describe '#limit' do
     before do
-      cequel[:posts].insert(row_keys.merge(title: 'Big Data'))
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(row_keys.merge(title: 'Big Data'))
+      cequel[posts_tn].insert(
         row_keys.merge(permalink: 'marshmallows', title: 'Marshmallows'))
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(permalink: 'zz-top', title: 'ZZ Top'))
     end
 
     it 'should add LIMIT' do
-      expect(cequel[:posts].where(row_keys.slice(:blog_subdomain)).limit(2).
+      expect(cequel[posts_tn].where(row_keys.slice(:blog_subdomain)).limit(2).
         map { |row| row[:title] }).to eq(['Big Data', 'Marshmallows'])
     end
   end
 
   describe '#order' do
     before do
-      cequel[:posts].insert(row_keys.merge(title: 'Big Data'))
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(row_keys.merge(title: 'Big Data'))
+      cequel[posts_tn].insert(
         row_keys.merge(permalink: 'marshmallows', title: 'Marshmallows'))
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(
         row_keys.merge(permalink: 'zz-top', title: 'ZZ Top'))
     end
 
     it 'should add order' do
-      expect(cequel[:posts].where(row_keys.slice(:blog_subdomain)).
+      expect(cequel[posts_tn].where(row_keys.slice(:blog_subdomain)).
         order(permalink: 'desc').map { |row| row[:title] }).
         to eq(['ZZ Top', 'Marshmallows', 'Big Data'])
     end
   end
 
   describe '#consistency' do
-    let(:data_set) { cequel[:posts].consistency(:one) }
+    let(:data_set) { cequel[posts_tn].consistency(:one) }
 
     it 'should issue SELECT with scoped consistency' do
       expect_query_with_consistency(anything, :one) { data_set.to_a }
@@ -621,7 +624,7 @@ describe Cequel::Metal::DataSet do
   describe 'default consistency' do
     before(:all) { cequel.default_consistency = :all }
     after(:all) { cequel.default_consistency = nil }
-    let(:data_set) { cequel[:posts] }
+    let(:data_set) { cequel[posts_tn] }
 
     it 'should issue SELECT with default consistency' do
       expect_query_with_consistency(anything, :all) { data_set.to_a }
@@ -653,7 +656,7 @@ describe Cequel::Metal::DataSet do
   end
 
   describe '#page_size' do
-    let(:data_set) { cequel[:posts].page_size(1) }
+    let(:data_set) { cequel[posts_tn].page_size(1) }
 
     it 'should issue SELECT with scoped page size' do
       expect_query_with_options(->(s){/SELECT/ === s.cql}, :page_size => 1) { data_set.to_a }
@@ -661,7 +664,7 @@ describe Cequel::Metal::DataSet do
   end
 
   describe '#paging_state' do
-    let(:data_set) { cequel[:posts].paging_state(nil) }
+    let(:data_set) { cequel[posts_tn].paging_state(nil) }
 
     it 'should issue SELECT with scoped paging state' do
       expect_query_with_options(->(s){/SELECT/ === s.cql}, :paging_state => nil) { data_set.to_a }
@@ -672,25 +675,25 @@ describe Cequel::Metal::DataSet do
     let(:row) { row_keys.merge(:title => 'Big Data') }
 
     before do
-      cequel[:posts].insert(row)
+      cequel[posts_tn].insert(row)
     end
 
     it 'should enumerate over results' do
-      expect(cequel[:posts].to_a.map { |row| row.select { |k, v| v }}).
+      expect(cequel[posts_tn].to_a.map { |row| row.select { |k, v| v }}).
         to eq([row.stringify_keys])
     end
 
     it 'should provide results with indifferent access' do
-      expect(cequel[:posts].to_a.first[:blog_permalink]).
+      expect(cequel[posts_tn].to_a.first[:blog_permalink]).
         to eq(row_keys[:blog_permalink])
     end
 
     it 'should not run query if no block given to #each' do
-      expect { cequel[:posts].each }.to_not raise_error
+      expect { cequel[posts_tn].each }.to_not raise_error
     end
 
     it 'should return Enumerator if no block given to #each' do
-      expect(cequel[:posts].each.each_with_index.
+      expect(cequel[posts_tn].each.each_with_index.
         map { |row, i| [row[:blog_permalink], i] }).
         to eq([[row[:blog_permalink], 0]])
     end
@@ -700,34 +703,34 @@ describe Cequel::Metal::DataSet do
     let(:row) { row_keys.merge(:title => 'Big Data') }
 
     before do
-      cequel[:posts].insert(row)
-      cequel[:posts].insert(
+      cequel[posts_tn].insert(row)
+      cequel[posts_tn].insert(
         row_keys.merge(:permalink => 'zz-top', :title => 'ZZ Top'))
     end
 
     it 'should run a query with LIMIT 1 and return first row' do
-      expect(cequel[:posts].first.select { |k, v| v }).to eq(row.stringify_keys)
+      expect(cequel[posts_tn].first.select { |k, v| v }).to eq(row.stringify_keys)
     end
   end
 
   describe '#count' do
     before do
       4.times do |i|
-        cequel[:posts].insert(row_keys.merge(
+        cequel[posts_tn].insert(row_keys.merge(
           permalink: "post-#{i}", title: "Post #{i}"))
       end
     end
 
     it 'should raise DangerousQueryError when attempting to count' do
-      expect{ cequel[:posts].count }.to raise_error(Cequel::Record::DangerousQueryError)
+      expect{ cequel[posts_tn].count }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
     it 'should raise DangerousQueryError when attempting to access size' do
-      expect{ cequel[:posts].size }.to raise_error(Cequel::Record::DangerousQueryError)
+      expect{ cequel[posts_tn].size }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
     it 'should raise DangerousQueryError when attempting to access length' do
-      expect{ cequel[:posts].length }.to raise_error(Cequel::Record::DangerousQueryError)
+      expect{ cequel[posts_tn].length }.to raise_error(Cequel::Record::DangerousQueryError)
     end
   end
 end