A Step By Step Guide To Reading And Understanding SQL Queries - KDnuggets

Återutgiven av Platon

anhängare: 0

En steg-för-steg-guide för att läsa och förstå SQL-frågor
Bild av Freepik

SQL, or Standard Query Language, is a programming language for managing and manipulating data within a relational database management system (RDBMS). It’s a standard language used in many companies to help businesses access data smoothly. Because it’s widely used, the employment usually cites SQL as one of the necessary skills. That’s why it’s essential to learn about SQL.

Ett av de vanligaste problemen för människor när de lär sig SQL är att förstå frågorna, främst när en annan person skriver dem. Vi skulle arbeta som ett team i företagen och behöver ofta läsa och förstå deras SQL-frågor. Så vi måste öva på att dekonstruera SQL-frågorna och förstå dem.

Den här artikeln går igenom en steg-för-steg-process för att läsa och förstå SQL-frågor. Hur gör vi det? Låt oss gå in i det.

Det första vi behöver göra när vi stöter på en SQL-fråga är att förstå den allmänna avsikten med SQL-frågorna. Den allmänna avsikten betyder inte att vi vet helt om frågans struktur; det handlar mer om de övergripande flödena.

Vi bör förstå standard SQL-frågor för att förstå den allmänna SQL-frågan. De flesta SQL-frågor börjar med VÄLJA klausul och följ med FRÅN klausul. För att fortsätta därifrån följs frågorna oftast av JOIN, VAR, GRUPP AV, SORTERA EFTER, och HAR klausuler.

Klausulerna ovan är standard i de SQL-frågor vi behöver förstå. För varje klausul är deras funktioner:

VÄLJA: Vilka kolumner som ska tas från tabellen
FRÅN: Vilken tabell data kom från
JOIN: Kombinera tabeller med den angivna identifieraren
VAR: Datafilter baserat på tillståndet
GRUPP AV: Organisera data baserat på kolumnens värde och tillåt aggregeringsfunktion att utföras.
SORTERA EFTER: Ordna dataresultatordningen baserat på den specifika kolumnen
HAR: Filtervillkoret för aggregeringsfunktion som inte kan specificeras med VAR

Dessa är standardsatserna och vad du bör hitta i början när du förstår den allmänna SQL-frågestrukturen. Låt oss använda exempelkoden för att lära oss mer.

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 tittar på frågan ovan, försök att identifiera standardklausulerna. Klausulen skulle ge dig en förståelse för vilka data som väljs (VÄLJA), var den kommer ifrån (FRÅN och JOIN), och tillståndet (VAR, GRUPP AV, SORTERA EFTERoch HAR).

Om du till exempel läser frågan ovan skulle du få förståelse för följande:

vi försöker få tre olika typer av data: Namnet från en tabell som heter kunder, Produkten från en tabell som heter inköp, och aggregeringen av priskolumner som inte identifierar var tabellen kommer från och med aliaset total_price (Information från klausul VÄLJA).

Den övergripande informationen skulle komma från inköps- och kundtabeller som sammanfogas med hjälp av cust_id-kolumnen från inköp och id-kolumnen från kundens tabell (Information från klausul FRÅN) och JOIN).

Vi skulle bara välja data med kategorikolumnvärdet i inköpstabellen som "kök" (Information från klausul VAR),

grupp för aggregeringsfunktionen med namnet och produktkolumnen som kom från respektive tabell (Information från klausul GRUPP AV),

filtreras också från aggregeringsfunktionen resultatsumma där total_price är mer än 10000 (information från klausul HAR), Och

beställ data fallande enligt total_price (information från klausul SORTERA EFTER).

Det är den allmänna SQL-frågestrukturen du behöver känna till och identifiera. Därifrån kan vi utforska vidare från den avancerade frågan. Låt oss gå vidare med nästa steg.

Det skulle finnas en tid då du skulle stöta på en komplex fråga där så många VÄLJA klausuler finns i samma fråga. I det här fallet bör vi förstå det slutliga resultatet av frågan eller det slutliga (första) VÄLJA ser du i frågan. Nyckeln är att veta vad frågeutgången vill vara.

Låt oss använda en mer komplex kod som den nedan.

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;

Frågan verkar mer komplex och längre nu, men det initiala fokuset bör ligga på den slutliga VÄLJ, som verkar försöka ta fram kundens totala utgifter och köphistorik. Försök att bedöma vad slutresultatet vill bli och bryt ner det därifrån.

Vi har insikten om resultatet bör vara från frågorna. Nästa del är att se vilka förutsättningarna för finalen VÄLJA är. Villkorsklausulen, inklusive VAR, GRUPP AV, SORTERA EFTERoch HAR var de som kontrollerade det övergripande dataresultatet.

Försök att läsa och förstå villkoren för vår sökfråga, så kommer vi att bättre förstå vår frågas slutresultat. Till exempel, i vår tidigare SQL-fråga är det slutliga villkoret endast SORTERA EFTER. Detta innebär att det slutliga resultatet skulle sorteras efter det totala produktpriset i fallande ordning.

Att känna till de slutliga villkoren skulle hjälpa dig att förstå en betydande del av frågan och den övergripande frågans avsikt.

Slutligen måste vi förstå var data kommer ifrån. Efter att vi känner till data som ska väljas och villkoren för att få dem måste vi förstå källan. Den slutliga JOIN klausul skulle ge oss en förståelse för hur tabellerna interagerar och dataflödet.

Till exempel visar den tidigare komplexa frågan att vi utförde Join två gånger. Det betyder att vi använde minst tre datakällor för det slutliga resultatet. Denna information skulle vara nödvändig i de senare stegen för att ytterligare förstå hur varje datakälla kommer fram, särskilt när datakällan kommer från underfrågan.

Efter att ha förstått hur det slutliga resultatet ska bli och var det kommer ifrån måste vi titta närmare på detaljerna. Härifrån skulle vi backa in i varje underfråga och förstå varför de är strukturerade så.

Vi försöker dock inte titta på dem i top-down-strukturerna. Istället bör vi försöka titta på de delfrågor som är närmare slutresultatet, och vi går upp till den som ligger längst bort från slutresultatet. Från kodexemplet ovan bör vi försöka förstå den här koden 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

Sedan går vi till koden längst bort som är den här:

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 spåra författarens tankeprocess tydligt när vi bryter ner varje delfråga från den som ligger närmast resultatet till längst bort.

Försök att upprepa processen ovan om du behöver hjälp med att förstå varje delfråga. Med lite övning kommer du att få en bättre upplevelse av att läsa och förstå frågan.

Att läsa och förstå SQL-frågor är en färdighet som alla borde ha i modern tid, eftersom alla företag hanterar dem. Genom att använda följande steg-för-steg-guide skulle du ha bättre tid att förstå de komplexa SQL-frågorna. Stegen inkluderar:

Förstå den allmänna SQL-frågestrukturen
Förstå det slutliga valet
Förstå den slutgiltiga villkorsklausulen
Förstå Final Join
Omvänd ordningsföljd avläsning och upprepning

Cornellius Yudha Wijaya är biträdande chef för datavetenskap och dataskribent. Medan han arbetar heltid på Allianz Indonesia älskar han att dela Python- och Data-tips via sociala medier och skrivande media.