モデル.new(属性={})

User.new

User.new(name: "DHH")

User.new(name: 'bob', age: '18')

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

モデル.create(属性=nil, ブロック引数)

# 失敗したら例外発生
モデル.create!(属性=nil, ブロック引数)

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

users = User.where(name: 'Oscar')
users.create

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

User.create do |user|
    User.name = 'tenderlove'
end

モデル.find(件数..)

Person.find(1)

Person.find(1, 2, 6)

Person.find([7, 17])

モデル.find_by(条件..)

# 失敗したら例外発生
モデル.find_by!(条件..)

Page.find_by 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_sole_by(条件..)

Product.find_sole_by(["price = %?", price])

モデル.find_each(start: 開始(nil), finish: 終了(nil), batch_size: バッチサイズ(1000), error_on_ignore: ErrorIgnore(nil), order: 並び順=:asc, ブロック引数)

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

モデル.in_batches(of: バッチのサイズ=1000, start: 開始する主キーの値=nil, finish: 終了する主キーの値=nil, load: リレーションをロードするか=false, error_on_ignore: エラーを発生させるか=nil, order: 主キーの順序=:asc)

Person.where("age > 21").in_batches do |relation|
  relation.delete_all
  sleep(10) # 削除クエリの調整
end

モデル.find_or_create_by(条件, ブロック引数)

# 失敗したら例外発生
モデル.find_or_create_by!(条件, ブロック引数)

User.find_or_create_by(first_name: "Taraou")
#=> <User id: 1, first_name: "Tarou", last_name: nil>

User.find_or_create_by(first_name: "Taraou")
#=> <User id: 1, first_name: "Taraou", last_name: nil>

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

create_or_find_by(属性, ブロック引数)

# 失敗したら例外発生
f.create_or_find_by(属性, ブロック引数)

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

User.create_or_find_by!(first_name: 'Penélope')

モデル.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_signed(署名されたID, purpose: nil)

# 失敗したら例外発生
モデル.find_signed!(署名されたID, purpose: nil)

signed_id = User.first.signed_id expires_in: 15.minutes, purpose: :password_reset

User.find_signed signed_id #=> nil, since the purpose does not match

travel 16.minutes
User.find_signed signed_id, purpose: :password_reset #=> nil, since the signed id has expired

travel_back
User.find_signed signed_id, purpose: :password_reset #=> User.first

モデル.find_by_sql(SQL文, バインド=[], preparable: プレパラート=nil, ブロック引数)

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

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

select_all(SQL文, 名前=nil, バインド=[], プレパラート=nil, async: Async=false)

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(件数=nil)

# 失敗したら例外発生
モデル.first!(件数=nil)

Page.first
# SQL: SELECT "pages".* FROM "pages" LIMIT 1

Page.first(3)
# SQL: SELECT "pages".* FROM "pages" LIMIT 3

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

Page.first
# nil

モデル.second()

# 失敗したら例外発生
モデル.second!()

Person.second # returns the second object fetched by SELECT * FROM people
Person.offset(3).second # returns the second object from OFFSET 3 (which is OFFSET 4)
Person.where(["user_name = :u", { u: user_name }]).second

モデル.third()

# 失敗したら例外発生
モデル.third!()

Person.third # returns the third object fetched by SELECT * FROM people
Person.offset(3).third # returns the third object from OFFSET 3 (which is OFFSET 5)
Person.where(["user_name = :u", { u: user_name }]).third

モデル.fourth()

# 失敗したら例外発生
モデル.fourth!()

Person.fourth # returns the fourth object fetched by SELECT * FROM people
Person.offset(3).fourth # returns the fourth object from OFFSET 3 (which is OFFSET 6)
Person.where(["user_name = :u", { u: user_name }]).fourth

モデル.fifth()

# 失敗したら例外発生
モデル.fifth!()

Person.fifth # returns the fifth object fetched by SELECT * FROM people
Person.offset(3).fifth # returns the fifth object from OFFSET 3 (which is OFFSET 7)
Person.where(["user_name = :u", { u: user_name }]).fifth

モデル.last(件数=nil)

# 失敗したら例外発生
モデル.last!(件数=nil)

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

Page.last(2)
# SELECT "pages".* FROM "pages" ORDER BY "pages"."id" DESC LIMIT 2

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

Page.last
# nil

モデル.second_to_last()

# 失敗したら例外発生
モデル.second_to_last!()

Person.second_to_last # returns the second-to-last object fetched by SELECT * FROM people
Person.offset(3).second_to_last # returns the second-to-last object from OFFSET 3
Person.where(["user_name = :u", { u: user_name }]).second_to_last

モデル.third_to_last()

# 失敗したら例外発生
モデル.third_to_last!()

