dynamic_migrations 2.2.0 → 3.1.0

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

@@ -10,11 +10,12 @@ module DynamicMigrations
               CREATE MATERIALIZED VIEW public.dynamic_migrations_keys_and_unique_constraints_cache as
                 SELECT
                   c.conname AS constraint_name,
+                  pg_get_constraintdef(c.oid, true) as constraint_definition,
                   CASE c.contype
-                    WHEN 'f'::"char" THEN 'FOREIGN_KEY'::text
-                    WHEN 'p'::"char" THEN 'PRIMARY_KEY'::text
-                    WHEN 'u'::"char" THEN 'UNIQUE'::text
-                  END::information_schema.character_data AS constraint_type,
+                    WHEN 'f'::"char" THEN 'foreign_key'::text
+                    WHEN 'p'::"char" THEN 'primary_key'::text
+                    WHEN 'u'::"char" THEN 'unique'::text
+                  END AS constraint_type,
                   sch.nspname AS schema_name,
                   tbl.relname AS table_name,
                   ARRAY_AGG(col.attname ORDER BY u.attposition) AS column_names,
@@ -24,7 +25,23 @@ module DynamicMigrations
                   NULLIF(ARRAY_AGG(f_col.attname ORDER BY f_u.attposition), ARRAY[null]::name[]) AS foreign_column_names,
                   c.condeferrable as deferrable,
                   c.condeferred as initially_deferred,
+                  CASE c.confupdtype
+                    WHEN 'a'::"char" THEN 'no_action'::text
+                    WHEN 'r'::"char" THEN 'restrict'::text
+                    WHEN 'c'::"char" THEN 'cascade'::text
+                    WHEN 'n'::"char" THEN 'set_null'::text
+                    WHEN 'd'::"char" THEN 'set_default'::text
+                  END AS on_update,
+                  CASE c.confdeltype
+                    WHEN 'a'::"char" THEN 'no_action'::text
+                    WHEN 'r'::"char" THEN 'restrict'::text
+                    WHEN 'c'::"char" THEN 'cascade'::text
+                    WHEN 'n'::"char" THEN 'set_null'::text
+                    WHEN 'd'::"char" THEN 'set_default'::text
+                  END AS on_delete,
                   am.amname as index_type,
+                  obj_description(c.oid, 'pg_constraint') as description,
+                  -- in case we need to update this query in a later version of DynamicMigrations
                   1 as table_version
                 FROM pg_constraint c
                 LEFT JOIN LATERAL UNNEST(c.conkey)
@@ -68,10 +85,10 @@ module DynamicMigrations
                 LEFT JOIN pg_am am ON am.oid=index_cls.relam
 
                 WHERE
-                -- only FOREIGN_KEY, UNIQUE or PRIMARY_KEY
+                -- only foreign_key, unique or primary_key
                 c.contype in ('f', 'u', 'p')
 
-              GROUP BY constraint_name, constraint_type, condeferrable, condeferred, schema_name, table_name, foreign_schema_name, foreign_table_name, am.amname
+              GROUP BY c.oid, constraint_name, constraint_type, condeferrable, condeferred, schema_name, table_name, foreign_schema_name, foreign_table_name, am.amname
               ORDER BY schema_name, table_name;
             SQL
             connection.exec(<<~SQL)
@@ -86,12 +103,12 @@ module DynamicMigrations
           # useful hash representing the keys and indexes of your database
           def fetch_keys_and_unique_constraints
             begin
-              rows = connection.exec_params(<<~SQL)
+              rows = connection.exec(<<~SQL)
                 SELECT * FROM public.dynamic_migrations_keys_and_unique_constraints_cache
               SQL
             rescue PG::UndefinedTable
               create_database_keys_and_unique_constraints_cache
-              rows = connection.exec_params(<<~SQL)
+              rows = connection.exec(<<~SQL)
                 SELECT * FROM public.dynamic_migrations_keys_and_unique_constraints_cache
               SQL
             end
@@ -111,14 +128,20 @@ module DynamicMigrations
 
               column_names = row["column_names"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
 
-              if constraint_type == :FOREIGN_KEY
+              description = (row["description"] == "") ? nil : row["description"]
+
+              if constraint_type == :foreign_key
                 foreign_schema_name = row["foreign_schema_name"].to_sym
                 foreign_table_name = row["foreign_table_name"].to_sym
                 foreign_column_names = row["foreign_column_names"].gsub(/\A\{/, "").gsub(/\}\Z/, "").split(",").map { |column_name| column_name.to_sym }
+                on_update = row["on_update"].to_sym
+                on_delete = row["on_delete"].to_sym
               else
                 foreign_schema_name = nil
                 foreign_table_name = nil
                 foreign_column_names = nil
+                on_update = nil
+                on_delete = nil
               end
 
               deferrable = row["deferrable"] == "TRUE"
@@ -137,6 +160,9 @@ module DynamicMigrations
                 foreign_column_names: foreign_column_names,
                 deferrable: deferrable,
                 initially_deferred: initially_deferred,
+                on_update: on_update,
+                on_delete: on_delete,
+                description: description,
                 index_type: index_type
               }
             end

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

