Lär dig SQL – En hand­led­ning med kod­nings­ex­em­pel

SQL-syntaxen baseras på re­la­tions­al­ge­bra, vilket gör pro­gram­me­rings­språ­ket an­norlun­da jämfört med andra språk. Att bekanta sig med syntaxen genom praktiska exempel kan hjälpa dig att lära dig SQL på ett effektivt sätt.

Vad är SQL-syntax?

Inom pro­gram­me­ring avser syntax hur ett pro­gram­me­rings­språk skrivs. Syntaxen avgör de grund­läg­gan­de kod­kon­struk­tio­ner­na och hur de ska kopplas samman. Att förstå syntaxen är en grund­läg­gan­de för­ut­sätt­ning för att kunna läsa och skriva kod i pro­gram­me­rings­språk.

De vik­ti­gas­te syn­tax­kon­struk­tio­ner­na i SQL är SQL-satser, som också kan innehålla klausuler. Båda kallas van­ligt­vis för ”SQL-kommandon”, även om detta ur teknisk synvinkel inte är helt korrekt. Dessa är dock inte de enda SQL-syn­tax­kon­struk­tio­ner­na. Nedan hittar du en tabell som ger dig en översikt över SQL-syn­tax­kon­struk­tio­ner­na.

Hur exekveras SQL-kod?

SQL-kod finns som källkod i textfiler. Koden får liv först i en lämplig ex­e­kve­rings­mil­jö. Källkoden läses av en SQL-tolkar och omvandlas till åtgärder i ett RDBMS. Det finns två grund­läg­gan­de till­vä­ga­gångs­sätt här:

1. Kör SQL-kod in­ter­ak­tivtI det här till­vä­ga­gångs­sät­tet matas SQL-koden in eller kopieras direkt till ett text­föns­ter. SQL-koden körs och re­sul­ta­tet visas. Du kan justera koden och köra den igen. Den snabba sekvensen av kod­ma­ni­pu­le­ring och visning av resultat gör detta till­vä­ga­gångs­sätt bäst lämpat för att lära sig och skapa komplexa frågor. 2. Kör SQL-kod somskript I denna metod körs en hel käll­kods­fil som in­ne­hål­ler SQL-kod rad för rad. Om det behövs skickas feedback endast till an­vän­da­ren i slutet av körningen. Denna metod är bäst lämpad för au­to­ma­ti­se­ring av processer och för import av MySQL-da­ta­bas­back­uper med MySQL dump.

Hur man kon­fi­gu­re­rar ett pro­dukt­led­nings­sy­stem med SQL

Det enklaste sättet att lära sig ett pro­gram­me­rings­språk är att skriva och köra kod själv. I den här hand­led­ning­en ska vi skapa en mini­da­ta­bas och köra frågor mot den. För att göra detta använder vi online-SQL-tolken från webb­plat­sen sql.js. För att följa hand­led­ning­en går du till webb­plat­sen och ersätter den SQL-kod som redan har angetts med koden från våra exempel. Kör koden bit för bit för att visa re­sul­ta­ten.

Kon­fi­gu­re­ra en SQL-databas

I det här exemplet ska vi bygga ett kom­mer­si­ellt pro­dukt­led­nings­sy­stem för en butik. Krav­spe­ci­fi­ka­tio­nen ser ut så här:

• Det finns flera produkter, och vi har en viss mängd av varje produkt i lager.
• Vår kundbas omfattar många kunder och klienter.
• Kundernas be­ställ­ning­ar kan innehålla flera produkter.
• För varje be­ställ­ning lagrar vi be­ställ­nings­da­tum och uppgifter om den person som lagt be­ställ­ning­en, samt vilka produkter som beställts och i vilken mängd.

Dessa krav översätts till en abstrakt be­skriv­ning och sedan till SQL-kod:

1. Skapa modell
2. Definiera schema
3. Ange da­ta­pos­ter
4. Definiera frågor

Skapa modell av enheter och re­la­tio­ner

Det första steget sker på papper eller med hjälp av speciella mo­del­le­rings­verk­tyg. Vi samlar in in­for­ma­tion om det system som ska mo­del­le­ras för att härleda enheter och re­la­tio­ner. Detta steg genomförs ofta i form av ett en­ti­tets­re­la­tions­di­a­gram (ER-diagram).

Vilka enheter finns det och hur är de re­la­te­ra­de till varandra? Enheter är klasser av saker. I vårt exempel med pro­dukt­led­nings­sy­ste­met är enheterna produkter, kunder och order. För varje enhet behövs en tabell. På grund av re­la­tions­mo­del­lens särdrag läggs yt­ter­li­ga­re tabeller till för att modellera re­la­tio­ner­na. För att inse detta och im­ple­men­te­ra det på rätt sätt krävs er­fa­ren­het.

En central fråga som måste besvaras är hur enheterna förhåller sig till varandra. Här måste vi beakta båda rikt­ning­ar­na i en relation och skilja mellan singular och plural. Här är ett exempel med bilar och bilägare:

1. En ägare kan po­ten­ti­ellt äga flera bilar.
2. En bil kan bara tillhöra en ägare.

Tre möjliga re­la­tions­möns­ter fram­trä­der mellan de två enheterna:

Im­ple­men­te­ra produkter

Först im­ple­men­te­rar vi pro­dukt­ta­bel­len. För att göra detta måste vi definiera ett schema, mata in da­ta­pos­ter och, för te­stän­da­mål, utföra några enkla frågor.

Definiera schema

Det centrala SQL-kommandot för att definiera da­ta­basta­bel­ler är CREATE TABLE. Med detta kommando kan du skapa en tabell med ett namn och ange ko­lum­ne­gen­ska­per. Samtidigt de­fi­nie­ras datatyper och, om nöd­vän­digt, be­gräns­ning­ar för de värden som ska lagras:

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );

Lägg till da­ta­mäng­der

Nu ska vi skapa några test­pos­ter. Vi använder SQL-kommandot INSERT INTO och funk­tio­nen VALUES för att fylla i fälten:

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);

Definiera frågor

För att kon­trol­le­ra statusen för tabellen Products skriver vi en enkel fråga. Vi använder kommandot SELECT FROM och visar hela tabellen:

SELECT * FROM Products;

Nu skriver vi en något mer komplex fråga som beräknar det totala värdet av de produkter vi har i lager:

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;

Im­ple­men­te­ra yt­ter­li­ga­re tabeller

Därefter skapar vi de åter­stå­en­de ta­bel­ler­na som vi behöver. Vi följer samma steg som vi använde för tabellen Produkter. Först skapar vi tabellen Kunder:

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );

Sedan matar vi in da­ta­pos­ter för två ex­em­pel­kun­der:

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');

För att kon­trol­le­ra om det fungerade visar vi kund­ta­bel­len:

SELECT * FROM Customers;

Nästa steg är att skapa tabellen Orders:

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );

Nu ska vi lägga in tre exempel på in­köpsor­der. För det första värdet i posterna tilldelar vi ett ID som pri­mär­nyc­kel. Det andra värdet är för be­fint­li­ga kund-ID:n, som fungerar som främmande nycklar. Sedan lagrar vi or­der­da­tu­met:

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08');

För att testa det kommer vi att utfärda följande order:

SELECT * FROM Orders;

Slutligen behöver vi en tabell för pro­duk­ter­na i en order till­sam­mans med deras antal. Detta är en m:n-relation eftersom en order kan innehålla flera produkter och en produkt kan förekomma i flera order. Vi de­fi­ni­e­rar en tabell som in­ne­hål­ler ID:n för order och produkter som främmande nycklar:

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );

Nu lägger vi in några produkter som har beställts. Vi väljer ID-nummer för be­ställ­ning­ar­na och pro­duk­ter­na så att det finns en be­ställ­ning med två produkter och en annan be­ställ­ning med endast en produkt:

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);

För att kon­trol­le­ra detta kommer vi att leverera de produkter som beställts:

SELECT * FROM OrderItems;

Skriv komplexa frågor

Om du har kört alla kod­snut­tar som visats hittills bör du kunna förstå struk­tu­ren i vår test­da­ta­bas. Låt oss nu gå vidare till mer komplexa frågor som visar kraften i SQL. Först ska vi skriva en fråga som sam­man­fo­gar data som är fördelade över flera tabeller. Vi använder ett SQL JOIN- kommando för att sam­man­fo­ga ta­bel­ler­na som in­ne­hål­ler kunddata och order. Samtidigt namnger vi ko­lum­ner­na och anger ett matchande kund-ID som ett JOIN-villkor. Tänk på att vi använder kva­li­fi­ce­ra­de iden­ti­fi­e­ra­re för att skilja mellan ko­lum­ner­na i de två ta­bel­ler­na:

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;

Nu använder vi ett annat JOIN-kommando för att beräkna den totala kostnaden för de beställda pro­duk­ter­na:

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;