dynamic_migrations 2.2.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b27309525226b33bbcff1b08b3361347e93cff1d182f5620debbe3195b5c1d88
-  data.tar.gz: 670213a55b129e2518e793bc5314fe522f72645da50d5b32355cacfec5cff8fb
+  metadata.gz: f112c797c02407f6c2b090fcd5dabd05861a864069f6aba51a96467be7a093f2
+  data.tar.gz: 78bb49e74e722db75f9a6366d6034b947632a41326241f24e51ea6eba4879720
 SHA512:
-  metadata.gz: 4227acc9480ac7c9022a0e1f9473627d3b7ab11611d164582b9edf9049928a4a36c1292ce5f43f9f627f9c2c4968e6b8bb4da1ed0dde11b41cd431d6d61022a6
-  data.tar.gz: ef666cf1f797e262469fc080524726d3e70e1f1a52a4dfdb08bc9b9fbc5925671b25cead8013555618ade984bf603e86812ea8689cba2e59a5dd1a8d411664dc
+  metadata.gz: 9ed20eadb8e64389d12665938cff6702d19c2ec5d8c8e9a8b52cc0a7cf715c76596eb9a868ae0411c3f417e39425708a96ee8b890ea40b4f6403ce67dc5daa92
+  data.tar.gz: 49aa26f15e57e2d4f18c5dc850e35946781881b63fe52182eb7d707605b9615f4c1d9c6ac1c4807782577646712207032d0a775614a4552ad6fbef7d83d68157

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [3.1.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.0.0...v3.1.0) (2023-08-14)
+
+
+### Features
+
+* adding a convenience method `to_migrations` on the differences class ([efe94be](https://github.com/craigulliott/dynamic_migrations/commit/efe94be9c620fc44d1cdba54f6cd365292ae0f34))
+
+
+### Bug Fixes
+
+* updating to_migrations method signature in differences class ([e4e502b](https://github.com/craigulliott/dynamic_migrations/commit/e4e502b7ec44add3d2b6727869a4ad90bc7531b7))
+
+## [3.0.0](https://github.com/craigulliott/dynamic_migrations/compare/v2.2.0...v3.0.0) (2023-08-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* functions and triggers, removed unusable index_type from primary key and unique constraints, added active record migrations and some general refactoring
+
+### Features
+
+* adding migration generators and active record migrators ([80bf481](https://github.com/craigulliott/dynamic_migrations/commit/80bf481bfd33941b8380e7deb010b171898c03df))
+* functions and triggers, removed unusable index_type from primary key and unique constraints, added active record migrations and some general refactoring ([45fcb7c](https://github.com/craigulliott/dynamic_migrations/commit/45fcb7ca3b6724625a4868198a9e75aefb1ea964))
+* now generating migrations from all database structure object types ([871ab04](https://github.com/craigulliott/dynamic_migrations/commit/871ab048efb6247bc7fadb6e49bb15f6933c5586))
+* various improvements to triggers and functions, and other general improvements ([e7dd9ab](https://github.com/craigulliott/dynamic_migrations/commit/e7dd9abeee736ea2791c192d3f797497f54773b4))
+
 ## [2.2.0](https://github.com/craigulliott/dynamic_migrations/compare/v2.1.0...v2.2.0) (2023-07-31)
 
 
@@ -19,11 +45,11 @@
 
 ### ⚠ BREAKING CHANGES
 
-* changing all name related methods from %object%_name to just name (i.e. `table.table_name` is now just `table.name`)
+* changing all name related methods from `%object%_name` to just `name` (i.e. `table.table_name` is now just `table.name`)
 
 ### Features
 
-* changing all name related methods from %object%_name to just name (i.e. `table.table_name` is now just `table.name`) ([77f18ae](https://github.com/craigulliott/dynamic_migrations/commit/77f18ae168c2449fa437fa7692ff9339931f9076))
+* changing all name related methods from `%object%_name` to just `name` (i.e. `table.table_name` is now just `table.name`) ([77f18ae](https://github.com/craigulliott/dynamic_migrations/commit/77f18ae168c2449fa437fa7692ff9339931f9076))
 
 ## [1.1.1](https://github.com/craigulliott/dynamic_migrations/compare/v1.1.0...v1.1.1) (2023-07-17)
 
@@ -31,8 +57,6 @@
 ### Bug Fixes
 
 * validating that new databases don't already exist and removing a debug print statement ([73bed2d](https://github.com/craigulliott/dynamic_migrations/commit/73bed2d6ab928c7a8f53b2aa17a188a77ed369e9))
-* validating that new databases don't already exist and removing a debug print statement ([73bed2d](https://github.com/craigulliott/dynamic_migrations/commit/73bed2d6ab928c7a8f53b2aa17a188a77ed369e9))
-* validating that new databases don't already exist and removing a debug print statement ([f4cfb1e](https://github.com/craigulliott/dynamic_migrations/commit/f4cfb1e81252ed967ad1a6d864d495c182ca908f))
 
 ## [1.1.0](https://github.com/craigulliott/dynamic_migrations/compare/v1.0.0...v1.1.0) (2023-07-10)
 

data/lib/dynamic_migrations/active_record/migrators/column.rb

@@ -0,0 +1,21 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Column
+        # add a comment to the column
+        def set_column_comment table_name, column_name, comment
+          execute <<~SQL
+            COMMENT ON COLUMN #{schema_name}.#{table_name}.#{column_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a column comment
+        def remove_column_comment table_name, column_name
+          execute <<~SQL
+            COMMENT ON COLUMN #{schema_name}.#{table_name}.#{column_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/foreign_key_constraint.rb

@@ -0,0 +1,112 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module ForeignKeyConstraint
+        class ForeignKeyOnDeleteOptionsError < StandardError
+        end
+
+        class UnexpectedReferentialActionError < StandardError
+        end
+
+        # because rails migrations don't support composite (multiple column) foreign keys
+        # column_names and foreign_column_names can be a single column name or
+        # an array of column names
+        def add_foreign_key table_name, column_names, foreign_schema_name, foreign_table_name, foreign_column_names, name:, initially_deferred: false, deferrable: false, on_delete: :no_action, on_update: :no_action, comment: nil
+          if initially_deferred == true && deferrable == false
+            raise DeferrableOptionsError, "A constraint can only be initially deferred if it is also deferrable"
+          end
+
+          # convert single column names into arrays, this simplifies the logic below
+          column_names = column_names.is_a?(Array) ? column_names : [column_names]
+          foreign_column_names = foreign_column_names.is_a?(Array) ? foreign_column_names : [foreign_column_names]
+
+          # allow it to be deferred, and defer it by default
+          deferrable_sql = if initially_deferred
+            "DEFERRABLE INITIALLY DEFERRED"
+
+          # allow it to be deferred, but do not deferr by default
+          elsif deferrable
+            "DEFERRABLE INITIALLY IMMEDIATE"
+
+          # it can not be deferred (this is the default)
+          else
+            "NOT DEFERRABLE"
+          end
+
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              ADD CONSTRAINT #{name}
+                FOREIGN KEY (#{column_names.join(", ")})
+                  REFERENCES  #{foreign_schema_name}.#{foreign_table_name} (#{foreign_column_names.join(", ")})
+              ON DELETE #{referential_action_to_sql on_delete}
+              ON UPDATE #{referential_action_to_sql on_update}
+              #{deferrable_sql};
+          SQL
+
+          if comment.is_a? String
+            set_foreign_key_comment table_name, name, comment
+          end
+        end
+
+        def remove_foreign_key table_name, name
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              DROP CONSTRAINT #{name};
+          SQL
+        end
+
+        # add a comment to the foreign_key
+        def set_foreign_key_comment table_name, foreign_key_name, comment
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{foreign_key_name} ON #{schema_name}.#{table_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a foreign_key comment
+        def remove_foreign_key_comment table_name, foreign_key_name
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{foreign_key_name} ON #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+
+        private
+
+        def referential_action_to_sql referential_action
+          case referential_action
+            #  Produce an error indicating that the deletion or update would create a
+            # foreign key constraint violation. If the constraint is deferred, this
+            # error will be produced at constraint check time if there still exist
+            # any referencing rows. This is the default action.
+          when :no_action
+            "NO ACTION"
+
+            # Produce an error indicating that the deletion or update would create a
+            # foreign key constraint violation. This is the same as NO ACTION except
+            # that the check is not deferrable.
+          when :restrict
+            "RESTRICT"
+
+            # Delete any rows referencing the deleted row, or update the values of
+            # the referencing column(s) to the new values of the referenced columns,
+            # respectively.
+          when :cascade
+            "CASCADE"
+
+            # Set all of the referencing columns, or a specified subset of the
+            # referencing columns, to null.
+          when :set_null
+            "SET NULL"
+
+            # Set all of the referencing columns, or a specified subset of the
+            # referencing columns, to their default values.
+          when :set_default
+            "SET DEFAULT"
+
+          else
+            raise UnexpectedReferentialActionError, referential_action
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/function.rb

@@ -0,0 +1,108 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Function
+        class FunctionDoesNotExistError < StandardError
+        end
+
+        class MissingFunctionBlockError < StandardError
+        end
+
+        # create a postgres function
+        def create_function table_name, function_name, comment: nil, &block
+          unless block
+            raise MissingFunctionBlockError, "create_function requires a block"
+          end
+          # todo - remove this once steep/rbs can better handle blocks
+          unless block.is_a? NilClass
+            fn_sql = block.call.strip
+          end
+
+          # ensure that the function ends with a semicolon
+          unless fn_sql.end_with? ";"
+            fn_sql << ";"
+          end
+
+          # schema_name was not provided to this method, it comes from the migration class
+          execute <<~SQL
+            CREATE FUNCTION #{schema_name}.#{function_name}() returns trigger language plpgsql AS
+            $$BEGIN #{fn_sql}
+            RETURN NEW;
+            END$$;
+          SQL
+
+          if comment.is_a? String
+            set_function_comment function_name, comment
+          end
+        end
+
+        # update a postgres function
+        def update_function table_name, function_name, comment: nil, &block
+          unless block
+            raise MissingFunctionBlockError, "create_function requires a block"
+          end
+          # todo - remove this once steep/rbs can better handle blocks
+          unless block.is_a? NilClass
+            fn_sql = block.call.strip
+          end
+
+          # ensure that the function ends with a semicolon
+          unless fn_sql.end_with? ";"
+            fn_sql << ";"
+          end
+
+          # schema_name was not provided to this method, it comes from the migration class
+          # assert it already exists
+          exists_result = execute <<~SQL
+            SELECT TRUE as exists
+            FROM pg_proc p
+            INNER JOIN pg_namespace p_n
+              ON p_n.oid = p.pronamespace
+            WHERE
+              p.proname = #{function_name}
+              AND p_n.nspname = #{schema_name}
+              -- arguments (defaulting to none for now)
+              AND pg_get_function_identity_arguments(p.oid) = ''
+          SQL
+
+          unless exists_result.to_a.first["exists"]
+            raise FunctionDoesNotExistError, "Can not update Function. Function #{schema_name}.#{function_name} does not exist."
+          end
+
+          # create or replace will update the function
+          execute <<~SQL
+            CREATE OR REPLACE FUNCTION #{schema_name}.#{function_name}() returns trigger language plpgsql AS
+            $$BEGIN #{fn_sql}
+            RETURN NEW;
+            END$$;
+          SQL
+
+          if comment.is_a? String
+            set_function_comment function_name, comment
+          end
+        end
+
+        # remove a function from the schema
+        def drop_function function_name
+          execute <<~SQL
+            DROP FUNCTION #{schema_name}.#{function_name}();
+          SQL
+        end
+
+        # add a comment to a function
+        def set_function_comment function_name, comment
+          execute <<~SQL
+            COMMENT ON FUNCTION #{schema_name}.#{function_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove the comment from a function
+        def remove_function_comment function_name
+          execute <<~SQL
+            COMMENT ON FUNCTION #{schema_name}.#{function_name} IS null;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/index.rb

@@ -0,0 +1,27 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Index
+        # add a comment to the index
+        # table name is not needed, but is included here for consistency with the other
+        # rils migrations methods, and to make it easier to understand what table this
+        # index is relate to
+        def set_index_comment table_name, index_name, comment
+          execute <<~SQL
+            COMMENT ON INDEX #{index_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a index comment
+        # table name is not needed, but is included here for consistency with the other
+        # rils migrations methods, and to make it easier to understand what table this
+        # index is relate to
+        def remove_index_comment table_name, index_name
+          execute <<~SQL
+            COMMENT ON INDEX #{index_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/schema.rb

@@ -0,0 +1,21 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Schema
+        def create_schema
+          # schema_name was not provided to this method, it comes from the migration class
+          execute <<~SQL
+            CREATE SCHEMA #{schema_name};
+          SQL
+        end
+
+        def drop_schema
+          # schema_name was not provided to this method, it comes from the migration class
+          execute <<~SQL
+            DROP SCHEMA #{schema_name};
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/table.rb

@@ -0,0 +1,21 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Table
+        # add a comment to the table
+        def set_table_comment table_name, comment
+          execute <<~SQL
+            COMMENT ON TABLE #{schema_name}.#{table_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a table comment
+        def remove_table_comment table_name
+          execute <<~SQL
+            COMMENT ON TABLE #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/trigger.rb

@@ -0,0 +1,109 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Trigger
+        # create a trigger
+        class UnexpectedEventManipulationError < StandardError
+        end
+
+        class UnexpectedActionOrientationError < StandardError
+        end
+
+        class UnexpectedActionTimingError < StandardError
+        end
+
+        class UnexpectedConditionsError < StandardError
+        end
+
+        # create a postgres trigger
+        def add_trigger table_name, name:, action_timing:, event_manipulation:, action_orientation:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          unless [:insert, :delete, :update].include? event_manipulation
+            raise UnexpectedEventManipulationError, event_manipulation
+          end
+
+          unless action_condition.nil? || action_condition.is_a?(String)
+            raise UnexpectedConditionsError, "expected String but got `#{action_condition}`"
+          end
+
+          unless [:row, :statement].include? action_orientation
+            raise UnexpectedActionOrientationError, action_orientation
+          end
+
+          unless [:before, :after, :instead_of].include? action_timing
+            raise UnexpectedActionTimingError, action_timing
+          end
+
+          # "INSTEAD OF/BEFORE/AFTER" "INSERT/UPDATE/DELETE"
+          timing_sql = "#{action_timing.to_s.sub("_", " ")} #{event_manipulation}".upcase
+
+          condition_sql = action_condition.nil? ? "" : "WHEN (#{action_condition})"
+
+          temp_tables = []
+          unless action_reference_old_table.nil?
+            temp_tables << "OLD TABLE AS #{action_reference_old_table}"
+          end
+          unless action_reference_new_table.nil?
+            temp_tables << "NEW TABLE AS #{action_reference_new_table}"
+          end
+          temp_tables_sql = temp_tables.any? ? "REFERENCING #{temp_tables.join(" ")}" : ""
+
+          # schema_name was not provided to this method, it comes from the migration class
+          execute <<~SQL
+            CREATE TRIGGER #{name}
+              #{timing_sql} ON #{schema_name}.#{table_name} #{temp_tables_sql}
+                FOR EACH #{action_orientation}
+                  #{condition_sql}
+                  EXECUTE FUNCTION #{function_schema_name}.#{function_name}();
+          SQL
+
+          if comment.is_a? String
+            set_trigger_comment table_name, name, comment
+          end
+        end
+
+        # wrappers for add_trigger which provide more friendly syntax
+        def before_insert table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :before, event_manipulation: :insert, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def before_update table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :before, event_manipulation: :update, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def before_delete table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :before, event_manipulation: :delete, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def after_insert table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :after, event_manipulation: :insert, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def after_update table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :after, event_manipulation: :update, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def after_delete table_name, name:, function_schema_name:, function_name:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, comment: nil
+          add_trigger table_name, name: name, action_timing: :after, event_manipulation: :delete, action_orientation: :row, function_schema_name: function_schema_name, function_name: function_name, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, comment: comment
+        end
+
+        def remove_trigger table_name, trigger_name
+          execute <<~SQL
+            DROP TRIGGER #{trigger_name} ON #{schema_name}.#{table_name};
+          SQL
+        end
+
+        def set_trigger_comment table_name, trigger_name, comment
+          execute <<~SQL
+            COMMENT ON TRIGGER #{trigger_name} ON #{schema_name}.#{table_name} IS '#{quote comment}';
+          SQL
+        end
+
+        def remove_trigger_comment table_name, trigger_name
+          execute <<~SQL
+            COMMENT ON TRIGGER #{trigger_name} ON #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/unique_constraint.rb

@@ -0,0 +1,63 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module UniqueConstraint
+        # because rails migrations don't support composite (multiple column) foreign keys
+        # column_names can be a single column name or an array of column names
+        def add_unique_constraint table_name, column_names, name:, deferrable: false, initially_deferred: false, comment: nil
+          if initially_deferred == true && deferrable == false
+            raise DeferrableOptionsError, "A constraint can only be initially deferred if it is also deferrable"
+          end
+
+          # convert single column names into arrays, this simplifies the logic below
+          column_names = column_names.is_a?(Array) ? column_names : [column_names]
+
+          # allow it to be deferred, and defer it by default
+          deferrable_sql = if initially_deferred
+            "DEFERRABLE INITIALLY DEFERRED"
+
+          # allow it to be deferred, but do not deferr by default
+          elsif deferrable
+            "DEFERRABLE INITIALLY IMMEDIATE"
+
+          # it can not be deferred (this is the default)
+          else
+            "NOT DEFERRABLE"
+          end
+
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              ADD CONSTRAINT #{name}
+                UNIQUE (#{column_names.join(", ")})
+                #{deferrable_sql};
+          SQL
+
+          if comment.is_a? String
+            set_unique_constraint_comment table_name, name, comment
+          end
+        end
+
+        def remove_unique_constraint table_name, name
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              DROP CONSTRAINT #{name};
+          SQL
+        end
+
+        # add a comment to the unique_constraint
+        def set_unique_constraint_comment table_name, unique_constraint_name, comment
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{unique_constraint_name} ON #{schema_name}.#{table_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a unique_constraint comment
+        def remove_unique_constraint_comment table_name, unique_constraint_name
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{unique_constraint_name} ON #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators/validation.rb

@@ -0,0 +1,67 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Validation
+        # this exists because because the standard rails migration does not support deffered constraints
+        def add_validation table_name, name:, initially_deferred: false, deferrable: false, comment: nil, &block
+          unless block
+            raise MissingFunctionBlockError, "create_function requires a block"
+          end
+          # todo - remove this once steep/rbs can better handle blocks
+          unless block.is_a? NilClass
+            sql = block.call.strip
+          end
+
+          if initially_deferred == true && deferrable == false
+            raise DeferrableOptionsError, "A constraint can only be initially deferred if it is also deferrable"
+          end
+
+          # allow it to be deferred, and defer it by default
+          deferrable_sql = if initially_deferred
+            "DEFERRABLE INITIALLY DEFERRED"
+
+          # allow it to be deferred, but do not deferr by default
+          elsif deferrable
+            "DEFERRABLE INITIALLY IMMEDIATE"
+
+          # it can not be deferred (this is the default)
+          else
+            "NOT DEFERRABLE"
+          end
+
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              ADD CONSTRAINT #{name}
+                CHECK (#{sql})
+                #{deferrable_sql};
+          SQL
+
+          if comment.is_a? String
+            set_validation_comment table_name, name, comment
+          end
+        end
+
+        def remove_validation table_name, name
+          execute <<~SQL
+            ALTER TABLE #{table_name}
+              DROP CONSTRAINT #{name};
+          SQL
+        end
+
+        # add a comment to the validation
+        def set_validation_comment table_name, validation_name, comment
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{validation_name} ON #{schema_name}.#{table_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove a validation comment
+        def remove_validation_comment table_name, validation_name
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{validation_name} ON #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end