sequel 3.21.0 → 3.31.0

data/spec/core/database_spec.rb

@@ -74,46 +74,46 @@ describe "A new Database" do
     Sequel.identifier_input_method = nil
     Sequel::Database.identifier_input_method.should == ""
     db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.should == nil
+    db.identifier_input_method.should be_nil
     db.identifier_input_method = :downcase
     db.identifier_input_method.should == :downcase
     db = Sequel::Database.new(:identifier_input_method=>:upcase)
     db.identifier_input_method.should == :upcase
     db.identifier_input_method = nil
-    db.identifier_input_method.should == nil
+    db.identifier_input_method.should be_nil
     Sequel.identifier_input_method = :downcase
     Sequel::Database.identifier_input_method.should == :downcase
     db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.should == nil
+    db.identifier_input_method.should be_nil
     db.identifier_input_method = :upcase
     db.identifier_input_method.should == :upcase
     db = Sequel::Database.new(:identifier_input_method=>:upcase)
     db.identifier_input_method.should == :upcase
     db.identifier_input_method = nil
-    db.identifier_input_method.should == nil
+    db.identifier_input_method.should be_nil
   end
   
   specify "should respect the :identifier_output_method option" do
     Sequel.identifier_output_method = nil
     Sequel::Database.identifier_output_method.should == ""
     db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.should == nil
+    db.identifier_output_method.should be_nil
     db.identifier_output_method = :downcase
     db.identifier_output_method.should == :downcase
     db = Sequel::Database.new(:identifier_output_method=>:upcase)
     db.identifier_output_method.should == :upcase
     db.identifier_output_method = nil
-    db.identifier_output_method.should == nil
+    db.identifier_output_method.should be_nil
     Sequel.identifier_output_method = :downcase
     Sequel::Database.identifier_output_method.should == :downcase
     db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.should == nil
+    db.identifier_output_method.should be_nil
     db.identifier_output_method = :upcase
     db.identifier_output_method.should == :upcase
     db = Sequel::Database.new(:identifier_output_method=>:upcase)
     db.identifier_output_method.should == :upcase
     db.identifier_output_method = nil
-    db.identifier_output_method.should == nil
+    db.identifier_output_method.should be_nil
   end
 
   specify "should use the default Sequel.quote_identifiers value" do
@@ -384,339 +384,197 @@ describe "Database#dataset" do
   end
 end
 
-describe "Database#execute" do
-  specify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(Sequel::NotImplemented)
-    proc {Sequel::Database.new << 'blah blah'}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#tables" do
-  specify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.tables}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#indexes" do
-  specify "should raise Sequel::NotImplemented" do
-    proc {Sequel::Database.new.indexes(:table)}.should raise_error(Sequel::NotImplemented)
-  end
-end
-
-describe "Database#<< and run" do
+describe "Database#dataset_class" do
   before do
-    sqls = @sqls = []
-    @c = Class.new(Sequel::Database) do
-      define_method(:execute_ddl){|sql, *opts| sqls.clear; sqls << sql; sqls.concat(opts)}
-    end
-    @db = @c.new({})
-  end
-  
-  specify "should pass the supplied sql to #execute_ddl" do
-    (@db << "DELETE FROM items")
-    @sqls.should == ["DELETE FROM items", {}]
-    @db.run("DELETE FROM items2")
-    @sqls.should == ["DELETE FROM items2", {}]
-  end
-  
-  specify "should return nil" do
-    (@db << "DELETE FROM items").should == nil
-    @db.run("DELETE FROM items").should == nil
+    @db = Sequel::Database.new
+    @dsc = Class.new(Sequel::Dataset)
   end
   
-  specify "should accept options passed to execute_ddl" do
-    @db.run("DELETE FROM items", :server=>:s1)
-    @sqls.should == ["DELETE FROM items", {:server=>:s1}]
+  specify "should have setter set the class to use to create datasets" do
+    @db.dataset_class = @dsc
+    ds = @db.dataset
+    ds.should be_a_kind_of(@dsc)
+    ds.opts.should == {}
+    ds.db.should be(@db)
   end
-end
 
-describe "Database#synchronize" do
-  before do
-    @db = Sequel::Database.new(:max_connections => 1){12345}
-  end
-  
-  specify "should wrap the supplied block in pool.hold" do
-    stop = false
-    c1, c2 = nil
-    t1 = Thread.new {@db.synchronize {|c| c1 = c; while !stop;sleep 0.1;end}}
-    while !c1;end
-    c1.should == 12345
-    t2 = Thread.new {@db.synchronize {|c| c2 = c}}
-    sleep 0.2
-    @db.pool.available_connections.should be_empty
-    c2.should be_nil
-    stop = true
-    t1.join
-    sleep 0.1
-    c2.should == 12345
-    t2.join
+  specify "should have getter return the class to use to create datasets" do
+    @db.dataset_class.should == Sequel::Dataset
+    @db.dataset_class = @dsc
+    @db.dataset_class.should == @dsc
   end
 end
-
-describe "Database#test_connection" do
+  
+describe "Database#extend_datasets" do
   before do
-    @db = Sequel::Database.new{@test = rand(100)}
+    @db = Sequel::Database.new
+    @m = Module.new{def foo() [3] end}
+    @m2 = Module.new{def foo() [4] + super end}
+    @db.extend_datasets(@m)
   end
   
-  specify "should pool#hold" do
-    @db.test_connection
-    @test.should_not be_nil
+  specify "should change the dataset class to a subclass the first time it is called" do
+    @db.dataset_class.superclass.should == Sequel::Dataset
   end
-  
-  specify "should return true if successful" do
-    @db.test_connection.should be_true
+
+  specify "should not create a subclass of the dataset class if called more than once" do
+    @db.extend_datasets(@m2)
+    @db.dataset_class.superclass.should == Sequel::Dataset
   end
 
-  specify "should raise an error if the attempting to connect raises an error" do
-    proc{Sequel::Database.new{raise Sequel::Error, 'blah'}.test_connection}.should raise_error(Sequel::Error)
+  specify "should make the dataset class include the module" do
+    @db.dataset_class.ancestors.should include(@m)
+    @db.dataset_class.ancestors.should_not include(@m2)
+    @db.extend_datasets(@m2)
+    @db.dataset_class.ancestors.should include(@m)
+    @db.dataset_class.ancestors.should include(@m2)
   end
-end
 
-class DummyDataset < Sequel::Dataset
-  def first
-    raise if @opts[:from] == [:a]
-    true
+  specify "should have datasets respond to the module's methods" do
+    @db.dataset.foo.should == [3]
+    @db.extend_datasets(@m2)
+    @db.dataset.foo.should == [4, 3]
   end
-end
 
-class DummyDatabase < Sequel::Database
-  attr_reader :sqls
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
+  specify "should take a block and create a module from it to use" do
+    @db.dataset.foo.should == [3]
+    @db.extend_datasets{def foo() [5] + super end}
+    @db.dataset.foo.should == [5, 3]
   end
-  
-  def transaction; yield; end
 
-  def dataset
-    DummyDataset.new(self)
+  specify "should raise an error if both a module and a block are provided" do
+    proc{@db.extend_datasets(@m2){def foo() [5] + super end}}.should raise_error(Sequel::Error)
   end
-end
 
-describe "Database#create_table" do
-  before do
-    @db = DummyDatabase.new
+  specify "should be able to override methods defined in the original Dataset class" do
+    @db.extend_datasets(Module.new{def select(*a, &block) super.order(*a, &block) end})
+    @db[:t].select(:a, :b).sql.should == 'SELECT a, b FROM t ORDER BY a, b'
   end
