初心者のためのSQLチュートリアル

初心者向けのこのSQLチュートリアルでは、独自のデータベースを作成し、そのデータベースにデータを挿入してから、そのデータベースに対してクエリを実行します。

このSQLチュートリアルでは、SQLクエリをすぐに実行できます！

SQLの例

SQLステートメントの例を次に示します。

SELECT * 
FROM Pets;

これは、SQLの記述がいかに簡単であるかを示す完璧な例です。この単純なSQLステートメントは実際に多くのことを行います。テーブル全体を返します。 Petsというテーブルからすべての列とすべての行を返します。

アスタリスク（* ）はワイルドカード文字で、「すべての列」を意味します。すべての列を入力しなくても、すばやく簡単にすべての列を取得できます。

これはSQLのすばらしい点の1つです。通常、最も単純なSQLクエリが最も強力です。より少ないデータを返したい場合は、実際にはもっと書き込む必要があります。。

たとえば、 Fetchという名前のペットだけが必要な場合、WHEREを追加しますその要件を規定した条項。

このように：

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE 句は、PetNameが存在する行のみにクエリをフィルタリングします列の値はFetch 。

このクエリは、PetNameという列があることを前提としています。 Petsというテーブルデータベース内。

このSQLチュートリアルでは、SQLを使用してこのようなデータベースを作成する方法を紹介します。

また、そのデータベースにデータを挿入する方法、データを更新する方法、データを削除する方法、データベースに対してクエリを実行する方法についても説明します。

SQLとは何ですか？

SQL はStructuredQueryLanguageの頭字語です。

SQLは、リレーショナルデータベースの操作に使用される標準のクエリ言語です。

SQLは、以下を含むすべての主要なリレーショナルデータベース管理システム（RDBMS）で使用されています。

Microsoft Access
SQL Server
Oracle
PostgreSQL
MySQL
SQLite

SQLで何ができますか？

SQLを使用して、データベースに対するクエリの実行、レコードの挿入、レコードの更新、およびレコードの削除を行うことができます。データベースやテーブルなどの新しいデータベースオブジェクトを作成することもできます。ログイン、自動化されたジョブ、データベースのバックアップなどのデータベース管理タスクを実行することもできます。

グラフィカルユーザーインターフェイス（GUI）を使用して作業を行う場合でも、データベース管理システム（DBMS）は、ほぼ確実に、そのタスクを実行するためにバックグラウンドでSQLを使用します。

たとえば、データベースの作成をクリックしてデータベースを作成する場合 OK をクリックしたら、新しいデータベースの詳細をダイアログボックスに入力しますまたは作成または、ボタンの読み取りに関係なく、データベースシステムはSQL CREATE DATABASEを使用します先に進み、指定されたとおりにデータベースを作成するステートメント。

クエリの実行、データの挿入など、他のタスクについても同じことが言えます。

SQLを使用すると、ストアドプロシージャ（自己完結型スクリプト）、ビュー（事前に作成されたクエリ）の作成、データベースオブジェクト（テーブル、ストアドプロシージャ、ビューなど）へのアクセス許可の設定などのより高度なアクションを実行することもできます。

とはいえ、SQLを使い始めるために、すべての高度なことを学ぶ必要はありません。 SQLの良いところは、最も一般的なタスクのいくつかが最も簡単に記述できることです。

SQL標準

SQLは1986年にANSIX3.135で標準化され、数か月以内にISOによってISO9075-1987として採用されました。それ以来、国際規格（現在のISO / IEC 9075）は定期的に改訂されており、現在9つの部分に分かれています。

ほとんどの主要なデータベースベンダーは、SQL標準に準拠する傾向があります。その良い点は、新しいDBMSを学習するたびに新しいクエリ言語を学習する必要がないことです。

ただし、実際には、各データベースベンダーがSQL標準を実装する方法には違いがあります。したがって、あるDBMSで記述したコードは、変更を加えることなく、別のDBMSで常に機能するとは限りません。

幸いなことに、すべての主要なDBMSは、最も一般的なタスクをほぼ同じ方法でサポートしています。

