cleansweep 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3cbb9366208c06f5d514941f464a4f87dcc1a5a
-  data.tar.gz: 47d8ffbb89cc27024bbd20d6af95275e0c05f978
+  metadata.gz: 171c5ce6b972df17162909a1538cf8ecc867e347
+  data.tar.gz: 6d91698f6759a599e03683287ea230230d99a475
 SHA512:
-  metadata.gz: c60c9e771c8711d67e548e8c68258ab5f6407675f96efdf27f7b31d2308c2b4a75e9c3a87d514fff67b54aab2fedab1621a6560dbb74146badee7930b57f6061
-  data.tar.gz: 4fa1bb94eff78d05bd7c2946d567dfb32a09bda50fcae7a305be431b486e0d253288079055771d391bfd21bb3ef2978bafba6044a4f361d259a00a8cbcf2c738
+  metadata.gz: 5373eb62b1acbf097681efde6a1ad08ad94c574ee5676546e0c798ba91d93a8a28efc97fe8f4ce95e8b5f0ee8f1e4b12e340c6cdf0a78e901589ecbc85f4fee5
+  data.tar.gz: 199c96ba5a90457bd6d3310b59a293de1dd185d84b009d1f849ce13637210415606ba29fd704312186c8767aaaf9990e902bfcbc7d4e561f28f200112ef83f0e

data/CHANGES.md

