Railsドキュメント(v6.0.2.1)

モデル.new([属性])

User.new
# <User id: nil, created_at: nil, updated_at: nil>

User.new(name: "DHH")
# <User id: nil, name: "DHH", created_at: nil, updated_at: nil>

users.new do |user|
  user.name = 'Oscar'
end

モデル.build([属性])

person.pets.build
# <Pet id: nil, name: nil, person_id: 1>

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

person.pets.build([{name: 'Spook'}, {name: 'Choo-Choo'}, {name: 'Brain'}])
# [
#   <Pet id: nil, name: "Spook", person_id: 1>,
#   <Pet id: nil, name: "Choo-Choo", person_id: 1>,
#   <Pet id: nil, name: "Brain", person_id: 1>
# ]

モデル.create([属性])

モデル.create!([属性])

User.create(name: "TestUser", profile: "profile")

User.create([{name: "A"},{name: "B"}])

モデル.find_by(条件)

モデル.find_by!(条件)

Page.find_by category_id: 1
# <Page id: 1, category_id: 1>
# SQL: SELECT "pages".* FROM "pages" WHERE "pages"."category_id" = 1 LIMIT 1

Page.find_by category_id: 1
# nil

Page.find_by category_id: 1, user_if: 1

# Page.find_by category_id: 1
Page.where(category_id: 1).take

モデル.find(件数)

Person.find(1)
# <Person id: 1, ...>

Person.find(1, 2, 6)
# [
#   <Person id: 1, ...>,
#   <Person id: 2, ...>,
#   <Person id: 6, ...>
# ]

Person.find([7, 17])
# [
#   <Person id: 7, ...>,
#   <Person id: 17, ...>
# ]

モデル.find_each([オプション]) do |i|
  処理内容
end

Person.find_each do |person|
  person.do_awesome_stuff
end

Post.find_each(:batch_size => 10) do |post|
end

Person.find_each(start: 2000, batch_size: 2000) do |person|
end

モデル.find_in_batches([オプション]) do |i|
  処理内容
end

Person.where("age > 21").find_in_batches do |group|
  sleep(50) # Make sure it doesn't get too crowded in there!
  group.each { |person| person.party_all_night! }
end

Person.all.find_in_batches(start: 2000, batch_size: 2000) do |group|
  group.each { |person| person.party_all_night! }
end

モデル.find_or_create_by(条件)

モデル.find_or_create_by!(条件)

User.find_or_create_by(first_name: 'Penélope')
# <User id: 1, first_name: 'Penélope', last_name: nil>

User.find_or_create_by(first_name: 'Penélope')
# <User id: 1, first_name: 'Penélope', last_name: nil>

User.find_or_create_by(first_name: 'Scarlett') do |user|
  user.last_name = "O'Hara"
end
# <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>

モデル.find_or_initialize_by(条件)

モデル.find_or_initialize_by!(条件)

User.find_or_initialize_by(first_name: 'Penélope')

User.find_or_initialize_by(first_name: 'Penélope')

User.find_or_initialize_by(first_name: 'Scarlett') do |user|
  user.last_name = "O'Hara"
end

モデル.find_by_sql(SQL文)

Page.find_by_sql("SELECT * FROM pages LIMIT 10")
# SELECT * FROM pages LIMIT 10

select_all(SQL文, [名前, binds, preparable])

Client.connection.select_all("SELECT first_name, created_at FROM clients WHERE id = '1'").to_hash
# [
#   {"first_name"=>"Rafael", "created_at"=>"2012-11-10 23:23:45.281189"},
#   {"first_name"=>"Eileen", "created_at"=>"2013-12-09 11:22:35.221282"}
# ]

モデル.all

Page.all
# SELECT "pages".* FROM "pages"

モデル.first([件数])

モデル.first!([件数])

Page.first
# <Page id: 1, ...>
# SQL: SELECT "pages".* FROM "pages" LIMIT 1

Page.first(3)
# [
#   <Page id: 1, ...>,
#   <Page id: 2, ...>,
#   <Page id: 3, ...>
# ]
# SQL: SELECT "pages".* FROM "pages" LIMIT 3

Page.order(:title).first
# <Page title: a, ...>
# SQL: SELECT * FROM pages ORDER BY pages.title ASC LIMIT 1

Page.first
# nil

モデル.respond_to?(メソッド名 [, include_private=false])

person.respond_to?(:name)
# true

person.respond_to?(:private_name, true)
# true

モデル.last([件数])

モデル.last!([件数])

Page.last
# #<Page id: 10, ...>
# SQL: SELECT "pages".* FROM "pages" ORDER BY "pages"."id" DESC LIMIT 1

Page.last(2)
# [
#   <Page id: 10, ...>,
#   <Page id: 9, ...>,
#   <Page id: 8, ...>
# ]
# SELECT "pages".* FROM "pages" ORDER BY "pages"."id" DESC LIMIT 3

Page.order(:title).last
# <Page title: z, ...>
# SQL: SELECT * FROM pages ORDER BY pages.title DESC LIMIT 1

Page.last
# nil

モデル.take([件数])

モデル.take!([件数])

Person.take
# <Person id: 1, ...>
# SQL: SELECT * FROM people LIMIT 1

Person.take(2)
# [
#   <Client id: 1, ...>,
#   <Client id: 220, ...>
# ]
# SQL: SELECT * FROM people LIMIT 5

Person.where(["name LIKE '%?'", name]).take

モデル.where(条件)

Page.where("category_id = '1'")
# SELECT "pages".* FROM "pages" WHERE "pages"."category_id" = 1

Page.where(category_id: 1)
# SELECT "pages".* FROM "pages" WHERE "pages"."category_id" = 1

Page.where(["category_id = ? and url_id = ?", 1, 1])
# SELECT "pages".* FROM "pages" WHERE (category_id = 1 and url_id = 1)

Page.where("category_id = :category_id", {category_id: params[:category_id]})

Page.where(category_id: [1, 2])
# SELECT * FROM pages WHERE (pages.category_id IN (1,2))

Page.where(title: nil)

Page.not.where category_id: 1
# SELECT * FROM pages WHERE (pages.category_id != 1)

Page.where(category_id: 1).where(user_id: 1)

Page.where(category_id: 1).or(Page.where(user_id: 1))

User.where(:id => 1..10)

User.where("name like '%hoge%'")

User.where(created_at: '2020-1-5'.in_time_zone.all_year)

User.where(created_at: '2020-1-5'.in_time_zone.all_month)

User.where(created_at: '2020-1-5'.in_time_zone.all_day)

User.where(age: 20..)
# SELECT * FROM users WHERE (users.age >= 20)

モデル.rewhere(条件)

Post.where(trashed: true).rewhere(trashed: false)
# WHERE `trashed` = 0

Post.where(active: true).where(trashed: true).rewhere(trashed: false)
# WHERE `active` = 1 AND `trashed` = 0

モデル.group(グループ化キー)

User.group("name")
# SELECT * FROM users GROUP BY name

User.group('name, age')
# SELECT * FROM users GROUP BY name, age

User.group(:age).count

User.joins(:categories).group("categories.name")

User.joins(categories: :tags).group("user.name")

モデル.order(:キー名 [ :並び順])
# または
モデル.order("キー名 [並び順]")

Page.order(:category_id)
# SELECT "pages".* FROM "pages" ORDER BY category_id

Page.order(:category_id :asc)
# SELECT "pages".* FROM "pages" ORDER BY category_id ASC

Page.order("category_id ASC")
# SELECT "pages".* FROM "pages" ORDER BY category_id ASC

User.order(:name, email: :desc)
# SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC

モデル.reorder(ソート式)

User.order('email DESC').reorder('id ASC')
# generated SQL has 'ORDER BY id ASC'

User.order('email DESC').reorder('id ASC').order('name ASC')

モデル.reverse_order()

Page.order("category_id").reverse_order

モデル.limit(最大取得行数)

User.limit(5)
# SELECT * FROM users LIMIT 5

User.limit(5).limit(20)
# SELECT * FROM users LIMIT 20

User.limit(5).offset(30)
# SELECT * FROM users LIMIT 5 OFFSET 30

モデル.none()

Post.none

モデル.offset(取得開始位置)

Page.offset(5)
# SELECT "pages".* FROM "pages" LIMIT -1 OFFSET 5

User.limit(5).offset(30)
# SELECT * FROM users LIMIT 5 OFFSET 30

モデル.readonly(値)

users = User.readonly
users.first.save
# ActiveRecord::ReadOnlyRecord: ActiveRecord::ReadOnlyRecord

モデル.having(条件式)

User.having(['AVG(age) >= ?', 30])
# SELECT * FROM users HAVING AVG(age) >= 30

モデル.includes(:モデル [, ...])

Page.includes(:category)
# SELECT "pages".* FROM "pages"
# SELECT "categories".* FROM "categories" WHERE "categories"."id" IN (1)

User.includes(:address, :friends)

User.includes(friends: :address)

User.joins(:friends).where("friends.id IS NOT NULL")

User.friends.joins(:followers).where("followers.id IS NOT NULL")

User.where(address: 'hoge').or(User.where(friends: 'fuga'))

モデル.joins(条件)

Category.joins(:posts)
# SELECT categories.* FROM categories INNER JOIN posts ON posts.category_id = categories.id

Post.joins(:category, :comments)
# SELECT posts.* FROM posts
# INNER JOIN categories ON posts.category_id = categories.id
# INNER JOIN comments ON comments.post_id = posts.id

Page.joins(categories: :element)
#  SELECT "pages".* FROM "pages" INNER JOIN "pages_categories" ON "pages_categories"."page_id" = "pages"."id" INNER JOIN "categories" ON "categories"."id" = "pages_categories"."category_id" INNER JOIN "elements" ON "elements"."id" = "categories"."element_id"

User.joins("LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id")
# SELECT "users".* FROM "users" LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id

モデル.except(条件式)

Page.order("category DESC").except(:order)

モデル.from(値 [, サブクエリ])

Topic.select('title').from('posts')
# SELECT title FROM posts

Topic.select('title').from(Topic.approved)
# SELECT title FROM (SELECT * FROM topics WHERE approved = 't') subquery

Topic.select('a.title').from(Topic.approved, :a)
# SELECT a.title FROM (SELECT * FROM topics WHERE approved = 't') a

default_scope(条件式 [, ブロック])

class Article < ActiveRecord::Base
  default_scope { where(published: true) }
end
Article.all
# SELECT * FROM articles WHERE published = true

モデル.count(カラム名)

User.count

Person.count(:age)

Person.group(:city).count
# {Rome: 5, Paris: 3 }

モデル.average(カラム名)

Page.average(:count)
# SELECT AVG("pages"."count") AS avg_id FROM "pages"

モデル.maximum(カラム名 [, オプション])

User.maximum('age')
# SELECT MAX("users"."age") AS max_id FROM "users"

Account.maximum(:limit, :conditions => "limit > 50")

モデル.minimum(カラム名 [, オプション])

User.minimum('age')
# SELECT MIN("users"."age") AS min_id FROM "users"

Account.minimum(:limit, :conditions => "limit > 50")

モデル.ids()

Person.ids
# SELECT people.id FROM people

Person.joins(:companies).ids
# SELECT people.id FROM people INNER JOIN companies ON companies.person_id = people.id

モデル.sum(カラム名)

Rating.sum(:score)
#  SELECT SUM("Ratings"."score") AS sum_id FROM "Ratings"

モデル.pluck(カラム名 [, ...])

Person.pluck(:id)
# SELECT people.id FROM people
# [1, 2, 3]

Person.pluck(:id, :name)
# SELECT people.id, people.name FROM people
# [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]

Person.where(age: 21).limit(5).pluck(:id)
# SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
# [2, 3]

モデル.reload()

@page = Page.find(1)
# SELECT "pages".* FROM "pages" WHERE "pages"."id" = ? LIMIT 1  [["id", 1]]
@page.reload
# SELECT "pages".* FROM "pages" WHERE "pages"."id" = ? LIMIT 1  [["id", 1]]

モデル.save()

user = User.new
user.name = "A"
user.save

User.new do |i|
  i.name = "A"
  i.save
end

user = User.new(name: "A")
user.save

if @user.save
  redirect_to :list
else
  render action: "new"
end

begin
  Entry.transaction do
    @many_entries.each { |entry| entry.save! }
  end
 vredirect_to :list
  rescue ActionRecord::RecordInvalid, ActionRecord::RecordNotSaved: ex
  render action: "input_multi_entries"
end

@entry = Entry.find(params[:id])
@entry.message = "new Message"
@entry.save

@user = User.find(parms[:id])
@user.attributes = { username: 'Phusion', is_admin: true }
@user.save

モデル.update(ID, 属性)

Person.update(15, user_name: "Samuel", group: "expert")

people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
Person.update(people.keys, people.values)

モデル.update_all(カラム名: 値 [, オプション])

User.update_all("name='A'", "category='B')

モデル.update_attributes(属性名, 値)

@user.update_attributes(:name, "hoge")

モデル.update_attribute(属性名, 値)

@user.update_attribute(:name, "hoge")

モデル.destroy([条件])

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

モデル.delete(条件)

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

モデル.delete_all([検索条件])

person.pets.delete_all

person.pets.delete_all("id > 0")

モデル.destroy_all([検索条件])

Person.destroy_all("last_login < '2004-04-04'")

Person.destroy_all(status: "inactive")

Person.where(age: 0..18).destroy_all

モデル.where.not(条件)

User.where.not(name: "Jon")
# SELECT * FROM users WHERE name != 'Jon'

User.where.not(name: nil)
# SELECT * FROM users WHERE name IS NOT NULL

User.where.not(name: %w(Ko1 Nobu))
# SELECT * FROM users WHERE name NOT IN ('Ko1', 'Nobu')

User.where.not(name: "Jon", role: "admin")
# SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'

モデル.calculate(処理方法, カラム名)

Page.calculate(:count, :all)
# SELECT COUNT(*) FROM "pages"

モデル.clone()

user = User.first
new_user = user.clone
user.name               # "Bob"
new_user.name = "Joe"
user.name               # "Joe"

モデル.increment(レコード, インクリメントする値)

Page.increment(:num, 3)

モデル.changed()

person.changed # []
person.name = 'bob'
person.changed # ["name"]

モデル.changed?()

@user.changed?

モデル.column_for_attribute([カラム名])

@page = Page.find(1)
@page.column_for_attribute(:title)

モデル.attribute_names()

Person.attribute_names
# ["id", "created_at", "updated_at", "name", "age"]

モデル.attribute_for_inspect(属性名)

person.attribute_for_inspect(:name)
# "\"David Heinemeier Hansson David Heinemeier Hansson D...\""

person.attribute_for_inspect(:created_at)
# => "\"2012-10-22 00:15:07\""

person.attribute_for_inspect(:tag_ids)
# => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"

モデル.attribute_present?(属性名)

person.attribute_present?(:title)
# true

モデル.attributes()

person = Person.create(name: 'Francesco', age: 22)
person.attributes
# {"id"=>3, "created_at"=>Sun, 21 Oct 2012 04:53:04, "updated_at"=>Sun, 21 Oct 2012 04:53:04, "name"=>"Francesco", "age"=>22}

モデル.attributes_before_type_cast()

task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
task.attributes
# {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
task.attributes_before_type_cast
# {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}

ActiveRecord::Base.record_timestamps = false

モデル.has_attribute?(属性)

person.has_attribute?(:name)
# true

person.has_attribute?(:nothing)
# false

モデル.read_attribute_before_type_cast(カラム名)

task = Task.new(id: '1', completed_on: '2012-10-21')
task.read_attribute('id')                            # 1
task.read_attribute_before_type_cast('id')           # '1'
task.read_attribute('completed_on')                  # Sun, 21 Oct 2012
task.read_attribute_before_type_cast('completed_on') # "2012-10-21"

モデル.attribute_method?(属性)

User.attribute_method?(:name)
# true

User.attribute_method?(:age)
# false

モデル.exists?([条件])

Page.exists?
# SELECT 1 FROM "pages" LIMIT 1

Page.exists?(category: "rails")
# SELECT 1 FROM "pages" WHERE "pages"."category" = "rails" LIMIT 1

モデル.to_sql()

User.where(name: 'Oscar').to_sql
# SELECT "users".* FROM "users"  WHERE "users"."name" = 'Oscar'

モデル.new_record?()

User.new_record?

モデル.persisted?()

User.persisted?

モデル.destroyed?()

@user.destroyed?

モデル.composed_of(条件 [, オプション])

composed_of :temperature, mapping: %w(reading celsius)

composed_of :balance, class_name: "Money", mapping: %w(balance amount), converter: Proc.new { |balance| balance.to_money }

モデル.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

モデル.instance_method_already_implemented?(属性)

Person.instance_method_already_implemented?(:save)
# ActiveRecord::DangerousAttributeError: save is defined by ActiveRecord

Person.instance_method_already_implemented?(:name)
# false

class User < ActiveRecord::Base
  def to_param  # overridden
    name
  end
end

class User < ActiveRecord::Base
  def to_param  # overridden
    name
  end
end

モデル.touch([名前])

product.touch

product.touch(time: Time.new(2015, 2, 16, 0, 0, 0))
# updates updated_at/on with specified time

モデル.create_with(属性)

users = users.create_with(name: 'DHH')
users.new.name
# 'DHH'

users = users.create_with(nil)
users.new.name
# 'Oscar'

モデル.eager_load(属性)

User.eager_load(:posts)
# SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, ...
# FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" =
# "users"."id"

モデル.extending(モジュール)

module Pagination
  def page(number)
    # pagination code goes here
  end
end

scope = Model.all.extending(Pagination)
scope.page(params[:page])

module Pagination
  def page(number)
    # pagination code goes here
  end
end

scope = Model.all.extending do
  def page(number)
    # pagination code goes here
  end
end
scope.page(params[:page])

モデル.as_json([オプション])

user.as_json
# {id: 1, name: "Konata Izumi", age: 16, created_at: "2006-08-01T17:27:133.000Z", awesome: true}

user.as_json(root: true)
# => { "user" => { "id" => 1, "age" => 16, "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }

user.as_json(only: [:id, :age])
# => { "id" => 1, "age" => 16 }

user.as_json(except: [:id, :created_at, :name])
# => { "age" => 16, "awesome" => true }

user.as_json(methods: :permalink)
# => { "id" => 1, "name" => "Konata Izumi", "age" => 16, "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true, "permalink" => "1-konata-izumi" }

user.as_json(include: :posts)
# => { "id" => 1, "name" => "Konata Izumi", "age" => 16, "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true, "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" }, { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }

モデル.changes()

person.changes # {}
person.name = 'bob'
person.changes # {name: ["bill", "bob"]}

モデル.clear_validators!()

Person.clear_validators!

count_by_sql(SQL文)

Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
# 12

foreign_key_exists?(from_table [, to_table = nil, オプション])

foreign_key_exists?(:accounts, :branches)

foreign_key_exists?(:accounts, column: :owner_id)

foreign_key_exists?(:accounts, name: "special_fk_name")

モデル.in_batches([オプション]) do |i|
  処理内容
end

Person.where("age > 21").in_batches do |relation|
  relation.delete_all
  sleep(10) # Throttle the delete queries
end

Person.in_batches.delete_all

Person.in_batches.update_all(awesome: true)

indexes(テーブル名)

indexes(:pages)

モデル.left_outer_joins(モデル名)

User.left_outer_joins(:posts)
# SELECT "users".* FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"

モデル.concat(モデル)

person.pets.count
# => 3

モデル.distinct([重複を削除するか])

User.select(:name).distinct

User.select(:name).distinct(false)

モデル.or(条件式)

Post.where("id = 1").or(Post.where("author_id = 3"))
# SELECT `posts`.* FROM `posts` WHERE ((id = 1) OR (author_id = 3))

モデル.unscope(条件式)

User.order('email DESC').unscope(:order) == User.all

モデル.previous_changes()

person.name # "bob"
person.name = 'robert'
person.save
person.previous_changes # {name: ["bob", "robert"]}

モデル.select(カラム名)

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

person.pets.select { |pet| pet.name =~ /oo/ }
# [
#   <Pet id: 2, name: "Spook", person_id: 1>,
#   <Pet id: 3, name: "Choo-Choo", person_id: 1>
# ]

モデル.only(条件)

Post.order('id asc').only(:where)

Post.order('id asc').only(:where, :order)

ActiveRecord::Base.transaction do
  例外が発生するかもしれない処理
end
  例外が発生しなかった場合の処理
resque => e
  例外が発生した場合の処理

モデル.transaction do
  例外が発生するかもしれない処理
end
  例外が発生しなかった場合の処理
resque => e
  例外が発生した場合の処理

def new
  User.transaction do
    a1 = User.new(name: 'tarou')
    a1.save!
    a2 = User.new(name: 'jirou')
    a2.save!
  end
  render text: '更新に成功しました'
  rescue: e
  render text: e.message
end

class CreateAddLockColumnToEntries < ActiveRecord::Migration
  def self.up
    create_table :add_lock_column_to_entries do |t|
      t.integer :entries, :lock_version, null: false, default: 0
    end
  end

  def self.down
    drop_table :add_lock_column_to_entries
  end
end

locked_entry = Entry.find(１，lock: true)