如何加速Active Record查询中查找相邻check_ins记录的操作？

原代码的核心性能问题 #

• N+1查询灾难：遍历每条check_ins时都发起一次数据库查询，请求量随记录数线性增长
• 内存低效查找：每次查询后用client_cis.index(ci)做遍历查找，时间复杂度O(n)，进一步拖慢速度
• 重复查询冗余：同一客户的多条记录会被重复查询，浪费数据库资源

优化方案一：批量预加载+内存映射（推荐入门优化） #

通过一次查询获取所有需要的数据，再在内存中构建索引映射，彻底消除N+1问题：

# 1. 提取所有涉及的客户ID，避免重复查询
client_ids = check_ins.pluck(:client_id).uniq

# 2. 一次性查询所有符合条件的客户到访记录
# 用joins代替where.not(weigh_ins: {id: nil})，内连接自动排除无关联weigh_in的记录，性能更优
all_client_cis = CheckIn.visible
  .includes(:weigh_in)
  .select(:id, :week, :created_at, :type_of_weighin, :client_id)
  .where(client_id: client_ids)
  .where.not(type_of_weighin: nil)
  .joins(:weigh_in)
  .where("weigh_ins.date >= ?", check_ins.min_by(&:created_at).created_at - 3.weeks)
  .order("client_id, weigh_ins.date DESC") # 按客户分组，按到访日期排序（根据业务调整排序字段）

# 3. 按客户ID分组，构建快速查找的哈希结构
client_cis_map = all_client_cis.group_by(&:client_id)

# 4. 提前为每个客户的记录构建ID到索引的映射，把O(n)查找变成O(1)
client_ci_index_map = client_cis_map.transform_values do |cis|
  cis.each_with_index.to_h { |ci, idx| [ci.id, idx] }
end

# 5. 遍历初始check_ins，快速获取前一条相邻记录
check_ins.each do |ci|
  client_cis = client_cis_map[ci.client_id]
  next unless client_cis

  current_idx = client_ci_index_map[ci.client_id][ci.id]
  neighbor = current_idx > 0 ? client_cis[current_idx - 1] : nil

  # 执行后续计算逻辑...
end

优化方案二：数据库窗口函数（极致性能优化） #

利用PostgreSQL的LAG()窗口函数，直接在数据库层面完成相邻记录的查找，完全避免内存中处理排序和索引：

# 用窗口函数直接查询出每条记录的前一条相邻记录字段
check_ins_with_neighbor = CheckIn.visible
  .joins(:weigh_in)
  .where(id: check_ins.pluck(:id)) # 限定为初始加载的check_ins集合
  .select(
    "check_ins.*",
    "LAG(check_ins.id) OVER (PARTITION BY check_ins.client_id ORDER BY weigh_ins.date) AS prev_check_in_id",
    "LAG(check_ins.week) OVER (PARTITION BY check_ins.client_id ORDER BY weigh_ins.date) AS prev_week",
    "LAG(check_ins.created_at) OVER (PARTITION BY check_ins.client_id ORDER BY weigh_ins.date) AS prev_created_at",
    "LAG(check_ins.type_of_weighin) OVER (PARTITION BY check_ins.client_id ORDER BY weigh_ins.date) AS prev_type_of_weighin"
  )
  .where.not(type_of_weighin: nil)
  .where("weigh_ins.date >= ?", check_ins.min_by(&:created_at).created_at - 3.weeks)

# 遍历处理，直接使用预查询的prev_*字段
check_ins_with_neighbor.each do |ci|
  # 如果需要完整的neighbor对象，可批量预加载：
  # prev_ids = check_ins_with_neighbor.pluck(:prev_check_in_id).compact
  # prev_cis = CheckIn.includes(:weigh_in).where(id: prev_ids).index_by(&:id)
  # neighbor = prev_cis[ci.prev_check_in_id]

  # 执行后续计算逻辑...
end

核心优化逻辑总结 #

1. 减少数据库请求：把N次查询合并为1-2次批量查询，彻底解决N+1问题
2. 内存查找优化：通过哈希映射把线性查找变成常数时间查找
3. 利用数据库能力：窗口函数让数据库完成排序和相邻记录计算，充分发挥数据库的优化能力

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