例えば２人が同じドキュメントを同時に編集しようとすると、変更が競合してデータが壊れてしまいますよね。これを避けるために用いられるのが排他制御で、適切な排他制御を導入することで安全なデータベース利用が可能になります。

ザックリいえば、同時に複数の人が同じデータに対して更新をしないようにデータにロックをかけましょう！というのが「排他処理」です。

排他制御は大きく以下の２通りあります。ここではそれぞれどのような仕組みで排他制御を実現しているのか？という観点で１からわかりやすく初心者向けにご説明します。

楽観ロック (Optimistic Locking) とは？

楽観ロックは、「他の人が同時にデータを使うことは少ないだろう」と考えてデータを扱う方法です。簡単に言うと、楽観ロックはデータの変更が同時に起きることをあまり心配せずに進めるけど、最後に問題がないかチェックする仕組みです。

楽観ロックの動作原理

1. データの読み取り
   • まず、データを読み取るときにそのデータのバージョンや変更された時間を記録します。これは「データがこの時点でどうなっているか」を覚えておくためです。
2. データの変更
   • 次に、データを変更します。この時点では他の誰かも同じデータを変更しているかもしれないと考えますが、気にせずに変更を進めます。
3. データの更新前のチェック
   • データをデータベースに保存する前に、最初に記録したバージョンや変更された時間と、現在のデータのバージョンや時間を比べます。
     • バージョンが同じ→他の誰もその間にデータを変更していないことが確認できるので、変更を保存。
     • バージョンが異なる→他の誰かがそのデータを変更したことが分かるので、今回の変更は失敗とみなします。再度データを読み取り直して、もう一度最初からやり直し。

楽観ロックの具体例

シナリオ　オンラインショッピング

背景: オンラインショッピングサイトで商品を購入する場合を考えます。このサイトでは在庫管理のために楽観ロックを使っていることとします。

1. データの読み取り
   • あなたがサイトにアクセスして、欲しい商品を選択。この時点で在庫情報が10個存在することと現在の時間を記録しておきます。
2. データの変更
   • 商品をカートに入れ、10個全部の購入手続きを進めます。（クレジットカード情報を入力し配送先の確認などを行うイメージ。）この間、他のユーザーも同じ商品を購入しようとしていますが、あなたは特に気にせず手続きを進めます。
3. データの更新前のチェック
   • 最後に「購入」ボタンを押したときにシステムで再度在庫を確認します。
     • 在庫がまだ10個ある場合→システムは他の誰もこの商品を購入していないことを確認。これにより、あなたの購入手続きを完了し、「購入が成功しました」と表示。
     • 在庫が変わっている場合（例えば、8個に減っている場合）→システムは、他の誰かがその間に商品を購入したことを検出します。この場合、システムは「在庫が不足しています」と表示し、あなたの購入手続きをやり直すように求めます。

このように楽観ロックは、データの競合が少ないことを前提として処理を進め、最後に一貫性を確認する方法です。システムはデータの更新時にだけ問題をチェックするので、全体的なパフォーマンスが向上しますが、競合が発生した場合には再試行が必要となるデメリットがあります。

悲観ロック (Pessimistic Locking) とは？

悲観ロックは、「他の人が同時にデータを使う可能性が高いから、今使っている間は他の人が触らないようにしよう」と考えてデータを扱う方法です。簡単に言うと、悲観ロックはデータを使うときにしっかりと鍵をかけて、誰もそのデータに触れないようにする仕組みです。

悲観ロックの動作原理

1. データの読み取り時にロックをかける
   • データを読み取るときに、そのデータに「鍵」をかけます。これにより、他の人はそのデータを使えなくなります。
2. データの変更
   • 鍵をかけた状態でデータを変更。誰もそのデータにアクセスできないので、安心して変更可能。
3. トランザクションの終了
   • 変更が終わり、トランザクションが完了したら鍵を外す。→これで他の人が再びそのデータを使えるようになる。

参考　トランザクションとは？

悲観ロックの具体例

シナリオ　オンラインデータベースのレコード編集

1. データの読み取り時にロックをかける
   • 会社のデータベースで顧客情報を編集しようとする場合に悲観ロックを採用しているとします。この場合顧客情報を読み取ると同時にその情報にロックをかけます。これにより、他の社員はその顧客情報を編集できなくなります。
2. データの変更
   • 顧客情報を更新します(例えば、住所を変更したり連絡先を追加したり）。この間、他の社員はその顧客情報を編集しようとすると、「他の人が編集中です」と表示され、待つことになります。
3. トランザクションの終了
   • あなたが編集を終えて変更を保存します。すると、ロックが解除され、他の社員もその顧客情報を編集できるようになります。

このように悲観ロックはデータを使っている間に他の人がそのデータにアクセスできないようにする方法です。データの競合が頻繁に発生する場合や、データの一貫性が非常に重要な場合に使われます。

まとめ　悲観ロックと楽観ロックの違い

悲観ロックと楽観ロックの実装例

ここからは「楽観ロック」と「悲観ロック」について再度振り返りつつ、より具体的にその実装例をお示します。

楽観ロック（Optimistic Lock）

概要
楽観ロックは、「データが他のトランザクションによって変更される可能性は低い」と仮定し、ロックをかけずに更新を試みます。競合が発生した場合のみエラーを出して処理をやり直します。

メリット

• ロックを使用しないため、パフォーマンスに優れる
• 競合が少ない環境では効率的に動作

デメリット

• 競合が頻発すると、更新のリトライが発生し、処理が遅くなる
• 競合時に例外処理を適切に実装する必要がある

SQLを使った楽観ロックの例

UPDATE products 
SET stock = stock - 1, version = version + 1 
WHERE id = 1 AND version = 3;

このSQLでは、version 列を利用して競合チェックを行います。もし version = 3 のレコードが他のトランザクションで変更されていた場合、この UPDATE は影響を与えず、更新されません（つまり競合が発生したことを示す）。

Java（JPA/Hibernate）を使った楽観ロックの例

import jakarta.persistence.*;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private int stock;
    
    @Version // 楽観ロックのためのバージョン管理
    private int version;

    // getter, setter
}

public void updateStock(EntityManager entityManager, Long productId) {
    entityManager.getTransaction().begin();
    
    Product product = entityManager.find(Product.class, productId);
    product.setStock(product.getStock() - 1);
    
    entityManager.getTransaction().commit();
}

ここでは @Version アノテーションを使い、バージョン管理を行っています。
もし commit() する前に他のトランザクションが Product を更新していた場合、OptimisticLockException がスローされ、更新が失敗します。

例外処理の実装例

public void updateStockWithRetry(EntityManager entityManager, Long productId) {
    int retryCount = 3;

    for (int i = 0; i < retryCount; i++) {
        try {
            entityManager.getTransaction().begin();
            Product product = entityManager.find(Product.class, productId);
            product.setStock(product.getStock() - 1);
            entityManager.getTransaction().commit();
            return;
        } catch (OptimisticLockException e) {
            entityManager.getTransaction().rollback();
            System.out.println("競合発生。リトライ " + (i + 1));
        }
    }
    throw new RuntimeException("更新に失敗しました");
}

このように OptimisticLockException をキャッチして、一定回数リトライすることで、楽観ロックによる競合が発生した際の対処を行います。

悲観ロック（Pessimistic Lock）

概要
悲観ロックは、「データが他のトランザクションによって変更される可能性がある」と考え、最初にロックを取得する方式です。更新対象のデータに排他ロックをかけ、他のプロセスが更新できないようにします。

メリット

• データ競合が頻発する場合に適している
• データの一貫性を高く維持できる

デメリット

• ロックの保持時間が長くなるとパフォーマンスに悪影響
• デッドロックのリスクがある

SQLを使った悲観ロックの例（MySQL）

START TRANSACTION;
SELECT * FROM products WHERE id = 1 FOR UPDATE; -- レコードに排他ロック
UPDATE products SET stock = stock - 1 WHERE id = 1;
COMMIT;

このSQLでは FOR UPDATE を使用して、id = 1 のレコードに排他ロックをかけています。他のトランザクションがこのレコードを更新しようとすると、現在のトランザクションが終了するまで待たされます。

Java（JPA/Hibernate）を使った悲観ロックの例

import jakarta.persistence.*;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private int stock;

    // getter, setter
}

public void updateStock(EntityManager entityManager, Long productId) {
    entityManager.getTransaction().begin();
    
    Product product = entityManager.find(Product.class, productId, LockModeType.PESSIMISTIC_WRITE);
    product.setStock(product.getStock() - 1);
    
    entityManager.getTransaction().commit();
}

LockModeType.PESSIMISTIC_WRITE を指定すると、対象のエンティティに対して排他ロックが取得されます。これにより、他のトランザクションが同じ Product を更新しようとするとブロックされます。

悲観ロックと楽観ロック：どちらを選ぶべきか？

• 悲観ロックが適しているケース
  • 銀行の口座取引など、データの厳密な一貫性が求められる場面
  • 更新競合が頻繁に発生し、リトライ処理が過負荷になる場合
• 楽観ロックが適しているケース
  • 競合がほぼ発生しないシステム（ユーザーごとの個別設定データなど）
  • 大量のトランザクションが発生するが、競合が少ない場合

• 悲観ロック は「競合することを前提」に排他制御を行い、確実なデータ更新を保証するが、パフォーマンスの問題がある。
• 楽観ロック は「競合しないことを前提」に高速に処理できるが、競合が起こるとリトライが必要。

上記の実装方法を理解し、システムの特性に応じて適切なロック方式を選択することが重要です。

IT初心者向けにわかりやすく説明すると「あらゆる情報が整理されている収納箱」のようなものと言えます。

データベースという概念が誕生する前は「〇〇の情報が知りたいなら東京にいく」「■■が知りたいなら大阪に行く」といったように、補完されている場所も形式もバラバラで、一元的な管理が行えませんでした。

そこで必要なデータを決められた形式で保持するための仕組みとして考えだされたのがデータベース。

システムエンジニアの世界では "DataBase" の頭文字をとって「DB」と呼ぶのが一般的。

このページでは、IT初心者向けに「データベースとは何か？」を１からわかりやすく解説します

プログラマーやシステムエンジニアを目指す方であれば、知らないと恥ずかしい超・基本知識の１つ。是非最後までご覧ください。

データベースとは

冒頭でも簡単にご説明した通り、データベースは一言で説明すると「様々なデータを決まった形で整理して集めたもの」「それを実現するための仕組み」です。

「様々なデータを決まった形で整理して集めたもの」「それを実現するための仕組み」－。

この定義に当てはまるものは基本的にデータベースと呼んでOK。

ただし、このページではより実践的に「システム」「IT」の世界における「データベース」の意味や特徴に焦点を当てて解説していきます。

1. 広義の意味での「データベース」
   • 定義：一定の基準や体系に従って集められ、整理・格納された情報やデータの集まり。
   • 例：図書館（物理的な本や資料の集合）、成績表（学生の成績データの集合）、アルバム（写真の集合）など。
   • 特徴：物理的・電子的問わず、情報やデータを一元的に集約・保管している場所やシステム全般を指す。
2. システムの世界での「データベース」
   • 定義：コンピュータシステム上で動作し、データの保存、検索、更新、削除などを効率的に行うためのソフトウェアやシステム。
     →データの持続性、整合性、並行アクセスのサポートなどの機能を持つ。
   • 例：Oracle、MySQL、PostgreSQL、MongoDBなどのデータベース管理システム（DBMS）。
   • 特徴：通常、特定のクエリ言語（例：SQL）を使用してデータにアクセスし、データの整合性やセキュリティを保ちながら、高速にデータを処理することが可能。

データベースの役割

IT / システムの文脈のおける「データベース」。その主な目的は、複数のデータを一元的に保存し、必要なデータを簡単に検索・取得・追加・更新・削除することができるようにすること。これにより、企業や組織が効率的に情報を扱うことができます。

Tips：データベースの歴史

補足としてデータベースの成り立ち・歴史を簡単にご説明したいと思います。

データベースという用語はDoD (Department of Defense = 米国国防省) で誕生しています。アメリカ国内で散在していた様々な軍事情報を一か所に集め、そこを見れば国内すべての軍事情報をすべて把握できるようにしたのがデータベースの起源です。

データベースという概念が誕生する前は、〇〇の情報を知りたいなら□□の図書館へ・・・△△の情報を知りたいなら●●の大学へ・・・・と情報収集するにも膨大な労力が必要でした。もっと言うと、そもそもあまり「情報」「データ」というものが今ほど重要視されていなかった時代に、情報の重要性を認識しその必要性に応じて誕生したのが「データベース」です。

散在している情報を１か所に集積し、決まった形で管理・保持することで、必要な情報を素早く収集することが可能にしたい！　→これが "データベース" の起源です。

データベースの例

データベースはシステムの世界に限らず実は様々な場面で利用されています。

広い意味で言うと、電話帳やアドレス帳、クラスの生徒名簿など、決まった形でデータが集められているのでデータベースの例と言えます。

我々はこのように様々な場面でデータベースを活用していることが分かります。

もしデータベースがなかったら、〇〇さんの電話番号が知りたい！思っても、過去のメモなどを頑張って探したり、知っている人に聞いたりしないといけません。

同じようにシステムの世界でも、決まったデータを決まった形で整理・保持しておくことは、システムの効率性を高めるうえで非常に重要なことなのです。

では、コンピュータの世界ではどのようにデータを管理・整理しているのでしょうか。次に、コンピュータ内部におけるデータ保持形式の違いに着目してデータベースを分類して解説します。

データベースの種類

データベースは、どのような形でデータを保持するか？という観点で見た際、以下の３種類に分類することができます。

３種類のデータベース

• リレーショナルデータベース
  ⇒エクセルのように表形式でデータを保存する
• 階層型データベース
  ⇒ツリー状にデータを保存する
• ネットワーク型データベース
  ⇒データを相互に関連付けて保存する

ここでは、代表的な３つのデータベースを見ていきながら、データベースのイメージを深めていきましょう。

リレーショナルデータベース

データベースの中で最も一般的に利用されるのがリレーショナルデータベースです。

リレーショナルデータベースは、エクセルのように表形式（テーブル）であらわされるデータベースで、テーブル間の関係（リレーション）を定義することでデータの結びつきや関連性をわかりやすく表します。

普段何気なく利用している電話帳や、学校の先生が使っていた出席簿などは、リレーショナルデータベースの原型とも言えます。そのうえで、リレーショナルデータベースの特徴は「リレーショナル」の名の通り（学生の個人情報を保持するテーブルや、成績を管理するテーブルなどを表形式で整理しつつ）それら２つのテーブルの関連性がわかるように整理されていることが特徴です。

「データベースといえばリレーショナルデータベース」と言っても過言ではないぐらいポピュラーな形式。データベースの勉強をする＝リレーショナルデータベースの勉強をする　という感じなので、リレーショナルデータベースという用語は必須で頭に入れておきましょう。

リレーショナルデータベースを専門的に解説すると

リレーショナルデータベースをより専門的に説明すると、表形式のデータを使用してデータを保存・管理するためのデータベースモデルと説明できます。

このモデルでは、データが複数のテーブルに分割され、各テーブルには行と列があります。

各テーブルは列に対応する「フィールド」と行に対応する「レコード」で構成され、フィールドにはテーブル内で保存されるデータの種類に応じてデータ型が定義されます。レコードには、テーブル内の各フィールドに対応する値が含まれます。

リレーショナルデータベースでは、複数のテーブルをリレーション（関連）として定義することができます。これにより、異なるテーブル間でデータを結合することができます。

例えば、生徒情報を保存するテーブルと成績情報を保存するテーブルがある場合、これら2つのテーブルを生徒の所属するクラスに関連付けることで、クラスごとの科目の点数を簡単に取得することが可能になります。

リレーショナルデータベースは、データの整合性を維持しやすく、柔軟性があります。

SQL（Structured Query Language）を使用してデータの検索、更新、挿入、削除などを行うことができます。そのため、リレーショナルデータベースは、現代のアプリケーションやビジネスにおいて、最も一般的に使用されているデータベースモデルの1つです。

参考　SQLとは？

階層型データベース

階層型データベースは、データを階層型の親子関係で表現するデータベースです。

上記の階層型データベースの例では、英語の点数を各生徒別に保持しています。Cさんの点数は、英語 ＞ C と階層をたどることで取得することができます。

この他にも階層型データベースの例としては、会社の組織図やOSのファイル管理システム（ディレクトリ）が分かりやすいかと思います。

階層型データベースのポイントは、データをツリー構造で表すということ。 そして1つのデータが他の複数のデータに対して、親子関係をもつということがポイントです。

class Department:
    def __init__(self, name):
        self.name = name
        self.sub_departments = []

    def add_sub_department(self, department):
        self.sub_departments.append(department)

    def display(self, level=0):
        print('  ' * level + self.name)
        for sub_department in self.sub_departments:
            sub_department.display(level + 1)

root = Department("会社")
sales = Department("営業部")
root.add_sub_department(sales)
sales.add_sub_department(Department("東京営業部"))
sales.add_sub_department(Department("大阪営業部"))

root.display()

# 会社
#   営業部
#     東京営業部
#     大阪営業部

ネットワーク型データベース

ネットワーク型データベースは、階層型データベースに代わるデータモデルの1つで、データの関係性を以下のようなグラフ構造で表現する方法です。

ネットワーク型データベースは、複数のデータレコードが相互に関連している場合に使用されます。各レコードは、複数の「親」レコードおよび「子」レコードにリンクすることができます。

例えば、会社の組織図を考えてみると、ネットワーク型データベースでは、部下が複数の上司を持つ場合に柔軟に対応できます。上司と部下の関係がツリー構造で表現される階層型データベースではそれが表現できません。

また同様に下記のネットワーク型データベースを見れば、Aさんは国語と英語を受験していますが、Cさんは英語しか受験していないということが分かります。

ネットワーク型データベースは従来の階層型データベースに比べて柔軟性が高く、複雑な関係を持つデータを扱うのに適しています。が、データの整合性を維持するために、リンクの数やパスの長さに制限がある場合があるという点がデメリットです。

【まとめ】データベースとは？

このプロトコルに従うトランザクションは、ロックの取得が成長フェーズと縮小フェーズの2つの段階で行われるため、この名前が付けられました。

成長フェーズではロックを取得し、縮小フェーズではロックを解放します。結果として、2PLはデータベースシステムにおける一貫性と整合性を確保する重要な役割を果たします。

このページでは、2相ロッキングプロトコル（2PL）の基本原則から具体的な動作、利点と欠点、実装例までを総合的に解説します。データベースエンジニアを目指す方であれば知らないと恥ずかしい基本知識の１つです。是非最後までご覧ください。