SQLの発音

SQLは通常、次の2つの方法のいずれかで発音されます。

「ess-que-el 」（つまり、各文字を綴る）
「続編」（元の綴り/発音のように）。

理由がわからない場合は、「S-Q-Lと発音されますか」または「続編」を参照してください。

このSQLチュートリアルには何が必要ですか？

このSQLチュートリアルを実際に活用するには、例に従ってください。つまり、SQLクエリを入力する場所が必要になります。次のようなものが必要です：

SQLクエリを実行する場合は、次のものが必要です。

インストールされているRDBMS（SQL Server、MySQL、PostgreSQL、SQLiteなど）
そのRDBMS（MySQL WorkBench、Azure Data Studio（写真）、DBeaver、SSMSなど）に対してSQLクエリを実行できるデータベースツール。

すでにそれぞれを1つずつインストールしている場合は、すばらしいです。チュートリアルを続けることができます。

これらをインストールしていない場合は、SQLを実行するために何が必要ですか？を参照してください。このSQLチュートリアルに戻る前に、RDBMSとそれに関連するデータベース管理ツールをインストールする手順について説明します。

データベースを作成する

RDBMSと適切なデータベースツールをインストールしたら、データベースを作成する準備が整います。

CREATE DATABASE PetHotel;

終わり！

そのステートメントは実際にデータベースを作成しました。空のデータベースですが、それでもデータベースです。

このデータベースには、このSQLチュートリアルで使用されるテーブルとデータが含まれます。テーブルを作成したりデータを挿入したりするときは、このデータベース内で行います。

SQLiteはデータベースの作成に異なる構文を使用していることに注意してください。 SQLiteを使用している場合、SQLiteでデータベースを作成する方法は次のとおりです。

データベースに接続する

テーブルの作成やデータの挿入などを開始する前に、適切なデータベースにいることを確認する必要があります。（先ほど行ったように）データベースを作成しても、必ずしもそのデータベースに接続できるとは限りません。

多くのDBMS（ SQL Server など）、 MySQL およびMariaDB ）、以下を使用して、指定したデータベースに切り替えることができます。

USE PetHotel;

これでPetHotel 現在のデータベース。

SQLite 、作成後、データベースにすでに存在している可能性があります。そうでない場合は、データベースを添付できます（データベースがまだ存在しない場合はデータベースも作成されます）：

ATTACH DATABASE 'PetHotel.db' AS Pets;

PostgreSQL 、psqlツールを使用している場合は、次を使用できます。

\connect PetHotel

または短縮版：

\c PetHotel

データベースの作成と接続のプロセスは、DBMS間で大きく異なる可能性があることに注意してください。

幸い、ほとんどのGUIツールでは、データベースをダブルクリックするか、データベース名を右クリックしてコンテキストメニューから新しいクエリタブを選択することで、データベースに接続できます。このステップで行き詰まった場合は、GUIを使用してDBを作成または接続してください。

テーブルを作成する

適切なデータベースに接続したので、先に進んでいくつかのテーブルを作成できます。

SQLでテーブルを作成するには、CREATE TABLEを使用しますステートメント。

テーブルを作成するときは、テーブルに含める列とそのデータ型を指定する必要があります。他の詳細を指定することもできますが、先に進まないでください。

テーブルを作成しましょう：

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

この場合、PetTypesというテーブルを作成します。テーブル名はCREATE TABLEの直後にあるため、少し。

その後、括弧で囲まれた列のリストが表示されます。

上記の表には、次の列が含まれています。

PetIdId
PetType

各列の後にはデータ型が続きます：

int この列が整数を受け入れることを意味します。私の知る限り、ほとんどの主要なDBMSは、列をintとして宣言することをサポートしています。。問題がある場合は、integerを使用してみてください。
varchar(60) これは、この列が最大60文字の文字列を受け入れることを意味します。 varchar 列は可変長の文字列です。別の文字列データ型はcharです（これは固定長の文字列です）。列をvarchar(60)として定義しようとして問題が発生した場合、char(60)を使用してみてください。

`NOT NULL` 制約

