1 Active Record 쿼리 인터페이스란 무엇인가?

데이터베이스 레코드를 찾기 위해 원시 SQL을 사용하는 것에 익숙하다면, 일반적으로 Rails에서 동일한 작업을 수행하는 더 좋은 방법이 있다는 것을 알게 될 것입니다. Active Record는 대부분의 경우 SQL을 사용할 필요 없이 작업을 수행할 수 있도록 해줍니다.

Active Record는 데이터베이스에서 쿼리를 수행하며, MySQL, MariaDB, PostgreSQL 및 SQLite를 포함한 대부분의 데이터베이스 시스템과 호환됩니다. 사용 중인 데이터베이스 시스템에 관계없이 Active Record 메소드 형식은 항상 동일합니다.

이 가이드의 코드 예제는 다음 중 하나 이상의 모델을 참조합니다.

팁: 다음 모델은 id를 기본 키로 사용합니다(다른 값으로 지정되지 않은 경우).

class Author < ApplicationRecord
  has_many :books, -> { order(year_published: :desc) }
end

class Book < ApplicationRecord
  belongs_to :supplier
  belongs_to :author
  has_many :reviews
  has_and_belongs_to_many :orders, join_table: 'books_orders'

  scope :in_print, -> { where(out_of_print: false) }
  scope :out_of_print, -> { where(out_of_print: true) }
  scope :old, -> { where(year_published: ...50.years.ago.year) }
  scope :out_of_print_and_expensive, -> { out_of_print.where('price > 500') }
  scope :costs_more_than, ->(amount) { where('price > ?', amount) }
end

class Customer < ApplicationRecord
  has_many :orders
  has_many :reviews
end

class Order < ApplicationRecord
  belongs_to :customer
  has_and_belongs_to_many :books, join_table: 'books_orders'

  enum :status, [:shipped, :being_packed, :complete, :cancelled]

  scope :created_before, ->(time) { where(created_at: ...time) }
end

class Review < ApplicationRecord
  belongs_to :customer
  belongs_to :book

  enum :state, [:not_reviewed, :published, :hidden]
end

class Supplier < ApplicationRecord
  has_many :books
  has_many :authors, through: :books
end

서점 모델의 다이어그램

2 데이터베이스에서 객체 검색하기

데이터베이스에서 객체를 검색하기 위해 Active Record는 여러 개의 검색 메소드를 제공합니다. 각 검색 메소드는 원시 SQL을 작성하지 않고도 데이터베이스에서 특정 쿼리를 수행할 수 있도록 인수를 전달할 수 있습니다.

다음은 사용 가능한 메소드입니다.

where 및 group과 같이 컬렉션을 반환하는 검색 메소드는 ActiveRecord::Relation의 인스턴스를 반환합니다. find 및 first와 같이 단일 엔티티를 찾는 메소드는 모델의 단일 인스턴스를 반환합니다.

Model.find(options)의 주요 작업은 다음과 같이 요약할 수 있습니다.

제공된 옵션을 동등한 SQL 쿼리로 변환합니다.
SQL 쿼리를 실행하고 데이터베이스에서 해당 결과를 검색합니다.
결과 행마다 적절한 모델의 동등한 루비 객체를 인스턴스화합니다.
after_find 및 after_initialize 콜백을 실행합니다(있는 경우).

2.1 단일 객체 검색

Active Record는 단일 객체를 검색하는 여러 가지 방법을 제공합니다.

2.1.1 `find`

find 메소드를 사용하여 지정된 기본 키에 해당하는 객체를 검색할 수 있습니다. 예를 들어:

# 기본 키 (id)가 10인 고객을 찾습니다.
irb> customer = Customer.find(10)
=> #<Customer id: 10, first_name: "Ryan">

위의 SQL과 동일한 쿼리는 다음과 같습니다.

SELECT * FROM customers WHERE (customers.id = 10) LIMIT 1

