sequel 5.45.0 → 5.77.0

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

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative '../utils/columns_limit_1'
+
 module Sequel
   module SqlAnywhere
     Sequel::Database.set_shared_adapter_scheme(:sqlanywhere, self)
@@ -35,7 +37,7 @@ module Sequel
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
           row[:allow_null] = row[:nulls_allowed].is_a?(Integer) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
-          row[:db_type] = row.delete(:domain_name)
+          row[:db_type] = row.delete(:domain_name_with_size)
           row[:type] = if row[:db_type] =~ /numeric/i and (row[:scale].is_a?(Integer) ? row[:scale] == 0 : !row[:scale])
             :integer
           else
@@ -193,6 +195,11 @@ module Sequel
         end
       end
 
+      # SQLAnywhere tinyint types are unsigned.
+      def column_schema_tinyint_type_is_unsigned?
+        true
+      end
+
       # SqlAnywhere doesn't support CREATE TABLE AS, it only supports SELECT INTO.
       # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
       # is given as the argument, it can't work with a string, so raise an
@@ -211,6 +218,8 @@ module Sequel
       def schema_column_type(db_type)
         if convert_smallint_to_bool && db_type =~ /smallint/i
           :boolean
+        elsif db_type =~ /unsigned (big)?int/i
+          :integer
         else
           super
         end
@@ -234,6 +243,7 @@ module Sequel
     module DatasetMethods
       Dataset.def_sql_method(self, :insert, %w'insert into columns values')
       Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having window compounds order lock')
+      include ::Sequel::Dataset::ColumnsLimit1
 
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the IBMDB module setting.
@@ -271,10 +281,6 @@ module Sequel
         false
       end
 
-      def supports_timestamp_usecs?
-        false
-      end
-
       def supports_window_clause?
         true
       end
@@ -368,6 +374,16 @@ module Sequel
 
       private
 
+      # SQLAnywhere only supports 3 digits after the decimal point for times.
+      def default_time_format
+        "'%H:%M:%S.%3N'"
+      end
+
+      # SQLAnywhere only supports 3 digits after the decimal point for timestamps.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%3N'"
+      end
+
       # Use 1 for true on Sybase
       def literal_true
         '1'

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

@@ -145,6 +145,11 @@ module Sequel
         sqlite_version >= 30608
       end
 
+      # SQLite 3.8.2+ supports the without rowid table constraint
+      def support_without_rowid?
+        sqlite_version >= 30802
+      end
+
       # Override the default setting for whether to use timezones in timestamps.
       # It is set to +false+ by default, as SQLite's date/time methods do not
       # support timezones in timestamps.
@@ -169,6 +174,7 @@ module Sequel
       #   DB.values([[1, 2], [3, 4]])
       #   # VALUES ((1, 2), (3, 4))
       def values(v)
+        raise Error, "Cannot provide an empty array for values" if v.empty?
         @default_dataset.clone(:values=>v)
       end
 
@@ -320,6 +326,12 @@ module Sequel
         end
       end
     
+      # SQLite does not restrict the integer or decimal type to a specific range.
+      def column_schema_integer_min_max_values(column)
+        nil
+      end
+      alias column_schema_decimal_min_max_values column_schema_integer_min_max_values
+
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas
@@ -337,6 +349,19 @@ module Sequel
         ps
       end
 
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
+      def create_table_sql(name, generator, options)
+        if options[:strict] && options[:without_rowid]
+          "#{super} STRICT, WITHOUT ROWID"
+        elsif options[:strict]
+          "#{super} STRICT"
+        elsif options[:without_rowid]
+          "#{super} WITHOUT ROWID"
+        else
+          super
+        end
+      end
+
       # SQLite support creating temporary views.
       def create_view_prefix_sql(name, options)
         create_view_sql_append_columns("CREATE #{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}", options[:columns])
@@ -345,8 +370,10 @@ module Sequel
       DATABASE_ERROR_REGEXPS = {
         /(is|are) not unique\z|PRIMARY KEY must be unique\z|UNIQUE constraint failed: .+\z/ => UniqueConstraintViolation,
         /foreign key constraint failed\z/i => ForeignKeyConstraintViolation,
+        /\ASQLITE ERROR 3091/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 275 \(CONSTRAINT_CHECK\) : )?CHECK constraint failed/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed\z/ => ConstraintViolation,
+        /\Acannot store [A-Z]+ value in [A-Z]+ column / => ConstraintViolation,
         /may not be NULL\z|NOT NULL constraint failed: .+\z/ => NotNullConstraintViolation,
         /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
       }.freeze
@@ -393,7 +420,7 @@ module Sequel
         old_columns = def_columns.map{|c| c[:name]}
         opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
 
-        yield def_columns if block_given?
+        yield def_columns if defined?(yield)
 
         constraints = (opts[:constraints] || []).dup
         pks = []
@@ -490,7 +517,6 @@ module Sequel
             # table_xinfo PRAGMA used, remove hidden columns
             # that are not generated columns
             if row[:generated] = (row.delete(:hidden) != 0)
-              next unless row[:type].end_with?(' GENERATED ALWAYS')
               row[:type] = row[:type].sub(' GENERATED ALWAYS', '')
             end
           end
@@ -562,10 +588,10 @@ module Sequel
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}.freeze
       EXTRACT_MAP.each_value(&:freeze)
 
-      Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
-      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
+      Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 33500', %w'with delete from where returning'], ['elsif db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
+      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 33500', %w'with insert conflict into columns values on_conflict returning'], ['elsif db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having window compounds order limit lock']])
-      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 33300', %w'with update table set from where'], ['elsif db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
+      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 33500', %w'with update table set from where returning'], ['elsif db.sqlite_version >= 33300', %w'with update table set from where'], ['elsif db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
         if type == Time or type == DateTime
@@ -639,10 +665,16 @@ module Sequel
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
-      def delete
-        @opts[:where] ? super : where(1=>1).delete
+      def delete(&block)
+        @opts[:where] ? super : where(1=>1).delete(&block)
       end
       
+      # Always return false when using VALUES
+      def empty?
+        return false if @opts[:values]
+        super
+      end
+
       # Return an array of strings specifying a query explanation for a SELECT of the
       # current dataset. Currently, the options are ignored, but it accepts options
       # to be compatible with other adapters.
@@ -657,10 +689,25 @@ module Sequel
       
       # HAVING requires GROUP BY on SQLite
       def having(*cond)
-        raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") unless @opts[:group]
+        raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") if !@opts[:group] && db.sqlite_version < 33900
         super
       end
       
+      # Support insert select for associations, so that the model code can use
+      # returning instead of a separate query.
+      def insert_select(*values)
+        return unless supports_insert_select?
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
+      end
+
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
         sql << '`' << c.to_s.gsub('`', '``') << '`'
@@ -742,6 +789,13 @@ module Sequel
         insert_conflict(:ignore)
       end
 
+      # Automatically add aliases to RETURNING values to work around SQLite bug.
+      def returning(*values)
+        return super if values.empty?
+        raise Error, "RETURNING is not supported on #{db.database_type}" unless supports_returning?(:insert)
+        clone(:returning=>_returning_values(values).freeze)
+      end
+
       # SQLite 3.8.3+ supports common table expressions.
       def supports_cte?(type=:select)
         db.sqlite_version >= 30803
@@ -782,6 +836,11 @@ module Sequel
         false
       end
       
+      # SQLite 3.35.0 supports RETURNING on INSERT/UPDATE/DELETE.
+      def supports_returning?(_)
+        db.sqlite_version >= 33500
+      end
+
       # SQLite supports timezones in literal timestamps, since it stores them
       # as text.  But using timezones in timestamps breaks SQLite datetime
       # functions, so we allow the user to override the default per database.
@@ -814,6 +873,26 @@ module Sequel
 
       private
       
+      # Add aliases to symbols and identifiers to work around SQLite bug.
+      def _returning_values(values)
+        values.map do |v|
+          case v
+          when Symbol
+            _, c, a = split_symbol(v)
+            a ? v : Sequel.as(v, c)
+          when SQL::Identifier, SQL::QualifiedIdentifier
+            Sequel.as(v, unqualified_column_for(v))
+          else
+            v
+          end
+        end
+      end
+
+      # Use from_self for aggregate dataset using VALUES.
+      def aggreate_dataset_use_from_self?
+        super || @opts[:values]
+      end
+      
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql_append(sql, aliaz, column_aliases=nil)
         raise Error, "sqlite does not support derived column lists" if column_aliases
@@ -851,6 +930,11 @@ module Sequel
         500
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        db.use_timestamp_timezones? ? "'%Y-%m-%d %H:%M:%S.%6N%z'" : super
+      end
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(', ')

data/lib/sequel/adapters/sqlanywhere.rb

@@ -120,7 +120,7 @@ module Sequel
 
         case type
         when :select
-          yield rs if block_given?
+          yield rs if defined?(yield)
         when :rows
           return @api.sqlany_affected_rows(rs)
         when :insert

data/lib/sequel/adapters/sqlite.rb

@@ -98,6 +98,11 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
+      def initialize(opts = OPTS)
+        super
+        @allow_regexp = typecast_value_boolean(opts[:setup_regexp_function])
+      end
+
       # Connect to the database. Since SQLite is a file based database,
       # available options are limited:
       #
