Transcript

1. RDBMS in Action 詳しくないとプロダクション環境で炎上しがちな RDBMS の勘所 2019/09/12 Seiya Yazaki 1

2. この話の⽬指すところ RDBMS 理解度の壁: プロダクションや運⽤保守で困らないシステムを作れる知識 ∨ それっぽく動くものを作れる知識 実際のシステムで遭遇・⾒聞きした事象をもとに、 上記のスキマにある各種 RDBMS 知識を説明します。

   RDBMS 本体の運⽤よりも、現実のアプリケーションにおける設計・実装上のハマリどころが 中⼼。 2

3. 例えばこういった話を知ってほしい 存在しないレコード、に⼤いに注意が必要であること 可変⻑/追記型の PostgreSQL と、固定⻑/in-place型の MySQL, Oracle の⻑所短所 Locale, Collation

   や driver ライブラリによる型マッピングの注意点 Failover や replication の特性, DB の選定への影響 3

4. 章⽴て 今回は以下のトピックについて触れます: 1. レコードロック・トランザクション整合性 2. RDBMS の内部アーキテクチャ による性能上の考慮事項 3. Index

   4. SELECT ⽂に関するその他のトピック 5. プリミティブ型の取扱い 6. ⾼可⽤性・⾼速性のためのシステム構成・DB 選定 RDBMS ある程度使ったことある前提になっているので、 そうでない⽅は「こんな話があるんだな」程度に聞いて 時が来たらこの話を思い出してやってください。 ( 本資料は公開予定 ) 4

5. Non-goal コンテキストをある程度絞っています: ⼀般的な web サービスやそのバッチを前提に書きます 多少の劣化も本気で許されないミッションクリティカル⽤途もスコープ外 事前の負荷試験をガチガチにやればいいんじゃん！という発想では語りません 専属 DBA (DataBase

   Administrator) が⼿厚くケアする世界観ではないです MySQL, Oracle, PostgreSQL のみに触れます 他の DB は筆者が実運⽤経験ないため 5

6. レコードロック・トランザクション整合性 6

7. トランザクション分離レベル SQL標準では、"トランザクション分離レベル" を 4 種類定義している: ↑ 弱い保証 READ UNCOMMITTED :

   他トランザクションの書きかけデータが⾒えてしまう READ COMMITTED : 他トランザクションが COMMIT したデータが⾒える REPEATABLE READ : 同じ SELECT ⽂を何回実⾏しても同じ結果を保証 SERIALIZABLE : 他トランザクションの影響が全く⾒えないことを保証 ↓ 強い保証 7

8. どのトランザクション分離レベルを使うか 実⽤的には... READ UNCOMMITTED : 保証が弱すぎ, まず使わない READ COMMITTED :

   (PostgreSQL, Oracle デフォルト) 筆者のおすすめ REPEATABLE READ (MySQL デフォルト) ⼀⾒便利そうだが、あまりおすすめしない (後述) SERIALIZABLE : 保証が強いが代償も⼤きすぎてあまり使わない トランザクションのリトライ を回避困難なのでアプリ側の設計が厄介 RDBMS 内部の ロック昇格 による予測困難な dead lock のリスク 性能上のオーバーヘッドやロック周りでの DB 負荷も⾼い ※ MySQL だけデフォルトが違うので覚えておきましょう MySQL でも READ COMMITTED は利⽤可能です。 8

9. レコードロック 以下のような処理を(⾮ SERIALIZABLE で)素朴に実装するとやばい: 1. SELECT 2. SELECT 結果をもとにアプリケーション側で⾊々計算 3.

   計算結果をもとに INSERT/UPDATE/DELETE 1 と 3 の間に他のトランザクションが同じレコードを更新している場合、 その更新を無視してしまう結果になる (lost update)。 こういうケースではレコードロックをすることでそれを防ぐのが常識。 9

10. レコードロックする流れ 1. SELECT FOR UPDATE この時点で対象のレコードがロックされる 2. SELECT 結果をもとにアプリケーション側で⾊々計算 3.

    計算結果をもとに INSERT/UPDATE/DELETE FOR UPDATE で⾏ロックすることで 1 と 3 の間に他のトランザクションが同じレコードを更新できなくなり、 整合性を確保できる。 10

11. Dead Lock 計算機における⼀般的なロックがそうであるように、⾏ロックも dead lock しうる。 対処法も⼀般的なロックに準ずる: 複数の⾏を個別にロックせずに、ロックの粒度を⼤きくする e.g. ⼦テーブルの⾏を操作するときは、必ず親テーブルの⾏をロック

    本来は並⾏でできる処理が並⾏できなくなりえるデメリットはある ロック順序を決めて、常に特定の順序でロック獲得するようにする 性能⾯では失うものがあまりない 設計・実装がかなり⾯倒 & ミスりやすいというデメリットがある 11

12. 粒度の⼤きいロックはやりすぎ注意 ⾏ロックをまじめに設計するより、⼤きい単位でロックしてしまったほうが楽だが... ⼤きく設計した粒度を後から⼩さく改修するのは⼤変困難 トランザクション周りのロジックをほぼ作り直すことになる 後から無理やり治すと⼤体モレや⽭盾が⽣まれてしまうのでバグりやすい 特に「ユーザー単位で常に排他的ロック」は殆の場合粒度が過⼤。 バッチ処理が出てきたときにロック過剰で死ぬ。 リアルタイム処理をバッチが妨害してしまうので。 仕様的にアトミックだと思える範囲(e.g. 記事ごと)に留めるほうが吉。

    12

13. 粒度⼤きめのロックが活きる場⾯ 複数の⾏を⼀括更新する UPDATE は「ロック順序を決める」ポリシーと相性が悪い: MySQL, PostgreSQL, Oracle いずれも⼀括 UPDATE 内部のロック順序は保証不能

    かといって、数万⾏オーダーの更新を 1 ⾏ごとに SQL 発⾏するのはかなり遅い こういうケースでは、⼀括更新対象の⾏の親レコード(単⼀のレコード)をロックする設計にし たほうが良い。 他にも、「存在しない」レコード区間をロックする⽬的でも有⽤ (後述)。 13

14. ロックのタイムアウト 他のトランザクションがロックしている場合、ロック獲得が待たされる。 待ち続けてしまうと DB サーバー・アプリサーバーの各種資源を圧迫するので、 明⽰的にタイムアウトすべきである。 やり⽅は DB によって違う, 以下などの⽅法で設定する:

    PostgreSQL: lock_timeout セッション変数や FOR UPDATE NOWAIT MySQL: innodb_lock_wait_timeout セッション変数 Oracle: FOR UPDATE WAIT n や FOR UPDATE NOWAIT 14

15. 存在しないレコードのロック・Gap Lock 以下のようなロジックは、かなり要注意: 1. SELECT FOR UPDATE 2. SELECT 結果の

    レコードが「存在しない」か「存在する」かに依存 した計算 3. 計算結果をもとに INSERT/UPDATE/DELETE 存在しない⾏をどうロックするか・ロックできるのか という問題がある。 存在しない⾏をロックしない限り、他トランザクションで INSERT されて破綻する。 15

16. 存在しない⾏に対する FOR UPDATE READ COMMITTED の場合は、そもそも存在しない⾏に対するロックや保証がない。 REPEATABLE READ の場合: Oracle:

    そもそも REPEATABLE READ ⾮対応 PostgreSQL: 存在しない⾏を FOR UPDATE ロックできない (後述) MySQL: Gap lock によって実現 (後述) 要するに MySQL 以外の 2 つでは、 FOR UPDATE で⾏が無かったとしても、 他トランザクションからの INSERT を防げない。 16

17. MySQL の Gap Lock (Next Key Lock) MySQL の REPEATABLE

    READ での FOR UPDATE はテーブル上のいずれかのindexの区間を gap X-lock することで他トランザクションが当該区間に INSERT することを防ぐ。 しかし gap lock はクエリの WHERE 条件を正確に反映するのではなく、 現存するレコードとレコードの間の区間全体をロックする。 それゆえに、意外な広範囲がロックされ、dead lock の温床にもなる。 「MySQL は Next Key Lock なる挙動が怖い」という⾵説はこれに由来している。 (Next Key Lock は ⾏ロック + Gap Lock の総称) REPEATABLE READ でなく READ COMMITTED を使えばこれは発⽣しない。 17

18. PostgreSQL と存在しない⾏のロック PostgreSQL は存在しない⾏をロックしない ( SERIALIZABLE 除く): postgres=# BEGIN; postgres=#

    SET TRANSACTION ISOLATION LEVEL REPEATABLE READ; このタイミングで別トランザクションから test テーブルに INSERT postgres=# SELECT FROM test FOR UPDATE; -- 全⾏ロック (0 rows) postgres=# INSERT INTO test VALUES ('a', 'value of a'); ERROR: duplicate key value violates unique constraint "test_pkey" (公式ドキュメントがこの点についてはちゃんと書いていないので PostgreSQL 11.4 で確認した) SELECT 結果の⾏の有無に依存するロジックは、 REPEATABLE READ でも厳しい。 18

19. 存在しない⾏をロックしないのが最善 MySQL でも READ COMMITTED がオススメである (Gap lock 問題を回避できる)。 存在しない⾏はロックできない前提でプログラミングすることになる。

    存在しない⾏のロックをしないで済ませるテクニック: 投機的に INSERT し、unique key / PK の重複エラーを catch する この⽅法ならば⾏の存在有無を確実に保証できる 「⾏がなければ INSERT , あれば UPDATE 」を atomic に⾏う RDBMS 機能を使う MERGE (Oracle), INSERT ... ON CONFLICT (PosrgreSQL), insert ... on duplicate key update (MySQL) 上記いずれも難しい場合は、親レコードをロックするといったロック粒度の拡⼤で対処するの も⼿である。 19

20. ⾏の存在・不存在に依存する処理いろいろ ⾏の存在・不存在に依存する処理は意外にあるので注意: COUNT や SUM に依存する処理 ⾏が増減すれば COUNT や SUM

    も変わる 親レコードロックで対策するのが⼿堅く、意味的にも妥当 外部から⼊⼒される値に対する⼀意性担保 例えばメールアドレスを⼀意の ID として使う場合 投機的 INSERT ⽅式との相性が良い 状態遷移に対する制限 e.g. "Hoge 状態のレコードは 2 つ存在してはいけない" 対処例: Unique key を貼る 対処例: "Hoge 状態のレコードを作成・削除する際にロックするレコード" で排他制 御 20

21. REPEATABLE READ, MVCC と更新系の相性 REPEATABLE READ と、DML, FOR UPDATE は相性悪い:

    REPEATABLE READ は過去のある時点のデータを常に返す FOR UPDATE や DML は最新のデータを取得・操作しないと不整合になってしまう 3 ⼤ RDBMS の挙動: MySQL: FOR UPDATE は REPEATABLE READ であっても最新レコードが取得される REPEATABLE 性が崩れる PostgreSQL: SELECT と DML, FOR UPDATE の間に更新があるとエラー トランザクションを最初からやり直す必要あり Oracle: そもそも REPEATABLE READ がない これも、 REPEATABLE READ より READ COMMITTED をおすすめする要因。 21

22. レコードロック・トランザクション整合性 まとめ: REPEATABLE READ より READ COMMITTED がおすすめ MySQL では明⽰的に変える必要あり

    Dead lock は、ロック順の固定か⼤粒度ロックで対策するのがメジャー レコードの存在・不存在に依存する処理は要注意 投機的 INSERT, Unique Key, ⼤粒度ロックなどで対処 22

23. 閑話休題: RDBMS 以外のシステムとのリトライ整合性 DB と外部の API 等の間でデータ整合性を保つ必要がある場合、 外部の API は

    DB のトランザクションとは無関係に動くため ⽚⽅の更新が成功 & ⽚⽅が失敗 した場合の対処を考える必要がある。 ⼀つの有⽤な⽅法として 外部 API でのデータ更新などは commit 直前に⾏う というアプローチがある。 commit の失敗が⾮常に稀にしか起きないという 3 ⼤ DB の性質を使っている。 他には 取り消し API を呼び出すアプローチ( 代償トランザクション ⽅式)もあるが その場合、取り消し API の失敗ケースなどの考慮事項が発⽣してしまい、 複雑・テスト困難になりがちなので、あまりおすすめしない。 23

24. RDBMS の内部アーキテクチャ による 性能上の考慮事項 24

25. RDBMS という漏れのある抽象化 RDBMS には内部設計の違いがある。 SQL である程度似たように使えるからといって同じではない。 特に意識すべき点: ロック・トランザクションの実挙動 (先述) DB

    サーバーの負荷特性 そして、内部設計の違いはアプリケーション設計時に⼗分考慮すべきである: 内部設計起因の課題・限界は ユニットテスト, ⼿作業 QA, 負荷試験 いずれの⼿法でも発 覚しにくい ⼤量かつ多種多様なトラフィックと蓄積されたデータがないと再現しにくい 特性の差がアプリケーションの設計に影響を与えてしまう (⼿戻りが⼤きい) 25

26. 可変⻑⽂字列( VARCHAR )の扱い MySQL, Oracle: VARCHAR(n) は常に n ⽂字/byte 確保する

    PostgreSQL: varchar は内部的にも可変⻑ 「とりあえず VARCHAR(255) ！」みたいなことは MySQL, Oracle では避ける: Disk I/O 帯域(iops)やキャッシュメモリを圧迫する 症状としては I/O 詰まりになる AWS RDS では I/O のネットワークの帯域幅もインスタンスサイズ⽐例 CPU からのメモリ(ひいては disk)アクセス効率の悪化 L1/L2/... cache hit しにくくなり演算性能が下がる ⾒た⽬上の症状として CPU 負荷が⾼く⾒える (実際は主記憶 I/O 待ち) ※ カラムの意味を曲げてまで無理やり短縮するべき、という話ではない 26

27. ⻑⼤な⽂字列・バイト列 JSON とかを DB に⼊れると時に便利という気持ちは⼤変分かりますが... I/O 負荷とレスポンス速度の問題 DB はキャッシュヒットしないと超遅いので、メモリを⾷う リアルタイム処理⽤途ではヒット率

    90% 程度は保ちたい ディスクやネットワークの帯域幅・最⼤速度にも限りがある DB サーバーのメモリや I/O 速度・帯域はコスト⾼い BLOB/CLOB や ⻑⼤な⽂字列 は特別扱いになりオーバーヘッド増 LOB/⻑⼤な⽂字列 は専⽤領域に格納され、レコード本体に格納されないのでオーバ ーヘッドあり (3 ⼤ DB 共通) (PostgreSQL) ⾃動で圧縮するため CPU オーバーヘッドもあり 特に master はスケールアウト困難なので CPU は限りある貴重な資源 Object Storage (S3, GCS) や KVS 等を最⼤限検討しましょう。 27

28. in-place 更新型と追記型 PostgreSQL : レコードの実体は immutable MySQL, Oracle : レコードの実体は

    mutable PostgreSQL の場合、 UPDATE であってもレコードの実体(tuple)を「作成」する。 古い tuple は削除・更新後にもゴミとして残るため、以下の課題が発⽣する: ゴミ tuple を消さないと table, index が肥⼤化し性能劣化する 経時でゴミ tuple が⼤量に積み重なると論外レベルで遅くなる AWS Aurora のように最⼤時のサイズで課⾦されるケースで課⾦額も増えがち ⼤量 update 時などに、前世代のゴミ + 新世代 のサイズで課⾦されるため また、index の B-Tree 等にも無駄が発⽣する。 28

29. PostgreSQL の VACUUM PostgreSQL には、ゴミ tuple に、再利⽤フラグを⽴てる VACUUM という処理がある。 フラグを⽴てることで、その

    tuple の領域が再利⽤の対象になる。 また、⾃動で VACUUM が⾏われる機能がありデフォルト有効( AUTO VACUUM )。 しかし VACUUM には限界が⾊々ある: PostgreSQL の tuple は可変⻑なので、断⽚化がネックになる レコードの内容次第でサイズがバラバラ 60byte の隙間に 80byte のレコードは⼊らない 60byte の隙間に 40byte のレコードを⼊れるとデッドスペースが出来る Index の断⽚化(スカスカ状態)は解消されない 29

