sequel 3.48.0 → 4.0.0

data/spec/integration/migrator_test.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 Sequel.extension :migration
 describe Sequel::Migrator do
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @m = Sequel::Migrator
   end
   after do

data/spec/integration/model_test.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Sequel::Model basic support" do 
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items, :engine=>:InnoDB) do
       primary_key :id
       String :name
@@ -201,7 +201,7 @@ end
 
 describe "Sequel::Model with no existing table" do 
   specify "should not raise an error when setting the dataset" do
-    db = INTEGRATION_DB
+    db = DB
     db.drop_table?(:items)
     proc{class ::Item < Sequel::Model(db); end; Object.send(:remove_const, :Item)}.should_not raise_error
     proc{c = Class.new(Sequel::Model); c.set_dataset(db[:items])}.should_not raise_error

data/spec/integration/plugin_test.rb

@@ -2,10 +2,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 # DB2 does not seem to support USING joins in every version; it seems to be
 # valid expression in DB2 iSeries UDB though.
-unless !INTEGRATION_DB.dataset.supports_join_using? || Sequel.guarded?(:db2)
+unless !DB.dataset.supports_join_using? || Sequel.guarded?(:db2)
 describe "Class Table Inheritance Plugin" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.instance_variable_set(:@schemas, {})
     @db.drop_table?(:staff, :executives, :managers, :employees)
     @db.create_table(:employees) do
@@ -148,7 +148,7 @@ end
 
 describe "Many Through Many Plugin" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.instance_variable_set(:@schemas, {})
     @db.drop_table?(:albums_artists, :albums, :artists)
     @db.create_table(:albums) do
@@ -396,7 +396,7 @@ end
 
 describe "Lazy Attributes plugin" do 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -440,7 +440,7 @@ end
 
 describe "Tactical Eager Loading Plugin" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.instance_variable_set(:@schemas, {})
     @db.create_table!(:artists) do
       primary_key :id
@@ -495,7 +495,7 @@ end
 
 describe "Touch plugin" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.drop_table? :albums_artists, :albums, :artists
     @db.create_table(:artists) do
       primary_key :id
@@ -585,7 +585,7 @@ end
 
 describe "Serialization plugin" do 
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items) do
       primary_key :id
       String :stuff
@@ -612,7 +612,7 @@ end
 
 describe "OptimisticLocking plugin" do 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:people) do
       primary_key :id
       String :name
@@ -654,7 +654,7 @@ end
 
 describe "Composition plugin" do 
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:events) do
       primary_key :id
       Integer :year
@@ -706,10 +706,10 @@ describe "Composition plugin" do
 end
 
 # DB2's implemention of CTE is too limited to use this plugin
-if INTEGRATION_DB.dataset.supports_cte? and !Sequel.guarded?(:db2)
+if DB.dataset.supports_cte? and !Sequel.guarded?(:db2)
   describe "RcteTree Plugin" do
     before(:all) do
-      @db = INTEGRATION_DB
+      @db = DB
       @db.create_table!(:nodes) do
         primary_key :id
         Integer :parent_id
@@ -941,7 +941,7 @@ end
 
 describe "Instance Filters plugin" do 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -1004,7 +1004,7 @@ end
 
 describe "UpdatePrimaryKey plugin" do 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:t) do
       Integer :a, :primary_key=>true
       Integer :b
@@ -1062,7 +1062,7 @@ end
 
 describe "AssociationPks plugin" do 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.drop_table?(:albums_tags, :albums_vocalists, :vocalists_instruments, :vocalists_hits, :hits, :instruments, :vocalists, :tags, :albums, :artists)
     @db.create_table(:artists) do
       primary_key :id
@@ -1387,7 +1387,7 @@ end
 
 describe "List plugin without a scope" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:sites) do
       primary_key :id
       String :name
@@ -1461,7 +1461,7 @@ end
 
 describe "List plugin with a scope" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:pages) do
       primary_key :id
       String :name
