ruby on rails - inverse_of - rails has_many: a través de has_many: a través de

rails references

Question

Me pregunto hasta qué punto puedo usar asociaciones en Rails. Tenga en cuenta lo siguiente:

class User < ActiveRecord::Base
has_one :provider
has_many :businesses, :through => :provider
end
class Provider < ActiveRecord::Base
has_many :businesses
has_many :bids, :through => :businesses
belongs_to :user
end
class Business < ActiveRecord::Base
has_many :bids
belongs_to :provider
end
class Bid < ActiveRecord::Base
belongs_to :business
end

Puedo configurar estos atajos ingeniosos como User.businesses y Provider.bids pero ¿qué tal si hago algo como User.bids ? ¿Es posible asociar una asociación, por así decirlo?

Answer 1

Aunque es muy útil tenerlo, no se puede has_many: a través de una relación has_many: through. Esta es una limitación del motor de unión.

Las alternativas son usar una sub-selección inteligente, o en este caso una selección sub-sub, o deliberadamente desnormalizar las tablas lo suficiente para reducir la profundidad de la unión.

Por ejemplo, dado que un Negocio se define en el contexto de un Proveedor, es lógico pensar que los elementos de Licitación también se asignan, de forma indirecta, a un Proveedor. Crear una asociación directa entre Oferta y Proveedor haría que las ofertas de consulta sean directamente fáciles.

Answer 2

Esto es completamente posible, pero necesita un poco de trabajo adicional. Las siguientes definiciones de modelo utilizadas junto con el complemento nested_has_many le permite obtener todas las ofertas que pertenecen a un usuario con solo @user.bids

class User < ActiveRecord::Base
has_one :provider
has_many :businesses, :through => :provider
has_many :bids, :through => :businesses
end
class Provider < ActiveRecord::Base
has_many :businesses
has_many :bids, :through => :businesses
belongs_to :user
end
class Business < ActiveRecord::Base
has_many :bids
belongs_to :provider
end
class Bid < ActiveRecord::Base
belongs_to :business
end

Sin embargo, obtener un usuario de una oferta requerirá más trabajo.

Answer 3

No hay nada que te detenga haciendo algo como esto afaik:

class User < ActiveRecord::Base
has_one :provider
has_many :businesses, :through => :provider
def bids
user_bids = []
businesses.each |business| do
user_bids += business.bids
end
user_bids
end
end
class Provider < ActiveRecord::Base
has_many :businesses
has_many :bids, :through => :businesses
belongs_to :user
end
class Business < ActiveRecord::Base
has_many :bids
belongs_to :provider
end
class Bid < ActiveRecord::Base
belongs_to :business
end

Luego, al llamar a @ user.bids, debe obtener el resultado deseado, también puede almacenar en caché las ofertas y hacer otras cosas de lujo si lo desea.

Answer 4

Si solo desea recuperar los registros, ¿por qué no utilizar use #delegate ? Funciona bien, al menos en el escenario que ha descrito.

class User < ActiveRecord::Base
has_one :provider
delegates :bids, :to => :provider
end
class Provider < ActiveRecord::Base
has_many :businesses
has_many :bids, :through => :businesses
belongs_to :user
end
class Business < ActiveRecord::Base
has_many :bids
belongs_to :provider
end
class Bid < ActiveRecord::Base
belongs_to :business
end

Aunque en mi opinión no tan humilde debería simplemente encadenar los métodos porque es más sencillo, y ya no está logrando el aumento de rendimiento a menos que vaya con algún loco SQL personalizado como dice tadman.