sequel 4.8.0 → 4.9.0

data/spec/extensions/current_datetime_timestamp_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "current_datetime_timestamp extension" do
+  before do
+    @ds = Sequel.mock[:table].extension(:current_datetime_timestamp)
+  end
+  after do
+    Sequel.datetime_class = Time
+  end
+
+  specify "should have current_timestamp respect Sequel.datetime_class" do
+    t = Sequel::Dataset.new(nil).current_datetime 
+    t.should be_a_kind_of(Time)
+    (Time.now - t < 0.1).should == true
+
+    Sequel.datetime_class = DateTime
+    t = Sequel::Dataset.new(nil).current_datetime 
+    t.should be_a_kind_of(DateTime)
+    (DateTime.now - t < (0.1/86400)).should == true
+  end
+
+  specify "should have current_timestamp value be literalized as CURRENT_TIMESTAMP" do
+    @ds.literal(@ds.current_datetime).should == 'CURRENT_TIMESTAMP'
+    Sequel.datetime_class = DateTime
+    @ds.literal(@ds.current_datetime).should == 'CURRENT_TIMESTAMP'
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -47,6 +47,18 @@ describe "Sequel::Plugins::DefaultsSetter" do
     (t - DateTime.now).should < 1/86400.0
   end
 
+  it "should work correctly with the current_datetime_timestamp extension" do
+    @db.autoid = 1
+    @db.fetch = {:id=>1}
+    @c.dataset = @c.dataset.extension(:current_datetime_timestamp)
+    c = @pr.call(Sequel::CURRENT_TIMESTAMP)
+    @db.sqls
+    o = c.new
+    o.a = o.a
+    o.save
+    @db.sqls.should == ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE (id = 1) LIMIT 1"]
+  end
+
   it "should not override a given value" do
     @pr.call(2)
     @c.new('a'=>3).a.should == 3

data/spec/extensions/eager_each_spec.rb

@@ -33,4 +33,10 @@ describe "Sequel::Plugins::EagerEach" do
     a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
     @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
   end
+
+  it "should not attempt to eager load when getting the columns" do
+    ds = @c.eager(:children)
+    def ds.all; raise; end
+    proc{ds.columns!}.should_not raise_error
+  end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -5,7 +5,7 @@ describe "NestedAttributes plugin" do
     if should.is_a?(Array)
       should.should include(is)
     else
-      should.should == is
+      is.should == should
     end
   end
 
@@ -94,7 +94,19 @@ describe "NestedAttributes plugin" do
       "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
-  
+
+  it "should should not remove existing values from object when validating" do
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>:id
+    @Artist.nested_attributes :first_album
+    @db.fetch = {:id=>1}
+    a = @Artist.load(:id=>1)
+    a.set(:first_album_attributes=>{:id=>1, :name=>'Ar'})
+    a.first_album.values.should == {:id=>1, :name=>'Ar'}
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.id = 1) LIMIT 1"]
+    a.save_changes
+    check_sql_array("UPDATE albums SET name = 'Ar' WHERE (id = 1)")
+  end
+
   it "should support creating new many_to_many objects" do
     a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}]})
     @db.sqls.should == []

data/spec/extensions/pg_array_spec.rb

@@ -24,6 +24,9 @@ describe "pg_array extension" do
     c = @converter[1009]
     c.call("{a}").to_a.first.should be_a_kind_of(String)
     c.call("{}").to_a.should == []
+    c.call('{""}').to_a.should == [""]
+    c.call('{"",""}').to_a.should == ["",""]
+    c.call('{"","",""}').to_a.should == ["","",""]
     c.call("{a}").to_a.should == ['a']
     c.call('{"a b"}').to_a.should == ['a b']
     c.call('{a,b}').to_a.should == ['a', 'b']
@@ -126,6 +129,17 @@ describe "pg_array extension" do
     c.call('{NULLA,"NULL",NULL}').to_a.should == ["NULLA", "NULL", nil]
   end
 
+  it "should raise errors when for certain recognized invalid arrays" do
+    c = @converter[1009]
+    proc{c.call('')}.should raise_error(Sequel::Error)
+    proc{c.call('}')}.should raise_error(Sequel::Error)
+    proc{c.call('{{}')}.should raise_error(Sequel::Error)
+    proc{c.call('{}}')}.should raise_error(Sequel::Error)
+    proc{c.call('{a""}')}.should raise_error(Sequel::Error)
+    proc{c.call('{a{}}')}.should raise_error(Sequel::Error)
+    proc{c.call('{""a}')}.should raise_error(Sequel::Error)
+  end
+
   it "should literalize arrays without types correctly" do
     @db.literal(@m::PGArray.new([])).should == 'ARRAY[]'
     @db.literal(@m::PGArray.new([1])).should == 'ARRAY[1]'
@@ -189,7 +203,7 @@ describe "pg_array extension" do
 
   it "should parse array types from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'integer[]'}, {:name=>'f', :db_type=>'real[]'}, {:name=>'d', :db_type=>'numeric[]'}, {:name=>'t', :db_type=>'text[]'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :integer_array, :float_array, :decimal_array, :string_array]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :integer_array, :real_array, :decimal_array, :string_array]
   end
 
   it "should support typecasting of the various array types" do
@@ -317,12 +331,6 @@ describe "pg_array extension" do
     @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).should == "'{}'::blah[]"
   end
 
-  it "should use and not override existing database typecast method if :typecast_method option is given" do
-    Sequel::Postgres::PGArray.register('foo', :typecast_method=>:float)
-    @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:float_array]
-  end
-
   it "should support registering custom array types on a per-Database basis" do
     @db.register_array_type('banana', :oid=>7865){|s| s}
     @db.typecast_value(:banana_array, []).should be_a_kind_of(Sequel::Postgres::PGArray)

data/spec/extensions/shared_caching_spec.rb

@@ -27,7 +27,7 @@ describe "Shared caching behavior" do
       @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.should equal(@cm12)
       @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.should equal(@cm21)
       @db.sqls.should == []
-      @cc.dataset._fetch = []
+      @db.fetch = []
       @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.should == nil
     end
   end
@@ -39,7 +39,7 @@ describe "Shared caching behavior" do
       @c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
       @c.load(:id=>4, :caching_model_id=>2).caching_model.should equal(@cm2)
       @db.sqls.should == []
-      @cc.dataset._fetch = []
+      @db.fetch = []
       @c.load(:id=>4, :caching_model_id=>3).caching_model.should == nil
     end
 
@@ -128,7 +128,7 @@ describe "Shared caching behavior" do
       @cache = cache
       
       @cc.plugin :caching, @cache
-      @cc.dataset._fetch = {:id=>1}
+      @db.fetch = {:id=>1}
       @cm1 = @cc[1]
       @cm2 = @cc[2]
       @cm12 = @cc[1, 2]
@@ -143,7 +143,7 @@ describe "Shared caching behavior" do
 
   describe "With static_cache plugin with single key" do
     before do
-      @cc.dataset._fetch = [{:id=>1}, {:id=>2}]
+      @db.fetch = [{:id=>1}, {:id=>2}]
       @cc.plugin :static_cache
       @cm1 = @cc[1]
       @cm2 = @cc[2]
@@ -163,7 +163,7 @@ describe "Shared caching behavior" do
   describe "With static_cache plugin with composite key" do
     before do
       @cc.set_primary_key([:id, :id2])
-      @cc.dataset._fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
+      @db.fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
       @cc.plugin :static_cache
       @cm12 = @cc[[1, 2]]
       @cm21 = @cc[[2, 1]]

data/spec/extensions/timestamps_spec.rb

@@ -34,6 +34,15 @@ describe "Sequel::Plugins::Timestamps" do
     o.updated_at.should == '2009-08-01'
   end
 
