<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>MVCC &#8211; SRA OSS Tech Blog</title>
	<atom:link href="https://www.sraoss.co.jp/tech-blog/tag/mvcc/feed/index.xml" rel="self" type="application/rss+xml" />
	<link>https://www.sraoss.co.jp/tech-blog/</link>
	<description>OSS専門の技術ブログ。PostgreSQL、Zabbixを中心に10種類以上のOSSの解説、アップデート情報、運用ヒントを提供。</description>
	<lastBuildDate>Mon, 09 Nov 2026 03:56:47 +0000</lastBuildDate>
	<language>ja</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.3</generator>

<image>
	<url>https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2018/07/blog-icon-150x150.png</url>
	<title>MVCC &#8211; SRA OSS Tech Blog</title>
	<link>https://www.sraoss.co.jp/tech-blog/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>PostgreSQL であなたの UPDATE が終わらない理由 〜トランザクション、ロック、MVCC を実験で理解する〜</title>
		<link>https://www.sraoss.co.jp/tech-blog/pgsql/postgresql-update-lock-wait/</link>
		
		<dc:creator><![CDATA[正野 裕大 (Yuta Masano)]]></dc:creator>
		<pubDate>Tue, 30 Jun 2026 05:21:12 +0000</pubDate>
				<category><![CDATA[PostgreSQL]]></category>
		<category><![CDATA[MVCC]]></category>
		<category><![CDATA[pg_blocking_pids()]]></category>
		<category><![CDATA[トランザクション]]></category>
		<category><![CDATA[ロック]]></category>
		<category><![CDATA[監視ビュー]]></category>
		<guid isPermaLink="false">https://www.sraoss.co.jp/tech-blog/?p=20842</guid>

					<description><![CDATA[アプリケーションから次のようなSQLを実行したのに、なかなか応答が返ってこないことがあります。 UPDATE accounts SET balance = balance - 100 WHERE id = 1; こういう ...]]></description>
										<content:encoded><![CDATA[<p>アプリケーションから次のようなSQLを実行したのに、なかなか応答が返ってこないことがあります。</p>
<pre><code>UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>こういうときに原因の一つとして早めに確認しておきたいものがロック待ちです。ロック待ちとは、あるトランザクションが更新中の行などを、別のトランザクションが同時に変更しようとして、先のトランザクションが終わるまで待っている状態です。PostgreSQLはデータの矛盾を防ぐため、同じ行を複数の処理が同時に勝手に書き換えられないようにします。そのため、後から実行した<code>UPDATE</code>は、必要なロックを取得できるまで待つことがあります。</p>
<p>本記事では、同じ行への<code>UPDATE</code>によってロック待ちが起きる状況を作り、どこを確認すれば原因を切り分けられるのかを説明します。</p>
<p><span id="more-20842"></span></p>
<p>対象読者は、PostgreSQLを使い始めたアプリケーション開発者や運用初心者です。SQLは書けるものの、トランザクション、ロック、MVCC、監視ビューの関係をまだ整理できていない人を想定しています。</p>
<h3>実験の前に</h3>
<p>この実験では、<code>psql</code>のセッションを3つ使います。</p>
<ul>
<li>セッションA:先に行を更新して、ロックを保持する</li>
<li>セッションB:同じ行を更新しようとして待つ</li>
<li>セッションC: PostgreSQLの状態を確認する</li>
</ul>
<p>ここで、実験に入る前にトランザクションについて簡単に整理します。</p>
<p>トランザクションとは、複数のSQL操作をひとまとまりの処理として扱う仕組みです。たとえば、口座Aから100円を引き、口座Bに100円を足す処理を考えます。この2つの更新は、片方だけの成功は許されません。引き落としだけ成功して、入金が失敗すると、データの整合性が崩れるためです。そこで、PostgreSQLでは、関連するSQLを1つのトランザクションとして扱えます。</p>
<p><code>BEGIN</code>を実行すると、トランザクションが始まります。</p>
<pre><code>BEGIN;
</code></pre>
<p>トランザクション内で実行した変更は、<code>COMMIT</code>するまで確定しません。</p>
<pre><code>COMMIT;
</code></pre>
<p><code>COMMIT</code>は、トランザクション内で行った変更を確定する操作です。<code>COMMIT</code> すると、他のセッションからもその変更が見えるようになります。一方、変更を取り消したい場合は<code>ROLLBACK</code>を実行します。</p>
<pre><code>ROLLBACK;
</code></pre>
<p><code>ROLLBACK</code>は、トランザクション内で行った変更を取り消す操作です。<code>ROLLBACK</code>すると、そのトランザクションで実行した更新はなかったことになります。</p>
<p>本記事のロック待ちを理解するうえで重要なのは、次の点です。トランザクション中に<code>UPDATE</code>文の実行が終わっていても、<code>COMMIT</code>または<code>ROLLBACK</code>を実行するまで、トランザクションは終わりません。そして、トランザクションが終わるまで、更新に関係するロックが保持されることがあります。つまり、次のような状態が問題になります。</p>
<pre><code>BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- COMMITもROLLBACKもしていない
</code></pre>
<p>この状態では、<code>UPDATE</code> 自体は終わっています。しかし、トランザクションはまだ終わっていません。そのため、別のセッションが同じ行を更新しようとすると、先のトランザクションが終わるまで待つことがあります。</p>
<p>本記事では実験を通して、この「トランザクションが終わっていないために、別の更新が待たされる状態」を意図的に作ります。つまり、単に <code>UPDATE</code>を実行するだけでなく、<code>BEGIN</code>でトランザクションを開始し、あえて <code>COMMIT</code>せずに残す操作が重要になります。</p>
<p>以降の実験では、セッションAがトランザクションを開いたまま行を更新し、セッションBが同じ行を更新しようとして待つ、という流れを何度か使います。</p>
<h2>実験の準備</h2>
<p>まず、検証用のテーブルを作ります。ここでは、口座残高を表す<code>accounts</code>テーブルを使います。</p>
<pre><code>-- accountsテーブルを作成
CREATE TABLE accounts (
  id integer PRIMARY KEY
  , owner_name text NOT NULL
  , balance integer NOT NULL
);

-- データを2件登録
INSERT INTO accounts (id, owner_name, balance)
VALUES
  (1, 'alice', 1000),
  (2, 'bob', 2000);
</code></pre>
<p>初期状態を確認します。</p>
<pre><code>SELECT * FROM accounts ORDER BY id;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
  2 | bob        |    2000
(2 rows)
</code></pre>
<p>以降は各実験を始める前に、セッションAとセッションBで次を実行しておくと安全です。</p>
<pre><code>-- 各実験の前にROLLBACKを実行してトランザクションを終了しておく
-- Session A/B
ROLLBACK;
</code></pre>
<p>すでにトランザクションが終わっている場合は、警告が出ることがあります。その場合でも、この実験では問題ありません。</p>
<p>合わせて、セッションAと セッションBのPIDも確認しておきます。</p>
<pre><code>-- セッションA
SELECT pg_backend_pid();
 pg_backend_pid
----------------
             52
(1 row)


-- セッションB
SELECT pg_backend_pid();
 pg_backend_pid
----------------
             57
(1 row)
</code></pre>
<h2>実験1:同じ行をUPDATEすると片方が待つ</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、同じ行を2つのトランザクションから<code>UPDATE</code>すると、後から実行した <code>UPDATE</code>が待たされることを確認します。ポイントは、先に<code>UPDATE</code>したセッションが<code>COMMIT</code>するまで、後続の <code>UPDATE</code>が進めないことです。</p>
<h3>手順1:セッションAでトランザクションを開始する</h3>
<p>まず、セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>この時点で、セッションAはトランザクションの中に入ります。まだデータは更新していません。</p>
<h3>手順2:セッションAでid = 1の行を更新する</h3>
<p>続けて、セッションAで<code>id = 1</code>の行を更新します。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>この<code>UPDATE</code>自体はすぐに終わります。ただし、まだ<code>COMMIT</code>していません。そのため、セッションA のトランザクションは開いたままです。</p>
<p>ここが重要です。<code>UPDATE</code>文の実行が終わっていても、トランザクションが終わっていなければ、PostgreSQL はその更新に関係するロックを保持し続けます。</p>
<h3>手順3:セッションBで同じ行を更新する</h3>
<p>次に、セッションBでもトランザクションを開始します。</p>
<pre><code>-- Session B
BEGIN;
</code></pre>
<p>そのあと、セッションBで同じ<code>id = 1</code>の行を更新します。</p>
<pre><code>-- Session B
UPDATE accounts SET balance = balance - 50 WHERE id = 1;
</code></pre>
<p>この<code>UPDATE</code>は応答が返ってきません。アプリケーションから見ると、「UPDATEが終わらない」状態に見えます。</p>
<h3>なぜ待つのか</h3>
<p>セッションAは、<code>id = 1</code>の行を先に更新しました。しかし、まだ<code>COMMIT</code>も <code>ROLLBACK</code>もしていません。この状態で、セッションBが同じ行を更新しようとすると、PostgreSQLはセッションB の更新をすぐには進めません。セッションAの更新が確定するのか、取り消されるのかがまだ分からないからです。そのため、セッションBはセッションA のトランザクションが終わるのを待ちます。この待ちが、ロック待ちです。</p>
<h3>この実験で分かったこと</h3>
<p>同じ行を同時に更新しようとすると、後から実行した<code>UPDATE</code>が待つことがあります。ただし、画面上で <code>UPDATE</code>が返ってこないだけでは、SQLの処理が重いのか、ロックを待っているのかは分かりません。</p>
<p>次は、PostgreSQLの中でその待ち状態を確認します。</p>
<h2>実験2: pg_stat_activityで何を待っているかを確認する</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、待っているセッションが本当にロック待ちなのかを確認します。使うのは、<code>pg_stat_activity</code>です。<code>pg_stat_activity</code> は、PostgreSQLに接続している各セッションの状態を確認できるビューです。</p>
<h3>確認するSQL</h3>
<p>セッションCから、次のSQLを実行します。</p>
<pre><code>-- Session C
SELECT
  pid
  , state
  , wait_event_type
  , wait_event
  , xact_start
  , query_start
  , query
FROM
  pg_stat_activity
WHERE
  datname = current_database()
  AND pid &lt;&gt; pg_backend_pid()
  AND query LIKE '%UPDATE accounts%'
ORDER BY
  query_start;
 pid |        state        | wait_event_type |  wait_event   |          xact_start           |          query_start          |                           query
-----+---------------------+-----------------+---------------+-------------------------------+-------------------------------+-----------------------------------------------------------
  52 | idle in transaction | Client          | ClientRead    | 2026-06-15 05:57:26.539576+00 | 2026-06-15 05:57:26.541089+00 | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
  57 | active              | Lock            | transactionid | 2026-06-15 05:57:31.885276+00 | 2026-06-15 05:57:31.886839+00 | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
(2 rows)
</code></pre>
<h3>まず確認する列</h3>
<p>ここで最初に確認する列は、次の3つです。</p>
<ul>
<li><code>state</code></li>
<li><code>wait_event_type</code></li>
<li><code>wait_event</code></li>
</ul>
<p><code>state</code>は、そのセッションの大まかな状態を示します。ここでは、<code>pid = 57</code>のセッションBは <code>state = 'active'</code>になっています。これは、PostgreSQLがそのSQLを処理中として扱っているという意味です。ただし、<code>active</code><br />
だからといって、CPUを使って計算し続けているとは限りません。何かを待っていても、SQLの実行中であれば<br />
<code>active</code>と表示されることがあります。</p>
<p>そこで、<code>wait_event_type</code>と<code>wait_event</code>を合わせて確認します。</p>
<h3>結果の読み方</h3>
<p>セッションBの行を確認すると、次のようになっています。</p>
<pre><code>wait_event_type = Lock
wait_event      = transactionid
</code></pre>
<p><code>wait_event_type = Lock</code>は、ロックを待っていることを示します。<code>wait_event = transactionid</code> は、別のトランザクションが終わるのを待っていることを示します。この例では、セッションBがセッションAのトランザクション終了を待っています。</p>
<p>つまり、セッションBの<code>UPDATE</code>は、検索や計算に時間がかかっているのではありません。ロック待ちで止まっています。</p>
<h3>この実験で分かったこと</h3>
<p><code>UPDATE</code>が返ってこないときは、まず<code>pg_stat_activity</code>を確認します。特に、<code>state</code><br />
だけで判断しないことが重要です。<code>wait_event_type</code>と<br />
<code>wait_event</code>を合わせて確認すると、そのセッションが何を待っているのかを確認できます。</p>
<p>次は、どのセッションが待たせているのかを確認します。</p>
<h2>実験3: pg_blocking_pids()で待たせている相手を探す</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、待っているセッションを止めている相手を特定します。待っている側を、ここではウェイターと呼びます。待たせている側を、ここではブロッカーと呼びます。</p>
<p>PostgreSQLでは、<code>pg_blocking_pids()</code>を使うと、当該PIDのブロッカーPIDを確認できます。</p>
<h3>確認するSQL</h3>
<p>セッションCで次のSQLを実行します。<code>pg_blocking_pids()</code>は引数に指定したPIDのブロッカーPIDの配列を返します。</p>
<pre><code>-- Session C
WITH activity AS (
  SELECT
    pid
    , state
    , wait_event_type
    , wait_event
    , pg_blocking_pids(pid) AS blocking_pids
    , query
  FROM
    pg_stat_activity
  WHERE
    datname = current_database()
    AND pid &lt;&gt; pg_backend_pid()
)
SELECT
  *
FROM
  activity
WHERE
  query LIKE '%UPDATE accounts%'
ORDER BY
  pid;
 pid |        state        | wait_event_type |  wait_event   | blocking_pids |                           query
-----+---------------------+-----------------+---------------+---------------+-----------------------------------------------------------
  57 | active              | Lock            | transactionid | {52}          | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
  52 | idle in transaction | Client          | ClientRead    | {}            | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<h3>結果の読み方</h3>
<p><code>pid = 57</code>の行を確認すると、<code>blocking_pids</code>が<code>{52}</code>になっています。これは、<code>pid = 57</code> のセッションが、<code>pid = 52</code>のセッションで待たされているという意味です。</p>
<p>この例では、次の関係になります。</p>
<pre><code>ウェイター（待っている側）:     pid = 57
ブロッカー（待たせている側）:   pid = 52
</code></pre>
<p>つまり、<code>pid = 57</code>のSQLだけを確認しても原因は分かりません。次に確認すべきなのは、ブロッカーの<code>pid = 52</code>の状態です。</p>
<h2>実験4: idle in transactionはロックを保持し得る状態</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、<code>idle in transaction</code>の意味を確認します。<code>idle in transaction</code>は、トランザクションの中にいるが、現在はSQL を実行していない状態です。何もしていないように見えても、トランザクションが終わっていなければ、ロックを保持していることがあります。</p>
<h3>状況の確認</h3>
<p>ここまでの状態では、セッションAが<code>id = 1</code>の行を更新し、まだ<code>COMMIT</code>していません。セッションB は、同じ行を更新しようとして待っています。</p>
<p>セッションCから次のSQLを実行します。実験3のSQLに表示列(<code>xact_start</code>, <code>state_change</code>)を追加しています。</p>
<pre><code>-- Session C
WITH activity AS (
  SELECT
    pid
    , state
    , wait_event_type
    , wait_event
    , pg_blocking_pids(pid) AS blocking_pids
    , xact_start
    , state_change
    , query
  FROM
    pg_stat_activity
  WHERE
    datname = current_database()
    AND pid &lt;&gt; pg_backend_pid()
)
SELECT
  *
FROM
  activity
WHERE
  query LIKE '%UPDATE accounts%'
ORDER BY
  xact_start NULLS LAST;
 pid |        state        | wait_event_type |  wait_event   | blocking_pids |          xact_start           |         state_change          |                           query
-----+---------------------+-----------------+---------------+---------------+-------------------------------+-------------------------------+-----------------------------------------------------------
  52 | idle in transaction | Client          | ClientRead    | {}            | 2026-06-15 05:57:26.539576+00 | 2026-06-15 05:57:26.542127+00 | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
  57 | active              | Lock            | transactionid | {52}          | 2026-06-15 05:57:31.885276+00 | 2026-06-15 05:57:31.886842+00 | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
(2 rows)
</code></pre>
<h3>結果の読み方</h3>
<p><code>pid = 52</code>のセッションは、<code>state = 'idle in transaction'</code>になっています。</p>
<p>これは、次の状態を意味します。</p>
<pre><code>トランザクションはまだ開いている
ただし、現在はSQLを実行していない
</code></pre>
<p>また、この行では<code>wait_event_type = Client</code>、<code>wait_event = ClientRead</code>になっています。これは、PostgreSQL がクライアントから次の命令を待っていることを示します。つまり、セッションAはデータベース内部でロックを待っているのではなく、クライアント側から次の SQL、<code>COMMIT</code>、または<code>ROLLBACK</code>が送られるのを待っている状態です。</p>
<p>この状態でも、セッションAはロックを解放していません。ロックは、トランザクションが<code>COMMIT</code>または <code>ROLLBACK</code>で終わるまで保持されます。そのため、セッションBは待ち続けます。</p>
<h3>なぜ問題になりやすいのか</h3>
<p><code>idle in transaction</code>は、アプリケーションの作りによって長引くことがあります。</p>
<p>たとえば、次のような処理です。</p>
<ul>
<li>トランザクションを開始したあとに、外部APIの応答を待つ</li>
<li>トランザクションを開始したあとに、ユーザー入力を待つ</li>
<li>例外が発生したのに、<code>ROLLBACK</code>しないまま接続を残す</li>
</ul>
<p>これらは、ロックを保持したまま待ち時間を伸ばす原因になります。</p>
<h3>実務で確認する列</h3>
<p>実務で<code>idle in transaction</code>を見つけたときは、すぐにセッションを終了する前に、まず次の列を確認します。</p>
<ul>
<li><code>xact_start</code></li>
<li><code>state_change</code></li>
<li><code>query</code></li>
<li><code>application_name</code></li>
<li><code>client_addr</code></li>
</ul>
<p>特に<br />
<code>xact_start</code><br />
が古い場合は、長時間トランザクションが開いたままになっている可能性があります。ただし、セッションを強制終了すると、アプリケーション側ではエラーになります。注文更新や残高更新の途中であれば、業務処理にも影響します。そのため、まずはどのアプリケーション、どの接続元、どの処理がトランザクションを開いたままにしたのかを特定することが重要です。</p>
<h3>timeout設定について</h3>
<p><code>idle in transaction</code>を長時間残したくない場合は、<code>idle_in_transaction_session_timeout</code> を使う方法もあります。この設定は、トランザクション内で何もしていないセッションを、指定時間後に切断します。ただし、切断された側のアプリケーションにはエラーとして見えます。本番環境で使う場合は、事前に影響を確認する必要があります。</p>
<h3>この実験で分かったこと</h3>
<p><code>idle in transaction</code><br />
は、何もしていない安全な状態とは限りません。トランザクションが終わっていなければ、ロックを保持し続けることがあります。ロック待ちを調べるときは、待っている側だけでなく、待たせている側の<br />
<code>state</code>と<code>xact_start</code>を確認します。</p>
<p>次は、通常のロック待ちとデッドロックの違いを確認します。</p>
<h2>実験5:通常のロック待ちとデッドロックは違う</h2>
<h3>この実験で確認すること</h3>
<p>ここまでの実験では、セッションBがセッションAを一方的に待っていました。この場合、セッションAが<code>COMMIT</code>または <code>ROLLBACK</code>すれば、セッションBは進めます。これは通常のロック待ちです。</p>
<p>一方で、デッドロックは違います。デッドロックは、複数のトランザクションが互いに相手を待ってしまい、どちらも先へ進めなくなる状態です。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行し、前の実験の状態を終わらせます。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAがid = 1を更新する</h3>
<pre><code>-- Session A
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>セッションAは、<code>id = 1</code>の行を更新します。まだ<code>COMMIT</code>はしません。</p>
<h3>手順2:セッションBがid = 2を更新する</h3>
<pre><code>-- Session B
BEGIN;
UPDATE accounts SET balance = balance - 50 WHERE id = 2;
</code></pre>
<p>セッションBは、<code>id = 2</code>の行を更新します。こちらも、まだ<code>COMMIT</code>はしません。</p>
<p>この時点では、セッションAとBは別々の行を更新しているため、互いに待っていません。</p>
<h3>手順3:セッションAがid = 2を更新しようとする</h3>
<p>次に、セッションAが<code>id = 2</code>の行を更新しようとします。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
</code></pre>
<p><code>id = 2</code>は、すでにセッションBが更新しています。そのため、セッションAはセッションBのトランザクション終了を待ちます。</p>
<p>この時点では、まだデッドロックではありません。セッションAが、セッションBを一方的に待っているだけです。</p>
<h3>手順4:セッションBがid = 1を更新しようとする</h3>
<p>最後に、セッションBが<code>id = 1</code>の行を更新しようとします。</p>
<pre><code>-- Session B
UPDATE accounts SET balance = balance + 50 WHERE id = 1;
</code></pre>
<p><code>id = 1</code>は、すでにセッションAが更新しています。そのため、セッションBはセッションAのトランザクション終了を待ちます。</p>
<p>これで、次の状態になります。</p>
<pre><code>セッションAは、セッションBを待っている
セッションBは、セッションAを待っている
</code></pre>
<p>これがデッドロックです。</p>
<h3>デッドロック時のエラー</h3>
<p>PostgreSQLはデッドロックを検出すると、どちらか一方のトランザクションを中止します。</p>
<p>エラーの例です。</p>
<pre><code>ERROR:  deadlock detected
DETAIL:  Process 57 waits for ShareLock on transaction 2317; blocked by process 52.
Process 52 waits for ShareLock on transaction 2318; blocked by process 57.
HINT:  See server log for query details.
CONTEXT:  while updating tuple (0,1) in relation "accounts"
</code></pre>
<p>このエラーが出たあとは、エラーになったトランザクションはそのまま続けられません。次の実験へ進む前に、セッションAとBの両方で <code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>通常のロック待ちとの違い</h3>
<p>通常のロック待ちは、ブロッカー側が終われば解消します。一方、デッドロックでは、互いに相手を待っています。そのままではどちらも進めません。</p>
<p>そのため、PostgreSQL はどちらか一方を中止して、待ち続ける状態を解消します。どちらのトランザクションが中止されるかをアプリケーション側で決め打ちしてはいけません。 デッドロックで失敗した場合は、失敗したSQLだけを再実行するのではなく、トランザクション全体を最初からやり直す必要があります。</p>
<h3>デッドロックを減らす考え方</h3>
<p>複数行を更新する処理では、更新する順序をそろえることが基本です。たとえば、ある処理は<code>id = 1</code>のあとに <code>id = 2</code>を更新し、別の処理は<code>id = 2</code>のあとに<code>id = 1</code>を更新すると、デッドロックが起きやすくなります。</p>
<p>更新順序を決められるなら、常に同じ順序で更新します。たとえば、常に<code>id</code>の小さい順に更新するなどが考えられます。</p>
<h3>lock_timeoutについて</h3>
<p>通常のロック待ちが長すぎる場合の安全装置として、<code>lock_timeout</code>があります。</p>
<pre><code>SET lock_timeout = '3s';
</code></pre>
<p><code>lock_timeout</code>は、ロックを取得できない状態が指定時間を超えたときに、そのSQL をエラーにします。これは、デッドロックを検出する設定ではありません。ロック待ちが長くなりすぎたSQLを失敗させるための設定です。また、<code>statement_timeout</code> との関係にも注意が必要です。<code>statement_timeout</code>は、SQL全体の実行時間に対する制限です。<code>lock_timeout</code><br />
は、ロック取得待ちに対する制限です。<code>statement_timeout</code>が<br />
<code>lock_timeout</code>以下に設定されていると、ロック待ち専用のエラーより先に <code>statement_timeout</code>が発生します。ロック待ちを切り分けたい場合は、両者の値を分けて設定します。</p>
<h3>この実験で分かったこと</h3>
<p>通常のロック待ちは、ブロッカー側が終われば解消します。一方、デッドロックは、互いに相手を待つため、そのままでは解消しません。PostgreSQL はどちらか一方のトランザクションを中止します。アプリケーションでは、デッドロックやロックタイムアウトで失敗した場合に、トランザクション全体をやり直せるようにしておく必要があります。</p>
<p>次は、書き込みではなく、読み取りがどう見えるのかを確認します。</p>
<h2>実験6:通常のSELECTは止まらない</h2>
<h3>この実験で確認すること</h3>
<p>ここまでの実験では、<code>UPDATE</code>同士の待ちを見てきました。では、あるセッションが行を更新してまだ <code>COMMIT</code>していないとき、別のセッションがその行を<code>SELECT</code>するとどうなるのでしょうか。</p>
<p><code>FOR UPDATE</code>などを付けない通常の<code>SELECT</code>は、多くの場合、更新中の行を待たずに結果を返します。これは、PostgreSQL が、読み取り時点で見えてよい行の版を選んで読みます。この仕組みをMVCC (Multi-Version Concurrency Control) と呼びます。日本語では、多版型同時実行制御と呼ばれます。</p>
<p>以降では、「見えてよい行の版を読む仕組み」を簡単に説明します。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAでid = 1を更新する</h3>
<p>まず、更新前の値を確認します。</p>
<pre><code>-- Session A
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>次に、<code>id = 1</code>の残高を<code>999</code>に更新します。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 999 WHERE id = 1;
</code></pre>
<p>ここでも、まだ<code>COMMIT</code>はしません。つまり、セッションAの変更はまだ確定していません。</p>
<h3>手順2:セッションBで通常のSELECTを実行する</h3>
<p>セッションBから、<code>BEGIN</code>でトランザクションを開始して、同じ行を読み取ります。</p>
<pre><code>-- Session B
BEGIN;
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションBの<code>SELECT</code>はロック待ちになりません。また、セッションAが更新した<code>balance = 999</code>も見えません。セッションB からは、最後に<code>COMMIT</code>済みの値である<code>1000</code>が見えます。</p>
<h3>なぜ止まらないのか</h3>
<p>セッションAの<code>UPDATE</code>は、まだ<code>COMMIT</code>されていません。もし、セッションBから未コミットの <code>999</code>が見えてしまうと、あとからセッションAが <code>ROLLBACK</code>したときに困ります。存在しなかった変更を読んだことになるからです。そのため、PostgreSQLは通常の <code>SELECT</code>に対して、未コミットの変更を見せません。代わりに、読み取り時点で見えてよい、古い行の版を返します。</p>
<p>PostgreSQLのデフォルト設定では、各SQLを実行するたびに、その時点で <code>COMMIT</code>済みのデータを読みます。この設定を、トランザクション分離レベルの<br />
<code>Read Committed</code><br />
と呼びます。トランザクション分離レベルとは、あるトランザクションから、他のトランザクションの変更をどこまで見せるかを決める設定です。</p>
<h3>SELECT FOR UPDATEは待つ</h3>
<p>ただし、すべての<code>SELECT</code>が待たないわけではありません。<code>SELECT FOR UPDATE</code> は、読み取った行をあとで更新する前提でロックしようとします。</p>
<pre><code>-- Session B
SELECT id, owner_name, balance FROM accounts WHERE id = 1 FOR UPDATE;
</code></pre>
<p>この場合は、セッションAのトランザクション終了を待ちます。通常の <code>SELECT</code>は、見えてよい行の版を読めるため、止まらないことが多いです。一方、<code>SELECT FOR UPDATE</code> は行をロックしようとするため、更新中の行と競合します。</p>
<h3>この実験で分かったこと</h3>
<p>PostgreSQLでは、未コミットの変更は通常の<code>SELECT</code>から見えません。この実験では、通常の <code>SELECT</code>は、更新中の行を待たずに、見えてよい行の版を読みます。一方、<code>SELECT FOR UPDATE</code> は行をロックしようとするため、対象の行が他のトランザクションで更新中の場合は、待つことがあります。</p>
<p>次は、ロック待ちしていた<code>UPDATE</code>が再開したときに、どの条件で更新されるのかを確認します。</p>
<h2>実験7: UPDATEは待ったあとにWHEREを再確認する</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、ロック待ちしていた<code>UPDATE</code>が再開したときの動きを確認します。重要なのは、ロック待ちしていた <code>UPDATE</code>が、ロック待ちの前に見えていた古い行をそのまま更新するわけではない、という点です。</p>
<p>PostgreSQLのデフォルト設定では、ロック待ちが終わったあと、更新後の行に対して<code>WHERE</code>条件をもう一度確認します。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAがid = 1を更新する</h3>
<p>まず、更新前の値を確認します。</p>
<pre><code>-- Session A
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>次に、<code>id = 1</code>の残高を<code>1000</code>にします。ここでは、同じ行を更新中の状態にするため、<code>id = 1</code>の残高を <code>1000</code>に更新します。値は変わりませんが、<code>UPDATE</code>は実行されるため、この行はセッションA のトランザクションが終わるまで、他の更新と競合する状態になります。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 1000 WHERE id = 1;
</code></pre>
<p>まだ<code>COMMIT</code>はしません。</p>
<h3>手順2:セッションBが条件付きUPDATEを実行する</h3>
<p>セッションBでトランザクションを開始します。</p>
<pre><code>-- Session B
BEGIN;
</code></pre>
<p>次に、残高が<code>500</code>以上の場合だけ、<code>50</code>減らす<code>UPDATE</code>を実行します。</p>
<pre><code>-- Session B
UPDATE accounts
SET balance = balance - 50
WHERE id = 1
  AND balance &gt;= 500
RETURNING *;
</code></pre>
<p>この<code>UPDATE</code>は待ちます。 セッションAが同じ<code>id = 1</code>の行を更新して、まだ<code>COMMIT</code>していないからです。</p>
<h3>手順3:セッションAが残高を400にしてCOMMITする</h3>
<p>セッションBが待っている間に、セッションAで同じ行の残高を<code>400</code>にします。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 400 WHERE id = 1;
</code></pre>
<p>そのあと、セッションAのトランザクションを確定します。</p>
<pre><code>-- Session A
COMMIT;
</code></pre>
<p>これで、セッションBの待ちが解除されます。</p>
<h3>セッションBの結果</h3>
<p>セッションBの<code>UPDATE</code>は再開します。ただし、セッションB は、ロック待ちの前に見えていた行をそのまま更新するわけではありません。セッションAが<code>COMMIT</code>した後の行に対して、<code>WHERE</code> 条件をもう一度確認します。</p>
<p>この時点で、<code>id = 1</code>の<code>balance</code>は<code>400</code>です。セッションBの条件は次のとおりでした。</p>
<pre><code>WHERE id = 1
  AND balance &gt;= 500
</code></pre>
<p><code>balance = 400</code>なので、<code>balance &gt;= 500</code>は成り立ちません。そのため、セッションBの<code>UPDATE</code>は0 行更新になります。</p>
<pre><code> id | owner_name | balance
----+------------+---------
(0 rows)
</code></pre>
<h3>この動きが重要な理由</h3>
<p>アプリケーションで避けたいのは、先に<code>SELECT</code>で値を確認し、その結果だけを前提にして、あとから無条件に <code>UPDATE</code>する書き方です。</p>
<pre><code>BEGIN;
SELECT balance FROM accounts WHERE id = 1;

UPDATE accounts
SET balance = balance - 500
WHERE id = 1;
COMMIT;
</code></pre>
<p>この書き方では、<code>SELECT</code>してから <code>UPDATE</code>するまでの間に、別のトランザクションが同じ行を更新する可能性があります。つまり、アプリケーションが事前に見た残高と、実際に <code>UPDATE</code>する時点の残高が同じとは限りません。</p>
<p>残高不足を防ぎたいなら、更新してよい条件を<code>UPDATE</code>の<code>WHERE</code>に入れます。</p>
<pre><code>BEGIN;
UPDATE accounts
SET balance = balance - 500
WHERE id = 1
  AND balance &gt;= 500;
COMMIT;
</code></pre>
<p>このSQLは、<code>UPDATE</code>する時点の<code>balance</code>が<code>500</code>以上の場合だけ、残高を減らします。1行更新されれば成功です。0 行なら、残高不足として扱えます。</p>
<h3>分離レベルを上げる場合</h3>
<p>トランザクション分離レベルを<code>Repeatable Read</code>や<br />
<code>Serializable</code><br />
に上げる方法もあります。ただし、その場合は競合する更新を検出して、トランザクションがエラーになることがあります。分離レベルを上げる場合は、失敗した SQLだけでなく、トランザクション全体を最初から再試行できる設計が必要です。</p>
<h3>この実験で分かったこと</h3>
<p>ロック待ちしていた<code>UPDATE</code>は、ロック待ちが終わったあとに <code>WHERE</code>条件を再確認します。そのため、並行更新に強い処理にしたい場合は、事前の<code>SELECT</code>結果だけに頼らず、<code>UPDATE</code> の<code>WHERE</code>に更新条件を入れることが重要です。</p>
<h2>実務での切り分け手順</h2>
<p>ここまでの実験で、ロック待ちの見方を段階的に確認しました。実務でも、まず見るところは同じです。</p>
<p><code>UPDATE</code>が返ってこないときは、最初に<code>pg_stat_activity</code>を確認します。ここで見るのは、待っているセッションの <code>state</code>、<code>wait_event_type</code>、<code>wait_event</code>です。<code>wait_event_type</code>が <code>Lock</code>であれば、そのセッションはロック待ちしている可能性が高いです。</p>
<p>次に、<code>pg_blocking_pids()</code>を使って、そのセッションを待たせているPIDを確認します。待っているSQL だけを見ても、原因は分かりません。重要なのは、待っている（ウェイター）側と、待たせている（ブロッカー）側を分けて見ることです。</p>
<p>待たせている（ブロッカー）側のPIDが分かったら、もう一度<br />
<code>pg_stat_activity</code><br />
を確認します。特に、<code>state</code>、<code>xact_start</code>、<code>state_change</code>、<code>application_name</code>、<code>client_addr</code>、<code>query</code> を見ます。<code>state = 'idle in transaction'</code>で、<code>xact_start</code> が古い場合は、トランザクションを開いたまま放置している可能性があります。ただし、すぐにセッションを終了すればよいとは限りません。まず、どのアプリケーション、どの接続元、どの処理がトランザクションを開いたままにしているのかを確認します。</p>
<h2>再発を減らす設計</h2>
<p>ロック待ちそのものは、PostgreSQLの異常ではありません。同じ行を同時に更新しようとすれば、待つことがあります。</p>
<p>問題になるのは、待たせているトランザクションが長く残り、他の処理を止め続けることです。</p>
<p>ここでは、再発を減らすための基本的な考え方を整理します。</p>
<h3>トランザクションを短くする</h3>
<p>更新や明示的なロックを取得したあとは、できるだけ早く<code>COMMIT</code>または<code>ROLLBACK</code>します。トランザクション中に外部API 呼び出し、ユーザー入力待ち、重いファイル処理などを入れると、ロックを持ったまま待ち時間が伸びます。また、例外が発生した場合は、必ず <code>ROLLBACK</code>します。</p>
<h3>更新順序をそろえる</h3>
<p>複数行を更新する処理では、更新順序をそろえます。ある処理は<code>id = 1</code>のあとに<code>id = 2</code>を更新し、別の処理は <code>id = 2</code>のあとに<code>id = 1</code>を更新すると、デッドロックが起きやすくなります。順序を決められるなら、常に同じ順序で更新します。</p>
<h3>lock_timeoutを検討する</h3>
<p>長時間待たせたくない処理では、<code>lock_timeout</code>を検討します。</p>
<pre><code>SET lock_timeout = '3s';
</code></pre>
<p>これは、ロックを取得できない状態が指定時間を超えたら、そのSQL をエラーにする設定です。ただし、エラーになった場合にアプリケーション側でどう扱うかを決めておく必要があります。</p>
<h3>log_lock_waitsを確認する</h3>
<p>本番環境では、<code>log_lock_waits</code>も確認対象になります。<code>log_lock_waits</code>を有効にすると、<code>deadlock_timeout</code> を超えたロック待ちをログに出せます。常に<code>pg_stat_activity</code>を手動で見続けるのではなく、ログから、どのSQL がいつ、どの程度ロック待ちしたのかを後から確認できます。</p>
<h3>アプリケーションで再試行を考える</h3>
<p>デッドロックやロックタイムアウトで失敗した場合、失敗したSQL だけを途中から再実行するのは危険です。基本は、トランザクション全体を最初からやり直します。ただし、無制限に再試行し続けるのではなく、再試行回数には上限を設けます。</p>
<h3>UPDATEのWHEREに条件を入れる</h3>
<p>並行更新で条件が変わる処理では、事前の<code>SELECT</code>結果だけに頼らないようにします。たとえば、残高が足りる場合だけ引き落とすなら、条件を <code>UPDATE</code>の<code>WHERE</code>に入れます。</p>
<pre><code>BEGIN;
UPDATE accounts
SET balance = balance - 500
WHERE id = 1
  AND balance &gt;= 500;
COMMIT;
</code></pre>
<p>以上、<code>UPDATE</code>が返ってこない状況を、同じ行への更新、ロック待ち、待たせているトランザクション、通常の <code>SELECT</code>の見え方に分けて確認しました。</p>
<p>ロック待ちそのものは、PostgreSQL の異常ではありません。同じデータを同時に矛盾なく更新するために必要な動きです。問題になるのは、ロックを持ったトランザクションが長く残り、他の処理を止め続けることです。</p>
<p><code>UPDATE</code>が返ってこないときは、待っているSQLだけを見るのではなく、PostgreSQLの中で何を待っているのかを確認します。そのうえで、<code>pg_blocking_pids()</code> を使い、待たせている相手を探します。</p>
<p>待っている側と、待たせている側を分けて見る。この見方を持っておくと、ロック待ちを原因の一つとして落ち着いて切り分けられます。</p>
<div>
<a href="https://www.sraoss.co.jp/prod_serv/support/pgsql-mainte/?utm_source=sraoss-techblog&utm_medium=referral&utm_campaign=under-article-pgsql" rel="noopener" style="color:initial;" target="_blank" class="no-ext"></p>
<div style="background-color:#DAEFF6; padding:20px; border-radius:8px; text-align:center;">
SRA OSSでは、PostgreSQL/Pgpool-II のサポートを提供しております。<br />
詳しくは<strong style="color:#2581c4;">弊社ホームページ</strong>をご覧ください。
</div>
<p></a>
</div>

]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>増永教授のDB特論⑧「MVCC」</title>
		<link>https://www.sraoss.co.jp/tech-blog/db-special-lecture/masunaga-db-special-lecture-8/</link>
		
		<dc:creator><![CDATA[増永良文 (Yoshifumi Masunaga)]]></dc:creator>
		<pubDate>Wed, 14 Sep 2022 00:00:16 +0000</pubDate>
				<category><![CDATA[増永教授のDB特論]]></category>
		<category><![CDATA[MVCC]]></category>
		<category><![CDATA[PostgreSQL]]></category>
		<category><![CDATA[RDB]]></category>
		<category><![CDATA[SQL]]></category>
		<category><![CDATA[リレーショナルデータベース]]></category>
		<guid isPermaLink="false">https://www.sraoss.co.jp/tech-blog/?p=10989</guid>

					<description><![CDATA[&#160; 1. はじめに &#8195;トランザクションの同時実行制御は障害時回復とならんでトランザクション管理には欠かせない機能であることは言うまでもないことです．そのために 2 相ロッキング（two phase l ...]]></description>
										<content:encoded><![CDATA[<p>&nbsp;</p>
<h4>1. はじめに</h4>
<p style="margin-top: -10px;">
&emsp;トランザクションの同時実行制御は障害時回復とならんでトランザクション管理には欠かせない機能であることは言うまでもないことです．そのために 2 相ロッキング（two phase locking, 2PL）プロトコルが考案され，伝統的に 2PL が多くのデータベース管理システム（DBMS）で実装されてきました．しかし，2PLでは同時実行されているトランザクションの直列化可能性を保証するために，トランザクションは読取りや更新の対象となるオブジェクトをロック（lock，施錠）することが必要で，それによる同時実行性（concurrency）の制約は古くから認識されるところでした．<br />
&emsp;<strong>多版同時実行制御</strong>（multiversion concurrency control, MVCC）は 2PL とは異なり，競合しているトランザクションの実行終了を待つのではなく，同じデータ項目の異なる<strong>版</strong>（version）を用意することによって，トランザクションの隔離性を向上させ，同時実行性を高めようとするアプローチです．データ項目の版という概念の導入は 1978 年に遡りますが[1]，その考え方はデータベース分野に直ちに入り込み，1980 年代初頭には MVCC の理論の礎が築かれました[2]．MVCC と一口に言ってもその実現法は <strong>MVTO</strong>（multiversion timestamp ordering），MV2PL，MVMM，MVOCC，SI（snapshot isolation，スナップショット隔離性），SSI（serializable snapshot isolation，直列化可能スナップショット隔離性）など多様です．現在 MVCC はこのようなさまざまな実現法を包括した用語として用いられると同時に，狭義には MVCC の原点である MVTO を指す言葉としても用いられます．現在，多くのプロプラィエタリ（proprietary）あるいは OSS のリレーショナル DBMS で MVCC が実装されています．<br />
&emsp;2PL と MVCC ではトランザクションの同時持実行制御の考え方が根本的に異なるので，2PL を念頭に制定された国際標準リレーショナルデータベース言語 SQL が定めた隔離性水準（isolation level）と MVCC の提供する隔離性水準との間には<ruby>齟齬<rt style="background-color: #dddddd;">そご</rt></ruby>が出ます．現在 PostgreSQL や Oracle で実装されている SI は ANSI SQL の隔離性水準を論評する過程で考案され，1995 年に公表されました[5]．<br />
&emsp;本稿では，MVTO と SI を中心において，MVCCと は何かを改めて議論しておきたいと考えます．</p>
<p><span id="more-10989"></span></p>
<h4>2. MVCC</h4>
<p style="margin-top: -10px;"><strong>2.1 MVCC とは</strong><br />
&emsp;<strong>MVCC</strong> という用語はとても一般的になっていますが，そもそも MVCC という概念は「更新可能なオブジェクトを不変な<strong>版</strong>（version）の系列と見なす」と発想した Reed の博士論文 “Naming and Synchronization in a Decentralized Computer Systems”[1] に見ることができます（1978 年 9 月にマサチューセッツ工科大学（MIT）に提出した学位請求論文）．この考え方は 1981 年に InterBase で実装されたということです（その後，Firebird としてオープンソース化されました）．<br />
&emsp;データベース分野で MVCC が本格的に論じられたのは Bernstein と Goodman が 1981 年に発表した論文 “Concurrency Control in Distributed Database Systems”[2]と考えられます．彼らはその論文で Reed の手法を “Multiversion Timestamp Ordering <strong>(MVTO)</strong>” として形式化し，その正当性の証明を与えて MVCC によるトランザクションの同時実行制御の時代の幕を切って落としました．MVCC の実現法はざまざまに考えられ，彼らはその論文で MVTO に加えて，従来の2PLに版の概念を導入して拡張した <strong>MV2PL</strong>，読みのみを発行するトランザクションを同期させるためには MVTO を使用し読み書きを行うトランザクションの同期には厳密な 2PL（strict 2PL）を使うMVMM（multiversion mixed method）を提案し，それらの正当性を証明しています．これら，初期の MVCC の手法は Bernstein らの一連の論文と著書に詳しく記載されています[2, 3, 4]．その後，MVCC の手法として Larson ら[6]により <strong>MVOCC</strong> が提案されています．これは，トランザクションの同時実行制御法として知られている楽観的同時実行制御法（optimistic concurrency control, OCC）[7]に多版（multiversion）の概念を導入した手法です．そして，ANSI SQL の隔離性水準を論評する過程で<strong>スナップショット隔離性</strong>（snapshot isolation， <strong>SI</strong>）が提案されました[5]．1995 年のことです．SI やそれを直列化可能とした<strong>直列化可能スナップショット隔離性</strong>（Serializable snapshot isolation，<strong>SSI</strong>）はシドニー大学（University of Sydney）の Fekete や Cahill ら[8, 9, 10]によりその性質や実装法が明らかにされましたが，それらも MVCC の一種です．このように MVCC は，広義には SI や SSI を含む多くの異形をカバーする用語ですが，狭義には MVTO を表す用語と理解するのが理にかなっているかと考えます．</p>
<p><strong>2.2 2PL vs. MVCC</strong><br />
&emsp;2PL ではなく，MVCC でトランザクションの同時実行を行うと何が嬉しいのか，それを単純ですが典型的な例で確認しておきたいと思います．以下，ここで想定している MVCC は，この概念の基礎となった MVTO をフォーマルに記述したものとします．なお，トランザクションの同時実行スケジュール，スケジュールのビュー等価（view equivalence）や相反等価（conflict equivalence）などの説明は省略しますが，参照されたい向きには拙著[11]を薦めます．<br />
&emsp;まず具体的に MVCC の意味するところを直観することにします．そこで，S<sub>1</sub> をトランザクション T<sub>1</sub> と T<sub>2</sub> の同時実行スケジュールとし，<strong>図 1(a)</strong>に示す通りとしましょう．すると，S<sub>1</sub> は相反直列化可能でない（従ってビュー直列化可能でもない）ことが確かめられますから，S<sub>1</sub> は 2PL では正しい実行を保証されないスケジュールであることが分かります．<br />
&emsp;ところが，MVCC のもとではこのスケジュールでトランザクションを実行しても正しい結果が得られます．それはどうしてでしょうか？そうなる仕組みはどのようなものなのでしょうか？それを見てみましょう．<br />
&emsp;まず，具体的に，なぜスケジュール S<sub>1</sub> は正しい結果を保証しないのでしょうか？それは，時刻5で発行された T<sub>1</sub>のデータ項目 y の読み，T<sub>1</sub>:read(y) は，T<sub>2</sub> が時刻 4 で y に書き出した T<sub>2</sub>:write(y) の結果を読んでしまうが，（トランザクションの隔離性という観点から考えれば）本来はデータ項目 y の初期値，これを y<sub>0</sub> と書く，を読みたかったはずなのに，スケジュール S<sub>1</sub> ではそれが叶わなかったということです．<br />
&emsp;しかし，もし T<sub>1</sub> と T<sub>2</sub> の同時実行スケジュールが<strong>図 1(b)</strong>に示した S<sub>2</sub> であったらどうでしょうか？このときは，容易に確かめられるように，S<sub>2</sub> は相反直列化可能スケジュールとなり，このスケジュールで T<sub>1</sub> と T<sub>2</sub> を同時実行すれば正しい結果が保証されます．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 550px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P03-01.png" alt="スケジュールS1とS2" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 1　スケジュール S<sub>1</sub> と S<sub>2</sub> </b></p>
<p></center></p>
<p>&emsp;さて，実は，MVCC のもとでは，スケジュール S<sub>1</sub> に従ってトランザクション T<sub>1</sub> と T<sub>2</sub> を同時実行しても，正しい結果を保証してくれます．これはどうしてかというと，MVCC では<strong>版</strong>の概念があるので，たとえスケジュール S<sub>1</sub> に従って T<sub>1</sub> と T<sub>2</sub> を同時実行しても，実質的にはスケジュール S<sub>2</sub> で T<sub>1</sub> と T<sub>2</sub> を実行したことになるからです．それが<ruby>正<rt style="background-color: #dddddd;">まさ</rt></ruby>しく MVCC の意図するところです．<br />
&emsp;そこで， MVCC アルゴリズムに従いトランザクションの同時実行をスケジュールする<strong>多版スケジューラ</strong>（mulitiversion scheduler）がどのようにトランザクションステップの実行を制御していくのか，そのアルゴリズムを示しますが，それを理解するための助けとなるかと考え，いくつか補足的説明を行います．</p>
<p style="margin-top: -10px;" > (1)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
トランザクション群 {T<sub>1</sub>,T<sub>2</sub>,・・・,T<sub>n</sub>}を同時実行するためのスケジュール S が与えられたとする．S に従いトランザクション T<sub>i</sub> が実行を開始したとき，その時の時刻を T<sub>i</sub> に<strong>時刻印</strong>（timestamp），これをts(T<sub>i</sub>)と書く，として付与する．一般に，時刻は単調に増加する識別子，例えばカウンタ，なら何でもよい（その意味で論理時刻ともいう）．トランザクションは並列（parallel）実行ではなく，同時（concurrent）実行なので，お互いの開始時間は異なるから，トランザクションが異なればそれらの時刻印は異なっていて，一意性が保証されている．つまり，時刻印を比較するとどちらが先発，あるいは後発のトランザクションであるかが分かる．
</td>
</tbody>
</table>
<p style="margin-top: -10px;" > (2)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
次に，データ項目 x を考える．多版スケジューラは x の<strong>版</strong>，これを x<sub>i</sub>, x<sub>j</sub>, x<sub>k</sub>, …という具合に書く，を保持する．版はトランザクションがデータ項目に対して書きを実行したときに生成される．例えば，トランザクション T<sub>i</sub> がデータ項目 x に対して write(x) を発行しそれが実行されれば，版 x<sub>i</sub> が生成される．このとき，x<sub>i</sub> にはそれが生成された時刻が時刻印として付与される．また，MVCC アルゴリズムはデータ項目の版に基づき作動するので，トランザクションの同時実行で使われるデータ項目 x については，その<strong>初期版</strong>（initial version）を設定しておく必要がある．そのために，各データ項目 x の初期版 x<sub>0</sub> を生成する擬似的なトランザクション T<sub>0</sub>，その時刻印は 0 とする，がすべてのトランザクションステップに先行して実行されることとする．
</td>
</tbody>
</table>
<p style="margin-top: -10px;" > (3)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
MVCC アルゴリズムを理解する上で大事なことは，データ項目 x の版の存在は多版スケジューラが把握していればよいことであって，ユーザが意識する必要はない．つまり，ユーザが発行するトランザクションはデータ項目の版を意識する必要はないということである．換言すれば，ユーザにとっては，データ項目 x の版はただ 1 つしかないといえる．したがって，トランザクション T<sub>i</sub> からデータ項目 x に対して読み（T<sub>i</sub>:read(x)）や書き（T<sub>i</sub>:write(x)）が発行された場合，多版スケジューラはそれらをデータマネジャが処理できるようにするために， データ項目 x の版，x<sub>i</sub>, x<sub>j</sub>, x<sub>k</sub>,…，に対する読み（r<sub>i</sub>[x<sub>k</sub>]，T<sub>i</sub> が版 x<sub>k</sub> を読むという意味）や書き（w<sub>i</sub>[x<sub>i</sub>]，T<sub>i</sub> が x に書込みをして版 x<Sub>i</sub> が生成される）に変換しないといけない．その変換によって，図 1 の例で説明すれば，スケジュール S<sub>1</sub> はあたかもスケジュール S<sub>2</sub> に従っているかのような実行を実現できたのである．
</td>
</tbody>
</table>
<p><strong>【MVCC アルゴリズム】</strong><br />
&emsp;MVCC アルゴリズムは次の規則に則り，トランザクションの読みや書きを版（version）への読込みや書込みに変換する．<br />
　(1)　T<sub>i</sub>:read(x) を r<sub>i</sub>[x<sub>k</sub>] に変換する．このとき x<sub>k</sub> は ts(T<sub>i</sub>) 以下で最大の時刻印を持つ x の<br />
　　　版を表す．<br />
　(2)　T<sub>i</sub>:write(x) は次の 2 つに場合分けされる．<br />
　　　　(i) もし，ts(T<sub>k</sub>)＜ts(T<sub>i</sub>)＜ts(T<sub>j</sub>)を満たす i, j, k に対して，r<sub>j</sub>[x<sub>k</sub>]なる処理が行われてい<br />
　　　　　 たならば，T<sub>i</sub>:write(x) は棄却される（従って，T<sub>i</sub> はアボートされる．）．<br />
　　　　(ii) そうでなければ，T<sub>i</sub>:write(x)をw<sub>i</sub>[x<sub>i</sub>] に変換する．</p>
<p>&emsp;補足すると，(2)(i) の言っていることは，自分（T<sub>i</sub>）より後発のトランザクション（T<sub>j</sub>）が自分より先発のトランザクション（T<sub>k</sub>）が書き出した結果を読んでしまっている（r<sub>j</sub>[x<sub>k</sub>]）なら，自分がそのデータ項目 x を書き換えるとことは許されない，ということである．</p>
<p>&emsp;さて，MVCC アルゴリズムに従った多版スケジューラが出力したスケジュールを<strong>多版スケジュール</strong>といいますが，この MVCC アルゴリズムに従って，図 1 (a) に示したスケジュール S<sub>1</sub> でトランザクション T<sub>1</sub> と T<sub>2</sub> を同時実行して得られた多版スケジュールを<strong>図 2</strong> に示します（<strong>←</strong>は代入を表す）．特に注目するべきところは，時刻 5 で，T<sub>1</sub>:read(x) は MVCC のもとでは，T<sub>2</sub> が直前に書き出した y<sub>2</sub> を読むのではなく，MVCC アルゴリズムの (1) により，y の初期値 y<sub>0</sub> を読んでいるところです．その結果，<br />
MVCC に従うとスケジュール S<sub>1</sub> で T<sub>1</sub> と T<sub>2</sub> を同時実行しても，その実行結果としての多版スケジュールは従来の相反直列化可能なスケジュール S<sub>2</sub> での実行と同じになっていて，従って，正しい実行であると考えることができるわけです．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 480px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P04-01.png" alt="スケジュール S1 の多版スケジュール" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 2　スケジュール S<sub>1</sub> の多版スケジュール</b></p>
<p></center></p>
<p>&emsp;このように，2PL の同時実行制御の考え方では相反直列化可能ではないスケジュール S<sub>1</sub> が，MVCC アルゴリズムのもとでは正しい実行を保証してくれるスケジュールと考えてよいことを示しましたが，この根底には MVCC アルゴリズムの正当性が示されていないといけません．つまり，このアルゴリズムに則って多版スケジューラが出力する多版スケジュールでトランザクションを同時実行することによってデータベースの一貫性が損なわれることはない，ということの証明が必要ということです．この証明の道筋は，多版スケジュールを単一版（single version, 1V）スケジュールに変換して（単一版とは版が 1 つしかないということだから，従来型のスケジュールということで，従って，従来型の同時実行制御の考え方が適用できる），その直列化可能性から多版スケジュールの正当性を示すのですが，この証明はいささか複雑すぎます．どうしてもそれを知りたいという読者は，文献[4]の第 5 章で与えられていますので，それに当たってください．ここでは，これ以上立ち入らず，MVCC アルゴリズムは正しいという結果を述べるに留めたいと思います．</p>
<h4>3. SI と SSI</h4>
<p style="margin-top: -10px;"><strong>3.1 SI の提案</strong><br />
&emsp;さて，1995 年に “A Critique of ANSI SQL Isolation Levels” と題した論文[5]が発表されました．この論文は，題目の通りANSI（American National Standards Institute，米国国家規格協会）が制定した SQL のトランザクションの隔離性水準の不備を指摘するとともに，「直列化可能ではないものの，<br />
ANSI SQL が指摘した現象，つまり<strong>汚読</strong>（dirty read），<strong>反復不可能な読み</strong>（unrepeatable read），<strong>幽霊</strong>（phantom）が発生しない多版同時実行メカニズム」を定義して，それを<strong>スナップショット隔離性</strong>（Snapshot Isolation，<strong>SI</strong>）と名付けました．そこでは，SI は MVMM（multiversion mixed method）の拡張であると紹介され，SI は ANSI の定義した READ COMMITTED よりは強く，<br />
REPEATABLE READ とは強弱が言えないことが述べられています．また，直列化可能ではないことの理由として<strong>書込みスキュー異状</strong>（write skew anomaly）の発生を挙げています．<br />
&emsp;SI は MVTO や MV2PL などと違ってトランザクションの同時実行の正しさ，つまりトランザクションの直列化可能性を保証するプロトコルではなく，書込みスキュー異状に加えて<strong>読取り専用トランザクション異状</strong>（read-only transaction anomaly）[8]の発生も許してしまうのですが，その特性はシドニー大学（University of Sydney）の研究者により深く研究されその性質や実装法が明らかにされました[8, 9, 10]．Fekete ら[9]は SI の下で TPC-C ベンチマークが異状を発生することなく実行可能であったことを実験的に示して，直列化可能性を保証できない SI ではあるが，ほとんどのトランザクションを問題なく同時実行できるのではないかということを強調しました．Cahill ら[10]は SI を直列化可能とする <strong>SSI</strong>（serializable snapshot isolation，直列化可能 SI）のアルゴリズムとその実装，ならびにその性能については様々なケースで 2PL より大幅に改善し，往々にして SI と同程度であったと報告しています．ただ，SSI では，現実的な実装法の制約から，本来は直列化可能なスケジュールなのにその実行が棄却されてしまうという<strong>擬陽性</strong>（false positive）が発生することは避けられないことには注意が必要です．これらの現象については，以下でより詳しく例題を挙げて説明します．<br />
&emsp;現在，SI は PostgreSQL，Oracle Database，MS SQL Server などで実装されています．SI は汚読，反復不可能な読み，幽霊を引き起こさないので，それを実装すれば SQL の隔離性水準である SERIALIZABLE を実現していることになります．Oracle Database はそれでもって SERIALIZABLE を実現，と<ruby>謳<rt style="background-color: #dddddd;">うた</rt></ruby>っているのですが，2PL に基づいた SERIALIZABLE の実現と違って SI では書込みスキュー異状や読取り専用トランザクション異状が発生するので，トランザクションの同時実行制御の理論が謳うところの真の意味での（あるいは完全な）直列化可能性を達成しているわけではないわけで，<br />
SERIALIZABLE と謳うのはいかがなものかと，この点で物議を<ruby>醸<rt style="background-color: #dddddd;">かも</rt></ruby>してきたことは本稿の読者であればどこかで耳にしていることでしょう．一方，PostgreSQL では REPEATABLE READ を SI で，<br />
SERIALIZABLE を SSI で，READ COMMITTED は SI を緩める，つまり，各読み<ruby>毎<rt style="background-color: #dddddd;">ごと</rt></ruby>にスナップショット（snapshot）を取り直す，ことで実装しています（READ UNCOMMITTED は実装されていなく，その隔離性水準を指定すると default の READ COMMITTED となります）．この詳細は Ports と Grittner [12]により報告されています．したがって，PostgreSQL では Oracle Database のような物議は<ruby>醸<rt style="background-color: #dddddd;">かも</rt></ruby>しませんが，前述のように SERIALIZABLE では擬陽性が発生することがあるので，それに注意する必要があります．</p>
<p><strong>3.2 SI</strong><br />
&emsp;さて，SI の定義を見てみることから始めましょう．<br />
<strong>【定義 1】(SI)</strong><br />
&emsp;SI の下で実行されるトランザクション T<sub>1</sub> は，それが開始された論理時刻，これを開始時刻印（start-timestamp）と呼ぶ，の時点で有効なコミット済みデータからなるスナップショットから常にデータを読み取る．T<sub>1</sub> の開始後にアクティブな他のトランザクションの更新は T<sub>1</sub> には見えない．T<sub>1</sub> がコミットの準備ができると，コミット時刻印（commit-timestamp）が割り当てられ，他の同時トランザクション T<sub>2</sub>（つまり，アクティブ期間 [開始時刻印, コミット時刻印] が T<sub>1</sub> の期間と重複するトランザクション）がすでに T<sub>1</sub> が書き込むことを意図しているデータに書込みをしていない場合にコミットが許可される．これは，遺失更新（lost update）を阻止するためで，<strong>First-Committer-Wins</strong> ルールと呼ばれる．</p>
<p>&emsp;実際には，ほとんどの実装では，更新された行に排他ロックが使用されるため，First-Committer-Wins の代わりに，First-Updater-Wins ルールが適用されています．共に，同時実行されている 2 つのトランザクションが同じデータ項目を更新することはできないというためのルールで，その差異は重要ではありません．これは遺失更新異状が発生しないことを意味しているわけです．同様に，トランザクション T のすべての読みは T が開始する前にコミットしたトランザクションの結果を見るので，不完全なトランザクションの影響がなく，これは SI では汚読の異状が発生しないことを意味します．<br />
&emsp;SI の定義と補足説明でほぼ明らかかと思われますが，トランザクションはその開始時点でのスナップショットを読み続けるので，汚読，反復不可能な読み，幽霊は発生のしようがなく，その結果として SI は SQL の規定している隔離性水準 SERIALIZABLE でのトランザクションの同時実行を保証してくれます．<br />
&emsp;しかしながら，トランザクションの同時実行制御の理論が謳うところの「真」の意味での直列化可能性（serializability）は満たしていないわけです．なぜならば，SI では書込みスキュー異状や読取り専用トランザクション異状が発生してしまうからです．このことを例題で説明しましょう．</p>
<p><strong>【書込みスキュー異状】（write skew anomaly）</strong><br />
&emsp;たとえば，データ項目 x，y の初期状態を，x<sub>0</sub>=50, y<sub>0</sub>=50 とします.また，データベースには一貫性制約が課せられていて，それは x+y≧0 であったとします．<br />
&emsp;このとき，SI のもとでトランザクション T<sub>1</sub> と T<sub>2</sub> が同時実行され，そのスケジュールが<strong>図 3</strong> に示されたようであったとします．論理時間は縦軸の上から下の方へ流れていっているとします．T<sub>1</sub> の読んだ x と y の初期値 <sub>x0</sub> と <sub>y0</sub> はそれぞれ 50 で，両者を足して 100 となります．このとき，T<sub>1</sub>が xを －20<br />
に書換えて x<sub>1</sub>=－20 としても（つまり，x<sub>0</sub>－70 を実行したということ），y<sub>0</sub>=50 なので，x<sub>1</sub>+y<sub>0</sub>=30<br />
となり一貫性制約には抵触しなく，T<sub>2</sub> はまだコミットしていないので，First Committer Wins ルールでコミットできます（それを c<sub>1</sub> で表しています）．一方，T<sub>1</sub> と同時実行されている T<sub>2</sub> は x<sub>0</sub> と y<sub>0</sub> を読み，y<sub>2</sub>=－30 と y を更新したとします．この更新も一貫性制約に抵触しないので許されます．さらに，T<sub>2</sub> は y を更新したのであって，x を更新したのではないので，First Committer Wins ルールによりコミットできます（これを c<sub>2</sub> で表しています）．<br />
&emsp;さて，T<sub>1</sub> と T<sub>2</sub> の同時実行により，データベースの状態はどのようになったでしょうか？データ項目 x の値は －20 となりました．一方，データ項目yの値は －30 となりました．両方を足すと，x+y の値は －50 になり，これはデータベースの一貫性制約 x+y≧0 に抵触していることになります．この問題は First-Committer-Wins ルールの適用時には検出されませんでした．なぜならば，2 つの異なるデータ項目は，それぞれが他方の状態が変化することなく元のままであることを前提として更新されているためです．それが，「ずれた書込み」（write skew）と名付けられた<ruby>所以<rt style="background-color: #dddddd;">ゆえん</rt></ruby>です．なお，図中，rw は rw-dependency （rw-従属性）の存在を示しています（rw-従属性の説明は 3.3 節）．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 360px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P09-01.png" alt="書込みスキュー異状が発生するトランザクションの同時実行例" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 3　書込みスキュー異状が発生するトランザクションの同時実行例</b></p>
<p></center></p>
<p><strong>【読取り専用トランザクション異状】(read-only transaction anomaly)</strong><br />
&emsp;3 つのトランザクション間に生起する異状で，そのうちの 2 つは更新トランザクションですが，1 つは読取り専用トランザクションで，この読取り専用トランザクションで発生する異状です．そこで，T<sub>1</sub>, T<sub>2</sub> を更新トランザクション, T<sub>3</sub> を読取り専用トランザクションとし，それらが SI の下で，<strong>図 4</strong> に示されたように同時実行されたとします．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 430px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P09-02.png" alt="読込み専用トランザクション異状が発生するトランザクションの同時実行例" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 4　読込み専用トランザクション異状が発生するトランザクションの同時実行例</b></p>
<p></center></p>
<p>&emsp;First-Committer-Wins ルールに従い，T<sub>1</sub> は y<sub>1</sub>=20 として問題なくコミットします（c<sub>1</sub>）．同様に T<sub>2</sub> は x<sub>2</sub>=－11 として問題なくコミットします（c<sub>2</sub>）．T<sub>3</sub> は読取り専用トランザクションなので，問題なくコミットします（c<sub>3</sub>）．<br />
&emsp;さて，このトランザクションの同時実行に問題はなかったのでしょうか？いや，実は，大きな問題があるのです．T<sub>3</sub> が返すデータ項目 x，y の値はそれぞれ 0 と 20 です．しかし，x=0, y=20 という結果は，T<sub>1</sub>, T<sub>2</sub>, T<sub>3</sub> をどのように直列実行しても得られる結果ではなく，意味不明です．このことについて付加的な説明を加えると，トランザクションが同時実行されたときに，その結果が正しいとはトランザクション群のある直列実行が存在して，その時に得られる結果になる，ということです．実際，T<sub>1</sub>, T<sub>2</sub>, T<sub>3</sub> の直列実行の仕方は3! (=6) 通りありますが，それらが返す x と y の値は次の通りです．ここで，例えば，T<sub>1</sub>→T<sub>2</sub>→T<sub>3</sub> はトランザクションが T<sub>1</sub>，T<sub>2</sub>，T<sub>3</sub> の順に直列実行されたことを表します．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 320px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P10-01.png" alt="直列実行" /></center> <br />
つまり，図 4 に示した T<sub>3</sub> は x=0, y=20 を返したのですが，これは T<sub>1</sub>, T<sub>2</sub>, T<sub>3</sub> のどのような直列実行の結果ともなっておらず，<ruby>おかしい<rt style="background-color: #dddddd;">・・・・</rt></ruby>というわけです．T<sub>3</sub> の返した結果は一体何だったのでしょうか？<br />
&emsp;なお，図中，wr は wr-dependency （wr-従属性）の存在を示しています（wr-従属性の説明は 3.3 節）．</p>
<p><strong>3.3 SII</strong><br />
&emsp;書込みスキュー異状や読込み専用トランザクション異状が発生するので，SI では真の意味での直列化可能性を保証できないということで，「SI を真の意味での直列化可能にする」ための研究が行われ，<strong>直列化可能スナップショット隔離性</strong>（serializable snapshot isolation，<strong>SSI</strong>）が Fekete ら[9]によって提案されました．まず，その定義を見てみたいと思いますが，鍵となる概念は SI の下でのデータ項目への書きや読みの間に観察される <strong>rw-従属性</strong>（rw-dependency）です．このような従属関係を基に<strong>直列化グラフ</strong>（serialization graph）を作成すると，SI の下で実行されるトランザクションの直列化可能性を規定することができ，SSI を定義できます．このことを，シドニー大学の研究者の論文 [8, 9, 10]を参考にして，少し詳しく見ていきましょう．<br />
&emsp;まず，一般に，MVCC や SI といった多版同時実行制御のもとで生成される多版スケジュールの直列化可能性は，<strong>多版直列化グラフ</strong>（multiversion serialization graph, <strong>MVSG</strong>）を用いて説明することができます．First-Committer-Wins ルールが，x の版を生成する 2 つのトランザクションの間では，一方が開始する前に他方がコミットしていることを保証している SI の下では，データ項目 x の版はそれらの版を作成したトランザクションの時系列に従って順序付けられるので，それに基づき MVSG を次のように定義できます．つまり，MVSG では，次の状況 (i)～(iii) のときに，あるコミット済みトランザクション T<sub>1</sub> から別のコミット済みトランザクション T<sub>2</sub> にエッジ（edge，辺）を設定します．</p>
<p style="margin-top: -10px;" >　(i)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
&emsp;T<sub>1</sub> は x の版を生成し，T<sub>2</sub> は x の新しい版を生成している（ww-従属性）．
</td>
</tbody>
</table>
<p style="margin-top: -10px;" >&emsp;(ii)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
&emsp;T<sub>1</sub> は x の版を生成し，T<sub>2</sub> はこの（またはそれ以降の）版の x を読み取っている（wr-従属性）．
</td>
</tbody>
</table>
<p style="margin-top: -10px;" >&emsp;(iii)</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
&emsp;T<sub>1</sub> は x の版を読取り，T<sub>2</sub> は x の新しい版を生成している（rw-従属性）．
</td>
</tbody>
</table>
<p>&emsp;<strong>図 5</strong> に図 3 に示した書込みスキュー異状が生じたトランザクション T<sub>1</sub> と T<sub>2</sub> の同時実行の MVSG を示します．rw-従属性が点線の矢印で示されています．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 280px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P11-01.png" alt="書込みスキュー異状（図 3）のMVSG" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 5　書込みスキュー異状（図 3）のMVSG</b></p>
<p></center></p>
<p>&emsp;さて，トランザクション理論で知られているように[4]，一般に MVSG にサイクルがないことは，トランザクションの同時実行が直列化可能であることを保証します．したがって，同時実行制御に SI を使用するシステムでどのような種類の MVSG が発生する可能性があるかを理解することが重要になります．<br />
&emsp;このことについて，Fekete ら[9, 10]は，「どのサイクルにも隣接して発生する 2 つの rw-従属性エッジがあり，さらに，これらのエッジのそれぞれが 2 つの同時実行されているトランザクションの間にあること」を示しました．そこで，同時実行されているトランザクション間の rw-従属性を<strong>脆弱なエッジ</strong>（vulnerable edge）と呼ぶことにし，サイクル内で 2 つの連続した脆弱なエッジが発生する状況を<strong>危険な構造</strong>（dangerous structure）と呼ぶことにします．これを<strong>図 6</strong> に示します．2 つの連続する脆弱なエッジの接合部のトランザクションを<strong>ピボット</strong>（pivot）トランザクションと呼びます．図 6 では T<sub>1</sub> がピボットです．そのうえで，SI のもとで直列化可能とならない同時実行の MVSG には必ずピボットがあることを示しました．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 440px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P11-02.png" alt="MVSG における「危険な構造」の一般化" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 6　MVSG における「危険な構造」の一般化</b></p>
<p></center></p>
<p><strong>■　SI で書込みスキュー異状が発生することの説明</strong><br />
&emsp;図 3 を使って説明します．図 3 では rw-従属性を 2 つ確認できます．一つは T<sub>2</sub> がデータ項目 x を読んだ後に T<sub>1</sub> がデータ項目 x を更新しています．もう一つは，T<sub>1</sub> がデータ項目 y を読んだ後に T<sub>2</sub> がデータ項目 y を更新しています．では，これらのことは SI というトランザクションの同時実行環境下ではどういう意味を持つのでしょうか？<br />
&emsp;まず，前者の場合ですが，SI の定義を思い出してください，次のようになります．「T<sub>2</sub> は，それが開始された時点で有効なコミット済みデータからなるスナップショットから常にデータを読み取る．T<sub>2</sub> の開始後にアクティブな他のトランザクションの更新は，T<sub>2</sub> には見えない」ということです．これは何を意味するのでしょうか？明らかです．T<sub>1</sub> が T<sub>2</sub> より先に実行され T<sub>1</sub> が開始される以前にコミットされては困る，ということを表しています．（First-Committer-Wins ルールの場合．もし，First-Updater-Wins ルールの場合は，T<sub>1</sub> が開始される以前にデータ項目 x を更新されては困る，となります）つまり，このことを回避するには，T<sub>2</sub> の実行を T<sub>1</sub> に先行させればよいわけです．このことを rw-従属性 T<sub>2</sub> <ruby>⇢<rt style="background-color: #dddddd;">rw</rt></ruby> T<sub>1</sub> で表したわけです．データ項目 y に関する後者の場合も同様で，rw-従属性 T<sub>1</sub> <ruby>⇢<rt style="background-color: #dddddd;">rw</rt></ruby> T<sub>2</sub> が得られます．この 2 つの rw-従属性から図 5 に示した書込みスキュー異状の MVSG が得られたわけです．明らかに，このグラフには「危険な構造」があります．したがって，T<sub>1</sub> と T<sub>2</sub> のこのスケジュールでの同時実行は直列化可能ではなかったことが分かります．</p>
<p><strong>■　SI で読取り専用トランザクション異状が発生することの説明</strong><br />
&emsp;図 4 で示した読取り専用トランザクション異状の同時実行から MVSG を作成すると<strong>図 7</strong> のようになります．明らかにこのグラフには「危険な構造」があります．したがって，図 4 に示した同時実行のスケジュールは直列化可能でないことが分かります．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 400px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P12-01.png" alt="読取り専用トランザクション異状（図 4）のMVSG" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 7　読取り専用トランザクション異状（図 4）の MVSG</b></p>
<p></center></p>
<p>&emsp;さて，ここまで議論すると，SI の下で直列化可能を実現するための考え方は，ほぼ明らかになったと言えます．トランザクションを同時実行していく過程で MVSG を作り，そこに「危険な構造」を見つけたら，それを解消するために何らかのトランザクションをアボート（abort）すればよいわけです．しかしながら，危険な構造は「<ruby>サイクル<rt style="background-color: #dddddd;">・・・・</rt></ruby>内で 2 つの連続した脆弱なエッジが発生する状況」であったのですが，そのためには同時実行されているすべてのトランザクションの実行を監視してそれら間の rw/wr/ww-従属性からサイクルが発生していないかを見つけなければなりません．Cahill ら[10]はそのコストは尋常ではないと考え，サイクルが形成されているかどうかは無視して，<strong>2 つの連続した脆弱なエッジが発生する状況</strong>を検知することだけにしました．その代償として，SSI では<strong>擬陽性</strong>（false positive）が発生してしまうのです．</p>
<p><strong>【定義 2】(SSI)</strong><br />
&emsp;SI の下で実行されるトランザクションの同時実行において，「2 つの連続した脆弱なエッジが発生する状況」を検知した場合は，直列化可能ではないと判定する．そうでなければ，SI の下で，直列化可能なトランザクションの同時実行が保証される．</p>
<p>&emsp;この定義に基づく SSI の実装は，まず，T を同時実行しているトランザクションとして，2 つのブールフラッグ（boolean flag）T.inConflict と T.outConflict を定義します．T.inConflict は同時実行されている何らかのトランザクションから T に rw-従属性があるか否かを示します．一方，T.outConflict はTから同時実行している何らかのトランザクションに rw-従属性があるか否かを示します．さらに，これらの情報を繋いで「2 つの連続した脆弱なエッジが発生する状況」を検知するために，通常の WRITE ロックとこのために特別に用意した SIREAD ロックを導入して行います．詳細に興味のある読者は Cahill らの論文[10]にあたってください．</p>
<p><strong>【擬陽性】</strong><br />
&emsp;擬陽性を呈するトランザクションの同時実行例を<strong>図 8</strong> に示します．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 460px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P13-01.png" alt="擬陽性が発生するトランザクションの同時実行例" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 8　擬陽性が発生するトランザクションの同時実行例</b></p>
<p></center></p>
<p>&emsp;ちなみに，図 8 で示されたトランザクションの同時実行の MVSG を描くと<strong>図 9</strong> に示すとおりです．明らかに，そこには「危険な構造」があります．したがって，トランザクションの直列化可能性を損なう恐れがあるということで，ピボットの T<sub>1</sub> あるいは T<sub>2</sub> でも T<sub>3</sub> でも構いませんが，いずれかのトランザクションをアボートすることを SSI スケジューラは行うということです．</p>
<p><center><img decoding="async" style="margin-top: -12px; width: 340px;" src="https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2022/09/drmasunaga-08-P14-01.png" alt="擬陽性が発生するトランザクションの同時実行例（図8）のMVSG" /></center></p>
<p><center></p>
<p style="margin-top: -30px;"><b>図 9　擬陽性が発生するトランザクションの同時実行例（図 8）の MVSG</b></p>
<p></center></p>
<p>&emsp;では，何が，問題だったのでしょうか？この原因は明らかです．図 6 に示したように，本来は危険な構造をその一部とする rw/wr/ww-従属性の「サイクル」が存在するときに初めて直列化可能ではないと言えるのですが，SSI ではサイクル検出には膨大なコストが掛かることを懸念して，「危険な構造」ではなく「2 つの連続した脆弱なエッジが発生する状況」を検出したら，それだけで直列化可能ではないと判定してしまったということです．ただ，これに関しては，擬陽性はめったに起こらないと釈明しています[10]．</p>
<h4>4. おわりに</h4>
<p style="margin-top: -10px;">
&emsp;MVCC とは多版の概念を持ち込むことによりトランザクションの同時実行性の向上を目指した技術です．本稿では，MVCC の原型であるMVTO にまず焦点を当てて，2PL では同時実行できないトランザクションが MVCC では同時実行できることを示して，その考え方の基本を示しました．続いて，MVCC の考え方に則った SI に焦点を当てて，その考え方と，それが SQL の隔離性水準である SERIALIZABLE を実現するが，書込みスキュー異状や読取り専用トランザクション異状が発生し，理論的な意味での真の直列化可能性を実現するものではないことに言及しました．SI は真の直列化可能性を実現できる SSI に進化しましたが，SSI の現実的な実装では擬陽性という異状が発生してしまう可能性のあることも紹介しました．SI 並びに SSI の性能評価については先に紹介した通り，SI の下で TPC-C ベンチマークが異状を発生することなく実行可能であること，SSI の性能は様々なケースで 2PL より大幅に改善し，往々にして SI と同程度であったとの報告があることを紹介しました．<br />
&emsp;PostgreSQL では隔離性水準を REPETABLE READ に設定すると SI が，SERIALIZABLE に設定すると SSI が駆動するように実装されています．また，PostgreSQL 14.1 Documentation（Chapter 13. Concurrency Control. 13.1 Introduction）[13] には次のような記載があります（アンダーラインは筆者による）．“Table- and row-level locking facilities are also available in PostgreSQL for applications which don&#8217;t generally need full transaction isolation and prefer to explicitly manage particular points of conflict. <u>However, proper use of MVCC will generally provide better performance than locks.</u>”このように，PostgreSQL はロック法ではなく MVCC の使用を推奨しているようです．<br />
&emsp;このような状況ですが，隔離性水準を READ COMMITTED に設定して（このレベルでは lost update，すなわち ww-conflict が発生することがある），表レベル及び行レベルのロック機能を使って特定の競合ポイントを明示的に管理することで，ちゃんとアプリケーション開発を行っている事例のあることは筆者の耳にするところです．ベンチマークテストの結果はもちろん参考になるとは思いますが，2PL vs. MVCC の議論の<ruby>要<rt style="background-color: #dddddd;">かなめ</rt></ruby>は，データベースアプリケーション開発の現場で発生するトランザクション群の同時実行制御にどちらが適しているのか，雰囲気や時代に流されるのではなく，それを見極める「力」が現場に求められているということではないでしょうか．</p>
<p><strong>【文献】</strong></p>
<p style="margin-top: -10px;" >[1]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
D.P. Reed. Naming and Synchronization in a Decentralized Computer System. MIT-LCS-TR-205, September, 1978.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[2]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
P.A. Bernstein and N. Goodman. Concurrency Control in Distributed Database Systems. ACM Computing Surveys, Vol.13, No.2, pp.185-221, 1981.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[3]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
P.A. Bernstein and N. Goodman. Multiversion concurrency control—theory and algorithms. ACM Transactions on Database Systems, Vol.8, No.4, pp.65-483, 1983.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[4]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
P.A. Bernstein, V. Hadzilacos and N. Goodman. Concurrency Control and Recovery in Database Systems (Book). Addison-Wesley Publishing Company, 1987.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[5]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
H. Berenson, P. Bernstein, J. Gray, J. Melton, E. O’Neil and P. O’Neil. A Critique of ANSI SQL Isolation Levels. Proceedings of the ACM SIGMOD International Symposium on Management of Data, pp.1-10, 1995.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[6]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
Per-Åke Larson, Spyros Blanas, Cristian Diaconu, Craig Freedman, Jignesh M. Patel and Mike Zwilling. High-Performance Concurrency Control Mechanisms for Main-Memory Databases. Proceedings of the VLDB Endowment, Vol. 5, No. 4, 298-309, 2012.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[7]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
H.-T. Kung and J.T. Robinson. On Optimistic Methods Concurrency Control. ACM Transactions on Database Systems, Vol.6, No.2, pp.213–226, 1981.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[8]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
A. Fekete, E. O’Neil and P. O’Neil. A Read-Only Transaction Anomaly Under Snapshot Isolation. ACM SIGMOD Record, Vol. 33, No. 3, pp.12–13, 2004.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[9]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
A. Fekete, D. Liarokapis, E. O’Neil, P. O’Neil and D. Shasha. Making Snapshot Isolation Serializable. ACM Transactions on Database Systems, Vol. 30, No. 2, pp.492–528, 2005.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[10]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
M.J. Cahill, U. Roehm and A. Fekete. Serializable Isolation for Snapshot Databases. Proceedings of the ACM SIGMOD International Symposium on Management of Data, pp.729-738, 2008.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[11]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
増永良文．リレーショナルデータベース入門[第3版]．サイエンス社，2017年．
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[12]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
D.R.K. Ports and K. Grittner. Serializable Snapshot Isolation in PostgreSQL. Proceedings of the International Conference on Very Large Data Bases, pp.1850-1861, 2012.
</td>
</tbody>
</table>
<p style="margin-top: -22px;" >[13]</p>
<table style="border:none; margin-top: -62px; margin-left: 20px; margin-bottom: -00px;" align="left" >
<tbody style="border:none;">
<td style="width: 800px; border:none;">
PostgreSQL 14.1 Documentation.<br />
<a href="https://www.postgresql.org/docs/14/index.html" target="_blank" rel="noopener noreferrer">https://www.postgresql.org/docs/14/index.html</a>
</td>
</tbody>
</table>
]]></content:encoded>
					
		
		
			</item>
	</channel>
</rss>
