sequel 5.106.0 → 5.109.0

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

@@ -42,7 +42,7 @@ module Sequel
       #
       # :result :: The result code of the stored procedure
       # :numrows :: The number of rows affected by the stored procedure
-      # output params :: Values for any output paramters, using the name given for the output parameter
+      # output params :: Values for any output parameters, using the name given for the output parameter
       #
       # Because Sequel datasets only support a single result set per query, and retrieving 
       # the result code and number of rows requires a query, this does not support
@@ -400,6 +400,9 @@ module Sequel
       # Error if a string is given.
       def create_table_as(name, ds, options)
         raise(Error, "must provide dataset instance as value of create_table :as option on MSSQL") unless ds.is_a?(Sequel::Dataset)
+        if options[:temp]
+          name = create_table_temp_table_name_sql(name, options)
+        end
         run(ds.into(name).sql.freeze)
       end
     
@@ -672,14 +675,17 @@ module Sequel
         end
       end
 
-      # MSSQL treats [] as a metacharacter in LIKE expresions.
+      # MSSQL treats [] as a metacharacter in LIKE expressions.
       def escape_like(string)
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
       end
    
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = OPTS)
-        terms = "\"#{Sequel.array_or_set_join(terms, '" OR "')}\"" if terms.is_a?(Array) || terms.is_a?(Set)
+        case terms
+        when Array, Set
+          terms = Sequel.array_or_set_join(terms.map{|term| "\"#{term.to_s.gsub('"', '""')}\""}, " OR ")
+        end
         where(Sequel.lit("CONTAINS (?, ?)", cols, terms))
       end
 
@@ -941,7 +947,7 @@ module Sequel
       # Allow update and delete for unordered, limited datasets only.
       def check_not_limited!(type)
         return if @opts[:skip_limit_check] && type != :truncate
-        raise Sequel::InvalidOperation, "Dataset##{type} not suppored on ordered, limited datasets" if opts[:order] && opts[:limit]
+        raise Sequel::InvalidOperation, "Dataset##{type} not supported on ordered, limited datasets" if opts[:order] && opts[:limit]
         super if type == :truncate || @opts[:offset]
       end
 
@@ -1040,7 +1046,7 @@ module Sequel
         end
       end
 
-      # MSSQL uses a literal hexidecimal number for blob strings
+      # MSSQL uses a literal hexadecimal number for blob strings
       def literal_blob_append(sql, v)
         sql << '0x' << v.unpack("H*").first
       end

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

@@ -381,7 +381,7 @@ module Sequel
         'AUTO_INCREMENT'
       end
       
-      # MySQL needs to set transaction isolation before begining a transaction
+      # MySQL needs to set transaction isolation before beginning a transaction
       def begin_new_transaction(conn, opts)
         set_transaction_isolation(conn, opts)
         log_connection_execute(conn, begin_transaction_sql)
@@ -937,7 +937,7 @@ module Sequel
       end
 
       # Check the database setting for whether fractional timestamps
-      # are suppported.
+      # are supported.
       def supports_timestamp_usecs?
         db.supports_timestamp_usecs?
       end

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

@@ -204,12 +204,12 @@ module Sequel
         @in = v
       end
 
-      # Assumes hash partitioning, sets the modulus for this parition.
+      # Assumes hash partitioning, sets the modulus for this partition.
       def modulus(v)
         @modulus = v
       end
 
-      # Assumes hash partitioning, sets the remainder for this parition.
+      # Assumes hash partitioning, sets the remainder for this partition.
       def remainder(v)
         @remainder = v
       end
@@ -346,7 +346,7 @@ module Sequel
       # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
       # :definition :: An SQL fragment for the definition of the constraint
       # :columns :: An array of column symbols for the columns referenced in the constraint,
-      #             can be an empty array if the database cannot deteremine the column symbols.
+      #             can be an empty array if the database cannot determine the column symbols.
       def check_constraints(table)
         m = output_identifier_meth
 
@@ -772,12 +772,12 @@ module Sequel
           seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq.freeze)))
           increment_by = :seqincrement
           min_value = :seqmin
-        # :nocov:
+        # simplecov:disable
         else
           seq_ds = metadata_dataset.from(LiteralString.new(seq))
           increment_by = :increment_by
           min_value = :min_value
-        # :nocov:
+        # simplecov:enable
         end
 
         get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)}
@@ -790,9 +790,9 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
-        # :nocov:
+        # simplecov:disable
         auto_increment_key = server_version >= 100002 ? :identity : :serial
-        # :nocov:
+        # simplecov:enable
         {:primary_key => true, auto_increment_key => true, :type=>Integer}
       end
 
@@ -979,12 +979,12 @@ module Sequel
         if server_version >= 90500
           cpos = Sequel.expr{array_position(co[:conkey], ctable[:attnum])}
           rpos = Sequel.expr{array_position(co[:confkey], rtable[:attnum])}
-        # :nocov:
+        # simplecov:disable
         else
           range = 0...32
           cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, ctable[:attnum])}
           rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, rtable[:attnum])}
-        # :nocov:
+        # simplecov:enable
         end
 
         ds = metadata_dataset.
@@ -1021,19 +1021,19 @@ module Sequel
       def _add_validated_enforced_constraint_columns(ds)
         validated_cond = if server_version >= 90100
           Sequel[:convalidated]
-        # :nocov:
+        # simplecov:disable
         else
           Sequel.cast(true, TrueClass)
-        # :nocov:
+        # simplecov:enable
         end
         ds = ds.select_append(validated_cond.as(:validated))
 
         enforced_cond = if server_version >= 180000
           Sequel[:conenforced]
-        # :nocov:
+        # simplecov:disable
         else
           Sequel.cast(true, TrueClass)
-        # :nocov:
+        # simplecov:enable
         end
         ds = ds.select_append(enforced_cond.as(:enforced))
 
@@ -1045,11 +1045,11 @@ module Sequel
         @_indexes_ds ||= begin
           if server_version >= 90500
             order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
-          # :nocov:
+          # simplecov:disable
           else
             range = 0...32
             order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
-          # :nocov:
+          # simplecov:enable
           end
 
           attnums = SQL::Function.new(:ANY, Sequel[:ind][:indkey])
@@ -1067,10 +1067,10 @@ module Sequel
             order(*order).
             select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
-          # :nocov:
+          # simplecov:disable
           ds = ds.where(:indisready=>true) if server_version >= 80300
           ds = ds.where(:indislive=>true) if server_version >= 90300
-          # :nocov:
+          # simplecov:enable
 
           ds
         end
@@ -1163,14 +1163,14 @@ module Sequel
             where{pg_attribute[:attnum] > 0}.
             order{pg_attribute[:attnum]}
 
-          # :nocov:
+          # simplecov:disable
           if server_version > 100000
-          # :nocov:
+          # simplecov:enable
             ds = ds.select_append{pg_attribute[:attidentity]}
 
-            # :nocov:
+            # simplecov:disable
             if server_version > 120000
-            # :nocov:
+            # simplecov:enable
               ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
             end
           end
@@ -1261,7 +1261,7 @@ module Sequel
 
       # If the :synchronous option is given and non-nil, set synchronous_commit
       # appropriately.  Valid values for the :synchronous option are true,
-      # :on, false, :off, :local, and :remote_write.
+      # :on, false, :off, :local, :remote_apply, and :remote_write.
       def begin_new_transaction(conn, opts)
         super
         if opts.has_key?(:synchronous)
@@ -1272,6 +1272,12 @@ module Sequel
             sync = :off
           when nil
             return
+          when :on, :off, :local, :remote_apply, :remote_write
+            nil
+          else
+            # SEQUEL6: raise
+            Sequel::Deprecation.deprecate("Unsupported :synchronous option given to Database#transaction: #{sync.inspect}, this will raise an error in Sequel 6.")
+            return
           end
 
           log_connection_execute(conn, "SET LOCAL synchronous_commit = #{sync}")
@@ -1526,8 +1532,14 @@ module Sequel
           if opts[:options] || opts[:format]
             options = String.new
             options << " ("
-            options << "FORMAT #{opts[:format]}" if opts[:format]
-            options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+            if format = opts[:format]
+              sql_format = format.to_s.downcase
+              unless %w[text csv json binary].freeze.include?(sql_format)
+                raise Error, "unsupported COPY TO format: #{format.inspect}"
+              end
+              options << "FORMAT #{format}"
+            end
+            options << "#{', ' if format}#{opts[:options]}" if opts[:options]
             options << ')'
           end
           table = if table.is_a?(::Sequel::Dataset)
@@ -1623,7 +1635,7 @@ module Sequel
         "#{super}#{create_table_suffix_sql(name, options)}"
       end
 
