sequel 2.2.0 → 2.3.0

data/spec/sequel_core/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel_core'
+end
+
+class MockDataset < Sequel::Dataset
+  def insert(*args)
+    @db.execute insert_sql(*args)
+  end
+  
+  def update(*args)
+    @db.execute update_sql(*args)
+  end
+  
+  def fetch_rows(sql)
+    @db.execute(sql)
+    yield({:id => 1, :x => 1})
+  end
+
+  def quoted_identifier(c)
+    "\"#{c}\""
+  end
+end
+
+class MockDatabase < Sequel::Database
+  @@quote_identifiers = false
+  attr_reader :sqls
+  
+  def execute(sql)
+    @sqls ||= []
+    @sqls << sql
+  end
+
+  def reset
+    @sqls = []
+  end
+
+  def transaction; yield; end
+  
+  def dataset; MockDataset.new(self); end
+end
+
+class SchemaDummyDatabase < Sequel::Database
+  attr_reader :sqls
+  
+  def execute(sql)
+    @sqls ||= []
+    @sqls << sql
+  end
+end

data/spec/{association_reflection_spec.rb → sequel_model/association_reflection_spec.rb}

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), "spec_helper")
 describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
   before do
     @c = Class.new(Sequel::Model)
-    class ParParent < Sequel::Model; end
+    class ::ParParent < Sequel::Model; end
   end
 
   it "should use the :class value if present" do
@@ -21,7 +21,7 @@ end
 describe Sequel::Model::Associations::AssociationReflection, "#associated_primary_key" do
   before do
     @c = Class.new(Sequel::Model)
-    class ParParent < Sequel::Model; end
+    class ::ParParent < Sequel::Model; end
   end
 
   it "should use the :right_primary_key value if present" do
@@ -46,9 +46,9 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
   end
 
   it "should figure out the reciprocal if the :reciprocal value is not present" do
-    class ParParent < Sequel::Model; end
-    class ParParentTwo < Sequel::Model; end
-    class ParParentThree < Sequel::Model; end
+    class ::ParParent < Sequel::Model; end
+    class ::ParParentTwo < Sequel::Model; end
+    class ::ParParentThree < Sequel::Model; end
     ParParent.many_to_one :par_parent_two
     ParParentTwo.one_to_many :par_parents
     ParParent.many_to_many :par_parent_threes
@@ -68,7 +68,7 @@ end
 describe Sequel::Model::Associations::AssociationReflection, "#select" do
   before do
     @c = Class.new(Sequel::Model)
-    class ParParent < Sequel::Model; end
+    class ::ParParent < Sequel::Model; end
   end
 
   it "should use the :select value if present" do

data/spec/{associations_spec.rb → sequel_model/associations_spec.rb}

@@ -4,7 +4,7 @@ describe Sequel::Model, "associate" do
   it "should use explicit class if given a class, symbol, or string" do
     MODEL_DB.reset
     klass = Class.new(Sequel::Model(:nodes))
-    class ParParent < Sequel::Model
+    class ::ParParent < Sequel::Model
     end
     
     klass.associate :many_to_one, :par_parent0, :class=>ParParent
@@ -48,6 +48,7 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.reset
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
+      unrestrict_primary_key
       columns :id, :parent_id, :par_parent_id, :blah
     end
 
@@ -66,7 +67,7 @@ describe Sequel::Model, "many_to_one" do
   end
   
   it "should use implicit class if omitted" do
-    class ParParent < Sequel::Model
+    class ::ParParent < Sequel::Model
     end
     
     @c2.many_to_one :par_parent
@@ -79,7 +80,7 @@ describe Sequel::Model, "many_to_one" do
   end
 
   it "should use class inside module if given as a string" do
-    module Par 
+    module ::Par 
       class Parent < Sequel::Model
       end
     end
@@ -263,10 +264,29 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == []
   end
 
