sequel 3.21.0 → 3.39.0

data/spec/model/model_spec.rb

@@ -12,13 +12,48 @@ describe "Sequel::Model()" do
     c.dataset.should == ds
   end
 
-  it "should return a model subclass with a dataset with the default database and given table name if given a symbol" do
+  it "should return a model subclass with a dataset with the default database and given table name if given a Symbol" do
     c = Sequel::Model(:blah)
     c.superclass.should == Sequel::Model
     c.db.should == @db
     c.table_name.should == :blah
   end
 
+  it "should return a model subclass with a dataset with the default database and given table name if given a LiteralString" do
+    c = Sequel::Model(Sequel.lit('blah'))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == Sequel.lit('blah')
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::Identifier" do
+    c = Sequel::Model(Sequel.identifier(:blah))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == Sequel.identifier(:blah)
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::QualifiedIdentifier" do
+    c = Sequel::Model(Sequel.qualify(:boo, :blah))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == Sequel.qualify(:boo, :blah)
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::AliasedExpression" do
+    c = Sequel::Model(Sequel.as(:blah, :boo))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :boo
+  end
+
+  it "should return a model subclass with the given dataset if given a dataset using an SQL::Identifier" do
+    ds = @db[Sequel.identifier(:blah)]
+    c = Sequel::Model(ds)
+    c.superclass.should == Sequel::Model
+    c.dataset.should == ds
+  end
+
   it "should return a model subclass associated to the given database if given a database" do
     db = Sequel::Database.new
     c = Sequel::Model(db)
@@ -32,7 +67,11 @@ describe "Sequel::Model()" do
   end
 
   describe "reloading" do
+    before do
+      Sequel::Model.cache_anonymous_models = true
+    end
     after do
+      Sequel::Model.cache_anonymous_models = false
       Object.send(:remove_const, :Album) if defined?(::Album)
     end
 
@@ -43,6 +82,34 @@ describe "Sequel::Model()" do
       end.should_not raise_error
     end
 
+    it "should work without raising an exception with an SQL::Identifier " do
+      proc do
+        class ::Album < Sequel::Model(Sequel.identifier(:table)); end
+        class ::Album < Sequel::Model(Sequel.identifier(:table)); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::QualifiedIdentifier " do
+      proc do
+        class ::Album < Sequel::Model(Sequel.qualify(:schema, :table)); end
+        class ::Album < Sequel::Model(Sequel.qualify(:schema, :table)); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::AliasedExpression" do
+      proc do
+        class ::Album < Sequel::Model(Sequel.as(:table, :alias)); end
+        class ::Album < Sequel::Model(Sequel.as(:table, :alias)); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an LiteralString" do
+      proc do
+        class ::Album < Sequel::Model(Sequel.lit('table')); end
+        class ::Album < Sequel::Model(Sequel.lit('table')); end
+      end.should_not raise_error
+    end
+
     it "should work without raising an exception with a database" do
       proc do
         class ::Album < Sequel::Model(@db); end
@@ -56,6 +123,21 @@ describe "Sequel::Model()" do
         class ::Album < Sequel::Model(@db[:table]); end
       end.should_not raise_error
     end
+
+    it "should work without raising an exception with a dataset with an SQL::Identifier" do
+      proc do
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+      end.should_not raise_error
+    end
+
+    it "should raise an exception if anonymous model caching is disabled" do
+      Sequel::Model.cache_anonymous_models = false
+      proc do
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+        class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
+      end.should raise_error
+    end
   end
 end
 
@@ -70,17 +152,16 @@ describe Sequel::Model do
   it "should be associated with a dataset" do
     model_a = Class.new(Sequel::Model) { set_dataset MODEL_DB[:as] }
 
-    model_a.dataset.should be_a_kind_of(MockDataset)
+    model_a.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_a.dataset.opts[:from].should == [:as]
 
     model_b = Class.new(Sequel::Model) { set_dataset MODEL_DB[:bs] }
 
