activerecord 7.1.4.2 → 7.2.0.beta1

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -7,17 +7,6 @@ gem "mysql2", "~> 0.5"
 require "mysql2"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def mysql2_adapter_class
-      ConnectionAdapters::Mysql2Adapter
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def mysql2_connection(config)
-      mysql2_adapter_class.new(config)
-    end
-  end
-
   module ConnectionAdapters
     # = Active Record MySQL2 Adapter
     class Mysql2Adapter < AbstractMysqlAdapter
@@ -116,22 +105,15 @@ module ActiveRecord
       end
 
       #--
-      # QUOTING ==================================================
+      # CONNECTION MANAGEMENT ====================================
       #++
 
-      # Quotes strings for use in SQL input.
-      def quote_string(string)
-        with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
-          connection.escape(string)
-        end
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
-      #--
-      # CONNECTION MANAGEMENT ====================================
-      #++
-
       def active?
-        !(@raw_connection.nil? || @raw_connection.closed?) && @lock.synchronize { @raw_connection&.ping } || false
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
       end
 
       alias :reset! :reconnect!
@@ -180,7 +162,7 @@ module ActiveRecord
         end
 
         def full_version
-          schema_cache.database_version.full_version_string
+          database_version.full_version_string
         end
 
         def get_full_version

data/lib/active_record/connection_adapters/pool_config.rb

@@ -3,10 +3,10 @@
 module ActiveRecord
   module ConnectionAdapters
     class PoolConfig # :nodoc:
-      include Mutex_m
+      include MonitorMixin
 
       attr_reader :db_config, :role, :shard
-      attr_writer :schema_reflection
+      attr_writer :schema_reflection, :server_version
       attr_accessor :connection_class
 
       def schema_reflection
@@ -28,6 +28,7 @@ module ActiveRecord
 
       def initialize(connection_class, db_config, role, shard)
         super()
+        @server_version = nil
         @connection_class = connection_class
         @db_config = db_config
         @role = role
@@ -36,6 +37,10 @@ module ActiveRecord
         INSTANCES[self] = self
       end
 
+      def server_version(connection)
+        @server_version || synchronize { @server_version ||= connection.get_database_version }
+      end
+
       def connection_name
         if connection_class.primary_class?
           "ActiveRecord::Base"
@@ -45,8 +50,6 @@ module ActiveRecord
       end
 
       def disconnect!(automatic_reconnect: false)
-        ActiveSupport::ForkTracker.check!
-
         return unless @pool
 
         synchronize do
@@ -60,8 +63,6 @@ module ActiveRecord
       end
 
       def pool
-        ActiveSupport::ForkTracker.check!
-
         @pool || synchronize { @pool ||= ConnectionAdapters::ConnectionPool.new(self) }
       end
 

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

@@ -14,10 +14,11 @@ module ActiveRecord
         def query(sql, name = nil) # :nodoc:
           mark_transaction_written_if_write(sql)
 
-          log(sql, name) do
+          log(sql, name) do |notification_payload|
             with_raw_connection do |conn|
               result = conn.async_exec(sql).map_types!(@type_map_for_results).values
               verified!
+              notification_payload[:row_count] = result.count
               result
             end
           end
@@ -50,11 +51,12 @@ module ActiveRecord
         end
 
         def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-          log(sql, name, async: async) do
+          log(sql, name, async: async) do |notification_payload|
             with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
               result = conn.async_exec(sql)
               verified!
               handle_warnings(result)
+              notification_payload[:row_count] = result.count
               result
             end
           end
@@ -69,7 +71,7 @@ module ActiveRecord
               fmod  = result.fmod i
               types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
             end
-            build_result(columns: fields, rows: result.values, column_types: types)
+            build_result(columns: fields, rows: result.values, column_types: types.freeze)
           end
         end
 
@@ -122,7 +124,7 @@ module ActiveRecord
         end
 
         # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
-        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP", retryable: true).freeze # :nodoc:
         private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
 
         def high_precision_current_timestamp
@@ -135,6 +137,27 @@ module ActiveRecord
           "EXPLAIN (#{options.join(", ").upcase})"
         end
 
+        # Set when constraints will be checked for the current transaction.
+        #
+        # Not passing any specific constraint names will set the value for all deferrable constraints.
+        #
+        # [<tt>deferred</tt>]
+        #   Valid values are +:deferred+ or +:immediate+.
+        #
+        # See https://www.postgresql.org/docs/current/sql-set-constraints.html
+        def set_constraints(deferred, *constraints)
+          unless %i[deferred immediate].include?(deferred)
+            raise ArgumentError, "deferred must be :deferred or :immediate"
+          end
+
+          constraints = if constraints.empty?
+            "ALL"
+          else
+            constraints.map { |c| quote_table_name(c) }.join(", ")
+          end
+          execute("SET CONSTRAINTS #{constraints} #{deferred.to_s.upcase}")
+        end
+
         private
           IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
           private_constant :IDLE_TRANSACTION_STATUSES

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

@@ -33,7 +33,7 @@ module ActiveRecord
             when ::Numeric
               # Sometimes operations on Times returns just float number of seconds so we need to handle that.
               # Example: Time.current - (Time.current + 1.hour) # => -3600.000001776 (Float)
-              value.seconds.iso8601(precision: self.precision)
+              ActiveSupport::Duration.build(value).iso8601(precision: self.precision)
             else
               super
             end

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

@@ -6,6 +6,7 @@ module ActiveRecord
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
           ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
+          CANONICAL_UUID = %r{\A[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}\z}
 
           alias :serialize :deserialize
 
@@ -15,18 +16,27 @@ module ActiveRecord
 
           def changed?(old_value, new_value, _new_value_before_type_cast)
             old_value.class != new_value.class ||
-              new_value && old_value.casecmp(new_value) != 0
+              new_value != old_value
           end
 
           def changed_in_place?(raw_old_value, new_value)
             raw_old_value.class != new_value.class ||
-              new_value && raw_old_value.casecmp(new_value) != 0
+              new_value != raw_old_value
           end
 
           private
             def cast_value(value)
-              casted = value.to_s
-              casted if casted.match?(ACCEPTABLE_UUID)
+              value = value.to_s
+              format_uuid(value) if value.match?(ACCEPTABLE_UUID)
+            end
+
+            def format_uuid(uuid)
+              if uuid.match?(CANONICAL_UUID)
+                uuid
+              else
+                uuid = uuid.delete("{}-").downcase
+                "#{uuid[..7]}-#{uuid[8..11]}-#{uuid[12..15]}-#{uuid[16..19]}-#{uuid[20..]}"
+              end
             end
         end
       end

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

@@ -4,9 +4,62 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module Quoting
+        extend ActiveSupport::Concern
+
         QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
         QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
 
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:\s+COLLATE\s+"\w+")?
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          # Quotes column names for use in SQL queries.
+          def quote_column_name(name) # :nodoc:
+            QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(name.to_s).freeze
+          end
+
+          # Checks the following cases:
+          #
+          # - table_name
+          # - "table.name"
+          # - schema_name.table_name
+          # - schema_name."table.name"
+          # - "schema.name".table_name
+          # - "schema.name"."table.name"
+          def quote_table_name(name) # :nodoc:
+            QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+          end
+        end
+
         class IntegerOutOf64BitRange < StandardError
           def initialize(msg)
             super(msg)
@@ -77,30 +130,13 @@ module ActiveRecord
           end
         end
 
-        # Checks the following cases:
-        #
-        # - table_name
-        # - "table.name"
-        # - schema_name.table_name
-        # - schema_name."table.name"
-        # - "schema.name".table_name
-        # - "schema.name"."table.name"
-        def quote_table_name(name) # :nodoc:
-          QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
-        end
-
-        # Quotes schema names for use in SQL queries.
-        def quote_schema_name(name)
-          PG::Connection.quote_ident(name)
-        end
-
         def quote_table_name_for_assignment(table, attr)
           quote_column_name(attr)
         end
 
