SQL-handledning för nybörjare

I denna SQL-handledning för nybörjare kommer du att skapa din egen databas, infoga data i den databasen och sedan köra frågor mot den databasen.

Denna SQL-handledning får dig att köra SQL-frågor på nolltid!

SQL-exempel

Här är ett exempel på en SQL-sats:

SELECT * 
FROM Pets;

Det här är ett perfekt exempel på hur lätt det kan vara att skriva SQL. Denna enkla SQL-sats gör faktiskt mycket. Det ger tillbaka hela tabellen. Den returnerar alla kolumner och alla rader från tabellen som heter Husdjur .

Asterisken (* ) är ett jokertecken, vilket betyder "alla kolumner". Det är ett snabbt och enkelt sätt att få alla kolumner utan att behöva skriva ut alla.

Det är en av de vackra sakerna med SQL. De enklaste SQL-frågorna är vanligtvis de mest kraftfulla. Om vi ville returnera mindre data skulle vi faktiskt behöva skriva mer .

Till exempel om vi bara ville ha husdjur med namnet Hämta , skulle vi lägga till en WHERE klausul som fastställde det kravet.

Så här:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE klausul filtrerar vår fråga till bara raderna där PetName kolumnen har värdet Fetch .

Den här frågan förutsätter att det finns en kolumn som heter PetName och en tabell som heter Husdjur i databasen.

I den här SQL-handledningen kommer jag att visa dig hur du skapar en sådan databas med SQL.

Jag kommer också att visa dig hur du infogar data i databasen, uppdaterar data, tar bort data och kör frågor mot den.

Vad är SQL?

SQL är en akronym för Structured Query Language.

SQL är standardfrågespråket som används för att arbeta med relationsdatabaser.

SQL används av alla större relationsdatabashanteringssystem (RDBMS), inklusive:

Microsoft Access
SQL-server
Oracle
PostgreSQL
MySQL
SQLite

Vad kan jag göra med SQL?

Du kan använda SQL för att köra frågor mot en databas, infoga poster, uppdatera poster och ta bort poster. Du kan också skapa nya databasobjekt som databaser och tabeller. Du kan också utföra databasadministrationsuppgifter, som att skapa inloggningar, automatiserade jobb, säkerhetskopiering av databas och mycket mer.

Även när du gör saker med ett grafiskt användargränssnitt (GUI), kommer ditt databashanteringssystem (DBMS) nästan säkert att använda SQL bakom kulisserna för att utföra den uppgiften.

Till exempel när du skapar en databas genom att klicka på Skapa databas och ange informationen om den nya databasen i en dialogruta när du klickar på OK eller Skapa eller vad knappen än läser kommer ditt databassystem att använda SQL CREATE DATABASE för att gå vidare och skapa databasen som specificerats.

Detsamma gäller för andra uppgifter, som att köra frågor, infoga data, etc.

SQL gör det också möjligt för dig att utföra mer avancerade åtgärder som att skapa lagrade procedurer (fristående skript), vyer (förgjorda frågor) och ställa in behörigheter för databasobjekt (som tabeller, lagrade procedurer och vyer).

Som sagt, du behöver inte lära dig alla avancerade saker för att komma igång med SQL. Det som är bra med SQL är att några av de vanligaste uppgifterna är de enklaste att skriva.

SQL Standard

SQL standardiserades i ANSI X3.135 1986, och inom några månader antogs den av ISO som ISO 9075-1987. Den internationella standarden (nu ISO/IEC 9075) har reviderats med jämna mellanrum sedan dess, och den finns för närvarande i 9 delar.

De flesta stora databasleverantörer tenderar att följa SQL-standarden. Det som är bra med det är att du inte behöver lära dig ett nytt frågespråk varje gång du lär dig ett nytt DBMS.

I praktiken finns det dock variationer mellan hur varje databasleverantör implementerar SQL-standarden. Därför kanske kod som du skriver i en DBMS inte alltid fungerar i en annan utan att behöva modifieras.