2相ロッキングプロトコル（2PL）とは？

2相ロッキングプロトコル（2PL）は、名前の通り、2つのフェーズで構成されるロッキングプロトコルです。データベースで多くの人が同時に作業するとき、お互いの作業がぶつからないように管理する方法の１つとして使用されます。

2相ロッキングプロトコル（2PL）は、具体的には成長フェーズと縮小フェーズの２つのフェーズから成り立ちます。

PL１　成長フェーズ（Growing Phase）

• 目的: トランザクションが必要なリソースに対してロックを取得します。
• 動作: このフェーズでは、トランザクションは新たなロックを取得することができますが、一度解放したロックを再取得することはできません。
• 注意点: 成長フェーズの終了時点で必要な全てのロックを取得しておく必要があります。

PL2　縮小フェーズ（Shrinking Phase）

• 目的: トランザクションが完了するために不要なロックを解放します。
• 動作: このフェーズでは、トランザクションはロックを解放することができますが、新たなロックを取得することはできません。
• 注意点: 必要なロックを解放してもデータの整合性が保たれるように慎重に解放する必要があります。

なぜ２つのフェーズに分けるのか？

2相ロッキングプロトコルが2つのフェーズに分かれる理由は、データの一貫性と整合性を保つためです。

具体例を通して、この点を詳しく見ていきましょう。

銀行の口座間送金

口座Aから口座Bへの送金を行うトランザクションを考えます。

ステップ１　成長フェーズ

• ロック取得: 口座Aの残高をチェックし、送金額が足りるか確認するため、口座Aにロックを取得。
• 新たなロック取得: 送金額が足りることが確認できれば、送金先の口座Bにロックを取得。

この段階では、ロックの取得が柔軟に行えます。

ステップ２　縮小フェーズ

• ロック解放の開始: 口座Aから送金額を減らし、口座Bに送金額を加算後、ロックを解放。
• 新しいロック取得の禁止: 一度縮小フェーズに入ると新しいロックの取得はできなくなります。

もし、この操作を2相ロッキングプロトコルに従わないとすると、例えばトランザクション1が口座Aのロックを取得している間に、トランザクション2が口座Bのロックを取得してしまう可能性があります。両者が互いの口座にロックを取得しようとすると、お互いが待ち合いの状態に陥りデッドロックが発生します。

また、同様に送金処理中に他のトランザクションが同じ口座への入金を行うと、最終的な口座残高が正しく反映されない可能性が出てきてしまいます。

2相ロッキングプロトコルは、データベースの一貫性と整合性を確保する重要なプロセス。2つのフェーズに分けない場合、死ロックの発生、データの不整合、パフォーマンスの低下など、多岐にわたる弊害が生じる可能性が生じてしまいます。

2相ロッキングプロトコルのロックの種類

2相ロッキングプロトコルでは、以下のロックが組み合わせて使用され、データベースの一貫性と整合性を確保します。各ロックの種類とその特性を理解することは、効果的なトランザクション処理の設計において重要なので、ここで詳細を以下に記載しておきます。

２相ロッキングプロトコルのメリット・デメリット

ここからは、2相ロッキングプロトコル（2PL）のメリットとデメリットについて、より具体的に実際のコード例も交えながらご説明していきます。

メリット１：整合性の保証

2PLはデータへのアクセスが他のトランザクションと干渉しないように制御します。これにより、データの整合性、つまり一貫性が保たれます。

以下のコードは、トランザクションを開始する際に、必要なロックを取得するシンプルな例です。

def start_transaction():
    acquire_locks() # データにアクセスする前にロックを取得
    # 以下、処理の実行

ロックを取得することで、同時にデータへのアクセスを試みる他のトランザクションと競合しないようにします。

メリット２：並行処理のサポート

2PLは、多くのトランザクションを同時に効率的に処理できます。ロックの管理により、複数のトランザクションが同時にデータにアクセスしても問題が発生しないようにします。

# 複数のトランザクションを並行実行
threads = [Thread(target=transaction_process) for _ in range(10)]
for t in threads:
    t.start()

このコードは、10個のトランザクションを同時に起動しています。それぞれのトランザクションは独立して処理されます。

デメリット１：デッドロックの可能性

デッドロックは、トランザクション同士が互いのロックを待ち合う状態のことです。2PLではこの問題が発生する可能性があります。

# デッドロックの検知と解決
def detect_deadlock():
    # デッドロックの検知ロジック
    # 必要に応じてロックの解放

このコード例は、デッドロックを検知し、必要に応じてロックを解放する仕組みを示しています。

関連　デッドロックとは？

デッドロックとは、複数のプログラムやトランザクションが同時に実行されるときに、お互いが必要とするリソース（例えばデータやファイル、メモリなど）を既に相手が保持しているため、どちらも先に進めなくなってしまう状態を指します。

たとえば、プロセスAがリソースXを持っていてリソースYを要求し、同時にプロセスBがリソースYを保持してリソースXを必要とすると、どちらも相手のリソースが解放されるのを待つだけになり、結果として永遠に動けなくなってしまうのです。

これは、狭い通路でお互いに譲らず前に進めない二人の人の状況に例えることができます。

この現象が発生すると、システム全体が停止してしまう可能性があるため、特にデータベースや複雑なマルチタスク環境では大きな問題となります。システムの設計段階から、どのリソースをどの順番で確保するか、または一定時間内に取得できなかった場合はタイムアウトして処理を中断するなどの工夫をすることで、デッドロックの発生リスクを軽減できます。

デメリット２：パフォーマンスの低下

2PLでロックの競合が頻繁に発生すると、システムの効率が低下することがあります。つまる、あるトランザクションがロックを持っている間、他のトランザクションが待機する必要があるため、処理の遅延が発生する可能性があります。

from threading import Lock

lock = Lock()

def transaction_process():
    with lock: # このロックが競合すると効率が低下します
        # 複雑な処理
        pass

# 複数のトランザクションを並行実行
threads = [Thread(target=transaction_process) for _ in range(10)]
for t in threads:
    t.start()

このコードは、10個のトランザクションが同一のロックを取得しようとして競合する状況を示しています。一度に1つのトランザクションしかロックを取得できないため、他のトランザクションは待機する必要があります。この待機時間が積み重なると、システム全体の効率が低下する可能性があります。

この問題を解決するためには、ロックの粒度を調整する、トランザクションのスケジューリングを工夫するなどの工夫が必要です。

補足：よくある質問

参考　SQLとは？（初心者向け解説）

名前に「window」と付いているのは、この関数が「視点（ウインドウ）」を移動させながら、その「ウインドウ」内のデータに基づいて計算を行うからです。

具体的には、ある行を中心に、その前後の行を「window」として捉え、その範囲内のデータを使って計算を行うイメージ。例えば、4日間の平均売上を求めたいとき、1日目、2日目、3日目、4日目の売上をウインドウ（＝計算範囲）として捉え、その平均を計算する、というようなことがwindow関数で可能です。

このページではwindow関数の基本を１からわかりやすく初心者向けに解説します。

プログラマーやシステムエンジニアを目指す方であれば知らないと恥ずかしい基本知識です。是非最後までご覧ください。

参考　【初心者向け】SQLの基本構文ルール

window関数とは？

window関数は、SQLの強力な機能の1つで、各行に対して、ある「window」と呼ばれる範囲内の行を基に計算を行う関数です。これにより、各行の相対的な情報、たとえば「この行の前の行の値は何か？」や「このグループ内でのこの行のランクは？」などを求めることができます。

window関数は通常の集計関数と異なり、結果セットの行数を変えずに各行に対して情報を提供します。

window関数の構文ルール

window関数を使用する際の基本的な構文は以下のようになります。

<関数名>(<式>) OVER (
    PARTITION BY <分割列>
    ORDER BY <並び替え列>
    <フレーム範囲指定>
)

1. <関数名>(<式>):
   • 使用するwindow関数の名前と、その関数に渡す引数または式。
   • OVER はwindow関数を利用しますよ！という宣言・印だと理解すればOK。
2. PARTITION BY <分割列>:
   • PARTITION BYオプションを使って、データを特定の列の値に基づいてグループに分けることができる。→これにより、各グループ内でwindow関数が適用される。
   • GROUP BY と同じようなイメージでOK。
3. ORDER BY <並び替え列>:
   • ウインドウ内のデータの順序を定義します。この順序は、ランキング関数や前後の行との比較を行う関数など、関数の動作に影響を与えます。
4. <フレーム範囲指定>:
   • window関数がどの範囲のデータを考慮して計算を行うかを指定します。例えば「現在の行から2行前まで」や「現在の行から次の行まで」といった具体的な範囲を定義できます。指定しない場合は、PARTITION全体が考慮されるのがデフォルトです。

と、文字だけではイメージしづらいかと思いますので、具体例を用いながらご説明します。

サンプル　studentsテーブルの例

| id | name    | score |
|----|---------|-------|
| 1  | Alice   | 85    |
| 2  | Bob     | 90    |
| 3  | Charlie | 85    |
| 4  | David   | 92    |
| 5  | Eve     | 88    |
|----|---------|-------|

↑のテーブルを例に説明します。このテーブルは5人の生徒のテストのスコアが記録されています。

ここでは代表的なwindow関数の１つ、ROW_NUMBER()を使用してスコアの高い順にランキングをつけたいと考えてみます。その例が↓。

SELECT
  name,
  score,
  ROW_NUMBER() OVER (ORDER BY score DESC) AS rank
FROM
  students;

/* 結果
|---------|-------|------|
| name    | score | rank |
|---------|-------|------|
| David   | 92    | 1    |
| Bob     | 90    | 2    |
| Eve     | 88    | 3    |
| Alice   | 85    | 4    |
| Charlie | 85    | 5    |
|---------|-------|------|
*/

参考　SELECT文の基本

• ROW_NUMBER()関数は、指定されたORDER BYの順序に従って、各行にユニークな連番を割り当てる。
• OVER (ORDER BY score DESC)部分は、スコアを降順に並べ替えて、その順番に従って連番を付けることを指示。
• 結果、最もスコアが高いDavidが1位、次に高いBobが2位というようにランキングが付けられる。AliceとCharlieは同じスコアですが、ROW_NUMBER()はユニークな値を割り当てるため、異なるランクが付けられています。

この基本的な動作を理解することで、他のウインドウ関数もより理解しやすくなるでしょう。

【補足】PARTITION

PARTITION BY を使うことで、window関数を特定のカテゴリやグループごとに適用することができます。先ほどの、students テーブルに class 列を追加し、その上で ROW_NUMBER() を使用してクラスごとに順番をつけてみましょう。

↓のテーブルを利用して、クラスごとにスコアの高い順にランキングをつけてみます。

/* 利用するテーブル
|----|---------|-------|-------|
| id | name    | score | class |
|----|---------|-------|-------|
| 1  | Alice   | 85    | A     |
| 2  | Bob     | 90    | B     |
| 3  | Charlie | 85    | A     |
| 4  | David   | 92    | B     |
| 5  | Eve     | 88    | A     |
|----|---------|-------|-------|
*/

-- クエリ
SELECT
  name,
  score,
  class,
  ROW_NUMBER() OVER (PARTITION BY class ORDER BY score DESC) AS rank_in_class
FROM
  students
ORDER BY
  class, rank_in_class;

/* 結果
| name    | score | class | rank_in_class |
|---------|-------|-------|---------------|
| Eve     | 88    | A     | 1             |
| Alice   | 85    | A     | 2             |
| Charlie | 85    | A     | 3             |
| David   | 92    | B     | 1             |
| Bob     | 90    | B     | 2             |
|---------|-------|-------|---------------|
*/

解説

• PARTITION BY class によって、データはクラスごとに分けられる→結果、各クラス内で独立したランキングが生成される。
• ORDER BY score DESC により、各クラス内でのランキングはスコアの降順にソートされる。
  →クラスAではEveが1位、クラスBではDavidが1位に。

このように、PARTITION BY を使うことで、ウインドウ関数を特定のカテゴリやグループごとに適用することができます。

フレーム範囲指定

フレーム範囲指定は、window関数を適用する際の対象範囲をより細かく制御するためのものです。通常、window関数は特定の行に基づいて、その行を中心に前後の範囲で計算を行いますが、フレーム範囲指定を使うことでその計算範囲を具体的に定義することができます。

<関数名>(<式>) OVER (
    PARTITION BY <分割列>
    ORDER BY <並び替え列>
    ROWS <範囲指定>
)

ROWS の代わりに RANGE も利用できますが、その動作は異なります。ここでは、まず ROWS を用いたフレーム範囲指定について詳しく説明します。

以下は、フレーム範囲指定の一般的な使用方法の例です。

1. ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING:
   • 現在の行を中心に、1行前と1行後を含む範囲で関数を適用します。
2. ROWS UNBOUNDED PRECEDING:
   • 現在の行から、最初の行までの範囲で関数を適用します。
3. ROWS 2 FOLLOWING:
   • 現在の行から、2行後までの範囲で関数を適用します。

サンプル　3日移動平均の計算

/* 利用するsalesテーブル
|------------|--------------|
| date       | sales_amount |
|------------|--------------|
| 2023-01-01 | 100          |
| 2023-01-02 | 110          |
| 2023-01-03 | 90           |
| 2023-01-04 | 95           |
| 2023-01-05 | 105          |
|------------|--------------|
*/

-- 各日の売上の3日移動平均を計算するためのSQLクエリ
SELECT
  date,
  sales_amount,
  AVG(sales_amount) OVER (
    ORDER BY date
    ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
  ) AS moving_avg_3days
FROM
  sales;

/* 結果
|------------|--------------|------------------|
| date       | sales_amount | moving_avg_3days |
|------------|--------------|------------------|
| 2023-01-01 | 100          | 105              |
| 2023-01-02 | 110          | 100              |
| 2023-01-03 | 90           | 98.33            |
| 2023-01-04 | 95           | 96.67            |
| 2023-01-05 | 105          | 100              |
|------------|--------------|------------------|
*/

解説

• ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING によって、各日の売上の1日前、当日、1日後の3日間のデータを対象として平均を計算。

フレーム範囲指定を利用することで、累積計算や移動平均、前後のデータとの差分計算など、さまざまな集計処理を行うことができます。

よく使われるwindow関数の紹介

window関数は非常に多岐にわたるため、ここでは特によく使われるwindow関数をいくつか使い方を簡潔に紹介します。

1. ROW_NUMBER()

• 説明: 各行に一意の連続する番号を割り当てます。主にランキングや行番号付けに使用されます。
• 例: 各商品の売上順にランキングをつける場合

ROW_NUMBER() OVER (ORDER BY sales_amount DESC)

さらに詳しく→　ROW_NUMBER関数　

2. RANK()

• 説明: 各行にランキングを割り当てますが、同じ値を持つ行には同じランクを割り当て、次のランクはスキップされます。
• 例: 各学生のテストスコアのランキングを付ける場合

RANK() OVER (ORDER BY score DESC)

3. DENSE_RANK()

• 説明: RANK()と同様にランキングを割り当てますが、同じ値を持つ行には同じランクを割り当て、次のランクはスキップされません。
• 例: スポーツのポイントランキングで、同点者がいても次の順位をスキップせずに付ける場合

DENSE_RANK() OVER (ORDER BY points DESC)

4. NTILE(n)

• 説明: データを指定したnの数だけの等しいサイズのバケットに分割します。
• 例: 学生を4つのグループに分ける場合

NTILE(4) OVER (ORDER BY score)

5. LAG()

• 説明: 指定したカラムの前の行の値を取得します。
• 例: 各月の売上と前月の売上の差分を計算する場合

sales_amount - LAG(sales_amount) OVER (ORDER BY month)

6. LEAD()

• 説明: 指定したカラムの次の行の値を取得します。
• 例: 各月の売上と次月の売上の差分を計算する場合

sales_amount - LEAD(sales_amount) OVER (ORDER BY month)

7. FIRST_VALUE(), LAST_VALUE()

• 説明: ウィンドウの最初の値や最後の値を取得します。
• 例: 各月の売上とその四半期の最初の月の売上を比較する場合

sales_amount - FIRST_VALUE(sales_amount) OVER (ORDER BY month)

これらの関数は、ビジネスやデータ分析の現場で頻繁に使われます。適切な関数を選ぶことで、複雑な集計や解析を効率的に行うことができます。

まとめ：window関数とは？

/* 利用するテーブル
|------------|------------|--------------|
| date       | product_id | sales_amount |
|------------|------------|--------------|
| 2023-01-01 | A          | 100          |
| 2023-01-02 | A          | 110          |
| 2023-01-03 | A          | 90           |
| 2023-01-01 | B          | 95           |
| 2023-01-02 | B          | 105          |
| 2023-01-03 | B          | 105          |
|------------|------------|--------------|
*/

-- 各製品ごとに日付を基にした売上の3日移動平均を計算するSQLクエリ
SELECT
  date,
  product_id,
  sales_amount,
  AVG(sales_amount) OVER (
    PARTITION BY product_id
    ORDER BY date
    ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
  ) AS moving_avg_3days
FROM
  sales;

/* 結果
|------------|------------|--------------|------------------|
| date       | product_id | sales_amount | moving_avg_3days |
|------------|------------|--------------|------------------|
| 2023-01-01 | A          | 100          | 105              |
| 2023-01-02 | A          | 110          | 100              |
| 2023-01-03 | A          | 90           | 100              |
| 2023-01-01 | B          | 95           | 100              |
| 2023-01-02 | B          | 105          | 101.67           |
| 2023-01-03 | B          | 105          | 105              |
|------------|------------|--------------|------------------|
*/

-- PARTITION BY product_id により、各製品ごとにウィンドウ関数を適用。
-- ORDER BY date で、日付の昇順にデータを整列しています。
-- ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING で、各日の売上の1日前、当日、1日後の3日間のデータを対象として平均を計算。

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！

SELECT ROW_NUMBER() OVER() as rownum, *
FROM sample_data;

参考　SELECT文の基本

• ROW_NUMBER()は、結果セットの行に連番を付与する関数。
• ORDER BYを使って、特定の順序で番号を付けることが可能。
• PARTITION BYを使うと、指定した列の値ごとに番号付けをリセットすることができる。

参考　window関数とは？

このページではROW_NUMBER関数の基本を１からわかりやすく初心者向けに解説します。

プログラマーやシステムエンジニアを目指す方であれば知らないと恥ずかしい基本知識です。是非最後までご覧ください。

参考　【初心者向け】SQLの基本構文ルール

ROW_NUMBER関数とは？

ROW_NUMBER()はSQLのウィンドウ関数の１つで、データセットの各行に一意の連続する番号（行番号）を付与するときに使用します。主に、行に番号をつけたい場面や特定の条件でのランキングをつけたい場面などで使用されます。

実際のデータに変更を加えるわけではなく、クエリの結果として表示されるデータに一時的に番号を付けるためのものです。

ROW_NUMBER関数：構文ルール

ROW_NUMBER() OVER (
    [PARTITION BY 列名1, 列名2, ... ]
    [ORDER BY 列名A [ASC | DESC], ... ]
)

• PARTITION BY
  • オプション（任意）：特定の列を基にしてデータをグループ分けし、そのグループごとに行番号を1から付け直します。
• ORDER BY
  • オプション（任意）：行番号を付与する際の順序を指定するためのもので、指定した列の順に従って行番号が付与されます。

サンプルコード１　studentsテーブル

/* サンプルデータ
|----|---------|-------|
| id | name    | score |
|----|---------|-------|
| 1  | Alice   | 85    |
| 2  | Bob     | 90    |
| 3  | Charlie | 85    |
| 4  | David   | 92    |
| 5  | Eve     | 88    |
|----|---------|-------|
*/

SELECT 
    ROW_NUMBER() OVER(ORDER BY score, name) as rownum,
    id, 
    name, 
    score
FROM students;

/* 実行結果
scoreの昇順（低いスコアから高いスコアへ）に基づいて行番号が付与された結果が得られる
|--------|----|---------|-------|
| rownum | id | name    | score |
|--------|----|---------|-------|
| 1      | 1  | Alice   | 85    |
| 2      | 3  | Charlie | 85    |
| 3      | 5  | Eve     | 88    |
| 4      | 2  | Bob     | 90    |
| 5      | 4  | David   | 92    |
|--------|----|---------|-------|
*/

サンプルコード２　employeesテーブル

/* 
サンプルデータ: employees
|----|---------|------------|--------|
| id | name    | department | salary |
|----|---------|------------|--------|
| 1  | Alice   | HR         | 5000   |
| 2  | Bob     | Sales      | 5500   |
| 3  | Charlie | HR         | 5200   |
| 4  | David   | Sales      | 5300   |
| 5  | Eve     | Sales      | 6000   |
|----|---------|------------|--------|
*/

-- 部署（department）ごとに給与（salary）の昇順で行番号を付けるクエリ
SELECT 
    ROW_NUMBER() OVER(PARTITION BY department ORDER BY salary) as rownum,
    id, 
    name,
    department,
    salary
FROM employees;

/* 実行結果
|--------|----|---------|------------|--------|
| rownum | id | name    | department | salary |
|--------|----|---------|------------|--------|
| 1      | 1  | Alice   | HR         | 5000   |
| 2      | 3  | Charlie | HR         | 5200   |
| 1      | 4  | David   | Sales      | 5300   |
| 2      | 2  | Bob     | Sales      | 5500   |
| 3      | 5  | Eve     | Sales      | 6000   |
|--------|----|---------|------------|--------|
*/

このクエリの実行結果を見ると、PARTITION BYの効果により、部署ごとに行番号が1から始まっています。そして、その中でORDER BYにより給与の昇順に行番号が付けられていることがわかります。

このように、PARTITION BYとORDER BYを組み合わせることで、特定のカテゴリやグループ内での順序付けを行うことができます。

ROW_NUMBER関数を利用する際の注意点

最後にROW_NUMBER関数を利用する際の注意点について補足しておきます。

この関数はよく利用する関数でもあるので、特に以下の点を押さえておくことが重要です。

1. 一意性の確保

ROW_NUMBER()関数は、指定した順序で行に一意の番号を付与します。しかし、同じ値を持つ行（つまり順序が同じ行）が複数存在する場合、それらの行の順序はデータベースエンジンに依存するため、必ずしも一定ではありません。

/* サンプルデータ: students
|----|---------|-------|
| id | name    | score |
|----|---------|-------|
| 1  | Alice   | 85    |
| 2  | Bob     | 85    |
| 3  | Charlie | 90    |
|----|---------|-------|
*/

SELECT 
    ROW_NUMBER() OVER(ORDER BY score) as rownum,
    id, 
    name, 
    score
FROM students;

/* 実行結果 (順序は不確定)
|--------|----|---------|-------|
| rownum | id | name    | score |
|--------|----|---------|-------|
| 1      | ?  | ?       | 85    |
| 2      | ?  | ?       | 85    |
| 3      | 3  | Charlie | 90    |
|--------|----|---------|-------|
*/

このクエリでは、AliceとBobのscoreが同じであるため、それらに付与される行番号の順序は不確定です。

一意の順序を確保するためには、ORDER BY句に複数の列を追加することで、一意性を強制することができます。以下のように、scoreの後にidを追加してみます。

/* サンプルデータ: students
|----|---------|-------|
| id | name    | score |
|----|---------|-------|
| 1  | Alice   | 85    |
| 2  | Bob     | 85    |
| 3  | Charlie | 90    |
|----|---------|-------|
*/

SELECT 
    ROW_NUMBER() OVER(ORDER BY score, id) as rownum,
    id, 
    name, 
    score
FROM students;

/* 実行結果 (一意の順序が確保される)
|--------|----|---------|-------|
| rownum | id | name    | score |
|--------|----|---------|-------|
| 1      | 1  | Alice   | 85    |
| 2      | 2  | Bob     | 85    |
| 3      | 3  | Charlie | 90    |
|--------|----|---------|-------|
*/

このクエリでは、scoreが同じ場合、次にidの順番を考慮するため、一意の順序が確保されます。

2. 性能に関する注意点

大量のデータを扱う場合、ROW_NUMBER()関数の計算には時間がかかることがあります。特にPARTITION BYやORDER BYを使った複雑なソートや分割を行う際には、パフォーマンスの低下が考えられます。

適切なインデックスの作成やクエリの最適化を検討することが重要です。

3. ROW_NUMBER() vs RANK() vs DENSE_RANK()

ROW_NUMBER()以外にも、RANK()やDENSE_RANK()などの関数があります。これらの関数も行に番号を付与するのに使用されますが、同じ値を持つ行に対する取り扱いが異なります。

使用する関数を選択する際には、それぞれの動作を理解して、目的に合った関数を選択することが重要です。

4. バージョンやデータベースの種類による違い

ROW_NUMBER()関数は、多くのリレーショナルデータベースシステムでサポートされていますが、使用できるバージョンや具体的な動作、性能などにはデータベースの種類やバージョンによる違いがあります。

公式のドキュメントやリファレンスを確認することをおすすめします。

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！

データベースは常にレコードが追加され更新され、また削除され続けます。もし正規化を適切に行っていなければ、データベースの中でレコード間で矛盾が発生し、データベースとして役割を果たさなくなってしまいます。

簡単に言えば、正規化の目的はデータの重複や不要な依存関係を排除することです。これにより、データの整合性を維持しやすくなります。

このページでは、データベース初心者向けに（もしくは、何度か正規化について学習しているけれどいまいち理解しきれない・・・という方向けに）データベース正規化の目的や、正規化の手順、基本となる知識をわかりやすく網羅的に解説します。

前提となる知識もこのページで網羅的に解説していくので、専門用語がわからない・・・という方でもご安心ください。

データベースエンジニアを目指す方はもちろん、システムエンジニアやプログラマーを目指す方であれば知らないと恥ずかしい超・基本知識です。

是非最後までご覧ください。

正規化とは？

正規化（英：Normalization）の最大の目的は、データベース上で扱うデータの重複を削除し、データの更新時に発生する異常を取り除くことです。

データベースには常に更新が発生します。正規化を適切に行っていない場合、レコードの更新時に異常が発生し、正しくレコードが登録されなくなってしまいます。

最初に "正規化されていないデータベース" にはどんなリスクが潜んでいるのか？を簡単にご説明します。

正規化をわかりやすく

「正規化できていない」以下２つのテーブルを考えます。

左側のテーブルは注文を受けたらその内容をどんどん追加していくようなテーブルで、右側のテーブルは注文した人とその内容を整理して出来上がったようなテーブルです。

一見、２つのテーブルはちゃんと利用できるように思えます。ですが、実はこのテーブルは利用しているとレコード間の不整合が発生します。

例として、このとき注文がキャンセルされてしまい、注文番号テーブルから対象のレコードを削除するとどうなるか？を考えてみたいと思います。

もし、キャンセルを受けた担当が、上記４つのレコード「だけ」削除してしまうと、テーブル間での矛盾が発生します。

本来であれば、４つのレコードを削除すると同時に、注文者テーブルの方のレコードも同じように削除しておく必要があります。

「注文番号テーブル」には存在しないのに、「注文者テーブル」にはそれに対応するレコードが存在するという謎な現象が起きてしまうのです。

このように正規化されていないテーブルを扱おうとすると、テーブル間の不整合が起きたり、レコードが破損してしまうなど、どこかで異常が発生することは避けられないということが分かります。

ここでは非常に簡単な例で説明しましたが、これだけではなく様々なパターンの更新時異常が存在します。

必ずどちらも更新するようにすれば良いのでは？という疑問

正規化しなくても、毎回必ず両方のテーブルを更新するようにすればOKなのでは？という疑問が出てきますよね。

結論から言えば、ある意味では「その通り」です。

例えば、更新時に異常が発生しないように更新が必要なすべてのテーブルをプログラムで更新するようにしたり、マニュアルを用意して片方のテーブルを更新したらもう一方のテーブルも更新するようにしたり・・・などの案が考えられます。

