sequel 3.48.0 → 4.0.0

data/spec/adapters/informix_spec.rb

@@ -1,14 +1,11 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+SEQUEL_ADAPTER_TEST = :informix
 
-unless defined?(INFORMIX_DB)
-  INFORMIX_DB = Sequel.connect('informix://localhost/mydb')
-end
-INTEGRATION_DB = INFORMIX_DB unless defined?(INTEGRATION_DB)
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-if INFORMIX_DB.table_exists?(:test)
-  INFORMIX_DB.drop_table :test
+if DB.table_exists?(:test)
+  DB.drop_table :test
 end
-INFORMIX_DB.create_table :test do
+DB.create_table :test do
   text :name
   integer :value
   
@@ -17,16 +14,16 @@ end
 
 describe "A Informix database" do
   specify "should provide disconnect functionality" do
-    INFORMIX_DB.execute("select user from dual")
-    INFORMIX_DB.pool.size.should == 1
-    INFORMIX_DB.disconnect
-    INFORMIX_DB.pool.size.should == 0
+    DB.execute("select user from dual")
+    DB.pool.size.should == 1
+    DB.disconnect
+    DB.pool.size.should == 0
   end
 end
 
 describe "A Informix dataset" do
   before do
-    @d = INFORMIX_DB[:test]
+    @d = DB[:test]
     @d.delete # remove all records
   end
   
@@ -79,7 +76,7 @@ describe "A Informix dataset" do
   end
   
   specify "should support transactions" do
-    INFORMIX_DB.transaction do
+    DB.transaction do
       @d << {:name => 'abc', :value => 1}
     end
 

data/spec/adapters/mssql_spec.rb

@@ -1,25 +1,19 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-require ENV['SEQUEL_MSSQL_SPEC_REQUIRE'] if ENV['SEQUEL_MSSQL_SPEC_REQUIRE']
+SEQUEL_ADAPTER_TEST = :mssql
 
-unless defined?(MSSQL_DB)
-  MSSQL_URL = 'jdbc:sqlserver://localhost;integratedSecurity=true;database=sandbox' unless defined? MSSQL_URL
-  MSSQL_DB = Sequel.connect(ENV['SEQUEL_MSSQL_SPEC_DB']||MSSQL_URL)
-end
-INTEGRATION_DB = MSSQL_DB unless defined?(INTEGRATION_DB)
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-def MSSQL_DB.sqls
+def DB.sqls
   (@sqls ||= [])
 end
 logger = Object.new
 def logger.method_missing(m, msg)
-  MSSQL_DB.sqls << msg
+  DB.sqls << msg
 end
-MSSQL_DB.loggers = [logger]
+DB.loggers = [logger]
 
 describe "A MSSQL database" do
   before do
-    @db = MSSQL_DB
+    @db = DB
   end
 
   cspecify "should be able to read fractional part of timestamp", :odbc do
@@ -40,7 +34,7 @@ end
   
 describe "A MSSQL database" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table! :test3 do
       Integer :value
       Time :time
@@ -57,7 +51,7 @@ end
 
 describe "MSSQL" do
   before(:all) do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table!(:test3){Integer :v3}
     @db.create_table!(:test4){Integer :v4}
     @db[:test3].import([:v3], [[1], [2]])
@@ -82,7 +76,7 @@ end
 #   CREATE FULLTEXT CATALOG ftscd AS DEFAULT
 describe "MSSQL full_text_search" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.drop_table?(:posts)
   end
   after do
@@ -107,19 +101,19 @@ end if false
 
 describe "MSSQL Dataset#join_table" do
   specify "should emulate the USING clause with ON" do
-    MSSQL_DB[:items].join(:categories, [:id]).sql.should ==
+    DB[:items].join(:categories, [:id]).sql.should ==
       'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON ([CATEGORIES].[ID] = [ITEMS].[ID])'
     ['SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID1] = [ITEMS].[ID1]) AND ([CATEGORIES].[ID2] = [ITEMS].[ID2]))',
       'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID2] = [ITEMS].[ID2]) AND ([CATEGORIES].[ID1] = [ITEMS].[ID1]))'].
-      should include(MSSQL_DB[:items].join(:categories, [:id1, :id2]).sql)
-    MSSQL_DB[:items___i].join(:categories___c, [:id]).sql.should ==
+      should include(DB[:items].join(:categories, [:id1, :id2]).sql)
+    DB[:items___i].join(:categories___c, [:id]).sql.should ==
       'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
   end
 end
 
 describe "MSSQL Dataset#output" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table!(:items){String :name; Integer :value}
     @db.create_table!(:out){String :name; Integer :value}
     @ds = @db[:items]
@@ -197,8 +191,8 @@ end
 
 describe "MSSQL dataset using #with and #with_recursive" do
   before do
-    @db = MSSQL_DB
-    @ds = MSSQL_DB[:t]
+    @db = DB
+    @ds = DB[:t]
       @ds1 = @ds.with(:t, @db[:x])
       @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t])
   end
@@ -226,7 +220,7 @@ end
 
 describe "MSSQL::Dataset#import" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.sqls.clear
     @ds = @db[:test]
   end
@@ -249,7 +243,7 @@ end
 
 describe "MSSQL joined datasets" do
   before do
-    @db = MSSQL_DB
+    @db = DB
   end
 
   specify "should format DELETE statements" do
@@ -265,7 +259,7 @@ end
 
 describe "Offset support" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table!(:i){Integer :id; Integer :parent_id}
     @ds = @db[:i].order(:id)
     @hs = []
@@ -288,7 +282,7 @@ end
 
 describe "Common Table Expressions" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table!(:i1){Integer :id; Integer :parent_id}
     @db.create_table!(:i2){Integer :id; Integer :parent_id}
     @ds = @db[:i1]
@@ -360,7 +354,7 @@ end
 
 describe "MSSSQL::Dataset#insert" do
   before do
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table!(:test5){primary_key :xid; Integer :value}
     @db.create_table! :test4 do
       String :name, :size => 20
