Question

我遇到一个问题，其中带有“扩展名”的多对多关系生成不正确的SQL。

class OrderItem < ApplicationRecord
  belongs_to :buyer, class_name: :User
  belongs_to :order
  belongs_to :item, polymorphic: true
end

class User < ApplicationRecord
  has_many :order_items_bought,
    -> { joins(:order).where.not(orders: { state: :expired }).order(created_at: :desc) },
    foreign_key: :buyer_id,
    class_name: :OrderItem

  has_many :videos_bought,
    -> { joins(:orders).select('DISTINCT ON (videos.id) videos.*').reorder('videos.id DESC') },
    through: :order_items_bought,
    source: :item,
    source_type: :Video do
      def confirmed
        where(orders: { state: :confirmed })
      end
    end
end

user.videos_bought.confirmed生成此SQL：

Video Load (47.0ms)  SELECT  DISTINCT ON (videos.id) videos.* FROM 
"videos" INNER JOIN "order_items" "order_items_videos_join" ON 
"order_items_videos_join"."item_id" = "videos"."id" AND 
"order_items_videos_join"."item_type" = $1 INNER JOIN 
"orders" ON "orders"."id" = "order_items_videos_join"."order_id" INNER JOIN 
"order_items" ON "videos"."id" = "order_items"."item_id" WHERE 
"order_items"."buyer_id" = $2 AND ("orders"."state" != $3) AND "order_items"."item_type" = $4 AND 
"orders"."state" = $5 ORDER BY videos.id DESC, "order_items"."created_at" DESC LIMIT $6

哪个返回一些Video记录，这些记录与未确认状态的订单一起加入。我希望所有订单都已确认状态。

如果我使用原始SQL，则一切正常：

has_many :videos_bought,
  -> {
    joins('INNER JOIN orders ON orders.id = order_items.order_id')
      .select('DISTINCT ON (videos.id) videos.*')
      .reorder('videos.id DESC')
  },
  through: :order_items_bought,
  source: :item,
  source_type: :Video do
    def confirmed
      where(orders: { state: :confirmed })
    end
end

现在user.videos_bought.confirmed生成此SQL：

Video Load (5.4ms)  SELECT  DISTINCT ON (videos.id) videos.* FROM 
"videos" INNER JOIN "order_items" ON 
"videos"."id" = "order_items"."item_id" INNER JOIN orders ON 
orders.id = order_items.order_id WHERE 
"order_items"."buyer_id" = $1 AND ("orders"."state" != $2) AND
"order_items"."item_type" = $3 AND "orders"."state" = $4 ORDER BY
videos.id DESC, "order_items"."created_at" DESC LIMIT $5

这似乎更简洁，因为它避免了自动生成的order_items_videos_join名称。它还仅返回状态已确认的订单。

知道发生了什么吗？有时候ActiveRecord只会生成错误的SQL吗？

使用滑轨5.1.5。升级到最新版本没有影响。

我希望能解释一下为什么Rails在第一种情况下会生成order_items_videos_join字符串，而在第二种情况下不会。同样，为什么第二个SQL查询产生不正确的结果。如果需要，我可以使用更多代码和数据样本来编辑问题。

Answer 1

ActiveRecord有时不仅会生成错误的SQL，而且还有一些细微差别，以至于在定义关系时最好从简单开始。例如，让我们重新处理您的查询以使该DISTINCT ON脱颖而出。我从未见过需要使用该SQL子句。

在链接高度自定义的关联逻辑之前，让我们先看看是否有更简单的查询方法，然后再检查是否有充分的理由将查询转换为关联。

看起来像您这样的架构：

用户

id

订购

id
状态

OrderItem

id
order_id
buyer_id（是否出于OrderItem而不是Order？）
item_type（视频）
item_id（videos.id）

视频

id

几个花絮

无需为查询条件创建关联扩展，这些关联扩展将在模型上实现完美的作用域。参见下文。

一个非常好的查询可能看起来像

Video.joins(order_item: :order).
    where(order_items: {
       buyer_id: 123, 
       order: {
          state: 'confirmed'
       }).
    # The following was part of the initial logic but
    #   doesn't alter the query results.
    # where.not(order_items: {
    #    order: {state: 'expired'}
    # }).
    order('id desc')

这是另一种方式：

class User < ActiveRecord::Base
  has_many :order_items, foreign_key: 'buyer_id'
  def videos_purchased
    Video.where(id: order_items.videos.confirmed.pluck(:id))
  end
end

class OrderItem < ActiveRecord::Base
  belongs_to :order, class_name: 'User', foreign_key: 'buyer_id'
  belongs_to :item, polymorphic: true
  scope :bought, -> {where.not(orders: {state: 'cancelled'})}
  scope :videos, -> {where(item_type: 'Video')}
end

class Video < ActiveRecord::Base
  has_many :order_items, ...

  scope :confirmed, -> {where(orders: {state: 'confirmed'})}
end

...
user = User.first()
user.videos_purchased

在涉及表和属性名称时，我可能会有一点语法上的麻烦，但这应该是一个开始。

请注意，我将其从一个查询更改为两个查询。我建议您运行它，直到您真正注意到性能问题为止，即使这样，与尝试优化复杂的联接逻辑相比，缓存查询也可能更容易。

Rails与扩展的多对多关系会生成错误的SQL

1 个答案: