sequel 3.48.0 → 4.0.0

data/spec/model/base_spec.rb

@@ -6,7 +6,7 @@ describe "Model attribute setters" do
       columns :id, :x, :y, :"x y"
     end
     @o = @c.new
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "refresh should return self" do
@@ -47,7 +47,7 @@ describe "Model.def_column_alias" do
       columns :id
       def_column_alias(:id2, :id)
     end.load(:id=>1)
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should create an getter alias for the column" do
@@ -412,6 +412,8 @@ describe "Model.db" do
       class ModelTest2 < Sequel::Model(@db[:foo])
         db.should == @db
       end
+      ModelTest.instance_variable_set(:@db, nil)
+      ModelTest.db.should == @db
     ensure
       Object.send(:remove_const, :ModelTest)
       Object.send(:remove_const, :ModelTest2)
@@ -462,14 +464,6 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     @c.allowed_columns.should == [:x, :y]
   end
 
-  qspecify "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)
@@ -481,36 +475,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     i = @c.new
     i.update(:x => 7, :z => 9)
     i.values.should == {:x => 7}
-    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
-  end
-
-  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}
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.should == {:x => 4, :y => 5}
-
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
-    i = @c.new
-    i.update(:x => 7, :z => 9)
-    i.values.should == {:x => 7}
-    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
-  end
-
-  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)
-    i.values.should == {:x => 1, :y => 2}
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.should == {:x => 4, :y => 5}
-
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:y => 7}
-    i = @c.new
-    i.update(:y => 7, :z => 9)
-    i.values.should == {:y => 7}
-    MODEL_DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 end
 
@@ -569,19 +534,13 @@ describe Sequel::Model, ".strict_param_setting" do
     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_all(:use_after_commit_rollback => false)}.should raise_error(Sequel::Error)
     proc{c.set_only({:x=>1}, :y)}.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_all(:use_after_commit_rollback=>false)}.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
-
   it "should be disabled by strict_param_setting = false" do
     @c.strict_param_setting = false
     @c.strict_param_setting.should == false
@@ -591,9 +550,9 @@ end
 
 describe Sequel::Model, ".require_modification" do
   before do
-    @ds1 = MODEL_DB[:items]
+    @ds1 = DB[:items]
     def @ds1.provides_accurate_rows_matched?() false end
-    @ds2 = MODEL_DB[:items]
+    @ds2 = DB[:items]
     def @ds2.provides_accurate_rows_matched?() true end
   end
   after do
@@ -618,7 +577,7 @@ end
 
 describe Sequel::Model, ".[] optimization" do
   before do
-    @db = MODEL_DB.clone
+    @db = DB.clone
     @db.quote_identifiers = true
     @c = Class.new(Sequel::Model(@db))
   end
@@ -700,47 +659,47 @@ describe "Model datasets #with_pk with #with_pk!" do
     @c = Class.new(Sequel::Model(:a))
     @ds = @c.dataset
     @ds._fetch = {:id=>1}
-    MODEL_DB.reset
+    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"]
+    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"]
+    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"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
     @ds.with_pk!(1).should == @c.load(:id=>1)
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should handle existing filters" do
     @ds.filter(:a=>2).with_pk(1)
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
     @ds.filter(:a=>2).with_pk!(1)
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
   end
 
   it "should work with string values" do
     @ds.with_pk("foo")
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
     @ds.with_pk!("foo")
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
   end
 
   it "should handle an array for composite primary keys" do
     @c.set_primary_key [:id1, :id2]
     @ds.with_pk([1, 2])
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
     "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(sqls.pop)
     sqls.should == []
 
     @ds.with_pk!([1, 2])
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
     "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(sqls.pop)
     sqls.should == []
@@ -749,26 +708,26 @@ describe "Model datasets #with_pk with #with_pk!" do
   it "should have with_pk return nil and with_pk! raise if no rows match" do
     @ds._fetch = []
     @ds.with_pk(1).should == nil
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
     proc{@ds.with_pk!(1)}.should raise_error(Sequel::NoMatchingRow)
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    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"]
+    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"]
+    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"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should not have #[] consider a string as a primary key lookup" do
     @ds['foo'].should == @c.load(:id=>1)
-    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
 end

data/spec/model/dataset_methods_spec.rb

@@ -10,7 +10,7 @@ describe Sequel::Model::DatasetMethods, "#destroy"  do
     end
     @d = @c.dataset
     @d._fetch = [{:id=>1}, {:id=>2}]
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should instantiate objects in the dataset and call destroy on each" do
@@ -28,13 +28,13 @@ describe Sequel::Model::DatasetMethods, "#destroy"  do
   it "should use a transaction if use_transactions is true for the model" do
     @c.use_transactions = true
     @d.destroy
-    MODEL_DB.sqls.should == ["BEGIN", "SELECT * FROM items", "COMMIT"]
+    DB.sqls.should == ["BEGIN", "SELECT * FROM items", "COMMIT"]
   end
 
   it "should not use a transaction if use_transactions is false for the model" do
     @c.use_transactions = false
     @d.destroy
-    MODEL_DB.sqls.should == ["SELECT * FROM items"]
+    DB.sqls.should == ["SELECT * FROM items"]
   end
 end
 
@@ -82,7 +82,7 @@ describe Sequel::Model::DatasetMethods  do
   end
 
   specify "#join_table should handle model classes that aren't simple selects using a subselect" do
-    @c.join(Class.new(Sequel::Model(MODEL_DB[:categories].where(:foo=>1))), :item_id => :id).sql.should == 'SELECT * FROM items INNER JOIN (SELECT * FROM categories WHERE (foo = 1)) AS t1 ON (t1.item_id = items.id)'
+    @c.join(Class.new(Sequel::Model(DB[:categories].where(:foo=>1))), :item_id => :id).sql.should == 'SELECT * FROM items INNER JOIN (SELECT * FROM categories WHERE (foo = 1)) AS t1 ON (t1.item_id = items.id)'
   end
 
   specify "#graph should allow use to use a model class when joining" do

data/spec/model/eager_loading_spec.rb

@@ -92,7 +92,7 @@ describe Sequel::Model, "#eager" do
       h
     end
 
-    MODEL_DB.reset
+    DB.reset
   end
   after do
     [:EagerAlbum, :EagerBand, :EagerTrack, :EagerGenre, :EagerBandMember].each{|x| Object.send(:remove_const, x)}
@@ -124,29 +124,39 @@ describe Sequel::Model, "#eager" do
 
   it "should eagerly load a single many_to_one association" do
     a = EagerAlbum.eager(:band).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (2))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (2))']
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.band.should == EagerBand.load(:id=>2)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single many_to_one association with the same name as the column" do
     EagerAlbum.def_column_alias(:band_id_id, :band_id)
     EagerAlbum.many_to_one :band_id, :key_column=>:band_id, :class=>EagerBand
     a = EagerAlbum.eager(:band_id).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (2))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (2))']
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.band_id.should == EagerBand.load(:id=>2)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single one_to_one association" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
+  end
+  
+  it "should use first matching entry when eager loading one_to_one association" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
+    EagerTrack.dataset._fetch = [{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}]
+    a = EagerAlbum.eager(:track).all
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single one_to_one association using the :distinct_on strategy" do
@@ -154,87 +164,76 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT DISTINCT ON (tracks.album_id) * FROM tracks WHERE (tracks.album_id IN (1)) ORDER BY tracks.album_id']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT DISTINCT ON (tracks.album_id) * FROM tracks WHERE (tracks.album_id IN (1)) ORDER BY tracks.album_id']
     a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single one_to_one association using the :window_function strategy" do
     def (EagerTrack.dataset).supports_window_functions?() true end
-    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :eager_limit_strategy=>true
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x = 1)']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x = 1)']
     a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
-  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
+  it "should not use distinct on eager limit strategy if the association has an offset" do
+    def (EagerTrack.dataset).supports_distinct_on?() true end
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1], :order=>:name
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 1))) ORDER BY name']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x = 2)']
     a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
-  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]
+  it "should automatically use an eager limit stategy if the association has an offset" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1]
+    EagerTrack.dataset._fetch = [{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}]
     a = EagerAlbum.eager(:track).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY t1.name, t1.name DESC, t1.name, t.name, 1 LIMIT 1))) ORDER BY tracks.name, tracks.name DESC, tracks.name, t.name, 1']
-    a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
-  end
-  
-  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]
-    c2.set_primary_key [:id, :album_id]
-    c1.one_to_one :track, :class=>c2, :key=>[:album_id, :id], :eager_limit_strategy=>:correlated_subquery
-    c2.dataset._fetch = {:id => 2, :album_id=>1}
-    a = c1.eager(:track).all
-    a.should == [c1.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (((tracks.album_id, tracks.id) IN ((1, 2))) AND ((tracks.id, tracks.album_id) IN (SELECT t1.id, t1.album_id FROM tracks AS t1 WHERE ((t1.album_id = tracks.album_id) AND (t1.id = tracks.id)) LIMIT 1)))']
-    a.first.track.should == c2.load(:id => 2, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    a.first.track.should == EagerTrack.load(:id => 4, :album_id=>1)
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single one_to_many association" do
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load a single many_to_many association" do
     a = EagerAlbum.eager(:genres).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    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.id) AND (ag.album_id IN (1)))"]
+    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.id) AND (ag.album_id IN (1)))"]
     a.first.genres.should == [EagerGenre.load(:id=>4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should support using a custom :key option when eager loading many_to_one associations" do
     EagerAlbum.many_to_one :sband, :clone=>:band, :key=>:band_id3
     EagerBand.dataset._fetch = {:id=>6}
     a = EagerAlbum.eager(:sband).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (6))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (6))']
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.sband.should == EagerBand.load(:id=>6)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   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, :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))']
+    DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE (albums.band_id IN (2))']
     a.should == [EagerBand.load(:id => 6)]
     a.first.salbums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
@@ -242,38 +241,38 @@ describe Sequel::Model, "#eager" do
     EagerGenre.dataset._fetch = {:id=>4, :x_foreign_key_x=>6}
     a = EagerAlbum.eager(:sgenres).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    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.id) AND (ag.album_id IN (6)))"]
+    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.id) AND (ag.album_id IN (6)))"]
     a.first.sgenres.should == [EagerGenre.load(:id=>4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_one associations" do
     EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loading_predicate_key=>Sequel./(:bands__id, 3), :primary_key_method=>:id3
     EagerBand.dataset._fetch = {:id=>6}
     a = EagerAlbum.eager(:sband).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE ((bands.id / 3) IN (2))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE ((bands.id / 3) IN (2))']
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.sband.should == EagerBand.load(:id=>6)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   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, :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))']
+    DB.sqls.should == ['SELECT * FROM bands', 'SELECT * FROM albums WHERE ((albums.band_id * 3) IN (6))']
     a.should == [EagerBand.load(:id => 6)]
     a.first.salbums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_many associations" do
     EagerAlbum.many_to_many :sgenres, :clone=>:genres, :eager_loading_predicate_key=>Sequel.*(:ag__album_id, 1)
     a = EagerAlbum.eager(:sgenres).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, (ag.album_id * 1) AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND ((ag.album_id * 1) IN (1)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, (ag.album_id * 1) AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND ((ag.album_id * 1) IN (1)))"]
     a.first.sgenres.should == [EagerGenre.load(:id=>4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should raise an error for an unhandled :eager_loader_key option" do
@@ -294,19 +293,19 @@ describe Sequel::Model, "#eager" do
   it "should correctly handle a :select=>[] option to many_to_many" do
     EagerAlbum.many_to_many :sgenres, :clone=>:genres, :select=>[]
     EagerAlbum.eager(:sgenres).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT *, 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)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT *, 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 correctly handle an aliased join table in many_to_many" do
     EagerAlbum.many_to_many :sgenres, :clone=>:genres, :join_table=>:ag___ga
     EagerAlbum.eager(:sgenres).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON ((ga.genre_id = genres.id) AND (ga.album_id IN (1)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ga.album_id AS x_foreign_key_x FROM genres INNER JOIN ag AS ga ON ((ga.genre_id = genres.id) AND (ga.album_id IN (1)))"]
   end
   
   it "should eagerly load multiple associations in a single call" do
     a = EagerAlbum.eager(:genres, :tracks, :band).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == 'SELECT * FROM albums'
     sqls.sort.should == ['SELECT * FROM bands WHERE (bands.id IN (2))',
       'SELECT * FROM tracks WHERE (tracks.album_id IN (1))',
@@ -315,13 +314,13 @@ describe Sequel::Model, "#eager" do
     a.band.should == EagerBand.load(:id=>2)
     a.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
     a.genres.should == [EagerGenre.load(:id => 4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should eagerly load multiple associations in separate calls" do
     a = EagerAlbum.eager(:genres).eager(:tracks).eager(:band).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == 'SELECT * FROM albums'
     sqls.sort.should == ['SELECT * FROM bands WHERE (bands.id IN (2))',
       'SELECT * FROM tracks WHERE (tracks.album_id IN (1))',
@@ -330,13 +329,13 @@ describe Sequel::Model, "#eager" do
     a.band.should == EagerBand.load(:id=>2)
     a.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
     a.genres.should == [EagerGenre.load(:id => 4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should allow cascading of eager loading for associations of associated models" do
     a = EagerTrack.eager(:album=>{:band=>:members}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == ['SELECT * FROM tracks', 
+    DB.sqls.should == ['SELECT * FROM tracks', 
       'SELECT * FROM albums WHERE (albums.id IN (1))',
       'SELECT * FROM bands WHERE (bands.id IN (2))',
       "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
@@ -344,41 +343,41 @@ describe Sequel::Model, "#eager" do
     a.album.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.album.band.should == EagerBand.load(:id => 2)
     a.album.band.members.should == [EagerBandMember.load(:id => 5)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should cascade eagerly loading when the :eager association option is used" do
     a = EagerBand.eager(:albums).all
     a.should == [EagerBand.load(:id=>2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+    DB.sqls.should == ['SELECT * FROM bands', 
       'SELECT * FROM albums WHERE (albums.band_id IN (2))',
       'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.albums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.albums.first.tracks.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should respect :eager when lazily loading an association" do
     a = EagerBand.all
     a.should == [EagerBand.load(:id=>2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM bands']
+    DB.sqls.should == ['SELECT * FROM bands']
     a = a.first.albums
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.band_id = 2)',
+    DB.sqls.should == ['SELECT * FROM albums WHERE (albums.band_id = 2)',
       'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should cascade eagerly loading when the :eager_graph association option is used" do
     EagerAlbum.dataset._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
     a = EagerBand.eager(:graph_albums).all
     a.should == [EagerBand.load(:id=>2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+    DB.sqls.should == ['SELECT * FROM bands', 
       'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id IN (2))']
     a.first.graph_albums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.first.graph_albums.first.tracks.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should raise an Error when eager loading a many_to_many association with the :eager_graph option" do
@@ -388,14 +387,14 @@ describe Sequel::Model, "#eager" do
   it "should respect :eager_graph when lazily loading an association" do
     a = EagerBand.all
     a.should == [EagerBand.load(:id=>2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM bands']
+    DB.sqls.should == ['SELECT * FROM bands']
     a = a.first
     EagerAlbum.dataset._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
     a.graph_albums
-    MODEL_DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id = 2)']
+    DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id = 2)']
     a.graph_albums.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
     a.graph_albums.first.tracks.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should respect :eager_graph when lazily loading a many_to_many association" do
@@ -404,70 +403,70 @@ describe Sequel::Model, "#eager" do
     ds._fetch = [{:id=>5, :bands_id=>2, :p_k=>6}, {:id=>5, :bands_id=>3, :p_k=>6}]
     a = EagerBand.load(:id=>2)
     a.graph_members.should == [EagerBandMember.load(:id=>5)]
-    MODEL_DB.sqls.should == ['SELECT members.id, bands.id AS bands_id, bands.p_k FROM (SELECT members.* FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id = 2))) AS members LEFT OUTER JOIN bm AS bm_0 ON (bm_0.member_id = members.id) LEFT OUTER JOIN bands ON (bands.id = bm_0.band_id) ORDER BY bands.id']
+    DB.sqls.should == ['SELECT members.id, bands.id AS bands_id, bands.p_k FROM (SELECT members.* FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id = 2))) AS members LEFT OUTER JOIN bm AS bm_0 ON (bm_0.member_id = members.id) LEFT OUTER JOIN bands ON (bands.id = bm_0.band_id) ORDER BY bands.id']
     a.graph_members.first.bands.should == [EagerBand.load(:id=>2, :p_k=>6), EagerBand.load(:id=>3, :p_k=>6)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should respect :conditions when eagerly loading" do
     EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>{:a=>32}
     a = EagerBandMember.eager(:good_bands).all
     a.should == [EagerBandMember.load(:id => 5)]
-    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (a = 32) ORDER BY id']
+    DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (a = 32) ORDER BY id']
     a.first.good_bands.should == [EagerBand.load(:id => 2)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
 
     EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>"x = 1"
     a = EagerBandMember.eager(:good_bands).all
-    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (x = 1) ORDER BY id']
+    DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (x = 1) ORDER BY id']
   end
   
   it "should respect :order when eagerly loading" do
     a = EagerBandMember.eager(:bands).all
     a.should == [EagerBandMember.load(:id => 5)]
-    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) ORDER BY id']
+    DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) ORDER BY id']
     a.first.bands.should == [EagerBand.load(:id => 2)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should populate the reciprocal many_to_one association when eagerly loading the one_to_many association" do
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
     a.first.tracks.first.album.should == a.first
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should cache the negative lookup when eagerly loading a many_to_one association" do
     a = EagerAlbum.eager(:band).filter(:id=>101).all
     a.should == [EagerAlbum.load(:id => 101, :band_id => 101)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (id = 101)', 'SELECT * FROM bands WHERE (bands.id IN (101))']
+    DB.sqls.should == ['SELECT * FROM albums WHERE (id = 101)', 'SELECT * FROM bands WHERE (bands.id IN (101))']
     a.first.associations.fetch(:band, 2).should be_nil
     a.first.band.should be_nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should cache the negative lookup when eagerly loading a *_to_many associations" do
     a = EagerBand.eager(:albums).filter('id > 100').all
     a.should == [EagerBand.load(:id => 101), EagerBand.load(:id =>102)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ['SELECT * FROM albums WHERE (albums.band_id IN (101, 102))', 'SELECT * FROM albums WHERE (albums.band_id IN (102, 101))'].should include(sqls.delete_at(1))
     sqls.should == ['SELECT * FROM bands WHERE (id > 100)', "SELECT * FROM tracks WHERE (tracks.album_id IN (101))"]
     a.map{|b| b.associations[:albums]}.should == [[EagerAlbum.load({:band_id=>101, :id=>101})], []]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should use the association's block when eager loading by default" do
     EagerAlbum.eager(:good_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
   end
 
   it "should use the eager_block option when eager loading if given" do
     EagerBand.eager(:good_albums).all
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
+    DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
     EagerBand.eager(:good_albums=>:good_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))", "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
+    DB.sqls.should == ['SELECT * FROM bands', "SELECT * FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))", "SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (name = 'Good'))"]
   end
 
   it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do
@@ -477,34 +476,34 @@ describe Sequel::Model, "#eager" do
 
   it "should respect the association's :select option" do
     EagerAlbum.eager(:band_name).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM bands WHERE (bands.id IN (2))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM bands WHERE (bands.id IN (2))"]
     EagerAlbum.eager(:track_names).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM tracks WHERE (tracks.album_id IN (1))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM tracks WHERE (tracks.album_id IN (1))"]
     EagerAlbum.eager(:genre_names).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
+    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 many_to_one association's :qualify option" do
     EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :qualify=>false, :key=>:band_id
     EagerBand.dataset._fetch = {:id=>2}
     as = EagerAlbum.eager(:special_band).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE (id IN (2))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE (id IN (2))"]
     as.map{|a| a.special_band}.should == [EagerBand.load(:id=>2)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   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._fetch = {:p_k=>2, :id=>1}
     as = EagerAlbum.eager(:special_band).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE (bands.p_k IN (2))"]
+    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)
 
     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))"]
+    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
@@ -513,7 +512,7 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :primary_key=>[:id, :p_k], :key=>[:band_id, :id]
     EagerBand.dataset._fetch = {:p_k=>1, :id=>2}
     as = EagerAlbum.eager(:special_band).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE ((bands.id, bands.p_k) IN ((2, 1)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM bands WHERE ((bands.id, bands.p_k) IN ((2, 1)))"]
     as.length.should == 1
     as.first.special_band.should == EagerBand.load(:p_k=>1, :id=>2)
   end
@@ -522,7 +521,7 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>[:band_id, :id], :key=>[:id, :album_id]
     EagerTrack.dataset._fetch = {:album_id=>1, :id=>2}
     as = EagerAlbum.eager(:special_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.id, tracks.album_id) IN ((2, 1)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.id, tracks.album_id) IN ((2, 1)))"]
     as.length.should == 1
     as.first.special_tracks.should == [EagerTrack.load(:album_id=>1, :id=>2)]
   end
@@ -531,7 +530,7 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :left_primary_key=>[:band_id, :id], :left_key=>[:l1, :l2], :right_primary_key=>[:xxx, :id], :right_key=>[:r1, :r2], :join_table=>:ag
     EagerGenre.dataset._fetch = [{:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>5}, {:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>6}]
     as = EagerAlbum.eager(:special_genres).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.l1 AS x_foreign_key_0_x, ag.l2 AS x_foreign_key_1_x FROM genres INNER JOIN ag ON ((ag.r1 = genres.xxx) AND (ag.r2 = genres.id) AND ((ag.l1, ag.l2) IN ((2, 1))))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.l1 AS x_foreign_key_0_x, ag.l2 AS x_foreign_key_1_x FROM genres INNER JOIN ag ON ((ag.r1 = genres.xxx) AND (ag.r2 = genres.id) AND ((ag.l1, ag.l2) IN ((2, 1))))"]
     as.length.should == 1
     as.first.special_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
   end
@@ -540,7 +539,7 @@ describe Sequel::Model, "#eager" 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._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
     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)))"]
+    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
@@ -549,101 +548,98 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2
     EagerTrack.dataset._fetch = [{:album_id=>1, :id=>2}, {:album_id=>1, :id=>3}, {:album_id=>1, :id=>4}]
     as = EagerAlbum.eager(:first_two_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
     as.length.should == 1
     as.first.first_two_tracks.should == [EagerTrack.load(:album_id=>1, :id=>2), EagerTrack.load(:album_id=>1, :id=>3)]
 
-    MODEL_DB.reset
-    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>[2,1]
+    DB.reset
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>[1,1]
+    as = EagerAlbum.eager(:first_two_tracks).all
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
+    as.length.should == 1
+    as.first.first_two_tracks.should == [EagerTrack.load(:album_id=>1, :id=>3)]
+
+    DB.reset
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>[nil,1]
     as = EagerAlbum.eager(:first_two_tracks).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
     as.length.should == 1
     as.first.first_two_tracks.should == [EagerTrack.load(:album_id=>1, :id=>3), EagerTrack.load(:album_id=>1, :id=>4)]
   end
 
   it "should respect the :limit option on a one_to_many association using the :window_function strategy" do
     def (EagerTrack.dataset).supports_window_functions?() true end
-    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name, :limit=>2
+    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :limit=>2
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should respect the :limit option with an offset on a one_to_many association using the :window_function strategy" do
     def (EagerTrack.dataset).supports_window_functions?() true end
-    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :eager_limit_strategy=>true, :order=>:name, :limit=>[2, 1]
-    a = EagerAlbum.eager(:tracks).all
-    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
-    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
-  end
-  
-  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
+    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :limit=>[2, 1]
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 2))) ORDER BY name']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
-  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]
+  it "should respect the :limit option with just an offset on a one_to_many association using the :window_function strategy" do
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :limit=>[nil, 1]
     a = EagerAlbum.eager(:tracks).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE ((tracks.album_id IN (1)) AND (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) ORDER BY name LIMIT 2 OFFSET 1))) ORDER BY name']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x >= 2)']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   it "should respect the limit option on a many_to_many association" 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, :limit=>2
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
     as = EagerAlbum.eager(:first_two_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.id) AND (ag.album_id IN (2)))"]
+    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.id) AND (ag.album_id IN (2)))"]
     as.length.should == 1
     as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
     
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
-    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, :limit=>[2, 1]
+    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, :limit=>[1, 1]
     as = EagerAlbum.eager(:first_two_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.id) AND (ag.album_id IN (2)))"]
+    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.id) AND (ag.album_id IN (2)))"]
+    as.length.should == 1
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>6)]
+    
+    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
+    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, :limit=>[nil, 1]
+    as = EagerAlbum.eager(:first_two_genres).all
+    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.id) AND (ag.album_id IN (2)))"]
     as.length.should == 1
     as.first.first_two_genres.should == [EagerGenre.load(:id=>6), EagerGenre.load(:id=>7)]
   end
 
   it "should respect the limit option on a many_to_many association using the :window_function strategy" do
     def (EagerGenre.dataset).supports_window_functions?() true end
-    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=>true, :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
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE (x_sequel_row_number_x <= 2)"]
-    as.length.should == 1
-    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
-
+    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, :limit=>2, :order=>:name
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
-    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=>true, :limit=>[2, 1], :order=>:name
     as = EagerAlbum.eager(:first_two_genres).all
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE (x_sequel_row_number_x <= 2)"]
     as.length.should == 1
     as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
-  end
 
-  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}]
+    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}]
+    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, :limit=>[1, 1], :order=>:name
     as = EagerAlbum.eager(:first_two_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.id) AND (ag.album_id IN (2))) WHERE (genres.id IN (SELECT t1.id FROM genres AS t1 INNER JOIN ag AS t2 ON ((t2.genre_id = t1.id) AND (t2.album_id = ag.album_id)) ORDER BY name LIMIT 2)) ORDER BY name"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 3))"]
     as.length.should == 1
-    as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
+    as.first.first_two_genres.should == [EagerGenre.load(:id=>5)]
 
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
-    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, 1], :order=>:name
+    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, :limit=>[nil, 1], :order=>:name
     as = EagerAlbum.eager(:first_two_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.id) AND (ag.album_id IN (2))) WHERE (genres.id IN (SELECT t1.id FROM genres AS t1 INNER JOIN ag AS t2 ON ((t2.genre_id = t1.id) AND (t2.album_id = ag.album_id)) ORDER BY name LIMIT 2 OFFSET 1)) ORDER BY name"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (2)))) AS t1 WHERE (x_sequel_row_number_x >= 2)"]
     as.length.should == 1
     as.first.first_two_genres.should == [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
   end
@@ -663,7 +659,7 @@ describe Sequel::Model, "#eager" do
     end)
     a = EagerAlbum.eager(:special_genres, :special_tracks, :special_band).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == 'SELECT * FROM albums'
     sqls.sort.should == ['SELECT * FROM bands WHERE (album_id IN (1, 2)) ORDER BY name LIMIT 1',
       'SELECT * FROM genres INNER JOIN ag USING (genre_id) WHERE (album_id IN (1))',
@@ -672,13 +668,9 @@ describe Sequel::Model, "#eager" do
     a.special_band.should == EagerBand.load(:id => 2)
     a.special_tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
     a.special_genres.should == [EagerGenre.load(:id => 4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
-  it "should raise an error if you use an :eager_loader proc with the wrong arity" do
-    proc{EagerAlbum.many_to_one :special_band, :eager_loader=>proc{|a, b|}}.should raise_error(Sequel::Error)
-  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}}
@@ -694,7 +686,7 @@ describe Sequel::Model, "#eager" do
     EagerAlbum.many_to_many :al_genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :uniq=>true
     EagerGenre.dataset._fetch = [{:x_foreign_key_x=>1, :id=>8}, {:x_foreign_key_x=>1, :id=>8}]
     a = EagerAlbum.eager(:al_genres).all.first
-    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.id) AND (ag.album_id IN (1)))"]
+    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.id) AND (ag.album_id IN (1)))"]
     a.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.al_genres.should == [EagerGenre.load(:id=>8)]
   end
