sequel 3.47.0 → 3.48.0

data/spec/extensions/schema_caching_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "schema_caching extension" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock.extension(:schema_caching)
     @schemas = {'"table"'=>[[:column, {:db_type=>"integer", :default=>"nextval('table_id_seq'::regclass)", :allow_null=>false, :primary_key=>true, :type=>:integer, :ruby_default=>nil}]]}
     @filename = "spec/files/test_schema_#$$.dump" 
     @db.instance_variable_set(:@schemas, @schemas)
@@ -20,7 +20,7 @@ describe "schema_caching extension" do
 
   it "Database#load_schema_cache should load cached schema from the given file dumped by #dump_schema_cache" do
     @db.dump_schema_cache(@filename)
-    db = Sequel::Database.new
+    db = Sequel::Database.new.extension(:schema_caching)
     db.load_schema_cache(@filename)
     @db.instance_variable_get(:@schemas).should == @schemas
   end
@@ -33,7 +33,7 @@ describe "schema_caching extension" do
   end
 
   it "Database#load_schema_cache? should load cached schema from the given file if it exists" do
-    db = Sequel::Database.new
+    db = Sequel::Database.new.extension(:schema_caching)
     File.exist?(@filename).should be_false
     db.load_schema_cache?(@filename)
     db.instance_variable_get(:@schemas).should == {}

data/spec/extensions/schema_dumper_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "Sequel::Schema::Generator dump methods" do
   before do
-    @d = Sequel::Database.new
+    @d = Sequel::Database.new.extension(:schema_dumper)
     @g = Sequel::Schema::Generator
   end
 
@@ -64,7 +64,7 @@ end
 
 describe "Sequel::Database dump methods" do
   before do
-    @d = Sequel::Database.new
+    @d = Sequel::Database.new.extension(:schema_dumper)
     @d.meta_def(:tables){|o| [:t1, :t2]}
     @d.meta_def(:schema) do |t, *o|
       case t
@@ -99,12 +99,14 @@ describe "Sequel::Database dump methods" do
 
   it "should handle foreign keys" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
     @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  foreign_key :c1, :t2, :key=>[:c2]\nend"
   end
 
   it "should handle primary keys that are also foreign keys" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
     s = @d.dump_table_schema(:t6)
     s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
@@ -114,6 +116,7 @@ describe "Sequel::Database dump methods" do
 
   it "should handle foreign key options" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
     s = @d.dump_table_schema(:t6)
     s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
@@ -125,6 +128,7 @@ describe "Sequel::Database dump methods" do
 
   it "should handle foreign key options in the primary key" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
     s = @d.dump_table_schema(:t6)
     s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
@@ -137,6 +141,7 @@ describe "Sequel::Database dump methods" do
 
   it "should omit foreign key options that are the same as defaults" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
     s = @d.dump_table_schema(:t6)
     s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
@@ -148,6 +153,7 @@ describe "Sequel::Database dump methods" do
 
   it "should omit foreign key options that are the same as defaults in the primary key" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
     s = @d.dump_table_schema(:t6)
     s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
@@ -169,11 +175,13 @@ describe "Sequel::Database dump methods" do
 
   it "should use a composite foreign_key calls if there is a composite foreign key" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer'}], [:c2, {:db_type=>'integer'}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}]}
     @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  Integer :c1\n  Integer :c2\n  \n  foreign_key [:c1, :c2], :t2, :key=>[:c3, :c4]\nend"
   end
 
   it "should include index information if available" do
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
@@ -227,6 +235,7 @@ END_MIG
     @d.meta_def(:schema) do |t|
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
     end
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
@@ -250,6 +259,7 @@ END_MIG
     @d.meta_def(:schema) do |t|
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
     end
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : [{:columns=>[:c1], :table=>:t1, :key=>[:c2]}]
     end
