dynamic_migrations 3.8.3 → 3.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08737568ccf7605e0a4d404063b7e1708e67c0ed96ab9f091bb72db627c0d50b'
-  data.tar.gz: 404f7bd4816def6c379a9277ec9c06ad4f58d188d3911f4ca9e9c1a38cf301f8
+  metadata.gz: 0237e61916864ca25f8f7ba1c8882ee7cd8ba687eb2ead948f7dc602cc11e58d
+  data.tar.gz: 8e883bcf30a9b2bf549b7e52062e1cd0576aecaedbe24eb20314522b7e6a6ac8
 SHA512:
-  metadata.gz: a403e1da441c1625e89034f07141d48c15fa07953404638795c2c11d58c79e26468f7b4b9070a37d18d6d62a91f069950b4d9ed824c6404071cee59fd3627d35
-  data.tar.gz: 3df74c476b5d84f8b98f774a69223934823670201649bf35f3aa5a6620738c0fba046bb56ac2e8139364a39ac5a6c4cbdcea547b2cf9625bf45f570261038b80
+  metadata.gz: c026e79bd2af5e73e7cc994fa0a3a28ed480c99f79e151377ae1f01a4953696875d9b3b3df8e53e8e4b6d0e463cadb784ceeed49e0e37b6b6fe9929261f030c5
+  data.tar.gz: 4de30c0cdc9586519da3790fd073eaa4e039214fff6448a064b1fc603a694f3264885ffa3258f542f588e22523173eec55b26c9596753d03a72bbebc5145e7a6

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [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)
+
+
+### Bug Fixes
+
+* asserting that enum values must be unique strings, and adding ability to add additional enum values ([5cf6093](https://github.com/craigulliott/dynamic_migrations/commit/5cf6093eed96387042f70987c3999b40e4041b76))
+
 ## [3.8.3](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.2...v3.8.3) (2023-10-06)
 
 

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

@@ -13,6 +13,12 @@ module DynamicMigrations
             class ExpectedValuesError < StandardError
             end
 
+            class ValueAlreadyExistsError < StandardError
+            end
+
+            class ValueMustBeStringError < StandardError
+            end
+
             attr_reader :schema
             attr_reader :name
             attr_reader :values
@@ -25,8 +31,6 @@ module DynamicMigrations
 
               @columns = []
 
-              @values = []
-
               raise ExpectedSchemaError, schema unless schema.is_a? Schema
               @schema = schema
 
@@ -36,7 +40,10 @@ module DynamicMigrations
               unless values.is_a?(Array) && values.count > 0
                 raise ExpectedValuesError, "Values are required for enums"
               end
-              @values = values
+              @values = []
+              values.each do |value|
+                add_value value
+              end
 
               unless description.nil?
                 raise ExpectedStringError, description unless description.is_a? String
@@ -45,6 +52,18 @@ module DynamicMigrations
               end
             end
 
+            def add_value value
+              unless value.is_a? String
+                raise ValueMustBeStringError, "Value `#{value}` must be a string"
+              end
+
+              if @values.include? value
+                raise ValueAlreadyExistsError, "Value `#{value}` already exists in enum `#{name}`"
+              end
+
+              @values << value
+            end
+
             # returns true if this enum has a description, otehrwise false
             def has_description?
               !@description.nil?

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)
@@ -253,7 +249,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,15 @@ 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")
+
                   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 (#{check_clause})
                   SQL
 
                   # get the normalized version of the constraint
@@ -158,29 +156,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]
+
+                  # 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
 
-                normalized_column_names = result["column_names"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
+                  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: matches[:inner_clause],
-                  column_names: normalized_column_names
-                }
+                  # 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.3"
+  VERSION = "3.8.5"
 end

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

@@ -16,6 +16,7 @@ module DynamicMigrations
             def full_name: -> Symbol
             def has_description?: -> bool
             def add_column: (Schema::Table::Column column) -> void
+            def add_value: (String value) -> void
             def differences_descriptions: (Enum other_enum) -> Array[String]
 
             class ExpectedSchemaError < StandardError
@@ -23,6 +24,12 @@ module DynamicMigrations
 
             class ExpectedValuesError < StandardError
             end
+
+            class ValueAlreadyExistsError < StandardError
+            end
+
+            class ValueMustBeStringError < StandardError
+            end
           end
         end
       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.3
+  version: 3.8.5
 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