Lär dig SQL – En handledning med kodningsexempel

SQL-syntaxen baseras på relationsalgebra, vilket gör programmeringsspråket annorlunda 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 programmering avser syntax hur ett programmeringsspråk skrivs. Syntaxen avgör de grundläggande kodkonstruktionerna och hur de ska kopplas samman. Att förstå syntaxen är en grundläggande förutsättning för att kunna läsa och skriva kod i programmeringsspråk.

De viktigaste syntaxkonstruktionerna i SQL är SQL-satser, som också kan innehålla klausuler. Båda kallas vanligtvis för ”SQL-kommandon”, även om detta ur teknisk synvinkel inte är helt korrekt. Dessa är dock inte de enda SQL-syntaxkonstruktionerna. Nedan hittar du en tabell som ger dig en översikt över SQL-syntaxkonstruktionerna.

Hur exekveras SQL-kod?

SQL-kod finns som källkod i textfiler. Koden får liv först i en lämplig exekveringsmiljö. Källkoden läses av en SQL-tolkar och omvandlas till åtgärder i ett RDBMS. Det finns två grundläggande tillvägagångssätt här:

1. Kör SQL-kod interaktivtI det här tillvägagångssättet matas SQL-koden in eller kopieras direkt till ett textfönster. SQL-koden körs och resultatet visas. Du kan justera koden och köra den igen. Den snabba sekvensen av kodmanipulering och visning av resultat gör detta tillvägagångssä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ällkodsfil som innehåller SQL-kod rad för rad. Om det behövs skickas feedback endast till användaren i slutet av körningen. Denna metod är bäst lämpad för automatisering av processer och för import av MySQL-databasbackuper med MySQL dump.

Hur man konfigurerar ett produktledningssystem med SQL

Det enklaste sättet att lära sig ett programmeringsspråk är att skriva och köra kod själv. I den här handledningen ska vi skapa en minidatabas och köra frågor mot den. För att göra detta använder vi online-SQL-tolken från webbplatsen sql.js. För att följa handledningen går du till webbplatsen 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 resultaten.

Konfigurera en SQL-databas

I det här exemplet ska vi bygga ett kommersiellt produktledningssystem för en butik. Kravspecifikationen 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 beställningar kan innehålla flera produkter.
• För varje beställning lagrar vi beställningsdatum och uppgifter om den person som lagt beställningen, samt vilka produkter som beställts och i vilken mängd.

Dessa krav översätts till en abstrakt beskrivning och sedan till SQL-kod:

1. Skapa modell
2. Definiera schema
3. Ange dataposter
4. Definiera frågor

Skapa modell av enheter och relationer

Det första steget sker på papper eller med hjälp av speciella modelleringsverktyg. Vi samlar in information om det system som ska modelleras för att härleda enheter och relationer. Detta steg genomförs ofta i form av ett entitetsrelationsdiagram (ER-diagram).

Vilka enheter finns det och hur är de relaterade till varandra? Enheter är klasser av saker. I vårt exempel med produktledningssystemet är enheterna produkter, kunder och order. För varje enhet behövs en tabell. På grund av relationsmodellens särdrag läggs ytterligare tabeller till för att modellera relationerna. För att inse detta och implementera det på rätt sätt krävs erfarenhet.

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 riktningarna i en relation och skilja mellan singular och plural. Här är ett exempel med bilar och bilägare:

1. En ägare kan potentiellt äga flera bilar.
2. En bil kan bara tillhöra en ägare.

Tre möjliga relationsmönster framträder mellan de två enheterna:

Implementera produkter

Först implementerar vi produkttabellen. För att göra detta måste vi definiera ett schema, mata in dataposter och, för teständamål, utföra några enkla frågor.

Definiera schema

Det centrala SQL-kommandot för att definiera databastabeller är CREATE TABLE. Med detta kommando kan du skapa en tabell med ett namn och ange kolumnegenskaper. Samtidigt definieras datatyper och, om nödvändigt, begränsningar 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 datamängder

Nu ska vi skapa några testposter. Vi använder SQL-kommandot INSERT INTO och funktionen 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 kontrollera 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;

Implementera ytterligare tabeller

Därefter skapar vi de återstående tabellerna 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 dataposter för två exempelkunder:

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

För att kontrollera om det fungerade visar vi kundtabellen:

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å inköpsorder. För det första värdet i posterna tilldelar vi ett ID som primärnyckel. Det andra värdet är för befintliga kund-ID:n, som fungerar som främmande nycklar. Sedan lagrar vi orderdatumet:

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 produkterna i en order tillsammans 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 definierar en tabell som innehåller 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 beställningarna och produkterna så att det finns en beställning med två produkter och en annan beställning 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 kontrollera detta kommer vi att leverera de produkter som beställts:

SELECT * FROM OrderItems;

Skriv komplexa frågor

Om du har kört alla kodsnuttar som visats hittills bör du kunna förstå strukturen i vår testdatabas. 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 sammanfogar data som är fördelade över flera tabeller. Vi använder ett SQL JOIN- kommando för att sammanfoga tabellerna som innehåller kunddata och order. Samtidigt namnger vi kolumnerna och anger ett matchande kund-ID som ett JOIN-villkor. Tänk på att vi använder kvalificerade identifierare för att skilja mellan kolumnerna i de två tabellerna:

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

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;