sequel 3.21.0 → 3.24.0

data/spec/model/eager_loading_spec.rb

@@ -163,6 +163,12 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   end
   
+  it "should correctly handle a :select=>[] option to many_to_many" do
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :select=>[]
+    a = EagerAlbum.eager(:sgenres).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT *, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
+  end
+  
   it "should eagerly load multiple associations in a single call" do
     a = EagerAlbum.eager(:genres, :tracks, :band).all
     a.should be_a_kind_of(Array)
@@ -646,6 +652,148 @@ describe Sequel::Model, "#eager" do
     a.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.al_genres.should == [EagerGenre.load(:id=>4)]
   end
+
+  it "should eagerly load a many_to_one association with custom eager block" do
+    a = EagerAlbum.eager(:band => proc {|ds| ds.select(:id, :name)}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id, name FROM bands WHERE (bands.id IN (2))']
+    a = a.first
+    a.band.should be_a_kind_of(EagerBand)
+    a.band.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should eagerly load a one_to_one association with custom eager block" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
+    a = EagerAlbum.eager(:track => proc {|ds| ds.select(:id)}).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should eagerly load a one_to_many association with custom eager block" do
+    a = EagerAlbum.eager(:tracks => proc {|ds| ds.select(:id)}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(EagerTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should eagerly load a many_to_many association with custom eager block" do
+    a = EagerAlbum.eager(:genres => proc {|ds| ds.select(:name)}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT name, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
+    a = a.first
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(EagerGenre)
+    a.genres.first.values.should == {:id => 4}
+    MODEL_DB.sqls.length.should == 2
+  end
+
+  it "should allow cascading of eager loading within a custom eager block" do
+    a = EagerTrack.eager(:album => proc {|ds| ds.eager(:band => :members)}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+      'SELECT * FROM albums WHERE (albums.id IN (1))',
+      'SELECT * FROM bands WHERE (bands.id IN (2))',
+      "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
+    a = a.first
+    a.album.should be_a_kind_of(EagerAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(EagerBand)
+    a.album.band.values.should == {:id => 2}
+    a.album.band.members.should be_a_kind_of(Array)
+    a.album.band.members.size.should == 1
+    a.album.band.members.first.should be_a_kind_of(EagerBandMember)
+    a.album.band.members.first.values.should == {:id => 5}
+    MODEL_DB.sqls.length.should == 4
+  end
+
+  it "should allow cascading of eager loading with custom callback with hash value" do
+    a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>{:band => :members}}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+      'SELECT id, band_id FROM albums WHERE (albums.id IN (1))',
+      'SELECT * FROM bands WHERE (bands.id IN (2))',
+      "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
+    a = a.first
+    a.album.should be_a_kind_of(EagerAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(EagerBand)
+    a.album.band.values.should == {:id => 2}
+    a.album.band.members.should be_a_kind_of(Array)
+    a.album.band.members.size.should == 1
+    a.album.band.members.first.should be_a_kind_of(EagerBandMember)
+    a.album.band.members.first.values.should == {:id => 5}
+    MODEL_DB.sqls.length.should == 4
+  end
+
+  it "should allow cascading of eager loading with custom callback with symbol value" do
+    a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>:band}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+      'SELECT id, band_id FROM albums WHERE (albums.id IN (1))',
+      'SELECT * FROM bands WHERE (bands.id IN (2))']
+    a = a.first
+    a.album.should be_a_kind_of(EagerAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(EagerBand)
+    a.album.band.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 3
+  end
+
+  it "should allow cascading of eager loading with custom callback with array value" do
+    a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>[:band, :band_name]}).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    MODEL_DB.sqls.length.should == 4
+    MODEL_DB.sqls[0..1].should == ['SELECT * FROM tracks',
+      'SELECT id, band_id FROM albums WHERE (albums.id IN (1))']
+    MODEL_DB.sqls[2..-1].sort.should == ['SELECT * FROM bands WHERE (bands.id IN (2))',
+      'SELECT id, name FROM bands WHERE (bands.id IN (2))']
+    a = a.first
+    a.album.should be_a_kind_of(EagerAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(EagerBand)
+    a.album.band.values.should == {:id => 2}
+    a.album.band_name.should be_a_kind_of(EagerBand)
+    a.album.band_name.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 4
+  end
+
+  it "should call both association and custom eager blocks" do
+    EagerBand.eager(:good_albums => proc {|ds| ds.select(:name)}).all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT name FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
+  end
 end
 
 describe Sequel::Model, "#eager_graph" do
@@ -664,6 +812,11 @@ describe Sequel::Model, "#eager_graph" do
         c.instance_variable_set(:@columns, (@columns.dup if @columns))
         c
       end
+      def select_columns(*a)
+        ds = select(*a)
+        ds.instance_variable_set(:@columns, a)
+        ds
+      end
     end
 
     class ::GraphAlbum < Sequel::Model(:albums)
@@ -1284,13 +1437,17 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :eager_grapher=>proc{|ds, aa, ta| ds.graph(GraphBand, {:active=>true}, :table_alias=>aa, :join_type=>:inner)}
     GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums INNER JOIN bands AS active_band ON (active_band.active IS TRUE)"
 
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|ds, aa, ta| ds.graph(GraphTrack, nil, :join_type=>:natural, :table_alias=>aa)}
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphTrack, nil, :join_type=>:natural, :table_alias=>eo[:table_alias])}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums NATURAL JOIN tracks AS right_tracks'
 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :eager_grapher=>proc{|ds, aa, ta| ds.graph(:ag, {:album_id=>:id}, :table_alias=>:a123, :implicit_qualifier=>ta).graph(GraphGenre, [:album_id], :table_alias=>aa)}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag AS a123 ON (a123.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres USING (album_id)"
   end
 
+  it "should raise an error if you use an :eager_grapher proc with the wrong arity" do
+    proc{GraphAlbum.many_to_one :special_band, :eager_grapher=>proc{|a, b|}}.should raise_error(Sequel::Error)
+  end
+
   it "should respect the association's :graph_only_conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_only_conditions=>{:active=>true}
     GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON (active_band.active IS TRUE)"
@@ -1367,6 +1524,8 @@ describe Sequel::Model, "#eager_graph" do
     as = ds.all
     as.should == [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.inner_genres.should == [GraphGenre.load(:id=>5), GraphGenre.load(:id=>6)]
+    GraphAlbum.set_primary_key :id
+    GraphGenre.set_primary_key :id
   end
   
   it "should handle eager loading with schemas and aliases of different types" do
@@ -1392,4 +1551,113 @@ describe Sequel::Model, "#eager_graph" do
     ds = c1.join(:s__t, [:b_id]).eager_graph(:a_genres)
     ds.sql.should == 'SELECT a.id, a_genres.id AS a_genres_id FROM (SELECT * FROM s.a INNER JOIN s.t USING (b_id)) AS a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
   end
+
+  it "should eagerly load a many_to_one association with a custom callback" do
+    ds = GraphAlbum.eager_graph(:band => proc {|ds| ds.select_columns(:id)})
+    ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0 FROM albums LEFT OUTER JOIN (SELECT id FROM bands) AS band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :band_id_0=>2})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.band.should be_a_kind_of(GraphBand)
+    a.band.values.should == {:id => 2}
+  end
+
+  it "should eagerly load a one_to_one association with a custom callback" do
+    GraphAlbum.one_to_one :track, :class=>'GraphTrack', :key=>:album_id
+    ds = GraphAlbum.eager_graph(:track => proc {|ds| ds.select_columns(:album_id)})
+    ds.sql.should == 'SELECT albums.id, albums.band_id, track.album_id FROM albums LEFT OUTER JOIN (SELECT album_id FROM tracks) AS track ON (track.album_id = albums.id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :album_id=>1})
+    end
+    a = ds.all
+    a.should == [GraphAlbum.load(:id => 1, :band_id => 2)]
+    a.first.track.should == GraphTrack.load(:album_id=>1)
+  end
+
+  it "should eagerly load a one_to_many association with a custom callback" do
+    ds = GraphAlbum.eager_graph(:tracks => proc {|ds| ds.select_columns(:album_id)})
+    ds.sql.should == 'SELECT albums.id, albums.band_id, tracks.album_id FROM albums LEFT OUTER JOIN (SELECT album_id FROM tracks) AS tracks ON (tracks.album_id = albums.id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :album_id=>1})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(GraphTrack)
+    a.tracks.first.values.should == {:album_id=>1}
+  end
+
+  it "should eagerly load a many_to_many association with a custom callback" do
+    ds = GraphAlbum.eager_graph(:genres => proc {|ds| ds.select_columns(:id)})
+    ds.sql.should == 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN (SELECT id FROM genres) AS genres ON (genres.id = ag.genre_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :genres_id=>4})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(GraphGenre)
+    a.genres.first.values.should == {:id => 4}
+  end
+
+  it "should allow cascading of eager loading with a custom callback with hash value" do
+    ds = GraphTrack.eager_graph(:album=>{proc{|ds| ds.select_columns(:id, :band_id)}=>{:band=>:members}})
+    ds.sql.should == 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, members.id AS members_id FROM tracks LEFT OUTER JOIN (SELECT id, band_id FROM albums) AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN bm ON (bm.band_id = band.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    a = a.first
+    a.album.should be_a_kind_of(GraphAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(GraphBand)
+    a.album.band.values.should == {:id => 2, :vocalist_id=>6}
+    a.album.band.members.should be_a_kind_of(Array)
+    a.album.band.members.size.should == 1
+    a.album.band.members.first.should be_a_kind_of(GraphBandMember)
+    a.album.band.members.first.values.should == {:id => 5}
+  end
+  
+  it "should allow cascading of eager loading with a custom callback with array value" do
+    ds = GraphTrack.eager_graph(:album=>{proc{|ds| ds.select_columns(:id, :band_id)}=>[:band, :tracks]})
+    ds.sql.should == 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, tracks_0.id AS tracks_0_id, tracks_0.album_id AS tracks_0_album_id FROM tracks LEFT OUTER JOIN (SELECT id, band_id FROM albums) AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN tracks AS tracks_0 ON (tracks_0.album_id = album.id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>6, :tracks_0_id=>3, :tracks_0_album_id=>1})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    a = a.first
+    a.album.should be_a_kind_of(GraphAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(GraphBand)
+    a.album.band.values.should == {:id => 2, :vocalist_id=>6}
+    a.album.tracks.should be_a_kind_of(Array)
+    a.album.tracks.size.should == 1
+    a.album.tracks.first.should be_a_kind_of(GraphTrack)
+    a.album.tracks.first.values.should == {:id => 3, :album_id => 1}
+  end
+  
 end

data/spec/model/hooks_spec.rb

@@ -268,4 +268,165 @@ describe "Model#before_validation && Model#after_validation" do
     @c.load(:id => 2233).save.should == nil
     MODEL_DB.sqls.should == []
   end
+  
+  specify "#valid? should return false if before_validation returns false" do
+    @c.send(:define_method, :before_validation){false}
+    @c.load(:id => 2233).valid?.should == false
+  end
+end
+
+describe "Model around filters" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :id, :x
+      def _save_refresh(*a) end
+    end
+  end
+  
+  specify "around_create should be called around new record creation" do
+    @c.class_eval do
+      def around_create
+        MODEL_DB << 'ac_before'
+        super
+        MODEL_DB << 'ac_after'
+      end
+    end
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [ 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after' ]
+  end
+
+  specify "around_delete should be called around record destruction" do
+    @c.class_eval do
+      def around_destroy
+        MODEL_DB << 'ad_before'
+        super
+        MODEL_DB << 'ad_after'
+      end
+    end
+    @c.load(:id=>1, :x => 2).destroy
+    MODEL_DB.sqls.should == [ 'ad_before', 'DELETE FROM items WHERE (id = 1)', 'ad_after' ]
+  end
+  
+  specify "around_update should be called around updating existing records" do
+    @c.class_eval do
+      def around_update
+        MODEL_DB << 'au_before'
+        super
+        MODEL_DB << 'au_after'
+      end
+    end
+    @c.load(:id=>1, :x => 2).save
+    MODEL_DB.sqls.should == [ 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after' ]
+  end
+
+  specify "around_update should be called around saving both new and existing records, around either after_create and after_update" do
+    @c.class_eval do
+      def around_update
+        MODEL_DB << 'au_before'
+        super
+        MODEL_DB << 'au_after'
+      end
+      def around_create
+        MODEL_DB << 'ac_before'
+        super
+        MODEL_DB << 'ac_after'
+      end
+      def around_save
+        MODEL_DB << 'as_before'
+        super
+        MODEL_DB << 'as_after'
+      end
+    end
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [ 'as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after' ]
+    MODEL_DB.sqls.clear
+    @c.load(:id=>1, :x => 2).save
+    MODEL_DB.sqls.should == [ 'as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after' ]
+  end
+
+  specify "around_validation should be called around validating records" do
+    @c.class_eval do
+      def around_validation
+        MODEL_DB << 'av_before'
+        super
+        MODEL_DB << 'av_after'
+      end
+      def validate
+        MODEL_DB << 'validate'
+      end
+    end
+    @c.new(:x => 2).valid?.should == true
+    MODEL_DB.sqls.should == [ 'av_before', 'validate', 'av_after' ]
+  end
+
+  specify "around_validation should be able to catch validation errors and modify them" do
+    @c.class_eval do
+      def validate
+        errors.add(:x, 'foo')
+      end
+    end
+    @c.new(:x => 2).valid?.should == false
+    @c.class_eval do
+      def around_validation
+        super
+        errors.clear
+      end
+    end
+    @c.new(:x => 2).valid?.should == true
+  end
+
+  specify "around_create that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_create){}
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_update that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_update){}
+    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_save that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_save){}
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_destroy that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_destroy){}
+    proc{@c.load(:x => 2).destroy}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_validation that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_validation){}
+    proc{@c.new.save}.should raise_error(Sequel::HookFailed)
+  end
+
+  specify "around_validation that doesn't call super should have valid? return false" do
+    @c.send(:define_method, :around_validation){}
+    @c.new.valid?.should == false
+  end
+
+  specify "around_* that doesn't call super should return nil if raise_on_save_failure is false" do
+    @c.raise_on_save_failure = false
+
+    o = @c.load(:id => 1)
+    o.meta_def(:around_save){}
+    o.save.should == nil
+
+    o = @c.load(:id => 1)
+    o.meta_def(:around_update){}
+    o.save.should == nil
+
+    o = @c.new
+    o.meta_def(:around_create){}
+    o.save.should == nil
+
+    o = @c.new
+    o.meta_def(:around_validation){}
+    o.save.should == nil
+  end
+
 end

data/spec/model/record_spec.rb

@@ -52,6 +52,7 @@ describe "Model#save" do
 
   it "should use dataset's insert_select method if present" do
     ds = @c.dataset = @c.dataset.clone
+    def ds.supports_insert_select?() true end
     def ds.insert_select(hash)
       execute("INSERT INTO items (y) VALUES (2)")
       {:y=>2}
@@ -63,6 +64,12 @@ describe "Model#save" do
     MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (2)"]
   end
 
+  it "should not use dataset's insert_select method if specific columns are selected" do
+    ds = @c.dataset = @c.dataset.select(:y)
+    ds.should_not_receive(:insert_select)
+    @c.new(:x => 1).save
+  end
+
   it "should use value returned by insert as the primary key and refresh the object" do
     @c.dataset.meta_def(:insert){|h| super(h); 13}
     o = @c.new(:x => 11)
@@ -1161,6 +1168,29 @@ describe Sequel::Model, "#initialize" do
     m.values.should == {:x => 2}
   end
 end
+  
+describe Sequel::Model, "#initialize_set" do
+  before do
+    @c = Class.new(Sequel::Model){columns :id, :x, :y}
+  end
+
+  specify "should be called by initialize to set the column values" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).values.should == {:y => 3}
+  end
+
+  specify "should be called with the hash given to initialize " do
+    x = nil
+    @c.send(:define_method, :initialize_set){|y| x = y}
+    @c.new(:x => 2)
+    x.should == {:x => 2}
+  end
+
+  specify "should not cause columns modified by the method to be considered as changed" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).changed_columns.should == []
+  end
+end
 
 describe Sequel::Model, ".create" do
 

data/spec/model/spec_helper.rb

@@ -8,6 +8,11 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class MockDataset < Sequel::Dataset
   def insert(*args)
     @db.execute insert_sql(*args)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  hash: 83
+  hash: 103
   prerelease: false
   segments: 
   - 3
-  - 21
+  - 24
   - 0
-  version: 3.21.0
+  version: 3.24.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 -08:00
+date: 2011-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -85,6 +85,9 @@ extra_rdoc_files:
 - doc/release_notes/3.19.0.txt
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
+- doc/release_notes/3.22.0.txt
+- doc/release_notes/3.23.0.txt
+- doc/release_notes/3.24.0.txt
 files: 
 - MIT-LICENSE
 - CHANGELOG
@@ -137,6 +140,9 @@ files:
 - doc/release_notes/3.19.0.txt
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
+- doc/release_notes/3.22.0.txt
+- doc/release_notes/3.23.0.txt
+- doc/release_notes/3.24.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc
@@ -216,6 +222,13 @@ files:
 - spec/extensions/xml_serializer_spec.rb
 - spec/extensions/to_dot_spec.rb
 - spec/extensions/association_autoreloading_spec.rb
+- spec/extensions/serialization_modification_detection_spec.rb
+- spec/extensions/defaults_setter_spec.rb
+- spec/extensions/prepared_statements_spec.rb
+- spec/extensions/prepared_statements_safe_spec.rb
+- spec/extensions/prepared_statements_with_pk_spec.rb
+- spec/extensions/prepared_statements_associations_spec.rb
+- spec/extensions/columns_introspection_spec.rb
 - spec/integration/associations_test.rb
 - spec/integration/database_test.rb
 - spec/integration/dataset_test.rb
