sequel 3.40.0 → 3.41.0

data/spec/adapters/postgres_spec.rb

@@ -6,14 +6,6 @@ unless defined?(POSTGRES_DB)
 end
 INTEGRATION_DB = POSTGRES_DB unless defined?(INTEGRATION_DB)
 
-# Automatic parameterization changes the SQL used, so don't check
-# for expected SQL if it is being used.
-if defined?(Sequel::Postgres::AutoParameterize)
-  check_sqls = false
-else
-  check_sqls = true
-end
-
 def POSTGRES_DB.sqls
   (@sqls ||= [])
 end
@@ -25,6 +17,37 @@ POSTGRES_DB.loggers << logger
 
 #POSTGRES_DB.instance_variable_set(:@server_version, 80200)
 
+describe "PostgreSQL", '#create_table' do
+  before do
+    @db = POSTGRES_DB
+    POSTGRES_DB.sqls.clear
+  end
+  after do
+    @db.drop_table?(:tmp_dolls)
+    @db.drop_table?(:unlogged_dolls)
+  end
+
+  specify "should create a temporary table" do
+    @db.create_table(:tmp_dolls, :temp => true){text :name}
+    check_sqls do
+      @db.sqls.should == ['CREATE TEMPORARY TABLE "tmp_dolls" ("name" text)']
+    end
+  end
+
+  specify "should create an unlogged table" do
+    @db.create_table(:unlogged_dolls, :unlogged => true){text :name}
+    check_sqls do
+      @db.sqls.should == ['CREATE UNLOGGED TABLE "unlogged_dolls" ("name" text)']
+    end
+  end
+
+  specify "should not allow to pass both :temp and :unlogged" do
+    proc do
+      @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
+    end.should raise_error(Sequel::Error, "can't provide both :temp and :unlogged to create_table")
+  end
+end
+
 describe "A PostgreSQL database" do
   before(:all) do
     @db = POSTGRES_DB
@@ -74,18 +97,18 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.select(:name).sql.should == 'SELECT "name" FROM "test"'
-    @d.select(Sequel.lit('COUNT(*)')).sql.should == 'SELECT COUNT(*) FROM "test"'
-    @d.select(Sequel.function(:max, :value)).sql.should == 'SELECT max("value") FROM "test"'
-    @d.select(Sequel.function(:NOW)).sql.should == 'SELECT NOW() FROM "test"'
-    @d.select(Sequel.function(:max, :items__value)).sql.should == 'SELECT max("items"."value") FROM "test"'
-    @d.order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
-    @d.select(Sequel.lit('test.name AS item_name')).sql.should == 'SELECT test.name AS item_name FROM "test"'
-    @d.select(Sequel.lit('"name"')).sql.should == 'SELECT "name" FROM "test"'
-    @d.select(Sequel.lit('max(test."name") AS "max_name"')).sql.should == 'SELECT max(test."name") AS "max_name" FROM "test"'
-    @d.insert_sql(:x => :y).should =~ /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
-
-    if check_sqls
+    check_sqls do
+      @d.select(:name).sql.should == 'SELECT "name" FROM "test"'
+      @d.select(Sequel.lit('COUNT(*)')).sql.should == 'SELECT COUNT(*) FROM "test"'
+      @d.select(Sequel.function(:max, :value)).sql.should == 'SELECT max("value") FROM "test"'
+      @d.select(Sequel.function(:NOW)).sql.should == 'SELECT NOW() FROM "test"'
+      @d.select(Sequel.function(:max, :items__value)).sql.should == 'SELECT max("items"."value") FROM "test"'
+      @d.order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
+      @d.select(Sequel.lit('test.name AS item_name')).sql.should == 'SELECT test.name AS item_name FROM "test"'
+      @d.select(Sequel.lit('"name"')).sql.should == 'SELECT "name" FROM "test"'
+      @d.select(Sequel.lit('max(test."name") AS "max_name"')).sql.should == 'SELECT max(test."name") AS "max_name" FROM "test"'
+      @d.insert_sql(:x => :y).should =~ /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
+
       @d.select(Sequel.function(:test, :abc, 'hello')).sql.should == "SELECT test(\"abc\", 'hello') FROM \"test\""
       @d.select(Sequel.function(:test, :abc__def, 'hello')).sql.should == "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
       @d.select(Sequel.function(:test, :abc__def, 'hello').as(:x2)).sql.should == "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