@@ -702,7 +694,7 @@ describe Sequel::Model, "#eager" do
   it "should respect :distinct option when eagerly loading many_to_many associations" do
     EagerAlbum.many_to_many :al_genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :distinct=>true
     a = EagerAlbum.eager(:al_genres).all.first
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT DISTINCT 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)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT DISTINCT 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.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.al_genres.should == [EagerGenre.load(:id=>4)]
   end
@@ -710,40 +702,40 @@ describe Sequel::Model, "#eager" do
   it "should eagerly load a many_to_one association with custom eager block" do
     a = EagerAlbum.eager(:band => proc {|ds| ds.select(:id, :name)}).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id, name FROM bands WHERE (bands.id IN (2))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT id, name FROM bands WHERE (bands.id IN (2))']
     a.first.band.should == EagerBand.load(:id => 2)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should eagerly load a one_to_one association with custom eager block" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
     a = EagerAlbum.eager(:track => proc {|ds| ds.select(:id)}).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.track.should == EagerTrack.load(:id => 3, :album_id=>1)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should eagerly load a one_to_many association with custom eager block" do
     a = EagerAlbum.eager(:tracks => proc {|ds| ds.select(:id)}).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
+    DB.sqls.should == ['SELECT * FROM albums', 'SELECT id FROM tracks WHERE (tracks.album_id IN (1))']
     a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should eagerly load a many_to_many association with custom eager block" do
     a = EagerAlbum.eager(:genres => proc {|ds| ds.select(:name)}).all
     a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT name, 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)))"]
