ridgepole 1.0.1 → 3.1.5

data/lib/ridgepole/diff.rb

@@ -3,6 +3,7 @@
 module Ridgepole
   class Diff
     PRIMARY_KEY_OPTIONS = %i[id limit default null precision scale collation unsigned].freeze
+    REGEX_COLUMN_IDENTIFIER_QUOTATION_CHARS = '"`'
 
     def initialize(options = {})
       @options = options
@@ -28,12 +29,15 @@ module Ridgepole
         if (from_attrs = from.delete(table_name))
           @logger.verbose_info("#   #{table_name}")
 
-          unless (attrs_delta = diff_inspect(from_attrs, to_attrs)).empty?
-            @logger.verbose_info(attrs_delta)
-          end
+          unless @options[:drop_table_only]
+            unless hash_deep_equal?(from_attrs, to_attrs)
+              attrs_delta = diff_inspect(from_attrs, to_attrs)
+              @logger.verbose_info(attrs_delta) unless attrs_delta.empty?
+            end
 
-          scan_change(table_name, from_attrs, to_attrs, delta)
-        else
+            scan_change(table_name, from_attrs, to_attrs, delta)
+          end
+        elsif !@options[:drop_table_only]
           delta[:add] ||= {}
           delta[:add][table_name] = to_attrs
         end
@@ -41,7 +45,7 @@ module Ridgepole
 
       scan_relation_info(relation_info)
 
-      if !@options[:merge] && @options[:force_drop_table]
+      if !@options[:merge] && (@options[:force_drop_table] || @options[:drop_table_only])
         from.each do |table_name, from_attrs|
           next unless target?(table_name)
 
@@ -99,8 +103,12 @@ module Ridgepole
 
       scan_options_change(table_name, from[:options], to[:options], table_delta)
       scan_definition_change(from[:definition], to[:definition], from[:indices], table_name, from[:options], table_delta)
+      apply_column_renames_to_indices(from[:indices], table_delta.dig(:definition, :rename))
       scan_indices_change(from[:indices], to[:indices], to[:definition], table_delta, from[:options], to[:options])
       scan_foreign_keys_change(from[:foreign_keys], to[:foreign_keys], table_delta, @options)
+      scan_check_constraints_change(from[:check_constraints], to[:check_constraints], table_delta)
+      scan_exclusion_constraints_change(from[:exclusion_constraints], to[:exclusion_constraints], table_delta)
+      scan_unique_constraints_change(from[:unique_constraints], to[:unique_constraints], table_delta)
 
       unless table_delta.empty?
         delta[:change] ||= {}
@@ -150,6 +158,14 @@ module Ridgepole
         end
       end
 
+      if Ridgepole::ConnectionAdapters.postgresql?
+        if @options[:postgresql_change_table_comment] && (from[:comment] != to[:comment])
+          from.delete(:comment)
+          to_comment = to.delete(:comment)
+          table_delta[:table_comment] = to_comment
+        end
+      end
+
       if @options[:dump_without_table_options]
         from.delete(:options)
         from.delete(:charset)
@@ -182,8 +198,8 @@ module Ridgepole
       to = to.except(*PRIMARY_KEY_OPTIONS)
 
       unless from == to
-        @logger.warn(<<-MSG)
-[WARNING] Table option changes are ignored on `#{table_name}`.
+        @logger.verbose_info(<<-MSG)
+# Table option changes are ignored on `#{table_name}`.
   from: #{from}
     to: #{to}
       MSG
@@ -227,6 +243,7 @@ module Ridgepole
       from = (from || {}).dup
       to = (to || {}).dup
       definition_delta = {}
+      column_comments = {}
 
       scan_column_rename(from, to, definition_delta)
 
@@ -242,10 +259,14 @@ module Ridgepole
         next if ignore_column
 
         if from_attrs
-          to_attrs = build_attrs_if_changed(to_attrs, from_attrs)
-          if to_attrs
-            definition_delta[:change] ||= {}
-            definition_delta[:change][column_name] = to_attrs
+          changed_attrs = build_attrs_if_changed(to_attrs, from_attrs)
+          if changed_attrs
+            if comment_only_change?(from_attrs, to_attrs)
+              column_comments[column_name] = to_attrs[:options][:comment]
+            else
+              definition_delta[:change] ||= {}
+              definition_delta[:change][column_name] = changed_attrs
+            end
           end
         else
           definition_delta[:add] ||= {}
@@ -300,6 +321,7 @@ module Ridgepole
       end
 
       table_delta[:definition] = definition_delta unless definition_delta.empty?
+      table_delta[:column_comments] = column_comments unless column_comments.empty?
     end
 
     def scan_column_rename(from, to, definition_delta)
@@ -321,6 +343,19 @@ module Ridgepole
       end
     end
 
+    def apply_column_renames_to_indices(indices, renames)
+      return unless indices && renames
+
+      # renames: { new_column_name => old_column_name }
+      rename_map = renames.invert # { old_column_name => new_column_name }
+
+      indices.each_value do |attrs|
+        next unless attrs[:column_name].is_a?(Array)
+
+        attrs[:column_name] = attrs[:column_name].map { |col| rename_map[col] || col }
+      end
+    end
+
     def scan_indices_change(from, to, to_columns, table_delta, _from_table_options, to_table_options)
       from = (from || {}).dup
       to = (to || {}).dup
@@ -389,15 +424,17 @@ module Ridgepole
 
     def normalize_column_options!(attrs, primary_key = false)
       opts = attrs[:options]
-      opts[:null] = true if !opts.key?(:null) && !primary_key
+      opts[:null] = true if !opts.key?(:null) && !primary_key && attrs[:type] != :virtual
       default_limit = Ridgepole::DefaultsLimit.default_limit(attrs[:type], @options)
       opts.delete(:limit) if opts[:limit] == default_limit
 
       # XXX: MySQL only?
-      opts[:default] = nil if !opts.key?(:default) && !primary_key
+      # Generated/virtual columns cannot have DEFAULT values in MySQL.
+      # cf. https://github.com/ridgepole/ridgepole/issues/482
+      opts[:default] = nil if !opts.key?(:default) && !primary_key && attrs[:type] != :virtual
 
       if Ridgepole::ConnectionAdapters.mysql?
-        opts[:unsigned] = false unless opts.key?(:unsigned)
+        opts[:unsigned] = false if !opts.key?(:unsigned) && attrs[:type] != :virtual
 
         if attrs[:type] == :integer && opts[:limit]
           min = Ridgepole::DefaultsLimit.default_limit(:integer, @options)
@@ -408,7 +445,7 @@ module Ridgepole
           end
         end
 
-        if opts[:size] && (attrs[:type] == :text || attrs[:type] == :blob || attrs[:type] == :binary)
+        if opts[:size] && %i[text blob binary].include?(attrs[:type])
           case opts.delete(:size)
           when :tiny
             attrs[:type] = :blob if attrs[:type] == :binary
@@ -419,9 +456,6 @@ module Ridgepole
             opts[:limit] = 4_294_967_295
           end
         end
-
-        # Workaround for Active Record 7.0
-        opts.delete(:precision) if attrs[:type] == :datetime && opts[:precision].nil?
       end
     end
 
@@ -429,6 +463,9 @@ module Ridgepole
       # XXX: MySQL only?
       opts[:using] = :btree unless opts.key?(:using)
       opts[:unique] = false unless opts.key?(:unique)
+
+      # 'algorithm: concurrently' is required for index creation but not stored in PostgreSQL DB metadata, so remove 'algorithm' to prevent diff
+      opts.delete(:algorithm)
     end
 
     def columns_all_include?(expected_columns, actual_columns, table_options)
@@ -444,6 +481,23 @@ module Ridgepole
       to = (to || {}).dup
       foreign_keys_delta = {}
 
