activerecord 7.0.8.7 → 7.2.2.1

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

@@ -27,9 +27,10 @@ module ActiveRecord
             value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
             when /^-?\D*+[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, "")
+              value.delete!("^-0-9.")
             when /^-?\D*+[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
+              value.delete!("^-0-9,")
+              value.tr!(",", ".")
             end
 
             super(value)

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

@@ -18,7 +18,7 @@ module ActiveRecord
           end
 
           def cast_value(value)
-            return if value == "empty"
+            return if ["empty", ""].include? value
             return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
@@ -28,7 +28,7 @@ module ActiveRecord
             if !infinity?(from) && extracted[:exclude_start]
               raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
             end
-            ::Range.new(from, to, extracted[:exclude_end])
+            ::Range.new(*sanitize_bounds(from, to), extracted[:exclude_end])
           end
 
           def serialize(value)
@@ -76,6 +76,15 @@ module ActiveRecord
               }
             end
 
+            INFINITE_FLOAT_RANGE = (-::Float::INFINITY)..(::Float::INFINITY) # :nodoc:
+
+            def sanitize_bounds(from, to)
+              [
+                (from == -::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(to)) ? nil : from,
+                (to == ::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(from)) ? nil : to
+              ]
+            end
+
             # When formatting the bound values of range types, PostgreSQL quotes
             # the bound value using double-quotes in certain conditions. Within
             # a double-quoted string, literal " and \ characters are themselves

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

@@ -15,7 +15,7 @@ module ActiveRecord
             time = super
             return time if time.is_a?(ActiveSupport::TimeWithZone) || !time.acts_like?(:time)
 
-            # While in UTC mode, the PG gem may not return times back in "UTC" even if they were provided to Postgres in UTC.
+            # While in UTC mode, the PG gem may not return times back in "UTC" even if they were provided to PostgreSQL in UTC.
             # We prefer times always in UTC, so here we convert back.
             if is_utc?
               time.getutc

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)
@@ -15,14 +68,14 @@ module ActiveRecord
 
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          @connection.escape_bytea(value) if value
+          valid_raw_connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          @connection.unescape_bytea(value) if value
+          valid_raw_connection.unescape_bytea(value) if value
         end
 
         def check_int_in_range(value)
@@ -72,33 +125,18 @@ module ActiveRecord
 
         # Quotes strings for use in SQL input.
         def quote_string(s) # :nodoc:
-          @connection.escape(s)
-        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)
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
         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.
@@ -118,7 +156,7 @@ module ActiveRecord
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
-          elsif column.type == :uuid && value.is_a?(String) && /\(\)/.match?(value)
+          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)
@@ -141,52 +179,18 @@ module ActiveRecord
             encode_array(value)
           when Range
             encode_range(value)
+          when Rational
+            value.to_f
           else
             super
           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)
         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+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/referential_integrity.rb

@@ -38,7 +38,7 @@ Rails needs superuser privileges to disable referential integrity.
           end
         end
 
-        def all_foreign_keys_valid? # :nodoc:
+        def check_all_foreign_keys_valid! # :nodoc:
           sql = <<~SQL
             do $$
               declare r record;
@@ -61,14 +61,8 @@ Rails needs superuser privileges to disable referential integrity.
             $$;
           SQL
 
-          begin
-            transaction(requires_new: true) do
-              execute(sql)
-            end
-
-            true
-          rescue ActiveRecord::StatementInvalid
-            false
+          transaction(requires_new: true) do
+            execute(sql)
           end
         end
       end

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

@@ -5,21 +5,30 @@ module ActiveRecord
     module PostgreSQL
       class SchemaCreation < SchemaCreation # :nodoc:
         private
+          delegate :quoted_include_columns_for_index, to: :@conn
+
           def visit_AlterTable(o)
-            super << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
+            sql = super
+            sql << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
+            sql << o.exclusion_constraint_adds.map { |con| visit_AddExclusionConstraint con }.join(" ")
+            sql << o.exclusion_constraint_drops.map { |con| visit_DropExclusionConstraint con }.join(" ")
+            sql << o.unique_constraint_adds.map { |con| visit_AddUniqueConstraint con }.join(" ")
+            sql << o.unique_constraint_drops.map { |con| visit_DropUniqueConstraint con }.join(" ")
           end
 
           def visit_AddForeignKey(o)
             super.dup.tap do |sql|
-              if o.deferrable
-                sql << " DEFERRABLE"
-                sql << " INITIALLY #{o.deferrable.to_s.upcase}" unless o.deferrable == true
-              end
-
+              sql << " DEFERRABLE INITIALLY #{o.options[:deferrable].to_s.upcase}" if o.deferrable
               sql << " NOT VALID" unless o.validate?
             end
           end
 
+          def visit_ForeignKeyDefinition(o)
+            super.dup.tap do |sql|
+              sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+            end
+          end
+
           def visit_CheckConstraintDefinition(o)
             super.dup.tap { |sql| sql << " NOT VALID" unless o.validate? }
           end
@@ -28,6 +37,54 @@ module ActiveRecord
             "VALIDATE CONSTRAINT #{quote_column_name(name)}"
           end
 