@@ -106,6 +111,18 @@ module Sequel
       #              static data that you do not want to modify
       # :timeout :: how long to wait for the database to be available if it
       #             is locked, given in milliseconds (default is 5000)
+      # :setup_regexp_function :: enable use of Regexp objects with SQL
+      #             'REGEXP' operator. If the value is :cached or "cached",
+      #             caches the generated regexps, which can result in a memory
+      #             leak if dynamic regexps are used.  If the value is a Proc,
+      #             it will be called with a string for the regexp and a string
+      #             for the value to compare, and should return whether the regexp
+      #             matches.
+      # :regexp_function_cache :: If setting +setup_regexp_function+ to +cached+, this
+      #             determines the cache to use.  It should either be a proc or a class, and it
+      #             defaults to +Hash+. You can use +ObjectSpace::WeakKeyMap+ on Ruby 3.3+ to
+      #             have the VM automatically remove regexps from the cache after they
+      #             are no longer used.
       def connect(server)
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
@@ -119,6 +136,10 @@ module Sequel
         end
         
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
+
+        if typecast_value_boolean(opts[:setup_regexp_function])
+          setup_regexp_function(db, opts[:setup_regexp_function])
+        end
         
         class << db
           attr_reader :prepared_statements
@@ -128,6 +149,12 @@ module Sequel
         db
       end
 
+      # Whether this Database instance is setup to allow regexp matching.
+      # True if the :setup_regexp_function option was passed when creating the Database.
+      def allow_regexp?
+        @allow_regexp
+      end
+
       # Disconnect given connections from the database.
       def disconnect_connection(c)
         c.prepared_statements.each_value{|v| v.first.close}
@@ -185,30 +212,57 @@ module Sequel
         @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
         set_integer_booleans
       end
+
+      def setup_regexp_function(db, how)
+        case how
+        when Proc
+          # nothing
+        when :cached, "cached"
+          cache = @opts[:regexp_function_cache] || Hash
+          cache = cache.is_a?(Proc) ? cache.call : cache.new
+          how = if RUBY_VERSION >= '2.4'
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match?(str)
+            end
+          else
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match(str)
+            end
+          end
+        else
+          how = if RUBY_VERSION >= '2.4'
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match?(str)}
+          else
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match(str)}
+          end
+        end
+
+        db.create_function("regexp", 2) do |func, regexp_str, str|
+          func.result = how.call(regexp_str, str) ? 1 : 0
+        end
+      end
       
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.
       def _execute(type, sql, opts, &block)
-        begin
-          synchronize(opts[:server]) do |conn|
-            return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
-            log_args = opts[:arguments]
-            args = {}
-            opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
-            case type
-            when :select
-              log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
-            when :insert
-              log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
-              conn.last_insert_row_id
-            when :update
-              log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
-              conn.changes
-            end
+        synchronize(opts[:server]) do |conn|
+          return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
+          log_args = opts[:arguments]
+          args = {}
+          opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
+          case type
+          when :select
+            log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
+          when :insert
+            log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
+            conn.last_insert_row_id
+          when :update
+            log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
+            conn.changes
           end
-        rescue SQLite3::Exception => e
-          raise_error(e)
         end
+      rescue SQLite3::Exception => e
+        raise_error(e)
       end
       
       # The SQLite adapter does not need the pool to convert exceptions.
@@ -323,6 +377,28 @@ module Sequel
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
+      # Support regexp functions if using :setup_regexp_function Database option.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*'
+          return super unless supports_regexp?
+
+          case_insensitive = [:'~*', :'!~*'].include?(op)
+          sql << 'NOT ' if [:'!~', :'!~*'].include?(op)
+          sql << '('
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[0])
+          sql << ')' if case_insensitive
+          sql << ' REGEXP '
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[1])
+          sql << ')' if case_insensitive
+          sql << ')'
+        else
+          super
+        end
+      end
+
       def fetch_rows(sql)
         execute(sql) do |result|
           cps = db.conversion_procs
@@ -346,6 +422,11 @@ module Sequel
           end
         end
       end
+
+      # Support regexp if using :setup_regexp_function Database option.
+      def supports_regexp?
+        db.allow_regexp?
+      end
       
       private
       

data/lib/sequel/adapters/tinytds.rb

@@ -75,7 +75,7 @@ module Sequel
                 return r.public_send(m) if m
               end
             end
-            yield(r) if block_given?
+            yield(r) if defined?(yield)
           rescue TinyTds::Error => e
             raise_error(e, :disconnect=>!c.active?)
           ensure

data/lib/sequel/adapters/trilogy.rb

@@ -0,0 +1,117 @@
+# frozen-string-literal: true
+
+require 'trilogy'
+require_relative 'shared/mysql'
+
+module Sequel
+  module Trilogy
+    class Database < Sequel::Database
+      include Sequel::MySQL::DatabaseMethods
+
+      QUERY_FLAGS = ::Trilogy::QUERY_FLAGS_CAST | ::Trilogy::QUERY_FLAGS_CAST_BOOLEANS
+      LOCAL_TIME_QUERY_FLAGS = QUERY_FLAGS | ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+
+      set_adapter_scheme :trilogy
+      
+      # Connect to the database.  See Trilogy documentation for options.
+      def connect(server)
+        opts = server_opts(server)
+        opts[:username] ||= opts.delete(:user)
+        opts[:found_rows] = true
+        conn = ::Trilogy.new(opts)
+        mysql_connection_setting_sqls.each{|sql| log_connection_yield(sql, conn){conn.query(sql)}}
+        conn
+      end
+
+      def disconnect_connection(c)
+        c.discard!
+      rescue ::Trilogy::Error
+        nil
+      end
+
+      # Execute the given SQL on the given connection and yield the result.
+      def execute(sql, opts)
+        r = synchronize(opts[:server]) do |conn|
+          log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn) do
+            conn.query_with_flags(sql, timezone.nil? || timezone == :local ? LOCAL_TIME_QUERY_FLAGS : QUERY_FLAGS)
+          end
+        end
+        yield r
+      rescue ::Trilogy::Error => e
+        raise_error(e)
+      end
+
+      def execute_dui(sql, opts=OPTS)
+        execute(sql, opts, &:affected_rows)
+      end
+
+      def execute_insert(sql, opts=OPTS)
+        execute(sql, opts, &:last_insert_id)
+      end
+
+      def freeze
+        server_version
+        super
+      end
+
+      # Return the version of the MySQL server to which we are connecting.
+      def server_version(_server=nil)
+        @server_version ||= super()
+      end
+
+      private
+
+      def database_specific_error_class(exception, opts)
+        case exception.message
+        when /1205 - Lock wait timeout exceeded; try restarting transaction\z/
+          DatabaseLockTimeout
+        else
+          super
+        end
+      end
+
+      def connection_execute_method
+        :query
+      end
+
+      def database_error_classes
+        [::Trilogy::Error]
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
+      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
+      def schema_column_type(db_type)
+        db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+
+      def fetch_rows(sql)
+        execute(sql) do |r|
+          self.columns = r.fields.map!{|c| output_identifier(c.to_s)}
+          r.each_hash{|h| yield h}
+        end
+        self
+      end
+      
+      private
+
+      def execute(sql, opts=OPTS)
+        opts = Hash[opts]
+        opts[:type] = :select
+        super
+      end
+
+      # Handle correct quoting of strings using ::Trilogy#escape.
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(v)} << "'"
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    module ColumnsLimit1
+      COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
+
+      # Use a limit of 1 instead of a limit of 0 when
+      # getting the columns.
+      def columns!
+        ds = clone(COLUMNS_CLONE_OPTIONS)
+        ds.each{break}
+
+        if cols = ds.cache[:_columns]
+          self.columns = cols
+        else
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module Sequel
         def execute(sql, opts=OPTS, &block)
           if opts[:sproc]
             call_sproc(sql, opts, &block)
-          elsif sql.is_a?(Symbol)
+          elsif sql.is_a?(Symbol) || sql.is_a?(Sequel::Dataset::ArgumentMapper)
             execute_prepared_statement(sql, opts, &block)
           else
             synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}

data/lib/sequel/ast_transformer.rb

@@ -80,6 +80,12 @@ module Sequel
         SQL::DelayedEvaluation.new(lambda{|ds| v(o.call(ds))})
       when SQL::Wrapper
         SQL::Wrapper.new(v(o.value))
+      when SQL::Expression
+        if o.respond_to?(:sequel_ast_transform)
+          o.sequel_ast_transform(method(:v))
+        else
+          o
+        end
       else
         o
       end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -55,13 +55,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # Yields the connection to the supplied block for the given server.
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default)
-    begin
-      server = pick_server(server)
-      yield(@conns[server] ||= make_new(server))
-    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
-      disconnect_server(server) if disconnect_error?(e)
-      raise
-    end
+    server = pick_server(server)
+    yield(@conns[server] ||= make_new(server))
+  rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+    disconnect_server(server) if disconnect_error?(e)
+    raise
   end
   
   # The ShardedSingleConnectionPool always has a maximum size of 1.