sequel 3.8.0 → 3.9.0

data/lib/sequel/adapters/jdbc.rb

@@ -35,35 +35,35 @@ module Sequel
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {:postgresql=>proc do |db|
-        Sequel.require 'adapters/jdbc/postgresql'
+        Sequel.ts_require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         JDBC.load_gem('postgres')
         org.postgresql.Driver
       end,
       :mysql=>proc do |db|
-        Sequel.require 'adapters/jdbc/mysql'
+        Sequel.ts_require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
-        Sequel.require 'adapters/jdbc/sqlite'
+        Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
       :oracle=>proc do |db|
-        Sequel.require 'adapters/jdbc/oracle'
+        Sequel.ts_require 'adapters/jdbc/oracle'
         db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
-        Sequel.require 'adapters/jdbc/mssql'
+        Sequel.ts_require 'adapters/jdbc/mssql'
         db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :h2=>proc do |db|
-        Sequel.require 'adapters/jdbc/h2'
+        Sequel.ts_require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
         JDBC.load_gem('h2')
         org.h2.Driver
@@ -74,7 +74,7 @@ module Sequel
     # works for PostgreSQL, MySQL, and SQLite.
     def self.load_gem(name)
       begin
-        require "jdbc/#{name}"
+        Sequel.tsk_require "jdbc/#{name}"
       rescue LoadError
         # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
       end
@@ -98,13 +98,12 @@ module Sequel
       # raise an error immediately if the connection doesn't have a
       # uri, since JDBC requires one.
       def initialize(opts)
-        @opts = opts
-        @convert_types = opts.include?(:convert_types) ? typecast_value_boolean(opts[:convert_types]) : true
+        super
+        @convert_types = @opts.include?(:convert_types) ? typecast_value_boolean(@opts[:convert_types]) : true
         raise(Error, "No connection string specified") unless uri
         if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
           prok.call(self)
         end
-        super(opts)
       end
       
       # Execute the given stored procedure with the give name. If a block is
@@ -215,7 +214,7 @@ module Sequel
       end 
 
       # All tables in this database
-      def tables
+      def tables(opts={})
         ts = []
         m = output_identifier_meth
         metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
@@ -240,11 +239,6 @@ module Sequel
         super
       end
       
-      # The JDBC adapter should not need the pool to convert exceptions.
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
-      end
-      
       # Close given adapter connections
       def disconnect_connection(c)
         c.close

data/lib/sequel/adapters/jdbc/h2.rb

@@ -101,6 +101,11 @@ module Sequel
         # H2 doesn't support JOIN USING
         def supports_join_using?
           false
+        end
+        
+        # H2 doesn't support multiple columns in IN/NOT IN
+        def supports_multiple_column_in?
+          false
         end 
 
         private

data/lib/sequel/adapters/mysql.rb

@@ -9,23 +9,6 @@ Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
-  #
-  # A class level convert_invalid_date_time accessor exists if
-  # the native adapter is used.  If set to nil or :nil, the adapter treats dates
-  # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
-  # it returns the strings as is.  It is false by default, which means that
-  # invalid dates and times will raise errors.
-  #
-  #   Sequel::MySQL.convert_invalid_date_time = nil
-  #
-  # Sequel converts the column type tinyint(1) to a boolean by default when
-  # using the native MySQL adapter.  You can turn off the conversion to use
-  # tinyint as an integer:
-  #
-  #   Sequel::MySQL.convert_tinyint_to_bool = false
-  #
-  # In most cases these settings need to be made after the adapter has been
-  # loaded, since the Sequel::MySQL module probably won't exist before then.
   module MySQL
     # Mapping of type numbers to conversion procs
     MYSQL_TYPES = {}
@@ -49,7 +32,16 @@ module Sequel
     @convert_tinyint_to_bool = true
 
     class << self
-      attr_accessor :convert_invalid_date_time, :convert_tinyint_to_bool
+      # By default, Sequel raises an exception if in invalid date or time is used.
+      # However, if this is set to nil or :nil, the adapter treats dates
+      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
+      # it returns the strings as is.  
+      attr_accessor :convert_invalid_date_time
+
+      # Sequel converts the column type tinyint(1) to a boolean by default when
+      # using the native MySQL adapter.  You can turn off the conversion by setting
+      # this to false.
+      attr_accessor :convert_tinyint_to_bool
     end
 
     # If convert_invalid_date_time is nil, :nil, or :string and
@@ -209,11 +201,6 @@ module Sequel
         :query
       end
       
-      # MySQL doesn't need the connection pool to convert exceptions.
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
-      end
-      
       # The MySQL adapter main error class is Mysql::Error
       def database_error_classes
         [Mysql::Error]

data/lib/sequel/adapters/odbc.rb

@@ -9,13 +9,13 @@ module Sequel
       DRV_NAME_GUARDS = '{%s}'.freeze
 
       def initialize(opts)
-        super(opts)
-        case opts[:db_type]
+        super
+        case @opts[:db_type]
         when 'mssql'
-          Sequel.require 'adapters/odbc/mssql'
+          Sequel.ts_require 'adapters/odbc/mssql'
           extend Sequel::ODBC::MSSQL::DatabaseMethods
         when 'progress'
-          Sequel.require 'adapters/shared/progress'
+          Sequel.ts_require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
         end
       end
@@ -50,7 +50,7 @@ module Sequel
           begin
             r = conn.run(sql)
             yield(r) if block_given?
-          rescue ::ODBC::Error => e
+          rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           ensure
             r.drop if r
@@ -64,7 +64,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             conn.do(sql)
-          rescue ::ODBC::Error => e
+          rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           end
         end
@@ -73,10 +73,6 @@ module Sequel
 
       private
       
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
-      end
-      
       def connection_execute_method
         :do
       end

data/lib/sequel/adapters/postgres.rb

@@ -254,11 +254,6 @@ module Sequel
         end
       end
 
-      # PostgreSQL doesn't need the connection pool to convert exceptions.
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
-      end
-      
       # Disconnect given connection
       def disconnect_connection(conn)
         begin

data/lib/sequel/adapters/shared/mssql.rb

@@ -183,7 +183,7 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with from output from2 where')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with into columns output values')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns from table_options join where group having order compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns into from table_options join where group having order compounds')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with table set output from where')
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
@@ -234,6 +234,11 @@ module Sequel
         naked.clone(default_server_opts(:sql=>output(nil, [:inserted.*]).insert_sql(*values))).single_record unless opts[:disable_insert_output]
       end
 
