dynamic_migrations 2.2.0 → 3.1.0

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module PrimaryKey
+                  def process_primary_key schema_name, table_name, configuration_primary_key, database_primary_key
+                    configuration_primary_key_exists = configuration_primary_key && configuration_primary_key[:exists]
+                    database_primary_key_exists = database_primary_key && database_primary_key[:exists]
+
+                    # If the primary_key exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_primary_key_exists == true && database_primary_key_exists == false
+                      # a migration to create the primary_key
+                      primary_key = @database.configured_schema(schema_name).table(table_name).primary_key
+                      @generator.add_primary_key primary_key
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_primary_key_exists == false && database_primary_key_exists == true
+                      # a migration to create the primary_key
+                      primary_key = @database.loaded_schema(schema_name).table(table_name).primary_key
+                      @generator.remove_primary_key primary_key
+
+                    # If the primary_key exists in both the configuration and database representations
+                    elsif configuration_primary_key_exists == true && database_primary_key_exists == true
+                      # If the definition (i.e. the column names) is different then we need to update the primary key.
+                      if configuration_primary_key.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                        # recreate the primary_key
+                        original_primary_key = @database.loaded_schema(schema_name).table(table_name).primary_key
+                        updated_primary_key = @database.configured_schema(schema_name).table(table_name).primary_key
+                        @generator.recreate_primary_key original_primary_key, updated_primary_key
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module Triggers
+                  def process_triggers schema_name, table_name, configuration_triggers, database_triggers
+                    # process all the triggers
+                    trigger_names = (configuration_triggers.keys + database_triggers.keys).uniq
+                    trigger_names.each do |trigger_name|
+                      process_trigger schema_name, table_name, trigger_name, configuration_triggers[trigger_name] || {}, database_triggers[trigger_name] || {}
+                    end
+                  end
+
+                  def process_trigger schema_name, table_name, trigger_name, configuration_trigger, database_trigger
+                    # If the trigger exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_trigger[:exists] == true && database_trigger[:exists] == false
+                      # a migration to create the trigger
+                      trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
+                      @generator.add_trigger trigger
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_trigger[:exists] == false && database_trigger[:exists] == true
+                      # a migration to create the trigger
+                      trigger = @database.loaded_schema(schema_name).table(table_name).trigger(trigger_name)
+                      @generator.remove_trigger trigger
+
+                    # If the trigger exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_trigger.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # recreate the trigger
+                      original_trigger = @database.loaded_schema(schema_name).table(table_name).trigger(trigger_name)
+                      updated_trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
+                      @generator.recreate_trigger original_trigger, updated_trigger
+                      # does the description also need to be updated
+                      if configuration_trigger[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_trigger[:description].nil?
+                          @generator.remove_trigger_comment trigger
+                        else
+                          @generator.set_trigger_comment trigger
+                        end
+                      end
+
+                    # If the trigger exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_trigger[:description][:matches] == false
+                      trigger = @database.configured_schema(schema_name).table(table_name).trigger(trigger_name)
+                      # if the description was removed
+                      if configuration_trigger[:description].nil?
+                        @generator.remove_trigger_comment trigger
+                      else
+                        @generator.set_trigger_comment trigger
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module UniqueConstraints
+                  def process_unique_constraints schema_name, table_name, configuration_unique_constraints, database_unique_constraints
+                    # process all the unique_constraints
+                    unique_constraint_names = (configuration_unique_constraints.keys + database_unique_constraints.keys).uniq
+                    unique_constraint_names.each do |unique_constraint_name|
+                      process_unique_constraint schema_name, table_name, unique_constraint_name, configuration_unique_constraints[unique_constraint_name] || {}, database_unique_constraints[unique_constraint_name] || {}
+                    end
+                  end
+
+                  def process_unique_constraint schema_name, table_name, unique_constraint_name, configuration_unique_constraint, database_unique_constraint
+                    # If the unique_constraint exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_unique_constraint[:exists] == true && database_unique_constraint[:exists] == false
+                      # a migration to create the unique_constraint
+                      unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
+                      @generator.add_unique_constraint unique_constraint
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_unique_constraint[:exists] == false && database_unique_constraint[:exists] == true
+                      # a migration to create the unique_constraint
+                      unique_constraint = @database.loaded_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
+                      @generator.remove_unique_constraint unique_constraint
+
+                    # If the unique_constraint exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_unique_constraint.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # recreate the unique_constraint
+                      original_unique_constraint = @database.loaded_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
+                      updated_unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
+                      @generator.recreate_unique_constraint original_unique_constraint, updated_unique_constraint
+                      # does the description also need to be updated
+                      if configuration_unique_constraint[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_unique_constraint[:description].nil?
+                          @generator.remove_unique_constraint_comment unique_constraint
+                        else
+                          @generator.set_unique_constraint_comment unique_constraint
+                        end
+                      end
+
+                    # If the unique_constraint exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_unique_constraint[:description][:matches] == false
+                      unique_constraint = @database.configured_schema(schema_name).table(table_name).unique_constraint(unique_constraint_name)
+                      # if the description was removed
+                      if configuration_unique_constraint[:description].nil?
+                        @generator.remove_unique_constraint_comment unique_constraint
+                      else
+                        @generator.set_unique_constraint_comment unique_constraint
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module Validations
+                  def process_validations schema_name, table_name, configuration_validations, database_validations
+                    # process all the validations
+                    validation_names = (configuration_validations.keys + database_validations.keys).uniq
+                    validation_names.each do |validation_name|
+                      process_validation schema_name, table_name, validation_name, configuration_validations[validation_name] || {}, database_validations[validation_name] || {}
+                    end
+                  end
+
+                  def process_validation schema_name, table_name, validation_name, configuration_validation, database_validation
+                    # If the validation exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_validation[:exists] == true && database_validation[:exists] == false
+                      # a migration to create the validation
+                      validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
+                      @generator.add_validation validation
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_validation[:exists] == false && database_validation[:exists] == true
+                      # a migration to create the validation
+                      validation = @database.loaded_schema(schema_name).table(table_name).validation(validation_name)
+                      @generator.remove_validation validation
+
+                    # If the validation exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_validation.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # recreate the validation
+                      original_validation = @database.loaded_schema(schema_name).table(table_name).validation(validation_name)
+                      updated_validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
+                      @generator.recreate_validation original_validation, updated_validation
+                      # does the description also need to be updated
+                      if configuration_validation[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_validation[:description].nil?
+                          @generator.remove_validation_comment validation
+                        else
+                          @generator.set_validation_comment validation
+                        end
+                      end
+
+                    # If the validation exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_validation[:description][:matches] == false
+                      validation = @database.configured_schema(schema_name).table(table_name).validation(validation_name)
+                      # if the description was removed
+                      if configuration_validation[:description].nil?
+                        @generator.remove_validation_comment validation
+                      else
+                        @generator.set_validation_comment validation
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                def process_tables schema_name, configuration_tables, database_tables
+                  # process all the tables
+                  table_names = (configuration_tables.keys + database_tables.keys).uniq
+                  table_names.each do |table_name|
+                    process_table schema_name, table_name, configuration_tables[table_name] || {}, database_tables[table_name] || {}
+                  end
+                end
+
+                def process_table schema_name, table_name, configuration_table, database_table
+                  # If the table exists in the configuration but not in the database
+                  # then we have to create it.
+                  if configuration_table[:exists] == true && database_table[:exists] == false
+                    # a migration to create the table
+                    table = @database.configured_schema(schema_name).table(table_name)
+                    @generator.create_table table
+
+                    # we process everything else after we create the table, because the other
+                    # database objects are dependent on the table
+                    process_dependents schema_name, table_name, configuration_table, {}
+
+                  # If the schema exists in the database but not in the configuration
+                  # then we need to delete it.
+                  elsif configuration_table[:exists] == false && database_table[:exists] == true
+                    # we process everything else before we drop the table, because the other
+                    # database objects are dependent on the table
+                    process_dependents schema_name, table_name, {}, database_table
+
+                    # a migration to remove the table
+                    table = @database.loaded_schema(schema_name).table(table_name)
+                    @generator.drop_table table
+
+                  # If the table exists in both the configuration and database representations
+                  # but the description is different then we need to update the description.
+                  elsif configuration_table[:description][:matches] == false
+                    table = @database.configured_schema(schema_name).table(table_name)
+                    # if the description was removed
+                    if configuration_table[:description].nil?
+                      @generator.remove_table_comment table
+                    else
+                      @generator.set_table_comment table
+                    end
+
+                    # process everything else
+                    process_dependents schema_name, table_name, configuration_table, database_table
+
+                  else
+                    # process everything else
+                    process_dependents schema_name, table_name, configuration_table, database_table
+
+                  end
+                end
+
+                def process_dependents schema_name, table_name, configuration_table, database_table
+                  process_columns schema_name, table_name, configuration_table[:columns] || {}, database_table[:columns] || {}
+                  process_foreign_key_constraints schema_name, table_name, configuration_table[:foreign_key_constraints] || {}, database_table[:foreign_key_constraints] || {}
+                  process_indexes schema_name, table_name, configuration_table[:indexes] || {}, database_table[:indexes] || {}
+                  process_triggers schema_name, table_name, configuration_table[:triggers] || {}, database_table[:triggers] || {}
+                  process_unique_constraints schema_name, table_name, configuration_table[:unique_constraints] || {}, database_table[:unique_constraints] || {}
+                  process_validations schema_name, table_name, configuration_table[:validations] || {}, database_table[:validations] || {}
+                  # Process the primary key. The primary key is singular (max of one per table)
+                  process_primary_key schema_name, table_name, configuration_table[:primary_key], database_table[:primary_key]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              def process_schema schema_name, configuration_schema, database_schema
+                # if the schema exists in the configuration but not in the database
+                # then we have to create it
+                if configuration_schema[:exists] == true && database_schema[:exists] == false
+                  # a migration to create the schema
+                  schema = @database.configured_schema schema_name
+                  @generator.create_schema schema
+
+                  # we process the tables and functions after we create the schema
+                  # otherwise the schemas objects will not be able to be created
+                  process_functions schema_name, configuration_schema[:functions], {}
+                  process_tables schema_name, configuration_schema[:tables], {}
+
+                # if the schema exists in the database but not in the configuration
+                # then we need to delete it
+                elsif configuration_schema[:exists] == false && database_schema[:exists] == true
+                  # we process the tables and functions before we drop the schema
+                  # as this will drop any dependencies on the schema
+                  process_functions schema_name, {}, database_schema[:functions]
+                  process_tables schema_name, {}, database_schema[:tables]
+
+                  # a migration to drop the schema
+                  schema = @database.loaded_schema schema_name
+                  @generator.drop_schema schema
+
+                # if the schema exists in both the configuration and database representations
+                # then we just need to process the tables and functions
+                else
+                  process_functions schema_name, configuration_schema[:functions], database_schema[:functions]
+                  process_tables schema_name, configuration_schema[:tables], database_schema[:tables]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            class UnexpectedDatabaseObjectError < StandardError
+            end
+
+            class UnexpectedDifferencesObjectError < StandardError
+            end
+
+            include Schemas
+            include Schemas::Functions
+            include Schemas::Tables
+            include Schemas::Tables::Columns
+            include Schemas::Tables::ForeignKeyConstraints
+            include Schemas::Tables::Indexes
+            include Schemas::Tables::PrimaryKey
+            include Schemas::Tables::Triggers
+            include Schemas::Tables::UniqueConstraints
+            include Schemas::Tables::Validations
+
+            def initialize database, differences
+              raise UnexpectedDatabaseObjectError, database unless database.is_a? Database
+              @database = database
+
+              raise UnexpectedDifferencesObjectError, differences unless differences.is_a? Differences
+              @differences = differences
+
+              # the generator which will build the migrations
+              @generator = Generator.new
+            end
+
+            def migrations
+              # process all the schemas (we can fetch the schema names from either the
+              # configuration or the database object)
+              schema_names = differences[:configuration].keys
+              schema_names.each do |schema_name|
+                process_schema schema_name, differences[:configuration][schema_name], differences[:database][schema_name]
+              end
+
+              # return the migrations organized by schema
+              @generator.migrations
+            end
+
+            private
+
+            def differences
+              @differences_hash ||= @differences.to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,9 @@ module DynamicMigrations
           class TableRequiredError < StandardError
           end
 
+          class FunctionRequiredError < StandardError
+          end
+
           class SchemaRequiredError < StandardError
           end
 
@@ -19,6 +22,12 @@ module DynamicMigrations
             @database = database
           end
 
+          # returns a hash of migrations for each schema which will bring the configured
+          # loaded database structure into alignment with the configured database structure
+          def to_migrations
+            ToMigrations.new(@database, self).migrations
+          end
+
           # return a hash representing any differenced betweek the loaded and configured
           # versions of the current database
           def to_h
@@ -53,9 +62,11 @@ module DynamicMigrations
             raise SchemaRequiredError if schema.nil?
 
             comparison_tables = comparison_schema.nil? ? {} : comparison_schema.tables_hash
+            comparison_functions = comparison_schema.nil? ? {} : comparison_schema.functions_hash
             {
               exists: true,
-              tables: compare_tables(schema.tables_hash, comparison_tables)
+              tables: compare_tables(schema.tables_hash, comparison_tables),
+              functions: compare_functions(schema.functions_hash, comparison_functions)
             }
           end
 
@@ -90,12 +101,16 @@ module DynamicMigrations
             if comparison_table
               comparison_primary_key = comparison_table.has_primary_key? ? comparison_table.primary_key : nil
               comparison_columns = comparison_table.columns_hash
+              comparison_indexes = comparison_table.indexes_hash
+              comparison_triggers = comparison_table.triggers_hash
               comparison_validations = comparison_table.validations_hash
               comparison_foreign_key_constraints = comparison_table.foreign_key_constraints_hash
               comparison_unique_constraints = comparison_table.unique_constraints_hash
             else
               comparison_primary_key = {}
               comparison_columns = {}
+              comparison_indexes = {}
+              comparison_triggers = {}
               comparison_validations = {}
               comparison_foreign_key_constraints = {}
               comparison_unique_constraints = {}
@@ -108,15 +123,41 @@ module DynamicMigrations
               },
               primary_key: compare_record(primary_key, comparison_primary_key, [
                 :name,
-                :index_type
+                :column_names,
+                :description
               ]),
               columns: compare_columns(table.columns_hash, comparison_columns),
+              indexes: compare_indexes(table.indexes_hash, comparison_indexes),
+              triggers: compare_triggers(table.triggers_hash, comparison_triggers),
               validations: compare_validations(table.validations_hash, comparison_validations),
               foreign_key_constraints: compare_foreign_key_constraints(table.foreign_key_constraints_hash, comparison_foreign_key_constraints),
               unique_constraints: compare_unique_constraints(table.unique_constraints_hash, comparison_unique_constraints)
             }
           end
 
+          # compare two hash representations of a set of functions and return
+          # an object which represents the provided `functions` and any differences
+          # between it and the `comparison_functions`
+          def self.compare_functions functions, comparison_functions
+            result = {}
+            # the base functions
+            functions.each do |function_name, function|
+              result[function_name] = compare_record function, comparison_functions[function_name], [
+                :definition,
+                :description
+              ]
+            end
+            # look for any in the comparison list which were not in the base list
+            comparison_functions.each do |function_name, function|
+              unless result.key? function_name
+                result[function_name] = {
+                  exists: false
+                }
+              end
+            end
+            result
+          end
+
           # compare two hash representations of a set of columns and return
           # an object which represents the provided `columns` and any differences
           # between it and the `comparison_columns`
@@ -144,6 +185,37 @@ module DynamicMigrations
             result
           end
 
+          # compare two hash representations of a set of triggers and return
+          # an object which represents the provided `triggers` and any differences
+          # between it and the `comparison_triggers`
+          def self.compare_triggers triggers, comparison_triggers
+            result = {}
+            # the base triggers
+            triggers.each do |trigger_name, trigger|
+              # compare this trigger to the equivilent in the comparison list
+              result[trigger_name] = compare_record trigger, comparison_triggers[trigger_name], [
+                :action_timing,
+                :event_manipulation,
+                :action_order,
+                :action_condition,
+                :action_statement,
+                :action_orientation,
+                :action_reference_old_table,
+                :action_reference_new_table,
+                :description
+              ]
+            end
+            # look for any triggers in the comparison list which were not in the base list
+            comparison_triggers.each do |trigger_name, trigger|
+              unless result.key? trigger_name
+                result[trigger_name] = {
+                  exists: false
+                }
+              end
+            end
+            result
+          end
+
           # compare two hash representations of a set of unique_constraints and return
           # an object which represents the provided `unique_constraints` and any differences
           # between it and the `comparison_unique_constraints`
@@ -154,7 +226,7 @@ module DynamicMigrations
               # compare this unique_constraint to the equivilent in the comparison list
               result[name] = compare_record unique_constraint, comparison_unique_constraints[name], [
                 :column_names,
-                :index_type,
+                :description,
                 :deferrable,
                 :initially_deferred
               ]
@@ -180,11 +252,10 @@ module DynamicMigrations
               # compare this index to the equivilent in the comparison list
               result[name] = compare_record index, comparison_indexes[name], [
                 :column_names,
+                :description,
                 :unique,
                 :where,
                 :type,
-                :deferrable,
-                :initially_deferred,
                 :order,
                 :nulls_position
               ]
@@ -211,6 +282,7 @@ module DynamicMigrations
               result[name] = compare_record validation, comparison_validations[name], [
                 :check_clause,
                 :column_names,
+                :description,
                 :deferrable,
                 :initially_deferred
               ]
@@ -239,8 +311,11 @@ module DynamicMigrations
                 :foreign_schema_name,
                 :foreign_table_name,
                 :foreign_column_names,
+                :description,
                 :deferrable,
-                :initially_deferred
+                :initially_deferred,
+                :on_delete,
+                :on_update
               ]
             end
             # look for any foreign_key_constraints in the comparison list which were not in the base list