+  it "should work with current_datetime_timestamp extension" do
+    Sequel.datetime_class = Time
+    @c.dataset = @c.dataset.extension(:current_datetime_timestamp)
+    o = @c.create
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES (CURRENT_TIMESTAMP)"]
+    o = @c.load(:id=>1).save
+    @c.db.sqls.should == ["UPDATE t SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
   it "should not update the update timestamp on creation" do
     @c.create.updated_at.should == nil
   end

data/spec/extensions/touch_spec.rb

@@ -26,6 +26,15 @@ describe "Touch plugin" do
     DB.sqls.first.should =~ /UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/
   end
 
+  specify "should work with current_datetime_timestamp extension" do
+    c = Class.new(Sequel::Model).set_dataset(:a)
+    c.dataset = c.dataset.extension(:current_datetime_timestamp)
+    c.plugin :touch
+    c.columns :id, :updated_at
+    c.load(:id=>1).touch
+    DB.sqls.should == ["UPDATE a SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
   specify "should allow #touch instance method for updating the updated_at column" do
     @Artist.plugin :touch
     @a.touch

data/spec/integration/database_test.rb

@@ -53,7 +53,7 @@ describe Sequel::Database do
       proc{@db[:test].update(:a=>'1', :b=>'2')}.should raise_error(Sequel::UniqueConstraintViolation)
     end
 
-    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, :sqlite, [:db2] do
+    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, [:db2], [proc{|db| db.sqlite_version < 30802}, :sqlite] do
       @db.create_table!(:test){String :a; check Sequel.~(:a=>'1')}
       proc{@db[:test].insert('1')}.should raise_error(Sequel::CheckConstraintViolation)
       @db[:test].insert('2')

data/spec/integration/dataset_test.rb

@@ -124,17 +124,39 @@ describe "Simple Dataset operations" do
   specify "should support iterating over large numbers of records with paged_each" do
     (2..100).each{|i| @ds.insert(:number=>i*10)}
 
+    [:offset, :filter].each do |strategy|
+      rows = []
+      @ds.order(:number).paged_each(:rows_per_fetch=>5, :strategy=>strategy){|row| rows << row}
+      rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+      rows = []
+      @ds.order(:number).paged_each(:rows_per_fetch=>3, :strategy=>strategy){|row| rows << row}
+      rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+      rows = []
+      @ds.order(:number, :id).paged_each(:rows_per_fetch=>5, :strategy=>strategy){|row| rows << row}
+      rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+
+      rows = []
+      @ds.reverse_order(:number).paged_each(:rows_per_fetch=>5, :strategy=>strategy){|row| rows << row}
+      rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}.reverse
+
+      rows = []
+      @ds.order(Sequel.desc(:number), :id).paged_each(:rows_per_fetch=>5, :strategy=>strategy){|row| rows << row}
+      rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}.reverse
+    end
+
     rows = []
-    @ds.order(:number).paged_each(:rows_per_fetch=>5){|row| rows << row}
-    rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
+    @ds.order(:number).limit(50, 25).paged_each(:rows_per_fetch=>3){|row| rows << row}
+    rows.should == (26..75).map{|i| {:id=>i, :number=>i*10}}
 
     rows = []
-    @ds.order(:number).paged_each(:rows_per_fetch=>3){|row| rows << row}
+    @ds.order(Sequel.*(:number, 2)).paged_each(:rows_per_fetch=>5){|row| rows << row}
     rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
 
     rows = []
-    @ds.order(:number).limit(50, 25).paged_each(:rows_per_fetch=>3){|row| rows << row}
-    rows.should == (26..75).map{|i| {:id=>i, :number=>i*10}}
+    @ds.order(Sequel.*(:number, 2)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, :filter_values=>proc{|row, _| [row[:number] * 2]}){|row| rows << row}
+    rows.should == (1..100).map{|i| {:id=>i, :number=>i*10}}
   end
 
   specify "should fetch all results correctly" do

