sequel 4.9.0 → 4.10.0

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -22,8 +22,10 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @Album.one_through_one :tag, :clone=>:tags
     @Artist.plugin :many_through_many
     @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @Artist.one_through_many :tag, :clone=>:tags
     @db.sqls
   end
 
@@ -38,10 +40,16 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2).tags
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2).tag
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) LIMIT 1 -- prepared"]
 
     @Artist.load(:id=>1).tags
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.artist_id = 1)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) -- prepared"]
+
+    @Artist.load(:id=>1).tag
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) WHERE (albums.artist_id = 1) LIMIT 1 -- prepared"]
   end
 
   specify "should run correct SQL for composite key associations" do
@@ -49,7 +57,10 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @Artist.one_to_one :album, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
     @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>[:album_id, :album_id2], :right_key=>[:tag_id, :tag_id2], :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+    @Album.one_through_one :tag, :clone=>:tags
+
     @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+    @Artist.one_through_many :tag, :clone=>:tags
 
     @Artist.load(:id=>1, :id2=>2).albums
     @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
@@ -61,10 +72,16 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @db.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1 -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2, :id2=>3).tag
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) WHERE ((albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) LIMIT 1 -- prepared"]
 
     @Artist.load(:id=>1, :id2=>2).tags
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+
+    @Artist.load(:id=>1, :id2=>2).tag
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2)) WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) LIMIT 1 -- prepared"]
   end
 
   specify "should not run query if no objects can be associated" do
@@ -76,6 +93,8 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
   specify "should run a regular query if there is a callback" do
     @Artist.load(:id=>1).albums(proc{|ds| ds})
     @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @Artist.load(:id=>1).album(proc{|ds| ds})
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) LIMIT 1"]
   end
 
   specify "should run a regular query if :prepared_statement=>false option is used for the association" do

data/spec/extensions/rcte_tree_spec.rb

@@ -2,14 +2,18 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "rcte_tree" do
   before do
-    @c = Class.new(Sequel::Model(DB[:nodes]))
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def supports_cte?(*) true end
+    end
+    @c = Class.new(Sequel::Model(@db[:nodes]))
     @c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
     end
     @ds = @c.dataset
     @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    DB.reset
+    @db.sqls
   end
 
   it "should define the correct associations" do
@@ -44,11 +48,11 @@ describe Sequel::Model, "rcte_tree" do
     @c.plugin :rcte_tree
     @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
     @c.eager(:ancestors).all
-    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (id IN (3)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes"]
+    @db.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (id IN (3)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes"]
 
     @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
     @c.eager(:descendants).all
-    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT parent_id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (parent_id IN (1)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes"]
+    @db.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT parent_id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (parent_id IN (1)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes"]
   end
   
   it "should use the correct SQL for lazy associations when giving options" do
@@ -114,7 +118,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     os = @ds.eager(:ancestors).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D'), @c.load(:id=>9, :parent_id=>nil, :name=>'E')]
@@ -126,7 +130,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :name=>'?', :parent_id=>nil), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil]
     os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil, nil]
     os.map{|o| o.parent.parent.parent.parent if o.parent and o.parent.parent and o.parent.parent.parent}.should == [nil, nil, nil, nil]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load ancestors when giving options" do
@@ -136,7 +140,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>1, :name=>'00', :pi=>8, :kal=>1}, {:i=>1, :name=>'00', :pi=>8, :kal=>2},
        {:i=>8, :name=>'?', :pi=>nil, :kal=>2}, {:i=>8, :name=>'?', :pi=>nil, :kal=>1}]]
     os = @ds.eager(:as).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT i AS kal, nodes\.\* FROM nodes WHERE \(i IN \([12], [12]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.pi = nodes\.i\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D'), @c.load(:i=>9, :pi=>nil, :name=>'E')]
@@ -157,7 +161,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     @ds.eager(:ancestors).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(id IN \([12], [12]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
@@ -169,7 +173,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     os = @ds.eager(:descendants).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
@@ -179,7 +183,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.children}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load descendants when giving options" do
@@ -189,7 +193,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>3, :name=>'00', :pi=>6, :kal=>6}, {:i=>3, :name=>'00', :pi=>6, :kal=>2},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7}, {:i=>5, :name=>'?', :pi=>4, :kal=>7}]]
     os = @ds.eager(:ds).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\* FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
@@ -199,7 +203,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.cs}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.cs.map{|o2| o2.cs}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.cs.map{|o2| o2.cs.map{|o3| o3.cs}}}.should == [[[[]], []], [[]], [[[]]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level" do
@@ -209,7 +213,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6, :x_level_x=>0}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2, :x_level_x=>1},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7, :x_level_x=>0}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7, :x_level_x=>1}]]
     os = @ds.eager(:descendants=>2).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, CAST\(0 AS integer\) AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
@@ -219,7 +223,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level when giving options" do
@@ -229,7 +233,7 @@ describe Sequel::Model, "rcte_tree" do
        {:i=>3, :name=>'00', :pi=>6, :kal=>6, :lal=>0}, {:i=>3, :name=>'00', :pi=>6, :kal=>2, :lal=>1},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7, :lal=>0}, {:i=>5, :name=>'?', :pi=>4, :kal=>7, :lal=>1}]]
     os = @ds.eager(:ds=>2).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\*, CAST\(0 AS integer\) AS lal FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\*, \(cte\.lal \+ 1\) AS lal FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\) WHERE \(cte\.lal < 1\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
@@ -239,7 +243,7 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:cs]}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs]}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs].map{|o3| o3.associations[:cs]}}}.should == [[[[]], []], [[]], [[nil]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
 
   it "should eagerly load descendants respecting association option :conditions" do
@@ -249,7 +253,7 @@ describe Sequel::Model, "rcte_tree" do
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     @ds.eager(:descendants).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
@@ -257,7 +261,11 @@ end
 
 describe Sequel::Model, "rcte_tree with composite keys" do
   before do
-    @c = Class.new(Sequel::Model(DB[:nodes]))
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def supports_cte?(*) true end
+    end
+    @c = Class.new(Sequel::Model(@db[:nodes]))
     @c.class_eval do
       def self.name; 'Node'; end
       columns :id, :id2, :name, :parent_id, :parent_id2, :i, :pi
@@ -265,7 +273,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
     end
     @ds = @c.dataset
     @o = @c.load(:id=>2, :id2=>5, :parent_id=>1, :parent_id2=>6, :name=>'AA', :i=>3, :pi=>4)
-    DB.reset
+    @db.sqls
   end
 
   it "should use the correct SQL for lazy associations" do
@@ -288,11 +296,11 @@ describe Sequel::Model, "rcte_tree with composite keys" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
     @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
     @c.eager(:ancestors).all
-    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((id, id2) IN ((3, 4))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes"]
+    @db.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((id, id2) IN ((3, 4))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes"]
 
     @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
     @c.eager(:descendants).all
-    DB.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((parent_id, parent_id2) IN ((1, 2))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes"]
+    @db.sqls.should == ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((parent_id, parent_id2) IN ((1, 2))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes"]
   end
   
   it "should add all parent associations when lazily loading ancestors" do
@@ -322,7 +330,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
        {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>1, :x_root_x_1=>2}, {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>2, :x_root_x_1=>3},
        {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>1, :x_root_x_1=>2}]]
     os = @ds.eager(:ancestors).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes\.\* FROM nodes WHERE \(\(id, id2\) IN \(\([12], [23]\), \([12], [23]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\* FROM nodes INNER JOIN t ON \(\(t\.parent_id = nodes\.id\) AND \(t\.parent_id2 = nodes\.id2\)\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'), @c.load(:id=>9, :id2=>10, :parent_id=>nil, :parent_id2=>nil, :name=>'E')]
@@ -334,7 +342,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
     os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil), @c.load(:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9), @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil), nil]
     os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil), nil, nil]
     os.map{|o| o.parent.parent.parent.parent if o.parent and o.parent.parent and o.parent.parent.parent}.should == [nil, nil, nil, nil]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load descendants" do
@@ -344,7 +352,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
        {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3},
        {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8}]]
     os = @ds.eager(:descendants).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes\.\* FROM nodes WHERE \(\(parent_id, parent_id2\) IN \(\([267], [378]\), \([267], [378]\), \([267], [378]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\* FROM nodes INNER JOIN t ON \(\(t\.id = nodes\.parent_id\) AND \(t\.id2 = nodes\.parent_id2\)\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D')]
@@ -354,7 +362,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
     os.map{|o| o.children}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E')], [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8)]]
     os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], []], [[]], [[@c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]]
     os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level" do
@@ -364,7 +372,7 @@ describe Sequel::Model, "rcte_tree with composite keys" do
        {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7, :x_level_x=>0}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>1},
        {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>0}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>1}]]
     os = @ds.eager(:descendants=>2).all
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM nodes"
     sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes\.\*, CAST\(0 AS integer\) AS x_level_x FROM nodes WHERE \(\(parent_id, parent_id2\) IN \(\([267], [378]\), \([267], [378]\), \([267], [378]\)\)\) UNION ALL SELECT t\.x_root_x_0, t\.x_root_x_1, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(\(t\.id = nodes\.parent_id\) AND \(t\.id2 = nodes\.parent_id2\)\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :id2=>3, :parent_id=>1, :parent_id=>2, :name=>'AA'), @c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D')]
