Cómo implementar tiene muchos: a través de las relaciones con Mongoid y mongodb?

Solo para ampliar esto, aquí están los modelos extendidos con métodos que actúan muy similares a has_many: a través de ActiveRecord devolviendo un proxy de consulta en lugar de una matriz de registros:

class Physician
  include Mongoid::Document
  has_many :appointments

  def patients
    Patient.in(id: appointments.pluck(:patient_id))
  end
end

class Appointment
  include Mongoid::Document
  belongs_to :physician
  belongs_to :patient
end

class Patient
  include Mongoid::Document
  has_many :appointments

  def physicians
    Physician.in(id: appointments.pluck(:physician_id))
  end
end

Steven Soroka solución es realmente genial! No tengo la reputación de comentar una respuesta(por eso estoy agregando una nueva respuesta :P) pero creo que usar map para una relación es costoso (especialmente si su relación has_many tiene cientos|miles de registros) porque obtiene los datos de la base de datos, construye cada registro, genera la matriz original y luego itera sobre la matriz original para construir una nueva con los valores del bloque dado.

Usando pluck es más rápido y tal vez el la opción más rápida.

class Physician
  include Mongoid::Document
  has_many :appointments

  def patients
    Patient.in(id: appointments.pluck(:patient_id))
  end
end

class Appointment
  include Mongoid::Document
  belongs_to :physician
  belongs_to :patient 
end

class Patient
  include Mongoid::Document
  has_many :appointments 

  def physicians
    Physician.in(id: appointments.pluck(:physician_id))
  end
end

Aquí algunas estadísticas con Benchmark.medida:

> Benchmark.measure { physician.appointments.map(&:patient_id) }
 => #<Benchmark::Tms:0xb671654 @label="", @real=0.114643818, @cstime=0.0, @cutime=0.0, @stime=0.010000000000000009, @utime=0.06999999999999984, @total=0.07999999999999985> 

> Benchmark.measure { physician.appointments.pluck(:patient_id) }
 => #<Benchmark::Tms:0xb6f4054 @label="", @real=0.033517774, @cstime=0.0, @cutime=0.0, @stime=0.0, @utime=0.0, @total=0.0> 

Estoy usando solo 250 citas. ¡No olvide agregar índices a: patient_id y: physician_id en el documento de cita!

Espero que ayude, Gracias por leer!

Quiero responder a esta pregunta desde la perspectiva de la asociación autorreferenciante, no solo desde la perspectiva has_many :through.

Digamos que tenemos un CRM con contactos. Los contactos tendrán relaciones con otros contactos, pero en lugar de crear una relación entre dos modelos diferentes, estaremos creando una relación entre dos instancias del mismo modelo. Un contacto puede tener muchos amigos y ser amigo de muchos otros contactos, así que vamos a tener que crear un relación de muchos a muchos.

Si estamos usando un RDBMS y ActiveRecord, usaríamos has_many :through. Por lo tanto, necesitaríamos crear un modelo de unión, como la Amistad. Este modelo tendría dos campos, un contact_id que representa al contacto actual que está agregando un amigo y un friend_id que representa al usuario que está siendo amigo.

Pero estamos usando MongoDB y Mongoid. Como se indicó anteriormente, Mongoid no tiene has_many :through o una característica equivalente. No sería tan útil con MongoDB porque no admite consultas de combinación. Por lo tanto, para modelar una relación muchos-muchos en una base de datos no RDBMS como MongoDB, se utiliza un campo que contiene una matriz de claves 'foráneas' a cada lado.

class Contact
  include Mongoid::Document
  has_and_belongs_to_many :practices
end

class Practice
  include Mongoid::Document
  has_and_belongs_to_many :contacts
end

Como dice la documentación:

Muchas a muchas relaciones donde los documentos inversos se almacenan en un colección separada del documento base se definen utilizando Mongoid has_and_belongs_to_many macro. Esto exhibe un comportamiento similar a Active Record con la excepción de que no se necesita ninguna colección de unión, los id de clave foránea se almacenan como matrices a cada lado de la relaci.

Al definir una relación de esta naturaleza, cada documento se almacena en su colección respectiva, y cada documento contiene una " clave foránea" referencia al otro en forma de matriz.

# the contact document
{
  "_id" : ObjectId("4d3ed089fb60ab534684b7e9"),
  "practice_ids" : [ ObjectId("4d3ed089fb60ab534684b7f2") ]
}

# the practice document
{
  "_id" : ObjectId("4d3ed089fb60ab534684b7e9"),
  "contact_ids" : [ ObjectId("4d3ed089fb60ab534684b7f2") ]
}

Ahora, para una Asociación de autorreferenciación en MongoDB, tiene algunas opciones.

has_many :related_contacts, :class_name => 'Contact', :inverse_of => :parent_contact
belongs_to :parent_contact, :class_name => 'Contact', :inverse_of => :related_contacts

¿Cuál es la diferencia entre contactos relacionados y contactos que tienen muchos y pertenecen a muchas prácticas? Gran diferencia! Una es una relación entre dos entidades. Otro es una auto-referencia.