30. PostgreSQL の VACUUM 系処理の負荷と速度 VACUUM 処理の動き: 1. まず、テーブル全体を⾛査してゴミ tuple を列挙する

    2. ゴミ tuple を⽚付ける VACUUM 処理はテーブル全体を⾛査するため、DB 負荷の要因になる。 特にデフォルトの AUTO VACUUM 頻度では多すぎたり、 ピーク時間帯の性能圧迫要因になりがち (意外と CPU 30%-50% とか⾷ったりする)。 しかし、頻度を下げすぎると負のスパイラルに陥る: AUTO VACUUM にはタイムアウトがある, 1. が進捗せずにタイムアウトすると... 次に AUTO VACUUM するまでの間にテーブルがより肥⼤化し... 1. に要する時間が伸びてなおさらタイムアウト... 30

31. PostgreSQL の VACUUM 系をどうするか PostgreSQL の根幹の構造に起因しており、頑張るしかない: DB 負荷の⾼いクエリ⼀覧を監視し、 AUTO VACUUM

    が現れたら対処する 頻度を下げたり、ピーク時間帯には⾛らないようしたり 先述の負のスパイラルには要注意 ゴミ tuple, 断⽚化の程度を監視し、過度に荒れているテーブルは処置する AUTO VACUUM の頻度を上げる ⼿動で pg_repack / VACUUM FULL する (応急処置, 後述) 不要にレコードを update, delete しないようにし、ゴミ tuple の発⽣量を減らす 洗い替え(変化がないレコードすらも delete + insert)しないように設計する しかし 1 record づつの update/merge 処理は遅い.... PostgreSQL をやめる 31

32. PostgreSQL の VACUUM FULL, pg_repack 本来論で⾔えば、 VACUUM によってレコードに削除フラグを⽴てて、 それが⾃然に再利⽤されるのが望ましい。 しかし、それでは⾜りないことも実際よくある...

    VACUUM 頻度が不⾜しており肥⼤化してしまう事故 負荷が変動しがちなシステムで、突発的負荷に負ける 断⽚化が積もりに積もって死 (VACUUM は断⽚化解消しない) VACUUM FULL / pg_repack で table, index 全体を強制的に再構築するしかない。 pg_repack PostgreSQL 拡張は trigger や⼀時テーブルを駆使してテーブルロックしない利 点がある。権限周りで苦労があるが、基本的にはこちらを使ったほうが良い。 32

33. RDBMS の内部アーキテクチャ による 性能上の考慮事項 まとめ: (MySQL, Oracle) 可変⻑⽂字列の定義⻑さを⻑くしすぎないように JSON とかを

    DB に⼊れるのはやめよう (PostgreSQL) 内部データ構造が断⽚化するしゴミも貯まるのが仕様 VACUUM で苦しめられることは未だによくあるが、気合で頑張るしかない レコードの更新や洗い替えを減らせるならぜひ減らそう 33

34. Index 34

35. Index を語るにはこの余⽩は⼩さすぎる Index 設計は、当然ながら性能上重要である。RDBMS は... DML 実⾏時に索引(index)を更新し クエリの実⾏時には最適な index を利⽤する計画(実⾏計画)を⽴案している

    しかし、深く語ると際限がないので、今回は筆者的 FAQ トピックのうち いくつかに触れるに留める。 なお、 USE THE INDEX, LUKE! という online book (⽇本語化もされている)があり、 ⾮常におすすめである。 RDBMS を触る・テーブル設計する⼈には広くおすすめしたい。 35

36. B-Tree index のおさらい 特に指定しない場合、index は⽊構造として実現される。 (B-Tree をベースにしたデータ構造が使われる) カラム ( A

    , B ) の複合 index の場合、以下のような⽊構造になる: ↑ Tree の Root 側 - Level 1: `A` カラムの値 - Level 2: `B` カラムの値 - Level 3: レコードへの参照 ↓ Leaf 側 36

37. Skip scan / loose indexscan ↑ Tree の Root 側

    - Level 1: `A` カラムの値 - Level 2: `B` カラムの値 - Level 3: レコードへの参照 ↓ Leaf 側 これに対してカラム B の値だけで検索するとどうなるか？ MySQL, Oracle : Level 1 は全⾛査するが、Level 2 を使って絞り込む Skip scan (Oracle), Loose indexscan (MySQL) と呼ばれる 例えば Level 1 に 10 通りの値しかないなら、かなり⾼速 PostgreSQL : 上記 index は活⽤できない ( B , A )  の順序に⼊れ替えるか、 B カラム単独の index があれば勿論最適。 37

38. Index が使われない！ 理想的な index があるにも関わらず使われない、というトラブルもありがち。 殆どの場合、以下のどちらかが要因: テーブルの統計情報が古い 実際のデータ分布とかけ離れた状態を前提に実⾏計画を組んでしまう 特に、レコード数が僅かである前提で index

    scan より full scan が選択される ケースがありがち クエリ中の JOIN, サブクエリがあまりに多すぎる 実⾏計画の探索空間が爆発するため、ヒューリスティック探索になったり⼀定時間 で適当に実⾏計画作成されたりする (3 ⼤ DB 共通) なお、Oracle は他の 2 DB よりもオプティマイザが圧倒的に強⼒だが、 それゆえに上記の 2 問題の影響も顕著に出やすい (問題ない時が速いので)。 38

39. 統計情報の明⽰的メンテナンス DB の統計情報は DML 実⾏回数や更新⾏数などを元に⾃動で再統計される。 しかし、特に洗い替え(⼀括削除 + ⼀括投⼊)をする場合、 再投⼊完了後の状態で統計しないとズレやすいため、 明⽰的に

    ANALYZE TABLE といった SQL を発⾏するのは定⽯。 また、カラムの MIN, MAX がある程度変わった際も再統計しないと、 範囲外の値が「ない」前提で最適化されてしまう。なので定期的な再統計も⼤事。 また、あえて⾃動的な統計情報取得を無効にし、 負荷の低い時間帯に統計情報を⼀気更新するのも良い⼯夫。 ただし、データの傾向が時間帯で変わらないことが⼤前提。バッチに要注意。 39

40. Hint 3 ⼤ DB それぞれ、特定の記述をすることで実⾏計画を指定する機能がある(hint)。 JOIN が多すぎて組合せ爆発し最適化が安定しないクエリなどでは、 hint を明⽰するのも選択肢ではあるが... クエリの内容や各テーブルのデータ傾向が変わった際に、hint

    が的外れになり逆効果にす らなる Hint の正当性を普段の CI テストなどで検証するのが困難 クエリのバインド変数の値に応じて実⾏計画を最適化できなくなる DB のバージョンアップの恩恵が得られにくくなる といった性質があるため、最⼤限オプティマイザに任せるべきである。 それが無理な場合は、まずシンプルなクエリに分解することを検討するのが良い。 保守性の観点で、Hint は本当に最終⼿段と考えるべし。 40

41. Index の更新オーバーヘッド あらゆる SELECT に対して最適な index があれば SELECT は⾼速になるが... DML

    で更新するたびに index の更新コストが発⽣ B-Tree のリバランスなどによる CPU 計算コスト + メモリアクセス待ち I/O の待ち時間や帯域の消費 Index のディスク消費 Index を貼ること = 絶対的な善 ではない。 テーブル全体の数割以上のデータを取得するならば index を使わない full scan でも⼗分速 い。 ( オプティマイザも実際にそう判断することが多い ) 41

42. 複数 index の活⽤ SELECT ... WHERE x = 1 AND

    y = 2 のようなクエリの場合、 ( x , y ) または ( y , x ) の複合 index があれば⼗分だが あらゆるクエリに対して複合 index を⽤意するのは時として過剰。 ⼀⽅で、 x , y カラムそれぞれ単独の index がある場合、 MySQL (>= 5), PostgreSQL (>= 8.1), Oracle であれば以下相当の最適化が可能である: SELECT ... WHERE x = 1 INNER JOIN SELECT ... WHERE y = 2 x , y index それぞれで絞り込んだ結果の AND を取る。 INNERT JOIN 相当のコストが掛かるため複合 index には劣るが、有⽤ではある。 ( MySQL は何故かこれが出来ないと思い込まれていることが... ) 42

43. Index まとめ: B-Tree index の構造と活⽤法は知っておこう テーブルの統計情報はちゃんとメンテすべし データが⼤きく変わるとき + 定期的 に更新しよう

    殺⼈的な JOIN 連発は⼈間だけでなくオプティマイザにも厳しい クエリの簡素化を頑張ろう Hint 句は本当に最終⼿段 Index を闇雲に増やすと更新系が重くなる 複数の index を結合して活⽤してくれる機能もある MySQL でそれができないという⾵説は誤り 43

44. SELECT ⽂に関するその他のトピック 44

45. ⼀時ディスクの消費 クエリの処理中にディスク領域を消費することがある。 特に⼤量データの JOIN はディスク上に⼀時ファイル・⼀時テーブルが作られがち。 クラウドサービスで DB に最⼩限のディスク容量を割当てる場合、 クエリの実⾏に起因する⼀時ディスク消費は考慮が必要。 サービスによって細部は異なるが、DB

    のログ・監査ログや REDO, UNDO ログなどとも容量 を⾷い合うことがあるため、それも含めて余裕があったほうが無難。 また、AWS Aurora は(今の所)⼀時ディスクの容量を⾃由に指定できず⾃動スケールもしない ため、特に注意が必要である。 45

46. Prepared Statement の⽤途 Prepared statement を使う動機: 元々の⽬的: prepare した statement

    を何回も使い回せば、SQL のパースなどが 1 回で済 むので DB 負荷が減る 実情: バインド変数機能( :1 とか ? )が SQL injection 対策になるので使う 筆者のオススメは後者のスタンス。前者の⽤途はおすすめしない: PS 使い回しはリーク(close 忘れ)の温床 PS は DB 上のリソースを確保してしまうので、リークすると痛い SQL のパースや実⾏計画の計算速度で困る状況があまりに稀 DB 側が⾼速化や statement cache などを頑張っているので 46

47. Prepared Statement, バインド変数 と 実⾏計画 実⾏計画・性能上の特性が 3 ⼤ DB それぞれで異なる:

    MySQL : クエリ実⾏のたびに素直に実⾏計画を計算する PostgreSQL : セッション(DB接続)内で PS ごとに実⾏計画をキャッシュ 最初の 5 回は素直に実⾏計画を計算 それ以降はバインド変数の値を無視した generic な実⾏計画を優先的に使う Oracle : DB インスタンス全体で PS の中⾝ごとに実⾏計画をキャッシュ 初回のクエリのバインド変数の値を前提とした実⾏計画を計算し保存 n 回⽬にクエリが極端に遅くなった場合、n + 1 回⽬に実⾏計画を追加⽣成 つまり n 回⽬のクエリは犠牲になる ⾒ての通り PostgreSQL, Oracle は固有の癖があるので要注意。 47

48. プリミティブ型の取扱い 48

