SQLite Sammanfogning: Naturlig vänster yttre, inre, kors med tabeller

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 det här steget öppnar du Den här datorn och navigerar till följande katalog "C:\sqlite" och öppnar 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 kopplingsvillkoret och eliminerar alla andra rader som inte matchar kopplingsvillkoret.

Exempelvis

I följande exempel kommer vi att koppla ihop 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 posterna från både studenternas och institutionens tabeller som matchar villkoret "Students.DepartmentId = Departments.DepartmentId". De omatchade raderna kommer att ignoreras och inte inkluderas i resultatet.

Det är därför endast 8 av 10 studenter returnerades från denna fråga med IT-, matematik- och fysikavdelningar. Medan studenterna "Jena" och "George" inte inkluderades, eftersom de har ett null-avdelnings-ID, vilket inte matchar kolumnen departmentId från avdelningstabellen. Enligt 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 … USING” skriver du inte ett join-villkor, du skriver bara join-kolumnen som är gemensam för de två joinade tabellerna. Istället för att skriva tabell1 ”INNER JOIN tabell2 ON tabell1.cola = tabell2.cola” skriver vi det som ”tabell1 JOIN tabell2 USING(cola)”.

Exempelvis

I följande exempel kommer vi att koppla ihop 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 bara ”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 join-villkor som den inre joinen använder för att sammanfoga de två tabellerna. I den naturliga joinen skriver du däremot inget join-villkor. Du skriver bara namnen på de två tabellerna utan något villkor. Då testar den naturliga joinen automatiskt för likhet mellan värdena för varje kolumn som finns i båda tabellerna. Natural join härleder join-villkoret automatiskt.
• 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 join-villkor med kolumnnamn (som vi gjorde i INNER JOIN). Vi behövde inte ens skriva kolumnnamnet en enda 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 ger exakt samma utdata som vi fick från INNER JOIN och JOIN USING-exemplen, eftersom alla tre frågorna är likvärdiga i vårt exempel. Men i vissa fall kommer utdata att skilja sig från Inner Join än i en Natural Join. Om det till exempel finns fler tabeller med samma namn kommer den Natural Join att matcha alla kolumner mot varandra. Inner Join kommer dock bara att matcha kolumnerna i join-villkoret.

SQLite VÄNSTER YTTRE GÅ MED

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

I LEFT OUTER JOIN kommer alla värden i de kolumner du väljer från den vänstra tabellen att inkluderas i resultatet av frågan, 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 resultatet av frågan att ha 'n' rader. Men för värdena i kolumnerna som kommer från den högra tabellen, om något värde 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 ni kan se inkluderas alla rader från elevtabellen, vilket är totalt 10 elever. Även om den fjärde och sista eleven, Jena och George, har avdelnings-ID:n som inte finns i avdelningstabellen, inkluderas de också.

Och i dessa fall kommer departmentName-värdet för både Jena och George att vara "null" eftersom departments-tabellen inte har ett departmentName som matchar deras departmentId-värde.

Låt oss ge den föregående frågan som använde vänsterkopplingen en djupare förklaring med hjälp av Venn-diagram:

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

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 behöver du med CROSS JOIN inte ange ett kopplingsvillkor, eftersom SQLite behöver det inte för CROSS JOIN.

Ocuco-landskapet SQLite kommer att resultera i en logisk resultatuppsättning genom att kombinera alla värden från den första tabellen med alla värden från den andra tabellen.

Om du till exempel valde en kolumn från den första tabellen (colA) och en annan kolumn från den andra tabellen (colB). KolumnA innehåller två värden (1,2) och kolumnB 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 specificerade vi inget kopplingsvillkor, bara de två tabellerna kombinerade med CROSS JOIN mitt emellan 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 den andra studenten John.
• Fyra värden för de fyra avdelningarna från avdelningstabellen matchade med den tredje studenten Jack… och så vidare.

Vanliga frågor