dynamic_migrations 3.8.6 → 3.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00405e194209e083433ebb55aa305922a16e24290ead4f240420602c9465bc90
-  data.tar.gz: 57b7136d7eb1f7efc5382101cf24a4dc5ed4852e66a5f67faf368294e05632c0
+  metadata.gz: 443be07abb74aef74bd5d94de87ab2be7f227f81e1c401cb7bf8ebc55bc1c6af
+  data.tar.gz: f93c398273cb1ae28cf6d5b257adeda625f3c732952f327692fb3ef076798f7f
 SHA512:
-  metadata.gz: bc594cb118caa67c0e9982f839c762e074b789b083328a1b69b3261297bd34055a53739f51cabb6f6e5685ea76f80eb4574b45649fd202bf213a579713842fac
-  data.tar.gz: 8d42ee7274c26e25086eae4e9c2646f958f930a18fd03eb9c6262f734cf55af380499763e3508a05156a6f1baad4c7bc30007e9d242674d9594bf83e75a7bf1f
+  metadata.gz: c35b3c1d1834fea80cfdc2c9b14f611b5d76f005b408e0cbfd7592216780454647c519fbc5113bcd5a946a578320417cde47eeaa785fc097dc5062b79a310522
+  data.tar.gz: '09780db07d086da4fc27c5187770248b174d91e7c89a6f3021f1a87e42f97c3b4cf091e7ed510ef7e853e4da360f5b359bbc91a7375b94edd55d09c52e0f905a'

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.8.7](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.6...v3.8.7) (2023-10-09)
+
+
+### Bug Fixes
+
+* added detection of missing extensions and better error messages when normalizing check_constrains and action_conditions ([d82ff57](https://github.com/craigulliott/dynamic_migrations/commit/d82ff57f5b51c8636e87b40b8d6b016d11e6c72a))
+* added enum value length validation ([d82ff57](https://github.com/craigulliott/dynamic_migrations/commit/d82ff57f5b51c8636e87b40b8d6b016d11e6c72a))
+* also drastic performance improvement of migration circular dependency resolution ([2915b8f](https://github.com/craigulliott/dynamic_migrations/commit/2915b8f28c9202bd18f221cfafa2c4352a80fd2c))
+* fixed regex for validating name within migration fragment (it was not allowing a single letter followed by an underscore) ([9b73eca](https://github.com/craigulliott/dynamic_migrations/commit/9b73ecac03816cc74f9b0d23084d0cfb09701012))
+* migration generation now finds and resolves circular dependencies which exist through N migrations (it used to only resolve immediate circular dependencies) ([2915b8f](https://github.com/craigulliott/dynamic_migrations/commit/2915b8f28c9202bd18f221cfafa2c4352a80fd2c))
+* providing the table dependency to all enum and function migrations if there is only one table which they rely on ([3d3708d](https://github.com/craigulliott/dynamic_migrations/commit/3d3708dfb7bdd2a83a477087ac22fd540ae1f881))
+* reducing some log messages from info level to debug level ([cdf1200](https://github.com/craigulliott/dynamic_migrations/commit/cdf12000186a9e373d5085f83d2fb197c7796c6c))
+* table migrations now allow enum related fragments ([b894bf1](https://github.com/craigulliott/dynamic_migrations/commit/b894bf14743c51b505693818407ba6bfb3f31571))
+* updating log level for some log entries ([456a90e](https://github.com/craigulliott/dynamic_migrations/commit/456a90e7fe6da78667a84928b75217f89c344f35))
+
 ## [3.8.6](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.5...v3.8.6) (2023-10-08)
 
 

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

@@ -6,16 +6,8 @@ module DynamicMigrations
         end
 
         def create_enum enum, code_comment = nil
-          # we only provide a table if the enum has a single column and they
-          # are in the same schema, otherwise we can't reliable handle dependencies
-          # so the enum will be created in the schema's migration
-          enum_table = nil
-          if enum.columns.count == 1 && enum.schema == enum.columns.first&.table&.schema
-            enum_table = enum.columns.first&.table
-          end
-
           add_fragment schema: enum.schema,
-            table: enum_table,
+            table: optional_enum_table(enum),
             migration_method: :create_enum,
             object: enum,
             code_comment: code_comment,
@@ -35,6 +27,7 @@ module DynamicMigrations
           end
 
           add_fragment schema: updated_enum.schema,
+            table: optional_enum_table(updated_enum),
             migration_method: :add_enum_values,
             object: updated_enum,
             code_comment: code_comment,
@@ -47,6 +40,7 @@ module DynamicMigrations
 
         def drop_enum enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :drop_enum,
             object: enum,
             code_comment: code_comment,
@@ -58,6 +52,7 @@ module DynamicMigrations
         # add a comment to a enum
         def set_enum_comment enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :set_enum_comment,
             object: enum,
             code_comment: code_comment,
@@ -71,6 +66,7 @@ module DynamicMigrations
         # remove the comment from a enum
         def remove_enum_comment enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :remove_enum_comment,
             object: enum,
             code_comment: code_comment,
@@ -78,6 +74,14 @@ module DynamicMigrations
               remove_enum_comment :#{enum.name}
             RUBY
         end
+
+        # we only provide a table to these migration fragments if the enum applies only to one table
+        # and that take is in the same schema as the enum
+        def optional_enum_table enum
+          # all the tables which use this enum
+          tables = enum.columns.map(&:table).uniq
+          (tables.count == 1 && tables.first&.schema == enum.schema) ? tables.first : nil
+        end
       end
     end
   end

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

@@ -15,7 +15,7 @@ module DynamicMigrations
         attr_reader :dependency_enum_name
 
         def initialize schema_name, table_name, migration_method, object_name, code_comment, content
-          valid_name_regex = /\A[a-z][a-z0-9]+(_[a-z0-9]+)*\z/
+          valid_name_regex = /\A[a-z][a-z0-9]*(_[a-z0-9]+)*\z/
 
           unless schema_name.nil? || (schema_name.to_s.match valid_name_regex)
             raise InvalidNameError, "Invalid schema name `#{schema_name}`, must only be lowercase letters, numbers and underscores"

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

@@ -21,16 +21,8 @@ module DynamicMigrations
 
           fn_sql = function.definition.strip
 
-          # we only provide a table if the function has a single trigger and they
-          # are in the same schema, otherwise we can't reliable handle dependencies
-          # so the function will be created in the schema's migration
-          function_table = nil
-          if function.triggers.count == 1 && function.schema == function.triggers.first&.table&.schema
-            function_table = function.triggers.first&.table
-          end
-
           add_fragment schema: function.schema,
-            table: function_table,
+            table: optional_function_table(function),
             migration_method: :create_function,
             object: function,
             code_comment: code_comment,
@@ -47,7 +39,7 @@ module DynamicMigrations
           fn_sql = function.definition.strip
 
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :update_function,
             object: function,
             code_comment: code_comment,
@@ -62,7 +54,7 @@ module DynamicMigrations
 
         def drop_function function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :drop_function,
             object: function,
             code_comment: code_comment,
@@ -74,7 +66,7 @@ module DynamicMigrations
         # add a comment to a function
         def set_function_comment function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :set_function_comment,
             object: function,
             code_comment: code_comment,
@@ -88,7 +80,7 @@ module DynamicMigrations
         # remove the comment from a function
         def remove_function_comment function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :remove_function_comment,
             object: function,
             code_comment: code_comment,
@@ -96,6 +88,14 @@ module DynamicMigrations
               remove_function_comment :#{function.name}
             RUBY
         end
+
+        # we only provide a table to these migration fragments if the function applies only to one table
+        # and that take is in the same schema as the function
+        def optional_function_table function
+          # all the tables which use this function
+          tables = function.triggers.map(&:table).uniq
+          (tables.count == 1 && tables.first&.schema == function.schema) ? tables.first : nil
+        end
       end
     end
   end

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

@@ -67,6 +67,39 @@ module DynamicMigrations
           @structure_templates = []
         end
 
+        def to_s
+          # because calling these methods will rise an error if there are no
+          # fragments, and this method is primarily used for debugging
+          if @fragments.any?
+            tds = table_dependencies
+            eds = enum_dependencies
+            fds = function_dependencies
+          else
+            tds = []
+            eds = []
+            fds = []
+          end
+          <<~PREVIEW.strip
+            # Migration content preview
+            # -------------------------
+            # Schema:#{@schema_name ? " #{@schema_name}" : ""}
+            # Table:#{@table_name ? " #{@table_name}" : ""}
+
+            # Table Dependencies (count: #{tds.count}):
+            #{(tds.any? ? "#   " : "") + tds.map { |d| "Schema: `#{d[:schema_name]}` Table: `#{d[:table_name]}`" }.join("\n#   ")}
+
+            # Enum Dependencies (count: #{eds.count}):
+            #{(eds.any? ? "#   " : "") + eds.map { |d| "Schema: `#{d[:schema_name]}` Enum: `#{d[:enum_name]}`" }.join("\n#   ")}
+
+            # Function Dependencies (count: #{fds.count}):
+            #{(fds.any? ? "#   " : "") + fds.map { |d| "Schema: `#{d[:schema_name]}` Function: `#{d[:function_name]}`" }.join("\n#   ")}
+
+            # Fragments (count: #{@fragments.count}):
+
+            #{@fragments.map(&:to_s).join("\n\n")}
+          PREVIEW
+        end
+
         # Add a migration fragment to this migration, if the migration is not
         # configured (via a structure template) to handle the method_name of the
         # fragment, then am error is raised. An error will also be raised if the
@@ -95,32 +128,37 @@ module DynamicMigrations
 
         # Return an array of table dependencies for this migration, this array comes from
         # combining any table dependencies from each fragment.
-        # Will raise an error if no fragments have been provided.
+        # Will raise an error if no fragments are available.
         def table_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:table_dependency).compact
+          @fragments.map(&:table_dependency).compact.uniq
         end
 
         # Return an array of function dependencies for this migration, this array comes from
         # combining any function dependencies from each fragment.
-        # Will raise an error if no fragments have been provided.
+        # Will raise an error if no fragments are available.
         def function_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:function_dependency).compact
+          @fragments.map(&:function_dependency).compact.uniq
         end
 
         # Return an array of enum dependencies for this migration, this array comes from
         # combining any enum dependencies from each fragment.
-        # Will raise an error if no fragments have been provided.
+        # Will raise an error if no fragments are available.
         def enum_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:enum_dependency).compact
+          @fragments.map(&:enum_dependency).compact.uniq
+        end
+
+        # returns the number of fragment within this migration which have the provided dependency
+        def fragments_with_table_dependency_count schema_name, table_name
+          @fragments.count { |f| f.is_dependent_on_table? schema_name, table_name }
         end
 
         # removes and returns any fragments which have a dependency on the table with the
         # provided schema_name and table_name, this is used for extracting fragments which
         # cause circular dependencies so they can be placed into their own migrations
-        def extract_fragments_with_dependency schema_name, table_name
+        def extract_fragments_with_table_dependency schema_name, table_name
           results = @fragments.filter { |f| f.is_dependent_on_table? schema_name, table_name }
           # remove any of these from the internal array of fragments
           @fragments.filter! { |f| !f.is_dependent_on_table?(schema_name, table_name) }

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

@@ -15,6 +15,8 @@ module DynamicMigrations
         add_structure_template [:drop_table], "Remove Tables"
         add_structure_template [:create_table], "Create Table"
         add_structure_template [:remove_table_comment, :set_table_comment], "Tables"
+        add_structure_template [:remove_enum_comment, :drop_enum], "Drop Enums"
+        add_structure_template [:create_enum, :add_enum_values, :set_enum_comment], "Enums"
         add_structure_template [:add_column], "Additional Columns"
         add_structure_template [:change_column, :remove_column_comment, :set_column_comment], "Update Columns"
         add_structure_template [:add_primary_key, :set_primary_key_comment, :remove_primary_key_comment], "Primary Key"

data/lib/dynamic_migrations/postgres/generator.rb

@@ -34,10 +34,13 @@ module DynamicMigrations
 
       def initialize
         @fragments = []
+        @logger = Logging.logger[self]
       end
 
       # builds the final migrations
       def migrations
+        log.info "Generating migrations"
+
         # a hash to hold the generated migrations orgnized by their schema and table
         # this makes it easier and faster to work with them within this method
         database_migrations = {}
@@ -49,6 +52,7 @@ module DynamicMigrations
         # Process each fragment, and organize them into migrations. We create a shared
         # Migration for each table, and a single shared migration for any schema migrations
         # which do not relate to a table.
+        log.info "  Organizing migration fragments"
         @fragments.each do |fragment|
           # The first time this schema is encountered we create an object to hold the migrations
           # and organize the different migrations.
@@ -87,32 +91,23 @@ module DynamicMigrations
 
         # Convert the hash of migrations into an array of migrations, this is
         # passed to the `circular_dependency?` method below, and any new migrations
-        # requred to resolve circular dependencies will be added to this array
+        # required to resolve circular dependencies will be added to this array
         all_table_migrations = database_migrations.values.map { |m| m[:table_migrations].values }.flatten
 
-        # iterate through all of the table migrations, and fix any circular dependencies caused
-        # by foreign key constraints
-        database_migrations.each do |schema_name, schema_migrations|
-          # we only need to process the TableMigrations, as the SchemaMigration
-          # never have dependencies
-          schema_migrations[:table_migrations].values.each do |table_migration|
-            # recursively test each table migration for circular dependencies
-            table_migration.table_dependencies.each do |dependency|
-              if circular_dependency? table_migration.schema_name, table_migration.table_name, dependency, all_table_migrations
-                # remove the fragment which is causing the circular dependency
-                removed_fragments = table_migration.extract_fragments_with_dependency dependency[:schema_name], dependency[:table_name]
-                # create a new table migration for these fragments (there should only
-                # be one, but we treat them as an array to futiure proof this)
-                new_migration = TableMigration.new(schema_name, table_migration.table_name)
-                # place these fragments in their own migration
-                removed_fragments.each do |removed_fragment|
-                  new_migration.add_fragment removed_fragment
-                end
-                # add the new migration to the list of migrations
-                schema_migrations[:additional_migrations] << new_migration
-              end
-            end
-          end
+        # For each migration, we recursively traverse the dependency graph to detect and handle circular
+        # dependencies.
+        #
+        # Initially, all the fragments which pertain to a particular table are grouped together in
+        # the same migration. If a circular dependency between migrations is detected, then we simply
+        # pop the offending migration fragments out of the dedicated table migration and into a new
+        # migration. This allows the migration to be processed later, and resolves the circular dependency.
+        log.info "  Resolving circular dependencies between migrations"
+        completed_table_migrations = []
+        all_table_migrations.each do |table_migration|
+          # skip it if it's already been processed
+          next if completed_table_migrations.include? table_migration
+          # recusrsively resolve the circular dependencies for this migration
+          resolve_circular_dependencies table_migration, all_table_migrations, database_migrations, completed_table_migrations
         end
 
         # Prepare a dependency sorter, this is used to sort the migrations via rubys included Tsort module
@@ -123,6 +118,7 @@ module DynamicMigrations
         #   migration1 => [migration2, migration3],
         #   migration3 => [migration2]
         # }
+        log.info "  Preparing migrations for sorting"
         dependency_sorter = MigrationDependencySorter.new
         database_migrations.each do |schema_name, schema_migrations|
           if schema_migrations[:schema_migration]
@@ -161,13 +157,24 @@ module DynamicMigrations
             # if there is a schema migration, then it should always come first
             # so make the table migration depend on it
             deps << schema_migrations[:schema_migration] if schema_migrations[:schema_migration]
+
             # additional migrations are always dependent on the table migration which they came from
             table_migration = schema_migrations[:table_migrations][additional_migration.table_name]
             # if the table migration is not found, then it's safe to assume the table was created
             # by an earlier set of migrations
             unless table_migration.nil?
               deps << table_migration
+
+              # if the table migration has any dependencies on functions or enums, then add them
+              (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
+                # functions are always added to a schema specific migration, if it does not exist then
+                # we can assume the function was added in a previous set of migrations
+                if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
+                  deps << dependencies_schema_migration
+                end
+              end
             end
+
             # if the additional_migration has any dependencies on other tables, then add them too
             additional_migration.table_dependencies.each do |dependency|
               # find the table migration which matches the dependency
@@ -178,19 +185,12 @@ module DynamicMigrations
                 deps << dependent_migration
               end
             end
-            # if the table migration has any dependencies on functions or enums, then add them
-            (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
-              # functions are always added to a schema specific migration, if it does not exist then
-              # we can assume the function was added in a previous set of migrations
-              if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
-                deps << dependencies_schema_migration
-              end
-            end
           end
         end
 
         # sort the migrations so that they are executed in the correct order
         # the order is determined by their dependencies
+        log.info "  Sorting migrations based on their dependencies"
         final_migrations = dependency_sorter.tsort
 
         # if any database only migrations exist, then add them to the front of the array here
@@ -210,23 +210,73 @@ module DynamicMigrations
 
       private
 
-      def circular_dependency? schema_name, table_name, dependency, all_table_migrations
-        # if the current dependency (schema_name and table_name) matches the original migration then we have a circular dependency
-        if dependency[:schema_name] == schema_name && dependency[:table_name] == table_name
-          true
-        else
-          # get all mirations which are for the same schema and table as the dependency
-          dependent_migrations = all_table_migrations.filter { |m| m.schema_name == dependency[:schema_name] && m.table_name == dependency[:table_name] }
-          # recursively call this method for all the dependencies for these migrations
-          dependent_migrations.each do |dependent_migration|
-            dependent_migration.table_dependencies.each do |next_dependency|
-              # if we find a dependency which matches the original schema and table name then we have a circular dependency
-              if circular_dependency?(schema_name, table_name, next_dependency, all_table_migrations)
-                return true
+      # Initially, all the fragments which pertain to a particular table are grouped together in
+      # the same migration. If a circular dependency between migrations is detected, then we simply
+      # pop the offending migration fragments out of the dedicated table migration and into a new
+      # migration. This allows the migration to be processed later, and resolves the circular dependency.
+      #
+      # Note, "table migrations" are the default migrations which initially contain all the fragments for
+      # a particular table.
+      #
+      # `table_migration` is the current migration which is being processed
+      # `all_table_migrations` is all the table migrations in this current set of migrations
+      # `database_migrations` is a hash of all the migrations, organized by schema and table, we need this
+      # object so that we can add any new migrations which are created to resolve circular dependencies
+      # `completed_table_migrations` is an array of all the table migrations which have already been
+      # processed, we use this for performance reasons, so that we dont process the same migration twice
+      # `stack` is an array of all the migrations which have been processed so far in this current recursive
+      # path, this is used to detect circular dependencies.
+      def resolve_circular_dependencies table_migration, all_table_migrations, database_migrations, completed_table_migrations, stack = []
+        # process all the current dependencies for this migration
+        # each dependency is a hash, with the schema_name and table_name
+        table_migration.table_dependencies.each do |dependency|
+          # look in the list of all table migrations and try and find the migration which
+          # matches the current dependency, note that this migration may not exist because
+          # the table could have been created in a previous set of migrations
+          if (next_table_migration = all_table_migrations.find { |m| m.schema_name == dependency[:schema_name] && m.table_name == dependency[:table_name] })
+            # if this migration has already been processed, then we can skip it
+            next if completed_table_migrations.include? next_table_migration
+
+            key = "#{next_table_migration.schema_name}.#{next_table_migration.table_name}"
+            # if this migration already exists in the stack, then we have a circular dependency
+            if stack.include? key
+              log.info "    Resolving circular dependency for #{table_migration.schema_name}.#{table_migration.table_name} -> #{next_table_migration.schema_name}.#{next_table_migration.table_name}"
+
+              # if the number of fragments in the table migration is equal to the number of fragments
+              # which would be removed, then there is no need to split the migration
+              next if table_migration.fragments.count == table_migration.fragments_with_table_dependency_count(next_table_migration.schema_name, next_table_migration.table_name)
+
+              # remove the fragments which are causing the circular dependency
+              removed_fragments = table_migration.extract_fragments_with_table_dependency next_table_migration.schema_name, next_table_migration.table_name
+
+              # create a new table migration for these fragments
+              new_migration = TableMigration.new(table_migration.schema_name, table_migration.table_name)
+
+              # place these fragments in their own migration
+              removed_fragments.each do |removed_fragment|
+                new_migration.add_fragment removed_fragment
               end
+
+              # add the new migration to the list of additional (not standard table migrations) for
+              # this schema
+              database_migrations[table_migration.schema_name][:additional_migrations] << new_migration
+
+              # continue to the next dependency
+              next
             end
+
+            # create a new stack, so that each recursive call has it's own copy
+            new_stack = stack + [key]
+
+            # recursively move on to the next migration
+            resolve_circular_dependencies next_table_migration, all_table_migrations, database_migrations, completed_table_migrations, new_stack
+
+            # when the code reaches this point, we have completed the recursive traversal of
+            # all the dependencies originating from next_table_migration, so we can add it to
+            # the array of completed migrations, note that this array is shared across all
+            # recursive calls, so that we can keep track of which migrations have been processed
+            completed_table_migrations << next_table_migration
           end
-          false
         end
       end
 
@@ -274,6 +324,10 @@ module DynamicMigrations
       def trim_lines string
         string.split("\n").map(&:rstrip).join("\n")
       end
+
+      def log
+        @logger
+      end
     end
   end
 end

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

@@ -11,14 +11,14 @@ module DynamicMigrations
                 # if the extension exists in the configuration but not in the database
                 # then we have to create it
                 if configuration_extension[:exists] == true && !database_extension[:exists]
-                  log.info "Extension `#{extension_name}` exists in configuration but not in the database"
+                  log.debug "Extension `#{extension_name}` exists in configuration but not in the database"
                   # a migration to create the extension
                   @generator.enable_extension extension_name
 
                 # if the extension exists in the database but not in the configuration
                 # then we need to delete it
                 elsif database_extension[:exists] == true && !configuration_extension[:exists]
-                  log.info "Extension `#{extension_name}` exists in database but not in the configuration"
+                  log.debug "Extension `#{extension_name}` exists in database but not in the configuration"
                   # a migration to drop the extension
                   if Postgres.remove_unused_extensions?
                     @generator.disable_extension extension_name

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

@@ -10,10 +10,10 @@ module DynamicMigrations
               module Enums
                 def process_enums schema_name, configuration_enums, database_enums
                   # process all the enums
-                  log.info "  Processing tables..."
+                  log.debug "  Processing tables"
                   enum_names = (configuration_enums.keys + database_enums.keys).uniq
                   enum_names.each do |enum_name|
-                    log.info "  Processing table #{enum_name}..."
+                    log.debug "  Processing table #{enum_name}"
                     process_enum schema_name, enum_name, configuration_enums[enum_name] || {}, database_enums[enum_name] || {}
                   end
                 end
@@ -22,7 +22,7 @@ module DynamicMigrations
                   # If the enum exists in the configuration but not in the database
                   # then we have to create it.
                   if configuration_enum[:exists] == true && !database_enum[:exists]
-                    log.info "  Enum `#{enum_name}` exists in configuration but not in the database"
+                    log.debug "  Enum `#{enum_name}` exists in configuration but not in the database"
 
                     # a migration to create the enum
                     enum = @database.configured_schema(schema_name).enum(enum_name)
@@ -35,7 +35,7 @@ module DynamicMigrations
                   # If the schema exists in the database but not in the configuration
                   # then we need to delete it.
                   elsif database_enum[:exists] == true && !configuration_enum[:exists]
-                    log.info "  Enum `#{enum_name}` exists in database but not in the configuration"
+                    log.debug "  Enum `#{enum_name}` exists in database but not in the configuration"
 
                     # a migration to create the enum
                     enum = @database.loaded_schema(schema_name).enum(enum_name)
@@ -44,9 +44,9 @@ module DynamicMigrations
                   # If the enum exists in both the configuration and database representations
                   # but the values is different then we need to update the values.
                   elsif configuration_enum[:values][:matches] == false
-                    log.info "  Enum `#{enum_name}` exists in both configuration and the database"
+                    log.debug "  Enum `#{enum_name}` exists in both configuration and the database"
 
-                    log.info "    Enum `#{enum_name}` values are different"
+                    log.debug "    Enum `#{enum_name}` values are different"
                     original_enum = @database.loaded_schema(schema_name).enum(enum_name)
                     updated_enum = @database.configured_schema(schema_name).enum(enum_name)
                     @generator.update_enum original_enum, updated_enum
@@ -54,10 +54,10 @@ module DynamicMigrations
                     if configuration_enum[:description][:matches] == false
                       # if the description was removed
                       if configuration_enum[:description].nil?
-                        log.info "    Enum `#{enum_name}` description exists in database but not in the configuration"
+                        log.debug "    Enum `#{enum_name}` description exists in database but not in the configuration"
                         @generator.remove_enum_comment updated_enum
                       else
-                        log.info "    Enum `#{enum_name}` description does not match"
+                        log.debug "    Enum `#{enum_name}` description does not match"
                         @generator.set_enum_comment updated_enum
                       end
                     end
@@ -68,10 +68,10 @@ module DynamicMigrations
                     enum = @database.configured_schema(schema_name).enum(enum_name)
                     # if the description was removed
                     if configuration_enum[:description].nil?
-                      log.info "    Enum `#{enum_name}` description exists in database but not in the configuration"
+                      log.debug "    Enum `#{enum_name}` description exists in database but not in the configuration"
                       @generator.remove_enum_comment enum
                     else
-                      log.info "    Enum `#{enum_name}` description does not match"
+                      log.debug "    Enum `#{enum_name}` description does not match"
                       @generator.set_enum_comment enum
                     end
                   end