@@ -94,10 +117,12 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.reverse_order(:name).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
-    @d.reverse_order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC'
-    @d.reverse_order(:name, Sequel.desc(:test)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
-    @d.reverse_order(Sequel.desc(:name), :test).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
+    check_sqls do
+      @d.reverse_order(:name).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC'
+      @d.reverse_order(Sequel.desc(:name)).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC'
+      @d.reverse_order(:name, Sequel.desc(:test)).sql.should == 'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
+      @d.reverse_order(Sequel.desc(:name), :test).sql.should == 'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
+    end
   end
 
   specify "should support regexps" do
@@ -175,17 +200,23 @@ describe "A PostgreSQL dataset" do
 
     @db.sqls.clear
     @db.transaction(:synchronous=>nil){}
-    @db.sqls.should == ['BEGIN', 'COMMIT']
+    check_sqls do
+      @db.sqls.should == ['BEGIN', 'COMMIT']
+    end
 
     if @db.server_version >= 90100
       @db.sqls.clear
       @db.transaction(:synchronous=>:local){}
-      @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = local"]
+      check_sqls do
+        @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = local"]
+      end
 
       if @db.server_version >= 90200
         @db.sqls.clear
         @db.transaction(:synchronous=>:remote_write){}
-        @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = remote_write"]
+        check_sqls do
+          @db.sqls.grep(/synchronous/).should == ["SET LOCAL synchronous_commit = remote_write"]
+        end
       end
     end
   end
@@ -210,28 +241,36 @@ describe "A PostgreSQL dataset" do
 
   specify "should support creating indexes concurrently" do
     @db.add_index :test, [:name, :value], :concurrently=>true
-    @db.sqls.should == ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")'] if check_sqls
+    check_sqls do
+      @db.sqls.should == ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")']
+    end
   end
 
   specify "should support dropping indexes only if they already exist" do
     @db.add_index :test, [:name, :value], :name=>'tnv1'
     @db.sqls.clear
     @db.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
-    @db.sqls.should == ['DROP INDEX IF EXISTS "tnv1"']
+    check_sqls do
+      @db.sqls.should == ['DROP INDEX IF EXISTS "tnv1"']
+    end
   end
 
   specify "should support CASCADE when dropping indexes" do
     @db.add_index :test, [:name, :value], :name=>'tnv2'
     @db.sqls.clear
     @db.drop_index :test, [:name, :value], :cascade=>true, :name=>'tnv2'
-    @db.sqls.should == ['DROP INDEX "tnv2" CASCADE']
+    check_sqls do
+      @db.sqls.should == ['DROP INDEX "tnv2" CASCADE']
+    end
   end
 
   specify "should support dropping indexes concurrently" do
     @db.add_index :test, [:name, :value], :name=>'tnv2'
     @db.sqls.clear
     @db.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
-    @db.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
+    check_sqls do
+      @db.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
+    end
   end if POSTGRES_DB.server_version >= 90200
 
   specify "#lock should lock table if inside a transaction" do
@@ -511,19 +550,23 @@ describe "A PostgreSQL database" do
 
   specify "should support opclass specification" do
     @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
-    @db.sqls.should == [
-    'CREATE TABLE "posts" ("title" text, "body" text, "user_id" integer)',
-    'CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+      'CREATE TABLE "posts" ("title" text, "body" text, "user_id" integer)',
+      'CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)'
+      ]
+    end
   end
 
   specify "should support fulltext indexes and searching" do
     @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
-    @db.sqls.should == [
-      %{CREATE TABLE "posts" ("title" text, "body" text)},
-      %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
-      %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
-    ] if check_sqls
+    check_sqls do
+      @db.sqls.should == [
+        %{CREATE TABLE "posts" ("title" text, "body" text)},
+        %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
+        %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
+      ]
+    end
 
     @db[:posts].insert(:title=>'ruby rails', :body=>'yowsa')
     @db[:posts].insert(:title=>'sequel', :body=>'ruby')
@@ -533,10 +576,12 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.should == [:title=>'ruby rails', :body=>'yowsa']
     @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.should == [{:title=>'ruby scooby', :body=>'x'}]
-    @db.sqls.should == [
-      %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('simple'::regconfig, 'rails'))},
-      %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple'::regconfig, 'yowsa | rails'))},
-      %{SELECT * FROM "posts" WHERE (to_tsvector('french'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('french'::regconfig, 'scooby'))}] if check_sqls
+    check_sqls do
+      @db.sqls.should == [
+        %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('simple'::regconfig, 'rails'))},
+        %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple'::regconfig, 'yowsa | rails'))},
+        %{SELECT * FROM "posts" WHERE (to_tsvector('french'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('french'::regconfig, 'scooby'))}]
+    end
 
     @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
