sequel 4.22.0 → 4.23.0

data/spec/extensions/csv_serializer_spec.rb

@@ -30,8 +30,8 @@ describe "Sequel::Plugins::CsvSerializer" do
   end
 
   it "should round trip successfully" do
-    @Artist.from_csv(@artist.to_csv).should == @artist
-    @Album.from_csv(@album.to_csv).should == @album
+    @Artist.from_csv(@artist.to_csv).must_equal @artist
+    @Album.from_csv(@album.to_csv).must_equal @album
   end
 
   it "should handle ruby objects in values" do
@@ -40,78 +40,78 @@ describe "Sequel::Plugins::CsvSerializer" do
     end
     a = @Artist.load(:name=>Date.today)
     opts = {:columns=>[:name]}
-    @Artist.from_csv(a.to_csv(opts), opts).should == a
+    @Artist.from_csv(a.to_csv(opts), opts).must_equal a
   end
 
   it "should handle the :only option" do
-    @Artist.from_csv(@artist.to_csv(:only=>:name), :only=>:name).should == @Artist.load(:name=>@artist.name)
-    @Album.from_csv(@album.to_csv(:only=>[:id, :name]), :only=>[:id, :name]).should == @Album.load(:id=>@album.id, :name=>@album.name)
+    @Artist.from_csv(@artist.to_csv(:only=>:name), :only=>:name).must_equal @Artist.load(:name=>@artist.name)
+    @Album.from_csv(@album.to_csv(:only=>[:id, :name]), :only=>[:id, :name]).must_equal @Album.load(:id=>@album.id, :name=>@album.name)
   end
 
   it "should handle the :except option" do
-    @Artist.from_csv(@artist.to_csv(:except=>:id), :except=>:id).should == @Artist.load(:name=>@artist.name)
-    @Album.from_csv(@album.to_csv(:except=>[:id, :artist_id]), :except=>[:id, :artist_id]).should == @Album.load(:name=>@album.name)
+    @Artist.from_csv(@artist.to_csv(:except=>:id), :except=>:id).must_equal @Artist.load(:name=>@artist.name)
+    @Album.from_csv(@album.to_csv(:except=>[:id, :artist_id]), :except=>[:id, :artist_id]).must_equal @Album.load(:name=>@album.name)
   end
 
   it "should handle the :include option for arbitrary attributes" do
-    @Album.from_csv(@album.to_csv(:include=>:blah), :include=>:blah).blah.should == @album.blah
+    @Album.from_csv(@album.to_csv(:include=>:blah), :include=>:blah).blah.must_equal @album.blah
   end
 
   it "should handle multiple inclusions using an array for the :include option" do
     a = @Album.from_csv(@album.to_csv(:include=>[:blah]), :include=>:blah)
-    a.blah.should == @album.blah
+    a.blah.must_equal @album.blah
   end
 
   it "#from_csv should set column values" do
     @artist.from_csv('AS', :only=>:name)
-    @artist.name.should == 'AS'
-    @artist.id.should == 2
+    @artist.name.must_equal 'AS'
+    @artist.id.must_equal 2
 
     @artist.from_csv('1', :only=>:id)
-    @artist.name.should == 'AS'
-    @artist.id.should == 1
+    @artist.name.must_equal 'AS'
+    @artist.id.must_equal 1
   end
 
   it ".array_from_csv should support :headers to specify headers" do
     @albums = @Album.array_from_csv("AS,2\nDF,3", :headers=>['name', 'artist_id'])
-    @albums.map(&:name).should == %w'AS DF'
-    @albums.map(&:artist_id).should == [2, 3]
+    @albums.map(&:name).must_equal %w'AS DF'
+    @albums.map(&:artist_id).must_equal [2, 3]
 
     @albums = @Album.array_from_csv("2,AS\n3,DF", :headers=>[nil, 'name'])
-    @albums.map(&:name).should == %w'AS DF'
-    @albums.map(&:artist_id).should == [nil, nil]
+    @albums.map(&:name).must_equal %w'AS DF'
+    @albums.map(&:artist_id).must_equal [nil, nil]
   end
 
   it ".from_csv should support :headers to specify headers" do
     @album = @Album.from_csv('AS,2', :headers=>['name', 'artist_id'])
