SQL tutorial for begyndere

I denne SQL-tutorial for begyndere vil du oprette din egen database, indsætte data i databasen og derefter køre forespørgsler mod databasen.

Denne SQL-tutorial får dig til at køre SQL-forespørgsler på ingen tid!

SQL-eksempel

Her er et eksempel på en SQL-sætning:

SELECT * 
FROM Pets;

Dette er et perfekt eksempel på, hvor nemt det kan være at skrive SQL. Denne simple SQL-sætning gør faktisk meget. Det returnerer hele bordet. Det returnerer alle kolonner og alle rækker fra tabellen kaldet Pets .

Stjernen (* ) er et jokertegn, som betyder "alle kolonner". Det er en hurtig og nem måde at få alle kolonner på uden at skulle skrive dem alle ud.

Det er en af de smukke ting ved SQL. De enkleste SQL-forespørgsler er normalt de mest kraftfulde. Hvis vi ville returnere færre data, ville vi faktisk skulle skrive mere .

For eksempel, hvis vi kun ville have kæledyr med navnet Fetch , ville vi tilføje en WHERE klausul, der fastsatte dette krav.

Sådan:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE klausul filtrerer vores forespørgsel til kun de rækker, hvor PetName kolonne har værdien Fetch .

Denne forespørgsel antager, at der er en kolonne kaldet PetName og en tabel kaldet Pets i databasen.

I denne SQL-tutorial viser jeg dig, hvordan du opretter en sådan database ved hjælp af SQL.

Jeg vil også vise dig, hvordan du indsætter data i databasen, opdaterer data, sletter data og kører forespørgsler mod den.

Hvad er SQL?

SQL er et akronym for Structured Query Language.

SQL er standard forespørgselssprog, der bruges til at arbejde med relationelle databaser.

SQL bruges af alle de store relationelle databasestyringssystemer (RDBMS), herunder:

Microsoft Access
SQL-server
Oracle
PostgreSQL
MySQL
SQLite

Hvad kan jeg gøre med SQL?

Du kan bruge SQL til at køre forespørgsler mod en database, indsætte poster, opdatere poster og slette poster. Du kan også oprette nye databaseobjekter såsom databaser og tabeller. Du kan også udføre databaseadministrationsopgaver, såsom oprettelse af logins, automatiserede job, databasesikkerhedskopiering og meget mere.

Selv når du laver ting ved hjælp af en grafisk brugergrænseflade (GUI), vil dit databasestyringssystem (DBMS) næsten helt sikkert bruge SQL bag kulisserne til at udføre denne opgave.

For eksempel, når du opretter en database ved at klikke på Opret database og indtaste detaljerne for den nye database i en dialogboks, når du klikker på OK eller Opret eller hvad knappen end lyder, vil dit databasesystem bruge SQL CREATE DATABASE sætning for at gå videre og oprette databasen som specificeret.

Det samme gælder for andre opgaver, såsom at køre forespørgsler, indsætte data osv.

SQL giver dig også mulighed for at udføre mere avancerede handlinger, såsom oprettelse af lagrede procedurer (selv-indeholdende scripts), visninger (forudarbejdede forespørgsler) og indstilling af tilladelser til databaseobjekter (såsom tabeller, lagrede procedurer og visninger).

Når det er sagt, behøver du ikke at lære alle de avancerede ting for at komme i gang med SQL. Det gode ved SQL er, at nogle af de mest almindelige opgaver er de nemmeste at skrive.

SQL Standard

SQL blev standardiseret i ANSI X3.135 i 1986, og i løbet af få måneder blev det vedtaget af ISO som ISO 9075-1987. Den internationale standard (nu ISO/IEC 9075) er blevet revideret med jævne mellemrum lige siden, og den findes i øjeblikket i 9 dele.

De fleste større databaseleverandører har en tendens til at overholde SQL-standarden. Det gode ved det er, at du ikke behøver at lære et nyt forespørgselssprog, hver gang du lærer et nyt DBMS.

I praksis er der dog variationer mellem, hvordan hver databaseleverandør implementerer SQL-standarden. Derfor fungerer kode, som du skriver i et DBMS, muligvis ikke altid i et andet uden behov for ændringer.

Den gode nyhed er, at alle større DBMS'er understøtter de mest almindelige opgaver på generelt samme måde.

SQL-udtale

SQL udtales typisk på en af to måder:

“ess-que-el ” (dvs. stave hvert bogstav)
“efterfølger ” (som i den oprindelige stavemåde/udtale).

Se Er det udtalt S-Q-L eller Sequel, hvis du undrer dig over hvorfor.

Hvad skal jeg bruge til dette SQL-tutorial?

For virkelig at drage fordel af denne SQL-tutorial, bør du følge eksemplerne. Det betyder, at du skal bruge et sted for at indtaste SQL-forespørgslerne. Du skal have noget som dette:

Hvis du skal køre SQL-forespørgsler, skal du bruge:

En RDBMS installeret (såsom SQL Server, MySQL, PostgreSQL, SQLite osv.).
Et databaseværktøj, der giver dig mulighed for at køre SQL-forespørgsler mod det pågældende RDBMS (såsom MySQL WorkBench, Azure Data Studio (billedet), DBeaver og SSMS).

Hvis du allerede har en af hver installeret, fantastisk! Du kan fortsætte med selvstudiet.

Hvis du ikke har disse installeret, se Hvad skal jeg bruge for at køre SQL? for instruktioner om installation af et RDBMS og dets relevante databasestyringsværktøj, før du vender tilbage til denne SQL-øvelse.

Opret en database

Når du har installeret dit RDBMS og det relevante databaseværktøj, er du klar til at oprette en database:

CREATE DATABASE PetHotel;

Færdig!

Den erklæring skabte faktisk en database. En tom database, men en database ikke desto mindre.

Denne database vil indeholde de tabeller og data, der bruges i denne SQL-øvelse. Når vi opretter en tabel eller indsætter data, vil vi gøre det i denne database.

Jeg bør nævne, at SQLite bruger en anden syntaks til at oprette databaser. Hvis du bruger SQLite, her er, hvordan du opretter en database i SQLite.

Opret forbindelse til databasen

Før du begynder at oprette tabeller, indsætte data og så videre, skal du være sikker på, at du er i den rigtige database. Oprettelse af en database (som vi lige har gjort) forbinder dig ikke nødvendigvis med den database.

I mange DBMS'er (såsom SQL Server , MySQL og MariaDB ), kan vi bruge følgende til at skifte over til den angivne database:

USE PetHotel;

Det gør PetHotel den aktuelle database.

I SQLite , er du sandsynligvis allerede i databasen efter at have oprettet den. Hvis ikke, kan du vedhæfte databasen (som også vil oprette den, hvis den ikke allerede eksisterer):

ATTACH DATABASE 'PetHotel.db' AS Pets;

I PostgreSQL , hvis du bruger psql-værktøjet, kan du bruge følgende:

\connect PetHotel

Eller den forkortede version:

\c PetHotel

Jeg bør nævne, at processen med at oprette og oprette forbindelse til databaser kan variere meget mellem DBMS'er.

Heldigvis lader de fleste GUI-værktøjer dig oprette forbindelse til en database ved enten at dobbeltklikke på databasen eller ved at højreklikke på databasenavnet og vælge en ny forespørgselsfane fra kontekstmenuen. Hvis du finder dig selv fast i dette trin, skal du bare bruge GUI'en til at oprette og/eller oprette forbindelse til din DB.

Opret en tabel

Nu hvor du har oprettet forbindelse til den rigtige database, kan du gå videre og oprette nogle tabeller.

For at oprette en tabel i SQL skal du bruge CREATE TABLE erklæring.

Når du opretter en tabel, skal du angive, hvilke kolonner der skal være i tabellen, samt deres datatyper. Du kan også angive andre detaljer, men lad os ikke komme os selv foran.

Lad os oprette en tabel:

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

I dette tilfælde opretter vi en tabel kaldet PetTypes . Vi ved det, fordi tabelnavnet kommer umiddelbart efter CREATE TABLE lidt.

Derefter kommer en liste over kolonner, omsluttet i parentes.

Ovenstående tabel indeholder følgende kolonner:

PetIdId
PetType

Hver kolonne efterfølges af dens datatype:

int betyder, at denne kolonne accepterer heltal. Så vidt jeg ved, understøtter de fleste større DBMS'er at erklære kolonner som int . Hvis du har problemer, så prøv at bruge integer .
varchar(60) betyder, at denne kolonne accepterer strenge på op til 60 tegn. varchar kolonner er strenge med variabel længde. En anden strengdatatype er char (som er en streng med fast længde). Hvis du har problemer med at prøve at definere en kolonne som varchar(60) , prøv at bruge char(60) .

`NOT NULL` Begrænsninger

I dette eksempel er begge kolonner defineret med NOT NULL begrænsninger. NOT NULL begrænsning betyder, at denne kolonne ikke må være tom. Når en ny række indsættes, vil enhver NOT NULL kolonner skal indeholde en værdi. Andre kolonner kan forblive tomme, hvis der ikke er data for disse kolonner.

Hvis NULL værdier er tilladt i kolonnen, kan du enten udelade NOT NULL del, eller erklær den som NULL (betyder NULL værdier er tilladt i denne kolonne).

Nogle DBMS'er (såsom DB2) understøtter ikke NULL søgeord alligevel, og du bliver derfor nødt til at udelade det, når du arbejder med sådanne DBMS'er.

Primære nøgler

Vi har også lavet PetTypeId kolonne den primære nøgle. Den primære nøgle er en eller flere kolonner, der unikt identificerer hver række i tabellen. Du angiver dine valgte kolonner som primærnøgle ved at bruge en primærnøglebegrænsning. Du kan gøre dette i CREATE TABLE sætning (som vi gjorde her), eller du kan tilføje en senere med en ALTER TABLE udmelding.

Primære nøgler skal indeholde unikke værdier. Det vil sige, at for hver række i den tabel skal værdien i primærnøglekolonnen/-erne være forskellig i hver række. Dette kunne være så simpelt som at have stigende tal (som 1, 2, 3... osv.), eller det kunne være en produktkode (som pr4650, pr2784, pr5981... osv.).

Primære nøgler skal også indeholde en værdi. Det kan ikke være NULL .

Selvom primærnøgler ikke er påkrævet, anses det generelt for at være god praksis at definere en primærnøgle på hver tabel.

Opret flere tabeller

Lad os oprette to tabeller mere:

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

Begge disse tabeller ligner den første, bortset fra at de har flere rækker og et par ekstra stykker, som jeg vil forklare nedenfor.

Hvis du er interesseret, så tjek SQL CREATE TABLE for begyndere for et par flere simple eksempler på oprettelse af tabeller i SQL.

Relationer

Da vi oprettede vores Pets tabel, skabte vi faktisk en relation mellem de tre tabeller.

Dette forhold er afbildet i følgende diagram.

Databaserelationer er en afgørende del af SQL. Relationer giver os mulighed for at forespørge flere tabeller for relaterede data og få nøjagtige og konsistente resultater.

I vores tilfælde ønsker vi at kunne søge efter kæledyr efter ejer eller kæledyr efter kæledyrstype osv. Og vi ønsker, at vores resultater skal være nøjagtige og konsistente.

For at opnå dette er vi nødt til at insistere på, at alle kæledyr indtastes sammen med deres ejer og kæledyrstype. Derfor er vi nødt til at sikre, at når et nyt kæledyr føjes til Pets tabellen, er der allerede en tilsvarende ejer i Owners tabel og en tilsvarende kæledyrstype i PetTypes bord.

Grundlæggende er vores krav som følger:

