sequel 3.21.0 → 3.29.0

data/spec/extensions/many_through_many_spec.rb

@@ -8,6 +8,7 @@ describe Sequel::Model, "many_through_many" do
       plugin :many_through_many
     end
     class ::Tag < Sequel::Model
+      columns :id, :h1, :h2
     end
     MODEL_DB.reset
     @c1 = Artist
@@ -111,6 +112,82 @@ describe Sequel::Model, "many_through_many" do
     n.tags.should == [@c2.load(:id=>1)]
   end
   
+  it "should allowing filtering by many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with a single through table" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists WHERE ((albums_artists.album_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with aliased tables" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :id, :id], [:albums_artists, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.id = albums_artists.album_id) INNER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_artists_0.id) WHERE ((albums_artists_1.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>@c2.load(:h1=>1234, :h2=>85)).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE ((albums_tags.g1 = 1234) AND (albums_tags.g2 = 85) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>@c2.load(:h1=>1234, :h2=>85)).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE ((albums_tags.g1 = 1234) AND (albums_tags.g2 = 85) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
+  it "should allowing filtering by multiple many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>[@c2.load(:id=>1234), @c2.load(:id=>2345)]).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (1234, 2345)) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by multiple many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>[@c2.load(:h1=>1234, :h2=>85), @c2.load(:h1=>2345, :h2=>95)]).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN ((1234, 85), (2345, 95))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by multiple many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>[@c2.load(:id=>1234), @c2.load(:id=>2345)]).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (1234, 2345)) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by multiple many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>[@c2.load(:h1=>1234, :h2=>85), @c2.load(:h1=>2345, :h2=>95)]).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN ((1234, 85), (2345, 95))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
+  it "should allowing filtering/excluding many_through_many associations with NULL values" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'f\''
+    @c1.exclude(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'t\''
+  end
+
+  it "should allowing filtering by many_through_many association datasets" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many association datasets with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN (SELECT h1, h2 FROM tags WHERE ((x = 1) AND (h1 IS NOT NULL) AND (h2 IS NOT NULL)))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by many_through_many association datasets" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by many_through_many association datasets with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN (SELECT h1, h2 FROM tags WHERE ((x = 1) AND (h1 IS NOT NULL) AND (h2 IS NOT NULL)))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
   it "should support a :conditions option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}
     n = @c1.load(:id => 1234)
@@ -481,24 +558,8 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
   end
   
   it "should cascade eagerly loading when the :eager_graph association option is used" do
-    Tag.dataset.extend(Module.new {
-      def columns
-        [:id]
-      end
-      def fetch_rows(sql)
-        @db << sql
-        yield({:id=>2, :tracks_id=>4, :x_foreign_key_x=>1})
-      end
-    })
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks
-    a = @c1.eager(:tags).all
-    a.should == [@c1.load(:id=>1)]
-    MODEL_DB.sqls.should == ['SELECT * FROM artists',
-      'SELECT tags.id, tracks.id AS tracks_id, albums_artists.artist_id AS x_foreign_key_x FROM (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) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
-    a = a.first
-    a.tags.should == [Tag.load(:id=>2)]
-    a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 2
+    proc{@c1.eager(:tags).all}.should raise_error(Sequel::Error)
   end
   
   it "should respect :eager_graph when lazily loading an association" do
@@ -560,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
@@ -576,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
@@ -705,8 +880,8 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.length.should == 1
   end
 
-  it "eager graphing should give you a graph of tables when called without .all" do 
-    @c1.eager_graph(:tags, :artists).first.should == {:artists=>@c1.load(:id=>1), :artists_0=>@c1.load(:id=>10), :tags=>Tag.load(:id=>2)}
+  it "eager graphing should give you a plain hash when called without .all" do 
+    @c1.eager_graph(:tags, :artists).first.should == {:albums_0_id=>3, :artists_0_id=>10, :id=>1, :tags_id=>2}
   end
 
   it "should be able to use eager and eager_graph together" do

data/spec/extensions/migration_spec.rb

@@ -202,7 +202,7 @@ describe "Sequel::IntegerMigrator" do
         @drops = []
         @tables_created = []
         @columns_created = []
-        @versions = {}
+        @versions = Hash.new{|h,k| h[k.to_sym]}
       end
   
       def version; versions.values.first || 0; end
@@ -212,7 +212,7 @@ describe "Sequel::IntegerMigrator" do
       def create_table(name, opts={}, &block)
         super
         @columns_created << / \(?(\w+) integer.*\)?\z/.match(sqls.last)[1].to_sym
-        @tables_created << name
+        @tables_created << name.to_sym
       end
       
       def dataset(opts={})
@@ -228,7 +228,7 @@ describe "Sequel::IntegerMigrator" do
       end
 
       def table_exists?(name)
-        @tables_created.include?(name)
+        @tables_created.include?(name.to_sym)
       end
     end
     @db = dbc.new
@@ -250,7 +250,7 @@ describe "Sequel::IntegerMigrator" do
 
   specify "should add a column name if it doesn't already exist in the schema_info table" do
     @db.create_table(:schema_info){Integer :v}
-    @db.should_receive(:alter_table).with(:schema_info)
+    @db.should_receive(:alter_table).with('schema_info')
     Sequel::Migrator.apply(@db, @dirname)
   end
 
@@ -320,45 +320,45 @@ describe "Sequel::TimestampMigrator" do
     @dsc = dsc = Class.new(MockDataset) do
       def columns
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           [:version]
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           [:filename]
-        when :sm
+        when :sm, 'sm'
           [:fn]
         end
       end
 
       def fetch_rows(sql)
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           yield({:version=>$sequel_migration_version})
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           $sequel_migration_files.sort.each{|f| yield(:filename=>f)}
-        when :sm
+        when :sm, 'sm'
           $sequel_migration_files.sort.each{|f| yield(:fn=>f)}
         end
       end
 
       def insert(h={})
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           $sequel_migration_version = h.values.first
-        when :schema_migrations, :sm
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
           $sequel_migration_files << h.values.first
         end
       end
 
       def update(h={})
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           $sequel_migration_version = h.values.first
         end
       end
 
       def delete
         case opts[:from].first
-        when :schema_migrations, :sm
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
           $sequel_migration_files.delete(opts[:where].args.last)
         end
       end
@@ -366,9 +366,9 @@ describe "Sequel::TimestampMigrator" do
     dbc = Class.new(MockDatabase) do
       tables = {}
       define_method(:dataset){|*a| dsc.new(self, *a)}
-      define_method(:create_table){|name, *args| tables[name] = true}
-      define_method(:drop_table){|*names| names.each{|n| tables.delete(n)}}
-      define_method(:table_exists?){|name| tables.has_key?(name)}
+      define_method(:create_table){|name, *args| tables[name.to_sym] = true}
+      define_method(:drop_table){|*names| names.each{|n| tables.delete(n.to_sym)}}
+      define_method(:table_exists?){|name| tables.has_key?(name.to_sym)}
     end
     @db = dbc.new
     @m = Sequel::Migrator

data/spec/extensions/named_timezones_spec.rb

@@ -66,8 +66,28 @@ describe "Sequel named_timezones extension" do
   end
   
   it "should work with the thread_local_timezones extension" do
-    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.should == @tz_out
+    tz2.should == @tz_in
   end
 end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -13,6 +13,7 @@ describe "NestedAttributes plugin" do
         mods << [:i, first_source, h, x]
         x
       end
+      define_method(:supports_insert_select?){true}
       define_method(:insert_select) do |h|
         x = ii.call
         mods << [:is, first_source, h, x]
@@ -28,6 +29,9 @@ describe "NestedAttributes plugin" do
       end
     end
     db = Sequel::Database.new({})
+    def db.connect(opts)
+      Object.new
+    end
     db.meta_def(:dataset) do |*a|
       x = super(*a)
       x.extend(ds_mod)

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AssociationPks" do
+  before do
+    @db = MODEL_DB.clone
+    mod = Module.new do
+      def fetch_rows(sql)
+        db << (is_a?(Sequel::Dataset::PreparedStatementMethods) ? :prepared : :regular)
+        db << sql
+      end
+    end
+    @db.meta_def(:dataset) do |*opts|
+      ds = super(*opts)
+      ds.extend mod
+      ds
+    end
+    def @db.transaction(opts)
+      execute('BEGIN')
+      yield
+      execute('COMMIT')
+    end
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.columns :id, :id2
+    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album.columns :id, :artist_id, :id2, :artist_id2
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.columns :id, :id2
+    @Artist.plugin :prepared_statements_associations
+    @Album.plugin :prepared_statements_associations
+    @Artist.one_to_many :albums, :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
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @db.reset
+  end
+
+  specify "should run correct SQL for associations" do
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2).artist
+    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2).tags
+    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1))"]
+    @db.reset
+
+    @Artist.load(:id=>1).tags
+    @db.sqls.should == [:prepared, "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))"]
+  end
+
+  specify "should run correct SQL for composite key associations" do
+    @Artist.one_to_many :albums, :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]
+    @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.load(:id=>1, :id2=>2).albums
+    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2))"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
+    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
+    @db.sqls.should == [:prepared, "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))"]
+    @db.reset
+
+    @Artist.load(:id=>1, :id2=>2).tags
+    @db.sqls.should == [:prepared, "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))"]
+  end
+
+  specify "should not run query if no objects can be associated" do
+    @Artist.new.albums.should == []
+    @Album.new.artist.should == nil
+    @db.sqls.should == []
+  end
+
+  specify "should run a regular query if there is a callback" do
+    @Artist.load(:id=>1).albums(proc{|ds| ds})
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :prepared_statement=>false option is used for the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :prepared_statement=>false
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if unrecognized association is used" do
+    a = @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    a[:type] = :foo
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if a block is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :conditions option is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+
+  specify "should run a regular query if :dataset option is used when defining the association" do
+    album = @Album
+    @Artist.one_to_many :albums, :class=>@Album, :dataset=>proc{album.filter(:artist_id=>id)} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.one_to_many :oalbums, :clone=>:albums
+    @Artist.load(:id=>1).oalbums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_safe plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people))
+    @c.columns :id, :name, :i
+    @ds = ds = @c.dataset
+    @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
+    def ds.fetch_rows(sql)
+      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
+      super{|h|}
+      yield(:id=>1, :name=>'foo', :i=>2)
+    end
+    def ds.update(*)
+      db << default_server_opts(opts)[:server]
+      super
+    end
+    def ds.insert(*)
+      db << default_server_opts(opts)[:server]
+      super
+      1
+    end
+    @c.plugin :prepared_statements_safe
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @c.db.execute 'foo'
+    @sqls = @c.db.sqls
+    @sqls.clear
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should set default values correctly" do
+    @c.prepared_statements_column_defaults.should == {:name=>nil, :i=>nil}
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    Class.new(@c).prepared_statements_column_defaults.should == {:name=>'foo'}
+  end
+
+  specify "should set default values when creating" do
+    @c.create
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \(NULL, NULL\)/
+    @sqls.clear
+    @c.create(:name=>'foo')
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((NULL|'foo'), (NULL|'foo')\)/
+    @sqls.clear
+    @c.create(:name=>'foo', :i=>2)
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end 
+
+  specify "should use database default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end
+
+  specify "should not set defaults for unparseable dataset default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @sqls[1].should == "INSERT INTO people (name) VALUES ('foo')"
+  end
+
+  specify "should save all fields when updating" do
+    @p.update(:i=>3)
+    @sqls[1].should =~ /UPDATE people SET (name = 'foo'|i = 3), (name = 'foo'|i = 3) WHERE \(id = 1\)/
+  end
+
+  specify "should work with abstract classes" do
+    c = Class.new(Sequel::Model)
+    c.plugin :prepared_statements_safe
+    c1 = Class.new(c)
+    c1.meta_def(:get_db_schema){@db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}}}
+    c1.set_dataset(:people)
+    c1.prepared_statements_column_defaults.should == {:name=>'foo'}
+    Class.new(c1).prepared_statements_column_defaults.should == {:name=>'foo'}
+  end
+end