-  
-  specify "should construct proper SQL" do
-    @db.create_table :test do
-      primary_key :id, :integer, :null => false
-      column :name, :text
-      index :name, :unique => true
-    end
-    @db.sqls.should == [
-      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_name_index ON test (name)'
-    ]
+
+  specify "should reapply settings if dataset_class is chagned" do
+    c = Class.new(Sequel::Dataset)
+    @db.dataset_class = c
+    @db.dataset_class.superclass.should == c
+    @db.dataset_class.ancestors.should include(@m)
+    @db.dataset.foo.should == [3]
   end
+end
   
-  specify "should create a temporary table" do
-    @db.create_table :test_tmp, :temp => true do
-      primary_key :id, :integer, :null => false
-      column :name, :text
-      index :name, :unique => true
-    end
-    
-    @db.sqls.should == [
-      'CREATE TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)'
-    ]
+describe "Database#execute" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(Sequel::NotImplemented)
   end
 end
 
-describe "Database#alter_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.alter_table :xyz do
-      add_column :aaa, :text, :null => false, :unique => true
-      drop_column :bbb
-      rename_column :ccc, :ddd
-      set_column_type :eee, :integer
-      set_column_default :hhh, 'abcd'
-      
-      add_index :fff, :unique => true
-      drop_index :ggg
-    end
-    
-    @db.sqls.should == [
-      'ALTER TABLE xyz ADD COLUMN aaa text NOT NULL UNIQUE',
-      'ALTER TABLE xyz DROP COLUMN bbb',
-      'ALTER TABLE xyz RENAME COLUMN ccc TO ddd',
-      'ALTER TABLE xyz ALTER COLUMN eee TYPE integer',
-      "ALTER TABLE xyz ALTER COLUMN hhh SET DEFAULT 'abcd'",
-      
-      'CREATE UNIQUE INDEX xyz_fff_index ON xyz (fff)',
-      'DROP INDEX xyz_ggg_index'
-    ]
+describe "Database#tables" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.tables}.should raise_error(Sequel::NotImplemented)
   end
 end
 
-describe "Database#add_column" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.add_column :test, :name, :text, :unique => true
-    @db.sqls.should == [
-      'ALTER TABLE test ADD COLUMN name text UNIQUE'
-    ]
+describe "Database#views" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.views}.should raise_error(Sequel::NotImplemented)
   end
 end
 
-describe "Database#drop_column" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_column :test, :name
-    @db.sqls.should == [
-      'ALTER TABLE test DROP COLUMN name'
-    ]
+describe "Database#indexes" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.indexes(:table)}.should raise_error(Sequel::NotImplemented)
   end
 end
 
-describe "Database#rename_column" do
+describe "Database#run" do
   before do
-    @db = DummyDatabase.new
+    @db = Sequel.mock(:servers=>{:s1=>{}})
   end
   
-  specify "should construct proper SQL" do
-    @db.rename_column :test, :abc, :def
-    @db.sqls.should == [
-      'ALTER TABLE test RENAME COLUMN abc TO def'
-    ]
-  end
-end
-
-describe "Database#set_column_type" do
-  before do
-    @db = DummyDatabase.new
+  specify "should execute the code on the database" do
+    @db.run("DELETE FROM items")
+    @db.sqls.should == ["DELETE FROM items"]
   end
   
-  specify "should construct proper SQL" do
-    @db.set_column_type :test, :name, :integer
-    @db.sqls.should == [
-      'ALTER TABLE test ALTER COLUMN name TYPE integer'
-    ]
-  end
-end
-
-describe "Database#set_column_default" do
-  before do
-    @db = DummyDatabase.new
+  specify "should return nil" do
+    @db.run("DELETE FROM items").should be_nil
   end
   
-  specify "should construct proper SQL" do
-    @db.set_column_default :test, :name, 'zyx'
-    @db.sqls.should == [
-      "ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"
-    ]
+  specify "should accept options passed to execute_ddl" do
+    @db.run("DELETE FROM items", :server=>:s1)
+    @db.sqls.should == ["DELETE FROM items -- s1"]
   end
 end
 
-describe "Database#add_index" do
+describe "Database#<<" do
   before do
-    @db = DummyDatabase.new
+    @db = Sequel.mock
   end
-  
-  specify "should construct proper SQL" do
-    @db.add_index :test, :name, :unique => true
-    @db.sqls.should == [
-      'CREATE UNIQUE INDEX test_name_index ON test (name)'
-    ]
+
+  specify "should execute the code on the database" do
+    @db << "DELETE FROM items"
+    @db.sqls.should == ["DELETE FROM items"]
   end
   
-  specify "should accept multiple columns" do
-    @db.add_index :test, [:one, :two]
-    @db.sqls.should == [
-      'CREATE INDEX test_one_two_index ON test (one, two)'
-    ]
+  specify "should be chainable" do
+    @db << "DELETE FROM items" << "DELETE FROM items2"
+    @db.sqls.should == ["DELETE FROM items", "DELETE FROM items2"]
   end
 end
 
-describe "Database#drop_index" do
+describe "Database#synchronize" do
   before do
-    @db = DummyDatabase.new
+    @db = Sequel::Database.new(:max_connections => 1){12345}
   end
   
-  specify "should construct proper SQL" do
-    @db.drop_index :test, :name
-    @db.sqls.should == [
-      'DROP INDEX test_name_index'
-    ]
+  specify "should wrap the supplied block in pool.hold" do
+    q, q1, q2, q3 = Queue.new, Queue.new, Queue.new, Queue.new
+    c1, c2 = nil
+    t1 = Thread.new{@db.synchronize{|c| c1 = c; q.push nil; q1.pop}; q.push nil}
+    q.pop
+    c1.should == 12345
+    t2 = Thread.new{@db.synchronize{|c| c2 = c; q2.push nil}}
+    @db.pool.available_connections.should be_empty
+    c2.should be_nil
+    q1.push nil
+    q.pop
+    q2.pop
+    c2.should == 12345
+    t1.join
+    t2.join
   end
-  
-end
-
-class Dummy2Database < Sequel::Database
-  attr_reader :sql
-  def execute(sql); @sql = sql; end
-  def transaction; yield; end
 end
 
-describe "Database#drop_table" do
+describe "Database#test_connection" do
   before do
-    @db = DummyDatabase.new
+    @db = Sequel::Database.new{@test = rand(100)}
   end
   
-  specify "should construct proper SQL" do
-    @db.drop_table :test
-    @db.sqls.should == ['DROP TABLE test']
+  specify "should attempt to get a connection" do
+    @db.test_connection
+    @test.should_not be_nil
   end
   
-  specify "should accept multiple table names" do
-    @db.drop_table :a, :bb, :ccc
-    @db.sqls.should == [
-      'DROP TABLE a',
-      'DROP TABLE bb',
-      'DROP TABLE ccc'
-    ]
+  specify "should return true if successful" do
+    @db.test_connection.should be_true
   end
-end
 
-describe "Database#rename_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.rename_table :abc, :xyz
-    @db.sqls.should == ['ALTER TABLE abc RENAME TO xyz']
+  specify "should raise an error if the attempting to connect raises an error" do
+    proc{Sequel::Database.new{raise Sequel::Error, 'blah'}.test_connection}.should raise_error(Sequel::Error)
   end
 end
 
 describe "Database#table_exists?" do
   specify "should try to select the first record from the table's dataset" do
