sequel 3.47.0 → 3.48.0

data/spec/model/base_spec.rb

@@ -462,7 +462,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     @c.allowed_columns.should == [:x, :y]
   end
 
-  it "should set the restricted columns correctly" do
+  qspecify "should set the restricted columns correctly" do
     @c.restricted_columns.should == nil
     @c.set_restricted_columns :x
     @c.restricted_columns.should == [:x]
@@ -484,7 +484,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
-  it "should not set restricted columns by default" do
+  qspecify "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}
@@ -498,7 +498,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
-  it "should have allowed take precedence over restricted" do
+  qspecify "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)
@@ -556,7 +556,7 @@ describe Sequel::Model, ".strict_param_setting" do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z, :id
-      set_restricted_columns :z
+      set_allowed_columns :x, :y
     end
   end
   
@@ -571,10 +571,14 @@ describe Sequel::Model, ".strict_param_setting" do
     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)
+  end
+
+  qspecify "should raise an error if a missing/restricted column/method is accessed by *_except" do
+    c = @c.new
+    proc{c.set_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
     proc{c.update_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
   end
 
@@ -631,8 +635,6 @@ describe Sequel::Model, ".[] optimization" do
   it "should have simple_pk be blank if compound or no primary key" do
     @c.no_primary_key
     @c.simple_pk.should == nil
-    @c.set_primary_key :b, :a
-    @c.simple_pk.should == nil
     @c.set_primary_key [:b, :a]
     @c.simple_pk.should == nil
   end
@@ -701,6 +703,13 @@ describe "Model datasets #with_pk with #with_pk!" do
     MODEL_DB.reset
   end
 
+  it "should be callable on the model class with optimized SQL" do
+    @c.with_pk(1).should == @c.load(:id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+    @c.with_pk!(1).should == @c.load(:id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+  end
+
   it "should return the first record where the primary key matches" do
     @ds.with_pk(1).should == @c.load(:id=>1)
     MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
@@ -723,7 +732,7 @@ describe "Model datasets #with_pk with #with_pk!" do
   end
 
   it "should handle an array for composite primary keys" do
-    @c.set_primary_key :id1, :id2
+    @c.set_primary_key [:id1, :id2]
     @ds.with_pk([1, 2])
     sqls = MODEL_DB.sqls
     ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
@@ -745,6 +754,14 @@ describe "Model datasets #with_pk with #with_pk!" do
     MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
+  it "should have with_pk return nil and with_pk! raise if no rows match when calling the class method" do
+    @ds._fetch = []
+    @c.with_pk(1).should == nil
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+    proc{@c.with_pk!(1)}.should raise_error(Sequel::NoMatchingRow)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+  end
+
   it "should have #[] consider an integer as a primary key lookup" do
     @ds[1].should == @c.load(:id=>1)
     MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]

data/spec/model/class_dataset_methods_spec.rb

@@ -0,0 +1,143 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Model, "class dataset methods"  do
+  before do
+    @db = Sequel.mock
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @d = @c.dataset
+    @d._fetch = {:id=>1}
+    @d.autoid = 1
+    @d.numrows = 0
+    @db.sqls
+  end
+
+  it "should call the dataset method of the same name with the same args" do
+    @c.<<({}).should == @d
+    @db.sqls.should == ["INSERT INTO items DEFAULT VALUES"]
+    @c.all.should == [@c.load(:id=>1)]
+    @db.sqls.should == ["SELECT * FROM items"]
+    @c.avg(:id).should == 1
+    @db.sqls.should == ["SELECT avg(id) AS avg FROM items LIMIT 1"]
+    @c.count.should == 1
+    @db.sqls.should == ["SELECT count(*) AS count FROM items LIMIT 1"]
+    @c.cross_join(@c).sql.should == "SELECT * FROM items CROSS JOIN items"
+    @c.distinct.sql.should == "SELECT DISTINCT * FROM items"
+    @c.each{|r| r.should == @c.load(:id=>1)}.should == @d
+    @db.sqls.should == ["SELECT * FROM items"]
+    @c.each_server{|r| r.opts[:server].should == :default}
+    @c.empty?.should be_false
+    @db.sqls.should == ["SELECT 1 AS one FROM items LIMIT 1"]
+    @c.except(@d, :from_self=>false).sql.should == "SELECT * FROM items EXCEPT SELECT * FROM items"
+    @c.exclude(:a).sql.should == "SELECT * FROM items WHERE NOT a"
+    @c.exclude_having(:a).sql.should == "SELECT * FROM items HAVING NOT a"
+    @c.exclude_where(:a).sql.should == "SELECT * FROM items WHERE NOT a"
+    @c.fetch_rows("S"){|r| r.should == {:id=>1}}
+    @db.sqls.should == ["S"]
+    @c.filter(:a).sql.should == "SELECT * FROM items WHERE a"
+    @c.first.should == @c.load(:id=>1)
+    @db.sqls.should == ["SELECT * FROM items LIMIT 1"]
+    @c.first!.should == @c.load(:id=>1)
+    @db.sqls.should == ["SELECT * FROM items LIMIT 1"]
+    @c.for_update.sql.should == "SELECT * FROM items FOR UPDATE"
+    @c.from.sql.should == "SELECT *"
+    @c.from_self.sql.should == "SELECT * FROM (SELECT * FROM items) AS t1"
+    @c.full_join(@c).sql.should == "SELECT * FROM items FULL JOIN items"
+    @c.full_outer_join(@c).sql.should == "SELECT * FROM items FULL OUTER JOIN items"
+    @c.get(:a).should == 1
+    @db.sqls.should == ["SELECT a FROM items LIMIT 1"]
+    @c.graph(@c, nil, :table_alias=>:a).sql.should == "SELECT * FROM items LEFT OUTER JOIN items AS a"
+    @db.sqls
+    @c.grep(:id, 'a%').sql.should == "SELECT * FROM items WHERE ((id LIKE 'a%' ESCAPE '\\'))"
+    @c.group(:a).sql.should == "SELECT * FROM items GROUP BY a"
+    @c.group_and_count(:a).sql.should == "SELECT a, count(*) AS count FROM items GROUP BY a"
+    @c.group_by(:a).sql.should == "SELECT * FROM items GROUP BY a"
+    @c.having(:a).sql.should == "SELECT * FROM items HAVING a"
+    @c.import([:id], [[1]])
+    @db.sqls.should == ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
+    @c.inner_join(@c).sql.should == "SELECT * FROM items INNER JOIN items"
+    @c.insert.should == 2
+    @db.sqls.should == ["INSERT INTO items DEFAULT VALUES"]
+    @c.intersect(@d, :from_self=>false).sql.should == "SELECT * FROM items INTERSECT SELECT * FROM items"
+    @c.interval(:id).should == 1
+    @db.sqls.should == ["SELECT (max(id) - min(id)) AS interval FROM items LIMIT 1"]
+    @c.join(@c).sql.should == "SELECT * FROM items INNER JOIN items"
+    @c.join_table(:inner, @c).sql.should == "SELECT * FROM items INNER JOIN items"
+    @c.last.should == @c.load(:id=>1)
+    @db.sqls.should == ["SELECT * FROM items ORDER BY id DESC LIMIT 1"]
+    @c.left_join(@c).sql.should == "SELECT * FROM items LEFT JOIN items"
+    @c.left_outer_join(@c).sql.should == "SELECT * FROM items LEFT OUTER JOIN items"
+    @c.limit(2).sql.should == "SELECT * FROM items LIMIT 2"
+    @c.lock_style(:update).sql.should == "SELECT * FROM items FOR UPDATE"
+    @c.map(:id).should == [1]
+    @db.sqls.should == ["SELECT * FROM items"]
+    @c.max(:id).should == 1
+    @db.sqls.should == ["SELECT max(id) AS max FROM items LIMIT 1"]
+    @c.min(:id).should == 1
+    @db.sqls.should == ["SELECT min(id) AS min FROM items LIMIT 1"]
+    @c.multi_insert([{:id=>1}])
+    @db.sqls.should == ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
+    @c.naked.row_proc.should == nil
+    @c.natural_full_join(@c).sql.should == "SELECT * FROM items NATURAL FULL JOIN items"
+    @c.natural_join(@c).sql.should == "SELECT * FROM items NATURAL JOIN items"
+    @c.natural_left_join(@c).sql.should == "SELECT * FROM items NATURAL LEFT JOIN items"
+    @c.natural_right_join(@c).sql.should == "SELECT * FROM items NATURAL RIGHT JOIN items"
+    @c.order(:a).sql.should == "SELECT * FROM items ORDER BY a"
+    @c.order_append(:a).sql.should == "SELECT * FROM items ORDER BY a"
+    @c.order_by(:a).sql.should == "SELECT * FROM items ORDER BY a"
+    @c.order_more(:a).sql.should == "SELECT * FROM items ORDER BY a"
+    @c.order_prepend(:a).sql.should == "SELECT * FROM items ORDER BY a"
+    @c.paged_each{|r| r.should == @c.load(:id=>1)}
+    @db.sqls.should == ["BEGIN", "SELECT * FROM items ORDER BY id LIMIT 1000 OFFSET 0", "COMMIT"]
+    @c.qualify.sql.should == 'SELECT items.* FROM items'
+    @c.right_join(@c).sql.should == "SELECT * FROM items RIGHT JOIN items"
+    @c.right_outer_join(@c).sql.should == "SELECT * FROM items RIGHT OUTER JOIN items"
+    @c.select(:a).sql.should == "SELECT a FROM items"
+    @c.select_all(:items).sql.should == "SELECT items.* FROM items"
+    @c.select_append(:a).sql.should == "SELECT *, a FROM items"
+    @c.select_group(:a).sql.should == "SELECT a FROM items GROUP BY a"
+    @c.select_hash(:id, :id).should == {1=>1}
+    @db.sqls.should == ["SELECT id, id FROM items"]
+    @c.select_hash_groups(:id, :id).should == {1=>[1]}
+    @db.sqls.should == ["SELECT id, id FROM items"]
+    @c.select_map(:id).should == [1]
+    @db.sqls.should == ["SELECT id FROM items"]
+    @c.select_order_map(:id).should == [1]
+    @db.sqls.should == ["SELECT id FROM items ORDER BY id"]
+    @c.server(:a).opts[:server].should == :a
+    @c.set_graph_aliases(:a=>:b).opts[:graph_aliases].should == {:a=>[:b, :a]}
+    @c.single_record.should == @c.load(:id=>1)
+    @db.sqls.should == ["SELECT * FROM items LIMIT 1"]
+    @c.single_value.should == 1
+    @db.sqls.should == ["SELECT * FROM items LIMIT 1"]
+    @c.sum(:id).should == 1
+    @db.sqls.should == ["SELECT sum(id) AS sum FROM items LIMIT 1"]
+    @c.to_hash(:id, :id).should == {1=>1}
+    @db.sqls.should == ["SELECT * FROM items"]
+    @c.to_hash_groups(:id, :id).should == {1=>[1]}
+    @db.sqls.should == ["SELECT * FROM items"]
+    @c.truncate
+    @db.sqls.should == ["TRUNCATE TABLE items"]
+    @c.union(@d, :from_self=>false).sql.should == "SELECT * FROM items UNION SELECT * FROM items"
+    @c.where(:a).sql.should == "SELECT * FROM items WHERE a"
+    @c.with(:a, @d).sql.should == "WITH a AS (SELECT * FROM items) SELECT * FROM items"
+    @c.with_recursive(:a, @d, @d).sql.should == "WITH a AS (SELECT * FROM items UNION ALL SELECT * FROM items) SELECT * FROM items"
+    @c.with_sql('S').sql.should == "S"
+
+    sc = Class.new(@c)
+    sc.set_dataset(@d.where(:a).order(:a).select(:a).group(:a).limit(2))
+    @db.sqls
+    sc.invert.sql.should == 'SELECT a FROM items WHERE NOT a GROUP BY a ORDER BY a LIMIT 2'
+    sc.dataset._fetch = {:v1=>1, :v2=>2}
+    sc.range(:a).should == (1..2)
+    @db.sqls.should == ["SELECT min(a) AS v1, max(a) AS v2 FROM (SELECT a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2) AS t1 LIMIT 1"]
+    sc.reverse.sql.should == 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
+    sc.reverse_order.sql.should == 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
+    sc.select_more(:a).sql.should == 'SELECT a, a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2'
+    sc.unfiltered.sql.should == 'SELECT a FROM items GROUP BY a ORDER BY a LIMIT 2'
+    sc.ungrouped.sql.should == 'SELECT a FROM items WHERE a ORDER BY a LIMIT 2'
+    sc.unordered.sql.should == 'SELECT a FROM items WHERE a GROUP BY a LIMIT 2'
+    sc.unlimited.sql.should == 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a'
+    sc.dataset.graph!(:a)
+    sc.dataset.ungraphed.opts[:graph].should == nil
+  end
+end

data/spec/model/dataset_methods_spec.rb

@@ -92,7 +92,7 @@ describe Sequel::Model::DatasetMethods  do
   end
 
   specify "#insert_sql should handle a single model instance as an argument" do
-    @c.insert_sql(@c.load(:id=>1)).should == 'INSERT INTO items (id) VALUES (1)'
+    @c.dataset.insert_sql(@c.load(:id=>1)).should == 'INSERT INTO items (id) VALUES (1)'
   end
 
   specify "#first should handle no primary key" do

data/spec/model/eager_loading_spec.rb

@@ -7,7 +7,7 @@ describe Sequel::Model, "#eager" do
       many_to_one :band, :class=>'EagerBand', :key=>:band_id
       one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id
       many_to_many :genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
-      one_to_many :good_tracks, :class=>'EagerTrack', :key=>:album_id do |ds|
+      one_to_many :good_tracks, :class=>'EagerTrack', :reciprocal=>nil, :key=>:album_id do |ds|
         ds.filter(:name=>'Good')
       end
       many_to_one :band_name, :class=>'EagerBand', :key=>:band_id, :select=>[:id, :name]
@@ -21,11 +21,11 @@ describe Sequel::Model, "#eager" do
 
     class ::EagerBand < Sequel::Model(:bands)
       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
+      one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks, :reciprocal=>:band
+      one_to_many :graph_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_graph=>:tracks, :reciprocal=>nil
       many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
       many_to_many :graph_members, :clone=>:members, :eager_graph=>:bands
-      one_to_many :good_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_block=>proc{|ds| ds.filter(:name=>'good')} do |ds|
+      one_to_many :good_albums, :class=>'EagerAlbum', :key=>:band_id, :reciprocal=>nil, :eager_block=>proc{|ds| ds.filter(:name=>'good')} do |ds|
         ds.filter(:name=>'Good')
       end
       one_to_many :self_titled_albums, :class=>'EagerAlbum', :key=>:band_id, :allow_eager=>false do |ds|
@@ -169,7 +169,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
-  it "should eagerly load a single one_to_one association using the :correlated_subquery strategy" do
+  qspecify "should eagerly load a single one_to_one association using the :correlated_subquery strategy" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -178,7 +178,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
-  it "should handle qualified order clauses when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
+  qspecify "should handle qualified order clauses when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>[:tracks__name, Sequel.desc(:tracks__name), Sequel.qualify(:tracks, :name), Sequel.qualify(:t, :name), 1]
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -187,7 +187,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
-  it "should handle qualified composite keys when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
+  qspecify "should handle qualified composite keys when eagerly loading a single one_to_one association using the :correlated_subquery strategy" do
     c1 = Class.new(EagerAlbum)
     c2 = Class.new(EagerTrack)
     c1.set_primary_key [:id, :band_id]
@@ -228,7 +228,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should support using a custom :primary_key option when eager loading one_to_many associations" do
-    EagerBand.one_to_many :salbums, :clone=>:albums, :primary_key=>:id3, :eager=>nil
+    EagerBand.one_to_many :salbums, :clone=>:albums, :primary_key=>:id3, :eager=>nil, :reciprocal=>nil
     EagerBand.dataset._fetch = {:id=>6}
     a = EagerBand.eager(:salbums).all
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE (albums.band_id IN (2))']
@@ -258,7 +258,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for one_to_many associations" do
-    EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>Sequel.*(:albums__band_id, 3), :key_method=>:band_id3, :eager=>nil
+    EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>Sequel.*(:albums__band_id, 3), :key_method=>:band_id3, :eager=>nil, :reciprocal=>nil
     EagerBand.dataset._fetch = {:id=>6}
     a = EagerBand.eager(:salbums).all
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE ((albums.band_id * 3) IN (6))']
@@ -501,7 +501,7 @@ describe Sequel::Model, "#eager" do
     as.length.should == 1
     as.first.special_band.should == EagerBand.load(:p_k=>2, :id=>1)
 
-    EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>:band_id, :key=>:album_id
+    EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>:band_id, :key=>:album_id, :reciprocal=>nil
     EagerTrack.dataset._fetch = {:album_id=>2, :id=>1}
     as = EagerAlbum.eager(:special_tracks).all
     MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (2))"]
@@ -581,7 +581,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
-  it "should respect the :limit option on a one_to_many association using the :correlated_subquery strategy" do
+  qspecify "should respect the :limit option on a one_to_many association using the :correlated_subquery strategy" do
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name, :limit=>2
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -590,7 +590,7 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.should == []
   end
   
-  it "should respect the :limit option with an offset on a one_to_many association using the :correlated_subquery strategy" do
+  qspecify "should respect the :limit option with an offset on a one_to_many association using the :correlated_subquery strategy" do
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>:correlated_subquery, :order=>:name, :limit=>[2, 1]
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -632,7 +632,7 @@ describe Sequel::Model, "#eager" do
     as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
   end
 
-  it "should respect the limit option on a many_to_many association using the :correlated_subquery strategy" do
+  qspecify "should respect the limit option on a many_to_many association using the :correlated_subquery strategy" do
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :eager_limit_strategy=>:correlated_subquery, :limit=>2, :order=>:name
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
     as = EagerAlbum.eager(:first_two_genres).all
@@ -649,17 +649,17 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should use the :eager_loader association option when eager loading" do
-    EagerAlbum.many_to_one :special_band, :key=>:band_id, :eager_loader=>(proc do |key_hash, records, assocs| 
-      item = EagerBand.filter(:album_id=>records.collect{|r| [r.pk, r.pk*2]}.flatten).order(:name).first
-      records.each{|r| r.associations[:special_band] = item}
+    EagerAlbum.many_to_one :special_band, :key=>:band_id, :eager_loader=>(proc do |eo| 
+      item = EagerBand.filter(:album_id=>eo[:rows].collect{|r| [r.pk, r.pk*2]}.flatten).order(:name).first
+      eo[:rows].each{|r| r.associations[:special_band] = item}
     end)
     EagerAlbum.one_to_many :special_tracks, :eager_loader=>(proc do |eo|
       items = EagerTrack.filter(:album_id=>eo[:rows].collect{|r| [r.pk, r.pk*2]}.flatten).all
       eo[:rows].each{|r| r.associations[:special_tracks] = items}
     end)
-    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}
+    EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :eager_loader=>(proc do |eo| 
+      items = EagerGenre.inner_join(:ag, [:genre_id]).filter(:album_id=>eo[:rows].collect{|r| r.pk}).all
+      eo[:rows].each{|r| r.associations[:special_genres] = items}
     end)
     a = EagerAlbum.eager(:special_genres, :special_tracks, :special_band).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -1166,7 +1166,7 @@ describe Sequel::Model, "#eager_graph" do
     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
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :primary_key=>:band_id, :reciprocal=>nil
     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)'
     ds._fetch = [{:id=>3, :band_id=>2, :right_tracks_id=>5, :album_id=>2}, {:id=>3, :band_id=>2, :right_tracks_id=>6, :album_id=>2}]
@@ -1276,7 +1276,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :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 IS TRUE))"
 
-    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :conditions=>{:id=>(0..100)}
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :conditions=>{:id=>(0..100)}, :reciprocal=>nil
     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, :conditions=>{true=>:active}
@@ -1322,13 +1322,13 @@ describe Sequel::Model, "#eager_graph" do
   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.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphBand, {:active=>true}, :table_alias=>eo[:table_alias], :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 IS TRUE)"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|eo| eo[:self].graph(GraphTrack, nil, :join_type=>:natural, :table_alias=>eo[:table_alias])}
     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.many_to_many :active_genres, :class=>'GraphGenre', :eager_grapher=>proc{|eo| eo[:self].graph(:ag, {:album_id=>:id}, :table_alias=>:a123, :implicit_qualifier=>eo[:implicit_qualifier]).graph(GraphGenre, [:album_id], :table_alias=>eo[:table_alias])}
     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
 
@@ -1380,7 +1380,7 @@ describe Sequel::Model, "#eager_graph" do
   end
 
   it "should add the association's :order for cascading associations" do
-    GraphBand.one_to_many :a_albums, :class=>'GraphAlbum', :key=>:band_id, :order=>:name
+    GraphBand.one_to_many :a_albums, :class=>'GraphAlbum', :key=>:band_id, :order=>:name, :reciprocal=>nil
     GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
     GraphBand.eager_graph(:a_albums=>:b_tracks).sql.should == 'SELECT bands.id, bands.vocalist_id, a_albums.id AS a_albums_id, a_albums.band_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM bands LEFT OUTER JOIN albums AS a_albums ON (a_albums.band_id = bands.id) LEFT OUTER JOIN tracks AS b_tracks ON (b_tracks.album_id = a_albums.id) ORDER BY a_albums.name, b_tracks.id, b_tracks.album_id'
     GraphAlbum.one_to_many :albums, :class=>'GraphAlbum', :key=>:band_id, :order=>[:band_id, :id]
@@ -1417,7 +1417,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.eager_graph(:band).join(:s__genres, [:b_id]).eager_graph(:genres).sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join(Sequel.qualify(:s, :genres), [:b_id]).eager_graph(:genres).sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join(Sequel.expr(:s__b).as('genres'), [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
-    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], Sequel.identifier(:genres)).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
+    GraphAlbum.eager_graph(:band).join(:s__b, [:b_id], :table_alias=>Sequel.identifier(:genres)).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN s.b AS genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join(Sequel.identifier(:genres), [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
     GraphAlbum.eager_graph(:band).join('genres', [:b_id]).eager_graph(:genres).sql.should ==  'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id, genres_0.id AS genres_0_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) INNER JOIN genres USING (b_id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genres_0 ON (genres_0.id = ag.genre_id)'
   end

data/spec/model/hooks_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Model#after_initialize" do
-  specify "should be called after initialization for both new object and objects retrieved from the database" do
+  qspecify "should be called after initialization for both new object and objects retrieved from the database" do
     
     a = Class.new(Sequel::Model) do
       self::Foo = []

data/spec/model/model_spec.rb

@@ -55,7 +55,7 @@ describe "Sequel::Model()" do
   end
 
   it "should return a model subclass associated to the given database if given a database" do
-    db = Sequel::Database.new
+    db = Sequel.mock
     c = Sequel::Model(db)
     c.superclass.should == Sequel::Model
     c.db.should == db
@@ -68,10 +68,10 @@ describe "Sequel::Model()" do
 
   describe "reloading" do
     before do
-      Sequel::Model.cache_anonymous_models = true
+      Sequel.cache_anonymous_models = true
     end
     after do
-      Sequel::Model.cache_anonymous_models = false
+      Sequel.cache_anonymous_models = false
       Object.send(:remove_const, :Album) if defined?(::Album)
     end
 
@@ -132,7 +132,7 @@ describe "Sequel::Model()" do
     end
 
     it "should raise an exception if anonymous model caching is disabled" do
-      Sequel::Model.cache_anonymous_models = false
+      Sequel.cache_anonymous_models = false
       proc do
         class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
         class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
@@ -308,7 +308,7 @@ describe Sequel::Model, "constructors" do
   end
   
   it "should have dataset row_proc create an existing object" do
-    @m.dataset = Sequel::Dataset.new(nil)
+    @m.dataset = Sequel.mock.dataset
     o = @m.dataset.row_proc.call(:a=>1)
     o.should be_a_kind_of(@m)
     o.values.should == {:a=>1}
@@ -329,7 +329,7 @@ describe Sequel::Model, "constructors" do
     o.new?.should be_false
   end
   
-  it "should have .new with a second true argument create an existing object" do
+  qspecify "should have .new with a second true argument create an existing object" do
     o = @m.new({:a=>1}, true)
     o.should be_a_kind_of(@m)
     o.values.should == {:a=>1}
@@ -520,6 +520,7 @@ end
 describe Sequel::Model, "attribute accessors" do
   before do
     db = Sequel.mock
+    def db.supports_schema_parsing?() true end
     def db.schema(*)
       [[:x, {:type=>:integer}], [:z, {:type=>:integer}]]
     end
@@ -616,7 +617,7 @@ describe Sequel::Model, ".[]" do
     sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end
   
-  it "should work correctly for composite primary key specified as separate arguments" do
+  qspecify "should work correctly for composite primary key specified as separate arguments" do
     @c.set_primary_key :node_id, :kind
     @c[3921, 201].should be_a_kind_of(@c)
     sqls = MODEL_DB.sqls
@@ -637,9 +638,23 @@ describe "Model.db_schema" do
       def self.columns; orig_columns; end
     end
     @db = Sequel.mock
+    def @db.supports_schema_parsing?() true end
     @dataset = @db[:items]
   end
   
+  specify "should not call database's schema if it isn't supported" do
+    def @db.supports_schema_parsing?() false end
+    def @db.schema(table, opts = {})
+      raise Sequel::Error
+    end
+    @dataset.instance_variable_set(:@columns, [:x, :y])
+
+    @c.dataset = @dataset
+    @c.db_schema.should == {:x=>{}, :y=>{}}
+    @c.columns.should == [:x, :y]
+    @c.dataset.instance_variable_get(:@columns).should == [:x, :y]
+  end
+
   specify "should use the database's schema and set the columns and dataset columns" do
     def @db.schema(table, opts = {})
       [[:x, {:type=>:integer}], [:y, {:type=>:string}]]