この例では、両方の列がNOT NULLで定義されています制約。 NOT NULL 制約は、この列を空にすることはできないことを意味します。新しい行が挿入されると、NOT NULL 列必須値が含まれています。他の列のデータがない場合、他の列は空のままにすることができます。

NULLの場合列に値を含めることができます。NOT NULLを省略できます。一部、またはNULLとして宣言します（つまり、NULL この列では値を使用できます）。

一部のDBMS（DB2など）はNULLをサポートしていませんとにかくキーワードなので、そのようなDBMSを使用する場合は省略してください。

主キー

PetTypeIdも作成しました主キーの列。 主キー テーブルの各行を一意に識別する1つ以上の列です。主キー制約を使用して、選択した列を主キーとして指定します。これは、CREATE TABLEで行うことができますステートメント（ここで行ったように）、または後でALTER TABLEを使用してステートメントを追加できます声明。

主キーには一意の値が含まれている必要があります。つまり、そのテーブルの各行について、主キー列の値は各行で異なる必要があります。これは、増分番号（1、2、3など）のように単純な場合もあれば、製品コード（pr4650、pr2784、pr5981など）の場合もあります。

また、主キーには値が含まれている必要があります。 NULLにすることはできません。

主キーは必須ではありませんが、通常、各テーブルに主キーを定義することをお勧めします。

さらにテーブルを作成する

さらに2つのテーブルを作成しましょう：

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

これらのテーブルは両方とも最初のテーブルと似ていますが、行が多く、いくつかの追加の部分がある点が異なります。これについては、以下で説明します。

興味がある場合は、SQLでテーブルを作成する簡単な例について、初心者向けのSQLCREATETABLEを確認してください。

関係

Petsを作成したときテーブルでは、実際に3つのテーブル間の関係を作成しました。

その関係を次の図に示します。

データベースの関係はSQLの重要な部分です。リレーションシップを使用すると、複数のテーブルで関連データをクエリして、正確で一貫性のある結果を得ることができます。

私たちの場合、飼い主ごとにペットを検索したり、ペットの種類ごとにペットを検索したりできるようにしたいのです。また、結果が正確で一貫している必要があります。

これを達成するために、私たちはすべてのペットが彼らの所有者とペットの種類と一緒に入力されることを主張する必要があります。したがって、新しいペットがPetsに追加されるたびに、それを確認する必要があります。テーブルの場合、Ownersにはすでに対応する所有者がいますテーブル、およびPetTypesの対応するペットタイプテーブル。

基本的に、要件は次のとおりです。

Pets.PetTypeIdの任意の値列はPetTypes.PetTypeIdの値と一致する必要があります列。
Pets.OwnerIdの任意の値列はOwners.OwnerIdの値と一致する必要があります列。

該当する列に対して外部キー制約を作成することにより、上記の要件を保証できます。 外部キー 制約は、特定の列が別のテーブルの主キーを参照することを指定するために使用されます。

上記のコードは、実際にPetsに2つの外部キー制約を作成しましたテーブル。

PetTypeIdに注意してくださいおよびOwnerId 列には、REFERENCES...で始まる追加のコードがいくつかあります。これらは、2つの外部キーを作成した部分です。

Petsを作成したときテーブル、そのPetTypeId 列には、REFERENCES PetTypes (PetTypeId)になるビットがあります。これは、Pets.PetTypeIdが列はPetTypeIdを参照します PetTypesの列テーブル。

OwnerIdについても同じです桁。 OwnerIdを参照します Ownersの列テーブル。

ほとんどのDBMSでは、ALTER TABLEを使用して、既存のテーブルに外部キーを作成することもできます。ステートメントですが、ここでは説明しません。詳細については、SQLでリレーションシップを作成する方法を参照してください。

とにかく、私たちの外部キーは作成されました。これで、誰かが新しいペットをPetsに挿入するたびにテーブル、PetTypeId およびOwnerId 値は、PetTypesに対応する値を持っている必要がありますおよびOwners それぞれテーブル。それらのいずれかがそうでない場合、データベースはエラーを返します。

