online_migrations 0.24.0 → 0.26.0

data/lib/online_migrations/batch_iterator.rb

@@ -19,8 +19,7 @@ module OnlineMigrations
       end
 
       relation = apply_limits(self.relation, column, start, finish, order)
-      unscopes = Utils.ar_version < 7.1 ? [:includes] : [:includes, :preload, :eager_load]
-      base_relation = relation.unscope(*unscopes).reselect(column).reorder(column => order)
+      base_relation = relation.unscope(:includes, :preload, :eager_load).reselect(column).reorder(column => order)
 
       start_id = start || begin
         start_row = base_relation.uncached { base_relation.first }
@@ -84,12 +83,16 @@ module OnlineMigrations
 
     private
       def apply_limits(relation, column, start, finish, order)
+        arel_column = relation.arel_table[column]
+
         if start
-          relation = relation.where(relation.arel_table[column].public_send((order == :asc ? :gteq : :lteq), start))
+          predicate = order == :asc ? :gteq : :lteq
+          relation = relation.where(arel_column.public_send(predicate, start))
         end
 
         if finish
-          relation = relation.where(relation.arel_table[column].public_send((order == :asc ? :lteq : :gteq), finish))
+          predicate = order == :asc ? :lteq : :gteq
+          relation = relation.where(arel_column.public_send(predicate, finish))
         end
 
         relation

data/lib/online_migrations/change_column_type_helpers.rb

@@ -267,11 +267,7 @@ module OnlineMigrations
         __copy_indexes(table_name, column_name, tmp_column_name)
         __copy_foreign_keys(table_name, column_name, tmp_column_name)
         __copy_check_constraints(table_name, column_name, tmp_column_name)
-
-        # Exclusion constraints were added in https://github.com/rails/rails/pull/40224.
-        if Utils.ar_version >= 7.1
-          __copy_exclusion_constraints(table_name, column_name, tmp_column_name)
-        end
+        __copy_exclusion_constraints(table_name, column_name, tmp_column_name)
 
         if column_name == primary_key
           __finalize_primary_key_type_change(table_name, column_name, column_names)
@@ -358,13 +354,22 @@ module OnlineMigrations
     # @see #cleanup_column_type_change
     #
     def cleanup_columns_type_change(table_name, *column_names)
-      conversions = column_names.index_with do |column_name|
-        __change_type_column(column_name)
+      tmp_column_names = column_names.map { |column_name| __change_type_column(column_name) }
+
+      # Safely remove existing indexes and foreign keys first, if any.
+      tmp_column_names.each do |column_name|
+        __indexes_for(table_name, column_name).each do |index|
+          remove_index(table_name, name: index.name, algorithm: :concurrently)
+        end
+
+        __foreign_keys_for(table_name, column_name).each do |fk|
+          remove_foreign_key(table_name, name: fk.name)
+        end
       end
 
       transaction do
-        __remove_copy_triggers(table_name, conversions.keys, conversions.values)
-        remove_columns(table_name, *conversions.values)
+        __remove_copy_triggers(table_name, column_names, tmp_column_names)
+        remove_columns(table_name, *tmp_column_names)
       end
     end
 
@@ -401,12 +406,13 @@ module OnlineMigrations
         to_column    = to_column.to_s
 
         __indexes_for(table_name, from_column).each do |index|
+          columns = index.columns
           new_columns =
             # Expression index.
-            if index.columns.is_a?(String)
-              index.columns.gsub(/\b#{from_column}\b/, to_column)
+            if columns.is_a?(String)
+              columns.gsub(/\b#{from_column}\b/, to_column)
             else
-              index.columns.map do |column|
+              columns.map do |column|
                 column == from_column ? to_column : column
               end
             end
@@ -429,6 +435,16 @@ module OnlineMigrations
             options[:opclass] = opclasses
           end
 
+          # If the index name is custom - do not rely on auto generated index names, because this
+          # doesn't work (idempotency check does not work, rails does not consider ':where' option)
+          # when there are partial and "classic" indexes on the same columns.
+          if index.name == index_name(table_name, columns)
+            options[:name] = index_name(table_name, new_columns)
+          else
+            truncated_index_name = index.name[0, max_identifier_length - "_2".length]
+            options[:name] = "#{truncated_index_name}_2"
+          end
+
           add_index(table_name, new_columns, **options, algorithm: :concurrently)
         end
       end
@@ -511,6 +527,13 @@ module OnlineMigrations
           # Lock the table explicitly to prevent new rows being inserted
           execute("LOCK TABLE #{quoted_table_name} IN ACCESS EXCLUSIVE MODE")
 
+          # https://stackoverflow.com/questions/47301722/how-can-view-depends-on-primary-key-constraint-in-postgres
+          #
+          # PG::DependentObjectsStillExist: ERROR:  cannot drop constraint appointments_pkey on table appointments because other objects depend on it (PG::DependentObjectsStillExist)
+          # DETAIL:  view appointment_statuses depends on constraint appointments_pkey on table appointments
+          # HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+          views = __drop_dependent_views(table_name)
+
           swap_column_names(table_name, column_name, tmp_column_name)
 
           # We need to update the trigger function in order to make PostgreSQL to
@@ -530,6 +553,8 @@ module OnlineMigrations
           execute("ALTER TABLE #{quoted_table_name} DROP CONSTRAINT #{quote_table_name(pkey_constraint_name)}")
           rename_index(table_name, pkey_index_name, pkey_constraint_name)
           execute("ALTER TABLE #{quoted_table_name} ADD CONSTRAINT #{quote_table_name(pkey_constraint_name)} PRIMARY KEY USING INDEX #{quote_table_name(pkey_constraint_name)}")
+
+          __recreate_views(views)
         end
       end
 
@@ -579,5 +604,40 @@ module OnlineMigrations
         function_name = __copy_triggers_name(table_name, column_names, tmp_column_names)
         execute("ALTER FUNCTION #{quote_table_name(function_name)}() RESET ALL")
       end
+
+      # https://stackoverflow.com/questions/69458819/is-there-any-way-to-list-all-the-views-related-to-a-table-in-the-existing-postgr
+      def __drop_dependent_views(table_name)
+        views = select_all(<<~SQL)
+          SELECT
+            u.view_schema AS schema,
+            u.view_name AS name,
+            v.view_definition AS definition,
+            c.relkind = 'm' AS materialized
+          FROM information_schema.view_table_usage u
+            JOIN information_schema.views v ON u.view_schema = v.table_schema
+              AND u.view_name = v.table_name
+            JOIN pg_class c ON c.relname = u.view_name
+          WHERE u.table_schema NOT IN ('information_schema', 'pg_catalog')
+            AND u.table_name = #{quote(table_name)}
+          ORDER BY u.view_schema, u.view_name
+        SQL
+
+        views.each do |row|
+          execute("DROP VIEW #{quote_table_name(row['schema'])}.#{quote_table_name(row['name'])}")
+        end
+
+        views
+      end
+
+      def __recreate_views(views)
+        views.each do |row|
+          schema, name, definition, materialized = row.values_at("schema", "name", "definition", "materialized")
+
+          execute(<<~SQL)
+            CREATE#{' MATERIALIZED' if materialized} VIEW #{quote_table_name(schema)}.#{quote_table_name(name)} AS
+            #{definition}
+          SQL
+        end
+      end
   end
 end

data/lib/online_migrations/command_checker.rb

@@ -80,6 +80,7 @@ module OnlineMigrations
         add_inheritance_column: "adding-a-single-table-inheritance-column",
         mismatched_foreign_key_type: "mismatched-reference-column-types",
       }
+      private_constant :ERROR_MESSAGE_TO_LINK
 
       def check_database_version
         return if defined?(@database_version_checked)
@@ -375,6 +376,31 @@ module OnlineMigrations
               cleanup_code: command_str(:cleanup_column_type_change, table_name, column_name),
               cleanup_down_code: command_str(:initialize_column_type_change, table_name, column_name, existing_type)
           end
+
+          # Constraints must be rechecked.
+          # PostgreSQL recommends dropping constraints before and adding them back.
+          # https://www.postgresql.org/docs/current/ddl-alter.html#DDL-ALTER-COLUMN-TYPE
+          constraints = connection.check_constraints(table_name).select do |c|
+            c.validated? && c.expression.match?(/\b#{column_name}\b/)
+          end
+
+          if constraints.any?
+            change_commands = constraints.map do |c|
+              command_str(:remove_check_constraint, table_name, c.expression, { name: c.name })
+            end
+            change_commands << command_str(:change_column, table_name, column_name, type, **options)
+            constraints.each do |c|
+              change_commands << command_str(:add_check_constraint, table_name, c.expression, { name: c.name, validate: false })
+            end
+
+            validate_commands = constraints.map do |c|
+              command_str(:validate_check_constraint, table_name, { name: c.name })
+            end
+
+            raise_error :change_column_constraint,
+              change_column_code: change_commands.join("\n    "),
+              validate_constraint_code: validate_commands.join("\n    ")
+          end
         end
       end
 
@@ -388,9 +414,9 @@ module OnlineMigrations
         if !allow_null && !new_or_small_table?(table_name)
           # In PostgreSQL 12+ you can add a check constraint to the table
           # and then "promote" it to NOT NULL for the column.
-          safe = check_constraints(table_name).any? do |c|
-            c["def"] == "CHECK ((#{column_name} IS NOT NULL))" ||
-              c["def"] == "CHECK ((#{connection.quote_column_name(column_name)} IS NOT NULL))"
+          safe = connection.check_constraints(table_name).select(&:validated?).any? do |c|
+            c.expression == "#{column_name} IS NOT NULL" ||
+              c.expression == "#{connection.quote_column_name(column_name)} IS NOT NULL"
           end
 
           if !safe
@@ -601,7 +627,7 @@ module OnlineMigrations
       def add_unique_constraint(table_name, column_name = nil, **options)
         return if new_or_small_table?(table_name) || options[:using_index] || !column_name
 
-        index_name = Utils.index_name(table_name, column_name)
+        index_name = connection.index_name(table_name, column_name)
 
         raise_error :add_unique_constraint,
           add_index_code: command_str(:add_index, table_name, column_name, unique: true, name: index_name, algorithm: :concurrently),
@@ -765,18 +791,6 @@ module OnlineMigrations
         "chk_rails_#{hashed_identifier}"
       end
 
-      def check_constraints(table_name)
-        constraints_query = <<~SQL
-          SELECT pg_get_constraintdef(oid) AS def
-          FROM pg_constraint
-          WHERE contype = 'c'
-            AND convalidated
-            AND conrelid = #{connection.quote(table_name)}::regclass
-        SQL
-
-        connection.select_all(constraints_query).to_a
-      end
-
       def check_inheritance_column(table_name, column_name, default)
         if column_name.to_s == ActiveRecord::Base.inheritance_column && !default.nil?
           raise_error :add_inheritance_column,
@@ -834,10 +848,8 @@ module OnlineMigrations
       end
 
       def index_include_column?(index, column)
-        # Expression index
-        (index.columns.is_a?(String) && index.columns.include?(column)) ||
-          index.columns.include?(column) ||
-          (Utils.ar_version >= 7.1 && index.include && index.include.include?(column)) ||
+        index.columns.include?(column) ||
+          (index.include && index.include.include?(column)) ||
           (index.where && index.where.include?(column))
       end
 

data/lib/online_migrations/config.rb

@@ -73,6 +73,13 @@ module OnlineMigrations
       end
     end
 
+    # Whether to require safety reason explanation when calling #safery_assured
+    #
+    # Disabled by default
+    # @return [Boolean]
+    #
+    attr_accessor :require_safety_assured_reason
+
     # Whether to perform checks when migrating down
     #
     # Disabled by default
@@ -230,6 +237,7 @@ module OnlineMigrations
       @start_after = 0
       @target_version = nil
       @small_tables = []
+      @require_safety_assured_reason = false
       @check_down = false
       @auto_analyze = false
       @alphabetize_schema = false

data/lib/online_migrations/error_messages.rb

@@ -242,6 +242,22 @@ during writes works automatically). For most column type changes, this does not
 8. Remove changes from step 3, if any
 9. Deploy",
 
+      change_column_constraint: "Changing the type of a column that has check constraints blocks reads and writes
+while every row is checked. Drop the check constraints on the column before
+changing the type and add them back afterwards.
+
+class <%= migration_name %> < <%= migration_parent %>
+  def change
+    <%= change_column_code %>
+  end
+end
+
+class Validate<%= migration_name %> < <%= migration_parent %>
+  def change
+    <%= validate_constraint_code %>
+  end
+end",
+
       change_column_default:
 "Partial writes are enabled, which can cause incorrect values
 to be inserted when changing the default value of a column.

data/lib/online_migrations/index_definition.rb

@@ -20,7 +20,7 @@ module OnlineMigrations
       # For ActiveRecord::ConnectionAdapters::IndexDefinition is for expression indexes,
       # `columns` is a string
       table == other.table &&
-        (columns & Array(other.columns)).any?
+        columns.intersect?(Array(other.columns))
     end
 
     # @param other [OnlineMigrations::IndexDefinition, ActiveRecord::ConnectionAdapters::IndexDefinition]

data/lib/online_migrations/lock_retrier.rb

@@ -46,10 +46,6 @@ module OnlineMigrations
   #     end
   #
   class LockRetrier
-    # Database connection on which retries are run
-    #
-    attr_accessor :connection
-
     # Returns the number of retrying attempts
     #
     def attempts
@@ -73,14 +69,15 @@ module OnlineMigrations
     # Executes the block with a retry mechanism that alters the `lock_timeout`
     # and sleep time between attempts.
     #
+    # @param connection The connection on which to retry lock timeouts
     # @return [void]
     #
     # @example
-    #   retrier.with_lock_retries do
+    #   retrier.with_lock_retries(connection) do
     #     add_column(:users, :name, :string)
     #   end
     #
-    def with_lock_retries(&block)
+    def with_lock_retries(connection, &block)
       return yield if lock_retries_disabled?
 
       current_attempt = 0
@@ -90,7 +87,7 @@ module OnlineMigrations
 
         current_lock_timeout = lock_timeout(current_attempt)
         if current_lock_timeout
-          with_lock_timeout(current_lock_timeout.in_milliseconds, &block)
+          with_lock_timeout(connection, current_lock_timeout.in_milliseconds, &block)
         else
           yield
         end
@@ -110,7 +107,7 @@ module OnlineMigrations
         Utils.to_bool(ENV["DISABLE_LOCK_RETRIES"])
       end
 
-      def with_lock_timeout(value)
+      def with_lock_timeout(connection, value)
         value = value.ceil.to_i
         prev_value = connection.select_value("SHOW lock_timeout")
         connection.execute("SET lock_timeout TO #{connection.quote("#{value}ms")}")
@@ -234,7 +231,7 @@ module OnlineMigrations
     def delay(*)
     end
 
-    def with_lock_retries
+    def with_lock_retries(_connection)
       yield
     end
   end

data/lib/online_migrations/migration.rb

@@ -45,7 +45,14 @@ module OnlineMigrations
     # @example
     #   safety_assured { remove_column(:users, :some_column) }
     #
-    def safety_assured(&block)
+    def safety_assured(reason = nil, &block)
+      config = OnlineMigrations.config
+      safe_version = version && version <= config.start_after
+
+      if config.require_safety_assured_reason && reason.blank? && !safe_version
+        raise OnlineMigrations::Error, "Specify a safety reason explanation when calling #safety_assured."
+      end
+
       command_checker.class.safety_assured(&block)
     end
 

data/lib/online_migrations/schema_cache.rb

@@ -3,84 +3,6 @@
 module OnlineMigrations
   # @private
   module SchemaCache
-    def primary_keys(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        super(column_rename_table(table_name))
-      else
-        super
-      end
-    end
-
-    def columns(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        columns = super(column_rename_table(table_name))
-        OnlineMigrations.config.column_renames[table_name].each do |old_column_name, new_column_name|
-          duplicate_column(old_column_name, new_column_name, columns)
-        end
-        columns
-      else
-        super.reject { |column| column.name.end_with?("_for_type_change") }
-      end
-    end
-
-    def indexes(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        super(column_rename_table(table_name))
-      else
-        super
-      end
-    end
-
-    def clear_data_source_cache!(name)
-      if (renamed_table = renamed_table?(name))
-        super(renamed_table)
-      end
-
-      if renamed_column?(name)
-        super(column_rename_table(name))
-      end
-
-      super
-    end
-
-    private
-      def renamed_table?(table_name)
-        table_renames = OnlineMigrations.config.table_renames
-        if table_renames.key?(table_name)
-          views = connection.views
-          table_renames[table_name] if views.include?(table_name)
-        end
-      end
-
-      def renamed_column?(table_name)
-        column_renames = OnlineMigrations.config.column_renames
-        column_renames.key?(table_name) && connection.views.include?(table_name)
-      end
-
-      def column_rename_table(table_name)
-        "#{table_name}_column_rename"
-      end
-
-      def duplicate_column(old_column_name, new_column_name, columns)
-        old_column = columns.find { |column| column.name == old_column_name }
-        new_column = old_column.dup
-        # Active Record defines only reader for :name
-        new_column.instance_variable_set(:@name, new_column_name)
-        # Correspond to the Active Record freezing of each column
-        columns << new_column.freeze
-      end
-  end
-
-  # @private
-  module SchemaCache71
-    # Active Record >= 7.1 changed signature of the methods,
-    # see https://github.com/rails/rails/pull/48716.
     def primary_keys(connection, table_name)
       if (renamed_table = renamed_table?(connection, table_name))
         super(connection, renamed_table)

data/lib/online_migrations/schema_statements.rb

@@ -568,8 +568,8 @@ module OnlineMigrations
     #
     def add_text_limit_constraint(table_name, column_name, limit, name: nil, validate: true)
       column = column_for(table_name, column_name)
-      if column.type != :text
-        raise "add_text_limit_constraint must be used only with :text columns"
+      if column.type != :text && column.type != :string
+        raise "add_text_limit_constraint must be used only with :text or :string columns"
       end
 
       name ||= __text_limit_constraint_name(table_name, column_name)
@@ -710,16 +710,12 @@ module OnlineMigrations
           index_name = (options[:name] || index_name(table_name, column_name)).to_s
           indexes(table_name).find { |i| i.name == index_name }
         else
-          # Rewrite this with `IndexDefinition#defined_for?` when Active Record >= 7.1 is supported.
-          # See https://github.com/rails/rails/pull/45160.
-          indexes(table_name).find { |i| __index_defined_for?(i, column_name, **options) }
+          indexes(table_name).find { |i| i.defined_for?(column_name, **options) }
         end
 
       if index
-        schema = __schema_for_table(table_name)
-
-        if __index_valid?(index.name, schema: schema)
-          Utils.say("Index was not created because it already exists.")
+        if index.valid?
+          Utils.say("Index #{index.name} was not created because it already exists.")
           return
         else
           Utils.say("Recreating invalid index: table_name: #{table_name}, column_name: #{column_name}")
@@ -764,22 +760,6 @@ module OnlineMigrations
       end
     end
 
-    # @private
-    # From ActiveRecord. Will not be needed for ActiveRecord >= 7.1.
-    def index_name(table_name, options)
-      if options.is_a?(Hash)
-        if options[:column]
-          Utils.index_name(table_name, options[:column])
-        elsif options[:name]
-          options[:name]
-        else
-          raise ArgumentError, "You must specify the index name"
-        end
-      else
-        index_name(table_name, column: options)
-      end
-    end
-
     # Extends default method to be idempotent.
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key
@@ -833,7 +813,7 @@ module OnlineMigrations
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_check_constraint
     #
     def add_check_constraint(table_name, expression, **options)
-      if __check_constraint_exists?(table_name, expression: expression, **options)
+      if check_constraint_exists?(table_name, expression: expression, **options)
         Utils.say(<<~MSG.squish)
           Check constraint was not created because it already exists (this may be due to an aborted migration or similar).
           table_name: #{table_name}, expression: #{expression}
@@ -864,7 +844,7 @@ module OnlineMigrations
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_check_constraint
     #
     def remove_check_constraint(table_name, expression = nil, **options)
-      if __check_constraint_exists?(table_name, expression: expression, **options)
+      if check_constraint_exists?(table_name, expression: expression, **options)
         super
       else
         Utils.say(<<~MSG.squish)
@@ -874,16 +854,14 @@ module OnlineMigrations
       end
     end
 
-    if Utils.ar_version >= 7.1
-      def add_exclusion_constraint(table_name, expression, **options)
-        if __exclusion_constraint_exists?(table_name, expression: expression, **options)
-          Utils.say(<<~MSG.squish)
-            Exclusion constraint was not created because it already exists (this may be due to an aborted migration or similar).
-            table_name: #{table_name}, expression: #{expression}
-          MSG
-        else
-          super
-        end
+    def add_exclusion_constraint(table_name, expression, **options)
+      if __exclusion_constraint_exists?(table_name, expression: expression, **options)
+        Utils.say(<<~MSG.squish)
+          Exclusion constraint was not created because it already exists (this may be due to an aborted migration or similar).
+          table_name: #{table_name}, expression: #{expression}
+        MSG
+      else
+        super
       end
     end
 
@@ -892,14 +870,10 @@ module OnlineMigrations
       views = self.views
 
       table_renames = OnlineMigrations.config.table_renames
-      renamed_tables = table_renames.select do |old_name, _|
-        views.include?(old_name)
-      end
+      renamed_tables = table_renames.slice(*views)
 
       column_renames = OnlineMigrations.config.column_renames
-      renamed_columns = column_renames.select do |table_name, _|
-        views.include?(table_name)
-      end
+      renamed_columns = column_renames.slice(*views)
 
       if renamed_tables.key?(table)
         super(renamed_tables[table])
@@ -919,8 +893,7 @@ module OnlineMigrations
       __ensure_not_in_transaction!
 
       retrier = OnlineMigrations.config.lock_retrier
-      retrier.connection = self
-      retrier.with_lock_retries(&block)
+      retrier.with_lock_retries(self, &block)
     end
 
     private
@@ -937,20 +910,9 @@ module OnlineMigrations
         end
       end
 
-      # Will not be needed for Active Record >= 7.1
-      def __index_defined_for?(index, columns = nil, name: nil, unique: nil, valid: nil, include: nil, nulls_not_distinct: nil, **options)
-        columns = options[:column] if columns.blank?
-        (columns.nil? || Array(index.columns) == Array(columns).map(&:to_s)) &&
-          (name.nil? || index.name == name.to_s) &&
-          (unique.nil? || index.unique == unique) &&
-          (valid.nil? || index.valid == valid) &&
-          (include.nil? || Array(index.include) == Array(include).map(&:to_s)) &&
-          (nulls_not_distinct.nil? || index.nulls_not_distinct == nulls_not_distinct)
-      end
-
       def __not_null_constraint_exists?(table_name, column_name, name: nil)
         name ||= __not_null_constraint_name(table_name, column_name)
-        __check_constraint_exists?(table_name, name: name)
+        check_constraint_exists?(table_name, name: name)
       end
 
       def __not_null_constraint_name(table_name, column_name)
@@ -963,21 +925,7 @@ module OnlineMigrations
 
       def __text_limit_constraint_exists?(table_name, column_name, name: nil)
         name ||= __text_limit_constraint_name(table_name, column_name)
-        __check_constraint_exists?(table_name, name: name)
-      end
-
-      # Can use index validity attribute for Active Record >= 7.1.
-      def __index_valid?(index_name, schema:)
-        select_value(<<~SQL)
-          SELECT indisvalid
-          FROM pg_index i
-          JOIN pg_class c
-            ON i.indexrelid = c.oid
-          JOIN pg_namespace n
-            ON c.relnamespace = n.oid
-          WHERE n.nspname = #{schema}
-            AND c.relname = #{quote(index_name)}
-        SQL
+        check_constraint_exists?(table_name, name: name)
       end
 
       def __copy_foreign_key(fk, to_column, **options)
@@ -1001,15 +949,6 @@ module OnlineMigrations
         end
       end
 
-      # Can be replaced by native method in Active Record >= 7.1.
-      def __check_constraint_exists?(table_name, **options)
-        if !options.key?(:name) && !options.key?(:expression)
-          raise ArgumentError, "At least one of :name or :expression must be supplied"
-        end
-
-        check_constraint_for(table_name, **options).present?
-      end
-
       def __exclusion_constraint_exists?(table_name, **options)
         if !options.key?(:name) && !options.key?(:expression)
           raise ArgumentError, "At least one of :name or :expression must be supplied"