sequel 2.0.1 → 2.1.0

data/spec/base_spec.rb

@@ -182,7 +182,7 @@ describe Sequel::Model, "dataset" do
   end
 end
 
-describe Sequel::Model, "def_dataset_method" do
+describe Sequel::Model, ".def_dataset_method" do
   setup do
     @c = Class.new(Sequel::Model(:items)) do
       @dataset = Object.new
@@ -210,6 +210,25 @@ describe Sequel::Model, "def_dataset_method" do
     @c.return_3.should == 3
     @c.return_4.should == 4
   end
+
+  it "should cache calls and readd methods if set_dataset is used" do
+    @c.instance_eval do
+      def_dataset_method(:return_3){3}
+    end
+    @c.set_dataset :items
+    @c.return_3.should == 3
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
+    @c.instance_eval do
+      def_dataset_method(:return_3){3}
+    end
+    c = Class.new(@c)
+    c.set_dataset :items
+    c.return_3.should == 3
+    c.dataset.return_3.should == 3
+  end
 end
 
 describe "A model class with implicit table name" do
@@ -256,3 +275,144 @@ describe "Model.db=" do
   end
 end
 
+describe Sequel::Model, ".(allowed|restricted)_columns " do
+  setup do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      columns :x, :y, :z
+      def refresh
+        self
+      end
+    end
+    @c.strict_param_setting = false
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+  end
+  
+  it "should set the allowed columns correctly" do
+    @c.allowed_columns.should == nil
+    @c.set_allowed_columns :x
+    @c.allowed_columns.should == [:x]
+    @c.set_allowed_columns :x, :y
+    @c.allowed_columns.should == [:x, :y]
+  end
+
+  it "should set the restricted columns correctly" do
+    @c.restricted_columns.should == nil
+    @c.set_restricted_columns :x
+    @c.restricted_columns.should == [:x]
+    @c.set_restricted_columns :x, :y
+    @c.restricted_columns.should == [:x, :y]
+  end
+
+  it "should only set allowed columns by default" do
+    @c.set_allowed_columns :x, :y
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.should == {:x => 4, :y => 5}
+    i.update(:x => 7, :y => 8, :z => 9)
+    i.values.delete(:id) # stupid specs
+    i.values.should == {:x => 7, :y => 8}
+  end
+
+  it "should not set restricted columns by default" do
+    @c.set_restricted_columns :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.should == {:x => 4, :y => 5}
+    i.update(:x => 7, :y => 8, :z => 9)
+    i.values.delete(:id) # stupid specs
+    i.values.should == {:x => 7, :y => 8}
+  end
+
+  it "should have allowed take precedence over restricted" do
+    @c.set_allowed_columns :x, :y
+    @c.set_restricted_columns :y, :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.should == {:x => 4, :y => 5}
+    i.update(:x => 7, :y => 8, :z => 9)
+    i.values.delete(:id) # stupid specs
+    i.values.should == {:x => 7, :y => 8}
+  end
+end
+
+describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
+  setup do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      set_primary_key :id
+      columns :x, :y, :z, :id
+      def refresh
+        self
+      end
+    end
+    @c.strict_param_setting = false
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+  end
+  
+  it "should restrict updates to primary key by default" do
+    i = @c.new(:x => 1, :y => 2, :id => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :id => 6)
+    i.values.should == {:x => 4, :y => 5}
+  end
+
+  it "should allow updates to primary key if unrestrict_primary_key is used" do
+    @c.unrestrict_primary_key
+    i = @c.new(:x => 1, :y => 2, :id => 3)
+    i.values.should == {:x => 1, :y => 2, :id=>3}
+    i.set(:x => 4, :y => 5, :id => 6)
+    i.values.should == {:x => 4, :y => 5, :id=>6}
+  end
+
+  it "should have restrict_primary_key? return true or false depending" do
+    @c.restrict_primary_key?.should == true
+    @c.unrestrict_primary_key
+    @c.restrict_primary_key?.should == false
+    c1 = Class.new(@c)
+    c1.restrict_primary_key?.should == false
+    @c.restrict_primary_key
+    @c.restrict_primary_key?.should == true
+    c1.restrict_primary_key?.should == false
+    c2 = Class.new(@c)
+    c2.restrict_primary_key?.should == true
+  end
+end
+
+describe Sequel::Model, ".strict_param_setting" do
+  setup do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      columns :x, :y, :z, :id
+      set_restricted_columns :z
+      def refresh
+        self
+      end
+    end
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+  end
+  
+  it "should be enabled by default" do
+    @c.strict_param_setting.should == true
+  end
+
+  it "should raise an error if a missing/restricted column/method is accessed" do
+    proc{@c.new(:z=>1)}.should raise_error(Sequel::Error)
+    proc{@c.create(:z=>1)}.should raise_error(Sequel::Error)
+    c = @c.new
+    proc{c.set(:z=>1)}.should raise_error(Sequel::Error)
+    proc{c.set_all(:id=>1)}.should raise_error(Sequel::Error)
+    proc{c.set_only({:x=>1}, :y)}.should raise_error(Sequel::Error)
+    proc{c.set_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
+    proc{c.update(:z=>1)}.should raise_error(Sequel::Error)
+    proc{c.update_all(:id=>1)}.should raise_error(Sequel::Error)
+    proc{c.update_only({:x=>1}, :y)}.should raise_error(Sequel::Error)
+    proc{c.update_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
+  end
+
+  it "should be disabled by strict_param_setting = false" do
+    @c.strict_param_setting = false
+    @c.strict_param_setting.should == false
+    proc{@c.new(:z=>1)}.should_not raise_error
+  end
+end

data/spec/dataset_methods_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model::DatasetMethods, "#destroy"  do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      @@destroyed = []
+      def destroy
+        @@destroyed << self
+      end
+      def self.destroyed
+        @@destroyed
+      end
+    end
+    @d = @c.dataset
+  end
+
+  it "should instantiate objects in the dataset and call destroy on each" do
+    def @d.fetch_rows(sql)
+      yield({:id=>1})
+      yield({:id=>2})
+    end
+    @d.destroy
+    @c.destroyed.collect{|x| x.values}.should == [{:id=>1}, {:id=>2}]
+  end
+
+  it "should return the number of records destroyed" do
+    def @d.fetch_rows(sql)
+      yield({:id=>1})
+      yield({:id=>2})
+    end
+    @d.destroy.should == 2
+    def @d.fetch_rows(sql)
+      yield({:id=>1})
+    end
+    @d.destroy.should == 1
+    def @d.fetch_rows(sql)
+    end
+    @d.destroy.should == 0
+  end
+end
+
+describe Sequel::Model::DatasetMethods, "#to_hash"  do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      set_primary_key :name
+    end
+    @d = @c.dataset
+  end
+
+  it "should result in a hash with primary key value keys and model object values" do
+    def @d.fetch_rows(sql)
+      yield({:name=>1})
+      yield({:name=>2})
+    end
+    h = @d.to_hash
+    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]}))
+  end
+
+  it "should raise an error if the class doesn't have a primary key" do
+    @c.no_primary_key
+    proc{@d.to_hash}.should raise_error(Sequel::Error)
+  end
+end

data/spec/eager_loading_spec.rb

@@ -277,7 +277,7 @@ describe Sequel::Model, "#eager" do
     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))']
     a = a.first
-    a.instance_variable_get(:@band).should == :null
+    a.associations.fetch(:band, 2).should == nil
     a.band.should == nil
     MODEL_DB.sqls.length.should == 2
   end
@@ -290,10 +290,10 @@ describe Sequel::Model, "#eager" do
     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))"]
-    a.first.instance_variable_get(:@albums).should be_a_kind_of(Array)
+    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)
-    a.last.instance_variable_get(:@albums).should == []
+    a.last.associations[:albums].should == []
     a.last.albums.should == []
     MODEL_DB.sqls.length.should == 3
   end
@@ -384,7 +384,7 @@ describe Sequel::Model, "#eager_graph" do
     
   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 band ON (band.id = albums.band_id)'
+    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)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3})
     end
@@ -436,7 +436,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should eagerly load multiple associations" 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 band ON (band.id = albums.band_id)'
+    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
@@ -460,7 +460,7 @@ describe Sequel::Model, "#eager_graph" do
 
   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 album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands 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)'
+    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)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6})
     end
@@ -505,7 +505,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should eager load multiple associations from the same table" do
     ds = GraphBand.eager_graph(:vocalist, :members)
-    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, vocalist.id AS vocalist_id_0, members.id AS members_id FROM bands LEFT OUTER JOIN members vocalist ON (vocalist.id = bands.vocalist_id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, vocalist.id AS vocalist_id_0, members.id AS members_id FROM bands LEFT OUTER JOIN members AS vocalist ON (vocalist.id = bands.vocalist_id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>2, :vocalist_id=>6, :vocalist_id_0=>6, :members_id=>5})
     end
@@ -525,16 +525,16 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should give you a graph of tables when called without .all" 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 band ON (band.id = albums.band_id)'
+    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)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3})
     end
-    ds.first.should == {:albums=>GraphAlbum.new(:id => 1, :band_id => 2), :band=>GraphBand.new(:id => 2, :vocalist_id=>3)}
+    ds.first.should == {:albums=>GraphAlbum.load(:id => 1, :band_id => 2), :band=>GraphBand.load(:id => 2, :vocalist_id=>3)}
   end
 
   it "should not drop any associated objects if the graph could not be a cartesian product" do
     ds = GraphBand.eager_graph(:members, :vocalist)
-    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, vocalist.id AS vocalist_id_0 FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members vocalist ON (vocalist.id = bands.vocalist_id)'
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, vocalist.id AS vocalist_id_0 FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members AS vocalist ON (vocalist.id = bands.vocalist_id)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6})
       yield({:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6})
@@ -615,7 +615,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should handle no associated records for 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 band ON (band.id = albums.band_id)'
+    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)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>1, :band_id=>2, :band_id_0=>nil, :vocalist_id=>nil})
     end
@@ -624,7 +624,7 @@ describe Sequel::Model, "#eager_graph" do
     a.size.should == 1
     a.first.should be_a_kind_of(GraphAlbum)
     a.first.values.should == {:id => 1, :band_id => 2}
-    a.first.instance_variable_get(:@band).should == :null
+    a.first.associations.fetch(:band, 2).should == nil
   end
 
   it "should handle no associated records for a single one_to_many association" do
@@ -657,7 +657,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should handle missing associated records when loading multiple associations" 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 band ON (band.id = albums.band_id)'
+    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=>nil, :tracks_id=>3, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil})
       yield({:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>4, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil})
@@ -674,13 +674,13 @@ describe Sequel::Model, "#eager_graph" do
     a.tracks.size.should == 4
     a.tracks.first.should be_a_kind_of(GraphTrack)
     a.tracks.collect{|x|x[:id]}.should == [3,4,5,6]
-    a.instance_variable_get(:@band).should == :null
+    a.associations.fetch(:band, 2).should == nil
     a.genres.should == []
   end
 
   it "should handle missing associated records when cascading 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 album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands 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)'
+    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)'
     def ds.fetch_rows(sql, &block)
       yield({:id=>2, :album_id=>2, :album_id_0=>nil, :band_id=>nil, :members_id=>nil, :band_id_0=>nil, :vocalist_id=>nil})
       yield({:id=>3, :album_id=>3, :album_id_0=>3, :band_id=>3, :members_id=>nil, :band_id_0=>nil, :vocalist_id=>nil})
@@ -693,10 +693,10 @@ describe Sequel::Model, "#eager_graph" do
     a.size.should == 4
     a.first.should be_a_kind_of(GraphTrack)
     a.collect{|x|x[:id]}.should == [2,3,4,5]
