sequel 4.49.0 → 5.0.0

data/lib/sequel/adapters/tinytds.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 require 'tiny_tds'
-Sequel.require 'adapters/shared/mssql'
+require_relative 'shared/mssql'
 
 module Sequel
   module TinyTDS
@@ -59,7 +59,7 @@ module Sequel
             else
               log_connection_yield(sql, c) do
                 r = c.execute(sql)
-                return r.send(m) if m
+                return r.public_send(m) if m
               end
             end
             yield(r) if block_given?
@@ -71,22 +71,18 @@ module Sequel
         end
       end
 
-      # Return the number of rows modified by the given +sql+.
       def execute_dui(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :do
         execute(sql, opts)
       end
 
-      # Return the value of the autogenerated primary key (if any)
-      # for the row inserted by the given +sql+.
       def execute_insert(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :insert
         execute(sql, opts)
       end
 
-      # Execute the DDL +sql+ on the database and return nil.
       def execute_ddl(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:return] = :each
@@ -135,9 +131,6 @@ module Sequel
         Dataset
       end
 
-      TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out)/
-      Sequel::Deprecation.deprecate_constant(self, :TINYTDS_DISCONNECT_ERRORS)
-
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
         super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out)/.match(e.message)))
@@ -185,9 +178,6 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
 
-      Database::DatasetClass = self
-      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
-      
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
@@ -213,10 +203,10 @@ module Sequel
       
       PreparedStatementMethods = prepared_statements_module("sql = prepared_sql; opts = Hash[opts]; opts[:arguments] = bind_arguments", ArgumentMapper)
     
-      # Yield hashes with symbol keys, attempting to optimize for
-      # various cases.
       def fetch_rows(sql)
         execute(sql) do |result|
+          # Mutating an array in the result is questionable, but supported
+          # by tiny_tds developers (tiny_tds issue #57)
           columns = result.fields.map!{|c| output_identifier(c)}
           if columns.empty?
             args = []
@@ -247,7 +237,7 @@ module Sequel
       
       private
       
-      # Properly escape the given string +v+.
+      # Properly escape the given string
       def literal_string_append(sql, v)
         sql << (mssql_unicode_strings ? "N'" : "'")
         sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(/\\((?:\r\n)|\n)/, '\\\\\\\\\\1\\1') << "'"

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -7,7 +7,7 @@ module Sequel
     # when ordering.
     def empty?
       return super unless emulate_offset_with_row_number?
-      get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
+      select(Dataset::EMPTY_SELECT).limit(1).single_value!.nil?
     end
 
     # Emulate OFFSET support with the ROW_NUMBER window function

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+require_relative '../shared/mysql'
+require_relative 'stored_procedures'
 
 module Sequel
   module MySQL
@@ -47,9 +48,6 @@ module Sequel
           conn.prepared_statements = {}
         end
 
-        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
-        # all constraint violations to 23000 even though it recognizes
-        # different types.
         def database_specific_error_class(exception, opts)
           case exception.errno
           when 1048

data/lib/sequel/adapters/utils/mysql_prepared_statements.rb

@@ -8,10 +8,9 @@ module Sequel
 
         # Executes a prepared statement on an available connection.  If the
         # prepared statement already exists for the connection and has the same
-        # SQL, reuse it, otherwise, prepare the new statement.  Because of the
-        # usual MySQL stupidity, we are forced to name arguments via separate
-        # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
-        # arguments.
+        # SQL, reuse it, otherwise, prepare the new statement.  Issue a SET
+        # query with literalized values for each argument, then an EXECUTE to
+        # execute the query with the arguments.
         def execute_prepared_statement(ps_name, opts, &block)
           args = opts[:arguments]
           ps = prepared_statement(ps_name)
@@ -30,8 +29,6 @@ module Sequel
       end
 
       module DatasetMethods
-        # Methods to add to MySQL prepared statement calls without using a
-        # real database prepared statement and bound variables.
         module CallableStatementMethods
           # Extend given dataset with this module so subselects inside subselects in
           # prepared statements work.

data/lib/sequel/adapters/utils/replace.rb

@@ -3,11 +3,6 @@
 module Sequel
   class Dataset
     module Replace
-      INSERT = 'INSERT'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :INSERT)
-      REPLACE = 'REPLACE'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :REPLACE)
-
       # Execute a REPLACE statement on the database (deletes any duplicate
       # rows before inserting).
       def replace(*values)

data/lib/sequel/adapters/utils/stored_procedures.rb

