foreign_key_checker 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61d367175ce6fba75c746ebc5425f463c20d903e31885edd04e407a100dbe72e
-  data.tar.gz: 1a6cb3b2f4d0123e884f432a7d6a4c48acf2d9e16a7fb3439ddfd4f06df198db
+  metadata.gz: 14d08201b2ec53461b6eeb2da97e21b0713c8dc1f62ebeb8f15644caa1ef7484
+  data.tar.gz: 78454098ee4372ca7c6076bb312f5e9ebdb90074f81c88871e2903898d6e1e27
 SHA512:
-  metadata.gz: 0437adb8468a7018a11e77d5e77fec0cd7fcd0b5cf37ccfb8d31a2da35da3ebd4a706a5d373ebb8f50ae91e3e698c73b1cd5cd4e28049b520156e90d9e65b619
-  data.tar.gz: 91f2dda0e5a8036cdc330a673a8d2aaba235435f870b02c99ea828140fca646456d555d979447fc78c3f9174c53ad23ff2c295084588c2f54ac211f606f684ac
+  metadata.gz: 1afaaeb393ab9ea52ca22ce080074298d13164b5f730e1fb34ff643b5c736351b433c60faed578ae46f26319361d95c9d603de9b4f862142fb9895b2b16f4515
+  data.tar.gz: f20849ecc864ff36304cf0b54baad81df7b805cca8a7a101e1eb5865eb71ab7951265950a1ec3c562f5b6716950b7f3272856fe000ee346b657a724a90e46c24

data/README.md