-    db2 = DummyDatabase.new
-    db2.table_exists?(:a).should be_false
-    db2.table_exists?(:b).should be_true
-  end
-end
-
-class Dummy3Database < Sequel::Database
-  attr_reader :sql, :transactions
-  def execute(sql, opts={}); @sql ||= []; @sql << sql; end
-
-  class DummyConnection
-    def initialize(db); @db = db; end
-    def execute(sql); @db.execute(sql); end
+    db = Sequel.mock(:fetch=>[Sequel::Error, [], [{:a=>1}]])
+    db.table_exists?(:a).should be_false
+    db.table_exists?(:b).should be_true
+    db.table_exists?(:c).should be_true
   end
 end
 
-describe "Database#transaction" do
-  before do
-    @db = Dummy3Database.new{Dummy3Database::DummyConnection.new(@db)}
-  end
-  
+shared_examples_for "Database#transaction" do  
   specify "should wrap the supplied block with BEGIN + COMMIT statements" do
     @db.transaction{@db.execute 'DROP TABLE test;'}
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should support transaction isolation levels" do
@@ -724,7 +582,7 @@ describe "Database#transaction" do
     [:uncommitted, :committed, :repeatable, :serializable].each do |l|
       @db.transaction(:isolation=>l){@db.run "DROP TABLE #{l}"}
     end
-    @db.sql.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
+    @db.sqls.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED', 'DROP TABLE committed', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'DROP TABLE repeatable', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
@@ -736,7 +594,7 @@ describe "Database#transaction" do
       @db.transaction_isolation_level = l
       @db.transaction{@db.run "DROP TABLE #{l}"}
     end
-    @db.sql.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
+    @db.sqls.should == ['BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED', 'DROP TABLE uncommitted', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED', 'DROP TABLE committed', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'DROP TABLE repeatable', 'COMMIT',
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
@@ -751,12 +609,12 @@ describe "Database#transaction" do
       end
     end
     @db.ret_commit
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should issue ROLLBACK if an exception is raised, and re-raise" do
     @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
-    @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
     
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
@@ -768,7 +626,50 @@ describe "Database#transaction" do
       @db.drop_table(:b)
     end
     
-    @db.sql.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
+  end
+  
+  specify "should have in_transaction? return true if inside a transaction" do
+    c = nil
+    @db.transaction{c = @db.in_transaction?}
+    c.should be_true
+  end
+  
+  specify "should have in_transaction? handle sharding correctly" do
+    c = []
+    @db.transaction(:server=>:test){c << @db.in_transaction?}
+    @db.transaction(:server=>:test){c << @db.in_transaction?(:server=>:test)}
+    c.should == [false, true]
+  end
+  
+  specify "should have in_transaction? return false if not in a transaction" do
+    @db.in_transaction?.should be_false
+  end
+  
+  specify "should return nil if Sequel::Rollback is called in the transaction" do
+    @db.transaction{raise Sequel::Rollback}.should be_nil
+  end
+  
+  specify "should reraise Sequel::Rollback errors when using :rollback=>:reraise option is given" do
+    proc {@db.transaction(:rollback=>:reraise){raise Sequel::Rollback}}.should raise_error(Sequel::Rollback)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    proc {@db.transaction(:rollback=>:reraise){raise ArgumentError}}.should raise_error(ArgumentError)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    @db.transaction(:rollback=>:reraise){1}.should == 1
+    @db.sqls.should == ['BEGIN', 'COMMIT']
+  end
+  
+  specify "should always rollback if :rollback=>:always option is given" do
+    proc {@db.transaction(:rollback=>:always){raise ArgumentError}}.should raise_error(ArgumentError)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    @db.transaction(:rollback=>:always){raise Sequel::Rollback}.should be_nil
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    @db.transaction(:rollback=>:always){1}.should be_nil
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    catch (:foo) do
+      @db.transaction(:rollback=>:always){throw :foo}
+    end
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
   end
   
   specify "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
@@ -780,47 +681,242 @@ describe "Database#transaction" do
   end
   
   specify "should be re-entrant" do
-    stop = false
+    q, q1 = Queue.new, Queue.new
     cc = nil
     t = Thread.new do
       @db.transaction {@db.transaction {@db.transaction {|c|
         cc = c
-        while !stop; sleep 0.1; end
+        q.pop
+        q1.push nil
+        q.pop
       }}}
     end
-    while cc.nil?; sleep 0.1; end
-    cc.should be_a_kind_of(Dummy3Database::DummyConnection)
-    @db.transactions.should == [t]
-    stop = true
+    q.push nil
+    q1.pop
+    cc.should be_a_kind_of(Sequel::Mock::Connection)
+    tr = @db.instance_variable_get(:@transactions)
+    tr.keys.should == [cc]
+    q.push nil
     t.join
-    @db.transactions.should be_empty
+    tr.should be_empty
+  end
+
+  specify "should correctly handle nested transacation use with separate shards" do
+    @db.transaction do |c1|
+      @db.transaction(:server=>:test) do |c2|
+        c1.should_not == c2
+        @db.execute 'DROP TABLE test;'
+      end
+    end
+    @db.sqls.should == ['BEGIN', 'BEGIN -- test', 'DROP TABLE test;', 'COMMIT -- test', 'COMMIT']
+  end
+  
+  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and RUBY_VERSION < '1.9'
+    specify "should handle Thread#kill for transactions inside threads" do
+      q = Queue.new
+      q1 = Queue.new
+      t = Thread.new do
+        @db.transaction do
+          @db.execute 'DROP TABLE test'
+          q1.push nil
+          q.pop
+          @db.execute 'DROP TABLE test2'
+        end
+      end
+      q1.pop
+      t.kill
+      t.join
+      @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
+    end
+  end
+
+  specify "should raise an Error if after_commit or after_rollback is called without a block" do
+    proc{@db.after_commit}.should raise_error(Sequel::Error)
+    proc{@db.after_rollback}.should raise_error(Sequel::Error)
+  end
+
+  specify "should have after_commit and after_rollback respect :server option" do
+    @db.transaction(:server=>:test){@db.after_commit(:server=>:test){@db.execute('foo', :server=>:test)}}
+    @db.sqls.should == ['BEGIN -- test', 'COMMIT -- test', 'foo -- test']
+    @db.transaction(:server=>:test){@db.after_rollback(:server=>:test){@db.execute('foo', :server=>:test)}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN -- test', 'ROLLBACK -- test', 'foo -- test']
+  end
+
+  specify "should execute after_commit outside transactions" do
+    @db.after_commit{@db.execute('foo')}
+    @db.sqls.should == ['foo']
+  end
+
+  specify "should ignore after_rollback outside transactions" do
+    @db.after_rollback{@db.execute('foo')}
+    @db.sqls.should == []
+  end
+
+  specify "should support after_commit inside transactions" do
+    @db.transaction{@db.after_commit{@db.execute('foo')}}
+    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo']
+  end
+
+  specify "should support after_rollback inside transactions" do
+    @db.transaction{@db.after_rollback{@db.execute('foo')}}
+    @db.sqls.should == ['BEGIN', 'COMMIT']
+  end
+
+  specify "should not call after_commit if the transaction rolls back" do
+    @db.transaction{@db.after_commit{@db.execute('foo')}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+  end
+
+  specify "should call after_rollback if the transaction rolls back" do
+    @db.transaction{@db.after_rollback{@db.execute('foo')}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo']
+  end
+
+  specify "should call multiple after_commit blocks in order if called inside transactions" do
+    @db.transaction{@db.after_commit{@db.execute('foo')}; @db.after_commit{@db.execute('bar')}}
+    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo', 'bar']
+  end
+
+  specify "should call multiple after_rollback blocks in order if called inside transactions" do
+    @db.transaction{@db.after_rollback{@db.execute('foo')}; @db.after_rollback{@db.execute('bar')}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo', 'bar']
+  end
+
+  specify "should support after_commit inside nested transactions" do
+    @db.transaction{@db.transaction{@db.after_commit{@db.execute('foo')}}}
+    @db.sqls.should == ['BEGIN', 'COMMIT', 'foo']
+  end
+
+  specify "should support after_rollback inside nested transactions" do
+    @db.transaction{@db.transaction{@db.after_rollback{@db.execute('foo')}}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'foo']
+  end
+
+  specify "should raise an error if you attempt to use after_commit inside a prepared transaction" do
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{@db.execute('foo')}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+  end
+
+  specify "should raise an error if you attempt to use after_rollback inside a prepared transaction" do
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{@db.execute('foo')}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
   end
 end
 
-describe "Database#transaction with savepoints" do
+describe "Database#transaction with savepoint support" do
   before do
-    @db = Dummy3Database.new{Dummy3Database::DummyConnection.new(@db)}
+    @db = Sequel.mock(:servers=>{:test=>{}})
+  end
+
+  it_should_behave_like "Database#transaction"
+
+  specify "should support after_commit inside savepoints" do
     @db.meta_def(:supports_savepoints?){true}
+    @db.transaction do
+      @db.after_commit{@db.execute('foo')}
+      @db.transaction(:savepoint=>true){@db.after_commit{@db.execute('bar')}}
+      @db.after_commit{@db.execute('baz')}
+    end
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT', 'foo', 'bar', 'baz']
+  end
+
+  specify "should support after_rollback inside savepoints" do
+    @db.meta_def(:supports_savepoints?){true}
+    @db.transaction do
+      @db.after_rollback{@db.execute('foo')}
+      @db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('bar')}}
+      @db.after_rollback{@db.execute('baz')}
+      raise Sequel::Rollback
+    end
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'RELEASE SAVEPOINT autopoint_1', 'ROLLBACK', 'foo', 'bar', 'baz']
+  end
+
+  specify "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
+    @db.meta_def(:supports_savepoints?){true}
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+  end
+
+  specify "should raise an error if you attempt to use after_rollback inside a savepoint in a prepared transaction" do
+    @db.meta_def(:supports_savepoints?){true}
+    @db.meta_def(:supports_prepared_transactions?){true}
+    proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+  end
+end
+  
+describe "Database#transaction without savepoint support" do
+  before do
+    @db = Sequel.mock(:servers=>{:test=>{}})
+    @db.meta_def(:supports_savepoints?){false}
+  end
+
+  it_should_behave_like "Database#transaction"
+end
+  
+describe "Sequel.transaction" do
+  before do
+    @sqls = []
+    @db1 = Sequel.mock(:append=>'1', :sqls=>@sqls)
+    @db2 = Sequel.mock(:append=>'2', :sqls=>@sqls)
+    @db3 = Sequel.mock(:append=>'3', :sqls=>@sqls)
+  end
+  
+  specify "should run the block inside transacitons on all three databases" do
+    Sequel.transaction([@db1, @db2, @db3]){1}.should == 1
+    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
+  end
+  
+  specify "should pass options to all the blocks" do
+    Sequel.transaction([@db1, @db2, @db3], :rollback=>:always){1}.should be_nil
+    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
+  end
+  
+  specify "should handle Sequel::Rollback exceptions raised by the block to rollback on all databases" do
+    Sequel.transaction([@db1, @db2, @db3]){raise Sequel::Rollback}.should be_nil
+    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
+  end
+  
+  specify "should handle nested transactions" do
+    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3]){1}}.should == 1
+    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
+  end
+  
+  specify "should handle savepoints" do
+    Sequel.transaction([@db1, @db2, @db3]){Sequel.transaction([@db1, @db2, @db3], :savepoint=>true){1}}.should == 1
+    @sqls.should == ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3',
+      'SAVEPOINT autopoint_1 -- 1', 'SAVEPOINT autopoint_1 -- 2', 'SAVEPOINT autopoint_1 -- 3',
+      'RELEASE SAVEPOINT autopoint_1 -- 3', 'RELEASE SAVEPOINT autopoint_1 -- 2', 'RELEASE SAVEPOINT autopoint_1 -- 1',
+      'COMMIT -- 3', 'COMMIT -- 2', 'COMMIT -- 1']
+  end
+end
+  
+describe "Database#transaction with savepoints" do
+  before do
+    @db = Sequel.mock
   end
   
   specify "should wrap the supplied block with BEGIN + COMMIT statements" do
     @db.transaction {@db.execute 'DROP TABLE test;'}
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should use savepoints if given the :savepoint option" do
     @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}}
-    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
   end
   
   specify "should not use a savepoints if no transaction is in progress" do
     @db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should reuse the current transaction if no :savepoint option is given" do
     @db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should handle returning inside of the block by committing" do
@@ -832,7 +928,7 @@ describe "Database#transaction with savepoints" do
       end
     end
     @db.ret_commit
-    @db.sql.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
   end
   
   specify "should handle returning inside of a savepoint by committing" do
@@ -846,34 +942,34 @@ describe "Database#transaction with savepoints" do
       end
     end
     @db.ret_commit
-    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
   end
   
   specify "should issue ROLLBACK if an exception is raised, and re-raise" do
     @db.transaction {@db.execute 'DROP TABLE test'; raise RuntimeError} rescue nil
-    @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
     
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
   
   specify "should issue ROLLBACK SAVEPOINT if an exception is raised inside a savepoint, and re-raise" do
     @db.transaction{@db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test'; raise RuntimeError}} rescue nil
-    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test', 'ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
     
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
   
-  specify "should issue ROLLBACK if Sequel::Rollback is called in the transaction" do
+  specify "should issue ROLLBACK if Sequel::Rollback is raised in the transaction" do
     @db.transaction do
       @db.drop_table(:a)
       raise Sequel::Rollback
       @db.drop_table(:b)
     end
     
-    @db.sql.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE a', 'ROLLBACK']
   end
   
-  specify "should issue ROLLBACK SAVEPOINT if Sequel::Rollback is called in a savepoint" do
+  specify "should issue ROLLBACK SAVEPOINT if Sequel::Rollback is raised in a savepoint" do
     @db.transaction do
       @db.transaction(:savepoint=>true) do
         @db.drop_table(:a)
@@ -882,7 +978,7 @@ describe "Database#transaction with savepoints" do
       @db.drop_table(:b)
     end
     
-    @db.sql.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'DROP TABLE b', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE a', 'ROLLBACK TO SAVEPOINT autopoint_1', 'DROP TABLE b', 'COMMIT']
   end
   
   specify "should raise database errors when commiting a transaction as Sequel::DatabaseError" do
@@ -898,37 +994,28 @@ end
 
 describe "A Database adapter with a scheme" do
   before do
-    class CCC < Sequel::Database
-      if defined?(DISCONNECTS)
-        DISCONNECTS.clear
-      else
-        DISCONNECTS = []
-      end
-      set_adapter_scheme :ccc
-      def disconnect
-        DISCONNECTS << self
-      end
-    end
+    @ccc = Class.new(Sequel::Database)
+    @ccc.send(:set_adapter_scheme, :ccc)
   end
 
   specify "should be registered in the ADAPTER_MAP" do
-    Sequel::ADAPTER_MAP[:ccc].should == CCC
+    Sequel::ADAPTER_MAP[:ccc].should == @ccc
   end
   
   specify "should give the database_type as the adapter scheme by default" do
-    CCC.new.database_type.should == :ccc
+    @ccc.new.database_type.should == :ccc
   end
   
   specify "should be instantiated when its scheme is specified" do
     c = Sequel::Database.connect('ccc://localhost/db')
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:host].should == 'localhost'
     c.opts[:database].should == 'db'
   end
   
   specify "should be accessible through Sequel.connect" do
     c = Sequel.connect 'ccc://localhost/db'
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:host].should == 'localhost'
     c.opts[:database].should == 'db'
   end
@@ -940,7 +1027,7 @@ describe "A Database adapter with a scheme" do
     returnValue = 'anything'
 
     p = proc do |c|
-      c.should be_a_kind_of(CCC)
+      c.should be_a_kind_of(@ccc)
       c.opts[:host].should == 'localhost'
       c.opts[:database].should == 'db'
       z = y
@@ -948,15 +1035,22 @@ describe "A Database adapter with a scheme" do
       x = c
       returnValue
     end
+
+    @ccc.class_eval do
+      self::DISCONNECTS = []
+      def disconnect
+        self.class::DISCONNECTS << self
+      end
+    end
     Sequel::Database.connect('ccc://localhost/db', &p).should == returnValue
-    CCC::DISCONNECTS.should == [x]
+    @ccc::DISCONNECTS.should == [x]
 
     Sequel.connect('ccc://localhost/db', &p).should == returnValue
-    CCC::DISCONNECTS.should == [y, x]
+    @ccc::DISCONNECTS.should == [y, x]
 
     Sequel.send(:def_adapter_method, :ccc)
     Sequel.ccc('db', :host=>'localhost', &p).should == returnValue
-    CCC::DISCONNECTS.should == [z, y, x]
+    @ccc::DISCONNECTS.should == [z, y, x]
   end
 
   specify "should be accessible through Sequel.<adapter>" do
@@ -967,31 +1061,31 @@ describe "A Database adapter with a scheme" do
     
     c = Sequel.ccc('mydb')
     p = proc{c.opts.delete_if{|k,v| k == :disconnection_proc || k == :single_threaded}}
-    c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :adapter_class=>CCC}
+    c.should be_a_kind_of(@ccc)
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :adapter_class=>@ccc}
     
     c = Sequel.ccc('mydb', :host => 'localhost')
-    c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>CCC}
+    c.should be_a_kind_of(@ccc)
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>@ccc}
     
     c = Sequel.ccc
-    c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :adapter_class=>CCC}
+    c.should be_a_kind_of(@ccc)
+    p.call.should == {:adapter=>:ccc, :adapter_class=>@ccc}
     
     c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
-    c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>CCC}
+    c.should be_a_kind_of(@ccc)
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>@ccc}
   end
   
   specify "should be accessible through Sequel.connect with options" do
     c = Sequel.connect(:adapter => :ccc, :database => 'mydb')
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:adapter].should == :ccc
   end
 
   specify "should be accessible through Sequel.connect with URL parameters" do
     c = Sequel.connect 'ccc:///db?host=/tmp&user=test'
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:host].should == '/tmp'
     c.opts[:database].should == 'db'
     c.opts[:user].should == 'test'
@@ -999,14 +1093,14 @@ describe "A Database adapter with a scheme" do
   
   specify "should have URL parameters take precedence over fixed URL parts" do
     c = Sequel.connect 'ccc://localhost/db?host=a&database=b'
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:host].should == 'a'
     c.opts[:database].should == 'b'
   end
   
   specify "should have hash options take predence over URL parameters or parts" do
     c = Sequel.connect 'ccc://localhost/db?host=/tmp', :host=>'a', :database=>'b', :user=>'c'
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:host].should == 'a'
     c.opts[:database].should == 'b'
     c.opts[:user].should == 'c'
@@ -1014,7 +1108,7 @@ describe "A Database adapter with a scheme" do
 
   specify "should unescape values of URL parameters and parts" do
     c = Sequel.connect 'ccc:///d%5bb%5d?host=domain%5cinstance'
-    c.should be_a_kind_of(CCC)
+    c.should be_a_kind_of(@ccc)
     c.opts[:database].should == 'd[b]'
     c.opts[:host].should == 'domain\\instance'
   end
@@ -1129,10 +1223,6 @@ describe "A single threaded database" do
 end
 
 describe "A database" do
-  before do
-    Sequel::Database.single_threaded = false
-  end
-  
   after do
     Sequel::Database.single_threaded = false
   end
@@ -1177,11 +1267,7 @@ end
 
 describe "Database#fetch" do
   before do
-    @db = Sequel::Database.new
-    c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql); yield({:sql => sql}); end
-    end
-    @db.meta_def(:dataset) {c.new(self)}
+    @db = Sequel.mock(:fetch=>proc{|sql| {:sql => sql}})
   end
   
   specify "should create a dataset and invoke its fetch_rows method with the given sql" do
@@ -1228,143 +1314,54 @@ end
 
 describe "Database#[]" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
   end
   
   specify "should return a dataset when symbols are given" do
     ds = @db[:items]
-    ds.class.should == Sequel::Dataset
+    ds.should be_a_kind_of(Sequel::Dataset)
     ds.opts[:from].should == [:items]
   end
   
   specify "should return a dataset when a string is given" do
-    c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql); yield({:sql => sql}); end
-    end
-    @db.meta_def(:dataset) {c.new(self)}
-
+    @db.fetch = proc{|sql| {:sql=>sql}}
     sql = nil
     @db['select * from xyz where x = ? and y = ?', 15, 'abc'].each {|r| sql = r[:sql]}
     sql.should == "select * from xyz where x = 15 and y = 'abc'"
   end
 end
 
-describe "Database#create_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL with raw SQL" do
-    @db.create_view :test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
-    @db.sqls.clear
-    @db.create_view :test.identifier, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
-  end
-  
-  specify "should construct proper SQL with dataset" do
-    @db.create_view :test, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.sqls.clear
-    @db.create_view :test.qualify(:sch), @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE VIEW sch.test AS SELECT a, b FROM items ORDER BY c']
-  end
-end
-
-describe "Database#create_or_replace_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL with raw SQL" do
-    @db.create_or_replace_view :test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT * FROM xyz']
-    @db.sqls.clear
-    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE OR REPLACE VIEW sch.test AS SELECT * FROM xyz']
-  end
-
-  specify "should construct proper SQL with dataset" do
-    @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.sqls.clear
-    @db.create_or_replace_view :test.identifier, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
-  end
-end
-
-describe "Database#drop_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_view :test
-    @db.drop_view :test.identifier
-    @db.drop_view :sch__test
-    @db.drop_view :test.qualify(:sch)
-    @db.sqls.should == ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
-  end
-end
-
-describe "Database#alter_table_sql" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should raise error for an invalid op" do
-    proc {@db.send(:alter_table_sql, :mau, :op => :blah)}.should raise_error(Sequel::Error)
-  end
-end
-
 describe "Database#inspect" do
-  before do
-    @db = DummyDatabase.new
-    
-    @db.meta_def(:uri) {'blah://blahblah/blah'}
-  end
-  
   specify "should include the class name and the connection url" do