data/spec/model/eager_loading_spec.rb

@@ -1725,6 +1725,8 @@ describe Sequel::Model, "#eager_graph" do
     c1.many_to_many :a_genres, :class=>c2, :left_primary_key=>:id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:s__ag
     ds = c1.join(:s__t, [:b_id]).eager_graph(:a_genres)
     ds.sql.should == 'SELECT a.id, a_genres.id AS a_genres_id FROM (SELECT * FROM s.a INNER JOIN s.t USING (b_id)) AS a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
+    ds = c1.eager_graph(:a_genres)
+    ds.sql.should == 'SELECT s.a.id, a_genres.id AS a_genres_id FROM s.a LEFT OUTER JOIN s.ag AS ag ON (ag.album_id = s.a.id) LEFT OUTER JOIN s.g AS a_genres ON (a_genres.id = ag.genre_id)'
   end
 
   it "should respect :after_load callbacks on associations when eager graphing" do
@@ -1868,3 +1870,33 @@ describe Sequel::Model, "#eager_graph" do
     a.album.tracks.should == [GraphTrack.load(:id => 3, :album_id => 1)]
   end
 end
+
+describe "Sequel::Models with double underscores in table names" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>1, :foo_id=>2})
+    @Foo = Class.new(Sequel::Model(@db[Sequel.identifier(:fo__os)]))
+    @Foo.columns :id, :foo_id
+    @Foo.one_to_many :foos, :class=>@Foo
+    @db.sqls
+  end
+
+  it "should have working eager_graph implementations" do
+    @db.fetch = {:id=>1, :foo_id=>1, :foos_id=>1, :foos_foo_id=>1}
+    foos = @Foo.eager_graph(:foos).all
+    @db.sqls.should == ["SELECT fo__os.id, fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM fo__os LEFT OUTER JOIN (SELECT * FROM fo__os) AS foos ON (foos._id = fo__os.id)"]
+    foos.should == [@Foo.load(:id=>1, :foo_id=>1)]
+    foos.first.foos.should == [@Foo.load(:id=>1, :foo_id=>1)]
+  end
+
+  it "should have working eager_graph implementations when qualified" do
+    @Foo.dataset = Sequel.identifier(:fo__os).qualify(:s)
+    @Foo.columns :id, :foo_id
+    @db.sqls
+    @db.fetch = {:id=>1, :foo_id=>1, :foos_id=>1, :foos_foo_id=>1}
+    foos = @Foo.eager_graph(:foos).all
+    @db.sqls.should == ["SELECT s.fo__os.id, s.fo__os.foo_id, foos.id AS foos_id, foos.foo_id AS foos_foo_id FROM s.fo__os LEFT OUTER JOIN (SELECT * FROM s.fo__os) AS foos ON (foos._id = s.fo__os.id)"]
+    foos.should == [@Foo.load(:id=>1, :foo_id=>1)]
+    foos.first.foos.should == [@Foo.load(:id=>1, :foo_id=>1)]
+  end
+end
+

data/spec/model/model_spec.rb

@@ -418,6 +418,113 @@ describe Sequel::Model, ".find" do
   end
 end
 