@@ -23,6 +23,12 @@ ForeignKeyChecker.check.each do |key, result|
 end
 ```
 
+Get general information about foreign keys
+```ruby
+ForeignKeyChecker::Utils.get_foreign_keys_hash
+# =>  {"users"=>[#<ForeignKeyChecker::Utils::Result:0x00005645e51756e8 @from_table="user_rating_changes", @from_column="user_id", @to_table="users", @to_column="id">]}
+```
+
 ## Installation
 Add this line to your application's Gemfile:
 

data/lib/foreign_key_checker.rb

@@ -1,4 +1,10 @@
 require "foreign_key_checker/railtie"
+require 'foreign_key_checker/utils'
+module ForeignKeyChecker::Checkers
+end
+require 'foreign_key_checker/checkers/relations'
+require 'foreign_key_checker/checkers/tables'
+require 'foreign_key_checker/utils/belongs_to'
 
 module ForeignKeyChecker
   class TypeMismatch < StandardError; end
@@ -79,7 +85,7 @@ module ForeignKeyChecker
       to_t = model.connection.quote_table_name(to_table)
       to_c = model.connection.quote_column_name(to_column)
       #"DELETE #{from_t} FROM #{from_t}.#{from_c} LEFT OUTER JOIN #{to_t} ON #{to_t}.#{to_c} = #{from_t}.#{from_c} WHERE #{to_t}.#{to_c} IS NULL"
-      "DELETE FROM #{from_t} WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT #{to_c} FROM #{to_t})"
+      "DELETE FROM #{from_t} WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT * FROM (SELECT #{to_c} FROM #{to_t}) AS t )"
     end
 
     def set_null_sql
@@ -88,7 +94,7 @@ module ForeignKeyChecker
       to_t = model.connection.quote_table_name(to_table)
       to_c = model.connection.quote_column_name(to_column)
       #"UPDATE #{from_t} SET #{from_t}.#{from_c} = NULL FROM #{from_t} LEFT OUTER JOIN #{to_t} ON #{to_t}.#{to_c} = #{from_t}.#{from_c} WHERE #{to_t}.#{to_c} IS NULL"
-      "UPDATE #{from_t} SET #{from_c} = NULL WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT #{to_c} FROM #{to_t})"
+      "UPDATE #{from_t} SET #{from_c} = NULL WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT * FROM (SELECT #{to_c} FROM #{to_t}) AS t )"
     end
 
     def set_null_migration
@@ -161,12 +167,21 @@ module ForeignKeyChecker
     def check_types(model, association)
       type_from = model.columns_hash[association.foreign_key.to_s].sql_type
       type_to = association.klass.columns_hash[association.klass.primary_key.to_s].sql_type
-      raise TypeMismatch, "TypeMissMatch #{type_from} != #{type_to}" if type_from != type_to
+      raise TypeMismatch, "TypeMissMatch for relation #{model}##{association.name} #{type_from} != #{type_to}" if type_from != type_to
     end
 
     def check_foreign_key_bt_association(model, association)
       return if model.name.starts_with?('HABTM_')
-      related = association.klass
+      begin
+        related = association.klass
+      rescue NameError => error
+        @result[:broken] << BrokenRelationResult.new(
+          model: model,
+          association: association,
+          error: error,
+        )
+        return
+      end
 
       column_name = model.connection.quote_column_name(association.foreign_key)
       scope = model.left_outer_joins(association.name).where(
@@ -187,7 +202,7 @@ module ForeignKeyChecker
         end
       end
 
-      if foreign_keys && !model.connection.foreign_key_exists?(model.table_name, related.table_name)
+      if foreign_keys && !model.connection.foreign_key_exists?(model.table_name, related.table_name, column: association.foreign_key, primary_key: related.primary_key)
         scope.first
         @result[:foreign_keys] << ForeignKeyResult.new(
           model: model,
@@ -210,6 +225,13 @@ module ForeignKeyChecker
       )
     end
 
+    def already_done_fk?(model, association)
+      @_done ||= {}
+      ret = @_done[[model.table_name, association.foreign_key]]
+      @_done[[model.table_name, association.foreign_key]] = true
+      ret
+    end
+
     def check
       Rails.application.eager_load!
       ActiveRecord::Base.descendants.each do |model|
@@ -217,11 +239,13 @@ module ForeignKeyChecker
         next if excluded_specification?(model)
 
         model.reflect_on_all_associations(:belongs_to).each do |association|
+
           if association.options[:polymorphic] && polymorphic_zombies
             check_polymorphic_bt_association(model, association)
             next
           end
 
+          next if already_done_fk?(model, association)
           check_foreign_key_bt_association(model, association)
         end
       end
@@ -232,5 +256,9 @@ module ForeignKeyChecker
     def check(options = {})
       Checker.new(options).check
     end
+
+    def hm_tree(model, **args)
+      ForeignKeyChecker::Utils::BelongsTo.build_hm_tree(model, **args)
+    end
   end
 end

data/lib/foreign_key_checker/checkers/relations.rb

@@ -0,0 +1,122 @@
+require 'foreign_key_checker/utils'
+
+module ForeignKeyChecker::Checkers::Relations
+  class Result
+    attr_reader :ok, :model, :association, :fk, :error, :table
+    def initialize(**args)
+      %i[model association ok error fk table].each do |key|
+        instance_variable_set("@#{key}", args[key])
+      end
+    end
+  end
+  class JoinResult < Result
+    def message
+      "expect { #{model.to_s}.joins(:#{association.name}).first }.to_not raise_exception" if !ok
+    end
+  end
+  class ErrorResult < Result
+    def message
+      "`#{model.to_s}##{association.name}` is broken\n#{error.class.to_s}\n#{error.message}\n#{error.backtrace.join("\n")}" if !ok
+    end
+  end
+  class HasOneOrManyResult < Result
+    def message
+      "expected has_many or has_one association for #{fk.inspect}"
+    end
+  end
+  class HasOneOrManyDependentResult < Result
+    def message
+      "expected has_many or has_one association with dependent option for #{fk.inspect}"
+    end
+  end
+  class NoModelResult < Result
+    def message
+      "expected find model for table #{table}"
+    end
+  end
+  def self.check_by_join
+    Rails.application.eager_load!
+    models = ActiveRecord::Base.descendants
+    models.each_with_object([]) do |model, results|
+      next if model.to_s.include?('HABTM')
+      model.reflect_on_all_associations.each do |association|
+        begin
+          next if association.options[:polymorphic]
+          next if association.scope && association.scope.is_a?(Proc) && association.scope.arity > 0
+          next if model.connection_specification_name != association.klass.connection_specification_name
+
+          model.joins(association.name).first
+          result = JoinResult.new(model: model, association: association, ok: true)
+          yield result if block_given?
+          results << result
+        rescue => e
+          result = JoinResult.new(model: model, association: association, ok: false, error: e)
+          yield result if block_given?
+          results << result
+        end
+      end
+    end
+  end
+
+  def self.check_by_fks
+    Rails.application.eager_load!
+    models = ActiveRecord::Base.descendants.group_by(&:table_name)
+    check_relation = proc do |model, fk, association|
+      begin
+        pk = association.options[:primary_key] || model.primary_key
+        association.klass.table_name.to_s == fk.from_table.to_s && association.foreign_key.to_s == fk.from_column.to_s && pk.to_s == fk.to_column.to_s
+      rescue => e
+        if block_given?
+          yield ErrorResult.new(model: model, association: association, fk: fk, ok: false, error: e)
+        else
+          p model
+          p fk
+          p association
+          raise e
+        end
+      end
+    end
+    ForeignKeyChecker::Utils.get_foreign_keys_hash.each do |to_table, fks|
+      fks.each do |fk|
+        unless models.key?(fk.to_table)
+          result = NoModelResult.new(ok: false, table: fk.to_table)
+          if block_given?
+            yield result
+          else
+            raise result.message
+          end
+          next
+        end
+        models[fk.to_table].each do |model|
+          next if model.connection_specification_name != 'primary'
+          ok = false
+          ok ||= !!model.reflect_on_all_associations(:has_many).find do |association|
+            check_relation.call(model, fk, association)
+          end
+          ok ||= !!model.reflect_on_all_associations(:has_one).find do |association|
+            check_relation.call(model, fk, association)
+          end
+          if block_given?
+            yield HasOneOrManyResult.new(model: model, fk: fk, ok: ok)
+          else
+            raise "expected has_many or has_one association for #{fk.inspect}" if !ok
+          end
+          next if !ok
+
+          dep = false
+          dep ||= !!model.reflect_on_all_associations(:has_many).find do |association|
+            check_relation.call(model, fk, association) && association.options[:dependent]
+          end
+          dep ||= !!model.reflect_on_all_associations(:has_one).find do |association|
+            check_relation.call(model, fk, association) && association.options[:dependent]
+          end
+          if block_given?
+            yield HasOneOrManyDependentResult.new(model: model, fk: fk, ok: ok)
+          else
+            raise "expected has_many or has_one association with dependent option for #{fk.inspect}" if !dep
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foreign_key_checker/checkers/tables.rb

