sequel 5.93.0 → 5.95.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd35e8223b7f6d450cf4c1efeaad152236b4a1e360299aa46b03841bb45996c6
-  data.tar.gz: '096a62cc241cf6f48d0c2b3e0799402f21aa24a1196a332e022ef53ebaaeea85'
+  metadata.gz: 7a008ffa4ce90081d7259c785ca68f6f3e3209d789ce6016da8040ea89acca49
+  data.tar.gz: a9f7af4d4214ca4dd82d4909e8aa2c79c96821245f39cc34278df788ae319cb6
 SHA512:
-  metadata.gz: 0b66c7e30dfb69468ad41bfe64de4e0442ad62590ea735b2e4bb591c46b949794a7a453c21532999c89296694f0136d9353041ec56fc470ab2ba0483f0534d61
-  data.tar.gz: 978dcd457829ff39f1ae9769dc574049cf29d07a2dbc8e307aa806a7b1954cd72432257de37d9e5236269b5746f615f8d0f7feb4979e9b86b619f582344afc29
+  metadata.gz: 9aa9d1fb1cb8a0a323331b2cdccc48b51b5b9f38289be280f693e0b998747d6c7a5e204c29c13cb89bd50caeb5bde604527eb8966249edfe3ab0866bb039bdf2
+  data.tar.gz: 894997717d624f602d9dbfaa554ac03270a50a69f5da6982fd687101af95e94c02a3c82b0fbe9e5ec8a5c4d39265fb4e18d9b9f706be216fccc7c45cd72a00ce

data/lib/sequel/adapters/ado/access.rb

@@ -281,7 +281,7 @@ module Sequel
           fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 
             rows << AdoSchema::Column.new(row)
           end
-          rows.sort!{|a,b| a["ORDINAL_POSITION"] <=> b["ORDINAL_POSITION"]}
+          rows.sort_by! { |a| a["ORDINAL_POSITION"] }
         end
         
         def ado_schema_foreign_keys(table_name)
@@ -289,7 +289,7 @@ module Sequel
           fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 
             rows << row
           end
-          rows.sort!{|a,b| a["ORDINAL"] <=> b["ORDINAL"]}
+          rows.sort_by! { |a| a["ORDINAL"] }
         end
         
         def fetch_ado_schema(type, criteria=[])

data/lib/sequel/adapters/ado.rb

@@ -234,7 +234,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ /Communication link failure/)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message.include?('Communication link failure'))
       end
 
       def rollback_transaction(conn, opts=OPTS)

data/lib/sequel/adapters/ibmdb.rb

@@ -324,7 +324,7 @@ module Sequel
         when Numeric
           v.to_s
         when Date, Time
-          literal(v).gsub("'", '')
+          literal(v).delete("'")
         else
           v
         end

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

@@ -26,7 +26,7 @@ module Sequel
 
         # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
         def disconnect_error?(exception, opts)
-          exception.message =~ /\ACommunications link failure/ || super
+          exception.message.start_with?("Communications link failure") || super
         end
 
         # Get the last inserted id using LAST_INSERT_ID().
@@ -64,7 +64,7 @@ module Sequel
 
         # Convert tinyint(1) type to boolean
         def schema_column_type(db_type)
-          db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+          db_type.start_with?("tinyint(1)") ? :boolean : super
         end
       
         # Run the default connection setting SQL statements.

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

@@ -55,7 +55,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || exception.message =~ /\AClosed Connection/
+          super || exception.message.start_with?("Closed Connection")
         end
 
         # Default the fetch size for statements to 100, similar to the oci8-based oracle adapter.

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

@@ -98,7 +98,7 @@ module Sequel
 
         # Whether the given exception is due to a foreign key error.
         def foreign_key_error?(exception)
-          exception.message =~ /query does not return ResultSet/
+          exception.message.include?('query does not return ResultSet')
         end
 
         # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.

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

@@ -84,7 +84,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || (exception.message =~ /connection is closed/)
+          super || (exception.message.include?('connection is closed'))
         end
       end
     end

data/lib/sequel/adapters/jdbc.rb

@@ -305,17 +305,31 @@ module Sequel
         m = output_identifier_meth
         schema, table = metadata_schema_and_table(table, opts)
         foreign_keys = {}
+
         metadata(:getImportedKeys, nil, schema, table) do |r|