+    DB.sqls.should == ['SELECT * FROM albums', "SELECT name, 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.first.genres.should == [EagerGenre.load(:id => 4)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should allow cascading of eager loading within a custom eager block" do
     a = EagerTrack.eager(:album => proc {|ds| ds.eager(:band => :members)}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+    DB.sqls.should == ['SELECT * FROM tracks',
       'SELECT * FROM albums WHERE (albums.id IN (1))',
       'SELECT * FROM bands WHERE (bands.id IN (2))',
       "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
@@ -751,13 +743,13 @@ describe Sequel::Model, "#eager" do
     a.album.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.album.band.should == EagerBand.load(:id => 2)
     a.album.band.members.should == [EagerBandMember.load(:id => 5)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should allow cascading of eager loading with custom callback with hash value" do
     a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>{:band => :members}}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+    DB.sqls.should == ['SELECT * FROM tracks',
       'SELECT id, band_id FROM albums WHERE (albums.id IN (1))',
       'SELECT * FROM bands WHERE (bands.id IN (2))',
       "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
@@ -765,25 +757,25 @@ describe Sequel::Model, "#eager" do
     a.album.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.album.band.should == EagerBand.load(:id => 2)
     a.album.band.members.should == [EagerBandMember.load(:id => 5)]
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should allow cascading of eager loading with custom callback with symbol value" do
     a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>:band}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    MODEL_DB.sqls.should == ['SELECT * FROM tracks',
+    DB.sqls.should == ['SELECT * FROM tracks',
       'SELECT id, band_id FROM albums WHERE (albums.id IN (1))',
       'SELECT * FROM bands WHERE (bands.id IN (2))']
     a = a.first
     a.album.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.album.band.should == EagerBand.load(:id => 2)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should allow cascading of eager loading with custom callback with array value" do
     a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>[:band, :band_name]}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.slice!(0..1).should == ['SELECT * FROM tracks',
       'SELECT id, band_id FROM albums WHERE (albums.id IN (1))']
     sqls.sort.should == ['SELECT * FROM bands WHERE (bands.id IN (2))',
@@ -792,12 +784,12 @@ describe Sequel::Model, "#eager" do
     a.album.should == EagerAlbum.load(:id => 1, :band_id => 2)
     a.album.band.should == EagerBand.load(:id => 2)
     a.album.band_name.should == EagerBand.load(:id => 2)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   it "should call both association and custom eager blocks" do
     EagerBand.eager(:good_albums => proc {|ds| ds.select(:name)}).all
-    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT name FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
+    DB.sqls.should == ['SELECT * FROM bands', "SELECT name FROM albums WHERE ((albums.band_id IN (2)) AND (name = 'good'))"]
   end
 end
 
@@ -1019,7 +1011,7 @@ describe Sequel::Model, "#eager_graph" do
   end
   
   it "should populate the reciprocal many_to_one association when eagerly loading the one_to_many association" do
-    MODEL_DB.reset
+    DB.reset
     ds = GraphAlbum.eager_graph(:tracks)
     ds.sql.should == 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
     ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
@@ -1028,7 +1020,7 @@ describe Sequel::Model, "#eager_graph" do
     a = a.first
     a.tracks.should == [GraphTrack.load(:id => 3, :album_id=>1)]
     a.tracks.first.album.should == a
-    MODEL_DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
+    DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
   end
 
   it "should eager load multiple associations from the same table" do
@@ -1086,7 +1078,7 @@ describe Sequel::Model, "#eager_graph" do
   end
 
   it "should be able to be used in combination with #eager" do
-    MODEL_DB.reset
+    DB.reset
     ds = GraphAlbum.eager_graph(:tracks).eager(:genres)
     ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
     ds2 = GraphGenre.dataset
@@ -1096,7 +1088,7 @@ describe Sequel::Model, "#eager_graph" do
     a = a.first
     a.tracks.should == [GraphTrack.load(:id=>3, :album_id=>1)]
     a.genres.should == [GraphGenre.load(:id => 6)]
-    MODEL_DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)',
+    DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)',
     "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)))"]
   end
 
@@ -1332,10 +1324,6 @@ 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 AS a123 ON (a123.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres USING (album_id)"
   end
 
-  it "should raise an error if you use an :eager_grapher proc with the wrong arity" do
-    proc{GraphAlbum.many_to_one :special_band, :eager_grapher=>proc{|a, b|}}.should raise_error(Sequel::Error)
-  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 IS TRUE)"