En av de största fördelarna med att använda relationsdatabaser som MySQL är att dess relationsstruktur låter dig enkelt lagra och fråga information i flera tabeller.
Låt oss undersöka hur du hämtar exakt de data du vill ha från flera databastabeller och de olika kopplingar som finns tillgängliga som gör att du kan få exakta resultat du vill ha.
Initiera provdatabasen
Detta krävs inte, men om du vill följa med exemplen i den här artikeln kan du initialisera en exempeldatabas lokalt med nedanstående terminalkommandon:
git klon https://github.com/mdizak/sample-select-db.git
cd sample-select-db
sudo mysql
mysql> VÄLJ RÄKN (*) FRÅN kunder;Du bör få ett resultat om att det finns 2000 rader inom kunder tabell.
Standard / INNER Gå med
Standardkopplingen används inom MySQL-databaser kallas INNER join, och är den vanligaste och rakt framåt. Den här kopplingen returnerar alla poster för vilka det finns matchande poster i båda tabellerna och avvisar alla andra poster.
Java tillhandahåller JDBC som en del av Java SDK. I den här artikeln ska vi titta på detaljerna i att ansluta till en MySQL-databas och utföra frågor med den.
Om du till exempel vill se kundens för- och efternamn, plus orderbelopp och datum för alla beställningar större än $ 1000, kan du använda följande SQL-uttalande:
VÄLJ
c.id, c.first_name, c.last_name, o.belopp, o.created_at
FRÅN
kunder c, beställningar o
VAR
o.customer_id = c.id OCH o.belopp> = 1000;
Några anteckningar angående ovanstående fråga:
- Fem olika kolumner väljs, tre från kundtabellen och två från ordertabellen.
- Inom FROM-satsen definieras de två tabellerna, men efterföljs av bokstäverna "c" och "o". Dessa anger helt enkelt alias inom SQL, kan vara vad du vill och används för att förkorta SQL-frågan.
- De o.customer_id = c.id är kopplingsaspekten av frågan och säkerställer korrekt korrelation mellan kunder och order.
Ett annat och tekniskt mer syntaktiskt korrekt sätt att skriva samma fråga är nedan:
VÄLJ
c.id, c.first_name, c.last_name, o.belopp, o.created_at
FRÅN
kunder c INNRE JOIN-beställningar o
PÅ
kund_id = c.id
VAR
o.belopp> = 1000;
Ovanstående fråga tenderar att vara lite lättare att läsa eftersom du enkelt kan se kopplingen mellan kund- och ordertabellen. För alla ändamål är dessa två frågor likadana och kommer att producera exakt samma poster.
VÄNSTER går med
Vänster sammanfogningar returnerar alla poster från den vänstra tabellen som också matchar poster från den högra tabellen och avvisar alla andra poster. Du kanske till exempel vill se det totala försäljningsbeloppet för varje produkt i databasen, du kan försöka använda en fråga som:
VÄLJ
p.name, sum (artikel.belopp) SOM belopp
FRÅN
orders_items artikel LEFT JOIN produkter s
PÅ
item.product_id = p.id
GRUPP PÅ artikel.produkt_ID BESTÄLLNING AV TILLBAKA DESC
Detta resulterar i en fin tvåkolumnvy som visar produktnamnet med det totala försäljningsbeloppet och fungerar som förväntat. Frågan gick igenom alla produkter inom order_items-tabellen, sammanfogade dem till poster i produkttabellen och returnerade det totala försäljningsbeloppet för varje.
RÄTT Går med
Använd ovanstående exempel och notera att frågan ovan bara returnerade 19 poster medan det totalt finns 22 produkter i databasen. Detta beror på att frågan började med order_items-tabellen och lämnade den till produkttabellen och eftersom vissa produkter aldrig har beställts finns inga register över dessa produkter inom orders_items tabell.
Vad händer om du vill få en lista över alla produkter med försäljningsbelopp, inklusive produkter som inte har beställts? Försök med en rätt anslutning med följande fråga:
VÄLJ
p.name, sum (artikel.belopp) SOM belopp
FRÅN
orders_items artikel RIGHT JOIN produkter s
PÅ
item.product_id = p.id
GRUPP VID p.id BESTÄLLNING AV TAMONT DESC
Det är bättre, och frågan returnerar nu hela 22 produkterna, varav tre av dem har en mängd null. Detta beror på att i stället för att använda orders_items som den primära tabellen som går med i produkttabellen, vänder den högra kopplingen ordern och kopplar produkttabellen till order_items-tabellen.
Flera sammanfogningar i en fråga
Ibland har du ett behov av att gå med i tre eller flera tabeller för att få en specifik uppsättning resultat.
Du kanske till exempel vill ha en lista över alla kunder som har köpt mikrovågsugnen (produkt-ID nr 1), inklusive deras namn och orderdatum. Detta kräver ett VÄLJ mellan tre tabeller som kan göras genom att använda två sammanfogningar med följande fråga:
VÄLJ
c.first_name, c.last_name, o.belopp, o.created_at
FRÅN
kunder c INNRE JOIN-beställningar o
PÅ
c.id = o.customer_id INNER JOIN orders_items artikel
PÅ
item.order_id = o.id
VAR
item.product_id = 1 BESTÄLLNING AV o.created_at;
Denna fråga returnerar alla 426 beställningar av mikrovågsugnen och fungerar som förväntat. Det matchar först alla kunder med deras respektive beställningar, sedan ytterligare frågor som resultatet ställs in av matchar alla beställningar till endast de inom order_items-tabellen som innehåller mikrovågsprodukten (id # 1).
Använd aldrig underfrågor med IN-klausuler
Som en snabb sidanot bör du till varje pris alltid undvika att använda underfrågor inom dina SQL-frågor som:
VÄLJ förnamn, efternamn FRÅN kunder VAR id IN (VÄLJ kund_id FRÅN beställningar VAR status = 'godkänd' OCH belopp <100);Frågor som ovan är mycket ineffektiva, använder ett stort antal resurser och bör undvikas så mycket som möjligt. Använd istället rätt kopplingar som beskrivs i ovanstående avsnitt. Till exempel bör ovanstående fråga skrivas om som:
VÄLJ c.first_name, c.last_name FRÅN kunder c VÄNSTER JOIN-beställningar o PÅ o.customer_id = c.id VAR o.status = 'godkänd' OCH o.belopp <100;Spara tid med SQL-anslutningar
Den här artikeln har förhoppningsvis hjälp att visa dig kraften i relationsdatabaser som MySQL och hur du bygger SQL-frågor som hämtar poster från flera tabeller inom en fråga med hjälp av sammanfogningar, så att du kan hämta exakta resultat.
Du har lärt dig tre olika kopplingar inom SQL, hur man alias kolumn- och tabellnamn, använder flera kopplingar i en fråga och varför du bör undvika underfrågor. Förvräng dig aldrig igen och försök att kompilera olika datauppsättningar manuellt till en och börja använda kopplingar för att imponera på dina arbetskollegor och spara tid.
Google Docs är nu ett kontorskraftverk. Med hjälp av dessa tillägg kan du få dina Google Docs att se snygga och snygga ut.
- Programmering
- SQL
- databas
Prenumerera på vårt nyhetsbrev
Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e-böcker och exklusiva erbjudanden!
Ett steg till…!
Bekräfta din e-postadress i e-postmeddelandet som vi just skickade till dig.