が、いずれにせよプログラムをきちんと作りこむ必要性やマニュアルの作成など、別のコストが発生してしまうことには変わりありません。また、通常そのような無理な回避策は長年動くシステムや業務では必ず破綻していきます。

したがって、あらかじめデータベースの正規化を適切に行っておく方がGood！な判断である場合がほとんどです。

正規化の手順

では、正規化はどのように行うのか？ここからは具体的に正規化とは何か？その手順はどのように進めるのか？をご説明していきます。

データベースの正規化は以下の通り順を追って進められます。

上記図の通り、正規化の過程ではデータベースはいくつかの「正規形」（例：第１正規形 / 第２正規形～）を経て構築されます。以下は正規化の主要な手順を簡単に説明したものです。

1. 第1正規形 (1NF)
   • 各カラムに１つの値のみを持たせる。
   • 同じカラム内での重複を避ける。
2. 第2正規形 (2NF)
   • 合成キー（2つ以上のカラムの組み合わせ）を持つテーブルで、キーの一部のみに依存するカラムを分離する。
3. 第3正規形 (3NF)
   • ある非キーカラムが他の非キーカラムに依存している場合、その依存関係を排除する。
4. 高次の正規形
   • 3NFを超える正規形（BCNF、4NF、5NFなど）も存在しますが、実際のデータベース設計でこれらを厳密に適用することは珍しい→しかし、特定の問題を解決するためにこれらの正規形を考慮することは有益。

正規化は一気に終わるのではなく、順を追って徐々により高次な正規形に進化していくようなイメージを持てればまずはOKです。

また、上記では現在存在する正規化の手順をすべて記載しましたが、実際のところは「第１正規形～第３正規形」までが基本で、それより高次の正規化は大抵の場合は不要。

理由はページ後半でまた解説しますが、まずは第１正規形～第３正規形を確実に理解することを目標としてください。

それでは実際の正規化の手順を順を追ってご説明していきます。

第１正規形

第１正規形の定義は、わかりやすく説明するとExcelのような１セル１レコードのテーブルとして表現できるようにすることです。

第１正規形はご覧の通り超・単純です。

正式にはすべてのドメインがシンプルであること（＝１セル１レコード）というのが第１正規形の定義です。

具体的には①：繰り返し項目を取り除くこと、②：２つ以上のレコードが保存されているドメインを取り除くこと、の２つが一番初めにおこなう正規化です。

以下のテーブルを例にすると青字部分は繰り返し項目・緑字部分が１つのドメインに２つのレコードが存在（商品IDと商品名）しているので、第１の正規化対象です。

これらの項目を整理して出来上がるテーブルが第１正規形です。

正規化のまとめ①

• 第１正規形
  １セル１レコードとなるようにシンプルなテーブルに整理された状態

第２正規形

続いて第２正規形の説明です。ここからグッと専門用語が多くなり、難易度も上がります。

多くの人はこの第２正規形の説明でドロップダウンしてしまうので、ゆっくり確実に学習を進めていきましょう。

第２正規形は「テーブルの各候補キーに従属する部分関数従属性が整理された」状態です。

「候補キー」「部分関数従属」の２点について用語の意味をご説明します。

候補キー（Candidate Key）をわかりやすく

候補キーとは「レコードを一意に特定するための属性（＝カラム）」または「レコードを一意に特定するための属性の組み合わせ」です。

例えば、以下のテーブルであれば候補キーは「出席番号」です。

出席番号さえ分かれば、どのレコードを指し示しているかが分かりますよね。

したがって、上記のテーブルでは出席番号項目が候補キーであるといえます。

逆に「氏名」列や「生年月日」列は同じ値が存在する可能性もあるため、候補キーとは言えません。

では、先ほど第１正規形を行ったテーブルの候補キーはどれになるでしょうか？

この場合は、どの列も単独ではレコードを一意に特定することができません。「注文番号」も「注文者」などが候補キーに該当しそうな気もしますが、どちらの列にも同じ値が存在します。

この場合、１つの項目が単独でレコードを特定することができないため、候補キーは各項目の組み合わせを判断し特定する必要があります。

再掲

候補キーとは「レコードを一意に特定するための属性（＝カラム）」または「レコードを一意に特定するための属性の組み合わせ」です。

上記テーブルの場合は "注文番号" と "商品ID" が分かれば（"注文番号" と "商品ID" の組み合わせを見れば）、どのレコードを指し示しているかを特定することができます。

したがって、候補キーは "注文番号" と "商品ID" になります。

また、重要なポイントの１つが「候補キーは複数存在する可能性がある」ということです。例えば、上記のテーブルでは「注文番号」と「商品名」の組み合わせも、候補キーになります。

何故なら、注文番号と商品名が分かれば、先ほどと同様にどのレコードを指し示しているかが分かるためです。

したがって、上記テーブルの候補キーは（注文番号,商品ID）と（注文番号,商品名）ということになります。

部分関数従属をわかりやすく

部分関数従属とは「一部の候補キーに対して」関数従属する属性を言います。

関数従属

• Xの値が決まるYの値が決まる関係のこと（X→Y）
  例) Y=3+X の場合 Xの値が7に決まれば Yの値は10に決定する

例えば、以下のテーブルでは注文番号が決まれば「注文日」「注文者ID」「注文者」のカラムは一意に決定することが分かります。

注文番号が「1001」であれば必ず注文日は「2020/10/1」で注文者IDは「A001」、注文者は「田中商事」に確定します。

このとき、注文日・注文者ID・注文者のカラムは候補キーの１つである「注文番号」に関数従属しているため「部分関数従属」している、ということができます。

また、同じ原理で「商品名」も商品IDに対して部分関数従属しているということができます。

第２正規形は「テーブルの各候補キーに従属する部分関数従属性が整理された」状態です。

したがって、部分関数従属している列を切り離し別のテーブルとして整理するのが第２正規化の手順です。

正規化のまとめ②

• 第１正規形
  １セル１レコードとなるようにシンプルなテーブルに整理された状態
• 第２正規形
  テーブルの各候補キーに従属する部分関数従属性が整理された状態

初心者にとってはこの第２正規形が第１正規形～第３正規形の中で１番理解しづらい部分です。

一度読んで理解しきれなかった方はもう一度この章を学習しなおしておきましょう。

第２正規形が分かれば、第３正規形は実はそこまで難しくはありません。

第３正規形

第３正規形は候補キー以外の列に関数従属している列が整理された状態です。

第２正規化で整理された注文詳細テーブルを例に第３正規化の手順を見ていきましょう。

第３正規形は「候補キー以外の列に関数従属している列が存在しない」状態です。したがって、上記の例でいうと、候補キーではない注文者IDに関数従属している「注文者」列を別表に移すのが第３正規化で行う手順です。

"注文者" 列を注文詳細テーブルから切り離し顧客マスタとして独立させました。

これによって、候補キー以外の列に関数従属している列が存在しない状態を作り出すことができます。

当初１つのテーブルに存在していたデータが正規化を行うことで、以下の４つのテーブルに整理されました。

この４つのテーブルが以下の第１正規形～第３正規形までの定義を満たしていることを確認してみてください。

システムエンジニアを目指したい方は

システムエンジニアを目指す方や、IT知識を１から身につけたい方は以下のページをご覧ください。

正直どこから学び始めればよいかわからない。どのように勉強していけば、エンジニアとしてのスキルが磨けるか？が分からない・・・という方は必見です。

システムエンジニア向けに「できるエンジニア」になる方法を１から解説しておりますので、是非ご覧ください。

1人前のシステムエンジニア(SE)になるために勉強した５つのこと

本ページでは、１人前のシステムエンジニアになるために学んだこと・読んだ本・勉強したプログラミング言語を現役のエンジニアが１から紹介しています。「正直何を勉強したらよいかわからない」という疑問をお持ちの方は特に必見です。

it-biz.online

2021.07.29

参考　SQLとは？

SELECT COUNT(対象カラム)
FROM テーブル名
WHERE 条件（任意）;

COUNT関数は指定したテーブル/カラムに存在するレコード数を返してくれます。

DISTINCTキーワードやGROUP BYキーワードと同時に利用したりすると、できることがたくさん増えるので理解必須の基本知識です。

このページではCOUNT関数の構文ルール / 利用する際の注意点を初心者でも理解できるように１分で解説します。

プログラマー/システムエンジニアを目指す方であれば知らないと恥ずかしい超・重要知識です。是非最後までご覧ください。

参考　【初心者向け】SQLの基本構文ルール

SQL：COUNT関数の基本

COUNT関数の基本構文ルールは以下の通り。

SELECT COUNT(対象カラム)
FROM テーブル名
WHERE 条件（任意）;

レコード数をカウントしたいカラム名を "COUNT" で囲んであげるだけの簡単な構文です。もしくは、カラムを指定せずに *（アスタリスク）でテーブルのレコード数をシンプルに取得することも可能。

以下のテーブルに含まれるレコード数をカウントしてみます。

SELECT COUNT(*)
FROM MemberList;

-- 結果「8」

結果は「８」となります。レコード数が８個あるので、その結果が返ってきてくるということ。

カラムを指定してCOUNT関数を利用する

先ほどは COUNT(*) のようにカラムを指定せずに単純にレコード数をカウントしました。

SELECT COUNT(*)
FROM MemberList;
--カラムを指定せずにレコード数をカウント

ですが、例えば Department カラムではNULL値が２行含まれており、このNULLを除外したレコード件数をカウントしたいような場合も存在します。

この場合は、Departmentカラムを以下のように指定してカウントすることで実現することができます。

