[RubyOnRails Guides] Active Record Query Interface - 2편

[RubyOnRails Guides] Active Record Query Interface - 2편

💼 서론

• RubyOnRails Guides Active Record Basics 를 참고해 작성한 글입니다.
• Ruby version은 2.6.3을 사용합니다.
• Ruby On Rails version은 5.2.1을 사용합니다.
• 1편에서는 단건 및 복수 조회, 조건, 정렬, 그룹 등을 정리했습니다 (참고링크)

Locking Records for Update

• DB 트랜잭션이 2개 이상 진행될 경우 프로세스 내에서 작업하는 쓰레드 자원이 꼬여 race codnition(경쟁 상태) 문제가 발생해 우리가 기대한 처리결과가 나오지 않을 경우가 있다.
• 따라서 우리는 이런 경우 Thread Safe 하게 해줘야 하는데, DB에서는 Lcok 기능으로 가능하게 한다.
• Locking이란 두개 이상의 작업이 동시에 진행될 경우 이전 작업이 끝날때 까지 대기하게 만드는 것입니다. Locking을 설정하면 트랜잭션이 unlock 할 때까지 데이터를 독점적으로 사용할 수 있습니다.

• Locking에는 두가지 종류가 있습니다. 낙관적 잠금, 비관적 잠금입니다.

Optimistic locking(낙관적 잠금)

• 여러 사용자가 편집을 위해 동일한 레코드에 접근할 수 있으며 데이터와 최소 충돌을 가정합니다.
• 테이블에 lock_version 컬럼이 있고 레코드가 업데이트 될 때마다 lock_version을 증가시킵니다.
• 현재 lock_version 컬럼 값보다 더 낮은 값으로 업데이트를 할 경우 ActvieRecord::StaleObejctError와 함께 업데이트 요청이 실패합니다.

1. 운영자가 배송상태를 변경하기 위해 version이 1인 주문 정보를 조회합니다.
2. 고객은 배송지를 변경하기 위해 version이 1인 주문정보를 조회합니다.
3. 운영자는 배송상태를 배송중으로 변경합니다.
4. 고객은 배송지를 변경합니다.
5. 운영자의 트랜잭션이 커밋되면서 version이 2로 변경됩니다.
6. 이후에 고객의 트랜잭션을 커밋하면 version이 다르기 떄문에 커밋이 실패하게 됩니다.

• 위의 메커니즘처럼 트랜잭션 충돌이 발생하지 않도록 처리하게 됩니다.
• 루비에서 낙관적 잠금을 하고, 아래와 같이 실행하면 ActvieRecord::StaleObejctError가 발생하게 됩니다.

c1 = Client.find(1)
c2 = Client.find(1)

c1.first_name = "Michael"
c1.save

c2.name = "should fail"
c2.save # Raises an ActiveRecord::StaleObjectError

• lock_version의 컬럼명을 변경할수도 있습니다.

class Client < ApplicationRecord
    lock_optimistically = true  
    self.locking_column = :lock_client_column
end

Pessimistic Locking(비관적 잠금)

• DB에서 사용하는 기본 locking 메커니즘을 사용한다.
• 관계를 작성할 때 lock을 사용하면 선택한 행(row)에서 exclusive lock을 얻습니다.
• 비관적 잠금은 Dead Lock(교착 상태)에 빠질수 있다.
  1. 스레드 1: A 정보를 구하고 잠금
  2. 스레드 2 : B 정보를 구하고 잠금
  3. 스레드 1: B 정보를 구하고자 할 떄 블로킹
  4. 스레드 2: A 정보를 구하고자 할 떄 블로킹
• 교착 상태를 방지하기 위해 lock을 사용하는 관계는 일반적으로 트랜잭션 내부에 랩핑(warpped) 됩니다.

Item.transaction do
  i = Item.lock.first
  i.name = 'Jones'
  i.save!
end

SQL (0.2ms)   BEGIN
Item Load (0.3ms)   SELECT * FROM `items` LIMIT 1 FOR UPDATE
Item Update (0.4ms)   UPDATE `items` SET `updated_at` = '2009-02-07 18:05:56', `name` = 'Jones' WHERE `id` = 1
SQL (0.8ms)   COMMIT

• lock의 다른 유형을 허용하기 위해 원시 SQL을 메소드에 전달할 수 도 있습니다.

Item.transaction do
  i = Item.lock("LOCK IN SHARE MODE").find(1)
  i.increment!(:views)
end

• 모델 인스턴스가 이미 있는 경우 아래와 같은 코드로 트랜잭션을 시작하고 잠금을 할 수 있습니다.