@@ -374,6 +382,6 @@ describe Sequel::Model, "rcte_tree with composite keys" do
     os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'), @c.load(:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E')], [@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], [@c.load(:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8)]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7)], []], [[]], [[@c.load(:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5)]]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
-    DB.sqls.should == []
+    @db.sqls.should == []
   end
 end

data/spec/extensions/sequel_3_dataset_methods_spec.rb

@@ -71,7 +71,6 @@ describe "Dataset#opts=" do
   specify "should change the dataset's opts" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
-    db2 = Sequel.mock
     ds.sql.should == 'SELECT * FROM items'
     ds.opts = {}
     ds.sql.should == 'SELECT *'

data/spec/extensions/sharding_spec.rb

@@ -113,7 +113,7 @@ describe "sharding plugin" do
     album.artist.update(:name=>'AS')
     @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
     album.tags.map{|a| a.update(:name=>'SR')}
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
     @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
     @db.sqls.should == ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
   end 
@@ -145,7 +145,7 @@ describe "sharding plugin" do
     sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
     
     album.remove_tag(3)
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) WHERE (tags.id = 3) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id = 1) AND (tags.id = 3)) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
   end 
 
   specify "should have objects retrieved from a specific shard remove all associated objects from that shard" do

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -75,4 +75,8 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
     DB.sqls.length.should == 1
   end
+
+  it "#marshallable should make marshalling not fail" do
+    proc{Marshal.dump(@c.all.map{|x| x.marshallable!})}.should_not raise_error
+  end
 end

data/spec/extensions/to_dot_spec.rb

@@ -25,6 +25,7 @@ END
   end
 
   it "should handle WITH" do
