sequel 5.92.0 → 5.94.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df46d23e3607466eb34477a5ba9c31d14fd57294275088599f8ef4d561179faf
-  data.tar.gz: 9566fcb614fded77e5e20c929c9ed5cb6786e0548c3e59837ae2dd1a1877762d
+  metadata.gz: 05c58f7009f56c4891e863d95ccd90eeb7acdc03f192979ff0d4a203fa1924d4
+  data.tar.gz: 957d465eebddd41b7de48475af26b04f4ae6fb387662257b97b9bdbc682eb197
 SHA512:
-  metadata.gz: 8375cb4204be00b492b841fea5427dce809e43d119c6fd9f559cbfa1b4b9f652e752d22e52a93942a8a228166829d4227202e0f783a89f790d4fad40a8eb0963
-  data.tar.gz: 4c6bbc4bd1172ed8c5117bd628651757b8685fab754b4d664ceb3254917fbeb58d778bccd3b8dbe998e4694f185baa4e630910dc1de8fe1b5026d23e95c215b4
+  metadata.gz: eb72cd090c58b8246b4a679082f9426f9aecf2d4815dffa2d96fe3be5a15b3e41b9ae7dd17effee49bfab82ac54c11d5d7d6aa67ff2a8aa54040145f5c72a3b0
+  data.tar.gz: 031fcb089d79550e485be488ec6d4b0d84024e4f686ebe953a08189c5b9d6e490c2351246b4258d8b78e9efafd013db61738f19e40a04afbb9fb1ec1796e5e6a

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/oracle.rb

@@ -353,6 +353,20 @@ module Sequel
           i = prepared_args.length
           LiteralString.new(":#{i}")
         end
+
+        # Avoid infinite recursion on Oracle <12 for datasets with limits
+        # (which are implemented via subqueries).  If the given dataset's
+        # prepared args are the same object as current dataset's, call the
+        # standard Sequel::Dataset#subselect_sql_append method, instead
+        # of calling super (which will call prepared_sql and result in
+        # infinite recursion).
+        def subselect_sql_append(sql, ds)
+          if !supports_fetch_next_rows? && ds.opts[:prepared_args].equal?(@opts[:prepared_args])
+            orig_subselect_sql_append(sql, ds)
+          else
+            super
+          end
+        end
       end
       
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
@@ -383,6 +397,8 @@ module Sequel
 
       private
 
+      alias orig_subselect_sql_append subselect_sql_append
+
       def literal_other_append(sql, v)
         case v
         when OraDate

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
@@ -101,7 +101,7 @@ module Sequel
 
     def self.mock_adapter_setup(db)
       db.instance_exec do
-        @server_version = 150000
+        @server_version = 170000
         initialize_postgres_adapter
         extend(MockAdapterDatabaseMethods)
       end
@@ -141,6 +141,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 +346,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 +612,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 +911,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 +985,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 +1179,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
@@ -1233,9 +1297,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,7 +1333,7 @@ module Sequel
         sqls
       end
 
-      # Handle exclusion constraints.
+      # Handle PostgreSQL-specific constraint features.
       def constraint_definition_sql(constraint)
         case type = constraint[:type]
         when :exclude
@@ -1293,6 +1357,9 @@ module Sequel
           end
         else # when :foreign_key, :check
           sql = super
+          if constraint[:not_enforced]
+            sql << " NOT ENFORCED"
+          end
           if constraint[:not_valid]
             sql << " NOT VALID"
           end
@@ -1300,6 +1367,13 @@ module Sequel
         end
       end
 
+      def column_definition_add_references_sql(sql, column)
+        super
+        if column[:not_enforced]
+          sql << " NOT ENFORCED"
+        end
+      end
+
       def database_specific_error_class_from_sqlstate(sqlstate)
         if sqlstate == '23P01'
           ExclusionConstraintViolation
@@ -1369,7 +1443,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'
@@ -1888,14 +1963,66 @@ module Sequel
         super
       end
 
