sequel 3.27.0 → 3.28.0

data/spec/core/spec_helper.rb

@@ -89,3 +89,14 @@ class Dummy2Database < Sequel::Database
   def transaction; yield; end
 end
 
+class DummyDataset < Sequel::Dataset
+  VALUES = [
+    {:a => 1, :b => 2},
+    {:a => 3, :b => 4},
+    {:a => 5, :b => 6}
+  ]
+  def fetch_rows(sql, &block)
+    VALUES.each(&block)
+  end
+end
+

data/spec/extensions/many_through_many_spec.rb

@@ -621,6 +621,120 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.length.should == 2
   end
 
+  it "should respect the :limit option on a many_through_many association" do
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2
+    Tag.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>1, :id=>5})
+        yield({:x_foreign_key_x=>1, :id=>6})
+        yield({:x_foreign_key_x=>1, :id=>7})
+      end
+    })
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+
+    MODEL_DB.reset
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1]
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
+    a.first.first_two_tags.should == [Tag.load(:id=>6), Tag.load(:id=>7)]
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should respect the :limit option on a many_through_many association using a :window_function strategy" do
+    Tag.dataset.meta_def(:supports_window_functions?){true}
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name
+    Tag.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>1, :id=>5})
+        yield({:x_foreign_key_x=>1, :id=>6})
+      end
+    })
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY 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) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+
+    MODEL_DB.reset
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY 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) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should respect the :limit option on a many_through_many association with composite primary keys on the main table using a :window_function strategy" do
+    Tag.dataset.meta_def(:supports_window_functions?){true}
+    @c1.set_primary_key([:id1, :id2])
+    @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name
+    @c1.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:id1=>1, :id2=>2})
+      end
+    })
+    Tag.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5})
+        yield({:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6})
+      end
+    })
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id1=>1, :id2=>2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY 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) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+
+    MODEL_DB.reset
+    @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id1=>1, :id2=>2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY 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) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should respect the :limit option on a many_through_many association using a :correlated_subquery strategy" do
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>:correlated_subquery, :order=>:name
+    Tag.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>1, :id=>5})
+        yield({:x_foreign_key_x=>1, :id=>6})
+      end
+    })
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2)) ORDER BY name']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+
+    MODEL_DB.reset
+    @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>:correlated_subquery, :order=>:name
+    a = @c1.eager(:first_two_tags).all
+    a.should == [@c1.load(:id=>1)]
+    MODEL_DB.sqls.should == ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2 OFFSET 1)) ORDER BY name']
+    a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
+    MODEL_DB.sqls.length.should == 2
+  end
+
   it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do
     proc{@c1.eager(:tags).all}.should_not raise_error
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :allow_eager=>false
@@ -637,7 +751,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.length.should == 2
   end
 
