Intersection de deux relations

Dire que j'ai deux relations qui détiennent des dossiers dans le même modèle, tels que:

@companies1 = Company.where(...)
@companies2 = Company.where(...)

Comment puis-je trouver l'intersection de ces deux relations, c'est à dire uniquement les entreprises qui existent à l'intérieur de deux à la fois?

Semble que vous ne voulez pas sql ici. Vous pouvez utiliser la matrice d'intersection de la méthode: ruby-doc.org/core/classes/Array.html#M000274

OriginalL'auteur sscirrus | 2011-06-22

12

Par défaut de la connexion de ces where ensemble crée ET qui est ce que vous voulez.

Donc nombreux:
```
class Company < ActiveRecord::Base
  def self.where_1
    where(...)
  end
  def self.where_2
    where(...)
  end
end

@companies = Company.where_1.where_2
```
====== Mise à JOUR ======

Il y a deux cas:
```
# case 1: the fields selecting are different
Company.where(:id => [1, 2, 3, 4]) & Company.where(:other_field => true)
# a-rel supports &, |, +, -, but please notice case 2

# case 2
Company.where(:id => [1, 2, 3]) & Company.where(:id => [1, 2, 4, 5])

# the result would be the same as
Company.where(:id => [1, 2, 4, 5])
# because it is &-ing the :id key, instead of the content inside :id key
```
Donc, si vous êtes dans le cas 2, vous aurez besoin de faire comme ce @apneadiving commenté.
```
Company.where(...).all & Company.where(...).all
```
Bien sûr, cela envoie deux requêtes et les plus susceptibles interrogé plus de résultats que vous avez besoin.

Peter, supposons que ces relations sont arrivés à travers différents moyens qui ne sont pas incluent where. Est-il un moyen manuel pour calculer cette intersection?
Mise à jour de la réponse, veuillez jeter un oeil.
N'est-ce pas retourner un tableau? Comment puis-je la faire revenir ActiveRecord de Ressources?
le & symbole ne fonctionne pas
Je l'ai juste essayé avec le & symbole et il a travaillé pour moi.

OriginalL'auteur PeterWong
5

Utiliser le mot clé sql se CROISENT.
```
params1 = [1,2,4]
params2 = [1,3,4]
query = "
SELECT companies.* FROM companies
WHERE id in (?,?,?)
INTERSECT
SELECT companies.* FROM companies
WHERE id in (?,?,?)
"
Company.find_by_sql([query, *params1, *params2])
```
il sera plus rapide que la précédente solution.

Merci pour votre réponse! Ce qui se passe si params1 et params2 sont à la fois des tableaux de indetermine longueur?
1. Vous pouvez modifier l'emplacement de la condition, si vous trouver pas par id à propos. 2. Quelque chose comme: "...where id IN (#{params1.carte{'?'}.join(',')})..."
J'ai trouvé que #{Array.new(params1.size, '?').join(',')} est plus rapide. Mais il n'est pas si important dans ce cas.

OriginalL'auteur Michael
4

- Je résoudre le même problème de cette façon
```
Company.connection.unprepared_statement do
  Company.find_by_sql "#{@companies1.to_sql} INTERSECT #{@companies2.to_sql}"
end
```
Nous avons besoin de unprepared_statement bloc ici car le dernier Rails utilisent des versions préparées pour accélérer arel requêtes, mais nous avons besoin de la pure SQL en place.

OriginalL'auteur MikDiet
1

Vous pouvez utiliser ActiveRecord::SpawnMethods#fusion

Exemple:
```
Company.where(condition: 'value').merge(Company.where(other_condition: 'value'))
```
Il ajoute juste une condition where. Ses pas d'alternative pour se CROISENT

OriginalL'auteur KARASZI István

Pour quelqu'un qui est coincé avec Rails4 et ne peux utiliser Rails5 .ou la syntaxe:

J'avais dynamiquement, un certain nombre de requêtes, qui avaient les mêmes conditions ( et donc aussi des résultats similaires). Mon rake serveur ont des problèmes quand toutes à la fois, serait d'obtenir instancié, convertis à des tableaux et ensuite fusionné.

J'avais besoin d'un ActiveRecord::Rapport (pas tiré encore) à utiliser avec find_each.

Cherché quelque chose comme ceci:

Class Conditions
  def initialize
    self.where_arr = []
    self.joins_arr = []
  end

  def my_condition1
    where_arr << 'customers.status = "active"'
    joins_arr << :customer
  end

  def my_condition2
    where_arr << 'companies.id = 1'
  end
end

conditions = []    
joins = []
# probably call them in a .each block with .send
conditions1 = Conditions.new
conditions1.my_condition1
conditions1.my_condition2
conditions << "(#{conditions1.where_arr.join(' AND ')})"
joins << conditions1.joins_arr

conditions2 = Conditions.new
conditions2.my_condition1
joins << conditions2.joins_arr

Company.joins(joins).where(conditions.join(' OR '))

=> SELECT companies.* FROM companies 
INNER JOIN customers ON companies.customer_id = customers.id 
WHERE (customers.status = 'active' AND companies.id = 1) OR
(customers.status = 'active')

Genre de hacky mais il fonctionne, jusqu'à ce que vous pouvez espérer de migrer vers les Rails 5

OriginalL'auteur lennart_dev

Vous devez vous connecter pour publier un commentaire.