-      # Return the results of an EXPLAIN query as a string
+      # Return the results of an EXPLAIN query.  Boolean options:
+      #
+      # :analyze :: Use the ANALYZE option.
+      # :buffers :: Use the BUFFERS option.
+      # :costs :: Use the COSTS option.
+      # :generic_plan :: Use the GENERIC_PLAN option.
+      # :memory :: Use the MEMORY option.
+      # :settings :: Use the SETTINGS option.
+      # :summary :: Use the SUMMARY option.
+      # :timing :: Use the TIMING option.
+      # :verbose :: Use the VERBOSE option.
+      # :wal :: Use the WAL option.
+      #
+      # Non boolean options:
+      #
+      # :format :: Use the FORMAT option to change the format of the
+      #            returned value.  Values can be :text, :xml, :json,
+      #            or :yaml.
+      # :serialize :: Use the SERIALIZE option to get timing on
+      #               serialization.  Values can be :none, :text, or
+      #               :binary.
+      #
+      # See the PostgreSQL EXPLAIN documentation for an explanation of
+      # what each option does.
+      #
+      # In most cases, the return value is a single string.  However,
+      # using the <tt>format: :json</tt> option can result in the return
+      # value being an array containing a hash.
       def explain(opts=OPTS)
-        with_sql((opts[:analyze] ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ') + select_sql).map(:'QUERY PLAN').join("\r\n")
+        rows = clone(:append_sql=>explain_sql_string_origin(opts)).map(:'QUERY PLAN')
+
+        if rows.length == 1
+          rows[0]
+        elsif rows.all?{|row| String === row}
+          rows.join("\r\n") 
+        # :nocov:
+        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:
+        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
@@ -2417,7 +2544,65 @@ module Sequel
           c ||= true
         end
       end
+
+      EXPLAIN_BOOLEAN_OPTIONS = {}
+      %w[analyze verbose costs settings generic_plan buffers wal timing summary memory].each do |str|
+        EXPLAIN_BOOLEAN_OPTIONS[str.to_sym] = str.upcase.freeze
+      end
+      EXPLAIN_BOOLEAN_OPTIONS.freeze
+
+      EXPLAIN_NONBOOLEAN_OPTIONS = {
+        :serialize => {:none=>"SERIALIZE NONE", :text=>"SERIALIZE TEXT", :binary=>"SERIALIZE BINARY"}.freeze,
+        :format => {:text=>"FORMAT TEXT", :xml=>"FORMAT XML", :json=>"FORMAT JSON", :yaml=>"FORMAT YAML"}.freeze
+      }.freeze
     
+      # A mutable string used as the prefix when explaining a query.
+      def explain_sql_string_origin(opts)
+        origin = String.new
+        origin << 'EXPLAIN '
+
+        # :nocov:
+        if server_version < 90000
+          if opts[:analyze]
+            origin << 'ANALYZE '
+          end
+
+          return origin
+        end
+        # :nocov:
+
+        comma = nil
+        paren = "("
+
+        add_opt = lambda do |str, value|
+          origin << paren if paren
+          origin << comma if comma
+          origin << str
+          origin << " FALSE" unless value
+          comma ||= ', '
+          paren &&= nil
+        end
+
+        EXPLAIN_BOOLEAN_OPTIONS.each do |key, str|
+          unless (value = opts[key]).nil?
+            add_opt.call(str, value)
+          end
+        end
+
+        EXPLAIN_NONBOOLEAN_OPTIONS.each do |key, e_opts|
+          if value = opts[key]
+            if str = e_opts[value]
+              add_opt.call(str, true)
+            else
+              raise Sequel::Error, "unrecognized value for Dataset#explain #{key.inspect} option: #{value.inspect}"
+            end
+          end
+        end
+
+        origin << ') ' unless paren
+        origin
+      end
+
       # Add ON CONFLICT clause if it should be used
       def insert_conflict_sql(sql)
         if opts = @opts[:insert_conflict]
@@ -2613,8 +2798,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/timed_queue.rb

@@ -236,7 +236,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