-    @db.inspect.should == '#<DummyDatabase: "blah://blahblah/blah">'
+    Sequel.connect('mock://foo/bar').inspect.should == '#<Sequel::Mock::Database: "mock://foo/bar">'
   end
 end
 
 describe "Database#get" do
   before do
-    @c = Class.new(DummyDatabase) do
-      def dataset
-        ds = super
-        def ds.get(*args, &block)
-          @db.execute select(*args, &block).sql
-          args
-        end
-        ds
-      end
-    end
-    
-    @db = @c.new
+    @db = Sequel.mock(:fetch=>{:a=>1})
   end
   
   specify "should use Dataset#get to get a single value" do
-    @db.get(1).should == [1]
-    @db.sqls.last.should == 'SELECT 1'
+    @db.get(1).should == 1
+    @db.sqls.should == ['SELECT 1 LIMIT 1']
     
     @db.get(:version.sql_function)
-    @db.sqls.last.should == 'SELECT version()'
+    @db.sqls.should == ['SELECT version() LIMIT 1']
   end
 
   specify "should accept a block" do
     @db.get{1}
-    @db.sqls.last.should == 'SELECT 1'
+    @db.sqls.should == ['SELECT 1 LIMIT 1']
     
     @db.get{version(1)}
-    @db.sqls.last.should == 'SELECT version(1)'
+    @db.sqls.should == ['SELECT version(1) LIMIT 1']
   end
 end
 
 describe "Database#call" do
   specify "should call the prepared statement with the given name" do
-    db = MockDatabase.new
+    db = Sequel.mock(:fetch=>{:id => 1, :x => 1})
     db[:items].prepare(:select, :select_all)
     db.call(:select_all).should == [{:id => 1, :x => 1}]
     db[:items].filter(:n=>:$n).prepare(:select, :select_n)
@@ -1376,146 +1373,129 @@ end
 describe "Database#server_opts" do
   specify "should return the general opts if no :servers option is used" do
     opts = {:host=>1, :database=>2}
-    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 1
+    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 1
   end
   
   specify "should return the general opts if entry for the server is present in the :servers option" do
     opts = {:host=>1, :database=>2, :servers=>{}}
-    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 1
+    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 1
   end
   
   specify "should return the general opts merged with the specific opts if given as a hash" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}}}
-    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 3
+    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 3
   end
   
   specify "should return the sgeneral opts merged with the specific opts if given as a proc" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>proc{|db| {:host=>4}}}}
-    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 4
+    Sequel::Database.new(opts).send(:server_opts, :server1)[:host].should == 4
   end
   
   specify "should raise an error if the specific opts is not a proc or hash" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>2}}
-    proc{MockDatabase.new(opts).send(:server_opts, :server1)}.should raise_error(Sequel::Error)
+    proc{Sequel::Database.new(opts).send(:server_opts, :server1)}.should raise_error(Sequel::Error)
   end
 end
 
 describe "Database#add_servers" do
   before do
-    @db = MockDatabase.new(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
-    def @db.connect(server)
-      server_opts(server)
-    end
-    def @db.disconnect_connection(c)
-    end
+    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
   end
 
   specify "should add new servers to the connection pool" do
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 1}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
 
     @db.add_servers(:server2=>{:host=>6})
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 6}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 6}
 
     @db.disconnect
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 6}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 6}
   end
 
   specify "should replace options for future connections to existing servers" do
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 1}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
 
     @db.add_servers(:default=>proc{{:host=>4}}, :server1=>{:host=>8})
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 1}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
 
     @db.disconnect
-    @db.synchronize{|c| c[:host].should == 4}
-    @db.synchronize(:server1){|c| c[:host].should == 8}
-    @db.synchronize(:server2){|c| c[:host].should == 4}
+    @db.synchronize{|c| c.opts[:host].should == 4}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 8}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 4}
   end
 end
 
 describe "Database#remove_servers" do
   before do
-    @db = MockDatabase.new(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
-    def @db.connect(server)
-      server_opts(server)
-    end
-    def @db.disconnect_connection(c)
-    end
+    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
   end
 
   specify "should remove servers from the connection pool" do
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 3}
-    @db.synchronize(:server2){|c| c[:host].should == 4}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 3}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 4}
 
     @db.remove_servers(:server1, :server2)
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 1}
-    @db.synchronize(:server2){|c| c[:host].should == 1}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 1}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
   end
   
   specify "should accept arrays of symbols" do
     @db.remove_servers([:server1, :server2])
-    @db.synchronize{|c| c[:host].should == 1}
-    @db.synchronize(:server1){|c| c[:host].should == 1}
-    @db.synchronize(:server2){|c| c[:host].should == 1}
+    @db.synchronize{|c| c.opts[:host].should == 1}
+    @db.synchronize(:server1){|c| c.opts[:host].should == 1}
+    @db.synchronize(:server2){|c| c.opts[:host].should == 1}
   end
 
   specify "should allow removal while connections are still open" do
     @db.synchronize do |c1|
-      c1[:host].should == 1
+      c1.opts[:host].should == 1
       @db.synchronize(:server1) do |c2|
-        c2[:host].should == 3
+        c2.opts[:host].should == 3
         @db.synchronize(:server2) do |c3|
-          c3[:host].should == 4
+          c3.opts[:host].should == 4
           @db.remove_servers(:server1, :server2)
             @db.synchronize(:server1) do |c4|
               c4.should_not == c2
               c4.should == c1
-              c4[:host].should == 1
+              c4.opts[:host].should == 1
               @db.synchronize(:server2) do |c5|
                 c5.should_not == c3
                 c5.should == c1
-                c5[:host].should == 1
+                c5.opts[:host].should == 1
               end
             end
-          c3[:host].should == 4
+          c3.opts[:host].should == 4
          end
-        c2[:host].should == 3
+        c2.opts[:host].should == 3
       end
-      c1[:host].should == 1
+      c1.opts[:host].should == 1
     end
   end
 end
 
 describe "Database#each_server with do/jdbc adapter connection string without :adapter option" do
-  before do
+  specify "should yield a separate database object for each server" do
     klass = Class.new(Sequel::Database)
-    klass.should_receive(:adapter_class).once.with(:jdbc).and_return(MockDatabase)
+    klass.should_receive(:adapter_class).once.with(:jdbc).and_return(Sequel::Mock::Database)
     @db = klass.connect('jdbc:blah:', :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
-    def @db.connect(server)
-      server_opts(server)
-    end
-    def @db.disconnect_connection(c)
-    end
-  end
 
-  specify "should yield a separate database object for each server" do
     hosts = []
     @db.each_server do |db|
       db.should be_a_kind_of(Sequel::Database)
       db.should_not == @db
-      db.opts[:adapter_class].should == MockDatabase
+      db.opts[:adapter_class].should == Sequel::Mock::Database
       db.opts[:database].should == 2
       hosts << db.opts[:host]
     end
@@ -1525,12 +1505,7 @@ end
 
 describe "Database#each_server" do
   before do
-    @db = Sequel.connect(:adapter=>:mock, :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
-    def @db.connect(server)
-      server_opts(server)
-    end
-    def @db.disconnect_connection(c)
-    end
+    @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
   end
 
   specify "should yield a separate database object for each server" do
@@ -1561,21 +1536,25 @@ describe "Database#each_server" do
 end
   
 describe "Database#raise_error" do
+  before do
+    @db = Sequel.mock
+  end
+
   specify "should reraise if the exception class is not in opts[:classes]" do
     e = Class.new(StandardError)
-    proc{MockDatabase.new.send(:raise_error, e.new(''), :classes=>[])}.should raise_error(e)
+    proc{@db.send(:raise_error, e.new(''), :classes=>[])}.should raise_error(e)
   end
 
-  specify "should convert the exception to a DatabaseError if the exception class is not in opts[:classes]" do
-    proc{MockDatabase.new.send(:raise_error, Interrupt.new(''), :classes=>[Interrupt])}.should raise_error(Sequel::DatabaseError)
+  specify "should convert the exception to a DatabaseError if the exception class is in opts[:classes]" do
+    proc{@db.send(:raise_error, Interrupt.new(''), :classes=>[Interrupt])}.should raise_error(Sequel::DatabaseError)
   end
 
   specify "should convert the exception to a DatabaseError if opts[:classes] if not present" do
-    proc{MockDatabase.new.send(:raise_error, Interrupt.new(''))}.should raise_error(Sequel::DatabaseError)
+    proc{@db.send(:raise_error, Interrupt.new(''))}.should raise_error(Sequel::DatabaseError)
   end
   
   specify "should convert the exception to a DatabaseDisconnectError if opts[:disconnect] is true" do
-    proc{MockDatabase.new.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.should raise_error(Sequel::DatabaseDisconnectError)
+    proc{@db.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.should raise_error(Sequel::DatabaseDisconnectError)
   end
 end
 
@@ -1594,6 +1573,303 @@ describe "Database#typecast_value" do
     proc{@db.typecast_value(:datetime, 4)}.should raise_error(Sequel::InvalidValue)
   end
 
+  specify "should handle integers with leading 0 as base 10" do
+    @db.typecast_value(:integer, "013").should == 13
+    @db.typecast_value(:integer, "08").should == 8
+    @db.typecast_value(:integer, "000013").should == 13
+    @db.typecast_value(:integer, "000008").should == 8
+  end
+
+  specify "should handle integers with leading 0x as base 16" do
+    @db.typecast_value(:integer, "0x013").should == 19
+    @db.typecast_value(:integer, "0x80").should == 128
+  end
+
+  specify "should typecast blobs as as Sequel::SQL::Blob" do
+    v = @db.typecast_value(:blob, "0x013")
+    v.should be_a_kind_of(Sequel::SQL::Blob)
+    v.should == Sequel::SQL::Blob.new("0x013")
+    @db.typecast_value(:blob, v).object_id.should == v.object_id
+  end
+
+  specify "should typecast boolean values to true, false, or nil" do
+    @db.typecast_value(:boolean, false).should be_false
+    @db.typecast_value(:boolean, 0).should be_false
+    @db.typecast_value(:boolean, "0").should be_false
+    @db.typecast_value(:boolean, 'f').should be_false
+    @db.typecast_value(:boolean, 'false').should be_false
+    @db.typecast_value(:boolean, true).should be_true
+    @db.typecast_value(:boolean, 1).should be_true
+    @db.typecast_value(:boolean, '1').should be_true
+    @db.typecast_value(:boolean, 't').should be_true
+    @db.typecast_value(:boolean, 'true').should be_true
+    @db.typecast_value(:boolean, '').should be_nil
+  end
+
+  specify "should typecast date values to Date" do
+    @db.typecast_value(:date, Date.today).should == Date.today
+    @db.typecast_value(:date, DateTime.now).should == Date.today
+    @db.typecast_value(:date, Time.now).should == Date.today
+    @db.typecast_value(:date, Date.today.to_s).should == Date.today
+    @db.typecast_value(:date, :year=>Date.today.year, :month=>Date.today.month, :day=>Date.today.day).should == Date.today
+  end
+
+  specify "should have Sequel.application_to_database_timestamp convert to Sequel.database_timezone" do
+    begin
+      t = Time.utc(2011, 1, 2, 3, 4, 5) # UTC Time
+      t2 = Time.mktime(2011, 1, 2, 3, 4, 5) # Local Time
+      t3 = Time.utc(2011, 1, 2, 3, 4, 5) - (t - t2) # Local Time in UTC Time
+      t4 = Time.mktime(2011, 1, 2, 3, 4, 5) + (t - t2) # UTC Time in Local Time
+      Sequel.application_timezone = :utc
+      Sequel.database_timezone = :local
+      Sequel.application_to_database_timestamp(t).should == t4
+      Sequel.application_timezone = :local
+      Sequel.database_timezone = :utc
+      Sequel.application_to_database_timestamp(t2).should == t3
+    ensure
+      Sequel.default_timezone = nil
+    end
+  end
+
+  specify "should have Database#to_application_timestamp convert values using the database's timezone" do
+    begin
+      t = Time.utc(2011, 1, 2, 3, 4, 5) # UTC Time
+      t2 = Time.mktime(2011, 1, 2, 3, 4, 5) # Local Time
+      t3 = Time.utc(2011, 1, 2, 3, 4, 5) - (t - t2) # Local Time in UTC Time
+      t4 = Time.mktime(2011, 1, 2, 3, 4, 5) + (t - t2) # UTC Time in Local Time
+      Sequel.default_timezone = :utc
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t
+      Sequel.database_timezone = :local
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t3
+      Sequel.default_timezone = :local
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t2
+      Sequel.database_timezone = :utc
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t4
+
+      Sequel.default_timezone = :utc
+      @db.timezone = :local
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t3
+      Sequel.default_timezone = :local
+      @db.timezone = :utc
+      @db.to_application_timestamp('2011-01-02 03:04:05').should == t4
+    ensure
+      Sequel.default_timezone = nil
+    end
+  end
+
+  specify "should typecast datetime values to Sequel.datetime_class with correct timezone handling" do
+    t = Time.utc(2011, 1, 2, 3, 4, 5) # 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
+    dt = DateTime.civil(2011, 1, 2, 3, 4, 5)
+    r1 = defined?(Rational) ? Rational(t2.utc_offset, 86400) : t2.utc_offset/86400.0
+    r2 = defined?(Rational) ? Rational((t - t2).to_i, 86400) : (t - t2).to_i/86400.0
+    dt2 = DateTime.civil(2011, 1, 2, 3, 4, 5, r1)
+    dt3 = DateTime.civil(2011, 1, 2, 3, 4, 5) - r2
+    dt4 = DateTime.civil(2011, 1, 2, 3, 4, 5, r1) + r2
+
+    t.should == t4
+    t2.should == t3
+    dt.should == dt4
+    dt2.should == dt3
+
+    check = proc do |i, o| 
+      v = @db.typecast_value(:datetime, i)
+      v.should == o
+      if o.is_a?(Time)
+        v.utc_offset.should == o.utc_offset
+      else
+        v.offset.should == o.offset
+      end
+    end
+    begin
+      @db.typecast_value(:datetime, dt).should == t
+      @db.typecast_value(:datetime, dt2).should == t2
+      @db.typecast_value(:datetime, t).should == t
+      @db.typecast_value(:datetime, t2).should == t2
+      @db.typecast_value(:datetime, dt.to_s).should == t
+      @db.typecast_value(:datetime, dt.strftime('%F %T')).should == t2
+      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == Time.mktime(2011, 1, 2, 0, 0, 0)
+      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec).should == t2
+
+      Sequel.datetime_class = DateTime
+      @db.typecast_value(:datetime, dt).should == dt
+      @db.typecast_value(:datetime, dt2).should == dt2
+      @db.typecast_value(:datetime, t).should == dt
+      @db.typecast_value(:datetime, t2).should == dt2
+      @db.typecast_value(:datetime, dt.to_s).should == dt
+      @db.typecast_value(:datetime, dt.strftime('%F %T')).should == dt
+      @db.typecast_value(:datetime, Date.civil(2011, 1, 2)).should == DateTime.civil(2011, 1, 2, 0, 0, 0)
+      @db.typecast_value(:datetime, :year=>dt.year, :month=>dt.month, :day=>dt.day, :hour=>dt.hour, :minute=>dt.min, :second=>dt.sec).should == dt
+
+      Sequel.application_timezone = :utc
+      Sequel.typecast_timezone = :local
+      Sequel.datetime_class = Time
+      check[dt, t]
+      check[dt2, t3]
+      check[t, t]
+      check[t2, t3]
+      check[dt.to_s, t]
+      check[dt.strftime('%F %T'), 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}, t3]
+
+      Sequel.datetime_class = DateTime
+      check[dt, dt]
+      check[dt2, dt3]
+      check[t, dt]
+      check[t2, dt3]
+      check[dt.to_s, dt]
+      check[dt.strftime('%F %T'), 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}, dt3]
+
+      Sequel.typecast_timezone = :utc
+      Sequel.datetime_class = Time
+      check[dt, t]
+      check[dt2, t3]
+      check[t, t]
+      check[t2, t3]
+      check[dt.to_s, t]
+      check[dt.strftime('%F %T'), 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}, t]
+
+      Sequel.datetime_class = DateTime
+      check[dt, dt]
+      check[dt2, dt3]
+      check[t, dt]
+      check[t2, dt3]
+      check[dt.to_s, dt]
+      check[dt.strftime('%F %T'), 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}, dt]
+
+      Sequel.application_timezone = :local
+      Sequel.datetime_class = Time
+      check[dt, t4]
+      check[dt2, t2]
+      check[t, t4]
+      check[t2, t2]
+      check[dt.to_s, t4]
+      check[dt.strftime('%F %T'), 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}, t4]
+
+      Sequel.datetime_class = DateTime
+      check[dt, dt4]
+      check[dt2, dt2]
+      check[t, dt4]
+      check[t2, dt2]
+      check[dt.to_s, dt4]
+      check[dt.strftime('%F %T'), 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}, dt4]
+
+      Sequel.typecast_timezone = :local
+      Sequel.datetime_class = Time
+      check[dt, t4]
+      check[dt2, t2]
+      check[t, t4]
+      check[t2, t2]
+      check[dt.to_s, t4]
+      check[dt.strftime('%F %T'), 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}, t2]
+
+      Sequel.datetime_class = DateTime
+      check[dt, dt4]
+      check[dt2, dt2]
+      check[t, dt4]
+      check[t2, dt2]
+      check[dt.to_s, dt4]
+      check[dt.strftime('%F %T'), 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}, dt2]
+
+    ensure
+      Sequel.default_timezone = nil
+      Sequel.datetime_class = Time
+    end
+  end
+
+  specify "should handle arrays when typecasting timestamps" do
+    begin
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+
+      Sequel.datetime_class = DateTime
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000, (defined?(Rational) ? Rational(1, 2) : 0.5)]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+    ensure
+      Sequel.datetime_class = Time
+    end
+  end
+
+  specify "should handle hashes when typecasting timestamps" do
+    begin
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+
+      Sequel.datetime_class = DateTime
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+    ensure
+      Sequel.datetime_class = Time
+    end
+  end
+
+  specify "should typecast decimal values to BigDecimal" do
+    [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
+      v = @db.typecast_value(:decimal, i)
+      v.should be_a_kind_of(BigDecimal)
+      v.should == BigDecimal.new('1.0')
+    end
+  end
+
+  specify "should typecast float values to Float" do
+    [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
+      v = @db.typecast_value(:float, i)
+      v.should be_a_kind_of(Float)
+      v.should == 1.0
+    end
+  end
+
+  specify "should typecast string values to String" do
+    [1.0, '1.0', '1.0'.to_sequel_blob].each do |i|
+      v = @db.typecast_value(:string, i)
+      v.should be_an_instance_of(String)
+      v.should == "1.0"
+    end
+  end
+
+  specify "should typecast time values to SQLTime" do
+    t = Time.now
+    st = Sequel::SQLTime.local(t.year, t.month, t.day, 1, 2, 3)
+    [st, Time.utc(t.year, t.month, t.day, 1, 2, 3), Time.local(t.year, t.month, t.day, 1, 2, 3), '01:02:03', {:hour=>1, :minute=>2, :second=>3}].each do |i|
+      v = @db.typecast_value(:time, i)
+      v.should be_an_instance_of(Sequel::SQLTime)
+      v.should == st
+    end
+  end
+
+  specify "should correctly handle time value conversion to SQLTime with fractional seconds" do
+    t = Time.now
+    st = Sequel::SQLTime.local(t.year, t.month, t.day, 1, 2, 3, 500000)
+    t = Time.local(t.year, t.month, t.day, 1, 2, 3, 500000)
+    @db.typecast_value(:time, t).should == st
+  end
+
   specify "should have an underlying exception class available at wrapped_exception" do
     begin
       @db.typecast_value(:date, 'a')
@@ -1639,7 +1915,7 @@ describe "Database#blank_object?" do
 end
 
 describe "Database#schema_autoincrementing_primary_key?" do
-  specify "should whether the parsed schema row indicates a primary key" do
+  specify "should indicate whether the parsed schema row indicates a primary key" do
     m = Sequel::Database.new.method(:schema_autoincrementing_primary_key?)
     m.call(:primary_key=>true).should == true
     m.call(:primary_key=>false).should == false
@@ -1695,7 +1971,7 @@ describe "Database#column_schema_to_ruby_default" do
     db = Sequel::Database.new
     m = db.method(:column_schema_to_ruby_default)
     p = lambda{|d,t| m.call(d,t)}
-    p[nil, :integer].should == nil
+    p[nil, :integer].should be_nil
     p['1', :integer].should == 1
     p['-1', :integer].should == -1
     p['1.0', :float].should == 1.0
@@ -1715,12 +1991,12 @@ describe "Database#column_schema_to_ruby_default" do
     p["'\\a''b'", :string].should == "\\a'b"
     p["'NULL'", :string].should == "NULL"
     p["'2009-10-29'", :date].should == Date.new(2009,10,29)
-    p["CURRENT_TIMESTAMP", :date].should == nil
-    p["today()", :date].should == nil
+    p["CURRENT_TIMESTAMP", :date].should be_nil
+    p["today()", :date].should be_nil
     p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
     p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
     p["'10:20:30'", :time].should == Time.parse('10:20:30')
-    p["NaN", :float].should == nil
+    p["NaN", :float].should be_nil
 
     db.meta_def(:database_type){:postgres}
     p["''::text", :string].should == ""
@@ -1744,8 +2020,8 @@ describe "Database#column_schema_to_ruby_default" do
     p["2009-10-29", :date].should == Date.new(2009,10,29)
     p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
     p["10:20:30", :time].should == Time.parse('10:20:30')
-    p["CURRENT_DATE", :date].should == nil
-    p["CURRENT_TIMESTAMP", :datetime].should == nil
+    p["CURRENT_DATE", :date].should be_nil
+    p["CURRENT_TIMESTAMP", :datetime].should be_nil
     p["a", :enum].should == "a"
     
     db.meta_def(:database_type){:mssql}