序章

多くのデータベース設計では、特定のデータポイント間の関係に基づいて、情報をさまざまなテーブルに分けています。 このような場合でも、一度に複数のテーブルから情報を取得したい場合があります。

単一のStructuredQuery Language （SQL）操作で複数のテーブルのデータにアクセスする一般的な方法は、テーブルを JOIN 句。 関係代数の結合演算に基づいて、 JOIN 句は、相互に関連する各テーブルの行を照合することにより、個別のテーブルを結合します。 通常、この関係は、あるテーブルの外部キーや別のテーブルの主キーなど、共通の値を共有する1対の列（各テーブルから1つ）に基づいています。キーリファレンス。

このガイドでは、以下を含むさまざまなSQLクエリを作成する方法の概要を説明します。 JOIN 句。 また、さまざまなタイプを強調しています JOIN 句、複数のテーブルのデータを組み合わせる方法、列名をエイリアスして書き込みを行う方法 JOIN 面倒な操作は少なくなります。

前提条件

このガイドに従うには、SQLを使用するある種のリレーショナルデータベース管理システム（RDBMS）を実行しているコンピューターが必要です。 このガイドの手順と例は、次の環境を使用して検証されています。

  • Ubuntu 20.04 の初期サーバーセットアップガイドで説明されているように、管理者権限を持つ非rootユーザーとUFWで構成されたファイアウォールを備えたUbuntu20.04を実行しているサーバー。
  • Ubuntu 20.04にMySQLをインストールする方法で概説されているように、MySQLがサーバーにインストールされて保護されています。 このガイドは、ステップ3 で説明されているように、新しく作成されたユーザーによって検証されました。

注：多くのRDBMSは、独自のSQL実装を使用していることに注意してください。 このチュートリアルで概説されているコマンドはほとんどのRDBMSで機能しますが、MySQL以外のシステムでテストした場合、正確な構文または出力が異なる場合があります。

  • また、使用の練習に使用できるサンプルデータがロードされたいくつかのテーブルを含むデータベースも必要です。 JOIN オペレーション。 MySQLサーバーに接続し、このガイド全体の例で使用されるテストデータベースを作成する方法の詳細については、次のMySQLへの接続とサンプルデータベースのセットアップセクションを実行することをお勧めします。

MySQLへの接続とサンプルデータベースの設定

SQLデータベースシステムがリモートサーバーで実行されている場合は、ローカルマシンからサーバーにSSHで接続します。

  1. ssh sammy@your_server_ip

次に、MySQLサーバープロンプトを開き、置き換えます sammy with the name of your MySQL user account:

  1. mysql -u sammy -p

名前の付いたデータベースを作成します joinsDB:

  1. CREATE DATABASE joinsDB;

データベースが正常に作成されると、次のような出力が表示されます。

Output
Query OK, 1 row affected (0.01 sec)

を選択するには joinsDB データベース、以下を実行します USE 声明：

  1. USE joinsDB;



Output
Database changed

選択した後 joinsDB、その中にいくつかのテーブルを作成します。 このガイドで使用されている例では、工場を運営していて、SQLデータベースで製品ライン、営業チームの従業員、および会社の売上に関する情報の追跡を開始することを決定したとします。 最初に3つのテーブルから始めることを計画しており、最初のテーブルには製品に関する情報が格納されます。 この最初のテーブルには3つの列が必要であると判断します。

  • productID：各製品の識別番号。 int データ・タイプ。 この列は、テーブルの主キーとして機能します。つまり、各値は、それぞれの行の一意の識別子として機能します。 主キーのすべての値は一意である必要があるため、この列にも UNIQUE それに適用される制約
  • productName：各製品の名前。 varchar 最大20文字のデータ型
  • price：各製品の価格。 decimal データ・タイプ。 このステートメントは、この列の値が最大4桁の長さに制限され、そのうちの2桁が小数点の右側にあることを指定します。 したがって、この列で許可される値の範囲は、 -99.99 に 99.99

名前の付いたテーブルを作成します products 次の3つの列があります。

  1. CREATE TABLE products (

  2. productID int UNIQUE,

  3. productName varchar(20),

  4. price decimal (4,2),

  5. PRIMARY KEY (productID)

  6. );

2番目のテーブルには、会社の営業チームの従業員に関する情報が格納されます。 このテーブルにも3つの列が必要であると判断しました。

  • empID：に似ています productID 列の場合、この列には、営業チームの各従業員の一意の識別番号が保持されます。 int データ・タイプ。 同様に、この列には UNIQUE 制約が適用され、の主キーとして機能します team テーブル
  • empName：各営業担当者の名前。 varchar 最大20文字のデータ型
  • productSpecialty：営業チームの各メンバーには、専門分野として製品が割り当てられています。 彼らはあなたの会社が作るどんな製品でも売ることができます、しかし彼らの全体的な焦点は彼らが専門とするどんな製品にもなります。 表でこれを示すために、この列を作成します。 productID 各従業員が専門とする製品の価値

確実にするために productSpecialty 列は有効な製品ID番号を表す値のみを保持するため、外部キー制約を参照する列に適用することにしました。 products テーブルの productID 桁。 外部キー制約は、それが適用される列の値が、それが参照する列にすでに存在している必要があることを要求することによって、2つのテーブル間の関係を表現する方法です。 以下では CREATE TABLE ステートメント、 FOREIGN KEY 制約では、値を追加する必要があります productSpecialty の列 team テーブルはすでにに存在している必要があります products テーブルの productID 桁。

名前の付いたテーブルを作成します team これらの3つの列で：

  1. CREATE TABLE team (

  2. empID int UNIQUE,

  3. empName varchar(20),

  4. productSpecialty int,

  5. PRIMARY KEY (empID),

  6. FOREIGN KEY (productSpecialty) REFERENCES products (productID)

  7. );

最後に作成するテーブルには、会社の売上の記録が保持されます。 このテーブルには4つの列があります。

  • saleID：に似ています productID と empID列の場合、この列には、販売ごとに一意の識別番号が保持されます。 int データ・タイプ。 この列には、 UNIQUE 制約により、 sales テーブル
  • quantity：販売された各製品のユニット数。 int データ・タイプ
  • productID：販売された製品の識別番号。 int
  • salesperson：販売を行った従業員の識別番号

以下のような productSpecialty からの列 team テーブル、あなたは適用することにしました FOREIGN KEY 両方への制約 productID と salesperson 列。 これにより、これらの列にすでに存在する値のみが含まれるようになります。 products テーブルの productID 列と team テーブルの empID それぞれ列。

名前の付いたテーブルを作成します sales これらの4つの列で：

  1. CREATE TABLE sales (

  2. saleID int UNIQUE,

  3. quantity int,

  4. productID int,

  5. salesperson int,

  6. PRIMARY KEY (saleID),

  7. FOREIGN KEY (productID) REFERENCES products (productID),

  8. FOREIGN KEY (salesperson) REFERENCES team (empID)

  9. );

その後、 products 以下を実行することにより、いくつかのサンプルデータを含むテーブル INSERT INTO 手術：

  1. INSERT INTO products

  2. VALUES

  3. (1, 'widget', 18.99),

  4. (2, 'gizmo', 14.49),

  5. (3, 'thingamajig', 39.99),

  6. (4, 'doodad', 11.50),

  7. (5, 'whatzit', 29.99);

次に、 team いくつかのサンプルデータを含む表：

  1. INSERT INTO team

  2. VALUES

  3. (1, 'Florence', 1),

  4. (2, 'Mary', 4),

  5. (3, 'Diana', 3),

  6. (4, 'Betty', 2);

をロードします sales いくつかのサンプルデータも含む表：

  1. INSERT INTO sales

  2. VALUES

  3. (1, 7, 1, 1),

  4. (2, 10, 5, 4),

  5. (3, 8, 2, 4),

  6. (4, 1, 3, 3),

  7. (5, 5, 1, 3);

