Active Record에서 다중 데이터베이스 사용하기

production:
  database: my_primary_database
  adapter: mysql2
  username: root
  password: <%= ENV['ROOT_PASSWORD'] %>

production:
  primary:
    database: my_primary_database
    username: root 
    password: <%= ENV['ROOT_PASSWORD'] %>
    adapter: mysql2
  primary_replica:
    database: my_primary_database
    username: root_readonly
    password: <%= ENV['ROOT_READONLY_PASSWORD'] %>
    adapter: mysql2
    replica: true
  animals:
    database: my_animals_database 
    username: animals_root
    password: <%= ENV['ANIMALS_ROOT_PASSWORD'] %>
    adapter: mysql2
    migrations_paths: db/animals_migrate
  animals_replica:
    database: my_animals_database
    username: animals_readonly 
    password: <%= ENV['ANIMALS_READONLY_PASSWORD'] %>
    adapter: mysql2
    replica: true

class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  # writing과 reading connection을 각각 primary와 primary_replica 데이터베이스에 연결합니다
  connects_to database: { writing: :primary, reading: :primary_replica }  
end

class PrimaryApplicationRecord < ActiveRecord::Base
  primary_abstract_class

  # primary 데이터베이스와 primary_replica 데이터베이스에 연결
  connects_to database: { writing: :primary, reading: :primary_replica }
end

class Person < PrimaryApplicationRecord
end

class AnimalsRecord < ApplicationRecord
  self.abstract_class = true

  connects_to database: { writing: :animals, reading: :animals_replica }
end

class Dog < AnimalsRecord
  # animals 데이터베이스와 자동으로 통신합니다.  
end

config.active_record.writing_role = :default
config.active_record.reading_role = :readonly

$ bin/rails --help
...
db:create                          # DATABASE_URL 또는 config/database.yml에서 데이터베이스 생성...
db:create:animals                  # 현재 환경의 animals 데이터베이스 생성
db:create:primary                  # 현재 환경의 primary 데이터베이스 생성 
db:drop                            # DATABASE_URL 또는 config/database.yml에서 데이터베이스 삭제...
db:drop:animals                    # 현재 환경의 animals 데이터베이스 삭제
db:drop:primary                    # 현재 환경의 primary 데이터베이스 삭제
db:migrate                         # 데이터베이스 마이그레이션 (옵션: VERSION=x, VERBOSE=false, SCOPE=blog)
db:migrate:animals                 # 현재 환경의 animals 데이터베이스 마이그레이션
db:migrate:primary                 # 현재 환경의 primary 데이터베이스 마이그레이션
db:migrate:status                  # 마이그레이션 상태 표시
db:migrate:status:animals          # animals 데이터베이스의 마이그레이션 상태 표시
db:migrate:status:primary          # primary 데이터베이스의 마이그레이션 상태 표시  
db:reset                           # 현재 환경의 모든 데이터베이스를 삭제하고 스키마에서 재생성한 뒤 시드 데이터를 로드
db:reset:animals                   # 현재 환경의 animals 데이터베이스를 삭제하고 스키마에서 재생성한 뒤 시드 데이터를 로드
db:reset:primary                   # 현재 환경의 primary 데이터베이스를 삭제하고 스키마에서 재생성한 뒤 시드 데이터를 로드
db:rollback                        # 스키마를 이전 버전으로 롤백 (STEP=n으로 단계 지정)
db:rollback:animals                # 현재 환경의 animals 데이터베이스를 롤백 (STEP=n으로 단계 지정)
db:rollback:primary                # 현재 환경의 primary 데이터베이스를 롤백 (STEP=n으로 단계 지정)
db:schema:dump                     # 데이터베이스 스키마 파일 생성 (db/schema.rb 또는 db/structure.sql...)
db:schema:dump:animals             # 데이터베이스 스키마 파일 생성 (db/schema.rb 또는 db/structure.sql...)
db:schema:dump:primary             # 모든 DB에서 이식 가능한 db/schema.rb 파일 생성...
db:schema:load                     # 데이터베이스 스키마 파일 로드 (db/schema.rb 또는 db/structure.sql...)
db:schema:load:animals             # 데이터베이스 스키마 파일 로드 (db/schema.rb 또는 db/structure.sql...)
db:schema:load:primary             # 데이터베이스 스키마 파일 로드 (db/schema.rb 또는 db/structure.sql...)  
db:setup                           # 모든 데이터베이스를 생성하고 모든 스키마를 로드한 뒤 시드 데이터로 초기화 (db:reset을 사용하면 먼저 모든 데이터베이스를 삭제)
db:setup:animals                   # animals 데이터베이스를 생성하고 스키마를 로드한 뒤 시드 데이터로 초기화 (db:reset:animals를 사용하면 먼저 데이터베이스를 삭제)
db:setup:primary                   # primary 데이터베이스를 생성하고 스키마를 로드한 뒤 시드 데이터로 초기화 (db:reset:primary를 사용하면 먼저 데이터베이스를 삭제)
...

production:
  primary:
    database: my_database 
    adapter: mysql2
  animals:
    database: my_animals_database
    adapter: mysql2
    database_tasks: false

$ bin/rails generate migration CreateDogs name:string --database animals

