Lær SQL – En vej­led­ning med ko­de­ek­semp­ler

SQL’s syntaks er baseret på re­la­tions­al­ge­bra, hvilket adskiller dette pro­gram­me­rings­sprog fra andre sprog. Ved at gøre dig fortrolig med syntaksen gennem praktiske eksempler kan du lære SQL på en effektiv måde.

Hvad er SQL-syntaks?

I pro­gram­me­ring henviser syntaks til den måde, et pro­gram­me­rings­sprog skrives på. Syntaksen fast­læg­ger de grund­læg­gen­de ko­de­kon­struk­tio­ner og hvordan de skal sam­men­kæ­des. At forstå syntaksen er en grund­læg­gen­de for­ud­sæt­ning for at kunne læse og skrive kode i pro­gram­me­rings­sprog.

De vigtigste syn­tak­s­e­le­men­ter i SQL er SQL-sætninger, som også kan indeholde klausuler. Begge betegnes ofte som »SQL-kom­man­do­er«, selvom dette rent teknisk set ikke er helt korrekt. Det er dog ikke de eneste syn­tak­s­e­le­men­ter i SQL. Nedenfor finder du en tabel, der giver dig et overblik over syn­tak­s­e­le­men­ter­ne i SQL.

Hvordan udføres SQL-kode?

SQL-kode findes som kildekode i tekst­fi­ler. Koden kommer først til live i et passende kør­sels­mil­jø. Kil­de­ko­den læses af en SQL-fortolker og omdannes til hand­lin­ger i et RDBMS. Der er to grund­læg­gen­de tilgange her:

1. Udfør SQL-kodein­ter­ak­tivt I denne frem­gangs­må­de indtastes eller kopieres SQL-koden direkte ind i et tekstvin­due. SQL-koden udføres, og re­sul­ta­tet vises. Du kan justere koden og udføre den igen. Den hurtige af­veks­ling mellem ko­de­ma­ni­pu­la­tion og visning af re­sul­ta­ter gør denne frem­gangs­må­de særdeles velegnet til at lære og oprette komplekse fo­re­spørgs­ler. 2. Udfør SQL-kode somscript I denne frem­gangs­må­de udføres en hel kil­de­ko­de­fil, der in­de­hol­der SQL-kode, linje for linje. Hvis det er nød­ven­digt, sendes feedback kun til brugeren ved af­slut­nin­gen af ud­fø­rel­sen. Denne frem­gangs­må­de er bedst egnet til au­to­ma­ti­se­ring af processer og til import af MySQL-database-backups med MySQL dump.

Sådan opretter du et pro­dukt­sty­rings­sy­stem ved hjælp af SQL

Den nemmeste måde at lære et pro­gram­me­rings­sprog på er at skrive og køre koden selv. I denne vej­led­ning skal vi oprette en mi­ni­da­ta­ba­se og køre fo­re­spørgs­ler på den. Til det formål bruger vi online-SQL-for­tol­ke­ren fra hjem­mesi­den sql.js. For at følge vej­led­nin­gen skal du gå ind på hjem­mesi­den og erstatte den SQL-kode, der allerede er indtastet, med koden fra vores eksempler. Kør koden stykke for stykke for at få re­sul­ta­ter­ne vist.

Opret en SQL-database

I dette eksempel skal vi udvikle et pro­dukt­sty­rings­sy­stem til en butik. Her er kravene:

• Vi har flere for­skel­li­ge produkter, og vi har et bestemt antal af hvert produkt på lager.
• Vores kundebase omfatter mange kunder.
• Ordrer afgivet af kunder kan indeholde flere produkter.
• For hver ordre gemmer vi or­dre­da­to­en og op­lys­nin­ger om den person, der har afgivet ordren, samt de bestilte produkter og den bestilte mængde.

Disse krav omsættes først til en abstrakt be­skri­vel­se og derefter til SQL-kode:

1. Opret model
2. Definer skema
3. Indtast da­ta­po­ster
4. Definer fo­re­spørgs­ler

Opret en model over enheder og re­la­tio­ner

Det første trin foregår på papir eller ved hjælp af specielle mo­del­le­rings­værk­tø­jer. Vi indsamler op­lys­nin­ger om det system, der skal mo­del­le­res, for at udlede enheder og re­la­tio­ner. Dette trin udmøntes ofte i et entitet-re­la­tions­di­a­gram (ER-diagram).