@@ -1,5 +1,11 @@
 See the [documentation](http://bkayser.github.io/cleansweep) for details
 
-# Version 1.0.1
+### Version 1.0.1
 
-* Initial release
+* Initial release
+
+### Version 1.0.2
+
+* Changed destination options so you can delete from a different table.
+* Added `dest_columns` option as a map of column names in the source to column names in the destination.
+* More testing and bug fixing in real environments

data/README.md

@@ -1,5 +1,6 @@
-Cleansweep is a utility for scripting purges using ruby in an efficient, low-impact manner on
-mysql innodb tables.  Based on the Percona `pt-archive` utility.
+Cleansweep is a utility for scripting purges using ruby in an
+efficient, low-impact manner on mysql innodb tables.  Based on the
+Percona `pt-archive` utility.
 
 ## Installation
 
@@ -35,12 +36,13 @@ Assume there is an active record model for it:
 
 ### Purging by traversing an index
 
-The most efficient way to work through a table is by scanning through an index one chunk
-at a time.
+The most efficient way to work through a table is by scanning through
+an index one chunk at a time.
 
 Let's assume we want to purge Comments older than 1 month.  We can
-scan the primary key index or the `account`,`timestamp` index.  In this case the latter will
-probably work better since we are evaluating the timestamp for the purge.
+scan the primary key index or the `account`,`timestamp` index.  In
+this case the latter will probably work better since we are evaluating
+the timestamp for the purge.
 
 ```ruby
     r = CleanSweep::PurgeRunner.new model: Comment,
@@ -62,7 +64,8 @@ Check what it will do:
     r.print_queries($stdout)
 ```
 
-This will show you what it will do by printing out the three different statements used:
+This will show you what it will do by printing out the three different
+statements used:
 
 ```sql
     Initial Query:
@@ -82,13 +85,15 @@ This will show you what it will do by printing out the three different statement
         WHERE (`id` = 2)
 ```
 
-It does the initial statement once to get the first chunk of rows.  Then it does subsequent queries
-starting at the index where the last chunk left off, thereby avoiding a complete index scan.  This works
-fine as long as you don't have rows with duplicate account id and timestamps.  If you do, you'll possibly
-miss rows between chunks.
+It does the initial statement once to get the first chunk of rows.
+Then it does subsequent queries starting at the index where the last
+chunk left off, thereby avoiding a complete index scan.  This works
+fine as long as you don't have rows with duplicate account id and
+timestamps.  If you do, you'll possibly miss rows between chunks.
 
-To avoid missing duplicates, you can traverse the index using only the first column with an inclusive comparator
-like `>=` instead of `>`.  Here's what that would look like:
+To avoid missing duplicates, you can traverse the index using only the
+first column with an inclusive comparator like `>=` instead of `>`.
+Here's what that would look like:
 
 ```ruby
     r = CleanSweep::PurgeRunner.new model:Comment,
@@ -107,48 +112,70 @@ The chunk query looks like:
     LIMIT 500
 ```
 
-You can scan the index in either direction.  To specify descending order, use the `reverse: true` option.
+You can scan the index in either direction.  To specify descending
+order, use the `reverse: true` option.
 
 ### Copying rows from one table to another
 
-You can use the same technique to copy rows from one table to another.  Support in CleanSweep is pretty
-minimal.  It won't _move_ rows, only copy them, although it would be easy to fix this.
-I used this to copy ids into a temporary table which I then
-used to delete later.
+You can use the same technique to copy rows from one table to another.
+Support in CleanSweep is pretty minimal.  It won't _move_ rows, only
+copy them, although it would be easy to fix this.  I used this to copy
+ids into a temporary table which I then used to delete later.
 
-Here's an example that copies rows from the `Comment` model to the `ExpiredComment` model (`expired_comments`).
-Comments older than one week are copied.
+Here's an example that copies rows from the `Comment` model to the
+`ExpiredComment` model (`expired_comments`).  Comments older than one
+week are copied.
 
 ```ruby
       copier = CleanSweep::PurgeRunner.new model: Comment,
                                            index: 'comments_on_account_timestamp',
                                            dest_model: ExpiredComment,
+                                           copy_only: true,
                                            copy_columns: %w[liked] do do | model |
         model.where('last_used_at < ?', 1.week.ago)
       end
 ```
 
-The `copy_columns` option specifies additional columns to be inserted into the `expired_comments` table.
+The `copy_columns` option specifies additional columns to be inserted
+into the `expired_comments` table.
+
+If the column names are different in the destination table than in the
+source table, you can specify a mapping with the `dest_columns` option
+which takes a map of source column name to destination name.
+
+### Deleting rows in another table
+
+What if you want to query one table and delete those rows in another?
+I needed this when I built a temporary table of account ids that
+referenced deleted accounts.  I then wanted to delete rows in other
+tables that referenced those account ids.  To do that, specify a
+`dest_table` without specifying `copy_only` mode.  This will execute
+the delete statement on the destination table without removing rows
+from the source table.
 
 ### Watching the history list and replication lag
 
-You can enter thresholds for the history list size and replication lag that will be used to pause the
-purge if either of those values get into an unsafe territory.  The script will pause for 5 minutes and
-only start once the corresponding metric goes back down to 90% of the specified threshold.
+You can enter thresholds for the history list size and replication lag
+that will be used to pause the purge if either of those values get
+into an unsafe territory.  The script will pause for 5 minutes and
+only start once the corresponding metric goes back down to 90% of the
+specified threshold.
 
 ### Logging and monitoring progress
 
-You pass in a standard log instance to capture all running output.  By default it will log to your
-`ActiveRecord::Base` logger, or stdout if that's not set up.
+You pass in a standard log instance to capture all running output.  By
+default it will log to your `ActiveRecord::Base` logger, or stdout if
+that's not set up.
 
-If you specify a reporting interval
-with the `report` option it will print the status of the purge at that interval.  This is useful to track
-progress and assess the rate of deletion.
+If you specify a reporting interval with the `report` option it will
+print the status of the purge at that interval.  This is useful to
+track progress and assess the rate of deletion.
 
 ### Joins and subqueries
 
-You can add subqueries and joins to your query in the scope block, but be careful.  The index and order
-clause may work against you if the table you are joining with doesn't have good parity with the indexes
+You can add subqueries and joins to your query in the scope block, but
+be careful.  The index and order clause may work against you if the
+table you are joining with doesn't have good parity with the indexes
 in your target table.
 
 ### Limitations
@@ -165,21 +192,24 @@ in your target table.
 
 ### Other options
 
-There are a number of other options you can use to tune the script.  For details look at the
-[API on the `PurgeRunner` class](http://bkayser.github.io/cleansweep/rdoc/CleanSweep/PurgeRunner.html)
+There are a number of other options you can use to tune the script.
+For details look at the [API on the `PurgeRunner`
+class](http://bkayser.github.io/cleansweep/rdoc/CleanSweep/PurgeRunner.html)
 
 ### NewRelic integration
 
-The script requires the [New Relic](http://github.com/newrelic/rpm) gem.  It won't impact anyting if you
-don't have a New Relic account to report to, but if you do use New Relic it is configured to show you
-detailed metrics.  I recommend turning off transaction traces for long purge jobs to reduce your memory
-footprint.
+The script requires the [New Relic](http://github.com/newrelic/rpm)
+gem.  It won't impact anyting if you don't have a New Relic account to
+report to, but if you do use New Relic it is configured to show you
+detailed metrics.  I recommend turning off transaction traces for long
+purge jobs to reduce your memory footprint.
 
 ## Testing
 
-To run the specs, start a local mysql instance.  The default user is root with an empty password.
-Override the user/password with environment variables `DB_USER` and `DB_PASSWORD`.  The test
-creates a db called 'cstest'.
+To run the specs, start a local mysql instance.  The default user is
+root with an empty password.  Override the user/password with
+environment variables `DB_USER` and `DB_PASSWORD`.  The test creates a
+db called 'cstest'.
 
 ## Contributing
 
@@ -197,5 +227,6 @@ Covered by the MIT [LICENSE](LICENSE.txt).
 
 ### Credits
 
-This was all inspired and informed by [Percona's `pt-archiver` script](http://www.percona.com/doc/percona-toolkit/2.1/pt-archiver.html)
+This was all inspired and informed by [Percona's `pt-archiver`
+script](http://www.percona.com/doc/percona-toolkit/2.1/pt-archiver.html)
 written by Baron Schwartz.

data/cleansweep.gemspec

@@ -9,11 +9,15 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Bill Kayser"]
   spec.email         = ["bkayser@newrelic.com"]
   spec.summary       = %q{Utility to purge or archive rows in mysql tables}
+
+  spec.platform      = Gem::Platform::RUBY
+  spec.required_ruby_version = '~> 2'
+
   spec.description   = <<-EOF
      Purge data from mysql innodb tables efficiently with low overhead and impact.
      Based on the Percona pt-archive utility.
   EOF
-  spec.homepage      = "http://github.com/bkayser/cleansweep"
+  spec.homepage      = "http://bkayser.github.com/cleansweep"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -23,7 +27,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'activerecord', '>= 3.0'
   spec.add_runtime_dependency 'newrelic_rpm'
-  spec.add_runtime_dependency 'mysql2', '~> 0.3.17'
+  spec.add_runtime_dependency 'mysql2', '~> 0.3'
 
   spec.add_development_dependency 'pry', '~> 0'
   spec.add_development_dependency 'bundler', '~> 1.7'

data/lib/clean_sweep/purge_runner.rb

@@ -36,11 +36,23 @@ require 'stringio'
 #    The log instance to use.  Defaults to the <tt>ActiveRecord::Base.logger</tt>
 #    if not nil, otherwise it uses _$stdout_
 # [:dest_model]
-#    When this option is present nothing is deleted, and instead rows are copied to
-#    the table for this model.  This model must
-#    have identically named columns as the source model.  By default, only columns in the
+#    Specifies the model for the delete operation, or the copy operation if in copy mode.
+#    When this option is present nothing is deleted in the model table.  Instead, rows
+#    are either inserted into this table or deleted from this table.
+#    The columns in this model must include the primary key columns found in the source
+#    model.  If they have different names you need to specify them with the
+#    <tt>dest_columns</tt> option.
+# [:copy_only]
+#    Specifies copy mode, where rows are inserted into the destination table instead of deleted from
+#    the model table. By default, only columns in the
 #    named index and primary key are copied but these can be augmented with columns in the
 #    <tt>copy_columns</tt> option.
+# [:dest_columns]
+#    This is a map of column names in the model to column names in the dest model when the
+#    corresponding models differ.  Only column names that are different need to be specified.
+#    For instance your table of account ids might have <tt>account_id</tt>
+#    as the primary key column, but you want to delete rows in the accounts table where the account id is
+#    the column named <tt>id</tt>
 # [:copy_columns]
 #    Extra columns to add when copying to a dest model.
 #
@@ -79,11 +91,15 @@ class CleanSweep::PurgeRunner
     @max_history      = options[:max_history]
     @max_repl_lag     = options[:max_repl_lag]
 
+    @copy_mode        = @target_model && options[:copy_only]
+
     @table_schema     = CleanSweep::TableSchema.new @model,
                                                     key_name: options[:index],
                                                     ascending: !options[:reverse],
                                                     extra_columns: options[:copy_columns],
-                                                    first_only: options[:first_only]
+                                                    first_only: options[:first_only],
+                                                    dest_model: @target_model,
+                                                    dest_columns: options[:dest_columns]
 
     if (@max_history || @max_repl_lag)
       @mysql_status = CleanSweep::PurgeRunner::MysqlStatus.new model: @model,
@@ -106,7 +122,7 @@ class CleanSweep::PurgeRunner
 
 
   def copy_mode?
-    @target_model.present?    
+    @copy_mode
   end
 
   # Execute the purge in chunks according to the parameters given on instance creation.
@@ -117,7 +133,10 @@ class CleanSweep::PurgeRunner
   #
   def execute_in_batches
 
-    print_queries($stdout) and return 0 if @dry_run
+    if @dry_run
+      print_queries($stdout)
+      return 0
+    end
 
     @start = Time.now
     verb = copy_mode? ? "copying" : "purging"
@@ -146,7 +165,7 @@ class CleanSweep::PurgeRunner
       last_row = rows.last
       if copy_mode?
         metric_op_name = 'INSERT'
-        statement = @table_schema.insert_statement(@target_model, rows)
+        statement = @table_schema.insert_statement(rows)
       else
         metric_op_name = 'DELETE'
         statement = @table_schema.delete_statement(rows)
@@ -190,11 +209,16 @@ class CleanSweep::PurgeRunner
     io.puts 'Initial Query:'
     io.puts format_query('    ', @query.to_sql)
     rows = @model.connection.select_rows @query.limit(1).to_sql
+    if rows.empty?
+      # Don't have any sample data to use for the sample queries, so use NULL values just
+      # so the query will print out.
+      rows << [nil] * 100
+    end
     io.puts "Chunk Query:"
     io.puts format_query('    ', @table_schema.scope_to_next_chunk(@query, rows.first).to_sql)
     if copy_mode?
       io.puts "Insert Statement:"
-      io.puts format_query('    ', @table_schema.insert_statement(@target_model, rows))
+      io.puts format_query('    ', @table_schema.insert_statement(rows))
     else
       io.puts "Delete Statement:"
       io.puts format_query('    ', @table_schema.delete_statement(rows))

data/lib/clean_sweep/table_schema/column_schema.rb

@@ -1,23 +1,39 @@
 class CleanSweep::TableSchema::ColumnSchema
 
-  attr_reader :name
+  attr_reader :name, :ar_column
   attr_accessor :select_position
+  attr_writer :dest_name
 
   def initialize(name, model)
     @name = name.to_sym
     col_num = model.column_names.index(name.to_s) or raise "Can't find #{name} in #{model.name}"
     @model = model
-    @column = model.columns[col_num]
+    @ar_column = model.columns[col_num]
   end
 
   def quoted_name
-    "`#{name}`"
+    quote_column_name(@model, name)
   end
+
+  def quoted_dest_name(dest_model)
+    quote_column_name(dest_model, @dest_name || @name)
+  end
+
   def value(row)
     row[select_position]
   end
+
   def quoted_value(row)
-    @model.quote_value(value(row), @column)
+    @model.quote_value(value(row), @ar_column)
+  end
+
+  def == other
+    return other && name == other.name
+  end
+
+  private
+  def quote_column_name(model, column_name)
+    model.connection.quote_table_name(model.table_name) + "." + model.connection.quote_column_name(column_name)
   end
 end
 

data/lib/clean_sweep/table_schema/index_schema.rb

@@ -1,6 +1,6 @@
 class CleanSweep::TableSchema::IndexSchema < Struct.new :name, :model, :ascending
 
-  attr_accessor :columns, :name, :model, :ascending, :first_only
+  attr_accessor :columns, :name, :model, :ascending, :first_only, :dest_model
 
   def initialize name, model
     @model = model
@@ -16,12 +16,12 @@ class CleanSweep::TableSchema::IndexSchema < Struct.new :name, :model, :ascendin
   # Take columns referenced by this index and add them to the list if they
   # are not present.  Record their position in the list because the position will
   # be where they are located in a row of values passed in later to #scope_to_next_chunk
-  def add_columns_to select_columns
+  def add_columns_to columns
     @columns.each do | column |
-      pos = select_columns.index column.name
+      pos = columns.index column
       if pos.nil?
-        select_columns << column.name
-        pos = select_columns.size - 1
+        columns << column
+        pos = columns.size - 1
       end
       column.select_position = pos
     end

data/lib/clean_sweep/table_schema.rb

@@ -2,7 +2,7 @@
 class CleanSweep::TableSchema
 
   # The list of columns used when selecting, the union of pk and traversing key columns
-  attr_reader :select_columns
+  attr_reader :columns
 
   # The schema for the primary key
   attr_reader :primary_key
@@ -18,8 +18,17 @@ class CleanSweep::TableSchema
     ascending            = options.include?(:ascending) ? options[:ascending] : true
     first_only           = options[:first_only]
     @model               = model
+    @dest_model          = options[:dest_model] || @model
+
+    # Downcase and symbolize the entries in the column name map:
+    dest_columns_map     = Hash[*(options[:dest_columns] || {}).to_a.flatten.map{|n| n.to_s.downcase.to_sym}]
+
     @name                = @model.table_name
-    @select_columns      = (options[:extra_columns] && options[:extra_columns].map(&:to_sym)) || []
+
+    @columns      =
+      (options[:extra_columns] || []).map do | extra_col_name |
+        CleanSweep::TableSchema::ColumnSchema.new extra_col_name, model
+      end
 
     key_schemas = build_indexes
 
@@ -28,31 +37,40 @@ class CleanSweep::TableSchema
     raise "Table #{model.table_name} must have a primary key" unless key_schemas.include? 'primary'
 
     @primary_key = key_schemas['primary']
-    @primary_key.add_columns_to @select_columns
+    @primary_key.add_columns_to @columns
     if traversing_key_name
       traversing_key_name.downcase!
       raise "BTREE Index #{traversing_key_name} not found" unless key_schemas.include? traversing_key_name
       @traversing_key = key_schemas[traversing_key_name]
-      @traversing_key.add_columns_to @select_columns
+      @traversing_key.add_columns_to @columns
       @traversing_key.ascending = ascending
       @traversing_key.first_only = first_only
     end
 
+    # Specify the column names in the destination map, if provided
+    @columns.each do | column |
+      column.dest_name = dest_columns_map[column.name]
+    end
+
   end
 
-  def insert_statement(target_model, rows)
-    "insert into #{target_model.quoted_table_name} (#{quoted_column_names}) values #{quoted_row_values(rows)}"
+  def column_names
+    @columns.map(&:name)
+  end
+
+  def insert_statement(rows)
+    "insert into #{@dest_model.quoted_table_name} (#{quoted_dest_column_names}) values #{quoted_row_values(rows)}"
   end
 
   def delete_statement(rows)
     rec_criteria = rows.map do | row |
       row_compares = []
       @primary_key.columns.each do |column|
-        row_compares << "#{column.quoted_name} = #{column.quoted_value(row)}"
+        row_compares << "#{column.quoted_dest_name(@dest_model)} = #{column.quoted_value(row)}"
       end
       "(" + row_compares.join(" AND ") + ")"
     end
-    "DELETE FROM #{@model.quoted_table_name} WHERE #{rec_criteria.join(" OR ")}"
+    "DELETE FROM #{@dest_model.quoted_table_name} WHERE #{rec_criteria.join(" OR ")}"
   end
 
   def initial_scope
@@ -82,15 +100,20 @@ class CleanSweep::TableSchema
   end
 
   def quoted_column_names
-    select_columns.map{|c| "`#{c}`"}.join(",")
+    columns.map{|c| "#{c.quoted_name}"}.join(",")
+  end
+
+  def quoted_dest_column_names
+    columns.map{|c| c.quoted_dest_name(@dest_model)}.join(",")
   end
 
   def quoted_row_values(rows)
     rows.map do |vec|
-      quoted_column_values = vec.map do |col_value|
-        @model.connection.quote(col_value)
-      end.join(",")
-      "(#{quoted_column_values})"
+      row = []
+      columns.each_with_index do | col, i |
+        row << @model.quote_value(vec[i], col.ar_column)
+      end
+      "(#{row.join(',')})"
     end.join(",")
   end
 

data/lib/clean_sweep/version.rb

@@ -1,3 +1,3 @@
 module CleanSweep
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/factories/books.rb

@@ -12,6 +12,7 @@ class Book < ActiveRecord::Base
        key book_index_by_bin(bin, id)
     )
     EOF
+    Book.delete_all
   end
 
 end
@@ -27,10 +28,17 @@ end
 class BookTemp < ActiveRecord::Base
 
   self.table_name = 'book_vault'
+  self.primary_key= 'book_id'
 
   def self.create_table
     connection.execute <<-EOF
-    create temporary table if not exists book_vault like books
+    create temporary table if not exists
+    book_vault (
+       `book_id` int(11) primary key auto_increment,
+       `bin` int(11),
+       `published_by` varchar(64)
+    )
     EOF
+    BookTemp.delete_all
   end
 end

data/spec/purge_runner_spec.rb

@@ -72,20 +72,20 @@ describe CleanSweep::PurgeRunner do
           purger.print_queries(output)
           expect(output.string).to eq <<EOF
 Initial Query:
-    SELECT  `id`,`account`,`timestamp`
+    SELECT  `comments`.`id`,`comments`.`account`,`comments`.`timestamp`
     FROM `comments` FORCE INDEX(comments_on_account_timestamp)
     WHERE (timestamp < '2014-11-25 21:47:43')
-    ORDER BY `account` ASC,`timestamp` ASC
+    ORDER BY `comments`.`account` ASC,`comments`.`timestamp` ASC
     LIMIT 500
 Chunk Query:
-    SELECT  `id`,`account`,`timestamp`
+    SELECT  `comments`.`id`,`comments`.`account`,`comments`.`timestamp`
     FROM `comments` FORCE INDEX(comments_on_account_timestamp)
-    WHERE (timestamp < '2014-11-25 21:47:43') AND (`account` > 0 OR (`account` = 0 AND `timestamp` > '2014-11-18 21:47:43'))\n    ORDER BY `account` ASC,`timestamp` ASC
+    WHERE (timestamp < '2014-11-25 21:47:43') AND (`comments`.`account` > 0 OR (`comments`.`account` = 0 AND `comments`.`timestamp` > '2014-11-18 21:47:43'))\n    ORDER BY `comments`.`account` ASC,`comments`.`timestamp` ASC
     LIMIT 500
 Delete Statement:
     DELETE
     FROM `comments`
-    WHERE (`id` = 2)
+    WHERE (`comments`.`id` = 2)
 EOF
         end
       end
@@ -167,13 +167,20 @@ EOF
       it 'copies books' do
         BookTemp.create_table
         purger = CleanSweep::PurgeRunner.new model: Book,
+                                             copy_columns: ['publisher'],
                                              dest_model: BookTemp,
+                                             dest_columns: { 'PUBLISHER' => 'published_by', 'ID' => 'book_id'},
                                              chunk_size: 4,
+                                             copy_only: true,
                                              index: 'book_index_by_bin'
 
         count = purger.execute_in_batches
         expect(count).to be(@total_book_size)
         expect(BookTemp.count).to eq(@total_book_size)
+        last_book = BookTemp.last
+        expect(last_book.book_id).to be 200
+        expect(last_book.bin).to be 2000
+        expect(last_book.published_by).to eq 'Random House'
       end
 
     end

data/spec/table_schema_spec.rb

@@ -17,22 +17,22 @@ describe CleanSweep::TableSchema do
     it 'should produce an ascending chunk clause' do
       rows = account_and_timestamp_rows
       expect(schema.scope_to_next_chunk(schema.initial_scope, rows.last).to_sql)
-          .to include("(`account` > 5 OR (`account` = 5 AND `timestamp` > '2014-12-01 23:13:25'))")
+          .to include("(`comments`.`account` > 5 OR (`comments`.`account` = 5 AND `comments`.`timestamp` > '2014-12-01 23:13:25'))")
     end
 
     it 'should produce all select columns' do
-      expect(schema.select_columns).to eq([:id, :account, :timestamp])
+      expect(schema.column_names).to eq([:id, :account, :timestamp])
     end
 
     it 'should produce the ascending order clause' do
-      expect(schema.initial_scope.to_sql).to include('`account` ASC,`timestamp` ASC')
+      expect(schema.initial_scope.to_sql).to include('`comments`.`account` ASC,`comments`.`timestamp` ASC')
     end
 
 
     it 'should produce an insert statement' do
       schema = CleanSweep::TableSchema.new Comment, key_name: 'comments_on_account_timestamp'
       rows = account_and_timestamp_rows
-      expect(schema.insert_statement(Comment, rows)).to eq("insert into `comments` (`id`,`account`,`timestamp`) values (1001,5,'2014-12-02 01:13:25'),(1002,2,'2014-12-02 00:13:25'),(1005,5,'2014-12-01 23:13:25')")
+      expect(schema.insert_statement(rows)).to eq("insert into `comments` (`comments`.`id`,`comments`.`account`,`comments`.`timestamp`) values (1001,5,'2014-12-02 01:13:25'),(1002,2,'2014-12-02 00:13:25'),(1005,5,'2014-12-01 23:13:25')")
     end
   end
 
@@ -43,14 +43,14 @@ describe CleanSweep::TableSchema do
     it 'should produce a descending where clause' do
       rows = account_and_timestamp_rows
       expect(schema.scope_to_next_chunk(schema.initial_scope, rows.last).to_sql)
-          .to include("(`account` < 5 OR (`account` = 5 AND `timestamp` < '2014-12-01 23:13:25'))")
+          .to include("(`comments`.`account` < 5 OR (`comments`.`account` = 5 AND `comments`.`timestamp` < '2014-12-01 23:13:25'))")
     end
 
 
     it 'should produce the descending order clause' do
       rows = account_and_timestamp_rows
       expect(schema.scope_to_next_chunk(schema.initial_scope, rows.last).to_sql)
-          .to include("`account` DESC,`timestamp` DESC")
+          .to include("`comments`.`account` DESC,`comments`.`timestamp` DESC")
     end
 
   end
@@ -59,13 +59,13 @@ describe CleanSweep::TableSchema do
     let(:schema) { CleanSweep::TableSchema.new Comment, key_name:'comments_on_account_timestamp', first_only: true }
 
     it 'should select all the rows' do
-      expect(schema.select_columns).to eq([:id, :account, :timestamp])
+      expect(schema.column_names).to eq([:id, :account, :timestamp])
     end
 
     it 'should only query using the first column of the index' do
       rows = account_and_timestamp_rows
       expect(schema.scope_to_next_chunk(schema.initial_scope, rows.last).to_sql)
-        .to include(" (`account` >= 5) ")
+        .to include(" (`comments`.`account` >= 5) ")
 
     end
 
@@ -83,7 +83,7 @@ describe CleanSweep::TableSchema do
 
   it 'should produce minimal select columns' do
     schema = CleanSweep::TableSchema.new Comment, key_name: 'PRIMARY'
-    expect(schema.select_columns).to eq([:id])
+    expect(schema.column_names).to eq([:id])
   end
 
   it 'should produce the from clause with an index' do
@@ -93,10 +93,10 @@ describe CleanSweep::TableSchema do
 
   it 'should include additional columns' do
     schema = CleanSweep::TableSchema.new Comment, key_name: 'comments_on_account_timestamp', extra_columns: %w[seen id]
-    expect(schema.select_columns).to eq([:seen, :id, :account, :timestamp])
+    expect(schema.column_names).to eq([:seen, :id, :account, :timestamp])
     rows = account_and_timestamp_rows
     rows.map! { |row| row.unshift 1 } # Insert 'seen' value to beginning of row
-    expect(schema.insert_statement(Comment, rows)).to eq("insert into `comments` (`seen`,`id`,`account`,`timestamp`) values (1,1001,5,'2014-12-02 01:13:25'),(1,1002,2,'2014-12-02 00:13:25'),(1,1005,5,'2014-12-01 23:13:25')")
+    expect(schema.insert_statement(rows)).to eq("insert into `comments` (`comments`.`seen`,`comments`.`id`,`comments`.`account`,`comments`.`timestamp`) values (1,1001,5,'2014-12-02 01:13:25'),(1,1002,2,'2014-12-02 00:13:25'),(1,1005,5,'2014-12-01 23:13:25')")
 
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cleansweep
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Bill Kayser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.17
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.17
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -167,7 +167,7 @@ files:
 - spec/purge_runner_spec.rb
 - spec/spec_helper.rb
 - spec/table_schema_spec.rb
-homepage: http://github.com/bkayser/cleansweep
+homepage: http://bkayser.github.com/cleansweep
 licenses:
 - MIT
 metadata: {}
@@ -177,9 +177,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="