+      # Converts conventionally named (i.e., the combination of a singular table name with `_id` suffix)
+      # foreign key column names to void.
+      #
+      # Example:
+      # in `foreign_key_name_or_tables`, it converts the foreign key column name to nil
+      #   - ["my_table", "referenced_table", "referenced_table_id"] => ["my_table", "referenced_table", nil]
+      # in `to_attrs`, it drops `column` option value
+      #   - {to_table: "referenced_table", options: {column: "referenced_table_id"}} => {to_table: "referenced_table", options: {}}
+      to = to.to_h do |foreign_key_name_or_tables, to_attrs|
+        foreign_key_column_name = "#{foreign_key_name_or_tables[1].singularize}_id"
+
+        foreign_key_name_or_tables[2] = nil if foreign_key_column_name == foreign_key_name_or_tables[2]
+        to_attrs[:options].delete(:column) if to_attrs[:options][:column] == foreign_key_column_name
+
+        [foreign_key_name_or_tables, to_attrs]
+      end
+
       to.each do |foreign_key_name_or_tables, to_attrs|
         ignore_fk = to_attrs.fetch(:options, {}).delete(:ignore)
         from_attrs = from.delete(foreign_key_name_or_tables)
@@ -475,6 +529,108 @@ module Ridgepole
       table_delta[:foreign_keys] = foreign_keys_delta unless foreign_keys_delta.empty?
     end
 