item = Item.first
item.with_lock do
  # This block is called within a transaction,
  # item is already locked.
  item.increment!(:views)
end

Joining Tables

joins

• 조인의 종류는 여러가지가 있습니다.

1. 특정 JOIN 절을 지정해 SQL을 사용할 수 있습니다.

    Author.joins("INNER JOIN posts ON posts.author_id = authors.id AND posts.published = 't'")
   
    SELECT authors.* FROM authors INNER JOIN posts ON posts.author_id = authors.id AND posts.published = 't'

2. Assciation 이름을 조인 방법으로 사용할 수 있습니다.

    class Category < ApplicationRecord
      has_many :articles
    end
   
    class Article < ApplicationRecord
      belongs_to :category
      has_many :comments
      has_many :tags
    end
   
    class Comment < ApplicationRecord
      belongs_to :article
      has_one :guest
    end
   
    class Guest < ApplicationRecord
      belongs_to :comment
    end
   
    class Tag < ApplicationRecord
      belongs_to :article
    end

   • 알아서 INNER JOIN이 됩니다.

3. 단일 연결 조인 하는 방법

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

   • 1:N의 관계이면 중복 cateogoies가 있는데 disinct 메소드를 사용하면 됩니다.

     Category.joins(:articles).distinct

4. 다중 연결조인하는 방법

    Article.joins(:category, :comments)
   
    SELECT articles.* FROM articles
      INNER JOIN categories ON categories.id = articles.category_id
      INNER JOIN comments ON comments.article_id = articles.id

    Category.joins(articles: [{ comments: :guest }, :tags])
   
    SELECT categories.* FROM categories
      INNER JOIN articles ON articles.category_id = categories.id
      INNER JOIN comments ON comments.article_id = articles.id
      INNER JOIN guests ON guests.comment_id = comments.id
      INNER JOIN tags ON tags.article_id = articles.id

• Join Table에 조건을 지정할 수도 있습니다.

time_range = (Time.now.midnight - 1.day)..Time.now.midnight
Client.joins(:orders).where('orders.created_at' => time_range)

• 위와 같이 코드를 작성하면 BETWEEN문의 조건이 포함되게 됩니다.

left_outer_joins

• OuterJoin을 하는 방법입니다.

Author.left_outer_joins(:posts).distinct.select('authors.*, COUNT(posts.*) AS posts_count').group('authors.id')

SELECT DISTINCT authors.*, COUNT(posts.*) AS posts_count FROM "authors"
LEFT OUTER JOIN posts ON posts.author_id = authors.id GROUP BY authors.id

Eager Loding

• 즉시로딩으로 Model.find() 시 연관관계로 되어 있는 코드를 한방에 불러오는 것 입니다.

N + 1 쿼리 문제

clients = Client.limit(10)

clients.each do |client|
  puts client.address.postcode
end

• 10명의 클라이언트를 조회한 이후에 주소를 불러오면 10개의 클라이언트를 불러오는 SQL하나와 각 주소를 불러오는 SQL 10개로 N + 1 문제가 발생하게 됩니다.

N + 1 해결 방법

• 이걸 해결 하기 위해 eager를 사용하면 됩니다.
• Lazy Loding이 아니라 Eager Loding으로 Clinet를 조회할때 join으로 address까지 같이 불러오게 됩니다.

clients = Client.includes(:address).limit(10)

clients.each do |client|
  puts client.address.postcode
end

SELECT * FROM clients LIMIT 10
SELECT addresses.* FROM addresses
  WHERE (addresses.client_id IN (1,2,3,4,5,6,7,8,9,10))

• 아래와 같이 조건을 지정할 수도 있습니다.

Article.includes(:comments).where(comments: { visible: true })

SELECT "articles"."id" AS t0_r0, ... "comments"."updated_at" AS t1_r5 FROM "articles" LEFT OUTER JOIN "comments" ON "comments"."article_id" = "articles"."id" WHERE (comments.visible = 1)

range

• 범위를 지정하면 연관 관계 모델에 대한 메서드 호출로 참조 될 수 있는 일반적으로 사용되는 쿼리를 지정할 수 있습니다.
• scope는 아래와 같이 설정할 수 있습니다.

class Article < ApplicationRecord
  scope :published, -> { where(published: true) }
end

class Article < ApplicationRecord
  def self.published
    where(published: true)
  end
end

• 2개다 모두 동일하며 원하시는 방식으로 설정하면 됩니다.
• range 내에서도 연결이 가능하빈다.

class Article < ApplicationRecord
  scope :published,               -> { where(published: true) }
  scope :published_and_commented, -> { published.where("comments_count > 0") }
end

• published 범위를 호출하기 위해서는 published 메서드를 사용하면 됩니다.

Article.published

매개변수 전달

• 매개변수를 전달할 수 도 있습니다.

class Article < ApplicationRecord
  scope :created_before, ->(time) { where("created_at < ?", time) }
end

class Article < ApplicationRecord
  def self.created_before(time)
    where("created_at < ?", time)
  end
end

• 아래와 같이 호출이 가능합니다.

Article.created_before(Time.zone.now)

조건문 사용

class Article < ApplicationRecord
  scope :created_before, ->(time) { where("created_at < ?", time) if time.present? }
end

class Article < ApplicationRecord
  def self.created_before(time)
    where("created_at < ?", time) if time.present?
  end
end

• 한가지 주의사항은 조건은 false가 나오면 nul을 반환하지만, scope는 항상 ActiveRecord::Relation 객체를 반환합니다. 즉, 조건 중 하나라도 false를 반환하면 조건부와 class method를 연결할 때 NoMethodError가 발생할 수 있습니다.

default scope(기본 범위)

• 아래와 같이 기본 범위를 지정할 수 있습니다.

class Client < ApplicationRecord
  default_scope { where("removed_at IS NULL") }
end

class Client < ApplicationRecord
  def self.default_scope
    # Should return an ActiveRecord::Relation.
  end
end

• 주의사항은 Query Arguments를 사용할 수 없습니다.

class Client < ApplicationRecord
  default_scope { where("active = ?", true) }
end

Client.new # => #<Client id: nil, active: nil>

scope 병합

class User < ApplicationRecord
  scope :active, -> { where state: 'active' }
  scope :inactive, -> { where state: 'inactive' }
end

User.active.inactive

SELECT "users".* FROM "users" WHERE "users"."state" = 'active' AND "users"."state" = 'inactive'

• AND 조건을 사용해 scope를 합치는 것입니다.
• 즉, 최종 SQL이 AND와 JOIN 된 모든 조건을 갖도록 scope를 혼합하고 일치시킬 수 있습니다.

 User.active.merge(User.inactive)

SELECT "users".* FROM "users" WHERE "users"."state" = 'inactive'

class User < ApplicationRecord
  default_scope { where state: 'pending' }
  scope :active, -> { where state: 'active' }
  scope :inactive, -> { where state: 'inactive' }
end

User.all
# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending'

User.active
# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'active'

User.where(state: 'inactive')
# SELECT "users".* FROM "users" WHERE "users"."state" = 'pending' AND "users"."state" = 'inactive'

• 위와 같이 중요한 주의 사항이 있습니다. default_scope가 제일 먼저 실행됩니다.(즉, scope, where 앞에 추가)

scope 삭제

• unscope 메서드를 사용하면 삭제할 수 있습니다.

Client.unscoped.load

Client.unscoped.all
# SELECT "clients".* FROM "clients"

Client.where(published: false).unscoped.all
# SELECT "clients".* FROM "clients"

• unscope는 사전에 정의된 모든 scope를 제거하고 테이블에서는 일반 Query로 작업할 수 있다고 생각하면 좋습니다.
• 블록을 허용도 합니다.

Client.unscoped {
  Client.created_before(Time.zone.now)
}

Dynamic Finders

• 테이블에 정의한 모든 필드에 대해 finder를 제공합니다. 예를들어 find_by_name라는 메서드로 SELECT * FROM USER WHERE name = 쿼리를 만들수 있다.
• 여러개를 사용하려면 and를 이용하면 된다.
  • Client.find_by_first_name_and_locked(...)

enum

• 정수 값을 Set으로 모아 놓는 enum도 사용이 가능합니다.

class Book < ApplicationRecord
  enum availability: [:available, :unavailable]
end

# Both examples below query just available books.
Book.available
# or
Book.where(availability: :available)

book = Book.new(availability: :available)
book.available?   # => true
book.unavailable! # => true
book.available?   # => false

Method chaining

• 여러 테이블에서 필터링 된 데이터 검색

Person
  .select('people.id, people.name, comments.text')
  .joins(:comments)
  .where('comments.created_at > ?', 1.week.ago)

SELECT people.id, people.name, comments.text
FROM people
INNER JOIN comments
  ON comments.person_id = people.id
WHERE comments.created_at = '2015-01-01'

• 여러 테이블에서 특정 데이터 검색

Person
  .select('people.id, people.name, companies.name')
  .joins(:company)
  .find_by('people.name' => 'John') # this should be the last

SELECT people.id, people.name, companies.name
FROM people
INNER JOIN companies
  ON companies.person_id = people.id
WHERE people.name = 'John'
LIMIT 1

