SQL kurz pro začátečníky

V tomto SQL tutoriálu pro začátečníky si vytvoříte vlastní databázi, vložíte do ní data a poté spouštíte dotazy proti této databázi.

Tento výukový program SQL vám umožní spouštět dotazy SQL během okamžiku!

Příklad SQL

Zde je příklad příkazu SQL:

SELECT * 
FROM Pets;

Toto je dokonalý příklad toho, jak snadné může být psaní SQL. Tento jednoduchý příkaz SQL dělá skutečně hodně. Vrátí celou tabulku. Vrací všechny sloupce a všechny řádky z tabulky nazvané Pets .

Hvězdička (* ) je zástupný znak, který znamená „všechny sloupce“. Je to rychlý a snadný způsob, jak získat všechny sloupce, aniž byste je museli všechny vypisovat.

To je jedna z krásných věcí na SQL. Nejjednodušší SQL dotazy jsou obvykle nejvýkonnější. Pokud bychom chtěli vrátit méně dat, museli bychom ve skutečnosti napsat více .

Pokud bychom například chtěli pouze domácí mazlíčky s názvem Načíst , přidali bychom WHERE doložka, která tento požadavek stanovila.

Takhle:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE klauzule filtruje náš dotaz pouze na řádky, kde je PetName sloupec má hodnotu Fetch .

Tento dotaz předpokládá, že existuje sloupec s názvem PetName a tabulku nazvanou Pets v databázi.

V tomto SQL tutoriálu vám ukážu, jak vytvořit takovou databázi pomocí SQL.

Také vám ukážu, jak vkládat data do této databáze, aktualizovat data, mazat data a spouštět proti nim dotazy.

Co je SQL?

SQL je zkratka pro Structured Query Language.

SQL je standardní dotazovací jazyk používaný pro práci s relačními databázemi.

SQL používají všechny hlavní systémy správy relačních databází (RDBMS), včetně:

• Microsoft Access
• SQL Server
• Oracle
• PostgreSQL
• MySQL
• SQLite

Co mohu dělat s SQL?

SQL můžete použít ke spouštění dotazů na databázi, vkládání záznamů, aktualizaci záznamů a odstraňování záznamů. Můžete také vytvářet nové databázové objekty, jako jsou databáze a tabulky. Můžete také provádět úlohy správy databáze, jako je vytváření přihlášení, automatické úlohy, zálohování databáze a mnoho dalšího.

I když děláte věci pomocí grafického uživatelského rozhraní (GUI), váš systém správy databází (DBMS) téměř jistě použije SQL v zákulisí k provedení tohoto úkolu.

Například když vytvoříte databázi kliknutím na Vytvořit databázi a zadání podrobností o nové databázi do dialogového okna, jakmile kliknete na OK nebo Vytvořit nebo ať už je na tlačítku cokoli, váš databázový systém použije SQL CREATE DATABASE příkaz pokračovat a vytvořit databázi, jak je uvedeno.

Totéž platí pro další úlohy, jako je spouštění dotazů, vkládání dat atd.

SQL také umožňuje provádět pokročilejší akce, jako je vytváření uložených procedur (samostatné skripty), pohledy (předem vytvořené dotazy) a nastavení oprávnění pro databázové objekty (jako jsou tabulky, uložené procedury a pohledy).

To znamená, že se nemusíte učit všechny pokročilé věci, abyste mohli začít s SQL. Dobrá věc na SQL je, že některé z nejběžnějších úloh se píší nejsnáze.

Standard SQL

SQL byl standardizován v ANSI X3.135 v roce 1986 a během několika měsíců byl přijat ISO jako ISO 9075-1987. Mezinárodní norma (nyní ISO/IEC 9075) byla od té doby pravidelně revidována a v současné době existuje v 9 částech.

Většina velkých dodavatelů databází má tendenci dodržovat standard SQL. Dobrá věc na tom je, že se nemusíte učit nový dotazovací jazyk pokaždé, když se učíte nový DBMS.

V praxi však existují rozdíly mezi tím, jak každý dodavatel databáze implementuje standard SQL. Proto kód, který napíšete v jednom DBMS, nemusí vždy fungovat v jiném bez nutnosti úprav.

