sequel 2.1.0 → 2.2.0

data/spec/caching_spec.rb

@@ -1,8 +1,7 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
 describe Sequel::Model, "caching" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     
     @cache_class = Class.new(Hash) do
@@ -15,6 +14,7 @@ describe Sequel::Model, "caching" do
     
     @c = Class.new(Sequel::Model(:items)) do
       set_cache cache
+      def self.name; 'Item' end
       
       columns :name, :id
     end
@@ -37,37 +37,51 @@ describe Sequel::Model, "caching" do
         $sqls << delete_sql
       end
     })
+    @c2 = Class.new(@c) do
+      def self.name; 'SubItem' end
+    end
   end
   
   it "should set the model's cache store" do
     @c.cache_store.should be(@cache)
+    @c2.cache_store.should be(@cache)
   end
   
   it "should have a default ttl of 3600" do
     @c.cache_ttl.should == 3600
+    @c2.cache_ttl.should == 3600
   end
   
   it "should take a ttl option" do
     @c.set_cache @cache, :ttl => 1234
     @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
   end
   
   it "should offer a set_cache_ttl method for setting the ttl" do
     @c.cache_ttl.should == 3600
     @c.set_cache_ttl 1234
     @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
   end
   
   it "should generate a cache key appropriate to the class" do
     m = @c.new
     m.values[:id] = 1
     m.cache_key.should == "#{m.class}:1"
+    m = @c2.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
     
     # custom primary key
     @c.set_primary_key :ttt
     m = @c.new
     m.values[:ttt] = 333
     m.cache_key.should == "#{m.class}:333"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
     
     # composite primary key
     @c.set_primary_key [:a, :b, :c]
@@ -76,12 +90,22 @@ describe Sequel::Model, "caching" do
     m.values[:c] = 456
     m.values[:b] = 789
     m.cache_key.should == "#{m.class}:123,789,456"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
   end
   
   it "should raise error if attempting to generate cache_key and primary key value is null" do
     m = @c.new
     proc {m.cache_key}.should raise_error(Sequel::Error)
-    
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+
+    m = @c2.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
     m.values[:id] = 1
     proc {m.cache_key}.should_not raise_error(Sequel::Error)
   end
@@ -89,6 +113,8 @@ describe Sequel::Model, "caching" do
   it "should not raise error if trying to save a new record" do
     proc {@c.new(:name=>'blah').save}.should_not raise_error
     proc {@c.create(:name=>'blah')}.should_not raise_error
+    proc {@c2.new(:name=>'blah').save}.should_not raise_error
+    proc {@c2.create(:name=>'blah')}.should_not raise_error
   end
   
   it "should set the cache when reading from the database" do
@@ -99,16 +125,23 @@ describe Sequel::Model, "caching" do
     $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
     m.values.should == $cache_dataset_row
     @cache[m.cache_key].should == m
-    
-    # read from cache
     m2 = @c[1]
     $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
     m2.should == m
     m2.values.should == $cache_dataset_row
+
+    $sqls.clear
+    m = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    m2 = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
   end
   
   it "should delete the cache when writing to the database" do
-    # fill the cache
     m = @c[1]
     @cache[m.cache_key].should == m
     
@@ -122,13 +155,31 @@ describe Sequel::Model, "caching" do
     m.save
     @cache.has_key?(m.cache_key).should be_false
     $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    
+    m.update_values(:name => 'tutu')
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
+    
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
   end
   
   it "should delete the cache when deleting the record" do
-    # fill the cache
     m = @c[1]
     @cache[m.cache_key].should == m
-    
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
     $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
@@ -138,16 +189,26 @@ describe Sequel::Model, "caching" do
     m = @c[:id => 3]
     @cache[m.cache_key].should be_nil
     $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
-    
     m = @c[1]
     @cache[m.cache_key].should == m
     $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
       "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    
     @c[:id => 4]
     $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
       "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
       "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+
+    $sqls.clear
+    m = @c2[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c2[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
   end
-  
 end

data/spec/eager_loading_spec.rb

@@ -20,6 +20,7 @@ describe Sequel::Model, "#eager" do
     class EagerBand < Sequel::Model(:bands)
       columns :id
       one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks
+      one_to_many :graph_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_graph=>:tracks
       many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
       one_to_many :good_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_block=>proc{|ds| ds.filter(:name=>'good')} do |ds|
         ds.filter(:name=>'Good')
@@ -28,6 +29,7 @@ describe Sequel::Model, "#eager" do
         ds.filter(:name=>name)
       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
     end
     
     class EagerTrack < Sequel::Model(:tracks)
@@ -46,6 +48,10 @@ describe Sequel::Model, "#eager" do
     end
     
     EagerAlbum.dataset.extend(Module.new {
+      def columns
+        [:id, :band_id]
+      end
+
       def fetch_rows(sql)
         h = if sql =~ /101/
           {:id => 101, :band_id=> 101}
@@ -106,7 +112,7 @@ describe Sequel::Model, "#eager" do
     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 bands.* FROM bands WHERE (id IN (2))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (2))']
     a = a.first
     a.band.should be_a_kind_of(EagerBand)
     a.band.values.should == {:id => 2}
@@ -119,7 +125,7 @@ describe Sequel::Model, "#eager" do
     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 tracks.* FROM tracks WHERE (album_id IN (1))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a = a.first
     a.tracks.should be_a_kind_of(Array)
     a.tracks.size.should == 1
@@ -151,8 +157,8 @@ describe Sequel::Model, "#eager" do
     a.first.values.should == {:id => 1, :band_id => 2}
     MODEL_DB.sqls.length.should == 4
     MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
-    MODEL_DB.sqls[1..-1].should(include('SELECT bands.* FROM bands WHERE (id IN (2))'))
-    MODEL_DB.sqls[1..-1].should(include('SELECT tracks.* FROM tracks WHERE (album_id IN (1))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM bands WHERE (bands.id IN (2))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM tracks WHERE (tracks.album_id IN (1))'))
     MODEL_DB.sqls[1..-1].should(include('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 (1)))'))
     a = a.first
     a.band.should be_a_kind_of(EagerBand)
@@ -176,8 +182,8 @@ describe Sequel::Model, "#eager" do
     a.first.values.should == {:id => 3, :album_id => 1}
     MODEL_DB.sqls.length.should == 4
     MODEL_DB.sqls.should == ['SELECT * FROM tracks', 
-      'SELECT albums.* FROM albums WHERE (id IN (1))',
-      'SELECT bands.* FROM bands WHERE (id IN (2))',
+      '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)
@@ -198,8 +204,8 @@ describe Sequel::Model, "#eager" do
     a.first.should be_a_kind_of(EagerBand)
     a.first.values.should == {:id => 2}
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 
-                             'SELECT albums.* FROM albums WHERE (band_id IN (2))',
-                             'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
+                             'SELECT * FROM albums WHERE (albums.band_id IN (2))',
+                             'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a = a.first
     a.albums.should be_a_kind_of(Array)
     a.albums.size.should == 1
@@ -223,8 +229,8 @@ describe Sequel::Model, "#eager" do
     a = a.first
     a.albums
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 
-                             'SELECT albums.* FROM albums WHERE (band_id = 2)',
-                             'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
+                             'SELECT * FROM albums WHERE (albums.band_id = 2)',
+                             'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.albums.should be_a_kind_of(Array)
     a.albums.size.should == 1
     a.albums.first.should be_a_kind_of(EagerAlbum)
@@ -237,6 +243,62 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 3
   end
   
+  it "should cascade eagerly loading when the :eager_graph association option is used" do
+    EagerAlbum.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1})
+      end
+    })
+    a = EagerBand.eager(:graph_albums).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBand)
+    a.first.values.should == {:id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+                             'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id IN (2))']
+    a = a.first
+    a.graph_albums.should be_a_kind_of(Array)
+    a.graph_albums.size.should == 1
+    a.graph_albums.first.should be_a_kind_of(EagerAlbum)
+    a.graph_albums.first.values.should == {:id => 1, :band_id => 2}
+    a = a.graph_albums.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 respect :eager_graph when lazily loading an association" do
+    a = EagerBand.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBand)
+    a.first.values.should == {:id => 2}
+    MODEL_DB.sqls.should == ['SELECT * FROM bands']
+    a = a.first
+    EagerAlbum.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1})
+      end
+    })
+    a.graph_albums
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+                             'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id = 2)']
+    a.graph_albums.should be_a_kind_of(Array)
+    a.graph_albums.size.should == 1
+    a.graph_albums.first.should be_a_kind_of(EagerAlbum)
+    a.graph_albums.first.values.should == {:id => 1, :band_id => 2}
+    a = a.graph_albums.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 respect :order when eagerly loading" do
     a = EagerBandMember.eager(:bands).all
     a.should be_a_kind_of(Array)