@@ -544,42 +589,52 @@ describe "A PostgreSQL database" do
 
   specify "should support spatial indexes" do
     @db.create_table(:posts){box :geom; spatial_index [:geom]}
-    @db.sqls.should == [
-      'CREATE TABLE "posts" ("geom" box)',
-      'CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        'CREATE TABLE "posts" ("geom" box)',
+        'CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")'
+      ]
+    end
   end
 
   specify "should support indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'hash'}
-    @db.sqls.should == [
-      'CREATE TABLE "posts" ("title" varchar(5))',
-      'CREATE INDEX "posts_title_index" ON "posts" USING hash ("title")'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        'CREATE TABLE "posts" ("title" varchar(5))',
+        'CREATE INDEX "posts_title_index" ON "posts" USING hash ("title")'
+      ]
+    end
   end
 
   specify "should support unique indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true}
-    @db.sqls.should == [
-      'CREATE TABLE "posts" ("title" varchar(5))',
-      'CREATE UNIQUE INDEX "posts_title_index" ON "posts" USING btree ("title")'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        'CREATE TABLE "posts" ("title" varchar(5))',
+        'CREATE UNIQUE INDEX "posts_title_index" ON "posts" USING btree ("title")'
+      ]
+    end
   end
 
   specify "should support partial indexes" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
-    @db.sqls.should == [
-      'CREATE TABLE "posts" ("title" varchar(5))',
-      'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        'CREATE TABLE "posts" ("title" varchar(5))',
+        'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
+      ]
+    end
   end
 
   specify "should support identifiers for table names in indicies" do
     @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
-    @db.sqls.should == [
-      'CREATE TABLE "posts" ("title" varchar(5))',
-      'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        'CREATE TABLE "posts" ("title" varchar(5))',
+        'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
+      ]
+    end
   end
 
   specify "should support renaming tables" do
@@ -602,7 +657,9 @@ describe "Postgres::Dataset#import" do
 
   specify "#import should a single insert statement" do
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
+    check_sqls do
+      @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
+    end
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 
@@ -646,7 +703,9 @@ describe "Postgres::Dataset#insert" do
 
   specify "should use INSERT RETURNING" do
     @ds.insert(:value=>10).should == 1
-    @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"' if check_sqls
+    check_sqls do
+      @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"'
+    end
   end
 
   specify "should have insert_select insert the record and return the inserted record" do
@@ -1124,10 +1183,14 @@ if POSTGRES_DB.adapter_scheme == :postgres
     specify "should respect the :rows_per_fetch option" do
       @db.sqls.clear
       @ds.use_cursor.all
-      @db.sqls.length.should == 6
-      @db.sqls.clear
+      check_sqls do
+        @db.sqls.length.should == 6
+        @db.sqls.clear
+      end
       @ds.use_cursor(:rows_per_fetch=>100).all
-      @db.sqls.length.should == 15
+      check_sqls do
+        @db.sqls.length.should == 15
+      end
     end
 
     specify "should handle returning inside block" do
@@ -1396,7 +1459,7 @@ describe 'PostgreSQL special float handling' do
     @db.drop_table?(:test5)
   end
 
-  if check_sqls
+  check_sqls do
     specify 'should quote NaN' do
       nan = 0.0/0.0
       @ds.insert_sql(:value => nan).should == %q{INSERT INTO "test5" ("value") VALUES ('NaN')}

data/spec/adapters/spec_helper.rb

@@ -51,4 +51,11 @@ end
       specify(message, &block)
     end
   end
+
+  def check_sqls
+    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
+  end
+  def self.check_sqls
+    yield unless ENV['SEQUEL_NO_CHECK_SQLS']
+  end
 end

data/spec/adapters/sqlite_spec.rb

@@ -595,4 +595,37 @@ describe "A SQLite database" do
     @db.drop_column :a, :b
     @db.indexes(:a).should == {:a_a_index=>{:unique=>false, :columns=>[:a]}}
   end
-end  
+
+  specify "should have support for various #transaction modes" do
+    sqls = []
+    @db.loggers << (l=Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new)
+
+    @db.transaction(:mode => :immediate) do
+      sqls.last.should == "BEGIN IMMEDIATE TRANSACTION"
+    end
+    @db.transaction(:mode => :exclusive) do
+      sqls.last.should == "BEGIN EXCLUSIVE TRANSACTION"
+    end
+    @db.transaction(:mode => :deferred) do
+      sqls.last.should == "BEGIN DEFERRED TRANSACTION"
+    end
+    @db.transaction do
+      sqls.last.should == Sequel::Database::SQL_BEGIN
+    end
+
+    @db.transaction_mode.should == nil
+    @db.transaction_mode = :immediate
+    @db.transaction_mode.should == :immediate
+    @db.transaction do
+      sqls.last.should == "BEGIN IMMEDIATE TRANSACTION"
+    end
+    @db.transaction(:mode => :exclusive) do
+      sqls.last.should == "BEGIN EXCLUSIVE TRANSACTION"
+    end
+
+    proc {@db.transaction_mode = :invalid}.should raise_error(Sequel::Error)
+
+    @db.transaction_mode.should == :immediate
+    proc {@db.transaction(:mode => :invalid) {}}.should raise_error(Sequel::Error)
+  end
+end

data/spec/core/connection_pool_spec.rb

@@ -1,9 +1,18 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001, :max_connections=>4}
 
+mock_db = lambda do |*a, &b|
+  db = Sequel.mock
+  db.meta_def(:connect){|c| b.arity == 1 ? b.call(c) : b.call} if b
+  if b2 = a.shift
+    db.meta_def(:disconnect_connection){|c| b2.arity == 1 ? b2.call(c) : b2.call}
+  end
+  db
+end
+
 describe "An empty ConnectionPool" do
   before do
-    @cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){}
+    @cpool = Sequel::ConnectionPool.get_pool(mock_db.call, CONNECTION_POOL_DEFAULTS)
   end
 
   specify "should have no available connections" do
@@ -21,24 +30,25 @@ end
 
 describe "ConnectionPool options" do
   specify "should support string option values" do
-    cpool = Sequel::ConnectionPool.get_pool({:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'}){}
+    cpool = Sequel::ConnectionPool.get_pool(mock_db.call, {:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'})
     cpool.max_size.should == 5
     cpool.instance_variable_get(:@timeout).should == 3
     cpool.instance_variable_get(:@sleep_time).should == 0.01
   end
 
   specify "should raise an error unless size is positive" do
-    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>0)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>-10)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>'-10')}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>'0')}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>0)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>-10)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'-10')}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'0')}.should raise_error(Sequel::Error)
   end
 end
 
 describe "A connection pool handling connections" do
   before do
     @max_size = 2
-    @cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3},  :max_connections=>@max_size)) {:got_connection}
+    msp = proc{@max_size=3}
+    @cpool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){:got_connection}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size))
   end
 
   specify "#hold should increment #created_count" do
@@ -127,11 +137,11 @@ end
 describe "ConnectionPool#hold" do
   before do
     value = 0
-    @c = Class.new do
+    c = @c = Class.new do
       define_method(:initialize){value += 1}
       define_method(:value){value}
     end
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){@c.new}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{c.new}, CONNECTION_POOL_DEFAULTS)
   end
   
   specify "should pass the result of the connection maker proc to the supplied block" do
@@ -158,7 +168,8 @@ end
 describe "A connection pool with a max size of 1" do
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1)) {@invoked_count += 1; 'herro'}
+    icp = proc{@invoked_count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{icp.call; 'herro'}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1))
   end
   
   specify "should let only one thread access the connection at any time" do
@@ -229,7 +240,7 @@ end
 
 shared_examples_for "A threaded connection pool" do  
   specify "should not have all_connections yield connections allocated to other threads" do
-    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)) {@invoked_count += 1}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
     q, q1 = Queue.new, Queue.new
     t = Thread.new do
       pool.hold do |c1|
@@ -246,7 +257,7 @@ shared_examples_for "A threaded connection pool" do
   end
 
   specify "should not have all_connections yield all available connections" do
-    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)){@invoked_count += 1}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
     q, q1 = Queue.new, Queue.new
     b = []
     t = Thread.new do
@@ -270,7 +281,7 @@ shared_examples_for "A threaded connection pool" do
   specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
     x = nil
     q, q1 = Queue.new, Queue.new
-    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>1, :pool_timeout=>0)) {@invoked_count += 1}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
     t = Thread.new{pool.hold{|c| q1.push nil; q.pop}}
     q1.pop
     proc{pool.hold{|c|}}.should raise_error(Sequel::PoolTimeout)
@@ -279,7 +290,7 @@ shared_examples_for "A threaded connection pool" do
   end
   
   it "should not add a disconnected connection back to the pool if the disconnection_proc raises an error" do
-    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>1, :pool_timeout=>0, :disconnection_proc=>proc{|c| raise Sequel::Error})) {@invoked_count += 1}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| raise Sequel::Error}, &@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
     proc{pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::Error)
     pool.available_connections.length.should == 0
   end
@@ -354,7 +365,7 @@ shared_examples_for "A threaded connection pool" do
   end
 
   specify "should store connections in a queue if :connection_handling=>:queue" do
-    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:queue)){@invoked_count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:queue))
     c2 = nil
     c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
     @pool.size.should == 2
@@ -367,9 +378,9 @@ shared_examples_for "A threaded connection pool" do
   end
 
   specify "should not store connections if :connection_handling=>:disconnect" do
-    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:disconnect)){@invoked_count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:disconnect))
     d = []
-    @pool.disconnection_proc = proc{|c| d << c}
+    @pool.db.meta_def(:disconnect_connection){|c| d << c}
     c = @pool.hold do |cc|
       cc.should == 1
       Thread.new{@pool.hold{|cc2| cc2.should == 2}}.join
@@ -392,8 +403,9 @@ end
 describe "Threaded Unsharded Connection Pool" do
   before do
     @invoked_count = 0
+    @icpp = proc{@invoked_count += 1}
     @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)
-    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
   end
   
   it_should_behave_like "A threaded connection pool"
@@ -402,8 +414,9 @@ end
 describe "Threaded Sharded Connection Pool" do
   before do
     @invoked_count = 0
+    @icpp = proc{@invoked_count += 1}
     @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})
