upsert 2.1.0 → 2.9.9

data/spec/jruby_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+describe Upsert do
+  it "works correct with large ints" do
+    u = Upsert.new($conn, :pets)
+    Pet.create(:name => "Jerry", :big_tag_number => 2)
+    u.row({ :name => 'Jerry' }, :big_tag_number => 3599657714)
+    Pet.find_by_name('Jerry').big_tag_number.should == 3599657714
+  end
+end if RUBY_PLATFORM == 'java'

data/spec/logger_spec.rb

@@ -1,17 +1,18 @@
 require 'spec_helper'
 describe Upsert do
+  MUTEX_FOR_PERFORM = Mutex.new
   describe "logger" do
     it "logs where you tell it" do
       begin
         old_logger = Upsert.logger
         io = StringIO.new
-        Thread.exclusive do
+        MUTEX_FOR_PERFORM.synchronize do
           Upsert.logger = Logger.new(io)
 
           Upsert.logger.warn "hello"
 
           io.rewind
-          io.read.chomp.should == 'hello'
+          io.read.chomp.should =~ /hello/
         end
       ensure
         Upsert.logger = old_logger
@@ -19,12 +20,12 @@ describe Upsert do
     end
 
     it "logs queries" do
+      old_logger = Upsert.logger
       begin
-        old_logger = Upsert.logger
         io = StringIO.new
-        Thread.exclusive do
+        MUTEX_FOR_PERFORM.synchronize do
           Upsert.logger = Logger.new(io)
-          
+
           u = Upsert.new($conn, :pets)
           u.row(:name => 'Jerry')
 
@@ -37,7 +38,8 @@ describe Upsert do
             log.should =~ /call #{Upsert::MergeFunction::NAME_PREFIX}_pets_SEL_name/i
           when /p.*g/i
             # [54ae2eea857] Possibly much more useful debug output
-            log.should =~ /selector:/i
+            # TODO: Should check for both upsert and non-upsert log output
+            log.should =~ /selector:|SHOW server_version/i
           else
             raise "not sure"
           end

