SQLite Gå med: Naturlig vänster yttre, inre, kors med bord Exempel

SQLite stöder olika typer av SQL Går med, som INNER JOIN, LEFT OUTER JOIN och CROSS JOIN. Varje typ av JOIN används för olika situationer som vi kommer att se i den här handledningen.

Introduktion till SQLite GÅ MED 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-satsen kan du länka två eller flera tabeller eller underfrågor genom att sammanfoga dem. Du kan också definiera med vilken kolumn du behöver länka tabellerna och med vilka villkor.

Varje JOIN-sats måste ha följande syntax:

Varje join-klausul innehåller:

• En tabell eller en underfråga som är den vänstra tabellen; tabellen eller underfrågan före join-satsen (till vänster om den).
• JOIN-operatör – ange kopplingstypen (antingen INNER JOIN, LEFT OUTER JOIN eller CROSS JOIN).
• JOIN-begränsning – efter att du har angett tabellerna eller underfrågorna som ska anslutas måste du ange en kopplingsbegränsning, vilket kommer att vara ett villkor där de matchande raderna som matchar det villkoret kommer att väljas beroende på kopplingstypen.

Observera att för alla följande SQLite JOIN-tabellexempel, du måste köra sqlite3.exe och öppna en anslutning till exempeldatabasen som flytande:

Steg 1) I detta steg

1. Öppna Den här datorn och navigera till följande katalog "C:\sqlite"Och
2. Öppna sedan "sqlite3.exe"

Steg 2) Öppna databasen "TutorialsSampleDB.db" med följande kommando:

Nu är du redo att köra vilken typ av fråga som helst på databasen.

SQLite INNER JOIN

INNER JOIN returnerar endast de rader som matchar sammanfogningsvillkoret och eliminerar alla andra rader som inte matchar sammanfogningsvillkoret.

Exempelvis

I följande exempel kommer vi att förena de två tabellerna "Studenter"Och"avdelningar” med DepartmentId för att få institutionsnamnet för varje student, enligt följande:

SELECT
  Students.StudentName,
  Departments.DepartmentName
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Förklaring av kod

INNER JOIN fungerar enligt följande:

• I Select-satsen kan du välja vilka kolumner du vill välja från de två refererade tabellerna.
• INNER JOIN-satsen är skriven efter den första tabellen som refereras till med "From"-satsen.
• Därefter anges kopplingsvillkoret med PÅ.
• Alias ​​kan anges för refererade tabeller.
• Det INRE ordet är valfritt, du kan bara skriva JOIN.

Produktion

• INNER JOIN producerar journalerna från båda – studenterna och institutionens tabeller som matchar villkoret som är ”Students.DepartmentId = Departments.DepartmentId ". De omatchade raderna kommer att ignoreras och inte inkluderas i resultatet.
• Det är därför endast 8 elever från 10 elever returnerades från denna fråga med IT-, matematik- och fysikavdelningar. Medan eleverna "Jena" och "George" inte inkluderades, eftersom de har ett noll avdelnings-ID, vilket inte matchar avdelnings-ID-kolumnen från avdelningstabellen. Som följande:

  

SQLite GÅ MED … ANVÄNDER

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 "JOIN .. USING" närhelst kolumnerna du ska jämföra i sammanfogningsvillkoret har samma namn. I sådana fall finns det inget behov av att upprepa dem med på-villkoret och bara ange kolumnnamnen och SQLite kommer att upptäcka det.

Skillnaden mellan INNER JOIN och JOIN .. ANVÄNDER:

Med “JOIN … ANVÄNDA” skriver du inte ett sammanfogningsvillkor, du skriver bara sammanfogningskolumnen som är gemensam mellan de två sammanfogade tabellen, istället för att skriva tabell1 “INNER JOIN-tabell2 PÅ table1.cola = table2.cola” skriver vi det som "tabell1 JOIN table2 USING(cola)".

Exempelvis

I följande exempel kommer vi att förena de två tabellerna "Studenter"Och"avdelningar” med DepartmentId för att få institutionsnamnet för varje student, enligt följande:

SELECT
  Students.StudentName,
  Departments.DepartmentName
FROM Students
INNER JOIN Departments USING(DepartmentId);

Förklaring

• Till skillnad från föregående exempel skrev vi inte "ON Students.DepartmentId = Departments.DepartmentId". Vi skrev precis "USING(DepartmentId)".
• SQLite leder automatiskt sammanfogningsvillkoret 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 har samma namn.

Produktion

• Detta kommer att ge dig samma exakta resultat som föregående exempel:

SQLite NATURLIG GÅ MED

En NATURAL JOIN liknar en JOIN...USING, skillnaden är att den automatiskt testar för likhet mellan värdena för varje kolumn som finns i båda tabellerna.

Skillnaden mellan INNER JOIN och en NATURAL JOIN:

• I INNER JOIN måste du ange ett sammanfogningsvillkor som den inre sammanfogningen använder för att sammanfoga de två tabellerna. I den naturliga sammanfogningen skriver du inte ett sammanfogningsvillkor. Du skriver bara de två tabellernas namn utan några villkor. Då kommer den naturliga kopplingen automatiskt att testa för likhet mellan värdena för varje kolumn som finns i båda tabellerna. Naturlig sammanfogning härleder automatiskt sammanfogningsvillkoret.
• I NATURAL JOIN kommer alla kolumner från båda tabellerna med samma namn att matchas mot varandra. Till exempel, om vi har två tabeller med två kolumnnamn gemensamma (de två kolumnerna finns med samma namn i de två tabellerna), kommer den naturliga sammanfogningen att förena de två tabellerna genom att jämföra värdena för båda kolumnerna och inte bara från en kolumn.

Exempelvis

SELECT
  Students.StudentName,
  Departments.DepartmentName
FROM Students
Natural JOIN Departments;

Förklaring

• Vi behöver inte skriva ett sammanfogningsvillkor 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 sammanfogningen kommer att skanna båda kolumnerna från de två tabellerna. Den 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 kommer att ge dig samma exakta utdata som den utdata vi fick från INNER JOIN och JOIN USING-exemplen. För i vårt exempel är alla tre frågorna likvärdiga. Men i vissa fall kommer utgången att vara annorlunda än inre koppling än i en naturlig koppling. Till exempel, om det finns fler tabeller med samma namn, kommer den naturliga sammanfogningen att matcha alla kolumner mot varandra. Den inre kopplingen kommer dock bara att matcha kolumnerna i kopplingsvillkoret (mer information i nästa avsnitt; skillnaden mellan den inre kopplingen och naturlig koppling).

SQLite VÄNSTER YTTRE GÅ MED

SQL-standarden definierar tre typer av OUTTER JOINs: LEFT, RIGHT och FULL men SQLite stöder endast den naturliga LEFT OUTER JOIN.

I LEFT OUTER JOIN kommer alla värden för kolumnerna du väljer från den vänstra tabellen att inkluderas i resultatet av fråga, så oavsett om 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 den högra tabellen, om något värde som inte matchar kopplingsvillkoret kommer det att innehålla ett "null"-värde.

Så du kommer att få ett antal rader motsvarande antalet rader i den vänstra kopplingen. Så att du får de matchande raderna från båda tabellerna (som INNER JOIN-resultaten), plus de omatchande raderna från den vänstra tabellen.

Exempelvis

I följande exempel kommer vi att prova "LEFT JOIN" för att sammanfoga de två tabellerna "Students" och "Departments":

SELECT
  Students.StudentName,
  Departments.DepartmentName
FROM Students             -- this is the left table
LEFT JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Förklaring

• SQLite LEFT JOIN syntax är densamma som INNER JOIN; du skriver LEFT JOIN mellan de två tabellerna, och sedan kommer joinvillkoret efter ON-satsen.
• Den första tabellen efter från-satsen är den vänstra tabellen. Medan den andra tabellen som anges efter den naturliga LEFT JOIN är den högra tabellen.
• OUTER-satsen är valfri; LEFT natural OUTER JOIN är samma som LEFT JOIN.

Produktion

• Som du kan se är alla rader från elevtabellen inkluderade som är 10 elever totalt. Även om den fjärde och den sista studenten, Jena, och Georges institutions-ID inte finns i tabellen Institutioner, 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 den föregående frågan med den vänstra sammanfogningen en djupare förklaring med hjälp av Van-diagram:

LEFT JOIN kommer att ge alla elever namn från studenttabellen även om studenten har ett avdelnings-ID som inte finns i avdelningstabellen. Så, frågan ger dig inte bara de matchande raderna som INNER JOIN, utan ger dig den extra delen som har de omatchande raderna från den vänstra tabellen som är elevtabellen.

Observera att varje studentnamn som inte har någon matchande avdelning kommer att ha ett "null"-värde för avdelningsnamn, eftersom det inte finns något matchande värde för det, och dessa värden är värdena i raderna som inte matchar.

SQLite KRÄSS GÅ MED

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 kommer du att få '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 sammanfogningsvillkor, eftersom SQLite behöver det inte för CROSS JOIN.

Smakämnen SQLite kommer att resultera i logiska resultat 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 blir (1,3), (1,4).
• Likaså 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).

Exempelvis

I följande fråga kommer vi att försöka CROSS JOIN mellan tabellerna Studenter och Institutioner:

SELECT
  Students.StudentName,
  Departments.DepartmentName
FROM Students
CROSS JOIN Departments;

Förklaring

• I SQLite välj från flera tabeller, vi valde bara två kolumner "studentnamn" från studenttabellen och "avdelningsnamn" från institutionstabellen.
• För korskopplingen angav vi inget sammanfogningsvillkor bara de två tabellerna kombinerade med CROSS JOIN i mitten av dem.

Produktion

Som du kan se är resultatet 40 rader; 10 värden från elevtabellen matchade mot de 4 avdelningarna från avdelningstabellen. Som följande:

• Fyra värden för de fyra institutionerna från institutionstabellen matchade 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

Använda SQLite JOIN-fråga, du kan länka en eller flera tabeller eller underfrågor för att välja kolumner från båda tabellerna eller underfrågorna.