Person.third_to_last # returns the third-to-last object fetched by SELECT * FROM people
Person.offset(3).third_to_last # returns the third-to-last object from OFFSET 3
Person.where(["user_name = :u", { u: user_name }]).third_to_last

モデル.take(件数=nil)

# 失敗したら例外発生
モデル.take!(件数=nil)

Person.take
# SQL: SELECT * FROM people LIMIT 1

Person.take(2)
# SQL: SELECT * FROM people LIMIT 2

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

Person.take！

モデル.select(カラム名..)

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

person.pets.select do |pet|
  pet.name =~ /oo/
end

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

where句.invert_where()

User.where(accepted: true)
# WHERE `accepted` = 1

User.where(accepted: true).invert_where
# WHERE `accepted` != 1

class User
    scope :active, -> { where(accepted: true, locked: false) }
end

User.active
# WHERE `accepted` = 1 AND `locked` = 0

User.active.invert_where
# WHERE NOT (`accepted` = 1 AND `locked` = 0)

モデル.where_values_hash(テーブル名=klass.table_name)

User.where(name: 'Oscar').where_values_hash
#=> {name: "Oscar"}

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

モデルのリレーション.and(他のモデルのリレーション)

Post.where(id: [1, 2]).and(Post.where(id: [2, 3]))
# SELECT `posts`.* FROM `posts` WHERE `posts`.`id` IN (1, 2) AND `posts`.`id` IN (2, 3)

モデル.or(条件式)

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

Post.where(id: 1, name: "名前").or(Post.where(age: nil))
# SELECT "posts".* FROM "posts" WHERE ("posts"."id" = 1 AND "posts"."name" =  "名前" OR "posts"."age" IS NULL)

Post.where(id: 1).or(Post.where(name: "名前", age: nil))
# SELECT "posts".* FROM "posts" WHERE ("posts"."id" = 1 OR "posts"."name" =  "名前" AND "posts"."age" IS NULL)

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

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

モデル.reverse_order()

Page.order("category_id").reverse_order

モデル.distinct(重複を削除するか=true)

User.select(:name).distinct

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

モデル.sole()

sole()

モデル.none()

Post.none

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

モデル.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(値=true)

# 失敗したら例外発生
モデル.readonly!(値=true)

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

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

モデル.left_outer_joins(モデル名..)

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

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

モデル.preload(引数..)

User.preload(:posts)
# SELECT "posts".* FROM "posts" WHERE "posts"."user_id" IN (1, 2, 3)

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

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

モデル.having(条件式)

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

User.select('age, count(*) as count').group('age').having('count >= ?', 30)

モデル.except(条件式..)

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

モデル.from(値, サブクエリ=nil)

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

モデル.optimizer_hints(引数..)

Topic.optimizer_hints("MAX_EXECUTION_TIME(50000)", "NO_INDEX_MERGE(topics)")
# SELECT /*+ MAX_EXECUTION_TIME(50000) NO_INDEX_MERGE(topics) */ `topics`.* FROM `topics`

Topic.optimizer_hints("SeqScan(topics)", "Parallel(topics 8)")
# SELECT /*+ SeqScan(topics) Parallel(topics 8) */ "topics".* FROM "topics"

モデル.reselect(引数..)

Post.select(:title, :body)
# SELECT `posts`.`title`, `posts`.`body` FROM `posts`

Post.select(:title, :body).reselect(:created_at)
# SELECT `posts`.`created_at` FROM `posts`

モデル.strict_loading(値=true)

# 失敗したら例外発生
モデル.strict_loading!(値=true)

user = User.strict_loading.first
user.comments.to_a
=> ActiveRecord::StrictLoadingViolationError

モデル.merge(他の条件, *rest)

Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
# Performs a single join query with both where conditions.

recent_posts = Post.order('created_at DESC').first(5)
Post.where(published: true).merge(recent_posts)
# Returns the intersection of all published posts with the 5 most recently created posts.
# (This is just an example. You'd probably want to do this with a single query!)

モデルのコレクション.count(カラム名=nil)

User.count

Person.count(:age)

Person.group(:city).count

モデル.count_by_sql(SQL文)

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

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

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

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

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

モデル.changed()

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

モデル.pluck(カラム名..)

Person.pluck(:id)
# SELECT people.id FROM people

Person.pluck(:id, :name)
# SELECT people.id, people.name FROM people

Person.where(age: 21).limit(5).pluck(:id)
# SELECT people.id FROM people WHERE people.age = 21 LIMIT 5

pick(カラム名..)

User.where(id: 1).pick(:name)

モデル.changes()

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

indexes(テーブル名)

indexes(:pages)

モデル.cache_key(タイムスタンプカラム='updated_at')

Product.where("name like ?", "%Cosmic Encounter%").cache_key

Product.where("name like ?", "%Game%").cache_key(:last_reviewed_at)

モデル.previous_changes()

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

モデル.accessed_fields()

class PostsController < ActionController::Base
    after_action :print_accessed_fields, only: :index

    def index
        @posts = Post.all
    end

    private

    def print_accessed_fields
        p @posts.first.accessed_fields
    end
end

モデル.reload(オプション=nil)

@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(オプション引数)

# 失敗したら例外発生
モデル.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=:all, 属性)

# 失敗したら例外発生
モデル.update！(ID=:all, 属性)

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(SQL文のSET部分、配列、またはハッシュ)

Customer.update_all wants_email: true

Book.where('title LIKE ?', '%Rails%').update_all(author: 'David')

Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(author: 'David')

Invoice.update_all('number = id')

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

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

モデル.touch([名前])

product.touch

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

モデル.touch_all(時刻のカラム名.., time: 時間=nil)

Person.all.touch_all
# "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670'"

Person.all.touch_all(:created_at)
# "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670', \"created_at\" = '2018-01-04 22:55:23.132670'"

Person.all.touch_all(time: Time.new(2020, 5, 16, 0, 0, 0))
# "UPDATE \"people\" SET \"updated_at\" = '2020-05-16 00:00:00'"

モデル.update_counters(ID, 条件)

Post.where(author_id: author.id).update_counters(comment_count: 1)

モデル.update_columns(属性)

user.update_columns(last_request_at: Time.current)

モデル.insert_all(属性, returning: nil, unique_by: nil, record_timestamps: nil)

# 失敗したら例外発生
モデル.insert_all!(属性, returning: nil, unique_by: nil, record_timestamps: nil)

Book.insert_all([
  { id: 1, title: "Rework", author: "David" },
  { id: 1, title: "Eloquent Ruby", author: "Russ" }
])

モデル.delete(IDかIDの配列)

Todo.delete(1)

Todo.delete([2,3,4])

モデル.delete_all()

Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all

モデル.delete_by(条件..)

Person.delete_by(id: 13)
Person.delete_by(name: 'Spartacus', rating: 4)
Person.delete_by("published_at < ?", 2.weeks.ago)

モデル.destroy(ID)

Todo.destroy(1)

Todo.destroy([1,2,3])

モデル.destroy_all()

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

モデル.destroy_by(条件..)

Person.destroy_by(id: 13)
Person.destroy_by(name: 'Spartacus', rating: 4)
Person.destroy_by("published_at < ?", 2.weeks.ago)

モデル.clone()

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

モデル.increment(レコード, インクリメントする値, touch: タイムスタンプ列=nil)

# 失敗したら例外発生
モデル.increment!(レコード, インクリメントする値, touch: タイムスタンプ列=nil)

Page.increment(:num, 3)

モデル.changed_attributes()

person.name #=> "bob"
person.name = 'robert'
person.changed_attributes #=> {"name" => "bob"}

モデル.attribute_present?(属性名)

person.attribute_present?(:title)
# true

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

person.respond_to?(:name)
# true

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

モデル.has_attribute?(属性)

person.has_attribute?(:name)
# true

person.has_attribute?(:nothing)
# false

モデル.structurally_compatible?(調べる条件)

Post.where("id = 1").structurally_compatible?(Post.where("author_id = 3"))
#=> true

Post.joins(:comments).structurally_compatible?(Post.where("id = 1"))
#=> false

モデル.changed?()

@user.changed?

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

モデル.new_record?()

User.new_record?

モデル.persisted?()

User.persisted?

モデル.destroyed?()

@user.destroyed?

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")

モデル.instance_method_already_implemented?(属性)

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

Person.instance_method_already_implemented?(:name)
# false

to_model()

class Person
    include ActiveModel::Conversion
end
person = Person.new
person.to_model == person
# true

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

to_param()

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

モデル.toggle(属性)

# 失敗したら例外発生
モデル.toggle!(属性)

user = User.first
user.banned? #=> false
user.toggle(:banned)
user.banned? #=> true

モデル.create_with(属性)

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

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

モデル.annotate(引数..)

User.annotate("selecting user names").select(:name)
# SELECT "users"."name" FROM "users" /* selecting user names */

User.annotate("selecting", "user", "names").select(:name)
# SELECT "users"."name" FROM "users" /* selecting */ /* user */ /* names */

モデル.excluding(レコード..)

Post.excluding(post)
# SELECT "posts".* FROM "posts" WHERE "posts"."id" != 1

Post.excluding(post_one, post_two)
# SELECT "posts".* FROM "posts" WHERE "posts"."id" NOT IN (1, 2)

モデル.as_json(オプション=nil)

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" } ] }

モデル.from_json(JSON文字列, include_root=include_root_in_json)

json = { name: 'bob', age: 22, awesome:true }.to_json
person = Person.new
person.from_json(json) #=> #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
person.name            #=> "bob"
person.age             #=> 22
person.awesome         #=> true

モデル.clear_validators!()

Person.clear_validators!

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

モデル.only(条件..)

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

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

モデル.transaction(requires_new: 新規作成=nil, isolation: isolation=nil, joinable: 結合=true, ブロック引数)

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)

モデル.in_order_of(カラム, 値)

User.in_order_of(:id, [1, 5, 3])
# SELECT "users".* FROM "users" ORDER BY FIELD("users"."id", 1, 5, 3)

alias_attribute(エイリアス名, エイリアス元の属性名)

alias_attribute :subject, :title

assign_attributes(属性のハッシュ)

class Cat
  include ActiveModel::AttributeAssignment
  attr_accessor :name, :status
end
cat = Cat.new
cat.assign_attributes(name: "Gorby", status: "yawning")
cat.name #=> 'Gorby'
cat.status #=> 'yawning'
cat.assign_attributes(status: "sleeping")
cat.name #=> 'Gorby'
cat.status #=> 'sleeping'

to_key()

class Person
    include ActiveModel::Conversion
    attr_accessor :id
    def initialize(id)
        @id = id
    end
end
person = Person.new(1)
person.to_key #=> [1]

to_param()

class Person
    include ActiveModel::Conversion
    attr_accessor :id
    def initialize(id)
        @id = id
    end
    def persisted?
        true
    end
end
person = Person.new(1)
person.to_param
#=> "1"

to_partial_path()

class Person
    include ActiveModel::Conversion
end
person = Person.new
person.to_partial_path
#=> "people/person"

has_secure_password(属性=:password, validations: バリデーション=true)

class User < ActiveRecord::Base
    has_secure_password
    has_secure_password :recovery_password, validations: false
end
user = User.new(name: 'david', password: '', password_confirmation: 'nomatch')
user.save                                                  #=> false, password required
user.password = 'mUc3m00RsqyRe'
user.save                                                  #=> false, confirmation doesn't match
user.password_confirmation = 'mUc3m00RsqyRe'
user.save                                                  #=> true
user.recovery_password = "42password"
user.recovery_password_digest                              #=> "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
user.save                                                  #=> true
user.authenticate('notright')                              #=> false
user.authenticate('mUc3m00RsqyRe')                         #=> user
user.authenticate_recovery_password('42password')          #=> user
User.find_by(name: 'david')&.authenticate('notright')      #=> false
User.find_by(name: 'david')&.authenticate('mUc3m00RsqyRe') #=> user

serializable_hash(オプション=nil)

class Person
    include ActiveModel::Serialization
    attr_accessor :name, :age
    def attributes
        {'name' => nil, 'age' => nil}
    end
    def capitalized_name
        name.capitalize
    end
end
person = Person.new
person.name = 'bob'
person.age  = 22
person.serializable_hash                #=> {"name"=>"bob", "age"=>22}
person.serializable_hash(only: :name)   #=> {"name"=>"bob"}
person.serializable_hash(except: :name) #=> {"age"=>22}
person.serializable_hash(methods: :capitalized_name)
#=> {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}

extract_associated(アソシエーション)

account.memberships.extract_associated(:user)
#=> Returns collection of User records

モデル.load([ブロック])

Post.where(published: true).load
#=> #<ActiveRecord::Relation>

モデル.load_async()

Post.where(published: true).load_async
#=> #<ActiveRecord::Relation>

default_scope(条件式=nil, all_queries: 全てのクエリ=nil, ブロック引数)

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

unscoped(ブロック引数)

Post.unscoped.all

Post.unscoped {
  Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
}

モデル.unscope(条件式..)

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

User.select(:id).order('email DESC').unscope(:select, :order)

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

モデル.scoping(all_queries: 全てのクエリ=nil, ブロック引数)

Comment.where(post_id: 1).scoping do
    Comment.first
end
#=> SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1

モデル.to_sql()

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

delegated_type(ロール, types: 型=nil, オプション引数)

class Entry < ApplicationRecord
    delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
end

Entry#entryable_class #=> +Message+ or +Comment+
Entry#entryable_name  #=> "message" or "comment"
Entry.messages        #=> Entry.where(entryable_type: "Message")
Entry#message?        #=> true when entryable_type == "Message"
Entry#message         #=> returns the message record, when entryable_type == "Message", otherwise nil
Entry#message_id      #=> returns entryable_id, when entryable_type == "Message", otherwise nil
Entry.comments        #=> Entry.where(entryable_type: "Comment")
Entry#comment?        #=> true when entryable_type == "Comment"
Entry#comment         #=> returns the comment record, when entryable_type == "Comment", otherwise nil
Entry#comment_id      #=> returns entryable_id, when entryable_type == "Comment", otherwise nil

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

モデル.minimum(カラム名)

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

モデル.sum(カラム名=nil, ブロック引数)

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

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

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