+describe Sequel::Model, ".finder" do
+  before do
+    @h = {:id=>1}
+    @db = Sequel.mock(:fetch=>@h)
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.instance_eval do
+      def foo(a, b)
+        where(:bar=>a).order(b)
+      end
+    end
+    @o = @c.load(@h)
+    @db.sqls
+  end
+
+  specify "should create a method that calls the method given and returns the first instance" do
+    @c.finder :foo
+    @c.first_foo(1, 2).should == @o
+    @c.first_foo(3, 4).should == @o
+    @db.sqls.should == ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  specify "should work correctly when subclassing" do
+    @c.finder(:foo)
+    @sc = Class.new(@c)
+    @sc.set_dataset :foos
+    @db.sqls
+    @sc.first_foo(1, 2).should == @sc.load(@h)
+    @sc.first_foo(3, 4).should == @sc.load(@h)
+    @db.sqls.should == ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  specify "should work correctly when dataset is modified" do
+    @c.finder(:foo)
+    @c.first_foo(1, 2).should == @o
+    @c.set_dataset :foos
+    @c.first_foo(3, 4).should == @o
+    @db.sqls.should == ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  specify "should create a method based on the given block if no method symbol provided" do
+    @c.finder(:name=>:first_foo){|pl, ds| ds.where(pl.arg).limit(1)}
+    @c.first_foo(:id=>1).should == @o
+    @db.sqls.should == ["SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+  end
+
+  specify "should raise an error if both a block and method symbol given" do
+    proc{@c.finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if two option hashes are provided" do
+    proc{@c.finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should support :type option" do
+    @c.finder :foo, :type=>:all
+    @c.finder :foo, :type=>:each
+    @c.finder :foo, :type=>:get
+
+    a = []
+    @c.all_foo(1, 2){|r| a << r}.should == [@o]
+    a.should == [@o]
+   
+    a = []
+    @c.each_foo(3, 4){|r| a << r}
+    a.should == [@o]
+
+    @c.get_foo(5, 6).should == [:id, 1]
+
+    @db.sqls.should == ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4", "SELECT * FROM items WHERE (bar = 5) ORDER BY 6 LIMIT 1"]
+  end
+
+  specify "should support :name option" do
+    @c.finder :foo, :name=>:find_foo
+    @c.find_foo(1, 2).should == @o
+    @c.find_foo(3, 4).should == @o
+    @db.sqls.should == ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  specify "should support :arity option" do
+    def @c.foobar(*b)
+      ds = dataset
+      b.each_with_index do |a, i|
+        ds = ds.where(i=>a)
+      end
+      ds
+    end
+    @c.finder :foobar, :arity=>1, :name=>:find_foobar_1
+    @c.finder :foobar, :arity=>2, :name=>:find_foobar_2
+    @c.find_foobar_1(:a)
+    @c.find_foobar_2(:a, :b)
+    @db.sqls.should == ["SELECT * FROM items WHERE (0 = a) LIMIT 1", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1"]
+  end
+
+  specify "should support :mod option" do
+    m = Module.new
+    @c.finder :foo, :mod=>m
+    proc{@c.first_foo}.should raise_error
+    @c.extend m
+    @c.first_foo(1, 2).should == @o
+    @c.first_foo(3, 4).should == @o
+    @db.sqls.should == ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  specify "should raise error when callign with the wrong arity" do
+  end
+end
+
 describe Sequel::Model, ".fetch" do
   before do
     DB.reset
@@ -437,32 +544,35 @@ end
 
 describe Sequel::Model, ".find_or_create" do
   before do
-    @c = Class.new(Sequel::Model(:items)) do
+    @db = Sequel.mock
+    @c = Class.new(Sequel::Model(@db[:items])) do
       set_primary_key :id
       columns :x
     end
-    DB.reset
+    @db.sqls
   end
 
   it "should find the record" do
+    @db.fetch = [{:x=>1, :id=>1}]
+    @db.autoid = 1
     @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
-    DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
+    @db.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
   end
   
   it "should create the record if not found" do
-    @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
-    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @db.fetch = [[], {:x=>1, :id=>1}]
+    @db.autoid = 1
     @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
-    DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
+    @db.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
       "INSERT INTO items (x) VALUES (1)",
       "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
 
   it "should pass the new record to be created to the block if no record is found" do
-    @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
-    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @db.fetch = [[], {:x=>1, :id=>1}]
+    @db.autoid = 1
     @c.find_or_create(:x => 1){|x| x[:y] = 2}.should == @c.load(:x=>1, :id=>1)
-    sqls = DB.sqls
+    sqls = @db.sqls
     sqls.first.should == "SELECT * FROM items WHERE (x = 1) LIMIT 1"
     ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[1])
     sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"