-    @album.name.should == 'AS'
-    @album.artist_id.should == 2
+    @album.name.must_equal 'AS'
+    @album.artist_id.must_equal 2
 
     @album = @Album.from_csv('2,AS', :headers=>[nil, 'name'])
-    @album.name.should == 'AS'
-    @album.artist_id.should == nil
+    @album.name.must_equal 'AS'
+    @album.artist_id.must_equal nil
   end
 
   it "#from_csv should support :headers to specify headers" do
     @album.from_csv('AS,2', :headers=>['name'])
-    @album.name.should == 'AS'
-    @album.artist_id.should == 2
+    @album.name.must_equal 'AS'
+    @album.artist_id.must_equal 2
 
     @album.from_csv('2,AS', :headers=>[nil, 'name'])
-    @album.name.should == 'AS'
-    @album.artist_id.should == 2
+    @album.name.must_equal 'AS'
+    @album.artist_id.must_equal 2
   end
 
   it "should support a to_csv class and dataset method" do
     @Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
     @Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
-    @Album.array_from_csv(@Album.to_csv).should == [@album]
-    @Album.array_from_csv(@Album.dataset.to_csv(:only=>:name), :only=>:name).should == [@Album.load(:name=>@album.name)]
+    @Album.array_from_csv(@Album.to_csv).must_equal [@album]
+    @Album.array_from_csv(@Album.dataset.to_csv(:only=>:name), :only=>:name).must_equal [@Album.load(:name=>@album.name)]
   end
 
   it "should have dataset to_csv method respect :array option" do
     a = @Album.new(:id=>1, :name=>'RF', :artist_id=>3)
-    @Album.array_from_csv(@Album.to_csv(:array=>[a])).should == [a]
+    @Album.array_from_csv(@Album.to_csv(:array=>[a])).must_equal [a]
   end
 
   it "#to_csv should respect class options" do
@@ -127,34 +127,34 @@ describe "Sequel::Plugins::CsvSerializer" do
     @album.artist = @artist
     @album.blah = 'Gak'
 
-    @album.to_csv.should == "name,artist_id,blah\nJK,2,Gak\n"
-    @album.to_csv(:write_headers=>false).should == "JK,2,Gak\n"
-    @album.to_csv(:headers=>[:name]).should == "name\nJK\n"
-    @album.to_csv(:headers=>[:name, :id]).should == "name,id\nJK,2\n"
-    @album.to_csv(:only=>[:name]).should == "name,blah\nJK,Gak\n"
-    @album.to_csv(:except=>nil).should == "id,name,artist_id,blah\n2,JK,2,Gak\n"
-    @album.to_csv(:except=>[:blah]).should == "id,name,artist_id\n2,JK,2\n"
+    @album.to_csv.must_equal "name,artist_id,blah\nJK,2,Gak\n"
+    @album.to_csv(:write_headers=>false).must_equal "JK,2,Gak\n"
+    @album.to_csv(:headers=>[:name]).must_equal "name\nJK\n"
+    @album.to_csv(:headers=>[:name, :id]).must_equal "name,id\nJK,2\n"
+    @album.to_csv(:only=>[:name]).must_equal "name,blah\nJK,Gak\n"
+    @album.to_csv(:except=>nil).must_equal "id,name,artist_id,blah\n2,JK,2,Gak\n"
+    @album.to_csv(:except=>[:blah]).must_equal "id,name,artist_id\n2,JK,2\n"
   end
 
   it "should store the default options in csv_serializer_opts" do
-    @Album.csv_serializer_opts.should == {}
+    @Album.csv_serializer_opts.must_equal({})
     c = Class.new(@Album)
     @Album.csv_serializer_opts[:include] = :blah
     c.plugin :csv_serializer, :naked=>false
-    c.csv_serializer_opts.should == {:naked=>false}
-    @Album.csv_serializer_opts.should == {:include=>:blah}
+    c.csv_serializer_opts.must_equal(:naked=>false)
+    @Album.csv_serializer_opts.must_equal(:include=>:blah)
   end
 
   it "should work correctly when subclassing" do
     @Artist2 = Class.new(@Artist)
     @Artist2.plugin :csv_serializer, :only=>:name
     @Artist3 = Class.new(@Artist2)