find 메소드는 일치하는 레코드가 없는 경우 ActiveRecord::RecordNotFound 예외를 발생시킵니다.

이 메소드를 사용하여 여러 객체를 쿼리할 수도 있습니다. find 메소드를 호출하고 기본 키의 배열을 전달하면, 반환되는 값은 공급된 기본 키에 대한 모든 일치하는 레코드를 포함하는 배열입니다. 예를 들어: ```irb

주요 키가 1과 10인 고객을 찾습니다.

irb> customers = Customer.find([1, 10]) # OR Customer.find(1, 10) => [#, #] ```

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers WHERE (customers.id IN (1,10))

경고: find 메소드는 제공된 주요 키에 대해 일치하는 레코드가 모두 찾아지지 않으면 ActiveRecord::RecordNotFound 예외를 발생시킵니다.

2.1.2 `take`

take 메소드는 암시적인 정렬 없이 레코드를 가져옵니다. 예를 들어:

irb> customer = Customer.take
=> #<Customer id: 1, first_name: "Lifo">

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers LIMIT 1

take 메소드는 레코드를 찾지 못하면 nil을 반환하며 예외는 발생하지 않습니다.

take 메소드에 숫자 인수를 전달하여 해당 수의 결과를 반환할 수 있습니다. 예를 들어:

irb> customers = Customer.take(2)
=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 220, first_name: "Sara">]

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers LIMIT 2

take! 메소드는 take와 동일하게 작동하지만 일치하는 레코드가 없으면 ActiveRecord::RecordNotFound를 발생시킵니다.

팁: 검색된 레코드는 데이터베이스 엔진에 따라 다를 수 있습니다.

2.1.3 `first`

first 메소드는 주요 키(기본값)로 정렬된 첫 번째 레코드를 찾습니다. 예를 들어:

irb> customer = Customer.first
=> #<Customer id: 1, first_name: "Lifo">

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.id ASC LIMIT 1

first 메소드는 일치하는 레코드를 찾지 못하면 nil을 반환하며 예외는 발생하지 않습니다.

기본 범위에 정렬 메소드가 포함되어 있는 경우 first는 이 정렬에 따라 첫 번째 레코드를 반환합니다.

first 메소드에 숫자 인수를 전달하여 해당 수의 결과를 반환할 수 있습니다. 예를 들어:

