ActiveRecord Query Union

Tôi đã viết một vài truy vấn phức tạp (ít nhất là với tôi) với giao diện truy vấn của Ruby on Rail:

watched_news_posts = Post.joins(:news => :watched).where(:watched => {:user_id => id})
watched_topic_posts = Post.joins(:post_topic_relationships => {:topic => :watched}).where(:watched => {:user_id => id})

Cả hai truy vấn này đều hoạt động tốt. Cả hai đều trả về đối tượng Đăng. Tôi muốn kết hợp các bài đăng này thành một ActiveRelation duy nhất. Vì có thể có hàng trăm nghìn bài đăng vào một thời điểm nào đó, điều này cần được thực hiện ở cấp cơ sở dữ liệu. Nếu đó là một truy vấn MySQL, tôi chỉ cần sử dụng UNIONtoán tử. Có ai biết liệu tôi có thể làm điều gì đó tương tự với giao diện truy vấn của RoR không?

Đây là một mô-đun nhỏ nhanh chóng mà tôi đã viết cho phép bạn UNION nhiều phạm vi. Nó cũng trả về kết quả dưới dạng một thể hiện của ActiveRecord :: Relation.

module ActiveRecord::UnionScope
  def self.included(base)
    base.send :extend, ClassMethods
  end

  module ClassMethods
    def union_scope(*scopes)
      id_column = "#{table_name}.id"
      sub_query = scopes.map { |s| s.select(id_column).to_sql }.join(" UNION ")
      where "#{id_column} IN (#{sub_query})"
    end
  end
end

Đây là ý chính: https://gist.github.com/tlowrimore/5162327

Biên tập:

Theo yêu cầu, đây là một ví dụ về cách UnionScope hoạt động:

class Property < ActiveRecord::Base
  include ActiveRecord::UnionScope

  # some silly, contrived scopes
  scope :active_nearby,     -> { where(active: true).where('distance <= 25') }
  scope :inactive_distant,  -> { where(active: false).where('distance >= 200') }

  # A union of the aforementioned scopes
  scope :active_near_and_inactive_distant, -> { union_scope(active_nearby, inactive_distant) }
end

Tôi cũng đã gặp sự cố này và bây giờ chiến lược đi tới của tôi là tạo SQL (bằng tay hoặc sử dụng to_sqltrên phạm vi hiện có) và sau đó gắn nó vào frommệnh đề. Tôi không thể đảm bảo rằng nó hiệu quả hơn bất kỳ phương pháp nào được chấp nhận của bạn, nhưng nó tương đối dễ nhìn và trả lại cho bạn một đối tượng ARel bình thường.

watched_news_posts = Post.joins(:news => :watched).where(:watched => {:user_id => id})
watched_topic_posts = Post.joins(:post_topic_relationships => {:topic => :watched}).where(:watched => {:user_id => id})

Post.from("(#{watched_news_posts.to_sql} UNION #{watched_topic_posts.to_sql}) AS posts")

Bạn cũng có thể làm điều này với hai mô hình khác nhau, nhưng bạn cần đảm bảo cả hai đều "trông giống nhau" bên trong UNION - bạn có thể sử dụng selecttrên cả hai truy vấn để đảm bảo chúng sẽ tạo ra các cột giống nhau.

topics = Topic.select('user_id AS author_id, description AS body, created_at')
comments = Comment.select('author_id, body, created_at')

Comment.from("(#{comments.to_sql} UNION #{topics.to_sql}) AS comments")

Dựa trên câu trả lời của Olives, tôi đã đưa ra một giải pháp khác cho vấn đề này. Nó có cảm giác hơi giống một vụ hack, nhưng nó trả về một ví dụ của ActiveRelation, đó là những gì tôi đã theo đuổi ngay từ đầu.

Post.where('posts.id IN 
      (
        SELECT post_topic_relationships.post_id FROM post_topic_relationships
          INNER JOIN "watched" ON "watched"."watched_item_id" = "post_topic_relationships"."topic_id" AND "watched"."watched_item_type" = "Topic" WHERE "watched"."user_id" = ?
      )
      OR posts.id IN
      (
        SELECT "posts"."id" FROM "posts" INNER JOIN "news" ON "news"."id" = "posts"."news_id" 
        INNER JOIN "watched" ON "watched"."watched_item_id" = "news"."id" AND "watched"."watched_item_type" = "News" WHERE "watched"."user_id" = ?
      )', id, id)

Tôi vẫn đánh giá cao nếu ai đó có bất kỳ đề xuất nào để tối ưu hóa điều này hoặc cải thiện hiệu suất, vì về cơ bản nó đang thực hiện ba truy vấn và cảm thấy hơi thừa.

Bạn cũng có thể sử dụng đá quý active_record_union của Brian Hempel mở rộng với một phương thức cho phạm vi.ActiveRecordunion

Truy vấn của bạn sẽ như thế này:

Post.joins(:news => :watched).
  where(:watched => {:user_id => id}).
  union(Post.joins(:post_topic_relationships => {:topic => :watched}
    .where(:watched => {:user_id => id}))

Hy vọng rằng điều này cuối cùng sẽ được hợp nhất vào ActiveRecordmột ngày nào đó.

Làm thế nào về...

def union(scope1, scope2)
  ids = scope1.pluck(:id) + scope2.pluck(:id)
  where(id: ids.uniq)
end

Bạn có thể sử dụng OR thay vì UNION không?

Sau đó, bạn có thể làm điều gì đó như:

Post.joins(:news => :watched, :post_topic_relationships => {:topic => :watched})
.where("watched.user_id = :id OR topic_watched.user_id = :id", :id => id)

(Vì bạn tham gia bảng đã xem hai lần nên tôi không chắc tên của các bảng sẽ là gì cho truy vấn)

Vì có rất nhiều liên kết, nó cũng có thể khá nặng trên cơ sở dữ liệu, nhưng nó có thể được tối ưu hóa.

Có thể cho rằng, điều này cải thiện khả năng đọc, nhưng không nhất thiết là hiệu suất:

def my_posts
  Post.where <<-SQL, self.id, self.id
    posts.id IN 
    (SELECT post_topic_relationships.post_id FROM post_topic_relationships
    INNER JOIN watched ON watched.watched_item_id = post_topic_relationships.topic_id 
    AND watched.watched_item_type = "Topic" 
    AND watched.user_id = ?
    UNION
    SELECT posts.id FROM posts 
    INNER JOIN news ON news.id = posts.news_id 
    INNER JOIN watched ON watched.watched_item_id = news.id 
    AND watched.watched_item_type = "News" 
    AND watched.user_id = ?)
  SQL
end

Phương thức này trả về một ActiveRecord :: Relation, vì vậy bạn có thể gọi nó như sau:

my_posts.order("watched_item_type, post.id DESC")

Có một viên ngọc active_record_union. Có thể hữu ích

https://github.com/brianhempel/active_record_union

Với ActiveRecordUnion, chúng ta có thể làm:

bài đăng (bản nháp) của người dùng hiện tại và tất cả các bài đăng đã xuất bản từ bất kỳ ai current_user.posts.union(Post.published) Tương đương với SQL sau:

SELECT "posts".* FROM (
  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 1
  UNION
  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:04:21.918366')
) posts

Tôi sẽ chỉ chạy hai truy vấn bạn cần và kết hợp các mảng bản ghi được trả về:

@posts = watched_news_posts + watched_topics_posts

Hoặc, ít nhất là kiểm tra nó ra. Bạn có nghĩ rằng sự kết hợp mảng trong ruby ​​sẽ quá chậm? Nhìn vào các truy vấn được đề xuất để giải quyết vấn đề, tôi không tin rằng sẽ có sự khác biệt đáng kể về hiệu suất.

Trong một trường hợp tương tự, tôi đã tổng hợp hai mảng và sử dụng Kaminari:paginate_array(). Giải pháp rất tốt và hiệu quả. Tôi không thể sử dụng where(), vì tôi cần tính tổng hai kết quả khác nhau order()trên cùng một bảng.

Ít vấn đề hơn và dễ theo dõi hơn:

    def union_scope(*scopes)
      scopes[1..-1].inject(where(id: scopes.first)) { |all, scope| all.or(where(id: scope)) }
    end

Cuối cùng:

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson trả lời tốt, ngoại trừ trường hợp một số quan hệ trống rỗng. Tôi sẽ làm một cái gì đó như thế:

def union_2_relations(relation1,relation2)
sql = ""
if relation1.any? && relation2.any?
  sql = "(#{relation1.to_sql}) UNION (#{relation2.to_sql}) as #{relation1.klass.table_name}"
elsif relation1.any?
  sql = relation1.to_sql
elsif relation2.any?
  sql = relation2.to_sql
end
relation1.klass.from(sql)

kết thúc

Đây là cách tôi tham gia các truy vấn SQL bằng UNION trên ứng dụng ruby ​​on rails của riêng tôi.

Bạn có thể sử dụng thông tin bên dưới làm nguồn cảm hứng cho mã của riêng bạn.

class Preference < ApplicationRecord
  scope :for, ->(object) { where(preferenceable: object) }
end

Dưới đây là UNION nơi tôi đã tham gia các phạm vi cùng nhau.

  def zone_preferences
    zone = Zone.find params[:zone_id]
    zone_sql = Preference.for(zone).to_sql
    region_sql = Preference.for(zone.region).to_sql
    operator_sql = Preference.for(Operator.current).to_sql

    Preference.from("(#{zone_sql} UNION #{region_sql} UNION #{operator_sql}) AS preferences")
  end