En trinvis vejledning til at læse og forstå SQL-forespørgsler - KDnuggets

Genudgivet af Platon

Abonnenter: 0

En trinvis vejledning til at læse og forstå SQL-forespørgsler
Billede af Freepik

SQL, eller Standard Query Language, er et programmeringssprog til styring og manipulation af data i et relationelt databasestyringssystem (RDBMS). Det er et standardsprog, der bruges i mange virksomheder til at hjælpe virksomheder med at få adgang til data problemfrit. Fordi det er meget udbredt, nævner ansættelsen normalt SQL som en af de nødvendige færdigheder. Derfor er det vigtigt at lære om SQL.

Et af de almindelige problemer for folk, når de lærer SQL, er at forstå forespørgslerne, primært når en anden person skriver dem. Vi ville arbejde som et team i virksomhederne og har ofte brug for at læse og forstå deres SQL-forespørgsler. Så vi skal øve os i at dekonstruere SQL-forespørgslerne og forstå dem.

Denne artikel vil gennemgå en trin-for-trin-proces for at læse og forstå SQL-forespørgsler. Hvordan gør vi det? Lad os komme ind i det.

Den første ting, vi skal gøre, når vi støder på en SQL-forespørgsel, er at forstå den generelle hensigt med SQL-forespørgslerne. Den generelle hensigt betyder ikke, at vi kender helt til forespørgslens struktur; det handler mere om de overordnede flows.

Vi bør forstå standard SQL-forespørgsler for at forstå den generelle SQL-forespørgsel. De fleste SQL-forespørgsler starter med SELECT klausul og følg med FRA klausul. Fortsat derfra bliver forespørgslerne oftest efterfulgt af JOIN, HVOR, GROUP BY, BESTIL AF, , SOM klausuler.

Ovenstående klausuler er standard i de SQL-forespørgsler, vi skal forstå. For hver klausul er deres funktioner:

SELECT: Hvilke kolonner skal tages fra tabellen
FRA: Hvilken tabel dataene kom fra
JOIN: Kombiner tabeller med den angivne identifikator
HVOR: Datafilter baseret på tilstanden
GROUP BY: Organiser dataene baseret på kolonnens værdi og tillad, at aggregeringsfunktionen udføres.
BESTIL BY: Arranger dataresultatrækkefølgen baseret på den specifikke kolonne
SOM: Filterbetingelsen for aggregeringsfunktion, som ikke kan specificeres med HVOR

Disse er standardklausulerne, og hvad du bør finde i begyndelsen, når du forstår den generelle SQL-forespørgselsstruktur. Lad os bruge eksempelkoden til at lære yderligere.

SELECT 
  customers.name, 
  purchases.product, 
  SUM(price) as total_price 
FROM 
  purchases 
  JOIN customers ON purchases.cust_id = customers.id 
WHERE 
  purchases.category = 'kitchen' 
GROUP BY 
  customers.name, 
  purchases.product 
HAVING 
  total_price > 10000 
ORDER BY 
  total_price DESC;

Når du ser på forespørgslen ovenfor, så prøv at identificere standardklausulerne. Klausulen vil give dig en forståelse af, hvilke data der er valgt (SELECT), hvor det er fra (FRA , JOIN), og tilstanden (HVOR, GROUP BY, BESTIL BYog SOM).

For eksempel vil læsning af forespørgslen ovenfor give dig forståelse for følgende:

vi forsøger at få tre forskellige slags data: Navnet fra en tabel kaldet kunder, Produktet fra en tabel kaldet indkøb, og aggregeringen af priskolonner, der ikke identificerer, hvor tabellen er fra og med aliaset total_price (Information fra klausul SELECT).

De overordnede data ville komme fra købs- og kundetabeller, der slutter sig sammen ved hjælp af cust_id-kolonnen fra indkøb og id-kolonnen fra kundens tabel (Information fra klausul FRA) , JOIN).

Vi ville kun vælge data med kategorikolonnens værdi i købstabellen som 'køkken' (Information fra klausul HVOR),

gruppe for aggregeringsfunktionen med navnet og produktkolonnen, der kom fra den respektive tabel (Information fra klausul GROUP BY),

filtreret også fra aggregeringsfunktionen resultatsum, hvor total_price er mere end 10000 (information fra klausul SOM), Og

bestil dataene faldende i henhold til total_price (information fra klausul BESTIL BY).

Det er den generelle SQL-forespørgselsstruktur, du skal kende og identificere. Derfra kan vi udforske yderligere fra den avancerede forespørgsel. Lad os komme videre med næste trin.

Der ville være et tidspunkt, hvor du ville støde på en kompleks forespørgsel, hvor så mange SELECT klausuler findes i den samme forespørgsel. I dette tilfælde bør vi forstå det endelige resultat af forespørgslen eller det endelige (første) SELECT du ser i forespørgslen. Nøglen er at vide, hvad forespørgselsoutputtet vil være.

