SQLite stöder olika typer av SQL Joins, som INNER JOIN, LEFT OUTER JOIN och CROSS JOIN. Varje typ av JOIN används för en annan situation som vi kommer att se i denna handledning.
I den här handledningen lär du dig-
- Introduktion till SQLite JOIN-klausul
- INRE KOPPLING
- GÅ MED ... ANVÄNDA
- NATURLIGT GÅ MED
- VÄNSTER YTTRE GÅNG
- CROSS JOIN
Introduktion till SQLite JOIN-klausul
När du arbetar med en databas med flera tabeller behöver du ofta hämta data från dessa flera tabeller.
Med JOIN-klausulen kan du länka två eller flera tabeller eller underfrågor genom att gå med i dem. Du kan också definiera vilken kolumn du behöver för att länka tabellerna och efter vilka villkor.
Alla JOIN-klausuler måste ha följande syntax:
Varje anslutningsklausul innehåller:
- En tabell eller en underfråga som är den vänstra tabellen; tabellen eller underfrågan före anslutningsklausulen (till vänster om den).
- JOIN-operatör - ange anslutningstyp (antingen INNER JOIN, LEFT OUTER JOIN eller CROSS JOIN).
- JOIN-begränsning - efter att du har angett de tabeller eller underfrågor som ska kopplas till måste du ange en kopplingsbegränsning, vilket är ett villkor för vilket de matchande raderna som matchar det villkoret kommer att väljas beroende på kopplingstypen.
Observera att för alla följande exempel måste du köra sqlite3.exe och öppna en anslutning till exempeldatabasen som flödande:
Steg 1) I detta steg,
- Öppna Den här datorn och navigera till följande katalog " C: \ sqlite " och
- Öppna sedan " sqlite3.exe ":
Steg 2) Öppna databasen " TutorialsSampleDB.db " med följande kommando:
Nu är du redo att köra alla typer av frågor i databasen.
SQLite INNER JOIN
INNER JOIN returnerar bara de rader som matchar kopplingsvillkoret och eliminerar alla andra rader som inte matchar kopplingsvillkoret.
Exempel
I följande exempel kommer vi att sammanfoga de två tabellerna " Studenter " och " Institutioner " med DepartmentId för att få avdelningsnamnet för varje student enligt följande:
VÄLJStudents.StudentName,Avdelningar. AvdelningsnamnFRÅN studenterINNER JOIN Institutioner PÅ Students.DepartmentId = Institutioner.DepartmentId;
Förklaring av kod:
INNER JOIN fungerar som följer:
- I Select-satsen kan du välja vilka kolumner du vill välja från de två refererade tabellerna.
- INNER JOIN-satsen skrivs efter att den första tabellen refereras till "From" -satsen.
- Då anges kopplingsvillkoret med PÅ.
- Alias kan anges för refererade tabeller.
- INNER-ordet är valfritt, du kan bara skriva JOIN.
Produktion:
- INNER JOIN producerar posterna från båda - studenterna och institutionens tabeller som matchar villkoret som är " S tudents.DepartmentId = Departments.DepartmentId ". De omatchade raderna ignoreras och ingår inte i resultatet.
- Det var därför endast 8 studenter från 10 studenter återlämnades från denna fråga med IT-, matematik- och fysikavdelningar. Medan eleverna "Jena" och "George" inte inkluderades, eftersom de har ett null-avdelnings-ID, vilket inte matchar avdelningen DepartmentId från avdelningstabellen. Enligt följande:
SQLite GÅ MED ... ANVÄNDA
INNER JOIN kan skrivas med hjälp av "USING" -satsen för att undvika redundans, så istället för att skriva "ON Students.DepartmentId = Departments.DepartmentId" kan du bara skriva "USING (DepartmentID)".
Du kan använda "GÅ MED ... ANVÄNDA" när kolumnerna du jämför i anslutningsvillkoret har samma namn. I sådana fall finns det inget behov av att upprepa dem med on-condition och ange bara kolumnnamnen och SQLite kommer att upptäcka det.
Skillnaden mellan INNER JOIN och JOIN ... ANVÄNDNING:
Med "JOIN
... ANVÄNDAR "du skriver inte ett kopplingsvillkor, du skriver bara kopplingskolumnen som är gemensamt mellan de två sammanfogade tabellerna, istället för att skriva tabell1" INNRE JOIN-tabell2 PÅ table1.cola = table2.cola "vi skriver det som" table1 JOIN table2 USING (cola) ".Exempel
I följande exempel kommer vi att sammanfoga de två tabellerna " Studenter " och " Institutioner " med DepartmentId för att få avdelningsnamnet för varje student enligt följande:
VÄLJStudents.StudentName,Avdelningar. AvdelningsnamnFRÅN studenterINNER JOIN Avdelningar som ANVÄNDER (DepartmentId);
Förklaring
- Till skillnad från föregående exempel skrev vi inte " ON Students.DepartmentId = Departments.DepartmentId ". Vi skrev just " USING (DepartmentId) ".
- SQLite grundar sig på kopplingsvillkoret automatiskt och jämför DepartmentId från båda tabellerna - studenter och institutioner.
- Du kan använda denna syntax när de två kolumnerna du jämför med har samma namn.
Produktion
- Detta ger dig samma exakta resultat som föregående exempel:
SQLite NATURAL JOIN
En NATURLIG JOIN liknar en JOIN ... ANVÄNDNING, skillnaden är att den automatiskt testar för likvärdighet mellan värdena för varje kolumn som finns i båda tabellerna.
Skillnaden mellan INNER JOIN och en NATURLIG JOIN:
- I INNER JOIN måste du ange ett kopplingsvillkor som den inre kopplingen använder för att sammanfoga de två tabellerna. I det naturliga kopplingen skriver du inte ett kopplingsvillkor. Du skriver bara namnen på de två tabellerna utan några villkor. Då testar den naturliga kopplingen automatiskt för likvärdighet mellan värdena för varje kolumn finns i båda tabellerna. Naturlig koppling leder till kopplingsvillkoret automatiskt.
- I NATURAL JOIN matchas alla kolumner från båda tabellerna med samma namn mot varandra. Om vi till exempel har två tabeller med två kolumnnamn gemensamt (de två kolumnerna finns med samma namn i de två tabellerna) kommer den naturliga kopplingen att sammanfoga de två tabellerna genom att jämföra värdena för båda kolumnerna och inte bara från en kolumn.
Exempel
VÄLJStudents.StudentName,Avdelningar. AvdelningsnamnFRÅN studenterNatural JOIN-avdelningar;
Förklaring
- Vi behöver inte skriva ett kopplingsvillkor med kolumnnamn (som vi gjorde i INNER JOIN). Vi behövde inte ens skriva kolumnnamnet en gång (som vi gjorde i JOIN USING).
- Den naturliga kopplingen skannar båda kolumnerna från de två tabellerna. Det kommer att upptäcka att villkoret bör bestå av att jämföra DepartmentId från både de två tabellerna Studenter och institutioner.
Produktion
- Natural JOIN ger dig samma exakta resultat som den output vi fick från INNER JOIN och JOIN USING-exemplen. Eftersom i vårt exempel är alla tre frågorna ekvivalenta. Men i vissa fall kommer produktionen att skilja sig från den inre kopplingen och sedan i en naturlig koppling. Till exempel, om det finns fler tabeller med samma namn, kommer den naturliga kopplingen att matcha alla kolumner mot varandra. Emellertid matchar den inre kopplingen endast kolumnerna i kopplingsvillkoret (mer information om nästa avsnitt; skillnaden mellan den inre kopplingen och den naturliga kopplingen).
SQLite VÄNSTER YTTRE GÅNG
SQL-standarden definierar tre typer av OUTER JOIN: LEFT, RIGHT och FULL men SQLite stöder endast LEFT OUTER JOIN.
I VÄNSTER OUTER JOIN kommer alla värden för de kolumner du väljer i den vänstra tabellen att inkluderas i resultatet av frågan, så oavsett värdet matchar kopplingsvillkoret eller inte kommer det att inkluderas i resultatet.
Så om den vänstra tabellen har 'n' rader, kommer resultaten av frågan att ha 'n' rader. Men för värdena för kolumnerna som kommer från höger tabell, om något värde som inte matchar kopplingsvillkoret kommer det att innehålla ett "null" -värde.
Så du får ett antal rader som motsvarar antalet rader i vänster koppling. Så att du får matchande rader från båda tabellerna (som INNER JOIN-resultaten), plus de un-matchande raderna från vänster tabell.
Exempel
I följande exempel försöker vi "VÄNSTER JOIN" för att gå med i de två tabellerna "Studenter" och "Institutioner":
VÄLJStudents.StudentName,Avdelningar. AvdelningsnamnFRÅN studenter - detta är den vänstra tabellenVÄNSTER GÅ MED Institutioner PÅ Students.DepartmentId = Institutioner.DepartmentId;
Förklaring
- VÄNSTER JOIN syntax är densamma som INNER JOIN; du skriver VÄNSTER JOIN mellan de två tabellerna och sedan kommer anslutningsvillkoret efter PÅ-klausulen.
- Den första tabellen efter från-klausulen är den vänstra tabellen. Medan den andra tabellen som anges efter vänster koppling är den högra tabellen.
- OUTER-klausulen är valfri; VÄNSTER YTTRE JOIN är samma som VÄNSTER JOIN.
Produktion
- Som du kan se ingår alla rader från studenttabellen som totalt är 10 elever. Även om den fjärde och den sista studenten, Jena och George avdelning Id inte finns i avdelningstabellen, ingår de också.
- Och i dessa fall kommer departmentName-värdet för både Jena och George att vara "null" eftersom avdelningstabellen inte har ett departmentName som matchar deras departmentId-värde.
Låt oss ge föregående fråga med vänster gå med en djupare förklaring med Van-diagram:
VÄNSTER JOIN ger alla elevernas namn från studenttabellen även om studenten har ett avdelnings-ID som inte finns i avdelningstabellen. Så, frågan ger dig inte bara matchande rader som INNER JOIN, utan ger dig den extra delen som har de omatchade raderna från den vänstra tabellen som är studenttabellen.
Observera att alla studentnamn som inte har någon matchande avdelning kommer att ha ett "null" -värde för avdelningsnamnet, eftersom det inte finns något matchande värde för det, och dessa värden är värdena i de icke-matchande raderna.
SQLite CROSS JOIN
En CROSS JOIN ger den kartesiska produkten för de valda kolumnerna i de två sammanfogade tabellerna genom att matcha alla värden från den första tabellen med alla värden från den andra tabellen.
Så för varje värde i den första tabellen får du n-matchningar från den andra tabellen där n är antalet andra tabellrader.
Till skillnad från INNER JOIN och LEFT OUTER JOIN, med CROSS JOIN, behöver du inte ange ett kopplingsvillkor, eftersom SQLite inte behöver det för CROSS JOIN.
SQLite resulterar i logiska resultatuppsättningar genom att kombinera alla värden från den första tabellen med alla värden från den andra tabellen.
Till exempel om du valde en kolumn från den första tabellen (colA) och en annan kolumn från den andra tabellen (colB). ColA innehåller två värden (1,2) och colB innehåller också två värden (3,4).
Då blir resultatet av CROSS JOIN fyra rader:
- Två rader genom att kombinera det första värdet från colA som är 1 med de två värdena för colB (3,4) som kommer att vara (1,3), (1,4).
- På samma sätt två rader genom att kombinera det andra värdet från colA som är 2 med de två värdena för colB (3,4) som är (2,3), (2,4).
Exempel
I följande fråga kommer vi att försöka CROSS JOIN mellan tabellerna Students and Institutions:
VÄLJStudents.StudentName,Avdelningar. AvdelningsnamnFRÅN studenterCROSS JOIN Avdelningar;
Förklaring
- I select-satsen valde vi bara två kolumner "studentnamn" från studenttabellen och "departmentName" från avdelningstabellen.
- För tvärföreningen angav vi inget kopplingsvillkor, bara de två tabellerna i kombination med CROSS JOIN i mitten av dem.
Produktion:
Som du kan se är resultatet 40 rader; 10 värden från studenttabellen matchade mot de fyra avdelningarna från avdelningstabellen. Enligt följande:
- Fyra värden för de fyra institutionerna från institutionstabellen matchade med den första studenten Michel.
- Fyra värden för de fyra avdelningarna från avdelningstabellen matchade med den andra studenten John.
- Fyra värden för de fyra avdelningarna från avdelningstabellen matchade med den tredje studenten Jack.
… och så vidare.
Sammanfattning
Med SQLite JOINs kan du länka en eller flera tabeller eller underfrågor för att välja kolumner från båda tabellerna eller underfrågorna.