@@ -3,8 +3,6 @@
 module Sequel 
   class Dataset
     module StoredProcedureMethods
-      Dataset.def_deprecated_opts_setter(self, :sproc_type, :sproc_name, :sproc_args)
-
       # The name of the stored procedure to call
       def sproc_name
         @opts[:sproc_name]

data/lib/sequel/adapters/utils/unmodified_identifiers.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module UnmodifiedIdentifiers
     module DatabaseMethods

data/lib/sequel/ast_transformer.rb

@@ -55,7 +55,7 @@ module Sequel
         end
         SQL::Function.new!(o.name, v(o.args), h)
       when SQL::Subscript
-        SQL::Subscript.new(v(o.f), v(o.sub))
+        SQL::Subscript.new(v(o.expression), v(o.sub))
       when SQL::Window
         opts = o.opts.dup
         opts[:partition] = v(opts[:partition]) if opts[:partition]
@@ -90,15 +90,8 @@ module Sequel
   # in the dataset are qualified with a given table name.
   class Qualifier < ASTTransformer
     # Set the table used to qualify unqualified columns
-    def initialize(table, unused=nil)
-      if unused
-        # :nocov:
-        Sequel::Deprecation.deprecate("Passing two arguments to Sequel::Qualifier.new", 'Pass only the second argument specifying the table used for qualification')
-        @table = unused
-        # :nocov:
-      else
-        @table = table
-      end
+    def initialize(table)
+      @table = table
     end
 
     private
@@ -128,88 +121,4 @@ module Sequel
       end
     end
   end
-
-  # +Unbinder+ is used to take a dataset filter and return a modified version
-  # that unbinds already bound values and returns a dataset with bound value
-  # placeholders and a hash of bind values.  You can then prepare the dataset
-  # and use the bound variables to execute it with the same values.
-  #
-  # This class only does a limited form of unbinding where the variable names
-  # and values can be associated unambiguously.  The only cases it handles
-  # are <tt>SQL::ComplexExpression<tt> with an operator in +UNBIND_OPS+, a
-  # first argument that's an instance of a member of +UNBIND_KEY_CLASSES+, and
-  # a second argument that's an instance of a member of +UNBIND_VALUE_CLASSES+.
-  #
-  # So it can handle cases like:
-  #
-  #   DB.where(:a=>1).exclude(:b=>2).where{c > 3}
-  #
-  # But it cannot handle cases like:
-  #
-  #   DB.where(:a + 1 < 0)
-  class Unbinder < ASTTransformer
-    # The <tt>SQL::ComplexExpression<tt> operates that will be considered
-    # for transformation.
-    UNBIND_OPS = [:'=', :'!=', :<, :>, :<=, :>=]
-
-    # The key classes (first argument of the ComplexExpression) that will
-    # considered for transformation.
-    UNBIND_KEY_CLASSES = [Symbol, SQL::Identifier, SQL::QualifiedIdentifier]
-
-    # The value classes (second argument of the ComplexExpression) that
-    # will be considered for transformation.
-    UNBIND_VALUE_CLASSES = [Numeric, String, Date, Time]
-
-    # The hash of bind variables that were extracted from the dataset filter.
-    attr_reader :binds
-
-    # Intialize an empty +binds+ hash.
-    def initialize
-      Sequel::Deprecation.deprecate("Sequel::Unbinder", 'There is no replacement')
-      @binds = {}
-    end
-
-    private
-
-    # Create a suitable bound variable key for the object, which should be
-    # an instance of one of the +UNBIND_KEY_CLASSES+.
-    def bind_key(obj)
-      case obj
-      when Symbol
-        obj
-      when String
-        obj.to_sym
-      when SQL::Identifier
-        bind_key(obj.value)
-      when SQL::QualifiedIdentifier
-        :"#{bind_key(obj.table)}.#{bind_key(obj.column)}"
-      else
-        raise Error, "unhandled object in Sequel::Unbinder#bind_key: #{obj}"
-      end
-    end
-
-    # Handle <tt>SQL::ComplexExpression</tt> instances with suitable ops
-    # and arguments, substituting the value with a bound variable placeholder
-    # and assigning it an entry in the +binds+ hash with a matching key.
-    def v(o)
-      if o.is_a?(SQL::ComplexExpression) && UNBIND_OPS.include?(o.op)
-        l, r = o.args
-        l = l.value if l.is_a?(Sequel::SQL::Wrapper)
-        r = r.value if r.is_a?(Sequel::SQL::Wrapper)
-        if UNBIND_KEY_CLASSES.any?{|c| l.is_a?(c)} && UNBIND_VALUE_CLASSES.any?{|c| r.is_a?(c)} && !r.is_a?(LiteralString)
-          key = bind_key(l)
-          if (old = binds[key]) && old != r
-            raise UnbindDuplicate, "two different values for #{key.inspect}: #{[r, old].inspect}" 
-          end
-          binds[key] = r
-          SQL::ComplexExpression.new(o.op, l, :"$#{key}")
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-  end
-  Sequel::Deprecation.deprecate_constant(self, :Unbinder)
 end

data/lib/sequel/connection_pool.rb

@@ -26,19 +26,13 @@
 #                                     specified by the array of symbols.
 class Sequel::ConnectionPool
   OPTS = Sequel::OPTS
+  POOL_CLASS_MAP = {
+    :threaded => :ThreadedConnectionPool,
+    :single => :SingleConnectionPool,
+    :sharded_threaded => :ShardedThreadedConnectionPool,
+    :sharded_single => :ShardedSingleConnectionPool
+  }.freeze
 
-  # The default server to use
-  DEFAULT_SERVER = :default
-  Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SERVER)
-  
-  # A map of [single threaded, sharded] values to symbols or ConnectionPool subclasses.
-  CONNECTION_POOL_MAP = {[true, false] => :single, 
-    [true, true] => :sharded_single,
-    [false, false] => :threaded,
-    [false, true] => :sharded_threaded}
-  CONNECTION_POOL__MAP = CONNECTION_POOL_MAP
-  Sequel::Deprecation.deprecate_constant(self, :CONNECTION_POOL_MAP)
-  
   # Class methods used to return an appropriate pool subclass, separated
   # into a module for easier overridding by extensions.
   module ClassMethods
@@ -47,23 +41,33 @@ class Sequel::ConnectionPool
     # use a new instance of an appropriate pool subclass based on the
     # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
     def get_pool(db, opts = OPTS)
-      case v = connection_pool_class(opts)
-      when Class
-        v.new(db, opts)
-      when Symbol
-        require("sequel/connection_pool/#{v}")
-        connection_pool_class(opts).new(db, opts) || raise(Sequel::Error, "No connection pool class found")
-      end
+      connection_pool_class(opts).new(db, opts)
     end
     
     private
     
     # Return a connection pool class based on the given options.
     def connection_pool_class(opts)
-      if opts[:pool_class] && !opts[:pool_class].is_a?(Class) && ![:threaded, :single, :sharded_threaded, :sharded_single].include?(opts[:pool_class])
-        Sequel::Deprecation.deprecate("Using an unrecognized :pool_class option", "Use a class for the :pool_class option to select a custom pool class, or one of the following symbols for one of the default pool classes: :threaded, :single, :sharded_threaded, :sharded_single")
+      if pc = opts[:pool_class]
+        unless pc.is_a?(Class)
+          unless name = POOL_CLASS_MAP[pc]
+            raise Sequel::Error, "unsupported connection pool type, please pass appropriate class as the :pool_class option"
+          end
+
+          require_relative "connection_pool/#{pc}"
+          pc = Sequel.const_get(name)
+        end
+
+        pc
+      else
+        pc = if opts[:single_threaded]
+          opts[:servers] ? :sharded_single : :single
+        else
+          opts[:servers] ? :sharded_threaded : :threaded
+        end
+
+        connection_pool_class(:pool_class=>pc)
       end
-      CONNECTION_POOL__MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL__MAP[[!!opts[:single_threaded], !!opts[:servers]]]
     end
   end
   extend ClassMethods
@@ -93,12 +97,6 @@ class Sequel::ConnectionPool
     @error_classes = db.send(:database_error_classes).dup.freeze
   end
   
-  # Alias for +size+, not aliased directly for ease of subclass implementation
-  def created_count(*args)
-    Sequel::Deprecation.deprecate("Sequel::ConnectionPool#created_count", "Use #size instead")
-    size(*args)
-  end
-  
   # An array of symbols for all shards/servers, which is a single <tt>:default</tt> by default.
   def servers
     [:default]

data/lib/sequel/connection_pool/sharded_single.rb

@@ -66,8 +66,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     1
   end
   
-  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations.  Similar to disconnecting from all given servers,
+  # Remove servers from the connection pool. 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)
@@ -110,6 +109,4 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = nil)
     servers.each{|s| hold(s){}}
   end
-  
-  CONNECTION_POOL__MAP[[true, true]] = self
 end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'sequel/connection_pool/threaded'
+require_relative 'threaded'
 
 # The slowest and most advanced connection, dealing with both multi-threaded
 # access and configurations with multiple shards/servers.
@@ -20,18 +20,14 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @available_connections = {}
     @connections_to_remove = []
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
-
-    if USE_WAITER
-      @waiter = nil
-      @waiters = {}
-    end
+    remove_instance_variable(:@waiter)
+    @waiters = {}
 
     add_servers([:default])
     add_servers(opts[:servers].keys) if opts[:servers]
   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
+  # Adds new servers to the connection pool.  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
@@ -40,7 +36,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
           @servers[server] = server
           @available_connections[server] = []
           @allocated[server] = {}
-          @waiters[server] = ConditionVariable.new if USE_WAITER
+          @waiters[server] = ConditionVariable.new
         end
       end
     end
@@ -77,12 +73,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @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.
+  # The total number of connections opened for the given server.
+  # Nonexistent servers will return the created count of the default server.
+  # The calling code should not have the mutex before calling this.
   def size(server=:default)
-    server = @servers[server]
-    @allocated[server].length + @available_connections[server].length
+    @mutex.synchronize{_size(server)}
   end
   
   # Removes all connections currently available on all servers, optionally
@@ -120,8 +115,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # 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.
+  # connection can be acquired, a Sequel::PoolTimeout is raised.
   def hold(server=:default)
     server = pick_server(server)
     t = Thread.current
@@ -139,8 +133,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     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,
+  # Remove servers from the connection pool. 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)
@@ -150,7 +143,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       servers.each do |server|
         if @servers.include?(server)
           conns = disconnect_server_connections(server)
-          @waiters.delete(server) if USE_WAITER
+          @waiters.delete(server)
           @available_connections.delete(server)
           @allocated.delete(server)
           @servers.delete(server)
@@ -174,71 +167,89 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   
   private
 
-  # Assigns a connection to the supplied thread for the given server, if one
-  # is available. The calling code should already have the mutex when
-  # calling this.
-  def _acquire(thread, server)
-    if conn = available(server)
-      allocated(server)[thread] = conn
-    end
+  # The total number of connections opened for the given server.
+  # The calling code should already have the mutex before calling this.
+  def _size(server)
+    server = @servers[server]
+    @allocated[server].length + @available_connections[server].length
   end
   
-  if USE_WAITER
-    # Assigns a connection to the supplied thread, if one
-    # is available. The calling code should NOT already have the mutex when
-    # calling this.
-    #
-    # This should return a connection is one is available within the timeout,
-    # or nil if a connection could not be acquired within the timeout.
-    def acquire(thread, server)
+  # Assigns a connection to the supplied thread, if one
+  # is available. The calling code should NOT already have the mutex when
+  # calling this.
+  #
+  # This should return a connection is one is available within the timeout,
+  # or nil if a connection could not be acquired within the timeout.
+  def acquire(thread, server)
+    if conn = assign_connection(thread, server)
+      return conn
+    end
+
+    time = Time.now
+
+    sync do
+      @waiters[server].wait(@mutex, @timeout)
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+    end
+
+    until conn = assign_connection(thread, server)
+      deadline ||= time + @timeout
+      current_time = Time.now
+      raise_pool_timeout(current_time - time, server) if current_time > deadline
+      # :nocov:
+      # It's difficult to get to this point, it can only happen if there is a race condition
+      # where a connection cannot be acquired even after the thread is signalled by the condition
       sync do
-        if conn = _acquire(thread, server)
-          return conn
+        @waiters[server].wait(@mutex, deadline - current_time)
+        if conn = next_available(server)
+          return(allocated(server)[thread] = conn)
         end
+      end
+      # :nocov:
+    end
+
+    conn
+  end
 
-        time = Time.now
-        @waiters[server].wait(@mutex, @timeout)
-        Thread.pass
+  # Assign a connection to the thread, or return nil if one cannot be assigned.
+  # The caller should NOT have the mutex before calling this.
+  def assign_connection(thread, server)
+    alloc = allocated(server)
 