Den goda nyheten är att alla större DBMS stöder de vanligaste uppgifterna på i stort sett samma sätt.

SQL-uttal

SQL uttalas vanligtvis på ett av två sätt:

“ess-que-el ” (dvs. stava varje bokstav)
”uppföljare ” (som i den ursprungliga stavningen/uttalet).

Se Är det uttalas S-Q-L eller Sequel om du undrar varför.

Vad behöver jag för denna SQL-handledning?

För att verkligen dra nytta av denna SQL-handledning bör du följa exemplen. Det betyder att du behöver någonstans att ange SQL-frågorna. Du måste ha något sånt här:

Om du ska köra SQL-frågor behöver du:

En RDBMS installerad (som SQL Server, MySQL, PostgreSQL, SQLite, etc).
Ett databasverktyg som låter dig köra SQL-frågor mot det RDBMS-systemet (som MySQL WorkBench, Azure Data Studio (bilden), DBeaver och SSMS).

Om du redan har en av varje installerad, bra! Du kan fortsätta med handledningen.

Om du inte har dessa installerade, se Vad behöver jag för att köra SQL? för instruktioner om hur du installerar ett RDBMS och dess relevanta databashanteringsverktyg innan du återgår till denna SQL-handledning.

Skapa en databas

När du har installerat ditt RDBMS och lämpligt databasverktyg är du redo att skapa en databas:

CREATE DATABASE PetHotel;

Gjort!

Det uttalandet skapade faktiskt en databas. En tom databas, men en databas ändå.

Den här databasen kommer att innehålla tabellerna och data som används i denna SQL-handledning. När vi skapar en tabell eller infogar data kommer vi att göra det i den här databasen.

Jag bör nämna att SQLite använder en annan syntax för att skapa databaser. Om du använder SQLite, så här skapar du en databas i SQLite.

Anslut till databasen

Innan du börjar skapa tabeller, infoga data och så vidare måste du vara säker på att du är i rätt databas. Att skapa en databas (som vi precis gjorde) ansluter dig inte nödvändigtvis till den databasen.

I många DBMS (som SQL Server , MySQL och MariaDB ), kan vi använda följande för att växla över till den angivna databasen:

USE PetHotel;

Det gör PetHotel den aktuella databasen.

I SQLite , är du förmodligen redan i databasen efter att du skapat den. Om inte kan du bifoga databasen (som också skapar den om den inte redan finns):

ATTACH DATABASE 'PetHotel.db' AS Pets;

I PostgreSQL , om du använder psql-verktyget kan du använda följande:

\connect PetHotel

Eller den förkortade versionen:

\c PetHotel

Jag bör nämna att processen att skapa och ansluta till databaser kan skilja sig mycket mellan DBMS.

Lyckligtvis låter de flesta GUI-verktyg dig ansluta till en databas genom att antingen dubbelklicka på databasen eller högerklicka på databasnamnet och välja en ny frågeflik från snabbmenyn. Om du hamnar i det här steget, använd bara GUI för att skapa och/eller ansluta till din DB.

Skapa en tabell

Nu när du har anslutit till rätt databas kan du gå vidare och skapa några tabeller.

För att skapa en tabell i SQL, använd CREATE TABLE uttalande.

När du skapar en tabell måste du ange vilka kolumner som ska finnas i tabellen, samt deras datatyper. Du kan också ange andra detaljer, men låt oss inte gå före oss själva.

Låt oss skapa en tabell:

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

I det här fallet skapar vi en tabell som heter PetTypes . Vi vet det, eftersom tabellnamnet kommer omedelbart efter CREATE TABLE bit.

Efter det kommer en lista med kolumner, omgivna inom parentes.

Tabellen ovan innehåller följande kolumner:

PetIdId
PetType

Varje kolumn följs av dess datatyp:

int betyder att denna kolumn accepterar heltal. Så vitt jag vet stöder de flesta större DBMS att deklarera kolumner som int . Om du har några problem, försök att använda heltal .
varchar(60) betyder att den här kolumnen accepterar strängar upp till 60 tecken långa. varchar kolumner är strängar med variabel längd. En annan strängdatatyp är char (som är en sträng med fast längd). Om du har problem med att försöka definiera en kolumn som varchar(60) , prova att använda char(60) .

`INTE NULL` Begränsningar

I det här exemplet är båda kolumnerna definierade med NOT NULL begränsningar. NOT NULL begränsning betyder att denna kolumn inte kan vara tom. När en ny rad infogas, någon NOT NULL kolumner måste innehålla ett värde. Andra kolumner kan förbli tomma om det inte finns några data för dessa kolumner.

Om NULL värden är tillåtna i kolumnen kan du antingen utelämna NOT NULL del, eller deklarera den som NULL (vilket betyder NULL värden är tillåtna i den här kolumnen).

Vissa DBMS:er (som DB2) stöder inte NULL nyckelord i alla fall, så du måste utelämna det när du arbetar med sådana DBMS.

Primära nycklar

Vi skapade även PetTypeId kolumnen primärnyckeln. Den primära nyckeln är en eller flera kolumner som unikt identifierar varje rad i tabellen. Du anger dina valda kolumner som primärnyckel genom att använda en primärnyckelrestriktion. Du kan göra detta i SKAPA TABELL uttalande (som vi gjorde här), eller så kan du lägga till en senare med en ALTER TABLE påstående.

Primära nycklar måste innehålla unika värden. Det vill säga, för varje rad i den tabellen måste värdet i primärnyckelkolumnen/kolumnerna vara olika i varje rad. Detta kan vara så enkelt som att ha ökande siffror (som 1, 2, 3... etc) eller det kan vara en produktkod (som pr4650, pr2784, pr5981... etc).

Primärnycklar måste också innehålla ett värde. Det kan inte vara NULL .

Även om primärnycklar inte krävs, anses det i allmänhet vara bra att definiera en primärnyckel för varje tabell.

Skapa fler tabeller

Låt oss skapa ytterligare två tabeller:

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

Båda dessa tabeller liknar den första, förutom att de har fler rader och ett par extra bitar, vilket jag ska förklara nedan.

Om du är intresserad, kolla in SQL CREATE TABLE för nybörjare för några fler enkla exempel på att skapa tabeller i SQL.

Relationer

När vi skapade våra Husdjur tabell skapade vi faktiskt en relation mellan de tre tabellerna.

Det förhållandet visas i följande diagram.

Databasrelationer är en avgörande del av SQL. Relationer gör att vi kan söka efter relaterade data i flera tabeller och få korrekta och konsekventa resultat.

I vårt fall vill vi kunna söka efter husdjur efter ägare, eller husdjur efter husdjurstyp, etc. Och vi vill att våra resultat ska vara korrekta och konsekventa.

För att uppnå detta måste vi insistera på att alla husdjur anges tillsammans med deras ägare och husdjurstyp. Därför måste vi se till att när ett nytt husdjur läggs till i Pets tabellen finns det redan en motsvarande ägare i Ägare tabell och en motsvarande husdjurstyp i PetTypes tabell.

I grund och botten är våra krav följande:

Alla värden i Pets.PetTypeId kolumnen måste matcha ett värde i PetTypes.PetTypeId kolumn.
Alla värden i Pets.OwnerId kolumnen måste matcha ett värde i Owners.OwnerId kolumn.

Vi kan säkerställa ovanstående krav genom att skapa en främmande nyckel-begränsning mot tillämpliga kolumner. En främmande nyckel begränsning används för att specificera att en viss kolumn refererar till primärnyckeln för en annan tabell.

Ovanstående kod skapade verkligen två främmande nyckelbegränsningar på Husdjur bord.

Lägg märke till att PetTypeId och OwnerId kolumner har lite extra kod som börjar med REFERENSER... . Det är de delar som skapade de två främmande nycklarna.

När vi skapade Husdjur tabellen, dess PetTypeId kolumnen har en bit som går REFERENSER PetTypes (PetTypeId) . Detta betyder att Pets.PetTypeId kolumnen refererar till PetTypeId kolumnen i PetTypes bord.

Det är samma affär för OwnerId kolumn. Den refererar till OwnerId kolumnen i Ägare bord.

I de flesta DBMS:er kan främmande nycklar också skapas på en befintlig tabell genom att använda ALTER TABLE uttalande, men det går vi inte över här. Se Hur man skapar en relation i SQL för mer om det.

Hur som helst, våra främmande nycklar har skapats. Nu, varje gång någon infogar ett nytt husdjur i Husdjur tabellen, PetTypeId och OwnerId värden måste ha ett motsvarande värde i PetTypes och Ägare tabeller respektive. Om någon av dem inte gör det kommer databasen att returnera ett fel.

Detta är fördelen med främmande nycklar. Det hjälper till att förhindra att dålig data matas in. Det hjälper till att upprätthålla dataintegritet och mer specifikt referensintegritet.

Kontrollera begränsningar

En kontrollbegränsning är en annan typ av begränsning som du bör vara medveten om. En kontrollbegränsning kontrollerar data innan den kommer in i databasen. När en tabell har en kontrollbegränsning aktiverad kan data bara komma in i tabellen om den inte bryter mot den begränsningen. Data som bryter mot begränsningen kan inte komma in i tabellen.

Du kan till exempel skapa en kontrollbegränsning för ett Price kolumn för att säkerställa att den bara accepterar värden som är större än noll. Eller så kan vi tillämpa en kontrollbegränsning på våra husdjur tabell för att säkerställa att DOB kolumnen finns inte i framtiden.

För ett exempel, se Vad är en CHECK-begränsning?

Whitespace

Du kanske har märkt att mina exempel inkluderar blanksteg. Till exempel har jag fördelat koden över flera rader och jag har använt tabbar för att dra in datatyperna osv.

Detta är helt giltigt i SQL. Du kan säkert göra detta, och det kommer inte att påverka resultatet. SQL låter dig sprida din kod över flera rader om du vill, och det låter dig använda flera blanksteg eller tabbar för att förbättra läsbarheten.

Kommentarer

Du kan också inkludera kommentarer i din kod. Kommentarer kan vara praktiska när du börjar skriva längre SQL-skript. När ett manus blir ganska långt kan kommentarer göra det lättare att snabbt identifiera vad varje del gör.

Infogade kommentarer

Du kan skapa inline-kommentarer genom att prefixa din kommentar med två bindestreck (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

I det här exemplet kommer båda frågorna att köras utan problem. Kommentarerna kommer att ignoreras av DBMS.

Kommentarer med flera rader

Du kan sprida kommentarer över flera rader genom att omge kommentaren med /* och */ :

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

I det här exemplet kommer båda frågorna att köras utan problem. Kommentarerna kommer att ignoreras av DBMS.

MySQL

Om du använder MySQL kan du också använda nummertecknet/hash-tecknet (# ) för kommentarer på en rad.

# This is a comment
SELECT * FROM Pets;

Kommentar ut kod

En annan cool fördel med kommentarer är att du kan kommentera ut koda. Till exempel, om du har ett långt SQL-skript som gör många saker, men du bara vill köra en eller två delar av det, kan du kommentera ut resten av manuset.

Här är ett exempel:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

I det här fallet, den första SELECT uttalandet har kommenterats bort, och så bara den andra SELECT uttalandet kommer att köras.

Du kan också använda flerradskommentarer för denna teknik.

Infoga data

Nu när vi har skapat tre tabeller och skapat lämpliga främmande nycklar kan vi gå vidare och lägga till data.

Det vanligaste sättet att infoga data i SQL är med INSERT påstående. Det är ungefär så här:

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

Du ersätter helt enkelt MyTable med namnet på tabellen som du infogar data i. På samma sätt ersätter du Column1 , etc med kolumnnamnen och Värde1 , etc med värdena som går in i dessa kolumner.

Vi skulle till exempel kunna göra detta:

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

Varje värde är i samma ordning som kolumnen anges.

Observera att kolumnnamnen matchar de namn vi använde när vi skapade tabellen.

Du kan utelämna kolumnnamnen om du infogar data i alla kolumner. Så vi kan ändra exemplet ovan så att det ser ut så här:

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

För den här handledningen kommer vi att lägga till en hel del fler rader, så vi lägger till fler INSERT INTO satser – en för varje rad vi vill infoga.

Så låt oss gå vidare och fylla i våra 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' );

Observera att vi fyllde i Husdjur bordet sist. Det finns en anledning till detta.

Om vi hade försökt infoga data i Husdjur innan vi fyller i de andra två, skulle vi ha fått ett fel på grund av vår främmande nyckel-begränsning. Och av goda skäl. När allt kommer omkring skulle vi ha försökt infoga värden i kolumnerna för främmande nyckel som ännu inte fanns i primärnyckelkolumnerna i de andra tabellerna. Det är ett stort "nej nej" när det kommer till främmande nycklar.

Så genom att fylla i Ägare och PetTypes tabeller först såg vi till att lämpliga värden redan fanns i primärnyckelkolumnerna innan vi fyllde i kolumnerna för främmande nyckel i Husdjur bord.

Se SQL INSERT för nybörjare för fler exempel på att infoga data i tabeller.

Kontrollera vår data

Puh! Äntligen kan vi börja köra frågor mot vår databas.

Låt oss kontrollera data i alla våra 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)

Bra, så det ser ut som att data har infogats.

Välj specifika kolumner

Det anses allmänt vara dålig praxis att välja alla rader och alla kolumner från en tabell (som vi gjorde i föregående exempel), om du inte verkligen behöver det. Att göra detta kan påverka prestandan för din databasserver, särskilt om det finns många rader i tabellen.

Det är inte ett problem när du använder små datamängder som vi är här, eller om du är i en utvecklingsmiljö eller liknande. Annars är det vanligtvis bättre att välja just de kolumner du behöver.

Därför, om vi ville ha ID, namn och födelsedatum för alla husdjur, kunde vi göra detta:

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

Om vi ville ha ID:n och födelsedatum för alla husdjur som heter Fluffy, skulle vi kunna använda detta:

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

Resultat:

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

Du kan också använda SELECT uttalande för att returnera ingen tabelldata. Det vill säga att den kan returnera data som inte är lagrad i en tabell. Se SQL SELECT Uttalande för nybörjare för att se ett exempel.

Sortering

SQL tillhandahåller ORDER BY klausul som gör det möjligt för oss att sortera data.

Vi kan lägga till en ORDER BY klausul till vårt tidigare exempel så att husdjuren sorteras efter deras namn:

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 stigande . När du använder ORDER BY sats, den är som standard stigande, så du kan utelämna ASC del om du vill.

För att sortera det i fallande ordning, använd 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 också sortera resultaten med flera kolumner. Den kommer att sortera efter den första angivna kolumnen, sedan om det finns några dubbletter i den kolumnen, kommer den att sortera dessa dubbletter efter den andra angivna kolumnen, och så vidare.

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 hur de två Fluffys har bytt position.

Om du inte använder ORDER BY klausul, det finns ingen garanti i vilken ordning dina resultat kommer att vara. Även om det kan se ut som att din databas sorterar resultaten efter en viss kolumn, kanske detta inte är fallet. I allmänhet utan en ORDER BY klausul, kommer data att sorteras i den ordning som den laddades in i tabellen. Men om rader har tagits bort eller uppdaterats kommer ordningen att påverkas av hur DBMS återanvänder återvunnet lagringsutrymme.

Lita därför inte på att DBMS sorterar resultaten i någon meningsfull ordning.

Nedersta raden:Om du vill att dina resultat ska sorteras, använd ORDER BY .

Se SQL ORDER BY Klausul för nybörjare för fler exempel.

Räkna raderna i en resultatuppsättning

Du kan använda COUNT() aggregatfunktion för att räkna raderna som kommer att returneras i en fråga.

SELECT COUNT(*) AS Count
FROM Pets;

Resultat:

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

Detta säger oss att det finns 8 rader i tabellen. Vi vet det eftersom vi har valt alla rader och alla kolumner.

Du kan använda COUNT() på alla frågor, till exempel frågor som använder en WHERE klausul för att filtrera resultaten.

Du kan också ange att en viss kolumn ska räknas. COUNT() funktionen räknar endast icke-NULL resultat, så om du anger en kolumn som innehåller NULL värden, kommer dessa värden inte att räknas.

Här är ett exempel för att visa vad jag menar.

SELECT COUNT(DOB) AS Count
FROM Pets;

Resultat:

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

Du kanske minns att Husdjur Tabellen innehåller två NULL värden i DOB kolumnen (två husdjur har inte angett sitt födelsedatum) och så COUNT(DOB) returnerar 6 istället för 8 när vi använde COUNT(*) . Orsaken COUNT(*) returnerade alla rader, beror på att de två raderna gjorde har data i de andra kolumnerna.

I mitt exempel returnerade min DBMS också en varning om detta. Du får eller kanske inte får en varning, beroende på ditt DBMS och din specifika konfiguration.

Se SQL COUNT för nybörjare för fler exempel.

Andra aggregerade funktioner inkluderar:AVG() , SUM() , MIN() och MAX() .

Gruppera efter

En annan användbar klausul är GROUP BY klausul. Detta gör i stort sett vad namnet lovar. Det låter dig gruppera resultaten efter en viss kolumn.

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 det här exemplet räknar vi hur många husdjur vi har för varje husdjurstyp och sorterar dem sedan i fallande ordning (med det högsta antalet överst).

Se SQL GROUP BY Klausul för nybörjare för fler exempel.

`HAVING` Klausul

Vi kan använda koden HAVING sats för att filtrera resultaten i GROUP BY klausul. HAVING sats returnerar rader där aggregerade värden uppfyller specificerade villkor.

Här är ett exempel.

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 det här fallet returnerade vi data för bara de husdjurstyper som har fler än två husdjur tilldelade den typen.

Se SQL HAV Klausul för nybörjare för fler exempel.

Gå med

I SQL, en join är där du kör en fråga som kombinerar data från flera tabeller.

De två föregående exemplen är OK, men de skulle vara bättre om de returnerade de faktiska husdjurstyperna (t.ex. katt, hund, fågel, etc) snarare än ID (t.ex. 1, 2, 3, etc).

Det enda problemet är Husdjur tabellen innehåller inte den informationen. Dessa data finns i PetTypes bord.

Lyckligtvis för oss kan vi göra en sammanfogning mellan dessa två bord. Här är ett exempel som använder 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       |
+-----------+---------+

Denna resultatuppsättning är mycket lättare att läsa än de tidigare. Det är lättare att förstå hur många av varje husdjurstyp som finns i tabellen.

Syntaxen använder jointypen (i detta fall LEFT JOIN ), följt av den första (vänster) tabellen, följt av ON , följt av anslutningsvillkoret.

Låt oss använda en INNER JOIN för att returnera alla husdjursnamn med sina respektive husdjurstyper.

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

Anslutningar öppnar verkligen upp våra alternativ, eftersom vi nu kan ta data från flera tabeller och presentera det som om det vore en enda tabell.

Du kommer att märka att i anslutningsexemplen kvalificerar vi våra kolumnnamn med tabellnamnen. Anledningen till att vi gör detta är för att undvika oklarheter angående kolumnkolumnnamnen mellan tabellerna. Båda tabellerna kan ha kolumner med samma namn (som i vårt exempel), och i sådana fall kommer DBMS inte att veta vilken kolumn du hänvisar till. Att prefixa kolumnnamnen med deras tabellnamn säkerställer att du hänvisar till höger kolumn och förhindrar eventuella fel som kan uppstå på grund av oklarheter om vilken kolumn du hänvisar till.

Se min självstudie för SQL Joins för fler exempel och en förklaring av de olika jointyperna.

Alias

Vi kan gå ett steg längre och tilldela ett alias till varje tabellnamn och kolumnnamn.

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

Detta har resulterat i nya kolumnrubriker, plus att koden är mer kortfattad.

Ett alias låter dig tillfälligt tilldela ett annat namn till en tabell eller kolumn under varaktigheten av en SELECT fråga. Detta kan vara särskilt användbart när tabeller och/eller kolumner har mycket långa eller komplexa namn.

Ett alias tilldelas genom användning av AS nyckelord, även om detta nyckelord är valfritt, så du kan säkert utelämna det. Observera att Oracle inte stöder AS nyckelord på tabellalias (men det gör det på kolumnalias).

I exemplet ovan har jag inkluderat AS nyckelord vid tilldelning av kolumnalias, men utelämnade det vid tilldelning av tabellalias.

Ett aliasnamn kan vara vad som helst, men är vanligtvis kort för läsbarhetssyften.

I vårt fall ändrade vi de två tabellerna till p och pt , och kolumnnamnen till Pet och Husdjurstyp . Observera att jag omgav Pet Type inom dubbla citattecken. Jag gjorde detta eftersom det finns ett mellanslag i namnet. För alias utan mellanslag behöver du inte göra detta. I SQL Server kan du alternativt använda hakparenteser ([] ) istället för dubbla citattecken (även om det också stöder dubbla citattecken).

Bruket att använda mellanslag i kolumner och alias avråds i allmänhet, eftersom det kan orsaka alla möjliga problem med vissa klientapplikationer.

Observera att vi fortfarande behövde använda de fullständiga kolumnnamnen när vi hänvisade till dem i kopplingen (efter ON nyckelord).

Jag bör påpeka att tilldelning av ett alias faktiskt inte byter namn på kolumnen eller tabellen.

Se SQL Alias Explained för fler exempel.

Uppdatera data

Du kan använda UPDATE uttalande för att uppdatera data i dina tabeller.

Den grundläggande syntaxen är ganska enkel:

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

I det exemplet uppdaterar vi Efternamn kolumnen för att få ett nytt värde på Stallone där OwnerId är 3 .

För att uppdatera flera kolumner, använd ett kommatecken för att separera varje kolumn/värdepar.

Men vad du än gör, glöm inte VAR klausul (såvida du inte faktiskt tänker uppdatera varje rad i tabellen med samma värde).

Se SQL UPPDATERING 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 uttalande:

DELETE FROM Owners
WHERE OwnerId = 5;

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

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 påstående. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL uttalande.

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

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.

När en transaktion gör flera ändringar i databasen, lyckas antingen alla ändringar när transaktionen genomförs, eller så ångras alla ändringar när transaktionen återställs.

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

Du kan skriva villkorlig logik inuti den transaktionen som rullar tillbaka transaktionen om något går fel.

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-handledning för nybörjare

SQL-exempel

Vad är SQL?

Vad kan jag göra med SQL?

SQL Standard

SQL-uttal

Vad behöver jag för denna SQL-handledning?

Skapa en databas

Anslut till databasen

Skapa en tabell

INTE NULL Begränsningar

Primära nycklar

Skapa fler tabeller

Relationer

Kontrollera begränsningar

Whitespace

Kommentarer

Infogade kommentarer

Kommentarer med flera rader

MySQL

Kommentar ut kod

Infoga data

Kontrollera vår data

Välj specifika kolumner

Sortering

Räkna raderna i en resultatuppsättning

Gruppera efter

HAVING Klausul

Gå med

Alias

Uppdatera 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

`INTE NULL` Begränsningar

`HAVING` Klausul