UNIÓN EXTERIOR IZQUIERDA en Raíles 4

En realidad hay una "Manera Rails" para hacer esto.

Puedes usar Arel , que es lo que Rails usa para construir consultas para ActiveRecrods

Lo envolvería en método para que puedas llamarlo bien y pasar cualquier argumento que quieras, algo como:

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

También existe la forma rápida (y ligeramente sucia) que muchos usan

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

Eager_load funciona muy bien, solo tiene el "efecto secundario" de almacenar modelos en la memoria que tal vez no necesite (como en su caso)
Consulte Rails ActiveRecord:: QueryMethods .eager_load
Hace exactamente lo que estás pidiendo de una manera ordenada.

Si alguien vino aquí buscando una forma genérica de hacer una unión externa izquierda en Rails 5, puede usar el #left_outer_joins función.

Ejemplo de combinación múltiple:

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

Ejecutarías la consulta como:

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

Combinando includes y where resulta en ActiveRecord realizando una UNIÓN EXTERNA IZQUIERDA detrás de las escenas (sin donde esto generaría el conjunto normal de dos consultas).

Así que podrías hacer algo como:

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

Documentos aquí: http://guides.rubyonrails.org/active_record_querying.html#specifying-conditions-on-eager-loaded-associations

Agregando a la respuesta anterior, para usar includes, si desea una COMBINACIÓN EXTERNA sin hacer referencia a la tabla en el where (como id siendo nil) o la referencia está en una cadena, puede usar references. Eso se vería así:

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

O

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

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

Es una consulta de unión en el Modelo Activo en Rails.

Haga clic aquí para obtener más información sobre el Formato de Consulta del Modelo Activo .

@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

He estado luchando con este tipo de problema durante bastante tiempo, y decidí hacer algo para resolverlo de una vez por todas. Publiqué una síntesis que aborda este tema: https://gist.github.com/nerde/b867cd87d580e97549f2

He creado un pequeño truco de AR que usa la tabla Arel para construir dinámicamente las uniones izquierdas para ti, sin tener que escribir SQL sin procesar en tu código:

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

Espero que ayude.

Use Squeel :

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

Si desea uniones EXTERNAS sin todos los objetos ActiveRecord extra cargados con impaciencia, use .pluck(:id) después de .eager_load() para abortar la carga ansiosa mientras conserva la UNIÓN EXTERNA. Usar .pluck(:id) frustra la carga ansiosa porque los alias de nombre de columna (items.location AS t1_r9, por ejemplo) desaparecen de la consulta generada cuando se usan (estos campos con nombre independiente se usan para crear instancias de todos los objetos ActiveRecord cargados ansiosamente).

Una desventaja de este enfoque es que luego necesita ejecutar una segunda consulta para introduzca los objetos ActiveRecord deseados identificados en la primera consulta:

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

Sé que esta es una vieja pregunta y un viejo hilo, pero en Rails 5, simplemente podrías hacer

Course.left_outer_joins(:student_enrollments)

Puedes usar la gema left_joins, que retroporta el método left_joins de Rails 5 para Rails 4 y 3.

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