SELECT COUNT(Department)
FROM MemberList;
--カラム "Department" を指定してカウント

この場合、NULL値がカウントされないので、結果は「６」となります。

COUNT関数の注意点

COUNT関数の大きな注意点がこのNULLのカウント方法にあります。

例えば、以下のテーブルをカラムを指定せずにカウントしてみます。

SELECT COUNT(*) FROM MemberList;
--カラムを指定せずにレコード数をカウント

普通に考えるとどのカラムもNULLなので、結果は０となりそうですが、実はこのSQLを実行すると「８」が返って来ます。

これは、COUNT関数が以下のような性質を持っていることが理由です。

つまり、以下のSQLを実行した場合は「８」と「０」が取得されるということ。

SELECT COUNT(*), COUNT(Department)
  FROM MemberList;

--COUNT(*)⇒8  /  COUNT(Department)⇒0

以上がCOUNT関数の大きな注意点です。SQL初心者にとって陥りがちな罠の１つですので、しっかりと押さえておきましょう。

Tips：DISTINCTキーワードとの合わせ技

COUNT関数はDISTINCTと組み合わせて利用することも可能です。

SELECT COUNT(DISTINCT Department)
FROM MemberList;

-- 結果「3」
-- Department列の重複を削除してカウント

Department列には「総務部」「財務部」「営業部」の３つの重複しないレコードが存在するため、結果は３となります。

先ほど解説した通り、COUNT(カラム名) とした場合はNULLを除外するので４では返って来ません。

SELECT COUNT(*)
FROM (SELECT DepartMent FROM MemberList );

-- テーブルの作成
CREATE TABLE students (
    id INT PRIMARY KEY,
    first_name VARCHAR(255),
    last_name VARCHAR(255),
    age INT
);

-- データの挿入
INSERT INTO students (id, first_name, last_name, age)
VALUES (1, 'John', 'Doe', 20);

INSERT INTO students (id, first_name, last_name, age)
VALUES (2, 'Jane', 'Smith', NULL);

INSERT INTO students (id, first_name, last_name, age)
VALUES (3, 'Bob', 'Johnson', 22);

INSERT INTO students (id, first_name, last_name, age)
VALUES (4, 'Alice', 'Martin', 24);

-- SELECT COUNT
SELECT COUNT(*) FROM students;

/* 結果
4
*/

--age 列を指定してカウント
SELECT COUNT(age) FROM students;

/* 結果
3

COUNT(age)はageカラムのNULL値を除外してレコード数をカウントします。
このサンプルコードでは1つのレコードにNULL値が含まれているため、
カウントは4から1つ減って3になります。
*/

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！

参考　SQLとは？

DISTINCTはSELECTした結果から "重複するレコードを除外する" オプションです。

このページではDISTINCTの構文ルールや利用方法の注意点を解説します。難しい内容ではないので１分ほどでマスターできます。

プログラマー/システムエンジニアを目指す方であれば知らないと恥ずかしい超・基本知識です。是非最後までご覧ください。

参考　SELECT文の基本

SELECT：DISTINCTの構文ルール

-- 基本形
SELECT DISTINCT カラム名
FROM テーブル名;

-- 複数のカラムに適用
SELECT DISTINCT カラム名1, カラム名2
FROM テーブル名;

1. 位置: DISTINCTキーワードは、SELECT文の直後に配置。
2. 対象: DISTINCTは１つ以上のカラムに適用され、そのカラムの組み合わせに対してユニークなレコードを返します。
3. 組み合わせ: 複数のカラムにDISTINCTを適用する場合、カラムの間にカンマ(,)を使用して区切る。

DISTINCTはSELECT句で指定するカラム名の前に記述します。

以下のテーブルから、"Department" 列を重複を除外したい場合のサンプルコードがこちら。

SELECT DISTINCT Department 
  FROM MemberList;

"Department" 列の重複が削除され、以下の結果が得られます。

もし、DISTINCTを用いずに単純にSELECTした場合は以下の結果が得られます。

SELECT Department 
  FROM MemberList;

NULLも１種類としてカウント

DISTINCTを用いた場合はNULL値も１種類のデータとしてカウントされます。

例えば、どこにも所属していない社員がいるような場合。

この場合、DISTINCTを用いるとNULLも消えずに選択されます。

SELECT DISTINCT Department 
  FROM MemberList;

NULLを出力したくない場合は、WHERE句でNULLを除外するように指定しましょう。

DISTINCTで複数のカラムを指定する場合

DISTINCTは以下のように複数のカラムを指定することも可能です。

SELECT DISTINCT Name, Department 
  FROM MemberList;

複数のカラムを指定する場合は、指定したカラムの組み合わせがすべて一意に決まるように重複が除かれます。

以上のように、Name列が "山田" かつDepartment列が "営業部" のように、組み合わせの結果が重複しているものが削除されるという点を押さえておきましょう。

初心者にとっては少しだけ難しいかもしれませんが、これだけ覚えればDISTINCTは完璧です。

DISTINCT は先頭のカラムの前にしか置けない

DISTINCTは先頭のカラムの前にしか記述することができません。

例えば、これはNG例。

SELECT Number, DISTINCT Department 
  FROM MemberList;

Department列の重複だけを削除したいと考えるとこのような使い方をしがちですが、これはSQLの構文ルール違反です。よくあるミスの１つです。

DISTINCTキーワードの注意点

DISTINCTキーワードを使用する際の注意点について、サンプルコードを用いながらご説明します。

注意点１　パフォーマンス

• DISTINCTは重複するレコードを除外するため、内部的にはソートやグルーピングが行われることがあります。そのため、大量のデータが存在するテーブルに対して使用するとパフォーマンスが低下する可能性があります。
• インデックスの有無や設計もパフォーマンスに影響します。

注意点２　結果の順序

• DISTINCTの後に続くカラムの順序は結果の表示順に影響しますが、ユニーク性の評価には影響しません。

-- 例1
SELECT DISTINCT column1, column2
FROM some_table;

-- 例2
SELECT DISTINCT column2, column1
FROM some_table;

-- 上記２つのSQLはユニークなレコードのセットは同じになりますが、結果の表示順は異なる可能性があります。

SELECT DISTINCTのまとめ

• DISTINCTはSELECTした結果から "重複するレコードを除外する" オプション

-- 基本形
SELECT DISTINCT カラム名
FROM テーブル名;

-- 複数のカラムに適用
SELECT DISTINCT カラム名1, カラム名2
FROM テーブル名;

サンプルコード

-- テーブルの作成
CREATE TABLE employees (
    id INT PRIMARY KEY,
    first_name VARCHAR(255),
    last_name VARCHAR(255),
    job_title VARCHAR(255)
);

-- レコードの挿入
INSERT INTO employees (id, first_name, last_name, job_title)
VALUES (1, 'John', 'Doe', 'Software Engineer');

INSERT INTO employees (id, first_name, last_name, job_title)
VALUES (2, 'Jane', 'Smith', 'Software Engineer');

INSERT INTO employees (id, first_name, last_name, job_title)
VALUES (3, 'Bob', 'Johnson', 'Project Manager');

INSERT INTO employees (id, first_name, last_name, job_title)
VALUES (4, 'Alice', 'Martin', 'Data Analyst');

INSERT INTO employees (id, first_name, last_name, job_title)
VALUES (5, 'Charlie', 'Brown', 'Data Analyst');

-- SELECT DISTINCT
SELECT DISTINCT job_title
FROM employees;

/* 結果
job_title
------------------
Software Engineer
Project Manager
Data Analyst

重複するjob_titleが取り除かれ一意のjob_titleのみが表示される
*/

参考　CREATE TABLE / INSERT

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！

SELECT 列名1, 列名2, ... 
FROM テーブル名
WHERE 条件式;

参考　SQLとは？

SELECT文は何も見なくてもすらすらと書けるのが、プログラマー/システムエンジニアとしての基本です！是非最後までご覧ください。

SELECT文の基本を知らないと、どの言語を扱うプログラマーであっても現場でも大変苦労します。このページの内容は確実に理解するようにしましょう！

"SELECT" は大文字で書けば良い？小文字で書けば良い・・・？

SQLの基本的な記述ルールが実は曖昧・・・。という方は以下の記事も併せてご覧ください。

【SQL】基本的な記述ルール5つを１分で解説

【SQL入門】SQL文を記述する際の基本ルール４つを解説します。OK例/NG例のそれぞれをサンプルコード付きでわかりやすく説明しています。たった今SQL文でエラーが発生して「ハマってる」人は必見です。

it-biz.online

2023.10.04

SELECT文の基本

テーブルからデータを取得する際の基本的なSELECT文は以下の通りです。

SELECT 列名1, 列名2, ... 
FROM テーブル名
WHERE 条件式;

• SELECT: 取得したいカラム（列）を指定します。
• FROM: どのテーブルからデータを取得するかを指定します。
• WHERE（任意）: 取得するデータの条件を指定します。この句はオプションで、指定しなければテーブルの全てのデータが取得されます。

句（clause）

句 とはSQLを構成する要素のこと。SELECT / FROM などのSQLキーワードから始まるフレーズを指します。

SELECT句やFROM句などというように「SQLキーワード＋句」とセットで呼称するのが一般的です。

以下は、employeesというテーブルからfirst_nameとlast_nameを取得する例です。

取得したいカラムが複数ある場合は「,」で区切ります。

