sequel 2.6.0 → 2.7.0

data/spec/sequel_model/association_reflection_spec.rb

@@ -18,21 +18,21 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
   end
 end
 
-describe Sequel::Model::Associations::AssociationReflection, "#associated_primary_key" do
+describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
   before do
     @c = Class.new(Sequel::Model)
     class ::ParParent < Sequel::Model; end
   end
 
-  it "should use the :right_primary_key value if present" do
-    @c.many_to_one :c, :class=>ParParent, :associated_primary_key=>:blah__blah
-    @c.association_reflection(:c).should include(:associated_primary_key)
-    @c.association_reflection(:c).associated_primary_key.should == :blah__blah
+  it "should use the :primary_key value if present" do
+    @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
+    @c.association_reflection(:c).should include(:primary_key)
+    @c.association_reflection(:c).primary_key.should == :blah__blah
   end
-  it "should use the associated table's primary key if :associated_primary_key is not present" do
+  it "should use the associated table's primary key if :primary_key is not present" do
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).should_not include(:associated_primary_key)
-    @c.association_reflection(:c).associated_primary_key.should == :id
+    @c.association_reflection(:c).should_not include(:primary_key)
+    @c.association_reflection(:c).primary_key.should == :id
   end
 end
 

data/spec/sequel_model/associations_spec.rb

@@ -46,7 +46,7 @@ end
 describe Sequel::Model, "many_to_one" do
   before do
     MODEL_DB.reset
-
+    
     @c2 = Class.new(Sequel::Model(:nodes)) do
       unrestrict_primary_key
       columns :id, :parent_id, :par_parent_id, :blah
@@ -105,6 +105,12 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 567) LIMIT 1"]
   end
 
+  it "should use :primary_key option if given" do
+    @c2.many_to_one :parent, :class => @c2, :key => :blah, :primary_key => :pk
+    @c2.new(:id => 1, :blah => 567).parent
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.pk = 567) LIMIT 1"]
+  end
+
   it "should use :select option if given" do
     @c2.many_to_one :parent, :class => @c2, :key => :blah, :select=>[:id, :name]
     @c2.new(:id => 1, :blah => 567).parent
@@ -157,6 +163,21 @@ describe Sequel::Model, "many_to_one" do
     d.values.should == {:id => 1, :parent_id => 6677}
   end
   
+  it "should have the setter method respect the :primary_key option" do
+    @c2.many_to_one :parent, :class => @c2, :primary_key=>:blah
+
+    d = @c2.new(:id => 1)
+    d.parent = @c2.new(:id => 4321, :blah=>444)
+    d.values.should == {:id => 1, :parent_id => 444}
+
+    d.parent = nil
+    d.values.should == {:id => 1, :parent_id => nil}
+
+    e = @c2.new(:id => 6677, :blah=>8)
+    d.parent = e
+    d.values.should == {:id => 1, :parent_id => 8}
+  end
+  
   it "should not persist changes until saved" do
     @c2.many_to_one :parent, :class => @c2
 
@@ -289,6 +310,14 @@ describe Sequel::Model, "many_to_one" do
     @c2.instance_methods.collect{|x| x.to_s}.should_not(include('parent='))
   end
 
+  it "should not add associations methods directly to class" do
+    @c2.many_to_one :parent, :class => @c2
+    @c2.instance_methods.collect{|x| x.to_s}.should(include('parent'))
+    @c2.instance_methods.collect{|x| x.to_s}.should(include('parent='))
+    @c2.instance_methods(false).collect{|x| x.to_s}.should_not(include('parent'))
+    @c2.instance_methods(false).collect{|x| x.to_s}.should_not(include('parent='))
+  end
+
   it "should raise an error if trying to set a model object that doesn't have a valid primary key" do
     @c2.many_to_one :parent, :class => @c2
     p = @c2.new
@@ -520,6 +549,18 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
   end
   
+  it "should have add_ method respect the :primary_key option" do
+    @c2.one_to_many :attributes, :class => @c1, :primary_key=>:xxx
+    
+    n = @c2.new(:id => 1234, :xxx=>5)
+    a = @c1.new(:id => 2345)
+    a.save!
+    MODEL_DB.reset
+    a.should == n.add_attribute(a)
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 2345)']
+  end
+
+  
   it "should raise an error in add_ and remove_ if the passed object returns false to save (is not valid)" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
@@ -540,6 +581,12 @@ describe Sequel::Model, "one_to_many" do
     proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
   end
   
+  it "should use :primary_key option if given" do
+    @c1.one_to_many :nodes, :class => @c2, :primary_key => :node_id, :key=>:id
+    n = @c1.load(:id => 1234, :node_id=>4321)
+    n.nodes_dataset.sql.should == "SELECT * FROM nodes WHERE (nodes.id = 4321)"
+  end
+
   it "should support a select option" do
     @c2.one_to_many :attributes, :class => @c1, :select => [:id, :name]
 
