Encuentre todos los registros que tengan un recuento de una asociación mayor que cero

Estoy tratando de hacer algo que pensé que sería simple, pero parece que no lo es.

Tengo un modelo de proyecto que tiene muchas vacantes.

class Project < ActiveRecord::Base

  has_many :vacancies, :dependent => :destroy

end

Quiero conseguir todos los proyectos que tengan al menos 1 vacante. Intenté algo como esto:

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

pero dice

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

joinsusa una combinación interna de forma predeterminada, por lo que el uso Project.joins(:vacancies)solo devolverá los proyectos que tengan una vacante asociada.

ACTUALIZAR:

Como señaló @mackskatz en el comentario, sin una groupcláusula, el código anterior devolverá proyectos duplicados para proyectos con más de una vacante. Para eliminar los duplicados, use

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

ACTUALIZAR:

Como lo señaló @Tolsee, también puede usar distinct.

Project.joins(:vacancies).distinct

Como ejemplo

[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) Para conseguir proyectos con al menos 1 vacante:

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

2) Para obtener proyectos con más de 1 vacante:

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

3) O, si el Vacancymodelo establece la caché del contador:

belongs_to :project, counter_cache: true

entonces esto también funcionará:

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

¿Es vacancyposible que sea necesario especificar manualmente la regla de inflexión para ?

Sí, vacanciesno es un campo en la combinación. Creo que quieres:

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

Realizar una unión interna a la tabla has_many combinada con un groupo uniqes potencialmente muy ineficiente, y en SQL esto se implementaría mejor como una semi-unión que se usa EXISTScon una subconsulta correlacionada.

Esto permite al optimizador de consultas sondear la tabla de vacantes para verificar la existencia de una fila con el project_id correcto. No importa si hay una fila o un millón que tienen ese project_id.

Eso no es tan sencillo en Rails, pero se puede lograr con:

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

Del mismo modo, busque todos los proyectos que no tengan vacantes:

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

Editar: en las versiones recientes de Rails, recibe una advertencia de desaprobación que le indica que no dependa de existsser delegado a arel. Arregle esto con:

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

Editar: si no se siente cómodo con SQL sin formato, intente:

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

Puede hacer que esto sea menos complicado agregando métodos de clase para ocultar el uso de arel_table, por ejemplo:

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

... entonces ...

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

En Rails 4+, también puedes usar includes o eager_load para obtener la misma respuesta:

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

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

Creo que hay una solución más sencilla:

Project.joins(:vacancies).distinct

Sin mucha magia de Rails, puedes hacer:

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

Este tipo de condiciones funcionará en todas las versiones de Rails ya que gran parte del trabajo se realiza directamente en el lado de la base de datos. Además, el .countmétodo de encadenamiento también funcionará bien. Me han quemado consultas como Project.joins(:vacancies)antes. Por supuesto, existen pros y contras, ya que no es independiente de DB.

También puede usar EXISTScon en SELECT 1lugar de seleccionar todas las columnas de la vacanciestabla:

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

El error es decirte que las vacantes no es una columna en los proyectos, básicamente.

Esto debería funcionar

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