mimi-db 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6c134a70d22d57cb28bc7eef7dd2dea944f743c
-  data.tar.gz: 9f7088a8658380872586ef77d273d4b9db8a4f22
+  metadata.gz: 7d8e5f05648963455f22f4495aeed73bbab8edd4
+  data.tar.gz: b519848493d926249f1be91a586e80aaceff153e
 SHA512:
-  metadata.gz: 64fb09362a80c2b1d60f671d4672862a4a70753024509c5a08091dfc5c8c846ba5df476190918f15d5e0968dae0abc4e3282a4dc18d2303cc7acaf0f8f2caa98
-  data.tar.gz: 6f6a42c8af65974cc9ddf7fcd4785e10cf0c1c2b16efc9320bda145ad3048b459304e41a82c3acad5ad38aec9ca76542363239de7f138740ff0e0de67c54dc25
+  metadata.gz: 0f61958bb7e08cbf6d2ed28e8ed566a983f38365894257eb84b5ed579da21b248cfbd6898a964d267b22e1d22a6b806c6c0add014afa245a143c997a0a784fbf
+  data.tar.gz: 5256b301a6bd6891cf3cf47698ae34608b9b68858b7d39c1854da2bfc041779b2dfacd101c6b7306b569d91e95c28298beae2aadbec97c3f3ba872a273783ff0

data/lib/mimi/db/dictate/migrator.rb

@@ -83,24 +83,28 @@ module Mimi
 
         def run_change_table!
           diff = Mimi::DB::Dictate::SchemaDiff.diff(from_schema, to_schema)
-          if diff.empty?
+          if diff[:columns].empty? && diff[:indexes].empty?
             logger.info "- no changes: #{table_name}"
             return
           end
           logger.info "- ALTER TABLE: #{table_name}"
-          run_change_table_columns!(diff[:columns]) if diff[:columns]
-          run_change_table_indexes!(diff[:indexes]) if diff[:indexes]
+          run_change_table_columns!(diff[:columns]) unless diff[:columns].empty?
+          run_change_table_indexes!(diff[:indexes]) unless diff[:indexes].empty?
         end
 
         def run_change_table_columns!(diff_columns)
-          diff_columns[:remove]&.each { |c| drop_column!(table_name, c) }
-          diff_columns[:change]&.each { |c| change_column!(table_name, c) }
-          diff_columns[:add]&.each    { |c| add_column!(table_name, c) }
+          diff_columns.each do |c, diff|
+            drop_column!(table_name, c) if diff[:from] && diff[:to].nil?
+            change_column!(table_name, diff[:to]) if diff[:from] && diff[:to]
+            add_column!(table_name, diff[:to]) if diff[:from].nil? && diff[:to]
+          end
         end
 
         def run_change_table_indexes!(diff_indexes)
-          diff_indexes[:remove]&.each { |i| drop_index!(table_name, i) }
-          diff_indexes[:add]&.each    { |i| add_index!(table_name, i) }
+          diff_indexes.each do |i, diff|
+            drop_index!(table_name, diff[:from]) if diff[:from] && diff[:to].nil?
+            add_index!(table_name, diff[:to]) if diff[:from].nil? && diff[:to]
+          end
         end
 
         def run_create_table!

data/lib/mimi/db/dictate/schema_diff.rb

@@ -15,58 +15,35 @@ module Mimi
         #
         # Compares two schema definitions
         #
-        # @return [Hash] :columns, :indexes => :add, :remove, :change
+        # @return [Hash] :columns, :indexes => :from, :to
         #
         def self.diff(from, to, opts = {})
           options = DEFAULT_OPTIONS.merge(opts)
-          from_column_names = from.columns.values.map(&:name)
-          to_column_names = to.columns.values.map(&:name)
-          columns_names_remove = from_column_names - to_column_names
-          columns_names_add    = to_column_names - from_column_names
-          columns_add          = to.columns.values.select do |c|
-            columns_names_add.include?(c.name)
+          result = { table_name: from.table_name, columns: {}, indexes: {} }
+          all_column_names = (from.columns.values.map(&:name) + to.columns.values.map(&:name)).uniq
+          all_column_names.each do |c|
+            if from.columns[c] && to.columns[c].nil?
+              result[:columns][c] = { from: from.columns[c], to: nil }
+            elsif from.columns[c] && to.columns[c] && !(from.columns[c] == to.columns[c])
+              result[:columns][c] = { from: from.columns[c], to: to.columns[c] }
+            elsif from.columns[c].nil? && to.columns[c]
+              result[:columns][c] = { from: nil, to: to.columns[c] }
+            end
+          end
+          from_indexes = from.indexes.map { |i| [i.columns, i] }.to_h
+          to_indexes   = to.indexes.map { |i| [i.columns, i] }.to_h
+          all_index_cols = (from_indexes.keys + to_indexes.keys).uniq
+          all_index_cols.each do |cc|
+            if from_indexes[cc] && to_indexes[cc].nil?
+              result[:indexes][cc] = { from: from_indexes[cc], to: nil }
+            elsif from_indexes[cc] && to_indexes[cc]
+              # index diff is not supported
+            elsif from_indexes[cc].nil? && to_indexes[cc]
+              result[:indexes][cc] = { from: nil, to: to_indexes[cc]}
+            end
           end
