União de consulta ActiveRecord

Eu escrevi algumas consultas complexas (pelo menos para mim) com a interface de consulta do 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})

Ambas as consultas funcionam bem sozinhas. Ambos retornam objetos Post. Eu gostaria de combinar essas postagens em um único ActiveRelation. Como pode haver centenas de milhares de postagens em algum ponto, isso precisa ser feito no nível do banco de dados. Se fosse uma consulta MySQL, eu poderia simplesmente usar o UNIONoperador. Alguém sabe se posso fazer algo semelhante com a interface de consulta do RoR?

Aqui está um pequeno módulo rápido que escrevi que permite UNIONAR múltiplos escopos. Ele também retorna os resultados como uma instância de 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

Aqui está a essência: https://gist.github.com/tlowrimore/5162327

Editar:

Conforme solicitado, aqui está um exemplo de como funciona o 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

Eu também encontrei esse problema e agora minha estratégia inicial é gerar SQL (manualmente ou usando to_sqlem um escopo existente) e, em seguida, inseri-lo na fromcláusula. Não posso garantir que seja mais eficiente do que o método aceito, mas é relativamente fácil para os olhos e devolve um objeto ARel normal.

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

Você também pode fazer isso com dois modelos diferentes, mas precisa ter certeza de que ambos "têm a mesma aparência" dentro do UNION - você pode usar selectem ambas as consultas para ter certeza de que produzirão as mesmas colunas.

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

Com base na resposta do Olives, descobri outra solução para esse problema. Parece um pouco como um hack, mas retorna uma instância de ActiveRelation, que é o que eu estava procurando em primeiro lugar.

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)

Ainda agradeceria se alguém tivesse alguma sugestão para otimizar isso ou melhorar o desempenho, porque essencialmente está executando três consultas e parece um pouco redundante.

Você também pode usar Brian Hempel 's active_record_union gem que se estende ActiveRecordcom um unionmétodo para escopos.

Sua consulta seria assim:

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

Esperançosamente isso será eventualmente mesclado em ActiveRecordalgum dia.

E se...

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

Você poderia usar um OR em vez de um UNION?

Então você poderia fazer algo como:

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

(Como você se junta à tabela observada duas vezes, não tenho certeza de quais serão os nomes das tabelas para a consulta)

Como há muitas junções, também pode ser muito pesado no banco de dados, mas pode ser otimizado.

Indiscutivelmente, isso melhora a legibilidade, mas não necessariamente o desempenho:

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

Este método retorna um ActiveRecord :: Relation, então você pode chamá-lo assim:

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

Existe uma gem active_record_union. Pode ser útil

https://github.com/brianhempel/active_record_union

Com ActiveRecordUnion, podemos fazer:

as postagens (rascunho) do usuário atual e todas as postagens publicadas de qualquer pessoa, o current_user.posts.union(Post.published) que é equivalente ao seguinte 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

Gostaria apenas de executar as duas consultas de que você precisa e combinar as matrizes de registros que são retornados:

@posts = watched_news_posts + watched_topics_posts

Ou, pelo menos, faça um teste. Você acha que a combinação do array em ruby ​​será muito lenta? Olhando para as consultas sugeridas para contornar o problema, não estou convencido de que haverá uma diferença significativa de desempenho.

Em um caso semelhante, somei dois arrays e usei Kaminari:paginate_array(). Solução muito agradável e funcional. Não consegui usar where(), pois preciso somar dois resultados com diferentes order()na mesma tabela.

Menos problemas e mais fácil de seguir:

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

Então, no final:

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson respondeu bem, exceto no caso em que algumas das relações estão vazias. Eu faria algo assim:

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)

fim

Veja como juntei consultas SQL usando UNION em meu próprio aplicativo Ruby on Rails.

Você pode usar o seguinte como inspiração em seu próprio código.

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

Abaixo está a UNION onde juntei os escopos.

  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