Enhver værdi i Pets.PetTypeId kolonnen skal matche en værdi i PetTypes.PetTypeId kolonne.
Enhver værdi i Pets.OwnerId kolonnen skal matche en værdi i Owners.OwnerId kolonne.

Vi kan sikre ovenstående krav ved at oprette en fremmednøgle-begrænsning mod de gældende kolonner. En fremmednøgle begrænsning bruges til at angive, at en bestemt kolonne refererer til den primære nøgle i en anden tabel.

Ovenstående kode skabte faktisk to fremmednøglebegrænsninger på Pets tabel.

Bemærk, at PetTypeId og OwnerId kolonner har en ekstra kode, der starter med REFERENCES... . Det er de dele, der skabte de to fremmednøgler.

Da vi oprettede Pets tabel, dens PetTypeId kolonne har en bit, der går REFERENCES PetTypes (PetTypeId) . Det betyder, at Pets.PetTypeId kolonne refererer til PetTypeId kolonnen i PetTypes tabel.

Det er den samme aftale for OwnerId kolonne. Det refererer til OwnerId kolonne i Owners tabel.

I de fleste DBMS'er kan fremmednøgler også oprettes på en eksisterende tabel ved at bruge ALTER TABLE udtalelse, men det vil vi ikke gå over her. Se Sådan opretter du et forhold i SQL for mere om det.

Under alle omstændigheder er vores fremmednøgler blevet oprettet. Nu, hver gang nogen indsætter et nyt kæledyr i Pets tabellen, PetTypeId og OwnerId værdier skal have en tilsvarende værdi i PetTypes og Owners tabeller hhv. Hvis nogen af dem ikke gør det, vil databasen returnere en fejl.

Dette er fordelen ved fremmednøgler. Det hjælper med at forhindre, at der indtastes dårlige data. Det hjælper med at bevare dataintegriteten og mere specifikt referentiel integritet.

Tjek begrænsninger

En kontrolbegrænsning er en anden begrænsningstype, du bør være opmærksom på. En kontrolbegrænsning kontrollerer data, før de kommer ind i databasen. Når en tabel har en kontrolbegrænsning aktiveret, kan data kun komme ind i tabellen, hvis de ikke overtræder denne begrænsning. Data, der overtræder begrænsningen, kan ikke komme ind i tabellen.

For eksempel kan du oprette en kontrolbegrænsning på en Price kolonne for at sikre, at den kun accepterer værdier, der er større end nul. Eller vi kunne anvende en kontrolbegrænsning på vores Pets tabel for at sikre, at DOB kolonne er ikke i fremtiden.

For et eksempel, se Hvad er en CHECK-begrænsning?

Whitespace

Du har måske bemærket, at mine eksempler inkluderer mellemrum. For eksempel har jeg fordelt koden på tværs af flere linjer, og jeg har brugt faner til at indrykke datatyperne osv.

Dette er helt gyldigt i SQL. Du kan roligt gøre dette, og det vil ikke påvirke resultatet. SQL giver dig mulighed for at sprede din kode på tværs af flere linjer, hvis du ønsker det, og det giver dig mulighed for at bruge flere mellemrum eller tabulatorer for at forbedre læsbarheden.

Kommentarer

Du kan også inkludere kommentarer i din kode. Kommentarer kan være praktiske, når du begynder at skrive længere SQL-scripts. Når et script bliver ret langt, kan kommentarer gøre det nemmere hurtigt at identificere, hvad hver del gør.

Inline kommentarer