-          columns_change       = to.columns.values.reject do |c|
-            res = from.columns[c.name].nil? || from.columns[c.name] == c
-            res ||= c.type == :primary_key unless options[:force_primary_key]
-          end
-          from_indexes_c = from.indexes.map(&:columns).uniq
-          to_indexes_c = to.indexes.map(&:columns).uniq
-          # ignore primary key indexes
-          from_indexes_c -= [[from.primary_key&.name]]
-          to_indexes_c -= [[to.primary_key&.name]]
 
-          indexes_c_remove = from_indexes_c - to_indexes_c
-          indexes_c_add = to_indexes_c - from_indexes_c
-          indexes_remove = from.indexes.select do |idx|
-            indexes_c_remove.include?(idx.columns)
-          end
-          indexes_add    = to.indexes.select do |idx|
-            indexes_c_add.include?(idx.columns)
-          end
-
-          diff = {}
-          unless columns_names_remove.empty?
-            diff[:columns] ||= {}
-            diff[:columns][:remove] = columns_names_remove
-          end
-          unless columns_change.empty?
-            diff[:columns] ||= {}
-            diff[:columns][:change] = columns_change
-          end
-          unless columns_add.empty?
-            diff[:columns] ||= {}
-            diff[:columns][:add] = columns_add
-          end
-          unless indexes_remove.empty?
-            diff[:indexes] ||= {}
-            diff[:indexes][:remove] = indexes_remove
-          end
-          unless indexes_add.empty?
-            diff[:indexes] ||= {}
-            diff[:indexes][:add] = indexes_add
-          end
-          diff
+          result
         end
       end # module SchemaDiff
     end # module Dictate

data/lib/mimi/db/dictate.rb

@@ -85,6 +85,31 @@ module Mimi
         logger.error "DB::Dictate failed to update DB schema: #{e}"
         raise
       end
+
+      # Diff existing DB schema and the target schema
+      #
+      # @param opts [Hash]
+      # @return [Hash]
+      #
+      def self.diff_schema!(opts = {})
+        logger = opts[:logger] || ActiveRecord::Base.logger
+        diff = { add_tables: [], change_tables: [], drop_tables: []}
+        Mimi::DB.all_table_names.each do |t|
+          m = Mimi::DB::Dictate::Migrator.new(t, opts)
+          if m.from_schema && m.to_schema.nil?
+            diff[:drop_tables] << t
+          elsif m.from_schema && m.to_schema
+            t_diff = Mimi::DB::Dictate::SchemaDiff.diff(m.from_schema, m.to_schema)
+            diff[:change_tables] << t_diff unless t_diff[:columns].empty? && t_diff[:indexes].empty?
+          elsif m.from_schema.nil? &&  m.to_schema
+            diff[:add_tables] << m.to_schema
+          end
+        end
+        diff
+      rescue StandardError => e
+        logger.error "DB::Dictate failed to update DB schema: #{e}"
+        raise
+      end
     end # module Dictate
   end # module DB
 end # module Mimi

data/lib/mimi/db/helpers.rb

@@ -60,6 +60,34 @@ module Mimi
         Mimi::DB::Dictate.update_schema!(opts)
       end
 
+      # Discovers differences between existing DB schema and target schema
+      # defined in models.
+      #
+      # @example
+      #   Mimi::DB.diff_schema
+      #
+      #   # =>
+      #   # {
+      #   #   add_tables: [<table_schema1>, <table_schema2> ...],
+      #   #   change_tables: [
+      #   #     { table_name: ...,
+      #   #       columns: {
+      #   #         "<column_name1>" => {
+      #   #           from: { <column_definition or nil> },
+      #   #           to: { <column_definition or nil> }
+      #   #         }
+      #   #       }
+      #   #     }, ...
+      #   #   ],
+      #   #   drop_tables: [<table_name1>, ...]
+      #   # }
+      # @return [Hash]
+      #
+      def diff_schema!(opts = {})
+        opts[:logger] ||= Mimi::DB.logger
+        Mimi::DB::Dictate.diff_schema(opts)
+      end
+
       # Creates the database specified in the current configuration.
       #
       def create!

data/lib/mimi/db/version.rb

@@ -1,5 +1,5 @@
 module Mimi
   module DB
-    VERSION = '0.2.3'.freeze
+    VERSION = '0.2.4'.freeze
   end
 end

data/lib/tasks/db.rake

@@ -59,6 +59,14 @@ namespace :db do
         logger.info "* Updating database schema (DRY RUN): #{Mimi::DB.module_options[:db_database]}"
         Mimi::DB.update_schema!(destructive: true, dry_run: true)
       end
+
+      desc 'Display differences between existing DB schema and target schema'
+      task diff: :"db:start" do
+        logger.info "* Diff database schema: #{Mimi::DB.module_options[:db_database]}"
+        diff = Mimi::DB.diff_schema(destructive: true, dry_run: true)
+        require 'pp'
+        pp diff
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mimi-db
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Alex Kukushkin