Question

I’ve got a model (a Feature) that can have many Assets. These Assets each have an issue_date. I’m struggling with what seems like a simple ActiveRecord query to find all Features and their Assets with an issue_date of tomorrow, regardless of if there are Assets or not — preferably with one query.

Here’s my query right now.

Feature.includes(:assets).where(:assets => { :issue_date => Date.tomorrow })

Unfortunately, this returns only the Features that have Assets with an issue_date of tomorrow. Even stranger, the generated SQL looks like this (tomorrow’s obviously the 19th).

SELECT `features`.* FROM `features`  WHERE `assets`.`issue_date` = '2011-08-19'

Shouldn’t this have an LEFT JOIN in there somewhere? That’s the sort of thing I’m going for. Using joins instead of includes does an INNER JOIN, but that’s not what I want. Strangely enough, it seems like I’m getting an INNER JOIN-type of behavior. When I run that includes query above, the actual SQL that’s spit out looks something like this…

SELECT `features`.`id` AS t0_r0, `features`.`property_id` AS t0_r1,
    // every other column from features truncated for sanity
    `assets`.`feature_id` AS t1_r1, `assets`.`asset_type` AS t1_r2,
    // all other asset columns truncated for sanity
FROM `features`
LEFT OUTER JOIN `assets` ON `assets`.`feature_id` = `features`.`id`
WHERE `assets`.`issue_date` = '2011-08-19'

Which looks like it should work right but it doesn’t. I get only the Features that have Assets with an issue_date of tomorrow. Any idea what I’m doing wrong?

I’ve tried the older, Rails v2 way of doing it…

Feature.find(:all,
             :include => :assets,
             :conditions => ['assets.issue_date = ?', Date.tomorrow])

Which gives me the same results. There’s one Feature I know that doesn’t have any Assets for tomorrow, and it’s not in that list.

I’ve also poked around and found similar questions, but I couldn’t seem to find one that explained this opposite behavior I’m seeing.

Edit: I’m so close. This gets me all the Feature objects.

Feature.joins("LEFT OUTER JOIN assets on assets.feature_id = feature.id AND asset.issue_date = #{Date.tomorrow}")

It does not, however, get me the matching Assets bundled into the object. With feature as a returned item in the query, feature.assets makes another call to the database, which I don’t want. I want feature.assets to return only those I’ve specified in that LEFT OUTER JOIN call. What else do I need to do to my query?

Answer 1

I thought this would get me what I needed, but it doesn’t. Calling feature.assets (with feature as an item returned in my query) does another query to look for all assets related to that feature.

Feature.joins("LEFT OUTER JOIN assets on assets.feature_id = feature.id AND asset.issue_date = #{Date.tomorrow}")

So here’s what does work. Seems a little cleaner, too. My Feature model already has a has_many :assets set on it. I’ve set up another association with has_many :tomorrows_assets that points to Assets, but with a condition on it. Then, when I ask for Feature.all or Feature.name_of_scope, I can specify .includes(:tomorrows_assets). Winner winner, chicken dinner.

has_many :tomorrows_assets,
  :class_name => "Asset",
  :readonly => true, 
  :conditions => "issue_date = '#{Date.tomorrow.to_s}'"

I can successfully query Features and get just what I need included with it, only if it matches the specified criteria (and I’ve set :readonly because I know I’ll never want to edit Assets like this). Here’s an IRB session that shows the magic.

features = Feature.includes(:tomorrows_assets)
feature1 = features.find_all{ |f| f.name == 'This Feature Has Assets' }.first
feature1.tomorrows_assets
=> [#<Asset id:1>, #<Asset id:2>]

feature2 = features.find_all{ |f| f.name == 'This One Does Not' }.first
feature2.tomorrows_assets
=> []

And all in only two SQL queries.