activerecord 7.1.5.2 → 8.1.2.1

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,22 +322,40 @@ 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.
+        #
+        #  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(...)
+          @base.validate_constraint(name, ...)
+        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(...)
+          @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)
@@ -355,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