+    def @ds.supports_cte?(*) true end
     a = dot(@ds.with(:a, @ds))
     a[0..3].should == ["1 -> 2 [label=\"with\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Hash\"];"]
     [["3 -> 4 [label=\"dataset\"];", "4 [label=\"Dataset\"];", "3 -> 5 [label=\"name\"];", "5 [label=\":a\"];"],

data/spec/extensions/touch_spec.rb

@@ -139,7 +139,7 @@ describe "Touch plugin" do
     @Artist.plugin :touch, :associations=>:albums
     @a.touch
     DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "SELECT albums.* FROM albums INNER JOIN aa ON (aa.album_id = albums.id) WHERE (aa.artist_id = 1)",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 
@@ -149,7 +149,7 @@ describe "Touch plugin" do
     @Artist.plugin :touch, :associations=>:albums
     @a.touch
     DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "SELECT albums.* FROM albums INNER JOIN aa ON (aa.album_id = albums.id) WHERE (aa.artist_id = 1)",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 

data/spec/integration/associations_test.rb

@@ -4,7 +4,7 @@ shared_examples_for "one_to_one 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
-    Artist.one_to_one  :second_album, {:clone=>:second_album}.merge(@els) if @els
+    Artist.one_to_one  :second_album, {:clone=>:second_album}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
     @album.update(:artist => @artist)
     diff_album = @diff_album.call
     ar = @pr.call[1]
@@ -29,7 +29,9 @@ shared_examples_for "one_to_one eager limit strategies" do
     [@album, same_album].should include(a.first.first_album)
     a.last.first_album.should == nil
   end
+end
 
+shared_examples_for "one_to_one eager_graph limit strategies" do
   specify "eager graphing one_to_one associations should work correctly" do
     @album.update(:artist => @artist)
     diff_album = @diff_album.call
@@ -50,12 +52,14 @@ shared_examples_for "one_to_one eager limit strategies" do
     a.last.last_album.should == nil
     a.first.last_album.values.should == diff_album.values
 
-    a = ds.eager_graph_with_options(:second_album, limit_strategy).all
-    a = ds.eager_graph(:second_album).all
-    a.should == [@artist, ar]
-    a.first.second_album.should == diff_album
-    a.last.second_album.should == nil
-    a.first.second_album.values.should == diff_album.values
+    if @els[:eager_limit_strategy] != :distinct_on && (@els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?) 
+      a = ds.eager_graph_with_options(:second_album, limit_strategy).all
+      a = ds.eager_graph(:second_album).all
+      a.should == [@artist, ar]
+      a.first.second_album.should == diff_album
+      a.last.second_album.should == nil
+      a.first.second_album.values.should == diff_album.values
+    end
 
     same_album = @same_album.call
     a = ds.eager_graph_with_options(:first_album, limit_strategy).all
@@ -93,7 +97,9 @@ shared_examples_for "one_to_many eager limit strategies" do
     ars.first.not_first_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
+end
 
+shared_examples_for "one_to_many eager_graph limit strategies" do
   specify "should correctly handle limits and offsets when eager graphing one_to_many associations" do
     @album.update(:artist => @artist)
     middle_album = @middle_album.call
@@ -108,17 +114,19 @@ shared_examples_for "one_to_many eager limit strategies" do
     ars.last.first_two_albums.should == []
     ars.first.first_two_albums.map{|x| x.values}.should == [@album, middle_album].map{|x| x.values}
 
-    ars = ds.eager_graph_with_options(:second_two_albums, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.second_two_albums.should == [middle_album, diff_album]
-    ars.last.second_two_albums.should == []
-    ars.first.second_two_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+    if @els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?
+      ars = ds.eager_graph_with_options(:second_two_albums, limit_strategy).all
+      ars.should == [@artist, ar]
+      ars.first.second_two_albums.should == [middle_album, diff_album]
+      ars.last.second_two_albums.should == []
+      ars.first.second_two_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
 
-    ars = ds.eager_graph_with_options(:not_first_albums, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.not_first_albums.should == [middle_album, diff_album]
-    ars.last.not_first_albums.should == []
-    ars.first.not_first_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+      ars = ds.eager_graph_with_options(:not_first_albums, limit_strategy).all
+      ars.should == [@artist, ar]
+      ars.first.not_first_albums.should == [middle_album, diff_album]
+      ars.last.not_first_albums.should == []
+      ars.first.not_first_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+    end
 
     ars = ds.eager_graph_with_options(:last_two_albums, limit_strategy).all
     ars.should == [@artist, ar]
@@ -131,7 +139,7 @@ end
 shared_examples_for "one_through_one eager limit strategies" do
   specify "should correctly handle offsets when eager loading one_through_one associations" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els) if @els
-    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els
+    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els) if @els
     tu, tv = @other_tags.call
     al = @pr.call.first
@@ -150,7 +158,9 @@ shared_examples_for "one_through_one eager limit strategies" do
     als.first.second_tag.values.should == tu.values
     als.first.last_tag.values.should == tv.values
   end
+end
 
+shared_examples_for "one_through_one eager_graph limit strategies" do
   specify "should correctly handle offsets when eager graphing one_through_one associations" do
     tu, tv = @other_tags.call
     al = @pr.call.first
@@ -163,7 +173,7 @@ shared_examples_for "one_through_one eager limit strategies" do
     als.last.first_tag.should == nil
     als.first.first_tag.values.should == @tag.values
 
-    als = ds.eager_graph_with_options(:second_tag, limit_strategy).all
+    als = ds.eager_graph_with_options(:second_tag, @els[:eager_limit_strategy] != :distinct_on ? limit_strategy : {}).all
     als.should == [@album, al]
     als.first.second_tag.should == tu
     als.last.second_tag.should == nil
@@ -203,7 +213,9 @@ shared_examples_for "many_to_many eager limit strategies" do
     als.first.not_first_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
+end
 
+shared_examples_for "many_to_many eager_graph limit strategies" do
   specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
     tu, tv = @other_tags.call
     al = @pr.call.first
@@ -266,7 +278,9 @@ shared_examples_for "many_through_many eager limit strategies" do
     ars.first.not_first_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 "many_through_many eager_graph limit strategies" do
   specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
@@ -305,7 +319,7 @@ end
 shared_examples_for "one_through_many eager limit strategies" do
   specify "should correctly handle offsets when eager loading one_through_many associations" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els) if @els