새로운 모델 조회 또는 저장

find_or_create_by

• 레코드가 존재하면 조회하고 레코드가 없으면 해당 레코드를 저장합니다.

Client.find_or_create_by(first_name: 'Andy')

SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1
BEGIN
INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57')
COMMIT

find_or_create_by!

• create가 아닌 new 메서드로 데이터가 초기화 됩니다. 즉, 새로운 Modal 인스턴스가 생성되지만, DB에는 저장되지 않습니다.

Client.find_or_create_by!(first_name: 'Marco')

• validate중에 presence: true로 설정되어 있는게 있다면, 예외가 발생합니다.

find_or_initialize_by

• DB에 저장되지 않고 인스턴스만 생성합니다.
• 추후 데이터를 저장하고 싶다면 save 메소드를 실행시켜주면 됩니다.

모델 조회 쿼리

find_by_sql

• SQL을 이용해 테이블에서 데이터를 조회합니다.

Client.find_by_sql("SELECT * FROM clients
  INNER JOIN orders ON clients.id = orders.client_id
  ORDER BY clients.created_at desc")
# =>  [
#   #<Client id: 1, first_name: "Lucas" >,
#   #<Client id: 2, first_name: "Jan" >,
#   ...
# ]

select_all

• 모든 모델을 가져오는 조회 쿼리입니다.

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

pluck

• 기본 테이블에서 단일 또는 여러 컬럼을 검색하는데 사용됩니다.

Client.where(active: true).pluck(:id)
# SELECT id FROM clients WHERE active = 1
# => [1, 2, 3]

Client.distinct.pluck(:role)
# SELECT DISTINCT role FROM clients
# => ['admin', 'member', 'guest']

Client.pluck(:id, :name)
# SELECT clients.id, clients.name FROM clients
# => [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]

• 결과가 배열로 나오기 때문에 쿼리 성능을 향상시킬수 있습니다.
• 그러나 pluck를 실행시키는 순간 Query를 trigger하기 때문에 chaining을 사용할수 없습니다.

Client.pluck(:name).limit(1)
# => NoMethodError: undefined method `limit' for #<Array:0x007ff34d3ad6d8>

Client.limit(1).pluck(:name)
# => ["David"]

ids

• 기본키를 사용해 관계의 모든 ID를 가져올수 있습니다.

모델 존재 여부 쿼리

exist?

• 단순히 객체의 존재를 확인하는 것으로 Boolean값이 나온다.
• 여러 데이터에 대한 값도 가능합니다.

Client.exists?(id: [1,2,3])
# or
Client.exists?(name: ['John', 'Sergei'])

• 그러나 위의 방식은 일부만 존재해도 true를 반환하며 모두 존재하지 않아야 false를 반환합니다.

컬럼 값 계산 쿼리

Count

• 모델 갯수를 셀수 있습니다.

Bulletin.count

# (0.1ms)  SELECT COUNT(*) FROM "bulletins"
#  => 63

Average & Sum

• 평균 & 합계을 계산할 수 있습니다.

Client.average("orders_count")
Client.sum("orders_count")

Maximum & Minimum

• 최댓값& 최솟값을 조회할 수 있습니다.

Client.maximum("age")
Client.minimum("age")

쿼리 탐색 결과 확인

• 쿼리 탐색 과정을 살펴볼 수 있는 explain 메소드가 존재합니다.

User.where(id: 1).joins(:articles).explain

## PostgreSQL

EXPLAIN for: SELECT "users".* FROM "users" INNER JOIN "articles" ON "articles"."user_id" = "users"."id" WHERE "users"."id" = 1
                                  QUERY PLAN
------------------------------------------------------------------------------
 Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
   Join Filter: (articles.user_id = users.id)
   ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
         Index Cond: (id = 1)
   ->  Seq Scan on articles  (cost=0.00..28.88 rows=8 width=4)
         Filter: (articles.user_id = 1)
(6 rows)

😇 결론

• Rails는 Active Record로 ORM 기능을 지원합니다.
• Query Interface로 개발자가 Query를 작성하지 않고도 DB SQL을 사용할 수 있습니다.
• 대부분의 Query 명령문을 지원하기 때문에 개발자가 Query에 집중할 필요가 없으며 vender에 맞춰 SQL이 조금씩 다른데 손 쉽게 vender를 변경할 수 있다는 장점도 가지고 있습니다.
• 2편에서는 Lock, Join, Eger Loading 등을 알아보도록 하겠습니다.

출처

Active Record Query Interface - Ruby on Rails Guides

비관적 잠금(선점 잠금, Pessimistic Lock)과 낙관적 잠금(비선점 잠금, Optimistic Lock)