关联

class Band
  include Mongoid::Document
  has_one :studio
end

class Studio
  include Mongoid::Document
  belongs_to :band
end

band = Band.create!(studio: Studio.new)
# => #<Band _id: 600114fa48966848ad5bd392, >
band.studio
# => #<Studio _id: 600114fa48966848ad5bd391, band_id: BSON::ObjectId('600114fa48966848ad5bd392')>

class Band
  include Mongoid::Document
  has_one :studio
  validates_presence_of :studio
end

class Band
  include Mongoid::Document
  has_many :members
end

class Member
  include Mongoid::Document
  belongs_to :band
end

band = Band.create!(members: [Member.new])
# => #<Band _id: 6001166d4896684910b8d1c5, >
band.members
# => [#<Member _id: 6001166d4896684910b8d1c6, band_id: BSON::ObjectId('6001166d4896684910b8d1c5')>]

class Band
  include Mongoid::Document
  has_many :members
  validates_presence_of :members
end

class Band
  include Mongoid::Document
  has_one :studio
end
class Studio
  include Mongoid::Document
  belongs_to :band, optional: true
end
studio = Studio.create!
# => #<Studio _id: 600118184896684987aa884f, band_id: nil>

class Band
  include Mongoid::Document
end
class Studio
  include Mongoid::Document
  belongs_to :band
end

class Band
  include Mongoid::Document
end
class Studio
  include Mongoid::Document
  belongs_to :band, inverse_of: nil
end

class Band
  include Mongoid::Document
  has_and_belongs_to_many :tags
end
class Tag
  include Mongoid::Document
  has_and_belongs_to_many :bands
end

band = Band.create!(tags: [Tag.create!])
# => #<Band _id: 60011d554896684b8b910a2a, tag_ids: [BSON::ObjectId('60011d554896684b8b910a29')]>
band.tags
# => [#<Tag _id: 60011d554896684b8b910a29, band_ids: [BSON::ObjectId('60011d554896684b8b910a2a')]>]

class Band
  include Mongoid::Document
  has_and_belongs_to_many :tags, inverse_of: nil
end
class Tag
  include Mongoid::Document
end
band = Band.create!(tags: [Tag.create!])
# => #<Band _id: 60011dbc4896684bbbaa9255, tag_ids: [BSON::ObjectId('60011dbc4896684bbbaa9254')]>
band.tags
# => [#<Tag _id: 60011dbc4896684bbbaa9254, >]

class Band
  include Mongoid::Document
  has_many :tours
  has_many :awards
  field :name, type: String
end
class Tour
  include Mongoid::Document
  belongs_to :band
  field :year, type: Integer
end
class Award
  include Mongoid::Document
  belongs_to :band
  field :name, type: String
end

band_ids = Tour.where(year: {'$gte' => 2000}).pluck(:band_id)
bands = Band.find(band_ids)

band_ids = Tour.where(year: {'$gte' => 2000}).pluck(:band_id)
awards = Award.where(band_id: {'$in' => band_ids})

class Tag
  include Mongoid::Document
  field :name, type: String
  recursively_embeds_many
end
root = Tag.new(name: "programming")
child_one = root.child_tags.build
child_two = root.child_tags.build
root.child_tags # [ child_one, child_two ]
child_one.parent_tag # [ root ]
child_two.parent_tag # [ root ]
class Node
  include Mongoid::Document
  recursively_embeds_one
end
root = Node.new
child = Node.new
root.child_node = child
root.child_node # child
child.parent_node # root

class Band
  include Mongoid::Document
  field :started_on, type: Date
  embeds_one :label
end
class Label
  include Mongoid::Document
  field :name, type: String
  embedded_in :band
end
# Retrieve labels for bands started in the last year.
#
# Sends a find query like this:
# {"find"=>"bands",
#  "filter"=>{"started_on"=>{"$gt"=>2018-07-01 00:00:00 UTC}},
#  "projection"=>{"_id"=>1, "label"=>1}}
Band.where(started_on: {'$gt' => Time.now - 1.year}).only(:label).map(&:label).compact.uniq

class Band
  include Mongoid::Document
  embeds_many :tours
  embeds_many :awards
  field :name, type: String
end
class Tour
  include Mongoid::Document
  embedded_in :band
  field :year, type: Integer
end
class Award
  include Mongoid::Document
  embedded_in :band
  field :name, type: String
end

# Get all bands that have toured since 2000
Band.where('tours.year' => {'$gte' => 2000})

# Get awards for bands that have toured since 2000
Band.where('tours.year' => {'$gte' => 2000}).pluck(:awards)

class Order
  include Mongoid::Document
  embeds_many :line_items
end
class LineItem
  include Mongoid::Document
  embedded_in :order
  field :_id, type: Object
end

class Band
  include Mongoid::Document
  embeds_many :albums
end
class Album
  include Mongoid::Document
  field :name, type: String
  embedded_in :band
end
band = Band.create!
band.albums = [ { name: "Narrow Stairs" }, { name: "Transatlanticism" } ]
p band.albums
# => [ #<Album _id: 633c71e93282a4357bb608e5, name: "Narrow Stairs">, #<Album _id: 633c71e93282a4357bb608e6, name: "Transatlanticism"> ]

class Person
  include Mongoid::Document
  embeds_many :addresses do
    def find_by_country(country)
      where(country: country).first
    end
    def chinese
      _target.select { |address| address.country == "China" }
    end
  end
end
person.addresses.find_by_country("Mongolia") # returns address
person.addresses.chinese # returns [ address ]

class Car
  include Mongoid::Document
  embeds_one :engine, class_name: "Motor", inverse_of: :machine
end
class Motor
  include Mongoid::Document
  embedded_in :machine, class_name: "Car", inverse_of: :engine
end

class Company
  include Mongoid::Document
  has_many :emails
end
class Email
  include Mongoid::Document
  belongs_to :company
end
company = Company.find(id)
# looks up emails where emails.company_id == company.id
company.emails

class Company
  include Mongoid::Document
  field :c, type: String
  has_many :emails, foreign_key: 'c_ref', primary_key: 'c'
end
class Email
  include Mongoid::Document
  # This definition of c_ref is automatically generated by Mongoid:
  # field :c_ref, type: Object
  # But the type can also be specified:
  field :c_ref, type: String
  belongs_to :company, foreign_key: 'c_ref', primary_key: 'c'
end
company = Company.find(id)
# looks up emails where emails.c_ref == company.c
company.emails

class Company
  include Mongoid::Document
  field :c_id, type: Integer
  field :e_ids, type: Array
  has_and_belongs_to_many :employees,
    primary_key: :e_id, foreign_key: :e_ids,
    inverse_primary_key: :c_id, inverse_foreign_key: :c_ids
end
class Employee
  include Mongoid::Document
  field :e_id, type: Integer
  field :c_ids, type: Array
  has_and_belongs_to_many :companies,
    primary_key: :c_id, foreign_key: :c_ids,
    inverse_primary_key: :e_id, inverse_foreign_key: :e_ids
end
company = Company.create!(c_id: 123)
# => #<Company _id: 5c565ece026d7c461d8a9d4e, c_id: 123, e_ids: nil>
employee = Employee.create!(e_id: 456)
# => #<Employee _id: 5c565ee8026d7c461d8a9d4f, e_id: 456, c_ids: nil>
company.employees << employee
company
# => #<Company _id: 5c565ece026d7c461d8a9d4e, c_id: 123, e_ids: [456]>
employee
# => #<Employee _id: 5c5883ce026d7c4b9e244c0c, e_id: 456, c_ids: [123]>

class Trainer
  has_many :pets, scope: -> { where(species: 'dog') }
  has_many :toys, scope: :rubber
end
class Pet
  belongs_to :trainer
end
class Toy
  scope :rubber, where(material: 'rubber')
  belongs_to :trainer
end

class Person
  include Mongoid::Document
  embeds_many :addresses, validate: false
  has_many :posts, validate: false
end

class Department
  include Mongoid::Document
  has_one :manager, as: :unit
end
class Team
  include Mongoid::Document
  has_one :manager, as: :unit
end
class Manager
  include Mongoid::Document
  belongs_to :unit, polymorphic: true
