ActiveRecord querying a tree structure efficiently

问题

I have inherited a Rails 3 app that stores much of it's data as a fairly sophisticated tree structure. The application works pretty well in general but we are noticing some problems with performance, mostly around database interactions.

I am seeing a lot of queries along the lines of these showing up in my logs:

SELECT `messages`.* FROM `messages` WHERE `messages`.`context_type` = 'Node' AND `messages`.`context_id` IN (153740, 153741, /* about a thousand records... */ 154837, 154838, 154839, 154840, 154841, 154842, 154843)

Followed by many single queries where it looks as though the same record is being queried time and again:

[1m[35mCACHE (0.0ms)[0m  SELECT `plans`.* FROM `plans` WHERE `plans`.`type` IN ('Scenario') AND `plans`.`id` = 1435 LIMIT 1

My log has that exact query roughly eighty times- now I'm guessing that initial Cache message means it is probably being pulled from a cache rather than going back to the database every time, but it still looks like a lot and this type of thing is happening repeatedly.

I am guessing that the above queries are an association being pulled out backwards so that message belongs_to plan and it is loading all the messages then pulling out the plan for each one rather than, as one might do in a sane world, starting with the plan and then loading all the messages.

Working in this vein, a single request contains 1641 SELECT statements and it seems very likely to me that the sheer amount of database traffic ( not to mention the number of sequential LIMIT 1 queries for neighbouring data in the same table ) is a significant bottleneck. I am reluctant to post too much code but this is a typical example of one of the larger queries:

 def nodes
    include_objects = [:sector, :market, :messages, :node_user_prefs, :reference_node, :project, {:available_events => :available_event_nodes}, :customer_factors, :active_components, :tags, { :event_histories => :node}, {:event_histories => :user }]

    project = self
    @cached_nodes ||= begin
      all_nodes = orig_nodes.includes(include_objects)
      all_nodes = all_nodes.map { |n| n.tap { |i| i.cached_project = project } }
      all_node_ids = all_nodes.map(&:id)
      all_nodes.select{ |n| n.type == 'InitialNode' || all_node_ids.include?(n.parent_node_id) } 
    end
  end

Obviously, the queries are pretty diverse and the application is large, but this is fairly representative of the standard approach taken.

What are the easy wins with ActiveRecord that I can use to try and speed things up? I can easily enough put together a query that would pull all the required data out in a single round trip, but how easy would it be to form that - redundancies and all - into my model hierarchy? What other techniques can I use to help out here?

回答1:

Ancestry Gem

Not a direct fix by any means, but you may wish to consider the ancestry gem -

This will give you a way to create a tree structure, whereby you'll be able to call single records & then have their descendents called a you wish. This will cut back on your SQL queries:

If you set up your nodes / objects in this fashion, it will allow you to call the records you require once & ancestry will populate the rest. If you want me to divulge more information on this, please let me know in the comments & I'll detail more specifics

来源：https://stackoverflow.com/questions/24651295/activerecord-querying-a-tree-structure-efficiently

标签

ruby-on-rails

ruby-on-rails-3

performance

activerecord