dynamic_migrations 3.6.16 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 166ee1f91202640e9ad50fd80c0cb4fade2993ba6ca873ff4bdbf207d939ce81
-  data.tar.gz: e23bc180aa98886aecd575a4b869d595d08f4d90136a59e7de46b7f42b6cbe11
+  metadata.gz: 437a84189a939e185f89db2de8395bc1fb8dc9f159b3948a97dcc5b04c4fedb7
+  data.tar.gz: 6e1df320ac06c0b0ca9d6aeb3abf684e47b9daac4ee1def93180de801f73125b
 SHA512:
-  metadata.gz: e3b9df7db4f4eed952f7144c52eda7a46447d66cdb83e44fff32f97f335cfb78e03ebd87d0e000f781b8c596a21615ccff085933032c8e2534d900864b242f36
-  data.tar.gz: e0ce6d30f2d346dbbb69ae506674aef00dc49eefe04c48d7cf7c8e81e06fea11fe5afb33e7822e87302c1d514d8be5da16070ecbc622829e51bfecc87f650885
+  metadata.gz: c2ce93a8d273abfb0c2ede80b7564216a8409bcd8a43b8fe6c85043eed83d750f8a2b2e53996afdc241e13db9f6cdf2c3f52034a5e93965663684bc121237b54
+  data.tar.gz: bb3378cc475e8e3c16dd2d3a9a5754484da539d3ba1feb4839d2312c1f24cb147ea11534ba3a9bfbcda827bee4bc5ae18cc2c7a2b23bdd67c84a23503fc4fcab

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [3.8.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.7.0...v3.8.0) (2023-10-04)
+
+
+### Features
+
+* configuration option to skip removing unused extensions ([5d27e36](https://github.com/craigulliott/dynamic_migrations/commit/5d27e36363dcec552ed015a196fbcf660e6b038c))
+
+
+### Bug Fixes
+
+* adding a setting to allow customizing where the schema where materialized view structure caches are created ([f3a81f8](https://github.com/craigulliott/dynamic_migrations/commit/f3a81f850dacc40ee434de77bb1d3f3c14ea0872))
+* handling arrays of enums properly ([5d27e36](https://github.com/craigulliott/dynamic_migrations/commit/5d27e36363dcec552ed015a196fbcf660e6b038c))
+* skipping views when loading database tables ([5d27e36](https://github.com/craigulliott/dynamic_migrations/commit/5d27e36363dcec552ed015a196fbcf660e6b038c))
+
+## [3.7.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.16...v3.7.0) (2023-09-27)
+
+
+### Features
+
+* providing access to foreign key constraints from both sides of the association ([48dcf1c](https://github.com/craigulliott/dynamic_migrations/commit/48dcf1cd4cdb23bc37da3e47b00f8007b8bc0f8a))
+
+
+### Bug Fixes
+
+* allowing foreign keys to the same table because they are valid and sometimes useful ([0566384](https://github.com/craigulliott/dynamic_migrations/commit/0566384a4cfeade757d9806059035477f7c41ee2))
+* lazy loading column names for validations when they were configured with a nil value for columns ([439200e](https://github.com/craigulliott/dynamic_migrations/commit/439200efdedf74dddc852bf9bd35e81c1f6b4336))
+* providing convenience method to retrieve columns base data type from array columns ([cd3d9bf](https://github.com/craigulliott/dynamic_migrations/commit/cd3d9bf06682335a890d9b11133d397d7bcd50af))
+* semi colon at the end of function definitions is now optional ([ca9b3aa](https://github.com/craigulliott/dynamic_migrations/commit/ca9b3aa04da23605ff61b2ec14baed927145d2c3))
+* structure loader was not identifying enums properly ([95276d3](https://github.com/craigulliott/dynamic_migrations/commit/95276d33f98f41eca9a9467bb6abeb458a37f16b))
+
 ## [3.6.16](https://github.com/craigulliott/dynamic_migrations/compare/v3.6.15...v3.6.16) (2023-09-16)
 
 

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

@@ -18,7 +18,9 @@ module DynamicMigrations
                 # then we need to delete it
                 elsif database_extension[:exists] == true && !configuration_extension[:exists]
                   # a migration to drop the extension
-                  @generator.disable_extension extension_name
+                  if Postgres.remove_unused_extensions?
+                    @generator.disable_extension extension_name
+                  end
                 end
               end
             end

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

@@ -7,7 +7,7 @@ module DynamicMigrations
         module KeysAndUniqueConstraintsLoader
           def create_database_keys_and_unique_constraints_cache
             connection.exec(<<~SQL)
-              CREATE MATERIALIZED VIEW public.dynamic_migrations_keys_and_unique_constraints_cache as
+              CREATE MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache as
                 SELECT
                   c.conname AS constraint_name,
                   pg_get_constraintdef(c.oid, true) as constraint_definition,
@@ -92,16 +92,16 @@ module DynamicMigrations
               ORDER BY schema_name, table_name;
             SQL
             connection.exec(<<~SQL)
-              CREATE UNIQUE INDEX dynamic_migrations_keys_and_unique_constraints_cache_index ON public.dynamic_migrations_keys_and_unique_constraints_cache (schema_name, table_name, constraint_name);
+              CREATE UNIQUE INDEX dynamic_migrations_keys_and_unique_constraints_cache_index ON #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache (schema_name, table_name, constraint_name);
             SQL
             connection.exec(<<~SQL)
-              COMMENT ON MATERIALIZED VIEW public.dynamic_migrations_keys_and_unique_constraints_cache IS 'A cached representation of the database constraints. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
+              COMMENT ON MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache IS 'A cached representation of the database constraints. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
             SQL
           end
 
           def refresh_database_keys_and_unique_constraints_cache
             connection.exec(<<~SQL)
-              REFRESH MATERIALIZED VIEW public.dynamic_migrations_keys_and_unique_constraints_cache
+              REFRESH MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache
             SQL
           rescue PG::UndefinedTable
             create_database_keys_and_unique_constraints_cache
@@ -112,12 +112,12 @@ module DynamicMigrations
           def fetch_keys_and_unique_constraints
             begin
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_keys_and_unique_constraints_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache
               SQL
             rescue PG::UndefinedTable
               create_database_keys_and_unique_constraints_cache
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_keys_and_unique_constraints_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_keys_and_unique_constraints_cache
               SQL
             end
 

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

@@ -42,7 +42,9 @@ module DynamicMigrations
                 # add each table column
                 table_definition[:columns].each do |column_name, column_definition|
                   if column_definition[:is_enum]
-                    enum_schema, enum_name = column_definition[:data_type].to_s.split(".")
+                    data_type = column_definition[:data_type].to_s
+                    enum_full_name = column_definition[:is_array] ? data_type[0..-3] : data_type
+                    enum_schema, enum_name = enum_full_name.split(".")
                     enum = table.schema.database.loaded_schema(enum_schema.to_sym).enum(enum_name.to_sym)
                   else
                     enum = nil

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

@@ -37,7 +37,9 @@ module DynamicMigrations
             # return a enum by its name, raises an error if the enum does not exist
             def enum enum_name
               raise ExpectedSymbolError, enum_name unless enum_name.is_a? Symbol
-              raise EnumDoesNotExistError unless has_enum? enum_name
+              unless has_enum? enum_name
+                raise EnumDoesNotExistError, "Enum `#{enum_name}` does not exist"
+              end
               @enums[enum_name]
             end
 

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

@@ -34,7 +34,7 @@ module DynamicMigrations
               raise ExpectedSymbolError, name unless name.is_a? Symbol
               @name = name
 
-              unless definition.is_a?(String) && definition.strip != "" && definition.strip.end_with?("END;")
+              unless definition.is_a?(String) && definition.strip != "" && definition.strip.end_with?("END;", "END")
                 raise ExpectedDefinitionError, "Definition must be a string, and end with `END;`. Definition provided:\n#{definition}"
               end
               @definition = definition.strip

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

@@ -77,6 +77,12 @@ module DynamicMigrations
                 !@enum.nil?
               end
 
+              # for arrays returns the column type without the array brackets, for non arrays
+              # jsut returnms the column type
+              def base_data_type
+                array? ? @data_type[0..-3]&.to_sym : @data_type
+              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

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

@@ -14,9 +14,6 @@ module DynamicMigrations
               class ExpectedArrayOfColumnsError < StandardError
               end
 
-              class ExpectedDifferentTablesError < StandardError
-              end
-
               class DuplicateColumnError < StandardError
               end
 
@@ -49,14 +46,14 @@ module DynamicMigrations
                   raise ExpectedArrayOfColumnsError
                 end
 
-                if table.name == foreign_table.name && table.schema.name == foreign_table.schema.name
-                  raise ExpectedDifferentTablesError
-                end
-
                 # tables must be set before the columns are added
                 @table = table
                 @foreign_table = foreign_table
 
+                # add this foreign_key_constraint to the remote table (so we can always find
+                # these from both sides of the association)
+                @foreign_table.add_remote_foreign_key_constraint self
+
                 @columns = {}
                 columns.each do |column|
                   add_column column

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

@@ -61,6 +61,11 @@ module DynamicMigrations
                 # return the new foreign_key_constraint
                 new_foreign_key_constraint
               end
+
+              # called automatically from the other side of the foreign key constraint to keep track of the foreign key from both sides
+              def add_remote_foreign_key_constraint foreign_key_constraint
+                @remote_foreign_key_constraints << foreign_key_constraint
+              end
             end
           end
         end

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

@@ -54,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
 
@@ -201,7 +201,7 @@ module DynamicMigrations
                 descriptions
               end
 
-              # create a temporary table in postgres to represent this validation and fetch
+              # 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?

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

@@ -37,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
@@ -80,11 +83,17 @@ 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.sort
+                columns.map(&:name)
               end
 
               def differences_descriptions other_validation
@@ -102,15 +111,19 @@ module DynamicMigrations
                 if from_database?
                   check_clause
                 else
-                  @normalized_check_clause ||= fetch_normalized_check_clause
+                  normalized_check_clause_and_column_names[: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
+              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")
 
@@ -122,31 +135,46 @@ module DynamicMigrations
                     );
                   SQL
 
-                  # get the normalzed version of the constraint
+                  # get the normalized version of the constraint
                   rows = connection.exec(<<~SQL)
-                    SELECT pg_get_constraintdef(pg_constraint.oid) AS check_clause
+                    SELECT
+                      pg_get_constraintdef(pg_constraint.oid) AS check_clause,
+                      ARRAY_AGG(col.attname ORDER BY u.attposition) AS column_names
                     FROM pg_constraint
-                    WHERE conrelid = 'validation_normalized_check_clause_temp_table'::regclass;
+                    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")
 
-                  # return the normalized check clause
-                  rows.first["check_clause"]
+                  rows.first
                 end
 
-                if ncc.nil?
+                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 = ncc.match(/\ACHECK \((?<inner_clause>.*)\)\z/)
+                matches = result["check_clause"].match(/\ACHECK \((?<inner_clause>.*)\)\z/)
                 if matches.nil?
-                  raise UnnormalizableCheckClauseError, "Unparsable normalized check_clause #{ncc}"
+                  raise UnnormalizableCheckClauseError, "Unparsable normalized check_clause #{result["check_clause"]}"
                 end
 
-                matches[:inner_clause]
+                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

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

@@ -7,12 +7,14 @@ module DynamicMigrations
         module StructureLoader
           def create_database_structure_cache
             connection.exec(<<~SQL)
-              CREATE MATERIALIZED VIEW public.dynamic_migrations_structure_cache AS
+              CREATE MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_structure_cache AS
                 SELECT
                   -- Name of the schema containing the table
                   schemata.schema_name,
                   -- Name of the table
                   tables.table_name,
+                  -- is this a real table or a view
+                  tables.table_type,
                   -- The comment which has been added to the table (if any)
                   table_description.description AS table_description,
                   -- Name of the column
@@ -24,6 +26,8 @@ module DynamicMigrations
                   -- YES if the column is possibly nullable, NO if
                   -- it is known not nullable
                   columns.is_nullable,
+                  -- Is this column an array
+                  columns.data_type = 'ARRAY' AS is_array,
                   -- The formatted data type (such as integer, char(5) or numeric(12,2)[])
                   CASE
                   WHEN tables.table_name IS NOT NULL THEN
@@ -34,12 +38,26 @@ module DynamicMigrations
                   )
                   END AS data_type,
                   -- is this an emum
-                  EXISTS (
-                    SELECT 1
-                    FROM pg_type typ
-                      INNER JOIN pg_enum enu ON typ.oid = enu.enumtypid
-                    WHERE typ.typname = columns.udt_name
-                  ) AS is_enum,
+                  CASE
+                  WHEN columns.data_type = 'ARRAY' OR columns.data_type = 'USER-DEFINED' THEN
+                  (
+                    SELECT EXISTS (
+                      SELECT 1
+                      FROM pg_type
+                      INNER JOIN pg_enum
+                        ON pg_type.oid = pg_enum.enumtypid
+                      INNER JOIN pg_namespace
+                        ON pg_namespace.oid = pg_type.typnamespace
+                      WHERE
+                        -- when the column is an array, the udt_name is the name of the enum prefixed with an underscore
+                        (columns.data_type = 'ARRAY' AND concat('_', pg_type.typname) = columns.udt_name AND pg_namespace.nspname = columns.udt_schema)
+                        -- when the column is not an array, the udt_name is the same name as the enum
+                        OR (columns.data_type = 'USER-DEFINED' AND pg_type.typname = columns.udt_name AND pg_namespace.nspname = columns.udt_schema)
+                    )
+                  )
+                  ELSE FALSE
+                  END
+                  AS is_enum,
                   -- If data_type identifies an interval type, this column contains
                   -- the specification which fields the intervals include for this
                   -- column, e.g., YEAR TO MONTH, DAY TO SECOND, etc. If no field
@@ -55,20 +73,24 @@ module DynamicMigrations
                 LEFT JOIN pg_catalog.pg_description table_description ON table_description.objoid = pg_statio_all_tables.relid AND table_description.objsubid = 0
                 -- required for the column description/comment
                 LEFT JOIN pg_catalog.pg_description column_description ON column_description.objoid = pg_statio_all_tables.relid AND column_description.objsubid = columns.ordinal_position
-                WHERE schemata.schema_name != 'information_schema'
+                WHERE
+                  -- skip internal postgres schemas
+                  schemata.schema_name != 'information_schema'
                   AND schemata.schema_name != 'postgis'
                   AND left(schemata.schema_name, 3) != 'pg_'
+                  -- only base tables (skip views), the null check is required for the left join as the schema might be empty
+                  AND (tables IS NULL OR tables.table_type = 'BASE TABLE')
                 -- order by the schema and table names alphabetically, then by the column position in the table
                 ORDER BY schemata.schema_name, tables.table_schema, columns.ordinal_position
             SQL
             connection.exec(<<~SQL)
-              COMMENT ON MATERIALIZED VIEW public.dynamic_migrations_structure_cache IS 'A cached representation of the database structure. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
+              COMMENT ON MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_structure_cache IS 'A cached representation of the database structure. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
             SQL
           end
 
           def refresh_database_structure_cache
             connection.exec(<<~SQL)
-              REFRESH MATERIALIZED VIEW public.dynamic_migrations_structure_cache
+              REFRESH MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_structure_cache
             SQL
           rescue PG::UndefinedTable
             create_database_structure_cache
@@ -79,12 +101,12 @@ module DynamicMigrations
           def fetch_structure
             begin
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_structure_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_structure_cache
               SQL
             rescue PG::UndefinedTable
               create_database_structure_cache
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_structure_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_structure_cache
               SQL
             end
 
@@ -108,7 +130,8 @@ 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[:is_array] = row["is_array"] == "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/validations_loader.rb

@@ -7,7 +7,7 @@ module DynamicMigrations
         module ValidationsLoader
           def create_database_validations_cache
             connection.exec(<<~SQL)
-              CREATE MATERIALIZED VIEW public.dynamic_migrations_validations_cache AS
+              CREATE MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache AS
                 SELECT
                   nspname AS schema_name,
                   pg_constraint_class.relname AS table_name,
@@ -38,16 +38,16 @@ module DynamicMigrations
                     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);
+              CREATE UNIQUE INDEX dynamic_migrations_validations_cache_index ON #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache (schema_name, table_name, validation_name);
             SQL
             connection.exec(<<~SQL)
-              COMMENT ON MATERIALIZED VIEW public.dynamic_migrations_validations_cache IS 'A cached representation of the database validations. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
+              COMMENT ON MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache IS 'A cached representation of the database validations. This is used by the dynamic migrations library and is created automatically and updated automatically after migrations have run.';
             SQL
           end
 
           def refresh_database_validations_cache
             connection.exec(<<~SQL)
-              REFRESH MATERIALIZED VIEW public.dynamic_migrations_validations_cache
+              REFRESH MATERIALIZED VIEW #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache
             SQL
           rescue PG::UndefinedTable
             create_database_validations_cache
@@ -58,12 +58,12 @@ module DynamicMigrations
           def fetch_validations
             begin
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_validations_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache
               SQL
             rescue PG::UndefinedTable
               create_database_validations_cache
               rows = connection.exec(<<~SQL)
-                SELECT * FROM public.dynamic_migrations_validations_cache
+                SELECT * FROM #{Postgres.cache_schema_name}.dynamic_migrations_validations_cache
               SQL
             end
 

data/lib/dynamic_migrations/postgres.rb

@@ -1,8 +1,33 @@
 # frozen_string_literal: true
 
 module DynamicMigrations
-  # This module exists only to namespace Postgres functionality and
-  # make it possible to add other database/storage types in the future.
   module Postgres
+    # The default behaviour of dynamic migrations is to generate migrations
+    # which remove any unused extensions.
+    # People don't always have control over which extensions are running on the
+    # database, so this behaviour can be disabled by setting
+    # `DynamicMigrations::Postgres.remove_unused_extensions = false`
+    def self.remove_unused_extensions= value
+      @remove_unused_extensions = value
+    end
+
+    # defaults to true, but can be set to false to disable the removal of unused
+    # extensions
+    def self.remove_unused_extensions?
+      (@remove_unused_extensions.nil? || @remove_unused_extensions) ? true : false
+    end
+
+    # Dynamic Migrations creates a materialized view to store a cache representation
+    # of various parts of the database structure, by default this is created in the
+    # public schema, but this can be changed by setting the otion below.
+    def self.cache_schema_name= value
+      @cache_schema_name = value
+    end
+
+    # defaults to true, but can be set to false to disable the removal of unused
+    # extensions
+    def self.cache_schema_name
+      @cache_schema_name || :public
+    end
   end
 end

data/lib/dynamic_migrations/version.rb

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

data/lib/dynamic_migrations.rb

@@ -10,6 +10,8 @@ require "dynamic_migrations/expected_integer_error"
 require "dynamic_migrations/expected_boolean_error"
 require "dynamic_migrations/module_included_into_unexpected_target_error"
 
+require "dynamic_migrations/postgres"
+
 require "dynamic_migrations/postgres/server/database/connection"
 require "dynamic_migrations/postgres/server/database/structure_loader"
 require "dynamic_migrations/postgres/server/database/validations_loader"

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

@@ -20,6 +20,8 @@ module DynamicMigrations
               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

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

@@ -6,7 +6,7 @@ module DynamicMigrations
           class Table
             class Validation < Source
               @columns: Hash[Symbol, Column]
-              @normalized_check_clause: String?
+              @normalized_check_clause_and_column_names: {check_clause: String, column_names: Array[Symbol]}?
 
               attr_reader table: Table
               attr_reader name: Symbol
@@ -16,7 +16,7 @@ module DynamicMigrations
               attr_reader description: String?
               attr_reader template: Symbol?
 
-              def initialize: (database_or_configuration source, Table table, Array[Column] columns, Symbol name, String check_clause, ?deferrable: bool, ?initially_deferred: bool, ?description: String?, ?template: Symbol?) -> void
+              def initialize: (database_or_configuration source, Table table, Array[Column]? columns, Symbol name, String check_clause, ?deferrable: bool, ?initially_deferred: bool, ?description: String?, ?template: Symbol?) -> void
               def columns: -> Array[Column]
               def column_names: -> Array[Symbol]
               def has_description?: -> bool
@@ -24,7 +24,9 @@ module DynamicMigrations
               def normalized_check_clause: -> String
 
               private
-              def fetch_normalized_check_clause: -> String
+
+              def normalized_check_clause_and_column_names: -> {check_clause: String, column_names: Array[Symbol]}
+              def fetch_normalized_check_clause_and_column_names: -> {check_clause: String, column_names: Array[Symbol]}
 
               def add_column: (Column column) -> void
 

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

@@ -11,7 +11,7 @@ module DynamicMigrations
               def has_validation?: (Symbol name) -> bool
               def validations: -> Array[Validation]
               def validations_hash: -> Hash[Symbol, Validation]
-              def add_validation: (Symbol name, Array[Symbol] column_names, String check_clause, **untyped) -> untyped
+              def add_validation: (Symbol name, Array[Symbol]? column_names, String check_clause, **untyped) -> untyped
 
               # these come from the table object (which this module is included into)
               def source: -> database_or_configuration

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

@@ -16,6 +16,7 @@ module DynamicMigrations
             attr_reader schema: Schema
             attr_reader name: Symbol
             attr_reader description: String?
+            attr_reader remote_foreign_key_constraints: Array[ForeignKeyConstraint]
             def initialize: (database_or_configuration source, Schema schema, Symbol name, ?description: String?) -> void
             def has_description?: -> bool
             def add_primary_key: (Symbol name, Array[Symbol] column_names, **untyped) -> untyped

data/sig/dynamic_migrations/postgres.rbs

@@ -1,4 +1,12 @@
 module DynamicMigrations
   module Postgres
+    self.@remove_unused_extensions: bool?
+    self.@cache_schema_name: Symbol?
+
+    def self.remove_unused_extensions=: (bool value) -> bool
+    def self.remove_unused_extensions?: -> bool
+
+    def self.cache_schema_name=: (Symbol value) -> Symbol
+    def self.cache_schema_name: -> Symbol
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.6.16
+  version: 3.8.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-16 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg