Eager Load Grandchilden w/o Children

I have several models that are all linked together in a time
tracking/billing system ala:

class Claim < AR::B
has_many :appointments

def student
@student ||= Student.joins(student_appointments:
:claim).where(’claims.id =
?’,self.id).group(’students.id’).first
#second draft
# @student ||= (student_appointments.size == 0 ? nil :
student_appointments[0].student) #first draft
end
end

class Appointment < AR::B
belongs_to :claim
belongs_to :student
end

class Student < AR::B
has_many :appointments
end

My users that administer these accounts want to be able to look at
claims
in the index but need to know who these claims were for. My first
attempt
building the view resulted in 2*N + 1 queries for getting the student’s
name, the second implementation paired that down to N+1 but obviously
that
still sucks. To totally avert the N+1 query problem typically I’d just
eager load what I needed via Claim.includes(:appointments => :student)
but
I’d really like to avoid this here since I’ll never actually use the
appointments in the view. I’ve tried a has_one :through but rails
doesn’t
allow a collection to then point at a single record this way, I’ve also
tried just loading them via: Student.joins(‘join through to
claims’).where(claims.id in (?),claims.map(&:id)) in the
presenter/controller but since everything is lazy loaded the query never
gets executed and then the N+1 loads start. The third though I had was
doing a belongs_to with conditions but there isn’t any way to include
joins
in there so that’s out. My last thought is to do something like:

class Claim < AR::B
has_many :appointments
has_one :appointment
has_one :student, :through => :appointment
end

but that clutters up the methods and would leave us open to the mistake
of
looking for the collection and getting the single. Are there any
suggestions out there aside from loading the whole tree?

Hi Tyler,

On Thu, Aug 9, 2012 at 2:32 PM, t.pickett66 [email protected]
wrote:

# @student ||= (student_appointments.size == 0 ? nil :

I’d really like to avoid this here since I’ll never actually use the
has_many :appointments
has_one :appointment
has_one :student, :through => :appointment
end

but that clutters up the methods and would leave us open to the mistake of
looking for the collection and getting the single. Are there any
suggestions out there aside from loading the whole tree?

If it were me, I’d get rid of the student method and just put a has_many
and belongs_to relationship directly between Student and Claim. You can
have both that and the relationship through Appointment.

HTH,
Bill

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs