【问题标题】:Any rails plugins/gems for detecting orphaned records?任何用于检测孤立记录的 Rails 插件/宝石?
【发布时间】:2011-01-02 03:22:37
【问题描述】:

寻找可以通过模型中定义的关系并可以检查数据库中表之间的孤立记录/断开链接的东西。

【问题讨论】:

标签: ruby-on-rails database plugins orphan


【解决方案1】:

(以下脚本的最新版本,请参阅https://gist.github.com/KieranP/3849777)

Martin 脚本的问题在于它使用 ActiveRecord 先提取记录,然后查找关联,然后获取关联。它为每个关联生成大量 SQL 调用。对于小型应用程序来说这还不错,但是当您有多个表有 100k 条记录并且每个表有 5+ 个 belongs_to 时,它可能需要 10+ 分钟才能完成。

以下脚本改为使用 SQL,为 Rails 应用程序中的 app/models 中的所有模型查找孤立的 belongs_to 关联。它使用:class_name 处理简单的belongs_to、belongs_to 和多态belongs_to 调用。在我使用的生产数据上,它把 Martin 脚本的稍微修改版本的运行时间从 9 分钟缩短到了 8 秒,并且发现了和以前一样的所有问题。

享受:-)

task :orphaned_check => :environment do

  Dir[Rails.root.join('app/models/*.rb').to_s].each do |filename|
    klass = File.basename(filename, '.rb').camelize.constantize
    next unless klass.ancestors.include?(ActiveRecord::Base)

    orphanes = Hash.new

    klass.reflect_on_all_associations(:belongs_to).each do |belongs_to|
      assoc_name, field_name = belongs_to.name.to_s, belongs_to.foreign_key.to_s

      if belongs_to.options[:polymorphic]
        foreign_type_field = field_name.gsub('_id', '_type')
        foreign_types = klass.unscoped.select("DISTINCT(#{foreign_type_field})")
        foreign_types = foreign_types.collect { |r| r.send(foreign_type_field) }

        foreign_types.sort.each do |foreign_type|
          related_sql = foreign_type.constantize.unscoped.select(:id).to_sql

          finder = klass.unscoped.select(:id).where("#{foreign_type_field} = '#{foreign_type}'")
          finder.where("#{field_name} NOT IN (#{related_sql})").each do |orphane|
            orphanes[orphane] ||= Array.new
            orphanes[orphane] << [assoc_name, field_name]
          end
        end
      else
        class_name = (belongs_to.options[:class_name] || assoc_name).classify
        related_sql = class_name.constantize.unscoped.select(:id).to_sql

        finder = klass.unscoped.select(:id)
        finder.where("#{field_name} NOT IN (#{related_sql})").each do |orphane|
          orphanes[orphane] ||= Array.new
          orphanes[orphane] << [assoc_name, field_name]
        end
      end
    end

    orphanes.sort_by { |record, data| record.id }.each do |record, data|
      data.sort_by(&:first).each do |assoc_name, field_name|
        puts "#{record.class.name}##{record.id} #{field_name} is present, but #{assoc_name} doesn't exist"
      end
    end
  end

end