+          def visit_ExclusionConstraintDefinition(o)
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "EXCLUDE"
+            sql << "USING #{o.using}" if o.using
+            sql << "(#{o.expression})"
+            sql << "WHERE (#{o.where})" if o.where
+            sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+
+            sql.join(" ")
+          end
+
+          def visit_UniqueConstraintDefinition(o)
+            column_name = Array(o.column).map { |column| quote_column_name(column) }.join(", ")
+
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "UNIQUE"
+
+            if o.using_index
+              sql << "USING INDEX #{quote_column_name(o.using_index)}"
+            else
+              sql << "(#{column_name})"
+            end
+
+            if o.deferrable
+              sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}"
+            end
+
+            sql.join(" ")
+          end
+
+          def visit_AddExclusionConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_DropExclusionConstraint(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
+          def visit_AddUniqueConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_DropUniqueConstraint(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
           def visit_ChangeColumnDefinition(o)
             column = o.column
             column.sql_type = type_to_sql(column.type, **column.options)
@@ -64,6 +121,15 @@ module ActiveRecord
             change_column_sql
           end
 
+          def visit_ChangeColumnDefaultDefinition(o)
+            sql = +"ALTER COLUMN #{quote_column_name(o.column.name)} "
+            if o.default.nil?
+              sql << "DROP DEFAULT"
+            else
+              sql << "SET DEFAULT #{quote_default_expression(o.default, o.column)}"
+            end
+          end
+
           def add_column_options!(sql, options)
             if options[:collation]
               sql << " COLLATE \"#{options[:collation]}\""
@@ -84,6 +150,10 @@ module ActiveRecord
             super
           end
 
+          def quoted_include_columns(o)
+            String === o ? o : quoted_include_columns_for_index(o)
+          end
+
           # Returns any SQL string to go between CREATE and TABLE. May be nil.
           def table_modifier_in_create(o)
             # A table cannot be both TEMPORARY and UNLOGGED, since all TEMPORARY

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

@@ -189,16 +189,83 @@ module ActiveRecord
         end
       end
 
+      ExclusionConstraintDefinition = Struct.new(:table_name, :expression, :options) do
+        def name
+          options[:name]
+        end
+
+        def using
+          options[:using]
+        end
+
+        def where
+          options[:where]
+        end
+
+        def deferrable
+          options[:deferrable]
+        end
+
+        def export_name_on_schema_dump?
+          !ActiveRecord::SchemaDumper.excl_ignore_pattern.match?(name) if name
+        end
+      end
+
+      UniqueConstraintDefinition = Struct.new(:table_name, :column, :options) do
+        def name
+          options[:name]
+        end
+
+        def deferrable
+          options[:deferrable]
+        end
+
+        def using_index
+          options[:using_index]
+        end
+
+        def export_name_on_schema_dump?
+          !ActiveRecord::SchemaDumper.unique_ignore_pattern.match?(name) if name
+        end
+
+        def defined_for?(name: nil, column: nil, **options)
+          (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 }
+        end
+      end
+
+      # = Active Record PostgreSQL Adapter \Table Definition
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
-        attr_reader :unlogged
+        attr_reader :exclusion_constraints, :unique_constraints, :unlogged
 
         def initialize(*, **)
           super
+          @exclusion_constraints = []
+          @unique_constraints = []
           @unlogged = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
         end
 
+        def exclusion_constraint(expression, **options)
+          exclusion_constraints << new_exclusion_constraint_definition(expression, options)
+        end
+
+        def unique_constraint(column_name, **options)
+          unique_constraints << new_unique_constraint_definition(column_name, options)
+        end
+
+        def new_exclusion_constraint_definition(expression, options) # :nodoc:
+          options = @conn.exclusion_constraint_options(name, expression, options)
+          ExclusionConstraintDefinition.new(name, expression, options)
+        end
+
+        def new_unique_constraint_definition(column_name, options) # :nodoc:
+          options = @conn.unique_constraint_options(name, column_name, options)
+          UniqueConstraintDefinition.new(name, column_name, options)
+        end
+
         def new_column_definition(name, type, **options) # :nodoc:
           case type
           when :virtual
@@ -209,6 +276,10 @@ module ActiveRecord
         end
 
         private
+          def valid_column_definition_options
+            super + [:array, :using, :cast_as, :as, :type, :enum_type, :stored]
+          end
+
           def aliased_types(name, fallback)
             fallback
           end
@@ -222,21 +293,99 @@ module ActiveRecord
           end
       end
 
+      # = Active Record PostgreSQL Adapter \Table
       class Table < ActiveRecord::ConnectionAdapters::Table
         include ColumnMethods
+
+        # Adds an exclusion constraint.
+        #
+        #  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)
+        end
+
+        # Removes the given exclusion constraint from the table.
+        #
+        #  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)
+        end
+
+        # Adds a unique constraint.
+        #
+        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred)
+        #
+        # See {connection.add_unique_constraint}[rdoc-ref:SchemaStatements#add_unique_constraint]
+        def unique_constraint(*args)
+          @base.add_unique_constraint(name, *args)
+        end
+
+        # Removes the given unique constraint from the table.
+        #
+        #  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)
+        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
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        attr_reader :constraint_validations
+        attr_reader :constraint_validations, :exclusion_constraint_adds, :exclusion_constraint_drops, :unique_constraint_adds, :unique_constraint_drops
 
         def initialize(td)
           super
           @constraint_validations = []
+          @exclusion_constraint_adds = []
+          @exclusion_constraint_drops = []
+          @unique_constraint_adds = []
+          @unique_constraint_drops = []
         end
 
         def validate_constraint(name)
           @constraint_validations << name
         end
+
+        def add_exclusion_constraint(expression, options)
+          @exclusion_constraint_adds << @td.new_exclusion_constraint_definition(expression, options)
+        end
+
+        def drop_exclusion_constraint(constraint_name)
+          @exclusion_constraint_drops << constraint_name
+        end
+
+        def add_unique_constraint(column_name, options)
+          @unique_constraint_adds << @td.new_unique_constraint_definition(column_name, options)
+        end
+
+        def drop_unique_constraint(unique_constraint_name)
+          @unique_constraint_drops << unique_constraint_name
+        end
       end
     end
   end