@@ -727,6 +774,22 @@ describe Sequel::Model, "one_to_many" do
     im.should_not(include('remove_all_attributes'))
   end
 
+  it "should not add associations methods directly to class" do
+    @c2.one_to_many :attributes, :class => @c1
+    im = @c2.instance_methods.collect{|x| x.to_s}
+    im.should(include('attributes'))
+    im.should(include('attributes_dataset'))
+    im.should(include('add_attribute'))
+    im.should(include('remove_attribute'))
+    im.should(include('remove_all_attributes'))
+    im2 = @c2.instance_methods(false).collect{|x| x.to_s}
+    im2.should_not(include('attributes'))
+    im2.should_not(include('attributes_dataset'))
+    im2.should_not(include('add_attribute'))
+    im2.should_not(include('remove_attribute'))
+    im2.should_not(include('remove_all_attributes'))
+  end
+
   it "should have has_many alias" do
     @c2.has_many :attributes, :class => @c1
     
@@ -777,6 +840,12 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)'
   end
 
+  it "should have the remove_all_ method respect the :primary_key option" do
+    @c2.one_to_many :attributes, :class => @c1, :primary_key=>:xxx
+    @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
+    MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE (node_id = 5)'
+  end
+
   it "remove_all should set the cached instance variable to []" do
     @c2.one_to_many :attributes, :class => @c1
     node = @c2.new(:id => 1234)
@@ -828,7 +897,7 @@ describe Sequel::Model, "one_to_many" do
     att.values.should == {}
   end
 
-  it "should not add a getter method if the :one_to_one option is true and :read_only option is true" do
+  it "should not add a setter method if the :one_to_one option is true and :read_only option is true" do
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :read_only=>true
     im = @c2.instance_methods.collect{|x| x.to_s}
     im.should(include('attribute'))
@@ -861,6 +930,25 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
   end
 
+  it "should have the setter method for the :one_to_one option respect the :primary_key option" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :primary_key=>:xxx
+    attrib = @c1.new(:id=>3)
+    d = @c1.dataset
+    def d.fetch_rows(s); yield({:id=>3}) end
+    @c2.new(:id => 1234, :xxx=>5).attribute = attrib
+    ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
+      'INSERT INTO attributes (id, node_id) VALUES (3, 5)'].should(include(MODEL_DB.sqls.first))
+    MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))'
+    MODEL_DB.sqls.length.should == 2
+    @c2.new(:id => 321, :xxx=>5).attribute.should == attrib
+    MODEL_DB.sqls.clear
+    attrib = @c1.load(:id=>3)
+    @c2.new(:id => 621, :xxx=>5).attribute = attrib
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 5, id = 3|id = 3, node_id = 5) WHERE \(id = 3\)/
+    MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))'
+  end
+
   it "should raise an error if the one_to_one getter would be the same as the association name" do
     proc{@c2.one_to_many :song, :class => @c1, :one_to_one=>true}.should raise_error(Sequel::Error)
   end
@@ -873,7 +961,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should make non getter and setter methods private if :one_to_one option is used" do 
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true do |ds| end
-    meths = @c2.private_instance_methods(false).collect{|x| x.to_s}
+    meths = @c2.private_instance_methods.collect{|x| x.to_s}
     meths.should(include("attributes"))
     meths.should(include("add_attribute"))
     meths.should(include("attributes_dataset"))
@@ -994,6 +1082,7 @@ describe Sequel::Model, "many_to_many" do
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
       unrestrict_primary_key
+      attr_accessor :yyy
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
       columns :id
@@ -1081,6 +1170,11 @@ describe Sequel::Model, "many_to_many" do
     a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) ORDER BY blah1, blah2'
   end
   
+  it "should support :left_primary_key and :right_primary_key options" do
+    @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
+    @c2.new(:id => 1234, :xxx=>5).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.yyy) AND (attributes_nodes.node_id = 5))'
+  end
+  
   it "should support a select option" do
     @c2.many_to_many :attributes, :class => @c1, :select => :blah
 
@@ -1182,6 +1276,26 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 2345))'
   end
 
+  it "should have the add_ method respect the :left_primary_key and :right_primary_key options" do
+    @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
+    
+    n = @c2.new(:id => 1234, :xxx=>5)
+    a = @c1.new(:id => 2345, :yyy=>8)
+    a.should == n.add_attribute(a)
+    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 8)',
+     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (8, 5)'
+    ].should(include(MODEL_DB.sqls.first))
+  end
+
+  it "should have the remove_ method respect the :left_primary_key and :right_primary_key options" do
+    @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy
+    
+    n = @c2.new(:id => 1234, :xxx=>5)
+    a = @c1.new(:id => 2345, :yyy=>8)
+    a.should == n.remove_attribute(a)
+    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 5) AND (attribute_id = 8))'
+  end
+
   it "should raise an error if the model object doesn't have a valid primary key" do
     @c2.many_to_many :attributes, :class => @c1 
     a = @c2.new