-    a[0].instance_variable_get(:@album).should == :null
+    a[0].associations.fetch(:album, 2).should == nil
     a[1].album.should be_a_kind_of(GraphAlbum)
     a[1].album.values.should == {:id => 3, :band_id => 3}
-    a[1].album.instance_variable_get(:@band).should == :null
+    a[1].album.associations.fetch(:band, 2).should == nil
     a[2].album.should be_a_kind_of(GraphAlbum)
     a[2].album.values.should == {:id => 4, :band_id => 2}
     a[2].album.band.should be_a_kind_of(GraphBand)
@@ -713,33 +713,44 @@ describe Sequel::Model, "#eager_graph" do
     a[3].album.band.members.last.values.should == {: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)'
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_select=>[:album_id]
+    GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id)'
+
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_select=>[]
+    GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER 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_one :inner_band, :class=>'GraphBand', :key=>:band_id, :graph_join_type=>:inner
-    GraphAlbum.eager_graph(:inner_band).sql.should == 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums INNER JOIN bands inner_band ON (inner_band.id = albums.band_id)'
+    GraphAlbum.eager_graph(:inner_band).sql.should == 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums INNER JOIN bands AS inner_band ON (inner_band.id = albums.band_id)'
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_join_type=>:right_outer
-    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 RIGHT OUTER JOIN tracks right_tracks ON (right_tracks.album_id = albums.id)'
+    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 RIGHT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id)'
 
     GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_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) INNER JOIN genres inner_genres ON (inner_genres.id = ag.genre_id)'
+    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_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 active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+    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.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 active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.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 active_band ON ((active_band.id = albums.band_id) AND ((active_band.id >= 0) AND (active_band.id <= 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 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_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.album_id = albums.id) AND (ag.active = 't')) LEFT OUTER JOIN genres active_genres ON (active_genres.id = ag.genre_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) 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_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 active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.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
 end

data/spec/model_spec.rb

@@ -25,7 +25,6 @@ describe Sequel::Model do
 end
 
 describe Sequel::Model, "dataset & schema" do
-
   before do
     @model = Class.new(Sequel::Model(:items))
   end
@@ -80,9 +79,57 @@ describe Sequel::Model, "dataset & schema" do
     @model.primary_key.should == :id
     @model.table_name.should == :foo
   end
+end
 
-  it "puts the lotion in the basket or it gets the hose again" do
-    # just kidding!
+describe Sequel::Model, "#sti_key" do
+  before do
+    class StiTest < Sequel::Model
+      def kind=(x); self[:kind] = x; end
+      def refresh; end
+      set_sti_key :kind
+    end
+    class StiTestSub1 < StiTest
+    end
+    class StiTestSub2 < StiTest
+    end
+    @ds = StiTest.dataset
+    MODEL_DB.reset
+  end
+  
+  it "should return rows with the correct class based on the polymorphic_key value" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTest'})
+      yield({:kind=>'StiTestSub1'})
+      yield({:kind=>'StiTestSub2'})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
+  end
+
+  it "should fallback to the main class if polymophic_key value is NULL" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>nil})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest]
+  end
+  
+  it "should fallback to the main class if the given class does not exist" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTestSub3'})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest]
+  end
+  
+  it "should add a before_create hook that sets the model class name for the key" do
+    StiTest.new.save
+    StiTestSub1.new.save
+    StiTestSub2.new.save
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
+  end
+  
+  it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
+    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub2')"
   end
 end
 
@@ -152,8 +199,7 @@ describe Sequel::Model, "new" do
 end
 
 describe Sequel::Model, ".subset" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items))
@@ -172,7 +218,6 @@ describe Sequel::Model, ".subset" do
     @c.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     
-    # check if subsets are composable
     @c.pricey.new_only.sql.should == "SELECT * FROM items WHERE ((price > 100) AND (age = 'new'))"
     @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE ((age = 'new') AND (price > 100))"
   end