end
dept = Department.create!
team = Team.create!
alice = Manager.create!(unit: dept)
alice.unit == dept
# => true
dept.manager == alice
# => true

class Product
  include Mongoid::Document
  field :name, type: String
  has_and_belongs_to_many :bundles
  embeds_many :prices, as: :item
end
class Bundle
  include Mongoid::Document
  field :name, type: String
  has_and_belongs_to_many :products
  embeds_many :prices, as: :item
end
class Price
  include Mongoid::Document
  embedded_in :item, polymorphic: true
end
pants = Product.create!(name: 'Pants',
  prices: [Price.new, Price.new])
costume = Bundle.create!(name: 'Costume', products: [pants],
  prices: [Price.new, Price.new])

class Bundle
  include Mongoid::Document
  # Does not work:
  has_many :items, polymorphic: true
end

 class Band
   include Mongoid::Document
   embeds_many :albums, cascade_callbacks: true
   embeds_one :label, cascade_callbacks: true
 end
band.save # Fires all save callbacks on the band, albums, and label.

class Band
  include Mongoid::Document
  has_many :albums, dependent: :delete_all
  belongs_to :label, dependent: :nullify
end
class Album
  include Mongoid::Document
  belongs_to :band
end
class Label
  include Mongoid::Document
  has_many :bands, dependent: :restrict_with_exception
end
label = Label.first
label.bands.push(Band.first)
label.delete # Raises an error since bands is not empty.
Band.first.destroy # Will delete all associated albums.

class Band
  include Mongoid::Document
  has_many :albums
end
class Album
  include Mongoid::Document
  belongs_to :band
end
band = Band.new
album = Album.create!(band: band)
# The band is not persisted at this point.
album.reload
album.band_id
# => BSON::ObjectId('6257699753aefe153121a3d5')
# Band does not exist.
album.band
# => nil

class Band
  include Mongoid::Document
  has_many :albums
end
class Album
  include Mongoid::Document
  belongs_to :band, autosave: true
end
band = Band.new
album = Album.create!(band: band)
# The band is persisted at this point.
album.reload
album.band_id
# => BSON::ObjectId('62576b4b53aefe178b65b8e3')
album.band
# => #<Band _id: 62576b4b53aefe178b65b8e3, >

class Band
  include Mongoid::Document
  embeds_one :label
  embeds_many :albums
end
band.label?
band.has_label?
band.albums?
band.has_albums?

class Band
  include Mongoid::Document
  embeds_one :label, autobuild: true
  has_one :producer, autobuild: true
end
band = Band.new
band.label # Returns a new empty label.
band.producer # Returns a new empty producer.

class Band
  include Mongoid::Document
  field :name
  belongs_to :label, touch: true
end
band = Band.first
band.name = "The Rolling Stones"
band.save! # Calls touch on the parent label.
band.touch # Calls touch on the parent label.

class Label
  include Mongoid::Document
  include Mongoid::Timestamps
  field :bands_updated_at, type: Time
  has_many :bands
end
class Band
  include Mongoid::Document
  belongs_to :label, touch: :bands_updated_at
end
label = Label.create!
band = Band.create!(label: label)
band.touch # Updates updated_at and bands_updated_at on the label.

class Order
  include Mongoid::Document
  belongs_to :customer, counter_cache: true
end
class Customer
  include Mongoid::Document
  include Mongoid::Attributes::Dynamic
  has_many :orders
end

class Order
  include Mongoid::Document
  belongs_to :customer
  private
  def internal_status
    'new'
  end
end
class Customer
  include Mongoid::Document
  has_many :orders
  private
  def internal_id
    42
  end
end
order = Order.new
customer = Customer.create!(orders: [order])
# has_many does not permit calling private methods on the target
customer.orders.first.internal_status
# NoMethodError (private method `internal_status' called for #<Order:0x000055af2ec46c50>)
# belongs_to permits calling private methods on the target
order.customer.internal_id
# => 42

class Person
  include Mongoid::Document
  embeds_many :addresses
end
person.addresses = [ address ]
person.addresses._target # returns [ address ]
person.addresses._base # returns person
person.addresses._association # returns the association metadata