+      # Specify a table for a SELECT ... INTO query.
+      def into(table)
+        clone(:into => table)
+      end
+
       # MSSQL uses a UNION ALL statement to insert multiple values at once.
       def multi_insert_sql(columns, values)
         [insert_sql(columns, LiteralString.new(values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")))]
@@ -285,7 +290,7 @@ module Sequel
       # 
       # The implementation is ugly, cloning the current dataset and modifying
       # the clone to add a ROW_NUMBER window function (and some other things),
-      # then using the modified clone in a CTE which is selected from.
+      # then using the modified clone in a subselect which is selected from.
       #
       # If offset is used, an order must be provided, because the use of ROW_NUMBER
       # requires an order.
@@ -293,16 +298,15 @@ module Sequel
         return super unless o = @opts[:offset]
         raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
         dsa1 = dataset_alias(1)
-        dsa2 = dataset_alias(2)
         rn = row_number_column
-        unlimited.
+        sel = [Sequel::SQL::WindowFunction.new(:ROW_NUMBER.sql_function, Sequel::SQL::Window.new(:order=>order)).as(rn)]
+        sel.unshift(WILDCARD) unless osel = @opts[:select] and !osel.empty?
+        subselect_sql(unlimited.
           unordered.
-          from_self(:alias=>dsa2).
-          select{[WILDCARD, ROW_NUMBER(:over, :order=>order){}.as(rn)]}.
+          select_more(*sel).
           from_self(:alias=>dsa1).
           limit(@opts[:limit]).
-          where(rn > o).
-          select_sql
+          where(SQL::Identifier.new(rn) > o))
       end
 
       # The version of the database server.
@@ -420,9 +424,13 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
 
+      def select_into_sql(sql)
+        sql << " INTO #{table_ref(@opts[:into])}" if @opts[:into]
+      end
+
       # MSSQL uses TOP for limit
       def select_limit_sql(sql)
-        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+        sql << " TOP (#{literal(@opts[:limit])})" if @opts[:limit]
       end
 
       # MSSQL uses the WITH statement to lock tables

data/lib/sequel/adapters/shared/mysql.rb

@@ -4,8 +4,17 @@ module Sequel
 
   module MySQL
     class << self
-      # Set the default options used for CREATE TABLE
-      attr_accessor :default_charset, :default_collate, :default_engine
+      # Set the default charset used for CREATE TABLE.  You can pass the
+      # :charset option to create_table to override this setting.
+      attr_accessor :default_charset
+
+      # Set the default collation used for CREATE TABLE.  You can pass the
+      # :collate option to create_table to override this setting.
+      attr_accessor :default_collate
+
+      # Set the default engine used for CREATE TABLE.  You can pass the
+      # :engine option to create_table to override this setting.
+      attr_accessor :default_engine
     end
 
     # Methods shared by Database instances that connect to MySQL,
@@ -120,16 +129,16 @@ module Sequel
         super
       end
       
-      # MySQL doesn't handle references as column constraints, it must use a separate table constraint
-      def column_references_column_constraint_sql(column)
-        "#{", FOREIGN KEY (#{quote_identifier(column[:name])})" unless column[:type] == :check}#{column_references_sql(column)}"
-      end
-      
       # Use MySQL specific syntax for engine type and character encoding
       def create_table_sql(name, generator, options = {})
         engine = options.include?(:engine) ? options[:engine] : Sequel::MySQL.default_engine
         charset = options.include?(:charset) ? options[:charset] : Sequel::MySQL.default_charset
         collate = options.include?(:collate) ? options[:collate] : Sequel::MySQL.default_collate
+        generator.columns.each do |c|
+          if t = c.delete(:table)
+            generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key))
+          end
+        end
         "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 

data/lib/sequel/adapters/shared/sqlite.rb

@@ -265,6 +265,11 @@ module Sequel
         @opts[:where] ? super : filter(1=>1).delete
       end
       
+      # SQLite does not support DISTINCT ON
+      def supports_distinct_on?
+        false
+      end
+      
       # Return an array of strings specifying a query explanation for a SELECT of the
       # current dataset.
       def explain

data/lib/sequel/adapters/sqlite.rb

@@ -100,7 +100,7 @@ module Sequel
       # Also, force the max connections to 1 if a memory database is being
       # used, as otherwise each connection gets a separate database.
       def connection_pool_default_options
-        o = super.merge(:pool_convert_exceptions=>false)
+        o = super.dup
         # Default to only a single connection if a memory database is used,
         # because otherwise each connection will get a separate database
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
@@ -192,6 +192,7 @@ module Sequel
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
         db.prepared_statements[name] = ps if name
+        ps.prepared_sql
         ps
       end
       

data/lib/sequel/connection_pool.rb

@@ -1,369 +1,87 @@
-# A ConnectionPool manages access to database connections by keeping
-# multiple connections and giving threads exclusive access to each
-# connection.
+# The base connection pool class, which all other connection pools are built
+# on.  This class is not instantiated directly, but subclasses should at
+# the very least implement the following API:
+# * initialize(Hash, &block) - The block is used as the connection proc,
+#   which should accept a single symbol argument.
+# * hold(Symbol, &block) - yield a connection object (obtained from calling
+#   the block passed to initialize) to the current block. For sharded
+#   connection pools, the Symbol passed is the shard/server to use.
+# * disconnect(Symbol, &block) - disconnect the connection object.  If a
+#   block is given, pass the connection option to it, otherwise use the
+#   :disconnection_proc option in the hash passed to initialize.  For sharded
+#   connection pools, the Symbol passed is the shard/server to use.
+# * servers - an array of shard/server symbols for all shards/servers that this
+#   connection pool recognizes.
+# * size - an integer representing the total number of connections in the pool,
+#   or for the given shard/server if sharding is supported.
+#
+# For sharded connection pools, the sharded API:
+# * add_servers(Array of Symbols) - start recognizing all shards/servers specified
+#   by the array of symbols.
+# * remove_servers(Array of Symbols) - no longer recognize all shards/servers
+#   specified by the array of symbols.
 class Sequel::ConnectionPool
-  # The proc used to create a new database connection.
-  attr_accessor :connection_proc
-
-  # The proc used to disconnect a database connection.
-  attr_accessor :disconnection_proc
-
-  # The maximum number of connections.
-  attr_reader :max_size
-  
-  # The mutex that protects access to the other internal variables.  You must use
-  # this if you want to manipulate the variables safely.
-  attr_reader :mutex
-  
-  # Constructs a new pool with a maximum size. If a block is supplied, it
-  # is used to create new connections as they are needed.
-  #
-  #   pool = ConnectionPool.new(:max_connections=>10) {MyConnection.new(opts)}
-  #
-  # The connection creation proc can be changed at any time by assigning a 
-  # Proc to pool#connection_proc.
-  #
-  #   pool = ConnectionPool.new(:max_connections=>10)
-  #   pool.connection_proc = proc {MyConnection.new(opts)}
-  #
-  # The connection pool takes the following options:
-  #
-  # * :disconnection_proc - The proc called when removing connections from the pool.
-  # * :max_connections - The maximum number of connections the connection pool
-  #   will open (default 4)
-  # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
-  #   to RuntimeError exceptions (default true)
-  # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
-  #   a connection again (default 0.001)
-  # * :pool_timeout - The amount of seconds to wait to acquire a connection
-  #   before raising a PoolTimeoutError (default 5)
-  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
-  #   present, will use a single :default server.  The server name symbol will
-  #   be passed to the connection_proc.
-  def initialize(opts = {}, &block)
-    @max_size = Integer(opts[:max_connections] || 4)
-    raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
-    @mutex = Mutex.new
-    @connection_proc = block
-    @disconnection_proc = opts[:disconnection_proc]    
-    @available_connections = {}
-    @allocated = {}
-    @connections_to_remove = []
-    @servers = Hash.new(:default)
-    add_servers([:default])
-    add_servers(opts[:servers].keys) if opts[:servers]
-    @timeout = Integer(opts[:pool_timeout] || 5)
-    @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
-    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
-  end
-  
-  # Adds new servers to the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations. Allows for dynamic expansion of the potential slaves/shards
-  # at runtime. servers argument should be an array of symbols. 
-  def add_servers(servers)
-    sync do
-      servers.each do |server|
-        unless @servers.has_key?(server)
-          @servers[server] = server
-          @available_connections[server] = []
-          @allocated[server] = {}
-        end
+  # The default server to use
+  DEFAULT_SERVER = :default
+  
+  # A map of [single threaded, sharded] values to files (indicating strings to
+  # be required) ConnectionPool subclasses.
+  CONNECTION_POOL_MAP = {[true, false] => :single, 
+    [true, true] => :sharded_single,
+    [false, false] => :threaded,
+    [false, true] => :sharded_threaded}
+  
+  # Class methods used to return an appropriate pool subclass, separated
+  # into a module for easier overridding by extensions.
+  module ClassMethods
+    # Return a pool subclass instance based on the given options.  If a :pool_class
+    # option is provided is provided, use that pool class, otherwise
+    # use a new instance of an appropriate pool subclass based on the
+    # :single_threaded and :servers options.
+    def get_pool(opts = {}, &block)
+      case v = connection_pool_class(opts)
+      when Class
+        v.new(opts, &block)
+      when Symbol
+        Sequel.ts_require("connection_pool/#{v}")
+        connection_pool_class(opts).new(opts, &block) || raise(Sequel::Error, "No connection pool class found")
       end
     end
-  end
-  
-  # A hash of connections currently being used for the given server, key is the
-  # Thread, value is the connection.  Nonexistent servers will return nil.  Treat
-  # this as read only, do not modify the resulting object.
-  def allocated(server=:default)
-    @allocated[server]
-  end
-  
-  # An array of connections opened but not currently used, for the given
-  # server. Nonexistent servers will return nil. Treat this as read only, do
-  # not modify the resulting object.
-  def available_connections(server=:default)
-    @available_connections[server]
-  end
-  
-  # The total number of connections opened for the given server, should
-  # be equal to available_connections.length + allocated.length.  Nonexistent
-  # servers will return the created count of the default server.
-  def created_count(server=:default)
-    server = @servers[server]
-    @allocated[server].length + @available_connections[server].length
-  end
-  alias size created_count
-  
-  # Removes all connection currently available on all servers, optionally
-  # yielding each connection to the given block. This method has the effect of 
-  # disconnecting from the database, assuming that no connections are currently
-  # being used.  If connections are being used, they are scheduled to be
-  # disconnected as soon as they are returned to the pool.
-  # 
-  # Once a connection is requested using #hold, the connection pool
-  # creates new connections to the database. Options:
-  # * :server - Should be a symbol specifing the server to disconnect from,
-  #   or an array of symbols to specify multiple servers.
-  def disconnect(opts={}, &block)
-    block ||= @disconnection_proc
-    sync do
-      (opts[:server] ? Array(opts[:server]) : @servers.keys).each do |s|
-        disconnect_server(s, &block)
-      end
+    
+    private
+    
+    # Return a connection pool class based on the given options.
+    def connection_pool_class(opts)
+      opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
     end
   end
+  extend ClassMethods
   
-  # Chooses the first available connection to the given server, or if none are
-  # available, creates a new connection.  Passes the connection to the supplied
-  # block:
-  # 
-  #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
-  # 
-  # Pool#hold is re-entrant, meaning it can be called recursively in
-  # the same thread without blocking.
-  #
-  # If no connection is immediately available and the pool is already using the maximum
-  # number of connections, Pool#hold will block until a connection
-  # is available or the timeout expires.  If the timeout expires before a
-  # connection can be acquired, a Sequel::PoolTimeout is 
-  # raised.
-  def hold(server=:default)
-    begin
-      sync{server = @servers[server]}
-      t = Thread.current
-      if conn = owned_connection(t, server)
-        return yield(conn)
-      end
-      begin
-        unless conn = acquire(t, server)
-          time = Time.now
-          timeout = time + @timeout
-          sleep_time = @sleep_time
-          sleep sleep_time
-          until conn = acquire(t, server)
-            raise(::Sequel::PoolTimeout) if Time.now > timeout
-            sleep sleep_time
-          end
-        end
-        yield conn
-      rescue Sequel::DatabaseDisconnectError
-        sync{@connections_to_remove << conn} if conn
-        raise
-      ensure
-        sync{release(t, conn, server)} if conn
-      end
-    rescue StandardError 
-      raise
-    rescue Exception => e
-      raise(@convert_exceptions ? RuntimeError.new(e.message) : e)
-    end
-  end
-
-  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations.  Similar to disconnecting from all given servers,
-  # except that after it is used, future requests for the server will use the
-  # :default server instead.
-  def remove_servers(servers)
-    sync do
-      raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
-      servers.each do |server|
-        if @servers.include?(server)
-          disconnect_server(server, &@disconnection_proc)
-          @available_connections.delete(server)
-          @allocated.delete(server)
-          @servers.delete(server)
-        end
-      end
-    end
-  end
-
-  # Return an array of symbols for servers in the connection pool.
-  def servers
-    sync{@servers.keys}
-  end
-
-  private
-
-  # Assigns a connection to the supplied thread for the given server, if one
-  # is available. The calling code should NOT already have the mutex when
-  # calling this.
-  def acquire(thread, server)
-    sync do
-      if conn = available(server)
-        allocated(server)[thread] = conn
-      end
-    end
-  end
-  
-  # Returns an available connection to the given server. If no connection is
-  # available, tries to create a new connection. The calling code should already
-  # have the mutex before calling this.
-  def available(server)
-    available_connections(server).pop || make_new(server)
-  end
-
-  # Disconnect from the given server.  Disconnects available connections
-  # immediately, and schedules currently allocated connections for disconnection
-  # as soon as they are returned to the pool. The calling code should already
-  # have the mutex before calling this.
-  def disconnect_server(server, &block)
-    if conns = available_connections(server)
-      conns.each{|conn| block.call(conn)} if block
-      conns.clear
-    end
-    @connections_to_remove.concat(allocated(server).values)
-  end
-
-  # Creates a new connection to the given server if the size of the pool for
-  # the server is less than the maximum size of the pool. The calling code
-  # should already have the mutex before calling this.
-  def make_new(server)
-    if (n = created_count(server)) >= @max_size
-      allocated(server).to_a.each{|t, c| release(t, c, server) unless t.alive?}
-      n = nil
-    end
-    if (n || created_count(server)) < @max_size
-      raise(Sequel::Error, "No connection proc specified") unless @connection_proc
-      begin
-        conn = @connection_proc.call(server)
-      rescue Exception=>exception
-        raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
-      end
-      raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
-      conn
-    end
-  end
-  
-  # Returns the connection owned by the supplied thread for the given server,
-  # if any. The calling code should NOT already have the mutex before calling this.
-  def owned_connection(thread, server)
-    sync{@allocated[server][thread]}
-  end
-  
-  # Releases the connection assigned to the supplied thread and server. If the
-  # server or connection given is scheduled for disconnection, remove the
-  # connection instead of releasing it back to the pool.
-  # The calling code should already have the mutex before calling this.
-  def release(thread, conn, server)
-    if @connections_to_remove.include?(conn)
-      remove(thread, conn, server)
-    else
-      available_connections(server) << allocated(server).delete(thread)
-    end
-  end
-
-  # Removes the currently allocated connection from the connection pool. The
-  # calling code should already have the mutex before calling this.
-  def remove(thread, conn, server)
-    @connections_to_remove.delete(conn)
-    allocated(server).delete(thread) if @servers.include?(server)
-    @disconnection_proc.call(conn) if @disconnection_proc
-  end
-  
-  # Yield to the block while inside the mutex. The calling code should NOT
-  # already have the mutex before calling this.
-  def sync
-    @mutex.synchronize{yield}
-  end
-end
-
-# A SingleThreadedPool acts as a replacement for a ConnectionPool for use
-# in single-threaded applications. ConnectionPool imposes a substantial
-# performance penalty, so SingleThreadedPool is used to gain some speed.
-class Sequel::SingleThreadedPool
-  # The proc used to create a new database connection
-  attr_writer :connection_proc
-  
-  # The proc used to disconnect a database connection.
-  attr_accessor :disconnection_proc
-
-  # Initializes the instance with the supplied block as the connection_proc.
-  #
-  # The single threaded pool takes the following options:
-  #
-  # * :disconnection_proc - The proc called when removing connections from the pool.
-  # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
-  #   to RuntimeError exceptions (default true)
-  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
-  #   present, will use a single :default server.  The server name symbol will
-  #   be passed to the connection_proc.
+  # Instantiates a connection pool with the given options.  The block is called
+  # with a single symbol (specifying the server/shard to use) every time a new
+  # connection is needed.  The following options are respected for all connection
+  # pools:  #
+  # * :disconnection_proc - The proc called when removing connections from the pool,
+  #   which is passed the connection to disconnect.
   def initialize(opts={}, &block)
-    @connection_proc = block
+    raise(Sequel::Error, "No connection proc specified") unless @connection_proc = block
     @disconnection_proc = opts[:disconnection_proc]
-    @conns = {}
-    @servers = Hash.new(:default)
-    add_servers([:default])
-    add_servers(opts[:servers].keys) if opts[:servers]
-    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
   
-  # Adds new servers to the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations. Allows for dynamic expansion of the potential slaves/shards
-  # at runtime. servers argument should be an array of symbols. 
-  def add_servers(servers)
-    servers.each{|s| @servers[s] = s}
+  # Alias for size, not aliased directly for ease of subclass implementation
+  def created_count(*args)
+    size(*args)
   end
   
-  # The connection for the given server.
-  def conn(server=:default)
-    @conns[@servers[server]]
-  end
-  
-  # Disconnects from the database. Once a connection is requested using
-  # #hold, the connection is reestablished. Options:
-  # * :server - Should be a symbol specifing the server to disconnect from,
-  #   or an array of symbols to specify multiple servers.
-  def disconnect(opts={}, &block)
-    block ||= @disconnection_proc
-    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s, &block)}
-  end
-  
-  # Yields the connection to the supplied block for the given server.
-  # This method simulates the ConnectionPool#hold API.
-  def hold(server=:default)
-    begin
-      begin
-        server = @servers[server]
-        yield(c = (@conns[server] ||= make_new(server)))
-      rescue Sequel::DatabaseDisconnectError
-        disconnect_server(server, &@disconnection_proc)
-        raise
-      end
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
-    end
-  end
-  
-  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations.  Similar to disconnecting from all given servers,
-  # except that after it is used, future requests for the server will use the
-  # :default server instead.
-  def remove_servers(servers)
-    raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
-    servers.each do |server|
-      disconnect_server(server, &@disconnection_proc)
-      @servers.delete(server)
-    end
-  end
-  
-  # Return an array of symbols for servers in the connection pool.
+  # An array of symbols for all shards/servers, which is a single :default by default.
   def servers
-    @servers.keys
+    [:default]
   end
   
   private
   
-  # Disconnect from the given server, if connected.
-  def disconnect_server(server, &block)
-    if conn = @conns.delete(server)
-      block.call(conn) if block
-    end
-  end
-  
-  # Return a connection to the given server, raising DatabaseConnectionError
-  # if the connection_proc raises an error or doesn't return a valid connection.
+  # Return a new connection by calling the connection proc with the given server name,
+  # and checking for connection errors.
   def make_new(server)
     begin
       conn = @connection_proc.call(server)