@@ -0,0 +1,88 @@
+require 'foreign_key_checker/utils'
+
+# Стоит использовать в тех случаях, когда подключается rails к уже существующей базе
+# Можно проверить, для каких таблиц всё ещё нет ActiveRecord-моделей
+module ForeignKeyChecker::Checkers::Tables
+  SPECIAL_TABLES = ['schema_migrations', 'ar_internal_metadata'].freeze
+  # Список таблиц, не описанных моделями (в том числе HABTM-моделями, сгенерированными автоматически rails)
+  def self.without_models(specification_name = 'primary')
+    Rails.application.eager_load!
+
+    actual_tables = ForeignKeyChecker::Utils.get_tables
+    actual_tables - modelised_tables(specification_name) - SPECIAL_TABLES
+  end
+
+  def self.without_foreign_keys(specification_name = 'primary')
+    all_fks = ForeignKeyChecker::Utils.get_foreign_keys
+    results = []
+    models(specification_name).each do |model|
+      model.column_names.each do |column_name|
+        next unless column_name.ends_with?('_id')
+        next if all_fks.find { |fk| fk.from_table = model.table_name && fk.from_column == column_name }
+
+        table_name = column_name.delete_suffix('_id')
+        results << ["#{table_name}.#{column_name}"]
+      end
+    end
+  end
+
+  def self.modelised_tables(specification_name = 'primary')
+    models(specification_name).map(&:table_name)
+  end
+
+  def self.models(specification_name = 'primary')
+    ActiveRecord::Base.descendants.select do |model|
+      model.connection_specification_name == specification_name
+    end
+  end
+
+
+  def self.common_tables
+    ForeignKeyChecker::Utils.get_tables - SPECIAL_TABLES
+  end
+
+  class Result
+    attr_reader :table_name, :foreign_keys, :internal_references
+    def initialize(**args)
+      %i[table_name foreign_keys internal_references].each do |key|
+        instance_variable_set("@#{key}", args[key] || args[key].to_s)
+      end
+    end
+
+    def ok?
+      foreign_keys.blank?
+    end
+
+    def referenced?
+      foreign_keys.present?
+    end
+
+    def ext_ref?
+      !internal_references
+    end
+
+  end
+
+  def self.check
+    tables = without_models
+    fks = ForeignKeyChecker::Utils.get_foreign_keys_hash
+    fks.default = []
+    tables.map do |table|
+      Result.new(
+        table_name: table,
+        foreign_keys: fks[table] || [],
+        internal_references: (fks[table].map(&:from_table) - tables).empty?,
+      )
+    end
+  end
+
+  # TODO вспомнить, что я тут задумал
+  def self.ordered(results = check)
+    return results if results.size == 0
+    oks = results.select(&:ok?)
+    if oks.size == 0
+      raise "no ok"
+    end
+  end
+
+end

data/lib/foreign_key_checker/railtie.rb

@@ -5,6 +5,7 @@ module ForeignKeyChecker
     end
     generators do
       require 'generators/foreign_key_checker/migration/migration_generator.rb'
+      require 'generators/foreign_key_checker/models_generator.rb'
     end
   end
 end

data/lib/foreign_key_checker/utils.rb

@@ -0,0 +1,132 @@
+module ForeignKeyChecker
+  module Utils
+    class Result
+      attr_reader :from_table, :to_table, :from_column, :to_column
+      def initialize(args)
+        args.each { |k, v| instance_variable_set("@#{k}", v) }
+      end
+    end
+    class UnsupportedConnectionAdapter < StandardError; end
+    def self.get_foreign_keys(model = ActiveRecord::Base)
+      adapter = model.connection_db_config.configuration_hash[:adapter]
+      raise(UnsupportedConnectionAdapter, adapter) unless %w[postgresql mysql2 sqlserver sqlite3].include?(adapter)
+
+      connection = model.connection
+      send("get_#{adapter}_foreign_keys", connection)
+    end
+
+    def self.get_foreign_keys_hash(model = ActiveRecord::Base)
+      get_foreign_keys(model).to_a.each_with_object({}) do |datum, obj|
+        obj[datum.to_table] ||= []
+        obj[datum.to_table].push(datum)
+      end
+    end
+
+    def self.get_sqlite3_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          m.name as from_table,
+          p."from" as from_column,
+          p."table" as to_table,
+          p."to" as to_column
+        FROM
+          sqlite_master m
+          JOIN pragma_foreign_key_list(m.name) p ON 1
+        WHERE m.type = 'table'
+        ORDER BY m.name ;
+      SQL
+      res.to_a.map{|i| Result.new(i) }
+    end
+
+    def self.get_mysql2_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          fks.TABLE_NAME AS from_table,
+          fks.COLUMN_NAME AS from_column,
+          fks.REFERENCED_TABLE_NAME AS to_table,
+          fks.REFERENCED_COLUMN_NAME AS to_column
+        FROM information_schema.KEY_COLUMN_USAGE AS fks
+        INNER JOIN information_schema.REFERENTIAL_CONSTRAINTS rules ON rules.CONSTRAINT_NAME = fks.CONSTRAINT_NAME
+        WHERE
+          fks.CONSTRAINT_SCHEMA = DATABASE()
+          AND rules.CONSTRAINT_SCHEMA = DATABASE();
+      SQL
+      res.to_a.map{|i| Result.new(i) }
+    end
+
+    def self.get_postgresql_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          tc.table_name AS from_table,
+          kcu.column_name AS from_column,
+          ccu.table_name AS to_table,
+          ccu.column_name AS to_column
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY';
+      SQL
+      res.to_a.map{ |i| Result.new(i) }
+    end
+
+    def self.get_sqlserver_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT  obj.name AS FK_NAME,
+            sch.name AS [schema_name],
+            tab1.name AS [from_table],
+            col1.name AS [from_column],
+            tab2.name AS [to_table],
+            col2.name AS [to_column]
+        FROM sys.foreign_key_columns fkc
+        INNER JOIN sys.objects obj
+            ON obj.object_id = fkc.constraint_object_id
+        INNER JOIN sys.tables tab1
+            ON tab1.object_id = fkc.parent_object_id
+        INNER JOIN sys.schemas sch
+            ON tab1.schema_id = sch.schema_id
+        INNER JOIN sys.columns col1
+            ON col1.column_id = parent_column_id AND col1.object_id = tab1.object_id
+        INNER JOIN sys.tables tab2
+            ON tab2.object_id = fkc.referenced_object_id
+        INNER JOIN sys.columns col2
+            ON col2.column_id = referenced_column_id AND col2.object_id = tab2.object_id
+      SQL
+      res.to_a.map { |i| Result.new(i) }
+    end
+
+    def self.get_tables(model = ActiveRecord::Base)
+      adapter = model.connection_db_config.configuration_hash[:adapter]
+      raise(UnsupportedConnectionAdapter, adapter) unless %w[postgresql mysql2 sqlite3 sqlserver].include?(adapter)
+
+      connection = model.connection
+      send("get_#{adapter}_tables", connection)
+    end
+
+    def self.get_mysql2_tables(connection)
+      connection.select_all("SELECT table_name FROM information_schema.tables WHERE TABLE_SCHEMA = '#{connection.current_database}'").to_a.pluck('table_name')
+    end
+
+    def self.get_postgresql_tables(connection)
+      connection.select_all("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema'").to_a.pluck('tablename')
+    end
+
+    def self.get_sqlite3_tables(connection)
+      connection.select_all("SELECT name FROM sqlite_master WHERE type='table'").to_a.pluck('name') - ['sqlite_sequence']
+    end
+
+    def self.get_sqlserver_tables(connection)
+      connection.tables
+    end
+
+    def self.get_columns(connection)
+      get_tables.each_with_object({}) do |table, object|
+        object[table] = connection.columns(table)
+      end
+    end
+  end
+end

data/lib/foreign_key_checker/utils/belongs_to.rb

