如何优化含固定枚举关联的模型查询，减少页面加载时间？

我有 Bouquet 和 Flower 两个模型：

class Bouquet < ApplicationRecord
  has_many :flowers
end

class Flower < ApplicationRecord
  belongs_to :bouquet

  enum color: {
    blue: 0,
    red: 1,
    yellow: 2,
    white: 3
  }
end

每个 Bouquet 里固定包含一朵蓝色、一朵红色、一朵黄色和一朵白色的 Flower。

现在需要做一个页面，按顺序列出所有 Bouquet 及其对应的 Flower，要怎么查询 Flower 才能最小化页面加载时间？

视图代码如下（注意白色 Flower 展示的信息和其他颜色不同）：

<% Bouquet.some_scope.each do |bouquet| %>
  <ul>
    <li><%= bouquet.name %></li>
    <li><%= bouquet.blue_flower.name %></li>
    <li><%= bouquet.red_flower.name %></li>
    <li><%= bouquet.yellow_flower.name %></li>
    <li><%= bouquet.white_flower.name_and_type %></li>
  </ul>
<% end %>

我试过两种方案：

• 在 Bouquet 模型里定义这些方法：

  class Bouquet < ApplicationRecord
    has_many :flowers
  
    def blue_flower
      flowers.find_by(color: :blue)
    end
  
    def red_flower
      flowers.find_by(color: :red)
    end
  
    # 其余颜色的方法类似...
  
  end
  

  然后视图里用 <% Bouquet.some_scope.includes(:flowers).each do |bouquet| %>，但所有 find_by 都会忽略预加载，每次调用都要查数据库。
• 因为 Flower 理论上是按固定顺序创建的，我改成这样：

  class Bouquet < ApplicationRecord
    has_many :flowers
  
    def blue_flower
      flowers.first
    end
  
    def red_flower
      flowers.second
    end
  
    # 其余颜色的方法类似...
  
  end
  

  这个方案能工作，但这是最优的处理方式吗？

你可以用以下几种更可靠且高效的方式来避免N+1查询，同时保证逻辑稳定性：

方法一：为每种颜色定义单独的关联 #

直接在 Bouquet 模型里为每种颜色的花建立一对一关联，这样就能通过预加载一次性拉取所有数据：

class Bouquet < ApplicationRecord
  has_many :flowers
  has_one :blue_flower, -> { where(color: :blue) }, class_name: 'Flower'
  has_one :red_flower, -> { where(color: :red) }, class_name: 'Flower'
  has_one :yellow_flower, -> { where(color: :yellow) }, class_name: 'Flower'
  has_one :white_flower, -> { where(color: :white) }, class_name: 'Flower'
end

查询时预加载这些关联即可：

<% Bouquet.some_scope.includes(:blue_flower, :red_flower, :yellow_flower, :white_flower).each do |bouquet| %>
  <!-- 视图代码保持不变 -->
<% end %>

这种方式逻辑清晰，关联语义明确，只会执行1次Bouquet查询 + 4次批量Flower查询（部分Rails版本会优化为更少查询），彻底避免N+1问题。

方法二：预加载后在内存中分组 #

如果不想定义过多关联，可以预加载所有flowers后，在模型内通过内存分组获取对应颜色的花，完全避免重复查询：

class Bouquet < ApplicationRecord
  has_many :flowers

  def blue_flower
    flowers_by_color[:blue]
  end

  def red_flower
    flowers_by_color[:red]
  end

  def yellow_flower
    flowers_by_color[:yellow]
  end

  def white_flower
    flowers_by_color[:white]
  end

  private

  def flowers_by_color
    @flowers_by_color ||= flowers.index_by(&:color)
  end
end

查询时只需预加载所有flowers：

<% Bouquet.some_scope.includes(:flowers).each do |bouquet| %>
  <!-- 视图代码保持不变 -->
<% end %>

这种方式仅执行1次Bouquet查询 + 1次Flower批量查询，性能最优，且不依赖花的创建顺序，逻辑更可靠。

为什么方案2不是最优？ #

方案2依赖花的创建顺序，一旦数据创建逻辑变动（如花被删除重建、创建顺序调整），就会导致颜色对应错误，属于不稳定实现，不适合生产环境。

内容的提问来源于stack exchange，提问作者yowqhu