sequel 4.36.0 → 5.61.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
@@ -16,6 +16,19 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        # SEQUEL6: Default to ansi: true
+        if opts[:ansi]
+          sql = %w(
+            ANSI_NULLS
+            ANSI_PADDING
+            ANSI_WARNINGS
+            ANSI_NULL_DFLT_ON
+            QUOTED_IDENTIFIER
+            CONCAT_NULL_YIELDS_NULL
+          ).map{|v| "SET #{v} ON"}.join(";")
+          log_connection_yield(sql, c){c.execute(sql)}
+        end
+
         if (ts = opts[:textsize])
           sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
           log_connection_yield(sql, c){c.execute(sql)}
@@ -59,10 +72,10 @@ 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?
+            yield(r) if defined?(yield)
           rescue TinyTds::Error => e
             raise_error(e, :disconnect=>!c.active?)
           ensure
@@ -71,22 +84,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
@@ -131,10 +140,13 @@ module Sequel
         end
       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)/
+      def dataset_class_default
+        Dataset
+      end
+
       # 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) && TINYTDS_DISCONNECT_ERRORS.match(e.message)))
+        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|DBPROCESS is dead or not enabled)/.match(e.message)))
       end
 
       # Dispose of any possible results of execution.
@@ -179,16 +191,11 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
 
-      Database::DatasetClass = self
-      
-      # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
         protected
         
-        # Return a hash with the same values as the given hash,
-        # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
           hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
@@ -197,24 +204,17 @@ module Sequel
         
         private
         
-        # SQLite uses a : before the name of the argument for named
-        # arguments.
         def prepared_arg(k)
           LiteralString.new("@#{k.to_s.gsub('.', '__')}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       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 = []
@@ -243,24 +243,16 @@ module Sequel
         self
       end
       
-      # Create a named prepared statement that is stored in the
-      # database (and connection) for reuse.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.set_prepared_statement(name, ps)
-        end
-        ps
-      end
-      
       private
       
-      # Properly escape the given string +v+.
+      # Properly escape the given string
       def literal_string_append(sql, v)
-        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
-        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+        sql << (mssql_unicode_strings ? "N'" : "'")
+        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(/\\((?:\r\n)|\n)/, '\\\\\\\\\\1\\1') << "'"
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
       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/emulate_offset_with_reverse_and_count.rb

@@ -32,20 +32,17 @@ module Sequel
       row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>String.new, :placeholder_literal_null=>true).count
       dsa1 = dataset_alias(1)
 
-      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = Sequel::Dataset::PreparedStatementMethods::PLACEHOLDER_RE.match(o.to_s))
+      if o.is_a?(Symbol) && @opts[:bind_vars] && /\A\$(.*)\z/ =~ o
         # Handle use of bound variable offsets.  Unfortunately, prepared statement
         # bound variable offsets cannot be handled, since the bound variable value
         # isn't available until later.
-        s = match[1].to_sym
-        if prepared_arg?(s)
-          o = prepared_arg(s)
-        end
+        o = prepared_arg($1.to_sym)
       end
 
       reverse_offset = row_count - o
       ds = if reverse_offset > 0
         ds.limit(reverse_offset).
-          reverse_order(*order).
+          reverse(*order).
           from_self(:alias=>dsa1).
           limit(@opts[:limit]).
           order(*order)

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
@@ -36,7 +36,7 @@ module Sequel
       sql = @opts[:append_sql] || String.new
       subselect_sql_append(sql, unlimited.
         unordered.
-        select_append{ROW_NUMBER{}.over(:order=>order).as(rn)}.
+        select_append(Sequel.function(:ROW_NUMBER).over(:order=>order).as(rn)).
         from_self(:alias=>dsa1).
         select(*columns).
         limit(@opts[:limit]).

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

@@ -0,0 +1,87 @@
+# frozen-string-literal: true
+
+require_relative '../shared/mysql'
+require_relative 'stored_procedures'
+
+module Sequel
+  module MySQL
+    # This module is used by the mysql and mysql2 adapters to support
+    # prepared statements and stored procedures.
+    module MysqlMysql2
+      module DatabaseMethods
+        disconnect_errors = <<-END.split("\n").map(&:strip)
+        Commands out of sync; you can't run this command now
+        Can't connect to local MySQL server through socket
+        MySQL server has gone away
+        Lost connection to MySQL server during query
+        MySQL client is not connected
+        This connection is still waiting for a result, try again once you have the result
+        closed MySQL connection
+        The MySQL server is running with the --read-only option so it cannot execute this statement
+        Connection was killed
+        END
+        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
+       
+        # Support stored procedures on MySQL
+        def call_sproc(name, opts=OPTS, &block)
+          args = opts[:args] || [] 
+          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+        end
+        
+        # Executes the given SQL using an available connection, yielding the
+        # connection if the block is given.
+        def execute(sql, opts=OPTS, &block)
+          if opts[:sproc]
+            call_sproc(sql, opts, &block)
+          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)}
+          end
+        end
+        
+        private
+
+        def add_prepared_statements_cache(conn)
+          class << conn
+            attr_accessor :prepared_statements
+          end
+          conn.prepared_statements = {}
+        end
+
+        def database_specific_error_class(exception, opts)
+          case exception.errno
+          when 1048
+            NotNullConstraintViolation
+          when 1062
+            UniqueConstraintViolation
+          when 1451, 1452, 1216, 1217
+            ForeignKeyConstraintViolation
+          when 4025
+            CheckConstraintViolation
+          when 1205
+            DatabaseLockTimeout
+          else
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
+          "sql = @opts[:sproc_name]; opts = Hash[opts]; opts[:args] = @opts[:sproc_args]; opts[:sproc] = true",
+          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
+        
+        private
+
+        # Extend the dataset with the MySQL stored procedure methods.
+        def prepare_extend_sproc(ds)
+          ds.with_extend(StoredProcedureMethods)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen-string-literal: true
+
+module Sequel
+  module MySQL
+    module PreparedStatements
+      module DatabaseMethods
+        private
+
+        # 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.  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)
+          sql = ps.prepared_sql
+          synchronize(opts[:server]) do |conn|
+            unless conn.prepared_statements[ps_name] == sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+              conn.prepared_statements[ps_name] = sql
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql_append(sql, ds)
+            ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+              send(:to_prepared_statement, :select, nil, :extend=>bound_variable_modules).
+              prepared_sql
+          end
+        end
+        
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
+        
+        private
+
+        def bound_variable_modules
+          [CallableStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+      end
+    end
+  end
+end

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

@@ -3,9 +3,6 @@
 module Sequel
   class Dataset
     module Replace
-      INSERT = Dataset::INSERT
-      REPLACE = 'REPLACE'.freeze
-
       # Execute a REPLACE statement on the database (deletes any duplicate
       # rows before inserting).
       def replace(*values)
@@ -31,7 +28,7 @@ module Sequel
 
       # If this is an replace instead of an insert, use replace instead
       def insert_insert_sql(sql)
-        sql << (@opts[:replace] ? REPLACE : INSERT)
+        sql << (@opts[:replace] ? 'REPLACE' : 'INSERT')
       end
     end
   end

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

@@ -4,16 +4,13 @@ module Sequel
   class Dataset
     module StoredProcedureMethods
       # The name of the stored procedure to call
-      attr_accessor :sproc_name
-      
-      # The name of the stored procedure to call
-      attr_writer :sproc_args
+      def sproc_name
+        @opts[:sproc_name]
+      end
       
       # Call the stored procedure with the given args
       def call(*args, &block)
-        sp = clone
-        sp.sproc_args = args
-        sp.run(&block)
+        clone(:sproc_args=>args).run(&block)
       end
 
       # Programmer friendly string showing this is a stored procedure,
@@ -24,7 +21,7 @@ module Sequel
       
       # Run the stored procedure with the current args on the database
       def run(&block)
-        case @sproc_type
+        case @opts[:sproc_type]
         when :select, :all
           all(&block)
         when :first
@@ -37,14 +34,6 @@ module Sequel
           delete
         end
       end
-      
-      # Set the type of the stored procedure and override the corresponding _sql
-      # method to return the empty string (since the result will be
-      # ignored anyway).
-      def sproc_type=(type)
-        @sproc_type = type
-        @opts[:sql] = ''
-      end
     end
   
     module StoredProcedures
@@ -58,18 +47,14 @@ module Sequel
       # Transform this dataset into a stored procedure that you can call
       # multiple times with new arguments.
       def prepare_sproc(type, name)
-        sp = clone
-        prepare_extend_sproc(sp)
-        sp.sproc_type = type
-        sp.sproc_name = name
-        sp
+        prepare_extend_sproc(self).clone(:sproc_type=>type, :sproc_name=>name, :sql=>'')
       end
       
       private
       
       # Extend the dataset with the stored procedure methods.
       def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
+        ds.with_extend(StoredProcedureMethods)
       end
     end
   end

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

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+module Sequel
+  module UnmodifiedIdentifiers
+    module DatabaseMethods
+      private
+
+      # Databases that use this module for unquoted identifiers to lowercase.
+      def folds_unquoted_identifiers_to_uppercase?
+        false
+      end
+    end
+
+    module DatasetMethods
+      private
+
+      # Turn the given symbol/string into a symbol, keeping the current case.
+      def output_identifier(v)
+        v == '' ? :untitled : v.to_sym
+      end
+
+      # Turn the given symbol/string into a string, keeping the current case.
+      def input_identifier(v)
+        v.to_s
+      end
+    end
+  end
+end

data/lib/sequel/ast_transformer.rb

@@ -26,8 +26,14 @@ module Sequel
         h = {}
         o.each{|k, val| h[v(k)] = v(val)}
         h
+      when SQL::NumericExpression
+        if o.op == :extract
+          o.class.new(o.op, o.args[0], v(o.args[1]))
+        else
+          o.class.new(o.op, *v(o.args))
+        end
       when SQL::ComplexExpression
-        SQL::ComplexExpression.new(o.op, *v(o.args))
+        o.class.new(o.op, *v(o.args))
       when SQL::Identifier
         SQL::Identifier.new(v(o.value))
       when SQL::QualifiedIdentifier
@@ -49,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]
@@ -74,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
@@ -83,10 +95,8 @@ module Sequel
   # Handles qualifying existing datasets, so that unqualified columns
   # in the dataset are qualified with a given table name.
   class Qualifier < ASTTransformer
-    # Store the dataset to use as the basis for qualification, 
-    # and the table used to qualify unqualified columns. 
-    def initialize(ds, table)
-      @ds = ds
+    # Set the table used to qualify unqualified columns
+    def initialize(table)
       @table = table
     end
 
@@ -99,7 +109,7 @@ module Sequel
     def v(o)
       case o
       when Symbol
-        t, column, aliaz = @ds.send(:split_symbol, o)
+        t, column, aliaz = Sequel.split_symbol(o)
         if t
           o
         elsif aliaz
@@ -117,86 +127,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.filter(:a=>1).exclude(:b=>2).where{c > 3}
-  #
-  # But it cannot handle cases like:
-  #
-  #   DB.filter(: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
-      @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
 end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -19,9 +19,9 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     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
-  # at runtime. servers argument should be an array of symbols. 
+  # Adds new servers to the connection pool. Primarily used in conjunction with primary/replica
+  # or sharded configurations. Allows for dynamic expansion of the potential replicas/shards
+  # at runtime. +servers+ argument should be an array of symbols. 
   def add_servers(servers)
     servers.each{|s| @servers[s] = s}
   end
@@ -41,19 +41,25 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # :server :: Should be a symbol specifing the server to disconnect from,
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
-    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
+    (opts[:server] ? Array(opts[:server]) : servers).each do |s|
+      raise Sequel::Error, "invalid server: #{s}" unless @servers.has_key?(s)
+      disconnect_server(s)
+    end
+  end
+
+  def freeze
+    @servers.freeze
+    super
   end
   
   # 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
-      disconnect_server(server)
-      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.
@@ -61,8 +67,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)
@@ -105,6 +110,4 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = nil)
     servers.each{|s| hold(s){}}
   end
-  
-  CONNECTION_POOL_MAP[[true, true]] = self
 end