@@ -397,13 +391,13 @@ describe "MSSSQL::Dataset#insert" do
   end
 
   specify "should play nicely with simple_select_all?" do
-    MSSQL_DB[:test4].disable_insert_output.send(:simple_select_all?).should == true
+    DB[:test4].disable_insert_output.send(:simple_select_all?).should == true
   end
 end
 
 describe "MSSSQL::Dataset#into" do
   before do
-    @db = MSSQL_DB
+    @db = DB
   end
 
   specify "should format SELECT statement" do
@@ -421,7 +415,7 @@ end
 
 describe "A MSSQL database" do
   before do
-    @db = MSSQL_DB
+    @db = DB
   end
   after do
     @db.drop_table?(:a)
@@ -447,68 +441,68 @@ end
 
 describe "MSSQL::Database#rename_table" do
   after do
-    MSSQL_DB.drop_table?(:foo)
+    DB.drop_table?(:foo)
   end
 
   specify "should work on non-schema bound tables which need escaping" do
-    MSSQL_DB.quote_identifiers = true
-    MSSQL_DB.create_table! :'foo bar' do
+    DB.quote_identifiers = true
+    DB.create_table! :'foo bar' do
       text :name
     end
-    MSSQL_DB.drop_table? :foo
-    proc { MSSQL_DB.rename_table 'foo bar', 'foo' }.should_not raise_error
+    DB.drop_table? :foo
+    proc { DB.rename_table 'foo bar', 'foo' }.should_not raise_error
   end
   
   specify "should work on schema bound tables" do
-    MSSQL_DB.execute(<<-SQL)
+    DB.execute(<<-SQL)
       IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'MY')
         EXECUTE sp_executesql N'create schema MY'
     SQL
-    MSSQL_DB.create_table! :MY__foo do
+    DB.create_table! :MY__foo do
       text :name
     end
-    proc { MSSQL_DB.rename_table :MY__foo, :MY__bar }.should_not raise_error
-    proc { MSSQL_DB.rename_table :MY__bar, :foo }.should_not raise_error
+    proc { DB.rename_table :MY__foo, :MY__bar }.should_not raise_error
+    proc { DB.rename_table :MY__bar, :foo }.should_not raise_error
   end
 end
 
 describe "MSSQL::Dataset#count" do
   specify "should work with a distinct query with an order clause" do
-    MSSQL_DB.create_table!(:items){String :name; Integer :value}
-    MSSQL_DB[:items].insert(:name => "name", :value => 1)
-    MSSQL_DB[:items].insert(:name => "name", :value => 1)
-    MSSQL_DB[:items].select(:name, :value).distinct.order(:name).count.should == 1
-    MSSQL_DB[:items].select(:name, :value).group(:name, :value).order(:name).count.should == 1
+    DB.create_table!(:items){String :name; Integer :value}
+    DB[:items].insert(:name => "name", :value => 1)
+    DB[:items].insert(:name => "name", :value => 1)
+    DB[:items].select(:name, :value).distinct.order(:name).count.should == 1
+    DB[:items].select(:name, :value).group(:name, :value).order(:name).count.should == 1
   end
 end
 
 describe "MSSQL::Database#create_table" do
   specify "should support collate with various other column options" do
-    MSSQL_DB.create_table!(:items){ String :name, :size => 128, :collate => :sql_latin1_general_cp1_ci_as, :default => 'foo', :null => false, :unique => true}
-    MSSQL_DB[:items].insert
-    MSSQL_DB[:items].select_map(:name).should == ["foo"]
+    DB.create_table!(:items){ String :name, :size => 128, :collate => :sql_latin1_general_cp1_ci_as, :default => 'foo', :null => false, :unique => true}
+    DB[:items].insert
+    DB[:items].select_map(:name).should == ["foo"]
   end
 end
 
 describe "MSSQL::Database#mssql_unicode_strings = false" do
   before do
-    MSSQL_DB.mssql_unicode_strings = false
+    DB.mssql_unicode_strings = false
   end
   after do
-    MSSQL_DB.drop_table?(:items)
-    MSSQL_DB.mssql_unicode_strings = true
+    DB.drop_table?(:items)
+    DB.mssql_unicode_strings = true
   end
 
   specify "should work correctly" do
-    MSSQL_DB.create_table!(:items){String :name}
-    MSSQL_DB[:items].mssql_unicode_strings.should == false
-    MSSQL_DB[:items].insert(:name=>'foo')
-    MSSQL_DB[:items].select_map(:name).should == ['foo']
+    DB.create_table!(:items){String :name}
+    DB[:items].mssql_unicode_strings.should == false
+    DB[:items].insert(:name=>'foo')
+    DB[:items].select_map(:name).should == ['foo']
   end
 
   specify "should be overridable at the dataset level" do
-    MSSQL_DB.create_table!(:items){String :name}
-    ds = MSSQL_DB[:items]
+    DB.create_table!(:items){String :name}
+    ds = DB[:items]
     ds.mssql_unicode_strings.should == false
     ds.mssql_unicode_strings = true
     ds.mssql_unicode_strings.should == true
@@ -520,7 +514,7 @@ end
 describe "A MSSQL database adds index with include" do
   before :all do
     @table_name = :test_index_include
-    @db = MSSQL_DB
+    @db = DB
     @db.create_table! @table_name do
       integer :col1
       integer :col2
@@ -542,34 +536,34 @@ end
 
 describe "MSSQL::Database#drop_column with a schema" do
   before do
-    MSSQL_DB.run "create schema test" rescue nil
+    DB.run "create schema test" rescue nil
   end
   after do
-    MSSQL_DB.drop_table(:test__items)
-    MSSQL_DB.run "drop schema test" rescue nil
+    DB.drop_table(:test__items)
+    DB.run "drop schema test" rescue nil
   end
 
   specify "drops columns with a default value" do