+  it "should get all matching records and only return the first if :key option is set to nil" do
+    c2 = @c2
+    @c2.one_to_many :children, :class => @c2, :key=>:parent_id
+    @c2.many_to_one :first_grand_parent, :class => @c2, :key=>nil, :eager_graph=>:children, :dataset=>proc{c2.filter(:children_id=>parent_id)}
+    ds = @c2.dataset
+    def ds.columns
+      [:id, :parent_id, :par_parent_id, :blah]
+    end
+    def ds.fetch_rows(sql, &block)
+      MODEL_DB.sqls << sql
+      yield({:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4, :children_id=>2, :children_parent_id=>1, :children_par_parent_id=>5, :children_blah=>6})
+    end
+    p = @c2.new(:parent_id=>2)
+    fgp = p.first_grand_parent
+    MODEL_DB.sqls.should == ["SELECT nodes.id, nodes.parent_id, nodes.par_parent_id, nodes.blah, children.id AS children_id, children.parent_id AS children_parent_id, children.par_parent_id AS children_par_parent_id, children.blah AS children_blah FROM nodes LEFT OUTER JOIN nodes AS children ON (children.parent_id = nodes.id) WHERE (children_id = 2)"]
+    fgp.values.should == {:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4}
+    fgp.children.first.values.should == {:id=>2, :parent_id=>1, :par_parent_id=>5, :blah=>6}
+  end
+
   it "should not create the setter method if :read_only option is used" do
     @c2.many_to_one :parent, :class => @c2, :read_only=>true
-    @c2.instance_methods.should(include('parent'))
-    @c2.instance_methods.should_not(include('parent='))
+    @c2.instance_methods.collect{|x| x.to_s}.should(include('parent'))
+    @c2.instance_methods.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
@@ -292,7 +312,7 @@ describe Sequel::Model, "many_to_one" do
 
   it "should make the change to the foreign_key value inside a _association= method" do
     @c2.many_to_one :parent, :class => @c2
-    @c2.private_instance_methods.sort.should(include("_parent="))
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_parent="))
     p = @c2.new
     c = @c2.load(:id=>123)
     def p._parent=(x)
@@ -362,6 +382,11 @@ describe Sequel::Model, "many_to_one" do
     proc{p.parent = nil}.should raise_error(Sequel::Error)
   end
 
+  it "should raise an error if a callback is not a proc or symbol" do
+    @c2.many_to_one :parent, :class => @c2, :before_add=>Object.new
+    proc{@c2.new.parent = @c2.load(:id=>1)}.should raise_error(Sequel::Error)
+  end
+
   it "should call the remove callbacks for the previous object and the add callbacks for the new object" do
     c = @c2.load(:id=>123)
     d = @c2.load(:id=>321)
@@ -398,10 +423,12 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.reset
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
+      unrestrict_primary_key
       columns :id, :node_id
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
+      unrestrict_primary_key
       attr_accessor :xxx
       
       def self.name; 'Node'; end
@@ -435,7 +462,7 @@ describe Sequel::Model, "one_to_many" do
   end
   
   it "should use implicit class if omitted" do
-    class HistoricalValue < Sequel::Model
+    class ::HistoricalValue < Sequel::Model
     end
     
     @c2.one_to_many :historical_values
@@ -448,7 +475,7 @@ describe Sequel::Model, "one_to_many" do
   end
   
   it "should use class inside a module if given as a string" do
-    module Historical
+    module ::Historical
       class Value < Sequel::Model
       end
     end
@@ -692,7 +719,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
     @c2.one_to_many :attributes, :class => @c1, :read_only=>true
-    im = @c2.instance_methods
+    im = @c2.instance_methods.collect{|x| x.to_s}
     im.should(include('attributes'))
     im.should(include('attributes_dataset'))
     im.should_not(include('add_attribute'))
@@ -803,7 +830,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should not add a getter 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
+    im = @c2.instance_methods.collect{|x| x.to_s}
     im.should(include('attribute'))
     im.should_not(include('attribute='))
   end
@@ -846,7 +873,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)
+    meths = @c2.private_instance_methods(false).collect{|x| x.to_s}
     meths.should(include("attributes"))
     meths.should(include("add_attribute"))
     meths.should(include("attributes_dataset"))
@@ -854,7 +881,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should call an _add_ method internally to add attributes" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.sort.should(include("_add_attribute"))
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_add_attribute"))
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._add_attribute(x)
@@ -867,7 +894,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should call a _remove_ method internally to remove attributes" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.sort.should(include("_remove_attribute"))
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_remove_attribute"))
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._remove_attribute(x)
@@ -966,12 +993,14 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.reset
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
+      unrestrict_primary_key
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
       columns :id
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
+      unrestrict_primary_key
       attr_accessor :xxx
       
       def self.name; 'Node'; end
@@ -1000,7 +1029,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should use implicit class if omitted" do
-    class Tag < Sequel::Model
+    class ::Tag < Sequel::Model
     end
     
     @c2.many_to_many :tags
@@ -1012,7 +1041,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should use class inside module if given as a string" do
-    module Historical
+    module ::Historical
       class Tag < Sequel::Model
       end
     end
@@ -1263,7 +1292,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
     @c2.many_to_many :attributes, :class => @c1, :read_only=>true