-          if fk = foreign_keys[r[:fk_name]]
-            fk[:columns] << [r[:key_seq], m.call(r[:fkcolumn_name])]
-            fk[:key] << [r[:key_seq], m.call(r[:pkcolumn_name])]
-          elsif r[:fk_name]
-            foreign_keys[r[:fk_name]] = {:name=>m.call(r[:fk_name]), :columns=>[[r[:key_seq], m.call(r[:fkcolumn_name])]], :table=>m.call(r[:pktable_name]), :key=>[[r[:key_seq], m.call(r[:pkcolumn_name])]]}
+          next unless fk_name = r[:fk_name]
+
+          key_seq = r[:key_seq]
+          columns = [key_seq, m.call(r[:fkcolumn_name])]
+          key = [key_seq, m.call(r[:pkcolumn_name])]
+
+          if fk = foreign_keys[fk_name]
+            fk[:columns] << columns
+            fk[:key] << key
+          else
+            foreign_keys[fk_name] = {
+              :name=>m.call(fk_name),
+              :columns=>[columns],
+              :table=>m.call(r[:pktable_name]),
+              :key=>[key]
+            }
           end
         end
+
+        fk_keys = [:columns, :key]
         foreign_keys.values.each do |fk|
-          [:columns, :key].each do |k|
-            fk[k] = fk[k].sort.map{|_, v| v}
+          fk_keys.each do |k|
+            fk[k].sort!.map!{|_, v| v}
           end
         end
       end

data/lib/sequel/adapters/mysql.rb

@@ -290,7 +290,7 @@ module Sequel
       
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        convert_tinyint_to_bool && db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        convert_tinyint_to_bool && db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
     

data/lib/sequel/adapters/mysql2.rb

@@ -221,13 +221,13 @@ module Sequel
         super ||
           ((conn = opts[:conn]) && !conn.ping) ||
           (e.is_a?(::Mysql2::Error) &&
-            (e.sql_state =~ /\A08/ ||
+            ((e.sql_state && e.sql_state.start_with?("08")) ||
              MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)))
       end
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        convert_tinyint_to_bool && db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        convert_tinyint_to_bool && db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
 

data/lib/sequel/adapters/odbc.rb

@@ -81,7 +81,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::ODBC::Error) && /\A08S01/.match(e.message))
+        super || (e.is_a?(::ODBC::Error) && e.message.start_with?("08S01"))
       end
     end
     

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

@@ -108,7 +108,7 @@ module Sequel
         from(name).first
         true
       rescue DatabaseError => e
-        if e.to_s =~ /Operation not allowed for reason code "7" on table/ && v == false
+        if e.to_s.include?('Operation not allowed for reason code "7" on table') && v == false
           # table probably needs reorg
           reorg(name)
           v = true
@@ -175,8 +175,13 @@ module Sequel
       # Supply columns with NOT NULL if they are part of a composite
       # primary key or unique constraint
       def column_list_sql(g)
-        ks = []
-        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :unique].include?(c[:type])} 
+        ks = {}
+        g.constraints.each do |c|
+          case c[:type]
+          when :primary_key, :unique
+            c[:columns].each{|c| ks[c] = true}
+          end
+        end
         g.columns.each{|c| c[:null] = false if ks.include?(c[:name]) }
         super
       end

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

@@ -705,7 +705,7 @@ module Sequel
 
       # Allows you to do a dirty read of uncommitted data using WITH (NOLOCK).
       def nolock
-        lock_style(:dirty)
+        cached_lock_style_dataset(:_nolock_ds, :dirty)
       end
 
       # Uses OUTER APPLY to join the given table into the current dataset.

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

@@ -456,7 +456,7 @@ module Sequel
               [pk]
             elsif !(pkc = generator.constraints.select{|con| con[:type] == :primary_key}).empty?
               pkc.first[:columns]
-            elsif !(pkc = generator.columns.select{|con| con[:primary_key] == true}).empty?
+            elsif !(pkc = generator.columns.select{|con| con[:primary_key]}).empty?
               pkc.map{|c| c[:name]}
             end
           else
@@ -787,7 +787,7 @@ module Sequel
 
       # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
       def for_share
-        lock_style(:share)
+        cached_lock_style_dataset(:_for_share_ds, :share)
       end
 
       # Adds full text filter

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

@@ -48,7 +48,7 @@ module Sequel
     TYPE_TRANSLATOR_DATE = date.freeze
     bytea = Object.new
     def bytea.call(str)