@@ -1539,7 +1539,7 @@ end
 
 describe "Sequel::Plugins::Tree" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
   end
 
   describe "with natural database order" do
@@ -1704,7 +1704,7 @@ end
 
 describe "Sequel::Plugins::PreparedStatements" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:ps_test) do
       primary_key :id
       String :name
@@ -1777,7 +1777,7 @@ end
 
 describe "Caching plugins" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.drop_table?(:albums, :artists)
     @db.create_table(:artists) do
       primary_key :id
@@ -1840,7 +1840,7 @@ end
 
 describe "Sequel::Plugins::ConstraintValidations" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.extension(:constraint_validations)
     @db.create_constraint_validations_table
     @ds = @db[:cv_test]
@@ -2029,7 +2029,7 @@ describe "date_arithmetic extension" do
   end
 
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.extension(:date_arithmetic)
     if @db.database_type == :sqlite
       @db.use_timestamp_timezones = false

data/spec/integration/prepared_statement_test.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Prepared Statements and Bound Arguments" do
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items) do
       primary_key :id
       integer :numb
@@ -258,7 +258,7 @@ end
 
 describe "Bound Argument Types" do
   before(:all) do
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table!(:items) do
       primary_key :id
       Date :d
@@ -343,9 +343,9 @@ end
 
 describe "Dataset#unbind" do
   before do
-    @ds = ds = INTEGRATION_DB[:items]
+    @ds = ds = DB[:items]
     @ct = proc do |t, v|
-      INTEGRATION_DB.create_table!(:items) do
+      DB.create_table!(:items) do
         column :c, t
       end
       ds.insert(:c=>v)
@@ -353,7 +353,7 @@ describe "Dataset#unbind" do
     @u = proc{|ds1| ds2, bv = ds1.unbind; ds2.call(:first, bv)}
   end
   after do
-    INTEGRATION_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
   
   specify "should unbind values assigned to equality and inequality statements" do
@@ -374,7 +374,7 @@ describe "Dataset#unbind" do
     @ct[String, 'foo']
     @u[@ds.filter(:c=>'foo')].should == {:c=>'foo'}
 
-    INTEGRATION_DB.create_table!(:items) do
+    DB.create_table!(:items) do
       BigDecimal :c, :size=>[15,2]
     end
     @ds.insert(:c=>BigDecimal.new('1.1'))
@@ -395,7 +395,7 @@ describe "Dataset#unbind" do
   end
 
   specify "should handle deep nesting" do
-    INTEGRATION_DB.create_table!(:items) do
+    DB.create_table!(:items) do
       Integer :a
       Integer :b
       Integer :c

data/spec/integration/schema_test.rb

@@ -2,71 +2,71 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Database schema parser" do
   before do
-    @iom = INTEGRATION_DB.identifier_output_method
-    @iim = INTEGRATION_DB.identifier_input_method
-    @qi = INTEGRATION_DB.quote_identifiers?
+    @iom = DB.identifier_output_method
+    @iim = DB.identifier_input_method
+    @qi = DB.quote_identifiers?
   end
   after do
-    INTEGRATION_DB.identifier_output_method = @iom
-    INTEGRATION_DB.identifier_input_method = @iim
-    INTEGRATION_DB.quote_identifiers = @qi
-    INTEGRATION_DB.drop_table?(:items)
+    DB.identifier_output_method = @iom
+    DB.identifier_input_method = @iim
+    DB.quote_identifiers = @qi
+    DB.drop_table?(:items)
   end
 
   specify "should handle a database with a identifier methods" do
-    INTEGRATION_DB.identifier_output_method = :reverse
-    INTEGRATION_DB.identifier_input_method = :reverse
-    INTEGRATION_DB.quote_identifiers = true
-    INTEGRATION_DB.create_table!(:items){Integer :number}
+    DB.identifier_output_method = :reverse
+    DB.identifier_input_method = :reverse
+    DB.quote_identifiers = true
+    DB.create_table!(:items){Integer :number}
     begin
