Союз запитів ActiveRecord

Я написав кілька складних запитів (принаймні для мене) за допомогою інтерфейсу запитів 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})

Обидва ці запити працюють самі по собі. Обидва повертають об'єкти Post. Я хотів би об’єднати ці повідомлення в єдину ActiveRelation. Оскільки в якийсь момент може бути сотні тисяч повідомлень, це потрібно робити на рівні бази даних. Якби це був запит MySQL, я міг би просто користуватися UNIONоператором. Хтось знає, чи можу я зробити щось подібне з інтерфейсом запитів RoR?

Ось короткий маленький модуль, який я написав, що дозволяє об’єднати кілька областей. Він також повертає результати як екземпляр 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

Ось суть: https://gist.github.com/tlowrimore/5162327

Редагувати:

За запитом, ось приклад того, як працює 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

Я також зіткнувся з цією проблемою, і зараз моєю стратегією є створення SQL (вручну або за to_sqlдопомогою існуючої області), а потім вставити його в fromпункт. Я не можу гарантувати, що він є більш ефективним, ніж ваш прийнятий метод, але це відносно легко для очей і повертає вам звичайний об'єкт 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")

Ви можете зробити це з двома різними моделями, але вам потрібно переконатися, що вони обидва "виглядають однаково" всередині UNION - ви можете використовувати selectобидва запити, щоб переконатися, що вони будуть створювати однакові стовпці.

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

Спираючись на відповідь Оліви, я дійсно придумав інше рішення цієї проблеми. Це трохи схоже на хакерство, але воно повертає екземпляр ActiveRelation, що я спочатку й шукав.

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)

Я все одно був би вдячний, якщо хтось має якісь пропозиції щодо оптимізації цього чи покращення продуктивності, оскільки він, по суті, виконує три запити і відчуває себе трохи зайвим.

Ви можете також використовувати Brian Hempel «s active_record_union дорогоцінний камінь , який проходить ActiveRecordз unionметодом для областей.

Ваш запит буде таким:

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

Сподіваємось, це з часом буде об’єднано в ActiveRecordякийсь день.

Як на рахунок...

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

Чи не могли б ви використати АБО замість СОЮЗУ?

Тоді ви можете зробити щось на зразок:

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

(Оскільки ви приєднуєтеся до переглянутої таблиці двічі, я не надто впевнений, якими будуть назви таблиць для запиту)

Оскільки об’єднань багато, це може також бути досить важким для бази даних, але його можна буде оптимізувати.

Можливо, це покращує читабельність, але не обов'язково продуктивність:

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

Цей метод повертає ActiveRecord :: Relation, тому ви можете назвати його так:

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

Існує камінь active_record_union. Може бути корисним

https://github.com/brianhempel/active_record_union

За допомогою ActiveRecordUnion ми можемо:

поточні повідомлення користувача (чернетка) та всі опубліковані повідомлення від кого-небудь, current_user.posts.union(Post.published) що еквівалентно наступному 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

Я б просто виконав два необхідні запити та об’єднав масиви записів, які повертаються:

@posts = watched_news_posts + watched_topics_posts

Або, принаймні, протестуйте це. Думаєте, комбінація масивів у рубіні буде занадто повільною? Переглядаючи запропоновані запити, щоб обійти проблему, я не впевнений, що буде така суттєва різниця в продуктивності.

У подібному випадку я підсумував два масиви та використав Kaminari:paginate_array(). Дуже приємне та робоче рішення. Я не зміг використати where(), оскільки мені потрібно підсумувати два результати з різними order()в одній таблиці.

Менше проблем і легше виконувати:

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

Отже, врешті-решт:

union_scope(watched_news_posts, watched_topic_posts)

Елліот Нельсон відповів добре, за винятком випадку, коли деякі стосунки порожні. Я б зробив щось подібне:

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)

кінець

Ось як я приєднався до запитів SQL за допомогою UNION на власному додатку ruby ​​on rails.

Ви можете використати наведене нижче як натхнення для власного коду.

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

Нижче СОЮЗ, де я приєднався до сфери діяльності.

  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