ActiveRecord Sorgu Birliği

Ruby on Rail'in sorgu arayüzüyle birkaç karmaşık sorgu (en azından benim için) yazdım:

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

Bu sorguların ikisi de kendi başlarına iyi çalışıyor. Her ikisi de Post nesnelerini döndürür. Bu gönderileri tek bir ActiveRelation'da birleştirmek istiyorum. Bir noktada yüz binlerce gönderi olabileceğinden, bunun veritabanı düzeyinde yapılması gerekir. Bir MySQL sorgusu olsaydı, UNIONoperatörü basitçe kullanabilirdim . RoR'un sorgu arayüzüne benzer bir şey yapıp yapamayacağımı bilen var mı?

İşte yazdığım, çoklu kapsamları BİRLEŞTİRMENİZE izin veren küçük bir modül. Ayrıca sonuçları bir ActiveRecord :: Relation örneği olarak döndürür.

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

İşin özü: https://gist.github.com/tlowrimore/5162327

Düzenle:

İstendiği gibi, UnionScope'un nasıl çalıştığına dair bir örnek:

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

Ben de bu sorunla karşılaştım ve şimdi stratejim SQL oluşturmak (elle veya to_sqlmevcut bir kapsamda kullanarak ) ve sonra onu tümceye yapıştırmak from. Kabul ettiğiniz yöntemden daha verimli olduğunu garanti edemem, ancak gözler için nispeten kolaydır ve size normal bir ARel nesnesini geri verir.

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

Bunu iki farklı modelle de yapabilirsiniz, ancak her ikisinin de UNION içinde "aynı göründüğünden" emin olmanız gerekir - selectaynı sütunları üreteceklerinden emin olmak için her iki sorguda da kullanabilirsiniz .

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

Zeytin'in cevabına dayanarak, bu soruna başka bir çözüm buldum. Biraz hack gibi geliyor, ama bir örnek ActiveRelationveriyor, ilk başta peşinde olduğum şey buydu.

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)

Bunu optimize etmek veya performansı artırmak için herhangi bir önerisi olan olursa yine de memnun olurum, çünkü bu aslında üç sorgu yürütüyor ve biraz gereksiz hissediyor.

Ayrıca kullanabilirsiniz Brian Hempel 'ın active_record_union uzanan mücevher ActiveRecordbir ile unionkapsamları için yöntemiyle.

Sorgunuz şöyle olacaktır:

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

Umarım bu eninde sonunda ActiveRecordbir gün içinde birleştirilecektir .

Peki ya ...

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

UNION yerine OR kullanabilir misiniz?

O zaman şöyle bir şey yapabilirsiniz:

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

(İzlenen tabloya iki kez katıldığınız için, sorgu için tabloların adlarının ne olacağından pek emin değilim)

Çok sayıda birleştirme olduğu için, veritabanında oldukça ağır olabilir, ancak optimize edilebilir.

Muhtemelen, bu okunabilirliği artırır, ancak performansı mutlaka artırmaz:

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

Bu yöntem bir ActiveRecord :: Relation döndürür, böylece onu şöyle çağırabilirsiniz:

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

Bir active_record_union mücevher var. Yardımcı olabilir

https://github.com/brianhempel/active_record_union

ActiveRecordUnion ile şunları yapabiliriz:

mevcut kullanıcının (taslak) gönderileri ve current_user.posts.union(Post.published) aşağıdaki SQL ile eşdeğer olan herkes tarafından yayınlanan tüm yayınlar :

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

İhtiyacınız olan iki sorguyu çalıştırır ve döndürülen kayıt dizilerini birleştiririm:

@posts = watched_news_posts + watched_topics_posts

Ya da en azından test edin. Ruby'deki dizi kombinasyonunun çok yavaş olacağını düşünüyor musunuz? Sorunun üstesinden gelmek için önerilen sorgulara baktığımda, önemli bir performans farkı olacağına ikna olmadım.

Benzer bir durumda iki diziyi topladım ve kullandım Kaminari:paginate_array(). Çok güzel ve çalışan bir çözüm. Kullanamadım where()çünkü order()aynı tabloda iki sonucu farklı olan iki sonucu toplamam gerekiyor .

Daha az sorun ve takip etmesi daha kolay:

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

Yani sonunda:

union_scope(watched_news_posts, watched_topic_posts)

Elliot Nelson, bazı ilişkilerin boş olduğu durum dışında iyi cevap verdi. Böyle bir şey yapardım:

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)

son

Kendi ruby ​​on rails uygulamamda UNION kullanarak SQL sorgularına nasıl katıldım.

Aşağıdakileri kendi kodunuz için ilham kaynağı olarak kullanabilirsiniz.

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

Kapsamlara birlikte katıldığım UNION aşağıdadır.

  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