@@ -8,6 +8,9 @@ module DynamicMigrations
           class UnexpectedConstrintTypeError < StandardError
           end
 
+          class UnexpectedTriggerSchema < StandardError
+          end
+
           # recursively process the database and build all the schemas,
           # tables and columns
           def recursively_build_schemas_from_database
@@ -17,7 +20,7 @@ module DynamicMigrations
               schema_validations = validations[schema_name]
 
               schema_definition[:tables].each do |table_name, table_definition|
-                table = schema.add_table table_name, table_definition[:description]
+                table = schema.add_table table_name, description: table_definition[:description]
                 table_validations = schema_validations && schema_validations[table_name]
 
                 # add each table column
@@ -31,7 +34,7 @@ module DynamicMigrations
 
                 # add any validations
                 table_validations&.each do |validation_name, validation_definition|
-                  table.add_validation validation_name, validation_definition[:columns], validation_definition[:check_clause]
+                  table.add_validation validation_name, validation_definition[:columns], validation_definition[:check_clause], description: validation_definition[:description], deferrable: validation_definition[:deferrable], initially_deferred: validation_definition[:initially_deferred]
                 end
               end
             end
@@ -45,14 +48,14 @@ module DynamicMigrations
                 keys_and_unique_constraints.each do |constraint_type, constraint_definitions|
                   constraint_definitions.each do |constraint_name, constraint_definition|
                     case constraint_type
-                    when :PRIMARY_KEY
-                      table.add_primary_key constraint_name, constraint_definition[:column_names], index_type: constraint_definition[:index_type]
+                    when :primary_key
+                      table.add_primary_key constraint_name, constraint_definition[:column_names], description: constraint_definition[:description]
 
-                    when :FOREIGN_KEY
-                      table.add_foreign_key_constraint constraint_name, constraint_definition[:column_names], constraint_definition[:foreign_schema_name], constraint_definition[:foreign_table_name], constraint_definition[:foreign_column_names], deferrable: constraint_definition[:deferrable], initially_deferred: constraint_definition[:initially_deferred]
+                    when :foreign_key
+                      table.add_foreign_key_constraint constraint_name, constraint_definition[:column_names], constraint_definition[:foreign_schema_name], constraint_definition[:foreign_table_name], constraint_definition[:foreign_column_names], description: constraint_definition[:description], deferrable: constraint_definition[:deferrable], initially_deferred: constraint_definition[:initially_deferred], on_delete: constraint_definition[:on_delete], on_update: constraint_definition[:on_update]
 
-                    when :UNIQUE
-                      table.add_unique_constraint constraint_name, constraint_definition[:column_names], deferrable: constraint_definition[:deferrable], initially_deferred: constraint_definition[:initially_deferred], index_type: constraint_definition[:index_type]
+                    when :unique
+                      table.add_unique_constraint constraint_name, constraint_definition[:column_names], description: constraint_definition[:description], deferrable: constraint_definition[:deferrable], initially_deferred: constraint_definition[:initially_deferred]
 
                     else
                       raise UnexpectedConstrintTypeError, constraint_type
@@ -61,6 +64,44 @@ module DynamicMigrations
                 end
               end
             end
+
+            # add all functions and triggers (functions first, because the triggers are dependent on them)
+            fetch_triggers_and_functions.each do |schema_name, schema_definition|
+              schema_definition.each do |table_name, triggers|
+                # the table that this trigger works on
+                table = loaded_schema(schema_name).table(table_name)
+                # all the triggers for this table
+                triggers.each do |trigger_name, trigger_definition|
+                  # the trigger and function can be in different schemas
+                  function_schema = loaded_schema(trigger_definition[:function_schema])
+                  trigger_schema = loaded_schema(trigger_definition[:trigger_schema])
+
+                  if trigger_schema != table.schema
+                    raise UnexpectedTriggerSchema, "Trigger schema `#{trigger_schema.name}` does not match table schema `#{table.schema.name}`"
+                  end
+
+                  # if this function does not exist locally, then add it
+                  unless function_schema.has_function?(trigger_definition[:function_name])
+                    function_schema.add_function trigger_definition[:function_name], trigger_definition[:function_definition], description: trigger_definition[:function_description]
+                  end
+
+                  # get the function
+                  function = function_schema.function(trigger_definition[:function_name])
+
+                  # create the trigger
+                  table.add_trigger trigger_name, action_timing: trigger_definition[:action_timing],
+                    event_manipulation: trigger_definition[:event_manipulation],
+                    action_order: trigger_definition[:action_order],
+                    action_statement: trigger_definition[:action_statement],
+                    action_orientation: trigger_definition[:action_orientation],
+                    function: function,
+                    action_condition: trigger_definition[:action_condition],
+                    action_reference_old_table: trigger_definition[:action_reference_old_table],
+                    action_reference_new_table: trigger_definition[:action_reference_new_table],
+                    description: trigger_definition[:description]
+                end
+              end
+            end
           end
         end
       end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          # This class represents a postgres function.
