Łącznik zewnętrzny lewy w szynach 4

W rzeczywistości istnieje "Rails Way", aby to zrobić.

Zawinąłbym go w metodzie, abyś mógł go ładnie nazwać i przekazać w dowolnym argumencie, jaki byś chciał, coś w stylu:

class Course < ActiveRecord::Base
  ....
  def left_join_student_enrollments(some_user)
    courses = Course.arel_table
    student_entrollments = StudentEnrollment.arel_table

    enrollments = courses.join(student_enrollments, Arel::Nodes::OuterJoin).
                  on(courses[:id].eq(student_enrollments[:course_id])).
                  join_sources

    joins(enrollments).where(
      student_enrollments: {student_id: some_user.id, id: nil},
      active: true
    )
  end
  ....
end

Istnieje również szybki (i lekko brudny) sposób, który wielu używa

Course.eager_load(:students).where(
    student_enrollments: {student_id: some_user.id, id: nil}, 
    active: true
)

Eager_load działa świetnie, po prostu ma "efekt uboczny" umieszczania modeli w pamięci, których możesz nie potrzebować (jak w Twoim przypadku)
Zobacz Rails ActiveRecord:: QueryMethods .eager_load
Robi dokładnie to, o co prosisz w schludny sposób.

Jeśli ktoś tu przyszedł, szukając ogólnego sposobu na zrobienie lewego zewnętrznego połączenia w Rails 5, możesz użyć #left_outer_joins Funkcja.

Przykład Multi-join:

Ruby:

Source.
 select('sources.id', 'count(metrics.id)').
 left_outer_joins(:metrics).
 joins(:port).
 where('ports.auto_delete = ?', true).
 group('sources.id').
 having('count(metrics.id) = 0').
 all

SQL:

SELECT sources.id, count(metrics.id)
  FROM "sources"
  INNER JOIN "ports" ON "ports"."id" = "sources"."port_id"
  LEFT OUTER JOIN "metrics" ON "metrics"."source_id" = "sources"."id"
  WHERE (ports.auto_delete = 't')
  GROUP BY sources.id
  HAVING (count(metrics.id) = 0)
  ORDER BY "sources"."id" ASC

Wykonałbyś zapytanie jako:

Course.joins('LEFT JOIN student_enrollment on courses.id = student_enrollment.course_id')
      .where(active: true, student_enrollments: { student_id: SOME_VALUE, id: nil })

Połączenie includes i where powoduje, że ActiveRecord wykonuje lewe zewnętrzne połączenie Za kulisami (bez gdzie generowałoby to normalny zestaw dwóch zapytań).

Więc możesz zrobić coś takiego:

Course.includes(:student_enrollments).where(student_enrollments: { course_id: nil })

Dokumenty tutaj: http://guides.rubyonrails.org/active_record_querying.html#specifying-conditions-on-eager-loaded-associations

Dodając do powyższej odpowiedzi, aby użyć includes, jeśli chcesz zewnętrzne połączenie bez odwoływania się do tabeli w where (np. id jest zerowe) lub odniesienie jest w łańcuchu możesz użyć references. To by wyglądało tak:

Course.includes(:student_enrollments).references(:student_enrollments)

Lub

Course.includes(:student_enrollments).references(:student_enrollments).where('student_enrollments.id = ?', nil)

Http://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-references

To join query w aktywnym modelu w Rails.

Kliknij tutaj, aby uzyskać więcej informacji na temat aktywnego formatu zapytania modelu .

@course= Course.joins("LEFT OUTER JOIN StudentEnrollment 
     ON StudentEnrollment .id = Courses.user_id").
     where("StudentEnrollment .id IS NULL AND StudentEnrollment .student_id = 
    <SOME_STUDENT_ID_VALUE> and Courses.active = true").select

Od dłuższego czasu borykam się z tego typu problemami i postanowiłem zrobić coś, aby rozwiązać je raz na zawsze. Opublikowałem Gist, który porusza ten problem: https://gist.github.com/nerde/b867cd87d580e97549f2

Stworzyłem mały hack AR, który używa tabeli Arel do dynamicznego budowania lewych złączy dla ciebie, bez konieczności pisania surowego SQL w kodzie:

class ActiveRecord::Base
  # Does a left join through an association. Usage:
  #
  #     Book.left_join(:category)
  #     # SELECT "books".* FROM "books"
  #     # LEFT OUTER JOIN "categories"
  #     # ON "books"."category_id" = "categories"."id"
  #
  # It also works through association's associations, like `joins` does:
  #
  #     Book.left_join(category: :master_category)
  def self.left_join(*columns)
    _do_left_join columns.compact.flatten
  end

  private

  def self._do_left_join(column, this = self) # :nodoc:
    collection = self
    if column.is_a? Array
      column.each do |col|
        collection = collection._do_left_join(col, this)
      end
    elsif column.is_a? Hash
      column.each do |key, value|
        assoc = this.reflect_on_association(key)
        raise "#{this} has no association: #{key}." unless assoc
        collection = collection._left_join(assoc)
        collection = collection._do_left_join value, assoc.klass
      end
    else
      assoc = this.reflect_on_association(column)
      raise "#{this} has no association: #{column}." unless assoc
      collection = collection._left_join(assoc)
    end
    collection
  end

  def self._left_join(assoc) # :nodoc:
    source = assoc.active_record.arel_table
    pk = assoc.association_primary_key.to_sym
    joins source.join(assoc.klass.arel_table,
      Arel::Nodes::OuterJoin).on(source[assoc.foreign_key].eq(
        assoc.klass.arel_table[pk])).join_sources
  end
end

Użyj :

Person.joins{articles.inner}
Person.joins{articles.outer}

Jeśli chcesz dołączyć zewnętrzne Bez wszystkich dodatkowych, chętnie załadowanych obiektów ActiveRecord, użyj .pluck(:id) po .eager_load(), aby przerwać eager load, zachowując zewnętrzne połączenie. Użycie .pluck(:id) utrudnia chętne ładowanie, ponieważ aliasy nazw kolumn (na przykładitems.location AS t1_r9) znikają z wygenerowanego zapytania, gdy są używane (te niezależnie nazwane pola są używane do tworzenia instancji wszystkich chętnie załadowanych obiektów ActiveRecord).

Wadą tego podejścia jest to, że musisz uruchomić drugie zapytanie, aby pobranie żądanych obiektów ActiveRecord zidentyfikowanych w pierwszym zapytaniu:

# first query
idents = Course
    .eager_load(:students)  # eager load for OUTER JOIN
    .where(
        student_enrollments: {student_id: some_user.id, id: nil}, 
        active: true
    )
    .distinct
    .pluck(:id)  # abort eager loading but preserve OUTER JOIN

# second query
Course.where(id: idents)

Wiem, że to stare pytanie i stary wątek, ale w Rails 5 możesz po prostu zrobić

Course.left_outer_joins(:student_enrollments)

Możesz użyć left_joins gem, który backportuje metodę left_joins z Rails 5 dla Rails 4 i 3.

Course.left_joins(:student_enrollments)
      .where('student_enrollments.id' => nil)