-      str = if str =~ /\A\\x/
+      str = if str.start_with?('\\x')
         # PostgreSQL 9.0+ bytea hex format
         str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
       else
@@ -124,6 +124,8 @@ module Sequel
       #
       # Options supported:
       #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
       # :name :: Name the constraint with the given name (useful if you may
       #          need to drop the constraint later)
       # :using :: Override the index_method for the exclusion constraint (defaults to gist).
@@ -141,6 +143,17 @@ module Sequel
         @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge!(opts)
       end
 
+      # Alter an existing constraint.  Options:
+      # :deferrable :: Modify deferrable setting for constraint (PostgreSQL 9.4+):
+      #                true :: DEFERRABLE INITIALLY DEFERRED
+      #                false :: NOT DEFERRABLE
+      #                :immediate :: DEFERRABLE INITIALLY IMMEDIATE
+      # :enforced :: Set true to use ENFORCED, or false to use NOT ENFORCED (PostgreSQL 18+)
+      # :inherit :: Set true to use INHERIT, or false to use NO INHERIT (PostgreSQL 18+)
+      def alter_constraint(name, opts=OPTS)
+        @operations << {:op => :alter_constraint, :name => name}.merge!(opts)
+      end
+
       # Validate the constraint with the given name, which should have
       # been added previously with NOT VALID.
       def validate_constraint(name)
@@ -335,7 +348,7 @@ module Sequel
         hash = {}
         _check_constraints_ds.where_each(:conrelid=>regclass_oid(table)) do |row|
           constraint = m.call(row[:constraint])
-          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[], :validated=>row[:validated], :enforced=>row[:enforced]}
           entry[:columns] << m.call(row[:column]) if row[:column]
         end
         
@@ -601,6 +614,8 @@ module Sequel
               :on_update=>fklod_map[row[:on_update]],
               :on_delete=>fklod_map[row[:on_delete]],
               :deferrable=>row[:deferrable],
+              :validated=>row[:validated],
+              :enforced=>row[:enforced],
               :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table]),
             }
 
@@ -898,11 +913,15 @@ module Sequel
 
       # Dataset used to retrieve CHECK constraint information
       def _check_constraints_ds
-        @_check_constraints_ds ||= metadata_dataset.
-          from{pg_constraint.as(:co)}.
-          left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
-          where(:contype=>'c').
-          select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+        @_check_constraints_ds ||= begin
+          ds = metadata_dataset.
+            from{pg_constraint.as(:co)}.
+            left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+            where(:contype=>'c').
+            select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+
+          _add_validated_enforced_constraint_columns(ds)
+        end
       end
 
       # Dataset used to retrieve foreign keys referenced by a table
@@ -968,6 +987,28 @@ module Sequel
           ds = ds.order_append(Sequel[:nsp][:nspname], Sequel[:cl2][:relname])
         end
 
+        _add_validated_enforced_constraint_columns(ds)
+      end
+
+      def _add_validated_enforced_constraint_columns(ds)
+        validated_cond = if server_version >= 90100
+          Sequel[:convalidated]
+        # :nocov:
+        else
+          Sequel.cast(true, TrueClass)
+        # :nocov:
+        end
+        ds = ds.select_append(validated_cond.as(:validated))
+
+        enforced_cond = if server_version >= 180000
+          Sequel[:conenforced]
+        # :nocov:
+        else
+          Sequel.cast(true, TrueClass)
+        # :nocov:
+        end
+        ds = ds.select_append(enforced_cond.as(:enforced))
+
         ds
       end
 
@@ -1140,6 +1181,31 @@ module Sequel
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
 
+      def alter_table_alter_constraint_sql(table, op)
+        sql = String.new
+        sql << "ALTER CONSTRAINT #{quote_identifier(op[:name])}"
+        
+        constraint_deferrable_sql_append(sql, op[:deferrable])
+
+        case op[:enforced]
+        when nil
+        when false
+          sql << " NOT ENFORCED"
+        else
+          sql << " ENFORCED"
+        end
+
+        case op[:inherit]
+        when nil
+        when false
+          sql << " NO INHERIT"
+        else
+          sql << " INHERIT"
+        end
+
+        sql
+      end
+
       def alter_table_generator_class
         Postgres::AlterTableGenerator
       end
@@ -1190,6 +1256,22 @@ module Sequel
         end
       end
 