-        # Quotes column names for use in SQL queries.
-        def quote_column_name(name) # :nodoc:
-          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(super).freeze
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(schema_name)
+          quote_column_name(schema_name)
         end
 
         # Quote date/time values for use in SQL input.
@@ -143,6 +179,8 @@ module ActiveRecord
             encode_array(value)
           when Range
             encode_range(value)
+          when Rational
+            value.to_f
           else
             super
           end
@@ -153,44 +191,6 @@ module ActiveRecord
           type_map.lookup(column.oid, column.fmod, column.sql_type)
         end
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
-        end
-
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
-            )
-            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
-            )
-            (?:\s+COLLATE\s+"\w+")?
-            (?:\s+ASC|\s+DESC)?
-            (?:\s+NULLS\s+(?:FIRST|LAST))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
         private
           def lookup_cast_type(sql_type)
             super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)

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

@@ -332,6 +332,26 @@ module ActiveRecord
         def remove_unique_constraint(*args)
           @base.remove_unique_constraint(name, *args)
         end
+
+        # Validates the given constraint on the table.
+        #
+        #  t.check_constraint("price > 0", name: "price_check", validate: false)
+        #  t.validate_constraint "price_check"
+        #
+        # See {connection.validate_constraint}[rdoc-ref:SchemaStatements#validate_constraint]
+        def validate_constraint(*args)
+          @base.validate_constraint(name, *args)
+        end
+
+        # Validates the given check constraint on the table
+        #
+        #  t.check_constraint("price > 0", name: "price_check", validate: false)
+        #  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)
+        end
       end
 
       # = Active Record PostgreSQL Adapter Alter \Table

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

@@ -112,7 +112,7 @@ module ActiveRecord
 
             orders = {}
             opclasses = {}
-            include_columns = include ? include.split(",").map(&:strip) : []
+            include_columns = include ? include.split(",").map { |c| Utils.unquote_identifier(c.strip.gsub('""', '"')) } : []
 
             if indkey.include?(0)
               columns = expressions
@@ -209,8 +209,16 @@ module ActiveRecord
         end
 
         # Creates a schema for the given schema name.
-        def create_schema(schema_name)
-          execute "CREATE SCHEMA #{quote_schema_name(schema_name)}"
+        def create_schema(schema_name, force: nil, if_not_exists: nil)
+          if force && if_not_exists
+            raise ArgumentError, "Options `:force` and `:if_not_exists` cannot be used simultaneously."
+          end
+
+          if force
+            drop_schema(schema_name, if_exists: true)
+          end
+
+          execute("CREATE SCHEMA#{' IF NOT EXISTS' if if_not_exists} #{quote_schema_name(schema_name)}")
         end
 
         # Drops the schema for the given schema name.
@@ -522,14 +530,6 @@ module ActiveRecord
         end
 
         def add_foreign_key(from_table, to_table, **options)
-          if options[:deferrable] == true
-            ActiveRecord.deprecator.warn(<<~MSG)
-              `deferrable: true` is deprecated in favor of `deferrable: :immediate`, and will be removed in Rails 7.2.
-            MSG
-
-            options[:deferrable] = :immediate
-          end
-
           assert_valid_deferrable(options[:deferrable])
 
           super
@@ -690,6 +690,10 @@ module ActiveRecord
         #   The constraint name. Defaults to <tt>excl_rails_<identifier></tt>.
         # [<tt>:deferrable</tt>]
         #   Specify whether or not the exclusion constraint should be deferrable. Valid values are +false+ or +:immediate+ or +:deferred+ to specify the default behavior. Defaults to +false+.