+          class Function < Source
+            class ExpectedSchemaError < StandardError
+            end
+
+            class ExpectedDefinitionError < StandardError
+            end
+
+            attr_reader :schema
+            attr_reader :name
+            attr_reader :definition
+            attr_reader :description
+            attr_reader :triggers
+
+            # initialize a new object to represent a postgres function
+            def initialize source, schema, name, definition, description: nil
+              super source
+
+              @triggers ||= []
+
+              raise ExpectedSchemaError, schema unless schema.is_a? Schema
+              @schema = schema
+
+              raise ExpectedSymbolError, name unless name.is_a? Symbol
+              @name = name
+
+              unless definition.is_a?(String) && definition.strip != ""
+                raise ExpectedDefinitionError, definition
+              end
+              @definition = definition
+
+              unless description.nil?
+                raise ExpectedStringError, description unless description.is_a? String
+                @description = description
+              end
+            end
+
+            # returns true if this function has a description, otehrwise false
+            def has_description?
+              !@description.nil?
+            end
+
+            # returns all the triggers which are associated with this function
+            def add_trigger trigger
+              # this should never happen, but adding it just in case
+              unless trigger.source == source
+                raise "Internal error - trigger source `#{trigger.source}` does not match function source `#{source}`"
+              end
+              @triggers << trigger
+            end
+
+            def differences_descriptions other_function
+              method_differences_descriptions other_function, [
+                :definition
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema < Source
+          module Functions
+            class FunctionAlreadyExistsError < StandardError
+            end
+
+            class FunctionDoesNotExistError < StandardError
+            end
+
+            # create and add a new function from a provided function name
+            def add_function function_name, definition, description: nil
+              raise ExpectedSymbolError, function_name unless function_name.is_a? Symbol
+              if has_function? function_name
+                raise(FunctionAlreadyExistsError, "Function #{function_name} already exists")
+              end
+              included_target = self
+              if included_target.is_a? Schema
+                new_function = @functions[function_name] = Function.new source, included_target, function_name, definition, description: description
+              else
+                raise ModuleIncludedIntoUnexpectedTargetError, included_target
+              end
+              # sort the hash so that the functions are in alphabetical order by name
+              sorted_functions = {}
+              @functions.keys.sort.each do |function_name|
+                sorted_functions[function_name] = @functions[function_name]
+              end
+              @functions = sorted_functions
+              # return the new function
+              new_function
+            end
+
+            # return a function by its name, raises an error if the function does not exist
+            def function function_name
+              raise ExpectedSymbolError, function_name unless function_name.is_a? Symbol
+              raise FunctionDoesNotExistError unless has_function? function_name
+              @functions[function_name]
+            end
+
+            # returns true/false representing if a function with the provided name exists
+            def has_function? function_name
+              raise ExpectedSymbolError, function_name unless function_name.is_a? Symbol
+              @functions.key? function_name
+            end
+
+            # returns an array of all functions in the schema
+            def functions
+              @functions.values
+            end
+
+            def functions_hash
+              @functions
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,6 +44,10 @@ module DynamicMigrations
               def has_description?
                 !@description.nil?
               end
+
+              def array?
+                @data_type.end_with? "[]"
+              end
             end
           end
         end

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

@@ -18,7 +18,7 @@ module DynamicMigrations
               # error if the column does not exist
               def column name
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
-                raise ColumnDoesNotExistError unless has_column? name
+                raise ColumnDoesNotExistError, name unless has_column? name
                 @columns[name]
               end
 

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

@@ -20,14 +20,20 @@ module DynamicMigrations
               class DuplicateColumnError < StandardError
               end
 
+              class UnexpectedReferentialActionError < StandardError
+              end
+
               attr_reader :table
               attr_reader :foreign_table
               attr_reader :name
               attr_reader :deferrable
               attr_reader :initially_deferred
+              attr_reader :on_delete
+              attr_reader :on_update
+              attr_reader :description
 
               # initialize a new object to represent a foreign_key_constraint in a postgres table
-              def initialize source, table, columns, foreign_table, foreign_columns, name, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, foreign_table, foreign_columns, name, description: nil, deferrable: false, initially_deferred: false, on_delete: :no_action, on_update: :no_action
                 super source
 
                 raise ExpectedTableError, table unless table.is_a? Table
@@ -64,11 +70,27 @@ module DynamicMigrations
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
+
                 raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
                 @deferrable = deferrable
 
                 raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
                 @initially_deferred = initially_deferred
+
+                raise UnexpectedReferentialActionError, on_delete unless [:no_action, :restrict, :cascade, :set_null, :set_default].include?(on_delete)
+                @on_delete = on_delete
+
+                raise UnexpectedReferentialActionError, on_update unless [:no_action, :restrict, :cascade, :set_null, :set_default].include?(on_update)
+                @on_update = on_update
+              end
+
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
               end
 
               def columns
@@ -83,10 +105,6 @@ module DynamicMigrations
                 @foreign_columns.values
               end
 
-              def foreign_column_names
-                @foreign_columns.keys
-              end
-
               def foreign_schema_name
                 @foreign_table.schema.name
               end
@@ -95,6 +113,23 @@ module DynamicMigrations
                 @foreign_table.name
               end
 
+              def foreign_column_names
+                @foreign_columns.keys
+              end
+
+              def differences_descriptions other_foreign_key_constraint
+                method_differences_descriptions other_foreign_key_constraint, [
+                  :column_names,
+                  :foreign_schema_name,
+                  :foreign_table_name,
+                  :foreign_column_names,
+                  :deferrable,
+                  :initially_deferred,
+                  :on_delete,
+                  :on_update
+                ]
+              end
+
               private
 
               # used internally to set the columns from this objects initialize method

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

@@ -35,13 +35,12 @@ module DynamicMigrations
               attr_reader :unique
               attr_reader :where
               attr_reader :type
-              attr_reader :deferrable
-              attr_reader :initially_deferred
               attr_reader :order
               attr_reader :nulls_position
+              attr_reader :description
 
               # initialize a new object to represent a index in a postgres table
-              def initialize source, table, columns, name, unique: false, where: nil, type: :btree, deferrable: false, initially_deferred: false, include_columns: [], order: :asc, nulls_position: :last
+              def initialize source, table, columns, name, description: nil, unique: false, where: nil, type: :btree, include_columns: [], order: :asc, nulls_position: :last
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -60,6 +59,11 @@ module DynamicMigrations
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
+
                 raise ExpectedBooleanError, unique unless [true, false].include?(unique)
                 @unique = unique
 
@@ -71,12 +75,6 @@ module DynamicMigrations
                 raise UnexpectedIndexTypeError, type unless INDEX_TYPES.include?(type)
                 @type = type
 
-                raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
-                @deferrable = deferrable
-
-                raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
-                @initially_deferred = initially_deferred
-
                 # assert that the include_columns is an array (it's optional, so can be an empty array)
                 unless include_columns.is_a?(Array)
                   raise ExpectedArrayOfColumnsError
@@ -93,6 +91,11 @@ module DynamicMigrations
                 @nulls_position = nulls_position
               end
 
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
+              end
+
               # return an array of this indexes columns
               def columns
                 @columns.values
@@ -111,6 +114,17 @@ module DynamicMigrations
                 @include_columns.keys
               end
 
+              def differences_descriptions other_index
+                method_differences_descriptions other_index, [
+                  :column_names,
+                  :unique,
+                  :where,
+                  :type,
+                  :order,
+                  :nulls_position
+                ]
+              end
+
               private
 
               # used internally to set the columns from this objects initialize method

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

@@ -8,8 +8,6 @@ module DynamicMigrations
           class Table
             # This class represents a postgres table primary_key
             class PrimaryKey < Source
-              INDEX_TYPES = [:btree, :gin]
-
               class ExpectedTableError < StandardError
               end
 
@@ -24,10 +22,10 @@ module DynamicMigrations
 
               attr_reader :table
               attr_reader :name
-              attr_reader :index_type
+              attr_reader :description
 
               # initialize a new object to represent a primary_key in a postgres table
-              def initialize source, table, columns, name, index_type: :btree
+              def initialize source, table, columns, name, description: nil
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -45,8 +43,15 @@ module DynamicMigrations
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
-                raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
-                @index_type = index_type
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
+              end
+
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
               end
 
               # return an array of this primary keys columns
@@ -54,6 +59,16 @@ module DynamicMigrations
                 @columns.values
               end
 
+              def column_names
+                @columns.keys
+              end
+
+              def differences_descriptions other_primary_key
+                method_differences_descriptions other_primary_key, [
+                  :column_names
+                ]
+              end
+
               private
 
               # used internally to set the columns from this objects initialize method