irb> customers = Customer.first(3)
=> [#<Customer id: 1, first_name: "Lifo">, #<Customer id: 2, first_name: "Fifo">, #<Customer id: 3, first_name: "Filo">]

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.id ASC LIMIT 3

order를 사용하여 정렬된 컬렉션에서 first는 order에 지정된 속성에 따라 첫 번째 레코드를 반환합니다.

irb> customer = Customer.order(:first_name).first
=> #<Customer id: 2, first_name: "Fifo">

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.first_name ASC LIMIT 1

first! 메소드는 first와 동일하게 작동하지만 일치하는 레코드가 없으면 ActiveRecord::RecordNotFound를 발생시킵니다.

2.1.4 `last`

last 메소드는 주요 키(기본값)로 정렬된 마지막 레코드를 찾습니다. 예를 들어:

irb> customer = Customer.last
=> #<Customer id: 221, first_name: "Russel">

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.id DESC LIMIT 1

last 메소드는 일치하는 레코드를 찾지 못하면 nil을 반환하며 예외는 발생하지 않습니다.

기본 범위에 정렬 메소드가 포함되어 있는 경우 last는 이 정렬에 따라 마지막 레코드를 반환합니다.

last 메소드에 숫자 인수를 전달하여 해당 수의 결과를 반환할 수 있습니다. 예를 들어:

irb> customers = Customer.last(3)
=> [#<Customer id: 219, first_name: "James">, #<Customer id: 220, first_name: "Sara">, #<Customer id: 221, first_name: "Russel">]

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.id DESC LIMIT 3

order를 사용하여 정렬된 컬렉션에서 last는 order에 지정된 속성에 따라 마지막 레코드를 반환합니다.

irb> customer = Customer.order(:first_name).last
=> #<Customer id: 220, first_name: "Sara">

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers ORDER BY customers.first_name DESC LIMIT 1

last! 메소드는 last와 동일하게 작동하지만 일치하는 레코드가 없으면 ActiveRecord::RecordNotFound를 발생시킵니다.

2.1.5 `find_by`

find_by 메소드는 일치하는 조건을 가진 첫 번째 레코드를 찾습니다. 예를 들어:

irb> Customer.find_by first_name: 'Lifo'
=> #<Customer id: 1, first_name: "Lifo">

irb> Customer.find_by first_name: 'Jon'
=> nil

다음과 같이 작성하는 것과 동일합니다:

Customer.where(first_name: 'Lifo').take

위의 SQL과 동일한 쿼리는 다음과 같습니다:

SELECT * FROM customers WHERE (customers.first_name = 'Lifo') LIMIT 1

위의 SQL에서는 ORDER BY가 없음을 유의하십시오. find_by 조건이 여러 레코드와 일치할 수 있는 경우, 결정론적인 결과를 보장하기 위해 정렬을 적용해야 합니다.

find_by! 메서드는 find_by와 정확히 동일하게 동작하지만, 일치하는 레코드가 없는 경우 ActiveRecord::RecordNotFound를 발생시킵니다. 예를 들어:

irb> Customer.find_by! first_name: 'does not exist'
ActiveRecord::RecordNotFound

이는 다음과 같이 작성하는 것과 동일합니다:

Customer.where(first_name: 'does not exist').take!

2.2 일괄적으로 여러 객체 검색하기

우리는 종종 대량의 레코드를 반복해서 처리해야 할 때가 있습니다. 예를 들어 대량의 고객에게 뉴스레터를 보내거나 데이터를 내보낼 때입니다.

이는 간단해 보일 수 있습니다:

# 테이블이 큰 경우 메모리를 너무 많이 소비할 수 있습니다.
Customer.all.each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

하지만 이 접근 방식은 테이블 크기가 커질수록 점점 비실용적이 됩니다. 왜냐하면 Customer.all.each는 Active Record에게 한 번에 전체 테이블을 가져오도록 지시하고, 각 행마다 모델 객체를 빌드한 다음 모델 객체의 전체 배열을 메모리에 유지하기 때문입니다. 실제로 레코드 수가 많으면 전체 컬렉션이 사용 가능한 메모리 양을 초과할 수 있습니다.

Rails는 이 문제를 해결하기 위해 기록을 메모리에 친화적인 일괄 처리를 위해 레코드를 나누는 두 가지 메서드를 제공합니다. 첫 번째 메서드인 find_each는 레코드를 검색하고 각 레코드를 모델로서 블록에 개별적으로 전달합니다. 두 번째 메서드인 find_in_batches는 레코드를 검색하고 전체 일괄을 모델의 배열로서 블록에 전달합니다.

팁: find_each 및 find_in_batches 메서드는 한 번에 모든 레코드를 메모리에 저장할 수 없는 대량의 레코드를 일괄 처리하는 데 사용됩니다. 1000개의 레코드를 루프하는 것만 필요한 경우 일반적인 검색 메서드가 선호됩니다.

2.2.1 `find_each`

find_each 메서드는 레코드를 일괄적으로 검색하고 각 레코드를 블록에 개별적으로 전달합니다. 다음 예제에서 find_each는 1000개씩 고객을 일괄적으로 검색하고 하나씩 블록에 전달합니다:

Customer.find_each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

이 과정은 필요에 따라 더 많은 일괄을 가져와서 모든 레코드가 처리될 때까지 반복됩니다.

find_each는 위에서 본 것처럼 모델 클래스에서 작동하며, 관계에서도 작동합니다:

Customer.where(weekly_subscriber: true).find_each do |customer|
  NewsMailer.weekly(customer).deliver_now
end

단, 정렬이 없는 경우에만 작동합니다. 이는 메서드가 반복하기 위해 내부적으로 순서를 강제해야 하기 때문입니다.

수신자에 정렬이 있는 경우 동작은 config.active_record.error_on_ignored_order 플래그에 따라 달라집니다. true인 경우 ArgumentError가 발생하고, 그렇지 않으면 순서가 무시되고 경고가 발생합니다(기본값). 이는 아래에서 설명하는 :error_on_ignore 옵션으로 재정의할 수 있습니다.

2.2.1.1 `find_each`의 옵션

:batch_size

:batch_size 옵션을 사용하면 각 일괄에서 검색할 레코드 수를 지정할 수 있습니다. 예를 들어 5000개씩 일괄로 레코드를 검색하려면:

Customer.find_each(batch_size: 5000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

:start

기본적으로 레코드는 기본 키의 오름차순으로 가져옵니다. :start 옵션을 사용하면 가장 낮은 ID가 필요한 것이 아닌 경우에 시퀀스의 첫 번째 ID를 구성할 수 있습니다. 예를 들어, 2000부터 시작하는 기본 키를 가진 고객에게만 뉴스레터를 보내려는 경우:

Customer.find_each(start: 2000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

:finish

start 옵션과 유사하게, :finish를 사용하면 가장 높은 ID가 필요한 것이 아닌 경우에 시퀀스의 마지막 ID를 구성할 수 있습니다. 예를 들어, 2000부터 10000까지의 기본 키를 가진 고객에게만 뉴스레터를 보내려는 경우:

Customer.find_each(start: 2000, finish: 10000) do |customer|
  NewsMailer.weekly(customer).deliver_now
end

다른 예로는 동일한 처리 큐를 처리하는 여러 워커를 원하는 경우입니다. 각 워커가 10000개의 레코드를 처리하도록 하려면 각 워커에 적절한 :start 및 :finish 옵션을 설정하면 됩니다.

:error_on_ignore

관계에 정렬이 있는 경우에 순서가 무시될 때 오류가 발생해야 하는지를 지정하기 위해 응용 프로그램 구성을 재정의합니다.

:order

기본 키 순서를 지정합니다(:asc 또는 :desc일 수 있음). 기본값은 :asc입니다. ruby Customer.find_each(order: :desc) do |customer| NewsMailer.weekly(customer).deliver_now end

2.2.2 `find_in_batches`

find_in_batches 메소드는 find_each와 유사하게 레코드의 일꾼을 검색합니다. 차이점은 find_in_batches는 개별적으로가 아닌 모델의 배열로 블록에 일꾼을 제공합니다. 다음 예제는 최대 1000명의 고객을 한 번에 배열로 제공하고, 마지막 블록에는 남은 고객을 포함합니다:

# 1000명의 고객을 한 번에 배열로 add_customers에 전달합니다.
Customer.find_in_batches do |customers|
  export.add_customers(customers)
end

find_in_batches는 위에서 본 것처럼 모델 클래스뿐만 아니라 관계에도 작동합니다:

# 최근 활동한 1000명의 고객을 한 번에 배열로 add_customers에 전달합니다.
Customer.recently_active.find_in_batches do |customers|
  export.add_customers(customers)
end

내부적으로 반복을 위해 순서를 강제해야하기 때문에 정렬이 없는 경우에만 작동합니다.

2.2.2.1 `find_in_batches`의 옵션

find_in_batches 메소드는 find_each와 동일한 옵션을 받습니다:

:batch_size

find_each와 마찬가지로 batch_size는 각 그룹에서 검색할 레코드의 수를 설정합니다. 예를 들어, 2500개의 레코드를 한 번에 검색하려면 다음과 같이 지정할 수 있습니다:

Customer.find_in_batches(batch_size: 2500) do |customers|
  export.add_customers(customers)
end

:start

start 옵션은 레코드를 선택할 시작 ID를 지정할 수 있습니다. 기본적으로 레코드는 기본 키의 오름차순으로 검색됩니다. 예를 들어, 2500개의 레코드로 시작하는 ID 5000의 고객을 검색하려면 다음 코드를 사용할 수 있습니다:

Customer.find_in_batches(batch_size: 2500, start: 5000) do |customers|
  export.add_customers(customers)
end

:finish

finish 옵션은 검색할 레코드의 끝 ID를 지정할 수 있습니다. 아래 코드는 ID 7000까지 고객을 검색하는 경우를 보여줍니다:

Customer.find_in_batches(finish: 7000) do |customers|
  export.add_customers(customers)
end

:error_on_ignore

error_on_ignore 옵션은 관계에 특정 순서가 있는 경우 오류를 발생시킬지 여부를 지정합니다.

3 조건

where 메소드는 반환되는 레코드를 제한하는 조건을 지정할 수 있습니다. 이는 SQL 문의 WHERE 부분을 나타냅니다. 조건은 문자열, 배열 또는 해시로 지정할 수 있습니다.

3.1 순수 문자열 조건

조건을 추가하려면 Book.where("title = 'Introduction to Algorithms'")와 같이 지정할 수 있습니다. 이는 title 필드 값이 'Introduction to Algorithms'인 모든 책을 찾습니다.

경고: 순수 문자열로 조건을 직접 작성하면 SQL 인젝션 취약점에 노출될 수 있습니다. 예를 들어, Book.where("title LIKE '%#{params[:title]}%'")은 안전하지 않습니다. 조건을 처리하는 우선적인 방법은 배열을 사용하는 것입니다.

3.2 배열 조건

제목이 매개변수에서 가져올 수 있는 경우 어떻게 될까요? 그렇다면 다음과 같이 찾을 수 있습니다:

Book.where("title = ?", params[:title])

Active Record는 첫 번째 인수를 조건 문자열로 사용하고 추가 인수는 그 안의 물음표 (?)를 대체합니다.

여러 조건을 지정하려면:

Book.where("title = ? AND out_of_print = ?", params[:title], false)

이 예제에서 첫 번째 물음표는 params[:title]의 값으로 대체되고 두 번째 물음표는 어댑터에 따라 false의 SQL 표현으로 대체됩니다.

이 코드는 다음 코드보다 훨씬 좋습니다:

Book.where("title = ?", params[:title])

이 코드는 다음 코드보다 훨씬 좋습니다:

Book.where("title = #{params[:title]}")

인수의 안전성 때문입니다. 변수를 직접 조건 문자열에 넣으면 변수가 데이터베이스로 그대로 전달됩니다. 이는 악의적인 의도를 가진 사용자로부터 직접적으로 이스케이프되지 않은 변수가 될 것입니다. 이렇게 하면 사용자가 데이터베이스를 악용할 수 있으므로 데이터베이스 전체가 위험에 빠집니다. 인수를 직접 조건 문자열 안에 넣지 마세요.

팁: SQL 인젝션의 위험에 대한 자세한 내용은 Ruby on Rails 보안 가이드를 참조하세요.

3.2.1 플레이스홀더 조건

매개변수의 (?) 대체 스타일과 마찬가지로 조건 문자열에 키와 해당 키/값 해시를 함께 지정할 수도 있습니다:

Book.where("created_at >= :start_date AND created_at <= :end_date",
  { start_date: params[:start_date], end_date: params[:end_date] })

이렇게 하면 변수 조건이 많을 때 더 명확하게 읽을 수 있습니다.

3.2.2 `LIKE`를 사용하는 조건

조건 인수는 SQL 인젝션을 방지하기 위해 자동으로 이스케이프되지만 SQL LIKE 와일드카드(% 및 _)는 **이스케이프되지 않습니다. 이는 인자로서 이스케이프되지 않은 값을 사용하면 예상치 못한 동작을 일으킬 수 있습니다. 예를 들어: ruby Book.order(:created_at).order(:title)