@@ -0,0 +1,594 @@
+module ForeignKeyChecker
+  module Utils
+    module BelongsTo
+      CONST_REGEXP = /\A[A-Z]\p{Alnum}*(::\p{Alnum}+)*\z/
+      class Result
+        attr_reader :primary_table, :dependant_table, :foreign_key, :foreign_type, :types, :polymorphic, :inverse_of, :name, :connection
+        attr_writer :build_class_name
+        def initialize(**args)
+          args.each do |key, value|
+            instance_variable_set("@#{key}", value)
+          end
+        end
+
+        def association_code
+          if inverse_of
+            has_many_code
+          else
+            belongs_to_code
+          end
+        end
+
+        def inversed_association(table)
+          @inversed_associations ||= {}
+          @inversed_associations[table] = build_inversed_association(table)
+          @inversed_associations[table].build_class_name = @build_class_name if @build_class_name
+          @inversed_associations[table]
+        end
+
+        def class_name
+          build_class_name
+        end
+
+        def model
+          return class_name.constantize if class_name.is_a?(String)
+
+          class_name
+        end
+
+        def primary_model
+          kls = build_primary_class_name
+          return kls.constantize if kls.is_a?(String)
+
+          kls
+        end
+
+        def dependant_model
+          kls = build_dependant_class_name
+          return kls.constantize if kls.is_a?(String)
+
+          kls
+        rescue NameError => e
+          puts "#{e.class.to_s} #{e.message} #{e.backtrace.first}"
+          nil
+        end
+
+        def delete_sql(ids)
+          dependent_sql(ids, prefix: 'DELETE FROM')
+        end
+
+        def select_sql_with_fk(ids)
+          dependent_sql(ids, prefix: "SELECT id, #{connection.quote_column_name(foreign_key)} FROM")
+        end
+
+        def select_sql(ids)
+          dependent_sql(ids)
+        end
+
+        def nullify_sql(ids)
+          dependent_sql(ids, prefix: 'UPDATE', suffix: nullify_suffix)
+        end
+
+        def has_many?
+          !belongs_to?
+        end
+
+        def belongs_to?
+          !inverse_of
+        end
+
+        def inspect
+          "#{class_name}.#{association_code}"
+        end
+
+        def conflict_with_fk?(fk)
+          return false if polymorphic
+
+          fk.from_column == foreign_key && fk.from_table == dependant_table && (fk.to_table != primary_table || fk.to_column != 'id')
+        end
+
+        private
+        def dependent_sql(ids, prefix: 'SELECT id FROM', suffix: '')
+          return nil if belongs_to?
+          return nil if ids.empty?
+          return if class_name.is_a?(ActiveRecord::Base) && class_name.primary_key.nil?
+
+          conn = connection
+          if polymorphic
+            [
+              "#{prefix} #{conn.quote_table_name(dependant_table.to_s)} #{suffix} WHERE #{conn.quote_column_name(foreign_key)} IN (#{ids.map(&:to_i).join(',')}) AND #{conn.quote_column_name(foreign_type)} = $1",
+              nil,
+              [class_name.to_s],
+            ]
+          else
+            ["#{prefix} #{conn.quote_table_name(dependant_table.to_s)} #{suffix} WHERE #{conn.quote_column_name(foreign_key)} IN (#{ids.map(&:to_i).join(',')})"]
+          end
+        end
+
+        def nullify_suffix
+          conn = connection
+          if polymorphic
+            "SET #{conn.quote_column_name(foreign_key)} = NULL, #{conn.quote_column_name(foreign_type)} = NULL"
+          else
+            "SET #{conn.quote_column_name(foreign_key)} = NULL"
+          end
+        end
+
+        def build_inversed_association(table)
+          table = table.table_name if table.is_a?(ActiveRecord::Base)
+          if polymorphic
+            self.class.new(primary_table: table, dependant_table: dependant_table, foreign_key: foreign_key, foreign_type: foreign_type, polymorphic: true, inverse_of: self, connection: connection)
+          else
+            self.class.new(primary_table: primary_table, connection: connection, dependant_table: dependant_table, foreign_key: foreign_key, inverse_of: self)
+          end
+        end
+
+        def has_many_code
+          if polymorphic
+            has_many_polymorphic_code
+          else
+            has_many_simple_code
+          end
+        end
+
+        def belongs_to_code
+          if polymorphic
+            "belongs_to :#{belongs_to_relation_name}, polymorphic: true, foreign_key: :#{foreign_key}, foreign_type: :#{foreign_type}"
+          else
+            "belongs_to :#{belongs_to_relation_name}, class_name: '#{build_primary_class_name}', foreign_key: :#{foreign_key}"
+          end
+        end
+
+        def has_many_polymorphic_code
+          "has_many :#{has_many_relation_name}, class_name: '#{build_dependant_class_name}', polymorphic: true, foreign_key: :#{foreign_key}, foreign_type: :#{foreign_type}, dependent: :destroy"
+        end
+
+        def has_many_simple_code
+          "has_many :#{has_many_relation_name}, class_name: '#{build_dependant_class_name}', foreign_key: :#{foreign_key}, dependent: :destroy"
+        end
+
+        def has_many_relation_name
+          dependant_table.tr('.', '_').underscore.pluralize
+        end
+
+        def belongs_to_relation_name
+          foreign_key.delete_suffix('_id')
+          #return polymorphic_belongs_to_relation_name if polymorphic
+          #primary_table.tr('.', '_').underscore.singularize
+        end
+
+        def polymorphic_belongs_to_relation_name
+          @name
+        end
+
+        def build_class_name(arg = _table)
+          @build_class_name.call(arg)
+        end
+
+        def build_primary_class_name
+          build_class_name(primary_table)
+        end
+
+        def build_dependant_class_name
+          build_class_name(dependant_table)
+        end
+
+        def type_to_table(type)
+          @type_to_table.is_a?(Proc) ? @type_to_table.call(type) : type.underscore.pluralize
+        end
+
+        def _table
+          return dependant_table if belongs_to?
+
+          primary_table
+        end
+      end
+      class TableLevel
+        attr_reader :connection, :table, :columns, :columns_of_table, :polymorphic_suffixes, :fks
+        def initialize(connection, table, columns_of_table, polymorphic_suffixes, fks:, on_error: proc { } )
+          @connection = connection
+          @table = table
+          @columns = columns_of_table[table]
+          @columns_of_table = columns_of_table
+          @polymorphic_suffixes = polymorphic_suffixes
+          @on_error = on_error
+          @fks = fks
+        end
+
+        def foreign_key_suffix
+          '_id'
+        end
+
+        def candidates
+          columns.select { |column| column.name.ends_with?(foreign_key_suffix) }.each_with_object([]) do |column, object|
+            level = ColumnLevel.new(self, column)
+            level.errors.each(&@on_error)
+            [level.association].compact.each do |ass|
+              next if fks.find { |fk| ass.conflict_with_fk?(fk) }
+
+              object.push(ass)
+            end
+          end
+        end
+      end
+      class ColumnLevel
+        attr_reader :table_level, :column
+        def initialize(table_level, column)
+          @table_level = table_level
+          @column = column
+          @errors = []
+          @association_name = column.name.delete_suffix(table_level.foreign_key_suffix)
+          @polymorphic_column_names = polymorphic_column_names
+        end
+
+        def association
+          perform if !@done
+          @association
+        end
+
+        def errors
+          perform if !@done
+          @errors
+        end
+
+        def polymorphic?
+          perform if !@done
+          @polymorphic
+        end
+
+        private
+
+        def perform
+          check_polymorphic!
+          check_common!
+          @done = true
+        end
+
+        def check_polymorphic!
+          if @polymorphic_column_names.size > 1
+            @errors.push("Can't determine polymorphic column for association #{@association_name}; candidates: #{@polymorphic_columns.join(', ')}")
+          elsif @polymorphic_column_names.size == 1
+            conn = table_level.connection
+            foreign_type = @polymorphic_column_names.first
+            types = conn.select_all("SELECT DISTINCT #{conn.quote_column_name(foreign_type)} FROM #{conn.quote_table_name(table_level.table)}").rows.map(&:first).compact.select { |tp| tp.match(CONST_REGEXP) }
+            @association = Result.new(polymorphic: true, foreign_key: column.name, foreign_type: foreign_type, types: types, name: @association_name, dependant_table: table_level.table, connection: conn)
+            @polymorphic = true
+          end
+        end
+
+        def check_common!
+          if @polymorphic_column_names.size != 0
+            return
+          end
+          matched_table = table_level.columns_of_table.keys.find do |table1|
+            next false if table1.singularize != @association_name
+            next false if table_level.columns_of_table[table1].find { |col| col.name == 'id' }&.type != column.type
+            true
+          end
+          if matched_table
+            @association = Result.new(polymorphic: false, foreign_key: column.name, primary_table: matched_table, dependant_table: table_level.table, connection: table_level.connection)
+            @polymorphic = false
+          end
+        end
+
+        def polymorphic_column_names
+          table_level.polymorphic_suffixes.map do |polymorphic_suffix|
+            column_candidate_name = "#{@association_name}#{polymorphic_suffix}"
+            next unless table_level.columns.find { |col| col.name == column_candidate_name && col.type == :string }
+
+            column_candidate_name
+          end.compact
+        end
+
+      end
+
+      def self.build_table_mapping(model: ActiveRecord::Base, module_if_gt: 3)
+        Rails.application.eager_load!
+        base_class = model
+        loop do
+          if !base_class.superclass.respond_to?(:connection) || base_class.superclass.connection != base_class.connection
+            break
+          end
+          base_class = base_class.superclass
+        end
+        @table_mappings ||= {}
+        @table_mappings[base_class] ||= begin
+          start_hash = base_class.descendants.reject do |_model|
+            _model.abstract_class || (_model.connection != model.connection)
+          end.group_by(&:table_name).transform_values do |models|
+            next models.first if models.size == 1
+
+            root_models = models.map do |_model|
+              if _model.to_s.demodulize.starts_with?("HABTM_")
+                next
+              end
+              loop do
+                break if !_model.superclass.respond_to?(:abstract_class?) || _model.superclass.table_name.nil?
+
+                _model = _model.superclass
+              end
+              _model
+            end.compact.uniq
+            if root_models.size > 1
+              raise "More than one root model for table #{models.first.table_name}: #{root_models.inspect}"
+            end
+            root_models.first
+          end
+          all_tables = ForeignKeyChecker::Utils.get_tables(model)
+          #group_tables(all_tables)
+          all_tables.each_with_object(start_hash) do |table, object|
+            object[table] ||= table.tr('.', '_').singularize.camelize
+          end
+        end
+      end
+
+      def self.group_tables(tables, level: 1)
+        if tables.size < 2
+          return tables
+        end
+        tables.group_by do |table|
+          table.split(/[\._]/).first(level).join('_')
+        end.transform_values do |children|
+          group_tables(children, level: level + 1)
+        end
+      end
+      def self.column_name_candidates(connection, polymorphic_suffixes: ['_type'], on_error: proc {})
+        columns_of_table = ForeignKeyChecker::Utils.get_columns(connection)
+        columns_of_table.each_with_object({}) do |(table, columns), object|
+          object[table] = TableLevel.new(connection, table, columns_of_table, polymorphic_suffixes, on_error: on_error, fks: fks).candidates
+        end
+      end
+
+      def self.all_candidates(connection, polymorphic_suffixes: ['_type'], on_error: proc {})
+        merge_candidates(
+          fk_candidates(connection, polymorphic_suffixes: polymorphic_suffixes, on_error: on_error),
+          column_name_candidates(connection, polymorphic_suffixes: polymorphic_suffixes, on_error: on_error)
+        )
+      end
+
+      def self.all_association_candidates(connection, polymorphic_suffixes: ['_type'], on_error: proc {})
+        belongs_to = all_candidates(connection, polymorphic_suffixes: ['_type'], on_error: proc {})
+        has_many = inverse(belongs_to)
+        belongs_to.each_with_object({}) do |(table, bt_associations), object|
+          object[table] = {belongs_to: bt_associations, has_many: has_many[table] || []}
+        end
+      end
+
+      def self.inverse(hash)
+        hash.each_with_object({}) do |(table, bt_associations), object|
+          bt_associations.each do |association|
+            object[association.primary_table] ||= []
+            object[association.primary_table].push(association.inversed_association(table))
+          end
+        end.transform_values do |associations|
+          associations.uniq do |result|
+            "#{result.polymorphic} #{result.foreign_key} #{result.primary_table} #{result.dependant_table} #{result.name} #{result.types&.join(',')}"
+          end
+        end
+      end
+
+      def self.fks
+        @fks ||= ForeignKeyChecker::Utils.get_foreign_keys
+      end
+
+      def self.fk_candidates(connection, polymorphic_suffixes: ['_type'], on_error: proc {})
+        fks.to_a.each_with_object({}) do |datum, obj|
+          obj[datum.from_table] ||= []
+          obj[datum.from_table].push(Result.new(polymorphic: false, foreign_key: datum.from_column, dependant_table: datum.from_table, primary_table: datum.to_table, connection: connection))
+        end
+      end
+
+      def self.merge_candidates(*hashes)
+        hashes.each_with_object({}) do |hash, object|
+          hash.each do |table, candidates|
+            object[table] ||= []
+            object[table] = (object[table] + candidates).uniq do |result|
+              "#{result.polymorphic} #{result.foreign_key} #{result.primary_table} #{result.dependant_table} #{result.name} #{result.types&.join(',')}"
+            end
+          end
+        end
+      end
+
+      # ForeignKeyChecker::Utils::BelongsTo.build_classes(User)
+      def self.build_classes(model, polymorphic_suffixes: ['_type'], on_error: proc {})
+        @build_classes ||= begin
+          mapping = build_table_mapping(model: model)
+          build_class_name = proc { |table| mapping[table] }
+          all_association_candidates(model.connection, polymorphic_suffixes: polymorphic_suffixes, on_error: on_error).map do |table, hash|
+            hash.transform_values { |results| results.map { |result| result.build_class_name = build_class_name; result }}.merge(
+              table_name: table,
+              class_name: mapping[table],
+            )
+          end
+        end
+      end
+
+      # ForeignKeyChecker::Utils::BelongsTo.build_delete_chain(City.where(slug: 'paris'), {countries: :capital_city_id, cities: %i[curator_id main_city_id]})
+      # ForeignKeyChecker::Utils::BelongsTo.build_delete_chain(City.where(slug: 'paris'), {countries: :capital_city_id, cities: %i[curator_id main_city_id], local_profiles: :published_edition_id, hint_places: :place_image_id}, {})
+      def self.build_delete_chain(scope, nullify = {}, **args)
+        tree = build_hm_tree(scope.model, **args)
+        all_ids = []
+        dependencies = {}
+        triggers = {}
+        cmds = [proc { |*args| __ids = scope.pluck(:id); all_ids << [scope.model.table_name, __ids, []]; __ids}]
+        process_tree = proc do |_tree, way|
+          _tree.each do |table, data|
+            cmds << proc do |*args|
+              primary_table = data[:associations].first.primary_table
+              ids = all_ids.select { |tn, __ids| tn == primary_table }.map(&:second).reduce(&:+).uniq
+              _id_fks = []
+              data[:associations].each do |association|
+                association.select_sql_with_fk(ids.dup).try do |sql|
+                  begin
+                    if Array.wrap(nullify[association.dependant_table.to_sym]).include?(association.foreign_key.to_sym)
+                      ids.in_groups_of(1000, false).each do |group|
+                        all_ids << [";sql;", association.nullify_sql(group), way]
+                      end
+                      next
+                    end
+
+                    p way
+                    _id_fks += association.connection.select_all(*sql).rows
+                  rescue => e
+                    raise e unless e.message.tr('"', '').include?("column id does not exist")
+                    ids.in_groups_of(1000, false).each do |group|
+                      all_ids << [";sql;", association.delete_sql(group), way]
+                    end
+                    puts e.message
+                  end
+                end
+              end
+              _id_fks.each do |_id, _fk|
+                dependencies[primary_table] ||= {}
+                dependencies[primary_table][_fk] ||= Set.new
+                dependencies[primary_table][_fk] << [table, _id]
+
+                triggers[table] ||= {}
+                triggers[table][_id] ||= Set.new
+                triggers[table][_id] << [primary_table, _fk]
+              end
+              _ids = _id_fks.map(&:first).uniq - (all_ids.select { |tn, __ids| tn == table }.map(&:second).reduce([], &:+).uniq)
+              if _ids.any?
+                all_ids << [table, _ids, way]
+                data[:children].presence.try { |ch| process_tree.call(ch, way + [table]) }
+              end
+              _ids
+            end
+          end
+        end
+        process_tree.call(tree, [scope.model.table_name])
+        arg = nil
+        cmds.each do |cmd|
+          arg = cmd.call(arg)
+        end
+        sql_queries = all_ids.select { |a, b, c| a == ';sql;' }.map(&:second)
+        t_ids = all_ids.reject { |a, b, c| a == ';sql;' }.group_by(&:first).transform_values { |vs| vs.map(&:second).reduce([], &:+).uniq }.to_a
+        loop do
+          break unless t_ids.map(&:second).any?(&:any?)
+          any = false
+          t_ids.each do |table, ids|
+            _ids = ids.select { |id| dependencies.dig(table, id).blank? }
+            ids.reject! { |id| dependencies.dig(table, id).blank? }
+            if _ids.present?
+              any = true
+              _ids.in_groups_of(1000, false).each do |ids_group|
+                sql_queries << ["DELETE FROM #{scope.model.connection.quote_table_name(table)} WHERE id IN (#{ids_group.map(&:to_i).join(',')})"]
+              end
+              _ids.each do |id|
+                triggers.dig(table, id)&.each do |keys|
+                  dependencies.dig(*keys).delete([table, id])
+                end
+              end
+            end
+          end
+          unless any
+            binding.pry
+            puts "Cannot destroy these objects. Check cyclic relation chains:\n#{find_cycles(tree, [scope.model.table_name]).inspect}"
+            return []
+          end
+        end
+        sql_queries
+      end
+      class WayPoint
+        attr_reader :table
+        def initialize(foreign_key, table)
+          @foreign_key = foreign_key
+          @table = table
+        end
+
+        def inspect
+          return @table if @foreign_key.blank?
+
+          "->#{@foreign_key}(#{@table})"
+        end
+
+        def ==(value)
+          return @table == value if value.is_a?(String)
+
+          value.table == @table
+        end
+      end
+
+      def self.find_ways(node, way)
+        way = way.map { |wp| next WayPoint.new(nil, wp) if wp.is_a?(String); wp}
+        return [way] if node.nil?
+        node.each_with_object([]) do |(key, item), obj|
+          tails = if way.include?(key)
+            [way + [key]]
+          else
+            find_ways(item[:children], way + [key])
+          end
+          item[:associations].each do |ass|
+            tails.each do |tail|
+              obj.push((tail[0...way.size]) + [WayPoint.new(ass.foreign_key, ass.dependant_table)] + (tail[(way.size + 1)..-1] || []))
+            end
+          end
+        end
+      end
+
+      def self.find_cycles(tree, start)
+        find_ways(tree, start).each_with_object([]) do |way, obj|
+          way[0..-2].index(way.last).try do |idx|
+            obj.push ([WayPoint.new(nil, way[idx].table)] + way[idx+1..-1])
+          end
+        end.uniq(&:inspect)
+      end
+
+      # ForeignKeyChecker::Utils::BelongsTo.ways_for(User)
+      def self.ways_for(model)
+        find_ways(build_hm_tree(model), [model.table_name])
+      end
+
+      # ForeignKeyChecker::Utils::BelongsTo.ways_for(User)
+      def self.cycles_for(model)
+        find_cycles(build_hm_tree(model), [model.table_name])
+      end
+
+      # ForeignKeyChecker::Utils::BelongsTo.build_hm_tree(User)
+      # построит дерево зависимостей от модели User
+      #find_cycle = proc { |node, way| puts way.join('->'); next [way] if node.nil?; node.each_with_object([]) { |(key, item), obj| ways = way.include?(key) ? [way + [key]] : find_cycle.call(item[:children], way + [key]); ways.each { |w| obj.push(w) } } v}
+      def self.build_hm_tree(model, **args)
+        mapping = build_table_mapping(model: model)
+        hash = build_classes(model, **args).group_by do |result|
+          result[:table_name]
+        end
+        found = {}
+        processing = {}
+        should_fill = []
+        find_children = proc do |c_table_name|
+          processing[c_table_name] = true
+          hash[c_table_name].each_with_object({}) do |results, object|
+            perform_result = proc do |result|
+              key = result.dependant_table
+              object[key] ||= {associations: []}
+              object[key][:associations].push(result)
+
+              if processing[key]
+                should_fill.push([key, object[key]])
+                next
+              end
+
+              found[key] ||= find_children.call(key)
+              object[key][:children] ||= found[key]
+            end
+            results[:has_many].each(&perform_result)
+            hash.each_value do |hs|
+              hs.each do |h|
+                h[:belongs_to].each do |r|
+                  next unless r.polymorphic && r.types.include?(mapping[c_table_name])
+
+                  perform_result.call(r.inversed_association(c_table_name))
+                end
+              end
+            end
+          end
+        end
+        ret = find_children.call(model.table_name)
+        should_fill.each do |table_name, item|
+          item[:children] = found[table_name]
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/foreign_key_checker/version.rb

