sequel 3.36.1 → 3.37.0

data/spec/model/eager_loading_spec.rb

@@ -13,6 +13,10 @@ describe Sequel::Model, "#eager" do
       many_to_one :band_name, :class=>'EagerBand', :key=>:band_id, :select=>[:id, :name]
       one_to_many :track_names, :class=>'EagerTrack', :key=>:album_id, :select=>[:id, :name]
       many_to_many :genre_names, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :select=>[:id]
+
+      def band_id3
+        band_id*3
+      end
     end
 
     class ::EagerBand < Sequel::Model(:bands)
@@ -29,6 +33,10 @@ describe Sequel::Model, "#eager" do
       end
       one_to_many :albums_by_name, :class=>'EagerAlbum', :key=>:band_id, :order=>:name, :allow_eager=>false
       one_to_many :top_10_albums, :class=>'EagerAlbum', :key=>:band_id, :limit=>10
+
+      def id3
+        id/3
+      end
     end
     
     class ::EagerTrack < Sequel::Model(:tracks)
@@ -90,6 +98,26 @@ describe Sequel::Model, "#eager" do
     [:EagerAlbum, :EagerBand, :EagerTrack, :EagerGenre, :EagerBandMember].each{|x| Object.send(:remove_const, x)}
   end
   
+  it "should populate :key_hash and :id_map option correctly for custom eager loaders" do
+    khs = {}
+    pr = proc{|a, m| proc{|h| khs[a] = h[:key_hash][m]; h[:id_map].should == h[:key_hash][m]}}
+    EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loader=>pr.call(:sband, :band_id)
+    EagerAlbum.one_to_many :stracks, :clone=>:tracks, :eager_loader=>pr.call(:stracks, :id)
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loader=>pr.call(:sgenres, :id)
+    EagerAlbum.eager(:sband, :stracks, :sgenres).all
+    khs.should == {:sband=>{2=>[EagerAlbum.load(:band_id=>2, :id=>1)]}, :stracks=>{1=>[EagerAlbum.load(:band_id=>2, :id=>1)]}, :sgenres=>{1=>[EagerAlbum.load(:band_id=>2, :id=>1)]}}
+  end
+
+  it "should populate :key_hash using the method symbol" do
+    khs = {}
+    pr = proc{|a, m| proc{|h| khs[a] = h[:key_hash][m]}}
+    EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loader=>pr.call(:sband, :band_id), :key=>:band_id, :key_column=>:b_id
+    EagerAlbum.one_to_many :stracks, :clone=>:tracks, :eager_loader=>pr.call(:stracks, :id), :primary_key=>:id, :primary_key_column=>:i
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loader=>pr.call(:sgenres, :id), :left_primary_key=>:id, :left_primary_key_column=>:i
+    EagerAlbum.eager(:sband, :stracks, :sgenres).all
+    khs.should == {:sband=>{2=>[EagerAlbum.load(:band_id=>2, :id=>1)]}, :stracks=>{1=>[EagerAlbum.load(:band_id=>2, :id=>1)]}, :sgenres=>{1=>[EagerAlbum.load(:band_id=>2, :id=>1)]}}
+  end
+
   it "should raise an error if called without a symbol or hash" do
     proc{EagerAlbum.eager(Object.new)}.should raise_error(Sequel::Error)
   end
@@ -189,6 +217,80 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
+  it "should support using a custom :key option when eager loading many_to_one associations" do
+    EagerAlbum.many_to_one :sband, :clone=>:band, :key=>:band_id3
+    EagerBand.dataset._fetch = {:id=>6}
+    a = EagerAlbum.eager(:sband).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (6))']
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    a.first.sband.should == EagerBand.load(:id=>6)
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should support using a custom :primary_key option when eager loading one_to_many associations" do
+    EagerBand.one_to_many :salbums, :clone=>:albums, :primary_key=>:id3, :eager=>nil
+    EagerBand.dataset._fetch = {:id=>6}
+    a = EagerBand.eager(:salbums).all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE (albums.band_id IN (2))']
+    a.should == [EagerBand.load(:id => 6)]
+    a.first.salbums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :left_primary_key=>:band_id3
+    EagerGenre.dataset._fetch = {:id=>4, :x_foreign_key_x=>6}
+    a = EagerAlbum.eager(:sgenres).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (6)))"]
+    a.first.sgenres.should == [EagerGenre.load(:id=>4)]
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_one associations" do
+    EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loading_predicate_key=>Sequel./(:bands__id, 3), :primary_key_method=>:id3
+    EagerBand.dataset._fetch = {:id=>6}
+    a = EagerAlbum.eager(:sband).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE ((bands.id / 3) IN (2))']
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    a.first.sband.should == EagerBand.load(:id=>6)
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for one_to_many associations" do
+    EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>Sequel.*(:albums__band_id, 3), :key_method=>:band_id3, :eager=>nil
+    EagerBand.dataset._fetch = {:id=>6}
+    a = EagerBand.eager(:salbums).all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE ((albums.band_id * 3) IN (6))']
+    a.should == [EagerBand.load(:id => 6)]
+    a.first.salbums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_many associations" do
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loading_predicate_key=>Sequel.*(:ag__album_id, 1)
+    a = EagerAlbum.eager(:sgenres).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, (ag.album_id * 1) AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND ((ag.album_id * 1) IN (1)))"]
+    a.first.sgenres.should == [EagerGenre.load(:id=>4)]
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should raise an error for an unhandled :eager_loader_key option" do
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loader_key=>1
+    ds = EagerAlbum.eager(:sgenres)
+    proc{ds.all}.should raise_error(Sequel::Error)
+  end
+  
+  it "should not add entry to key_hash for :eager_loader_key=>nil option" do
+    eo = nil
+    EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loader_key=>nil, :eager_loader=>proc{|o| eo = o}
+    ds = EagerAlbum.eager(:sgenres)
+    ds.all
+    eo[:key_hash].should == {}
+    eo[:id_map].should == nil
+  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
@@ -349,7 +451,9 @@ describe Sequel::Model, "#eager" do
   it "should cache the negative lookup when eagerly loading a *_to_many associations" do
     a = EagerBand.eager(:albums).filter('id > 100').all
     a.should == [EagerBand.load(:id => 101), EagerBand.load(:id =>102)]
-    MODEL_DB.sqls.should == ['SELECT * FROM bands WHERE (id > 100)', 'SELECT * FROM albums WHERE (albums.band_id IN (101, 102))', "SELECT * FROM tracks WHERE (tracks.album_id IN (101))"]
+    sqls = MODEL_DB.sqls
+    ['SELECT * FROM albums WHERE (albums.band_id IN (101, 102))', 'SELECT * FROM albums WHERE (albums.band_id IN (102, 101))'].should include(sqls.delete_at(1))
+    sqls.should == ['SELECT * FROM bands WHERE (id > 100)', "SELECT * FROM tracks WHERE (tracks.album_id IN (101))"]
     a.map{|b| b.associations[:albums]}.should == [[EagerAlbum.load({:band_id=>101, :id=>101})], []]
     MODEL_DB.sqls.should == []
   end
@@ -545,7 +649,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should use the :eager_loader association option when eager loading" do
-    EagerAlbum.many_to_one :special_band, :eager_loader=>(proc do |key_hash, records, assocs| 
+    EagerAlbum.many_to_one :special_band, :key=>:band_id, :eager_loader=>(proc do |key_hash, records, assocs| 
       item = EagerBand.filter(:album_id=>records.collect{|r| [r.pk, r.pk*2]}.flatten).order(:name).first
       records.each{|r| r.associations[:special_band] = item}
     end)
@@ -758,6 +862,37 @@ describe Sequel::Model, "#eager_graph" do
     proc{ds2.eager_graph(:tracks)}.should_not raise_error
   end
 
+  it "should allow manually selecting the alias base per call via an AliasedExpression" do
+    ds = GraphAlbum.eager_graph(Sequel.as(:band, :b))
+    ds.sql.should == 'SELECT albums.id, albums.band_id, b.id AS b_id, b.vocalist_id FROM albums LEFT OUTER JOIN bands AS b ON (b.id = albums.band_id)'
+    ds._fetch = {:id=>1, :band_id=>2, :b_id=>2, :vocalist_id=>3}
+    a = ds.all
+    a.should == [GraphAlbum.load(:id => 1, :band_id => 2)]
+    a.first.band.should == GraphBand.load(:id => 2, :vocalist_id=>3)
+  end
+  
+  it "should handle multiple associations using the same alias base" do
+    ds = GraphAlbum.eager_graph(Sequel.as(:genres, :b), Sequel.as(:tracks, :b), Sequel.as(:band, :b))
+    ds.sql.should == 'SELECT albums.id, albums.band_id, b.id AS b_id, b_0.id AS b_0_id, b_0.album_id, b_1.id AS b_1_id, b_1.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS b ON (b.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_0 ON (b_0.album_id = albums.id) LEFT OUTER JOIN bands AS b_1 ON (b_1.id = albums.band_id)'
+    ds._fetch = {:id=>1, :band_id=>2, :b_id=>4, :b_0_id=>3, :album_id=>1, :b_1_id=>2, :vocalist_id=>6}
+    a = ds.all
+    a.should == [GraphAlbum.load(:id => 1, :band_id => 2)]
+    a = a.first
+    a.band.should == GraphBand.load(:id => 2, :vocalist_id=>6)
+    a.tracks.should == [GraphTrack.load({:id => 3, :album_id=>1})]
+    a.genres.should == [GraphGenre.load(:id => 4)]
+
+    ds = GraphTrack.eager_graph(Sequel.as(:album, :b)=>{Sequel.as(:band, :b)=>Sequel.as(:members, :b)})
+    ds.sql.should == 'SELECT tracks.id, tracks.album_id, b.id AS b_id, b.band_id, b_0.id AS b_0_id, b_0.vocalist_id, b_1.id AS b_1_id FROM tracks LEFT OUTER JOIN albums AS b ON (b.id = tracks.album_id) LEFT OUTER JOIN bands AS b_0 ON (b_0.id = b.band_id) LEFT OUTER JOIN bm ON (bm.band_id = b_0.id) LEFT OUTER JOIN members AS b_1 ON (b_1.id = bm.member_id)'
+    ds._fetch = {:id=>3, :album_id=>1, :b_id=>1, :band_id=>2, :b_1_id=>5, :b_0_id=>2, :vocalist_id=>6}
+    a = ds.all
+    a.should == [GraphTrack.load(:id => 3, :album_id => 1)]
+    a = a.first
+    a.album.should == GraphAlbum.load(:id => 1, :band_id => 2)
+    a.album.band.should == GraphBand.load(:id => 2, :vocalist_id=>6)
+    a.album.band.members.should == [GraphBandMember.load(:id => 5)]
+  end
+  
   it "should eagerly load a single many_to_one association" do
     ds = GraphAlbum.eager_graph(:band)
     ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'

data/spec/model/model_spec.rb

@@ -502,24 +502,24 @@ describe Sequel::Model, "attribute accessors" do
   before do
     db = Sequel.mock
     def db.schema(*)
-      [[:x, {:type=>:integer}], [:y, {:type=>:integer}]]
+      [[:x, {:type=>:integer}], [:z, {:type=>:integer}]]
     end
-    @dataset = db[:items].columns(:x, :y)
+    @dataset = db[:items].columns(:x, :z)
     @c = Class.new(Sequel::Model)
     MODEL_DB.reset
   end
 
   it "should be created on set_dataset" do
-    %w'x y x= y='.each do |x|
-      @c.instance_methods.collect{|y| y.to_s}.should_not include(x)
+    %w'x z x= z='.each do |x|
+      @c.instance_methods.collect{|z| z.to_s}.should_not include(x)
     end
     @c.set_dataset(@dataset)
-    %w'x y x= y='.each do |x|
-      @c.instance_methods.collect{|y| y.to_s}.should include(x)
+    %w'x z x= z='.each do |x|
+      @c.instance_methods.collect{|z| z.to_s}.should include(x)
     end
     o = @c.new
-    %w'x y x= y='.each do |x|
-      o.methods.collect{|y| y.to_s}.should include(x)
+    %w'x z x= z='.each do |x|
+      o.methods.collect{|z| z.to_s}.should include(x)
     end
 
     o.x.should be_nil
@@ -538,7 +538,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should have a working typecasting setter even if the column is not selected" do
-    @c.set_dataset(@dataset.select(:y).columns(:y))
+    @c.set_dataset(@dataset.select(:z).columns(:z))
     o = @c.new
 
     o.x = '34'
@@ -546,7 +546,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should typecast if the new value is the same as the existing but has a different class" do
-    @c.set_dataset(@dataset.select(:y).columns(:y))
+    @c.set_dataset(@dataset.select(:z).columns(:z))
     o = @c.new
 
     o.x = 34

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 3.36.1
+  version: 3.37.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-02 00:00:00.000000000 Z
+date: 2012-07-02 00:00:00.000000000 Z
 dependencies: []
 description: The Database Toolkit for Ruby
 email: code@jeremyevans.net
@@ -97,6 +97,7 @@ extra_rdoc_files:
 - doc/release_notes/3.34.0.txt
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
+- doc/release_notes/3.37.0.txt
 files:
 - MIT-LICENSE
 - CHANGELOG
@@ -170,6 +171,7 @@ files:
 - doc/release_notes/3.34.0.txt
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
+- doc/release_notes/3.37.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/validations.rdoc
@@ -276,6 +278,11 @@ files:
 - spec/extensions/pg_json_spec.rb
 - spec/extensions/core_extensions_spec.rb
 - spec/extensions/pg_inet_spec.rb
+- spec/extensions/eval_inspect_spec.rb
+- spec/extensions/pg_range_spec.rb
+- spec/extensions/split_array_nil_spec.rb
+- spec/extensions/pg_range_ops_spec.rb
+- spec/extensions/pg_interval_spec.rb
 - spec/extensions/columns_introspection_spec.rb
 - spec/integration/associations_test.rb
 - spec/integration/database_test.rb
@@ -398,6 +405,7 @@ files:
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/utils/stored_procedures.rb
 - lib/sequel/adapters/utils/emulate_offset_with_row_number.rb
+- lib/sequel/adapters/utils/pg_types.rb
 - lib/sequel/adapters/mysql2.rb
 - lib/sequel/adapters/swift.rb
 - lib/sequel/adapters/swift/mysql.rb
@@ -462,6 +470,11 @@ files:
 - lib/sequel/extensions/core_extensions.rb
 - lib/sequel/extensions/query_literals.rb
 - lib/sequel/extensions/pg_inet.rb
+- lib/sequel/extensions/eval_inspect.rb
+- lib/sequel/extensions/pg_range.rb
+- lib/sequel/extensions/split_array_nil.rb
+- lib/sequel/extensions/pg_range_ops.rb
+- lib/sequel/extensions/pg_interval.rb
 - lib/sequel/metaprogramming.rb
 - lib/sequel/model.rb
 - lib/sequel/model/associations.rb