Dobrou zprávou je, že všechny hlavní DBMS podporují nejběžnější úkoly obecně stejným způsobem.

Výslovnost SQL

SQL se obvykle vyslovuje jedním ze dvou způsobů:

• „ess-que-el “ (tj. hláskovat každé písmeno)
• „pokračování “ (jako v původním pravopisu/výslovnosti).

Pokud vás zajímá proč, podívejte se na Je to vyslovováno S-Q-L nebo Sequel.

Co potřebuji pro tento kurz SQL?

Chcete-li tento výukový program SQL skutečně využít, měli byste postupovat podle příkladů. To znamená, že budete potřebovat někde zadat dotazy SQL. Budete potřebovat něco takového:

Pokud budete spouštět dotazy SQL, budete potřebovat:

• Nainstalovaný RDBMS (jako je SQL Server, MySQL, PostgreSQL, SQLite atd.).
• Databázový nástroj, který vám umožňuje spouštět dotazy SQL proti tomuto RDBMS (jako je MySQL WorkBench, Azure Data Studio (na obrázku), DBeaver a SSMS).

Pokud již máte jeden od každého nainstalovaný, skvělé! Můžete pokračovat v tutoriálu.

Pokud je nemáte nainstalované, přečtěte si článek Co potřebuji ke spuštění SQL? pro pokyny k instalaci RDBMS a příslušného nástroje pro správu databází, než se vrátíte k tomuto SQL tutoriálu.

Vytvořit databázi

Jakmile nainstalujete RDBMS a příslušný databázový nástroj, jste připraveni vytvořit databázi:

CREATE DATABASE PetHotel;

Hotovo!

Toto prohlášení ve skutečnosti vytvořilo databázi. Prázdná databáze, ale přesto databáze.

Tato databáze bude obsahovat tabulky a data použitá v tomto SQL tutoriálu. Když vytvoříme tabulku nebo vložíme data, uděláme to uvnitř této databáze.

Měl bych zmínit, že SQLite používá jinou syntaxi pro vytváření databází. Pokud používáte SQLite, zde je návod, jak vytvořit databázi v SQLite.

Připojte se k databázi

Než začnete vytvářet tabulky, vkládat data a tak dále, musíte si být jisti, že jste ve správné databázi. Vytvoření databáze (jako jsme to právě udělali) vás nutně k této databázi nepřipojí.

V mnoha DBMS (jako je SQL Server , MySQL a MariaDB ), můžeme k přepnutí do zadané databáze použít následující:

USE PetHotel;

To dělá PetHotel aktuální databázi.

V SQLite , pravděpodobně jste již v databázi po jejím vytvoření. Pokud ne, můžete připojit databázi (která ji také vytvoří, pokud ještě neexistuje):

ATTACH DATABASE 'PetHotel.db' AS Pets;

V PostgreSQL , pokud používáte nástroj psql, můžete použít následující:

\connect PetHotel

Nebo zkrácená verze:

\c PetHotel

Měl bych zmínit, že proces vytváření a připojování k databázím se může mezi DBMS značně lišit.

Naštěstí většina nástrojů GUI umožňuje připojení k databázi buď poklepáním na databázi, nebo kliknutím pravým tlačítkem na název databáze a výběrem nové záložky dotazu z kontextové nabídky. Pokud se ocitnete v tomto kroku, stačí použít GUI k vytvoření a/nebo připojení k vaší DB.

Vytvořte tabulku

Nyní, když jste se připojili ke správné databázi, můžete pokračovat a vytvořit nějaké tabulky.

Chcete-li vytvořit tabulku v SQL, použijte CREATE TABLE prohlášení.

Když vytváříte tabulku, musíte určit, jaké sloupce budou v tabulce, a také jejich datové typy. Můžete zadat i další podrobnosti, ale nepředbíhejme.

Vytvoříme tabulku:

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

V tomto případě vytvoříme tabulku s názvem PetTypes . Víme to, protože název tabulky je hned za CREATE TABLE bit.

Poté následuje seznam sloupců uzavřený v závorkách.

Výše uvedená tabulka obsahuje následující sloupce:

• PetIdId
• PetType

Za každým sloupcem následuje jeho datový typ:

