ActiveRecord nested associations - ruby-on-rails

Question

I have some models like Service, Payment and Manager
class Service < ApplicationRecord
validates :name, presence: true
has_and_belongs_to_many :tickets
has_many :payments
end
class Payment < ApplicationRecord
belongs_to :manager
belongs_to :service
validates :value, :manager_id, :service_id, presence: true
end
class Manager < ApplicationRecord
validates :name, presence: true
end
Service can have multiple Payments and each Payment has single Manager.
I want to get the whole data using all nested associations as a hash that I could reformat (or map) and sent to the client. I am stuck with query:
Service.includes(payments: :manager).references(:payments, :managers)
as it is using lazy load, and I need to do something like:
services.first.payments.first.manager
to get data, and it is non-optimal.
Is it possible to get all data with all nested associations?
I did calculations like this:
services = Service.includes(payments: :manager)
.references(:payments, :managers)
result = []
services.each do |service|
service.payments.each do |payment|
manager_name = payment[:manager][:name]
value = payment[:value]
service[manager_name] = value
end
result.push(service)
end
and got an error NoMethodError (undefined method '[]' for nil:NilClass):
on manager_name = payment[:manager][:name] line.

Answer 1

You can define an additional has_many through relationship which should give you what you want.
has_many :managers, through: :payments
class Service < ApplicationRecord
validates :name, presence: true
has_and_belongs_to_many :tickets
has_many :payments
has_many :managers, through: :payments
end
class Payment < ApplicationRecord
belongs_to :manager
belongs_to :service
validates :value, :manager_id, :service_id, presence: true
end
class Manager < ApplicationRecord
validates :name, presence: true
end

Answer 2

I did not understand your need %100 but I come up and idea like following. Please review it.
payments = Payment.joins(:service).select(:service_id, :manager_id, :value).
group_by(&:service_id)
managers = Manager.where('id IN(SELECT manager_id FROM payments)').
select(:name,:id)
group_by(&:id).transform_values{ |value| value.first }
result = []
ResultClass = Struct.new(:service, :manager, :payment_value)
Service.all.each do |service|
payment = payments[service.id]
manager = managers[payment.manager_id]
result << ResultClass.new(service, manager, payment.value)
end
With this code, we are actually trying to accomplish rails includes mechanism under the hood. What we did actually here?
We get the payments and converted them to hash that the id is hash key
Then we get the managers those have payments and we converted also these records with manager id as hash key
We created ResultClass with Struct to store the references of objects like service and manager
We start the iteration. Because of the fact that we have payments and members as hash, there is fast look up and there is no time complexity. In overall, this iteration's time complexity is O(n)
If you have any questions please feel free to drop a comment.

Answer 3

After lots of tries I've finally find some misspells I made and archieved behaviour I want using such code
services = Service.eager_load(payments: :manager)
services.reduce([]) do |acc, service|
service_rec = {
id: service[:id],
name: service[:name],
surgery: service[:surgery]
}
service.payments.each do |payment|
manager_name = payment.manager[:name]
value = payment[:value]
service_rec[manager_name] = value
end
acc.push(service_rec)
end
and SQL query it produces
SQL (0.2ms) SELECT "services"."id" AS t0_r0, "services"."code" AS t0_r1, "services"."name" AS t0_r2, "services"."surgery" AS t0_r3, "services"."enabled" AS t0_r4, "services"."created_at" AS t0_r5, "services"."updated_at" AS t0_r6, "payments"."id" AS t1_r0, "payments"."service_id" AS t1_r1, "payments"."manager_id" AS t1_r2, "payments"."value" AS t1_r3, "payments"."created_at" AS t1_r4, "payments"."updated_at" AS t1_r5, "managers"."id" AS t2_r0, "managers"."name" AS t2_r1, "managers"."enabled" AS t2_r2, "managers"."created_at" AS t2_r3, "managers"."updated_at" AS t2_r4 FROM "services" LEFT OUTER JOIN "payments" ON "payments"."service_id" = "services"."id" LEFT OUTER JOIN "managers" ON "managers"."id" = "payments"."manager_id"
It is interesting that using includes instead of eager_load produces three queries instead
Service Load (0.1ms) SELECT "services".* FROM "services"
↳ app/services/payments_service.rb:6
Payment Load (0.1ms) SELECT "payments".* FROM "payments" WHERE "payments"."service_id" IN (?, ?, ?, ?, ?, ?, ?, ?) [["service_id", 1], ["service_id", 2], ["service_id", 3], ["service_id", 4], ["service_id", 5], ["service_id", 6], ["service_id", 7], ["service_id", 8]]
↳ app/services/payments_service.rb:6
Manager Load (0.1ms) SELECT "managers".* FROM "managers" WHERE "managers"."id" IN (?, ?, ?, ?) [["id", 1], ["id", 2], ["id", 3], ["id", 4]]
Also we can use Service.includes(payments: :manager).references(:payments, :managers) and got the same query as eager_load but it's longer to type))
Thanks everyone for participation! Does anyone have another opinion about eager_load or code optimisation proposals?