tdiary 5.0.9 → 5.0.10

data/vendor/bundle/gems/sequel-5.9.0/spec/core/database_spec.rb

@@ -1,2673 +0,0 @@
-require_relative "spec_helper"
-
-describe "A new Database" do
-  before do
-    @db = Sequel::Database.new(1 => 2, :logger => 3)
-  end
-  
-  it "should not allow dup/clone" do
-    proc{@db.dup}.must_raise NoMethodError
-    proc{@db.clone}.must_raise NoMethodError
-  end
-
-  it "should receive options" do
-    @db.opts[1].must_equal 2
-    @db.opts[:logger].must_equal 3  
-  end
-  
-  it "should set the logger from opts[:logger] and opts[:loggers]" do
-    @db.loggers.must_equal [3]
-    Sequel::Database.new(1 => 2, :loggers => 3).loggers.must_equal [3]
-    Sequel::Database.new(1 => 2, :loggers => [3]).loggers.must_equal [3]
-    Sequel::Database.new(1 => 2, :logger => 4, :loggers => 3).loggers.must_equal [4,3]
-    Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).loggers.must_equal [4,3]
-  end
-
-  it "should support :preconnect option to preconnect to database" do
-    @db.pool.size.must_equal 0
-    c = Class.new(Sequel::Database) do
-      def dataset_class_default; Sequel::Dataset end
-      def connect(_)
-        :connect
-      end
-    end
-    db = c.new(1 => 2, :logger => 3, :preconnect=>true)
-    db.pool.size.must_equal db.pool.max_size
-    db = c.new(1 => 2, :logger => 3, :preconnect=>:concurrently)
-    db.pool.size.must_equal db.pool.max_size
-  end
-  
-  it "should handle the default string column size" do
-    @db.default_string_column_size.must_equal 255
-    db = Sequel::Database.new(:default_string_column_size=>50)
-    db.default_string_column_size.must_equal 50
-    db.default_string_column_size = 2
-    db.default_string_column_size.must_equal 2
-  end
-  
-  it "should set the sql_log_level from opts[:sql_log_level]" do
-    Sequel::Database.new(1 => 2, :sql_log_level=>:debug).sql_log_level.must_equal :debug
-    Sequel::Database.new(1 => 2, :sql_log_level=>'debug').sql_log_level.must_equal :debug
-  end
-  
-  it "should create a connection pool" do
-    @db.pool.must_be_kind_of(Sequel::ConnectionPool)
-    @db.pool.max_size.must_equal 4
-    
-    Sequel::Database.new(:max_connections => 10).pool.max_size.must_equal 10
-  end
-  
-  it "should have the connection pool use the connect method to get connections" do
-    cc = nil
-    d = Sequel::Database.new
-    d.define_singleton_method(:connect){|c| 1234}
-    d.synchronize {|c| cc = c}
-    cc.must_equal 1234
-  end
-
-  it "should respect the :single_threaded option" do
-    db = Sequel::Database.new(:single_threaded=>true){123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'t'){123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'1'){123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>false){123}
-    db.pool.must_be_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'f'){123}
-    db.pool.must_be_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'0'){123}
-    db.pool.must_be_kind_of(Sequel::ConnectionPool)
-  end
-
-  it "should just use a :uri option for jdbc with the full connection string" do
-    db = Sequel::Database.stub(:adapter_class, Class.new(Sequel::Database){def connect(*); Object.new end}) do
-      Sequel.connect('jdbc:test://host/db_name')
-    end
-    db.must_be_kind_of(Sequel::Database)
-    db.opts[:uri].must_equal 'jdbc:test://host/db_name'
-  end
-
-  it "should populate :adapter option when using connection string" do
-    Sequel.connect('mock:/').opts[:adapter].must_equal "mock"
-  end
-
-  it "should respect the :keep_reference option for not keeping a reference in Sequel::DATABASES" do
-    db = Sequel.connect('mock:///?keep_reference=f')
-    Sequel::DATABASES.wont_include(db)
-  end
-
-  it 'should strip square brackets for ipv6 hosts' do
-    Sequel.connect('mock://[::1]').opts[:host].must_equal "::1"
-  end
-end
-
-describe "Database :connect_sqls option" do
-  it "should issue the each sql query for each new connection" do
-    db = Sequel.mock(:connect_sqls=>['SELECT 1', 'SELECT 2'])
-    db.sqls.must_equal ['SELECT 1', 'SELECT 2']
-    db['SELECT 3'].get
-    db.sqls.must_equal ['SELECT 3']
-    db.disconnect
-    db['SELECT 3'].get
-    db.sqls.must_equal ['SELECT 1', 'SELECT 2', 'SELECT 3']
-  end
-end
-
-describe "Database#freeze" do
-  before do
-    @db = Sequel.mock.freeze
-  end
-
-  it "should freeze internal structures" do
-    @db.instance_exec do
-      frozen?.must_equal true
-      opts.frozen?.must_equal true
-      pool.frozen?.must_equal true
-      loggers.frozen?.must_equal true
-      @dataset_class.frozen?.must_equal true
-      @dataset_modules.frozen?.must_equal true
-      @schema_type_classes.frozen?.must_equal true
-      from(:a).frozen?.must_equal  true
-      metadata_dataset.frozen?.must_equal true
-    end
-
-    proc{@db.extend_datasets{}}.must_raise RuntimeError, TypeError
-  end
-end
-
-describe "Database#disconnect" do
-  it "should call pool.disconnect" do
-    d = Sequel::Database.new
-    p = d.pool
-    def p.disconnect(h)
-      raise unless h == {}
-      2
-    end
-    d.disconnect.must_equal 2
-  end
-end
-
-describe "Sequel.extension" do
-  it "should attempt to load the given extension" do
-    proc{Sequel.extension :blah}.must_raise(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
-
-  it "should log message at info level to all loggers" do
-    @db.log_info('blah')
-    @o.logs.must_equal [[:info, 'blah']]
-  end
-
-  it "should log message with args at info level to all loggers" do
-    @db.log_info('blah', [1, 2])
-    @o.logs.must_equal [[:info, 'blah; [1, 2]']]
-  end
-end
-
-describe "Database#log_connection_yield" do
-  before do
-    @o = Object.new
-    def @o.logs; @logs || []; end
-    def @o.to_ary; [self]; end
-    def @o.warn(*args); (@logs ||= []) << [:warn] + args; end
-    def @o.method_missing(*args); (@logs ||= []) << args; end
-    @conn = Object.new
-    @db = Sequel::Database.new(:logger=>@o)
-  end
-
-  it "should log SQL to the loggers" do
-    @db.log_connection_yield("some SQL", @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :info
-    @o.logs.first.last.must_match(/some SQL\z/)
-    @o.logs.first.last.wont_match(/\(conn: -?\d+\) some SQL\z/)
-  end
-
-  it "should include connection information when logging" do
-    @db.log_connection_info = true
-    @db.log_connection_yield("some SQL", @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :info
-    @o.logs.first.last.must_match(/\(conn: -?\d+\) some SQL\z/)
-  end
-
-  it "should yield to the passed block" do
-    a = nil
-    @db.log_connection_yield('blah', @conn){a = 1}
-    a.must_equal 1
-  end
-
-  it "should raise an exception if a block is not passed" do
-    proc{@db.log_connection_yield('blah', @conn)}.must_raise LocalJumpError
-  end
-
-  it "should log message with duration at info level to all loggers" do
-    @db.log_connection_yield('blah', @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :info
-    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
-  end
-
-  it "should respect sql_log_level setting" do
-    @db.sql_log_level = :debug
-    @db.log_connection_yield('blah', @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :debug
-    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
-  end
-
-  it "should log message with duration at warn level if duration greater than log_warn_duration" do
-    @db.log_warn_duration = 0
-    @db.log_connection_yield('blah', @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :warn
-    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
-  end
-
-  it "should log message with duration at info level if duration less than log_warn_duration" do
-    @db.log_warn_duration = 1000
-    @db.log_connection_yield('blah', @conn){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :info
-    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
-  end
-
-  it "should log message at error level if block raises an error" do
-    @db.log_warn_duration = 0
-    proc{@db.log_connection_yield('blah', @conn){raise Sequel::Error, 'adsf'}}.must_raise Sequel::Error
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :error
-    @o.logs.first.last.must_match(/\ASequel::Error: adsf: blah\z/)
-  end
-
-  it "should include args with message if args passed" do
-    @db.log_connection_yield('blah', @conn, [1, 2]){}
-    @o.logs.length.must_equal 1
-    @o.logs.first.length.must_equal 2
-    @o.logs.first.first.must_equal :info
-    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/)
-  end
-end
-
-describe "Database#uri" do
-  before do
-    @c = Class.new(Sequel::Database) do
-      def dataset_class_default; Sequel::Dataset end
-      def connect(*); Object.new end
-      set_adapter_scheme :mau
-    end
-    
-    @db = Sequel.connect('mau://user:pass@localhost:9876/maumau')
-  end
-  
-  it "should return the connection URI for the database" do
-    @db.uri.must_equal 'mau://user:pass@localhost:9876/maumau'
-  end
-  
-  it "should return nil if a connection uri was not used" do
-    Sequel.mock.uri.must_be_nil
-  end
-  
-  it "should be aliased as #url" do
-    @db.url.must_equal 'mau://user:pass@localhost:9876/maumau'
-  end
-end
-
-describe "Database.adapter_scheme and #adapter_scheme" do
-  it "should return the database scheme" do
-    Sequel::Database.adapter_scheme.must_be_nil
-
-    @c = Class.new(Sequel::Database) do
-      def dataset_class_default; Sequel::Dataset end
-      set_adapter_scheme :mau
-    end
-    
-    @c.adapter_scheme.must_equal :mau
-    @c.new({}).adapter_scheme.must_equal :mau
-  end
-end
-
-describe "Database#dataset" do
-  before do
-    @db = Sequel.mock
-    @ds = @db.dataset
-  end
-  
-  it "should provide a blank dataset through #dataset" do
-    @ds.must_be_kind_of(Sequel::Dataset)
-    @ds.opts.must_equal({})
-    @ds.db.must_be_same_as(@db)
-  end
-  
-  it "should provide a #from dataset" do
-    d = @db.from(:mau)
-    d.must_be_kind_of(Sequel::Dataset)
-    d.sql.must_equal 'SELECT * FROM mau'
-    
-    e = @db[:miu]
-    e.must_be_kind_of(Sequel::Dataset)
-    e.sql.must_equal 'SELECT * FROM miu'
-  end
-  
-  it "should provide a #from dataset that supports virtual row blocks" do
-    @db.from{a(b)}.sql.must_equal 'SELECT * FROM a(b)'
-  end
-  
-  it "should provide a #select dataset" do
-    d = @db.select(:a, :b, :c).from(:mau)
-    d.must_be_kind_of(Sequel::Dataset)
-    d.sql.must_equal 'SELECT a, b, c FROM mau'
-  end
-  
-  it "should allow #select to take a block" do
-    d = @db.select(:a, :b){c}.from(:mau)
-    d.must_be_kind_of(Sequel::Dataset)
-    d.sql.must_equal '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
-  
-  it "should have setter set the class to use to create datasets" do
-    @db.dataset_class = @dsc
-    ds = @db.dataset
-    ds.must_be_kind_of(@dsc)
-    ds.opts.must_equal({})
-    ds.db.must_be_same_as(@db)
-  end
-
-  it "should have getter return the class to use to create datasets" do
-    [@db.dataset_class, @db.dataset_class.superclass].must_include(Sequel::Dataset)
-    @db.dataset_class = @dsc
-    [@db.dataset_class, @db.dataset_class.superclass].must_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
-  
-  it "should clear a cached dataset" do
-    @db = Sequel::Database.new
-    @db.literal(1).must_equal '1'
-    @db.extend_datasets{def literal(v) '2' end}
-    @db.literal(1).must_equal '2'
-  end
-
-  it "should change the dataset class to a subclass the first time it is called" do
-    @db.dataset_class.superclass.must_equal Sequel::Dataset
-  end
-
-  it "should not create a subclass of the dataset class if called more than once" do
-    @db.extend_datasets(@m2)
-    @db.dataset_class.superclass.must_equal Sequel::Dataset
-  end
-
-  it "should make the dataset class include the module" do
-    @db.dataset_class.ancestors.must_include(@m)
-    @db.dataset_class.ancestors.wont_include(@m2)
-    @db.extend_datasets(@m2)
-    @db.dataset_class.ancestors.must_include(@m)
-    @db.dataset_class.ancestors.must_include(@m2)
-  end
-
-  it "should have datasets respond to the module's methods" do
-    @db.dataset.foo.must_equal [3]
-    @db.extend_datasets(@m2)
-    @db.dataset.foo.must_equal [4, 3]
-  end
-
-  it "should take a block and create a module from it to use" do
-    @db.dataset.foo.must_equal [3]
-    @db.extend_datasets{def foo() [5] + super end}
-    @db.dataset.foo.must_equal [5, 3]
-  end
-
-  it "should raise an error if both a module and a block are provided" do
-    proc{@db.extend_datasets(@m2){def foo() [5] + super end}}.must_raise(Sequel::Error)
-  end
-
-  it "should be able to override methods defined in the original Dataset class" do
-    @db.extend_datasets do
-      def select(*a, &block) super.order(*a, &block) end
-      def input_identifier(v) v.to_s end
-    end
-    @db[:t].with_quote_identifiers(false).select(:a, :b).sql.must_equal 'SELECT a, b FROM t ORDER BY a, b'
-  end
-
-  it "should reapply settings if dataset_class is changed" do
-    c = Class.new(Sequel::Dataset)
-    @db.dataset_class = c
-    @db.dataset_class.superclass.must_equal c
-    @db.dataset_class.ancestors.must_include(@m)
-    @db.dataset.foo.must_equal [3]
-  end
-end
-  
-describe "Database#extend_datasets custom methods" do
-  before do
-    @db = Sequel.mock
-  end
-
-  def ds
-    @db[:items]
-  end
-  
-  it "should have dataset_module support a where method" do
-    @db.extend_datasets{where :released, :released}
-    ds.released.sql.must_equal 'SELECT * FROM items WHERE released'
-    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
-  end
-
-  it "should have dataset_module support a having method" do
-    @db.extend_datasets{having(:released){released}}
-    ds.released.sql.must_equal 'SELECT * FROM items HAVING released'
-    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING released'
-  end
-
-  it "should have dataset_module support an exclude method" do
-    @db.extend_datasets{exclude :released, :released}
-    ds.released.sql.must_equal 'SELECT * FROM items WHERE NOT released'
-    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND NOT released)'
-  end
-
-  it "should have dataset_module support an exclude_having method" do
-    @db.extend_datasets{exclude_having :released, :released}
-    ds.released.sql.must_equal 'SELECT * FROM items HAVING NOT released'
-    ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING NOT released'
-  end
-
-  it "should have dataset_module support a distinct method" do
-    @db.extend_datasets{def supports_distinct_on?; true end; distinct :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items'
-    ds.where(:bar).foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items WHERE bar'
-  end
-
-  it "should have dataset_module support a grep method" do
-    @db.extend_datasets{grep :foo, :baz, 'quux%'}
-    ds.foo.sql.must_equal 'SELECT * FROM items WHERE ((baz LIKE \'quux%\' ESCAPE \'\\\'))'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE (bar AND ((baz LIKE \'quux%\' ESCAPE \'\\\')))'
-  end
-
-  it "should have dataset_module support a group method" do
-    @db.extend_datasets{group :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar GROUP BY baz'
-  end
-
-  it "should have dataset_module support a group_and_count method" do
-    @db.extend_datasets{group_and_count :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items GROUP BY baz'
-    ds.where(:bar).foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items WHERE bar GROUP BY baz'
-  end
-
-  it "should have dataset_module support a group_append method" do
-    @db.extend_datasets{group_append :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
-    ds.group(:bar).foo.sql.must_equal 'SELECT * FROM items GROUP BY bar, baz'
-  end
-
-  it "should have dataset_module support a limit method" do
-    @db.extend_datasets{limit :foo, 1}
-    ds.foo.sql.must_equal 'SELECT * FROM items LIMIT 1'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar LIMIT 1'
-  end
-
-  it "should have dataset_module support a offset method" do
-    @db.extend_datasets{offset :foo, 1}
-    ds.foo.sql.must_equal 'SELECT * FROM items OFFSET 1'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar OFFSET 1'
-  end
-
-  it "should have dataset_module support a order method" do
-    @db.extend_datasets{order(:foo){:baz}}
-    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz'
-  end
-
-  it "should have dataset_module support a order_append method" do
-    @db.extend_datasets{order_append :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
-    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY bar, baz'
-  end
-
-  it "should have dataset_module support a order_prepend method" do
-    @db.extend_datasets{order_prepend :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
-    ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
-  end
-
-  it "should have dataset_module support a reverse method" do
-    @db.extend_datasets{reverse(:foo){:baz}}
-    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz DESC'
-    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz DESC'
-  end
-
-  it "should have dataset_module support a select method" do
-    @db.extend_datasets{select :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT baz FROM items'
-    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar'
-  end
-
-  it "should have dataset_module support a select_all method" do
-    @db.extend_datasets{select_all :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT baz.* FROM items'
-    ds.where(:bar).foo.sql.must_equal 'SELECT baz.* FROM items WHERE bar'
-  end
-
-  it "should have dataset_module support a select_append method" do
-    @db.extend_datasets{select_append :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT *, baz FROM items'
-    ds.where(:bar).foo.sql.must_equal 'SELECT *, baz FROM items WHERE bar'
-  end
-
-  it "should have dataset_module support a select_group method" do
-    @db.extend_datasets{select_group :foo, :baz}
-    ds.foo.sql.must_equal 'SELECT baz FROM items GROUP BY baz'
-    ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar GROUP BY baz'
-  end
-
-  it "should have dataset_module support a server method" do
-    @db.extend_datasets{server :foo, :baz}
-    ds.foo.opts[:server].must_equal :baz
-    ds.where(:bar).foo.opts[:server].must_equal :baz
-  end
-end
-
-describe "Database#disconnect_connection" do
-  it "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).must_equal true
-  end
-end
-
-describe "Database#valid_connection?" do
-  it "should issue a query to validate the connection" do
-    db = Sequel.mock
-    db.synchronize{|c| db.valid_connection?(c)}.must_equal true
-    db.synchronize do |c|
-      def c.execute(*) raise Sequel::DatabaseError, "error" end
-      db.valid_connection?(c)
-    end.must_equal false
-  end
-end
-
-describe "Database#run" do
-  before do
-    @db = Sequel.mock(:servers=>{:s1=>{}})
-  end
-  
-  it "should execute the code on the database" do
-    @db.run("DELETE FROM items")
-    @db.sqls.must_equal ["DELETE FROM items"]
-  end
-  
-  it "should handle placeholder literal strings" do
-    @db.run(Sequel.lit("DELETE FROM ?", :items))
-    @db.sqls.must_equal ["DELETE FROM items"]
-  end
-  
-  it "should return nil" do
-    @db.run("DELETE FROM items").must_be_nil
-  end
-  
-  it "should accept options passed to execute_ddl" do
-    @db.run("DELETE FROM items", :server=>:s1)
-    @db.sqls.must_equal ["DELETE FROM items -- s1"]
-  end
-end
-
-describe "Database#<<" do
-  before do
-    @db = Sequel.mock
-  end
-
-  it "should execute the code on the database" do
-    @db << "DELETE FROM items"
-    @db.sqls.must_equal ["DELETE FROM items"]
-  end
-  
-  it "should handle placeholder literal strings" do
-    @db << Sequel.lit("DELETE FROM ?", :items)
-    @db.sqls.must_equal ["DELETE FROM items"]
-  end
-  
-  it "should be chainable" do
-    @db << "DELETE FROM items" << "DELETE FROM items2"
-    @db.sqls.must_equal ["DELETE FROM items", "DELETE FROM items2"]
-  end
-end
-
-describe "Database#synchronize" do
-  before do
-    @db = Sequel::Database.new(:max_connections => 1)
-    @db.define_singleton_method(:connect){|c| 12345}
-  end
-  
-  it "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.must_equal 12345
-    t2 = Thread.new{@db.synchronize{|c| c2 = c; q2.push nil}}
-    @db.pool.available_connections.must_be :empty?
-    c2.must_be_nil
-    q1.push nil
-    q.pop
-    q2.pop
-    c2.must_equal 12345
-    t1.join
-    t2.join
-  end
-end
-
-describe "Database#test_connection" do
-  before do
-    @db = Sequel::Database.new
-    pr = proc{@test = rand(100)}
-    @db.define_singleton_method(:connect){|c| pr.call}
-  end
-  
-  it "should attempt to get a connection" do
-    @db.test_connection
-    @test.wont_equal nil
-  end
-  
-  it "should return true if successful" do
-    @db.test_connection.must_equal true
-  end
-
-  it "should raise an error if the attempting to connect raises an error" do
-    def @db.connect(*) raise Sequel::Error end
-    proc{@db.test_connection}.must_raise(Sequel::DatabaseConnectionError)
-  end
-end
-
-describe "Database#table_exists?" do
-  it "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).must_equal false
-    db.sqls.must_equal ["SELECT NULL AS nil FROM a LIMIT 1"]
-    db.table_exists?(:b).must_equal true
-    db.table_exists?(:c).must_equal true
-  end
-
-  it "should use a savepoint if inside a transaction" do
-    db = Sequel.mock(:fetch=>[Sequel::Error, [], [{:a=>1}]])
-    def db.supports_savepoints?; true end
-    db.transaction do
-      db.table_exists?(:a).must_equal false
-    end
-    db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SELECT NULL AS nil FROM a LIMIT 1", "ROLLBACK TO SAVEPOINT autopoint_1", "COMMIT"]
-    db.table_exists?(:b).must_equal true
-    db.table_exists?(:c).must_equal true
-  end
-end
-
-DatabaseTransactionSpecs = shared_description do
-  it "should wrap the supplied block with BEGIN + COMMIT statements" do
-    @db.transaction{@db.execute 'DROP TABLE test;'}
-    @db.sqls.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "should support transaction isolation levels" do
-    @db.define_singleton_method(:supports_transaction_isolation_levels?){true}
-    [:uncommitted, :committed, :repeatable, :serializable].each do |l|
-      @db.transaction(:isolation=>l){@db.run "DROP TABLE #{l}"}
-    end
-    @db.sqls.must_equal ['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
-
-  it "should allow specifying a default transaction isolation level" do
-    @db.define_singleton_method(: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.must_equal ['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
-  
-  it "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.must_equal ['BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.must_equal [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.must_equal ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.must_equal [1, 1, 1]
-  end
-  
-  it "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.must_raise(Sequel::ConstraintViolation)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK']
-    a.must_equal [1, 1]
-  end
-  
-  it "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.must_raise(Sequel::SerializationFailure)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK'] * 100
-    a.must_equal [1] * 100
-  end
-  
-  it "should support :before_retry option for invoking callback before retrying" do
-    a, errs, calls = [], [], []
-    retryer = proc{|n, err| calls << n; errs << err }
-    @db.transaction(:retry_on=>Sequel::DatabaseDisconnectError, :before_retry => retryer) do
-      a << 1; raise Sequel::DatabaseDisconnectError if a.length < 3
-    end
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
-    a.must_equal [1, 1, 1]
-    errs.count.must_equal 2
-    errs.each { |e| e.class.must_equal Sequel::DatabaseDisconnectError }
-    calls.must_equal [1, 2]
-  end
-  
-  it "should raise an error if attempting to use :retry_on inside another transaction" do
-    proc{@db.transaction{@db.transaction(:retry_on=>Sequel::ConstraintViolation){}}}.must_raise(Sequel::Error)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.must_raise(RuntimeError)
-  end
-  
-  it "should handle errors when sending BEGIN" do
-    ec = Class.new(StandardError)
-    @db.define_singleton_method(:database_error_classes){[ec]}
-    @db.define_singleton_method(: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.wont_equal nil
-    e.wrapped_exception.must_be_kind_of(ec)
-    @db.sqls.must_equal ['ROLLBACK']
-  end
-  
-  it "should handle errors when sending COMMIT" do
-    ec = Class.new(StandardError)
-    @db.define_singleton_method(:database_error_classes){[ec]}
-    @db.define_singleton_method(: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.wont_equal nil
-    e.wrapped_exception.must_be_kind_of(ec)
-    @db.sqls.must_equal ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
-  end
-  
-  it "should raise original exception if there is an exception raised when rolling back" do
-    ec = Class.new(StandardError)
-    @db.define_singleton_method(:database_error_classes){[ec]}
-    @db.define_singleton_method(:log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
-    begin
-      @db.transaction{raise ArgumentError, 'asdf'}
-    rescue => e
-    end
-    e.must_be_kind_of(ArgumentError)
-    @db.sqls.must_equal ['BEGIN']
-  end
-  
-  it "should raise original exception if there is an exception raised when rolling back when using :rollback=>:always" do
-    ec = Class.new(StandardError)
-    @db.define_singleton_method(:database_error_classes){[ec]}
-    @db.define_singleton_method(:log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
-    begin
-      @db.transaction(:rollback=>:always){}
-    rescue => e
-    end
-    e.must_be_kind_of(ec)
-    @db.sqls.must_equal ['BEGIN']
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
-  end
-  
-  it "should have in_transaction? return true if inside a transaction" do
-    c = nil
-    @db.transaction{c = @db.in_transaction?}
-    c.must_equal true
-  end
-  
-  it "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.must_equal [false, true]
-  end
-  
-  it "should have in_transaction? return false if not in a transaction" do
-    @db.in_transaction?.must_equal false
-  end
-  
-  it "should have rollback_checker return a proc which returns whether the transaction was rolled back" do
-    proc{@db.rollback_checker}.must_raise Sequel::Error
-    proc{@db.transaction(:server=>:test){@db.rollback_checker}}.must_raise Sequel::Error
-
-    rbc = nil
-    @db.transaction do 
-      rbc = @db.rollback_checker
-      rbc.call.must_be_nil
-    end
-    rbc.call.must_equal false
-
-    @db.transaction(:rollback=>:always) do 
-      rbc = @db.rollback_checker
-      rbc.call.must_be_nil
-    end
-    rbc.call.must_equal true
-
-    proc do
-      @db.transaction do 
-        rbc = @db.rollback_checker
-        raise
-      end
-    end.must_raise RuntimeError
-    rbc.call.must_equal true
-
-    @db.transaction(:server=>:test){rbc = @db.rollback_checker(:server=>:test)}
-    rbc.call.must_equal false
-  end
-  
-  it "should return nil if Sequel::Rollback is called in the transaction" do
-    @db.transaction{raise Sequel::Rollback}.must_be_nil
-  end
-  
-  it "should reraise Sequel::Rollback errors when using :rollback=>:reraise option is given" do
-    proc {@db.transaction(:rollback=>:reraise){raise Sequel::Rollback}}.must_raise(Sequel::Rollback)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    proc {@db.transaction(:rollback=>:reraise){raise ArgumentError}}.must_raise(ArgumentError)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:reraise){1}.must_equal 1
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-  end
-  
-  it "should always rollback if :rollback=>:always option is given" do
-    proc {@db.transaction(:rollback=>:always){raise ArgumentError}}.must_raise(ArgumentError)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:always){raise Sequel::Rollback}.must_be_nil
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:always){1}.must_equal 1
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    catch(:foo) do
-      @db.transaction(:rollback=>:always){throw :foo}
-    end
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-  end
-
-  it "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
-    @db.define_singleton_method(:commit_transaction){raise ArgumentError}
-    lambda{@db.transaction{}}.must_raise(ArgumentError)
-
-    @db.define_singleton_method(:database_error_classes){[ArgumentError]}
-    lambda{@db.transaction{}}.must_raise(Sequel::DatabaseError)
-  end
-  
-  it "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.must_be_kind_of(Sequel::Mock::Connection)
-    tr = @db.instance_variable_get(:@transactions)
-    tr.keys.must_equal [cc]
-    q.push nil
-    t.join
-    tr.must_be :empty?
-  end
-
-  it "should correctly handle nested transaction use with separate shards" do
-    @db.transaction do |c1|
-      @db.transaction(:server=>:test) do |c2|
-        c1.wont_equal c2
-        @db.execute 'DROP TABLE test;'
-      end
-    end
-    @db.sqls.must_equal ['BEGIN', 'BEGIN -- test', 'DROP TABLE test;', 'COMMIT -- test', 'COMMIT']
-  end
-  
-  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and !RUBY_VERSION.start_with?('1.9')
-    it "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.must_equal ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    end
-  end
-
-  it "should raise an Error if after_commit or after_rollback is called without a block" do
-    proc{@db.after_commit}.must_raise(Sequel::Error)
-    proc{@db.after_rollback}.must_raise(Sequel::Error)
-  end
-
-  it "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.must_equal ['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.must_equal ['BEGIN -- test', 'ROLLBACK -- test', 'foo -- test']
-  end
-
-  it "should execute after_commit outside transactions" do
-    @db.after_commit{@db.execute('foo')}
-    @db.sqls.must_equal ['foo']
-  end
-
-  it "should ignore after_rollback outside transactions" do
-    @db.after_rollback{@db.execute('foo')}
-    @db.sqls.must_equal []
-  end
-
-  it "should support after_commit inside transactions" do
-    @db.transaction{@db.after_commit{@db.execute('foo')}}
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'foo']
-  end
-
-  it "should support after_rollback inside transactions" do
-    @db.transaction{@db.after_rollback{@db.execute('foo')}}
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-  end
-
-  it "should have transaction inside after_commit work correctly" do
-    @db.transaction{@db.after_commit{@db.transaction{@db.execute('foo')}}}
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'BEGIN', 'foo', 'COMMIT']
-  end
-
-  it "should have transaction inside after_rollback work correctly" do
-    @db.transaction(:rollback=>:always){@db.after_rollback{@db.transaction{@db.execute('foo')}}}
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK', 'BEGIN', 'foo', 'COMMIT']
-  end
-
-  it "should not call after_commit if the transaction rolls back" do
-    @db.transaction{@db.after_commit{@db.execute('foo')}; raise Sequel::Rollback}
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-  end
-
-  it "should call after_rollback if the transaction rolls back" do
-    @db.transaction{@db.after_rollback{@db.execute('foo')}; raise Sequel::Rollback}
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK', 'foo']
-  end
-
-  it "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.must_equal ['BEGIN', 'COMMIT', 'foo', 'bar']
-  end
-
-  it "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.must_equal ['BEGIN', 'ROLLBACK', 'foo', 'bar']
-  end
-
-  it "should support after_commit inside nested transactions" do
-    @db.transaction{@db.transaction{@db.after_commit{@db.execute('foo')}}}
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'foo']
-  end
-
-  it "should support after_rollback inside nested transactions" do
-    @db.transaction{@db.transaction{@db.after_rollback{@db.execute('foo')}}; raise Sequel::Rollback}
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK', 'foo']
-  end
-
-  it "should raise an error if you attempt to use after_commit inside a prepared transaction" do
-    @db.define_singleton_method(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{@db.execute('foo')}}}.must_raise(Sequel::Error)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-  end
-
-  it "should raise an error if you attempt to use after_rollback inside a prepared transaction" do
-    @db.define_singleton_method(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.must_raise(Sequel::Error)
-    @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-  end
-end
-
-describe "Database#transaction with savepoint support" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-  end
-
-  include DatabaseTransactionSpecs
-
-  it "should support :retry_on option for automatically retrying transactions when using :savepoint option" do
-    a = []
-    @db.transaction do
-      @db.transaction(:retry_on=>Sequel::SerializationFailure, :savepoint=>true) do
-        a << 1
-        raise Sequel::SerializationFailure if a.length == 1
-      end
-    end
-    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "ROLLBACK TO SAVEPOINT autopoint_1", "SAVEPOINT autopoint_1", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
-    a.must_equal [1, 1]
-  end
-  
-  it "should automatically use a savepoint if :rollback=>:always given inside a transaction" do
-    @db.transaction do
-      @db.transaction(:rollback=>:always) do
-        @db.get(1)
-      end
-    end
-    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SELECT 1 AS v LIMIT 1", "ROLLBACK TO SAVEPOINT autopoint_1", "COMMIT"]
-  end
-  
-  it "should support :retry_on option for automatically retrying transactions inside an :auto_savepoint transaction" do
-    a = []
-    @db.transaction(:auto_savepoint=>true) do
-      @db.transaction(:retry_on=>Sequel::SerializationFailure) do
-        a << 1
-        raise Sequel::SerializationFailure if a.length == 1
-      end
-    end
-    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "ROLLBACK TO SAVEPOINT autopoint_1", "SAVEPOINT autopoint_1", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
-    a.must_equal [1, 1]
-  end
-  
-  it "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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT', 'foo', 'bar', 'baz']
-  end
-
-  it "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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
-  end
-
-  it "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
-    @db.define_singleton_method(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{@db.execute('foo')}}}}.must_raise(Sequel::Error)
-    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-  end
-
-  it "should raise an error if you attempt to use after_rollback inside a savepoint in a prepared transaction" do
-    @db.define_singleton_method(:supports_prepared_transactions?){true}
-    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('foo')}}}}.must_raise(Sequel::Error)
-    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-  end
-
-  it "should create savepoint if inside a transaction when :savepoint=>:only is used" do
-    @db.transaction{@db.transaction(:savepoint=>:only){}}
-    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1','RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-
-  it "should not create transaction if not inside a transaction when :savepoint=>:only is used" do
-    @db.transaction(:savepoint=>:only){}
-    @db.sqls.must_equal []
-  end
-end
-  
-describe "Database#transaction without savepoint support" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-    @db.define_singleton_method(:supports_savepoints?){false}
-  end
-
-  it "should not create savepoint if inside a transaction when :savepoint=>:only is used" do
-    @db.transaction{@db.transaction(:savepoint=>:only){}}
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-  end
-
-  it "should automatically use a savepoint if :rollback=>:always given inside a transaction" do
-    proc do
-      @db.transaction do
-        @db.transaction(:rollback=>:always) do
-          @db.get(1)
-        end
-      end
-    end.must_raise Sequel::Error
-    @db.sqls.must_equal ["BEGIN", "ROLLBACK"]
-  end
-  
-  include DatabaseTransactionSpecs
-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
-  
-  it "should run the block inside transacitons on all three databases" do
-    Sequel.transaction([@db1, @db2, @db3]){1}.must_equal 1
-    @sqls.must_equal ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
-  end
-  
-  it "should pass options to all the blocks" do
-    Sequel.transaction([@db1, @db2, @db3], :rollback=>:always){1}.must_equal 1
-    @sqls.must_equal ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
-  end
-  
-  it "should handle Sequel::Rollback exceptions raised by the block to rollback on all databases" do
-    Sequel.transaction([@db1, @db2, @db3]){raise Sequel::Rollback}.must_be_nil
-    @sqls.must_equal ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
-  end
-  
-  it "should handle nested transactions" do
-    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3]){1}}.must_equal 1
-    @sqls.must_equal ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
-  end
-  
-  it "should handle savepoints" do
-    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3], :savepoint=>true){1}}.must_equal 1
-    @sqls.must_equal ['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
-  
-  it "should wrap the supplied block with BEGIN + COMMIT statements" do
-    @db.transaction {@db.execute 'DROP TABLE test;'}
-    @db.sqls.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "should use savepoints if given the :savepoint option" do
-    @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}}
-    @db.sqls.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-  
-  it "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.must_equal ['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.must_equal ['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.must_equal ['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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-
-  it "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.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "should not use a savepoint if no transaction is in progress" do
-    @db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}
-    @db.sqls.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "should reuse the current transaction if no :savepoint option is given" do
-    @db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}
-    @db.sqls.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE test;', 'COMMIT']
-  end
-  
-  it "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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.must_raise(RuntimeError)
-  end
-  
-  it "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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
-    
-    proc {@db.transaction {raise RuntimeError}}.must_raise(RuntimeError)
-  end
-  
-  it "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.must_equal ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
-  end
-  
-  it "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.must_equal ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'DROP TABLE b', 'COMMIT']
-  end
-  
-  it "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
-    @db.define_singleton_method(:commit_transaction){raise ArgumentError}
-    lambda{@db.transaction{}}.must_raise(ArgumentError)
-    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.must_raise(ArgumentError)
-
-    @db.define_singleton_method(:database_error_classes){[ArgumentError]}
-    lambda{@db.transaction{}}.must_raise(Sequel::DatabaseError)
-    lambda{@db.transaction{@db.transaction(:savepoint=>true){}}}.must_raise(Sequel::DatabaseError)
-  end
-end
-
-describe "A Database adapter with a scheme" do
-  before do
-    require_relative '../../lib/sequel/adapters/mock'
-    @ccc = Class.new(Sequel::Mock::Database)
-    @ccc.send(:set_adapter_scheme, :ccc)
-  end
-
-  it "should be registered in the ADAPTER_MAP" do
-    Sequel::ADAPTER_MAP[:ccc].must_equal @ccc
-  end
-  
-  it "should give the database_type as the adapter scheme by default" do
-    @ccc.new.database_type.must_equal :ccc
-  end
-  
-  it "should be instantiated when its scheme is specified" do
-    c = Sequel::Database.connect('ccc://localhost/db')
-    c.must_be_kind_of(@ccc)
-    c.opts[:host].must_equal 'localhost'
-    c.opts[:database].must_equal 'db'
-  end
-  
-  it "should be accessible through Sequel.connect" do
-    c = Sequel.connect 'ccc://localhost/db'
-    c.must_be_kind_of(@ccc)
-    c.opts[:host].must_equal 'localhost'
-    c.opts[:database].must_equal 'db'
-  end
-
-  it "should be accessible through Sequel.connect via a block" do
-    x = nil
-    y = nil
-    z = nil
-    returnValue = 'anything'
-
-    p = proc do |c|
-      c.must_be_kind_of(@ccc)
-      c.opts[:host].must_equal 'localhost'
-      c.opts[:database].must_equal '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).must_equal returnValue
-    @ccc::DISCONNECTS.must_equal [x]
-
-    Sequel.connect('ccc://localhost/db', &p).must_equal returnValue
-    @ccc::DISCONNECTS.must_equal [y, x]
-
-    Sequel.send(:def_adapter_method, :ccc)
-    Sequel.ccc('db', :host=>'localhost', &p).must_equal returnValue
-    @ccc::DISCONNECTS.must_equal [z, y, x]
-    Sequel.singleton_class.send(:remove_method, :ccc)
-  end
-
-  it "should be accessible through Sequel.<adapter>" do
-    Sequel.send(:def_adapter_method, :ccc)
-
-    # invalid parameters
-    proc {Sequel.ccc('abc', 'def')}.must_raise(Sequel::Error)
-    proc {Sequel.ccc(1)}.must_raise(Sequel::Error)
-    
-    c = Sequel.ccc('mydb')
-    c.must_be_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :adapter_class).must_equal [:ccc, 'mydb', @ccc]
-    
-    c = Sequel.ccc('mydb', :host => 'localhost')
-    c.must_be_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :host, :adapter_class).must_equal [:ccc, 'mydb', 'localhost', @ccc]
-    
-    c = Sequel.ccc
-    c.must_be_kind_of(@ccc)
-    c.opts.values_at(:adapter, :adapter_class).must_equal [:ccc, @ccc]
-    
-    c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
-    c.must_be_kind_of(@ccc)
-    c.opts.values_at(:adapter, :database, :host, :adapter_class).must_equal [:ccc, 'mydb', 'localhost', @ccc]
-    Sequel.singleton_class.send(:remove_method, :ccc)
-  end
-  
-  it "should be accessible through Sequel.connect with options" do
-    c = Sequel.connect(:adapter => :ccc, :database => 'mydb')
-    c.must_be_kind_of(@ccc)
-    c.opts[:adapter].must_equal :ccc
-  end
-
-  it "should be accessible through Sequel.connect with URL parameters" do
-    c = Sequel.connect 'ccc:///db?host=/tmp&user=test'
-    c.must_be_kind_of(@ccc)
-    c.opts[:host].must_equal '/tmp'
-    c.opts[:database].must_equal 'db'
-    c.opts[:user].must_equal 'test'
-  end
-  
-  it "should have URL parameters take precedence over fixed URL parts" do
-    c = Sequel.connect 'ccc://localhost/db?host=a&database=b'
-    c.must_be_kind_of(@ccc)
-    c.opts[:host].must_equal 'a'
-    c.opts[:database].must_equal 'b'
-  end
-  
-  it "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.must_be_kind_of(@ccc)
-    c.opts[:host].must_equal 'a'
-    c.opts[:database].must_equal 'b'
-    c.opts[:user].must_equal 'c'
-  end
-
-  it "should unescape values of URL parameters and parts" do
-    c = Sequel.connect 'ccc:///d%5bb%5d?host=domain%5cinstance'
-    c.must_be_kind_of(@ccc)
-    c.opts[:database].must_equal 'd[b]'
-    c.opts[:host].must_equal 'domain\\instance'
-  end
-
-  it "should test the connection if test parameter is truthy" do
-    @ccc.send(:define_method, :connect){}
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=t'}.must_raise(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d?test=1'}.must_raise(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>true}.must_raise(Sequel::DatabaseConnectionError)
-    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>'t'}.must_raise(Sequel::DatabaseConnectionError)
-  end
-
-  it "should not test the connection if test parameter is not truthy" do
-    Sequel.connect 'ccc:///d%5bb%5d?test=f'
-    Sequel.connect 'ccc:///d%5bb%5d?test=0'
-    Sequel.connect 'ccc:///d%5bb%5d', :test=>false
-    Sequel.connect 'ccc:///d%5bb%5d', :test=>'f'
-  end
-end
-
-describe "Sequel::Database.connect" do
-  it "should raise an Error if not given a String or Hash" do
-    proc{Sequel::Database.connect(nil)}.must_raise(Sequel::Error)
-    proc{Sequel::Database.connect(Object.new)}.must_raise(Sequel::Error)
-  end
-end
-
-describe "An unknown database scheme" do
-  it "should raise an error in Sequel::Database.connect" do
-    proc {Sequel::Database.connect('ddd://localhost/db')}.must_raise(Sequel::AdapterNotFound)
-  end
-
-  it "should raise an error in Sequel.connect" do
-    proc {Sequel.connect('ddd://localhost/db')}.must_raise(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
-  
-  it "should raise an error" do
-    proc {Sequel.connect('blah://blow')}.must_raise(Sequel::AdapterNotFound)
-  end
-end
-
-describe "Sequel::Database.load_adapter" do
-  it "should not raise an error if subadapter does not exist" do
-    Sequel::Database.load_adapter(:foo, :subdir=>'bar').must_be_nil
-  end
-end
-
-describe "A single threaded database" do
-  after do
-    Sequel.single_threaded = false
-  end
-  
-  it "should use a SingleConnectionPool instead of a ConnectionPool" do
-    db = Sequel::Database.new(:single_threaded => true){123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-  end
-  
-  it "should be constructable using :single_threaded => true option" do
-    db = Sequel::Database.new(:single_threaded => true){123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-  end
-  
-  it "should be constructable using Sequel.single_threaded = true" do
-    Sequel.single_threaded = true
-    Sequel.single_threaded.must_equal true
-    db = Sequel::Database.new{123}
-    db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
-  end
-end
-
-describe "A single threaded database" do
-  before do
-    conn = 1234567
-    @db = Sequel::Database.new(:single_threaded => true)
-    @db.define_singleton_method(:connect) do |c|
-      conn += 1
-    end
-  end
-  
-  it "should invoke connection_proc only once" do
-    @db.pool.hold {|c| c.must_equal 1234568}
-    @db.pool.hold {|c| c.must_equal 1234568}
-  end
-  
-  it "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.must_equal x}
-    @db.disconnect
-    @db.dc.must_equal x
-  end
-  
-  it "should convert an Exception on connection into a DatabaseConnectionError" do
-    db = Class.new(Sequel::Database){def connect(*) raise Exception end}.new(:single_threaded => true, :servers=>{}, :test=>false)
-    proc {db.pool.hold {|c|}}.must_raise(Sequel::DatabaseConnectionError)
-  end
-  
-  it "should raise a DatabaseConnectionError if the connection proc returns nil" do
-    db = Class.new(Sequel::Database){def connect(*) end}.new(:single_threaded => true, :servers=>{}, :test=>false)
-    proc {db.pool.hold {|c|}}.must_raise(Sequel::DatabaseConnectionError)
-  end
-end
-
-describe "A database" do
-  after do
-    Sequel.single_threaded = false
-  end
-  
-  it "should have single_threaded? respond to true if in single threaded mode" do
-    db = Sequel::Database.new(:single_threaded => true){1234}
-    db.must_be :single_threaded?
-    
-    db = Sequel::Database.new(:max_options => 1)
-    db.wont_be :single_threaded?
-    
-    db = Sequel::Database.new
-    db.wont_be :single_threaded?
-    
-    Sequel.single_threaded = true
-    
-    db = Sequel::Database.new{123}
-    db.must_be :single_threaded?
-    
-    db = Sequel::Database.new(:max_options => 4){123}
-    db.must_be :single_threaded?
-  end
-  
-  it "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.must_equal [s]
-    db.logger = nil
-    db.loggers.must_equal []
-
-    db.loggers = [s]
-    db.loggers.must_equal [s]
-    db.loggers = []
-    db.loggers.must_equal []
-
-    t = "I'm also a logger"
-    db.loggers = [s, t]
-    db.loggers.must_equal [s,t]
-  end
-end
-
-describe "Database#fetch" do
-  before do
-    @db = Sequel.mock(:fetch=>proc{|sql| {:sql => sql}})
-  end
-  
-  it "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.must_equal 'select * from xyz'
-  end
-  
-  it "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.must_equal "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.must_equal "select name from table where name = 'aman' or id in (3, 4, 7)"
-  end
-  
-  it "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.must_equal "select * from xyz where x = 15 and y = 'abc'"
-  end
-  
-  it "should return the dataset if no block is given" do
-    @db.fetch('select * from xyz').must_be_kind_of(Sequel::Dataset)
-    
-    @db.fetch('select a from b').map {|r| r[:sql]}.must_equal ['select a from b']
-
-    @db.fetch('select c from d').inject([]) {|m, r| m << r; m}.must_equal \
-      [{:sql => 'select c from d'}]
-  end
-  
-  it "should return a dataset that always uses the given sql for SELECTs" do
-    ds = @db.fetch('select * from xyz')
-    ds.select_sql.must_equal 'select * from xyz'
-    ds.sql.must_equal 'select * from xyz'
-    
-    ds = ds.where{price.sql_number < 100}
-    ds.select_sql.must_equal 'select * from xyz'
-    ds.sql.must_equal 'select * from xyz'
-  end
-end
-
-
-describe "Database#[]" do
-  before do
-    @db = Sequel.mock
-  end
-  
-  it "should return a dataset when symbols are given" do
-    ds = @db[:items]
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.opts[:from].must_equal [:items]
-  end
-  
-  it "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.must_equal "select * from xyz where x = 15 and y = 'abc'"
-  end
-end
-
-describe "Database#inspect" do
-  it "should include the class name and the connection url" do
-    Sequel.connect('mock://foo/bar').inspect.must_equal '#<Sequel::Mock::Database: "mock://foo/bar">'
-  end
-
-  it "should include the class name and the connection options if an options hash was given" do
-    Sequel.connect(:adapter=>:mock).inspect.must_equal '#<Sequel::Mock::Database: {:adapter=>:mock}>'
-  end
-
-  it "should include the class name, uri, and connection options if uri and options hash was given" do
-    Sequel.connect('mock://foo', :database=>'bar').inspect.must_equal '#<Sequel::Mock::Database: "mock://foo" {:database=>"bar"}>'
-  end
-end
-
-describe "Database#get" do
-  before do
-    @db = Sequel.mock(:fetch=>{:a=>1})
-  end
-  
-  it "should use Dataset#get to get a single value" do
-    @db.get(:a).must_equal 1
-    @db.sqls.must_equal ['SELECT a LIMIT 1']
-    
-    @db.get(Sequel.function(:version).as(:version))
-    @db.sqls.must_equal ['SELECT version() AS version LIMIT 1']
-  end
-
-  it "should accept a block" do
-    @db.get{a}
-    @db.sqls.must_equal ['SELECT a LIMIT 1']
-    
-    @db.get{version(a).as(version)}
-    @db.sqls.must_equal ['SELECT version(a) AS version LIMIT 1']
-  end
-
-  it "should work when an alias cannot be determined" do
-    @db.get(1).must_equal 1
-    @db.sqls.must_equal ['SELECT 1 AS v LIMIT 1']
-  end
-end
-
-describe "Database#call" do
-  it "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).must_equal [{:id => 1, :x => 1}]
-    db[:items].filter(:n=>:$n).prepare(:select, :select_n)
-    db.call(:select_n, :n=>1).must_equal [{:id => 1, :x => 1}]
-    db.sqls.must_equal ['SELECT * FROM items', 'SELECT * FROM items WHERE (n = 1)']
-  end
-end
-
-describe "Database#server_opts" do
-  it "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].must_equal 1
-  end
-  
-  it "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].must_equal 1
-  end
-  
-  it "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].must_equal 3
-  end
-  
-  it "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].must_equal 4
-  end
-  
-  it "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)}.must_raise(Sequel::Error)
-  end
-
-  it "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].must_equal 2
-  end
-end
-
-describe "Database#add_servers" do
-  before do
-    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
-  end
-
-  it "should add new servers to the connection pool" do
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 1}
-
-    @db.add_servers(:server2=>{:host=>6})
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 6}
-
-    @db.disconnect
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 6}
-  end
-
-  it "should replace options for future connections to existing servers" do
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 1}
-
-    @db.add_servers(:default=>proc{{:host=>4}}, :server1=>{:host=>8})
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 1}
-
-    @db.disconnect
-    @db.synchronize{|c| c.opts[:host].must_equal 4}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 8}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 4}
-  end
-
-  it "should raise error for unsharded pool" do
-    proc{Sequel.mock.add_servers(:server1=>{})}.must_raise Sequel::Error
-  end
-end
-
-describe "Database#remove_servers" do
-  before do
-    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
-  end
-
-  it "should remove servers from the connection pool" do
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 3}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 4}
-
-    @db.remove_servers(:server1, :server2)
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 1}
-  end
-  
-  it "should accept arrays of symbols" do
-    @db.remove_servers([:server1, :server2])
-    @db.synchronize{|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server1){|c| c.opts[:host].must_equal 1}
-    @db.synchronize(:server2){|c| c.opts[:host].must_equal 1}
-  end
-
-  it "should allow removal while connections are still open" do
-    @db.synchronize do |c1|
-      c1.opts[:host].must_equal 1
-      @db.synchronize(:server1) do |c2|
-        c2.opts[:host].must_equal 3
-        @db.synchronize(:server2) do |c3|
-          c3.opts[:host].must_equal 4
-          @db.remove_servers(:server1, :server2)
-            @db.synchronize(:server1) do |c4|
-              c4.wont_equal c2
-              c4.must_equal c1
-              c4.opts[:host].must_equal 1
-              @db.synchronize(:server2) do |c5|
-                c5.wont_equal c3
-                c5.must_equal c1
-                c5.opts[:host].must_equal 1
-              end
-            end
-          c3.opts[:host].must_equal 4
-         end
-        c2.opts[:host].must_equal 3
-      end
-      c1.opts[:host].must_equal 1
-    end
-  end
-
-  it "should raise error for unsharded pool" do
-    proc{Sequel.mock.remove_servers(:server1)}.must_raise Sequel::Error
-  end
-end
-
-describe "Database#raise_error" do
-  before do
-    @db = Sequel.mock
-  end
-
-  it "should reraise if the exception class is not in opts[:classes]" do
-    e = Class.new(StandardError)
-    proc{@db.send(:raise_error, e.new(''), :classes=>[])}.must_raise(e)
-  end
-
-  it "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])}.must_raise(Sequel::DatabaseError)
-  end
-
-  it "should convert the exception to a DatabaseError if opts[:classes] if not present" do
-    proc{@db.send(:raise_error, Interrupt.new(''))}.must_raise(Sequel::DatabaseError)
-  end
-  
-  it "should convert the exception to a DatabaseDisconnectError if opts[:disconnect] is true" do
-    proc{@db.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.must_raise(Sequel::DatabaseDisconnectError)
-  end
-  
-  it "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
-    e = Class.new(StandardError)
-    proc{@db.send(:raise_error, e.new('foo'))}.must_raise(Sequel::DatabaseDisconnectError)
-    proc{@db.send(:raise_error, e.new('bar'))}.must_raise(Sequel::ConstraintViolation)
-  end
-end
-
-describe "Database#typecast_value" do
-  before do
-    @db = Sequel::Database.new
-  end
-
-  it "should raise an InvalidValue when given an invalid value" do
-    proc{@db.typecast_value(:integer, "13a")}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:float, "4.e2")}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:decimal, :invalid_value)}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:date, Object.new)}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:date, 'a')}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:time, Date.new)}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:datetime, 4)}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should handle integers with leading 0 as base 10" do
-    @db.typecast_value(:integer, "013").must_equal 13
-    @db.typecast_value(:integer, "08").must_equal 8
-    @db.typecast_value(:integer, "000013").must_equal 13
-    @db.typecast_value(:integer, "000008").must_equal 8
-  end
-
-  it "should handle integers with leading 0x as base 16" do
-    @db.typecast_value(:integer, "0x013").must_equal 19
-    @db.typecast_value(:integer, "0x80").must_equal 128
-  end
-
-  it "should typecast blobs as as Sequel::SQL::Blob" do
-    v = @db.typecast_value(:blob, "0x013")
-    v.must_be_kind_of(Sequel::SQL::Blob)
-    v.must_equal Sequel::SQL::Blob.new("0x013")
-    @db.typecast_value(:blob, v).object_id.must_equal v.object_id
-  end
-
-  it "should typecast boolean values to true, false, or nil" do
-    @db.typecast_value(:boolean, false).must_equal false
-    @db.typecast_value(:boolean, 0).must_equal false
-    @db.typecast_value(:boolean, "0").must_equal false
-    @db.typecast_value(:boolean, 'f').must_equal false
-    @db.typecast_value(:boolean, 'false').must_equal false
-    @db.typecast_value(:boolean, true).must_equal true
-    @db.typecast_value(:boolean, 1).must_equal true
-    @db.typecast_value(:boolean, '1').must_equal true
-    @db.typecast_value(:boolean, 't').must_equal true
-    @db.typecast_value(:boolean, 'true').must_equal true
-    @db.typecast_value(:boolean, '').must_be_nil
-  end
-
-  it "should typecast date values to Date" do
-    @db.typecast_value(:date, Date.today).must_equal Date.today
-    @db.typecast_value(:date, DateTime.now).must_equal Date.today
-    @db.typecast_value(:date, Time.now).must_equal Date.today
-    @db.typecast_value(:date, Date.today.to_s).must_equal Date.today
-    @db.typecast_value(:date, :year=>Date.today.year, :month=>Date.today.month, :day=>Date.today.day).must_equal Date.today
-  end
-
-  it "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).must_equal t4
-      Sequel.application_timezone = :local
-      Sequel.database_timezone = :utc
-      Sequel.application_to_database_timestamp(t2).must_equal t3
-    ensure
-      Sequel.default_timezone = nil
-    end
-  end
-
-  it "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').must_equal t
-      Sequel.database_timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').must_equal t3
-      Sequel.default_timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').must_equal t2
-      Sequel.database_timezone = :utc
-      @db.to_application_timestamp('2011-01-02 03:04:05').must_equal t4
-
-      Sequel.default_timezone = :utc
-      @db.timezone = :local
-      @db.to_application_timestamp('2011-01-02 03:04:05').must_equal t3
-      Sequel.default_timezone = :local
-      @db.timezone = :utc
-      @db.to_application_timestamp('2011-01-02 03:04:05').must_equal t4
-    ensure
-      Sequel.default_timezone = nil
-    end
-  end
-
-  it "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 = Rational(11, 2)
-    r1 = Rational(t2.utc_offset, 86400)
-    r2 = Rational((t - t2).to_i, 86400)
-    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.must_equal t4
-    t2.must_equal t3
-    dt.must_equal dt4
-    dt2.must_equal dt3
-
-    check = proc do |i, o| 
-      v = @db.typecast_value(:datetime, i)
-      v.must_equal o
-      if o.is_a?(Time)
-        v.utc_offset.must_equal o.utc_offset
-      else
-        v.offset.must_equal o.offset
-      end
-    end
-    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; true; end})
-    begin
-      @db.typecast_value(:datetime, dt).must_equal t
-      @db.typecast_value(:datetime, dt2).must_equal t2
-      @db.typecast_value(:datetime, t).must_equal t
-      @db.typecast_value(:datetime, t2).must_equal t2
-      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).must_equal t
-      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).must_equal t2
-      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).must_equal 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).must_equal t2
-
-      Sequel.datetime_class = DateTime
-      @db.typecast_value(:datetime, dt).must_equal dt
-      @db.typecast_value(:datetime, dt2).must_equal dt2
-      @db.typecast_value(:datetime, t).must_equal dt
-      @db.typecast_value(:datetime, t2).must_equal dt2
-      @db.typecast_value(:datetime, @db.literal(dt)[1...-1]).must_equal dt
-      @db.typecast_value(:datetime, dt.strftime('%F %T.%N')).must_equal dt
-      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).must_equal 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).must_equal 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
-
-  it "should handle arrays when typecasting timestamps" do
-    begin
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).must_equal Time.local(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).must_equal Time.local(2011, 10, 11, 12, 13, 14, 500000)
-
-      Sequel.datetime_class = DateTime
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14)
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2))
-      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000, Rational(1, 2)]).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), Rational(1, 2))
-    ensure
-      Sequel.datetime_class = Time
-    end
-  end
-
-  it "should handle hashes when typecasting timestamps" do
-    begin
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).must_equal 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).must_equal 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).must_equal 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).must_equal 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).must_equal 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).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).must_equal 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).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2))
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :offset=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14, Rational(1, 2))
-      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), Rational(1, 2))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, 14, Rational(1, 2))
-      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>Rational(1, 2)).must_equal DateTime.civil(2011, 10, 11, 12, 13, Rational(29, 2), Rational(1, 2))
-    ensure
-      Sequel.datetime_class = Time
-    end
-  end
-
-  it "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.must_be_kind_of(BigDecimal)
-      v.must_equal BigDecimal('1.0')
-    end
-  end
-
-  it "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.must_be_kind_of(Float)
-      v.must_equal 1.0
-    end
-  end
-
-  it "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.must_be_instance_of(String)
-      v.must_equal "1.0"
-    end
-  end
-
-  it "should raise errors when typecasting hash and array values to String" do
-    [[], {}].each do |i|
-      proc{@db.typecast_value(:string, i)}.must_raise(Sequel::InvalidValue)
-    end
-  end
-
-  it "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.must_be_instance_of(Sequel::SQLTime)
-      v.must_equal st
-    end
-  end
-
-  it "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).must_equal st
-  end
-
-  it "should have an underlying exception class available at wrapped_exception" do
-    begin
-      @db.typecast_value(:date, 'a')
-      true.must_equal false
-    rescue Sequel::InvalidValue => e
-      e.wrapped_exception.must_be_kind_of(ArgumentError)
-    end
-  end
-
-  it "should have an underlying exception class available at cause" do
-    begin
-      @db.typecast_value(:date, 'a')
-      true.must_equal false
-    rescue Sequel::InvalidValue => e
-      e.cause.must_be_kind_of(ArgumentError)
-    end
-  end if RUBY_VERSION >= '2.1'
-
-  it "should have an underlying exception class available at cause when using nested exceptions" do
-    begin
-      begin
-        raise ArgumentError
-      rescue => e1
-        begin
-          raise RuntimeError
-        rescue
-          @db.send(:raise_error, e1)
-        end
-      end
-    rescue Sequel::DatabaseError => e
-      e.cause.must_be_kind_of(ArgumentError)
-    end
-  end if RUBY_VERSION >= '2.1'
-
-  it "should include underlying exception class in #inspect" do
-    begin
-      @db.typecast_value(:date, 'a')
-      true.must_equal false
-    rescue Sequel::InvalidValue => e
-      e.inspect.must_equal '#<Sequel::InvalidValue: ArgumentError: invalid date>'
-    end
-  end
-end
-
-describe "Database#blank_object?" do
-  it "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?, "").must_equal true
-    db.send(:blank_object?, "  ").must_equal true
-    db.send(:blank_object?, nil).must_equal true
-    db.send(:blank_object?, false).must_equal true
-    db.send(:blank_object?, []).must_equal true
-    db.send(:blank_object?, {}).must_equal true
-    db.send(:blank_object?, c[:empty?, true]).must_equal true
-    db.send(:blank_object?, c[:blank?, true]).must_equal true
-
-    db.send(:blank_object?, " a ").must_equal false
-    db.send(:blank_object?, 1).must_equal false
-    db.send(:blank_object?, 1.0).must_equal false
-    db.send(:blank_object?, true).must_equal false
-    db.send(:blank_object?, [1]).must_equal false
-    db.send(:blank_object?, {1.0=>2.0}).must_equal false
-    db.send(:blank_object?, c[:empty?, false]).must_equal false
-    db.send(:blank_object?, c[:blank?, false]).must_equal false 
-  end
-end
-
-describe "Database#schema_autoincrementing_primary_key?" do
-  it "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, :auto_increment=>true).must_equal true
-    m.call(:primary_key=>true, :auto_increment=>false).must_equal false
-    m.call(:primary_key=>false).must_equal false
-  end
-end
-
-describe "Database#supports_schema_parsing?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_schema_parsing?.must_equal false
-  end
-
-  it "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?.must_equal true
-  end
-end
-
-describe "Database#supports_foreign_key_parsing?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_foreign_key_parsing?.must_equal false
-  end
-
-  it "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?.must_equal true
-  end
-end
-
-describe "Database#supports_index_parsing?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_index_parsing?.must_equal false
-  end
-
-  it "should be true if the database implements indexes" do
-    db = Sequel::Database.new
-    def db.indexes(*) end
-    db.supports_index_parsing?.must_equal true
-  end
-end
-
-describe "Database#supports_table_listing?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_table_listing?.must_equal false
-  end
-
-  it "should be true if the database implements tables" do
-    db = Sequel::Database.new
-    def db.tables(*) end
-    db.supports_table_listing?.must_equal true
-  end
-end
-
-describe "Database#supports_view_listing?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_view_listing?.must_equal false
-  end
-
-  it "should be true if the database implements views" do
-    db = Sequel::Database.new
-    def db.views(*) end
-    db.supports_view_listing?.must_equal true
-  end
-end
-
-describe "Database#supports_deferrable_constraints?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_deferrable_constraints?.must_equal false
-  end
-end
-
-describe "Database#supports_deferrable_foreign_key_constraints?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_deferrable_foreign_key_constraints?.must_equal false
-  end
-end
-
-describe "Database#supports_transactional_ddl?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_transactional_ddl?.must_equal false
-  end
-end
-
-describe "Database#global_index_namespace?" do
-  it "should be true by default" do
-    Sequel::Database.new.global_index_namespace?.must_equal true
-  end
-end
-
-describe "Database#supports_savepoints?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_savepoints?.must_equal false
-  end
-end
-
-describe "Database#supports_views_with_check_option?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_views_with_check_option?.must_equal false
-  end
-end
-
-describe "Database#supports_views_with_local_check_option?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_views_with_local_check_option?.must_equal false
-  end
-end
-
-describe "Database#supports_savepoints_in_prepared_transactions?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_savepoints_in_prepared_transactions?.must_equal false
-  end
-
-  it "should be true if both savepoints and prepared transactions are supported" do
-    db = Sequel::Database.new
-    db.define_singleton_method(:supports_savepoints?){true}
-    db.define_singleton_method(:supports_prepared_transactions?){true}
-    db.supports_savepoints_in_prepared_transactions?.must_equal true
-  end
-end
-
-describe "Database#supports_prepared_transactions?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_prepared_transactions?.must_equal false
-  end
-end
-
-describe "Database#supports_transaction_isolation_levels?" do
-  it "should be false by default" do
-    Sequel::Database.new.supports_transaction_isolation_levels?.must_equal false
-  end
-end
-
-describe "Database#column_schema_to_ruby_default" do
-  it "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].must_be_nil
-    p[1, :integer].must_equal 1
-    p['1', :integer].must_equal 1
-    p['-1', :integer].must_equal(-1)
-    p[1.0, :float].must_equal 1.0
-    p['1.0', :float].must_equal 1.0
-    p['-1.0', :float].must_equal(-1.0)
-    p['1.0', :decimal].must_equal BigDecimal('1.0')
-    p['-1.0', :decimal].must_equal BigDecimal('-1.0')
-    p[true, :boolean].must_equal true
-    p[false, :boolean].must_equal false
-    p['1', :boolean].must_equal true
-    p['0', :boolean].must_equal false
-    p['true', :boolean].must_equal true
-    p['false', :boolean].must_equal false
-    p["'t'", :boolean].must_equal true
-    p["'f'", :boolean].must_equal false
-    p["'a'", :string].must_equal 'a'
-    p["'a'", :blob].must_equal Sequel.blob('a')
-    p["'a'", :blob].must_be_kind_of(Sequel::SQL::Blob)
-    p["''", :string].must_equal ''
-    p["'\\a''b'", :string].must_equal "\\a'b"
-    p["'NULL'", :string].must_equal "NULL"
-    p[Date.today, :date].must_equal Date.today
-    p["'2009-10-29'", :date].must_equal Date.new(2009,10,29)
-    p["CURRENT_TIMESTAMP", :date].must_equal Sequel::CURRENT_DATE
-    p["CURRENT_DATE", :date].must_equal Sequel::CURRENT_DATE
-    p["now()", :date].must_equal Sequel::CURRENT_DATE
-    p["getdate()", :date].must_equal Sequel::CURRENT_DATE
-    p["CURRENT_TIMESTAMP", :datetime].must_equal Sequel::CURRENT_TIMESTAMP
-    p["CURRENT_DATE", :datetime].must_equal Sequel::CURRENT_TIMESTAMP
-    p["now()", :datetime].must_equal Sequel::CURRENT_TIMESTAMP
-    p["getdate()", :datetime].must_equal Sequel::CURRENT_TIMESTAMP
-    p["'2009-10-29T10:20:30-07:00'", :datetime].must_equal DateTime.parse('2009-10-29T10:20:30-07:00')
-    p["'2009-10-29 10:20:30'", :datetime].must_equal DateTime.parse('2009-10-29 10:20:30')
-    p["'10:20:30'", :time].must_equal Time.parse('10:20:30')
-    p["NaN", :float].must_be_nil
-
-    db = Sequel.mock(:host=>'postgres')
-    p["''::text", :string].must_equal ""
-    p["'\\a''b'::character varying", :string].must_equal "\\a'b"
-    p["'a'::bpchar", :string].must_equal "a"
-    p["(-1)", :integer].must_equal(-1)
-    p["(-1.0)", :float].must_equal(-1.0)
-    p['(-1.0)', :decimal].must_equal BigDecimal('-1.0')
-    p["'a'::bytea", :blob].must_equal Sequel.blob('a')
-    p["'a'::bytea", :blob].must_be_kind_of(Sequel::SQL::Blob)
-    p["'2009-10-29'::date", :date].must_equal Date.new(2009,10,29)
-    p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].must_equal DateTime.parse('2009-10-29 10:20:30.241343')
-    p["'10:20:30'::time without time zone", :time].must_equal Time.parse('10:20:30')
-
-    db = Sequel.mock(:host=>'mysql')
-    p["\\a'b", :string].must_equal "\\a'b"
-    p["a", :string].must_equal "a"
-    p["NULL", :string].must_equal "NULL"
-    p["-1", :float].must_equal(-1.0)
-    p['-1', :decimal].must_equal BigDecimal('-1.0')
-    p["2009-10-29", :date].must_equal Date.new(2009,10,29)
-    p["2009-10-29 10:20:30", :datetime].must_equal DateTime.parse('2009-10-29 10:20:30')
-    p["10:20:30", :time].must_equal Time.parse('10:20:30')
-    p["a", :enum].must_equal "a"
-    p["a,b", :set].must_equal "a,b"
-    
-    db = Sequel.mock(:host=>'mssql')
-    p["(N'a')", :string].must_equal "a"
-    p["((-12))", :integer].must_equal(-12)
-    p["((12.1))", :float].must_equal 12.1
-    p["((-12.1))", :decimal].must_equal BigDecimal('-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
-
-  it "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.must_equal 1
-  end
-
-  it "should not call the block multiple times if extension loaded more than once" do
-    @db.opts[:foo] = []
-    Sequel::Database.register_extension(:foo){|db| db.opts[:foo] << 1}
-    @db.extension(:foo).opts[:foo].must_equal [1]
-    @db.extension(:foo).opts[:foo].must_equal [1]
-  end
-
-  it "should be able to register an extension with a block and have Database#extension call the block" do
-    Sequel::Database.register_extension(:foo){|db| db.opts[:foo] = 1}
-    @db.extension(:foo).opts[:foo].must_equal 1
-  end
-
-  it "should be able to register an extension with a callable and Database#extension call the callable" do
-    Sequel::Database.register_extension(:foo, proc{|db| db.opts[:foo] = 1})
-    @db.extension(:foo).opts[:foo].must_equal 1
-  end
-
-  it "should be able to load multiple extensions in the same call" do
-    a = []
-    Sequel::Database.register_extension(:foo, proc{|db| a << db.opts[:foo] = 1})
-    Sequel::Database.register_extension(:bar, proc{|db| a << db.opts[:bar] = 2})
-    @db.extension(:foo, :bar).opts.values_at(:foo, :bar).must_equal [1, 2]
-    a.must_equal [1, 2]
-  end
-
-  it "should return the receiver" do
-    Sequel::Database.register_extension(:foo, Module.new{def a; 1; end})
-    @db.extension(:foo).must_be_same_as(@db)
-  end
-
-  it "should raise an Error if registering with both a module and a block" do
-    proc{Sequel::Database.register_extension(:foo, Module.new){}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an Error if attempting to load an incompatible extension" do
-    proc{@db.extension(:foo2)}.must_raise(Sequel::Error)
-  end
-
-  it "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.wont_respond_to(:a)
-    @db.wont_respond_to(:b)
-    Sequel.mock.a.must_equal 1
-    Sequel.mock.b.must_equal 2
-  end
-
-  it "should be loadable via the :extensions Database option" do
-    Sequel::Database.register_extension(:a, Module.new{def a; 1; end})
-    Sequel::Database.register_extension(:b, Module.new{def b; 2; end})
-    Sequel.mock(:extensions=>:a).a.must_equal 1
-    db = Sequel.mock(:extensions=>'a,b')
-    db.a.must_equal 1
-    db.b.must_equal 2
-    db = Sequel.mock(:extensions=>[:a, :b])
-    db.a.must_equal 1
-    db.b.must_equal 2
-    proc{Sequel.mock(:extensions=>nil).a}.must_raise NoMethodError
-    proc{Sequel.mock(:extensions=>Object.new)}.must_raise Sequel::Error
-  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
-
-  it "should use appropriate exception classes for given SQL states" do
-    @db.fetch = ArgumentError
-    @db.sql_state = '23502'
-    proc{@db.get(:a)}.must_raise(Sequel::NotNullConstraintViolation)
-    @db.sql_state = '23503'
-    proc{@db.get(:a)}.must_raise(Sequel::ForeignKeyConstraintViolation)
-    @db.sql_state = '23505'
-    proc{@db.get(:a)}.must_raise(Sequel::UniqueConstraintViolation)
-    @db.sql_state = '23513'
-    proc{@db.get(:a)}.must_raise(Sequel::CheckConstraintViolation)
-    @db.sql_state = '40001'
-    proc{@db.get(:a)}.must_raise(Sequel::SerializationFailure)
-  end
-end
-
-describe "Database.after_initialize" do
-  after do
-    Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
-  end
-
-  it "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.must_equal :debug
-  end
-
-  it "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.must_equal :debug
-    db.loggers.must_include(11)
-  end
-
-  it "should raise an error if registration is called without a block" do
-    proc {
-      Sequel::Database.after_initialize
-    }.must_raise(Sequel::Error, /must provide block/i)
-  end
-end
-
-describe "Database#schema_type_class" do
-  it "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).must_equal 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
-
-  it "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.must_equal ["DELETE FROM table", "SET foo", "INSERT INTO table DEFAULT VALUES"]
-  end
-end
-
-describe "Dataset identifier folding" do
-  it "should fold to uppercase by default, as per SQL" do
-    Sequel::Database.new.send(:folds_unquoted_identifiers_to_uppercase?).must_equal true
-  end
-end