-    @Artist3.from_csv(@Artist3.load(:id=>2, :name=>'YYY').to_csv).should == @Artist3.load(:name=>'YYY')
+    @Artist3.from_csv(@Artist3.load(:id=>2, :name=>'YYY').to_csv).must_equal @Artist3.load(:name=>'YYY')
   end
 
   it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
     @Artist.restrict_primary_key
-    proc{@Artist.from_csv(@artist.to_csv)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{@Artist.from_csv(@artist.to_csv)}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should use a dataset's selected columns" do
@@ -162,12 +162,12 @@ describe "Sequel::Plugins::CsvSerializer" do
     ds = @Artist.select(*columns).limit(1)
     ds.instance_variable_set(:@columns, columns)
     ds._fetch = [:id => 10]
-    ds.to_csv(:write_headers => true).should == "id\n10\n"
+    ds.to_csv(:write_headers => true).must_equal "id\n10\n"
   end
 
   it "should pass all the examples from the documentation" do
-    @album.to_csv(:write_headers=>true).should == "id,name,artist_id\n1,RF,2\n"
-    @album.to_csv(:only=>:name).should == "RF\n"
-    @album.to_csv(:except=>[:id, :artist_id]).should == "RF\n"
+    @album.to_csv(:write_headers=>true).must_equal "id,name,artist_id\n1,RF,2\n"
+    @album.to_csv(:only=>:name).must_equal "RF\n"
+    @album.to_csv(:except=>[:id, :artist_id]).must_equal "RF\n"
   end
 end

data/spec/extensions/current_datetime_timestamp_spec.rb

@@ -8,20 +8,20 @@ describe "current_datetime_timestamp extension" do
     Sequel.datetime_class = Time
   end
 
-  specify "should have current_timestamp respect Sequel.datetime_class" do
+  it "should have current_timestamp respect Sequel.datetime_class" do
     t = Sequel::Dataset.new(nil).current_datetime 
-    t.should be_a_kind_of(Time)
-    (Time.now - t < 0.1).should == true
+    t.must_be_kind_of(Time)
+    (Time.now - t < 0.1).must_equal true
 
     Sequel.datetime_class = DateTime
     t = Sequel::Dataset.new(nil).current_datetime 
-    t.should be_a_kind_of(DateTime)
-    (DateTime.now - t < (0.1/86400)).should == true
+    t.must_be_kind_of(DateTime)
+    (DateTime.now - t < (0.1/86400)).must_equal true
   end
 
-  specify "should have current_timestamp value be literalized as CURRENT_TIMESTAMP" do
-    @ds.literal(@ds.current_datetime).should == 'CURRENT_TIMESTAMP'
+  it "should have current_timestamp value be literalized as CURRENT_TIMESTAMP" do
+    @ds.literal(@ds.current_datetime).must_equal 'CURRENT_TIMESTAMP'
     Sequel.datetime_class = DateTime
-    @ds.literal(@ds.current_datetime).should == 'CURRENT_TIMESTAMP'
+    @ds.literal(@ds.current_datetime).must_equal 'CURRENT_TIMESTAMP'
   end
 end

data/spec/extensions/dataset_associations_spec.rb

@@ -43,166 +43,166 @@ describe "Sequel::Plugins::DatasetAssociations" do
 
   it "should work for many_to_one associations" do
     ds = @Album.artists
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Artist
-    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Artist
+    ds.sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
   end
 
   it "should work for one_to_many associations" do
     ds = @Artist.albums
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Album
-    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Album
+    ds.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
   end
 
   it "should work for one_to_one associations" do
     ds = @Artist.first_albums
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Album
-    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Album
+    ds.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
   end
 
   it "should work for many_to_many associations" do
     ds = @Album.tags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
   end
 
   it "should work for one_through_one associations" do
     ds = @Album.first_tags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums))))"
   end
 
   it "should work for many_through_many associations" do
     ds = @Artist.tags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
   it "should work for one_through_many associations" do
     ds = @Artist.otags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
   it "should work for pg_array_to_many associations" do
     ds = @Artist.artist_tags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT * FROM tags WHERE (id IN (SELECT unnest(artists.tag_ids) FROM artists))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT * FROM tags WHERE (id IN (SELECT unnest(artists.tag_ids) FROM artists))"
   end
 
   it "should work for many_to_pg_array associations" do
     ds = @Tag.artists
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Artist
-    ds.sql.should == "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), 'f')"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Artist
+    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), 'f')"
   end
 
   it "should have an associated method that takes an association symbol" do
     ds = @Album.associated(:artist)
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Artist
-    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Artist
+    ds.sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
   end
 
   it "should raise an Error if an invalid association is given to associated" do