-  it "should respect many_to_many association's :left_primary_key and :right_primary_key options" do
+  it "should respect many_through_many association's :left_primary_key and :right_primary_key options" do
     @c1.send(:define_method, :yyy){values[:yyy]}
     @c1.dataset.extend(Module.new {
       def columns

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -23,16 +23,16 @@ describe "prepared_statements_with_pk plugin" do
 
   specify "should correctly lookup by primary key from dataset" do
     @c.dataset.filter(:name=>'foo')[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((name = 'foo') AND (id = 1)) LIMIT 1"]
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1"]
   end
 
   specify "should still work correctly if there are multiple conflicting variables" do
     @c.dataset.filter(:name=>'foo').or(:name=>'bar')[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (id = 1)) LIMIT 1"]
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (people.id = 1)) LIMIT 1"]
   end
 
   specify "should still work correctly if the primary key is used elsewhere in the query" do
     @c.dataset.filter{id > 2}[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((id > 2) AND (id = 1)) LIMIT 1"]
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((id > 2) AND (people.id = 1)) LIMIT 1"]
   end
 end

data/spec/integration/associations_test.rb

@@ -1,8 +1,105 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
+shared_examples_for "eager limit strategies" do
+  specify "eager loading one_to_one associations should work correctly" do
+    Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els) if @els
+    Artist.one_to_one  :last_album, {:clone=>:last_album}.merge(@els) if @els
+    @album.update(:artist => @artist)
+    diff_album = @diff_album.call
+    al, ar, t = @pr.call
+    
+    a = Artist.eager(:first_album, :last_album).all
+    a.should == [@artist, ar]
+    a.first.first_album.should == @album
+    a.first.last_album.should == diff_album
+    a.last.first_album.should == nil
+    a.last.last_album.should == nil
+
+    # Check that no extra columns got added by the eager loading
+    a.first.first_album.values.should == @album.values
+    a.first.last_album.values.should == diff_album.values
+
+    same_album = @same_album.call
+    a = Artist.eager(:first_album).all
+    a.should == [@artist, ar]
+    [@album, same_album].should include(a.first.first_album)
+    a.last.first_album.should == nil
+  end
+
+  specify "should correctly handle limits and offsets when eager loading one_to_many associations" do
+    Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els) if @els
+    Artist.one_to_many :second_two_albums, {:clone=>:second_two_albums}.merge(@els) if @els
+    Artist.one_to_many :last_two_albums, {:clone=>:last_two_albums}.merge(@els) if @els
+    @album.update(:artist => @artist)
+    middle_album = @middle_album.call
+    diff_album = @diff_album.call
+    al, ar, t = @pr.call
+    
+    ars = Artist.eager(:first_two_albums, :second_two_albums, :last_two_albums).order(:name).all
+    ars.should == [@artist, ar]
+    ars.first.first_two_albums.should == [@album, middle_album]
+    ars.first.second_two_albums.should == [middle_album, diff_album]
+    ars.first.last_two_albums.should == [diff_album, middle_album]
+    ars.last.first_two_albums.should == []
+    ars.last.second_two_albums.should == []
+    ars.last.last_two_albums.should == []
+    
+    # Check that no extra columns got added by the eager loading
+    ars.first.first_two_albums.map{|x| x.values}.should == [@album, middle_album].map{|x| x.values}
+    ars.first.second_two_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+    ars.first.last_two_albums.map{|x| x.values}.should == [diff_album, middle_album].map{|x| x.values}
+  end
+  
+  specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
+    Album.many_to_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
+    Album.many_to_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
+    Album.many_to_many :last_two_tags, {:clone=>:last_two_tags}.merge(@els) if @els
+    tu, tv = @other_tags.call
+    al, ar, t = @pr.call
+    
+    als = Album.eager(:first_two_tags, :second_two_tags, :last_two_tags).order(:name).all
+    als.should == [@album, al]
+    als.first.first_two_tags.should == [@tag, tu]
+    als.first.second_two_tags.should == [tu, tv]
+    als.first.last_two_tags.should == [tv, tu]
+    als.last.first_two_tags.should == []
+    als.last.second_two_tags.should == []
+    als.last.last_two_tags.should == []
+    
+    # Check that no extra columns got added by the eager loading
+    als.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
+    als.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    als.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+  end
+  
+  specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
+    Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
+    Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
+    Artist.many_through_many :last_two_tags, {:clone=>:last_two_tags}.merge(@els) if @els
+    @album.update(:artist => @artist)
+    tu, tv = @other_tags.call
+    al, ar, t = @pr.call
+    
+    ars = Artist.eager(:first_two_tags, :second_two_tags, :last_two_tags).order(:name).all
+    ars.should == [@artist, ar]
+    ars.first.first_two_tags.should == [@tag, tu]
+    ars.first.second_two_tags.should == [tu, tv]
+    ars.first.last_two_tags.should == [tv, tu]
+    ars.last.first_two_tags.should == []
+    ars.last.second_two_tags.should == []
+    ars.last.last_two_tags.should == []
+    
+    # Check that no extra columns got added by the eager loading
+    ars.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
+    ars.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    ars.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+  end
+end
+
 shared_examples_for "regular and composite key associations" do  
   specify "should return no objects if none are associated" do
     @album.artist.should == nil
+    @artist.first_album.should == nil
     @artist.albums.should == []
     @album.tags.should == []
     @tag.albums.should == []
@@ -17,6 +114,7 @@ shared_examples_for "regular and composite key associations" do
     @tag.reload
     
     @album.artist.should == @artist
+    @artist.first_album.should == @album
     @artist.albums.should == [@album]
     @album.tags.should == [@tag]
     @tag.albums.should == [@album]
@@ -32,6 +130,7 @@ shared_examples_for "regular and composite key associations" do
     
     [Tag, Album, Artist].each{|x| x.plugin :prepared_statements_associations}
     @album.artist.should == @artist
+    @artist.first_album.should == @album
     @artist.albums.should == [@album]
     @album.tags.should == [@tag]
     @tag.albums.should == [@album]
@@ -42,6 +141,7 @@ shared_examples_for "regular and composite key associations" do
     @album.add_tag(@tag)
     
     Artist.filter(:albums=>@album).all.should == [@artist]
+    Artist.filter(:first_album=>@album).all.should == [@artist]
     Album.filter(:artist=>@artist).all.should == [@album]
     Album.filter(:tags=>@tag).all.should == [@album]
     Tag.filter(:albums=>@album).all.should == [@tag]
@@ -55,6 +155,7 @@ shared_examples_for "regular and composite key associations" do
     album, artist, tag = @pr.call
 
     Artist.exclude(:albums=>@album).all.should == [artist]
+    Artist.exclude(:first_album=>@album).all.should == [artist]
     Album.exclude(:artist=>@artist).all.should == [album]
     Album.exclude(:tags=>@tag).all.should == [album]
     Tag.exclude(:albums=>@album).all.should == [tag]
@@ -67,6 +168,7 @@ shared_examples_for "regular and composite key associations" do
     @album.add_tag(@tag)
     
     Artist.filter(:albums=>[@album, album]).all.should == [@artist]
+    Artist.filter(:first_album=>[@album, album]).all.should == [@artist]
     Album.filter(:artist=>[@artist, artist]).all.should == [@album]
     Album.filter(:tags=>[@tag, tag]).all.should == [@album]
     Tag.filter(:albums=>[@album, album]).all.should == [@tag]
@@ -76,6 +178,7 @@ shared_examples_for "regular and composite key associations" do
     album.add_tag(tag)
 
     Artist.filter(:albums=>[@album, album]).all.should == [@artist]
+    Artist.filter(:first_album=>[@album, album]).all.should == [@artist]
     Album.filter(:artist=>[@artist, artist]).all.should == [@album]
     Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
     Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
@@ -84,6 +187,7 @@ shared_examples_for "regular and composite key associations" do
     album.update(:artist => artist)
 
     Artist.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Artist.filter(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
     Album.filter(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
     Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
     Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
@@ -94,6 +198,7 @@ shared_examples_for "regular and composite key associations" do
     album, artist, tag = @pr.call
 
     Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
     Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
     Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
     Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
@@ -103,6 +208,7 @@ shared_examples_for "regular and composite key associations" do
     @album.add_tag(@tag)
 
     Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [artist]
+    Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [artist]
     Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [album]
     Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
     Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [tag]
@@ -111,6 +217,7 @@ shared_examples_for "regular and composite key associations" do
     album.add_tag(tag)
 
     Artist.exclude(:albums=>[@album, album]).all.should == [artist]
+    Artist.exclude(:first_album=>[@album, album]).all.should == [artist]
     Album.exclude(:artist=>[@artist, artist]).all.should == [album]
     Album.exclude(:tags=>[@tag, tag]).all.should == []
     Tag.exclude(:albums=>[@album, album]).all.should == []
@@ -119,6 +226,7 @@ shared_examples_for "regular and composite key associations" do
     album.update(:artist => artist)
 
     Artist.exclude(:albums=>[@album, album]).all.should == []
+    Artist.exclude(:first_album=>[@album, album]).all.should == []
     Album.exclude(:artist=>[@artist, artist]).all.should == []
     Album.exclude(:tags=>[@tag, tag]).all.should == []
     Tag.exclude(:albums=>[@album, album]).all.should == []
@@ -127,6 +235,7 @@ shared_examples_for "regular and composite key associations" do
   
   specify "should work correctly when excluding by associations in regards to NULL values" do
     Artist.exclude(:albums=>@album).all.should == [@artist]
+    Artist.exclude(:first_album=>@album).all.should == [@artist]
     Album.exclude(:artist=>@artist).all.should == [@album]
     Album.exclude(:tags=>@tag).all.should == [@album]
     Tag.exclude(:albums=>@album).all.should == [@tag]
@@ -156,6 +265,9 @@ shared_examples_for "regular and composite key associations" do
     Artist.filter(:albums=>Album.dataset).all.sort_by{|x| x.pk}.should == [@artist, artist]
     Artist.filter(:albums=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
     Artist.filter(:albums=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+    Artist.filter(:first_album=>Album.dataset).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Artist.filter(:first_album=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
+    Artist.filter(:first_album=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
     Album.filter(:artist=>Artist.dataset).all.sort_by{|x| x.pk}.should == [@album, album]
     Album.filter(:artist=>Artist.dataset.filter(Array(Artist.primary_key).zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [album]
     Album.filter(:artist=>Artist.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
@@ -226,9 +338,10 @@ shared_examples_for "regular and composite key associations" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    a = Artist.eager(:albums=>:tags).all
+    a = Artist.eager(:albums=>:tags).eager(:first_album).all
     a.should == [@artist]
     a.first.albums.should == [@album]
+    a.first.first_album.should == @album
     a.first.albums.first.tags.should == [@tag]
     
     a = Tag.eager(:albums=>:artist).all
@@ -237,13 +350,32 @@ shared_examples_for "regular and composite key associations" do
     a.first.albums.first.artist.should == @artist
   end
   
+  describe "with no :eager_limit_strategy" do
+    it_should_behave_like "eager limit strategies"
+  end
+
+  describe "with :eager_limit_strategy=>true" do
+    before do
+      @els = {:eager_limit_strategy=>true}
+    end
+    it_should_behave_like "eager limit strategies"
+  end
+
+  describe "with :eager_limit_strategy=>:window_function" do
+    before do
+      @els = {:eager_limit_strategy=>:window_function}
+    end
+    it_should_behave_like "eager limit strategies"
+  end if INTEGRATION_DB.dataset.supports_window_functions?
+
   specify "should eager load via eager_graph correctly" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    a = Artist.eager_graph(:albums=>:tags).all
+    a = Artist.eager_graph(:albums=>:tags).eager_graph(:first_album).all
     a.should == [@artist]
     a.first.albums.should == [@album]
+    a.first.first_album.should == @album
     a.first.albums.first.tags.should == [@tag]
     
     a = Tag.eager_graph(:albums=>:artist).all
@@ -285,31 +417,43 @@ end
 describe "Sequel::Model Simple Associations" do
   before do
     @db = INTEGRATION_DB
-    @db.create_table!(:artists) do
+    [:albums_tags, :tags, :albums, :artists].each{|t| @db.drop_table(t) rescue nil}
+    @db.create_table(:artists) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:albums) do
+    @db.create_table(:albums) do
       primary_key :id
       String :name
       foreign_key :artist_id, :artists
     end
-    @db.create_table!(:tags) do
+    @db.create_table(:tags) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:albums_tags) do
+    @db.create_table(:albums_tags) do
       foreign_key :album_id, :albums
       foreign_key :tag_id, :tags
     end
     class ::Artist < Sequel::Model(@db)
       one_to_many :albums
+      one_to_one :first_album, :class=>:Album, :order=>:name
+      one_to_one :last_album, :class=>:Album, :order=>:name.desc
+      one_to_many :first_two_albums, :class=>:Album, :order=>:name, :limit=>2
+      one_to_many :second_two_albums, :class=>:Album, :order=>:name, :limit=>[2, 1]
+      one_to_many :last_two_albums, :class=>:Album, :order=>:name.desc, :limit=>2
       plugin :many_through_many
-      Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]]
+      many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]]
+      many_through_many :first_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>2
+      many_through_many :second_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>[2, 1]
+      many_through_many :last_two_tags, :clone=>:tags, :order=>:tags__name.desc, :limit=>2
     end
     class ::Album < Sequel::Model(@db)
       many_to_one :artist
-      many_to_many :tags
+      many_to_many :tags, :right_key=>:tag_id
+      many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
+      many_to_many :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
+      many_to_many :last_two_tags, :clone=>:tags, :order=>:name.desc, :limit=>2
     end
     class ::Tag < Sequel::Model(@db)
       many_to_many :albums
@@ -317,6 +461,10 @@ describe "Sequel::Model Simple Associations" do
     @album = Album.create(:name=>'Al')
     @artist = Artist.create(:name=>'Ar')
     @tag = Tag.create(:name=>'T')
+    @same_album = lambda{Album.create(:name=>'Al', :artist_id=>@artist.id)}
+    @diff_album = lambda{Album.create(:name=>'lA', :artist_id=>@artist.id)}
+    @middle_album = lambda{Album.create(:name=>'Bl', :artist_id=>@artist.id)}
+    @other_tags = lambda{t = [Tag.create(:name=>'U'), Tag.create(:name=>'V')]; @db[:albums_tags].insert([:album_id, :tag_id], Tag.select(@album.id, :id)); t}
     @pr = lambda{[Album.create(:name=>'Al2'),Artist.create(:name=>'Ar2'),Tag.create(:name=>'T2')]}
     @ins = lambda{@db[:albums_tags].insert(:tag_id=>@tag.id)}
   end
@@ -325,6 +473,15 @@ describe "Sequel::Model Simple Associations" do
     [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
   end
   
+  it_should_behave_like "regular and composite key associations"
+
+  describe "with :eager_limit_strategy=>:correlated_subquery" do
+    before do
+      @els = {:eager_limit_strategy=>:correlated_subquery}
+    end
+    it_should_behave_like "eager limit strategies"
+  end unless [:mysql, :db2].include?(INTEGRATION_DB.database_type)
+
   specify "should handle aliased tables when eager_graphing" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
@@ -348,8 +505,6 @@ describe "Sequel::Model Simple Associations" do
     a.first.balbums.first.bartist.should == @artist
   end
   
-  it_should_behave_like "regular and composite key associations"
-
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
     Album.delete
@@ -435,13 +590,14 @@ end
 describe "Sequel::Model Composite Key Associations" do
   before do
     @db = INTEGRATION_DB
-    @db.create_table!(:artists) do
+    [:albums_tags, :tags, :albums, :artists].each{|t| @db.drop_table(t) rescue nil}
+    @db.create_table(:artists) do
       Integer :id1
       Integer :id2
       String :name
       primary_key [:id1, :id2]
     end
-    @db.create_table!(:albums) do
+    @db.create_table(:albums) do
       Integer :id1
       Integer :id2
       String :name
@@ -450,13 +606,13 @@ describe "Sequel::Model Composite Key Associations" do
       foreign_key [:artist_id1, :artist_id2], :artists
       primary_key [:id1, :id2]
     end
-    @db.create_table!(:tags) do
+    @db.create_table(:tags) do
       Integer :id1
       Integer :id2
       String :name
       primary_key [:id1, :id2]
     end
-    @db.create_table!(:albums_tags) do
+    @db.create_table(:albums_tags) do
       Integer :album_id1
       Integer :album_id2
       Integer :tag_id1
@@ -468,14 +624,25 @@ describe "Sequel::Model Composite Key Associations" do
       set_primary_key :id1, :id2
       unrestrict_primary_key
       one_to_many :albums, :key=>[:artist_id1, :artist_id2]
+      one_to_one :first_album, :clone=>:albums, :order=>:name
+      one_to_one :last_album, :clone=>:albums, :order=>:name.desc
+      one_to_many :first_two_albums, :clone=>:albums, :order=>:name, :limit=>2
+      one_to_many :second_two_albums, :clone=>:albums, :order=>:name, :limit=>[2, 1]
+      one_to_many :last_two_albums, :clone=>:albums, :order=>:name.desc, :limit=>2
       plugin :many_through_many
-      Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]]
+      many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]]
+      many_through_many :first_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>2
+      many_through_many :second_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>[2, 1]
+      many_through_many :last_two_tags, :clone=>:tags, :order=>:tags__name.desc, :limit=>2
     end
     class ::Album < Sequel::Model(@db)
       set_primary_key :id1, :id2
       unrestrict_primary_key
       many_to_one :artist, :key=>[:artist_id1, :artist_id2]
       many_to_many :tags, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+      many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
+      many_to_many :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
+      many_to_many :last_two_tags, :clone=>:tags, :order=>:name.desc, :limit=>2
     end
     class ::Tag < Sequel::Model(@db)
       set_primary_key :id1, :id2
@@ -485,6 +652,10 @@ describe "Sequel::Model Composite Key Associations" do
     @album = Album.create(:name=>'Al', :id1=>1, :id2=>2)
     @artist = Artist.create(:name=>'Ar', :id1=>3, :id2=>4)
     @tag = Tag.create(:name=>'T', :id1=>5, :id2=>6)
+    @same_album = lambda{Album.create(:name=>'Al', :id1=>7, :id2=>8, :artist_id1=>3, :artist_id2=>4)}
+    @diff_album = lambda{Album.create(:name=>'lA', :id1=>9, :id2=>10, :artist_id1=>3, :artist_id2=>4)}
+    @middle_album = lambda{Album.create(:name=>'Bl', :id1=>13, :id2=>14, :artist_id1=>3, :artist_id2=>4)}
+    @other_tags = lambda{t = [Tag.create(:name=>'U', :id1=>17, :id2=>18), Tag.create(:name=>'V', :id1=>19, :id2=>20)]; @db[:albums_tags].insert([:album_id1, :album_id2, :tag_id1, :tag_id2], Tag.select(1, 2, :id1, :id2)); t}
     @pr = lambda{[Album.create(:name=>'Al2', :id1=>11, :id2=>12),Artist.create(:name=>'Ar2', :id1=>13, :id2=>14),Tag.create(:name=>'T2', :id1=>15, :id2=>16)]}
     @ins = lambda{@db[:albums_tags].insert(:tag_id1=>@tag.id1, :tag_id2=>@tag.id2)}
   end
@@ -495,6 +666,13 @@ describe "Sequel::Model Composite Key Associations" do
 
   it_should_behave_like "regular and composite key associations"
 
+  describe "with :eager_limit_strategy=>:correlated_subquery" do
+    before do
+      @els = {:eager_limit_strategy=>:correlated_subquery}
+    end
+    it_should_behave_like "eager limit strategies"
+  end if INTEGRATION_DB.dataset.supports_multiple_column_in? && ![:mysql, :db2].include?(INTEGRATION_DB.database_type)
+
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
     Album.delete