-    model_b.dataset.should be_a_kind_of(MockDataset)
+    model_b.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_b.dataset.opts[:from].should == [:bs]
 
     model_a.dataset.opts[:from].should == [:as]
   end
-
 end
 
 describe Sequel::Model, "dataset & schema" do
@@ -106,12 +187,36 @@ describe Sequel::Model, "dataset & schema" do
     @model.table_name.should == :foo
   end
 
-  it "set_dataset should take a symbol" do
+  it "set_dataset should take a Symbol" do
     @model.db = MODEL_DB
     @model.set_dataset(:foo)
     @model.table_name.should == :foo
   end
 
+  it "set_dataset should take a LiteralString" do
+    @model.db = MODEL_DB
+    @model.set_dataset(Sequel.lit('foo'))
+    @model.table_name.should == Sequel.lit('foo')
+  end
+
+  it "set_dataset should take an SQL::Identifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(Sequel.identifier(:foo))
+    @model.table_name.should == Sequel.identifier(:foo)
+  end
+
+  it "set_dataset should take an SQL::QualifiedIdentifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(Sequel.qualify(:bar, :foo))
+    @model.table_name.should == Sequel.qualify(:bar, :foo)
+  end
+
+  it "set_dataset should take an SQL::AliasedExpression" do
+    @model.db = MODEL_DB
+    @model.set_dataset(Sequel.as(:foo, :bar))
+    @model.table_name.should == :bar
+  end
+
   it "table_name should respect table aliases" do
     @model.set_dataset(:foo___x)
     @model.table_name.should == :x
@@ -121,16 +226,30 @@ describe Sequel::Model, "dataset & schema" do
     proc{@model.set_dataset(Object.new)}.should raise_error(Sequel::Error)
   end
 
-  it "set_dataset should add the destroy method to the dataset" do
+  it "set_dataset should add the destroy method to the dataset that destroys each object" do
     ds = MODEL_DB[:foo]
     ds.should_not respond_to(:destroy)
     @model.set_dataset(ds)
     ds.should respond_to(:destroy)
+    MODEL_DB.sqls
+    ds._fetch = [{:id=>1}, {:id=>2}]
+    ds.destroy.should == 2
+    MODEL_DB.sqls.should == ["SELECT * FROM foo", "DELETE FROM foo WHERE id = 1", "DELETE FROM foo WHERE id = 2"]
+  end
+
+  it "set_dataset should add the destroy method that respects sharding with transactions" do
+    db = Sequel.mock(:servers=>{:s1=>{}})
+    ds = db[:foo].server(:s1)
+    @model.use_transactions = true
+    @model.set_dataset(ds)
+    db.sqls
+    ds.destroy.should == 0
+    db.sqls.should == ["BEGIN -- s1", "SELECT * FROM foo -- s1", "COMMIT -- s1"]
   end
 
   it "should raise an error on set_dataset if there is an error connecting to the database" do
     @model.meta_def(:columns){raise Sequel::DatabaseConnectionError}
-    proc{@model.set_dataset(MODEL_DB[:foo].join(:blah))}.should raise_error
+    proc{@model.set_dataset(Sequel::Database.new[:foo].join(:blah))}.should raise_error
   end
 
   it "should not raise an error if there is a problem getting the columns for a dataset" do
@@ -149,9 +268,8 @@ describe Sequel::Model, "dataset & schema" do
   end
 end
 
-describe Sequel::Model, "constructor" do
-  
-  before(:each) do
+describe Sequel::Model, "constructors" do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :a, :b
   end
@@ -170,11 +288,38 @@ describe Sequel::Model, "constructor" do
     m.values[:a].should == 1
   end
   
+  it "should have dataset row_proc create an existing object" do
+    @m.dataset = Sequel::Dataset.new(nil)
+    o = @m.dataset.row_proc.call(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "should have .call create an existing object" do
+    o = @m.call(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "should have .load create an existing object" do
+    o = @m.load(:a=>1)
+    o.should be_a_kind_of(@m)
+    o.values.should == {:a=>1}
+    o.new?.should be_false
+  end
+  
+  it "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}
+    o.new?.should be_false
+  end
 end
 
 describe Sequel::Model, "new" do
-
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model) do
       set_dataset MODEL_DB[:items]
       columns :x, :id
@@ -194,15 +339,8 @@ describe Sequel::Model, "new" do
   end
 
   it "should use the last inserted id as primary key if not in values" do
-    d = @m.dataset
-    def d.insert(*args)
-      super
-      1234
-    end
-
-    def d.first
-      {:x => 1, :id => 1234}
-    end
+    @m.instance_dataset._fetch = @m.dataset._fetch = {:x => 1, :id => 1234}
+    @m.instance_dataset.autoid = @m.dataset.autoid = 1234
 
     o = @m.new(:x => 1)
     o.save
@@ -212,25 +350,23 @@ describe Sequel::Model, "new" do
     o.save
     o.id.should == 333
   end
-
 end
 
 describe Sequel::Model, ".subset" do
   before do
-    MODEL_DB.reset
-
     @c = Class.new(Sequel::Model(:items))
+    MODEL_DB.reset
   end
 
   specify "should create a filter on the underlying dataset" do
     proc {@c.new_only}.should raise_error(NoMethodError)
     
-    @c.subset(:new_only) {:age.sql_number < 'new'}
+    @c.subset(:new_only){age < 'new'}
     
     @c.new_only.sql.should == "SELECT * FROM items WHERE (age < 'new')"
     @c.dataset.new_only.sql.should == "SELECT * FROM items WHERE (age < 'new')"
     
-    @c.subset(:pricey) {:price.sql_number > 100}
+    @c.subset(:pricey){price > 100}
     
     @c.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
@@ -247,44 +383,31 @@ describe Sequel::Model, ".subset" do
 end
 
 describe Sequel::Model, ".find" do
-
-  before(:each) do
-    MODEL_DB.reset
-    
+  before do
     @c = Class.new(Sequel::Model(:items))
-    
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-    })
+    @c.dataset._fetch = {:name => 'sharon', :id => 1}
+    MODEL_DB.reset
   end
   
   it "should return the first record matching the given filter" do
     @c.find(:name => 'sharon').should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"]
 
-    @c.find(:name.like('abc%')).should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"
+    @c.find(Sequel.expr(:name).like('abc%')).should be_a_kind_of(@c)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"]
   end
   
   specify "should accept filter blocks" do
-    @c.find{:id.sql_number > 1}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id > 1) LIMIT 1"
+    @c.find{id > 1}.should be_a_kind_of(@c)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id > 1) LIMIT 1"]
 
-    @c.find {(:x.sql_number > 1) & (:y.sql_number < 2)}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"
+    @c.find{(x > 1) & (y < 2)}.should be_a_kind_of(@c)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"]
   end
-
 end
 
 describe Sequel::Model, ".fetch" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items))
   end
@@ -301,80 +424,53 @@ describe Sequel::Model, ".fetch" do
 end
 
 describe Sequel::Model, ".find_or_create" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
+      set_primary_key :id
       columns :x
     end
+    MODEL_DB.reset
   end
 
   it "should find the record" do
-    @c.find_or_create(:x => 1)
+    @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
     MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
-    
-    MODEL_DB.reset
   end
   
   it "should create the record if not found" do
-    @c.meta_def(:find) do |*args|
-      dataset.filter(*args).first
-      nil
-    end
-    
-    @c.find_or_create(:x => 1)
-    MODEL_DB.sqls.should == [
-      "SELECT * FROM items WHERE (x = 1) LIMIT 1",
-      "INSERT INTO items (x) VALUES (1)"
-    ]
+    @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
+    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
+    MODEL_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.meta_def(:find){|*|} 
-    @c.find_or_create(:x => 1){|x| x[:y] = 2}
-    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(MODEL_DB.sqls.first)
+    @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
+    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @c.find_or_create(:x => 1){|x| x[:y] = 2}.should == @c.load(:x=>1, :id=>1)
+    sqls = MODEL_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"
   end
 end
 
 describe Sequel::Model, ".all" do