これは外部キーの利点です。不正なデータが入力されるのを防ぐのに役立ちます。データの整合性、より具体的には参照整合性を維持するのに役立ちます。

チェック制約

チェック制約 知っておくべきもう1つの制約タイプです。チェック制約は、データベースに入る前にデータをチェックします。テーブルでチェック制約が有効になっている場合、データはその制約に違反していない場合にのみテーブルに入ることができます。制約に違反するデータはテーブルに入ることができません。

たとえば、Priceにチェック制約を作成できます。ゼロより大きい値のみを受け入れるようにするための列。または、Petsにチェック制約を適用することもできます。 DOBを確認するためのテーブルコラムは将来のものではありません。

例については、「チェック制約とは」を参照してください。

空白

私の例には空白が含まれていることに気づいたかもしれません。たとえば、コードを複数の行にまたがって配置し、タブを使用してデータ型などをインデントしました。

これはSQLで完全に有効です。これは安全に行うことができ、結果に影響を与えることはありません。 SQLを使用すると、必要に応じてコードを複数の行に分散でき、複数のスペースまたはタブを使用して読みやすさを向上させることができます。

コード内にコメントを含めることもできます。長いSQLスクリプトを書き始めたら、コメントが便利です。スクリプトが非常に長くなると、コメントを使用すると、各部分の機能をすばやく簡単に識別できます。

インラインコメント

コメントの前に2つのハイフン文字（--）を付けることで、インラインコメントを作成できます。）：

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

この例では、両方のクエリが問題なく実行されます。コメントはDBMSによって無視されます。

複数行のコメント

コメントを/*で囲むことにより、コメントを複数行に広げることができますおよび*/ ：

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

この例では、両方のクエリが問題なく実行されます。コメントはDBMSによって無視されます。

MySQL

MySQLを使用している場合は、番号記号/ハッシュ記号（#）を使用することもできます）1行のコメントの場合。

# This is a comment
SELECT * FROM Pets;

コードのコメントアウト

コメントのもう1つの優れた利点は、コメントアウトできることです。コード。たとえば、多くのことを実行する長いSQLスクリプトがあり、その1つまたは2つの部分だけを実行したい場合は、コメントアウトできます。スクリプトの残りの部分。

次に例を示します：

-- SELECT * FROM Pets;

SELECT * FROM Owners;

この場合、最初のSELECT ステートメントはコメント化されているため、2番目のSELECTのみステートメントが実行されます。

この手法には、複数行のコメントを使用することもできます。

データを挿入

3つのテーブルを作成し、適切な外部キーを作成したので、先に進んでデータを追加できます。

SQLにデータを挿入する最も一般的な方法は、INSERTを使用することです。声明。次のようになります：

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

MyTableを置き換えるだけですデータを挿入するテーブルの名前を使用します。同様に、Column1を置き換えます、などの列名、およびValue1 、など、それらの列に入る値を使用します。

たとえば、次のようにすることができます：

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

各値は、列が指定されているのと同じ順序です。

列名は、テーブルの作成時に使用した名前と一致することに注意してください。

すべての列にデータを挿入する場合は、列名を省略できます。したがって、上記の例を次のように変更できます。

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

このチュートリアルでは、かなりの数の行を追加するので、INSERT INTOをさらに追加します。ステートメント–挿入する行ごとに1つ。

それでは、先に進んでテーブルにデータを入力しましょう。

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Petsにデータを入力したことに注意してください最後のテーブル。これには理由があります。

Petsにデータを挿入しようとした場合他の2つを設定する前にテーブルを作成すると、外部キーの制約のためにエラーが発生します。そして、正当な理由があります。結局のところ、他のテーブルの主キー列にまだ存在していない外部キー列に値を挿入しようとしていたのです。これは、外部キーに関しては大きな「ノーノー」です。

したがって、Ownersにデータを入力することによっておよびPetTypes 最初にテーブルを作成し、Petsに外部キー列を設定する前に、適切な値がすでに主キー列にあることを確認しました。テーブル。

テーブルにデータを挿入するその他の例については、初心者向けのSQLINSERTを参照してください。

データを確認する

ふぅ！最後に、データベースに対してクエリの実行を開始できます。

すべてのテーブルのデータを確認しましょう。

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

結果：

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

すばらしいので、データは正常に挿入されたようです。

特定の列を選択

本当に必要な場合を除いて、テーブルからすべての行とすべての列を選択することは、一般的に悪い習慣と見なされています（前の例で行ったように）。これを行うと、特にテーブルに多くの行がある場合、データベースサーバーのパフォーマンスに影響を与える可能性があります。

ここにあるような小さなデータセットを使用している場合や、開発環境などを使用している場合は、問題ありません。それ以外の場合は、通常、必要な列だけを選択することをお勧めします。

したがって、すべてのペットのID、名前、生年月日が必要な場合は、次のようにすることができます。

SELECT PetId, PetName, DOB 
FROM Pets;

結果：

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

ふわふわという名前のすべてのペットのIDと生年月日が必要な場合は、次のように使用できます。

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

結果：

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

SELECTを使用することもできますテーブルなしのデータを返すステートメント。つまり、テーブルに格納されていないデータを返すことができます。 SQL SELECTを参照してください初心者向けのステートメントで例をご覧ください。

並べ替え

SQLはORDER BYを提供しますデータの並べ替えを可能にする句。

ORDER BYを追加できますペットが名前でソートされるように、前の例の句：

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

結果：

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

ASC 一部は昇順を意味します。 ORDER BYを使用する場合句はデフォルトで昇順であるため、ASCを省略できます。必要に応じて分割してください。

降順で並べ替える注文するには、DESCを使用します。

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

結果：

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

複数の列を使用して結果を並べ替えることもできます。指定された最初の列で並べ替えられ、その列に重複がある場合は、指定された2番目の列でそれらの重複が並べ替えられます。

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

結果：

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

2人のふわふわがどのように位置を入れ替えたかをご覧ください。

ORDER BYを使用しない場合条項、結果がどのような順序になるかは保証されません。見た目 データベースが特定の列で結果を並べ替えているように、これは実際には当てはまらない場合があります。通常、ORDER BYなし句では、データはテーブルにロードされた順序で並べ替えられます。ただし、行が削除または更新された場合、DBMSが再利用されたストレージスペースを再利用する方法によって順序が影響を受けます。

したがって、DBMSに依存して結果を意味のある順序で並べ替えないでください。

結論：結果を並べ替える場合は、ORDER BYを使用します。

SQL ORDER BYを参照してくださいその他の例については、初心者向けの条項。

結果セットの行をカウントする

COUNT()を使用できますクエリで返される行をカウントする集計関数。

SELECT COUNT(*) AS Count
FROM Pets;

結果：

+---------+
| Count   |
|---------|
| 8       |
+---------+

これは、テーブルに8行あることを示しています。すべての行とすべての列を選択したので、それがわかります。

COUNT()を使用できます WHEREを使用するクエリなどのクエリ結果をフィルタリングする句。

カウントする特定の列を指定することもできます。 COUNT() 関数はNULL以外のみをカウントします結果として、NULLを含む列を指定した場合値、それらの値はカウントされません。

これが私の意味を示す例です。

SELECT COUNT(DOB) AS Count
FROM Pets;

結果：

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Petsを思い出してくださいテーブルには2つのNULLが含まれています DOBの値列（2匹のペットは生年月日を提供していません）なので、COUNT(DOB) COUNT(*)を使用した場合、8ではなく6を返します。理由COUNT(*) すべての行が返されました。これは、これら2つの行がしたためです。他の列にデータがあります。

私の例では、DBMSもこれに関する警告を返しました。 DBMSと特定の構成に応じて、警告が表示される場合と表示されない場合があります。

SQL COUNTを参照してくださいその他の例については、初心者向けです。

その他の集計関数は次のとおりです。AVG() 、SUM() 、MIN() 、およびMAX() 。

グループ化

もう1つの便利な句は、GROUP BYです。句。これは、その名前が約束することとほぼ同じです。結果を特定の列でグループ化できます。

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

結果：

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

この例では、ペットの種類ごとに飼っているペットの数を数え、降順で並べ替えています（最も多い数が一番上にあります）。

SQL GROUP BYを参照してくださいその他の例については、初心者向けの条項。

`HAVING` 条項

HAVINGを使用できます GROUP BYの結果をフィルタリングする句句。 HAVING 句は、集計値が指定された条件を満たす行を返します。

これが例です。

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

結果：

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

この場合、2匹以上のペットが割り当てられているペットタイプのみのデータを返しました。

SQL HAVINGを参照してくださいその他の例については、初心者向けの条項。

参加

SQLでは、参加ここで、複数のテーブルのデータを組み合わせるクエリを実行します。

前の2つの例は問題ありませんが、ID（1、2、3など）ではなく、実際のペットの種類（猫、犬、鳥など）を返す方がよいでしょう。

唯一の問題は、Pets テーブルにはそのデータが含まれていません。そのデータはPetTypesにありますテーブル。

幸いなことに、これら2つのテーブル間で結合を行うことができます。 LEFT JOINを使用する例を次に示します。：

SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

結果：

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

この結果セットは、以前の結果セットよりもはるかに読みやすくなっています。テーブルにペットの種類がいくつあるかを理解するのは簡単です。

構文は結合タイプ（この場合はLEFT JOIN）を使用します）、最初の（左）テーブル、ONが続きます、その後に結合条件が続きます。

INNER JOINを使用しましょうすべてのペットの名前とそれぞれのペットの種類を返します。

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

結果：

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

複数のテーブルからデータを取得して、単一のテーブルであるかのように表示できるようになったため、結合によってオプションが実際に開かれます。

結合の例では、列名をテーブル名で修飾していることに気付くでしょう。これを行う理由は、テーブル間の列列名に関するあいまいさを回避するためです。両方のテーブルに同じ名前の列が含まれている可能性があり（この例のように）、そのような場合、DBMSは参照している列を認識しません。列名の前にテーブル名を付けると、正しい列を参照していることが保証され、参照している列のあいまいさから生じる可能性のあるエラーを防ぐことができます。

その他の例とさまざまな結合タイプの説明については、SQL結合チュートリアルを参照してください。

エイリアス

さらに一歩進んで、エイリアスを割り当てることができます各テーブル名と列名に。

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

結果：

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

これにより、新しい列ヘッダーが作成され、コードがより簡潔になりました。

エイリアスを使用すると、SELECTの期間中、テーブルまたは列に別の名前を一時的に割り当てることができます。クエリ。これは、テーブルや列の名前が非常に長い場合や複雑な場合に特に便利です。

エイリアスは、ASを使用して割り当てられますキーワード。ただし、このキーワードはオプションであるため、安全に省略できます。 OracleはASをサポートしていないことに注意してくださいテーブルエイリアスのキーワード（ただし、列エイリアスには適用されます）。

上記の例では、ASを含めました列エイリアスを割り当てるときはキーワードですが、テーブルエイリアスを割り当てるときは省略します。

エイリアス名は何でもかまいませんが、読みやすくするために通常は短くします。

この例では、2つのテーブルをpに変更しましたおよびpt 、およびPetへの列名およびPet Type 。 Pet Typeを囲んでいることに注意してください二重引用符で囲みます。名前にスペースがあるので、これを行いました。スペースのないエイリアスの場合、これを行う必要はありません。 SQL Serverでは、代わりに角かっこ（[]）を使用できます。）二重引用符の代わりに（ただし、二重引用符もサポートしています）。

一部のクライアントアプリケーションであらゆる種類の問題が発生する可能性があるため、列とエイリアスでスペースを使用することは一般的に推奨されていません。

結合で列名を参照するときは（ONの後）、完全な列名を使用する必要があることに注意してください。キーワード）。

エイリアスを割り当てても、実際には列またはテーブルの名前が変更されないことを指摘しておく必要があります。

その他の例については、SQLエイリアスの説明を参照してください。

データの更新

UPDATEを使用できますテーブル内のデータを更新するステートメント。

基本的な構文は非常に単純です：

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

その例では、LastNameを更新します Stalloneの新しい値を持つ列ここで、OwnerId 3です。

複数の列を更新するには、コンマを使用して各列と値のペアを区切ります。

ただし、何をするにしても、 WHEREを忘れないでください条項 （実際にテーブルのすべての行を更新する場合を除きます。同じ値で）。

SQL UPDATEを参照してくださいより多くの例とより詳細な説明については、初心者向けです。

データの削除

DELETEを使用できますテーブルからデータを削除するステートメント。

基本的な構文は、UPDATEよりもさらに単純です。ステートメント：

DELETE FROM Owners
WHERE OwnerId = 5;

ここでは、Ownersから所有者番号5を削除しますテーブル。

UPDATEと同様ステートメント、 WHEREを忘れないでください条項 （テーブルのすべての行を削除する場合を除きます。。

SQL DELETEを参照してくださいその他の例と詳細な説明については、初心者向けです。

オブジェクトの削除

物事を削除するというテーマで、データベースオブジェクト（テーブル、ビュー、ストアドプロシージャなど）を削除すると、そのオブジェクトを「ドロップ」すると言われます。たとえば、テーブルが不要になった場合は、「ドロップ」します。

構文は非常に単純で、次のようになります。

DROP TABLE Customers;

これらの3つの単語は、Customersというテーブルを完全に消去しました。。テーブルとそのすべてのデータがなくなりました。

ご想像のとおり、これは非常に危険なステートメントである可能性があるため、細心の注意を払って使用する必要があります。

tableを置き換えることを除いて、他のオブジェクトタイプにも同じ構文を使用できます。オブジェクトタイプ（例：DROP VIEW vPets vPetsというビューをドロップします。

外部キーによって参照されているテーブルを削除しようとすると、エラーが発生する可能性があります。この場合、外部キーをドロップする必要があります（ALTER TABLEを使用）ステートメント）または子テーブル自体。

SQL演算子

SQLでは、オペレーター 1つまたは複数の式に対して実行されるアクションを指定する記号です。

オペレーターは個々のデータ項目を操作し、結果を返します。データ項目はオペランドと呼ばれますまたは引数。 In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ）。 We also ran a query that used the Greater Than operator (> ）。 These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables 。

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW 構文。

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

結果：

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY 条項。

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

結果：

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId 。 This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE 声明。 You can alternatively shorten it to EXEC 。 In PostgreSQL, use the CALL ステートメント。

EXEC uspGetPetById @PetId = 3;

結果：

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT 、UPDATE 、またはDELETE ステートメント。

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

Create a DML Trigger in SQL Server
Create a “last modified” column
Automatically send an email when someone tries to delete a record
Update a column’s value whenever another column is updated
Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

SQL Server String Functions
SQL Server Mathematical Functions
SQL Server Date &Time Functions

MySQL

MySQL String Functions
MySQL Mathematical Functions

PostgreSQL

PostgreSQL Date &Time Functions
PostgreSQL Math Functions

SQLite

SQLite Aggregate Functions
SQLite Date &Time Functions

初心者のためのSQLチュートリアル

SQLの例

SQLとは何ですか？

SQLで何ができますか？

SQL標準

SQLの発音

このSQLチュートリアルには何が必要ですか？

データベースを作成する

データベースに接続する

テーブルを作成する

NOT NULL 制約

主キー

さらにテーブルを作成する

関係

チェック制約

空白

コメント

インラインコメント

複数行のコメント

MySQL

コードのコメントアウト

データを挿入

データを確認する

特定の列を選択

並べ替え

結果セットの行をカウントする

グループ化

HAVING 条項

参加

エイリアス

データの更新

データの削除

オブジェクトの削除

SQL演算子

SQL Views

Views and the ORDER BY Clause

Stored Procedures

SQL Triggers

SQL Transactions

SQL Functions

User-Defined Functions

Inbuilt Functions

SQL Server

MySQL

PostgreSQL

SQLite

`NOT NULL` 制約

`HAVING` 条項