@@ -277,6 +287,7 @@ END_MIG
     @d.meta_def(:schema) do |t|
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
     end
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
       raise Sequel::DatabaseError unless [:t1, :t2].include?(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
@@ -318,6 +329,7 @@ END_MIG
   end
 
   it "should honor the :index_names => false option to not include names of indexes" do
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
@@ -349,6 +361,7 @@ END_MIG
   end
   
   it "should make :index_names => :namespace option a noop if there is a  global index namespace" do
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
@@ -381,6 +394,7 @@ END_MIG
 
   it "should honor the :index_names => :namespace option to include names of indexes with prepended table name if there is no global index namespace" do
     @d.meta_def(:global_index_namespace?){false}
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
@@ -412,6 +426,7 @@ END_MIG
   end
 
   it "should honor the :indexes => false option to not include indexes" do
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
@@ -444,6 +459,7 @@ END_MIG
   end
 
   it "should have :foreign_keys option override :indexes => false disabling of foreign keys" do
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
@@ -452,6 +468,7 @@ END_MIG
 
   it "should support dumping just indexes as a migration" do
     @d.meta_def(:tables){|o| [:t1]}
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
@@ -468,6 +485,7 @@ END_MIG
 
   it "should honor the :index_names => false option to not include names of indexes when dumping just indexes as a migration" do
     @d.meta_def(:tables){|o| [:t1]}
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
@@ -484,6 +502,7 @@ END_MIG
 
   it "should honor the :index_names => :namespace option be a noop if there is a global index namespace" do
     @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
@@ -504,6 +523,7 @@ END_MIG
   it "should honor the :index_names => :namespace option to include names of indexes with prepended table name when dumping just indexes as a migration if there is no global index namespace" do
     @d.meta_def(:global_index_namespace?){false}
     @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:supports_index_parsing?){true}
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
@@ -548,6 +568,7 @@ END_MIG
     @d.meta_def(:schema) do |t|
       t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer'}]]
     end
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t, *a|
       case t
       when :t1
@@ -601,6 +622,8 @@ END_MIG
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
     @d.meta_def(:database_type){:mysql}
+    @d.meta_def(:supports_index_parsing?){false}
+    @d.meta_def(:supports_foreign_key_parsing?){false}
     @d.meta_def(:schema) do |t, *os|
       s = [[:c10, {:db_type=>'foo', :default=>"'6 weeks'", :type=>nil, :allow_null=>true}]]
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
@@ -739,6 +762,7 @@ END_MIG
 
   it "should use explicit type for non integer foreign_key types" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :primary_key=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>Date, :key=>[:c1]\n  \n  primary_key [:c1]\nend",
      "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>Date\n  \n  primary_key [:c1]\nend"].should include(@d.dump_table_schema(:t4))
@@ -748,6 +772,7 @@ END_MIG
 
   it "should correctly handing autoincrementing primary keys that are also foreign keys" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true}]]}
+    @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",
      "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].should include(@d.dump_table_schema(:t4))

data/spec/extensions/schema_spec.rb

@@ -91,12 +91,12 @@ describe Sequel::Model, "schema methods" do
 
   it "drop_table? should drop the table if it exists" do
     @model.drop_table?
-    MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items']
+    MODEL_DB.sqls.should == ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items']
   end
   
   it "create_table! should drop table if it exists and then create the table" do
     @model.create_table!
-    MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
+    MODEL_DB.sqls.should == ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
   end
   
   it "create_table? should not create the table if it already exists" do

data/spec/extensions/scissors_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "scissors plugin" do
+  before do
+    @m = Class.new(Sequel::Model(:items))
+    @m.use_transactions = true
+    @m.plugin :scissors
+    @m.db.sqls
+  end
+
+  it "Model.delete should delete from the dataset" do
+    @m.delete
+    @m.db.sqls.should == ['DELETE FROM items']
+  end
+
+  it "Model.update should update the dataset" do
+    @m.update(:a=>1)
+    @m.db.sqls.should == ['UPDATE items SET a = 1']
+  end
+
+  it "Model.destory each instance in the dataset" do
+    @m.dataset._fetch = {:id=>1}
+    @m.destroy
+    @m.db.sqls.should == ['BEGIN', 'SELECT * FROM items', 'DELETE FROM items WHERE id = 1', 'COMMIT']
+  end
+end