-    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+    proc{@Album.associated(:foo)}.must_raise(Sequel::Error)
   end
 
   it "should raise an Error if an unrecognized association type is used" do
     @Album.association_reflection(:artist)[:type] = :foo
-    proc{@Album.artists}.should raise_error(Sequel::Error)
+    proc{@Album.artists}.must_raise(Sequel::Error)
   end
 
   it "should work correctly when chaining" do
     ds = @Artist.albums.tags
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.model.should == @Tag
-    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))))"
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id) IN (SELECT albums.id FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))))"
   end
 
   it "should deal correctly with filters before the association method" do
-    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+    @Artist.filter(:id=>1).albums.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
   end
 
   it "should deal correctly with filters after the association method" do
-    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+    @Artist.albums.filter(:id=>1).sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
   end
 
   it "should deal correctly with block on the association" do
     @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
-    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
   end
 
   it "should deal correctly with :conditions option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
-    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
   end
 
   it "should deal correctly with :distinct option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
-    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+    @Artist.albums.sql.must_equal "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
   end
 
   it "should deal correctly with :eager option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
-    @Artist.albums.opts[:eager].should == {:tags=>nil}
+    @Artist.albums.opts[:eager].must_equal(:tags=>nil)
   end
 
   it "should deal correctly with :eager_block option on the association, ignoring the association block" do
     @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
-    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
   end
 
   it "should deal correctly with :extend option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
-    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+    @Artist.albums.foo(1).sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
   end
 
   it "should deal correctly with :order option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
-    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
   end
 
   it "should deal correctly with :select option on the association" do
     @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
-    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+    @Artist.albums.sql.must_equal "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
   end
 
   it "should deal correctly with :order option for one_to_one associations" do
     @Artist.one_to_one :first_album, :clone=>:first_album, :order=>:name
-    @Artist.first_albums.sql.should == 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT DISTINCT ON (albums.artist_id) albums.id FROM albums ORDER BY albums.artist_id, name))) ORDER BY name'
+    @Artist.first_albums.sql.must_equal 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT DISTINCT ON (albums.artist_id) albums.id FROM albums ORDER BY albums.artist_id, name))) ORDER BY name'
   end
 
   it "should deal correctly with :limit option for one_to_many associations" do
     @Artist.one_to_many :albums, :clone=>:albums, :limit=>10, :order=>:name
-    @Artist.albums.sql.should == 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT id FROM (SELECT albums.id, row_number() OVER (PARTITION BY albums.artist_id ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
+    @Artist.albums.sql.must_equal 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT id FROM (SELECT albums.id, row_number() OVER (PARTITION BY albums.artist_id ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
   end
 
   it "should deal correctly with :order option for one_through_one associations" do
     @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>:tags__name
-    @Album.first_tags.sql.should == 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT DISTINCT ON (albums_tags.album_id) albums_tags.album_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) ORDER BY albums_tags.album_id, tags.name))))) ORDER BY tags.name'
+    @Album.first_tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT DISTINCT ON (albums_tags.album_id) albums_tags.album_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) ORDER BY albums_tags.album_id, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_to_many associations" do
     @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
