dynamic_migrations 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bbdbe66b5d24e600037fcaf794929bca95cb55b6a2bd45de324934ab1ab22b2
-  data.tar.gz: 06dd757a70e427b753e6f5b3f1bdbf970c749947d13ba7771449f595a2968743
+  metadata.gz: 389dc33f29bc39c47961125ad36f5faa377d8609d6d64c2f008517c81bbeb44c
+  data.tar.gz: 27bb1d8d55727f8467b52b7240373bfaf397262d88adfa07db2a04a5d3b52e65
 SHA512:
-  metadata.gz: c1f8deb5208188c16ff9b6b0071b9fea82111626336cd73d77e519ce93bb1af4df74090c3e34de49d007d1709f7b7041f95cbfca97dc4676e91e74b19b5ee556
-  data.tar.gz: bfced908cb97de19a678043f6e6fff00faeb11d4dc1ac8b3b15b3e8611f21c121b5ad9a04dae54a8cbf118f9efee9b9462a1b6dcf12904c511d23c15d079ea93
+  metadata.gz: bf62099155ca8274632d52fbe7328e66eed962a73cbafd6c53cd056ca8fcea00851ddec52263f47d82ea8486756ea89bf79d03d8b2d2fa489399c7f7e60fb3c0
+  data.tar.gz: 0ea7b26061538ae65d1b1c9cddf91dd8afa3a8c2ac3ff41416926235ccb5e0b2ad6cad304129b038d39939cab32492d00c289a85331cc7724a24678b0e202821

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [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))
+* work in progress on the migrations generator ([3e8deb9](https://github.com/craigulliott/dynamic_migrations/commit/3e8deb954913be291ad8e6e7d1c09af619378e4d))
+* work in progress on the migrations generator ([7a999ee](https://github.com/craigulliott/dynamic_migrations/commit/7a999ee8467527164e79f2c6da704245e78cf0cd))
+
+## [2.2.0](https://github.com/craigulliott/dynamic_migrations/compare/v2.1.0...v2.2.0) (2023-07-31)
+
+
+### Features
+
+* using postgres shorthand names such as `numeric(12,2)` for types, and removing the additional column metadata ([86d0113](https://github.com/craigulliott/dynamic_migrations/commit/86d0113aabd4350f278164d18e3c0a611fcf5595))
+
 ## [2.1.0](https://github.com/craigulliott/dynamic_migrations/compare/v2.0.0...v2.1.0) (2023-07-31)
 
 

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

data/lib/dynamic_migrations/active_record/migrators.rb

@@ -0,0 +1,64 @@
+# include this module at the top of your migration to get access to the
+# custom migration methods. For example:
+#
+# class CreateFooBars < ActiveRecord::Migration[7.0]
+#   include DynamicMigrations::ActiveRecord::Migrators
+#
+#   def change
+#     ...
+#   end
+# end
+#
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      class SchemaNameNotSetError < StandardError
+      end
+
+      class DeferrableOptionsError < StandardError
+      end
+
+      class MissingFunctionBlockError < StandardError
+      end
+
+      include Schema
+      include Validation
+      include ForeignKeyConstraint
+      include Table
+      include Index
+      include Column
+      include Function
+      include UniqueConstraint
+      include Trigger
+
+      # The schema name should be set before the migrations for
+      # each schema's migrations are run. This is done by:
+      # DynamicMigrations::ActiveRecord::Migrators.set_schema_name :schema_name
+      def self.schema_name
+        @current_schema
+      end
+
+      def self.set_schema_name schema_name
+        @current_schema = schema_name.to_sym
+      end
+
+      def self.clear_schema_name
+        @current_schema = nil
+      end
+
+      def quote string
+        connection.quote string
+      end
+
+      # this method is made available on the final migration class
+      def schema_name
+        sn = Migrators.schema_name
+        if sn.nil?
+          raise SchemaNameNotSetError
+        end
+        # return the schema name
+        sn
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/name_helper.rb

@@ -0,0 +1,13 @@
+module DynamicMigrations
+  module NameHelper
+    # shortens a table name like 'invoice_subscription_prepayments' to 'inv_sub_pre'
+    warn "no unit tests"
+    def abbreviate_table_name table_name
+      table_name_without_schema = table_name.to_s.split(".").last
+      if table_name_without_schema.nil?
+        raise "no table name provided"
+      end
+      table_name_without_schema.split("_").map { |v| v[0..2] }.join("_")
+    end
+  end
+end