belongs_to(関連モデル名, scope=nil, オプション={})

belongs_to :user

belongs_to :admin_user, class_name: "User"

belongs_to :user, conditions: "user_id = 2"

belongs_to :user, order: "id DESC"

belongs_to :user, dependent: :destroy

belongs_to :user, foreign_key: "blog_id"

belongs_to :account, default: -> { company.account }

* [GitHub](https://github.com/rails/rails/blob/984c3ef2775781d47efa9f541ce570daa2434a80/activerecord/lib/active_record/associations.rb#L769)

has_one(関連モデル名, scope=nil, オプション引数)

class CreateUsersProjectsTable < ActiveRecord::Migration
  def self.up
    create_table :users_projects, id: false do |t|
      t.integer :user_id
      t.integer :project_id
    end
  end
  def self.down
    drop_table :users_projects
 vend
end

class User < ActiveRecord::Base
  has_one :project
end

class Project < ActiveRecord::Base
  belongs_to :user
end

has_one :admin_user, class_name: "User"

has_one :user, conditions: "user_id = 2"

has_one :user, order: "id DESC"

has_one :user, dependent: :destroy

has_one :user, foreign_key: "blog_id"

has_many(関連モデル名, scope=nil, オプション引数)

class CreateUsersProjectsTable < ActiveRecord::Migration
  def self.up
    create_table :users_projects, id: false do |t|
      t.integer :user_id
      t.integer :project_id
    end
  end
  def self.down
    drop_table :users_projects
  end
end

class User < ActiveRecord::Base
  has_many :projects
  accepts_nested_attributes_for :projects
end

class Project < ActiveRecord::Base
  belongs_to :user
  accepts_nested_attributes_for :user
end

has_many :admin_user, class_name: "User"
accepts_nested_attributes_for :admin_user

has_many :user, conditions: "user_id = 2"
accepts_nested_attributes_for :user

has_many :user, order: "id DESC"
accepts_nested_attributes_for :user

has_many :users, group: "category"
accepts_nested_attributes_for :users

has_many :user, foreign_key: "blog_id"
accepts_nested_attributes_for :user

has_and_belongs_to_many(関連モデル名, scope=nil, オプション引数)

class CreateUsersProjectsTable < ActiveRecord::Migration
  def self.up
    create_table :users_projects, id: false do |t|
      t.integer :user_id
      t.integer :project_id
    end
  end
  def self.down
    drop_table :users_projects
  end
end

class User < ActiveRecord::Base
  has_and_belongs_to_many :projects
end

class Project < ActiveRecord::Base
  has_and_belongs_to_many :users
end

$ rails generate model AttachmentImage attachable_id:integer attachable_type:string

class CreateAttachmentImage < ActiveRecord::Migration
  def self.up
    create_table :attachment_images do |t|
      t.integer :attachable_id
      t.string :attachable_type

    t.timestamps
  end
end

class AttachmentImage < ActiveRecord::Base
  belongs_to :attachable, polymorphic: true
end

class Blog < ActiveRecord::Base
  has_many :entries
  has_one :attachment_image, as: :attachable
end

class Entry < ActiveRecord::Base
  belongs_to :blog
end

def self.down
  drop_table :attachment_images
end

belongs_to(:親モデル, counter_cache: 親モデルのカラム)

def self.up
  add_column :entries, :comments_count, :integer, default: 0
end

belongs_to :entry, counter_cache: :comments_count

モデルのコレクション.build(属性={}, ブロック引数)

person.pets.build

person.pets.build(name: 'Fancy-Fancy')

person.pets.build([{name: 'Spook'}, {name: 'Choo-Choo'}, {name: 'Brain'}])

モデルのコレクション.create(属性={}, ブロック引数)

person.pets.create(name: 'Fancy-Fancy')
#=> <Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.create([{name: 'Spook'}, {name: 'Choo-Choo'}])
#=> [
#      <Pet id: 2, name: "Spook", person_id: 1>,
#      <Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

モデルのコレクション.find(ID..)

person.pets.find(1)
#=> <Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.find(2, 3)
#=> [
#       <Pet id: 2, name: "Spook", person_id: 1>,
#       <Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

モデルのコレクション.select(カラム.., ブロック引数)

person.pets.select(:name)

person.pets.select(:id, :name)

person.pets.select { |pet| /oo/.match?(pet.name) }

モデルのコレクション.first(取得する件数=nil)

person.pets.first
#=> <Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.first(2)
#=> [
#      <Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#      <Pet id: 2, name: "Spook", person_id: 1>
#    ]

モデルのコレクション.last(取得する件数=nil)

person.pets.last
#=> <Pet id: 3, name: "Choo-Choo", person_id: 1>

person.pets.last(2)
#=> [
#      <Pet id: 2, name: "Spook", person_id: 1>,
#      <Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

モデルのコレクション.take(取得する件数=nil)

person.pets.take

person.pets.take(2)

モデルのコレクション.delete(レコード..)

person.pets.delete(Pet.find(1))

person.pets.delete(Pet.find(1), Pet.find(3))

モデルのコレクション.delete_all(依存=nil)

person.pets.delete_all

モデルのコレクション.destroy(レコード..)

person.pets.destroy(Pet.find(1))

person.pets.destroy(Pet.find(2), Pet.find(3))

モデルのコレクション.destroy_all()

person.pets.destroy_all

モデルのコレクション.count(カラム名=nil, ブロック引数)

person.pets.count
#=> 3

モデルのコレクション.empty?()

class Person < ActiveRecord::Base
    has_many :pets
end

person.pets.count  #=> 1
person.pets.empty? #=> false

person.pets.delete_all

person.pets.count  #=> 0
person.pets.empty? #=> true

モデルのコレクション.length()

class Person < ActiveRecord::Base
    has_many :pets
end

person.pets.length #=> 3
# executes something like SELECT "pets".* FROM "pets" WHERE "pets"."person_id" = 1

モデルのコレクション.size()

person.pets.size
#=> 3

モデル.loaded?()

person.pets.loaded? #=> false
person.pets.records
person.pets.loaded? #=> true

モデルのコレクション.any?()

class Person < ActiveRecord::Base
  has_many :pets
end
person.pets.count # 0
person.pets.any?  # false
person.pets << Pet.new(name: 'Snoop')
person.pets.count # 0
person.pets.any?  # true

person.pets
# [<Pet name: "Snoop", group: "dogs">]

person.pets.any? do |pet|
  pet.group == 'cats'
end
# false

person.pets.any? do |pet|
  pet.group == 'dogs'
end
# true

モデルのコレクション.many?()

class Person < ActiveRecord::Base
    has_many :pets
end

person.pets.count #=> 1
person.pets.many? #=> false

person.pets << Pet.new(name: 'Snoopy')
person.pets.count #=> 2
person.pets.many? #=> true

モデルのコレクション.distinct(ユニークにするか=true)

person.pets.select(:name).distinct

person.pets.select(:name).distinct.distinct(false)

モデルのコレクション.include?(レコード)

person.pets.include?(Pet.find(20))
#=> true

モデルのコレクション.reload()

person.pets.reload

モデルのコレクション.replace(他の配列)

person.pets
#=> [<Pet id: 1, name: "Gorby", group: "cats", person_id: 1>]

other_pets = [Pet.new(name: 'Puff', group: 'celebrities')]

person.pets.replace(other_pets)

person.pets
#=> [<Pet id: 2, name: "Puff", group: "celebrities", person_id: 1>]

モデルのコレクション.reset()

person.pets.reset