sequel 3.21.0 → 3.29.0

data/spec/extensions/columns_introspection_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "Sequel::Dataset.introspect_all_columns" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    class Sequel::Dataset
+      # Handle case where introspect_all_columns has already been called
+      alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
+    end
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
+  end
+  after do
+    class Sequel::Dataset
+      alias columns columns_without_introspection
+    end
+  end
+
+  specify "should turn on column introspection by default" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+end
+
+describe "columns_introspection extension" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
+    @db.reset
+  end
+
+  specify "should not issue a database query if the columns are already loaded" do
+    @ds.instance_variable_set(:@columns, [:x])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+  
+  specify "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::Identifiers " do
+    @ds.select(:x.identifier).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(:x.qualify(:t)).columns.should == [:x]
+    @ds.select(:x.identifier.qualify(:t)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(:x.as(:a)).columns.should == [:a]
+    @ds.select(:x.as(:a.identifier)).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query if the wildcard is selected" do
+    @ds.columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query if an unsupported type is used" do
+    @ds.select(1).columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should not have column introspection on by default" do
+    @db[:a].select(:x).columns
+    @db.sqls.length.should == 1
+  end
+end

data/spec/extensions/dataset_associations_spec.rb

@@ -0,0 +1,199 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DatasetAssociations" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album
+    @Artist.one_to_one :first_album, :class=>@Album
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag
+    @Tag.many_to_many :albums, :class=>@Album
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    ds = @Album.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    ds = @Artist.albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    ds = @Artist.first_albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    ds = @Album.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should work for many_through_many associations" do
+    ds = @Artist.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should have an associated method that takes an association symbol" do
+    ds = @Album.associated(:artist)
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should raise an Error if an invalid association is given to associated" do
+    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an Error if an unrecognized association type is used" do
+    @Album.association_reflection(:artist)[:type] = :foo
+    proc{@Album.artists}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly when chaining" do
+    ds = @Artist.albums.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should deal correctly with filters before the association method" do
+    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+  end
+
+  it "should deal correctly with filters after the association method" do
+    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with block on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :conditions option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :distinct option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
+    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should deal correctly with :eager option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
+    @Artist.albums.opts[:eager].should == {:tags=>nil}
+  end
+
+  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :extend option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
+    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with :order option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+  end
+
+  it "should deal correctly with :select option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
+    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+end
+
+describe "Sequel::Plugins::DatasetAssociations with composite keys" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.set_primary_key([:id1, :id2])
+    @Album.set_primary_key([:id1, :id2])
+    @Tag.set_primary_key([:id1, :id2])
+
+    @Artist.columns :id1, :id2, :name
+    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
+    @Tag.columns :id1, :id2, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work for many_through_many associations" do
+    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work correctly when chaining" do
+    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DefaultsSetter" do
+  before do
+    @db = db = Sequel::Database.new
+    @c = c = Class.new(Sequel::Model(db[:foo]))
+    @c.instance_variable_set(:@db_schema, {:a=>{}})
+    @c.plugin :defaults_setter
+    @c.columns :a
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+  end
+
+  it "should set default value upon initialization" do
+    @pr.call(2).new.values.should == {:a=>2}
+  end
+
+  it "should not mark the column as modified" do
+    @pr.call(2).new.changed_columns.should == []
+  end
+
+  it "should not set a default of nil" do
+    @pr.call(nil).new.values.should == {}
+  end
+
+  it "should not override a given value" do
+    @pr.call(2)
+    @c.new('a'=>3).values.should == {:a=>3}
+    @c.new('a'=>nil).values.should == {:a=>nil}
+  end
+
+  it "should work correctly when subclassing" do
+    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+  end
+
+  it "should contain the default values in default_values" do
+    @pr.call(2).default_values.should == {:a=>2}
+    @pr.call(nil).default_values.should == {}
+  end
+
+  it "should allow modifications of default values" do
+    @pr.call(2)
+    @c.default_values[:a] = 3
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should allow proc default values" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{3}
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should have procs that set default values set them to nil" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{nil}
+    @c.new.values.should == {:a => nil}
+  end
+
+  it "should work correctly on a model without a dataset" do
+    @pr.call(2)
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.default_values.should == {:a=>2}
+  end
+end

data/spec/extensions/identity_map_spec.rb

@@ -13,6 +13,11 @@ describe "Sequel::Plugins::IdentityMap" do
         execute(sql)
         yield h
       end
+      def self.waw_identity_map(&block) # with and without
+        with_identity_map(&block)
+        db.reset
+        yield
+      end
     end
     class ::IdentityMapAlbum < ::IdentityMapModel
       columns :artist_id
@@ -216,4 +221,161 @@ describe "Sequel::Plugins::IdentityMap" do
       MODEL_DB.sqls.length.should == 2
     end
   end
+
+  it "should not override custom :eager_loaders for many_to_many associations" do
+    @c1.columns :id
+    @c2.columns :id
+    c = @c2
+    @c1.many_to_many :artists, :class=>@c2, :left_key=>:album_id, :right_key=>:artist_id, :join_table=>:aa, :eager_loader=>(proc do |eo|
+       eo[:rows].each{|object| object.associations[:artists] = [c.load(:id=>object.id)]}
+    end)
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1})
+      yield({:id=>2})
+      yield({:id=>3})
+    end
+
+    @c.waw_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      a = @c1.eager(:artists).all
+      MODEL_DB.sqls.length.should == 1
+      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
+      a.map{|x| x.artists}.should == [[@c2.load(:id=>1)], [@c2.load(:id=>2)], [@c2.load(:id=>3)]]
+      MODEL_DB.sqls.length.should == 1
+    end
+  end
+
+  it "should work correctly when eagerly loading many_to_many associations" do
+    @c1.columns :id
+    @c2.columns :id
+    @c1.many_to_many :artists, :class=>@c2, :left_key=>:album_id, :right_key=>:artist_id, :join_table=>:aa
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1})
+      yield({:id=>2})
+      yield({:id=>3})
+    end
+    ds = @c2.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :x_foreign_key_x=>1})
+      yield({:id=>1, :x_foreign_key_x=>2})
+      yield({:id=>2, :x_foreign_key_x=>1})
+      yield({:id=>2, :x_foreign_key_x=>2})
+      yield({:id=>3, :x_foreign_key_x=>1})
+      yield({:id=>3, :x_foreign_key_x=>1})
+    end
+
+    @c.waw_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      a = @c1.eager(:artists).all
+      MODEL_DB.sqls.length.should == 2
+      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
+      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should work correctly when eagerly loading many_to_many associations with composite keys" do
+    @c1.columns :id, :id2
+    @c2.columns :id
+    @c1.set_primary_key :id, :id2
+    @c1.many_to_many :artists, :class=>@c2, :left_key=>[:album_id1, :album_id2], :right_key=>:artist_id, :join_table=>:aa
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :id2=>4})
+      yield({:id=>2, :id2=>5})
+      yield({:id=>3, :id2=>6})
+    end
+    ds = @c2.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5})
+      yield({:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5})
+      yield({:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+    end
+
+    @c.waw_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      a = @c1.eager(:artists).all
+      MODEL_DB.sqls.length.should == 2
+      a.should == [@c1.load(:id=>1, :id2=>4), @c1.load(:id=>2, :id2=>5), @c1.load(:id=>3, :id2=>6)]
+      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should work correctly when eagerly loading many_through_many associations" do
+    @c1.columns :id
+    @c2.columns :id
+    @c1.plugin :many_through_many
+    @c1.many_through_many :artists, [[:aa, :album_id, :artist_id]], :class=>@c2
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1})
+      yield({:id=>2})
+      yield({:id=>3})
+    end
+    ds = @c2.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :x_foreign_key_x=>1})
+      yield({:id=>1, :x_foreign_key_x=>2})
+      yield({:id=>2, :x_foreign_key_x=>1})
+      yield({:id=>2, :x_foreign_key_x=>2})
+      yield({:id=>3, :x_foreign_key_x=>1})
+      yield({:id=>3, :x_foreign_key_x=>1})
+    end
+
+    @c.waw_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      a = @c1.eager(:artists).all
+      MODEL_DB.sqls.length.should == 2
+      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
+      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should work correctly when eagerly loading many_to_many associations with composite keys" do
+    @c1.columns :id, :id2
+    @c2.columns :id
+    @c1.set_primary_key :id, :id2
+    @c1.plugin :many_through_many
+    @c1.many_through_many :artists, [[:aa, [:album_id1, :album_id2], :artist_id]], :class=>@c2
+    ds = @c1.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :id2=>4})
+      yield({:id=>2, :id2=>5})
+      yield({:id=>3, :id2=>6})
+    end
+    ds = @c2.dataset
+    def ds.fetch_rows(sql)
+      execute(sql)
+      yield({:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5})
+      yield({:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5})
+      yield({:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+      yield({:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4})
+    end
+
+    @c.waw_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      a = @c1.eager(:artists).all
+      MODEL_DB.sqls.length.should == 2
+      a.should == [@c1.load(:id=>1, :id2=>4), @c1.load(:id=>2, :id2=>5), @c1.load(:id=>3, :id2=>6)]
+      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
 end

data/spec/extensions/instance_hooks_spec.rb

@@ -177,3 +177,74 @@ describe "InstanceHooks plugin" do
     @r.should == [2, 1, 4, 3]
   end
 end
+
+describe "InstanceHooks plugin with transactions" do
+  before do
+    @logger = Object.new
+    def @logger.method_missing(meth, sql)
+      (@sqls ||= []) << sql
+    end
+    def @logger.sqls
+      @sqls
+    end
+    @db = Class.new(Sequel::Database) do
+      def connect(*)
+        Object.new
+      end
+      def log_connection_execute(conn, sql)
+        execute(sql)
+      end
+      def execute(sql, opts={})
+        @loggers.each{|l| l.info(sql)}
+      end
+    end.new(:loggers=>[@logger])
+    pr = proc{|x| r(x)}
+    @c = Class.new(Sequel::Model(@db[:items])) do
+      attr_accessor :rb
+      def _delete
+      end
+      def after_save
+        db.execute('as')
+        raise Sequel::Rollback if rb
+      end
+      def after_destroy
+        db.execute('ad')
+        raise Sequel::Rollback if rb
+      end
+    end
+    @c.use_transactions = true
+    @c.plugin :instance_hooks
+    @o = @c.load({:id=>1})
+    @or = @c.load({:id=>1})
+    @or.rb = true
+    @r = []
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_commit_hook{@db.execute('ac1')}
+    @o.after_commit_hook{@db.execute('ac2')}
+    @o.save.should_not be_nil
+    @logger.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac1', 'ac2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_rollback_hook{@db.execute('ar1')}
+    @or.after_rollback_hook{@db.execute('ar2')}
+    @or.save.should be_nil
+    @logger.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_destroy_commit_hook{@db.execute('adc1')}
+    @o.after_destroy_commit_hook{@db.execute('adc2')}
+    @o.destroy.should_not be_nil
+    @logger.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc1', 'adc2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_destroy_rollback_hook{@db.execute('adr1')}
+    @or.after_destroy_rollback_hook{@db.execute('adr2')}
+    @or.destroy.should be_nil
+    @logger.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr1', 'adr2']
+  end
+end