dynamic_migrations 3.8.4 → 3.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a9d25190ae4b67f3154feae64f9aa7a11d6b6effc9a6422cce43cde28cbcc68
-  data.tar.gz: 6a7a23a1d7793155f383899ec83f3477ec18581cf94a762a0729466e6d791ac4
+  metadata.gz: 00405e194209e083433ebb55aa305922a16e24290ead4f240420602c9465bc90
+  data.tar.gz: 57b7136d7eb1f7efc5382101cf24a4dc5ed4852e66a5f67faf368294e05632c0
 SHA512:
-  metadata.gz: 84c9ed288329dbb5cc687335820feb293dd4aced564d9ebd8c65e0a84ab12368f8a2b774bef93af9fb9c845fb889eb8daadb9f8c60229e00cc8a78ce768ff3cd
-  data.tar.gz: e2b639cc38df40ed02de870e97707a71a1305819ce3eeac3d61384cdda75c764a3793616149187bf2eed3a40443a3c30f2b19d32ca3a13cf1da2a5f010e01571
+  metadata.gz: bc594cb118caa67c0e9982f839c762e074b789b083328a1b69b3261297bd34055a53739f51cabb6f6e5685ea76f80eb4574b45649fd202bf213a579713842fac
+  data.tar.gz: 8d42ee7274c26e25086eae4e9c2646f958f930a18fd03eb9c6262f734cf55af380499763e3508a05156a6f1baad4c7bc30007e9d242674d9594bf83e75a7bf1f

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.8.6](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.5...v3.8.6) (2023-10-08)
+
+
+### Bug Fixes
+
+* replacing enum casts with the temporary enums when normalizing check clause and action conditions ([0cb67fc](https://github.com/craigulliott/dynamic_migrations/commit/0cb67fcff4d7833ec1dd60453526b1bc3dbe45ee))
+
+## [3.8.5](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.4...v3.8.5) (2023-10-08)
+
+
+### Bug Fixes
+
+* missing error class ([761e478](https://github.com/craigulliott/dynamic_migrations/commit/761e478fbd9234014751d853da3dde35d2043a7e))
+* normalized validation check constraint and trigger action condition now work with enum columns ([a657dd6](https://github.com/craigulliott/dynamic_migrations/commit/a657dd66f3bb3e140672db89224b0b562bb91ef0))
+
 ## [3.8.4](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.3...v3.8.4) (2023-10-06)
 
 

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

@@ -16,6 +16,9 @@ module DynamicMigrations
             class ValueAlreadyExistsError < StandardError
             end
 
+            class ValueMustBeStringError < StandardError
+            end
+
             attr_reader :schema
             attr_reader :name
             attr_reader :values

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

@@ -82,19 +82,6 @@ module DynamicMigrations
               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
-              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/columns.rb

@@ -18,7 +18,9 @@ module DynamicMigrations
               # error if the column does not exist
               def column name
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
-                raise ColumnDoesNotExistError, name unless has_column? name
+                unless has_column? name
+                  raise ColumnDoesNotExistError, "column `#{name}` does not exist within table `#{self.name}`"
+                end
                 @columns[name]
               end
 
@@ -40,7 +42,7 @@ module DynamicMigrations
               # adds a new column to this table, and returns it
               def add_column name, data_type, **column_options
                 if has_column? name
-                  raise(DuplicateColumnError, "Column #{name} already exists")
+                  raise DuplicateColumnError, "Column `#{name}` already exists"
                 end
                 included_target = self
                 if included_target.is_a? Table

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

@@ -202,7 +202,7 @@ module DynamicMigrations
               end
 
               # create a temporary table in postgres to represent this trigger and fetch
-              # the actual normalized check constraint directly from the database
+              # the actual normalized action_condition directly from the database
               def normalized_action_condition
                 if action_condition.nil?
                   nil
@@ -215,12 +215,8 @@ module DynamicMigrations
                     # 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 the temp table and add the expected columns
+                    temp_enums = table.create_temp_table(connection, "trigger_normalized_action_condition_temp_table")
 
                     # create a temporary function to trigger (triggers require a function)
                     connection.exec(<<~SQL)
@@ -228,6 +224,13 @@ module DynamicMigrations
                       $$ BEGIN END $$;
                     SQL
 
+                    temp_action_condition = action_condition
+                    # string replace any real enum names with their temp enum names
+                    temp_enums.each do |temp_enum_name, enum|
+                      temp_action_condition.gsub!("::#{enum.name}", "::#{temp_enum_name}")
+                      temp_action_condition.gsub!("::#{enum.full_name}", "::#{temp_enum_name}")
+                    end
+
                     # create a temporary trigger, from which we will fetch the normalized action condition
                     connection.exec(<<~SQL)
                       CREATE TRIGGER trigger_normalized_action_condition_temp_trigger
@@ -253,7 +256,15 @@ module DynamicMigrations
                     connection.exec("ROLLBACK")
 
                     # return the normalized action condition
-                    rows.first["action_condition"]
+                    action_condition_result = rows.first["action_condition"]
+
+                    # string replace any enum names with their real enum names
+                    temp_enums.each do |temp_enum_name, enum|
+                      real_enum_name = (enum.schema == table.schema) ? enum.name : enum.full_name
+                      action_condition_result.gsub!("::#{temp_enum_name}", "::#{real_enum_name}")
+                    end
+
+                    action_condition_result
                   end
 
                   if ac.nil?

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

@@ -128,17 +128,22 @@ module DynamicMigrations
                 if table.columns.empty?
                   raise ExpectedTableColumnsError, "Can not normalize check clause or validation columnns because the table has no columns"
                 end
-                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
+                table.schema.database.with_connection do |connection|
+                  # wrapped in a transaction so we can rollback the creation of the table and any enums
                   connection.exec("BEGIN")
 
-                  # create the temp table and add the expected columns and constraint
+                  temp_enums = table.create_temp_table(connection, "validation_normalized_check_clause_temp_table")
+
+                  temp_check_clause = check_clause
+                  # string replace any real enum names with their temp enum names
+                  temp_enums.each do |temp_enum_name, enum|
+                    temp_check_clause.gsub!("::#{enum.name}", "::#{temp_enum_name}")
+                    temp_check_clause.gsub!("::#{enum.full_name}", "::#{temp_enum_name}")
+                  end
+
                   connection.exec(<<~SQL)
-                    CREATE TEMP TABLE validation_normalized_check_clause_temp_table (
-                      #{table.columns.map { |column| '"' + column.name.to_s + '" ' + column.temp_table_data_type.to_s }.join(", ")},
-                      CONSTRAINT #{name} CHECK (#{check_clause})
-                    );
+                    ALTER TABLE validation_normalized_check_clause_temp_table
+                      ADD CONSTRAINT #{name} CHECK (#{temp_check_clause})
                   SQL
 
                   # get the normalized version of the constraint
@@ -158,29 +163,37 @@ module DynamicMigrations
                     GROUP BY pg_constraint.oid;
                   SQL
 
-                  # delete the temp table and close the transaction
+                  # delete the table and any temporary enums
                   connection.exec("ROLLBACK")
 
-                  rows.first
-                end
+                  check_clause_result = rows.first["check_clause"]
+                  column_names_string = rows.first["column_names"]
 
-                if result["check_clause"].nil?
-                  raise UnnormalizableCheckClauseError, "Failed to nomalize check clause `#{check_clause}`"
-                end
+                  if check_clause_result.nil?
+                    raise UnnormalizableCheckClauseError, "Failed to nomalize check clause `#{check_clause_result}`"
+                  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
+                  # extract the check clause from the result "CHECK(%check_clause%)"
+                  matches = check_clause_result.match(/\ACHECK \((?<inner_clause>.*)\)\z/)
+                  if matches.nil?
+                    raise UnnormalizableCheckClauseError, "Unparsable normalized check_clause #{check_clause_result}"
+                  end
+                  check_clause_result = matches[:inner_clause]
 
-                normalized_column_names = result["column_names"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
+                  # string replace any enum names with their real enum names
+                  temp_enums.each do |temp_enum_name, enum|
+                    real_enum_name = (enum.schema == table.schema) ? enum.name : enum.full_name
+                    check_clause_result.gsub!("::#{temp_enum_name}", "::#{real_enum_name}")
+                  end
 
-                # return the normalized check clause
-                {
-                  check_clause: matches[:inner_clause],
-                  column_names: normalized_column_names
-                }
+                  column_names_result = column_names_string.gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
+
+                  # return the normalized check clause
+                  {
+                    check_clause: check_clause_result,
+                    column_names: column_names_result
+                  }
+                end
               end
 
               # used internally to set the columns from this objects initialize method

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

@@ -78,6 +78,56 @@ module DynamicMigrations
               end
               pk
             end
+
+            # Used within validations and triggers when normalizing check clauses and other
+            # SQL statements which require a table to process the SQL.
+            #
+            # This method returns a hash representation of any temporary enums created to satisfy
+            # the columns in the table
+            def create_temp_table connection, temp_table_name
+              # create the temp table and add the expected columns
+
+              # if any of the columns are enums, then we need to create a temporary enum type for them.
+              # we cant just create temporary columns as text fields because postgres may automatically
+              # add casts to those columns, which would result in a different normalized check clause
+              temp_enums = {}
+
+              # an array of sql column definitions for within the create table SQL
+              # we process each column individually like this so that we can create temporary enums for
+              # any enum columns
+              columns_sql = columns.map do |column|
+                enum = column.enum
+                if enum
+                  # create the temporary enum type
+                  temp_enum_name = "#{temp_table_name}_enum_#{temp_enums.count}"
+                  connection.exec(<<~SQL)
+                    CREATE TYPE #{temp_enum_name} as ENUM ('#{enum.values.join("','")}');
+                  SQL
+                  temp_enums[temp_enum_name] = enum
+
+                  # return the column definition used within the CREATE TABLE SQL
+                  data_type = column.array? ? "#{temp_enum_name}[]" : temp_enum_name
+                  "\"#{column.name}\" #{data_type}"
+
+                else
+                  # return the column definition used within the CREATE TABLE SQL
+                  "\"#{column.name}\" #{column.data_type}"
+                end
+              end
+
+              # in case any of the columnbs are citext columns
+              connection.exec("CREATE EXTENSION IF NOT EXISTS citext;")
+
+              # note, this is not actually a TEMP TABLE, it is created within a transaction
+              # and rolled back.
+              connection.exec(<<~SQL)
+                CREATE TABLE #{temp_table_name} (
+                  #{columns_sql.join(", ")}
+                );
+              SQL
+
+              temp_enums
+            end
           end
         end
       end

data/lib/dynamic_migrations/version.rb

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

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

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

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

@@ -15,6 +15,7 @@ module DynamicMigrations
 
               # these come from the table object (which this module is included into)
               def source: -> database_or_configuration
+              def name: -> String
 
               class ColumnDoesNotExistError < StandardError
               end

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

@@ -22,7 +22,7 @@ module DynamicMigrations
             def add_primary_key: (Symbol name, Array[Symbol] column_names, **untyped) -> untyped
             def has_primary_key?: -> bool
             def primary_key: -> PrimaryKey
-
+            def create_temp_table: (PG::Connection connection, String table_name) -> Hash[String, Enum]
             class ExpectedSchemaError < StandardError
             end
 

metadata

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