@@ -304,6 +317,9 @@ files:
 - lib/sequel/adapters/jdbc/postgresql.rb
 - lib/sequel/adapters/jdbc/sqlite.rb
 - lib/sequel/adapters/jdbc/as400.rb
+- lib/sequel/adapters/jdbc/informix.rb
+- lib/sequel/adapters/jdbc/jtds.rb
+- lib/sequel/adapters/jdbc/sqlserver.rb
 - lib/sequel/adapters/mysql.rb
 - lib/sequel/adapters/odbc.rb
 - lib/sequel/adapters/odbc/mssql.rb
@@ -317,6 +333,7 @@ files:
 - lib/sequel/adapters/shared/progress.rb
 - lib/sequel/adapters/shared/sqlite.rb
 - lib/sequel/adapters/shared/access.rb
+- lib/sequel/adapters/shared/informix.rb
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/utils/stored_procedures.rb
 - lib/sequel/adapters/mysql2.rb
@@ -364,6 +381,7 @@ files:
 - lib/sequel/extensions/string_date_time.rb
 - lib/sequel/extensions/thread_local_timezones.rb
 - lib/sequel/extensions/to_dot.rb
+- lib/sequel/extensions/columns_introspection.rb
 - lib/sequel/metaprogramming.rb
 - lib/sequel/model.rb
 - lib/sequel/model/associations.rb
@@ -410,9 +428,16 @@ files:
 - lib/sequel/plugins/tree.rb
 - lib/sequel/plugins/xml_serializer.rb
 - lib/sequel/plugins/association_autoreloading.rb
+- lib/sequel/plugins/serialization_modification_detection.rb
+- lib/sequel/plugins/defaults_setter.rb
+- lib/sequel/plugins/prepared_statements.rb
+- lib/sequel/plugins/prepared_statements_safe.rb
+- lib/sequel/plugins/prepared_statements_with_pk.rb
+- lib/sequel/plugins/prepared_statements_associations.rb
 - lib/sequel/sql.rb
 - lib/sequel/timezones.rb
 - lib/sequel/version.rb
+- lib/sequel/ast_transformer.rb
 - lib/sequel_core.rb
 - lib/sequel_model.rb
 has_rdoc: true