@@ -258,7 +320,7 @@ describe Sequel::Model, "#eager" do
     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 tracks.* FROM tracks WHERE (album_id IN (1))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a = a.first
     a.tracks.should be_a_kind_of(Array)
     a.tracks.size.should == 1
@@ -275,7 +337,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerAlbum)
     a.first.values.should == {:id => 101, :band_id => 101}
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (id = 101)', 'SELECT bands.* FROM bands WHERE (id IN (101))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (id = 101)', 'SELECT * FROM bands WHERE (bands.id IN (101))']
     a = a.first
     a.associations.fetch(:band, 2).should == nil
     a.band.should == nil
@@ -289,7 +351,7 @@ describe Sequel::Model, "#eager" do
     a.first.should be_a_kind_of(EagerBand)
     a.first.values.should == {:id => 101}
     a.last.values.should == {:id => 102}
-    MODEL_DB.sqls.should == ['SELECT * FROM bands WHERE (id > 100)', 'SELECT albums.* FROM albums WHERE (band_id IN (101, 102))', "SELECT tracks.* FROM tracks WHERE (album_id IN (101))"]
+    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))"]
     a.first.associations[:albums].should be_a_kind_of(Array)
     a.first.albums.length.should == 1
     a.first.albums.first.should be_a_kind_of(EagerAlbum)
@@ -300,15 +362,15 @@ describe Sequel::Model, "#eager" do
   
   it "should use the association's block when eager loading by default" do
     EagerAlbum.eager(:good_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT tracks.* FROM tracks WHERE ((album_id IN (1)) AND (name = 'Good'))"]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
   end
 
   it "should use the eager_block option when eager loading if given" do
     EagerBand.eager(:good_albums).all
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT albums.* FROM albums WHERE ((band_id IN (2)) AND (name = 'good'))"]
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
     MODEL_DB.sqls.clear
     EagerBand.eager(:good_albums=>:good_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT albums.* FROM albums WHERE ((band_id IN (2)) AND (name = 'good'))", "SELECT tracks.* FROM tracks WHERE ((album_id IN (1)) AND (name = 'Good'))"]
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))", "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
   end
 
   it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do
@@ -318,14 +380,52 @@ describe Sequel::Model, "#eager" do
 
   it "should respect the association's :select option" do
     EagerAlbum.eager(:band_name).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM bands WHERE (id IN (2))"]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM bands WHERE (bands.id IN (2))"]
     MODEL_DB.sqls.clear
     EagerAlbum.eager(:track_names).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM tracks WHERE (album_id IN (1))"]
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM tracks WHERE (tracks.album_id IN (1))"]
     MODEL_DB.sqls.clear
     EagerAlbum.eager(:genre_names).all
     MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, 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 use the :eager_loader association option when eager loading" do
+    EagerAlbum.many_to_one :special_band, :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)
+    EagerAlbum.one_to_many :special_tracks, :eager_loader=>(proc do |key_hash, records, assocs| 
+      items = EagerTrack.filter(:album_id=>records.collect{|r| [r.pk, r.pk*2]}.flatten).all
+      records.each{|r| r.associations[:special_tracks] = items}
+    end)
+    EagerAlbum.many_to_many :special_genres, :eager_loader=>(proc do |key_hash, records, assocs| 
+      items = EagerGenre.inner_join(:ag, [:genre_id]).filter(:album_id=>records.collect{|r| r.pk}).all
+      records.each{|r| r.associations[:special_genres] = items}
+    end)
+    a = EagerAlbum.eager(:special_genres, :special_tracks, :special_band).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.length.should == 4
+    MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM bands WHERE (album_id IN (1, 2)) ORDER BY name LIMIT 1'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM tracks WHERE (album_id IN (1, 2))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM genres INNER JOIN ag USING (genre_id) WHERE (album_id IN (1))'))
+    a = a.first
+    a.special_band.should be_a_kind_of(EagerBand)
+    a.special_band.values.should == {:id => 2}
+    a.special_tracks.should be_a_kind_of(Array)
+    a.special_tracks.size.should == 1
+    a.special_tracks.first.should be_a_kind_of(EagerTrack)
+    a.special_tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.special_genres.should be_a_kind_of(Array)
+    a.special_genres.size.should == 1
+    a.special_genres.first.should be_a_kind_of(EagerGenre)
+    a.special_genres.first.values.should == {:id => 4}
+    MODEL_DB.sqls.length.should == 4
+  end
+  
 end
 
 describe Sequel::Model, "#eager_graph" do
@@ -735,15 +835,23 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) INNER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
   end
 
+  it "should respect the association's :graph_join_type option" do 
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_join_type=>:inner
+    GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
+
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_join_type=>:inner, :graph_join_type=>:right_outer
+    GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) RIGHT OUTER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
+  end
+
   it "should respect the association's :graph_conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_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.id = albums.band_id) AND (active_band.active = 't'))"
 
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_conditions=>{:id=>(0..100)}
+    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 LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
+
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_conditions=>{true=>:active}
     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 ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
-
-    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_conditions=>{:id=>(0..100)}
-    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.id = albums.band_id) AND ((active_band.id >= 0) AND (active_band.id <= 100)))"
   end
 
   it "should respect the association's :graph_join_table_conditions option" do 
@@ -753,4 +861,43 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_conditions=>{true=>:active}, :graph_join_table_conditions=>{true=>:active}
     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 ON ((ag.album_id = albums.id) AND ('t' = albums.active)) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
   end
+
+  it "should respect the association's :graph_block option" do 
+    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_block=>proc{|ja,lja,js| {:active.qualify(ja)=>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.id = albums.band_id) AND (active_band.active = 't'))"
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_block=>proc{|ja,lja,js| {:id.qualify(ja)=>(0..100)}}
+    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 LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
+
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}
+    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 ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
+  end
+
+  it "should respect the association's :graph_join_block option" do 
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
+    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 ON ((ag.album_id = albums.id) AND (ag.active = 't')) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
+
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}, :graph_join_table_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}
+    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 ON ((ag.album_id = albums.id) AND ('t' = albums.active)) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
+  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 = 't')"
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_only_conditions=>nil, :graph_join_type=>:natural
+    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', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>[:album_id]
+    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 ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres USING (album_id)"
+  end
+
+  it "should respect the association's :graph_join_table_only_conditions option" do 
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_only_conditions=>{:active=>true}
+    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 ON (ag.active = 't') LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
+
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(:price + 2 > 100), :graph_join_table_only_conditions=>"active"
+    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 ON (active) LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"
+  end
+
 end