-    @Album.tags.sql.should == 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT b, c FROM (SELECT albums_tags.album_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_tags.album_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
+    @Album.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT b, c FROM (SELECT albums_tags.album_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_tags.album_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :order option for one_through_many associations" do
     @Artist.one_through_many :otag, :clone=>:otag, :order=>:tags__name
-    @Artist.otags.sql.should == 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT DISTINCT ON (albums.artist_id) albums.artist_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) ORDER BY albums.artist_id, tags.name))))) ORDER BY tags.name'
+    @Artist.otags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT DISTINCT ON (albums.artist_id) albums.artist_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) ORDER BY albums.artist_id, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_through_many associations" do
     @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
-    @Artist.tags.sql.should == 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT b, c FROM (SELECT albums.artist_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums.artist_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
+    @Artist.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT b, c FROM (SELECT albums.artist_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums.artist_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 end
 
@@ -248,64 +248,64 @@ describe "Sequel::Plugins::DatasetAssociations with composite keys" do
   end
 
   it "should work for many_to_one associations" do
-    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+    @Album.artists.sql.must_equal "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
   end
 
   it "should work for one_to_many associations" do
-    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
   end
 
   it "should work for one_to_one associations" do
-    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+    @Artist.first_albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
   end
 
   it "should work for many_to_many associations" do
-    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums))))"
+    @Album.tags.sql.must_equal "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums))))"
   end
 
   it "should work for one_through_one associations" do
-    @Album.first_tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums))))"
+    @Album.first_tags.sql.must_equal "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums))))"
   end
 
   it "should work for many_through_many associations" do
-    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+    @Artist.tags.sql.must_equal "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
   end
 
   it "should work for one_through_many associations" do
-    @Artist.otags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+    @Artist.otags.sql.must_equal "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
   end
 
   it "should work correctly when chaining" do
-    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))))"
+    @Artist.albums.tags.sql.must_equal "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))))"
   end
 
   it "should deal correctly with :order option for one_to_one associations" do
     @Artist.one_to_one :first_album, :clone=>:first_album, :order=>:name
-    @Artist.first_albums.sql.should == 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.id1, albums.id2 FROM albums ORDER BY albums.artist_id1, albums.artist_id2, name))) ORDER BY name'
+    @Artist.first_albums.sql.must_equal 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.id1, albums.id2 FROM albums ORDER BY albums.artist_id1, albums.artist_id2, name))) ORDER BY name'
   end
 
   it "should deal correctly with :limit option for one_to_many associations" do
     @Artist.one_to_many :albums, :clone=>:albums, :limit=>10, :order=>:name
-    @Artist.albums.sql.should == 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT id1, id2 FROM (SELECT albums.id1, albums.id2, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
+    @Artist.albums.sql.must_equal 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT id1, id2 FROM (SELECT albums.id1, albums.id2, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
   end
 
   it "should deal correctly with :order option for one_through_one associations" do
     @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>:tags__name
-    @Album.first_tags.sql.should == 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums_tags.album_id1, albums_tags.album_id2) albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) ORDER BY albums_tags.album_id1, albums_tags.album_id2, tags.name))))) ORDER BY tags.name'
+    @Album.first_tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums_tags.album_id1, albums_tags.album_id2) albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) ORDER BY albums_tags.album_id1, albums_tags.album_id2, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_to_many associations" do
     @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
-    @Album.tags.sql.should == 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums_tags.album_id1 AS b, albums_tags.album_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums_tags.album_id1, albums_tags.album_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
+    @Album.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums_tags.album_id1 AS b, albums_tags.album_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums_tags.album_id1, albums_tags.album_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :order option for one_through_many associations" do
     @Artist.one_through_many :otag, :clone=>:otag, :order=>:tags__name
-    @Artist.otags.sql.should == 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.artist_id1, albums.artist_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2)) ORDER BY albums.artist_id1, albums.artist_id2, tags.name))))) ORDER BY tags.name'
+    @Artist.otags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.artist_id1, albums.artist_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2)) ORDER BY albums.artist_id1, albums.artist_id2, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_through_many associations" do
     @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
-    @Artist.tags.sql.should == 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums.artist_id1 AS b, albums.artist_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
+    @Artist.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums.artist_id1 AS b, albums.artist_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 end