Rails 4 Accessing Join Table Attributes

问题:

I have a has_many through join table setup for a recipe app where Ingredient and Meal connect through MealIngredient. Within MealIngredient, I have meal_id, ingredient_id, and amount. My question is: How can I access the amount column?

In my recipe view, I loop through the ingredients:

@meal.ingredients.each do |i|

I can access the properties of the ingredient but not the amount from the MealIngredient join record.

I tried using includes in the query doing @meal.ingredients.includes(:meal_ingredients), but I'm unsure of how to access the amount within the aforementioned loop. When I use i.inspect, I don't see any references to the meal_ingredients table at all.

Is there some way to access the variable within that loop using i.amount?

Thank you in advance for any help!

回答1:

Ahhh the good old how do I access my extra join table attributes question. Struggled with this for MONTHS until we came up with a solution

--

ActiveRecord Association Extensions

The problem you have is that Rails will just use the foreign_keys in your join table to load the associative data you need. Unless you actually load the join model directly, it won't give you the ability to access the join attributes

Some foraging lead us to ActiveRecord Association Extensions - a way to access the intermediary data in between different ActiveRecord Associations (using a collection called proxy_association). This will allow you to access the extra attributes from the join model, appending them to your "original" model:

#app/models/ingredient.rb
class Ingredient < ActiveRecord::Base
   attr_accessor :amount #-> need a setter/getter
end

#app/models/meal.rb
class Meal < ActiveRecord::Base
   has_many :meal_ingredients
   has_many :ingredients, through: :meal_ingredients, extend: IngredientAmount
end

#app/models/concerns/ingerdient_amount.rb
module IngredientAmount

    #Load
    def load
        amounts.each do |amount|
            proxy_association.target << amount
        end
    end

    #Private
    private

    #Amounts
    def amounts
        return_array = []
        through_collection.each_with_index do |through,i|
            associate = through.send(reflection_name)
            associate.assign_attributes({amount: items[i]}) if items[i].present?
            return_array.concat Array.new(1).fill( associate )
        end
        return_array
    end

    #######################
    #      Variables      #
    #######################

    #Association
    def reflection_name
        proxy_association.source_reflection.name
    end

    #Foreign Key
    def through_source_key
        proxy_association.reflection.source_reflection.foreign_key
    end

    #Primary Key
    def through_primary_key
        proxy_association.reflection.through_reflection.active_record_primary_key
    end

    #Through Name
    def through_name
        proxy_association.reflection.through_reflection.name
    end

    #Through
    def through_collection
        proxy_association.owner.send through_name
    end

    #Captions
    def items
        through_collection.map(&:amount)
    end

    #Target
    def target_collection
        #load_target
        proxy_association.target
    end

end

This should append the amount attribute to your ingredient objects now, allowing you to perform:

@meal = Meal.find 1
@meal.ingredients.each do |ingredient|
   ingredient.amount
end

回答2:

In this case, you should loop through the meal_ingredients association. You should eager load the ingredients association to reduce db queries.

@meal.meal_ingredients.includes(:ingredient).each do |meal_ingredient|
  puts meal_ingredient.amount
  puts meal_ingredient.ingredient.name
end

UPDATE

This update came after Rich Peck's answer but I think there's a simpler way to achieve what he did.

@meal.ingredients.select('ingredients.*, meal_ingredients.amount').each do |ingredient|
  puts ingredient.amount
  puts ingredient.name
end