$ bin/rails generate scaffold Dog name:string --database animals

class AnimalsRecord < ApplicationRecord
  self.abstract_class = true

  connects_to database: { writing: :animals }
end

class Dog < AnimalsRecord
end

$ bin/rails generate scaffold Dog name:string --database animals --parent Animals::Record

$ bin/rails g active_record:multi_db

Rails.application.configure do
  config.active_record.database_selector = { delay: 2.seconds }
  config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
  config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
end

class MyCookieResolver < ActiveRecord::Middleware::DatabaseSelector::Resolver
  # 요청을 받아 cookie로부터 새 인스턴스를 생성합니다
  def self.call(request)
    new(request.cookies)
  end

  # cookie로 초기화합니다
  def initialize(cookies)
    @cookies = cookies
  end

  attr_reader :cookies

  # cookie에서 마지막 쓰기 타임스탬프를 읽어옵니다
  def last_write_timestamp
    self.class.convert_timestamp_to_time(cookies[:last_write])
  end

  # 현재 시간으로 마지막 쓰기 타임스탬프를 업데이트합니다
  def update_last_write_timestamp
    cookies[:last_write] = self.class.convert_time_to_timestamp(Time.now)
  end

  # 응답을 저장합니다
  def save(response)
  end
end

config.active_record.database_selector = { delay: 2.seconds }
config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
config.active_record.database_resolver_context = MyCookieResolver

ActiveRecord::Base.connected_to(role: :reading) do
  # 이 블록 내의 모든 코드는 reading role에 연결됩니다.
end

ActiveRecord::Base.connected_to(role: :reading, prevent_writes: true) do
  # Rails는 각 쿼리가 읽기 쿼리인지 확인합니다.
end

production:
  primary:
    database: my_primary_database
    adapter: mysql2
  primary_replica:
    database: my_primary_database
    adapter: mysql2
    replica: true
  primary_shard_one:
    database: my_primary_shard_one
    adapter: mysql2
    migrations_paths: db/migrate_shards
  primary_shard_one_replica:
    database: my_primary_shard_one
    adapter: mysql2
    replica: true
  primary_shard_two:
    database: my_primary_shard_two
    adapter: mysql2
    migrations_paths: db/migrate_shards
  primary_shard_two_replica:
    database: my_primary_shard_two
    adapter: mysql2
    replica: true

class ApplicationRecord < ActiveRecord::Base
  primary_abstract_class

  connects_to database: { writing: :primary, reading: :primary_replica }
end

class ShardRecord < ApplicationRecord
  self.abstract_class = true

  connects_to shards: {
    shard_one: { writing: :primary_shard_one, reading: :primary_shard_one_replica },
    shard_two: { writing: :primary_shard_two, reading: :primary_shard_two_replica }
  }
end

$ bin/rails g scaffold Dog name:string --database primary_shard_one

ActiveRecord::Base.connected_to(role: :writing, shard: :default) do
  @id = Person.create! # ":default"라는 이름의 shard에 레코드 생성
end

ActiveRecord::Base.connected_to(role: :writing, shard: :shard_one) do
  Person.find(@id) # 레코드를 찾을 수 없습니다. ":default"라는 이름의 
                   # shard에 생성되었기 때문입니다.
end

ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
  Person.first # shard one의 read replica에서 레코드를 조회합니다.
end

$ bin/rails g active_record:multi_db

Rails.application.configure do
  config.active_record.shard_selector = { lock: true }
  config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
end

config.active_record.shard_resolver = ->(request) {
  subdomain = request.subdomain  
  tenant = Tenant.find_by_subdomain!(subdomain)
  tenant.shard  
}

AnimalsRecord.connected_to(role: :reading) do
  Dog.first # animals_replica에서 읽기를 수행합니다.
  Person.first  # primary에서 읽기를 수행합니다.
end

AnimalsRecord.connected_to(role: :reading, shard: :shard_one) do
  # shard_one_replica에서 읽어옵니다. shard_one_replica에 대한 연결이 존재하지 않는 경우,
  # ConnectionNotEstablished 에러가 발생합니다.
  Dog.first

  # primary writer에서 읽어옵니다. 
  Person.first
end

ApplicationRecord.connected_to(role: :reading, shard: :shard_one) do
  Person.first # primary_shard_one_replica에서 읽음
  Dog.first # animals_primary에서 읽음
end

class Dog < AnimalsRecord
  has_many :treats, through: :humans, disable_joins: true
  has_many :humans

  has_one :home  
  has_one :yard, through: :home, disable_joins: true
end

class Home
  belongs_to :dog
  has_one :yard
end

class Yard
  belongs_to :home
end

SELECT "humans"."id" FROM "humans" WHERE "humans"."dog_id" = ?  [["dog_id", 1]]
SELECT "treats".* FROM "treats" WHERE "treats"."human_id" IN (?, ?, ?)  [["human_id", 1], ["human_id", 2], ["human_id", 3]]

"homes"에서 "home"."id"를 선택하되 "homes"."dog_id" = ? 인 경우 [["dog_id", 1]]
"yards"에서 "yards".*를 선택하되 "yards"."home_id" = ? 인 경우 [["home_id", 1]]