dynamic_migrations 3.6.15 → 3.6.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b1f731ee879fc2da123605b8cb10c5dee47ff16a065dd043be4ec4424ceba90
-  data.tar.gz: ee8925da339476c44a54440240d4736b443ae671075d6f9791033052ef542da3
+  metadata.gz: 166ee1f91202640e9ad50fd80c0cb4fade2993ba6ca873ff4bdbf207d939ce81
+  data.tar.gz: e23bc180aa98886aecd575a4b869d595d08f4d90136a59e7de46b7f42b6cbe11
 SHA512:
-  metadata.gz: 841a16d865fc252e0c7ea85b589d0de86703c1d718ba05fd695852daff12117e6dbbfd7ccb22e7f29659253e8193054dccca635423ccd9ea0dc7875482606cb8
-  data.tar.gz: 16ffa1cffc44cf979247738466a5884db216042f82b945b4936e0f1beca4d04b4544f71b4912e65a1b2e5581d8ffb5c4b2d288a55198eaf6dfdcad04372b10b6
+  metadata.gz: e3b9df7db4f4eed952f7144c52eda7a46447d66cdb83e44fff32f97f335cfb78e03ebd87d0e000f781b8c596a21615ccff085933032c8e2534d900864b242f36
+  data.tar.gz: e0ce6d30f2d346dbbb69ae506674aef00dc49eefe04c48d7cf7c8e81e06fea11fe5afb33e7822e87302c1d514d8be5da16070ecbc622829e51bfecc87f650885

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [3.6.16](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.15...v3.6.16) (2023-09-16)
+
+
+### Bug Fixes
+
+* adding convenience method to call all three cache rebuild methods at once ([287a73d](https://github.com/craigulliott/dynamic_migrations/commit/287a73d96c4bfa303150e3c1f65cb514569c03b6))
+* allowing functions and triggers to be in different schemas ([6df3377](https://github.com/craigulliott/dynamic_migrations/commit/6df337780a9a6b6815776a1f65afd3c8325a00fd))
+* always sorting column names on validations so that they match the structure loader ([3e7e646](https://github.com/craigulliott/dynamic_migrations/commit/3e7e646e834140bcce74e357e6e84c3996b9525e))
+* corrected bug where we passed nil as trigger for updating trigger comment ([c7a3677](https://github.com/craigulliott/dynamic_migrations/commit/c7a3677694130125d581f8f68e56865644d5c442))
+* enum values should be strings not symbols ([080e5da](https://github.com/craigulliott/dynamic_migrations/commit/080e5daaeefa1504912e2cd4f3482af82890ee08))
+* fixed bug where constraint was duplicated due to pg check_constraints table allowing duplicates ([471b6f8](https://github.com/craigulliott/dynamic_migrations/commit/471b6f82fc01770e63f657a12d01d18011c69f07))
+* fixing whitespace with create table migrator syntax ([5bf1a7f](https://github.com/craigulliott/dynamic_migrations/commit/5bf1a7f9f337883ca677b1a2015dd0c41a27442c))
+* generating materialized views automatically when refreshing them but they don't yet exist ([471b6f8](https://github.com/craigulliott/dynamic_migrations/commit/471b6f82fc01770e63f657a12d01d18011c69f07))
+* handling default comments via templates ([3e7e646](https://github.com/craigulliott/dynamic_migrations/commit/3e7e646e834140bcce74e357e6e84c3996b9525e))
+* methods to refresh caches because this needs to be performed before and after migrations are generated and run ([ab72670](https://github.com/craigulliott/dynamic_migrations/commit/ab72670e5fc7d379aed86cf72be956cdc39ed620))
+* more strictly validating column types data types which use enums ([3e7e646](https://github.com/craigulliott/dynamic_migrations/commit/3e7e646e834140bcce74e357e6e84c3996b9525e))
+* removed code which was stripping empty lines from migrations, but inadvertently removing empty lines from within SQL statements ([3e7e646](https://github.com/craigulliott/dynamic_migrations/commit/3e7e646e834140bcce74e357e6e84c3996b9525e))
+* updating action order so that its sequential based on the event manipulation type (update, insert etc.) ([3e7e646](https://github.com/craigulliott/dynamic_migrations/commit/3e7e646e834140bcce74e357e6e84c3996b9525e))
+* validations should not end with a semicolon ([9e2cc8e](https://github.com/craigulliott/dynamic_migrations/commit/9e2cc8ebf1c6da8c4741c5257c6567fc9f3668a7))
+* various fixes after running a variety of real migrations from platformer ([301db01](https://github.com/craigulliott/dynamic_migrations/commit/301db01397f1cb16c6c0e08e9e8c69e1f3ec799e))
+
 ## [3.6.15](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.14...v3.6.15) (2023-09-14)
 
 

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

@@ -0,0 +1,21 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module PrimaryKey
+        # add a comment to the primary_key
+        def set_primary_key_comment table_name, primary_key_name, comment
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{primary_key_name} ON #{schema_name}.#{table_name} IS #{quote comment};
+          SQL
+        end
+
+        # remove a primary_key comment
+        def remove_primary_key_comment table_name, primary_key_name
+          execute <<~SQL
+            COMMENT ON CONSTRAINT #{primary_key_name} ON #{schema_name}.#{table_name} IS NULL;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators.rb

@@ -30,6 +30,7 @@ module DynamicMigrations
       include UniqueConstraint
       include Trigger
       include Enum
+      include PrimaryKey
 
       def self.included(base)
         base.extend(ClassMethods)

data/lib/dynamic_migrations/postgres/generator/primary_key.rb

@@ -59,6 +59,38 @@ module DynamicMigrations
           # return the new fragments (the main reason to return them here is for the specs)
           [removal_fragment, recreation_fragment]
         end
+
+        # add a comment to a primary_key
+        def set_primary_key_comment primary_key, code_comment = nil
+          description = primary_key.description
+
+          if description.nil?
+            raise MissingDescriptionError, "Missing required description for primary_key `#{primary_key.name}` in table `#{primary_key.table.schema.name}.#{primary_key.table.name}`"
+          end
+
+          add_fragment schema: primary_key.table.schema,
+            table: primary_key.table,
+            migration_method: :set_primary_key_comment,
+            object: primary_key,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_primary_key_comment :#{primary_key.table.name}, :#{primary_key.name}, <<~COMMENT
+                #{indent description}
+              COMMENT
+            RUBY
+        end
+
+        # remove the comment from a primary_key
+        def remove_primary_key_comment primary_key, code_comment = nil
+          add_fragment schema: primary_key.table.schema,
+            table: primary_key.table,
+            migration_method: :remove_primary_key_comment,
+            object: primary_key,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_primary_key_comment :#{primary_key.table.name}, :#{primary_key.name}
+            RUBY
+        end
       end
     end
   end

data/lib/dynamic_migrations/postgres/generator/table.rb

@@ -93,10 +93,20 @@ module DynamicMigrations
           lines = []
           timestamps = []
           columns.each do |column|
-            # skip the :id, as it is handled by the table_options method
-            next if column.name == :id
-            # skip the :created_at and :updated_at as they are handled below
+            # skip creating the :id column as it is handled by the table_options
+            # method, but add the comment if there is one
+            if column.name == :id
+              unless column.description.nil?
+                set_column_comment column
+              end
+              next
+            end
+            # skip creating the :created_at and :updated_at column as it is handled
+            # by the table_options method, but add the comments
             if column.name == :created_at || column.name == :updated_at
+              unless column.description.nil?
+                set_column_comment column
+              end
               timestamps << column.name
               next
             end
@@ -115,7 +125,7 @@ module DynamicMigrations
             if column.description.nil?
               raise NoTableColumnCommentError, "Refusing to generate create_table migration, no description was provided for `#{column.table.schema.name}`.`#{column.table.name}` column `#{column.name}`"
             end
-            options[:comment] = <<~RUBY
+            options[:comment] = <<~RUBY.strip
               <<~COMMENT
                 #{indent column.description}
               COMMENT
@@ -163,6 +173,12 @@ module DynamicMigrations
             elsif pk_column_names.count > 1
               options << "primary_key: [:#{pk_column_names.join(", :")}]"
             end
+
+            # if the primary key has a description, then add it seperately
+            if table.primary_key.description
+              set_primary_key_comment table.primary_key
+            end
+
           end
 
           options << "comment: table_comment"

data/lib/dynamic_migrations/postgres/generator/table_migration.rb

@@ -17,7 +17,7 @@ module DynamicMigrations
         add_structure_template [:remove_table_comment, :set_table_comment], "Tables"
         add_structure_template [:add_column], "Additional Columns"
         add_structure_template [:change_column, :remove_column_comment, :set_column_comment], "Update Columns"
-        add_structure_template [:add_primary_key], "Primary Key"
+        add_structure_template [:add_primary_key, :set_primary_key_comment, :remove_primary_key_comment], "Primary Key"
         add_structure_template [:add_index, :set_index_comment], "Indexes"
         add_structure_template [:add_foreign_key, :set_foreign_key_constraint_comment, :remove_foreign_key_constraint_comment], "Foreign Keys"
         add_structure_template [:add_validation, :add_unique_constraint, :set_validation_comment, :remove_validation_comment, :set_unique_constraint_comment, :remove_unique_constraint_comment], "Validations"

data/lib/dynamic_migrations/postgres/generator/validation.rb

@@ -57,10 +57,6 @@ module DynamicMigrations
             options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
 
             validation_sql = validation.check_clause.strip
-            # ensure that the validation ends with a semicolon
-            unless validation_sql.end_with? ";"
-              validation_sql << ";"
-            end
 
             add_fragment schema: validation.table.schema,
               table: validation.table,

data/lib/dynamic_migrations/postgres/generator/validation_template_base.rb

@@ -46,14 +46,16 @@ module DynamicMigrations
           matches[:value]
         end
 
-        def name_and_description_options_string default_name
+        def name_and_description_options_string default_name, default_comment = nil
           options = {}
           # we only need to provide a name if it is different than the default
           unless @validation.name == default_name
             options[:name] = @validation.name
           end
-          # only provide a comment if it is not nil
-          unless @validation.description.nil?
+          # only provide a comment if it is not nil and not equal to the provided
+          # default_comment, if it is the same as the default then we wont want to show
+          # it in the migration files
+          unless @validation.description.nil? || @validation.description == default_comment
             options[:comment] = <<~RUBY
               <<~COMMENT
                 #{indent @validation.description || ""}

data/lib/dynamic_migrations/postgres/generator.rb

@@ -243,9 +243,8 @@ module DynamicMigrations
       # This method is called from within the various modules which are included to this class.
       # It locally stores all the fragments which will later be organized into different migrations.
       def add_fragment migration_method:, object:, migration:, schema: nil, table: nil, code_comment: nil, dependent_table: nil, dependent_function: nil, dependent_enum: nil
-        # Remove any empty lines and whitespace from the beginning or the end of the migration and then
-        # strip any empty lines witin the migration (remove the whitespace from them, not delete them).
-        final_migration = strip_empty_lines(migration).strip
+        # Remove any empty lines and whitespace from the beginning or the end of the migration
+        final_migration = trim_lines migration
         fragment = Fragment.new(schema&.name, table&.name, migration_method, object.name, code_comment, final_migration)
 
         if dependent_table
@@ -272,8 +271,8 @@ module DynamicMigrations
         multi_line_string.gsub("\n", "\n#{spaces}")
       end
 
-      def strip_empty_lines multi_line_string
-        multi_line_string.gsub(/^\s*\n/, "")
+      def trim_lines string
+        string.split("\n").map(&:rstrip).join("\n")
       end
     end
   end

data/lib/dynamic_migrations/postgres/server/database/connection.rb

@@ -42,10 +42,12 @@ module DynamicMigrations
             # perform work with the connection
             # todo: `yield connection` would have been preferred, but rbs/steep doesnt understand that syntax
             if block.is_a? Proc
-              block.call connection
+              result = block.call connection
             end
             # close the connection
             disconnect
+            # return whever was returned from within the block
+            result
           end
         end
       end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions.rb

@@ -33,7 +33,7 @@ module DynamicMigrations
 
                   # If the function exists in both the configuration and database representations
                   # but the definition is different then we need to update the definition.
-                  elsif configuration_function[:definition][:matches] == false
+                  elsif configuration_function[:normalized_definition][:matches] == false
                     function = @database.configured_schema(schema_name).function(function_name)
                     @generator.update_function function
                     # does the description also need to be updated

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/foreign_key_constraints.rb

@@ -44,9 +44,9 @@ module DynamicMigrations
                       if configuration_foreign_key_constraint[:description][:matches] == false
                         # if the description was removed
                         if configuration_foreign_key_constraint[:description].nil?
-                          @generator.remove_foreign_key_constraint_comment foreign_key_constraint
+                          @generator.remove_foreign_key_constraint_comment updated_foreign_key_constraint
                         else
-                          @generator.set_foreign_key_constraint_comment foreign_key_constraint
+                          @generator.set_foreign_key_constraint_comment updated_foreign_key_constraint
                         end
                       end
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/indexes.rb

@@ -44,9 +44,9 @@ module DynamicMigrations
                       if configuration_index[:description][:matches] == false
                         # if the description was removed
                         if configuration_index[:description].nil?
-                          @generator.remove_index_comment index
+                          @generator.remove_index_comment updated_index
                         else
-                          @generator.set_index_comment index
+                          @generator.set_index_comment updated_index
                         end
                       end
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/triggers.rb

@@ -44,9 +44,9 @@ module DynamicMigrations
                       if configuration_trigger[:description][:matches] == false
                         # if the description was removed
                         if configuration_trigger[:description].nil?
-                          @generator.remove_trigger_comment trigger
+                          @generator.remove_trigger_comment updated_trigger
                         else
-                          @generator.set_trigger_comment trigger
+                          @generator.set_trigger_comment updated_trigger
                         end
                       end
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/unique_constraints.rb

@@ -44,9 +44,9 @@ module DynamicMigrations
                       if configuration_unique_constraint[:description][:matches] == false
                         # if the description was removed
                         if configuration_unique_constraint[:description].nil?
-                          @generator.remove_unique_constraint_comment unique_constraint
+                          @generator.remove_unique_constraint_comment updated_unique_constraint
                         else
-                          @generator.set_unique_constraint_comment unique_constraint
+                          @generator.set_unique_constraint_comment updated_unique_constraint
                         end
                       end
 

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/validations.rb

@@ -44,9 +44,9 @@ module DynamicMigrations
                       if configuration_validation[:description][:matches] == false
                         # if the description was removed
                         if configuration_validation[:description].nil?
-                          @generator.remove_validation_comment validation
+                          @generator.remove_validation_comment updated_validation
                         else
-                          @generator.set_validation_comment validation
+                          @generator.set_validation_comment updated_validation
                         end
                       end
 

data/lib/dynamic_migrations/postgres/server/database/differences.rb

@@ -172,7 +172,7 @@ module DynamicMigrations
             # the base functions
             functions.each do |function_name, function|
               result[function_name] = compare_record function, comparison_functions[function_name], [
-                :definition,
+                :normalized_definition,
                 :description
               ]
             end
@@ -249,7 +249,7 @@ module DynamicMigrations
                 :action_timing,
                 :event_manipulation,
                 :action_order,
-                :action_condition,
+                :normalized_action_condition,
                 :parameters,
                 :action_orientation,
                 :action_reference_old_table,
@@ -332,7 +332,7 @@ module DynamicMigrations
             validations.each do |name, validation|
               # compare this validation to the equivilent in the comparison list
               result[name] = compare_record validation, comparison_validations[name], [
-                :check_clause,
+                :normalized_check_clause,
                 :column_names,
                 :description,
                 :deferrable,

data/lib/dynamic_migrations/postgres/server/database/enums_loader.rb

@@ -22,7 +22,7 @@ module DynamicMigrations
             rows.each do |row|
               schema_name = row["schema_name"].to_sym
               enum_name = row["enum_name"].to_sym
-              enum_value = row["enum_value"].to_sym
+              enum_value = row["enum_value"]
 
               schema = schemas[schema_name] ||= {}
               enum = schema[enum_name] ||= {

data/lib/dynamic_migrations/postgres/server/database/keys_and_unique_constraints_loader.rb

@@ -99,6 +99,14 @@ module DynamicMigrations
             SQL
           end
 
+          def refresh_database_keys_and_unique_constraints_cache
+            connection.exec(<<~SQL)
+              REFRESH MATERIALIZED VIEW public.dynamic_migrations_keys_and_unique_constraints_cache
+            SQL
+          rescue PG::UndefinedTable
+            create_database_keys_and_unique_constraints_cache
+          end
+
           # fetch all required data from the database and build and return a
           # useful hash representing the keys and indexes of your database
           def fetch_keys_and_unique_constraints

data/lib/dynamic_migrations/postgres/server/database/schema/function.rb

@@ -13,6 +13,9 @@ module DynamicMigrations
             class ExpectedDefinitionError < StandardError
             end
 
+            class UnnormalizableDefinitionError < StandardError
+            end
+
             attr_reader :schema
             attr_reader :name
             attr_reader :definition
@@ -59,9 +62,55 @@ module DynamicMigrations
 
             def differences_descriptions other_function
               method_differences_descriptions other_function, [
-                :definition
+                :normalized_definition
               ]
             end
+
+            # temporarily create a function in postgres and fetch the actual
+            # normalized definition directly from the database
+            def normalized_definition
+              # no need to normalize definitions which originated from the database
+              if from_database?
+                definition
+              else
+                @normalized_definition ||= fetch_normalized_definition
+              end
+            end
+
+            private
+
+            def fetch_normalized_definition
+              fn_def = schema.database.with_connection do |connection|
+                # wrapped in a transaction just in case something here fails, because
+                # we don't want the function to be persisted
+                connection.exec("BEGIN")
+
+                # create a temporary function, from which we will fetch the normalized definition
+                connection.exec(<<~SQL)
+                  CREATE OR REPLACE FUNCTION normalized_definition_temp_fn() returns trigger language plpgsql AS
+                  $$#{definition}$$;
+                SQL
+
+                # get the normalzed version of the definition
+                rows = connection.exec(<<~SQL)
+                  SELECT prosrc AS function_definition
+                  FROM pg_proc
+                  WHERE proname = 'normalized_definition_temp_fn';
+                SQL
+
+                # delete the temp table and close the transaction
+                connection.exec("ROLLBACK")
+
+                # return the normalized function definition
+                rows.first["function_definition"]
+              end
+
+              if fn_def.nil?
+                raise UnnormalizableDefinitionError, "Failed to nomalize action condition `#{definition}`"
+              end
+
+              fn_def
+            end
           end
         end
       end

data/lib/dynamic_migrations/postgres/server/database/schema/table/column.rb

@@ -36,7 +36,11 @@ module DynamicMigrations
                 @data_type = data_type
 
                 @null = null
-                @default = default
+
+                unless default.nil?
+                  raise ExpectedStringError, default unless default.is_a? String
+                  @default = default
+                end
 
                 unless description.nil?
                   raise ExpectedStringError, description unless description.is_a? String
@@ -50,7 +54,7 @@ module DynamicMigrations
                   unless enum.is_a? Enum
                     raise UnexpectedEnumError, "#{enum} is not a valid enum"
                   end
-                  unless @data_type == enum.full_name || @data_type == "#{enum.full_name}[]"
+                  if (array? && @data_type != :"#{enum.full_name}[]") || (!array? && @data_type != enum.full_name)
                     raise UnexpectedEnumError, "enum `#{enum.full_name}` does not match this column's data type `#{@data_type}`"
                   end
                   @enum = enum
@@ -68,6 +72,23 @@ module DynamicMigrations
               def array?
                 @data_type.end_with? "[]"
               end
+
+              def enum?
+                !@enum.nil?
+              end
+
+              # sometimes this system makes temporary tables in order to fetch the normalized
+              # version of constraint check clauses, function definitions or trigger action conditions
+              # because certain data types might not yet exist, we need to use alternative types
+              def temp_table_data_type
+                if enum
+                  :text
+                elsif @data_type == :citext || @data_type == :"citext[]"
+                  :text
+                else
+                  @data_type
+                end
+              end
             end
           end
         end

data/lib/dynamic_migrations/postgres/server/database/schema/table/trigger.rb

@@ -38,6 +38,9 @@ module DynamicMigrations
               class UnexpectedTemplateError < StandardError
               end
 
+              class UnnormalizableActionConditionError < StandardError
+              end
+
               attr_reader :table
               attr_reader :name
               attr_reader :event_manipulation
@@ -147,11 +150,11 @@ module DynamicMigrations
                   end
                   action_order
 
-                # otherwise return the dynamically calculated action order, this is calculated
-                # by returning this triggers index in the list of alphabetically sorted triggers
-                # for this triggers table
+                # otherwise is is computed by finding the index of the trigger within a list of
+                # triggers that are alphabetically sorted, all of which pertain to the same event
+                # manipulation (such as update, insert, etc.) for this triggers table
                 else
-                  pos = @table.triggers.sort_by(&:name).index(self)
+                  pos = @table.triggers.select { |t| t.event_manipulation == event_manipulation }.sort_by(&:name).index(self)
                   if pos.nil?
                     raise "Trigger not found in table triggers list. This should be impossible."
                   end
@@ -184,7 +187,7 @@ module DynamicMigrations
                   :event_manipulation,
                   :action_timing,
                   :action_order,
-                  :action_condition,
+                  :normalized_action_condition,
                   :parameters,
                   :action_orientation,
                   :action_reference_old_table,
@@ -197,6 +200,69 @@ module DynamicMigrations
                 # return the combined differences
                 descriptions
               end
+
+              # create a temporary table in postgres to represent this validation and fetch
+              # the actual normalized check constraint directly from the database
+              def normalized_action_condition
+                if action_condition.nil?
+                  nil
+                # no need to normalize action_conditions which originated from the database
+                elsif from_database?
+                  action_condition
+                else
+                  ac = table.schema.database.with_connection do |connection|
+                    # wrapped in a transaction just in case something here fails, because
+                    # we don't want the function, temporary table or trigger to be persisted
+                    connection.exec("BEGIN")
+
+                    # create the temp table and add the expected columns and constraint
+                    connection.exec(<<~SQL)
+                      CREATE TEMP TABLE trigger_normalized_action_condition_temp_table (
+                        #{table.columns.map { |column| '"' + column.name.to_s + '" ' + column.temp_table_data_type.to_s }.join(", ")}
+                      );
+                    SQL
+
+                    # create a temporary function to trigger (triggers require a function)
+                    connection.exec(<<~SQL)
+                      CREATE OR REPLACE FUNCTION trigger_normalized_action_condition_temp_fn() returns trigger language plpgsql AS
+                      $$ BEGIN END $$;
+                    SQL
+
+                    # create a temporary trigger, from which we will fetch the normalized action condition
+                    connection.exec(<<~SQL)
+                      CREATE TRIGGER trigger_normalized_action_condition_temp_trigger
+                      BEFORE UPDATE ON trigger_normalized_action_condition_temp_table
+                        FOR EACH ROW
+                          WHEN (#{action_condition})
+                          EXECUTE FUNCTION trigger_normalized_action_condition_temp_fn();
+                    SQL
+
+                    # get the normalzed version of the action condition
+                    rows = connection.exec(<<~SQL)
+                      SELECT (
+                        regexp_match(
+                          pg_get_triggerdef(oid),
+                          '.{35,} WHEN ((.+)) EXECUTE FUNCTION')
+                        )[1] as action_condition
+                      FROM pg_trigger
+                      WHERE tgname = 'trigger_normalized_action_condition_temp_trigger'
+                      ;
+                    SQL
+
+                    # delete the temp table and close the transaction
+                    connection.exec("ROLLBACK")
+
+                    # return the normalized action condition
+                    rows.first["action_condition"]
+                  end
+
+                  if ac.nil?
+                    raise UnnormalizableActionConditionError, "Failed to nomalize action condition `#{action_condition}`"
+                  end
+
+                  ac
+                end
+              end
             end
           end
         end

data/lib/dynamic_migrations/postgres/server/database/schema/table/validation.rb

@@ -20,6 +20,9 @@ module DynamicMigrations
               class UnexpectedTemplateError < StandardError
               end
 
+              class UnnormalizableCheckClauseError < StandardError
+              end
+
               attr_reader :table
               attr_reader :name
               attr_reader :check_clause
@@ -81,19 +84,71 @@ module DynamicMigrations
               end
 
               def column_names
-                @columns.keys
+                @columns.keys.sort
               end
 
               def differences_descriptions other_validation
                 method_differences_descriptions other_validation, [
-                  :check_clause,
+                  :normalized_check_clause,
                   :deferrable,
                   :initially_deferred
                 ]
               end
 
+              # create a temporary table in postgres to represent this validation and fetch
+              # the actual normalized check constraint directly from the database
+              def normalized_check_clause
+                # no need to normalize check_clauses which originated from the database
+                if from_database?
+                  check_clause
+                else
+                  @normalized_check_clause ||= fetch_normalized_check_clause
+                end
+              end
+
               private
 
+              def fetch_normalized_check_clause
+                ncc = table.schema.database.with_connection do |connection|
+                  # wrapped in a transaction jsut in case something here fails, because
+                  # we don't want the temporary table to be persisted
+                  connection.exec("BEGIN")
+
+                  # create the temp table and add the expected columns and constraint
+                  connection.exec(<<~SQL)
+                    CREATE TEMP TABLE validation_normalized_check_clause_temp_table (
+                      #{columns.map { |column| '"' + column.name.to_s + '" ' + column.temp_table_data_type.to_s }.join(", ")},
+                      CONSTRAINT #{name} CHECK (#{check_clause})
+                    );
+                  SQL
+
+                  # get the normalzed version of the constraint
+                  rows = connection.exec(<<~SQL)
+                    SELECT pg_get_constraintdef(pg_constraint.oid) AS check_clause
+                    FROM pg_constraint
+                    WHERE conrelid = 'validation_normalized_check_clause_temp_table'::regclass;
+                  SQL
+
+                  # delete the temp table and close the transaction
+                  connection.exec("ROLLBACK")
+
+                  # return the normalized check clause
+                  rows.first["check_clause"]
+                end
+
+                if ncc.nil?
+                  raise UnnormalizableCheckClauseError, "Failed to nomalize check clause `#{check_clause}`"
+                end
+
+                # extract the check clause from the result "CHECK(%check_clause%)"
+                matches = ncc.match(/\ACHECK \((?<inner_clause>.*)\)\z/)
+                if matches.nil?
+                  raise UnnormalizableCheckClauseError, "Unparsable normalized check_clause #{ncc}"
+                end
+
+                matches[:inner_clause]
+              end
+
               # used internally to set the columns from this objects initialize method
               def add_column column
                 # assert that the provided dsl name is an array of Columns

data/lib/dynamic_migrations/postgres/server/database/structure_loader.rb

@@ -66,6 +66,14 @@ module DynamicMigrations
             SQL
           end
 
+          def refresh_database_structure_cache
+            connection.exec(<<~SQL)
+              REFRESH MATERIALIZED VIEW public.dynamic_migrations_structure_cache
+            SQL
+          rescue PG::UndefinedTable
+            create_database_structure_cache
+          end
+
           # fetch all columns from the database and build and return a
           # useful hash representing the structure of your database
           def fetch_structure

data/lib/dynamic_migrations/postgres/server/database/triggers_and_functions_loader.rb

@@ -91,9 +91,10 @@ module DynamicMigrations
               schema = schemas[event_object_schema] ||= {}
               table = schema[event_object_table] ||= {}
 
-              # by convention (and to simplify things) we place these all in the same schema
-              unless row["trigger_schema"] == row["function_schema"] && row["function_schema"] == row["event_object_schema"]
-                raise EventTriggerProcedureSchemaMismatchError, "Expected trigger, procedure and event_object to be in the same schema for trigger '#{trigger_name}'"
+              # By convention (and to simplify things) we place the trigger and the triggers table in the same schema
+              # The function can be in a different schema (and often is, expecially for shared functions)
+              unless row["trigger_schema"] == row["event_object_schema"]
+                raise EventTriggerProcedureSchemaMismatchError, "Expected trigger and event_object to be in the same schema for trigger '#{trigger_name}'"
               end
 
               # turn the parameters into an array of strings

data/lib/dynamic_migrations/postgres/server/database/validations_loader.rb

@@ -7,36 +7,35 @@ module DynamicMigrations
         module ValidationsLoader
           def create_database_validations_cache
             connection.exec(<<~SQL)
-              CREATE MATERIALIZED VIEW public.dynamic_migrations_validations_cache as
-                SELECT table_constraints.table_schema as schema_name,
-                  table_constraints.table_name,
-                  array_agg(col.column_name ORDER BY col.column_name) AS columns,
-                  table_constraints.constraint_name as validation_name,
-                  pg_get_expr(conbin, conrelid, true) as check_clause,
-                  obj_description(pgc.oid, 'pg_constraint') as description,
+              CREATE MATERIALIZED VIEW public.dynamic_migrations_validations_cache AS
+                SELECT
+                  nspname AS schema_name,
+                  pg_constraint_class.relname AS table_name,
+                  array_agg(columns.column_name ORDER BY columns.column_name) AS columns,
+                  pg_get_constraintdef(pg_constraint.oid) AS check_clause,
+                  conname AS validation_name,
+                  obj_description(pg_constraint.oid, 'pg_constraint') AS description,
                   -- in case we need to update this query in a later version of DynamicMigrations
                   1 as table_version
-                FROM information_schema.table_constraints
-                JOIN information_schema.check_constraints
-                  ON table_constraints.constraint_schema = check_constraints.constraint_schema
-                  AND table_constraints.constraint_name = check_constraints.constraint_name
-                JOIN pg_namespace nsp ON nsp.nspname = check_constraints.constraint_schema
-                JOIN pg_constraint pgc ON pgc.conname = check_constraints.constraint_name
-                  AND pgc.connamespace = nsp.oid
-                  AND pgc.contype = 'c'
-                JOIN information_schema.columns col
-                  ON col.table_schema = table_constraints.table_schema
-                  AND col.table_name = table_constraints.table_name
-                  AND col.ordinal_position = ANY(pgc.conkey)
-                WHERE table_constraints.constraint_schema != 'information_schema'
-                  AND table_constraints.constraint_schema != 'postgis'
-                  AND left(table_constraints.constraint_schema, 3) != 'pg_'
-                GROUP BY
-                  pgc.oid,
-                  table_constraints.table_schema,
-                  table_constraints.table_name,
-                  table_constraints.constraint_name,
-                  check_constraints.check_clause;
+                FROM pg_catalog.pg_constraint
+                INNER JOIN pg_catalog.pg_class pg_constraint_class
+                  ON pg_constraint_class.oid = pg_constraint.conrelid
+                INNER JOIN pg_catalog.pg_namespace pg_constraint_namespace
+                  ON pg_constraint_namespace.oid = connamespace
+                JOIN information_schema.columns
+                  ON columns.table_schema = nspname
+                  AND columns.table_name = pg_constraint_class.relname
+                  AND columns.ordinal_position = ANY(pg_constraint.conkey)
+                  WHERE
+                    contype = 'c'
+                    AND nspname != 'information_schema'
+                    AND nspname != 'postgis'
+                    AND left(nspname, 3) != 'pg_'
+                  GROUP BY
+                    pg_constraint.oid,
+                    nspname,
+                    pg_constraint_class.relname,
+                    conname;
             SQL
             connection.exec(<<~SQL)
               CREATE UNIQUE INDEX dynamic_migrations_validations_cache_index ON public.dynamic_migrations_validations_cache (schema_name, table_name, validation_name);
@@ -46,6 +45,14 @@ module DynamicMigrations
             SQL
           end
 
+          def refresh_database_validations_cache
+            connection.exec(<<~SQL)
+              REFRESH MATERIALIZED VIEW public.dynamic_migrations_validations_cache
+            SQL
+          rescue PG::UndefinedTable
+            create_database_validations_cache
+          end
+
           # fetch all columns from the database and build and return a
           # useful hash representing the validations of your database
           def fetch_validations
@@ -70,9 +77,15 @@ module DynamicMigrations
 
               validation_name = row["validation_name"].to_sym
 
+              matches = row["check_clause"].match(/\ACHECK \((?<inner_clause>.*)\)\z/)
+              if matches.nil?
+                raise StandardError, "Unparsable check_clause #{row["check_clause"]}"
+              end
+              check_clause = matches[:inner_clause]
+
               table[validation_name] = {
                 columns: row["columns"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym },
-                check_clause: row["check_clause"],
+                check_clause: check_clause,
                 description: row["description"],
                 deferrable: row["deferrable"] == "TRUE",
                 initially_deferred: row["initially_deferred"] == "TRUE"

data/lib/dynamic_migrations/postgres/server/database.rb

@@ -55,6 +55,12 @@ module DynamicMigrations
         def differences
           Differences.new(self)
         end
+
+        def refresh_caches
+          refresh_database_structure_cache
+          refresh_database_keys_and_unique_constraints_cache
+          refresh_database_validations_cache
+        end
       end
     end
   end

data/lib/dynamic_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicMigrations
-  VERSION = "3.6.15"
+  VERSION = "3.6.16"
 end

data/lib/dynamic_migrations.rb

@@ -95,6 +95,7 @@ require "dynamic_migrations/active_record/migrators/trigger"
 require "dynamic_migrations/active_record/migrators/table"
 require "dynamic_migrations/active_record/migrators/index"
 require "dynamic_migrations/active_record/migrators/enum"
+require "dynamic_migrations/active_record/migrators/primary_key"
 require "dynamic_migrations/active_record/migrators/column"
 require "dynamic_migrations/active_record/migrators"
 

data/sig/dynamic_migrations/active_record/migrators/primary_key.rbs

@@ -0,0 +1,18 @@
+# TypeProf 0.21.7
+
+# Classes
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module PrimaryKey
+        def set_primary_key_comment: (Symbol table_name, Symbol primary_key_name, String comment) -> void
+        def remove_primary_key_comment: (Symbol table_name, Symbol primary_key_name) -> void
+
+        # stubbing these out, as they are available on the module which includes this module
+        def execute: (String sql) -> void
+        def schema_name: () -> Symbol
+        def quote: (String str) -> String
+      end
+    end
+  end
+end

data/sig/dynamic_migrations/postgres/generator/primary_key.rbs

@@ -8,6 +8,8 @@ module DynamicMigrations
         def add_primary_key: (Postgres::Server::Database::Schema::Table::PrimaryKey primary_key, ?String? code_comment) -> Fragment
         def remove_primary_key: (Postgres::Server::Database::Schema::Table::PrimaryKey primary_key, ?String? code_comment) -> Fragment
         def recreate_primary_key: (Postgres::Server::Database::Schema::Table::PrimaryKey original_primary_key, Postgres::Server::Database::Schema::Table::PrimaryKey updated_primary_key) -> Array[Fragment]
+        def set_primary_key_comment: (Postgres::Server::Database::Schema::Table::PrimaryKey primary_key, ?String? code_comment) -> Fragment
+        def remove_primary_key_comment: (Postgres::Server::Database::Schema::Table::PrimaryKey primary_key, ?String? code_comment) -> Fragment
 
         # these come from the generator object (which this module is included into)
         def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment

data/sig/dynamic_migrations/postgres/generator/table.rbs

@@ -13,6 +13,8 @@ module DynamicMigrations
         # these come from the generator object (which this module is included into)
         def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment
         def add_column: (Postgres::Server::Database::Schema::Table::Column column, ?String? code_comment) -> Fragment
+        def set_column_comment: (Postgres::Server::Database::Schema::Table::Column column, ?String? code_comment) -> Fragment
+        def set_primary_key_comment: (Postgres::Server::Database::Schema::Table::PrimaryKey primary_key, ?String? code_comment) -> Fragment
 
         def indent: (String migration, ?Integer levels) -> String
 

data/sig/dynamic_migrations/postgres/generator/validation_template_base.rbs

@@ -6,20 +6,20 @@ module DynamicMigrations
     class Generator
       class ValidationTemplateBase
 
-        attr_reader validation: untyped
+        attr_reader validation: Postgres::Server::Database::Schema::Table::Validation
         attr_reader code_comment: String?
 
-        def initialize: (untyped validation, untyped code_comment) -> void
+        def initialize: (Postgres::Server::Database::Schema::Table::Validation validation, String? code_comment) -> void
 
         # abstract method (should actually be added to child classes)
         def fragment_arguments: -> {schema: Postgres::Server::Database::Schema, table: Postgres::Server::Database::Schema::Table, migration_method: Symbol, object: untyped, code_comment: String?, migration: String, dependent_function: Postgres::Server::Database::Schema::Function?}
 
         private
-        def assert_not_deferred!: -> nil
-        def assert_column_count!: (?Integer count) -> nil
-        def first_column: -> untyped
-        def value_from_check_clause: (untyped regex) -> untyped
-        def name_and_description_options_string: (untyped default_name) -> String?
+        def assert_not_deferred!: -> void
+        def assert_column_count!: (?Integer count) -> void
+        def first_column: -> Postgres::Server::Database::Schema::Table::Column
+        def value_from_check_clause: (Regexp regex) -> untyped
+        def name_and_description_options_string: (Symbol default_name, ?String? default_comment) -> String?
         def indent: (String multi_line_string, ?Integer levels) -> String
 
         class TemplateError < StandardError

data/sig/dynamic_migrations/postgres/generator.rbs

@@ -31,9 +31,9 @@ module DynamicMigrations
       def supported_migration_method?: (Symbol migration_method) -> bool
       def add_fragment: (migration_method: Symbol, object: untyped, migration: String, ?schema: Server::Database::Schema?, ?table: Server::Database::Schema::Table?, ?code_comment: String?, ?dependent_table: Server::Database::Schema::Table?, ?dependent_function: Server::Database::Schema::Function?, ?dependent_enum: Server::Database::Schema::Enum?) -> Fragment
       def indent: (String migration, ?Integer levels) -> String
-      def strip_empty_lines: (String migration) -> String
       def tsort_each_node: -> Enumerator[untyped, untyped]
       def tsort_each_child: (untyped node) -> untyped
+      def trim_lines: (String migration) -> String
 
       class ExpectedSymbolError < StandardError
       end

data/sig/dynamic_migrations/postgres/server/database/connection.rbs

@@ -8,7 +8,7 @@ module DynamicMigrations
           def connect: -> PG::Connection
           def connection: -> PG::Connection
           def disconnect: -> void
-          def with_connection: -> void
+          def with_connection: -> untyped
 
           # these come from the database object (which this module is included into)
           def name: -> Symbol

data/sig/dynamic_migrations/postgres/server/database/keys_and_unique_constraints_loader.rbs

@@ -5,6 +5,7 @@ module DynamicMigrations
         module KeysAndUniqueConstraintsLoader
           def create_database_keys_and_unique_constraints_cache: -> void
           def fetch_keys_and_unique_constraints: -> Hash[untyped, untyped]
+          def refresh_database_keys_and_unique_constraints_cache: -> void
 
           # these come from the database object (which this module is included into)
           def connection: -> PG::Connection

data/sig/dynamic_migrations/postgres/server/database/schema/enum.rbs

@@ -9,10 +9,10 @@ module DynamicMigrations
           class Enum < Source
             attr_reader schema: Schema
             attr_reader name: Symbol
-            attr_reader values: Array[Symbol]
+            attr_reader values: Array[String]
             attr_reader description: String?
             attr_reader columns: Array[Table::Column]
-            def initialize: (database_or_configuration source, Schema schema, Symbol name, Array[Symbol] values, ?description: String?) -> void
+            def initialize: (database_or_configuration source, Schema schema, Symbol name, Array[String] values, ?description: String?) -> void
             def full_name: -> Symbol
             def has_description?: -> bool
             def add_column: (Schema::Table::Column column) -> void

data/sig/dynamic_migrations/postgres/server/database/schema/enums.rbs

@@ -9,7 +9,7 @@ module DynamicMigrations
           module Enums
             @enums: Hash[Symbol, Enum]
 
-            def add_enum: (Symbol enum_name, Array[Symbol] values, ?description: String?) -> nil
+            def add_enum: (Symbol enum_name, Array[String] values, ?description: String?) -> nil
             def enum: (Symbol enum_name) -> Enum
             def has_enum?: (Symbol enum_name) -> bool
             def enums: -> Array[Enum]

data/sig/dynamic_migrations/postgres/server/database/schema/function.rbs

@@ -7,6 +7,8 @@ module DynamicMigrations
       class Database
         class Schema
           class Function < Source
+            @normalized_definition: String?
+
             attr_reader schema: Schema
             attr_reader name: Symbol
             attr_reader definition: String
@@ -16,12 +18,19 @@ module DynamicMigrations
             def has_description?: -> bool
             def add_trigger: (Schema::Table::Trigger trigger) -> void
             def differences_descriptions: (Function other_function) -> Array[String]
+            def normalized_definition: -> String
+
+            private
+            def fetch_normalized_definition: -> String
 
             class ExpectedSchemaError < StandardError
             end
 
             class ExpectedDefinitionError < StandardError
             end
+
+            class UnnormalizableDefinitionError < StandardError
+            end
           end
         end
       end

data/sig/dynamic_migrations/postgres/server/database/schema/table/column.rbs

@@ -18,6 +18,8 @@ module DynamicMigrations
               def initialize: (database_or_configuration source, Table table, Symbol name, Symbol data_type, ?null: bool, ?default: untyped, ?description: String?, ?interval_type: Symbol?, ?enum: Enum?) -> void
               def has_description?: -> bool
               def array?: -> bool
+              def enum?: -> bool
+              def temp_table_data_type: -> Symbol
 
               class ExpectedTableError < StandardError
               end

data/sig/dynamic_migrations/postgres/server/database/schema/table/trigger.rbs

@@ -9,6 +9,8 @@ module DynamicMigrations
           class Table
             class Trigger < Source
               @action_order: Integer?
+              @normalized_action_condition: String?
+
               attr_reader table: Table
               attr_reader name: Symbol
               attr_reader event_manipulation: Symbol
@@ -26,6 +28,10 @@ module DynamicMigrations
               def action_order: -> Integer
               def has_description?: -> false
               def differences_descriptions: (Trigger other_trigger) -> Array[String]
+              def normalized_action_condition: -> String?
+
+              private
+              def fetch_normalized_action_condition: -> String
 
               class ExpectedTableError < StandardError
               end
@@ -56,6 +62,9 @@ module DynamicMigrations
 
               class UnexpectedTemplateError < StandardError
               end
+
+              class UnnormalizableActionConditionError < StandardError
+              end
             end
           end
         end

data/sig/dynamic_migrations/postgres/server/database/schema/table/validation.rbs

@@ -6,6 +6,7 @@ module DynamicMigrations
           class Table
             class Validation < Source
               @columns: Hash[Symbol, Column]
+              @normalized_check_clause: String?
 
               attr_reader table: Table
               attr_reader name: Symbol
@@ -20,8 +21,11 @@ module DynamicMigrations
               def column_names: -> Array[Symbol]
               def has_description?: -> bool
               def differences_descriptions: (Validation other_validation) -> Array[String]
+              def normalized_check_clause: -> String
 
               private
+              def fetch_normalized_check_clause: -> String
+
               def add_column: (Column column) -> void
 
               class ExpectedTableError < StandardError
@@ -39,6 +43,8 @@ module DynamicMigrations
               class UnexpectedTemplateError < StandardError
               end
 
+              class UnnormalizableCheckClauseError < StandardError
+              end
             end
           end
         end

data/sig/dynamic_migrations/postgres/server/database/structure_loader.rbs

@@ -8,6 +8,7 @@ module DynamicMigrations
           def recursively_load_database_structure: -> void
           def fetch_schema_names: -> Array[String]
           def fetch_table_names: (Symbol schema_name) -> Array[String]
+          def refresh_database_structure_cache: -> void
 
           # these come from the database object (which this module is included into)
           def connection: -> PG::Connection

data/sig/dynamic_migrations/postgres/server/database/validations_loader.rbs

@@ -5,6 +5,7 @@ module DynamicMigrations
         module ValidationsLoader
           def create_database_validations_cache: -> void
           def fetch_validations: -> Hash[untyped, untyped]
+          def refresh_database_validations_cache: -> void
 
           # these come from the database object (which this module is included into)
           def connection: -> PG::Connection

data/sig/dynamic_migrations/postgres/server/database.rbs

@@ -25,6 +25,7 @@ module DynamicMigrations
         def initialize: (Server server, Symbol name) -> void
         def schema: (Symbol schema_name, database_or_configuration source) -> untyped
         def differences: -> Differences
+        def refresh_caches: -> void
 
         class ExpectedServerError < StandardError
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.6.15
+  version: 3.6.16
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2023-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -71,6 +71,7 @@ files:
 - lib/dynamic_migrations/active_record/migrators/foreign_key_constraint.rb
 - lib/dynamic_migrations/active_record/migrators/function.rb
 - lib/dynamic_migrations/active_record/migrators/index.rb
+- lib/dynamic_migrations/active_record/migrators/primary_key.rb
 - lib/dynamic_migrations/active_record/migrators/table.rb
 - lib/dynamic_migrations/active_record/migrators/trigger.rb
 - lib/dynamic_migrations/active_record/migrators/unique_constraint.rb
@@ -162,6 +163,7 @@ files:
 - sig/dynamic_migrations/active_record/migrators/foreign_key_constraint.rbs
 - sig/dynamic_migrations/active_record/migrators/function.rbs
 - sig/dynamic_migrations/active_record/migrators/index.rbs
+- sig/dynamic_migrations/active_record/migrators/primary_key.rbs
 - sig/dynamic_migrations/active_record/migrators/table.rbs
 - sig/dynamic_migrations/active_record/migrators/trigger.rbs
 - sig/dynamic_migrations/active_record/migrators/unique_constraint.rbs