【讨论】:

    【解决方案2】:

    这可能取决于您想对孤儿采取什么行动。也许您只是想删除它们?这可以通过几个 SQL 查询轻松解决。

    【讨论】:

    • 所以,例如:SELECT * FROM Table1 WHERE id NOT IN (SELECT table1_id from Table2)
    • 我使用posts和cmets来让孤儿的情况更加清晰,这里我们要找到孤儿的cmets:select * from cmets where post_id not in (select id from posts)
    【解决方案3】:

    有相同的任务,并且当前的查找器以以下方式结束:

    Product.where.not(category_id: Category.pluck("id")).delete_all
    

    删除所有同时失去其类别的产品。

    【讨论】:

      【解决方案4】:

      您可以创建一个 Rake 任务来搜索和处理孤立记录,例如:

      namespace :db do
        desc "Handle orphans"
        task :handle_orphans => :environment do
          Dir[Rails.root + "app/models/**/*.rb"].each do |path|
            require path
          end
          ActiveRecord::Base.send(:descendants).each do |model|
            model.reflections.each do |association_name, reflection|
              if reflection.macro == :belongs_to
                model.all.each do |model_instance|
                  unless model_instance.send(reflection.primary_key_name).blank?
                    if model_instance.send(association_name).nil?
                      print "#{model.name} with id #{model_instance.id} has an invalid reference, would you like to handle it? [y/n]: "
                      case STDIN.gets.strip
                        when "y", "Y"
                          # handle it
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
      

      【讨论】:

      • 您可能还需要检查 :has_and_belongs_to_many 关系。我不确定。
      【解决方案5】:

      假设您有一个用户可以订阅杂志的应用程序。使用 ActiveRecord 关联,它看起来像这样:

          # app/models/subscription.rb
          class Subscription < ActiveRecord::Base
            belongs_to :magazine
            belongs_to :user
          end
      
          # app/models/user.rb
          class User < ActiveRecord::Base
            has_many :subscriptions
            has_many :users, through: :subscriptions
          end
      
          # app/models/magazine.rb
          class Magazine < ActiveRecord::Base
            has_many :subscriptions
            has_many :users, through: :subscriptions
          end
      

      不幸的是,有人忘记在 has_many :subscriptions 中添加dependent: :destroy。删除用户或杂志时,会留下一个孤立的订阅。

      dependent: :destroy 修复了这个问题,但仍有大量孤立记录徘徊。 您可以使用两种方法来删除孤立记录。

      方法 1 - 难闻的气味

      Subscription.find_each do |subscription|
        if subscription.magazine.nil? || subscription.user.nil?
          subscription.destroy
        end
      end
      

      这对每条记录执行单独的 SQL 查询,检查它是否是孤立的,如果是则销毁它。

      方法 2 — 好闻

      Subscription.where([
        "user_id NOT IN (?) OR magazine_id NOT IN (?)",
        User.pluck("id"),
        Magazine.pluck("id")
      ]).destroy_all
      

      这种方法首先获取所有用户和杂志的 ID,然后执行一个查询以查找不属于用户或查询的所有订阅。

      【讨论】:

      【解决方案6】:

      KieranP 的回答对我帮助很大,但他的脚本不处理命名空间类。我为此添加了几行代码,同时忽略了关注目录。如果您想删除所有孤立记录,我还添加了一个可选的 DELETE=true 命令行参数。

      namespace :db do
        desc "Find orphaned records. Set DELETE=true to delete any discovered orphans."
        task :find_orphans => :environment do
      
          found = false
      
          model_base = Rails.root.join('app/models')
      
          Dir[model_base.join('**/*.rb').to_s].each do |filename|
      
            # get namespaces based on dir name
            namespaces = (File.dirname(filename)[model_base.to_s.size+1..-1] || '').split('/').map{|d| d.camelize}.join('::')
      
            # skip concerns folder
            next if namespaces == "Concerns"
      
            # get class name based on filename and namespaces
            class_name = File.basename(filename, '.rb').camelize
            klass = "#{namespaces}::#{class_name}".constantize
      
            next unless klass.ancestors.include?(ActiveRecord::Base)
      
            orphans = Hash.new
      
            klass.reflect_on_all_associations(:belongs_to).each do |belongs_to|
              assoc_name, field_name = belongs_to.name.to_s, belongs_to.foreign_key.to_s
      
              if belongs_to.options[:polymorphic]
                foreign_type_field = field_name.gsub('_id', '_type')
                foreign_types = klass.unscoped.select("DISTINCT(#{foreign_type_field})")
                foreign_types = foreign_types.collect { |r| r.send(foreign_type_field) }
      
                foreign_types.sort.each do |foreign_type|
                  related_sql = foreign_type.constantize.unscoped.select(:id).to_sql
      
                  finder = klass.unscoped.where("#{foreign_type_field} = '#{foreign_type}'")
                  finder.where("#{field_name} NOT IN (#{related_sql})").each do |orphan|
                    orphans[orphan] ||= Array.new
                    orphans[orphan] << [assoc_name, field_name]
                  end
                end
              else
                class_name = (belongs_to.options[:class_name] || assoc_name).classify
                related_sql = class_name.constantize.unscoped.select(:id).to_sql
      
                finder = klass.unscoped
                finder.where("#{field_name} NOT IN (#{related_sql})").each do |orphan|
                  orphans[orphan] ||= Array.new
                  orphans[orphan] << [assoc_name, field_name]
                end
              end
            end
      
            orphans.sort_by { |record, data| record.id }.each do |record, data|
              found = true
              data.sort_by(&:first).each do |assoc_name, field_name|
                puts "#{record.class.name}##{record.id} #{field_name} is present, but #{assoc_name} doesn't exist" + (ENV['DELETE'] ? ' -- deleting' : '')
                record.delete if ENV['DELETE']
              end
            end
          end
      
          puts "No orphans found" unless found
        end
      end
      

      【讨论】:

        【解决方案7】:

        我创建了一个名为 OrphanRecords 的 gem。它为显示/删除孤儿记录提供了 rake 任务。目前不支持HABTM协会,有兴趣的可以contribute :)

        【讨论】:

          【解决方案8】:

          我已经在我的 gem PolyBelongsTo 中编写了一个方法来做到这一点

          您可以通过在任何 ActiveRecord 模型上调用 pbt_orphans 方法来查找所有孤立记录。

          宝石文件

          gem 'poly_belongs_to'
          

          代码示例

          User.pbt_orphans
          # => #<ActiveRecord::Relation []> # nil for objects without belongs_to
          Story.pbt_orphans
          # => #<ActiveRecord::Relation []> # nil for objects without belongs_to
          

          返回所有孤立记录。

          如果您只想检查单个记录是否为孤立记录,可以使用 :orphan? 方法。

          User.first.orphan?
          Story.find(5).orphan?
          

          适用于多态关系和非多态关系。

          如果您想查找具有无效类型的多态记录,您可以执行以下操作:

          Story.pbt_mistyped
          

          返回您的 Story 记录中使用的无效 ActiveRecord 模型名称的记录数组。类型为 ["Object", "Class", "Storyable"] 的记录。

          【讨论】:

            猜你喜欢
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 2012-12-21
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            相关资源
            最近更新 更多