-    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els
+    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els) if @els
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
@@ -327,7 +341,9 @@ shared_examples_for "one_through_many eager limit strategies" do
     ars.first.second_tag.values.should == tu.values
     ars.first.last_tag.values.should == tv.values
   end
+end
 
+shared_examples_for "one_through_many eager_graph limit strategies" do
   specify "should correctly handle offsets when eager graphing one_through_many associations" do
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
@@ -343,7 +359,7 @@ shared_examples_for "one_through_many eager limit strategies" do
     ars.last.first_tag.should == tu
     ars.first.first_tag.values.should == @tag.values
 
-    ars = ds.eager_graph_with_options(:second_tag, limit_strategy).all
+    ars = ds.eager_graph_with_options(:second_tag, @els[:eager_limit_strategy] != :distinct_on ? limit_strategy : {}).all
     ars.should == [@artist, ar]
     ars.first.second_tag.should == tu
     ars.last.second_tag.should == nil
@@ -366,6 +382,15 @@ shared_examples_for "eager limit strategies" do
   it_should_behave_like "one_through_many eager limit strategies"
 end
 
+shared_examples_for "eager_graph limit strategies" do
+  it_should_behave_like "one_to_one eager_graph limit strategies"
+  it_should_behave_like "one_to_many eager_graph limit strategies"
+  it_should_behave_like "many_to_many eager_graph limit strategies"
+  it_should_behave_like "one_through_one eager_graph limit strategies"
+  it_should_behave_like "many_through_many eager_graph limit strategies"
+  it_should_behave_like "one_through_many eager_graph limit strategies"
+end
+
 shared_examples_for "filtering/excluding by associations" do
   specify "should handle association inner joins" do
     @Artist.association_join(:albums).all.should == []
@@ -1008,7 +1033,7 @@ shared_examples_for "filtering/excluding by associations" do
   end
 end
 
-shared_examples_for "filter by associations singular association limit strategies" do
+shared_examples_for "filter by associations one_to_one limit strategies" do
   specify "filter by associations with limited one_to_one associations should work correctly" do
     Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els)
     Artist.one_to_one :last_album, {:clone=>:last_album}.merge(@els)
@@ -1023,10 +1048,12 @@ shared_examples_for "filter by associations singular association limit strategie
     ds.exclude(:first_album=>@album).all.should == [ar]
     ds.exclude(:first_album=>diff_album).all.should == [@artist, ar]
 
-    ds.where(:second_album=>@album).all.should == []
-    ds.where(:second_album=>diff_album).all.should == [@artist]
-    ds.exclude(:second_album=>@album).all.should == [@artist, ar]
-    ds.exclude(:second_album=>diff_album).all.should == [ar]
+    if @els[:eager_limit_strategy] != :distinct_on && (@els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?) 
+      ds.where(:second_album=>@album).all.should == []
+      ds.where(:second_album=>diff_album).all.should == [@artist]
+      ds.exclude(:second_album=>@album).all.should == [@artist, ar]
+      ds.exclude(:second_album=>diff_album).all.should == [ar]
+    end
 
     ds.where(:last_album=>@album).all.should == []
     ds.where(:last_album=>diff_album).all.should == [@artist]
@@ -1038,11 +1065,15 @@ shared_examples_for "filter by associations singular association limit strategie
     ds.where(:first_album=>[@album, diff_album]).all.should == [ar]
     ds.exclude(:first_album=>[@album, diff_album]).all.should == [@artist]
   end
+end
+
+shared_examples_for "filter by associations singular association limit strategies" do
+  it_should_behave_like "filter by associations one_to_one limit strategies"
 
   specify "dataset associations with limited one_to_one associations should work correctly" do
     Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els)
     Artist.one_to_one :last_album, {:clone=>:last_album}.merge(@els)
-    Artist.one_to_one :second_album, {:clone=>:second_album}.merge(@els)
+    Artist.one_to_one :second_album, {:clone=>:second_album}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     @album.update(:artist => @artist)
     diff_album = @diff_album.call
     ar = @pr.call[1]
@@ -1063,7 +1094,7 @@ shared_examples_for "filter by associations singular association limit strategie
 
   specify "filter by associations with limited one_through_one associations should work correctly" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els)
-    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els)
+    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els)
     tu, tv = @other_tags.call
     al = @pr.call.first
@@ -1104,7 +1135,7 @@ shared_examples_for "filter by associations singular association limit strategie
 
   specify "dataset associations with limited one_through_one associations should work correctly" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els)
-    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els)
+    Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els)
     tu, tv = @other_tags.call
     al = @pr.call.first
@@ -1135,7 +1166,7 @@ shared_examples_for "filter by associations singular association limit strategie
 
   specify "filter by associations with limited one_through_many associations should work correctly" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els)
-    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els)
+    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els)
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
@@ -1178,7 +1209,7 @@ shared_examples_for "filter by associations singular association limit strategie
 
   specify "dataset associations with limited one_through_many associations should work correctly" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els)
-    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els)
+    Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els)
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
@@ -1210,9 +1241,7 @@ shared_examples_for "filter by associations singular association limit strategie
   end
 end
 
-shared_examples_for "filter by associations limit strategies" do
-  it_should_behave_like "filter by associations singular association limit strategies"
-
+shared_examples_for "filter by associations one_to_many limit strategies" do
   specify "filter by associations with limited one_to_many associations should work correctly" do
     Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els)
     Artist.one_to_many :second_two_albums, {:clone=>:second_two_albums}.merge(@els)
@@ -1231,7 +1260,13 @@ shared_examples_for "filter by associations limit strategies" do
     ds.exclude(:first_two_albums=>middle_album).all.should == [ar]
     ds.exclude(:first_two_albums=>diff_album).all.should == [@artist, ar]
     
-    [:second_two_albums, :not_first_albums, :last_two_albums].each do |a|
+    assocs = if @els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?
+      [:second_two_albums, :not_first_albums, :last_two_albums]
+    else
+      [:last_two_albums]
+    end
+
+    assocs.each do |a|
       ds.where(a=>@album).all.should == []
       ds.where(a=>middle_album).all.should == [@artist]
       ds.where(a=>diff_album).all.should == [@artist]
@@ -1245,6 +1280,11 @@ shared_examples_for "filter by associations limit strategies" do
     ds.where(:first_two_albums=>[@album, diff_album]).all.should == [ar]
     ds.exclude(:first_two_albums=>[@album, diff_album]).all.should == [@artist]
   end
+end
+
+shared_examples_for "filter by associations limit strategies" do
+  it_should_behave_like "filter by associations singular association limit strategies"
+  it_should_behave_like "filter by associations one_to_many limit strategies"
 
   specify "dataset associations with limited one_to_many associations should work correctly" do
     Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els)
@@ -1660,20 +1700,31 @@ shared_examples_for "regular and composite key associations" do
     it_should_behave_like "filtering/excluding by associations"
   end
 
+  describe "with default/union :eager_limit_strategy" do
+    before do
+      @els = {}
+    end
+    it_should_behave_like "eager limit strategies"
+  end
+
   describe "with :eager_limit_strategy=>:ruby" do
     before do
       @els = {:eager_limit_strategy=>:ruby}
     end
     it_should_behave_like "eager limit strategies"
+    it_should_behave_like "eager_graph limit strategies"
   end
 
-  describe "with :eager_limit_strategy=>true" do
+  describe "with :eager_limit_strategy=>:distinct_on" do
     before do