+        # [<tt>:using</tt>]
+        #   Specify which index method to use when creating this exclusion constraint (e.g. +:btree+, +:gist+ etc).
+        # [<tt>:where</tt>]
+        #   Specify an exclusion constraint on a subset of the table (internally PostgreSQL creates a partial index for this).
         def add_exclusion_constraint(table_name, expression, **options)
           options = exclusion_constraint_options(table_name, expression, options)
           at = create_alter_table(table_name)

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -20,17 +20,6 @@ require "active_record/connection_adapters/postgresql/type_metadata"
 require "active_record/connection_adapters/postgresql/utils"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def postgresql_adapter_class
-      ConnectionAdapters::PostgreSQLAdapter
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects
-    def postgresql_connection(config)
-      postgresql_adapter_class.new(config)
-    end
-  end
-
   module ConnectionAdapters
     # = Active Record PostgreSQL Adapter
     #
@@ -133,6 +122,15 @@ module ActiveRecord
       # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
       class_attribute :datetime_type, default: :timestamp
 
+      ##
+      # :singleton-method:
+      # Toggles automatic decoding of date columns.
+      #
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> String
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates = true
+      #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> Date
+      class_attribute :decode_dates, default: false
+
       NATIVE_DATABASE_TYPES = {
         primary_key: "bigserial primary key",
         string:      { name: "character varying" },
@@ -290,10 +288,6 @@ module ActiveRecord
         { concurrently: "CONCURRENTLY" }
       end
 
-      def return_value_after_insert?(column) # :nodoc:
-        column.auto_populated?
-      end
-
       class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
         def initialize(connection, max)
           super(max)
@@ -342,6 +336,10 @@ module ActiveRecord
         @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
       end
 
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.finished?)
+      end
+
       # Is this connection alive and ready for queries?
       def active?
         @lock.synchronize do
@@ -613,7 +611,9 @@ module ActiveRecord
 
       # Returns the version of the connected PostgreSQL server.
       def get_database_version # :nodoc:
-        valid_raw_connection.server_version
+        with_raw_connection do |conn|
+          conn.server_version
+        end
       end
       alias :postgresql_version :database_version
 
@@ -889,10 +889,11 @@ module ActiveRecord
           update_typemap_for_default_timezone
 
           type_casted_binds = type_casted_binds(binds)
-          log(sql, name, binds, type_casted_binds, async: async) do
-            with_raw_connection do |conn|
+          log(sql, name, binds, type_casted_binds, async: async) do |notification_payload|
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
               result = conn.exec_params(sql, type_casted_binds)
               verified!
+              notification_payload[:row_count] = result.count
               result
             end
           end
@@ -903,13 +904,14 @@ module ActiveRecord
 
           update_typemap_for_default_timezone
 
-          with_raw_connection do |conn|
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
             stmt_key = prepare_statement(sql, binds, conn)
             type_casted_binds = type_casted_binds(binds)
 
-            log(sql, name, binds, type_casted_binds, stmt_key, async: async) do
+            log(sql, name, binds, type_casted_binds, stmt_key, async: async) do |notification_payload|
               result = conn.exec_prepared(stmt_key, type_casted_binds)
               verified!
+              notification_payload[:row_count] = result.count
               result
             end
           end
@@ -919,7 +921,7 @@ module ActiveRecord
           # Nothing we can do if we are in a transaction because all commands
           # will raise InFailedSQLTransaction
           if in_transaction?
-            raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+            raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message, connection_pool: @pool)
           else
             @lock.synchronize do
               # outside of transactions we can simply flush this query and retry
@@ -995,6 +997,8 @@ module ActiveRecord
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.
         # This is called by #connect and should not be called manually.
         def configure_connection
+          super
+
           if @config[:encoding]
             @raw_connection.set_client_encoding(@config[:encoding])
           end
@@ -1165,6 +1169,7 @@ module ActiveRecord
             "timestamp" => PG::TextDecoder::TimestampUtc,
             "timestamptz" => PG::TextDecoder::TimestampWithTimeZone,
           }
+          coders_by_name["date"] = PG::TextDecoder::Date if decode_dates
 
           known_coder_types = coders_by_name.keys.map { |n| quote(n) }
           query = <<~SQL % known_coder_types.join(", ")