ActiveRecord Query Union

Ich habe einige komplexe Abfragen (zumindest für mich) mit der Abfrageoberfläche von Ruby on Rail geschrieben:

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

Beide Abfragen funktionieren für sich. Beide geben Post-Objekte zurück. Ich möchte diese Beiträge in einer einzigen ActiveRelation kombinieren. Da es irgendwann Hunderttausende von Posts geben kann, muss dies auf Datenbankebene erfolgen. Wenn es eine MySQL-Abfrage wäre, könnte ich einfach den UNIONOperator verwenden. Weiß jemand, ob ich mit der Abfrageschnittstelle von RoR etwas Ähnliches tun kann?

Hier ist ein kurzes kleines Modul, das ich geschrieben habe und mit dem Sie mehrere Bereiche mit UNION verbinden können. Die Ergebnisse werden auch als Instanz von ActiveRecord :: Relation zurückgegeben.

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

Hier ist das Wesentliche: https://gist.github.com/tlowrimore/5162327

Bearbeiten:

Hier ist ein Beispiel für die Funktionsweise von 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

Ich bin auch auf dieses Problem gestoßen, und jetzt besteht meine Strategie darin, SQL (von Hand oder to_sqlin einem vorhandenen Bereich) zu generieren und es dann in die fromKlausel einzufügen. Ich kann nicht garantieren, dass es effizienter ist als Ihre akzeptierte Methode, aber es ist relativ augenschonend und gibt Ihnen ein normales ARel-Objekt zurück.

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

Sie können dies auch mit zwei verschiedenen Modellen tun, aber Sie müssen sicherstellen, dass beide innerhalb der UNION "gleich aussehen". Sie können selectbeide Abfragen verwenden, um sicherzustellen, dass sie dieselben Spalten erzeugen.

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

Basierend auf der Antwort von Olives habe ich eine andere Lösung für dieses Problem gefunden. Es fühlt sich ein bisschen wie ein Hack an, aber es gibt eine Instanz von zurück ActiveRelation, nach der ich überhaupt gesucht habe.

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)

Ich würde es immer noch begrüßen, wenn jemand Vorschläge hat, dies zu optimieren oder die Leistung zu verbessern, da es im Wesentlichen drei Abfragen ausführt und sich etwas überflüssig anfühlt.

Sie können auch verwenden , Brian Hempel ‚s active_record_union Juwel , das sich ActiveRecordmit einem unionfür Tive Verfahren.

Ihre Anfrage würde so aussehen:

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

Hoffentlich wird dies irgendwann in ActiveRecordeinem Tag zusammengeführt.

Wie wäre es mit...

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

Könnten Sie ein ODER anstelle einer UNION verwenden?

Dann könnten Sie so etwas tun wie:

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

(Da Sie zweimal der überwachten Tabelle beitreten, bin ich mir nicht sicher, wie die Namen der Tabellen für die Abfrage lauten werden.)

Da es viele Verknüpfungen gibt, ist die Datenbank möglicherweise sehr stark belastet, kann jedoch optimiert werden.

Dies verbessert wohl die Lesbarkeit, aber nicht unbedingt die Leistung:

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

Diese Methode gibt eine ActiveRecord :: Relation zurück, sodass Sie sie folgendermaßen aufrufen können:

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

Es gibt ein Juwel aus active_record_union. Könnte hilfreich sein

https://github.com/brianhempel/active_record_union

Mit ActiveRecordUnion können wir Folgendes tun:

die (Entwurfs-) Beiträge des aktuellen Benutzers und alle veröffentlichten Beiträge von jedermann, current_user.posts.union(Post.published) was der folgenden SQL entspricht:

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

Ich würde nur die zwei Abfragen ausführen, die Sie benötigen, und die Arrays der zurückgegebenen Datensätze kombinieren:

@posts = watched_news_posts + watched_topics_posts

Oder zumindest testen. Denken Sie, dass die Array-Kombination in Ruby viel zu langsam sein wird? Wenn ich mir die vorgeschlagenen Fragen ansehe, um das Problem zu umgehen, bin ich nicht davon überzeugt, dass es einen so signifikanten Leistungsunterschied geben wird.

In einem ähnlichen Fall habe ich zwei Arrays summiert und verwendet Kaminari:paginate_array(). Sehr schöne und funktionierende Lösung. Ich konnte nicht verwenden where(), da ich zwei Ergebnisse mit unterschiedlichen Ergebnissen order()in derselben Tabelle summieren muss .

Weniger Probleme und leichter zu folgen:

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

Also am Ende:

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson antwortete gut, außer in dem Fall, in dem einige der Beziehungen leer sind. Ich würde so etwas tun:

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)

Ende

Hier ist, wie ich SQL-Abfragen mit UNION in meiner eigenen Ruby on Rails-Anwendung verbunden habe.

Sie können das Folgende als Inspiration für Ihren eigenen Code verwenden.

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

Unten ist die UNION, in der ich die Bereiche zusammengefügt habe.

  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