最後に、あなたの会社があなたの販売チームの誰も関与せずにいくつかの販売を行っていると想像してください。 これらの売上を記録するには、次の操作を実行して3つの行をに追加します。 sales の値を含まないテーブル salesperson 桁：

  1. INSERT INTO sales (saleID, quantity, productID)

  2. VALUES

  3. (6, 1, 5),

  4. (7, 3, 1),

  5. (8, 4, 5);

これで、ガイドの残りの部分に従い、SQLでテーブルを結合する方法について学習する準備が整いました。

の構文を理解する JOIN オペレーション

JOIN 句は、UPDATEおよびDELETE操作を含む、さまざまなSQLステートメントで使用できます。 ただし、説明のために、このガイドの例では SELECT 方法を示すためのクエリ JOIN 句は機能します。

次の例は、 SELECT を含むステートメント JOIN 句：

  1. SELECT table1.column1, table2.column2

  2. FROM table1 JOIN table2

  3. ON search_condition;

この構文は、 SELECT 2つの別々のテーブルから2つの列を返すステートメント。 なぜなら JOIN 句は複数のテーブルの内容を比較します。この構文例では、列の名前の前にテーブルの名前とピリオドを付けて、各列を選択するテーブルを指定します。 これは、完全修飾列参照として知られています。

このような完全修飾列参照はどの操作でも使用できますが、技術的には、異なるテーブルの2つの列が同じ名前を共有する操作でのみ必要です。 ただし、複数のテーブルを操作する場合は、これらを使用することをお勧めします。 JOIN 読みやすく理解しやすい操作。

後に SELECT 節が来る FROM 句。 どのクエリでも、 FROM 句は、目的のデータを返すために検索する必要があるデータセットを定義する場所です。 ここでの唯一の違いは、 FROM 句には、で区切られた2つのテーブルが含まれます JOIN キーワード。 クエリを書くことを考えるのに役立つ方法は、あなたが SELECT どの列を返すか FROM クエリするテーブル。

続いて ON 検索条件を定義することにより、クエリが2つのテーブルを結合する方法を説明する句。 検索条件は、1つ以上の述語のセット、または特定の条件が「true」、「false」、または「unknown」であるかどうかを評価できる式です。 考えると役立つ場合があります JOIN 両方のテーブルのすべての行を結合し、検索条件が ON 句は「true」と評価されます。

で ON 句では、通常、2つの関連する列（1つのテーブルの外部キーと外部キーが参照する別のテーブルの主キーなど）が等しい値を持っているかどうかをテストする検索条件を含めることは理にかなっています。 これは、 equijoinと呼ばれることもあります。

等結合が複数のテーブルのデータと一致する方法の例として、前に追加したサンプルデータを使用して次のクエリを実行します。 このステートメントは、 products と team それぞれの一致する値をテストする検索条件を持つテーブル productID と productSpecialty 列。 次に、営業チームのすべてのメンバーの名前、彼らが専門とする各製品の名前、およびそれらの製品の価格が返されます。

  1. SELECT team.empName, products.productName, products.price

  2. FROM products JOIN team

  3. ON products.productID = team.productSpecialty;

このクエリの結果セットは次のとおりです。

Output
+----------+-------------+-------+
| empName  | productName | price |
+----------+-------------+-------+
| Florence | widget      | 18.99 |
| Mary     | doodad      | 11.50 |
| Diana    | thingamajig | 39.99 |
| Betty    | gizmo       | 14.49 |
+----------+-------------+-------+
4 rows in set (0.00 sec)

SQLがこれらのテーブルを組み合わせてこの結果セットを形成する方法を説明するために、このプロセスを詳しく見てみましょう。 明確にするために、データベース管理システムが2つのテーブルを結合したときに何が起こるかは正確にはわかりませんが、次のことを考えると役立つ場合があります。 JOIN このような手順に従って操作します。

まず、クエリは、の最初のテーブルのすべての行と列を出力します。 FROM 句、 products:

JOIN Process Example
+-----------+-------------+-------+
| productID | productName | price |
+-----------+-------------+-------+
|         1 | widget      | 18.99 |
|         2 | gizmo       | 14.49 |
|         3 | thingamajig | 39.99 |
|         4 | doodad      | 11.50 |
|         5 | whatzit     | 29.99 |
+-----------+-------------+-------+

次に、これらの各行を調べて、 team そのテーブル productSpecialty に等しい productID その行の値：

JOIN Process Example
+-----------+-------------+-------+-------+----------+------------------+
| productID | productName | price | empID | empName  | productSpecialty |
+-----------+-------------+-------+-------+----------+------------------+
|         1 | widget      | 18.99 |     1 | Florence |                1 |
|         2 | gizmo       | 14.49 |     4 | Betty    |                2 |
|         3 | thingamajig | 39.99 |     3 | Diana    |                3 |
|         4 | doodad      | 11.50 |     2 | Mary     |                4 |
|         5 | whatzit     | 29.99 |       |          |                  |
+-----------+-------------+-------+-------+----------+------------------+

次に、一致しない行を切り取り、列の順序に基づいて列を再配置します。 SELECT 句は、指定されていない列をすべて削除し、行を再分類して、最終的な結果セットを返します。

JOIN Process Example
+----------+-------------+-------+
| empName  | productName | price |
+----------+-------------+-------+
| Florence | widget      | 18.99 |
| Mary     | doodad      | 11.50 |
| Diana    | thingamajig | 39.99 |
| Betty    | gizmo       | 14.49 |
+----------+-------------+-------+
4 rows in set (0.00 sec)

表を結合する最も一般的な方法は等結合を使用することですが、次のような他のSQL演算子を使用することもできます。 <, >, LIKE, NOT LIKE、 あるいは BETWEEN の ON 句の検索条件。 ただし、より複雑な検索条件を使用すると、結果セットに表示されるデータを予測することが困難になる可能性があることに注意してください。

ほとんどの実装では、SQL標準で「」と呼ばれるものを持つ任意の列のセットでテーブルを結合できます。JOIN 適格な」データ型。 つまり、一般に、数値データを保持する列を、それぞれのデータ型に関係なく、数値データを保持する他の列と結合することができます。 同様に、通常、文字値を保持する任意の列を、文字データを保持する他の列と結合することができます。 ただし、前述のように、2つのテーブルを結合するために一致する列は、通常、外部キーとそれが参照する別のテーブルの主キーのように、テーブル間の関係をすでに示している列になります。

多くのSQL実装では、同じ名前の列を USING 代わりにキーワード ON. このような操作の構文は次のようになります。

  1. SELECT table1.column1, table2.column2

  2. FROM table1 JOIN table2

  3. USING (related_column);

この構文例では、 USING 節はと同等です ON table1.related_column = table2.related_column;.

なぜなら sales と products それぞれに名前の付いた列があります productID、これらの列を USING キーワード。 次のコマンドはこれを実行し、 saleID 各販売の、販売されたユニットの数量、販売された各製品の名前、およびその価格。 また、結果セットをに基づいて昇順で並べ替えます。 saleID 価値：

  1. SELECT sales.saleID, sales.quantity, products.productName, products.price

  2. FROM sales JOIN products

  3. USING (productID)

  4. ORDER BY saleID;



Output
+--------+----------+-------------+-------+
| saleID | quantity | productName | price |
+--------+----------+-------------+-------+
|      1 |        7 | widget     | 18.99 |
|      2 |       10 | whatzit     | 29.99 |
|      3 |        8 | gizmo       | 14.49 |
|      4 |        1 | thingamajig | 39.99 |
|      5 |        5 | widget      | 18.99 |
|      6 |        1 | whatzit     | 29.99 |
|      7 |        3 | widget      | 18.99 |
|      8 |        4 | whatzit     | 29.99 |
+--------+----------+-------------+-------+
8 rows in set (0.00 sec)

テーブルを結合するとき、データベースシステムは、予測が容易でない方法で行を再配置することがあります。 を含む ORDER BY このような句は、結果セットをより一貫性のある読みやすいものにするのに役立ちます。

3つ以上のテーブルを結合する

2つ以上のテーブルのデータを組み合わせる必要がある場合があります。 埋め込むことで、任意の数のテーブルを結合できます JOIN 他の条項内 JOIN 条項。 次の構文は、3つのテーブルを結合するときにこれがどのように見えるかの例です。

  1. SELECT table1.column1, table2.column2, table3.column3

  2. FROM table1 JOIN table2

  3. ON table1.related_column = table2.related_column

  4. JOIN table3

  5. ON table3.related_column = table1_or_2.related_column;

この構文例は FROM 条項は参加することから始まります table1 と table2. この参加後 ON 節、それは秒を開始します JOIN 結合されたテーブルの初期セットを table3. 3番目のテーブルは、1番目または2番目のテーブルのいずれかの列に結合できることに注意してください。

説明のために、従業員の売上がどれだけの収益をもたらしたかを知りたいが、専門の製品を販売している従業員が関与する売上記録のみを気にしていると想像してください。

この情報を取得するには、次のクエリを実行できます。 このクエリは、 products と sales それぞれのテーブルを一致させることによって一緒にテーブル productID 列。 その後、参加します team 最初の各行を一致させることにより、テーブルを最初の2つに JOIN そのに productSpecialty 桁。 次に、クエリは結果をフィルタリングします WHERE 一致した従業員が販売を行った人でもある行のみを返す句。 このクエリには、 ORDER BY 最終結果を、の値に基づいて昇順で並べ替える句 saleID 桁：

  1. SELECT sales.saleID,

  2. team.empName,

  3. products.productName,

  4. (sales.quantity * products.price)

  5. FROM products JOIN sales

  6. USING (productID)

  7. JOIN team

  8. ON team.productSpecialty = sales.productID

  9. WHERE team.empID = sales.salesperson

  10. ORDER BY sales.saleID;

このクエリにリストされている列の中で注意してください SELECT 句は、の値を乗算する式です。 sales テーブルの quantity による列 products テーブルの price 値。 一致した行にこれらの値の積を返します。

Output
+--------+----------+-------------+-----------------------------------+
| saleID | empName  | productName | (sales.quantity * products.price) |
+--------+----------+-------------+-----------------------------------+
|      1 | Florence | widget      |                            132.93 |
|      3 | Betty    | gizmo       |                            115.92 |
|      4 | Diana    | thingamajig |                             39.99 |
+--------+----------+-------------+-----------------------------------+
3 rows in set (0.00 sec)

これまでのすべての例では、同じタイプの JOIN 条項： INNER JOIN. の概要について INNER 参加し、 OUTER 結合、およびそれらの違いについては、次のセクションを読み続けてください。

インナーvs。 アウター JOIN オペレーション

2つの主なタイプがあります JOIN 条項： INNER 参加して OUTER 参加します。 これらの2つのタイプの結合の違いは、それらが返すデータに関係しています。 INNER 結合操作は、結合された各テーブルから一致する行のみを返しますが、 OUTER 結合は、一致する行と一致しない行の両方を返します。

前のセクションの構文とクエリの例はすべて使用されています INNER JOIN それらのどれも含まれていなくても条項 INNER キーワード。 ほとんどのSQL実装は、 JOIN としての節 INNER 特に明記されていない限り、参加してください。

を指定するクエリ OUTER JOIN 複数のテーブルを組み合わせて、一致する行と一致しない行を返します。 これは、値が欠落している行を見つける場合や、部分的な一致が許容される場合に役立ちます。

OUTER 結合操作はさらに3つのタイプに分けることができます。 LEFT OUTER 参加し、 RIGHT OUTER 参加し、 FULL OUTER 参加します。 LEFT OUTER 参加する、または単に LEFT 結合、2つの結合されたテーブルからのすべての一致する行、および「左」テーブルからのすべての一致しない行を返します。 の文脈で JOIN 操作では、「左」テーブルは常に直後に指定された最初のテーブルです。 FROM キーワードとの左側 JOIN キーワード。 同様に、「右」のテーブルは2番目のテーブル、つまり直後のテーブルです。 JOIN、 と RIGHT OUTER 結合は、「右」テーブルからのすべての一致しない行とともに、結合されたテーブルからのすべての一致する行を返します。 A FULL OUTER JOIN 一致するものがないいずれかのテーブルの行を含む、両方のテーブルのすべての行を返します。

これらのさまざまなタイプの JOIN 句はデータを返し、前のサンプルデータベースへの接続と設定サブセクションで作成されたテーブルに対して次のクエリ例を実行します。 これらのクエリは、それぞれが異なるタイプを指定することを除いて同一です。 JOIN 句。

この最初の例では、 INNER JOIN 組み合わせるには sales と team それぞれのテーブルを一致させることによって一緒にテーブル salesperson と empID 列。 繰り返しますが、 INNER キーワードは明示的に含まれていなくても暗黙的に示されます。

  1. SELECT sales.saleID, sales.quantity, sales.salesperson, team.empName 

  2. FROM sales JOIN team

  3. ON sales.salesperson = team.empID;

このクエリは INNER JOIN 句では、両方のテーブルから一致する行のみを返します。

Output
+--------+----------+-------------+----------+
| saleID | quantity | salesperson | empName  |
+--------+----------+-------------+----------+
|      1 |        7 |           1 | Florence |
|      4 |        1 |           3 | Diana    |
|      5 |        5 |           3 | Diana    |
|      2 |       10 |           4 | Betty    |
|      3 |        8 |           4 | Betty    |
+--------+----------+-------------+----------+
5 rows in set (0.00 sec)

このバージョンのクエリは、 LEFT OUTER JOIN 代わりに句：

  1. SELECT sales.saleID, sales.quantity, sales.salesperson, team.empName

  2. FROM sales LEFT OUTER JOIN team

  3. ON sales.salesperson = team.empID;

前のクエリと同様に、これも両方のテーブルから一致するすべての値を返します。 ただし、「左」テーブルからの値も返します（この場合、 sales）「正しい」テーブルに一致するものがない（team). 左側のテーブルのこれらの行には右側の一致がないため、一致しない値は次のように返されます。 NULL:

Output
+--------+----------+-------------+----------+
| saleID | quantity | salesperson | empName  |
+--------+----------+-------------+----------+
|      1 |        7 |           1 | Florence |
|      2 |       10 |           4 | Betty    |
|      3 |        8 |           4 | Betty    |
|      4 |        1 |           3 | Diana    |
|      5 |        5 |           3 | Diana    |
|      6 |        1 |        NULL | NULL     |
|      7 |        3 |        NULL | NULL     |
|      8 |        4 |        NULL | NULL     |
+--------+----------+-------------+----------+
8 rows in set (0.00 sec)

この次のバージョンのクエリは、代わりに RIGHT JOIN 句：

  1. SELECT sales.saleID, sales.quantity, sales.salesperson, team.empName

  2. FROM sales RIGHT JOIN team

  3. ON sales.salesperson = team.empID;

このクエリは JOIN 節は読む RIGHT JOIN それ以外の RIGHT OUTER JOIN. どのように INNER キーワードを指定する必要はありません INNER JOIN 句、 OUTER あなたが書くときはいつでも暗示されます LEFT JOIN また RIGHT JOIN.

このクエリの結果は、両方のテーブルからすべての行を返すという点で前のクエリの結果とは逆ですが、「右」のテーブルから一致しない行のみを返します。

Output
+--------+----------+-------------+----------+
| saleID | quantity | salesperson | empName  |
+--------+----------+-------------+----------+
|      1 |        7 |           1 | Florence |
|   NULL |     NULL |        NULL | Mary     |
|      4 |        1 |           3 | Diana    |
|      5 |        5 |           3 | Diana    |
|      2 |       10 |           4 | Betty    |
|      3 |        8 |           4 | Betty    |
+--------+----------+-------------+----------+
6 rows in set (0.00 sec)

注：MySQLはサポートしていないことに注意してください FULL OUTER JOIN 条項。 このクエリが使用した場合に返されるデータを説明するために FULL OUTER JOIN 句、PostgreSQLデータベースでの結果セットは次のようになります。

  1. SELECT sales.saleID, sales.quantity, sales.salesperson, team.empName

  2. FROM sales FULL OUTER JOIN team

  3. ON sales.salesperson = team.empID;



Output
 saleid | quantity | salesperson | empname  
--------+----------+-------------+----------
      1 |        7 |           1 | Florence
      2 |       10 |           4 | Betty
      3 |        8 |           4 | Betty
      4 |        1 |           3 | Diana
      5 |        5 |           3 | Diana
      6 |        1 |             | 
      7 |        3 |             | 
      8 |        4 |             | 
        |          |             | Mary
(9 rows)

この出力が示すように、 FULL JOIN 一致しないものを含む両方のテーブルのすべての行を返します。

でのテーブル名と列名のエイリアシング JOIN 条項

長い名前または非常にわかりやすい名前でテーブルを結合する場合、完全修飾された複数の列参照を作成する必要があるのは面倒な場合があります。 これを回避するために、ユーザーはテーブル名または列名に短いエイリアスを指定すると便利な場合があります。

SQLでこれを行うには、次のテーブル定義に従います。 FROM との句 AS キーワードを入力し、それに続いて任意のエイリアスを使用します。

  1. SELECT t1.column1, t2.column2

  2. FROM table1 AS t1 JOIN table2 AS t2

  3. ON t1.related_column = t2.related_column;

この構文例では、 SELECT それらが定義されるまでは定義されていなくても、句 FROM 句。 これが可能なのは、SQLクエリでは、実行の順序が FROM 句。 これは混乱を招く可能性がありますが、クエリの作成を開始する前に、これを覚えてエイリアスについて考えると役立ちます。

例として、を結合する次のクエリを実行します sales と products テーブルとエイリアスを提供します S と P、 それぞれ：

  1. SELECT S.saleID, S.quantity,

  2. P.productName,

  3. (P.price * S.quantity) AS revenue 

  4. FROM sales AS S JOIN products AS P

  5. USING (productID);

この例では、3番目のエイリアスも作成されることに注意してください。 revenue、の値の積の場合 sales テーブルの quantity 列とそれらの一致する値 products テーブルの price 桁。 これは、結果セットの列名でのみ明らかですが、このようなエイリアスを提供すると、クエリ結果の背後にある意味や目的を伝えるのに役立ちます。

Output
+--------+----------+-------------+---------+
| saleID | quantity | productName | revenue |
+--------+----------+-------------+---------+
|      1 |        7 | widget      |  132.93 |
|      2 |       10 | whatzit     |  299.90 |
|      3 |        8 | gizmo       |  115.92 |
|      4 |        1 | thingamajig |   39.99 |
|      5 |        5 | widget      |   94.95 |
|      6 |        1 | whatzit     |   29.99 |
|      7 |        3 | widget      |   56.97 |
|      8 |        4 | whatzit     |  119.96 |
+--------+----------+-------------+---------+
8 rows in set (0.00 sec)

エイリアスを定義するときは、 AS キーワードは技術的にオプションです。 前の例は、次のように書くこともできます。

  1. SELECT S.saleID, S.quantity, P.productName, (P.price * S.quantity) revenue 

  2. FROM sales S JOIN products P

  3. USING (productID);

にもかかわらず AS エイリアスを定義するためにキーワードは必要ありません。キーワードを含めることをお勧めします。 そうすることで、クエリの目的を明確に保ち、読みやすさを向上させることができます。

結論

このガイドを読むことで、使い方を学びました JOIN 個別のテーブルを単一のクエリ結果セットに結合する操作。 ここに示すコマンドはほとんどのリレーショナルデータベースで機能するはずですが、すべてのSQLデータベースが独自の言語実装を使用していることに注意してください。 各コマンドとそのオプションの完全なセットの詳細については、DBMSの公式ドキュメントを参照してください。

SQLの操作について詳しく知りたい場合は、SQLの使用方法に関するこのシリーズの他のチュートリアルを確認することをお勧めします。