+    def scan_check_constraints_change(from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      check_constraints_delta = {}
+
+      to.each do |name, to_attrs|
+        from_attrs = from.delete(name)
+
+        if from_attrs
+          if normalize_check_constraint(from_attrs) != normalize_check_constraint(to_attrs)
+            check_constraints_delta[:add] ||= {}
+            check_constraints_delta[:add][name] = to_attrs
+
+            check_constraints_delta[:delete] ||= {}
+            check_constraints_delta[:delete][name] = from_attrs
+          end
+        else
+          check_constraints_delta[:add] ||= {}
+          check_constraints_delta[:add][name] = to_attrs
+        end
+      end
+
+      unless @options[:merge]
+        from.each do |name, from_attrs|
+          check_constraints_delta[:delete] ||= {}
+          check_constraints_delta[:delete][name] = from_attrs
+        end
+      end
+
+      table_delta[:check_constraints] = check_constraints_delta unless check_constraints_delta.empty?
+    end
+
+    def normalize_check_constraint(attr)
+      attr = attr.dup
+      attr[:expression] = attr[:expression].delete(REGEX_COLUMN_IDENTIFIER_QUOTATION_CHARS)
+      attr
+    end
+
+    def scan_exclusion_constraints_change(from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      exclusion_constraints_delta = {}
+
+      to.each do |name, to_attrs|
+        from_attrs = from.delete(name)
+
+        if from_attrs
+          if from_attrs != to_attrs
+            exclusion_constraints_delta[:add] ||= {}
+            exclusion_constraints_delta[:add][name] = to_attrs
+
+            exclusion_constraints_delta[:delete] ||= {}
+            exclusion_constraints_delta[:delete][name] = from_attrs
+          end
+        else
+          exclusion_constraints_delta[:add] ||= {}
+          exclusion_constraints_delta[:add][name] = to_attrs
+        end
+      end
+
+      unless @options[:merge]
+        from.each do |name, from_attrs|
+          exclusion_constraints_delta[:delete] ||= {}
+          exclusion_constraints_delta[:delete][name] = from_attrs
+        end
+      end
+
+      table_delta[:exclusion_constraints] = exclusion_constraints_delta unless exclusion_constraints_delta.empty?
+    end
+
+    def scan_unique_constraints_change(from, to, table_delta)
+      from = (from || {}).dup
+      to = (to || {}).dup
+      unique_constraints_delta = {}
+
+      to.each do |name, to_attrs|
+        from_attrs = from.delete(name)
+
+        if from_attrs
+          if from_attrs != to_attrs
+            unique_constraints_delta[:add] ||= {}
+            unique_constraints_delta[:add][name] = to_attrs
+
+            unique_constraints_delta[:delete] ||= {}
+            unique_constraints_delta[:delete][name] = from_attrs
+          end
+        else
+          unique_constraints_delta[:add] ||= {}
+          unique_constraints_delta[:add][name] = to_attrs
+        end
+      end
+
+      unless @options[:merge]
+        from.each do |name, from_attrs|
+          unique_constraints_delta[:delete] ||= {}
+          unique_constraints_delta[:delete][name] = from_attrs
+        end
+      end
+
+      table_delta[:unique_constraints] = unique_constraints_delta unless unique_constraints_delta.empty?
+    end
+
     # XXX: MySQL only?
     # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L760
     # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract/schema_creation.rb#L102
@@ -506,9 +662,30 @@ module Ridgepole
         attrs2.fetch(:options).delete(:comment)
       end
 
+      if attrs1[:options][:as] != attrs2[:options][:as] && attrs1[:options].fetch(:as, '').delete(' ') == attrs2[:options].fetch(:as, '').delete(' ')
+        @logger.warn(<<-MSG)
+[WARNING] Same expressions but only differed by white spaces were detected. This operation may fail.
+  Before: '#{attrs1[:options][:as]}'
+  After : '#{attrs2[:options][:as]}'
+        MSG
+      end
+
       attrs1 == attrs2
     end
 
+    def comment_only_change?(attrs1, attrs2)
+      return false if @options[:skip_column_comment_change]
+
+      attrs1 = attrs1.merge(options: attrs1.fetch(:options, {}).dup)
+      attrs2 = attrs2.merge(options: attrs2.fetch(:options, {}).dup)
+      normalize_default_proc_options!(attrs1[:options], attrs2[:options])
+
+      comment1 = attrs1.fetch(:options).delete(:comment)
+      comment2 = attrs2.fetch(:options).delete(:comment)
+
+      attrs1 == attrs2 && comment1 != comment2
+    end
+
     def normalize_default_proc_options!(opts1, opts2)
       if opts1[:default].is_a?(Proc) && opts2[:default].is_a?(Proc)
         opts1[:default] = opts1[:default].call
@@ -619,5 +796,16 @@ module Ridgepole
         @logger.warn "[WARNING] '#{table_name}' definition is not found" unless definition.key?(table_name)
       end
     end
+
+    def hash_deep_equal?(hash1, hash2)
+      return false unless hash1.is_a?(Hash) && hash2.is_a?(Hash)
+      return false if hash1.keys.to_set != hash2.keys.to_set
+
+      hash1.each do |k, v|
+        return false unless hash2.key?(k) && v == hash2[k]
+      end
+
+      true
+    end
   end
 end

data/lib/ridgepole/dsl_parser/context.rb

@@ -48,7 +48,7 @@ module Ridgepole
         table_name = table_name.to_s
         # Keep column_name for expression index support
         # https://github.com/rails/rails/pull/23393
-        column_name = [column_name].flatten.map(&:to_s) unless column_name.is_a?(String) && /\W/ === column_name # rubocop:disable Style/CaseEquality
+        column_name = [column_name].flatten.map(&:to_s) unless column_name.is_a?(String) && /\W/ === column_name
         options[:name] = options[:name].to_s if options[:name]
         @__definition[table_name] ||= {}
         @__definition[table_name][:indices] ||= {}
@@ -77,8 +77,16 @@ module Ridgepole
         from_table = from_table.to_s
         to_table = to_table.to_s
         options[:name] = options[:name].to_s if options[:name]
-        options[:primary_key] = options[:primary_key].to_s if options[:primary_key]
-        options[:column] = options[:column].to_s if options[:column]
+        if options[:primary_key].is_a?(Array)
+          options[:primary_key] = options[:primary_key].map(&:to_s)
+        elsif options[:primary_key]
+          options[:primary_key] = options[:primary_key].to_s
+        end
+        if options[:column].is_a?(Array)
+          options[:column] = options[:column].map(&:to_s)
+        elsif options[:column]
+          options[:column] = options[:column].to_s
+        end
         @__definition[from_table] ||= {}
         @__definition[from_table][:foreign_keys] ||= {}
         idx = options[:name] || [from_table, to_table, options[:column]]
@@ -91,6 +99,51 @@ module Ridgepole
         }
       end
 
+      def add_check_constraint(table_name, expression, options = {})
+        table_name = table_name.to_s
+        expression = expression.to_s
+        options[:name] = options[:name].to_s if options[:name]
+
+        idx = options[:name] || expression
+
+        @__definition[table_name] ||= {}
+        @__definition[table_name][:check_constraints] ||= {}
+        @__definition[table_name][:check_constraints][idx] = {
+          expression: expression,
+          options: options,
+        }
+      end
+
+      def add_exclusion_constraint(table_name, expression, options = {})
+        table_name = table_name.to_s
+        expression = expression.to_s
+        options[:name] = options[:name].to_s if options[:name]
+
+        idx = options[:name] || expression
+
+        @__definition[table_name] ||= {}
+        @__definition[table_name][:exclusion_constraints] ||= {}
+        @__definition[table_name][:exclusion_constraints][idx] = {
+          expression: expression,
+          options: options,
+        }
+      end
+
+      def add_unique_constraint(table_name, column_name, options = {})
+        table_name = table_name.to_s
+        column_name = Array(column_name).map(&:to_sym)
+        options[:name] = options[:name].to_s if options[:name]
+
+        idx = options[:name] || column_name
+
+        @__definition[table_name] ||= {}
+        @__definition[table_name][:unique_constraints] ||= {}
+        @__definition[table_name][:unique_constraints][idx] = {
+          column_name: column_name,
+          options: options,
+        }
+      end
+
       def require(file)
         schemafile = %r{\A/}.match?(file) ? file : File.join(@__working_dir, file)
 

data/lib/ridgepole/dsl_parser/table_definition.rb

@@ -26,32 +26,41 @@ module Ridgepole
       DEFAULT_PRIMARY_KEY_TYPE = :bigint
 
       TYPES = {
-        # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L274
-        string: {},
-        text: {},
-        integer: {},
+        # https://github.com/rails/rails/blob/main/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L300-L301
         bigint: {},
-        float: {},
-        decimal: {},
-        datetime: {},
-        timestamp: {},
-        time: {},
-        date: {},
         binary: {},
         boolean: {},
+        date: {},
+        datetime: {},
+        decimal: {},
+        float: {},
+        integer: {},
+        json: {},
+        string: {},
+        text: {},
+        time: {},
+        timestamp: {},
+        virtual: {},
 
-        # https://github.com/rails/rails/blob/v4.2.1/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L79
+        # https://github.com/rails/rails/blob/v6.0.6/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L101
         serial: { null: false },
         bigserial: { null: false },
+        # string: {},
+        # text: {},
+        # integer: {},
+        # float: {},
+        # decimal: {},
+        # datetime: {},
+        # time: {},
+        # date: {},
         daterange: {},
         numrange: {},
         tsrange: {},
         tstzrange: {},
         int4range: {},
         int8range: {},
-        # binary: {}, # dup key
-        # boolean: {}, # dup key
-        # bigint: {}, # dup key
+        # binary: {},
+        # boolean: {},
         xml: {},
         tsvector: {},
         hstore: {},
@@ -59,20 +68,27 @@ module Ridgepole
         cidr: {},
         macaddr: {},
         uuid: {},
-        json: {},
+        # json: {},
         jsonb: {},
         ltree: {},
         citext: {},
         point: {},
+        line: {},
+        lseg: {},
+        box: {},
+        path: {},
+        polygon: {},
+        circle: {},
         bit: {},
         bit_varying: {},
         money: {},
+        interval: {},
+        oid: {},
 
-        # https://github.com/rails/rails/blob/v5.1.1/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L184
-        virtual: {},
+        # https://github.com/ridgepole/ridgepole/issues/394
+        timestamptz: {},
 
-        # https://github.com/rails/rails/blob/v5.0.4/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb#L53
-        # json: {}, # dup key
+        enum: {},
       }.freeze
 
       TYPES.each do |column_type, default_options|
@@ -129,8 +145,8 @@ module Ridgepole
 
       def timestamps(*args)
         options = { null: false }.merge(args.extract_options!)
-        column(:created_at, :datetime, options)
-        column(:updated_at, :datetime, options)
+        column(:created_at, :datetime, options.dup)
+        column(:updated_at, :datetime, options.dup)
       end
 
       def references(*args)
@@ -159,6 +175,18 @@ module Ridgepole
         end
       end
       alias belongs_to references
+
+      def check_constraint(expression, options = {})
+        @base.add_check_constraint(@table_name, expression, options)
+      end
+
+      def exclusion_constraint(expression, options = {})
+        @base.add_exclusion_constraint(@table_name, expression, options)
+      end
+
+      def unique_constraint(column_name, options = {})
+        @base.add_unique_constraint(@table_name, column_name, options)
+      end
     end
   end
 end

data/lib/ridgepole/dsl_parser.rb

@@ -23,25 +23,41 @@ module Ridgepole
     end
 
     def check_orphan_index(table_name, attrs)
-      raise "Table `#{table_name}` to create the index is not defined: #{attrs[:indices].keys.join(',')}" if attrs[:indices] && !(attrs[:definition])
+      raise "Table `#{table_name}` to create the index is not defined: #{attrs[:indices].keys.join(',')}" if attrs[:indices] && !attrs[:definition]
     end
 
     def check_orphan_foreign_key(table_name, attrs)
-      raise "Table `#{table_name}` to create the foreign key is not defined: #{attrs[:foreign_keys].keys.join(',')}" if attrs[:foreign_keys] && !(attrs[:definition])
+      raise "Table `#{table_name}` to create the foreign key is not defined: #{attrs[:foreign_keys].keys.join(',')}" if attrs[:foreign_keys] && !attrs[:definition]
     end
 
     def check_foreign_key_without_index(table_name, attrs)
+      return if Ridgepole::ConnectionAdapters.postgresql?
       return unless attrs[:foreign_keys]
-      return unless attrs[:options][:options]&.include?('ENGINE=InnoDB')
+      return unless innodb_table?(attrs)
 
-      attrs[:foreign_keys].each do |_, foreign_key_attrs|
+      attrs[:foreign_keys].each_value do |foreign_key_attrs|
         fk_index = foreign_key_attrs[:options][:column] || "#{foreign_key_attrs[:to_table].singularize}_id"
-        next if attrs[:indices]&.any? { |_k, v| v[:column_name].first == fk_index }
-        # NOTE: For composite primary keys, the first column of the primary key is used as the foreign key index
-        next if Array(attrs[:options][:primary_key]).first == fk_index
+        next if attrs[:indices]&.any? { |_, v| match_column_name?(v[:column_name], fk_index) }
+        next if match_column_name?(attrs[:options][:primary_key], fk_index)
 
-        raise "The column `#{fk_index}` of the table `#{table_name}` has a foreign key but no index. Although InnoDB creates an index automatically, please add one explicitly in order for ridgepole to manage it."
+        raise("The column `#{fk_index}` of the table `#{table_name}` has a foreign key but no index. " \
+              'Although InnoDB creates an index automatically, ' \
+              'please add one explicitly in order for ridgepole to manage it.')
       end
     end
+
+    def match_column_name?(index_column_name, fk_index)
+      if fk_index.is_a?(Array)
+        index_column_name == fk_index
+      else
+        # NOTE: For composite primary keys, the first column of the primary key is used as the foreign key index
+        Array(index_column_name).first == fk_index
+      end
+    end
+
+    def innodb_table?(attrs)
+      engine = attrs[:options][:options]&.match(/ENGINE=([^ ]+)/) && Regexp.last_match(1)
+      engine.nil? || engine == 'InnoDB'
+    end
   end
 end

data/lib/ridgepole/dumper.rb

@@ -39,7 +39,7 @@ module Ridgepole
 
       dsl = stream.string.lines.select do |line|
         line !~ /\A#/ &&
-          line !~ /\AActiveRecord::Schema\.define/ &&
+          line !~ /\AActiveRecord::Schema(\[\d\.\d\])?\.define/ &&
           line !~ /\Aend/
       end
 
@@ -85,14 +85,18 @@ module Ridgepole
     end
 
     def target?(table_name)
-      !(@options[:tables]) || @options[:tables].include?(table_name)
+      !@options[:tables] || @options[:tables].include?(table_name)
     end
 
     def dump_from(conn)
       stream = StringIO.new
       conn.without_table_options(@options[:dump_without_table_options]) do
         ActiveRecord::SchemaDumper.with_default_fk_name(@options[:dump_with_default_fk_name]) do
-          ActiveRecord::SchemaDumper.dump(conn, stream)
+          if ActiveRecord.gem_version < Gem::Version.new('7.2.0')
+            ActiveRecord::SchemaDumper.dump(conn, stream)
+          else
+            ActiveRecord::SchemaDumper.dump(conn.pool, stream)
+          end
         end
       end
       stream