@@ -1,3 +1,3 @@
 module ForeignKeyChecker
-  VERSION = '0.2.1'
+  VERSION = '0.5.0'
 end

data/lib/generators/foreign_key_checker/models_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators/active_record'
+module ForeignKeyChecker
+  module Generators
+    class ModelsGenerator < ActiveRecord::Generators::Base
+      desc "generates models for all tables in development database"
+      argument :name, type: :string, default: 'FixForeignKeys'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def install
+        ForeignKeyChecker::Utils::BelongsTo.build_classes(ActiveRecord::Base.connection).each do |object|
+          file_path = "app/models/#{object[:class_name].underscore}.rb"
+          @object = object
+          template 'models/model.rb.erb', file_path
+        end
+      end
+
+
+    end
+  end
+end

data/lib/generators/foreign_key_checker/templates/models/model.rb.erb

@@ -0,0 +1,9 @@
+class <%= @object[:class_name] %> < ApplicationRecord
+  self.table_name = '<%= @object[:table_name] %>'
+<% @object[:belongs_to].each do |bt| %>
+  <%= bt.association_code %>
+<% end %>
+<% @object[:has_many].each do |bt| %>
+  <%= bt.association_code %>
+<% end %>
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreign_key_checker
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.5.0
 platform: ruby
 authors:
 - AnatolyShirykalov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,90 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tiny_tds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: e2mmap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: annotate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Run task to obtain problems with your database
 email:
 - pipocavsobake@gmail.com
@@ -49,17 +133,23 @@ files:
 - README.md
 - Rakefile
 - lib/foreign_key_checker.rb
+- lib/foreign_key_checker/checkers/relations.rb
+- lib/foreign_key_checker/checkers/tables.rb
 - lib/foreign_key_checker/railtie.rb
+- lib/foreign_key_checker/utils.rb
+- lib/foreign_key_checker/utils/belongs_to.rb
 - lib/foreign_key_checker/version.rb
 - lib/generators/foreign_key_checker/migration/migration_generator.rb
 - lib/generators/foreign_key_checker/migration/templates/migrations/fix_foreign_keys.rb.erb
+- lib/generators/foreign_key_checker/models_generator.rb
+- lib/generators/foreign_key_checker/templates/models/model.rb.erb
 - lib/tasks/foreign_key_checker_tasks.rake
 homepage: https://gitlab.com/pipocavsobake/foreign_key_checker
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -74,8 +164,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Find problems with relations in active_record models
 test_files: []