ActiveRecord Requête Union

Voici un petit module que j'ai écrit qui permet à l'UNION de plusieurs étendues. Il renvoie également les résultats d'une instance 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

Voici l'essentiel: https://gist.github.com/tlowrimore/5162327

Edit:

Comme demandé, voici un exemple de la façon dont UnionScope travaux:

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

Basé sur les Olives de réponse, je n'ai trouvé d'autre solution à ce problème. Il se sent un peu comme un hack, mais elle renvoie une instance de ActiveRelation, qui est ce que je recherchais en premier lieu.

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)

Je serais toujours reconnaissant si quelqu'un a des suggestions pour optimiser ce ou d'améliorer les performances, parce que c'est essentiellement l'exécution de trois requêtes et se sent un peu redondant.

Vous pouvez également utiliser Brian Hempel's active_record_union joyau qui s'étend ActiveRecord avec un union méthode pour les étendues.

Votre requête serait comme ceci:

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

J'espère que ce sera finalement fusionné ActiveRecord un jour.

Sans doute, ce qui améliore la lisibilité, mais pas nécessairement de la performance:

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

Cette méthode retourne un ActiveRecord::Relation, de sorte que vous pouvez l'appeler comme ceci:

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

Je voudrais juste exécuter deux requêtes dont vous avez besoin et combiner les tableaux d'enregistrements sont renvoyés:

@posts = watched_news_posts + watched_topics_posts

Ou, à tout le moins de le tester. Pensez-vous que le tableau de combinaison en ruby sera beaucoup trop lent? En regardant les requêtes suggérées pour contourner le problème, je ne suis pas convaincu qu'il y va y avoir beaucoup de différence en termes de performances.

Elliot Nelson répondu bon, sauf le cas où les relations sont vides. Je voudrais faire quelque chose comme ça:

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)

fin

Moins de problèmes et plus facile à suivre:

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

Donc en fin de compte:

union_scope(watched_news_posts, watched_topic_posts)