dynamic_migrations 3.6.15 → 3.7.0

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
@@ -51,7 +54,7 @@ module DynamicMigrations
               attr_reader :description
               attr_reader :template
 
-              # initialize a new object to represent a validation in a postgres table
+              # initialize a new object to represent a trigger in a postgres table
               def initialize source, table, name, action_timing:, event_manipulation:, parameters:, action_orientation:, function:, action_order: nil, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil, template: nil
                 super source
 
@@ -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 trigger 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
@@ -34,22 +37,25 @@ module DynamicMigrations
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
 
-                # assert that the provided columns is an array
-                unless columns.is_a?(Array) && columns.count > 0
-                  raise ExpectedArrayOfColumnsError
-                end
-
-                @columns = {}
-                columns.each do |column|
-                  add_column column
-                end
-
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
                 raise ExpectedStringError, check_clause unless check_clause.is_a? String
                 @check_clause = check_clause.strip
 
+                # if this validation is created via configuration (apposed to being loaded) then they can be lazy loaded
+                unless from_configuration? && columns.nil?
+                  # assert that the provided columns is an array
+                  unless columns.is_a?(Array) && columns.count > 0
+                    raise ExpectedArrayOfColumnsError
+                  end
+
+                  @columns = {}
+                  columns.each do |column|
+                    add_column column
+                  end
+                end
+
                 unless description.nil?
                   raise ExpectedStringError, description unless description.is_a? String
                   @description = description.strip
@@ -77,23 +83,100 @@ module DynamicMigrations
 
               # return an array of this validations columns
               def columns
+                if @columns.nil?
+                  @columns = {}
+                  normalized_check_clause_and_column_names[:column_names].each do |column_name|
+                    add_column table.column(column_name)
+                  end
+                end
                 @columns.values
               end
 
               def column_names
-                @columns.keys
+                columns.map(&:name)
               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_and_column_names[:check_clause]
+                end
+              end
+
               private
 
+              def normalized_check_clause_and_column_names
+                @normalized_check_clause_and_column_names ||= fetch_normalized_check_clause_and_column_names
+              end
+
+              def fetch_normalized_check_clause_and_column_names
+                result = table.schema.database.with_connection do |connection|
+                  # wrapped in a transaction just 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 normalized version of the constraint
+                  rows = connection.exec(<<~SQL)
+                    SELECT
+                      pg_get_constraintdef(pg_constraint.oid) AS check_clause,
+                      ARRAY_AGG(col.attname ORDER BY u.attposition) AS column_names
+                    FROM pg_constraint
+                    LEFT JOIN LATERAL UNNEST(pg_constraint.conkey)
+                      WITH ORDINALITY AS u(attnum, attposition)
+                      ON TRUE
+                    LEFT JOIN pg_attribute col
+                      ON
+                        (col.attrelid = pg_constraint.conrelid
+                        AND col.attnum = u.attnum)
+                    WHERE conrelid = 'validation_normalized_check_clause_temp_table'::regclass
+                    GROUP BY pg_constraint.oid;
+                  SQL
+
+                  # delete the temp table and close the transaction
+                  connection.exec("ROLLBACK")
+
+                  rows.first
+                end
+
+                if result["check_clause"].nil?
+                  raise UnnormalizableCheckClauseError, "Failed to nomalize check clause `#{check_clause}`"
+                end
+
+                # extract the check clause from the result "CHECK(%check_clause%)"
+                matches = result["check_clause"].match(/\ACHECK \((?<inner_clause>.*)\)\z/)
+                if matches.nil?
+                  raise UnnormalizableCheckClauseError, "Unparsable normalized check_clause #{result["check_clause"]}"
+                end
+
+                normalized_column_names = result["column_names"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
+
+                # return the normalized check clause
+                {
+                  check_clause: matches[:inner_clause],
+                  column_names: normalized_column_names
+                }
+              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/schema/table/validations.rb

@@ -42,7 +42,7 @@ module DynamicMigrations
                 if has_validation? name
                   raise(ValidationAlreadyExistsError, "Validation #{name} already exists")
                 end
-                columns = column_names.map { |column_name| column column_name }
+                columns = column_names&.map { |column_name| column column_name }
                 included_target = self
                 if included_target.is_a? Table
                   new_validation = @validations[name] = Validation.new source, included_target, columns, name, check_clause, **validation_options

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

@@ -26,6 +26,7 @@ module DynamicMigrations
             attr_reader :schema
             attr_reader :name
             attr_reader :description
+            attr_reader :remote_foreign_key_constraints
 
             # initialize a new object to represent a postgres table
             def initialize source, schema, name, description: nil
@@ -47,6 +48,7 @@ module DynamicMigrations
               @validations = {}
               @indexes = {}
               @foreign_key_constraints = {}
+              @remote_foreign_key_constraints = []
               @triggers = {}
               @unique_constraints = {}
             end

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
@@ -100,7 +108,7 @@ module DynamicMigrations
 
                   column[:data_type] = row["data_type"].to_sym
                   column[:null] = row["is_nullable"] == "YES"
-                  column[:is_enum] = row["is_enum"] == "TRUE"
+                  column[:is_enum] = row["is_enum"] == "t"
                   column[:default] = row["column_default"]
                   column[:description] = row["column_description"]
                   column[:interval_type] = row["interval_type"].nil? ? nil : row["interval_type"].to_sym

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.7.0"
 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,10 @@ 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
+              # untyped because we cant specify this logic in rbs yet (compiler is concerned this might be nil)
+              def base_data_type: -> untyped
 
               class ExpectedTableError < StandardError
               end

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

@@ -38,9 +38,6 @@ module DynamicMigrations
               class ExpectedArrayOfColumnsError < StandardError
               end
 
-              class ExpectedDifferentTablesError < StandardError
-              end
-
               class DuplicateColumnError < StandardError
               end
 

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

@@ -12,6 +12,7 @@ module DynamicMigrations
               def foreign_key_constraints: -> Array[ForeignKeyConstraint]
               def foreign_key_constraints_hash: -> Hash[Symbol, ForeignKeyConstraint]
               def add_foreign_key_constraint: (Symbol name, Array[Symbol] column_names, Symbol foreign_schema_name, Symbol foreign_table_name, Array[Symbol] foreign_column_names, **untyped) -> untyped
+              def add_remote_foreign_key_constraint: (ForeignKeyConstraint foreign_key_constraint) -> untyped
 
               # these come from the table object (which this module is included into)
               def source: -> database_or_configuration