data/spec/extensions/select_remove_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Dataset#select_remove" do
   before do
-    @d = Sequel.mock.from(:test)
+    @d = Sequel.mock.from(:test).extension(:select_remove)
     @d.columns :a, :b, :c
   end
   

data/spec/extensions/sequel_3_dataset_methods_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Dataset#to_csv" do
+  before do
+    @ds = Sequel.mock(:fetch=>[{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9}])[:items].columns(:a, :b, :c).extension(:sequel_3_dataset_methods)
+  end
+  
+  specify "should format a CSV representation of the records" do
+    @ds.to_csv.should == "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  end
+
+  specify "should exclude column titles if so specified" do
+    @ds.to_csv(false).should == "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  end
+end
+
+describe "Dataset#[]=" do
+  specify "should perform an update on the specified filter" do
+    db = Sequel.mock
+    ds = db[:items].extension(:sequel_3_dataset_methods)
+    ds[:a => 1] = {:x => 3}
+    db.sqls.should == ['UPDATE items SET x = 3 WHERE (a = 1)']
+  end
+end
+
+describe "Dataset#insert_multiple" do
+  before do
+    @db = Sequel.mock(:autoid=>2)
+    @ds = @db[:items].extension(:sequel_3_dataset_methods)
+  end
+  
+  specify "should insert all items in the supplied array" do
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}])
+    @db.sqls.should == ["INSERT INTO items VALUES ('aa')",
+      "INSERT INTO items VALUES (5)",
+      "INSERT INTO items VALUES (3)",
+      "INSERT INTO items (a) VALUES (2)"]
+  end
+  
+  specify "should pass array items through the supplied block if given" do
+    @ds.insert_multiple(["inevitable", "hello", "the ticking clock"]){|i| i.gsub('l', 'r')}
+    @db.sqls.should == ["INSERT INTO items VALUES ('inevitabre')",
+      "INSERT INTO items VALUES ('herro')",
+      "INSERT INTO items VALUES ('the ticking crock')"]
+  end
+
+  specify "should return array of inserted ids" do
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).should == [2, 3, 4, 5]
+  end
+
+  specify "should work exactly like in metioned in the example" do
+    @ds.insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2 ; row }
+    sqls = @db.sqls
+    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[0])
+    ["INSERT INTO items (x, y) VALUES (2, 4)", "INSERT INTO items (y, x) VALUES (4, 2)"].should include(sqls[1])
+  end
+end
+
+describe "Dataset#db=" do
+  specify "should change the dataset's database" do
+    db = Sequel.mock
+    ds = db[:items].extension(:sequel_3_dataset_methods)
+    db2 = Sequel.mock
+    ds.db = db2
+    ds.db.should == db2
+    ds.db.should_not == db
+  end
+end
+
+describe "Dataset#opts=" do
+  specify "should change the dataset's opts" do
+    db = Sequel.mock
+    ds = db[:items].extension(:sequel_3_dataset_methods)
+    db2 = Sequel.mock
+    ds.sql.should == 'SELECT * FROM items'
+    ds.opts = {}
+    ds.sql.should == 'SELECT *'
+    ds.opts.should == {}
+  end
+end
+
+describe "Dataset#set" do
+  specify "should act as alias to #update" do
+    db = Sequel.mock
+    ds = db[:items].extension(:sequel_3_dataset_methods)
+    ds.set({:x => 3})
+    db.sqls.should == ['UPDATE items SET x = 3']
+  end
+end
+
+describe "Sequel::Dataset#qualify_to_first_source" do
+  specify "should qualify to the first source" do
+    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a < t.b)'
+  end
+end
+
+describe "Sequel::Dataset#qualify_to" do
+  specify "should qualify to the given table" do
+    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+  end
+end
+

