Rechercher tous les enregistrements dont le nombre d'associations est supérieur à zéro

J'essaie de faire quelque chose que je pensais que ce serait simple mais qui ne semble pas l'être.

J'ai un modèle de projet qui a de nombreux postes vacants.

class Project < ActiveRecord::Base

  has_many :vacancies, :dependent => :destroy

end

Je souhaite obtenir tous les projets qui ont au moins 1 poste vacant. J'ai essayé quelque chose comme ça:

Project.joins(:vacancies).where('count(vacancies) > 0')

mais ça dit

SQLite3::SQLException: no such column: vacancies: SELECT "projects".* FROM "projects" INNER JOIN "vacancies" ON "vacancies"."project_id" = "projects"."id" WHERE ("projects"."deleted_at" IS NULL) AND (count(vacancies) > 0).

joinsutilise une jointure interne par défaut, donc l'utilisation Project.joins(:vacancies)ne retournera en fait que les projets qui ont un poste vacant associé.

METTRE À JOUR:

Comme indiqué par @mackskatz dans le commentaire, sans groupclause, le code ci-dessus renverra les projets en double pour les projets avec plus d'un poste vacant. Pour supprimer les doublons, utilisez

Project.joins(:vacancies).group('projects.id')

METTRE À JOUR:

Comme indiqué par @Tolsee, vous pouvez également utiliser distinct.

Project.joins(:vacancies).distinct

Par exemple

[10] pry(main)> Comment.distinct.pluck :article_id
=> [43, 34, 45, 55, 17, 19, 1, 3, 4, 18, 44, 5, 13, 22, 16, 6, 53]
[11] pry(main)> _.size
=> 17
[12] pry(main)> Article.joins(:comments).size
=> 45
[13] pry(main)> Article.joins(:comments).distinct.size
=> 17
[14] pry(main)> Article.joins(:comments).distinct.to_sql
=> "SELECT DISTINCT \"articles\".* FROM \"articles\" INNER JOIN \"comments\" ON \"comments\".\"article_id\" = \"articles\".\"id\""

1) Pour obtenir des projets avec au moins 1 poste vacant:

Project.joins(:vacancies).group('projects.id')

2) Pour obtenir des projets avec plus d'un poste vacant:

Project.joins(:vacancies).group('projects.id').having('count(project_id) > 1')

3) Ou, si le Vacancymodèle définit le cache du compteur:

belongs_to :project, counter_cache: true

alors cela fonctionnera aussi:

Project.where('vacancies_count > ?', 1)

La règle d'inflexion pour vacancypeut devoir être spécifiée manuellement ?

Ouais, ce vacanciesn'est pas un champ dans la jointure. Je crois que tu veux:

Project.joins(:vacancies).group("projects.id").having("count(vacancies.id)>0")

# None
Project.joins(:vacancies).group('projects.id').having('count(vacancies) = 0')
# Any
Project.joins(:vacancies).group('projects.id').having('count(vacancies) > 0')
# One
Project.joins(:vacancies).group('projects.id').having('count(vacancies) = 1')
# More than 1
Project.joins(:vacancies).group('projects.id').having('count(vacancies) > 1')

Effectuer une jointure interne à la table has_many combinée avec un groupou uniqest potentiellement très inefficace, et en SQL, cela serait mieux implémenté comme une semi-jointure qui utilise EXISTSune sous-requête corrélée.

Cela permet à l'optimiseur de requêtes de sonder la table des postes vacants pour vérifier l'existence d'une ligne avec le project_id correct. Peu importe qu'il y ait une ligne ou un million qui aient cet id_projet.

Ce n'est pas aussi simple dans Rails, mais peut être réalisé avec:

Project.where(Vacancies.where("vacancies.project_id = projects.id").exists)

De même, recherchez tous les projets qui n'ont pas de poste vacant:

Project.where.not(Vacancies.where("vacancies.project_id = projects.id").exists)

Edit: dans les versions récentes de Rails, vous recevez un avertissement d'obsolescence vous indiquant de ne pas compter sur la existsdélégation à arel. Corrigez cela avec:

Project.where.not(Vacancies.where("vacancies.project_id = projects.id").arel.exists)

Edit: si vous n'êtes pas à l'aise avec le SQL brut, essayez:

Project.where.not(Vacancies.where(Vacancy.arel_table[:project_id].eq(Project.arel_table[:id])).arel.exists)

Vous pouvez rendre cela moins compliqué en ajoutant des méthodes de classe pour masquer l'utilisation de arel_table, par exemple:

class Project
  def self.id_column
    arel_table[:id]
  end
end

... alors ...

Project.where.not(
  Vacancies.where(
    Vacancy.project_id_column.eq(Project.id_column)
  ).arel.exists
)

Dans Rails 4+, vous pouvez également utiliser includes ou eager_load pour obtenir la même réponse:

Project.includes(:vacancies).references(:vacancies).
        where.not(vacancies: {id: nil})

Project.eager_load(:vacancies).where.not(vacancies: {id: nil})

Je pense qu'il existe une solution plus simple:

Project.joins(:vacancies).distinct

Sans beaucoup de magie Rails, vous pouvez faire:

Project.where('(SELECT COUNT(*) FROM vacancies WHERE vacancies.project_id = projects.id) > 0')

Ce type de conditions fonctionnera dans toutes les versions de Rails car une grande partie du travail est effectuée directement du côté DB. De plus, la .countméthode de chaînage fonctionnera bien aussi. J'ai été brûlé par des requêtes comme Project.joins(:vacancies)avant. Bien sûr, il y a des avantages et des inconvénients car ce n'est pas indépendant de DB.

Vous pouvez également utiliser EXISTSavec SELECT 1plutôt que de sélectionner toutes les colonnes du vacanciestableau:

Project.where("EXISTS(SELECT 1 from vacancies where projects.id = vacancies.project_id)")

L'erreur vous dit que les postes vacants ne sont pas essentiellement une rubrique dans les projets.

Cela devrait fonctionner

Project.joins(:vacancies).where('COUNT(vacancies.project_id) > 0')