ActiveRecord Query Union

Ho scritto un paio di query complesse (almeno a me) con Ruby sull'interfaccia di query di 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})

Entrambe queste query funzionano bene da sole. Entrambi restituiscono oggetti Post. Vorrei combinare questi post in un unico ActiveRelation. Poiché a un certo punto potrebbero esserci centinaia di migliaia di post, è necessario farlo a livello di database. Se fosse una query MySQL, potrei semplicemente utilizzare l' UNIONoperatore. Qualcuno sa se posso fare qualcosa di simile con l'interfaccia di query di RoR?

Ecco un piccolo modulo veloce che ho scritto che ti consente di UNION più ambiti. Restituisce inoltre i risultati come istanza di 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

Ecco il succo: https://gist.github.com/tlowrimore/5162327

Modificare:

Come richiesto, ecco un esempio di come funziona 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

Ho anche riscontrato questo problema e ora la mia strategia di riferimento è generare SQL (a mano o utilizzando to_sqlun ambito esistente) e quindi inserirlo nella fromclausola. Non posso garantire che sia più efficiente del tuo metodo accettato, ma è relativamente facile per gli occhi e ti restituisce un normale oggetto 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")

Puoi farlo anche con due modelli diversi, ma devi assicurarti che entrambi "abbiano lo stesso aspetto" all'interno di UNION - puoi usarli selectsu entrambe le query per assicurarti che producano le stesse colonne.

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

Sulla base della risposta di Olives, ho trovato un'altra soluzione a questo problema. Sembra un po 'un hack, ma restituisce un'istanza di ActiveRelation, che è quello che stavo cercando in primo luogo.

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)

Lo apprezzerei comunque se qualcuno avesse qualche suggerimento per ottimizzare questo o migliorare le prestazioni, perché essenzialmente sta eseguendo tre query e sembra un po 'ridondante.

Puoi anche usare la gemma active_record_union di Brian Hempel che si estende con un metodo per gli ambiti.ActiveRecordunion

La tua domanda sarebbe come questa:

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

Si spera che questo possa essere fuso in ActiveRecordun giorno.

Che ne dite di...

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

Potresti usare un OR invece di UNION?

Quindi potresti fare qualcosa come:

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

(Dal momento che ti unisci alla tabella osservata due volte, non sono sicuro di quali saranno i nomi delle tabelle per la query)

Poiché ci sono molti join, potrebbe anche essere piuttosto pesante sul database, ma potrebbe essere ottimizzato.

Probabilmente, questo migliora la leggibilità, ma non necessariamente le prestazioni:

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

Questo metodo restituisce un ActiveRecord :: Relation, quindi puoi chiamarlo in questo modo:

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

C'è una gemma active_record_union. Potrebbe essere utile

https://github.com/brianhempel/active_record_union

Con ActiveRecordUnion possiamo fare:

i post (bozza) dell'utente corrente e tutti i post pubblicati da chiunque Il current_user.posts.union(Post.published) che è equivalente al seguente 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

Vorrei solo eseguire le due query di cui hai bisogno e combinare gli array di record che vengono restituiti:

@posts = watched_news_posts + watched_topics_posts

O almeno provalo. Pensi che la combinazione di array in ruby ​​sarà troppo lenta? Guardando le query suggerite per aggirare il problema, non sono convinto che ci sarà una differenza di prestazioni così significativa.

In un caso simile ho sommato due array e ho usato Kaminari:paginate_array(). Soluzione molto bella e funzionante. Non sono stato in grado di utilizzare where(), perché ho bisogno di sommare due risultati con diversi order()sulla stessa tabella.

Meno problemi e più facile da seguire:

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

Quindi alla fine:

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson ha risposto bene, tranne il caso in cui alcune delle relazioni sono vuote. Farei qualcosa del genere:

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)

fine

Ecco come ho unito le query SQL usando UNION sulla mia applicazione ruby ​​on rails.

Puoi utilizzare quanto segue come ispirazione per il tuo codice.

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

Di seguito è riportata l'UNIONE in cui ho unito gli ambiti.

  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