asana2flowdock 1.0.0 → 1.1.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/spec/core/database_spec.rb

@@ -1,2487 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-describe "A new Database" do
-  before do
-    @db = Sequel::Database.new(1 => 2, :logger => 3)
-  end
-  after do
-    Sequel.quote_identifiers = false
-    Sequel.identifier_input_method = nil
-    Sequel.identifier_output_method = nil
-  end
-  
-  specify "should receive options" do
-    @db.opts[1].should == 2
-    @db.opts[:logger].should == 3  
-  end
-  
-  specify "should set the logger from opts[:logger] and opts[:loggers]" do
-    @db.loggers.should == [3]
-    Sequel::Database.new(1 => 2, :loggers => 3).loggers.should == [3]
-    Sequel::Database.new(1 => 2, :loggers => [3]).loggers.should == [3]
-    Sequel::Database.new(1 => 2, :logger => 4, :loggers => 3).loggers.should == [4,3]
-    Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).loggers.should == [4,3]
-  end
-
-  specify "should handle the default string column size" do
-    @db.default_string_column_size.should == 255
-    db = Sequel::Database.new(:default_string_column_size=>50)
-    db.default_string_column_size.should == 50
-    db.default_string_column_size = 2
-    db.default_string_column_size.should == 2
-  end
-  
-  specify "should set the sql_log_level from opts[:sql_log_level]" do
-    Sequel::Database.new(1 => 2, :sql_log_level=>:debug).sql_log_level.should == :debug
-    Sequel::Database.new(1 => 2, :sql_log_level=>'debug').sql_log_level.should == :debug
-  end
-  
-  specify "should create a connection pool" do
-    @db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-    @db.pool.max_size.should == 4
-    
-    Sequel::Database.new(:max_connections => 10).pool.max_size.should == 10
-  end
-  
-  specify "should have the connection pool use the connect method to get connections" do
-    cc = nil
-    d = Sequel::Database.new
-    meta_def(d, :connect){|c| 1234}
-    d.synchronize {|c| cc = c}
-    cc.should == 1234
-  end
-
-  specify "should respect the :single_threaded option" do
-    db = Sequel::Database.new(:single_threaded=>true){123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'t'){123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'1'){123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>false){123}
-    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'f'){123}
-    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'0'){123}
-    db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-  end
-
-  specify "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false)
-    db.quote_identifiers?.should == false
-    db = Sequel::Database.new(:quote_identifiers=>true)
-    db.quote_identifiers?.should == true
-  end
-
-  specify "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new
-    db.send(:identifier_input_method_default).should == :upcase
-    db.send(:identifier_output_method_default).should == :downcase
-  end
-
-  specify "should respect the :identifier_input_method option" do
-    Sequel.identifier_input_method = nil
-    Sequel::Database.identifier_input_method.should == false
-    db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.should be_nil
-    db.identifier_input_method = :downcase
-    db.identifier_input_method.should == :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase)
-    db.identifier_input_method.should == :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.should be_nil
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.identifier_input_method.should == :downcase
-    db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.should be_nil
-    db.identifier_input_method = :upcase
-    db.identifier_input_method.should == :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase)
-    db.identifier_input_method.should == :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.should be_nil
-  end
-  
-  specify "should respect the :identifier_output_method option" do
-    Sequel.identifier_output_method = nil
-    Sequel::Database.identifier_output_method.should == false
-    db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.should be_nil
-    db.identifier_output_method = :downcase
-    db.identifier_output_method.should == :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase)
-    db.identifier_output_method.should == :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.should be_nil
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.identifier_output_method.should == :downcase
-    db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.should be_nil
-    db.identifier_output_method = :upcase
-    db.identifier_output_method.should == :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase)
-    db.identifier_output_method.should == :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.should be_nil
-  end
-
-  specify "should use the default Sequel.quote_identifiers value" do
-    Sequel.quote_identifiers = true
-    Sequel::Database.new({}).quote_identifiers?.should == true
-    Sequel.quote_identifiers = false
-    Sequel::Database.new({}).quote_identifiers?.should == false
-    Sequel::Database.quote_identifiers = true
-    Sequel::Database.new({}).quote_identifiers?.should == true
-    Sequel::Database.quote_identifiers = false
-    Sequel::Database.new({}).quote_identifiers?.should == false
-  end
-
-  specify "should use the default Sequel.identifier_input_method value" do
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.new({}).identifier_input_method.should == :downcase
-    Sequel.identifier_input_method = :upcase
-    Sequel::Database.new({}).identifier_input_method.should == :upcase
-    Sequel::Database.identifier_input_method = :downcase
-    Sequel::Database.new({}).identifier_input_method.should == :downcase
-    Sequel::Database.identifier_input_method = :upcase
-    Sequel::Database.new({}).identifier_input_method.should == :upcase
-  end
-  
-  specify "should use the default Sequel.identifier_output_method value" do
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.new({}).identifier_output_method.should == :downcase
-    Sequel.identifier_output_method = :upcase
-    Sequel::Database.new({}).identifier_output_method.should == :upcase
-    Sequel::Database.identifier_output_method = :downcase
-    Sequel::Database.new({}).identifier_output_method.should == :downcase
-    Sequel::Database.identifier_output_method = :upcase
-    Sequel::Database.new({}).identifier_output_method.should == :upcase
-  end
-
-  specify "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
-    Sequel.quote_identifiers = nil
-    Sequel::Database.new({}).quote_identifiers?.should == true
-    x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
-    x.new({}).quote_identifiers?.should == false
-    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
-    y.new({}).quote_identifiers?.should == true
-  end
-  
-  specify "should respect the identifier_input_method_default method" do
-    class Sequel::Database
-      @identifier_input_method = nil
-    end
-    x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
-    x.new({}).identifier_input_method.should == :downcase
-    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
-    y.new({}).identifier_input_method.should == :camelize
-  end
-  
-  specify "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
-    class Sequel::Database
-      @identifier_output_method = nil
-    end
-    x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
-    x.new({}).identifier_output_method.should == :upcase
-    y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
-    y.new({}).identifier_output_method.should == :underscore
-  end
-
-  specify "should just use a :uri option for jdbc with the full connection string" do
-    Sequel::Database.should_receive(:adapter_class).once.with(:jdbc).and_return(Sequel::Database)
-    db = Sequel.connect('jdbc:test://host/db_name')
-    db.should be_a_kind_of(Sequel::Database)
-    db.opts[:uri].should == 'jdbc:test://host/db_name'
-  end
-
-  specify "should just use a :uri option for do with the full connection string" do
-    Sequel::Database.should_receive(:adapter_class).once.with(:do).and_return(Sequel::Database)
-    db = Sequel.connect('do:test://host/db_name')
-    db.should be_a_kind_of(Sequel::Database)
-    db.opts[:uri].should == 'do:test://host/db_name'
-  end
-
-  specify "should populate :adapter option when using connection string" do
-    Sequel.connect('mock:/').opts[:adapter].should == "mock"
-  end
-
-  specify "should respect the :keep_reference option for not keeping a reference in Sequel::DATABASES" do
-    db = Sequel.connect('mock:///?keep_reference=f')
-    Sequel::DATABASES.should_not include(db)
-  end
-end
-
-describe "Database#disconnect" do
-  specify "should call pool.disconnect" do
-    d = Sequel::Database.new
-    p = d.pool
-    p.should_receive(:disconnect).once.with({}).and_return(2)
-    d.disconnect.should == 2
-  end
-end
-
-describe "Sequel.extension" do
-  specify "should attempt to load the given extension" do
-    proc{Sequel.extension :blah}.should raise_error(LoadError)
-  end
-end
-
-describe "Database#log_info" do
-  before do
-    @o = Object.new
-    def @o.logs; @logs || []; end
-    def @o.to_ary; [self]; end
-    def @o.method_missing(*args); (@logs ||= []) << args; end
-    @db = Sequel::Database.new(:logger=>@o)
-  end
-
-  specify "should log message at info level to all loggers" do
-    @db.log_info('blah')
-    @o.logs.should == [[:info, 'blah']]
-  end
-
-  specify "should log message with args at info level to all loggers" do
-    @db.log_info('blah', [1, 2])
-    @o.logs.should == [[:info, 'blah; [1, 2]']]
-  end
-end
-
-describe "Database#log_yield" do
-  before do
-    @o = Object.new
-    def @o.logs; @logs || []; end
-    def @o.warn(*args); (@logs ||= []) << [:warn] + args; end
-    def @o.method_missing(*args); (@logs ||= []) << args; end
-    def @o.to_ary; [self]; end
-    @db = Sequel::Database.new(:logger=>@o)
-  end
-
-  specify "should yield to the passed block" do
-    a = nil
-    @db.log_yield('blah'){a = 1}
-    a.should == 1
-  end
-
-  specify "should raise an exception if a block is not passed" do
-    proc{@db.log_yield('blah')}.should raise_error
-  end
-
-  specify "should log message with duration at info level to all loggers" do
-    @db.log_yield('blah'){}
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :info
-    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
-  end
-
-  specify "should respect sql_log_level setting" do
-    @db.sql_log_level = :debug
-    @db.log_yield('blah'){}
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :debug
-    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
-  end
-
-  specify "should log message with duration at warn level if duration greater than log_warn_duration" do
-    @db.log_warn_duration = 0
-    @db.log_yield('blah'){}
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :warn
-    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
-  end
-
-  specify "should log message with duration at info level if duration less than log_warn_duration" do
-    @db.log_warn_duration = 1000
-    @db.log_yield('blah'){}
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :info
-    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
-  end
-
-  specify "should log message at error level if block raises an error" do
-    @db.log_warn_duration = 0
-    proc{@db.log_yield('blah'){raise Sequel::Error, 'adsf'}}.should raise_error
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :error
-    @o.logs.first.last.should =~ /\ASequel::Error: adsf: blah\z/ 
-  end
-
-  specify "should include args with message if args passed" do
-    @db.log_yield('blah', [1, 2]){}
-    @o.logs.length.should == 1
-    @o.logs.first.length.should == 2
-    @o.logs.first.first.should == :info
-    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/ 
-  end
-end
-
-describe "Database#uri" do
-  before do
-    @c = Class.new(Sequel::Database) do
-      set_adapter_scheme :mau
-    end
-    
-    @db = Sequel.connect('mau://user:pass@localhost:9876/maumau')
-  end
-  
-  specify "should return the connection URI for the database" do
-    @db.uri.should == 'mau://user:pass@localhost:9876/maumau'
-  end
-  
-  specify "should return nil if a connection uri was not used" do
-    Sequel.mock.uri.should be_nil
-  end
-  
-  specify "should be aliased as #url" do
-    @db.url.should == 'mau://user:pass@localhost:9876/maumau'
-  end
-end
-
-describe "Database.adapter_scheme and #adapter_scheme" do
-  specify "should return the database scheme" do
-    Sequel::Database.adapter_scheme.should be_nil
-
-    @c = Class.new(Sequel::Database) do
-      set_adapter_scheme :mau
-    end
-    
-    @c.adapter_scheme.should == :mau
-    @c.new({}).adapter_scheme.should == :mau
-  end
-end
-
-describe "Database#dataset" do
-  before do
-    @db = Sequel::Database.new
-    @ds = @db.dataset
-  end
-  
-  specify "should provide a blank dataset through #dataset" do
-    @ds.should be_a_kind_of(Sequel::Dataset)
-    @ds.opts.should == {}
-    @ds.db.should be(@db)
-  end
-  
-  specify "should provide a #from dataset" do
-    d = @db.from(:mau)
-    d.should be_a_kind_of(Sequel::Dataset)
-    d.sql.should == 'SELECT * FROM mau'
-    
-    e = @db[:miu]
-    e.should be_a_kind_of(Sequel::Dataset)
-    e.sql.should == 'SELECT * FROM miu'
-  end
-  
-  specify "should provide a filtered #from dataset if a block is given" do
-    d = @db.from(:mau){x.sql_number > 100}
-    d.should be_a_kind_of(Sequel::Dataset)
-    d.sql.should == 'SELECT * FROM mau WHERE (x > 100)'
-  end
-  
-  specify "should provide a #select dataset" do
-    d = @db.select(:a, :b, :c).from(:mau)
-    d.should be_a_kind_of(Sequel::Dataset)
-    d.sql.should == 'SELECT a, b, c FROM mau'
-  end
-  
-  specify "should allow #select to take a block" do
-    d = @db.select(:a, :b){c}.from(:mau)
-    d.should be_a_kind_of(Sequel::Dataset)
-    d.sql.should == 'SELECT a, b, c FROM mau'
-  end
-end
-
-describe "Database#dataset_class" do
-  before do
-    @db = Sequel::Database.new
-    @dsc = Class.new(Sequel::Dataset)
-  end
-  
-  specify "should have setter set the class to use to create datasets" do
-    @db.dataset_class = @dsc
-    ds = @db.dataset
-    ds.should be_a_kind_of(@dsc)
-    ds.opts.should == {}
-    ds.db.should be(@db)
-  end
-
-  specify "should have getter return the class to use to create datasets" do
-    [@db.dataset_class, @db.dataset_class.superclass].should include(Sequel::Dataset)
-    @db.dataset_class = @dsc
-    [@db.dataset_class, @db.dataset_class.superclass].should include(@dsc)
-  end
-end
-  
-describe "Database#extend_datasets" do
-  before do
-    @db = Sequel::Database.new
-    @m = Module.new{def foo() [3] end}
-    @m2 = Module.new{def foo() [4] + super end}
-    @db.extend_datasets(@m)
-  end
-  
-  specify "should clear a cached dataset" do
-    @db = Sequel::Database.new
-    @db.literal(1).should == '1'
-    @db.extend_datasets{def literal(v) '2' end}
-    @db.literal(1).should == '2'
-  end
-
-  specify "should change the dataset class to a subclass the first time it is called" do
-    @db.dataset_class.superclass.should == Sequel::Dataset
-  end
-
-  specify "should not create a subclass of the dataset class if called more than once" do
-    @db.extend_datasets(@m2)
-    @db.dataset_class.superclass.should == Sequel::Dataset
-  end
-
-  specify "should make the dataset class include the module" do
-    @db.dataset_class.ancestors.should include(@m)
-    @db.dataset_class.ancestors.should_not include(@m2)
-    @db.extend_datasets(@m2)
-    @db.dataset_class.ancestors.should include(@m)
-    @db.dataset_class.ancestors.should include(@m2)
-  end
-
-  specify "should have datasets respond to the module's methods" do
-    @db.dataset.foo.should == [3]
-    @db.extend_datasets(@m2)
-    @db.dataset.foo.should == [4, 3]
-  end
-
-  specify "should take a block and create a module from it to use" do
-    @db.dataset.foo.should == [3]
-    @db.extend_datasets{def foo() [5] + super end}
-    @db.dataset.foo.should == [5, 3]
-  end
-
-  specify "should raise an error if both a module and a block are provided" do
-    proc{@db.extend_datasets(@m2){def foo() [5] + super end}}.should raise_error(Sequel::Error)
-  end
-
-  specify "should be able to override methods defined in the original Dataset class" do
-    @db.extend_datasets(Module.new{def select(*a, &block) super.order(*a, &block) end})
-    @db[:t].select(:a, :b).sql.should == 'SELECT a, b FROM t ORDER BY a, b'
-  end
-
-  specify "should reapply settings if dataset_class is changed" do
-    c = Class.new(Sequel::Dataset)
-    @db.dataset_class = c
-    @db.dataset_class.superclass.should == c
-    @db.dataset_class.ancestors.should include(@m)
-    @db.dataset.foo.should == [3]
-  end
-end
-  
-describe "Database#disconnect_connection" do
-  specify "should call close on the connection" do
-    o = Object.new
-    def o.close() @closed=true end
-    Sequel::Database.new.disconnect_connection(o)
-    o.instance_variable_get(:@closed).should == true
-  end
-end
-
-describe "Database#valid_connection?" do
-  specify "should issue a query to validate the connection" do
-    db = Sequel.mock
-    db.synchronize{|c| db.valid_connection?(c)}.should == true
-    db.synchronize do |c|
-      def c.execute(*) raise Sequel::DatabaseError, "error" end
-      db.valid_connection?(c)
-    end.should == false
-  end
-end
-
-describe "Database#run" do
-  before do
-    @db = Sequel.mock(:servers=>{:s1=>{}})
-  end
-  
-  specify "should execute the code on the database" do
-    @db.run("DELETE FROM items")
-    @db.sqls.should == ["DELETE FROM items"]
-  end
-  
-  specify "should handle placeholder literal strings" do
-    @db.run(Sequel.lit("DELETE FROM ?", :items))
-    @db.sqls.should == ["DELETE FROM items"]
-  end
-  
-  specify "should return nil" do
-    @db.run("DELETE FROM items").should be_nil
-  end
-  
-  specify "should accept options passed to execute_ddl" do
-    @db.run("DELETE FROM items", :server=>:s1)
-    @db.sqls.should == ["DELETE FROM items -- s1"]
-  end
-end
-
-describe "Database#<<" do
-  before do
-    @db = Sequel.mock
-  end
-
-  specify "should execute the code on the database" do
-    @db << "DELETE FROM items"
-    @db.sqls.should == ["DELETE FROM items"]
-  end
-  
-  specify "should handle placeholder literal strings" do
-    @db << Sequel.lit("DELETE FROM ?", :items)
-    @db.sqls.should == ["DELETE FROM items"]
-  end
-  
-  specify "should be chainable" do
-    @db << "DELETE FROM items" << "DELETE FROM items2"
-    @db.sqls.should == ["DELETE FROM items", "DELETE FROM items2"]
-  end
-end
-
-describe "Database#synchronize" do
-  before do
-    @db = Sequel::Database.new(:max_connections => 1)
-    meta_def(@db, :connect){|c| 12345}
-  end
-  
-  specify "should wrap the supplied block in pool.hold" do
-    q, q1, q2 = Queue.new, Queue.new, Queue.new
-    c1, c2 = nil
-    t1 = Thread.new{@db.synchronize{|c| c1 = c; q.push nil; q1.pop}; q.push nil}
-    q.pop
-    c1.should == 12345
-    t2 = Thread.new{@db.synchronize{|c| c2 = c; q2.push nil}}
-    @db.pool.available_connections.should be_empty
-    c2.should be_nil
-    q1.push nil
-    q.pop
-    q2.pop
-    c2.should == 12345
-    t1.join
-    t2.join
-  end
-end
-
-describe "Database#test_connection" do
-  before do
-    @db = Sequel::Database.new
-    pr = proc{@test = rand(100)}
-    meta_def(@db, :connect){|c| pr.call}
-  end
-  
-  specify "should attempt to get a connection" do
-    @db.test_connection
-    @test.should_not be_nil
-  end
-  
-  specify "should return true if successful" do
-    @db.test_connection.should == true
-  end
-
-  specify "should raise an error if the attempting to connect raises an error" do
-    def @db.connect(*) raise Sequel::Error end
-    proc{@db.test_connection}.should raise_error(Sequel::Error)
-  end
-end
-
-describe "Database#table_exists?" do
-  specify "should test existence by selecting a row from the table's dataset" do
-    db = Sequel.mock(:fetch=>[Sequel::Error, [], [{:a=>1}]])
-    db.table_exists?(:a).should == false
-    db.sqls.should == ["SELECT NULL AS nil FROM a LIMIT 1"]
-    db.table_exists?(:b).should == true
-    db.table_exists?(:c).should == true
-  end
-end
-
-shared_examples_for "Database#transaction" do  
-  specify "should wrap the supplied block with BEGIN + COMMIT statements" do
-    @db.transaction{@db.execute 'DROP TABLE test;'}
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should support transaction isolation levels" do
-    meta_def(@db, :supports_transaction_isolation_levels?){true}
-    [:uncommitted, :committed, :repeatable, :serializable].each do |l|
-      @db.transaction(:isolation=>l){@db.run "DROP TABLE #{l}"}
-    end
-    @db.sqls.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED', 'DROP TABLE committed', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'DROP TABLE repeatable', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
-  end
-
-  specify "should allow specifying a default transaction isolation level" do
-    meta_def(@db, :supports_transaction_isolation_levels?){true}
-    [:uncommitted, :committed, :repeatable, :serializable].each do |l|
-      @db.transaction_isolation_level = l
-      @db.transaction{@db.run "DROP TABLE #{l}"}
-    end
-    @db.sqls.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED', 'DROP TABLE committed', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'DROP TABLE repeatable', 'COMMIT',
-                       'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
-  end
-  
-  specify "should support :retry_on option for automatically retrying transactions" do
-    a = []
-    @db.transaction(:retry_on=>Sequel::DatabaseDisconnectError){a << 1; raise Sequel::DatabaseDisconnectError if a.length < 2}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.should == [1, 1]
-
-    a = []
-    @db.transaction(:retry_on=>[Sequel::ConstraintViolation, Sequel::SerializationFailure]) do
-      a << 1
-      raise Sequel::SerializationFailure if a.length == 1
-      raise Sequel::ConstraintViolation if a.length == 2
-    end
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.should == [1, 1, 1]
-  end
-  
-  specify "should support :num_retries option for limiting the number of retry times" do
-    a = []
-    lambda do
-      @db.transaction(:num_retries=>1, :retry_on=>[Sequel::ConstraintViolation, Sequel::SerializationFailure]) do
-        a << 1
-        raise Sequel::SerializationFailure if a.length == 1
-        raise Sequel::ConstraintViolation if a.length == 2
-      end
-    end.should raise_error(Sequel::ConstraintViolation)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK']
-    a.should == [1, 1]
-  end
-  
-  specify "should support :num_retries=>nil option to retry indefinitely" do
-    a = []
-    lambda do
-      @db.transaction(:num_retries=>nil, :retry_on=>[Sequel::ConstraintViolation]) do
-        a << 1
-        raise Sequel::SerializationFailure if a.length >= 100
-        raise Sequel::ConstraintViolation
-      end
-    end.should raise_error(Sequel::SerializationFailure)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK'] * 100
-    a.should == [1] * 100
-  end
-  
-  specify "should raise an error if attempting to use :retry_on inside another transaction" do
-    proc{@db.transaction{@db.transaction(:retry_on=>Sequel::ConstraintViolation){}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-  
-  specify "should handle returning inside of the block by committing" do
-    def @db.ret_commit
-      transaction do
-        execute 'DROP TABLE test;'
-        return
-      end
-    end
-    @db.ret_commit
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should issue ROLLBACK if an exception is raised, and re-raise" do
-    @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
-  end
-  
-  specify "should handle errors when sending BEGIN" do
-    ec = Class.new(StandardError)
-    meta_def(@db, :database_error_classes){[ec]}
-    meta_def(@db, :log_connection_execute){|c, sql| sql =~ /BEGIN/ ? raise(ec, 'bad') : super(c, sql)}
-    begin
-      @db.transaction{@db.execute 'DROP TABLE test;'}
-    rescue Sequel::DatabaseError => e
-    end
-    e.should_not be_nil
-    e.wrapped_exception.should be_a_kind_of(ec)
-    @db.sqls.should == ['ROLLBACK']
-  end
-  
-  specify "should handle errors when sending COMMIT" do
-    ec = Class.new(StandardError)
-    meta_def(@db, :database_error_classes){[ec]}
-    meta_def(@db, :log_connection_execute){|c, sql| sql =~ /COMMIT/ ? raise(ec, 'bad') : super(c, sql)}
-    begin
-      @db.transaction{@db.execute 'DROP TABLE test;'}
-    rescue Sequel::DatabaseError => e
-    end
-    e.should_not be_nil
-    e.wrapped_exception.should be_a_kind_of(ec)
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
-  end
-  
-  specify "should raise original exception if there is an exception raised when rolling back" do
-    ec = Class.new(StandardError)
-    meta_def(@db, :database_error_classes){[ec]}
-    meta_def(@db, :log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
-    begin
-      @db.transaction{raise ArgumentError, 'asdf'}
-    rescue => e
-    end
-    e.should be_a_kind_of(ArgumentError)
-    @db.sqls.should == ['BEGIN']
-  end
-  
-  specify "should issue ROLLBACK if Sequel::Rollback is called in the transaction" do
-    @db.transaction do
-      @db.drop_table(:a)
-      raise Sequel::Rollback
-      @db.drop_table(:b)
-    end
-    
-    @db.sqls.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
-  end
-  
-  specify "should have in_transaction? return true if inside a transaction" do
-    c = nil
-    @db.transaction{c = @db.in_transaction?}
-    c.should == true
-  end
-  
-  specify "should have in_transaction? handle sharding correctly" do
-    c = []
-    @db.transaction(:server=>:test){c << @db.in_transaction?}
-    @db.transaction(:server=>:test){c << @db.in_transaction?(:server=>:test)}
-    c.should == [false, true]
-  end
-  
-  specify "should have in_transaction? return false if not in a transaction" do
-    @db.in_transaction?.should == false
-  end
-  
-  specify "should return nil if Sequel::Rollback is called in the transaction" do
-    @db.transaction{raise Sequel::Rollback}.should be_nil
-  end
-  
-  specify "should reraise Sequel::Rollback errors when using :rollback=>:reraise option is given" do
-    proc {@db.transaction(:rollback=>:reraise){raise Sequel::Rollback}}.should raise_error(Sequel::Rollback)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-    proc {@db.transaction(:rollback=>:reraise){raise ArgumentError}}.should raise_error(ArgumentError)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:reraise){1}.should == 1
-    @db.sqls.should == ['BEGIN', 'COMMIT']
-  end
-  
-  specify "should always rollback if :rollback=>:always option is given" do
-    proc {@db.transaction(:rollback=>:always){raise ArgumentError}}.should raise_error(ArgumentError)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:always){raise Sequel::Rollback}.should be_nil
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:always){1}.should be_nil
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-    catch(:foo) do
-      @db.transaction(:rollback=>:always){throw :foo}
-    end
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-  
-  specify "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
-    meta_def(@db, :commit_transaction){raise ArgumentError}
-    lambda{@db.transaction{}}.should raise_error(ArgumentError)
-
-    meta_def(@db, :database_error_classes){[ArgumentError]}
-    lambda{@db.transaction{}}.should raise_error(Sequel::DatabaseError)
-  end
-  
-  specify "should be re-entrant" do
-    q, q1 = Queue.new, Queue.new
-    cc = nil
-    t = Thread.new do
-      @db.transaction {@db.transaction {@db.transaction {|c|
-        cc = c
-        q.pop
-        q1.push nil
-        q.pop
-      }}}
-    end
-    q.push nil
-    q1.pop
-    cc.should be_a_kind_of(Sequel::Mock::Connection)
-    tr = @db.instance_variable_get(:@transactions)
-    tr.keys.should == [cc]
-    q.push nil
-    t.join
-    tr.should be_empty
-  end
-
-  specify "should correctly handle nested transacation use with separate shards" do
-    @db.transaction do |c1|
-      @db.transaction(:server=>:test) do |c2|
-        c1.should_not == c2
-        @db.execute 'DROP TABLE test;'
-      end
-    end
-    @db.sqls.should == ['BEGIN', 'BEGIN -- test', 'DROP TABLE test;', 'COMMIT -- test', 'COMMIT']
-  end
-  
-  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and !RUBY_VERSION.start_with?('1.9')
-    specify "should handle Thread#kill for transactions inside threads" do
-      q = Queue.new
-      q1 = Queue.new
-      t = Thread.new do
-        @db.transaction do
-          @db.execute 'DROP TABLE test'
-          q1.push nil
-          q.pop
-          @db.execute 'DROP TABLE test2'
-        end
-      end
-      q1.pop
-      t.kill
-      t.join
-      @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    end
-  end
-
-  specify "should raise an Error if after_commit or after_rollback is called without a block" do
-    proc{@db.after_commit}.should raise_error(Sequel::Error)
-    proc{@db.after_rollback}.should raise_error(Sequel::Error)
-  end
-
-  specify "should have after_commit and after_rollback respect :server option" do
-    @db.transaction(:server=>:test){@db.after_commit(:server=>:test){@db.execute('foo', :server=>:test)}}
-    @db.sqls.should == ['BEGIN -- test', 'COMMIT -- test', 'foo -- test']
-    @db.transaction(:server=>:test){@db.after_rollback(:server=>:test){@db.execute('foo', :server=>:test)}; raise Sequel::Rollback}
-    @db.sqls.should == ['BEGIN -- test', 'ROLLBACK -- test', 'foo -- test']
-  end
-
-  specify "should execute after_commit outside transactions" do
-    @db.after_commit{@db.execute('foo')}
-    @db.sqls.should == ['foo']
-  end
-
-  specify "should ignore after_rollback outside transactions" do
-    @db.after_rollback{@db.execute('foo')}
-    @db.sqls.should == []
-  end
-
-  specify "should support after_commit inside transactions" do
-    @db.transaction{@db.after_commit{@db.execute('foo')}}
-    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo']
-  end
-
-  specify "should support after_rollback inside transactions" do
-    @db.transaction{@db.after_rollback{@db.execute('foo')}}
-    @db.sqls.should == ['BEGIN', 'COMMIT']
-  end
-
-  specify "should not call after_commit if the transaction rolls back" do
-    @db.transaction{@db.after_commit{@db.execute('foo')}; raise Sequel::Rollback}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-
-  specify "should call after_rollback if the transaction rolls back" do
-    @db.transaction{@db.after_rollback{@db.execute('foo')}; raise Sequel::Rollback}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo']
-  end
-
-  specify "should call multiple after_commit blocks in order if called inside transactions" do
-    @db.transaction{@db.after_commit{@db.execute('foo')}; @db.after_commit{@db.execute('bar')}}
-    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo', 'bar']
-  end
-
-  specify "should call multiple after_rollback blocks in order if called inside transactions" do
-    @db.transaction{@db.after_rollback{@db.execute('foo')}; @db.after_rollback{@db.execute('bar')}; raise Sequel::Rollback}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo', 'bar']
-  end
-
-  specify "should support after_commit inside nested transactions" do
-    @db.transaction{@db.transaction{@db.after_commit{@db.execute('foo')}}}
-    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo']
-  end
-
-  specify "should support after_rollback inside nested transactions" do
-    @db.transaction{@db.transaction{@db.after_rollback{@db.execute('foo')}}; raise Sequel::Rollback}
-    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo']
-  end
-
-  specify "should raise an error if you attempt to use after_commit inside a prepared transaction" do
-    meta_def(@db, :supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{@db.execute('foo')}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-
-  specify "should raise an error if you attempt to use after_rollback inside a prepared transaction" do
-    meta_def(@db, :supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'ROLLBACK']
-  end
-end
-
-describe "Database#transaction with savepoint support" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-  end
-
-  it_should_behave_like "Database#transaction"
-
-  specify "should support after_commit inside savepoints" do
-    @db.transaction do
-      @db.after_commit{@db.execute('foo')}
-      @db.transaction(:savepoint=>true){@db.after_commit{@db.execute('bar')}}
-      @db.after_commit{@db.execute('baz')}
-    end
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT', 'foo', 'bar', 'baz']
-  end
-
-  specify "should support after_rollback inside savepoints" do
-    @db.transaction do
-      @db.after_rollback{@db.execute('foo')}
-      @db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('bar')}}
-      @db.after_rollback{@db.execute('baz')}
-      raise Sequel::Rollback
-    end
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
-  end
-
-  specify "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
-    meta_def(@db, :supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-  end
-
-  specify "should raise an error if you attempt to use after_rollback inside a savepoint in a prepared transaction" do
-    meta_def(@db, :supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-  end
-end
-  
-describe "Database#transaction without savepoint support" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-    meta_def(@db, :supports_savepoints?){false}
-  end
-
-  it_should_behave_like "Database#transaction"
-end
-  
-describe "Sequel.transaction" do
-  before do
-    @sqls = []
-    @db1 = Sequel.mock(:append=>'1', :sqls=>@sqls)
-    @db2 = Sequel.mock(:append=>'2', :sqls=>@sqls)
-    @db3 = Sequel.mock(:append=>'3', :sqls=>@sqls)
-  end
-  
-  specify "should run the block inside transacitons on all three databases" do
-    Sequel.transaction([@db1, @db2, @db3]){1}.should == 1
-    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
-  end
-  
-  specify "should pass options to all the blocks" do
-    Sequel.transaction([@db1, @db2, @db3], :rollback=>:always){1}.should be_nil
-    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
-  end
-  
-  specify "should handle Sequel::Rollback exceptions raised by the block to rollback on all databases" do
-    Sequel.transaction([@db1, @db2, @db3]){raise Sequel::Rollback}.should be_nil
-    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
-  end
-  
-  specify "should handle nested transactions" do
-    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3]){1}}.should == 1
-    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
-  end
-  
-  specify "should handle savepoints" do
-    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3], :savepoint=>true){1}}.should == 1
-    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3',
-      'SAVEPOINT autopoint_1 -- 1', 'SAVEPOINT autopoint_1 -- 2', 'SAVEPOINT autopoint_1 -- 3',
-      'RELEASE SAVEPOINT autopoint_1 -- 3', 'RELEASE SAVEPOINT autopoint_1 -- 2', 'RELEASE SAVEPOINT autopoint_1 -- 1',
-      'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
-  end
-end
-  
-describe "Database#transaction with savepoints" do
-  before do
-    @db = Sequel.mock
-  end
-  
-  specify "should wrap the supplied block with BEGIN + COMMIT statements" do
-    @db.transaction {@db.execute 'DROP TABLE test;'}
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should use savepoints if given the :savepoint option" do
-    @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}}
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-  
-  specify "should use savepoints if surrounding transaction uses :auto_savepoint option" do
-    @db.transaction(:auto_savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-
-    @db.transaction(:auto_savepoint=>true){@db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}}
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-
-    @db.transaction(:auto_savepoint=>true){@db.transaction(:auto_savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}}
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-
-    @db.transaction{@db.transaction(:auto_savepoint=>true, :savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}}
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-
-  specify "should not use savepoints if surrounding transaction uses :auto_savepoint and current transaction uses :savepoint=>false option" do
-    @db.transaction(:auto_savepoint=>true){@db.transaction(:savepoint=>false){@db.execute 'DROP TABLE test;'}}
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should not use a savepoint if no transaction is in progress" do
-    @db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should reuse the current transaction if no :savepoint option is given" do
-    @db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should handle returning inside of the block by committing" do
-    def @db.ret_commit
-      transaction do
-        execute 'DROP TABLE test;'
-        return
-      end
-    end
-    @db.ret_commit
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  specify "should handle returning inside of a savepoint by committing" do
-    def @db.ret_commit
-      transaction do
-        transaction(:savepoint=>true) do
-          execute 'DROP TABLE test;'
-          return
-        end
-      end
-    end
-    @db.ret_commit
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-  
-  specify "should issue ROLLBACK if an exception is raised, and re-raise" do
-    @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
-  end
-  
-  specify "should issue ROLLBACK SAVEPOINT if an exception is raised inside a savepoint, and re-raise" do
-    @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test'; raise RuntimeError}} rescue nil
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
-  end
-  
-  specify "should issue ROLLBACK if Sequel::Rollback is raised in the transaction" do
-    @db.transaction do
-      @db.drop_table(:a)
-      raise Sequel::Rollback
-      @db.drop_table(:b)
-    end
-    
-    @db.sqls.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
-  end
-  
-  specify "should issue ROLLBACK SAVEPOINT if Sequel::Rollback is raised in a savepoint" do
-    @db.transaction do
-      @db.transaction(:savepoint=>true) do
-        @db.drop_table(:a)
-        raise Sequel::Rollback
-      end
-      @db.drop_table(:b)
-    end
-    
-    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'DROP TABLE b', 'COMMIT']
-  end
-  
-  specify "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
-    meta_def(@db, :commit_transaction){raise ArgumentError}
-    lambda{@db.transaction{}}.should raise_error(ArgumentError)
-    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.should raise_error(ArgumentError)
-
-    meta_def(@db, :database_error_classes){[ArgumentError]}
-    lambda{@db.transaction{}}.should raise_error(Sequel::DatabaseError)
-    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.should raise_error(Sequel::DatabaseError)
-  end
-end
-
-describe "A Database adapter with a scheme" do
-  before do
-    @ccc = Class.new(Sequel::Mock::Database)
-    @ccc.send(:set_adapter_scheme, :ccc)
-  end
-
-  specify "should be registered in the ADAPTER_MAP" do
-    Sequel::ADAPTER_MAP[:ccc].should == @ccc
-  end
-  
-  specify "should give the database_type as the adapter scheme by default" do
-    @ccc.new.database_type.should == :ccc
-  end
-  
-  specify "should be instantiated when its scheme is specified" do
-    c = Sequel::Database.connect('ccc://localhost/db')
-    c.should be_a_kind_of(@ccc)
-    c.opts[:host].should == 'localhost'
-    c.opts[:database].should == 'db'
-  end
-  
-  specify "should be accessible through Sequel.connect" do
-    c = Sequel.connect 'ccc://localhost/db'
-    c.should be_a_kind_of(@ccc)
-    c.opts[:host].should == 'localhost'
-    c.opts[:database].should == 'db'
-  end
-
-  specify "should be accessible through Sequel.connect via a block" do
-    x = nil
-    y = nil
-    z = nil
-    returnValue = 'anything'
-
-    p = proc do |c|
-      c.should be_a_kind_of(@ccc)
-      c.opts[:host].should == 'localhost'
-      c.opts[:database].should == 'db'
-      z = y
-      y = x
-      x = c
-      returnValue
-    end
-
-    @ccc.class_eval do
-      self::DISCONNECTS = []
-      def disconnect
-        self.class::DISCONNECTS << self
-      end
-    end
-    Sequel::Database.connect('ccc://localhost/db', &p).should == returnValue
-    @ccc::DISCONNECTS.should == [x]
-
-    Sequel.connect('ccc://localhost/db', &p).should == returnValue
-    @ccc::DISCONNECTS.should == [y, x]
-
-    Sequel.send(:def_adapter_method, :ccc)
-    Sequel.ccc('db', :host=>'localhost', &p).should == returnValue
-    @ccc::DISCONNECTS.should == [z, y, x]
-    class << Sequel; remove_method(:ccc) end
-  end
-
-  specify "should be accessible through Sequel.<adapter>" do
-    Sequel.send(:def_adapter_method, :ccc)
-
-    # invalid parameters
-    proc {Sequel.ccc('abc', 'def')}.should raise_error(Sequel::Error)
-    proc {Sequel.ccc(1)}.should raise_error(Sequel::Error)
-    
-    c = Sequel.ccc('mydb')
-    c.should be_a_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :adapter_class).should == [:ccc, 'mydb', @ccc]
-    
-    c = Sequel.ccc('mydb', :host => 'localhost')
-    c.should be_a_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :host, :adapter_class).should == [:ccc, 'mydb', 'localhost', @ccc]
-    
-    c = Sequel.ccc
-    c.should be_a_kind_of(@ccc)
-    c.opts.values_at(:adapter, :adapter_class).should == [:ccc, @ccc]
-    
-    c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
-    c.should be_a_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :host, :adapter_class).should == [:ccc, 'mydb', 'localhost', @ccc]
-    class << Sequel; remove_method(:ccc) end
-  end
-  
-  specify "should be accessible through Sequel.connect with options" do
-    c = Sequel.connect(:adapter => :ccc, :database => 'mydb')
-    c.should be_a_kind_of(@ccc)
-    c.opts[:adapter].should == :ccc
-  end
-
-  specify "should be accessible through Sequel.connect with URL parameters" do
-    c = Sequel.connect 'ccc:///db?host=/tmp&user=test'
-    c.should be_a_kind_of(@ccc)
-    c.opts[:host].should == '/tmp'
-    c.opts[:database].should == 'db'
-    c.opts[:user].should == 'test'
-  end
-  
-  specify "should have URL parameters take precedence over fixed URL parts" do
-    c = Sequel.connect 'ccc://localhost/db?host=a&database=b'
-    c.should be_a_kind_of(@ccc)
-    c.opts[:host].should == 'a'
-    c.opts[:database].should == 'b'
-  end
-  
-  specify "should have hash options take predence over URL parameters or parts" do
-    c = Sequel.connect 'ccc://localhost/db?host=/tmp', :host=>'a', :database=>'b', :user=>'c'
-    c.should be_a_kind_of(@ccc)
-    c.opts[:host].should == 'a'
-    c.opts[:database].should == 'b'
-    c.opts[:user].should == 'c'
-  end
-
-  specify "should unescape values of URL parameters and parts" do
-    c = Sequel.connect 'ccc:///d%5bb%5d?host=domain%5cinstance'
-    c.should be_a_kind_of(@ccc)
-    c.opts[:database].should == 'd[b]'
-    c.opts[:host].should == 'domain\\instance'
-  end
-
-  specify "should test the connection if test parameter is truthy" do
-    @ccc.send(:define_method, :connect){}
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=t'}.should raise_error(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=1'}.should raise_error(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>true}.should raise_error(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>'t'}.should raise_error(Sequel::DatabaseConnectionError)
-  end
-
-  specify "should not test the connection if test parameter is not truthy" do
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=f'}.should_not raise_error
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=0'}.should_not raise_error
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>false}.should_not raise_error
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>'f'}.should_not raise_error
-  end
-end
-
-describe "Sequel::Database.connect" do
-  specify "should raise an Error if not given a String or Hash" do
-    proc{Sequel::Database.connect(nil)}.should raise_error(Sequel::Error)
-    proc{Sequel::Database.connect(Object.new)}.should raise_error(Sequel::Error)
-  end
-end
-
-describe "An unknown database scheme" do
-  specify "should raise an error in Sequel::Database.connect" do
-    proc {Sequel::Database.connect('ddd://localhost/db')}.should raise_error(Sequel::AdapterNotFound)
-  end
-
-  specify "should raise an error in Sequel.connect" do
-    proc {Sequel.connect('ddd://localhost/db')}.should raise_error(Sequel::AdapterNotFound)
-  end
-end
-
-describe "A broken adapter (lib is there but the class is not)" do
-  before do
-    @fn = File.join(File.dirname(__FILE__), '../../lib/sequel/adapters/blah.rb')
-    File.open(@fn,'a'){}
-  end
-  
-  after do
-    File.delete(@fn)
-  end
-  
-  specify "should raise an error" do
-    proc {Sequel.connect('blah://blow')}.should raise_error(Sequel::AdapterNotFound)
-  end
-end
-
-describe "Sequel::Database.load_adapter" do
-  specify "should not raise an error if subadapter does not exist" do
-    Sequel::Database.load_adapter(:foo, :subdir=>'bar').should == nil
-  end
-end
-
-describe "A single threaded database" do
-  after do
-    Sequel::Database.single_threaded = false
-  end
-  
-  specify "should use a SingleConnectionPool instead of a ConnectionPool" do
-    db = Sequel::Database.new(:single_threaded => true){123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-  end
-  
-  specify "should be constructable using :single_threaded => true option" do
-    db = Sequel::Database.new(:single_threaded => true){123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-  end
-  
-  specify "should be constructable using Database.single_threaded = true" do
-    Sequel::Database.single_threaded = true
-    db = Sequel::Database.new{123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-  end
-
-  specify "should be constructable using Sequel.single_threaded = true" do
-    Sequel.single_threaded = true
-    db = Sequel::Database.new{123}
-    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
-  end
-end
-
-describe "A single threaded database" do
-  before do
-    conn = 1234567
-    @db = Sequel::Database.new(:single_threaded => true)
-    meta_def(@db, :connect) do |c|
-      conn += 1
-    end
-  end
-  
-  specify "should invoke connection_proc only once" do
-    @db.pool.hold {|c| c.should == 1234568}
-    @db.pool.hold {|c| c.should == 1234568}
-  end
-  
-  specify "should disconnect correctly" do
-    def @db.disconnect_connection(c); @dc = c end
-    def @db.dc; @dc end
-    x = nil
-    @db.pool.hold{|c| x = c}
-    @db.pool.hold{|c| c.should == x}
-    proc{@db.disconnect}.should_not raise_error
-    @db.dc.should == x
-  end
-  
-  specify "should convert an Exception on connection into a DatabaseConnectionError" do
-    db = Sequel::Database.new(:single_threaded => true, :servers=>{})
-    def db.connect(*) raise Exception end
-    proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
-  end
-  
-  specify "should raise a DatabaseConnectionError if the connection proc returns nil" do
-    db = Sequel.mock(:single_threaded => true, :servers=>{})
-    def db.connect(*) end
-    proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
-  end
-end
-
-describe "A database" do
-  after do
-    Sequel::Database.single_threaded = false
-  end
-  
-  specify "should have single_threaded? respond to true if in single threaded mode" do
-    db = Sequel::Database.new(:single_threaded => true){1234}
-    db.should be_single_threaded
-    
-    db = Sequel::Database.new(:max_options => 1)
-    db.should_not be_single_threaded
-    
-    db = Sequel::Database.new
-    db.should_not be_single_threaded
-    
-    Sequel::Database.single_threaded = true
-    
-    db = Sequel::Database.new{123}
-    db.should be_single_threaded
-    
-    db = Sequel::Database.new(:max_options => 4){123}
-    db.should be_single_threaded
-  end
-  
-  specify "should be able to set loggers via the logger= and loggers= methods" do
-    db = Sequel::Database.new
-    s = "I'm a logger"
-    db.logger = s
-    db.loggers.should == [s]
-    db.logger = nil
-    db.loggers.should == []
-
-    db.loggers = [s]
-    db.loggers.should == [s]
-    db.loggers = []
-    db.loggers.should == []
-
-    t = "I'm also a logger"
-    db.loggers = [s, t]
-    db.loggers.should == [s,t]
-  end
-end
-
-describe "Database#fetch" do
-  before do
-    @db = Sequel.mock(:fetch=>proc{|sql| {:sql => sql}})
-  end
-  
-  specify "should create a dataset and invoke its fetch_rows method with the given sql" do
-    sql = nil
-    @db.fetch('select * from xyz') {|r| sql = r[:sql]}
-    sql.should == 'select * from xyz'
-  end
-  
-  specify "should format the given sql with any additional arguments" do
-    sql = nil
-    @db.fetch('select * from xyz where x = ? and y = ?', 15, 'abc') {|r| sql = r[:sql]}
-    sql.should == "select * from xyz where x = 15 and y = 'abc'"
-    
-    @db.fetch('select name from table where name = ? or id in ?', 'aman', [3,4,7]) {|r| sql = r[:sql]}
-    sql.should == "select name from table where name = 'aman' or id in (3, 4, 7)"
-  end
-  
-  specify "should format the given sql with named arguments" do
-    sql = nil
-    @db.fetch('select * from xyz where x = :x and y = :y', :x=>15, :y=>'abc') {|r| sql = r[:sql]}
-    sql.should == "select * from xyz where x = 15 and y = 'abc'"
-  end
-  
-  specify "should return the dataset if no block is given" do
-    @db.fetch('select * from xyz').should be_a_kind_of(Sequel::Dataset)
-    
-    @db.fetch('select a from b').map {|r| r[:sql]}.should == ['select a from b']
-
-    @db.fetch('select c from d').inject([]) {|m, r| m << r; m}.should == \
-      [{:sql => 'select c from d'}]
-  end
-  
-  specify "should return a dataset that always uses the given sql for SELECTs" do
-    ds = @db.fetch('select * from xyz')
-    ds.select_sql.should == 'select * from xyz'
-    ds.sql.should == 'select * from xyz'
-    
-    ds.filter!{price.sql_number < 100}
-    ds.select_sql.should == 'select * from xyz'
-    ds.sql.should == 'select * from xyz'
-  end
-end
-
-
-describe "Database#[]" do
-  before do
-    @db = Sequel.mock
-  end
-  
-  specify "should return a dataset when symbols are given" do
-    ds = @db[:items]
-    ds.should be_a_kind_of(Sequel::Dataset)
-    ds.opts[:from].should == [:items]
-  end
-  
-  specify "should return a dataset when a string is given" do
-    @db.fetch = proc{|sql| {:sql=>sql}}
-    sql = nil
-    @db['select * from xyz where x = ? and y = ?', 15, 'abc'].each {|r| sql = r[:sql]}
-    sql.should == "select * from xyz where x = 15 and y = 'abc'"
-  end
-end
-
-describe "Database#inspect" do
-  specify "should include the class name and the connection url" do
-    Sequel.connect('mock://foo/bar').inspect.should == '#<Sequel::Mock::Database: "mock://foo/bar">'
-  end
-
-  specify "should include the class name and the connection options if an options hash was given" do
-    Sequel.connect(:adapter=>:mock).inspect.should =~ /#<Sequel::Mock::Database: \{:adapter=>:mock\}>/
-  end
-
-  specify "should include the class name, uri, and connection options if uri and options hash was given" do
-    Sequel.connect('mock://foo', :database=>'bar').inspect.should =~ /#<Sequel::Mock::Database: "mock:\/\/foo" \{:database=>"bar"\}>/
-  end
-end
-
-describe "Database#get" do
-  before do
-    @db = Sequel.mock(:fetch=>{:a=>1})
-  end
-  
-  specify "should use Dataset#get to get a single value" do
-    @db.get(:a).should == 1
-    @db.sqls.should == ['SELECT a LIMIT 1']
-    
-    @db.get(Sequel.function(:version).as(:version))
-    @db.sqls.should == ['SELECT version() AS version LIMIT 1']
-  end
-
-  specify "should accept a block" do
-    @db.get{a}
-    @db.sqls.should == ['SELECT a LIMIT 1']
-    
-    @db.get{version(a).as(version)}
-    @db.sqls.should == ['SELECT version(a) AS version LIMIT 1']
-  end
-
-  specify "should work when an alias cannot be determined" do
-    @db.get(1).should == 1
-    @db.sqls.should == ['SELECT 1 AS v LIMIT 1']
-  end
-end
-
-describe "Database#call" do
-  specify "should call the prepared statement with the given name" do
-    db = Sequel.mock(:fetch=>{:id => 1, :x => 1})
-    db[:items].prepare(:select, :select_all)
-    db.call(:select_all).should == [{:id => 1, :x => 1}]
-    db[:items].filter(:n=>:$n).prepare(:select, :select_n)
-    db.call(:select_n, :n=>1).should == [{:id => 1, :x => 1}]
-    db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (n = 1)']
-  end
-end
-
-describe "Database#server_opts" do
-  specify "should return the general opts if no :servers option is used" do
-    opts = {:host=>1, :database=>2}
-    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 1
-  end
-  
-  specify "should return the general opts if entry for the server is present in the :servers option" do
-    opts = {:host=>1, :database=>2, :servers=>{}}
-    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 1
-  end
-  
-  specify "should return the general opts merged with the specific opts if given as a hash" do
-    opts = {:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}}}
-    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 3
-  end
-  
-  specify "should return the sgeneral opts merged with the specific opts if given as a proc" do
-    opts = {:host=>1, :database=>2, :servers=>{:server1=>proc{|db| {:host=>4}}}}
-    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 4
-  end
-  
-  specify "should raise an error if the specific opts is not a proc or hash" do
-    opts = {:host=>1, :database=>2, :servers=>{:server1=>2}}
-    proc{Sequel::Database.new(opts).send(:server_opts, :server1)}.should raise_error(Sequel::Error)
-  end
-
-  specify "should return the general opts merged with given opts if given opts is a Hash" do
-    opts = {:host=>1, :database=>2}
-    Sequel::Database.new(opts).send(:server_opts, :host=>2)[:host].should == 2
-  end
-end
-
-describe "Database#add_servers" do
-  before do
-    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
-  end
-
-  specify "should add new servers to the connection pool" do
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
-
-    @db.add_servers(:server2=>{:host=>6})
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 6}
-
-    @db.disconnect
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 6}
-  end
-
-  specify "should replace options for future connections to existing servers" do
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
-
-    @db.add_servers(:default=>proc{{:host=>4}}, :server1=>{:host=>8})
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
-
-    @db.disconnect
-    @db.synchronize{|c| c.opts[:host].should == 4}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 8}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 4}
-  end
-end
-
-describe "Database#remove_servers" do
-  before do
-    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
-  end
-
-  specify "should remove servers from the connection pool" do
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 4}
-
-    @db.remove_servers(:server1, :server2)
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 1}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
-  end
-  
-  specify "should accept arrays of symbols" do
-    @db.remove_servers([:server1, :server2])
-    @db.synchronize{|c| c.opts[:host].should == 1}
-    @db.synchronize(:server1){|c| c.opts[:host].should == 1}
-    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
-  end
-
-  specify "should allow removal while connections are still open" do
-    @db.synchronize do |c1|
-      c1.opts[:host].should == 1
-      @db.synchronize(:server1) do |c2|
-        c2.opts[:host].should == 3
-        @db.synchronize(:server2) do |c3|
-          c3.opts[:host].should == 4
-          @db.remove_servers(:server1, :server2)
-            @db.synchronize(:server1) do |c4|
-              c4.should_not == c2
-              c4.should == c1
-              c4.opts[:host].should == 1
-              @db.synchronize(:server2) do |c5|
-                c5.should_not == c3
-                c5.should == c1
-                c5.opts[:host].should == 1
-              end
-            end
-          c3.opts[:host].should == 4
-         end
-        c2.opts[:host].should == 3
-      end
-      c1.opts[:host].should == 1
-    end
-  end
-end
-
-describe "Database#each_server with do/jdbc adapter connection string without :adapter option" do
-  specify "should yield a separate database object for each server" do
-    klass = Class.new(Sequel::Database)
-    klass.should_receive(:adapter_class).once.with(:jdbc).and_return(Sequel::Mock::Database)
-    @db = klass.connect('jdbc:blah:', :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
-
-    hosts = []
-    @db.each_server do |db|
-      db.should be_a_kind_of(Sequel::Database)
-      db.should_not == @db
-      db.opts[:adapter_class].should == Sequel::Mock::Database
-      db.opts[:database].should == 2
-      hosts << db.opts[:host]
-    end
-    hosts.sort.should == [1, 3]
-  end
-
-  specify "should raise if not given a block" do
-    proc{Sequel.mock.each_server}.should raise_error(Sequel::Error)
-  end
-end
-
-describe "Database#each_server" do
-  before do
-    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
-  end
-
-  specify "should yield a separate database object for each server" do
-    hosts = []
-    @db.each_server do |db|
-      db.should be_a_kind_of(Sequel::Database)
-      db.should_not == @db
-      db.opts[:adapter].should == :mock
-      db.opts[:database].should == 2
-      hosts << db.opts[:host]
-    end
-    hosts.sort.should == [1, 3, 4]
-  end
-
-  specify "should disconnect and remove entry from Sequel::DATABASES after use" do
-    dbs = []
-    dcs = []
-    @db.each_server do |db|
-      dbs << db
-      Sequel::DATABASES.should include(db)
-      meta_def(db, :disconnect){dcs << db}
-    end
-    dbs.each do |db|
-      Sequel::DATABASES.should_not include(db)
-    end
-    dbs.should == dcs
-  end
-end
-  
-describe "Database#raise_error" do
-  before do
-    @db = Sequel.mock
-  end
-
-  specify "should reraise if the exception class is not in opts[:classes]" do
-    e = Class.new(StandardError)
-    proc{@db.send(:raise_error, e.new(''), :classes=>[])}.should raise_error(e)
-  end
-
-  specify "should convert the exception to a DatabaseError if the exception class is in opts[:classes]" do
-    proc{@db.send(:raise_error, Interrupt.new(''), :classes=>[Interrupt])}.should raise_error(Sequel::DatabaseError)
-  end
-
-  specify "should convert the exception to a DatabaseError if opts[:classes] if not present" do
-    proc{@db.send(:raise_error, Interrupt.new(''))}.should raise_error(Sequel::DatabaseError)
-  end
-  
-  specify "should convert the exception to a DatabaseDisconnectError if opts[:disconnect] is true" do
-    proc{@db.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.should raise_error(Sequel::DatabaseDisconnectError)
-  end
-  
-  specify "should convert the exception to an appropriate error if exception message matches regexp" do
-    def @db.database_error_regexps
-      {/foo/ => Sequel::DatabaseDisconnectError, /bar/ => Sequel::ConstraintViolation}
-    end
-    proc{@db.send(:raise_error, Interrupt.new('foo'))}.should raise_error(Sequel::DatabaseDisconnectError)
-    proc{@db.send(:raise_error, Interrupt.new('bar'))}.should raise_error(Sequel::ConstraintViolation)
-  end
-end
-
-describe "Database#typecast_value" do
-  before do
-    @db = Sequel::Database.new
-  end
-
-  specify "should raise an InvalidValue when given an invalid value" do
-    proc{@db.typecast_value(:integer, "13a")}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:float, "4.e2")}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:decimal, :invalid_value)}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:date, Object.new)}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:date, 'a')}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:time, Date.new)}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:datetime, 4)}.should raise_error(Sequel::InvalidValue)
-  end
-
-  specify "should handle integers with leading 0 as base 10" do
-    @db.typecast_value(:integer, "013").should == 13
-    @db.typecast_value(:integer, "08").should == 8
-    @db.typecast_value(:integer, "000013").should == 13
-    @db.typecast_value(:integer, "000008").should == 8
-  end
-
-  specify "should handle integers with leading 0x as base 16" do
-    @db.typecast_value(:integer, "0x013").should == 19
-    @db.typecast_value(:integer, "0x80").should == 128
-  end
-
-  specify "should typecast blobs as as Sequel::SQL::Blob" do
-    v = @db.typecast_value(:blob, "0x013")
-    v.should be_a_kind_of(Sequel::SQL::Blob)
-    v.should == Sequel::SQL::Blob.new("0x013")
-    @db.typecast_value(:blob, v).object_id.should == v.object_id
-  end
-
-  specify "should typecast boolean values to true, false, or nil" do
-    @db.typecast_value(:boolean, false).should == false
-    @db.typecast_value(:boolean, 0).should == false
-    @db.typecast_value(:boolean, "0").should == false
-    @db.typecast_value(:boolean, 'f').should == false
-    @db.typecast_value(:boolean, 'false').should == false
-    @db.typecast_value(:boolean, true).should == true
-    @db.typecast_value(:boolean, 1).should == true
-    @db.typecast_value(:boolean, '1').should == true
-    @db.typecast_value(:boolean, 't').should == true
-    @db.typecast_value(:boolean, 'true').should == true
-    @db.typecast_value(:boolean, '').should be_nil
-  end
-
-  specify "should typecast date values to Date" do
-    @db.typecast_value(:date, Date.today).should == Date.today
-    @db.typecast_value(:date, DateTime.now).should == Date.today
-    @db.typecast_value(:date, Time.now).should == Date.today
-    @db.typecast_value(:date, Date.today.to_s).should == Date.today
-    @db.typecast_value(:date, :year=>Date.today.year, :month=>Date.today.month, :day=>Date.today.day).should == Date.today
-  end
-
-  specify "should have Sequel.application_to_database_timestamp convert to Sequel.database_timezone" do
-    begin
-      t = Time.utc(2011, 1, 2, 3, 4, 5) # UTC Time
-      t2 = Time.mktime(2011, 1, 2, 3, 4, 5) # Local Time
-      t3 = Time.utc(2011, 1, 2, 3, 4, 5) - (t - t2) # Local Time in UTC Time
-      t4 = Time.mktime(2011, 1, 2, 3, 4, 5) + (t - t2) # UTC Time in Local Time
-      Sequel.application_timezone = :utc
-      Sequel.database_timezone = :local
-      Sequel.application_to_database_timestamp(t).should == t4
-      Sequel.application_timezone = :local
-      Sequel.database_timezone = :utc
-      Sequel.application_to_database_timestamp(t2).should == t3
-    ensure
-      Sequel.default_timezone = nil
-    end
-  end
-
-  specify "should have Database#to_application_timestamp convert values using the database's timezone" do
-    begin
-      t = Time.utc(2011, 1, 2, 3, 4, 5) # UTC Time
-      t2 = Time.mktime(2011, 1, 2, 3, 4, 5) # Local Time
-      t3 = Time.utc(2011, 1, 2, 3, 4, 5) - (t - t2) # Local Time in UTC Time
-      t4 = Time.mktime(2011, 1, 2, 3, 4, 5) + (t - t2) # UTC Time in Local Time
-      Sequel.default_timezone = :utc
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t
-      Sequel.database_timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t3
-      Sequel.default_timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t2
-      Sequel.database_timezone = :utc
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t4
-
-      Sequel.default_timezone = :utc
-      @db.timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t3
-      Sequel.default_timezone = :local
-      @db.timezone = :utc
-      @db.to_application_timestamp('2011-01-02 03:04:05').should == t4
-    ensure
-      Sequel.default_timezone = nil
-    end
-  end
-
-  specify "should typecast datetime values to Sequel.datetime_class with correct timezone handling" do
-    t = Time.utc(2011, 1, 2, 3, 4, 5, 500000) # UTC Time
-    t2 = Time.mktime(2011, 1, 2, 3, 4, 5, 500000) # Local Time
-    t3 = Time.utc(2011, 1, 2, 3, 4, 5, 500000) - (t - t2) # Local Time in UTC Time
-    t4 = Time.mktime(2011, 1, 2, 3, 4, 5, 500000) + (t - t2) # UTC Time in Local Time
-    secs = defined?(Rational) ? Rational(11, 2) : 5.5
-    r1 = defined?(Rational) ? Rational(t2.utc_offset, 86400) : t2.utc_offset/86400.0
-    r2 = defined?(Rational) ? Rational((t - t2).to_i, 86400) : (t - t2).to_i/86400.0
-    dt = DateTime.civil(2011, 1, 2, 3, 4, secs)
-    dt2 = DateTime.civil(2011, 1, 2, 3, 4, secs, r1)
-    dt3 = DateTime.civil(2011, 1, 2, 3, 4, secs) - r2
-    dt4 = DateTime.civil(2011, 1, 2, 3, 4, secs, r1) + r2
-
-    t.should == t4
-    t2.should == t3
-    dt.should == dt4
-    dt2.should == dt3
-
-    check = proc do |i, o| 
-      v = @db.typecast_value(:datetime, i)
-      v.should == o
-      if o.is_a?(Time)
-        v.utc_offset.should == o.utc_offset
-      else
-        v.offset.should == o.offset
-      end
-    end
-    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; true; end})
-    begin
-      @db.typecast_value(:datetime, dt).should == t
-      @db.typecast_value(:datetime, dt2).should == t2
-      @db.typecast_value(:datetime, t).should == t
-      @db.typecast_value(:datetime, t2).should == t2
-      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).should == t
-      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).should == t2
-      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == Time.mktime(2011, 1, 2, 0, 0, 0)
-      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000).should == t2
-
-      Sequel.datetime_class = DateTime
-      @db.typecast_value(:datetime, dt).should == dt
-      @db.typecast_value(:datetime, dt2).should == dt2
-      @db.typecast_value(:datetime, t).should == dt
-      @db.typecast_value(:datetime, t2).should == dt2
-      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).should == dt
-      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).should == dt
-      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == DateTime.civil(2011, 1, 2, 0, 0, 0)
-      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000).should == dt
-
-      Sequel.application_timezone = :utc
-      Sequel.typecast_timezone = :local
-      Sequel.datetime_class = Time
-      check[dt, t]
-      check[dt2, t3]
-      check[t, t]
-      check[t2, t3]
-      check[@db.literal(dt)[1...-1], t]
-      check[dt.strftime('%F %T.%N'), t3]
-      check[Date.civil(2011, 1, 2), Time.utc(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t3]
-
-      Sequel.datetime_class = DateTime
-      check[dt, dt]
-      check[dt2, dt3]
-      check[t, dt]
-      check[t2, dt3]
-      check[@db.literal(dt)[1...-1], dt]
-      check[dt.strftime('%F %T.%N'), dt3]
-      check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt3]
-
-      Sequel.typecast_timezone = :utc
-      Sequel.datetime_class = Time
-      check[dt, t]
-      check[dt2, t3]
-      check[t, t]
-      check[t2, t3]
-      check[@db.literal(dt)[1...-1], t]
-      check[dt.strftime('%F %T.%N'), t]
-      check[Date.civil(2011, 1, 2), Time.utc(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t]
-
-      Sequel.datetime_class = DateTime
-      check[dt, dt]
-      check[dt2, dt3]
-      check[t, dt]
-      check[t2, dt3]
-      check[@db.literal(dt)[1...-1], dt]
-      check[dt.strftime('%F %T.%N'), dt]
-      check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt]
-
-      Sequel.application_timezone = :local
-      Sequel.datetime_class = Time
-      check[dt, t4]
-      check[dt2, t2]
-      check[t, t4]
-      check[t2, t2]
-      check[@db.literal(dt)[1...-1], t4]
-      check[dt.strftime('%F %T.%N'), t4]
-      check[Date.civil(2011, 1, 2), Time.local(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t4]
-
-      Sequel.datetime_class = DateTime
-      check[dt, dt4]
-      check[dt2, dt2]
-      check[t, dt4]
-      check[t2, dt2]
-      check[@db.literal(dt)[1...-1], dt4]
-      check[dt.strftime('%F %T.%N'), dt4]
-      check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0, r1)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt4]
-
-      Sequel.typecast_timezone = :local
-      Sequel.datetime_class = Time
-      check[dt, t4]
-      check[dt2, t2]
-      check[t, t4]
-      check[t2, t2]
-      check[@db.literal(dt)[1...-1], t4]
-      check[dt.strftime('%F %T.%N'), t2]
-      check[Date.civil(2011, 1, 2), Time.local(2011, 1, 2, 0, 0, 0)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, t2]
-
-      Sequel.datetime_class = DateTime
-      check[dt, dt4]
-      check[dt2, dt2]
-      check[t, dt4]
-      check[t2, dt2]
-      check[@db.literal(dt)[1...-1], dt4]
-      check[dt.strftime('%F %T.%N'), dt2]
-      check[Date.civil(2011, 1, 2), DateTime.civil(2011, 1, 2, 0, 0, 0, r1)]
-      check[{:year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec, :nanos=>500000000}, dt2]
-
-    ensure
-      Sequel.default_timezone = nil
-      Sequel.datetime_class = Time
-    end
-  end
-
-  specify "should handle arrays when typecasting timestamps" do
-    begin
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == Time.local(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
-
-      Sequel.datetime_class = DateTime
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000, (defined?(Rational) ? Rational(1, 2) : 0.5)]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
-    ensure
-      Sequel.datetime_class = Time
-    end
-  end
-
-  specify "should handle hashes when typecasting timestamps" do
-    begin
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
-
-      Sequel.datetime_class = DateTime
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
-    ensure
-      Sequel.datetime_class = Time
-    end
-  end
-
-  specify "should typecast decimal values to BigDecimal" do
-    [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
-      v = @db.typecast_value(:decimal, i)
-      v.should be_a_kind_of(BigDecimal)
-      v.should == BigDecimal.new('1.0')
-    end
-  end
-
-  specify "should typecast float values to Float" do
-    [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
-      v = @db.typecast_value(:float, i)
-      v.should be_a_kind_of(Float)
-      v.should == 1.0
-    end
-  end
-
-  specify "should typecast string values to String" do
-    [1.0, '1.0', Sequel.blob('1.0')].each do |i|
-      v = @db.typecast_value(:string, i)
-      v.should be_an_instance_of(String)
-      v.should == "1.0"
-    end
-  end
-
-  specify "should raise errors when typecasting hash and array values to String" do
-    [[], {}].each do |i|
-      proc{@db.typecast_value(:string, i)}.should raise_error(Sequel::InvalidValue)
-    end
-  end
-
-  specify "should typecast time values to SQLTime" do
-    t = Time.now
-    st = Sequel::SQLTime.local(t.year, t.month, t.day, 1, 2, 3)
-    [st, Time.utc(t.year, t.month, t.day, 1, 2, 3), Time.local(t.year, t.month, t.day, 1, 2, 3), '01:02:03', {:hour=>1, :minute=>2, :second=>3}].each do |i|
-      v = @db.typecast_value(:time, i)
-      v.should be_an_instance_of(Sequel::SQLTime)
-      v.should == st
-    end
-  end
-
-  specify "should correctly handle time value conversion to SQLTime with fractional seconds" do
-    t = Time.now
-    st = Sequel::SQLTime.local(t.year, t.month, t.day, 1, 2, 3, 500000)
-    t = Time.local(t.year, t.month, t.day, 1, 2, 3, 500000)
-    @db.typecast_value(:time, t).should == st
-  end
-
-  specify "should have an underlying exception class available at wrapped_exception" do
-    begin
-      @db.typecast_value(:date, 'a')
-      true.should == false
-    rescue Sequel::InvalidValue => e
-      e.wrapped_exception.should be_a_kind_of(ArgumentError)
-    end
-  end
-
-  specify "should include underlying exception class in #inspect" do
-    begin
-      @db.typecast_value(:date, 'a')
-      true.should == false
-    rescue Sequel::InvalidValue => e
-      e.inspect.should =~ /\A#<Sequel::InvalidValue: ArgumentError: .*>\z/
-    end
-  end
-end
-
-describe "Database#blank_object?" do
-  specify "should return whether the object is considered blank" do
-    db = Sequel::Database.new
-    c = lambda{|meth, value| Class.new{define_method(meth){value}}.new}
-
-    db.send(:blank_object?, "").should == true
-    db.send(:blank_object?, "  ").should == true
-    db.send(:blank_object?, nil).should == true
-    db.send(:blank_object?, false).should == true
-    db.send(:blank_object?, []).should == true
-    db.send(:blank_object?, {}).should == true
-    db.send(:blank_object?, c[:empty?, true]).should == true
-    db.send(:blank_object?, c[:blank?, true]).should == true
-
-    db.send(:blank_object?, " a ").should == false
-    db.send(:blank_object?, 1).should == false
-    db.send(:blank_object?, 1.0).should == false
-    db.send(:blank_object?, true).should == false
-    db.send(:blank_object?, [1]).should == false
-    db.send(:blank_object?, {1.0=>2.0}).should == false
-    db.send(:blank_object?, c[:empty?, false]).should == false
-    db.send(:blank_object?, c[:blank?, false]).should == false 
-  end
-end
-
-describe "Database#schema_autoincrementing_primary_key?" do
-  specify "should indicate whether the parsed schema row indicates a primary key" do
-    m = Sequel::Database.new.method(:schema_autoincrementing_primary_key?)
-    m.call(:primary_key=>true, :db_type=>'integer').should == true
-    m.call(:primary_key=>true, :db_type=>'varchar(255)').should == false
-    m.call(:primary_key=>false, :db_type=>'integer').should == false
-  end
-end
-
-describe "Database#supports_schema_parsing?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_schema_parsing?.should == false
-  end
-
-  specify "should be true if the database implements schema_parse_table" do
-    db = Sequel::Database.new
-    def db.schema_parse_table(*) end
-    db.supports_schema_parsing?.should == true
-  end
-end
-
-describe "Database#supports_foreign_key_parsing?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_foreign_key_parsing?.should == false
-  end
-
-  specify "should be true if the database implements foreign_key_list" do
-    db = Sequel::Database.new
-    def db.foreign_key_list(*) end
-    db.supports_foreign_key_parsing?.should == true
-  end
-end
-
-describe "Database#supports_index_parsing?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_index_parsing?.should == false
-  end
-
-  specify "should be true if the database implements indexes" do
-    db = Sequel::Database.new
-    def db.indexes(*) end
-    db.supports_index_parsing?.should == true
-  end
-end
-
-describe "Database#supports_table_listing?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_table_listing?.should == false
-  end
-
-  specify "should be true if the database implements tables" do
-    db = Sequel::Database.new
-    def db.tables(*) end
-    db.supports_table_listing?.should == true
-  end
-end
-
-describe "Database#supports_view_listing?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_view_listing?.should == false
-  end
-
-  specify "should be true if the database implements views" do
-    db = Sequel::Database.new
-    def db.views(*) end
-    db.supports_view_listing?.should == true
-  end
-end
-
-describe "Database#supports_deferrable_constraints?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_deferrable_constraints?.should == false
-  end
-end
-
-describe "Database#supports_deferrable_foreign_key_constraints?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_deferrable_foreign_key_constraints?.should == false
-  end
-end
-
-describe "Database#supports_transactional_ddl?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_transactional_ddl?.should == false
-  end
-end
-
-describe "Database#global_index_namespace?" do
-  specify "should be true by default" do
-    Sequel::Database.new.global_index_namespace?.should == true
-  end
-end
-
-describe "Database#supports_savepoints?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_savepoints?.should == false
-  end
-end
-
-describe "Database#supports_views_with_check_option?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_views_with_check_option?.should == false
-  end
-end
-
-describe "Database#supports_views_with_local_check_option?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_views_with_local_check_option?.should == false
-  end
-end
-
-describe "Database#supports_savepoints_in_prepared_transactions?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_savepoints_in_prepared_transactions?.should == false
-  end
-
-  specify "should be true if both savepoints and prepared transactions are supported" do
-    db = Sequel::Database.new
-    meta_def(db, :supports_savepoints?){true}
-    meta_def(db, :supports_prepared_transactions?){true}
-    db.supports_savepoints_in_prepared_transactions?.should == true
-  end
-end
-
-describe "Database#supports_prepared_transactions?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_prepared_transactions?.should == false
-  end
-end
-
-describe "Database#supports_transaction_isolation_levels?" do
-  specify "should be false by default" do
-    Sequel::Database.new.supports_transaction_isolation_levels?.should == false
-  end
-end
-
-describe "Database#input_identifier_meth" do
-  specify "should be the input_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new
-    db.send(:input_identifier_meth).call(:a).should == 'a'
-    db.identifier_input_method = :upcase
-    db.send(:input_identifier_meth).call(:a).should == 'A'
-  end
-end
-
-describe "Database#output_identifier_meth" do
-  specify "should be the output_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new
-    db.send(:output_identifier_meth).call('A').should == :A
-    db.identifier_output_method = :downcase
-    db.send(:output_identifier_meth).call('A').should == :a
-  end
-end
-
-describe "Database#metadata_dataset" do
-  specify "should be a dataset with the default settings for identifier_input_method and identifier_output_method" do
-    ds = Sequel::Database.new.send(:metadata_dataset)
-    ds.literal(:a).should == 'A'
-    ds.send(:output_identifier, 'A').should == :a
-  end
-end
-
-describe "Database#column_schema_to_ruby_default" do
-  specify "should handle converting many default formats" do
-    db = Sequel::Database.new
-    p = lambda{|d,t| db.send(:column_schema_to_ruby_default, d, t)}
-    p[nil, :integer].should be_nil
-    p[1, :integer].should == 1
-    p['1', :integer].should == 1
-    p['-1', :integer].should == -1
-    p[1.0, :float].should == 1.0
-    p['1.0', :float].should == 1.0
-    p['-1.0', :float].should == -1.0
-    p['1.0', :decimal].should == BigDecimal.new('1.0')
-    p['-1.0', :decimal].should == BigDecimal.new('-1.0')
-    p[true, :boolean].should == true
-    p[false, :boolean].should == false
-    p['1', :boolean].should == true
-    p['0', :boolean].should == false
-    p['true', :boolean].should == true
-    p['false', :boolean].should == false
-    p["'t'", :boolean].should == true
-    p["'f'", :boolean].should == false
-    p["'a'", :string].should == 'a'
-    p["'a'", :blob].should == Sequel.blob('a')
-    p["'a'", :blob].should be_a_kind_of(Sequel::SQL::Blob)
-    p["''", :string].should == ''
-    p["'\\a''b'", :string].should == "\\a'b"
-    p["'NULL'", :string].should == "NULL"
-    p[Date.today, :date].should == Date.today
-    p["'2009-10-29'", :date].should == Date.new(2009,10,29)
-    p["CURRENT_TIMESTAMP", :date].should == Sequel::CURRENT_DATE
-    p["CURRENT_DATE", :date].should == Sequel::CURRENT_DATE
-    p["now()", :date].should == Sequel::CURRENT_DATE
-    p["getdate()", :date].should == Sequel::CURRENT_DATE
-    p["CURRENT_TIMESTAMP", :datetime].should == Sequel::CURRENT_TIMESTAMP
-    p["CURRENT_DATE", :datetime].should == Sequel::CURRENT_TIMESTAMP
-    p["now()", :datetime].should == Sequel::CURRENT_TIMESTAMP
-    p["getdate()", :datetime].should == Sequel::CURRENT_TIMESTAMP
-    p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
-    p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
-    p["'10:20:30'", :time].should == Time.parse('10:20:30')
-    p["NaN", :float].should be_nil
-
-    db = Sequel.mock(:host=>'postgres')
-    p["''::text", :string].should == ""
-    p["'\\a''b'::character varying", :string].should == "\\a'b"
-    p["'a'::bpchar", :string].should == "a"
-    p["(-1)", :integer].should == -1
-    p["(-1.0)", :float].should == -1.0
-    p['(-1.0)', :decimal].should == BigDecimal.new('-1.0')
-    p["'a'::bytea", :blob].should == Sequel.blob('a')
-    p["'a'::bytea", :blob].should be_a_kind_of(Sequel::SQL::Blob)
-    p["'2009-10-29'::date", :date].should == Date.new(2009,10,29)
-    p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].should == DateTime.parse('2009-10-29 10:20:30.241343')
-    p["'10:20:30'::time without time zone", :time].should == Time.parse('10:20:30')
-
-    db = Sequel.mock(:host=>'mysql')
-    p["\\a'b", :string].should == "\\a'b"
-    p["a", :string].should == "a"
-    p["NULL", :string].should == "NULL"
-    p["-1", :float].should == -1.0
-    p['-1', :decimal].should == BigDecimal.new('-1.0')
-    p["2009-10-29", :date].should == Date.new(2009,10,29)
-    p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
-    p["10:20:30", :time].should == Time.parse('10:20:30')
-    p["a", :enum].should == "a"
-    p["a,b", :set].should == "a,b"
-    
-    db = Sequel.mock(:host=>'mssql')
-    p["(N'a')", :string].should == "a"
-    p["((-12))", :integer].should == -12
-    p["((12.1))", :float].should == 12.1
-    p["((-12.1))", :decimal].should == BigDecimal.new('-12.1')
-  end
-end
-
-describe "Database extensions" do
-  before(:all) do
-    class << Sequel
-      alias _extension extension
-      remove_method :extension
-      def extension(*)
-      end
-    end
-  end
-  after(:all) do
-    class << Sequel
-      remove_method :extension
-      alias extension _extension
-      remove_method :_extension
-    end
-  end
-  before do
-    @db = Sequel.mock
-  end
-  after do
-    Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
-  end
-
-  specify "should be able to register an extension with a module have Database#extension extend the module" do
-    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
-    @db.extension(:foo).a.should == 1
-  end
-
-  specify "should be able to register an extension with a block and have Database#extension call the block" do
-    @db.quote_identifiers = false
-    Sequel::Database.register_extension(:foo){|db| db.quote_identifiers = true}
-    @db.extension(:foo).quote_identifiers?.should == true
-  end
-
-  specify "should be able to register an extension with a callable and Database#extension call the callable" do
-    @db.quote_identifiers = false
-    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
-    @db.extension(:foo).quote_identifiers?.should == true
-  end
-
-  specify "should be able to load multiple extensions in the same call" do
-    @db.quote_identifiers = false
-    @db.identifier_input_method = :downcase
-    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
-    Sequel::Database.register_extension(:bar, proc{|db| db.identifier_input_method = nil})
-    @db.extension(:foo, :bar)
-    @db.quote_identifiers?.should == true
-    @db.identifier_input_method.should be_nil
-  end
-
-  specify "should return the receiver" do
-    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
-    @db.extension(:foo).should equal(@db)
-  end
-
-  specify "should raise an Error if registering with both a module and a block" do
-    proc{Sequel::Database.register_extension(:foo, Module.new){}}.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise an Error if attempting to load an incompatible extension" do
-    proc{@db.extension(:foo2)}.should raise_error(Sequel::Error)
-  end
-
-  specify "should be able to load an extension into all future Databases with Database.extension" do
-    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
-    Sequel::Database.register_extension(:bar, Module.new{def b; 2; end})
-    Sequel::Database.extension(:foo, :bar)
-    @db.should_not respond_to(:a)
-    @db.should_not respond_to(:b)
-    Sequel.mock.a.should == 1
-    Sequel.mock.b.should == 2
-  end
-end
-
-describe "Database specific exception classes" do
-  before do
-    @db = Sequel.mock
-    class << @db
-      attr_accessor :sql_state
-
-      def database_exception_sqlstate(exception, opts={})
-        @sql_state
-      end
-    end
-  end
-
-  specify "should use appropriate exception classes for given SQL states" do
-    @db.fetch = ArgumentError
-    @db.sql_state = '23502'
-    proc{@db.get(:a)}.should raise_error(Sequel::NotNullConstraintViolation)
-    @db.sql_state = '23503'
-    proc{@db.get(:a)}.should raise_error(Sequel::ForeignKeyConstraintViolation)
-    @db.sql_state = '23505'
-    proc{@db.get(:a)}.should raise_error(Sequel::UniqueConstraintViolation)
-    @db.sql_state = '23513'
-    proc{@db.get(:a)}.should raise_error(Sequel::CheckConstraintViolation)
-    @db.sql_state = '40001'
-    proc{@db.get(:a)}.should raise_error(Sequel::SerializationFailure)
-  end
-end
-
-describe "Database.after_initialize" do
-  after do
-    Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
-  end
-
-  specify "should allow a block to be run after each new instance is created" do
-    Sequel::Database.after_initialize{|db| db.sql_log_level = :debug }
-    db = Sequel.mock
-    db.sql_log_level.should == :debug
-  end
-
-  specify "should allow multiple hooks to be registered" do
-    Sequel::Database.after_initialize{|db| db.sql_log_level = :debug }
-    Sequel::Database.after_initialize{|db| db.loggers << 11 }
-
-    db = Sequel.mock
-
-    db.sql_log_level.should == :debug
-    db.loggers.should include(11)
-  end
-
-  specify "should raise an error if registration is called without a block" do
-    proc {
-      Sequel::Database.after_initialize
-    }.should raise_error(Sequel::Error, /must provide block/i)
-  end
-end
-
-describe "Database#schema_type_class" do
-  specify "should return the class or array of classes for the given type symbol" do
-    db = Sequel.mock
-    {:string=>String, :integer=>Integer, :date=>Date, :datetime=>[Time, DateTime],
-      :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass], :float=>Float, :decimal=>BigDecimal,
-      :blob=>Sequel::SQL::Blob}.each do |sym, klass|
-      db.schema_type_class(sym).should == klass
-    end
-  end
-end
-
-describe "Database#execute_{dui,ddl,insert}" do
-  before do
-    @db = Sequel::Database.new
-    def @db.execute(sql, opts={})
-      (@sqls ||= []) << sql
-    end
-    def @db.sqls
-      @sqls
-    end
-  end
-
-  specify "should execute the SQL" do
-    @db.execute_dui "DELETE FROM table"
-    @db.execute_ddl "SET foo"
-    @db.execute_insert "INSERT INTO table DEFAULT VALUES"
-    @db.sqls.should == ["DELETE FROM table", "SET foo", "INSERT INTO table DEFAULT VALUES"]
-  end
-end