@@ -1300,6 +1414,22 @@ describe Sequel::Model, "many_to_many" do
     im.should_not(include('remove_all_attributes'))
   end
 
+  it "should not add associations methods directly to class" do
+    @c2.many_to_many :attributes, :class => @c1
+    im = @c2.instance_methods.collect{|x| x.to_s}
+    im.should(include('attributes'))
+    im.should(include('attributes_dataset'))
+    im.should(include('add_attribute'))
+    im.should(include('remove_attribute'))
+    im.should(include('remove_all_attributes'))
+    im2 = @c2.instance_methods(false).collect{|x| x.to_s}
+    im2.should_not(include('attributes'))
+    im2.should_not(include('attributes_dataset'))
+    im2.should_not(include('add_attribute'))
+    im2.should_not(include('remove_attribute'))
+    im2.should_not(include('remove_all_attributes'))
+  end
+
   it "should have has_and_belongs_to_many alias" do
     @c2.has_and_belongs_to_many :attributes, :class => @c1 
 
@@ -1315,6 +1445,12 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE (node_id = 1234)'
   end
 
+  it "should have the remove_all_ method respect the :left_primary_key option" do
+    @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx
+    @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
+    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE (node_id = 5)'
+  end
+
   it "remove_all should set the cached instance variable to []" do
     @c2.many_to_many :attributes, :class => @c1
     node = @c2.new(:id => 1234)
@@ -1463,6 +1599,20 @@ describe Sequel::Model, "many_to_many" do
     p.remove_attribute(c).should == nil
     p.attributes.should == [c]
   end
+
+  it "should support a :uniq option that removes duplicates from the association" do
+    h = []
+    @c2.many_to_many :attributes, :class => @c1, :uniq=>true
+    @c1.class_eval do
+      def @dataset.fetch_rows(sql)
+        yield({:id=>20})
+        yield({:id=>30})
+        yield({:id=>20})
+        yield({:id=>30})
+      end
+    end
+    @c2.load(:id=>10, :parent_id=>20).attributes.should == [@c1.load(:id=>20), @c1.load(:id=>30)]
+  end
 end
 
 describe Sequel::Model, " association reflection methods" do
@@ -1514,4 +1664,15 @@ describe Sequel::Model, " association reflection methods" do
     @c1.associate :one_to_many, :children, :class => @c1
     @c1.associations.sort_by{|x|x.to_s}.should == [:children, :parent]
   end
+
+  it "association reflections should be copied upon subclasing" do
+    @c1.associate :many_to_one, :parent, :class => @c1
+    c = Class.new(@c1)
+    @c1.associations.should == [:parent]
+    c.associations.should == [:parent]
+    c.associate :many_to_one, :parent2, :class => @c1
+    @c1.associations.should == [:parent]
+    c.associations.sort_by{|x| x.to_s}.should == [:parent, :parent2]
+    c.instance_methods.map{|x| x.to_s}.should include('parent')
+  end
 end

data/spec/sequel_model/caching_spec.rb

@@ -12,7 +12,8 @@ describe Sequel::Model, "caching" do
     cache = @cache_class.new
     @cache = cache
     
-    @c = Class.new(Sequel::Model(:items)) do
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
       set_cache cache
       def self.name; 'Item' end
       

data/spec/sequel_model/eager_loading_spec.rb

@@ -18,7 +18,7 @@ describe Sequel::Model, "#eager" do
     end
 
     class ::EagerBand < Sequel::Model(:bands)
-      columns :id
+      columns :id, :p_k
       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
@@ -38,7 +38,7 @@ describe Sequel::Model, "#eager" do
     end
     
     class ::EagerGenre < Sequel::Model(:genres)
-      columns :id
+      columns :id, :xxx
       many_to_many :albums, :class=>'EagerAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
     end
     
@@ -418,6 +418,47 @@ describe Sequel::Model, "#eager" do
     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 respect the association's :primary_key option" do