-    MSSQL_DB.create_table!(:test__items){ Integer :id; String :name, :default => 'widget' }
-    MSSQL_DB.drop_column(:test__items, :name)
-    MSSQL_DB[:test__items].columns.should == [:id]
+    DB.create_table!(:test__items){ Integer :id; String :name, :default => 'widget' }
+    DB.drop_column(:test__items, :name)
+    DB[:test__items].columns.should == [:id]
   end
 end
 
 describe "Database#foreign_key_list" do
   before(:all) do
-    MSSQL_DB.create_table! :items do
+    DB.create_table! :items do
       primary_key :id
       integer     :sku
     end
-    MSSQL_DB.create_table! :prices do
+    DB.create_table! :prices do
       integer     :item_id
       datetime    :valid_from
       float       :price
       primary_key [:item_id, :valid_from]
       foreign_key [:item_id], :items, :key => :id, :name => :fk_prices_items
     end
-    MSSQL_DB.create_table! :sales do
+    DB.create_table! :sales do
       integer  :id
       integer  :price_item_id
       datetime :price_valid_from
@@ -577,12 +571,12 @@ describe "Database#foreign_key_list" do
     end
   end
   after(:all) do
-    MSSQL_DB.drop_table :sales
-    MSSQL_DB.drop_table :prices
-    MSSQL_DB.drop_table :items
+    DB.drop_table :sales
+    DB.drop_table :prices
+    DB.drop_table :items
   end
   it "should support typical foreign keys" do
-    MSSQL_DB.foreign_key_list(:prices).should == [{:name      => :fk_prices_items, 
+    DB.foreign_key_list(:prices).should == [{:name      => :fk_prices_items, 
                                                    :table     => :items, 
                                                    :columns   => [:item_id], 
                                                    :key       => [:id], 
@@ -590,7 +584,7 @@ describe "Database#foreign_key_list" do
                                                    :on_delete => :no_action }]
   end
   it "should support a foreign key with multiple columns" do
-    MSSQL_DB.foreign_key_list(:sales).should == [{:name      => :fk_sales_prices, 
+    DB.foreign_key_list(:sales).should == [{:name      => :fk_sales_prices, 
                                                   :table     => :prices, 
                                                   :columns   => [:price_item_id, :price_valid_from], 
                                                   :key       => [:item_id, :valid_from], 
@@ -600,12 +594,12 @@ describe "Database#foreign_key_list" do
 
   context "with multiple schemas" do
     before(:all) do
-      MSSQL_DB.execute_ddl "create schema vendor"
-      MSSQL_DB.create_table! :vendor__vendors do
+      DB.execute_ddl "create schema vendor"
+      DB.create_table! :vendor__vendors do
         primary_key :id
         varchar     :name
       end
-      MSSQL_DB.create_table! :vendor__mapping do
+      DB.create_table! :vendor__mapping do
         integer :vendor_id
         integer :item_id
         foreign_key [:vendor_id], :vendor__vendors, :name => :fk_mapping_vendor
@@ -613,12 +607,12 @@ describe "Database#foreign_key_list" do
       end
     end
     after(:all) do
-      MSSQL_DB.drop_table :vendor__mapping
-      MSSQL_DB.drop_table :vendor__vendors
-      MSSQL_DB.execute_ddl "drop schema vendor"
+      DB.drop_table :vendor__mapping
+      DB.drop_table :vendor__vendors
+      DB.execute_ddl "drop schema vendor"
     end
     it "should support mixed schema bound tables" do
- MSSQL_DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.should == [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => :vendor__vendors, :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
+ DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.should == [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => :vendor__vendors, :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
     end
   end
 end

data/spec/adapters/mysql_spec.rb

@@ -1,28 +1,21 @@
+SEQUEL_ADAPTER_TEST = :mysql
+
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-unless defined?(MYSQL_USER)
-  MYSQL_USER = 'root'
-end
-unless defined?(MYSQL_DB)
-  MYSQL_URL = (ENV['SEQUEL_MY_SPEC_DB']||"mysql://#{MYSQL_USER}@localhost/sandbox") unless defined? MYSQL_URL
-  MYSQL_DB = Sequel.connect(MYSQL_URL)
-end
 unless defined?(MYSQL_SOCKET_FILE)
   MYSQL_SOCKET_FILE = '/tmp/mysql.sock'
 end
-INTEGRATION_DB = MYSQL_DB unless defined?(INTEGRATION_DB)
-
-MYSQL_URI = URI.parse(MYSQL_DB.uri)
+MYSQL_URI = URI.parse(DB.uri)
 
-def MYSQL_DB.sqls
+def DB.sqls
   (@sqls ||= [])
 end
 logger = Object.new
 def logger.method_missing(m, msg)
-  MYSQL_DB.sqls << msg
+  DB.sqls << msg
 end
-MYSQL_DB.loggers = [logger]
-MYSQL_DB.drop_table?(:items, :dolls, :booltest)
+DB.loggers = [logger]
+DB.drop_table?(:items, :dolls, :booltest)
 
 SQL_BEGIN = 'BEGIN'
 SQL_ROLLBACK = 'ROLLBACK'
@@ -30,8 +23,8 @@ SQL_COMMIT = 'COMMIT'
 
 describe "MySQL", '#create_table' do
   before do
-    @db = MYSQL_DB
-    MYSQL_DB.sqls.clear
+    @db = DB
+    DB.sqls.clear
   end
   after do
     @db.drop_table?(:dolls)
@@ -99,10 +92,10 @@ describe "MySQL", '#create_table' do
   end
 end
 
-if [:mysql, :mysql2].include?(MYSQL_DB.adapter_scheme)
+if [:mysql, :mysql2].include?(DB.adapter_scheme)
   describe "Sequel::MySQL::Database#convert_tinyint_to_bool" do
     before do
-      @db = MYSQL_DB
+      @db = DB
       @db.create_table(:booltest){column :b, 'tinyint(1)'; column :i, 'tinyint(4)'}
       @ds = @db[:booltest]
     end
@@ -162,12 +155,12 @@ end
 
 describe "A MySQL dataset" do
   before do
-    MYSQL_DB.create_table(:items){String :name; Integer :value}
-    @d = MYSQL_DB[:items]
-    MYSQL_DB.sqls.clear
+    DB.create_table(:items){String :name; Integer :value}
+    @d = DB[:items]
+    DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "should quote columns and tables using back-ticks if quoting identifiers" do
@@ -237,7 +230,7 @@ end
 
 describe "MySQL datasets" do
   before do
-    @d = MYSQL_DB[:orders]
+    @d = DB[:orders]
   end
 
   specify "should correctly quote column references" do
@@ -253,7 +246,7 @@ end
 
 describe "Dataset#distinct" do
   before do
-    @db = MYSQL_DB
+    @db = DB
     @db.create_table!(:a) do
       Integer :a
       Integer :b
@@ -276,7 +269,7 @@ end
 
 describe "MySQL join expressions" do
   before do
-    @ds = MYSQL_DB[:nodes]
+    @ds = DB[:nodes]
   end
 
   specify "should raise error for :full_outer join requests." do
@@ -326,7 +319,7 @@ end
 
 describe "Joined MySQL dataset" do
   before do
-    @ds = MYSQL_DB[:nodes]
+    @ds = DB[:nodes]
   end
 
   specify "should quote fields correctly" do
@@ -350,17 +343,17 @@ end
 
 describe "A MySQL database" do
   after do
-    MYSQL_DB.drop_table?(:test_innodb)
+    DB.drop_table?(:test_innodb)
   end
 
   specify "should handle the creation and dropping of an InnoDB table with foreign keys" do
-    proc{MYSQL_DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
+    proc{DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
   end
 end
 
 describe "A MySQL database" do
   before(:all) do
-    @db = MYSQL_DB
+    @db = DB
     @db.create_table! :test2 do
       text :name
       integer :value
@@ -457,10 +450,10 @@ describe "A MySQL database with table options" do
     Sequel::MySQL.default_charset = 'utf8'
     Sequel::MySQL.default_collate = 'utf8_general_ci'
 
-    @db = MYSQL_DB
+    @db = DB
     @db.drop_table?(:items)
 
-    MYSQL_DB.sqls.clear
+    DB.sqls.clear
   end
   after do
     @db.drop_table?(:items)
@@ -494,9 +487,9 @@ end
 
 describe "A MySQL database" do
   before do
-    @db = MYSQL_DB
+    @db = DB
     @db.drop_table?(:items)
-    MYSQL_DB.sqls.clear
+    DB.sqls.clear
   end
   after do
     @db.drop_table?(:items, :users)
@@ -596,20 +589,20 @@ describe "A MySQL database" do
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost
-if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and MYSQL_DB.adapter_scheme == :mysql
+if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and DB.adapter_scheme == :mysql
   describe "A MySQL database" do
     specify "should accept a socket option" do
-      db = Sequel.mysql(MYSQL_DB.opts[:database], :host => 'localhost', :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(DB.opts[:database], :host => 'localhost', :user => DB.opts[:user], :password => DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
 
     specify "should accept a socket option without host option" do
-      db = Sequel.mysql(MYSQL_DB.opts[:database], :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
+      db = Sequel.mysql(DB.opts[:database], :user => DB.opts[:user], :password => DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
       proc {db.test_connection}.should_not raise_error
     end
 
     specify "should fail to connect with invalid socket" do
-      db = Sequel.mysql(MYSQL_DB.opts[:database], :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket =>'blah')
+      db = Sequel.mysql(DB.opts[:database], :user => DB.opts[:user], :password => DB.opts[:password], :socket =>'blah')
       proc {db.test_connection}.should raise_error
     end
   end
@@ -617,93 +610,93 @@ end
 
 describe "A MySQL database" do
   specify "should accept a read_timeout option when connecting" do
-    db = Sequel.connect(MYSQL_DB.opts.merge(:read_timeout=>22342))
+    db = Sequel.connect(DB.opts.merge(:read_timeout=>22342))
     proc {db.test_connection}.should_not raise_error
   end
 
   specify "should accept a connect_timeout option when connecting" do
-    db = Sequel.connect(MYSQL_DB.opts.merge(:connect_timeout=>22342))
+    db = Sequel.connect(DB.opts.merge(:connect_timeout=>22342))
     proc {db.test_connection}.should_not raise_error
   end
 end
 
 describe "MySQL foreign key support" do
   after do
-    MYSQL_DB.drop_table?(:testfk, :testpk)
+    DB.drop_table?(:testfk, :testpk)
   end
 
   specify "should create table without :key" do
-    MYSQL_DB.create_table!(:testpk){primary_key :id}
-    MYSQL_DB.create_table!(:testfk){foreign_key :fk, :testpk}
+    DB.create_table!(:testpk){primary_key :id}
+    DB.create_table!(:testfk){foreign_key :fk, :testpk}
   end
 
   specify "should create table with composite keys without :key" do
-    MYSQL_DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
-    MYSQL_DB.create_table!(:testfk){Integer :fk; Integer :fk2; foreign_key([:fk, :fk2], :testpk)}
+    DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
+    DB.create_table!(:testfk){Integer :fk; Integer :fk2; foreign_key([:fk, :fk2], :testpk)}
   end
 
   specify "should create table with self referential without :key" do
-    MYSQL_DB.create_table!(:testfk){primary_key :id; foreign_key :fk, :testfk}
+    DB.create_table!(:testfk){primary_key :id; foreign_key :fk, :testfk}
   end
 
   specify "should create table with self referential with composite keys without :key" do
-    MYSQL_DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2]); foreign_key([:fk, :fk2], :testfk)}
+    DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2]); foreign_key([:fk, :fk2], :testfk)}
   end
 
   specify "should alter table without :key" do
-    MYSQL_DB.create_table!(:testpk){primary_key :id}
-    MYSQL_DB.create_table!(:testfk){Integer :id}
-    MYSQL_DB.alter_table(:testfk){add_foreign_key :fk, :testpk}
+    DB.create_table!(:testpk){primary_key :id}
+    DB.create_table!(:testfk){Integer :id}
+    DB.alter_table(:testfk){add_foreign_key :fk, :testpk}
   end
 
   specify "should alter table with composite keys without :key" do
-    MYSQL_DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
-    MYSQL_DB.create_table!(:testfk){Integer :fk; Integer :fk2}
-    MYSQL_DB.alter_table(:testfk){add_foreign_key([:fk, :fk2], :testpk)}
+    DB.create_table!(:testpk){Integer :id; Integer :id2; primary_key([:id, :id2])}
+    DB.create_table!(:testfk){Integer :fk; Integer :fk2}
+    DB.alter_table(:testfk){add_foreign_key([:fk, :fk2], :testpk)}
   end
 
   specify "should alter table with self referential without :key" do
-    MYSQL_DB.create_table!(:testfk){primary_key :id}
-    MYSQL_DB.alter_table(:testfk){add_foreign_key :fk, :testfk}
+    DB.create_table!(:testfk){primary_key :id}
+    DB.alter_table(:testfk){add_foreign_key :fk, :testfk}
   end
 
   specify "should alter table with self referential with composite keys without :key" do
-    MYSQL_DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2])}
-    MYSQL_DB.alter_table(:testfk){add_foreign_key [:fk, :fk2], :testfk}
+    DB.create_table!(:testfk){Integer :id; Integer :id2; Integer :fk; Integer :fk2; primary_key([:id, :id2])}
+    DB.alter_table(:testfk){add_foreign_key [:fk, :fk2], :testfk}
   end
 end
 
 describe "A grouped MySQL dataset" do
   before do
-    MYSQL_DB.create_table! :test2 do
+    DB.create_table! :test2 do
       text :name
       integer :value
     end
-    MYSQL_DB[:test2] << {:name => '11', :value => 10}
-    MYSQL_DB[:test2] << {:name => '11', :value => 20}
-    MYSQL_DB[:test2] << {:name => '11', :value => 30}
-    MYSQL_DB[:test2] << {:name => '12', :value => 10}
-    MYSQL_DB[:test2] << {:name => '12', :value => 20}
-    MYSQL_DB[:test2] << {:name => '13', :value => 10}
+    DB[:test2] << {:name => '11', :value => 10}
+    DB[:test2] << {:name => '11', :value => 20}
+    DB[:test2] << {:name => '11', :value => 30}
+    DB[:test2] << {:name => '12', :value => 10}
+    DB[:test2] << {:name => '12', :value => 20}
+    DB[:test2] << {:name => '13', :value => 10}
   end
   after do
-    MYSQL_DB.drop_table?(:test2)
+    DB.drop_table?(:test2)
   end
 
   specify "should return the correct count for raw sql query" do
-    ds = MYSQL_DB["select name FROM test2 WHERE name = '11' GROUP BY name"]
+    ds = DB["select name FROM test2 WHERE name = '11' GROUP BY name"]
     ds.count.should == 1
   end
 
   specify "should return the correct count for a normal dataset" do
-    ds = MYSQL_DB[:test2].select(:name).where(:name => '11').group(:name)
+    ds = DB[:test2].select(:name).where(:name => '11').group(:name)
     ds.count.should == 1
   end
 end
 
 describe "A MySQL database" do
   before do
-    @db = MYSQL_DB
+    @db = DB
     @db.drop_table?(:posts)
     @db.sqls.clear
   end
@@ -785,18 +778,18 @@ end
 
 describe "MySQL::Dataset#insert and related methods" do
   before do
-    MYSQL_DB.create_table(:items){String :name; Integer :value}
-    @d = MYSQL_DB[:items]
-    MYSQL_DB.sqls.clear
+    DB.create_table(:items){String :name; Integer :value}
+    @d = DB[:items]
+    DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "#insert should insert record with default values when no arguments given" do
     @d.insert
     check_sqls do
-      MYSQL_DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
+      DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
     end
     @d.all.should == [{:name => nil, :value => nil}]
   end
@@ -804,7 +797,7 @@ describe "MySQL::Dataset#insert and related methods" do
   specify "#insert  should insert record with default values when empty hash given" do
     @d.insert({})
     check_sqls do
-      MYSQL_DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
+      DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
     end
     @d.all.should == [{:name => nil, :value => nil}]
   end
@@ -812,23 +805,23 @@ describe "MySQL::Dataset#insert and related methods" do
   specify "#insert should insert record with default values when empty array given" do
     @d.insert []
     check_sqls do
-      MYSQL_DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
+      DB.sqls.should == ["INSERT INTO `items` () VALUES ()"]
     end
     @d.all.should == [{:name => nil, :value => nil}]
   end
 
   specify "#on_duplicate_key_update should work with regular inserts" do
-    MYSQL_DB.add_index :items, :name, :unique=>true
-    MYSQL_DB.sqls.clear
+    DB.add_index :items, :name, :unique=>true
+    DB.sqls.clear
     @d.insert(:name => 'abc', :value => 1)
     @d.on_duplicate_key_update(:name, :value => 6).insert(:name => 'abc', :value => 1)
     @d.on_duplicate_key_update(:name, :value => 6).insert(:name => 'def', :value => 2)
 
     check_sqls do
-      MYSQL_DB.sqls.length.should == 3
-      MYSQL_DB.sqls[0].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('abc'|1), (1|'abc')\)\z/
-      MYSQL_DB.sqls[1].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('abc'|1), (1|'abc')\) ON DUPLICATE KEY UPDATE `name`=VALUES\(`name`\), `value`=6\z/
-      MYSQL_DB.sqls[2].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('def'|2), (2|'def')\) ON DUPLICATE KEY UPDATE `name`=VALUES\(`name`\), `value`=6\z/
+      DB.sqls.length.should == 3
+      DB.sqls[0].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('abc'|1), (1|'abc')\)\z/
+      DB.sqls[1].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('abc'|1), (1|'abc')\) ON DUPLICATE KEY UPDATE `name`=VALUES\(`name`\), `value`=6\z/
+      DB.sqls[2].should =~ /\AINSERT INTO `items` \(`(name|value)`, `(name|value)`\) VALUES \(('def'|2), (2|'def')\) ON DUPLICATE KEY UPDATE `name`=VALUES\(`name`\), `value`=6\z/
     end
 
     @d.all.should == [{:name => 'abc', :value => 6}, {:name => 'def', :value => 2}]
