sequel 4.26.0 → 5.37.0

data/spec/extensions/accessed_columns_spec.rb

@@ -1,51 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "accessed_columns plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:name=>'a', :b=>'c'}, :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.columns :name, :b
-    @c.plugin :accessed_columns
-    @o = @c.new
-  end
-
-  it "should record columns accessed" do
-    @o.accessed_columns.must_equal []
-    @o.name
-    @o.accessed_columns.must_equal [:name]
-    @o.name
-    @o.accessed_columns.must_equal [:name]
-    @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
-  end
-
-  it "should clear accessed columns when refreshing" do
-    @o.name
-    @o.refresh
-    @o.accessed_columns.must_equal []
-  end
-
-  it "should clear accessed columns when saving" do
-    @o.name
-    @o.save
-    @o.accessed_columns.must_equal []
-  end
-
-  it "should work when duping and cloning instances" do
-    @o.name
-    o = @o.dup
-    @o.accessed_columns.must_equal [:name]
-    @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
-    o.accessed_columns.must_equal [:name]
-    o2 = o.clone
-    o2.refresh
-    o.accessed_columns.must_equal [:name]
-    o2.accessed_columns.must_equal []
-  end
-
-  it "should not raise exceptions when object is frozen" do
-    @o.freeze
-    @o.name
-  end
-end

data/spec/extensions/active_model_spec.rb

@@ -1,123 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-begin
-  require 'active_model'
-  begin
-    require 'minitest'
-    if defined?(MiniTest::Unit)
-      class << MiniTest::Unit
-        def autorun; end
-      end
-    end
-    if defined?(MiniTest::Test)
-      test_class = MiniTest::Test
-    end
-  rescue
-    require 'test/unit'
-    test_class = Test::Unit::TestCase
-    if Test::Unit.respond_to?(:run=)
-      Test::Unit.run = false
-      require 'test/unit/testresult'
-    end
-  end
-rescue LoadError => e
-  skip_warn "active_model plugin: can't load active_model (#{e.class}: #{e})"
-else
-describe "ActiveModel plugin" do
-  it "should be compliant to the ActiveModel spec" do
-    tc = Class.new(test_class)
-    tc.class_eval do
-      define_method(:setup) do
-        class ::AMLintTest < Sequel::Model
-          set_primary_key :id
-          columns :id, :id2
-          def delete; end
-        end
-        module ::Blog
-          class Post < Sequel::Model
-             plugin :active_model
-          end
-        end
-        @c = AMLintTest
-        @c.plugin :active_model
-        @m = @model = @c.new
-        @o = @c.load({})
-        super()
-      end
-      def teardown
-        super
-        Object.send(:remove_const, :AMLintTest)
-        Object.send(:remove_const, :Blog)
-      end
-      include ActiveModel::Lint::Tests
-
-      # Should return self, not a proxy object
-      def test__to_model
-        assert_equal @m.to_model.object_id, @m.object_id
-      end
-      
-      def test__to_key
-        assert_equal nil, @m.to_key
-        @o.id = 1
-        assert_equal [1], @o.to_key
-        @o.id = nil
-        assert_equal nil, @o.to_key
-
-        @c.set_primary_key [:id2, :id]
-        assert_equal nil, @o.to_key
-        @o.id = 1
-        @o.id2 = 2
-        assert_equal [2, 1], @o.to_key
-        @o.destroy
-        assert_equal [2, 1], @o.to_key
-        @o.id = nil
-        assert_equal nil, @o.to_key
-      end
-      
-      def test__to_param
-        assert_equal nil, @m.to_param
-        @o.id = 1
-        assert_equal '1', @o.to_param
-        @c.set_primary_key [:id2, :id]
-        @o.id2 = 2
-        assert_equal '2-1', @o.to_param
-        @o.meta_def(:to_param_joiner){'|'}
-        assert_equal '2|1', @o.to_param
-        @o.destroy
-        assert_equal nil, @o.to_param
-      end
-
-      def test__persisted?
-        assert_equal false, @m.persisted?
-        assert_equal true, @o.persisted?
-        @m.destroy
-        @o.destroy
-        assert_equal false, @m.persisted?
-        assert_equal false, @o.persisted?
-      end
-
-      # Should return self, not a proxy object
-      def test__to_partial_path
-        assert_equal 'am_lint_tests/am_lint_test', @m.to_partial_path
-        assert_equal 'blog/posts/post', Blog::Post.new.to_partial_path
-      end
-      
-    end
-    if defined?(MiniTest::Test) || defined?(MiniTest::Unit)
-      tc.instance_methods.map{|x| x.to_s}.reject{|n| n !~ /\Atest_/}.each do |m|
-        i = tc.new(m)
-        i.setup
-        i.send(m)
-        i.teardown
-      end
-    else
-      res = ::Test::Unit::TestResult.new
-      tc.suite.run(res){}
-      if res.failure_count > 0
-        puts res.instance_variable_get(:@failures)
-      end
-      res.failure_count.must_equal 0
-    end
-  end
-end 
-end