49. ⽂字列の扱い ⽂字列は注意すべき点がある: ⻑さ いわゆる⽂字コード (appendix 参照) = や DISTINCT ,

    ORDER BY , LIKE , ... の整合性 DB の周辺ツールとの互換性 そして、実は DB それぞれで⼤変込み⼊っている... 49

50. ⽂字列の⻑さ ドキュメントなどを⾒つつ、適切な設定・型を使いましょう。 Unicode の⾮ LOB 型に絞って、かいつまんでまとめると... MySQL: utf8 (<= 3byte/char),

    utf8mb4 (<= 4byte/char) 基本的には絵⽂字なども無難に扱える utf8mb4 が便利だが... ⾏⻑が最⼤ 65,535 byte であることにも注意 PostgreSQL: 1GB まで可能 (⾃動で圧縮された後のサイズ) ⻑い⽂字列は⾏外に配置され、他 DB における CLOB/BLOB に近い性能特性になる 点に注意 Oracle: 1 カラム 4000 byte まで 複数の varchar カラムに分けることで⻑さを稼ぐテクも⼀応ある ⾏⻑は 65,535 byte まで 50

51. いわゆる⽂字コード RDBMS において、いわゆる⽂字コードは以下の 2 箇所で問題になる: 1. DB で⽂字列を保存する際の⽂字コード できるだけ Unicode

    系にすべし 2. クライアントライブラリ・CLI の動作時の⽂字コード 1. と揃えるべし 1. と 2. が揃っていない場合、⽂字コードの変換が⾏われる (3 ⼤ DB 共通)。 しかし、その挙動に依存することは望ましくない: アプリの実装や運⽤作業でのデータ読み書きの際の⽂字コード変換と⼀致しない 運⽤上の混乱、突き合わせ作業の実施困難、といった苦難を⽣む もともと同⼀だった⽂字列が不⼀致になり得るため、バグの温床 意図せぬ変換が発⽣し、制御も難しい PostgreSQL, Oracle ではテーブル・カラム単位の制御もできない Appendix も参照のこと。 51

52. Locale, Collation 3 ⼤ DB いずれも、以下の挙動を⾊々と制御できる: どの⽂字とどの⽂字を「同⼀」とみなすか = や DISTINCT

    , LIKE などなどに影響 ⽂字の順序 ORDER BY 合字(例: ㍻ , ㋿ )や絵⽂字などの扱い それらの⽂字が⼊ってしまう場合に全体的に影響 気をつけないと詰むので、少なくとも DB の新規作成時には明⽰的に制御すること。 引き継いだシステムでここがダメダメなときのガッカリ感はすごい。 特に MySQL や PostgreSQL では、デフォルトのまま使うとヤバいことになる。 Appendix を参照されたし。 52

53. DB ごとの collation の各操作への影響 MySQL だいたい collation 通りに動く...はず LIKE は

    collation を無視して⽂字単位で⽐較 (SQL 標準準拠) PostgreSQL C ロケールならバイナリ⼀致, 性能⾯でも問題なし それ以外の場合は collation に従う index 作成時に text_pattern_ops などのオプションを要考慮 Oracle ⼤抵は NLS_COMP=BINARY 。そうであればバイナリでのソート・⼀意性になる そうでない場合は この表 とかを⾒ながら頑張れ... 53

54. バイナリ⼀致の collation 環境下での LIKE のコツ DB の collation 機能を活⽤しようとすると沼が深い上に アプリケーション側との挙動不整合にさいなまれる要因にしかならない。

    アプリ側で⽂字列を正規化し、DB ではバイナリ的に⽂字列を扱うのが良い。 しかし LIKE 検索では「似たような」⽂字は検索でマッチさせたいであろう。 そのような検索⽤途では Unicode 正規形 NFKC を使うと便利。 ( ⼤抵の⾔語処理系で利⽤可能 ) 検索対象のカラムの中⾝と LIKE クエリ両⽅をアプリ側で正規化すれば、 合字・異体字を始めとする各種の表記ゆれを確実に吸収する検索が実現できる。 ※ 正規化は⾮可逆操作なので、正規化前のデータも残しておいたほうがいい。 54

55. ⽇時 ⽂字列に加え、⽇時型も DB ごとに癖が⼤いにあるので要注意。 ⽇時・⽇付型は driver ライブラリが勝⼿に変換していることが多いため、 使っている⾔語・ライブラリ・O/R mapper 依存の振る舞いがある:

    精度の違い ⾔語側の⽇時型がミリ秒/マイクロ秒単位なのに DB 側が秒単位、とか DB 由来の⽇時とアプリ側の⽇時オブジェクトを == するのは危ない タイムゾーン タイムゾーンを持たない⽇時型ではタイムゾーンに要注意 特にクラウド環境ではサーバーの NOW は UTC だったりする 特殊値・異常値の取り扱い PostgreSQL は OS 依存でうるう秒 (0859:60) を返すことがある MySQL の TIMESTAMP 型は NULL の代わりに 0000-00-00 00:00:00 になる 55

56. プリミティブ型の取扱い まとめ: ⽂字列カラムや⾏の最⼤⻑には要注意 DB にいわゆる⽂字コードを⾃動変換させるのはやめよう 変換はアプリ側で明⽰的に⾏う⽅が、不整合や思わぬ変換を防げる DB に⽂字列の同⼀視を頑張らせるのはやめよう utf8_bin (MySQL),

    C locale (PostgreSQL) などを明⽰的に設定しよう 必要なら、アプリケーション側で NFKC 正規化などしよう 正規化前のデータを捨てるべきではない点に注意 ⽇時は 精度 と タイムゾーン と 特殊値・異常値 に要注意 ⽂字列周りのもう少し踏み込んだ話は Appendix も参照のこと。 56

57. ⾼可⽤性・⾼速性のためのシステム構成・DB 選定 57

58. Connection Pooling で良くなる点 クライアントから⾒たオーバーヘッドの削減: DNS クエリ時間 + TCP のハンドシェイク時間 (普通は微々たるもの)

    DB 側のコネクション作成所要時間 初期化処理 (user 認証など) のハンドシェイク時間 Proxy を経由する場合、その接続オーバーヘッド GCP の cloud SQL proxy や pgpool などなど DB 側の負荷の軽減: コネクションの作成・初期化の処理コスト PostgreSQL, Oracle はプロセスが⽴つので、作成が重くなりやすい 58

59. Connection Pooling の悪い点 クライアント側: セッション(接続)が使い回される セッションの設定や変数がキレイにクリアされないと... セッション内のリソース(prepared statement)などがリークしやすい Failover や接続断の対応が厄介

    Connection を再利⽤する際に死活チェックが必要 DB 側: コネクションの維持コスト 使われていないコネクションも維持されてしまうのでリソースの無駄 PostgreSQL, Oracle はプロセスが⽴つので特に 59

60. Connection Pooling どうするか ⼤体、以下のどれかのパターンになる: 1. 接続が重いかもしれない場合 (重い = 遅い or

    接続処理の DB 負荷が無視できない) Pooling する MySQL の場合は結構軽いので、このケースにならないことも多い ただし Google Cloud SQL Proxy 経由だとスパイク的に遅くなるので... 2. 接続が⼗分軽い しかし 対象の DB への接続数を抑制したい 場合 Pooling ライブラリを使うことで DB への最⼤同時接続数を制限する しかし、コネクションは毎回再⽣成する (pooling はしない) 3. 接続が⼗分軽い かつ DB に⼤量接続・過負荷を掛けても許される 場合 Pooling しない ※ RDBMS 種別やネットワーク構成の前提なく要・不要を断定している情報に踊らされないこと。 60

61. Failover 対応 Failover には⼤体 2 パターンがある: IP アドレスが変わらず L2 ルーティングが変わる

    (Cloud SQL やオンプレに多い) オンプレの場合は OS の ARP cache に注意を要することが多い ホスト名が変わらないが IP アドレスが変わる (AWS RDS) JVM などの勝⼿に DNS キャッシュする処理系で要注意 Connection pooling する場合は先述の通り、 コネクション再利⽤時にコネクションが死んでいないかのチェックが必須。 (ライブラリ機能でできることが多いはず) AWS RDS や Cloud SQL は⼿動で failover を発⽣させられるので、 アプリケーション側の振る舞いを⼀回テストしておくと⼤変良い。 61

62. Failover ⽅式とその特性 Failover の実現⽅式パターン: 1. DB インスタンス間でストレージを共有 (AWS RDS や

    Oracle RAC) ストレージ(≒ EBS)が不調になると詰む その点に対策したのが Aurora 2. master の更新ログを slave がリプレイ (Google Cloud SQL) 更新ログのリプレイが間に合わないと、failover に時間がかかる Cloud SQL が⾼可⽤性⽤途にあまり向かない理由 master はログを slave に送るだけ 3. DB インスタンス間で同期的に更新ログをレプリ (オンプレ DB でよくある) master が死んだときに即座に replica が master になる 更新ログのリプレイが間に合わないと master が低速化する 62

63. Read replica DB の master ノードはスケールしにくいため、 SELECT 系負荷を slave (read

    replica) に逃がす⼿法もしばしば⽤いられる。 特に分析系クエリは、それによってアプリケーションの主要機能を劣化させるべきではないこ とが多いので、read replica に逃がす意義が⼤きい。 ただし、レプリケーションには遅延を伴うことが多いため、以下の⽤途では適さない: 最新のデータが⾒えないといけない要件 / ユーザーが混乱するケース データを登録したのに⾒えないぞ？？等と混乱されることが許容できるか SELECT 結果を元に更新系処理を⾏うケース 古いデータを元に更新処理を⾏うと、データの先祖返りを招く 63

64. Read replica の形態ごとの特性 1. 完全リアルタイムのレプリカ (同期的にレプリ, オンプレで使われることがある) レプリケーションが詰まると master が低速化する

    Read replica ⽤途では本末転倒なのでオススメできない 2. ストレージ共有型のレプリカ (Oracle RAC, Aurora) 完全リアルタイム(Oracle), ミリ秒〜数秒程度の遅延 (Aurora) 3. ⾮同期レプリケーション (Cloud SQL, AWS RDS - not Aurora) master の更新内容を slave でリプレイするため、詰まることがある 時系列を再現する都合上、単⼀ or 少数のスレッドでリプレイするので、master の全⼒には追いつけないこと多し PostgreSQL の場合、slave 側に long transaction があると tuple を消すリプレイが できない構造上の問題でレプリが⼤幅遅延することもある 64

65. DB 選定の観点 DB 選定の観点は数多いが、ここまでに述べた性質が少なからず参考になるはず。 例えば... 低遅延な read replica が必要なら AWS

    Aurora が有⽤ Google Cloud SQL 使うならば、⾮同期レプリケーションゆえの failover 遅延を意識する 必要あり VACUUM による負荷(または肥⼤化・断⽚化による低速化) + レプリケーションの⼤幅遅 延が望ましくないケースでは PostgreSQL は要注意 65

66. ⾼可⽤性・⾼速性のためのシステム構成・DB 選定 まとめ: Connection Pooling する・しない の判断はシステム構成次第 Connection Pooling どうするか

    スライドを参照 Failover のことを忘れずに Pool されたコネクションの⽣存チェックが必要 AWS, GCP では⼿動で failover して挙動を確かめるべし Failover, Replication の特性・制限事項には RDBMS やクラウド環境での差がある DB 選定をする上でも意識すべきポイントである 66

67. 今回、深く扱わなかったトピック データのモデリング, テーブル設計 第3 正規形 とかは知っておこう ※ 病的にテーブルを細切れにすると作者以外が不幸になるので程々に 名前付けが怪しいときは、たいていモデリング⾃体が怪しい テーブル設計とクエリパターンは表裏⼀体

    SELECT の効率化の様々な話: Use the index, Luke! をとりあえず読むべし RDB or NoSQL KVS, Object Storage, Document DB はスケーラビリティやコスパが良い 異種 DB を混⽤する場合、transaction 境界は分断するべからず NoSQL にちゃんと取り組むと RDBMS の⻑所・短所の理解が深まる 67

68. 終 I do not know what I may appear to

    the world, but to myself I seem to have been only like a boy playing on the seashore, and diverting myself in now and then finding a smoother pebble or a prettier shell than ordinary, whilst the great ocean of truth lay all undiscovered before me. 私は、海辺で遊んでいる少年のようである。ときおり、普通のものよりもなめらかな⼩ ⽯やかわいい⾙殻を⾒つけて夢中になっている。真理の⼤海は、すべてが未発⾒のま ま、⽬の前に広がっているというのに ーー Isaac Newton 深く果てしない DB の沼で⾜掻いていくための知⾒のシェアを歓迎します！ 68

69. Appendix. DB ごとの⽂字の取り扱いの沼 69

70. いわゆる⽂字コード いわゆる ⽂字コード は曖昧な概念であり、以下の概念に分離した⽅が良い: ⽂字集合 (e.g. Unicode, JIS ⽂字集合) コードポイント(⽂字・⽂字列の最⼩構成要素)の集合

    ※ 厳密には "符号化"⽂字集合 と ⽂字集合 の違いなどもあるだろうが踏み込まない エンコーディング (e.g. UTF-8, EUC-JP) コードポイントの列をビット列でどう表現するかの定義 基本的には⽂字集合に従属する (UTF-8 は Unicode ⽂字集合のための規格) Unicode における、書記素クラスター ⼈間の⽂化的解釈に近い "1⽂字" の単位 1 つ以上のコードポイントの列で表される (e.g. か + ﾞ (結合⽂字の濁点)) 上記 3 概念の区別を意識すれば、個別の RDBMS の諸概念・各種設定項⽬や実際の挙動も理 解してゆけるだろう (ここでは各 DB の仕様の説明まではしない)。 70

71. 実⽤上の留意点 ⽂字集合とそのバージョン Unicode にはバージョンがあり、DB のバージョンや設定しだいで異なる Unicode バージョンで定義されていないものはうまく扱えないことも JIS の⽂字集合についても同様 コードポイントと書記素クラスターの関係

    何をもって "1 ⽂字" とするかの問題 異体字,合字(例: ㋿ ),絵⽂字 などを使うときは、DB の仕様をよく調べよう。 71

72. MySQL で特に気をつける設定 テーブルやカラム毎に設定を変えられてしまうが、 そうするメリットはめったに無いので、DB 全体でエンコーディングと collation を設定したほ うが良い。 MySQL の

    unicode collation の考え⽅は独特, デフォルトで以下すべてを同⼀視する: 異体字など unicode 的に同じ⽂字を同⼀視/区別 アクセントの有無を同⼀視/区別 濁点・半濁点も "アクセント" 扱いで同⼀視される ⼤⽂字・⼩⽂字を同⼀視/区別 平仮名の⼤⼩も同⼀視される これらを同⼀視するメリットがない限り (アプリ側での正規化で対処できる限り)、 極⼒ utf8_bin を使ってすべて同⼀視しないようにするのが無難。 異体字をどうしても同⼀視したいなら utf8mb4_0900_as_cs といったものにする。 72

73. PostgreSQL で特に気をつける設定 ロケールを忘れずに C にするのが安定: PostgreSQL は⽂字コードを OS の処理系に丸投げする (環境依存する)

    その仕組み上、パフォーマンスもあまり良くない... ダンプ・リストア(pg_dump)とかでも変えられない呪いになる C ロケール(要するにバイナリ的に⼀意判定・ソート)なら速いし確実 しかし、database はデフォルトでは OS のデフォルトロケールになっている。 AWS RDS もデフォルトが en_US (AWS DMS 等のツールで困る)。 C ロケールで database を新規作成するおまじないを使いましょう: CREATE DATABASE hogehoge LC_COLLATE 'C' LC_CTYPE 'C' TEMPLATE template0; 73

74. Oracle Oracle の⽂字周りの実装はかなり⾼機能だが... -> DB の設定は AL32UTF8 + AL16UTF16 が鉄板

    (のはず) Oracle は⽂字コードを DB 全体で設定する 後者は NVARCHAR といった national なデータ型のための設定 -> 接続時の設定は NLS_LANG=AMERICAN_AMERICA.AL32UTF8 が無難 (Windows以外) DB の設定と違う⽂字コードを指定すれば変換してもらえるが、 〜 問題などの温床 になるので変換はアプリ側に倒すほうがよい なお、⽂字化けをエラーとして検知できない( ? に変換されてしまう)。 より知るための資料: 公式のセミナー資料 マルチバイト・キャラクタセット - SHIFT the Oracle 74