sequel 3.22.0 → 3.23.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/record_spec.rb

@@ -63,6 +63,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)

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: 95
+  hash: 91
   prerelease: false
   segments: 
   - 3
-  - 22
+  - 23
   - 0
-  version: 3.22.0
+  version: 3.23.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-01 00:00:00 -07:00
+date: 2011-05-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -86,6 +86,7 @@ extra_rdoc_files:
 - 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
 files: 
 - MIT-LICENSE
 - CHANGELOG
@@ -139,6 +140,7 @@ files:
 - 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/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc
@@ -218,6 +220,8 @@ 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/columns_introspection_spec.rb
 - spec/integration/associations_test.rb
 - spec/integration/database_test.rb
 - spec/integration/dataset_test.rb
@@ -366,6 +370,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
@@ -412,6 +417,7 @@ 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/sql.rb
 - lib/sequel/timezones.rb
 - lib/sequel/version.rb