• int znamená, že tento sloupec přijímá celá čísla. Pokud je mi známo, většina hlavních DBMS podporuje deklarování sloupců jako int . Pokud máte nějaké problémy, zkuste použít integer .
• varchar(60) znamená, že tento sloupec přijímá řetězce dlouhé až 60 znaků. varchar sloupce jsou řetězce s proměnnou délkou. Jiný datový typ řetězce je char (což je řetězec pevné délky). Pokud máte problémy s definováním sloupce jako varchar(60) , zkuste použít char(60) .

NOT NULL Omezení

V tomto příkladu jsou oba sloupce definovány pomocí NOT NULL omezení. NOT NULL omezení znamená, že tento sloupec nemůže být prázdný. Když je vložen nový řádek, všechny NOT NULL sloupce musí obsahovat hodnotu. Ostatní sloupce mohou zůstat prázdné, pokud pro tyto sloupce nejsou žádná data.

Pokud NULL hodnoty jsou ve sloupci povoleny, můžete buď vynechat NOT NULL část nebo ji deklarujte jako NULL (což znamená NULL hodnoty jsou v tomto sloupci povoleny).

Některé DBMS (například DB2) nepodporují NULL klíčové slovo tak jako tak, a tak ho budete muset při práci s takovými DBMS vynechat.

Primární klíče

Vytvořili jsme také PetTypeId sloupec primární klíč. Primární klíč je jeden nebo více sloupců, které jednoznačně identifikují každý řádek v tabulce. Vybrané sloupce určíte jako primární klíč pomocí omezení primárního klíče. Můžete to udělat v CREATE TABLE (jako jsme to udělali zde), nebo jej můžete přidat později pomocí ALTER TABLE prohlášení.

Primární klíče musí obsahovat jedinečné hodnoty. To znamená, že pro každý řádek v této tabulce musí být hodnota ve sloupcích primárního klíče v každém řádku odlišná. Mohlo by to být tak jednoduché jako zvýšení čísel (jako 1, 2, 3… atd.), nebo to může být kód produktu (jako pr4650, pr2784, pr5981… atd.).

Primární klíče musí také obsahovat hodnotu. Nemůže být NULL .

Ačkoli primární klíče nejsou vyžadovány, obecně se považuje za dobrou praxi definovat primární klíč v každé tabulce.

Vytvořit další tabulky

Vytvoříme další dvě tabulky:

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
);

Obě tyto tabulky jsou podobné té první, až na to, že mají více řádků a pár kusů navíc, což vysvětlím níže.

Pokud máte zájem, podívejte se na SQL CREATE TABLE pro začátečníky, kde najdete několik dalších jednoduchých příkladů vytváření tabulek v SQL.

Vztahy

Když jsme vytvořili naše Pets tabulka, vytvořili jsme vlastně vztah mezi třemi tabulkami.

Tento vztah je znázorněn na následujícím diagramu.

Databázové vztahy jsou klíčovou součástí SQL. Vztahy nám umožňují dotazovat se na související data ve více tabulkách a získávat přesné a konzistentní výsledky.

V našem případě chceme mít možnost vyhledávat domácí mazlíčky podle majitele nebo mazlíčky podle typu zvířete atd. A chceme, aby naše výsledky byly přesné a konzistentní.

Abychom toho dosáhli, musíme trvat na tom, aby všechna domácí zvířata byla zadána spolu s jejich majitelem a typem zvířete. Proto se musíme ujistit, že kdykoli se do Pets přidá nový mazlíček v tabulce Owners již existuje odpovídající vlastník tabulka a odpovídající typ mazlíčka v PetTypes stůl.

V zásadě jsou naše požadavky následující:

• Jakákoli hodnota v Pets.PetTypeId sloupec musí odpovídat hodnotě v PetTypes.PetTypeId sloupec.
• Jakákoli hodnota v Pets.OwnerId sloupec musí odpovídat hodnotě v Owners.OwnerId sloupec.

Výše uvedené požadavky můžeme zajistit vytvořením omezení cizího klíče vůči příslušným sloupcům. Cizí klíč omezení se používá k určení, že určitý sloupec odkazuje na primární klíč jiné tabulky.

Výše uvedený kód skutečně vytvořil dvě omezení cizího klíče na Pets tabulka.