Lad os bruge en mere kompleks kode som den nedenfor.

WITH customerspending AS (
  SELECT 
    customers.id, 
    SUM(purchases.price) as total_spending 
  FROM 
    purchases 
    JOIN customers ON purchases.cust_id = customers.id 
  GROUP BY 
    customers.id
) 
SELECT 
  c.name, 
  pd.product, 
  pd.total_product_price, 
  cs.total_spending 
FROM 
  (
    SELECT 
      purchases.cust_id, 
      purchases.product, 
      SUM(purchases.price) as total_product_price 
    FROM 
      purchases 
    WHERE 
      purchases.category = 'kitchen' 
    GROUP BY 
      purchases.cust_id, 
      purchases.product 
    HAVING 
      SUM(purchases.price) > 10000
  ) AS pd 
  JOIN customers c ON pd.cust_id = c.id 
  JOIN customerspending cs ON c.id = cs.id 
ORDER BY 
  pd.total_product_price DESC;

Forespørgslen virker mere kompleks og længere nu, men det første fokus bør være på den endelige VÆLG, som ser ud til at forsøge at producere kundens samlede forbrug og købshistorik. Prøv at vurdere, hvad det endelige resultat vil være, og bryd det ned derfra.

Vi har indsigt i, at resultatet skal være fra forespørgslerne. Den næste del er at se, hvad betingelserne for finalen SELECT er. Betingelsesparagraffen, herunder HVOR, GROUP BY, BESTIL BYog SOM var dem, der kontrollerede det samlede dataresultat.

Prøv at læse og forstå vores forespørgsels betingelser, og vi vil bedre forstå vores forespørgsels endelige resultat. For eksempel, i vores tidligere SQL-forespørgsel er den endelige betingelse kun BESTIL BY. Dette betyder, at det endelige resultat vil blive sorteret efter den samlede produktpris i faldende rækkefølge.

At kende de endelige betingelser vil hjælpe dig med at forstå en væsentlig del af forespørgslen og den overordnede forespørgselshensigt.

Til sidst skal vi forstå, hvor dataene kommer fra. Når vi kender de data, der skal vælges, og betingelserne for at få dem, skal vi forstå kilden. Finalen JOIN klausul ville give os en forståelse af, hvordan tabellerne interagerer og datastrømmen.

For eksempel viser den tidligere komplekse forespørgsel, at vi udførte Join to gange. Det betyder, at vi brugte mindst tre datakilder til det endelige resultat. Disse oplysninger ville være nødvendige i de senere trin for yderligere at forstå, hvordan hver datakilde kommer forbi, især når datakilden kommer fra underforespørgslen.

Efter at have forstået, hvordan det endelige resultat skal være, og hvor det kommer fra, skal vi se nærmere på detaljerne. Herfra ville vi gå tilbage til hver underforespørgsel og forstå, hvorfor de er struktureret sådan.

Vi forsøger dog ikke at se på dem i top-down strukturerne. I stedet skal vi prøve at se på de underforespørgsler, der er tættere på det endelige resultat, og vi rykker op til den, der er længst væk fra det endelige resultat. Fra kodeeksemplet ovenfor bør vi prøve at forstå denne kode først:

SELECT 
  purchases.cust_id, 
  purchases.product, 
  SUM(purchases.price) as total_product_price 
FROM 
  purchases 
WHERE 
  purchases.category = 'kitchen' 
GROUP BY 
  purchases.cust_id, 
  purchases.product 
HAVING 
  SUM(purchases.price) > 10000

Derefter flytter vi til den fjerneste kode, som er denne:

WITH customerspending AS (
  SELECT 
    customers.id, 
    SUM(purchases.price) as total_spending 
  FROM 
    purchases 
    JOIN customers ON purchases.cust_id = customers.id 
  GROUP BY 
    customers.id
)

Vi kan opspore forfatterens tankeproces tydeligt, når vi opdeler hver underforespørgsel fra den, der er tættere på resultatet, til den længste.

Prøv at gentage processen ovenfor, hvis du har brug for hjælp til at forstå hver underforespørgsel. Med lidt øvelse vil du få en bedre oplevelse med at læse og forstå forespørgslen.

At læse og forstå SQL-forespørgsler er en færdighed, som alle burde have i den moderne æra, da enhver virksomhed beskæftiger sig med dem. Ved at bruge den følgende trin-for-trin guide, ville du have bedre tid til at forstå de komplekse SQL-forespørgsler. Trinene omfatter:

Forstå den generelle SQL-forespørgselsstruktur
Forstå det endelige valg
Forstå den endelige vilkårsklausul
Forstå den endelige tilslutning
Omvendt rækkefølge aflæsning og gentag

Cornellius Yudha Wijaya er en data science assisterende leder og dataskribent. Mens han arbejder på fuld tid hos Allianz Indonesia, elsker han at dele Python- og Data-tips via sociale medier og skrivemedier.