-      # Handle various PostgreSQl specific table extensions such as inheritance,
+      # Handle various PostgreSQL specific table extensions such as inheritance,
       # partitioning, tablespaces, and foreign tables.
       def create_table_suffix_sql(name, options)
         sql = String.new
@@ -1922,9 +1934,9 @@ module Sequel
             row[:auto_increment] = !!(row[:default] =~ /\A(?:nextval)/i) || identity == 'a' || identity == 'd'
           end
 
-          # :nocov:
+          # simplecov:disable
           if server_version >= 90600
-          # :nocov:
+          # simplecov:enable
             case row[:oid]
             when 1082
               row[:min_value] = MIN_DATE
@@ -2013,9 +2025,9 @@ module Sequel
     
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
-        # :nocov:
+        # simplecov:disable
         :local if server_version >= 90400
-        # :nocov:
+        # simplecov:enable
       end
     end
 
@@ -2118,12 +2130,12 @@ module Sequel
           rows[0]
         elsif rows.all?{|row| String === row}
           rows.join("\r\n") 
-        # :nocov:
+        # simplecov:disable
         else
           # This branch is unreachable in tests, but it seems better to just return
           # all rows than throw in error if this case actually happens.
           rows
-        # :nocov:
+        # simplecov:enable
         end
       end
 
@@ -2133,26 +2145,6 @@ module Sequel
         cached_lock_style_dataset(:_for_key_share_ds, :key_share)
       end
 
-      # Set FOR PORTION OF clause for UPDATE and DELETE statements.
-      # The first argument is the range or multirange column. If two arguments
-      # are provided, the second argument is an expression with the same
-      # database type as the first argument. If three arguments are provided,
-      # the second specifies the inclusive start of the portion to update and the third
-      # specifies the exclusive end of portion to update. When using the three argument
-      # form, nil can be provided as the second or third argument to have the start or
-      # end of the portion be unbounded.  Supported on PostgreSQL 19+.
-      # Example:
-      #
-      #   DB[:t].for_portion_of(:rc, Sequel.function(:int4range, 1, 2)).update(c: 3)
-      #   # UPDATE t FOR PORTION OF rc (int4range(1, 2)) SET c = 3
-      #   
-      #   DB[:t].for_portion_of(:rc, 1, 2).update(c: 3)
-      #   # UPDATE t FOR PORTION OF rc FROM 1 TO 2 SET c = 3
-      def for_portion_of(column, range, to=(arg_not_given=true))
-        range = [range, to].freeze unless arg_not_given
-        clone(:for_portion_of => [column, range].freeze)
-      end
-
       # Return a cloned dataset which will use FOR NO KEY UPDATE to lock returned rows.
       # This is generally a better choice than using for_update on PostgreSQL, unless
       # you will be deleting the row or modifying a key column. Supported on PostgreSQL 9.3+.
@@ -2245,8 +2237,11 @@ module Sequel
       # Handle uniqueness violations when inserting, by updating the conflicting row, using
       # ON CONFLICT. With no options, uses ON CONFLICT DO NOTHING.  Options:
       # :conflict_where :: The index filter, when using a partial index to determine uniqueness.
-      # :constraint :: An explicit constraint name, has precendence over :target.
+      # :constraint :: An explicit constraint name, has precedence over :target.
       # :target :: The column name or expression to handle uniqueness violations on.
+      # :select :: Use ON CONFLICT DO SELECT. This will use the dataset's lock style.
+      #            You must use #returning on this dataset when using this option.
+      # :select_where :: A WHERE condition to use for the select.
       # :update :: A hash of columns and values to set.  Uses ON CONFLICT DO UPDATE.
       # :update_where :: A WHERE condition to use for the update.
       #
@@ -2277,7 +2272,21 @@ module Sequel
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT ON CONSTRAINT table_a_uidx
       #   # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+      #   
+      #   DB[:table].returning(:a).insert_conflict(target: :a, select: true).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO SELECT RETURNING a
+      #   
+      #   DB[:table].returning(:a).for_update.
+      #     insert_conflict(target: :a, select: true, select_where: {Sequel[:excluded][:b] => 3}).
+      #     insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) DO SELECT FOR UPDATE WHERE (excluded.b = 3) RETURNING a
       def insert_conflict(opts=OPTS)
+        if opts[:select] && opts[:update]
+          raise Error, "Cannot provide both :select and :update options to insert_conflict"
+        end
+
         clone(:insert_conflict => opts)
       end
 
@@ -2518,14 +2527,14 @@ module Sequel
         server_version >= 90500
       end
 
-      # :nocov:
+      # simplecov:disable
 
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         # SEQUEL6: Remove
         true
       end
-      # :nocov:
+      # simplecov:enable
 
       # PostgreSQL 8.4+ supports WINDOW clause.
       def supports_window_clause?
@@ -2640,7 +2649,7 @@ module Sequel
       end
 
       # Use from_self for aggregate dataset using VALUES.
-      def aggreate_dataset_use_from_self?
+      def aggregate_dataset_use_from_self?
         super || @opts[:values]
       end
       
@@ -2655,11 +2664,10 @@ module Sequel
         "'%Y-%m-%d %H:%M:%S.%6N%z'"
       end
 
-      # Only include the primary table in the main delete clause.
-      # Support FOR PORTION OF.
+      # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << ' FROM '
-        table_for_portion_of_sql_append(sql)
+        source_list_append(sql, @opts[:from][0..0])
       end
 
       # Use USING to specify additional tables in a delete query
@@ -2702,7 +2710,7 @@ module Sequel
         origin = String.new
         origin << 'EXPLAIN '
 
-        # :nocov:
+        # simplecov:disable
         if server_version < 90000
           if opts[:analyze]
             origin << 'ANALYZE '
@@ -2710,7 +2718,7 @@ module Sequel
 
           return origin
         end
-        # :nocov:
+        # simplecov:enable
 
         comma = nil
         paren = "("
@@ -2744,32 +2752,6 @@ module Sequel
         origin
       end
 
-      # Add FOR PORTION OF SQL if the dataset uses it.
-      def table_for_portion_of_sql_append(sql)
-        fpo_column, fpo_range = @opts[:for_portion_of]
-        if fpo_column
-          table, aliaz = split_alias(@opts[:from].first)
-          source_list_append(sql, [table])
-          sql << ' FOR PORTION OF '
-          literal_append(sql, fpo_column)
-
-          if fpo_range.is_a?(Array)
-            fpo_start, fpo_end = fpo_range
-            sql << ' FROM '
-            literal_append(sql, fpo_start)
-            sql << ' TO '
-            literal_append(sql, fpo_end)
-          else
-            sql << ' ('
-            literal_append(sql, fpo_range)
-            sql << ')'
-          end
-          as_sql_append(sql, aliaz) if aliaz
-        else
-          source_list_append(sql, @opts[:from][0..0])
-        end
-      end
-
       # Add ON CONFLICT clause if it should be used
       def insert_conflict_sql(sql)
         if opts = @opts[:insert_conflict]
@@ -2790,13 +2772,19 @@ module Sequel
           if values = opts[:update]
             sql << " DO UPDATE SET "
             update_sql_values_hash(sql, values)
-            if update_where = opts[:update_where]
-              sql << " WHERE "
-              literal_append(sql, update_where)
-            end
+            where = opts[:update_where]
+          elsif opts[:select]
+            sql << " DO SELECT"
+            select_lock_sql(sql)
+            where = opts[:select_where]
           else
             sql << " DO NOTHING"
           end
+
+          if where
+            sql << " WHERE "
+            literal_append(sql, where)
+          end
         end
       end
 
@@ -3059,10 +3047,10 @@ module Sequel
         join_from_sql(:FROM, sql)
       end
 
-      # Support FOR PORTION OF.
+      # Only include the primary table in the main update clause
       def update_table_sql(sql)
         sql << ' '
-        table_for_portion_of_sql_append(sql)
+        source_list_append(sql, @opts[:from][0..0])
       end
     end
   end

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

@@ -305,38 +305,6 @@ module Sequel
           super(sql, :+, args)
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
-        when :LIKE, :"NOT LIKE"
-          sql << '('
-          literal_append(sql, args[0])
-          sql << (op == :LIKE ? ' REGEXP ' : ' NOT REGEXP ')
-          pattern = String.new
-          last_c = ''
-          args[1].each_char do |c|
-            if  c == '_' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.'
-            elsif c == '%' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.*'
-            elsif c == '[' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\['
-            elsif c == ']' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\]'
-            elsif c == '*' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\*'
-            elsif c == '?' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\?'
-            else
-              pattern << c
-            end
-            if c == '\\' and last_c == '\\'
-              last_c = ''
-            else
-              last_c = c
-            end
-          end
-          literal_append(sql, pattern)
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
-          sql << ')'
         when :ILIKE, :"NOT ILIKE"
           super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :extract

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

@@ -210,7 +210,7 @@ module Sequel
           if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint || op[:op] == :set_column_null}
             null_ops, ops = ops.partition{|op| op[:op] == :set_column_null}
 
-            # Apply NULL/NOT NULL ops first, since those should be purely idependent of the constraints.
+            # Apply NULL/NOT NULL ops first, since those should be purely independent of the constraints.
             null_ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
 
             # If you are just doing constraints, apply all of them at the same time,
@@ -677,14 +677,15 @@ module Sequel
         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.
+      # Return a string specifying a query explanation for a SELECT of the
+      # current dataset. Options:
+      # :query_plan :: Use EXPLAIN QUERY PLAN instead of EXPLAIN if true.
       def explain(opts=nil)
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
-        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}".freeze)
+        keyword = (opts && opts[:query_plan]) ? "EXPLAIN QUERY PLAN" : "EXPLAIN"
+        ds = db.send(:metadata_dataset).clone(:sql=>"#{keyword} #{select_sql}".freeze)
         rows = ds.all
         Sequel::PrettyTable.string(rows, ds.columns)
       end
@@ -729,7 +730,7 @@ module Sequel
 
       # Handle uniqueness violations when inserting, by using a specified
       # resolution algorithm. With no options, uses INSERT OR REPLACE. SQLite
-      # supports the following conflict resolution algoriths: ROLLBACK, ABORT,
+      # supports the following conflict resolution algorithms: ROLLBACK, ABORT,
       # FAIL, IGNORE and REPLACE.
       #
       # On SQLite 3.24.0+, you can pass a hash to use an ON CONFLICT clause.
@@ -891,7 +892,7 @@ module Sequel
       end
 
       # Use from_self for aggregate dataset using VALUES.
-      def aggreate_dataset_use_from_self?
+      def aggregate_dataset_use_from_self?
         super || @opts[:values]
       end
       

data/lib/sequel/adapters/sqlite.rb

@@ -336,16 +336,20 @@ module Sequel
           log_sql << sql
           log_sql << ")"
         end
-        if block
-          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
-        else
-          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
-          case type
-          when :insert
-            conn.last_insert_row_id
-          when :update
-            conn.changes
+        begin
+          if block
+            log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
+          else
+            log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
+            case type
+            when :insert
+              conn.last_insert_row_id
+            when :update
+              conn.changes
+            end
           end
+        ensure
+          cps.clear_bindings!
         end
       end
       

data/lib/sequel/adapters/trilogy.rb

@@ -62,7 +62,8 @@ module Sequel
       private
 
       def database_specific_error_class(exception, opts)
-        if exception.error_code == 1205
+        case exception.error_code
+        when 1205, 3572
           DatabaseLockTimeout
         else
           super

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

@@ -49,7 +49,7 @@ module Sequel
       else
         # Sequel doesn't allow a nonpositive limit.  If the offset
         # is greater than the number of rows, the empty result set
-        # shuld be returned, so use a condition that is always false.
+        # should be returned, so use a condition that is always false.
         ds.where(1=>0)
       end
       sql = @opts[:append_sql] || String.new

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

@@ -22,7 +22,17 @@ module Sequel
         END
         # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
         MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
-       
+
+        # 2027 (CR_MALFORMED_PACKET) deliberately not included (protocol error, not connection error)
+        MYSQL_DISCONNECT_ERROR_CODES = [
+          2002, # CR_CONNECTION_ERROR
+          2006, # CR_SERVER_GONE_ERROR
+          2013, # CR_SERVER_LOST
+          2014, # CR_COMMANDS_OUT_OF_SYNC
+          2055, # CR_SERVER_LOST_EXTENDED
+        ].freeze
+        private_constant :MYSQL_DISCONNECT_ERROR_CODES
+
         # Support stored procedures on MySQL
         def call_sproc(name, opts=OPTS, &block)
           args = opts[:args] || [] 

data/lib/sequel/connection_pool/sharded_single.rb

@@ -38,7 +38,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   
   # 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,
+  # :server :: Should be a symbol specifying 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 do |s|