ActiveRecord 쿼리 통합

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})

이 두 쿼리는 모두 잘 작동합니다. 둘 다 Post 객체를 반환합니다. 이 게시물을 단일 ActiveRelation으로 결합하고 싶습니다. 특정 시점에 수십만 개의 게시물이있을 수 있으므로 이는 데이터베이스 수준에서 수행되어야합니다. MySQL 쿼리라면 간단히 UNION연산자를 사용할 수 있습니다. RoR의 쿼리 인터페이스와 비슷한 작업을 수행 할 수 있는지 아는 사람이 있습니까?

다음은 여러 범위를 통합 할 수있는 간단한 모듈입니다. 또한 결과를 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

요점은 다음과 같습니다 : https://gist.github.com/tlowrimore/5162327

편집하다:

요청에 따라 다음은 UnionScope 작동 방식의 예입니다.

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

나는 또한이 문제에 직면했고 이제 나의 전략은 SQL을 생성하고 (수동으로 또는 to_sql기존 범위에서 사용) from절에 고정하는 것입니다 . 허용되는 방법보다 더 효율적이라고 보장 할 수는 없지만 비교적 눈에 띄고 일반 ARel 객체를 돌려줍니다.

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")

두 개의 다른 모델에서도이 작업을 수행 할 수 있지만 UNION 내에서 둘 다 "동일하게 보이는"지 확인해야합니다 select. 두 쿼리 모두에서 동일한 열을 생성하는지 확인할 수 있습니다.

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")

Olives의 대답을 바탕으로이 문제에 대한 또 다른 해결책을 찾았습니다. 약간 해킹처럼 느껴지지만 ActiveRelation처음에 내가 추구했던를 반환합니다 .

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)

기본적으로 세 개의 쿼리를 실행하고 약간 중복 된 느낌이 들기 때문에 누군가 이것을 최적화하거나 성능을 향상시킬 제안이 있다면 여전히 감사하겠습니다.

범위에 대한 메소드로 확장 되는 Brian Hempel 의 active_record_union gem을 사용할 수도 있습니다 .ActiveRecordunion

쿼리는 다음과 같습니다.

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

바라건대 이것은 결국 ActiveRecord언젠가 병합 될 것입니다.

어때 ...

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

UNION 대신 OR를 사용할 수 있습니까?

그런 다음 다음과 같이 할 수 있습니다.

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

(당신이 감시 된 테이블을 두 번 조인하기 때문에 쿼리에 대한 테이블 이름이 무엇인지 잘 모르겠습니다)

조인이 많기 때문에 데이터베이스에서 상당히 무겁지만 최적화 할 수 있습니다.

아마도 이것은 가독성을 향상 시키지만 반드시 성능을 향상시키는 것은 아닙니다.

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

이 메서드는 ActiveRecord :: Relation을 반환하므로 다음과 같이 호출 할 수 있습니다.

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

active_record_union gem이 있습니다. 도움이 될 수 있습니다

https://github.com/brianhempel/active_record_union

ActiveRecordUnion으로 다음을 수행 할 수 있습니다.

현재 사용자의 (초안) 게시물 및 모든 게시 된 게시물 current_user.posts.union(Post.published) 은 다음 SQL과 동일합니다.

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

필요한 두 쿼리를 실행하고 반환되는 레코드 배열을 결합합니다.

@posts = watched_news_posts + watched_topics_posts

또는 최소한 테스트 해보십시오. 루비의 배열 조합이 너무 느릴 것이라고 생각하십니까? 문제를 해결하기 위해 제안 된 쿼리를 살펴보면 성능 ​​차이가 크게 나타날 것이라고 확신하지 못합니다.

비슷한 경우에 두 개의 배열을 합산하고 Kaminari:paginate_array(). 매우 훌륭하고 작동하는 솔루션. 동일한 테이블에서 where()서로 다른 두 결과를 합산해야하므로을 사용할 수 없습니다 order().

문제가 적고 따르기 쉽습니다.

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

그래서 결국 :

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson은 일부 관계가 비어있는 경우를 제외하고는 좋은 대답을했습니다. 나는 다음과 같이 할 것입니다.

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)

종료

내 자신의 Ruby on Rails 애플리케이션에서 UNION을 사용하여 SQL 쿼리를 조인하는 방법은 다음과 같습니다.

아래 내용을 자신의 코드에 대한 영감으로 사용할 수 있습니다.

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

아래는 내가 스코프를 결합한 UNION입니다.

  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