-    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
   end
 
   it_should_behave_like "A threaded connection pool"
@@ -412,7 +425,8 @@ end
 describe "ConnectionPool#disconnect" do
   before do
     @count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {{:id => @count += 1}}
+    cp = proc{@count += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{{:id => cp.call}}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{}))
     threads = []
     q, q1 = Queue.new, Queue.new
     5.times {|i| threads << Thread.new {@pool.hold {|c| q1.push nil; q.pop}}}
@@ -426,7 +440,8 @@ describe "ConnectionPool#disconnect" do
     @pool.available_connections.size.should == 5
     @pool.available_connections.each {|c| c[:id].should_not be_nil}
     conns = []
-    @pool.disconnect {|c| conns << c}
+    @pool.db.meta_def(:disconnect_connection){|c| conns << c}
+    @pool.disconnect
     conns.size.should == 5
   end
   
@@ -442,7 +457,8 @@ describe "ConnectionPool#disconnect" do
       @pool.available_connections.size.should == 4
       @pool.available_connections.each {|c| c.should_not be(conn)}
       conns = []
-      @pool.disconnect {|c| conns << c}
+      @pool.db.meta_def(:disconnect_connection){|c| conns << c}
+      @pool.disconnect
       conns.size.should == 4
       @pool.size.should == 1
     end
@@ -452,8 +468,8 @@ end
 
 describe "A connection pool with multiple servers" do
   before do
-    @invoked_counts = Hash.new(0)
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    ic = @invoked_counts = Hash.new(0)
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
   end
   
   specify "#all_connections should return connections for all servers" do
@@ -494,7 +510,8 @@ describe "A connection pool with multiple servers" do
   end
 
   specify "should support a :servers_hash option used for converting the server argument" do
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new(:read_only), :servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    ic = @invoked_counts
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new(:read_only), :servers=>{:read_only=>{}}))
     @pool.hold(:blah) do |c1|
       c1.should == "read_only1"
       @pool.hold(:blah) do |c2|
@@ -505,7 +522,7 @@ describe "A connection pool with multiple servers" do
       end
     end
 
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new{|h,k| raise Sequel::Error}, :servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new{|h,k| raise Sequel::Error}, :servers=>{:read_only=>{}}))
     proc{@pool.hold(:blah){|c1|}}.should raise_error(Sequel::Error)
   end
 
@@ -542,7 +559,8 @@ describe "A connection pool with multiple servers" do
     conns = []
     @pool.size.should == 1
     @pool.size(:read_only).should == 1
-    @pool.disconnect{|c| conns << c}
+    @pool.db.meta_def(:disconnect_connection){|c| conns << c}
+    @pool.disconnect
     conns.sort.should == %w'default1 read_only1'
     @pool.size.should == 0
     @pool.size(:read_only).should == 0
@@ -551,7 +569,7 @@ describe "A connection pool with multiple servers" do
   end
   
   specify "#add_servers should add new servers to the pool" do
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
     
     pool.hold{}
     pool.hold(:server2){}
@@ -582,7 +600,7 @@ describe "A connection pool with multiple servers" do
   end
 
   specify "#add_servers should ignore existing keys" do
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
     
     pool.allocated.length.should == 0
     pool.allocated(:server1).length.should == 0
@@ -628,7 +646,7 @@ describe "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should disconnect available connections immediately" do
-    pool = Sequel::ConnectionPool.get_pool(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :max_connections=>5, :servers=>{:server1=>{}})
     threads = []
     q, q1 = Queue.new, Queue.new
     5.times {|i| threads << Thread.new {pool.hold(:server1){|c| q1.push nil; q.pop}}}
@@ -643,7 +661,7 @@ describe "A connection pool with multiple servers" do
   
   specify "#remove_servers should disconnect connections in use as soon as they are returned to the pool" do
     dc = []
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| dc << c}){|c| c}, :servers=>{:server1=>{}})
     c1 = nil
     pool.hold(:server1) do |c|
       pool.size(:server1).should == 1
@@ -658,7 +676,7 @@ describe "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should remove server related data structures immediately" do
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
     pool.available_connections(:server1).should == []
     pool.allocated(:server1).should == {}
     pool.remove_servers([:server1])
@@ -667,14 +685,14 @@ describe "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should not allow the removal of the default server" do
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
     proc{pool.remove_servers([:server1])}.should_not raise_error
     proc{pool.remove_servers([:default])}.should raise_error(Sequel::Error)
   end
   
   specify "#remove_servers should ignore servers that have already been removed" do
     dc = []
-    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| dc << c}){|c| c}, :servers=>{:server1=>{}})
     c1 = nil
     pool.hold(:server1) do |c|
       pool.size(:server1).should == 1
@@ -694,7 +712,7 @@ ST_CONNECTION_POOL_DEFAULTS = CONNECTION_POOL_DEFAULTS.merge(:single_threaded=>t
 
 describe "SingleConnectionPool" do
   before do
-    @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS){1234}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{1234}, ST_CONNECTION_POOL_DEFAULTS)
   end
   
   specify "should provide a #hold method" do
@@ -706,7 +724,7 @@ describe "SingleConnectionPool" do
   specify "should provide a #disconnect method" do
     conn = nil
     x = nil
-    pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| conn = c})){1234}
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| conn = c}){1234}, ST_CONNECTION_POOL_DEFAULTS)
     pool.hold{|c| x = c}
     x.should == 1234
     pool.disconnect
@@ -717,7 +735,8 @@ end
 describe "A single threaded pool with multiple servers" do
   before do
     @max_size=2
-    @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
+    msp = proc{@max_size += 1}
+    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){|c| c}, ST_CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
   end
   
   specify "#all_connections should return connections for all servers" do
@@ -811,11 +830,10 @@ describe "A single threaded pool with multiple servers" do
   specify "#disconnect should disconnect from all servers" do
     @pool.hold(:read_only){}
     @pool.hold{}
-    conns = []
     @pool.conn.should == :default
     @pool.conn(:read_only).should == :read_only
-    @pool.disconnect{|c| conns << c}
-    conns.sort_by{|x| x.to_s}.should == [:default, :read_only]
+    @pool.disconnect
+    @max_size.should == 4
     @pool.conn.should == nil
     @pool.conn(:read_only).should == nil
   end
@@ -836,14 +854,18 @@ describe "A single threaded pool with multiple servers" do
 end
 
 shared_examples_for "All connection pools classes" do
+  specify "should have pool_type return a symbol" do
+    @class.new(mock_db.call{123}, {}).pool_type.should be_a_kind_of(Symbol)
+  end
+
   specify "should have all_connections yield current and available connections" do
-    p = @class.new({}){123}
+    p = @class.new(mock_db.call{123}, {})
     p.hold{|c| p.all_connections{|c1| c.should == c1}}
   end
 
   specify "should be able to modify after_connect proc after the pool is created" do
     a = []
-    p = @class.new({}){123}
+    p = @class.new(mock_db.call{123}, {})
     p.after_connect = pr = proc{|c| a << c}
     p.after_connect.should == pr
     a.should == []
@@ -851,77 +873,56 @@ shared_examples_for "All connection pools classes" do
     a.should == [123]
   end
 
-  specify "should be able to modify disconnection_proc after the pool is created" do
-    a = []
-    p = @class.new({}){123}
-    p.disconnection_proc = pr = proc{|c| a << c}
-    p.disconnection_proc.should == pr
-    p.hold{}
-    a.should == []
-    p.disconnect
-    a.should == [123]
-  end
-
   specify "should not raise an error when disconnecting twice" do
-    c = @class.new({}){123}
+    c = @class.new(mock_db.call{123}, {})
     proc{c.disconnect}.should_not raise_error
     proc{c.disconnect}.should_not raise_error
   end
   
   specify "should yield a connection created by the initialize block to hold" do
     x = nil
