如何在Rails中结合已存与未保存数据执行查询并验证库存限制？

我的Rails应用需要基于多张表的数据判断库存限制，比如箱子的重量/空间上限、板条箱能容纳的箱子数量上限等。这些判断需要整合多张表的多条记录数据。现有代码如下：

class Item < ApplicationRecord
  # Item 有 weight 数据库字段
  belongs_to :box
end

class Box < ApplicationRecord
  # Box 有 weight_limit 和 weight 数据库字段
  has_many :items

  def weight_limit_check()
    if( items.any? { |item| item.weight > weight_limit } )
      return false
    end

    return true
  end

  def weight()
    return items.reduce( 0 ) { |sum, item| sum + item.weight } + weight
  end
end

class Crate < ApplicationRecord
  # Crate 有 weight_limit 数据库字段
  has_many :boxes

  def weight_limit_check()
    if( boxes.any? { |box| box.weight > weight_limit } )
      return false
    end

    return true
  end
end

class CrateController < ApplicationController
  # GET /crate/:id/weight_limit_check
  def weight_limit_check()
    if( Crate.find( params[:id] ).weight_limit_check() )
      render :ok
    else
      render :not_acceptable
    end
  end
end

现在我希望在这些计算中加入临时数据，不用实际保存变更——也就是模拟变更后的数据库状态，但不持久化。因为我需要用到记录的其他属性，这些属性可能受现有记录和临时记录的共同影响。修改后的控制器代码如下：

class CrateController < ApplicationController
  # GET /crate/:id/weight_limit_check
  def weight_limit_check()
    if( Crate.find( params[:id] ).weight_limit_check( params[:additional_boxes_with_stuff] ) )
      render :ok
    else
      render :not_acceptable
    end
  end
end

有没有办法暂存任意数量表的变更，让计算逻辑像读取新的数据库数据一样运行，但最终不保存这些变更？目前我想到的是用事务应用数据、执行计算后抛出异常回滚，但不确定这是不是最优方案。对应的模型方法待实现：

class Crate < ApplicationRecord
  ...

  def weight_limit_check( additional_boxes_with_stuff )
    ...Somehow include the additional_boxes_with_stuff in the calculation...

    if( boxes.any? { |box| box.weight > weight_limit } )
      return false
    end

    return true
  end
end

1. 改进版事务回滚方案 #

事务回滚确实能实现需求，但不需要刻意抛出无意义异常，用Rails内置的ActiveRecord::Rollback就能安全触发回滚，且不会被识别为错误。这种方式的核心优势是完全复用现有模型的查询和计算逻辑，不需要修改原有代码：

def weight_limit_check(additional_boxes_data)
  ActiveRecord::Base.transaction do
    # 批量创建临时箱子及关联物品（事务内操作不会持久化到数据库）
    additional_boxes_data.each do |box_data|
      box = boxes.build(box_data.except(:items))
      box.items.build(box_data[:items])
      box.save! # 事务内的save仅在事务上下文生效
    end

    # 执行原有的重量检查逻辑
    result = boxes.none? { |box| box.weight > weight_limit }

    # 主动触发回滚，丢弃所有临时变更
    raise ActiveRecord::Rollback
    result
  end
end

这种方案适合复杂多表关联场景，尤其是当计算逻辑依赖数据库查询（比如has_many懒加载、关联统计）时，几乎不需要改动原有代码，成本最低。

2. 内存中模拟关联数据（无数据库操作） #

如果不想占用数据库连接，追求极致性能，可以直接在内存中构建临时对象并修改关联集合。这种方式完全脱离数据库，但需要确保所有计算逻辑能处理未保存的对象：

class Crate < ApplicationRecord
  has_many :boxes

  def weight_limit_check(additional_boxes_data)
    # 复制现有箱子集合，避免修改原对象的关联数据
    temp_boxes = boxes.to_a.dup

    # 构建临时箱子及物品（不写入数据库）
    additional_boxes_data.each do |box_data|
      box = Box.new(box_data.except(:items))
      box.items = box_data[:items].map { |item_data| Item.new(item_data) }
      temp_boxes << box
    end

    # 遍历临时集合执行检查
    temp_boxes.none? { |box| box.calculated_weight > weight_limit }
  end
end

class Box < ApplicationRecord
  has_many :items

  # 新增独立的计算方法，避免和原有weight字段冲突
  def calculated_weight
    items.sum(&:weight) + self.weight
  end

  def weight_limit_check
    items.none? { |item| item.weight > weight_limit }
  end
end

这种方案性能最优，但需要调整原有计算逻辑（比如把依赖数据库的weight方法改成内存计算的calculated_weight），适合逻辑不复杂的场景。

3. 方案对比 #

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