+      def column_definition_append_include_sql(sql, constraint)
+        if include_cols = constraint[:include]
+          sql << " INCLUDE " << literal(Array(include_cols))
+        end
+      end
+    
+      def column_definition_append_primary_key_sql(sql, constraint)
+        super
+        column_definition_append_include_sql(sql, constraint)
+      end
+
+      def column_definition_append_unique_sql(sql, constraint)
+        super
+        column_definition_append_include_sql(sql, constraint)
+      end
+
       # Literalize non-String collate options. This is because unquoted collatations
       # are folded to lowercase, and PostgreSQL used mixed case or capitalized collations.
       def column_definition_collate_sql(sql, column)
@@ -1233,9 +1315,9 @@ module Sequel
       end
 
       # PostgreSQL can't combine rename_column operations, and it can combine
-      # the custom validate_constraint operation.
+      # validate_constraint and alter_constraint operations.
       def combinable_alter_table_op?(op)
-        (super || op[:op] == :validate_constraint) && op[:op] != :rename_column
+        (super || op[:op] == :validate_constraint || op[:op] == :alter_constraint) && op[:op] != :rename_column
       end
 
       VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze.each(&:freeze)
@@ -1269,30 +1351,49 @@ module Sequel
         sqls
       end
 
-      # Handle exclusion constraints.
+      # Handle PostgreSQL-specific constraint features.
       def constraint_definition_sql(constraint)
         case type = constraint[:type]
         when :exclude
           elements = constraint[:elements].map{|c, op| "#{literal(c)} WITH #{op}"}.join(', ')
           sql = String.new
-          sql << "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
+          sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
+          sql << "EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})"
+          column_definition_append_include_sql(sql, constraint)
+          sql << " WHERE #{filter_expr(constraint[:where])}" if constraint[:where]
           constraint_deferrable_sql_append(sql, constraint[:deferrable])
           sql
         when :primary_key, :unique
+          sql = String.new
+          sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
+
+          if type == :primary_key
+            sql << primary_key_constraint_sql_fragment(constraint)
+          else
+            sql << unique_constraint_sql_fragment(constraint)
+          end
+
           if using_index = constraint[:using_index]
-            sql = String.new
-            sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
-            if type == :primary_key
-              sql << primary_key_constraint_sql_fragment(constraint)
-            else
-              sql << unique_constraint_sql_fragment(constraint)
-            end
             sql << " USING INDEX " << quote_identifier(using_index)
           else
-            super
+            cols = literal(constraint[:columns])
+            cols.insert(-2, " WITHOUT OVERLAPS") if constraint[:without_overlaps]
+            sql << " " << cols
+
+            if include_cols = constraint[:include]
+              sql << " INCLUDE " << literal(Array(include_cols))
+            end
           end
+
+          sql
         else # when :foreign_key, :check
           sql = super
+          if constraint[:no_inherit]
+            sql << " NO INHERIT"
+          end
+          if constraint[:not_enforced]
+            sql << " NOT ENFORCED"
+          end
           if constraint[:not_valid]
             sql << " NOT VALID"
           end
@@ -1300,6 +1401,46 @@ module Sequel
         end
       end
 
+      def column_definition_add_references_sql(sql, column)
+        super
+        if column[:not_enforced]
+          sql << " NOT ENFORCED"
+        end
+      end
+
+      def column_definition_null_sql(sql, column)
+        constraint = column[:not_null]
+        constraint = nil unless constraint.is_a?(Hash)
+        if constraint && (name = constraint[:name])
+          sql << " CONSTRAINT #{quote_identifier(name)}"
+        end
+        super
+        if constraint && constraint[:no_inherit]
+          sql << " NO INHERIT"
+        end
+      end
+
+      # Handle :period option
+      def column_references_table_constraint_sql(constraint)
+        sql = String.new
+        sql << "FOREIGN KEY "
+        cols = constraint[:columns]
+        cols = column_references_add_period(cols) if constraint[:period]
+        sql << literal(cols) << column_references_sql(constraint)
+      end
+
+      def column_references_append_key_sql(sql, column)
+        cols = Array(column[:key])
+        cols = column_references_add_period(cols) if column[:period]
+        sql << "(#{cols.map{|x| quote_identifier(x)}.join(', ')})"
+      end
+
+      def column_references_add_period(cols)
+        cols= cols.dup
+        cols[-1] = Sequel.lit("PERIOD #{quote_identifier(cols[-1])}")
+        cols
+      end
+  
       def database_specific_error_class_from_sqlstate(sqlstate)
         if sqlstate == '23P01'
           ExclusionConstraintViolation
