Rails :include vs. :joins
It appears that the :include
functionality was changed with Rails 2.1. Rails used to do the join in all cases, but for performance reasons it was changed to use multiple queries in some circumstances. This blog post by Fabio Akita has some good information on the change (see the section entitled "Optimized Eager Loading").
Include vs Join
includes
can't magically retrieve everything you want it to in one query; it will run one query per model (typically) that you need to hit. Instead, it eliminates future unnecessary queries. Take the following examples:
Bad
users = User.first(5)
users.each do |user|
p user.debits.first
end
There will be 6 queries in total here, one to User retrieving all the users, then one for each .debits
call in the loop.
Good!
users = User.includes(:debits).first(5)
users.each do |user|
p user.debits.first
end
You'll only make two queries here: one for the users and one for their associated debits. This is how includes
speeds up your application, by eagerly loading things you know you'll need.
As for your comment, yes it seems to make sense to combine them into one table. Depending on your situation, I'd recommend looking into Single Table Inheritance (STI). If you don't go this route, be careful with adding a column called type
, Rails won't like that!
What's the difference between includes and joins in ActiveRecord query?
:joins
joins tables together in sql, :includes
eager loads associations to avoid the n+1 problem (where one query is executed to retrieve the record and then one per association which is loaded).
I suggest you read their sections in Rails Guides to get more info.
How to use joins inside includes in rails active record query?
you do this by chaining both together:
Student.joins(parents: :emails).includes(:parents).where("emails.email_address is not null and emails.email_address != ''")
The way it works is that joins
will create a JOIN
but not kep any of the data in memory, whereas includes
will preload the data in memory but not create the join.
I suggest reading this blog post: https://web.archive.org/web/20200804112405/http://tomdallimore.com/blog/includes-vs-joins-in-rails-when-and-where/
Rails query] difference between joins and includes
You use joins when you want to query against the joined model. This is doing an inner join between your tables.
Includes is when you want to eager load the associated model to the end result.
This allows you to call the association on any of the results without having to again do the db lookup.
You cannot query against a model that is loaded via includes. If you want to query against it you must use joins( you can do both! )
Related Topics
How to Generate a Random String in Ruby
No Increment Operator (++) in Ruby
Why Does Ruby Have Both Private and Protected Methods
How to Get a Single Character Without Pressing Enter
Creating Matrix With 'Array.New(N, Array.New)'
How to Convert a Unix Timestamp (Seconds Since Epoch) to Ruby Datetime
How to Keep the Delimiters When Splitting a Ruby String
How to Dynamically Create a Local Variable
How to Sort an Array in Descending Order in Ruby
How to Avoid Running Activerecord Callbacks
Error to Install Nokogiri on Osx 10.9 Maverick
String Concatenation Vs. Interpolation in Ruby