-      INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
-      INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
+      DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
+      DB.schema(:items, :reload=>true).first.first.should == :number
     ensure 
-      INTEGRATION_DB.drop_table(:items)
+      DB.drop_table(:items)
     end
   end
 
   specify "should handle a dataset with identifier methods different than the database's" do
-    INTEGRATION_DB.identifier_output_method = :reverse
-    INTEGRATION_DB.identifier_input_method = :reverse
-    INTEGRATION_DB.quote_identifiers = true
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.identifier_output_method = @iom
-    INTEGRATION_DB.identifier_input_method = @iim
-    ds = INTEGRATION_DB[:items]
+    DB.identifier_output_method = :reverse
+    DB.identifier_input_method = :reverse
+    DB.quote_identifiers = true
+    DB.create_table!(:items){Integer :number}
+    DB.identifier_output_method = @iom
+    DB.identifier_input_method = @iim
+    ds = DB[:items]
     ds.identifier_output_method = :reverse
     ds.identifier_input_method = :reverse
     begin
-      INTEGRATION_DB.schema(ds, :reload=>true).should be_a_kind_of(Array)
-      INTEGRATION_DB.schema(ds, :reload=>true).first.first.should == :number
+      DB.schema(ds, :reload=>true).should be_a_kind_of(Array)
+      DB.schema(ds, :reload=>true).first.first.should == :number
     ensure 
-      INTEGRATION_DB.identifier_output_method = :reverse
-      INTEGRATION_DB.identifier_input_method = :reverse
-      INTEGRATION_DB.drop_table(:items)
+      DB.identifier_output_method = :reverse
+      DB.identifier_input_method = :reverse
+      DB.drop_table(:items)
     end
   end
 
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items, :reload=>true)
-    INTEGRATION_DB.schema(:items)
-    INTEGRATION_DB.schema(:items, :reload=>true)
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items, :reload=>true)
+    DB.schema(:items)
+    DB.schema(:items, :reload=>true)
   end
 
   specify "Model schema should include columns in the table, even if they aren't selected" do
-    INTEGRATION_DB.create_table!(:items){String :a; Integer :number}
-    m = Sequel::Model(INTEGRATION_DB[:items].select(:a))
+    DB.create_table!(:items){String :a; Integer :number}
+    m = Sequel::Model(DB[:items].select(:a))
     m.columns.should == [:a]
     m.db_schema[:number][:type].should == :integer
   end
 
   specify "should raise an error when the table doesn't exist" do
-    proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error)
+    proc{DB.schema(:no_table)}.should raise_error(Sequel::Error)
   end
 
   specify "should return the schema correctly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    schema = INTEGRATION_DB.schema(:items, :reload=>true)
+    DB.create_table!(:items){Integer :number}
+    schema = DB.schema(:items, :reload=>true)
     schema.should be_a_kind_of(Array)
     schema.length.should == 1
     col = schema.first
@@ -76,110 +76,110 @@ describe "Database schema parser" do
     col_info = col.last
     col_info.should be_a_kind_of(Hash)
     col_info[:type].should == :integer
-    INTEGRATION_DB.schema(:items)
+    DB.schema(:items)
   end
 
   specify "should parse primary keys from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
-    INTEGRATION_DB.create_table!(:items){primary_key :number}
-    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
-    INTEGRATION_DB.create_table!(:items){Integer :number1; Integer :number2; primary_key [:number1, :number2]}
-    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    DB.create_table!(:items){primary_key :number}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    DB.create_table!(:items){Integer :number1; Integer :number2; primary_key [:number1, :number2]}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
   end
 
   specify "should parse NULL/NOT NULL from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number, :null=>true}
-    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == true
-    INTEGRATION_DB.create_table!(:items){Integer :number, :null=>false}
-    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == false
+    DB.create_table!(:items){Integer :number, :null=>true}
+    DB.schema(:items).first.last[:allow_null].should == true
+    DB.create_table!(:items){Integer :number, :null=>false}
+    DB.schema(:items).first.last[:allow_null].should == false
   end
 
   specify "should parse defaults from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == nil
-    INTEGRATION_DB.create_table!(:items){Integer :number, :default=>0}
-    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 0
-    INTEGRATION_DB.create_table!(:items){String :a, :default=>"blah"}
-    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items).first.last[:ruby_default].should == nil
+    DB.create_table!(:items){Integer :number, :default=>0}
+    DB.schema(:items).first.last[:ruby_default].should == 0
+    DB.create_table!(:items){String :a, :default=>"blah"}
+    DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
   specify "should parse current timestamp defaults from the schema properly" do
-    INTEGRATION_DB.create_table!(:items){Time :a, :default=>Sequel::CURRENT_TIMESTAMP}
-    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == Sequel::CURRENT_TIMESTAMP
+    DB.create_table!(:items){Time :a, :default=>Sequel::CURRENT_TIMESTAMP}
+    DB.schema(:items).first.last[:ruby_default].should == Sequel::CURRENT_TIMESTAMP
   end
 
   cspecify "should parse current date defaults from the schema properly", :mysql, :oracle do
-    INTEGRATION_DB.create_table!(:items){Date :a, :default=>Sequel::CURRENT_DATE}
-    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == Sequel::CURRENT_DATE
+    DB.create_table!(:items){Date :a, :default=>Sequel::CURRENT_DATE}
+    DB.schema(:items).first.last[:ruby_default].should == Sequel::CURRENT_DATE
   end
 
   cspecify "should parse types from the schema properly", [:jdbc, :db2], :oracle do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