/* 対象テーブルのレコード
+----+------------+-----------+-------------+
| id | first_name | last_name | department  |
+----+------------+-----------+-------------+
|  1 | John       | Doe       | Engineering |
|  2 | Jane       | Smith     | HR          |
|  3 | Alice      | Johnson   | Sales       |
|  4 | Bob        | White     | Engineering |
+----+------------+-----------+-------------+
*/

-- 全ての従業員の名前を取得
SELECT first_name, last_name 
FROM employees;

/* 結果
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| John       | Doe       |
| Jane       | Smith     |
| Alice      | Johnson   |
| Bob        | White     |
+------------+-----------+
*/

-- first_nameが"John"である従業員の名前と部署を取得
SELECT first_name, last_name, department
FROM employees 
WHERE first_name = 'John';

/* 
+------------+-----------+-------------+
| first_name | last_name | department  |
+------------+-----------+-------------+
| John       | Doe       | Engineering |
+------------+-----------+-------------+
*/

↑の形がSELECT文の基本中の基本です。

WHERE：抽出条件の指定

WHERE句についてはいくつかの注意点があるので、１から基本から再度振り返っておきます。

• WHERE（任意）: 取得するデータの条件を指定。指定しなければテーブルの全てのデータが取得される。

例えば、↓のテーブルから「Suzuki」さんに関するデータを取得したいような場合。

このようなシーンで利用されるのがWHERE句です。

レコードを抽出する条件を指定する場合、以下のようにWHERE句を用います。

MemberList テーブルから "Name" 列が「Suzuki」となっているものを取得する場合のサンプルコードがこちらです。

SELECT Number, Name, Address, PhoneNumber
  FROM MemberList
 WHERE Name = "Suzuki";

SELECT *：すべてのカラムを抽出する

テーブルのカラムが多くなっていくと、１つ１つのカラムをSELECT句で指定するのは大変です。

そこで、テーブルにあるすべてのカラムを抽出したい場合は「*　アスタリスク」を用います。

SELECT *　の基本

• *はワイルドカードとして機能し、テーブル内のすべてのカラムを意味する。
• このコマンドは、テーブルの内容を迅速に確認したい時や、テーブルの構造（どのようなカラムがあるか）を知りたい場合に便利です。

SELECT *
  FROM （テーブル名）;

例えばテーブル「employees」からすべてのカラムを抽出したい場合は以下のように記述します。

SELECT * FROM employees;

結果はすべてのカラムがそのまま抽出されます。

「*」を使用すると、結果の並び順は「CREATE TABLE」で定義した通りに出力されます。

結果の並び順を変更したい場合には、SELECT句でカラム名を順番を変えて記述する必要があります。

「*」を利用すればSQL文の記述も早くなりカラム名指定などのミスも格段に減ります。

ただし、すべてのカラムを抽出する分、SQL実行のパフォーマンスも落ちてしまうというデメリットも存在します。

ちょっとしたときにSELECT文を書くようなときは「*」指定はOKですが、例えば高効率なパフォーマンスが求められる場合や、抽出したいカラムが決まっている場合は１個１個カラムを指定するように心がけることをおすすめします。

AS：カラム名に別名を付与して抽出

SQL文では、抽出するカラム名に別名を付与してレコードを抽出することが可能です。

SELECT Number      AS "番号", 
       Name        AS "氏名", 
       Address     AS "住所", 
       PhoneNumber AS "電話番号"
  FROM MemberList;

通常、テーブルのカラム名はアルファベットか数字で表されている場合が多いのですが、これだと少し分かりづらい場面があります。このようなタイミングでASキーワードを利用して日本語の別名を付与してあげたりする使い方もできます。

日本語で別名を付与する場合は必ず「"　ダブルクォーテーション」で囲んであげる必要があります。

もし、別名もアルファベットで付与する場合にはダブルクォーテーションは不要です。

SELECT Number      AS A, 
       Name        AS B, 
       Address     AS C, 
       PhoneNumber AS D
  FROM MemberList;

WHERE句では別名（AS）は使用不可

WHERE句の注意点の１つが、別名使用不可という点です。

例えば以下のような利用方法はできません。

SELECT Number      AS A, 
       Name        AS B, 
       Address     AS C, 
       PhoneNumber AS D
  FROM MemberList
 WHERE B = "Suzuki";

せっかくASキーワードで別名を付けたのだからWHERE句でも使いたい・・・！という気持ちもしますが、SQLではNGです。データベース初心者にとっては陥りがちなミスの１つでもあるので、しっかり頭に入れておきましょう。

SQL：SELECT文のまとめ

-- SELECT文の基本
SELECT * FROM employees;

-- 複雑なSELECT文
SELECT first_name, last_name, salary
FROM employees
WHERE salary > 50000
ORDER BY salary DESC;

-- より複雑なSELECT文
SELECT e1.first_name, e1.last_name, e1.salary, d.department_name
FROM employees e1
INNER JOIN (
    SELECT department_id, AVG(salary) AS avg_salary
    FROM employees
    GROUP BY department_id
) AS e2 ON e1.department_id = e2.department_id
INNER JOIN departments d ON e1.department_id = d.department_id
WHERE e1.salary > e2.avg_salary
ORDER BY d.department_name, e1.salary DESC;

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！

参考　SQLとは？

SQL自体は決して難しくはない言語です。ですが、初心者にとってはなかなかエラーなくSQL文を書くことも簡単ではないのではないでしょうか。

このページでは、頭に入れておきたいSQLの基本的な構文ルールを簡単に解説しておきたいと思います。

プログラマーやシステムエンジニアを目指す方であれば知らないと恥ずかしい超・基本知識です。是非最後までご覧ください。

そもそもSQLって何？という方はこちら

以下のページではSQLとは何か？データベースとは？をIT初心者向けにわかりやすく解説しています。気になった方は併せてチェックしておきましょう。

SQLとは？初心者向けにわかりやすく３分で解説【簡単】

【IT初心者向け】SQL (Structured Query Language) って何？というプログラマー/エンジニア志望の方向けにSQLの基本を１からわかりやすく解説。DDL,DCL,DMLって何？という方でも理解できるよう、豊富なサンプルコード付きでご説明します。

it-biz.online

2023.10.04

ルール１：SQLの文末は「;」セミコロン

SQL文は「;」セミコロンで終えるのが必須のルールです。

SELECT Name FROM MemberList;

参考　SELECT文

よくある初歩的なミスとして「;」セミコロンを忘れるのがSQL初心者の罠。一つひとつのSQL文は必ず「;」で終わりを示すのがルールです。

ルール２：キーワードの大文字・小文字は区別されない

SQLのキーワード（SELECTなど）は大文字・小文字の区別はされません。

したがって、以下どちらの記述で書いても結果は同じです。

SELECT Name FROM MemberList;

select Name from MemberList;

ルール３：単語は半角スペースか改行で区切る

SQLのキーワードやテーブル名、カラム名などの単語は必ず「半角スペース」か「改行」で区切ります。

SELECT Name FROM MemberList;

SELECT
Name
FROM
MemberList;

半角スペースか改行で区切らないとエラーとなります。例えば以下はNGです。

SELECTName FROM MemberList;
-- SELECT と Name の間にスペースが存在しないため構文エラー

また、これもよくある落とし穴ですが「全角スペースで区切るのもNG」です。

SELECT　Name FROM MemberList;
--SELECT と Name の間が全角スペースなのでNG

たまに、このミスを犯してドツボにはまる人もいるので、基本の「き」としてしっかり頭に入れておきましょう！

ルール４：定数は「'」で囲む

SQL文では、抽出条件を指定する場面などで「定数」を記述することができます。「定数」を記述する場合は、それが定数であることを明示するために「'」シングルコーテーションで囲みます。

CREATE TABLE MemberList (
Number INT,
Name VARCHAR(50),
Address VARCHAR(150),
----------------------------
PhoneNumber VARCHAR(13) DEFAULT '090-1234-5678'
----------------------------
);

--'090-1234-5678' は定数

参考　CREATE TABLE文

ただし、数字の定数の場合は「'」シングルコーテーションで囲む必要はありません。以下ではNumberカラムのデフォルト値として 100 を指定するSQL文の例です。

CREATE TABLE MemberList (
----------------------------
Number INT DEFAULT 100,
----------------------------
Name VARCHAR(50),
Address VARCHAR(150),
PhoneNumber VARCHAR(13) DEFAULT '090-1234-5678'
);

ルール５：１行コメントは「--」：複数行コメントは「/* */」

SQLでは文中にコメントを記述することができます。

複雑なSQL文の説明を記載しておいたりするような使い方が一般的です。

-- これは1行のコメントです
SELECT * FROM tablename;

/*
これは複数行の
コメントです
*/
SELECT * FROM tablename;

コメントはSQL実行時に一切考慮されない行なので、基本的には何を書いてもOKです。日本語で書いてもアルファベットで書いてもSQL自体の処理内容には一切影響がありません。

SELECT Name FROM MemberList;
-- MemberListからName列のレコードを取得

SELECT Name
/* このようにSQL文中に無理やりコメントを挟むこともできます。
   ですが、返って可読性を落としてしまうのでオススメできる利用方法ではありません。*/
FROM MemberList;

現在のスキルに今一つ満足できていないシステムエンジニア/プログラマーの方へ。

SQLやデータベースの仕組みを１から学習したい方（学び直したい方）向けに、現役エンジニア達のスキルを結集して 完全無料 のSQL教材を作成しました。是非この機会にブックマークを！

読者料典　【完全無料】SQL：初心者向け学習ロードマップ　←こちらから！