activerecord 8.0.0 → 8.1.4

data/lib/active_record/connection_adapters/mysql2/database_statements.rb

@@ -48,30 +48,64 @@ module ActiveRecord
             # made since we established the connection
             raw_connection.query_options[:database_timezone] = default_timezone
 
-            result = if prepare
-              stmt = @statements[sql] ||= raw_connection.prepare(sql)
+            result = nil
+            if binds.nil? || binds.empty?
+              result = raw_connection.query(sql)
+              # Ref: https://github.com/brianmario/mysql2/pull/1383
+              # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
+              # from that same connection was GCed while `#query` released the GVL.
+              # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
+              # of hitting the bug.
+              @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
+            elsif prepare
+              retry_count = 1
+              begin
+                stmt = @statements[sql] ||= raw_connection.prepare(sql)
+                result = stmt.execute(*type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
+              rescue ::Mysql2::Error => error
+                @statements.delete(sql)
+                # Sometimes for an unknown reason, we get that error.
+                # It suggest somehow that the prepared statement was deallocated
+                # but the client doesn't know it.
+                # But we know that this error is safe to retry, so we do so after
+                # getting rid of the originally cached statement.
+                if error.error_number == Mysql2Adapter::ER_UNKNOWN_STMT_HANDLER
+                  if retry_count.positive?
+                    retry_count -= 1
+                    retry
+                  end
+                end
+                raise
+              end
+            else
+              stmt = raw_connection.prepare(sql)
 
               begin
-                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                  stmt.execute(*type_casted_binds)
+                result = stmt.execute(*type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
+
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # by eagerly closing uncached prepared statements, we also reduce the chances of
+                # that bug happening. It can still happen if `#execute` is used as we have no callback
+                # to eagerly close the statement.
+                if result
+                  result.instance_variable_set(:@_ar_stmt_to_close, stmt)
+                else
+                  stmt.close
                 end
               rescue ::Mysql2::Error
-                @statements.delete(sql)
                 stmt.close
                 raise
               end
-              verified!
-            else
-              raw_connection.query(sql)
             end
 
+            notification_payload[:affected_rows] = @affected_rows_before_warnings
             notification_payload[:row_count] = result&.size || 0
 
-            @affected_rows_before_warnings = raw_connection.affected_rows
             raw_connection.abandon_results!
 
             verified!
-            handle_warnings(sql)
             result
           ensure
             if reset_multi_statement && active?
@@ -79,17 +113,34 @@ module ActiveRecord
             end
           end
 
-          def cast_result(result)
-            if result.nil? || result.fields.empty?
-              ActiveRecord::Result.empty
+          def cast_result(raw_result)
+            return ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings) if raw_result.nil?
+
+            fields = raw_result.fields
+
+            result = if fields.empty?
+              ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings)
             else
-              ActiveRecord::Result.new(result.fields, result.to_a)
+              ActiveRecord::Result.new(fields, raw_result.to_a)
             end
+
+            free_raw_result(raw_result)
+
+            result
           end
 
-          def affected_rows(result)
+          def affected_rows(raw_result)
+            free_raw_result(raw_result) if raw_result
+
             @affected_rows_before_warnings
           end
+
+          def free_raw_result(raw_result)
+            raw_result.free
+            if stmt = raw_result.instance_variable_get(:@_ar_stmt_to_close)
+              stmt.close
+            end
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -13,6 +13,7 @@ module ActiveRecord
       ER_BAD_DB_ERROR           = 1049
       ER_DBACCESS_DENIED_ERROR  = 1044
       ER_ACCESS_DENIED_ERROR    = 1045
+      ER_UNKNOWN_STMT_HANDLER   = 1243
       ER_CONN_HOST_ERROR        = 2003
       ER_UNKNOWN_HOST_ERROR     = 2005
 
@@ -91,8 +92,6 @@ module ActiveRecord
         true
       end
 