-    INTEGRATION_DB.create_table!(:items){Fixnum :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
-    INTEGRATION_DB.create_table!(:items){Bignum :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
-    INTEGRATION_DB.create_table!(:items){Float :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :float
-    INTEGRATION_DB.create_table!(:items){BigDecimal :number, :size=>[11, 2]}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :decimal
-    INTEGRATION_DB.create_table!(:items){Numeric :number, :size=>[12, 0]}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
-    INTEGRATION_DB.create_table!(:items){String :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :string
-    INTEGRATION_DB.create_table!(:items){Date :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :date
-    INTEGRATION_DB.create_table!(:items){Time :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :datetime
-    INTEGRATION_DB.create_table!(:items){DateTime :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :datetime
-    INTEGRATION_DB.create_table!(:items){File :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :blob
-    INTEGRATION_DB.create_table!(:items){TrueClass :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :boolean
-    INTEGRATION_DB.create_table!(:items){FalseClass :number}
-    INTEGRATION_DB.schema(:items).first.last[:type].should == :boolean
-  end
-end if INTEGRATION_DB.supports_schema_parsing?
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items).first.last[:type].should == :integer
+    DB.create_table!(:items){Fixnum :number}
+    DB.schema(:items).first.last[:type].should == :integer
+    DB.create_table!(:items){Bignum :number}
+    DB.schema(:items).first.last[:type].should == :integer
+    DB.create_table!(:items){Float :number}
+    DB.schema(:items).first.last[:type].should == :float
+    DB.create_table!(:items){BigDecimal :number, :size=>[11, 2]}
+    DB.schema(:items).first.last[:type].should == :decimal
+    DB.create_table!(:items){Numeric :number, :size=>[12, 0]}
+    DB.schema(:items).first.last[:type].should == :integer
+    DB.create_table!(:items){String :number}
+    DB.schema(:items).first.last[:type].should == :string
+    DB.create_table!(:items){Date :number}
+    DB.schema(:items).first.last[:type].should == :date
+    DB.create_table!(:items){Time :number}
+    DB.schema(:items).first.last[:type].should == :datetime
+    DB.create_table!(:items){DateTime :number}
+    DB.schema(:items).first.last[:type].should == :datetime
+    DB.create_table!(:items){File :number}
+    DB.schema(:items).first.last[:type].should == :blob
+    DB.create_table!(:items){TrueClass :number}
+    DB.schema(:items).first.last[:type].should == :boolean
+    DB.create_table!(:items){FalseClass :number}
+    DB.schema(:items).first.last[:type].should == :boolean
+  end
+end if DB.supports_schema_parsing?
 
 describe "Database index parsing" do
   after do
-    INTEGRATION_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "should parse indexes into a hash" do
     # Delete :deferrable entry, since not all adapters implement it
-    f = lambda{h = INTEGRATION_DB.indexes(:items); h.values.each{|h2| h2.delete(:deferrable)}; h}
+    f = lambda{h = DB.indexes(:items); h.values.each{|h2| h2.delete(:deferrable)}; h}
 
-    INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a}
+    DB.create_table!(:items){Integer :n; Integer :a}
     f.call.should == {}
-    INTEGRATION_DB.add_index(:items, :n)
+    DB.add_index(:items, :n)
     f.call.should == {:items_n_index=>{:columns=>[:n], :unique=>false}}
-    INTEGRATION_DB.drop_index(:items, :n)
+    DB.drop_index(:items, :n)
     f.call.should == {}
-    INTEGRATION_DB.add_index(:items, :n, :unique=>true, :name=>:blah_blah_index)
+    DB.add_index(:items, :n, :unique=>true, :name=>:blah_blah_index)
     f.call.should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}}
-    INTEGRATION_DB.add_index(:items, [:n, :a])
+    DB.add_index(:items, [:n, :a])
     f.call.should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
-    INTEGRATION_DB.drop_index(:items, :n, :name=>:blah_blah_index)
+    DB.drop_index(:items, :n, :name=>:blah_blah_index)
     f.call.should == {:items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
-    INTEGRATION_DB.drop_index(:items, [:n, :a])
+    DB.drop_index(:items, [:n, :a])
     f.call.should == {}
   end
   
   specify "should not include a primary key index" do
-    INTEGRATION_DB.create_table!(:items){primary_key :n}
-    INTEGRATION_DB.indexes(:items).should == {}
-    INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a; primary_key [:n, :a]}
-    INTEGRATION_DB.indexes(:items).should == {}
+    DB.create_table!(:items){primary_key :n}
+    DB.indexes(:items).should == {}
+    DB.create_table!(:items){Integer :n; Integer :a; primary_key [:n, :a]}
+    DB.indexes(:items).should == {}
   end
-end if INTEGRATION_DB.supports_index_parsing?
+end if DB.supports_index_parsing?
 
 describe "Database foreign key parsing" do
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @pr = lambda do |table, *expected|
       actual = @db.foreign_key_list(table).sort_by{|c| c[:columns].map{|s| s.to_s}.join << (c[:key]||[]).map{|s| s.to_s}.join}.map{|v| v.values_at(:columns, :table, :key)}
       actual.zip(expected).each do |a, e|
@@ -231,11 +231,11 @@ describe "Database foreign key parsing" do
     @db.create_table!(:b, :engine=>:InnoDB){Integer :e; Integer :f; foreign_key [:e, :f], :a; foreign_key [:f, :e], :a, :key=>[:c, :b]}
     @pr[:b, [[:e, :f], :a, [:pk, :b, :c]], [[:f, :e], :a, [:c, :b]]]
   end
-end if INTEGRATION_DB.supports_foreign_key_parsing?
+end if DB.supports_foreign_key_parsing?
 
 describe "Database schema modifiers" do
   before do
-    @db = INTEGRATION_DB
+    @db = DB
     @ds = @db[:items]
   end
   after do
@@ -269,7 +269,7 @@ describe "Database schema modifiers" do
       @ds.insert(:number=>2)
     end
     after do
-      @db.drop_view(:items_view)
+      @db.drop_view(:items_view) rescue nil
     end
 
     specify "should create views correctly" do
@@ -277,6 +277,11 @@ describe "Database schema modifiers" do
       @db[:items_view].map(:number).should == [1]
     end
 
+    cspecify "should create views with explicit columns correctly", :sqlite do
+      @db.create_view(:items_view, @ds.where(:number=>1), :columns=>[:n])
+      @db[:items_view].map(:n).should == [1]
+    end
+
     specify "should create or replace views correctly" do
       @db.create_or_replace_view(:items_view, @ds.where(:number=>1))
       @db[:items_view].map(:number).should == [1]
@@ -289,7 +294,7 @@ describe "Database schema modifiers" do
     @db.drop_table?(:items)
     @db.transaction(:rollback=>:always){@db.create_table(:items){Integer :number}}
     @db.table_exists?(:items).should be_false
-  end if INTEGRATION_DB.supports_transactional_ddl?
+  end if DB.supports_transactional_ddl?
   
   describe "join tables" do
     after do
@@ -307,7 +312,7 @@ describe "Database schema modifiers" do
   end
 
   specify "should create temporary tables without raising an exception" do
-    @db.create_table!(:items, :temp=>true){Integer :number}
+    @db.create_table!(:items_temp, :temp=>true){Integer :number}
   end
 
   specify "should have create_table? only create the table if it doesn't already exist" do
@@ -646,7 +651,7 @@ describe "Database schema modifiers" do
     @db.create_table!(:items){foreign_key :id, :items2, :deferrable=>true}
     proc{@db[:items].insert(1)}.should raise_error(Sequel::DatabaseError)
     proc{@db.transaction{proc{@db[:items].insert(1)}.should_not raise_error}}.should raise_error(Sequel::DatabaseError)
-  end if INTEGRATION_DB.supports_deferrable_foreign_key_constraints?
+  end if DB.supports_deferrable_foreign_key_constraints?
 
   specify "should support deferrable unique constraints when creating or altering tables" do
     @db.create_table!(:items){Integer :t; unique [:t], :name=>:atest_def, :deferrable=>true, :using=>:btree}
@@ -661,7 +666,7 @@ describe "Database schema modifiers" do
     @db[:items].insert(2)
     proc{@db[:items].insert(2)}.should raise_error(Sequel::DatabaseError)
     proc{@db.transaction{proc{@db[:items].insert(2)}.should_not raise_error}}.should raise_error(Sequel::DatabaseError)
-  end if INTEGRATION_DB.supports_deferrable_constraints?
+  end if DB.supports_deferrable_constraints?
 end
 
 describe "Database#tables" do
@@ -672,7 +677,7 @@ describe "Database#tables" do
         "xxxxx#{@@xxxxx += 1}"
       end
     end
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table(:sequel_test_table){Integer :a}
     @db.create_view :sequel_test_view, @db[:sequel_test_table]
     @iom = @db.identifier_output_method
@@ -698,7 +703,7 @@ describe "Database#tables" do
     @db.identifier_input_method = :xxxxx
     @db.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
   end
-end if INTEGRATION_DB.supports_table_listing?
+end if DB.supports_table_listing?
 
 describe "Database#views" do
   before do
@@ -708,7 +713,7 @@ describe "Database#views" do
         "xxxxx#{@@xxxxx += 1}"
       end
     end
-    @db = INTEGRATION_DB
+    @db = DB
     @db.create_table(:sequel_test_table){Integer :a}
     @db.create_view :sequel_test_view, @db[:sequel_test_table]
     @iom = @db.identifier_output_method
@@ -734,4 +739,4 @@ describe "Database#views" do
     @db.identifier_input_method = :xxxxx
     @db.views.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
   end
-end if INTEGRATION_DB.supports_view_listing?
+end if DB.supports_view_listing?