-  
-  before(:each) do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-    
-    @c.dataset.meta_def(:all) {1234}
-  end
-  
   it "should return all records in the dataset" do
-    @c.all.should == 1234
+    c = Class.new(Sequel::Model(:items))
+    c.all.should == [c.load(:x=>1, :id=>1)]
   end
-  
-end
-
-class DummyModelBased < Sequel::Model(:blog)
-end
-
-describe Sequel::Model, "(:tablename)" do
-
-  it "should allow reopening of descendant classes" do
-    proc do
-      eval "class DummyModelBased < Sequel::Model(:blog); end"
-    end.should_not raise_error
-  end
-
 end
 
 describe Sequel::Model, "A model class without a primary key" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       columns :x
       no_primary_key
     end
+    MODEL_DB.reset
   end
 
   it "should be able to insert records without selecting them back" do
@@ -387,8 +483,11 @@ describe Sequel::Model, "A model class without a primary key" do
   end
 
   it "should raise when deleting" do
-    o = @c.new
-    proc {o.delete}.should raise_error
+    proc{@c.load(:x=>1).delete}.should raise_error
+  end
+
+  it "should raise when updating" do
+    proc{@c.load(:x=>1).update(:x=>2)}.should raise_error
   end
 
   it "should insert a record when saving" do
@@ -397,37 +496,30 @@ describe Sequel::Model, "A model class without a primary key" do
     o.save
     MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
   end
-
 end
 
 describe Sequel::Model, "attribute accessors" do
   before do
-    MODEL_DB.reset
-    @dataset = Sequel::Dataset.new(MODEL_DB)
-    def @dataset.columns; [:x, :y]; end
-    @c = Class.new(Sequel::Model) do
-      def self.db_schema
-         set_columns(Array(@columns))
-        @db_schema = {:x=>{:type=>:integer}, :y=>{:type=>:integer}}
-      end
-      def self.set_dataset(ds, opts={}) 
-        @columns = ds.columns
-        db_schema
-      end
+    db = Sequel.mock
+    def db.schema(*)
+      [[:x, {:type=>:integer}], [:z, {:type=>:integer}]]
     end
+    @dataset = db[:items].columns(:x, :z)
+    @c = Class.new(Sequel::Model)
+    MODEL_DB.reset
   end
 
   it "should be created on set_dataset" do
-    %w'x y x= y='.each do |x|
-      @c.instance_methods.collect{|y| y.to_s}.should_not include(x)
+    %w'x z x= z='.each do |x|
+      @c.instance_methods.collect{|z| z.to_s}.should_not include(x)
     end
     @c.set_dataset(@dataset)
-    %w'x y x= y='.each do |x|
-      @c.instance_methods.collect{|y| y.to_s}.should include(x)
+    %w'x z x= z='.each do |x|
+      @c.instance_methods.collect{|z| z.to_s}.should include(x)
     end
     o = @c.new
-    %w'x y x= y='.each do |x|
-      o.methods.collect{|y| y.to_s}.should include(x)
+    %w'x z x= z='.each do |x|
+      o.methods.collect{|z| z.to_s}.should include(x)
     end
 
     o.x.should be_nil
@@ -446,7 +538,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should have a working typecasting setter even if the column is not selected" do
-    @c.set_dataset(@dataset.select(:y))
+    @c.set_dataset(@dataset.select(:z).columns(:z))
     o = @c.new
 
     o.x = '34'
@@ -454,7 +546,7 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should typecast if the new value is the same as the existing but has a different class" do
-    @c.set_dataset(@dataset.select(:y))
+    @c.set_dataset(@dataset.select(:z).columns(:z))
     o = @c.new
 
     o.x = 34
@@ -466,58 +558,57 @@ describe Sequel::Model, "attribute accessors" do
 end
 
 describe Sequel::Model, ".[]" do
-
-  before(:each) do
-    MODEL_DB.reset
-
+  before do
     @c = Class.new(Sequel::Model(:items))
