activerecord 7.2.2.1 → 8.1.2

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

@@ -25,6 +25,10 @@ module ActiveRecord
               build_point(x, y)
             when ::Array
               build_point(*value)
+            when ::Hash
+              return if value.blank?
+
+              build_point(*values_array_from_hash(value))
             else
               value
             end
@@ -36,6 +40,8 @@ module ActiveRecord
               "(#{number_for_point(value.x)},#{number_for_point(value.y)})"
             when ::Array
               serialize(build_point(*value))
+            when ::Hash
+              serialize(build_point(*values_array_from_hash(value)))
             else
               super
             end
@@ -57,6 +63,10 @@ module ActiveRecord
             def build_point(x, y)
               ActiveRecord::Point.new(Float(x), Float(y))
             end
+
+            def values_array_from_hash(value)
+              [value.values_at(:x, "x").compact.first, value.values_at(:y, "y").compact.first]
+            end
         end
       end
     end

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,12 +45,10 @@ Rails needs superuser privileges to disable referential integrity.
             BEGIN
             FOR r IN (
               SELECT FORMAT(
-                'UPDATE pg_constraint SET convalidated=false WHERE conname = ''%I'' AND connamespace::regnamespace = ''%I''::regnamespace; ALTER TABLE %I.%I VALIDATE CONSTRAINT %I;',
+                '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;',
                 constraint_name,
                 table_schema,
-                table_schema,
-                table_name,
-                constraint_name
+                table_name
               ) AS constraint_check
               FROM information_schema.table_constraints WHERE constraint_type = 'FOREIGN KEY'
             )

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

@@ -6,19 +6,17 @@ 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
             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|
-              sql << " DEFERRABLE INITIALLY #{o.options[:deferrable].to_s.upcase}" if o.deferrable
               sql << " NOT VALID" unless o.validate?
             end
           end
@@ -55,6 +53,7 @@ module ActiveRecord
             sql = ["CONSTRAINT"]
             sql << quote_column_name(o.name)
             sql << "UNIQUE"
+            sql << "NULLS NOT DISTINCT" if supports_nulls_not_distinct? && o.nulls_not_distinct
 
             if o.using_index
               sql << "USING INDEX #{quote_column_name(o.using_index)}"
@@ -73,18 +72,10 @@ module ActiveRecord
             "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)
@@ -109,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
@@ -136,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
@@ -224,11 +211,17 @@ module ActiveRecord
           options[:using_index]
         end
 
+        def nulls_not_distinct
+          options[:nulls_not_distinct]
+        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)
+          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 }
@@ -302,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.
@@ -311,17 +304,17 @@ 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.
         #
-        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred)
+        #  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.
@@ -329,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.
@@ -339,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
@@ -349,22 +342,20 @@ 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
 
       # = Active Record PostgreSQL Adapter Alter \Table
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        attr_reader :constraint_validations, :exclusion_constraint_adds, :exclusion_constraint_drops, :unique_constraint_adds, :unique_constraint_drops
+        attr_reader :constraint_validations, :exclusion_constraint_adds, :unique_constraint_adds
 
         def initialize(td)
           super
           @constraint_validations = []
           @exclusion_constraint_adds = []
-          @exclusion_constraint_drops = []
           @unique_constraint_adds = []
-          @unique_constraint_drops = []
         end
 
         def validate_constraint(name)
@@ -375,17 +366,9 @@ module ActiveRecord
           @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

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

@@ -5,6 +5,23 @@ module ActiveRecord
     module PostgreSQL
       class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         private
+          attr_accessor :schema_name
+
+          def initialize(connection, options = {})
+            super
+
+            @dump_schemas =
+              case ActiveRecord.dump_schemas
+              when :schema_search_path
+                connection.current_schemas
+              when String
+                schema_names = ActiveRecord.dump_schemas.split(",").map(&:strip)
+                schema_names & connection.schema_names
+              else
+                connection.schema_names
+              end
+          end
+
           def extensions(stream)
             extensions = @connection.extensions
             if extensions.any?
@@ -17,19 +34,21 @@ module ActiveRecord
           end
 
           def types(stream)
-            types = @connection.enum_types
-            if types.any?
-              stream.puts "  # Custom types defined in this database."
-              stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
-              types.sort.each do |name, values|
-                stream.puts "  create_enum #{name.inspect}, #{values.split(",").inspect}"
+            within_each_schema do
+              types = @connection.enum_types
+              if types.any?
+                stream.puts "  # Custom types defined in this database."
+                stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
+                types.sort.each do |name, values|
+                  stream.puts "  create_enum #{relation_name(name).inspect}, #{values.inspect}"
+                end
+                stream.puts
               end