-    im = @c2.instance_methods
+    im = @c2.instance_methods.collect{|x| x.to_s}
     im.should(include('attributes'))
     im.should(include('attributes_dataset'))
     im.should_not(include('add_attribute'))
@@ -1329,7 +1358,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should call an _add_ method internally to add attributes" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.sort.should(include("_add_attribute"))
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_add_attribute"))
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._add_attribute(x)
@@ -1342,7 +1371,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should call a _remove_ method internally to remove attributes" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.sort.should(include("_remove_attribute"))
+    @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_remove_attribute"))
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._remove_attribute(x)

data/spec/{base_spec.rb → sequel_model/base_spec.rb}

@@ -79,10 +79,11 @@ describe "Model#serialize" do
 
     @c.create(:abc => 1)
     @c.create(:abc => "hello")
+    x = [Marshal.dump("hello")].pack('m')
 
     MODEL_DB.sqls.should == [ \
       "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
-      "INSERT INTO items (abc) VALUES ('BAgiCmhlbGxv\n')", \
+      "INSERT INTO items (abc) VALUES ('#{x}')", \
     ]
   end
 

data/spec/{dataset_methods_spec.rb → sequel_model/dataset_methods_spec.rb}

@@ -56,7 +56,19 @@ describe Sequel::Model::DatasetMethods, "#to_hash"  do
     h.should be_a_kind_of(Hash)
     a = h.to_a
     a.collect{|x| x[1].class}.should == [@c, @c]
-    [[[1, {:name=>1}], [2, {:name=>2}]], [[2, {:name=>2}], [1, {:name=>1}]]].should(include(a.collect{|x| [x[0], x[1].values]}))
+    a.sort_by{|x| x[0]}.collect{|x| [x[0], x[1].values]}.should == [[1, {:name=>1}], [2, {:name=>2}]]
+  end
+
+  it "should result in a hash with given value keys and model object values" do
+    def @d.fetch_rows(sql)
+      yield({:name=>1, :number=>3})
+      yield({:name=>2, :number=>4})
+    end
+    h = @d.to_hash(:number)
+    h.should be_a_kind_of(Hash)
+    a = h.to_a
+    a.collect{|x| x[1].class}.should == [@c, @c]
+    a.sort_by{|x| x[0]}.collect{|x| [x[0], x[1].values]}.should == [[3, {:name=>1, :number=>3}], [4, {:name=>2, :number=>4}]]
   end
 
   it "should raise an error if the class doesn't have a primary key" do

data/spec/{eager_loading_spec.rb → sequel_model/eager_loading_spec.rb}

@@ -4,7 +4,7 @@ describe Sequel::Model, "#eager" do
   before(:each) do
     MODEL_DB.reset
     
-    class EagerAlbum < Sequel::Model(:albums)
+    class ::EagerAlbum < Sequel::Model(:albums)
       columns :id, :band_id
       many_to_one :band, :class=>'EagerBand', :key=>:band_id
       one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id
@@ -17,7 +17,7 @@ describe Sequel::Model, "#eager" do
       many_to_many :genre_names, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :select=>[:id]
     end
 
-    class EagerBand < Sequel::Model(:bands)
+    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
@@ -32,17 +32,17 @@ describe Sequel::Model, "#eager" do
       one_to_many :top_10_albums, :class=>'EagerAlbum', :key=>:band_id, :limit=>10
     end
     
-    class EagerTrack < Sequel::Model(:tracks)
+    class ::EagerTrack < Sequel::Model(:tracks)
       columns :id, :album_id
       many_to_one :album, :class=>'EagerAlbum', :key=>:album_id
     end
     
-    class EagerGenre < Sequel::Model(:genres)
+    class ::EagerGenre < Sequel::Model(:genres)
       columns :id
       many_to_many :albums, :class=>'EagerAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
     end
     
-    class EagerBandMember < Sequel::Model(:members)
+    class ::EagerBandMember < Sequel::Model(:members)
       columns :id
       many_to_many :bands, :class=>'EagerBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm, :order =>:id
     end
@@ -106,6 +106,10 @@ describe Sequel::Model, "#eager" do
     })
   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
+
   it "should eagerly load a single many_to_one association" do
     a = EagerAlbum.eager(:band).all
     a.should be_a_kind_of(Array)
@@ -149,7 +153,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   end
   
-  it "should eagerly load multiple associations" do
+  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)
     a.size.should == 1
@@ -174,6 +178,31 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 4
   end
   
