在Rails中，如何将一个模型两次连接到一个多态属于的另一个模型？

Question

I'm trying to determine the appropriate way to setup the following schema and associations in Rails 4:

Business
  company_name
  ->1 street_address (Address)
  ->0..1 mailing_address (Address)
  ->0..n employees (Employee)

Employee
  first_name
  last_name
  birthday
  ->0..n addresses (Address)

Address
  street
  city
  state
  zip
  ->1 resource (Business or Employee or potentially something else in the future)

The main goals here are:

1. to be able to retrieve an arbitrary Address and in turn find the resource that it belongs to (which may be a Business or an Employee)
2. to have one Address designated as the "street address" for each Business, and optionally another address as the "mailing address"
3. to allow each Business to have multiple Employees, each of which may have other different addresses (home address, etc).
4. to allow other future resources (as-yet-unknown) to also have associated Addresses

Note that an Address can either belong to a Business (acting as either the street address or the mailing address for the business), or to an Employee (and an employee can have multiple addresses). This to me implies a polymorphic relationship, and my first stab at implementing this in Rails looks like this:

class Business < ActiveRecord::Base
  has_one :street_address, class_name: 'Address', as: :resource, 
                           inverse_of: :resource, dependent: :destroy
  has_one :mailing_address, class_name: 'Address', as: :resource, 
                            inverse_of: :resource, dependent: :destroy
  has_many :business_employees, inverse_of: :business, dependent: :destroy
  has_many :employees, through: :business_employees
end

class BusinessEmpoloyee < ActiveRecord::Base
  belongs_to :business
  belongs_to :employee
end

class Employee < ActiveRecord::Base
  has_many :business_employees, inverse_of: :employee, dependent: :destroy
  has_many :businesses, through: :business_employees
  has_many :addresses, as: :resource, inverse_of: :resource, dependent: :destroy
end

class Address < ActiveRecord::Base
  belongs_to :resource, polymorphic: true
end

However, this isn't working as hoped. The street address and mailing address for the business are always both returning the same value. For example:

2.1.2 :001 > b = Business.create(company_name: 'Test Business')

2.1.2 :002 > b.street_address = Address.create(street: '123 Main St', city: 'San Francisco', state: 'CA')

2.1.2 :003 > b.mailing_address = Address.create(street: 'P.O. Box 123', city: 'New York', state_code: 'NY')

2.1.2 :004 > b2 = Business.find_by_company_name('Test Business')
  Business Load (1.2ms)  SELECT  "businesses".* FROM "businesses"  WHERE "businesses"."company_name" = 'Test Business' LIMIT 1
 => #<Business id: 1168, company_name: "Test Business", street_address_id: nil, mailing_address_id: nil, created_at: "2014-09-04 19:57:14", updated_at: "2014-09-04 19:57:14"> 

2.1.2 :005 > b2.mailing_address
  Address Load (0.5ms)  SELECT  "addresses".* FROM "addresses"  WHERE "addresses"."resource_id" = $1 AND "addresses"."resource_type" = $2 LIMIT 1  [["resource_id", 1168], ["resource_type", "Business"]]
 => #<Address id: 1186, resource_id: 1168, resource_type: "Business", street: "P.O. Box 123", city: "New York", state: "NY", zip: nil, created_at: "2014-09-04 19:57:56", updated_at: "2014-09-04 19:57:56"> 

2.1.2 :006 > b2.street_address
  Address Load (0.5ms)  SELECT  "addresses".* FROM "addresses"  WHERE "addresses"."resource_id" = $1 AND "addresses"."resource_type" = $2 LIMIT 1  [["resource_id", 1168], ["resource_type", "Business"]]
 => #<Address id: 1186, resource_id: 1168, resource_type: "Business", street: "P.O. Box 123", city: "New York", state: "NY", zip: nil, created_at: "2014-09-04 19:57:56", updated_at: "2014-09-04 19:57:56"> 

Of course, this does make sense - how is the Business suppose to know which Address to use for which address value?

So, that being the case, any suggestions on how I can capture the relationships described here?

Answer 1

A rule of thumb: relationship is written into a model that belongs . If you specify for one model two associations pointing to the same model they will effectively be the same, as there is only one way to belong: have a certain model's resource_id and resource_type .

You'll need to add another parameter to "belonging" in order to filter "what kind of belonging that is". A rather standard way for that is single table inheritance (STI) (and I happened to write about how to use it ), which works as follows: you add a type:string:index column to Address and create a new class that inherits from Address , say, MailingAddress :

class MailingAddress < Address
end

Most of the time it should be empty, it inherits everything from Address , even storage: it's stored in the same table, but can be distinguished by type="MailingAddress" which is added automatically when you query for instances of this class from the databse. However, when you query for Address es, you also get MailingAddress es, per inheritance principle.

Other ways of doing the same involve something similar: adding another column to filter out mailing addresses from all the others. A string is not the fastest thing to compare, even though RDBMS are insanely fast at doing that.