-        until conn = _acquire(thread, server)
-          deadline ||= time + @timeout
-          current_time = Time.now
-          raise_pool_timeout(current_time - time, server) if current_time > deadline
-          # :nocov:
-          # It's difficult to get to this point, it can only happen if there is a race condition
-          # where a connection cannot be acquired even after the thread is signalled by the condition
-          # variable that a connection is ready.
-          @waiters[server].wait(@mutex, deadline - current_time)
-          Thread.pass
-          # :nocov:
-        end
+    do_make_new = false
+    sync do
+      if conn = next_available(server)
+        alloc[thread] = conn
+        return conn
+      end
+
+      if (n = _size(server)) >= (max = @max_size)
+        alloc.to_a.each{|t,c| release(t, c, server) unless t.alive?}
+        n = nil
+      end
 
-        conn
+      if (n || _size(server)) < max
+        do_make_new = alloc[thread] = true
       end
     end
-  else
-    # :nocov:
-    def acquire(thread, server)
-      unless conn = sync{_acquire(thread, server)}
-        time = Time.now
-        timeout = time + @timeout
-        sleep_time = @sleep_time
-        sleep sleep_time
-        until conn = sync{_acquire(thread, server)}
-          raise_pool_timeout(Time.now - time, server) if Time.now > timeout
-          sleep sleep_time
+
+    # Connect to the database outside of the connection pool mutex,
+    # as that can take a long time and the connection pool mutex
+    # shouldn't be locked while the connection takes place.
+    if do_make_new
+      begin
+        conn = make_new(server)
+        sync{alloc[thread] = conn}
+      ensure
+        unless conn
+          sync{alloc.delete(thread)}
         end
       end
-      conn
     end
-    # :nocov:
-  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)
-    next_available(server) || make_new(server)
+    conn
   end
 
   # Return a connection to the pool of available connections for the server,
@@ -246,10 +257,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # before calling this.
   def checkin_connection(server, conn)
     available_connections(server) << conn
-    if USE_WAITER
-      @waiters[server].signal
-      Thread.pass
-    end
+    @waiters[server].signal
     conn
   end
 
@@ -263,29 +271,18 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     if dis_conns = available_connections(server)
       conns = dis_conns.dup
       dis_conns.clear
+      @waiters[server].signal
     end
     conns
   end
 
-  # Disconnect all given connections.  
-  # immediately, and schedules currently allocated connections for disconnection
+  # Disconnect all available connections immediately, and schedule currently allocated connections for disconnection
   # as soon as they are returned to the pool. The calling code should not
   # have the mutex before calling this.
   def disconnect_connections(conns)
     conns.each{|conn| disconnect_connection(conn)}
   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 = size(server)) >= @max_size
-      allocated(server).to_a.each{|t, c| release(t, c, server) unless t.alive?}
-      n = nil
-    end
-    default_make_new(server) if (n || size(server)) < @max_size
-  end
-
   # Return the next available connection in the pool for the given server, or nil
   # if there is not currently an available connection for the server.
   # The calling code should already have the mutex before calling this.
@@ -309,17 +306,20 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     sync{@servers[server]}
   end
   
-  # Create the maximum number of connections to each server immediately.
+  # Create the maximum number of connections immediately.  The calling code should
+  # NOT have the mutex before calling this.
   def preconnect(concurrent = false)
-    conn_servers = @servers.keys.map{|s| Array.new(max_size - size(s), s)}.flatten
+    conn_servers = @servers.keys.map!{|s| Array.new(max_size - _size(s), s)}.flatten!
 
     if concurrent
-      conn_servers.map{|s| Thread.new{[s, make_new(s)]}}.map(&:join).each{|t| checkin_connection(*t.value)}
+      conn_servers.map!{|s| Thread.new{[s, make_new(s)]}}.map!(&:value)
     else
-      conn_servers.each{|s| checkin_connection(s, make_new(s))}
+      conn_servers.map!{|s| [s, make_new(s)]}
     end
+
+    sync{conn_servers.each{|s, conn| checkin_connection(s, conn)}}
   end
-  
+
   # Raise a PoolTimeout error showing the current timeout, the elapsed time, the server
   # the connection attempt was made to, and the database's name (if any).
   def raise_pool_timeout(elapsed, server)
@@ -343,6 +343,10 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
         checkin_connection(server, conn)
       end
     end
+
+    if waiter = @waiters[server]
+      waiter.signal
+    end
   end
 
   # Removes the currently allocated connection from the connection pool. The
@@ -352,6 +356,4 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     allocated(server).delete(thread) if @servers.include?(server)
     disconnect_connection(conn)
   end
-  
-  CONNECTION_POOL__MAP[[false, true]] = self
 end