Hvilke enheder findes der, og hvordan hænger de sammen? Enheder er ka­te­go­ri­er af objekter. I vores eksempel på et pro­dukt­sty­rings­sy­stem er enhederne produkter, kunder og ordrer. Der skal oprettes en tabel for hver enhed. På grund af den re­la­tio­nel­le models særlige ka­rak­te­ri­sti­ka tilføjes der yder­li­ge­re tabeller for at modellere sam­men­hæn­ge­ne. Det kræver erfaring at forstå dette og im­ple­men­te­re det korrekt.

Et centralt spørgsmål, der skal besvares, er, hvordan enhederne forholder sig til hinanden. Her skal vi tage højde for begge retninger i en relation og skelne mellem ental og flertal. Her er et eksempel med biler og bilejere:

1. En ejer kan po­ten­ti­elt eje flere biler.
2. En bil kan kun tilhøre én ejer.

Der tegner sigtre mulige mønstre for forholdet mellem de to enheder:

Im­ple­men­te­re produkter

Først skal vi oprette pro­dukt­ta­bel­len. For at gøre dette skal vi definere et skema, indtaste da­ta­po­ster og, med henblik på test, køre et par enkle fo­re­spørgs­ler.

Definer skema

Den centrale SQL-kommando til op­ret­tel­se af da­ta­ba­se­ta­bel­ler er CREATE TABLE. Med denne kommando kan du oprette en tabel med et navn og angive ko­lon­ne­e­gen­ska­ber. Samtidig defineres datatyper og, hvis nød­ven­digt, be­græns­nin­ger for de værdier, der skal gemmes:

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

Tilføj datasæt

Nu skal vi oprette et par test­po­ster. Vi bruger SQL-kom­man­do­en INSERT INTO samt funk­tio­nen VALUES til at udfylde felterne:

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

Definer fo­re­spørgs­ler

For at se, hvordan det står til med tabellen »Produkter«, skriver vi en simpel fo­re­spørgsel. Vi bruger kom­man­do­en SELECT FROM og viser hele tabellen:

SELECT * FROM Products;

Nu skal vi skrive en lidt mere kompleks fo­re­spørgsel, der beregner den samlede værdi af de varer, vi har på lager:

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

Opret yder­li­ge­re tabeller

Nu skal vi oprette de re­ste­ren­de tabeller, vi har brug for. Vi følger de samme trin, som vi brugte til tabellen »Produkter«. Først opretter vi tabellen »Kunder«:

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

Derefter indtaster vi data for to eksempler på kunder:

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

For at se, om det virkede, viser vi kun­de­ta­bel­len:

SELECT * FROM Customers;

Det næste trin er at oprette tabellen »Orders«:

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

Nu skal vi indtaste tre eksempler på ind­køb­sor­drer. For den første værdi i posterne tildeler vi et ID som pri­mær­nøg­le. Den anden værdi er ek­si­ste­ren­de kunde-ID’er, som fungerer som frem­med­nøg­ler. Derefter gemmer vi or­dre­da­to­en:

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

For at teste det vil vi udføre følgende kom­man­do­er:

SELECT * FROM Orders;

Endelig har vi brug for en tabel, der in­de­hol­der pro­duk­ter­ne i en ordre sammen med deres antal. Dette er et m:n-forhold, da en ordre kan indeholde flere produkter, og et produkt kan forekomme i flere ordrer. Vi opretter en tabel, der in­de­hol­der ID’erne for ordrer og produkter som frem­med­nøg­ler:

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

Nu indtaster vi et par produkter, der er blevet bestilt. Vi vælger ID’erne for ordrerne og pro­duk­ter­ne, så der er en ordre med to produkter og en anden ordre med kun ét 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);

For at kon­trol­le­re dette vil vi udlevere de bestilte varer:

SELECT * FROM OrderItems;

Skriv komplekse fo­re­spørgs­ler

Hvis du har kørt alle de ko­destyk­ker, der er vist indtil nu, bør du kunne forstå struk­tu­ren i vores test­da­ta­ba­se. Lad os nu gå videre til mere komplekse fo­re­spørgs­ler, der viser, hvor kraft­fuldt SQL er. Lad os først skrive en fo­re­spørgsel, der samler data fra flere for­skel­li­ge tabeller. Vi bruger en SQL JOIN-kommando til at sam­men­fø­je de tabeller, der in­de­hol­der kundedata og ordrer. I den for­bin­del­se navngiver vi ko­lon­ner­ne og angiver et matchende kunde-ID som JOIN-be­tin­gel­se. Husk, at vi bruger kva­li­fi­ce­re­de iden­ti­fi­ka­to­rer til at skelne mellem ko­lon­ner­ne i de to tabeller:

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 bruger vi endnu en JOIN-kommando til at beregne de samlede om­kost­nin­ger for de bestilte produkter:

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;