Suchen Sie alle Datensätze, deren Zuordnung größer als Null ist

Ich versuche etwas zu tun, von dem ich dachte, es wäre einfach, aber es scheint nicht so zu sein.

Ich habe ein Projektmodell mit vielen offenen Stellen.

class Project < ActiveRecord::Base

  has_many :vacancies, :dependent => :destroy

end

Ich möchte alle Projekte bekommen, die mindestens 1 freie Stelle haben. Ich habe so etwas versucht:

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

aber es heißt

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

joinsVerwendet standardmäßig einen inneren Join, sodass bei Verwendung Project.joins(:vacancies)nur Projekte zurückgegeben werden, denen eine freie Stelle zugeordnet ist.

AKTUALISIEREN:

Wie von @mackskatz im Kommentar ausgeführt, groupgibt der obige Code ohne Klausel doppelte Projekte für Projekte mit mehr als einer offenen Stelle zurück. Verwenden Sie zum Entfernen der Duplikate

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

AKTUALISIEREN:

Wie von @Tolsee hervorgehoben, können Sie auch verwenden distinct.

Project.joins(:vacancies).distinct

Als Beispiel

[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) Um Projekte mit mindestens 1 offenen Stelle zu erhalten:

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

2) Um Projekte mit mehr als einer offenen Stelle zu erhalten:

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

3) Oder wenn das VacancyModell den Zähler-Cache setzt:

belongs_to :project, counter_cache: true

dann funktioniert das auch:

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

Die Flexionsregel für muss vacancymöglicherweise manuell angegeben werden .

Ja, vacanciesist kein Feld im Join. Ich glaube du willst:

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

Das Durchführen eines inneren Joins für die Tabelle has_many in Kombination mit einem groupoder uniqist möglicherweise sehr ineffizient. In SQL ist dies besser als Semi-Join implementiert, der EXISTSmit einer korrelierten Unterabfrage verwendet wird.

Auf diese Weise kann der Abfrageoptimierer die Tabelle der offenen Stellen prüfen, um festzustellen, ob eine Zeile mit der richtigen Projekt-ID vorhanden ist. Es spielt keine Rolle, ob es eine Zeile oder eine Million gibt, die diese project_id haben.

Das ist in Rails nicht so einfach, kann aber erreicht werden mit:

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

Ebenso finden Sie alle Projekte, die keine offenen Stellen haben:

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

Bearbeiten: In neueren Rails-Versionen wird eine Warnung angezeigt, dass Sie sich nicht darauf verlassen sollen exists, an arel delegiert zu werden. Beheben Sie dies mit:

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

Bearbeiten: Wenn Sie mit Raw SQL nicht vertraut sind, versuchen Sie:

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

Sie können dies weniger chaotisch machen, indem Sie Klassenmethoden hinzufügen, um die Verwendung von arel_tablebeispielsweise zu verbergen :

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

... so ...

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

In Rails 4+, können Sie dort auch enthalten oder eager_load die gleiche Antwort zu bekommen:

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

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

Ich denke, es gibt eine einfachere Lösung:

Project.joins(:vacancies).distinct

Ohne viel Rails-Magie können Sie Folgendes tun:

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

Diese Art von Bedingungen funktioniert in allen Rails-Versionen, da ein Großteil der Arbeit direkt auf der DB-Seite ausgeführt wird. Außerdem .countfunktioniert die Verkettungsmethode auch gut. Ich bin wie Project.joins(:vacancies)zuvor von Fragen verbrannt worden . Natürlich gibt es Vor- und Nachteile, da es nicht DB-Agnostiker ist.

Sie können auch verwenden , EXISTSmit SELECT 1eher als alle Spalten aus der vacanciesAuswahltabelle:

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

Der Fehler sagt Ihnen, dass offene Stellen im Grunde genommen keine Spalte in Projekten sind.

Das sollte funktionieren

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