-      # HELPER METHODS ===========================================
-
       def error_number(exception)
         exception.error_number if exception.respond_to?(:error_number)
       end
@@ -106,7 +105,14 @@ module ActiveRecord
       end
 
       def active?
-        connected? && @lock.synchronize { @raw_connection&.ping } || false
+        if connected?
+          @lock.synchronize do
+            if @raw_connection&.ping
+              verified!
+              true
+            end
+          end
+        end || false
       end
 
       alias :reset! :reconnect!

data/lib/active_record/connection_adapters/pool_config.rb

@@ -5,9 +5,8 @@ module ActiveRecord
     class PoolConfig # :nodoc:
       include MonitorMixin
 
-      attr_reader :db_config, :role, :shard
+      attr_reader :db_config, :role, :shard, :connection_descriptor
       attr_writer :schema_reflection, :server_version
-      attr_accessor :connection_class
 
       def schema_reflection
         @schema_reflection ||= SchemaReflection.new(db_config.lazy_schema_cache_path)
@@ -29,7 +28,7 @@ module ActiveRecord
       def initialize(connection_class, db_config, role, shard)
         super()
         @server_version = nil
-        @connection_class = connection_class
+        self.connection_descriptor = connection_class
         @db_config = db_config
         @role = role
         @shard = shard
@@ -41,11 +40,12 @@ module ActiveRecord
         @server_version || synchronize { @server_version ||= connection.get_database_version }
       end
 
-      def connection_name
-        if connection_class.primary_class?
-          "ActiveRecord::Base"
+      def connection_descriptor=(connection_descriptor)
+        case connection_descriptor
+        when ConnectionHandler::ConnectionDescriptor
+          @connection_descriptor = connection_descriptor
         else
-          connection_class.name
+          @connection_descriptor = ConnectionHandler::ConnectionDescriptor.new(connection_descriptor.name, connection_descriptor.primary_class?)
         end
       end
 

data/lib/active_record/connection_adapters/postgresql/column.rb

@@ -30,6 +30,10 @@ module ActiveRecord
           @generated.present?
         end
 
+        def virtual_stored?
+          @generated == "s"
+        end
+
         def has_default?
           super && !virtual?
         end
@@ -65,7 +69,8 @@ module ActiveRecord
           other.is_a?(Column) &&
             super &&
             identity? == other.identity? &&
-            serial? == other.serial?
+            serial? == other.serial? &&
+            virtual? == other.virtual?
         end
         alias :eql? :==
 
@@ -73,7 +78,8 @@ module ActiveRecord
           Column.hash ^
             super.hash ^
             identity?.hash ^
-            serial?.hash
+            serial?.hash ^
+            virtual?.hash
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -11,8 +11,8 @@ module ActiveRecord
         end
 
         # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) # :nodoc:
-          result = internal_execute(sql, name)
+        def query(sql, name = nil, allow_retry: true, materialize_transactions: true) # :nodoc:
+          result = internal_execute(sql, name, allow_retry:, materialize_transactions:)
           result.map_types!(@type_map_for_results).values
         end
 
@@ -27,21 +27,6 @@ module ActiveRecord
           !READ_QUERY.match?(sql.b)
         end
 
-        # Executes an SQL statement, returning a PG::Result object on success
-        # or raising a PG::Error exception otherwise.
-        #
-        # Setting +allow_retry+ to true causes the db to reconnect and retry
-        # executing the SQL statement in case of a connection-related exception.
-        # This option should only be enabled for known idempotent queries.
-        #
-        # Note: the PG::Result object is manually memory managed; if you don't
-        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
-        def execute(...) # :nodoc:
-          super
-        ensure
-          @notice_receiver_sql_warnings = []
-        end
-
         def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
           if use_insert_returning? || pk == false
             super
@@ -127,7 +112,14 @@ module ActiveRecord
           def cancel_any_running_query
             return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
 
-            @raw_connection.cancel
+            # Skip @raw_connection.cancel (PG::Connection#cancel) when using libpq >= 18 with pg < 1.6.0,
+            # because the pg gem cannot obtain the backend_key in that case.
+            # This method is only called from exec_rollback_db_transaction and exec_restart_db_transaction.
+            # Even without cancel, rollback will still run. However, since any running
+            # query must finish first, the rollback may take longer.
+            if !(PG.library_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0"))
+              @raw_connection.cancel
+            end
             @raw_connection.block
           rescue PG::Error
           end
@@ -163,25 +155,27 @@ module ActiveRecord
             end
 
             verified!
-            handle_warnings(result)
-            notification_payload[:row_count] = result.count
+
+            notification_payload[:affected_rows] = result.cmd_tuples
+            notification_payload[:row_count] = result.ntuples
             result
           end
 
           def cast_result(result)
-            if result.fields.empty?
-              result.clear
-              return ActiveRecord::Result.empty
-            end
+            ar_result = if result.fields.empty?
+              ActiveRecord::Result.empty(affected_rows: result.cmd_tuples)
+            else
+              fields = result.fields
+              types = Array.new(fields.size)
+              fields.size.times do |index|
+                ftype = result.ftype(index)
+                fmod  = result.fmod(index)
+                types[index] = get_oid_type(ftype, fmod, fields[index])
+              end
 
-            types = {}
-            fields = result.fields
-            fields.each_with_index do |fname, i|
-              ftype = result.ftype i
-              fmod  = result.fmod i
-              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
+              ActiveRecord::Result.new(fields, result.values, types.freeze, affected_rows: result.cmd_tuples)
             end
-            ar_result = ActiveRecord::Result.new(fields, result.values, types.freeze)
+
             result.clear
             ar_result
           end
@@ -213,8 +207,10 @@ module ActiveRecord
             pk unless pk.is_a?(Array)
           end
 
-          def handle_warnings(sql)
-            @notice_receiver_sql_warnings.each do |warning|
+          def handle_warnings(result, sql)
+            warnings, @notice_receiver_sql_warnings = @notice_receiver_sql_warnings, []
+
+            warnings.each do |warning|
               next if warning_ignored?(warning)
 
               warning.sql = sql

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -16,8 +16,8 @@ module ActiveRecord
             @subtype = subtype
             @delimiter = delimiter
 
-            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
-            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_encoder = PG::TextEncoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
+            @pg_decoder = PG::TextDecoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
           end
 
           def deserialize(value)

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -14,7 +14,10 @@ module ActiveRecord
           end
 
           def type_cast_for_schema(value)
-            value.inspect.gsub("Infinity", "::Float::INFINITY")
+            from = bound_for_schema(value.begin)
+            to   = bound_for_schema(value.end)
+            op   = value.exclude_end? ? "..." : ".."
+            "#{from}#{op}#{to}"
           end
 
           def cast_value(value)
@@ -58,6 +61,19 @@ module ActiveRecord
           end
 
           private
+            def bound_for_schema(bound)
+              case bound
+              when nil
+                "nil"
+              when ::Float::INFINITY
+                "::Float::INFINITY"
+              when -::Float::INFINITY
+                "-::Float::INFINITY"
+              else
+                @subtype.type_cast_for_schema(bound)
+              end
+            end
+
             def type_cast_single(value)
               infinity?(value) ? value : @subtype.deserialize(value)
             end
@@ -67,7 +83,7 @@ module ActiveRecord
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",", 2)
+              from, to = split_bounds(value[1..-2])
               {
                 from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
                 to:            (to == "" || to == "infinity") ? infinity : unquote(to),
@@ -76,6 +92,33 @@ module ActiveRecord
               }
             end
 
+            # Matches the comma-separated lower and upper bounds of a range's
+            # textual representation when a bound is double-quoted. A quoted
+            # bound can itself contain a comma, so a naive split on the first
+            # comma would corrupt such values. Within a double-quoted bound,
+            # literal " and \ are escaped (as "" / \" and \\ respectively), so
+            # those escapes are skipped while scanning for the separating comma.
+            #
+            # An unquoted bound never contains a comma or a double-quote
+            # (PostgreSQL quotes the whole bound when it would), so the
+            # alternation matches an unquoted run with [^,"] rather than [^,].
+            # Excluding " keeps the two alternatives mutually exclusive, which
+            # removes any ambiguity over how a "-prefixed bound is consumed. The
+            # /m flag lets the captured upper bound (and quoted bounds) span
+            # newlines.
+            BOUNDS = /\A((?:"(?:[^"\\]|""|\\.)*"|[^,"])*),(.*)\z/m # :nodoc:
+
+            def split_bounds(value)
+              # Fast path: an unquoted representation (every built-in range
+              # type -- int/num/date/timestamp) has no embedded comma, so a
+              # plain split is correct and avoids the regexp. Only quoted
+              # bounds (custom text/varchar/money/... ranges) need the
+              # comma-skipping scan.
+              return value.split(",", 2) unless value.include?('"')
+
+              (match = BOUNDS.match(value)) ? [match[1], match[2]] : [value, nil]
+            end
+
             INFINITE_FLOAT_RANGE = (-::Float::INFINITY)..(::Float::INFINITY) # :nodoc:
 
             def sanitize_bounds(from, to)
@@ -94,7 +137,7 @@ module ActiveRecord
             # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
             # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
             def unquote(value)
-              if value.start_with?('"') && value.end_with?('"')
+              if value && value.start_with?('"') && value.end_with?('"')
                 unquoted_value = value[1..-2]
                 unquoted_value.gsub!('""', '"')
                 unquoted_value.gsub!("\\\\", "\\")

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -68,7 +68,7 @@ module ActiveRecord
 
             def register_array_type(row)
               register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
-                OID::Array.new(subtype, row["typdelim"])
+                OID::Array.new(subtype, row["typdelim"].freeze)
               end
             end
 

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -153,14 +153,15 @@ module ActiveRecord
           "'#{escape_bytea(value.to_s)}'"
         end
 
+        # `column` may be either an instance of Column or ColumnDefinition.
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
           elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
-            type = lookup_cast_type_from_column(column)
-            quote(type.serialize(value))
+            # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+            quote(column.fetch_cast_type(self).serialize(value))
           else
             super
           end
@@ -186,16 +187,12 @@ module ActiveRecord
           end
         end
 
-        def lookup_cast_type_from_column(column) # :nodoc:
-          verify! if type_map.nil?
-          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        # TODO: Make this method private after we release 8.1.
+        def lookup_cast_type(sql_type) # :nodoc:
+          super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)
         end
 
         private
-          def lookup_cast_type(sql_type)
-            super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)
-          end
-
           def encode_array(array_data)
             encoder = array_data.encoder
             values = type_cast_array(array_data.values)
@@ -208,7 +205,17 @@ module ActiveRecord
           end
 
           def encode_range(range)
-            "[#{type_cast_range_value(range.begin)},#{type_cast_range_value(range.end)}#{range.exclude_end? ? ')' : ']'}"
+            lower_bound = type_cast_range_value(range.begin)
+            upper_bound = if date_or_time_range?(range)
+              # Postgres will convert `[today,]` to `[today,)`, making it exclusive.
+              # We can use the special timestamp value `infinity` to force inclusion.
+              # https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INFINITE
+              range.end.nil? ? "infinity" : type_cast(range.end)
+            else
+              type_cast_range_value(range.end)
+            end
+
+            "[#{lower_bound},#{upper_bound}#{range.exclude_end? ? ')' : ']'}"
           end
 
           def determine_encoding_of_strings_in_array(value)
@@ -232,6 +239,10 @@ module ActiveRecord
           def infinity?(value)
             value.respond_to?(:infinite?) && value.infinite?
           end
+
+          def date_or_time_range?(range)
+            [range.begin.class, range.end.class].intersect?([Date, DateTime, Time])
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb

@@ -45,7 +45,7 @@ Rails needs superuser privileges to disable referential integrity.
             BEGIN
             FOR r IN (
               SELECT FORMAT(
-                'UPDATE pg_catalog.pg_constraint SET convalidated=false WHERE conname = ''%1$I'' AND connamespace::regnamespace = ''%2$I''::regnamespace; ALTER TABLE %2$I.%3$I VALIDATE CONSTRAINT %1$I;',
+                'UPDATE pg_catalog.pg_constraint SET convalidated=false WHERE conname = ''%1$I'' AND connamespace::regnamespace = ''%2$I''::regnamespace AND conrelid::regclass = ''%3$I''::regclass; ALTER TABLE %2$I.%3$I VALIDATE CONSTRAINT %1$I;',
                 constraint_name,
                 table_schema,
                 table_name

data/lib/active_record/connection_adapters/postgresql/schema_creation.rb

@@ -6,6 +6,7 @@ module ActiveRecord
       class SchemaCreation < SchemaCreation # :nodoc:
         private
           delegate :quoted_include_columns_for_index, to: :@conn
+          delegate :database_version, to: :@conn
 
           def visit_AlterTable(o)
             sql = super
@@ -99,7 +100,7 @@ module ActiveRecord
               if options[:default].nil?
                 change_column_sql << ", ALTER COLUMN #{quoted_column_name} DROP DEFAULT"
               else
-                quoted_default = quote_default_expression(options[:default], column)
+                quoted_default = quote_default_expression_for_column_definition(options[:default], column)
                 change_column_sql << ", ALTER COLUMN #{quoted_column_name} SET DEFAULT #{quoted_default}"
               end
             end
@@ -126,16 +127,17 @@ module ActiveRecord
             end
 
             if as = options[:as]
-              sql << " GENERATED ALWAYS AS (#{as})"
+              stored = options[:stored]
 
-              if options[:stored]
-                sql << " STORED"
-              else
+              if stored != true && database_version < 18_00_00
                 raise ArgumentError, <<~MSG
-                  PostgreSQL currently does not support VIRTUAL (not persisted) generated columns.
+                  PostgreSQL versions before 18 do not support VIRTUAL (not persisted) generated columns.
                   Specify 'stored: true' option for '#{options[:column].name}'
                 MSG
               end
+
+              sql << " GENERATED ALWAYS AS (#{as})"
+              sql << (stored ? " STORED" : " VIRTUAL")
             end
             super
           end

data/lib/active_record/connection_adapters/postgresql/schema_definitions.rb

@@ -5,6 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module ColumnMethods
         extend ActiveSupport::Concern
+        extend ConnectionAdapters::ColumnMethods::ClassMethods
 
         # Defines the primary key field.
         # Use of the native PostgreSQL UUID type is supported, and can be used
@@ -15,22 +16,10 @@ module ActiveRecord
         #     t.timestamps
         #   end
         #
-        # By default, this will use the <tt>gen_random_uuid()</tt> function from the
-        # +pgcrypto+ extension. As that extension is only available in
-        # PostgreSQL 9.4+, for earlier versions an explicit default can be set
-        # to use <tt>uuid_generate_v4()</tt> from the +uuid-ossp+ extension instead:
+        # By default, this will use the <tt>gen_random_uuid()</tt> function.
         #
-        #   create_table :stuffs, id: false do |t|
-        #     t.primary_key :id, :uuid, default: "uuid_generate_v4()"
-        #     t.uuid :foo_id
-        #     t.timestamps
-        #   end
-        #
-        # To enable the appropriate extension, which is a requirement, use
-        # the +enable_extension+ method in your migrations.
-        #
-        # To use a UUID primary key without any of the extensions, set the
-        # +:default+ option to +nil+:
+        # To use a UUID primary key without any defaults, set the +:default+
+        # option to +nil+:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: nil
@@ -181,12 +170,10 @@ module ActiveRecord
         # :method: enum
         # :call-seq: enum(*names, **options)
 
-        included do
-          define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
-            :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
-            :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
-            :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml, :timestamptz, :enum
-        end
+        define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
+          :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
+          :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
+          :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml, :timestamptz, :enum
       end
 
       ExclusionConstraintDefinition = Struct.new(:table_name, :expression, :options) do
@@ -233,6 +220,8 @@ module ActiveRecord
         end
 
         def defined_for?(name: nil, column: nil, **options)
+          options = options.slice(*self.options.keys)
+
           (name.nil? || self.name == name.to_s) &&
             (column.nil? || Array(self.column) == Array(column).map(&:to_s)) &&
             options.all? { |k, v| self.options[k].to_s == v.to_s }
@@ -306,8 +295,8 @@ module ActiveRecord
         #  t.exclusion_constraint("price WITH =, availability_range WITH &&", using: :gist, name: "price_check")
         #
         # See {connection.add_exclusion_constraint}[rdoc-ref:SchemaStatements#add_exclusion_constraint]
-        def exclusion_constraint(*args)
-          @base.add_exclusion_constraint(name, *args)
+        def exclusion_constraint(...)
+          @base.add_exclusion_constraint(name, ...)
         end
 
         # Removes the given exclusion constraint from the table.
@@ -315,8 +304,8 @@ module ActiveRecord
         #  t.remove_exclusion_constraint(name: "price_check")
         #
         # See {connection.remove_exclusion_constraint}[rdoc-ref:SchemaStatements#remove_exclusion_constraint]
-        def remove_exclusion_constraint(*args)
-          @base.remove_exclusion_constraint(name, *args)
+        def remove_exclusion_constraint(...)
+          @base.remove_exclusion_constraint(name, ...)
         end
 
         # Adds a unique constraint.
@@ -324,8 +313,8 @@ module ActiveRecord
         #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred, nulls_not_distinct: true)
         #
         # See {connection.add_unique_constraint}[rdoc-ref:SchemaStatements#add_unique_constraint]
-        def unique_constraint(*args)
-          @base.add_unique_constraint(name, *args)
+        def unique_constraint(...)
+          @base.add_unique_constraint(name, ...)
         end
 
         # Removes the given unique constraint from the table.
@@ -333,8 +322,8 @@ module ActiveRecord
         #  t.remove_unique_constraint(name: "unique_position")
         #
         # See {connection.remove_unique_constraint}[rdoc-ref:SchemaStatements#remove_unique_constraint]
-        def remove_unique_constraint(*args)
-          @base.remove_unique_constraint(name, *args)
+        def remove_unique_constraint(...)
+          @base.remove_unique_constraint(name, ...)
         end
 
         # Validates the given constraint on the table.
@@ -343,8 +332,8 @@ module ActiveRecord
         #  t.validate_constraint "price_check"
         #
         # See {connection.validate_constraint}[rdoc-ref:SchemaStatements#validate_constraint]
-        def validate_constraint(*args)
-          @base.validate_constraint(name, *args)
+        def validate_constraint(...)
+          @base.validate_constraint(name, ...)
         end
 
         # Validates the given check constraint on the table
@@ -353,8 +342,8 @@ module ActiveRecord
         #  t.validate_check_constraint name: "price_check"
         #
         # See {connection.validate_check_constraint}[rdoc-ref:SchemaStatements#validate_check_constraint]
-        def validate_check_constraint(*args)
-          @base.validate_check_constraint(name, *args)
+        def validate_check_constraint(...)
+          @base.validate_check_constraint(name, ...)
         end
       end