+    EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :primary_key=>:p_k, :key=>:band_id
+    EagerBand.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:p_k=>2, :id=>1})
+      end
+    })
+    as = EagerAlbum.eager(:special_band).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE (bands.p_k IN (2))"]
+    as.length.should == 1
+    as.first.special_band.should == EagerBand.load(:p_k=>2, :id=>1)
+    MODEL_DB.sqls.clear
+    EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>:band_id, :key=>:album_id
+    EagerTrack.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:album_id=>2, :id=>1})
+      end
+    })
+    as = EagerAlbum.eager(:special_tracks).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (2))"]
+    as.length.should == 1
+    as.first.special_tracks.should == [EagerTrack.load(:album_id=>2, :id=>1)]
+  end
+
+  it "should respect many_to_many association's :left_primary_key and :right_primary_key options" do
+    EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_primary_key=>:xxx, :right_key=>:genre_id, :join_table=>:ag
+    EagerGenre.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        MODEL_DB.sqls << sql
+        yield({:x_foreign_key_x=>2, :id=>5})
+        yield({:x_foreign_key_x=>2, :id=>6})
+      end
+    })
+    as = EagerAlbum.eager(:special_genres).all
+    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.xxx) AND (ag.album_id IN (2)))"]
+    as.length.should == 1
+    as.first.special_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+  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
@@ -427,7 +468,7 @@ describe Sequel::Model, "#eager" do
       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| 
+    EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :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)
@@ -455,6 +496,16 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 4
   end
   
+  it "should respect :after_load callbacks on associations when eager loading" do
+    EagerAlbum.many_to_one :al_band, :class=>'EagerBand', :key=>:band_id, :after_load=>proc{|o, a| a.id *=2}
+    EagerAlbum.one_to_many :al_tracks, :class=>'EagerTrack', :key=>:album_id, :after_load=>proc{|o, os| os.each{|a| a.id *=2}}
+    EagerAlbum.many_to_many :al_genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :after_load=>proc{|o, os| os.each{|a| a.id *=2}}
+    a = EagerAlbum.eager(:al_band, :al_tracks, :al_genres).all.first
+    a.should == EagerAlbum.load(:id => 1, :band_id => 2)
+    a.al_band.should == EagerBand.load(:id=>4)
+    a.al_tracks.should == [EagerTrack.load(:id=>6, :album_id=>1)]
+    a.al_genres.should == [EagerGenre.load(:id=>8)]
+  end
 end
 
 describe Sequel::Model, "#eager_graph" do
@@ -902,6 +953,42 @@ describe Sequel::Model, "#eager_graph" do
     a[3].album.band.members.last.values.should == {:id => 6}
   end
 
+  it "should respect the association's :primary_key option" do 
+    GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>:band_id, :primary_key=>:vocalist_id
+    ds = GraphAlbum.eager_graph(:inner_band)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS inner_band ON (inner_band.vocalist_id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :band_id=>2, :inner_band_id=>5, :vocalist_id=>2})
+    end
+    as = ds.all
+    as.should == [GraphAlbum.load(:id=>3, :band_id=>2)]
+    as.first.inner_band.should == GraphBand.load(:id=>5, :vocalist_id=>2)
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :primary_key=>:band_id
+    ds = GraphAlbum.eager_graph(:right_tracks)
+    ds.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.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :band_id=>2, :right_tracks_id=>5, :album_id=>2})
+      yield({:id=>3, :band_id=>2, :right_tracks_id=>6, :album_id=>2})
+    end
+    as = ds.all
+    as.should == [GraphAlbum.load(:id=>3, :band_id=>2)]
+    as.first.right_tracks.should == [GraphTrack.load(:id=>5, :album_id=>2), GraphTrack.load(:id=>6, :album_id=>2)]
+  end
+
+  it "should respect many_to_many association's :left_primary_key and :right_primary_key options" do 
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :left_primary_key=>:band_id, :right_key=>:genre_id, :right_primary_key=>:xxx, :join_table=>:ag
+    ds = GraphAlbum.eager_graph(:inner_genres)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.band_id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.xxx = ag.genre_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12})
+      yield({:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22})
+    end
+    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)]
+  end
+
   it "should respect the association's :graph_select option" do 
     GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>:band_id, :graph_select=>:vocalist_id
     GraphAlbum.eager_graph(:inner_band).sql.should == 'SELECT albums.id, albums.band_id, inner_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS inner_band ON (inner_band.id = albums.band_id)'
@@ -970,6 +1057,17 @@ describe Sequel::Model, "#eager_graph" do
     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 :eager_grapher option" 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 = 't')"
+
+    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.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 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')"
@@ -1026,4 +1124,10 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
     GraphAlbum.eager_graph(:a_genres, :b_tracks).sql.should == 'SELECT albums.id, albums.band_id, a_genres.id AS a_genres_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS a_genres ON (a_genres.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_tracks ON (b_tracks.album_id = albums.id) ORDER BY a_genres.id, b_tracks.id, b_tracks.album_id'
   end
+
+  it "should use the correct qualifier when graphing multiple tables with extra conditions" do
+    GraphAlbum.many_to_many :a_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
+    GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_conditions=>{:a=>:b}
+    GraphAlbum.eager_graph(:a_genres, :b_tracks).sql.should == 'SELECT albums.id, albums.band_id, a_genres.id AS a_genres_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS a_genres ON (a_genres.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_tracks ON ((b_tracks.album_id = albums.id) AND (b_tracks.a = albums.b))'
+  end
 end