Všimněte si, že PetTypeId a OwnerId sloupce mají nějaký další kód, který začíná REFERENCES... . To jsou části, které vytvořily dva cizí klíče.

Když jsme vytvořili Pets tabulka, její PetTypeId sloupec má bit, který jde REFERENCES PetTypes (PetTypeId) . To znamená, že Pets.PetTypeId sloupec odkazuje na PetTypeId ve sloupci PetTypes tabulka.

Je to stejná nabídka pro OwnerId sloupec. Odkazuje na OwnerId ve sloupci Owners tabulka.

Ve většině DBMS lze cizí klíče vytvořit také na existující tabulce pomocí ALTER TABLE prohlášení, ale tím se zde nebudeme zabývat. Další informace naleznete v části Jak vytvořit vztah v SQL.

Každopádně naše cizí klíče byly vytvořeny. Nyní, kdykoli někdo vloží nového mazlíčka do Pets tabulka PetTypeId a OwnerId hodnoty budou muset mít odpovídající hodnotu v PetTypes a Owners tabulky resp. Pokud některý z nich ne, databáze vrátí chybu.

To je výhoda cizích klíčů. Pomáhá předcházet zadávání špatných dat. Pomáhá udržovat integritu dat a konkrétněji referenční integritu.

Zkontrolujte omezení

Kontrolní omezení je další typ omezení, o kterém byste měli vědět. Kontrolní omezení kontroluje data před jejich vstupem do databáze. Když má tabulka povolenou kontrolní podmínku, data mohou do tabulky vstupovat pouze tehdy, pokud toto omezení neporušují. Data, která porušují omezení, nemohou vstoupit do tabulky.

Můžete například vytvořit kontrolní omezení pro Price aby bylo zajištěno, že přijímá pouze hodnoty větší než nula. Nebo bychom mohli použít kontrolní omezení na naše Pets tabulky, abyste zajistili, že DOB sloupec není v budoucnosti.

Příklad viz Co je omezení KONTROLA?

Mezerník

Možná jste si všimli, že moje příklady obsahují mezery. Kód jsem například rozložil na více řádků a použil jsem tabulátory k odsazení datových typů atd.

To je dokonale platné v SQL. Můžete to udělat bezpečně a neovlivní to výsledek. SQL vám umožňuje rozložit kód na více řádků, pokud chcete, a umožňuje vám používat více mezer nebo tabulátorů pro zlepšení čitelnosti.

Komentáře

Do kódu můžete také zahrnout komentáře. Komentáře mohou být užitečné, jakmile začnete psát delší SQL skripty. Jakmile je skript poměrně dlouhý, komentáře mohou usnadnit rychlou identifikaci toho, co jednotlivé části dělají.

Vložené komentáře