Du kan oprette indlejrede kommentarer ved at sætte to bindestregstegn foran din kommentar (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

I dette eksempel vil begge forespørgsler køre uden problemer. Kommentarerne vil blive ignoreret af DBMS.

Kommentarer med flere linjer

Du kan sprede kommentarer over flere linjer ved at omgive kommentaren med /* og */ :

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

I dette eksempel vil begge forespørgsler køre uden problemer. Kommentarerne vil blive ignoreret af DBMS.

MySQL

Hvis du bruger MySQL, kan du også bruge taltegnet/hash-tegnet (# ) for enkeltlinjekommentarer.

# This is a comment
SELECT * FROM Pets;

Kommenter kode

En anden cool fordel ved kommentarer er, at du kan kommentere ud kode. For eksempel, hvis du har et langt SQL-script, der gør mange ting, men du kun vil køre en eller to dele af det, kan du kommentere ud resten af scriptet.

Her er et eksempel:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

I dette tilfælde, den første SELECT sætningen er blevet kommenteret ud, og derfor er kun den anden SELECT erklæring vil køre.

Du kan også bruge flere linjers kommentarer til denne teknik.

Indsæt data

Nu hvor vi har oprettet tre tabeller og oprettet de passende fremmednøgler, kan vi gå videre og tilføje data.

Den mest almindelige måde at indsætte data i SQL er med INSERT udmelding. Det lyder sådan her:

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

Du erstatter blot MyTable med navnet på den tabel, du indsætter data i. Ligeledes erstatter du Column1 osv. med kolonnenavnene og Value1 osv. med de værdier, der går ind i disse kolonner.

For eksempel kunne vi gøre dette:

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

Hver værdi er i samme rækkefølge, som kolonnen er angivet.

Bemærk, at kolonnenavnene matcher de navne, vi brugte, da vi oprettede tabellen.

Du kan udelade kolonnenavnene, hvis du indsætter data i alle kolonner. Så vi kunne ændre ovenstående eksempel til at se sådan ud:

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

Til denne øvelse tilføjer vi en del flere rækker, så vi tilføjer flere INSERT INTO udsagn – en for hver række, vi ønsker at indsætte.

Så lad os gå videre og udfylde vores tabeller.

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

Bemærk, at vi har udfyldt Pets bord sidst. Det er der en grund til.

Hvis vi havde forsøgt at indsætte data i Pets tabel, før vi udfyldte de to andre, ville vi have modtaget en fejl på grund af vores fremmednøglebegrænsning. Og med god grund. Vi ville trods alt have forsøgt at indsætte værdier i de fremmednøglekolonner, der endnu ikke eksisterede i de primære nøglekolonner på de andre tabeller. Det er et stort "nej nej", når det kommer til fremmednøgler.

Så ved at udfylde Owners og PetTypes tabeller først, sikrede vi, at de relevante værdier allerede var i primærnøglekolonnerne, før vi udfyldte fremmednøglekolonnerne i Pets tabel.

Se SQL INSERT for begyndere for flere eksempler på indsættelse af data i tabeller.

Tjek vores data

Pyha! Endelig kan vi begynde at køre forespørgsler mod vores database.

Lad os tjekke dataene i alle vores tabeller.

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

Resultat:

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

Fantastisk, så det ser ud til, at dataene er blevet indsat.

Vælg specifikke kolonner

Det anses generelt for dårlig praksis at vælge alle rækker og alle kolonner fra en tabel (som vi gjorde i det forrige eksempel), medmindre du virkelig har brug for det. At gøre dette kan påvirke ydeevnen af din databaseserver, især hvis der er mange rækker i tabellen.

Det er ikke et problem, når du bruger små datasæt, som vi er her, eller hvis du er i et udviklingsmiljø eller lignende. Ellers er det normalt bedre at vælge netop de kolonner, du har brug for.

Derfor, hvis vi ville have ID'er, navne og fødselsdatoer for alle kæledyr, kunne vi gøre dette:

SELECT PetId, PetName, DOB 
FROM Pets;

Resultat:

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

Hvis vi ville have ID'erne og fødselsdatoen for alle kæledyr ved navn Fluffy, kunne vi bruge dette:

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

Resultat:

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

Du kan også bruge SELECT erklæring for at returnere data uden tabel. Det vil sige, at den kan returnere data, der ikke er gemt i en tabel. Se SQL SELECT Erklæring til begyndere for at se et eksempel.

Sortering

SQL giver ORDER BY klausul, der gør det muligt for os at sortere data.

Vi kan tilføje en ORDER BY klausul til vores tidligere eksempel, så kæledyrene er sorteret efter deres navne:

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

Resultat:

+---------+-----------+------------+
| 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 del betyder stigende . Når du bruger ORDER BY klausul, er den standard til stigende, så du kan udelade ASC del, hvis du ønsker det.

For at sortere det i faldende rækkefølge, brug DESC .

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

Resultat:

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

Du kan også sortere resultaterne ved hjælp af flere kolonner. Det vil sortere efter den første kolonne specificeret, hvis der er nogen dubletter i den kolonne, vil den sortere disse dubletter efter den anden kolonne specificeret, og så videre.

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

Resultat:

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

Se, hvordan de to Fluffys har byttet deres position.

Hvis du ikke bruger ORDER BY klausul, er der ingen garanti for, hvilken rækkefølge dine resultater vil være i. Selvom det kan se ud Ligesom din database sorterer resultaterne efter en bestemt kolonne, er dette muligvis ikke tilfældet. Generelt uden en ORDER BY klausul, vil data blive sorteret i den rækkefølge, som de blev indlæst i tabellen. Men hvis rækker er blevet slettet eller opdateret, vil rækkefølgen blive påvirket af, hvordan DBMS genbruger genvundet lagerplads.

Stol derfor ikke på, at DBMS sorterer resultaterne i nogen meningsfuld rækkefølge.

Nederste linje:Hvis du ønsker, at dine resultater skal sorteres, skal du bruge ORDER BY .

Se SQL ORDER BY Klausul for begyndere for flere eksempler.

Tæl rækkerne i et resultatsæt

Du kan bruge COUNT() aggregatfunktion til at tælle de rækker, der returneres i en forespørgsel.

SELECT COUNT(*) AS Count
FROM Pets;

Resultat:

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

Dette fortæller os, at der er 8 rækker i tabellen. Vi ved det, fordi vi valgte alle rækker og alle kolonner.

Du kan bruge COUNT() på enhver forespørgsel, for eksempel forespørgsler, der bruger en WHERE klausul for at filtrere resultaterne.

Du kan også angive en bestemt kolonne, der skal tælles. COUNT() funktion tæller kun ikke-NULL resultater, så hvis du angiver en kolonne, der indeholder NULL værdier, vil disse værdier ikke blive talt med.

Her er et eksempel for at vise, hvad jeg mener.

SELECT COUNT(DOB) AS Count
FROM Pets;

Resultat:

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

Du husker måske, at Pets tabel indeholder to NULL værdier i DOB kolonne (to kæledyr har ikke oplyst deres fødselsdato), og så COUNT(DOB) returnerer 6 i stedet for 8, når vi brugte COUNT(*) . Årsagen COUNT(*) returnerede alle rækker, fordi de to rækker gjorde har data i de andre kolonner.

I mit eksempel returnerede mit DBMS også en advarsel om dette. Du kan muligvis ikke få en advarsel, afhængigt af dit DBMS og din specifikke konfiguration.

Se SQL COUNT for begyndere for flere eksempler.

Andre aggregerede funktioner omfatter:AVG() , SUM() , MIN() , og MAX() .

Gruppér efter

En anden nyttig klausul er GROUP BY klausul. Dette gør stort set, hvad navnet lover. Det giver dig mulighed for at gruppere resultaterne efter en given kolonne.

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

Resultat:

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

I dette eksempel tæller vi, hvor mange kæledyr vi har for hver kæledyrstype, og sorterer det derefter i faldende rækkefølge (med det højeste antal øverst).

Se SQL GROUP BY Klausul for begyndere for flere eksempler.

`HAVING` Klausul

Vi kan bruge koden HAVING klausul for at filtrere resultaterne i GROUP BY klausul. HAVING klausul returnerer rækker, hvor aggregerede værdier opfylder specificerede betingelser.

Her er et eksempel.

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

Resultat:

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

I dette tilfælde returnerede vi data for kun de kæledyrstyper, der har mere end 2 kæledyr tildelt den type.

Se SQL HAVING Klausul for begyndere for flere eksempler.

Deltager

I SQL, en join er, hvor du kører en forespørgsel, der kombinerer data fra flere tabeller.

De foregående to eksempler er OK, men de ville være bedre, hvis de returnerede de faktiske kæledyrstyper (f.eks. kat, hund, fugl osv.) i stedet for ID'et (f.eks. 1, 2, 3 osv.).

Det eneste problem er, Pets tabel indeholder ikke disse data. Disse data er i PetTypes tabel.

Heldigvis for os kan vi lave en sammenføjning mellem disse to borde. Her er et eksempel, der bruger en 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;

Resultat:

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

Dette resultatsæt er meget lettere at læse end de foregående. Det er nemmere at forstå, hvor mange af hver kæledyrstype der er i tabellen.

Syntaksen bruger jointypen (i dette tilfælde LEFT JOIN ), efterfulgt af den første (venstre) tabel efterfulgt af ON , efterfulgt af join-betingelsen.

Lad os bruge en INNER JOIN for at returnere alle kæledyrsnavne med deres respektive kæledyrstyper.

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

Resultat:

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

Joins really open up our options, because we can now grab data from multiple tables and present it as if it were a single table.

You’ll notice that in the join examples, we qualify our column names with the table names. The reason we do this is to avoid any ambiguity regarding the column column names between the tables. Both tables could have columns of the same name (like in our example), and in such cases, the DBMS won’t know which column you’re referring to. Prefixing the column names with their table names ensures that you’re referencing the right column, and prevents any errors that could result from any ambiguity about which column you’re referring to.

See my SQL Joins Tutorial for more examples and an explanation of the various join types.

Aliases

We can go a step further and assign an alias to each table name and column name.

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

Resultat:

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

This has resulted in new column headers, plus the code is more concise.

An alias allows you to temporarily assign another name to a table or column for the duration of a SELECT query. This can be particularly useful when tables and/or columns have very long or complex names.

An alias is assigned through the use of the AS keyword, although this keyword is optional, so you can safely omit it. Note that Oracle doesn’t support the AS keyword on table aliases (but it does on column aliases).

In the above example, I’ve included the AS keyword when assigning the column aliases, but omitted it when assigning the table aliases.

An alias name could be anything, but is usually kept short for readability purposes.

In our case, we changed the two tables to p and pt , and the column names to Pet and Pet Type . Note that I surrounded Pet Type in double quotes. I did this, because there’s a space in the name. For aliases without spaces, you don’t need to do this. In SQL Server, you can alternatively use square brackets ([] ) instead of double quotes (although it also supports double quotes).

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

I should point out that assigning an alias does not actually rename the column or table.

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 statement:

DELETE FROM Owners
WHERE OwnerId = 5;

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

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 syntax.

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.

Resultat:

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 klausul.

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;

Resultat:

+-----------+---------+
| 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 udmelding. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL erklæring.

EXEC uspGetPetById @PetId = 3;

Resultat:

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

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 tutorial for begyndere

SQL-eksempel

Hvad er SQL?

Hvad kan jeg gøre med SQL?

SQL Standard

SQL-udtale

Hvad skal jeg bruge til dette SQL-tutorial?

Opret en database

Opret forbindelse til databasen

Opret en tabel

NOT NULL Begrænsninger

Primære nøgler

Opret flere tabeller

Relationer

Tjek begrænsninger

Whitespace

Kommentarer

Inline kommentarer

Kommentarer med flere linjer

MySQL

Kommenter kode

Indsæt data

Tjek vores data

Vælg specifikke kolonner

Sortering

Tæl rækkerne i et resultatsæt

Gruppér efter

HAVING Klausul

Deltager

Aliases

Updating Data

Deleting Data

Dropping Objects

SQL Operators

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` Begrænsninger

`HAVING` Klausul