-
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-    })
+    @c.dataset._fetch = {:name => 'sharon', :id => 1}
+    MODEL_DB.reset
   end
 
   it "should return the first record for the given pk" do
-    @c[1].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
-    @c[9999].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 9999) LIMIT 1"
+    @c[1].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    @c[9999].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 9999"]
+  end
+
+  it "should have #[] return nil if no rows match" do
+    @c.dataset._fetch = []
+    @c[1].should == nil
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
   end
 
   it "should work correctly for custom primary key" do
     @c.set_primary_key :name
-    @c['sharon'].should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"
+    @c['sharon'].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE name = 'sharon'"]
+  end
+
+  it "should return the first record for the given pk for a filtered dataset" do
+    @c.dataset = @c.dataset.filter(:active=>true)
+    @c[1].should == @c.load(:name => 'sharon', :id => 1)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((active IS TRUE) AND (id = 1)) LIMIT 1"]
   end
 
   it "should work correctly for composite primary key specified as array" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].should be_a_kind_of(@c)
-    $sqls.last.should =~ \
-    /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 1
+    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
     @c.set_primary_key :node_id, :kind
     @c[3921, 201].should be_a_kind_of(@c)
-    $sqls.last.should =~ \
-    /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 1
+    sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end
 end
 
 describe "Model#inspect" do
-  before do
-    @o = Sequel::Model.load(:x => 333)
-  end
-  
   specify "should include the class name and the values" do
-    @o.inspect.should == '#<Sequel::Model @values={:x=>333}>'
+    Sequel::Model.load(:x => 333).inspect.should == '#<Sequel::Model @values={:x=>333}>'
   end
 end
 
@@ -526,16 +617,13 @@ describe "Model.db_schema" do
     @c = Class.new(Sequel::Model(:items)) do
       def self.columns; orig_columns; end
     end
-    @dataset = Sequel::Dataset.new(nil).from(:items)
-    @dataset.meta_def(:db){@db ||= Sequel::Database.new}
-    def @dataset.naked; self; end
-    def @dataset.columns; []; end
-    def @dataset.def_mutation_method(*names);  end
+    @db = Sequel.mock
+    @dataset = @db[:items]
   end
   
   specify "should use the database's schema_for_table and set the columns and dataset columns" do
     d = @dataset.db
-    def d.schema(table, opts = {})
+    def @db.schema(table, opts = {})
       [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
     end
     @c.dataset = @dataset
@@ -545,36 +633,20 @@ describe "Model.db_schema" do
   end
 
   specify "should not restrict the schema for datasets with a :select option" do
-    ds = @dataset.select(:x, :y___z)
-    d = ds.db
-    def d.schema(table, opts = {})
+    def @c.columns; [:x, :z]; end
+    def @db.schema(table, opts = {})
       [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
     end
-    def @c.columns; [:x, :z]; end
-    @c.dataset = ds
+    @c.dataset = @dataset.select(:x, :y___z)
     @c.db_schema.should == {:x=>{:type=>:integer}, :z=>{}, :y=>{:type=>:string}}
   end
 
-  specify "should not use schema if the dataset uses multiple tables or custom sql" do
-    ds = @dataset.join(:x, :id)
-    d = ds.db
-    e = false
-    d.meta_def(:schema){|table, *opts| e = true}
-    def @c.columns; [:x]; end
-    @c.dataset = ds
-    @c.db_schema.should == {:x=>{}}
-    e.should == false
-  end
-
   specify "should fallback to fetching records if schema raises an error" do
-    ds = @dataset.join(:x, :id)
-    d = ds.db
-    def d.schema(table, opts={})
-      raise StandardError
+    def @db.schema(table, opts={})
+      raise Sequel::Error
     end
-    def @c.columns; [:x]; end
-    @c.dataset = ds
-    @c.db_schema.should == {:x=>{}}
+    @c.dataset = @dataset.join(:x, :id).columns(:id, :x)
+    @c.db_schema.should == {:x=>{}, :id=>{}}
   end
   
   specify "should automatically set a singular primary key based on the schema" do