data/spec/extensions/set_overrides_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Dataset #set_defaults" do
+  before do
+    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
+  end
+
+  specify "should set the default values for inserts" do
+    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:x=>2).should == "INSERT INTO items (x) VALUES (2)"
+    @ds.insert_sql(:y=>2).should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
+    @ds.set_defaults(:y=>2).insert_sql.should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
+    @ds.set_defaults(:x=>2).insert_sql.should == "INSERT INTO items (x) VALUES (2)"
+  end
+
+  specify "should set the default values for updates" do
+    @ds.update_sql.should == "UPDATE items SET x = 1"
+    @ds.update_sql(:x=>2).should == "UPDATE items SET x = 2"
+    @ds.update_sql(:y=>2).should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
+    @ds.set_defaults(:y=>2).update_sql.should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
+    @ds.set_defaults(:x=>2).update_sql.should == "UPDATE items SET x = 2"
+  end
+end
+
+describe "Sequel::Dataset #set_overrides" do
+  before do
+    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
+  end
+
+  specify "should override the given values for inserts" do
+    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:x=>2).should == "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:y=>2).should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
+    @ds.set_overrides(:y=>2).insert_sql.should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
+    @ds.set_overrides(:x=>2).insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+  end
+
+  specify "should override the given values for updates" do
+    @ds.update_sql.should == "UPDATE items SET x = 1"
+    @ds.update_sql(:x=>2).should == "UPDATE items SET x = 1"
+    @ds.update_sql(:y=>2).should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
+    @ds.set_overrides(:y=>2).update_sql.should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
+    @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1"
+  end
+end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -121,6 +121,16 @@ describe Sequel::Model, "single table inheritance plugin" do
       Object.send(:remove_const, :StiTest4)
     end
 
+    specify "should have working row_proc if using set_dataset in subclass to remove columns" do
+      StiTest2.plugin :single_table_inheritance, :kind
+      class ::StiTest3 < ::StiTest2
+        set_dataset(dataset.select(*(columns - [:blah])))
+      end
+      class ::StiTest4 < ::StiTest3; end
+      StiTest3.dataset._fetch = {:id=>1, :kind=>'StiTest4'}
+      StiTest3[1].should == StiTest4.load(:id=>1, :kind=>'StiTest4')
+    end
+
     it "should work with custom procs with strings" do
       StiTest2.plugin :single_table_inheritance, :kind, :model_map=>proc{|v| v == 1 ? 'StiTest3' : 'StiTest4'}, :key_map=>proc{|klass| klass.name == 'StiTest3' ? 1 : 2}
       class ::StiTest3 < ::StiTest2; end

data/spec/extensions/spec_helper.rb

@@ -17,6 +17,8 @@ unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel/no_core_ext'
 end
+Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
+SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING = true
 
 begin
   # Attempt to load ActiveSupport blank extension and inflector first, so Sequel
@@ -42,6 +44,26 @@ def skip_warn(s)
   warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
 end
 
+(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+  if ENV['SEQUEL_DEPRECATION_WARNINGS']
+    class << self
+      alias qspecify specify
+    end
+  else
+    def self.qspecify(*a, &block)
+      specify(*a) do
+        begin
+          output = Sequel::Deprecation.output
+          Sequel::Deprecation.output = false
+          instance_exec(&block)
+        ensure
+          Sequel::Deprecation.output = output 
+        end
+      end
+    end
+  end
+end
+
 Sequel.quote_identifiers = false
 Sequel.identifier_input_method = nil
 Sequel.identifier_output_method = nil
@@ -61,9 +83,10 @@ class << Sequel::Model
 end
 
 Sequel::Model.use_transactions = false
-Sequel::Model.cache_anonymous_models = false
+Sequel.cache_anonymous_models = false
 
 db = Sequel.mock(:fetch=>{:id => 1, :x => 1}, :numrows=>1, :autoid=>proc{|sql| 10})
 def db.schema(*) [[:id, {:primary_key=>true}]] end
 def db.reset() sqls end
+def db.supports_schema_parsing?() true end
 Sequel::Model.db = MODEL_DB = db