data/spec/extensions/after_initialize_spec.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::AfterInitialize" do
-  before do
-    @db = Sequel.mock(:host=>'mysql', :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.class_eval do
-      columns :id, :name
-      plugin :after_initialize
-      def after_initialize
-        self.name *= 2
-        self.id *= 3 if id
-      end
-    end
-  end
-
-  it "should have after_initialize hook be called for new objects" do
-    @c.new(:name=>'foo').values.must_equal(:name=>'foofoo')
-  end
-
-  it "should have after_initialize hook be called for objects loaded from the database" do
-    @c.call(:id=>1, :name=>'foo').values.must_equal(:id=>3, :name=>'foofoo')
-  end
-end

data/spec/extensions/arbitrary_servers_spec.rb

@@ -1,109 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "arbtirary servers" do
-  before do
-    @db = Sequel.mock(:servers=>{})
-    @db.extension :arbitrary_servers
-  end
-
-  it "should allow arbitrary server options using a hash" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].must_equal 'host1'
-      c.opts[:database].must_equal 'db1'
-    end
-  end
-
-  it "should not cache connections to arbitrary servers" do
-    x = nil
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      x = c
-    end
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-      c2.wont_be_same_as(x)
-    end
-  end
-
-  it "should yield same connection correctly when nesting" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.must_be_same_as(c)
-      end
-    end
-  end
-
-  it "should disconnect when connection is finished" do
-    x, x1 = nil, nil
-    @db.meta_def(:disconnect_connection){|c| x = c}
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      x1 = c
-      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.must_be_same_as(c)
-      end
-      x.must_be_same_as(nil)
-    end
-    x.must_be_same_as(x1)
-  end
-
-  it "should yield different connection correctly when nesting" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].must_equal 'host1'
-      @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
-        c2.opts[:host].must_equal 'host2'
-        c2.wont_be_same_as(c)
-      end
-    end
-  end
-
-  it "should respect multithreaded access" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      Thread.new do
-        @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-          _(c2).wont_be_same_as(c)
-        end
-      end.join
-    end
-  end
-
-  it "should work correctly with server_block plugin" do
-    @db.extension :server_block
-    @db.with_server(:host=>'host1', :database=>'db1') do
-      @db.synchronize do |c|
-        c.opts[:host].must_equal 'host1'
-        c.opts[:database].must_equal 'db1'
-        @db.synchronize do |c2|
-          c2.must_be_same_as(c)
-        end
-      end
-    end
-  end
-
-  it "should respect multithreaded access with server block plugin" do
-    @db.extension :server_block
-    q, q1 = Queue.new, Queue.new
-    
-    t = nil
-    @db[:t].all
-    @db.with_server(:host=>'a') do
-      @db[:t].all
-      t = Thread.new do
-        @db[:t].all
-        @db.with_server(:host=>'c') do
-          @db[:t].all
-          @db.with_server(:host=>'d'){@db[:t].all}
-          q.push nil
-          q1.pop
-          @db[:t].all
-        end
-        @db[:t].all
-      end
-      q.pop
-      @db.with_server(:host=>'b'){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    q1.push nil
-    t.join
-    @db.sqls.must_equal ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
-      'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
-  end
-end

data/spec/extensions/association_dependencies_spec.rb

@@ -1,117 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "AssociationDependencies plugin" do
-  before do
-    @mods = []
-    @c = Class.new(Sequel::Model)
-    @c.plugin :association_dependencies
-    @Artist = Class.new(@c).set_dataset(:artists)
-    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
-    @Album = Class.new(@c).set_dataset(:albums)
-    @Album.dataset._fetch = {:id=>1, :name=>'Al', :artist_id=>2}
-    @Artist.columns :id, :name
-    @Album.columns :id, :name, :artist_id
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id, :conditions=>{:position=>1}
-    @Artist.many_to_many :other_artists, :class=>@Artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
-    @Album.many_to_one :artist, :class=>@Artist
-    DB.reset
-  end
-
-  it "should allow destroying associated many_to_one associated object" do
-    @Album.add_association_dependencies :artist=>:destroy
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated many_to_one associated object" do
-    @Album.add_association_dependencies :artist=>:delete
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
-  end
-  
-  it "should allow destroying associated one_to_one associated object" do
-    @Artist.add_association_dependencies :first_album=>:destroy
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated one_to_one associated object" do
-    @Artist.add_association_dependencies :first_album=>:delete
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow destroying associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:destroy
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:delete
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-  
-  it "should allow nullifying associated one_to_one objects" do
-    @Artist.add_association_dependencies :first_album=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow nullifying associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow nullifying associated many_to_many associations" do
-    @Artist.add_association_dependencies :other_artists=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should raise an error if attempting to nullify a many_to_one association" do
-    proc{@Album.add_association_dependencies :artist=>:nullify}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using an unrecognized dependence action" do
-    proc{@Album.add_association_dependencies :artist=>:blah}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if a nonexistent association is used" do
-    proc{@Album.add_association_dependencies :blah=>:delete}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if a invalid association type is used" do
-    @Artist.plugin :many_through_many
-    @Artist.many_through_many :other_albums, [[:id, :id, :id]]
-    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using a many_to_many association type without nullify" do
-    proc{@Artist.add_association_dependencies :other_artists=>:delete}.must_raise(Sequel::Error)
-  end
-
-  it "should allow specifying association dependencies in the plugin call" do
-    @Album.plugin :association_dependencies, :artist=>:destroy
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should work with subclasses" do
-    c = Class.new(@Album)
-    c.add_association_dependencies :artist=>:destroy
-    c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1']
-
-    @Album.add_association_dependencies :artist=>:destroy
-    c2 = Class.new(@Album)
-    c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-end

data/spec/extensions/association_pks_spec.rb

@@ -1,365 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::AssociationPks" do
-  before do
-    @db = Sequel.mock(:autoid=>1, :fetch=>proc do |sql|
-      case sql
-      when /SELECT \* FROM (?:artists|albums) WHERE \(id = (\d+)\) LIMIT 1/
-        {:id=>$1.to_i}
-      when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
-        [{:id=>1}, {:id=>2}, {:id=>3}]
-      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
-        a = []
-        a << {:tag_id=>1} if $1 == '1'
-        a << {:tag_id=>2} if $1 != '3'
-        a << {:tag_id=>3} if $1 == '2'
-        a
-      when "SELECT first, last FROM vocalists WHERE (vocalists.album_id = 1)"
-        [{:first=>"F1", :last=>"L1"}, {:first=>"F2", :last=>"L2"}]
-      when /SELECT first, last FROM albums_vocalists WHERE \(album_id = (\d)\)/
-        a = []
-        a << {:first=>"F1", :last=>"L1"} if $1 == '1'
-        a << {:first=>"F2", :last=>"L2"} if $1 != '3'
-        a << {:first=>"F3", :last=>"L3"} if $1 == '2'
-        a
-      when "SELECT id FROM instruments WHERE ((instruments.first = 'F1') AND (instruments.last = 'L1'))"
-        [{:id=>1}, {:id=>2}]
-      when /SELECT instrument_id FROM vocalists_instruments WHERE \(\((?:first|last) = '?[FL1](\d)/
-        a = []
-        a << {:instrument_id=>1} if $1 == "1"
-        a << {:instrument_id=>2} if $1 != "3"
-        a << {:instrument_id=>3} if $1 == "2"
-        a
-      when "SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"
-        [{:year=>1997, :week=>1}, {:year=>1997, :week=>2}]
-      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/
-        a = []
-        a << {:year=>1997, :week=>1} if $1 == "1"
-        a << {:year=>1997, :week=>2} if $1 != "3"
-        a << {:year=>1997, :week=>3} if $1 == "2"
-        a
-      end
-    end)
-    @Artist = Class.new(Sequel::Model(@db[:artists]))
-    @Artist.columns :id
-    @Album = Class.new(Sequel::Model(@db[:albums]))
-    @Album.columns :id, :artist_id
-    @Tag = Class.new(Sequel::Model(@db[:tags]))
-    @Tag.columns :id
-    @Vocalist = Class.new(Sequel::Model(@db[:vocalists]))
-    @Vocalist.columns :first, :last, :album_id
-    @Vocalist.set_primary_key [:first, :last]
-    @Instrument = Class.new(Sequel::Model(@db[:instruments]))
-    @Instrument.columns :id, :first, :last
-    @Hit = Class.new(Sequel::Model(@db[:hits]))
-    @Hit.columns :year, :week, :first, :last
-    @Hit.set_primary_key [:year, :week]
-    @Artist.plugin :association_pks
-    @Album.plugin :association_pks
-    @Vocalist.plugin :association_pks
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
-    @db.sqls
-  end
-
-  it "should return correct associated pks for one_to_many associations" do
-    @Artist.load(:id=>1).album_pks.must_equal [1,2,3]
-    @Artist.load(:id=>2).album_pks.must_equal []
-  end
-
-  it "should return correct associated pks for many_to_many associations" do
-    @Album.load(:id=>1).tag_pks.must_equal [1, 2]
-    @Album.load(:id=>2).tag_pks.must_equal [2, 3]
-    @Album.load(:id=>3).tag_pks.must_equal []
-  end
-
-  it "should set associated pks correctly for a one_to_many association" do
-    @Artist.load(:id=>1).album_pks = [1, 2]
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
-  end
-
-  it "should use associated class's primary key for a one_to_many association" do
-    @Album.set_primary_key :foo
-    @Artist.load(:id=>1).album_pks = [1, 2]
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (foo NOT IN (1, 2)))"]
-  end
-
-  it "should set associated pks correctly for a many_to_many association" do
-    @Album.load(:id=>2).tag_pks = [1, 3]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[2].must_equal 'BEGIN'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls[4].must_equal 'COMMIT'
-    sqls.length.must_equal 5
-  end
-
-  it "should return correct right-side associated cpks for one_to_many associations" do
-    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
-    @Album.load(:id=>1).vocalist_pks.must_equal [["F1", "L1"], ["F2", "L2"]]
-    @Album.load(:id=>2).vocalist_pks.must_equal []
-  end
-
-  it "should return correct right-side associated cpks for many_to_many associations" do
-    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
-    @Album.load(:id=>1).vocalist_pks.must_equal [["F1", "L1"], ["F2", "L2"]]
-    @Album.load(:id=>2).vocalist_pks.must_equal [["F2", "L2"], ["F3", "L3"]]
-    @Album.load(:id=>3).vocalist_pks.must_equal []
-  end
-
-  it "should set associated right-side cpks correctly for a one_to_many association" do
-    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
-    @Album.load(:id=>1).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
-    @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN (('F1', 'L1'), ('F2', 'L2')))",
-      "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"]
-  end
-
-  it "should set associated right-side cpks correctly for a many_to_many association" do
-    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
-    @Album.load(:id=>2).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"
-    sqls[1].must_equal 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
-    match = sqls[3].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F1'", "last"=>"'L1'", "album_id"=>"2")
-    sqls.length.must_equal 5
-  end
-
-  it "should return correct associated pks for left-side cpks for one_to_many associations" do
-    @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.must_equal [1, 2]
-    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.must_equal []
-  end
-
-  it "should return correct associated pks for left-side cpks for many_to_many associations" do
-    @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.must_equal [1, 2]
-    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.must_equal [2, 3]
-    @Vocalist.load(:first=>'F3', :last=>'L3').instrument_pks.must_equal []
-  end
-
-  it "should set associated pks correctly for left-side cpks for a one_to_many association" do
-    @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks = [1, 2]
-    sqls = @db.sqls
-    sqls[0].must_match(/UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/)
-    sqls[1].must_match(/UPDATE instruments SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(instruments.first = 'F1'\) AND \(instruments.last = 'L1'\) AND \(id NOT IN \(1, 2\)\)\)/)
-    sqls.length.must_equal 2
-  end
-
-  it "should set associated pks correctly for left-side cpks for a many_to_many association" do
-    @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
-    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks = [1, 2]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2') AND (instrument_id NOT IN (1, 2)))"
-    sqls[1].must_equal "SELECT instrument_id FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2'))"
-    match = sqls[3].match(/INSERT INTO vocalists_instruments \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "instrument_id"=>"1")
-    sqls.length.must_equal 5
-  end
-
-  it "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
-    @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal []
-  end
-
-  it "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
-    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
-    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
-    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
-  end
-
-  it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do
-    @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last], :order=>:week
-    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks = [[1997, 1], [1997, 2]]
-    sqls = @db.sqls
-    sqls[0].must_match(/UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/)
-    sqls[1].must_match(/UPDATE hits SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(hits.first = 'F1'\) AND \(hits.last = 'L1'\) AND \(\(year, week\) NOT IN \(\(1997, 1\), \(1997, 2\)\)\)\)/)
-    sqls.length.must_equal 2
-  end
-
-  it "should set associated right-side cpks correctly for left-side cpks for a many_to_many association" do
-    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [[1997, 1], [1997, 2]]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
-    sqls[1].must_equal "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
-    match = sqls[3].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1")
-    sqls.length.must_equal 5
-  end
-
-  it "should use transactions if the object is configured to use transactions" do
-    artist = @Artist.load(:id=>1)
-    artist.use_transactions = true
-    artist.album_pks = [1, 2]
-    @db.sqls.must_equal ["BEGIN",
-      "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))",
-      "COMMIT"]
-
-    album = @Album.load(:id=>2)
-    album.use_transactions = true
-    album.tag_pks = [1, 3]
-    sqls = @db.sqls
-    sqls[0].must_equal "BEGIN"
-    sqls[1].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[2].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls[4].must_equal "COMMIT"
-    sqls.length.must_equal 5
-  end
-
-  it "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
-    @Album.db_schema[:id][:type] = :integer
-    @Artist.load(:id=>1).album_pks = %w'1 2'
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
-  end
-
-  it "should not automatically convert keys if the primary key is not an integer for one_to_many associations" do
-    @Album.db_schema[:id][:type] = :string
-    @Artist.load(:id=>1).album_pks = %w'1 2'
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN ('1', '2')))"]
-  end
-
-  it "should automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
-    @Tag.db_schema[:id][:type] = :integer
-    @Album.load(:id=>2).tag_pks = %w'1 3'
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls.length.must_equal 5
-  end
-
-  it "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
-    @Tag.db_schema[:id][:type] = :string
-    @Album.load(:id=>2).tag_pks = %w'1 3'
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/)
-    sqls[4].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/)
-    sqls.length.must_equal 6
-  end
-
-  it "should automatically convert keys to numbers for appropriate integer primary key for composite key associations" do
-    @Hit.db_schema[:year][:type] = :integer
-    @Hit.db_schema[:week][:type] = :integer
-    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [['1997', '1'], ['1997', '2']]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
-    sqls[1].must_equal "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
-    match = sqls[3].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1")
-    sqls.length.must_equal 5
-
-    @Vocalist.db_schema[:first][:type] = :integer
-    @Vocalist.db_schema[:last][:type] = :integer
-    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
-    @Album.load(:id=>1).vocalist_pks = [["11", "11"], ["12", "12"]]
-    @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN ((11, 11), (12, 12)))",
-      "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN ((11, 11), (12, 12))))"]
-
-    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
-    @Album.load(:id=>2).vocalist_pks = [["11", "11"], ["12", "12"]]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN ((11, 11), (12, 12))))"
-    sqls[1].must_equal 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
-    match = sqls[3].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"11", "last"=>"11", "album_id"=>"2")
-    match = sqls[4].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"12", "last"=>"12", "album_id"=>"2")
-    sqls.length.must_equal 6
-  end
-
-  it "should handle delaying setting of association pks until after saving for new objects, if :delay plugin option is used" do
-    @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>true
-    @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>true
-
-    ar = @Artist.new
-    ar.album_pks.must_equal []
-    ar.album_pks = [1,2,3]
-    ar.album_pks.must_equal [1,2,3]
-    @db.sqls.must_equal []
-
-    ar.save
-    @db.sqls.must_equal [
-      "INSERT INTO artists DEFAULT VALUES",
-      "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2, 3))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2, 3)))",
-      "SELECT * FROM artists WHERE (id = 1) LIMIT 1",
-    ]
-
-    al = @Album.new
-    al.tag_pks.must_equal []
-    al.tag_pks = [1,2]
-    al.tag_pks.must_equal [1, 2]
-    @db.sqls.must_equal []
-
-    al.save
-    @db.sqls.must_equal [
-      "INSERT INTO albums DEFAULT VALUES",
-      "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 2)))",
-      "SELECT tag_id FROM albums_tags WHERE (album_id = 2)",
-      "BEGIN",
-      "INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)",
-      "COMMIT",
-      "SELECT * FROM albums WHERE (id = 2) LIMIT 1"
-    ]
-  end
-
-  it "should handle delaying setting of association pks until after saving for existing objects, if :delay=>:all plugin option is used" do
-    @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>:always
-    @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>:always
-
-    ar = @Artist.load(:id=>1)
-    ar.album_pks.must_equal [1,2,3]
-    @db.sqls
-    ar.album_pks = [2,4]
-    ar.album_pks.must_equal [2,4]
-    @db.sqls.must_equal []
-
-    ar.save_changes
-    @db.sqls.must_equal [
-      "UPDATE albums SET artist_id = 1 WHERE (id IN (2, 4))",
-      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (2, 4)))"
-    ]
-
-    al = @Album.load(:id=>1)
-    al.tag_pks.must_equal [1,2]
-    @db.sqls
-    al.tag_pks = [2,3]
-    al.tag_pks.must_equal [2,3]
-    @db.sqls.must_equal []
-
-    al.save_changes
-    @db.sqls.must_equal [
-      "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id NOT IN (2, 3)))",
-      "SELECT tag_id FROM albums_tags WHERE (album_id = 1)",
-      "BEGIN",
-      "INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3)",
-      "COMMIT",
-    ]
-  end
-
-  it "should clear delayed associated pks if refreshing, if :delay plugin option is used" do
-    @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>:always
-    @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>:always
-
-    ar = @Artist.load(:id=>1)
-    ar.album_pks.must_equal [1,2,3]
-    ar.album_pks = [2,4]
-    ar.album_pks.must_equal [2,4]
-    ar.refresh
-    ar.album_pks.must_equal [1,2,3]
-  end
-end