-              stream.puts
             end
           end
 
           def schemas(stream)
-            schema_names = @connection.schema_names - ["public"]
+            schema_names = @dump_schemas - ["public"]
 
             if schema_names.any?
               schema_names.sort.each do |name|
@@ -39,45 +58,43 @@ module ActiveRecord
             end
           end
 
+          def tables(stream)
+            previous_schema_had_tables = false
+            within_each_schema do
+              stream.puts if previous_schema_had_tables
+              super
+              previous_schema_had_tables = @connection.tables.any?
+            end
+          end
+
           def exclusion_constraints_in_create(table, stream)
             if (exclusion_constraints = @connection.exclusion_constraints(table)).any?
-              add_exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
-                parts = [
-                  "t.exclusion_constraint #{exclusion_constraint.expression.inspect}"
-                ]
-
+              exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
+                parts = [ exclusion_constraint.expression.inspect ]
                 parts << "where: #{exclusion_constraint.where.inspect}" if exclusion_constraint.where
                 parts << "using: #{exclusion_constraint.using.inspect}" if exclusion_constraint.using
                 parts << "deferrable: #{exclusion_constraint.deferrable.inspect}" if exclusion_constraint.deferrable
+                parts << "name: #{exclusion_constraint.name.inspect}" if exclusion_constraint.export_name_on_schema_dump?
 
-                if exclusion_constraint.export_name_on_schema_dump?
-                  parts << "name: #{exclusion_constraint.name.inspect}"
-                end
-
-                "    #{parts.join(', ')}"
+                "    t.exclusion_constraint #{parts.join(', ')}"
               end
 
-              stream.puts add_exclusion_constraint_statements.sort.join("\n")
+              stream.puts exclusion_constraint_statements.sort.join("\n")
             end
           end
 
           def unique_constraints_in_create(table, stream)
             if (unique_constraints = @connection.unique_constraints(table)).any?
-              add_unique_constraint_statements = unique_constraints.map do |unique_constraint|
-                parts = [
-                  "t.unique_constraint #{unique_constraint.column.inspect}"
-                ]
-
+              unique_constraint_statements = unique_constraints.map do |unique_constraint|
+                parts = [ unique_constraint.column.inspect ]
+                parts << "nulls_not_distinct: #{unique_constraint.nulls_not_distinct.inspect}" if unique_constraint.nulls_not_distinct
                 parts << "deferrable: #{unique_constraint.deferrable.inspect}" if unique_constraint.deferrable
+                parts << "name: #{unique_constraint.name.inspect}" if unique_constraint.export_name_on_schema_dump?
 
-                if unique_constraint.export_name_on_schema_dump?
-                  parts << "name: #{unique_constraint.name.inspect}"
-                end
-
-                "    #{parts.join(', ')}"
+                "    t.unique_constraint #{parts.join(', ')}"
               end
 
-              stream.puts add_unique_constraint_statements.sort.join("\n")
+              stream.puts unique_constraint_statements.sort.join("\n")
             end
           end
 
@@ -87,11 +104,11 @@ module ActiveRecord
 
             if @connection.supports_virtual_columns? && column.virtual?
               spec[:as] = extract_expression_for_virtual_column(column)
-              spec[:stored] = true
+              spec[:stored] = "true" if column.virtual_stored?
               spec = { type: schema_type(column).inspect }.merge!(spec)
             end
 
-            spec[:enum_type] = "\"#{column.sql_type}\"" if column.enum?
+            spec[:enum_type] = column.sql_type.inspect if column.enum?
 
             spec
           end
@@ -121,6 +138,26 @@ module ActiveRecord
           def extract_expression_for_virtual_column(column)
             column.default_function.inspect
           end
+
+          def within_each_schema
+            @dump_schemas.each do |schema_name|
+              old_search_path = @connection.schema_search_path
+              @connection.schema_search_path = schema_name
+              self.schema_name = schema_name
+              yield
+            ensure
+              self.schema_name = nil
+              @connection.schema_search_path = old_search_path
+            end
+          end
+
+          def relation_name(name)
+            if @dump_schemas.size == 1
+              name
+            else
+              "#{schema_name}.#{name}"
+            end
+          end
       end
     end
   end