-    @class.new({}){123}.hold{|c| x = c}
+    @class.new(mock_db.call{123}, {}).hold{|c| x = c}
     x.should == 123
   end
   
   specify "should have the initialize block accept a shard/server argument" do
     x = nil
-    @class.new({}){|c| [c, c]}.hold{|c| x = c}
+    @class.new(mock_db.call{|c| [c, c]}, {}).hold{|c| x = c}
     x.should == [:default, :default]
   end
   
   specify "should have respect an :after_connect proc that is called with each newly created connection" do
     x = nil
-    @class.new(:after_connect=>proc{|c| x = [c, c]}){|c| 123}.hold{}
+    @class.new(mock_db.call{123}, :after_connect=>proc{|c| x = [c, c]}).hold{}
     x.should == [123, 123]
   end
   
   specify "should raise a DatabaseConnectionError if the connection raises an exception" do
-    proc{@class.new({}){|c| raise Exception}.hold{}}.should raise_error(Sequel::DatabaseConnectionError)
+    proc{@class.new(mock_db.call{|c| raise Exception}, {}).hold{}}.should raise_error(Sequel::DatabaseConnectionError)
   end
   
   specify "should raise a DatabaseConnectionError if the initialize block returns nil" do
-    proc{@class.new({}){}.hold{}}.should raise_error(Sequel::DatabaseConnectionError)
+    proc{@class.new(mock_db.call{}, {}).hold{}}.should raise_error(Sequel::DatabaseConnectionError)
   end
   
   specify "should call the disconnection_proc option if the hold block raises a DatabaseDisconnectError" do
     x = nil
-    proc{@class.new(:disconnection_proc=>proc{|c| x = c}){123}.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
+    proc{c = @class.new(mock_db.call(proc{|c| x = c}){123}).hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
     x.should == 123
   end
   
-  specify "should have a disconnect method that calls the :disconnection_proc option with the connection" do
+  specify "should have a disconnect method that disconnects the connection" do
     x = nil
-    c = @class.new(:disconnection_proc=>proc{|c| x = c}){123}
+    c = @class.new(mock_db.call(proc{|c| x = c}){123})
     c.hold{}
     x.should == nil
     c.disconnect
     x.should == 123
   end
   
-  specify "should have a disconnect method that calls the given block with the connection" do
-    x = nil
-    y = nil
-    c = @class.new(:disconnection_proc=>proc{|c| x = c}){123}
-    c.hold{}
-    c.disconnect{|c| y = c}
-    x.should == nil
-    y.should == 123
-  end
-  
   specify "should have a reentrent hold method" do
     o = Object.new
-    c = @class.new({}){o}
+    c = @class.new(mock_db.call{o}, {})
     c.hold do |x|
       x.should == o
       c.hold do |x1|
@@ -934,11 +935,11 @@ shared_examples_for "All connection pools classes" do
   end
   
   specify "should have a servers method that returns an array of shard/server symbols" do
-    @class.new({}){123}.servers.should == [:default]
+    @class.new(mock_db.call{123}, {}).servers.should == [:default]
   end
   
   specify "should have a servers method that returns an array of shard/server symbols" do
-    c = @class.new({}){123}
+    c = @class.new(mock_db.call{123}, {})
     c.size.should == 0
     c.hold{}
     c.size.should == 1
@@ -948,6 +949,9 @@ end
 Sequel::ConnectionPool::CONNECTION_POOL_MAP.keys.each do |k, v|
   opts = {:single_threaded=>k, :servers=>(v ? {} : nil)}
   describe "Connection pool with #{opts.inspect}" do
+    before(:all) do
+      Sequel::ConnectionPool.send(:get_pool, mock_db.call, opts)
+    end
     before do
       @class = Sequel::ConnectionPool.send(:connection_pool_class, opts)
     end