Vložené komentáře můžete vytvořit tak, že před komentář přidáte dva znaky pomlčky (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

V tomto příkladu poběží oba dotazy bez problémů. Komentáře budou DBMS ignorovány.

Víceřádkové komentáře

Komentáře můžete rozložit na více řádků tak, že komentář obklopíte znakem /* a */ :

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

V tomto příkladu poběží oba dotazy bez problémů. Komentáře budou DBMS ignorovány.

MySQL

Pokud používáte MySQL, můžete také použít znak čísla / znak křížku (# ) pro jednořádkové komentáře.

# This is a comment
SELECT * FROM Pets;

Komentování kódu

Další skvělou výhodou komentářů je, že můžete komentovat kód. Pokud máte například dlouhý skript SQL, který dělá mnoho věcí, ale chcete spustit pouze jednu nebo dvě jeho části, můžete přidat komentář zbytek skriptu.

Zde je příklad:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

V tomto případě první SELECT příkaz byl zakomentován, a tak pouze druhý SELECT příkaz se spustí.

Pro tuto techniku ​​můžete také použít víceřádkové komentáře.

Vložit data

Nyní, když jsme vytvořili tři tabulky a vytvořili příslušné cizí klíče, můžeme pokračovat a přidat data.

Nejběžnějším způsobem vkládání dat do SQL je INSERT prohlášení. Zní to nějak takto:

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

Jednoduše nahradíte MyTable s názvem tabulky, do které vkládáte data. Podobně nahradíte Column1 , atd. s názvy sloupců a Value1 atd. s hodnotami, které jdou do těchto sloupců.

Mohli bychom například udělat toto:

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

Každá hodnota je ve stejném pořadí, v jakém je zadán sloupec.

Všimněte si, že názvy sloupců se shodují s názvy, které jsme použili při vytváření tabulky.

Pokud vkládáte data do všech sloupců, můžete názvy sloupců vynechat. Výše uvedený příklad bychom tedy mohli změnit, aby vypadal takto:

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

Pro tento tutoriál přidáme několik dalších řádků, takže přidáme další INSERT INTO příkazy – jeden pro každý řádek, který chceme vložit.

Takže pojďme do toho a naplňte naše stoly.

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' );

Všimněte si, že jsme naplnili Pets poslední stůl. Má to svůj důvod.

Kdybychom zkusili vložit data do Pets před naplněním dalších dvou bychom obdrželi chybu kvůli našemu omezení cizího klíče. A z dobrého důvodu. Koneckonců bychom se snažili vložit hodnoty do sloupců cizího klíče, které ještě neexistovaly ve sloupcích primárního klíče v ostatních tabulkách. To je velké „ne ne“, pokud jde o cizí klíče.

Tedy vyplněním Owners a PetTypes Nejprve jsme se ujistili, že příslušné hodnoty již byly ve sloupcích primárního klíče, než jsme naplnili sloupce cizího klíče v Pets tabulka.

Další příklady vkládání dat do tabulek naleznete v tématu SQL INSERT pro začátečníky.

Zkontrolujte naše údaje

Fuj! Konečně můžeme začít spouštět dotazy na naši databázi.

Pojďme zkontrolovat data ve všech našich tabulkách.

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

Výsledek:

+---------+-------------+-----------+-----------+------------+
| 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)

Skvělé, takže to vypadá, že data byla úspěšně vložena.

Vyberte konkrétní sloupce

Obecně se považuje za špatný postup vybrat z tabulky všechny řádky a všechny sloupce (jako jsme to udělali v předchozím příkladu), pokud to opravdu nepotřebujete. To může mít dopad na výkon vašeho databázového serveru, zvláště pokud je v tabulce mnoho řádků.

Není to problém, když používáte malé datové sady, jako jsme my, nebo když jste ve vývojovém prostředí nebo podobně. Jinak je obvykle lepší vybrat pouze sloupce, které požadujete.

Pokud bychom tedy chtěli ID, jména a data narození všech domácích mazlíčků, mohli bychom udělat toto:

SELECT PetId, PetName, DOB 
FROM Pets; 

Výsledek:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

Pokud bychom chtěli ID a datum narození všech mazlíčků jménem Fluffy, mohli bychom použít toto:

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

Výsledek:

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

Můžete také použít SELECT příkaz vrátit data bez tabulky. To znamená, že může vrátit data, která nejsou uložena v tabulce. Viz SQL SELECT Prohlášení pro začátečníky, aby viděli příklad.

Řazení

SQL poskytuje ORDER BY klauzule, která nám umožňuje třídit data.

Můžeme přidat ORDER BY klauzule k našemu dřívějšímu příkladu, takže mazlíčci jsou seřazeni podle jejich jmen:

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

Výsledek:

+---------+-----------+------------+
| 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 část znamená vzestupně . Když použijete ORDER BY klauzule, výchozí je vzestupná, takže můžete vynechat ASC část, chcete-li.

Chcete-li jej seřadit sestupně při objednávce použijte DESC .

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

Výsledek:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

Výsledky můžete také seřadit pomocí více sloupců. Seřadí se podle prvního zadaného sloupce, a pokud jsou v tomto sloupci nějaké duplikáty, seřadí je podle druhého zadaného sloupce a tak dále.

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

Výsledek:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

Podívejte se, jak si dva Fluffyové vyměnili své pozice.

Pokud nepoužijete ORDER BY klauzule, neexistuje žádná záruka, v jakém pořadí budou vaše výsledky. I když to může vypadat jako vaše databáze řadí výsledky podle konkrétního sloupce, nemusí tomu tak být. Obecně platí, že bez ORDER BY klauzule, budou data seřazeny v pořadí, v jakém byla načtena do tabulky. Pokud však byly řádky smazány nebo aktualizovány, bude pořadí ovlivněno tím, jak systém DBMS znovu využívá uvolněný úložný prostor.

Proto se nespoléhejte na to, že DBMS seřadí výsledky v nějakém smysluplném pořadí.

Sečteno a podtrženo:Pokud chcete, aby byly vaše výsledky seřazeny, použijte ORDER BY .

Viz SQL ORDER BY Další příklady naleznete v doložce pro začátečníky.

Počítání řádků v sadě výsledků

Můžete použít COUNT() agregační funkce pro počítání řádků, které budou vráceny v dotazu.

SELECT COUNT(*) AS Count
FROM Pets;

Výsledek:

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

To nám říká, že v tabulce je 8 řádků. Víme to, protože jsme vybrali všechny řádky a všechny sloupce.

Můžete použít COUNT() na jakýkoli dotaz, například na dotazy, které používají WHERE klauzule pro filtrování výsledků.

Můžete také určit konkrétní sloupec, který se má počítat. COUNT() funkce počítá pouze jiné než NULL výsledky, takže pokud zadáte sloupec, který obsahuje NULL hodnoty, tyto hodnoty se nebudou počítat.

Zde je příklad, který demonstruje, co tím myslím.

SELECT COUNT(DOB) AS Count
FROM Pets;

Výsledek:

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

Možná si vzpomínáte, že Pets tabulka obsahuje dvě NULL hodnoty v DOB sloupec (dva domácí mazlíčci neuvedli své datum narození), a tak COUNT(DOB) vrátí 6 místo 8, když jsme použili COUNT(*) . Důvod COUNT(*) vrátil všechny řádky, protože tyto dva řádky dělaly mít data v ostatních sloupcích.

V mém příkladu můj DBMS také vrátil varování o tomto. V závislosti na vaší DBMS a vaší konkrétní konfiguraci se může nebo nemusí zobrazit varování.

Viz SQL COUNT pro začátečníky, kde najdete další příklady.

Mezi další agregační funkce patří:AVG() , SUM() , MIN() a MAX() .

Seskupit podle

Další užitečnou klauzulí je GROUP BY doložka. To dělá to, co slibuje jeho název. Umožňuje seskupit výsledky podle daného sloupce.

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

Výsledek:

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

V tomto příkladu počítáme, kolik domácích mazlíčků máme pro každý typ mazlíčka, a pak je seřadíme v sestupném pořadí (s nejvyšším počtem nahoře).

Viz SQL GROUP BY Další příklady naleznete v doložce pro začátečníky.

Položka HAVING Ustanovení

Můžeme použít HAVING klauzule k filtrování výsledků v GROUP BY doložka. HAVING klauzule vrátí řádky, kde agregované hodnoty splňují zadané podmínky.

Zde je příklad.

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

Výsledek:

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

V tomto případě jsme vrátili data pouze pro typy domácích mazlíčků, které mají k tomuto typu přiřazeny více než 2 domácí mazlíčky.

Viz SQL HAVING Další příklady naleznete v doložce pro začátečníky.

Připojuje se

V SQL připojení je místo, kde spustíte dotaz, který kombinuje data z více tabulek.

Předchozí dva příklady jsou v pořádku, ale bylo by lepší, kdyby vracely skutečné typy domácích mazlíčků (např. kočka, pes, pták atd.), nikoli ID (např. 1, 2, 3 atd.).

Jediný problém je, Pets tabulka tato data neobsahuje. Tato data jsou v PetTypes tabulka.

Naštěstí pro nás můžeme tyto dvě tabulky spojit. Zde je příklad, který používá 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;

Výsledek:

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

Tato sada výsledků je mnohem snáze čitelná než předchozí. Je snazší porozumět tomu, kolik jednotlivých typů zvířat je v tabulce.

Syntaxe používá typ spojení (v tomto případě LEFT JOIN ), za kterou následuje první (levá) tabulka a za ní ON , za kterým následuje podmínka spojení.

Použijme INNER JOIN vrátit všechna jména zvířat s příslušnými typy zvířat.

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

Výsledek:

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

Spojení skutečně otevírají naše možnosti, protože nyní můžeme získat data z více tabulek a prezentovat je, jako by to byla jedna tabulka.

Všimnete si, že v příkladech spojení kvalifikujeme názvy sloupců s názvy tabulek. Důvodem, proč to děláme, je vyhnout se jakékoli nejednoznačnosti ohledně názvů sloupců mezi tabulkami. Obě tabulky mohou mít sloupce se stejným názvem (jako v našem příkladu) a v takových případech DBMS nebude vědět, na který sloupec odkazujete. Přidání názvů sloupců před názvy jejich tabulek zajistí, že odkazujete na správný sloupec, a zabráníte jakýmkoli chybám, které by mohly vzniknout v důsledku nejasností ohledně toho, na který sloupec odkazujete.

Další příklady a vysvětlení různých typů spojení najdete v mém výukovém programu SQL Joins.

Aliasy

Můžeme jít o krok dále a přiřadit alias ke každému názvu tabulky a názvu sloupce.

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

Výsledek:

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

Výsledkem jsou nová záhlaví sloupců a kód je stručnější.

Alias ​​umožňuje dočasně přiřadit jiný název tabulce nebo sloupci po dobu SELECT dotaz. To může být užitečné zejména v případě, že tabulky a/nebo sloupce mají velmi dlouhé nebo složité názvy.

Alias ​​je přiřazen pomocí AS klíčové slovo, ačkoli je toto klíčové slovo nepovinné, takže jej můžete bezpečně vynechat. Všimněte si, že Oracle nepodporuje AS klíčové slovo na aliasech tabulky (ale dělá to na aliasech sloupců).

Ve výše uvedeném příkladu jsem zahrnul AS klíčové slovo při přiřazování aliasů sloupců, ale při přiřazování aliasů tabulky je vynechali.

Název aliasu může být jakýkoli, ale obvykle je z důvodu čitelnosti krátký.

V našem případě jsme změnili dvě tabulky na p a pt a názvy sloupců Pet a Pet Type . Všimněte si, že jsem obklopil Pet Type ve dvojitých uvozovkách. Udělal jsem to, protože v názvu je mezera. U aliasů bez mezer to nemusíte dělat. V SQL Server můžete alternativně použít hranaté závorky ([] ) místo dvojitých uvozovek (ačkoli také podporuje dvojité uvozovky).

The practice of using spaces in columns and aliases is generally discouraged, as it can cause all sorts of problems with some client applications.

Note that we still needed to use the full column names when referencing them in the join (after the ON keyword).

Měl bych zdůraznit, že přiřazení aliasu ve skutečnosti nepřejmenuje sloupec nebo tabulku.

See SQL Alias Explained for more examples.

Updating Data

You can use the UPDATE statement to update data in your tables.

The basic syntax is pretty simple:

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

In that example, we update the LastName column to have a new value of Stallone where the OwnerId is 3 .

To update multiple columns, use a comma to separate each column/value pair.

But whatever you do, don’t forget the WHERE clause (unless you actually intend to update every row in the table with the same value).

See SQL UPDATE for Beginners for more examples and a more detailed explanation.

Deleting Data

You can use the DELETE statement to delete data from your tables.

The basic syntax is even more simple than the UPDATE prohlášení:

DELETE FROM Owners
WHERE OwnerId = 5;

Here, we’re deleting owner number 5 from the Owners tabulka.

As with the UPDATE statement, don’t forget the WHERE clause (unless you intend to delete every row in the table ).

See SQL DELETE for Beginners for more examples and a detailed explanation.

Dropping Objects

While we’re on the subject of deleting things, when you delete a database object (such as a table, view, stored procedure, etc), it’s said that you “drop” that object. For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:

DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

SQL Operators

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. The data items are called operands or arguments . 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 syntaxe.

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.

Výsledek:

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 doložka.

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;

Výsledek:

+-----------+---------+
| 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 prohlášení. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL prohlášení.

EXEC uspGetPetById @PetId = 3;

Výsledek:

+-----------+------------+-----------+-------------+
| 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 , or DELETE prohlášení.

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.

Když transakce provede více změn v databázi, buď budou všechny změny úspěšné, když je transakce potvrzena, nebo se všechny změny vrátí zpět, když je transakce odvolána.

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 

Do této transakce můžete napsat podmíněnou logiku, která transakci vrátí zpět, pokud se něco pokazí.

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