data/spec/postgresql_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'upsert/merge_function/postgresql'
+
+describe Upsert do
+  version = 'postgresql' == ENV['DB'] ? Upsert::MergeFunction::Postgresql.extract_version(
+    Pet.connection.select_value("SHOW server_version")
+  ) : 0
+
+  let(:upsert) do
+    Upsert.new($conn, :pets)
+  end
+
+  it "uses the native method if available (#{(UNIQUE_CONSTRAINT && version >= 90500).inspect})" do
+    p = Pet.create(:name => 'Jerry', :tag_number => 5)
+    upsert.row({ :name => 'Jerry'}, :tag_number => 6 )
+    expect(upsert.instance_variable_get(:@merge_function_cache).values.first.use_pg_native?).to(
+      UNIQUE_CONSTRAINT && version >= 90500 ? be_truthy : be_falsey
+    )
+  end
+
+  if version >= 90500 && UNIQUE_CONSTRAINT
+    it "works with a schema" do
+      table_name = ["#{RawConnectionFactory::DB_NAME}2", :pets2]
+      cls = clone_ar_class(Pet, table_name)
+      upsert = Upsert.new $conn, table_name
+      upsert.row({:name => 'Jerry'}, {:gender => 'male'})
+      expect(upsert.instance_variable_get(:@merge_function_cache).values.first.use_pg_native?).to be_truthy
+    end
+
+    it "checks the correct table for a unique constraint" do
+      Pet.connection.execute("CREATE SCHEMA IF NOT EXISTS unique_constraint_test")
+      Pet.connection.execute("CREATE TABLE unique_constraint_test.pets (LIKE public.pets INCLUDING ALL)")
+      Pet.connection.execute("SET search_path TO unique_constraint_test")
+
+      if RUBY_PLATFORM == "java"
+        $conn.nativeSQL("SET search_path TO unique_constraint_test")
+        $conn.setSchema("unique_constraint_test")
+      else
+        $conn.exec("SET search_path TO unique_constraint_test")
+      end
+
+      Pet.connection.execute("DROP INDEX unique_constraint_test.pets_name_idx")
+      Pet.connection.execute("ALTER TABLE unique_constraint_test.pets DROP CONSTRAINT IF EXISTS unique_name")
+      p = Pet.create(:name => 'Jerry', :tag_number => 5)
+      upsert.row({ :name => 'Jerry'}, :tag_number => 6 )
+      expect(upsert.instance_variable_get(:@merge_function_cache).values.first.use_pg_native?).to be_falsey
+      Pet.connection.execute("SET search_path TO public")
+
+      if RUBY_PLATFORM == "java"
+        $conn.nativeSQL("SET search_path TO public")
+        $conn.setSchema("public")
+      else
+        $conn.exec("SET search_path TO public")
+      end
+
+      Pet.connection.execute("DROP SCHEMA unique_constraint_test CASCADE")
+    end
+  end
+
+  describe "array escaping" do
+    let(:upsert) do
+      Upsert.new($conn, :posts)
+    end
+
+    before(:all) do
+      Sequel.migration do
+        change do
+          db = self
+          create_table?(:posts) do
+            primary_key :id
+            String :name
+            column :tags, "text[]"
+          end
+        end
+      end.apply(DB, :up)
+
+      Object.const_set("Post", Class.new(ActiveRecord::Base))
+    end
+
+    [
+      %w[1 2 3],
+      %w[can't stop won't stop],
+      %w["''" '""' '\\],
+      ["[]", "{}", "\\\\", "()"],
+      %w[*& *&^ $%IUBS (&^ ) ()*& // \\ \\\\ (*&^JN) (*HNCSD) ~!!!`` {} } { ( )],
+      %w[\\ \\\\ \\\\\\ \\\\\\\\ \\'\\'\'\\\'" \\'\\"\''\""],
+    ].each do |arr|
+      it "properly upserts array of: #{arr}" do
+        upsert.row({name: "same-name"}, tags: arr)
+        expect(Post.first.tags).to eq(arr)
+      end
+    end
+  end
+end if ENV['DB'] == 'postgresql'

data/spec/reserved_words_spec.rb

@@ -7,33 +7,37 @@ describe Upsert do
     end.map do |path|
       IO.readlines(path)
     end.flatten.map(&:chomp).select(&:present?).uniq
-  
+
     # make lots of AR models, each of which has 10 columns named after these words
     nasties = []
     reserved_words.each_slice(10) do |words|
-      eval %{
-        class Nasty#{nasties.length} < ActiveRecord::Base
-        end
-      }
-      nasty = Object.const_get("Nasty#{nasties.length}")
+      name = "Nasty#{nasties.length}"
+      Object.const_set(name, Class.new(ActiveRecord::Base))
+      nasty = Object.const_get(name)
       nasty.class_eval do
-        self.primary_key = 'fake_primary_key'
-        col :fake_primary_key
-        words.each do |word|
-          col word
-        end
+        self.table_name = name.downcase
+        self.primary_key = "fake_primary_key"
       end
+
+      Sequel.migration do
+        change do
+          db = self
+          create_table?(name.downcase) do
+            primary_key :fake_primary_key
+            words.each do |word|
+              String word, limit: 191
+            end
+          end
+        end
+      end.apply(DB, :up)
       nasties << [ nasty, words ]
     end
-    nasties.each do |nasty, _|
-      nasty.auto_upgrade!
-    end
-  
+
     describe "reserved words" do
       nasties.each do |nasty, words|
         it "doesn't die on reserved words #{words.join(',')}" do
           upsert = Upsert.new $conn, nasty.table_name
-          random = rand(1e3).to_s
+          random = rand(1e3)
           selector = { :fake_primary_key => random, words.first => words.first }
           setter = words[1..-1].inject({}) { |memo, word| memo[word] = word; memo }
           assert_creates nasty, [selector.merge(setter)] do
@@ -43,4 +47,4 @@ describe Upsert do
       end
     end
   end
-end
+end

data/spec/sequel_spec.rb

@@ -4,17 +4,36 @@ require 'sequel'
 describe Upsert do
   describe "Plays nice with Sequel" do
     config = ActiveRecord::Base.connection.instance_variable_get(:@config)
-    case
-      when 'postgresql' == config[:adapter]; config[:adapter] = 'postgres'
-      when 'sqlite3' == config[:adapter]; config[:adapter] = 'sqlite'
+    config[:adapter] = case config[:adapter]
+                       when 'postgresql' then 'postgres'
+                       when 'sqlite3' then 'sqlite'
+                       else config[:adapter]
+                       end
+
+    let(:db) do
+      if RUBY_PLATFORM == "java"
+        Sequel.connect(
+          RawConnectionFactory::CONFIG,
+          :user => RawConnectionFactory::DB_USER,
+          :password => RawConnectionFactory::DB_PASSWORD
+        )
+      elsif config[:adapter] == "sqlite"
+        Sequel.sqlite("temp.db")
+      else
+        Sequel.connect(config.merge(
+          :user => config.values_at(:user, :username).compact.first,
+          :host => config.values_at(:host, :hostaddr).compact.first,
+          :database => config.values_at(:database, :dbname).compact.first
+        ))
+      end
     end
 
     it "Doesn't explode on connection" do
-      expect { DB = Sequel.connect config }.to_not raise_error
+      expect { db }.to_not raise_error
     end
 
     it "Doesn't explode when using DB.pool.hold" do
-      DB.pool.hold do |conn|
+      db.pool.hold do |conn|
         expect {
           upsert = Upsert.new(conn, :pets)
           assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
@@ -25,7 +44,7 @@ describe Upsert do
     end
 
     it "Doesn't explode when using DB.synchronize" do
-      DB.synchronize do |conn|
+      db.synchronize do |conn|
         expect {
           upsert = Upsert.new(conn, :pets)
           assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
@@ -35,4 +54,4 @@ describe Upsert do
       end
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,94 +1,182 @@
 # -*- encoding: utf-8 -*-
 require 'bundler/setup'
+Bundler.require(:default, :development)
 
-require 'pry'
+require 'shellwords'
+require "sequel"
+Sequel.default_timezone = :utc
+Sequel.extension :migration
 
-require 'active_record'
+require "active_record"
+require "activerecord-import"
 ActiveRecord::Base.default_timezone = :utc
 
-require 'active_record_inline_schema'
+raise "A DB value is required" unless ENV["DB"]
+ENV['DB'] = 'postgresql' if ENV['DB'].to_s =~ /postgresql/i
+UNIQUE_CONSTRAINT = ENV['UNIQUE_CONSTRAINT'] == 'true'
 
-require 'activerecord-import' if RUBY_VERSION >= '1.9'
-
-ENV['DB'] ||= 'mysql'
+raise "please use DB=postgresql NOT postgres" if ENV["DB"] == "postgres"
 
 class RawConnectionFactory
-  DATABASE = 'upsert_test'
-  CURRENT_USER = `whoami`.chomp
-  PASSWORD = ''
-
-  case ENV['DB']
-
-  when 'postgresql'
-    Kernel.system %{ dropdb upsert_test }
-    Kernel.system %{ createdb upsert_test }
-    if RUBY_PLATFORM == 'java'
-      CONFIG = "jdbc:postgresql://localhost/#{DATABASE}?user=#{CURRENT_USER}"
-      require 'jdbc/postgres'
-      # http://thesymanual.wordpress.com/2011/02/21/connecting-jruby-to-postgresql-with-jdbc-postgre-api/
-      Jdbc::Postgres.load_driver
-      # java.sql.DriverManager.register_driver org.postgresql.Driver.new
-      def new_connection
-        java.sql.DriverManager.get_connection CONFIG
-      end
-    else
-      CONFIG = { :dbname => DATABASE }
-      require 'pg'
-      def new_connection
-        PG::Connection.new CONFIG
-      end
-    end
-    ActiveRecord::Base.establish_connection :adapter => 'postgresql', :database => DATABASE, :username => CURRENT_USER
-
-  when 'mysql'
-    password_argument = (PASSWORD.empty?) ? "" : "-p#{PASSWORD}"
-    Kernel.system %{ mysql -u #{CURRENT_USER} #{password_argument} -e "DROP DATABASE IF EXISTS #{DATABASE}" }
-    Kernel.system %{ mysql -u #{CURRENT_USER} #{password_argument} -e "CREATE DATABASE #{DATABASE} CHARSET utf8" }
-    if RUBY_PLATFORM == 'java'
-      CONFIG = "jdbc:mysql://127.0.0.1/#{DATABASE}?user=#{CURRENT_USER}&password=#{PASSWORD}"
-      require 'jdbc/mysql'
-      Jdbc::MySQL.load_driver
-      # java.sql.DriverManager.register_driver com.mysql.jdbc.Driver.new
-      def new_connection
-        java.sql.DriverManager.get_connection CONFIG
-      end
-    else
-      require 'mysql2'
-      def new_connection
-        config = { :username => CURRENT_USER, :database => DATABASE, :host => "127.0.0.1" }
-        config.merge!(:password => PASSWORD) unless PASSWORD.empty?
-        Mysql2::Client.new config
-      end
-    end
-    ActiveRecord::Base.establish_connection "#{RUBY_PLATFORM == 'java' ? 'mysql' : 'mysql2'}://#{CURRENT_USER}:#{PASSWORD}@127.0.0.1/#{DATABASE}"
+  DB_NAME = ENV['DB_NAME'] || 'upsert_test'
+  # You *need* to specific DB_USER on certain combinations of JRuby/JDK as spawning a shell
+  # has some oddities
+  DB_USER = (ENV['DB_USER'] || `whoami`.chomp).to_s
+  raise "A DB_USER value is required" if DB_USER.empty?
+  DB_PASSWORD = ENV['DB_PASSWORD']
+  DB_HOST = ENV['DB_HOST'] || '127.0.0.1'
+
+  def self.db_env
+    @db_env ||= base_params(nil, false).map { |k, v| [":#{k}", v.to_s.empty? ? nil : Shellwords.escape(v)] }.to_h
+  end
+
+  def self.adapter_name(adapter = nil)
+    RUBY_PLATFORM != "java" && adapter == "mysql" ? "mysql2" : adapter
+  end
+
+  def self.base_params(adapter = nil, show_additional_params = true)
+    return { :adapter => "sqlite3", :database => "temp.db", cache: "shared" } if adapter == "sqlite3"
+    {
+      host: DB_HOST,
+      database: DB_NAME,
+      dbname: DB_NAME,
+      username: DB_USER,
+      user: DB_USER,
+      password: DB_PASSWORD,
+      adapter: adapter,
+    }.merge(
+      show_additional_params ? additional_params(adapter) : {}
+    )
+  end
 
-  when 'sqlite3'
-    CONFIG = { :adapter => 'sqlite3', :database => 'file::memory:?cache=shared' }
-    if RUBY_PLATFORM == 'java'
-      # CONFIG = 'jdbc:sqlite://test.sqlite3'
-      require 'jdbc/sqlite3'
+  def self.additional_params(adapter = nil)
+    {
+      "mysql" => { encoding: "utf8mb4" },
+      "mysql2" => { encoding: "utf8mb4" },
+    }.fetch(adapter, {})
+  end
+
+  def self.postgresql_call(string)
+    Kernel.system "PGHOST=#{db_env[":host"]} PGUSER=#{db_env[":user"]} PGPASSWORD=#{db_env[":password"]} #{string.gsub(/:[a-z]+/, db_env)}"
+  end
+
+  def self.mysql_call(string)
+    Kernel.system "mysql -h #{db_env[":host"]} -u #{db_env[":user"]} --password=#{db_env[":password"]} #{string.gsub(/:[a-z]+/, db_env)}"
+  end
+
+  SYSTEM_CALLS = {
+    "postgresql" => [
+      %{ dropdb :dbname },
+      %{ createdb :dbname },
+      %{ psql -d :dbname -c 'DROP SCHEMA IF EXISTS :dbname2 CASCASE' },
+      %{ psql -d :dbname -c 'CREATE SCHEMA :dbname2' },
+    ],
+    "mysql" => [
+      %{ -e "DROP DATABASE IF EXISTS :dbname" },
+      %{ -e "DROP DATABASE IF EXISTS :dbname2" },
+      %{ -e "CREATE DATABASE :dbname CHARSET utf8mb4 COLLATE utf8mb4_general_ci" },
+      %{ -e "CREATE DATABASE :dbname2 CHARSET utf8mb4 COLLATE utf8mb4_general_ci" },
+    ]
+  }.freeze
+
+  REQUIRES = {
+    "mysql" => "mysql2",
+    "postgresql" => "pg",
+    "sqlite3" => "sqlite3",
+    "java-postgresql" => "jdbc/postgres",
+    "java-mysql" => "jdbc/mysql",
+    "java-sqlite3" => "jdbc/sqlite3",
+  }.freeze
+
+  NEW_CONNECTION = {
+    "postgresql" => ->(base_params) { PG::Connection.new(base_params.except(:database, :username, :adapter)) },
+    "mysql" => ->(base_params) { Mysql2::Client.new(base_params) },
+    "sqlite3" => ->(base_params) { ActiveRecord::Base.connection.raw_connection },
+  }
+
+  POST_CONNECTION = {
+    "mysql" => -> { ActiveRecord::Base.connection.execute "SET NAMES utf8mb4 COLLATE utf8mb4_general_ci" },
+    "sqlite3" => -> { [ActiveRecord::Base.connection, ::DB].each { |c| c.execute "ATTACH DATABASE 'temp2.db' AS #{DB_NAME}2" } },
+  }
+
+  SYSTEM_CALLS.fetch(ENV["DB"], []).each do |str|
+    send("#{ENV["DB"]}_call", str)
+  end
+
+  if RUBY_PLATFORM == 'java'
+    CONFIG = "jdbc:#{ENV["DB"]}://#{DB_HOST}/#{DB_NAME}"
+    require REQUIRES["java-#{ENV["DB"]}"]
+
+    case ENV["DB"]
+    when "postgresql" then Jdbc::Postgres.load_driver
+    when "mysql"      then Jdbc::MySQL.load_driver
+    when "sqlite3"
       Jdbc::SQLite3.load_driver
+      CONFIG = "jdbc:sqlite::memory:?cache=shared"
+    end
+
+    def new_connection
+      java.util.TimeZone.setDefault(java.util.TimeZone.getTimeZone("+00:00"))
+      java.sql.DriverManager.get_connection CONFIG, DB_USER, DB_PASSWORD
+    end
+  else
+    case ENV['DB']
+    when "postgresql", "mysql"
+      require REQUIRES[ENV["DB"]]
       def new_connection
-        ActiveRecord::Base.connection.raw_connection.connection
+        NEW_CONNECTION[ENV["DB"]].call(self.class.base_params(ENV["DB"]))
       end
-    else
-      require 'sqlite3'
+    when "sqlite3"
+      require REQUIRES[ENV["DB"]]
       def new_connection
-        ActiveRecord::Base.connection.raw_connection
+        NEW_CONNECTION[ENV["DB"]].call(self.class.base_params(ENV["DB"]))
       end
+      CONFIG = { :adapter => "sqlite3", :database => "temp.db", cache: "shared" }
+
     end
-    ActiveRecord::Base.establish_connection CONFIG
+  end
 
-  when 'postgres'
-    raise "please use DB=postgresql NOT postgres"
+  ActiveRecord::Base.establish_connection(
+    base_params(adapter_name(ENV["DB"]))
+  )
+  ari_adapter_name = adapter_name(ENV["DB"]) == "mysql" ? "mysql2" : adapter_name(ENV["DB"])
+  require "activerecord-import/active_record/adapters/#{ari_adapter_name}_adapter"
+end
 
-  else
-    raise "not supported"
-  end
+raise "not supported" unless RawConnectionFactory.instance_methods.include?(:new_connection)
+
+config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+config[:adapter] = case config[:adapter]
+  when "postgresql" then "postgres"
+  when "sqlite3" then "sqlite"
+  else config[:adapter]
+end
+params = if RUBY_PLATFORM == "java"
+  RawConnectionFactory::CONFIG
+else
+  config.merge(
+    :user => config.values_at(:user, :username).compact.first,
+    :host => config.values_at(:host, :hostaddr).compact.first,
+    :database => config.values_at(:database, :dbname).compact.first
+  )
+end
+DB = if RUBY_PLATFORM == "java"
+  Sequel.connect(
+    params,
+    :user => RawConnectionFactory::DB_USER,
+    :password => RawConnectionFactory::DB_PASSWORD
+  )
+elsif ENV["DB"] == "sqlite3"
+  Kernel.at_exit { FileUtils.rm(Dir.glob("temp*.db")) }
+  Sequel.sqlite("temp.db")
+else
+  Sequel.connect(params)
 end
 
 $conn_factory = RawConnectionFactory.new
 $conn = $conn_factory.new_connection
+RawConnectionFactory::POST_CONNECTION.fetch(ENV["DB"], -> {}).call
+
 
 require 'logger'
 require 'fileutils'
@@ -101,30 +189,71 @@ else
   ActiveRecord::Base.logger.level = Logger::WARN
 end
 
-class Pet < ActiveRecord::Base
-  col :name
-  col :gender
-  col :spiel
-  col :good, :type => :boolean
-  col :lovability, :type => :float
-  col :morning_walk_time, :type => :datetime
-  col :zipped_biography, :type => :binary
-  col :tag_number, :type => :integer
-  col :birthday, :type => :date
-  col :home_address, :type => :text
-  if ENV['DB'] == 'postgresql'
-    col :tsntz, :type => 'timestamp without time zone'
+if ENV['DB'] == 'postgresql'
+  begin
+    DB << "ALTER TABLE pets DROP CONSTRAINT IF EXISTS unique_name"
+  rescue => e
+    puts e.inspect
   end
-  add_index :name, :unique => true
 end
-Pet.auto_upgrade!
 
-class Task < ActiveRecord::Base
-  col :name
-  col :created_at, :type => :datetime
-  col :created_on, :type => :datetime
+class InternalMigration
+  DEFINITIONS = {
+    pets: ->(db) {
+      primary_key :id
+      String :name, { size: 191 }.merge(ENV["DB"] == "mysql" || UNIQUE_CONSTRAINT ? { index: { unique: true } } : {})
+      String :gender
+      String :spiel
+      TrueClass :good
+      BigDecimal :lovability, size: [30, 15] # 15 integer digits and 15 fractional digits
+      DateTime :morning_walk_time
+      File :zipped_biography
+      Integer :tag_number
+      Bignum :big_tag_number
+      Date :birthday
+      String :home_address, text: true
+
+      if db.database_type == :postgres
+        column :tsntz, "timestamp without time zone"
+      end
+    },
+    tasks: ->(db) {
+      primary_key :id
+      String :name
+      DateTime :created_at
+      DateTime :created_on
+    },
+    people: ->(db) {
+      primary_key :id
+      String :"First Name"
+      String :"Last Name"
+    },
+    alphabets: ->(db) {
+      ("a".."z").each do |col|
+        Integer "the_letter_#{col}".to_sym
+      end
+    }
+  }
+end
+
+Sequel.migration do
+  change do
+    db = self
+    InternalMigration::DEFINITIONS.each do |table, blk|
+      create_table?(table) do
+        instance_exec(db, &blk)
+      end
+    end
+  end
+end.apply(DB, :up)
+
+if ENV['DB'] == 'postgresql' && UNIQUE_CONSTRAINT
+  DB << "ALTER TABLE pets ADD CONSTRAINT unique_name UNIQUE (name)"
+end
+
+%i[Pet Task Person Alphabet].each do |name|
+  Object.const_set(name, Class.new(ActiveRecord::Base))
 end
-Task.auto_upgrade!
 
 require 'zlib'
 require 'benchmark'
@@ -157,7 +286,7 @@ module SpecHelper
           names.choice
         end
         setter = {
-          :lovability => BigDecimal.new(rand(1e11).to_s, 2),
+          :lovability => BigDecimal(rand(1e11).to_s, 2),
           :tag_number => rand(1e8),
           :spiel => Faker::Lorem.sentences.join,
           :good => true,
@@ -176,7 +305,7 @@ module SpecHelper
   def assert_same_result(records, &blk)
     blk.call(records)
     ref1 = Pet.order(:name).all.map { |pet| pet.attributes.except('id') }
-    
+
     Pet.delete_all
 
     Upsert.batch($conn, :pets) do |upsert|
@@ -197,6 +326,7 @@ module SpecHelper
     expected_records.each do |selector, setter|
       setter ||= {}
       found = model.where(selector).map { |record| record.attributes.except('id') }
+      expect(found).to_not be_empty, { :selector => selector, :setter => setter }.inspect
       expected = [ selector.stringify_keys.merge(setter.stringify_keys) ]
       compare_attribute_sets expected, found
     end
@@ -230,7 +360,7 @@ module SpecHelper
     Pet.delete_all
     sleep 1
     # --
-    
+
     ar_time = Benchmark.realtime { blk.call(records) }
 
     Pet.delete_all
@@ -246,6 +376,35 @@ module SpecHelper
     upsert_time.should be < ar_time
     $stderr.puts "   Upsert was #{((ar_time - upsert_time) / ar_time * 100).round}% faster than #{competition}"
   end
+
+  def clone_ar_class(klass, table_name)
+    u = Upsert.new $conn, klass.table_name
+    new_table_name = [*table_name].compact
+    # AR's support for quoting of schema and table names is horrendous
+    # schema.table and schema.`table` are considiered different names on MySQL, but
+    # schema.table and schema."table" are correctly considered the same on Postgres
+    sequel_table_name = new_table_name.map(&:to_sym)
+    new_table_name[-1] = u.connection.quote_ident(new_table_name[-1]) if new_table_name[-1].to_s.index('.')
+    new_table_name = new_table_name.join('.')
+
+    Sequel.migration do
+      change do
+        db = self
+        create_table?(sequel_table_name.length > 1 ? Sequel.qualify(*sequel_table_name) : sequel_table_name.first) do
+          instance_exec(db, &InternalMigration::DEFINITIONS[klass.table_name.to_sym])
+        end
+      end
+    end.apply(DB, :up)
+
+    cls = Class.new(klass)
+    cls.class_eval do
+      self.table_name = new_table_name
+      def self.quoted_table_name
+        new_table_name
+      end
+    end
+    cls
+  end
 end
 
 RSpec.configure do |c|