Een van de grootste voordelen van het gebruik van relationele databases zoals MySQL is dat u dankzij de relationele structuur gemakkelijk informatie over meerdere tabellen kunt opslaan en opvragen.
Laten we eens kijken hoe u precies de gewenste gegevens uit meerdere databasetabellen kunt halen en welke verschillende joins beschikbaar zijn waarmee u de exacte resultaten kunt ophalen die u wilt.
Initialiseer de voorbeelddatabase
Dit is niet vereist, maar als u de voorbeelden in dit artikel wilt volgen, kunt u een voorbeelddatabase lokaal initialiseren met de onderstaande terminalopdrachten:
git kloon https://github.com/mdizak/sample-select-db.git
cd sample-select-db
sudo mysql
mysql> SELECTEER AANTAL (*) VAN klanten;U zou een resultaat moeten krijgen waarin staat dat er 2000 rijen zijn binnen het klanten tafel.
Standaard / BINNEN Deelnemen
De standaard join die binnen wordt gebruikt MySQL-databases wordt de INNER-join genoemd en is de meest voorkomende en ongecompliceerde. Deze samenvoeging retourneert alle records waarvoor er overeenkomende records in beide tabellen zijn en verwijdert alle andere records.
Java biedt JDBC als onderdeel van de Java SDK. Laten we in dit artikel eens kijken naar de details van het verbinden met een MySQL-database en het uitvoeren van zoekopdrachten ermee.
Als u bijvoorbeeld de voor- en achternaam van de klant wilt zien, plus het bestelbedrag en de datum voor alle bestellingen van meer dan $ 1000, kunt u de volgende SQL-instructie gebruiken:
SELECTEER
c.id, c.first_name, c.last_name, o. amount, o.created_at
VAN
klanten c, bestellingen o
WAAR
o.customer_id = c.id EN o.amount> = 1000;
Een paar opmerkingen met betrekking tot de bovenstaande vraag:
- Er worden vijf verschillende kolommen geselecteerd, drie uit de klantentafel en twee uit de besteltafel.
- Binnen de FROM-clausule zijn de twee tabellen gedefinieerd, maar met de letters "c" en "o" als achtervoegsel. Deze specificeren eenvoudig aliassen binnen SQL, kunnen alles zijn wat u maar wilt en worden gebruikt om de SQL-query in te korten.
- De o.customer_id = c.id is het join-aspect van de vraag en zorgt voor een goede correlatie tussen klanten en bestellingen.
Een andere en technisch meer syntactisch correcte manier om dezelfde query te schrijven is hieronder:
SELECTEER
c.id, c.first_name, c.last_name, o. amount, o.created_at
VAN
klanten c INNER JOIN bestellingen o
AAN
customer_id = c.id
WAAR
o.hoeveelheid> = 1000;
De bovenstaande vraag is meestal iets gemakkelijker te lezen, omdat u gemakkelijk de verbinding tussen de tabel met klanten en bestellingen kunt zien. Deze twee query's zijn echter in alle opzichten hetzelfde en zullen exact dezelfde records opleveren.
LINKS sluit zich aan
Left joins retourneren alle records uit de linkertabel die ook overeenkomen met records uit de rechtertabel, en negeren alle andere records. Als u bijvoorbeeld het totale aantal verkopen voor elk product in de database wilt zien, kunt u een zoekopdracht proberen zoals:
SELECTEER
p.name, sum (item.amount) AS tamount
VAN
orders_items item LEFT JOIN producten p
AAN
item.product_id = p.id
GROEP BY item.product_id ORDER BY tamount DESC
Dit resulteert in een mooie weergave in twee kolommen met de productnaam met het totale verkoopbedrag, en werkt zoals verwacht. De query ging door alle producten in de tabel orders_items, voegde ze samen met records in de producttabel en leverde het totale verkoopbedrag van elk op.
RIGHT sluit zich aan
Houd er met het bovenstaande voorbeeld rekening mee dat de bovenstaande zoekopdracht slechts 19 records heeft geretourneerd, terwijl er in totaal 22 producten in de database zijn. Dit komt doordat de zoekopdracht begon met de tabel orders_items en links is toegevoegd aan de producttabel, en aangezien sommige producten nooit zijn besteld, bestaan er geen records van die producten binnen de orders_items tafel.
Wat gebeurt er als u een lijst wilt krijgen van alle producten met verkoopbedragen, inclusief producten die niet zijn besteld? Probeer een juiste join met de volgende vraag:
SELECTEER
p.name, sum (item.amount) AS tamount
VAN
orders_items item RIGHT JOIN producten p
AAN
item.product_id = p.id
GROEP OP p.id BESTEL OP tamount DESC
Dat is beter, en de query retourneert nu de volledige 22 producten, waarvan er drie een aantal hebben van nul. Dit komt doordat in plaats van orders_items te gebruiken als de primaire tabel die samenkomt met de producttabel, de juiste join de order omdraait en de producttabel samenvoegt met de orders_items-tabel.
Meerdere joins in een query
Soms is het nodig om drie of meer tafels samen te voegen om een specifieke reeks resultaten te krijgen.
U wilt bijvoorbeeld een lijst met alle klanten die de magnetron hebben gekocht (product-id # 1), inclusief hun naam en besteldatum. Dit vereist een SELECT over drie tabellen die kan worden gedaan door twee joins te gebruiken met de volgende query:
SELECTEER
c.first_name, c.last_name, o.amount, o.created_at
VAN
klanten c INNER JOIN bestellingen o
AAN
c.id = o.customer_id INNER JOIN orders_items item
AAN
item.order_id = o.id
WAAR
item.product_id = 1 BESTELLING DOOR o.created_at;
Deze query retourneert alle 426 bestellingen van de magnetron en werkt zoals verwacht. Het koppelt eerst alle klanten aan hun respectievelijke bestellingen, en vervolgens worden verdere vragen ingesteld door het matchen van alle bestellingen met alleen die in de orders_items-tabel die het magnetronproduct (id # 1).
Gebruik nooit subquery's met IN-clausules
Als een snelle opmerking: u moet koste wat het kost altijd vermijden om subquery's te gebruiken binnen uw SQL-query's, zoals:
SELECT voornaam, achternaam VAN klanten WHERE id IN (SELECT klant_id VAN bestellingen WHERE status = 'goedgekeurd' EN bedrag <100);Query's zoals hierboven zijn erg inefficiënt, gebruiken een groot aantal bronnen en moeten zoveel mogelijk worden vermeden. Gebruik in plaats daarvan de juiste joins zoals beschreven in de bovenstaande secties. De bovenstaande zoekopdracht moet bijvoorbeeld herschreven worden als:
SELECTEER c.first_name, c.last_name VAN klanten c LINKS JOIN bestellingen o OP o.customer_id = c.id WAAR o.status = 'goedgekeurd' EN o.bedrag <100;Bespaar tijd met SQL-joins
Dit artikel heeft u hopelijk geholpen om u de kracht van relationele databases zoals MySQL te laten zien, en hoe u deze kunt bouwen SQL-query's die records uit meerdere tabellen binnen één query ophalen met behulp van joins, zodat u de exacte gewenste resultaten kunt ophalen.
U hebt drie verschillende joins binnen SQL geleerd, hoe u een alias maakt voor kolom- en tabelnamen, meerdere joins in één query gebruikt en waarom u subquery's moet vermijden. Nooit meer ronddraaien om handmatig verschillende datasets tot één te compileren, en gebruik joins om indruk te maken op uw collega's en tijd te besparen.
Google Documenten is nu een krachtpatser op kantoor. Met behulp van deze add-ons kunt u uw Google-documenten er mooi en stijlvol uit laten zien.
- Programmeren
- SQL
- database
Abonneer op onze nieuwsbrief
Word lid van onze nieuwsbrief voor technische tips, recensies, gratis e-boeken en exclusieve deals!
Nog een stap…!
Bevestig uw e-mailadres in de e-mail die we u zojuist hebben gestuurd.