@@ -838,7 +831,7 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.multi_replace([{:name => 'abc'}, {:name => 'def'}])
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "REPLACE INTO `items` (`name`) VALUES ('abc'), ('def')",
         SQL_COMMIT
@@ -855,7 +848,7 @@ describe "MySQL::Dataset#insert and related methods" do
       :commit_every => 2)
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "REPLACE INTO `items` (`value`) VALUES (1), (2)",
         SQL_COMMIT,
@@ -878,7 +871,7 @@ describe "MySQL::Dataset#insert and related methods" do
       :slice => 2)
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "REPLACE INTO `items` (`value`) VALUES (1), (2)",
         SQL_COMMIT,
@@ -900,7 +893,7 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT INTO `items` (`name`) VALUES ('abc'), ('def')",
         SQL_COMMIT
@@ -917,7 +910,7 @@ describe "MySQL::Dataset#insert and related methods" do
       :commit_every => 2)
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT INTO `items` (`value`) VALUES (1), (2)",
         SQL_COMMIT,
@@ -940,7 +933,7 @@ describe "MySQL::Dataset#insert and related methods" do
       :slice => 2)
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT INTO `items` (`value`) VALUES (1), (2)",
         SQL_COMMIT,
@@ -962,7 +955,7 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.import([:name, :value], [['abc', 1], ['def', 2]])
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT INTO `items` (`name`, `value`) VALUES ('abc', 1), ('def', 2)",
         SQL_COMMIT
@@ -979,7 +972,7 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.insert_ignore.multi_insert([{:name => 'abc'}, {:name => 'def'}])
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT IGNORE INTO `items` (`name`) VALUES ('abc'), ('def')",
         SQL_COMMIT
@@ -994,7 +987,7 @@ describe "MySQL::Dataset#insert and related methods" do
   specify "#insert_ignore should add the IGNORE keyword for single inserts" do
     @d.insert_ignore.insert(:name => 'ghi')
     check_sqls do
-      MYSQL_DB.sqls.should == ["INSERT IGNORE INTO `items` (`name`) VALUES ('ghi')"]
+      DB.sqls.should == ["INSERT IGNORE INTO `items` (`name`) VALUES ('ghi')"]
     end
     @d.all.should == [{:name => 'ghi', :value => nil}]
   end
@@ -1003,7 +996,7 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.on_duplicate_key_update.import([:name,:value], [['abc', 1], ['def',2]])
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         "SELECT * FROM `items` LIMIT 1",
         SQL_BEGIN,
         "INSERT INTO `items` (`name`, `value`) VALUES ('abc', 1), ('def', 2) ON DUPLICATE KEY UPDATE `name`=VALUES(`name`), `value`=VALUES(`value`)",
@@ -1022,7 +1015,7 @@ describe "MySQL::Dataset#insert and related methods" do
     )
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         SQL_BEGIN,
         "INSERT INTO `items` (`name`, `value`) VALUES ('abc', 1), ('def', 2) ON DUPLICATE KEY UPDATE `value`=VALUES(`value`)",
         SQL_COMMIT
@@ -1038,21 +1031,21 @@ end
 
 describe "MySQL::Dataset#update and related methods" do
   before do
-    MYSQL_DB.create_table(:items){String :name; Integer :value; index :name, :unique=>true}
-    @d = MYSQL_DB[:items]
+    DB.create_table(:items){String :name; Integer :value; index :name, :unique=>true}
+    @d = DB[:items]
   end
   after do
-    MYSQL_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "#update_ignore should not raise error where normal update would fail" do
     @d.insert(:name => 'cow', :value => 0)
     @d.insert(:name => 'cat', :value => 1)
     proc{@d.where(:value => 1).update(:name => 'cow')}.should raise_error(Sequel::DatabaseError)
-    MYSQL_DB.sqls.clear
+    DB.sqls.clear
     @d.update_ignore.where(:value => 1).update(:name => 'cow')
     check_sqls do
-      MYSQL_DB.sqls.should == ["UPDATE IGNORE `items` SET `name` = 'cow' WHERE (`value` = 1)"]
+      DB.sqls.should == ["UPDATE IGNORE `items` SET `name` = 'cow' WHERE (`value` = 1)"]
     end
     @d.order(:name).all.should == [{:name => 'cat', :value => 1}, {:name => 'cow', :value => 0}]
   end
@@ -1060,16 +1053,16 @@ end
 
 describe "MySQL::Dataset#replace" do
   before do
-    MYSQL_DB.create_table(:items){Integer :id, :unique=>true; Integer :value}
-    @d = MYSQL_DB[:items]
-    MYSQL_DB.sqls.clear
+    DB.create_table(:items){Integer :id, :unique=>true; Integer :value}
+    @d = DB[:items]
+    DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "should use default values if they exist" do
-    MYSQL_DB.alter_table(:items){set_column_default :id, 1; set_column_default :value, 2}
+    DB.alter_table(:items){set_column_default :id, 1; set_column_default :value, 2}
     @d.replace
     @d.all.should == [{:id=>1, :value=>2}]
     @d.replace([])
@@ -1102,7 +1095,7 @@ end
 
 describe "MySQL::Dataset#complex_expression_sql" do
   before do
-    @d = MYSQL_DB.dataset
+    @d = DB.dataset
   end
 
   specify "should handle string concatenation with CONCAT if more than one record" do
@@ -1119,28 +1112,28 @@ end
 
 describe "MySQL::Dataset#calc_found_rows" do
   before do
-    MYSQL_DB.create_table!(:items){Integer :a}
+    DB.create_table!(:items){Integer :a}
   end
   after do
-    MYSQL_DB.drop_table?(:items)
+    DB.drop_table?(:items)
   end
 
   specify "should add the SQL_CALC_FOUND_ROWS keyword when selecting" do
-    MYSQL_DB[:items].select(:a).calc_found_rows.limit(1).sql.should == \
+    DB[:items].select(:a).calc_found_rows.limit(1).sql.should == \
       'SELECT SQL_CALC_FOUND_ROWS `a` FROM `items` LIMIT 1'
   end
 
   specify "should count matching rows disregarding LIMIT clause" do
-    MYSQL_DB[:items].multi_insert([{:a => 1}, {:a => 1}, {:a => 2}])
-    MYSQL_DB.sqls.clear
+    DB[:items].multi_insert([{:a => 1}, {:a => 1}, {:a => 2}])
+    DB.sqls.clear
 
-    MYSQL_DB.synchronize do
-      MYSQL_DB[:items].calc_found_rows.filter(:a => 1).limit(1).all.should == [{:a => 1}]
-      MYSQL_DB.dataset.select(Sequel.function(:FOUND_ROWS).as(:rows)).all.should == [{:rows => 2 }]
+    DB.synchronize do
+      DB[:items].calc_found_rows.filter(:a => 1).limit(1).all.should == [{:a => 1}]
+      DB.dataset.select(Sequel.function(:FOUND_ROWS).as(:rows)).all.should == [{:rows => 2 }]
     end
 
     check_sqls do