@@ -1369,7 +1510,8 @@ module Sequel
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts=OPTS)
         args = opts[:args]
-        if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
+        in_out = %w'OUT INOUT'
+        if (!opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 && in_out.include?(a[2].to_s)})
           returns = opts[:returns] || 'void'
         end
         language = opts[:language] || 'SQL'
@@ -1816,6 +1958,15 @@ module Sequel
         end
       end
 
+      # Support :nulls_not_distinct option.
+      def unique_constraint_sql_fragment(constraint)
+        if constraint[:nulls_not_distinct]
+          'UNIQUE NULLS NOT DISTINCT'
+        else
+          'UNIQUE'
+        end
+      end
+    
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
         # :nocov:
@@ -1932,9 +2083,22 @@ module Sequel
         end
       end
 
+      # Return a cloned dataset which will use FOR KEY SHARE to lock returned rows.
+      # Supported on PostgreSQL 9.3+.
+      def for_key_share
+        cached_lock_style_dataset(:_for_key_share_ds, :key_share)
+      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+.
+      def for_no_key_update
+        cached_lock_style_dataset(:_for_no_key_update_ds, :no_key_update)
+      end
+
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
       def for_share
-        lock_style(:share)
+        cached_lock_style_dataset(:_for_share_ds, :share)
       end
 
       # Run a full text search on PostgreSQL.  By default, searching for the inclusion
@@ -2710,8 +2874,13 @@ module Sequel
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         lock = @opts[:lock]
-        if lock == :share
+        case lock
+        when :share
           sql << ' FOR SHARE'
+        when :no_key_update
+          sql << ' FOR NO KEY UPDATE'
+        when :key_share
+          sql << ' FOR KEY SHARE'
         else
           super
         end

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

@@ -95,14 +95,14 @@ module Sequel
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
           if opts[:only_autocreated]
             # If specifically asked for only autocreated indexes, then return those an only those
-            next unless r[:name] =~ /\Asqlite_autoindex_/
+            next unless r[:name].start_with?('sqlite_autoindex_')
           elsif r.has_key?(:origin)
             # If origin is set, then only exclude primary key indexes and partial indexes
             next if r[:origin] == 'pk'
             next if r[:partial].to_i == 1
           else
             # When :origin key not present, assume any autoindex could be a primary key one and exclude it
-            next if r[:name] =~ /\Asqlite_autoindex_/
+            next if r[:name].start_with?('sqlite_autoindex_')
           end
 
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
@@ -302,7 +302,7 @@ module Sequel
 
       # A name to use for the backup table
       def backup_table_name(table, opts=OPTS)
-        table = table.gsub('`', '')
+        table = table.delete('`')
         (opts[:times]||1000).times do |i|
           table_name = "#{table}_backup#{i}"
           return table_name unless table_exists?(table_name)

data/lib/sequel/adapters/tinytds.rb

@@ -14,7 +14,7 @@ module Sequel
         opts = server_opts(server)
         opts[:username] = opts[:user]
         c = TinyTds::Client.new(opts)
-        c.query_options.merge!(:cache_rows=>false)
+        c.query_options[:cache_rows] = false
 
         # SEQUEL6: Default to ansi: true
         if opts[:ansi]

data/lib/sequel/adapters/trilogy.rb

@@ -83,7 +83,7 @@ module Sequel
 
       # 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
+        db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
 

data/lib/sequel/connection_pool/sharded_timed_queue.rb

@@ -140,6 +140,12 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection for the given
+  # server.
+  def num_waiting(server=:default)
+    @queues[pick_server(server)].num_waiting
+  end
+
   # The total number of connections in the pool. Using a non-existant server will return nil.
   def size(server=:default)
     sync{@sizes[server]}

data/lib/sequel/connection_pool/timed_queue.rb

@@ -102,6 +102,11 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection.
+  def num_waiting(_server=:default)
+    @queue.num_waiting
+  end
+
   def pool_type
     :timed_queue
   end
@@ -236,7 +241,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = false)
     if concurrent
       if times = sync{@max_size > (size = @size[0]) ? @max_size - size : false}
-        times.times.map{Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
+        Array.new(times){Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
       end
     else
       while conn = try_make_new

data/lib/sequel/core.rb

@@ -403,7 +403,7 @@ module Sequel
       when -1, 0
         vr.instance_exec(&block)
       else
-        block.call(vr)
+        yield(vr)
       end  
     end