-      @els = {:eager_limit_strategy=>true}
+      @els = {:eager_limit_strategy=>:distinct_on}
     end
     it_should_behave_like "one_to_one eager limit strategies"
     it_should_behave_like "one_through_one eager limit strategies"
     it_should_behave_like "one_through_many eager limit strategies"
+    it_should_behave_like "one_to_one eager_graph limit strategies"
+    it_should_behave_like "one_through_one eager_graph limit strategies"
+    it_should_behave_like "one_through_many eager_graph limit strategies"
     it_should_behave_like "filter by associations singular association limit strategies"
   end if DB.dataset.supports_ordered_distinct_on?
 
@@ -1682,6 +1733,7 @@ shared_examples_for "regular and composite key associations" do
       @els = {:eager_limit_strategy=>:window_function}
     end
     it_should_behave_like "eager limit strategies"
+    it_should_behave_like "eager_graph limit strategies"
     it_should_behave_like "filter by associations limit strategies"
   end if DB.dataset.supports_window_functions?
 
@@ -1833,6 +1885,34 @@ describe "Sequel::Model Simple Associations" do
   
   it_should_behave_like "regular and composite key associations"
 
+  describe "with :correlated_subquery limit strategy" do
+    before do
+      @els = {:eager_limit_strategy=>:correlated_subquery}
+    end
+
+    it_should_behave_like "one_to_one eager_graph limit strategies"
+    it_should_behave_like "one_to_many eager_graph limit strategies"
+    it_should_behave_like "filter by associations one_to_one limit strategies"
+    it_should_behave_like "filter by associations one_to_many limit strategies"
+  end if DB.dataset.supports_limits_in_correlated_subqueries?
+
+  specify "should handle eager loading limited associations for many objects" do
+    @db[:artists].import([:name], (1..99).map{|i| [i.to_s]})
+    artists = Artist.eager(:albums).all
+    artists.length.should == 100
+    artists.each{|a| a.albums.should == []}
+    artists = Artist.eager(:first_two_albums).all
+    artists.length.should == 100
+    artists.each{|a| a.first_two_albums.should == []}
+    @db[:albums].insert([:artist_id], @db[:artists].select(:id))
+    artists = Artist.eager(:albums).all
+    artists.length.should == 100
+    artists.each{|a| a.albums.length.should == 1}
+    artists = Artist.eager(:first_two_albums).all
+    artists.length.should == 100
+    artists.each{|a| a.first_two_albums.length.should == 1}
+  end
+
   specify "should handle many_to_one associations with same name as :key" do
     Album.def_column_alias(:artist_id_id, :artist_id)
     Album.many_to_one :artist_id, :key_column =>:artist_id, :class=>Artist
@@ -2058,6 +2138,17 @@ describe "Sequel::Model Composite Key Associations" do
 
   it_should_behave_like "regular and composite key associations"
 
+  describe "with :correlated_subquery limit strategy" do
+    before do
+      @els = {:eager_limit_strategy=>:correlated_subquery}
+    end
+
+    it_should_behave_like "one_to_one eager_graph limit strategies"
+    it_should_behave_like "one_to_many eager_graph limit strategies"
+    it_should_behave_like "filter by associations one_to_one limit strategies"
+    it_should_behave_like "filter by associations one_to_many limit strategies"
+  end if DB.dataset.supports_limits_in_correlated_subqueries? && DB.dataset.supports_multiple_column_in?
+
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
     Album.dataset.delete
@@ -2168,6 +2259,7 @@ describe "Sequel::Model pg_array_to_many" do
   
   it_should_behave_like "basic regular and composite key associations"
   it_should_behave_like "many_to_many eager limit strategies"
+  it_should_behave_like "many_to_many eager_graph limit strategies"
 
   it "should handle adding and removing entries in array" do
     a = Album.create
@@ -2248,6 +2340,7 @@ describe "Sequel::Model many_to_pg_array" do
   
   it_should_behave_like "basic regular and composite key associations"
   it_should_behave_like "many_to_many eager limit strategies"
+  it_should_behave_like "many_to_many eager_graph limit strategies"
 
   it "should handle adding and removing entries in array" do
     a = Album.create