-      MYSQL_DB.sqls.should == [
+      DB.sqls.should == [
         'SELECT SQL_CALC_FOUND_ROWS * FROM `items` WHERE (`a` = 1) LIMIT 1',
         'SELECT FOUND_ROWS() AS `rows`',
       ]
@@ -1148,34 +1141,34 @@ describe "MySQL::Dataset#calc_found_rows" do
   end
 end
 
-if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc or MYSQL_DB.adapter_scheme == :mysql2
+if DB.adapter_scheme == :mysql or DB.adapter_scheme == :jdbc or DB.adapter_scheme == :mysql2
   describe "MySQL Stored Procedures" do
     before do
-      MYSQL_DB.create_table(:items){Integer :id; Integer :value}
-      @d = MYSQL_DB[:items]
-      MYSQL_DB.sqls.clear
+      DB.create_table(:items){Integer :id; Integer :value}
+      @d = DB[:items]
+      DB.sqls.clear
     end
     after do
-      MYSQL_DB.drop_table?(:items)
-      MYSQL_DB.execute('DROP PROCEDURE test_sproc')
+      DB.drop_table?(:items)
+      DB.execute('DROP PROCEDURE test_sproc')
     end
 
     specify "should be callable on the database object" do
-      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
-      MYSQL_DB[:items].delete
-      MYSQL_DB[:items].insert(:value=>1)
-      MYSQL_DB[:items].count.should == 1
-      MYSQL_DB.call_sproc(:test_sproc)
-      MYSQL_DB[:items].count.should == 0
+      DB.execute_ddl('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
+      DB[:items].delete
+      DB[:items].insert(:value=>1)
+      DB[:items].count.should == 1
+      DB.call_sproc(:test_sproc)
+      DB[:items].count.should == 0
     end
 
     # Mysql2 doesn't support stored procedures that return result sets, probably because
     # CLIENT_MULTI_RESULTS is not set.
-    unless MYSQL_DB.adapter_scheme == :mysql2
+    unless DB.adapter_scheme == :mysql2
       specify "should be callable on the dataset object" do
-        MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
-        MYSQL_DB[:items].delete
-        @d = MYSQL_DB[:items]
+        DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+        DB[:items].delete
+        @d = DB[:items]
         @d.call_sproc(:select, :test_sproc, 3).should == []
         @d.insert(:value=>1)
         @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
@@ -1184,9 +1177,9 @@ if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc or MYSQ
       end
 
       specify "should be callable on the dataset object with multiple arguments" do
-        MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
-        MYSQL_DB[:items].delete
-        @d = MYSQL_DB[:items]
+        DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
+        DB[:items].delete
+        @d = DB[:items]
         @d.call_sproc(:select, :test_sproc, 3, 4).should == []
         @d.insert(:value=>1)
         @d.call_sproc(:select, :test_sproc, 4, 5).should == [{:id=>nil, :value=>1, :b=>4, :d=>5}]
@@ -1196,58 +1189,58 @@ if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc or MYSQ
     end
 
     specify "should deal with nil values" do
-      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(i INTEGER, v INTEGER) BEGIN INSERT INTO items VALUES (i, v); END')
-      MYSQL_DB[:items].delete
-      MYSQL_DB.call_sproc(:test_sproc, :args=>[1, nil])
-      MYSQL_DB[:items].all.should == [{:id=>1, :value=>nil}]
+      DB.execute_ddl('CREATE PROCEDURE test_sproc(i INTEGER, v INTEGER) BEGIN INSERT INTO items VALUES (i, v); END')
+      DB[:items].delete
+      DB.call_sproc(:test_sproc, :args=>[1, nil])
+      DB[:items].all.should == [{:id=>1, :value=>nil}]
     end
   end
 end
 
-if MYSQL_DB.adapter_scheme == :mysql
+if DB.adapter_scheme == :mysql
   describe "MySQL bad date/time conversions" do
     after do
-      MYSQL_DB.convert_invalid_date_time = false
+      DB.convert_invalid_date_time = false
     end
 
     specify "should raise an exception when a bad date/time is used and convert_invalid_date_time is false" do
-      MYSQL_DB.convert_invalid_date_time = false
-      proc{MYSQL_DB["SELECT CAST('0000-00-00' AS date)"].single_value}.should raise_error(Sequel::InvalidValue)
-      proc{MYSQL_DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value}.should raise_error(Sequel::InvalidValue)
-      proc{MYSQL_DB["SELECT CAST('25:00:00' AS time)"].single_value}.should raise_error(Sequel::InvalidValue)
+      DB.convert_invalid_date_time = false
+      proc{DB["SELECT CAST('0000-00-00' AS date)"].single_value}.should raise_error(Sequel::InvalidValue)
+      proc{DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value}.should raise_error(Sequel::InvalidValue)
+      proc{DB["SELECT CAST('25:00:00' AS time)"].single_value}.should raise_error(Sequel::InvalidValue)
     end
 
     specify "should not use a nil value bad date/time is used and convert_invalid_date_time is nil or :nil" do
-      MYSQL_DB.convert_invalid_date_time = nil
-      MYSQL_DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == nil
-      MYSQL_DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == nil
-      MYSQL_DB["SELECT CAST('25:00:00' AS time)"].single_value.should == nil
-      MYSQL_DB.convert_invalid_date_time = :nil
-      MYSQL_DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == nil
-      MYSQL_DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == nil
-      MYSQL_DB["SELECT CAST('25:00:00' AS time)"].single_value.should == nil
+      DB.convert_invalid_date_time = nil
+      DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == nil
+      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == nil
+      DB["SELECT CAST('25:00:00' AS time)"].single_value.should == nil
+      DB.convert_invalid_date_time = :nil
+      DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == nil
+      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == nil
+      DB["SELECT CAST('25:00:00' AS time)"].single_value.should == nil
     end
 
     specify "should not use a nil value bad date/time is used and convert_invalid_date_time is :string" do
-      MYSQL_DB.convert_invalid_date_time = :string
-      MYSQL_DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == '0000-00-00'
-      MYSQL_DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == '0000-00-00 00:00:00'
-      MYSQL_DB["SELECT CAST('25:00:00' AS time)"].single_value.should == '25:00:00'
+      DB.convert_invalid_date_time = :string
+      DB["SELECT CAST('0000-00-00' AS date)"].single_value.should == '0000-00-00'
+      DB["SELECT CAST('0000-00-00 00:00:00' AS datetime)"].single_value.should == '0000-00-00 00:00:00'
+      DB["SELECT CAST('25:00:00' AS time)"].single_value.should == '25:00:00'
     end
   end
 
   describe "MySQL multiple result sets" do
     before do
-      MYSQL_DB.create_table!(:a){Integer :a}
-      MYSQL_DB.create_table!(:b){Integer :b}
-      @ds = MYSQL_DB['SELECT * FROM a; SELECT * FROM b']
-      MYSQL_DB[:a].insert(10)
-      MYSQL_DB[:a].insert(15)
-      MYSQL_DB[:b].insert(20)
-      MYSQL_DB[:b].insert(25)
+      DB.create_table!(:a){Integer :a}
+      DB.create_table!(:b){Integer :b}
+      @ds = DB['SELECT * FROM a; SELECT * FROM b']
+      DB[:a].insert(10)
+      DB[:a].insert(15)
+      DB[:b].insert(20)
+      DB[:b].insert(25)
     end
     after do
-      MYSQL_DB.drop_table?(:a, :b)
+      DB.drop_table?(:a, :b)
     end
 
     specify "should combine all results by default" do
@@ -1255,14 +1248,14 @@ if MYSQL_DB.adapter_scheme == :mysql
     end
 
     specify "should work with Database#run" do
-      proc{MYSQL_DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
-      proc{MYSQL_DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
+      proc{DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
+      proc{DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
     end
 
     specify "should work with Database#run and other statements" do
-      proc{MYSQL_DB.run('UPDATE a SET a = 1; SELECT * FROM a; DELETE FROM b')}.should_not raise_error
-      MYSQL_DB[:a].select_order_map(:a).should == [1, 1]
-      MYSQL_DB[:b].all.should == []
+      proc{DB.run('UPDATE a SET a = 1; SELECT * FROM a; DELETE FROM b')}.should_not raise_error
+      DB[:a].select_order_map(:a).should == [1, 1]
+      DB[:b].all.should == []
     end
 
     specify "should split results returned into arrays if split_multiple_result_sets is used" do
@@ -1283,24 +1276,24 @@ if MYSQL_DB.adapter_scheme == :mysql
     end
 
     specify "should not allow splitting a graphed dataset" do
-      proc{MYSQL_DB[:a].graph(:b, :b=>:a).split_multiple_result_sets}.should raise_error(Sequel::Error)
+      proc{DB[:a].graph(:b, :b=>:a).split_multiple_result_sets}.should raise_error(Sequel::Error)
     end
   end
 end
 
-if MYSQL_DB.adapter_scheme == :mysql2
+if DB.adapter_scheme == :mysql2
   describe "Mysql2 streaming" do
     before(:all) do
-      MYSQL_DB.create_table!(:a){Integer :a}
-      MYSQL_DB.transaction do
+      DB.create_table!(:a){Integer :a}
+      DB.transaction do
         1000.times do |i|
-          MYSQL_DB[:a].insert(i)
+          DB[:a].insert(i)
         end
       end
-      @ds = MYSQL_DB[:a].stream.order(:a)
+      @ds = DB[:a].stream.order(:a)
     end
     after(:all) do
-      MYSQL_DB.drop_table?(:a)
+      DB.drop_table?(:a)
     end
 
     specify "should correctly stream results" do