+  it "should eagerly load multiple associations in separate calls" do
+    a = EagerAlbum.eager(:genres).eager(:tracks).eager(: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 (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)
+    a.band.values.should == {:id => 2}
+    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}
+    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 == 4
+  end
+  
   it "should allow cascading of eager loading for associations of associated models" do
     a = EagerTrack.eager(:album=>{:band=>:members}).all
     a.should be_a_kind_of(Array)
@@ -430,13 +459,13 @@ end
 
 describe Sequel::Model, "#eager_graph" do
   after(:all) do
-    class MockDataset
+    class ::MockDataset
       alias clone orig_clone
     end
   end
 
   before(:all) do
-    class MockDataset
+    class ::MockDataset
       alias orig_clone clone
       def clone(opts = {})
         c = super()
@@ -446,15 +475,16 @@ describe Sequel::Model, "#eager_graph" do
       end
     end
 
-    class GraphAlbum < Sequel::Model(:albums)
+    class ::GraphAlbum < Sequel::Model(:albums)
       dataset.opts[:from] = [:albums]
       columns :id, :band_id
       many_to_one :band, :class=>'GraphBand', :key=>:band_id
       one_to_many :tracks, :class=>'GraphTrack', :key=>:album_id
       many_to_many :genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
+      many_to_one :previous_album, :class=>'GraphAlbum'
     end
 
-    class GraphBand < Sequel::Model(:bands)
+    class ::GraphBand < Sequel::Model(:bands)
       dataset.opts[:from] = [:bands]
       columns :id, :vocalist_id
       many_to_one :vocalist, :class=>'GraphBandMember', :key=>:vocalist_id
@@ -463,25 +493,29 @@ describe Sequel::Model, "#eager_graph" do
       many_to_many :genres, :class=>'GraphGenre', :left_key=>:band_id, :right_key=>:genre_id, :join_table=>:bg
     end
     
-    class GraphTrack < Sequel::Model(:tracks)
+    class ::GraphTrack < Sequel::Model(:tracks)
       dataset.opts[:from] = [:tracks]
       columns :id, :album_id
       many_to_one :album, :class=>'GraphAlbum', :key=>:album_id
     end
     
-    class GraphGenre < Sequel::Model(:genres)
+    class ::GraphGenre < Sequel::Model(:genres)
       dataset.opts[:from] = [:genres]
       columns :id
       many_to_many :albums, :class=>'GraphAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
     end
     
-    class GraphBandMember < Sequel::Model(:members)
+    class ::GraphBandMember < Sequel::Model(:members)
       dataset.opts[:from] = [:members]
       columns :id
       many_to_many :bands, :class=>'GraphBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm
     end
   end
     
+  it "should raise an error if called without a symbol or hash" do
+    proc{GraphAlbum.eager_graph(Object.new)}.should raise_error(Sequel::Error)
+  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)'
@@ -534,7 +568,7 @@ describe Sequel::Model, "#eager_graph" do
     a.genres.first.values.should == {:id => 4}
   end
 
-  it "should eagerly load multiple associations" do 
+  it "should eagerly load multiple associations in a single call" do 
     ds = GraphAlbum.eager_graph(:genres, :tracks, :band)
     ds.sql.should == 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
     def ds.fetch_rows(sql, &block)
@@ -558,6 +592,30 @@ describe Sequel::Model, "#eager_graph" do
     a.genres.first.values.should == {:id => 4}
   end
 
+  it "should eagerly load multiple associations in separate calls" do 
+    ds = GraphAlbum.eager_graph(:genres).eager_graph(:tracks).eager_graph(:band)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :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(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, :vocalist_id=>6}
+    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 == {:id => 3, :album_id=>1}
+    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 for associations of associated models" do
     ds = GraphTrack.eager_graph(:album=>{: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 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)'
@@ -900,4 +958,7 @@ 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 (active) LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"
   end
 
+  it "should create unique table aliases for all associations" do
+    GraphAlbum.eager_graph(:previous_album=>{:previous_album=>:previous_album}).sql.should == "SELECT albums.id, albums.band_id, previous_album.id AS previous_album_id, previous_album.band_id AS previous_album_band_id, previous_album_0.id AS previous_album_0_id, previous_album_0.band_id AS previous_album_0_band_id, previous_album_1.id AS previous_album_1_id, previous_album_1.band_id AS previous_album_1_band_id FROM albums LEFT OUTER JOIN albums AS previous_album ON (previous_album.id = albums.previous_album_id) LEFT OUTER JOIN albums AS previous_album_0 ON (previous_album_0.id = previous_album.previous_album_id) LEFT OUTER JOIN albums AS previous_album_1 ON (previous_album_1.id = previous_album_0.previous_album_id)"
+  end
 end