# Join

join-prefixet länkar den inlästa tabellen till en existerande namngiven tabell eller den senast skapade datatabellen.

Effekten av att slå samman (join) data är att måltabellen utökas med ytterligare en uppsättning fält eller attribut, nämligen sådana som inte redan finns i måltabellen. Eventuella gemensamma fältnamn mellan källdatauppsättningen och måltabellen används för att räkna ut hur de nya inkommande posterna ska associeras. Detta kallas ofta för en "naturlig koppling" (natural join). En Qlik-kopplingsoperation kan leda till att den resulterande måltabellen får fler eller färre poster än den hade från början, beroende på hur unik kopplingsassociationen är och vilken typ av koppling som används.

[Join script prefix](https://play.vidyard.com/7xrdzssVH99Jsr8gmPunCC)

## Typer av kopplingar

Det finns fyra typer av kopplingar:

* Left join

* Inner join

* Outer join

* Right join

Exempel på resultatuppsättningar från olika typer av kopplingsoperationer

Exempel på resultatuppsättningar från olika typer av kopplingsoperationer

Exempel på resultatuppsättningar från olika typer av kopplingsoperationer ![Exempel på resultatuppsättningar från olika typer av kopplingsoperationer, med en före-och-efter-representation av datatabellerna efter varje operation. Indata består av en måltabell och en inkommande datauppsättning. Måltabellen har två kolumner med två radposter för fälten 'Trade ID' och 'Asset Class'. Inkommande data har två kolumner med två radposter för fälten 'Trade ID' och 'Exchange'. Left Join behåller den ursprungliga måltabellen och lägger till en tredje kolumn där allt är tomt förutom tillägget av en av 'Exchange'-radposterna. Inner Join skapar en tabell med en Trade ID-rad och en tredje kolumn, återigen för 'Exchange'-radposten. Outer Join behåller måltabellen och lägger till en tredje kolumn, längs en tredje rad till vilken den andra raden i den inkommande datauppsättningen läggs till. Right Join tar bort den andra radposten i måltabellen och ersätter den med information från den andra radposten i den inkommande datauppsättningen, och lägger till en tredje kolumn i processen.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/scripting-functions-join-examples-operations.png)

### Left join

Left join är den vanligaste kopplingstypen. Om du till exempel har en transaktionsdatauppsättning och vill kombinera den med en referensdatauppsättning, skulle du normalt använda en `Left Join`. Du skulle ladda transaktionstabellen först och sedan ladda referensdatauppsättningen samtidigt som du kopplar den via ett `Left Join`-prefix till den redan laddade transaktionstabellen. En `Left Join` behåller alla transaktioner som de är och lägger till de kompletterande referensdatafälten där en matchning hittas.

Left join

Left join

Left join ![Diagram som på en övergripande nivå beskriver de datakombinationer som uppstår under en left join.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/join-types-scripting_left.png)

### Inner join

När du har två datauppsättningar där du bara bryr dig om resultat där det finns en matchande association, bör du överväga att använda en `Inner Join`. Detta eliminerar alla poster från både de laddade källdata och måltabellen om ingen matchning hittas. Som ett resultat kan detta lämna din måltabell med färre poster än innan kopplingsoperationen ägde rum.

Inner join

Inner join

Inner join ![Diagram som på en övergripande nivå beskriver de datakombinationer som uppstår under en inner join.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/join-types-scripting_inner.png)

### Outer join (standard)

När du behöver behålla både målposterna och alla inkommande poster använder du en `Outer Join`. Där ingen matchning hittas behålls fortfarande varje uppsättning poster medan fälten från den motsatta sidan av kopplingen förblir ofyllda (null).

Om typnyckelordet utelämnas är standardkopplingstypen en outer join.

Outer join

Outer join

Outer join ![Diagram som på en övergripande nivå beskriver de datakombinationer som uppstår under en outer join.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/join-types-scripting_outer.png)

### Right join

Denna kopplingstyp behåller alla poster som ska laddas, samtidigt som den reducerar posterna i den tabell som är målet för kopplingen till endast de poster där det finns en associationsmatchning i de inkommande posterna. Detta är en nischad kopplingstyp som ibland används som ett sätt att trimma ner en redan förladdad tabell med poster till en nödvändig delmängd.

Right join

Right join

Right join ![Diagram som på en övergripande nivå beskriver de datakombinationer som uppstår under en right join.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/join-types-scripting_right.png)

### Cross join

Anteckning om informationOm det inte finns några gemensamma fältnamn mellan källan och målet för en kopplingsoperation, kommer kopplingen att resultera i en kartesisk produkt av alla rader – detta kallas en "cross join".

Exempel på resultatuppsättning från en "cross join"-operation

Exempel på resultatuppsättning från en "cross join"-operation

Exempel på resultatuppsättning från en "cross join"-operation ![Före-och-efter-jämförelse av indata med utdata efter en cross join-operation (som kan involvera en kopplingsoperation av vilken typ som helst). Indata är en måltabell och en inkommande datauppsättning. Måltabellen består av tre kolumner, med två radposter. Kolumnerna är 'Trade ID', 'Base Currency' och 'Amount'. Den inkommande datauppsättningen har två kolumner ('Trade Currency' och 'Rate') och två radposter. Den resulterande tabellen har fem kolumner, vilka är 'Trade ID', 'Base Currency', 'Amount', 'Target Currency' och 'Rate'. Det finns fyra radposter som kombinerar alla data. Varje 'Trade ID'-post har två rader med olika data i de andra fälten.](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Resources/Images/scripting-functions-examples-join-no-common-fields.png)

## Syntax och argument

[inner | outer | left | right ]Join [ (tablename ) ]( loadstatement | selectstatement )

Argument

| Argument | Beskrivning |
| --- | --- |
| tablename | Namnet på den tabell som ska jämföras med den inlästa tabellen. |
| loadstatementeller selectstatement | LOAD- eller SELECT-satsen för den laddade tabellen. |

## Relaterade ämnen

Dessa ämnen kan hjälpa dig att arbeta med den här funktionen:

Relaterade ämnen

| Ämne | Beskrivning |
| --- | --- |
| [Kombinera tabeller med Join och Keep](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/combine-tables-join-keep.htm) | Det här ämnet ger ytterligare förklaring av begreppen att "koppla" (join) och "behålla" (keep) datauppsättningar. |
| [Keep](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Keep.htm) | Laddningsprefixet `Keep` liknar prefixet `Join`, men det kombinerar inte käll- och måldatauppsättningarna. Istället trimmar det varje datauppsättning enligt den typ av operation som antagits (inner, outer, left eller right). |

## Exempel på laddningsskript - Left join

En left join behåller alla poster från din huvudtabell (måltabell) och lägger till matchande data från en andra tabell (källtabell). Om det inte finns någon matchning i källan visas huvudtabellens post fortfarande, men med tomma fält från källtabellen.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Left join: grundläggande exempel

Lägg till exempelskriptet i din applikation och kör det. När du vill se resultatet lägger du till fälten som listas i resultatkolumnen i ett ark i din applikation.

Laddningsskript

```
Table1:
Load * inline [
Column1, Column2
A, B
1, aa
2, cc
3, ee ];

Table2:
Left Join Load * inline [
Column1, Column3
A, C
1, xx
4, yy ]; 
```

Mer information om att använda inline-laddningar finns i [Använda inline-laddningar för att ladda data](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm).

Resultat

Resulterande tabell

| Column1 | Column2 | Column3 |
| --- | --- | --- |
| A | B | C |
| 1 | aa | xx |
| 2 | cc | - |
| 3 | ee | - |

Det här exemplet demonstrerar utdata för Left Join där endast värden som finns i den första (vänstra) tabellen kopplas.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på left join: Berika beställningar med kundinformation

Översikt

Anta att du har en lista med beställningar, men att inte alla beställningar har en matchande kundpost.

Laddningsskript

```
Orders:
Load * inline [
OrderID, CustomerID, Amount
1, 101, 200
2, 102, 150
3, 104, 400
];

Customers:
Left Join (Orders)
Load * inline [
CustomerID, Name
101, Alice
102, Bob
103, Carol
];
```

Resultat

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabell i datamodellvyn

| OrderID | CustomerID | Amount | Name |
| --- | --- | --- | --- |
| 1 | 101 | 200 | Alice |
| 2 | 102 | 150 | Bob |
| 3 | 104 | 400 | - |

OrderID 1 och 2 har matchande kunder. OrderID 3 har ingen matchande kund, så Name är tomt.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på left join: Berika en måltabell med en referensdatauppsättning

Översikt

Öppna dataladdningsredigeraren och lägg till laddningsskriptet nedan i ett nytt delavsnitt.

Laddningsskriptet innehåller:

* En datauppsättning som representerar ändringsposter, som laddas in i en tabell med namnet `Changes`. Den inkluderar ett Status ID-nyckelfält.

* En andra datauppsättning som representerar ändringsstatusar, som laddas och kombineras med de ursprungliga ändringsposterna genom att koppla den med ett vänster `Join`-laddningsprefix.

Denna left join säkerställer att ändringsposterna förblir intakta samtidigt som statusattribut läggs till där en matchning i de inkommande statusposterna hittas baserat på ett gemensamt Status ID.

Laddningsskript

```
Changes:
Load * inline [ 
Change ID	Status ID	Scheduled Start Date	Scheduled End Date	Business Impact 
10030	4	19/01/2022	23/02/2022	None
10015	3	04/01/2022	15/02/2022	Low
10103	1	02/04/2022	29/05/2022	Medium
10185	2	23/06/2022	08/09/2022	None
10323	1	08/11/2022	26/11/2022	High
10326	2	11/11/2022	05/12/2022	None
10138	2	07/05/2022	03/08/2022	None
10031	3	20/01/2022	25/03/2022	Low
10040	1	29/01/2022	22/04/2022	None
10134	1	03/05/2022	08/07/2022	Low
10334	2	19/11/2022	06/02/2023	Low
10220	2	28/07/2022	06/09/2022	None
10264	1	10/09/2022	17/10/2022	Medium
10116	1	15/04/2022	24/04/2022	None
10187	2	25/06/2022	24/08/2022	Low
] (delimiter is '\t');

Status:
Left Join (Changes)
Load * inline [
Status ID	Status	Sub Status
1	Open	Not Started
2	Open	Started
3	Closed	Completed
4	Closed	Cancelled
5	Closed	Obsolete			
] (delimiter is '\t');
```

Resultat

Öppna datamodellvyn och notera datamodellens form. Endast en avnormaliserad tabell finns. Det är en kombination av alla ursprungliga ändringsposter, med de matchande statusattributen kopplade till varje ändringspost.

Resulterande intern datamodell

| Changes |
| --- |
| Change ID |
| Status ID |
| Scheduled Start Date |
| Scheduled End Date |
| Business Impact |
| Status |
| Sub Status |

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabellen Changes i datamodellvyn

| Change ID | Status ID | Scheduled Start Date | Scheduled End Date | Business Impact | Status | Sub Status |
| --- | --- | --- | --- | --- | --- | --- |
| 10030 | 4 | 19/01/2022 | 23/02/2022 | None | Closed | Cancelled |
| 10031 | 3 | 20/01/2022 | 25/03/2022 | Low | Closed | Completed |
| 10015 | 3 | 04/01/2022 | 15/02/2022 | Low | Closed | Completed |
| 10103 | 1 | 02/04/2022 | 29/05/2022 | Medium | Open | Not Started |
| 10116 | 1 | 15/04/2022 | 24/04/2022 | None | Open | Not Started |
| 10134 | 1 | 03/05/2022 | 08/07/2022 | Low | Open | Not Started |
| 10264 | 1 | 10/09/2022 | 17/10/2022 | Medium | Open | Not Started |
| 10040 | 1 | 29/01/2022 | 22/04/2022 | None | Open | Not Started |
| 10323 | 1 | 08/11/2022 | 26/11/2022 | High | Open | Not Started |
| 10187 | 2 | 25/06/2022 | 24/08/2022 | Low | Open | Started |
| 10185 | 2 | 23/06/2022 | 08/09/2022 | None | Open | Started |
| 10220 | 2 | 28/07/2022 | 06/09/2022 | None | Open | Started |
| 10326 | 2 | 11/11/2022 | 05/12/2022 | None | Open | Started |
| 10138 | 2 | 07/05/2022 | 03/08/2022 | None | Open | Started |
| 10334 | 2 | 19/11/2022 | 06/02/2023 | Low | Open | Started |

Eftersom den femte raden i tabellen Status (Status ID: '5', Status: 'Closed', Sub Status: 'Obsolete') inte motsvarar någon av posterna i tabellen Changes, visas inte informationen på den här raden i resultatuppsättningen ovan.

Gå tillbaka till Dataladdningsredigeraren. Ladda data och öppna ett ark. Skapa en ny tabell och lägg till det här fältet som en dimension: `Status`.

Lägg till detta mått:

`=Count([Change ID])`

Nu kan du inspektera antalet Changes per Status.

Resultattabell

| Status | =Count([Change ID]) |
| --- | --- |
| Open | 12 |
| Closed | 3 |

## Exempel på laddningsskript - Inner join

En inner join behåller endast poster som finns i båda tabellerna (baserat på matchande fältvärden).

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Inner join: grundläggande exempel

Laddningsskript

Lägg till exempelskriptet i din applikation och kör det. När du vill se resultatet lägger du till fälten som listas i resultatkolumnen i ett ark i din applikation.

```
Table1:
Load * inline [
Column1, Column2
A, B
1, aa
2, cc
3, ee ];

Table2:
Inner Join Load * inline [
Column1, Column3
A, C
1, xx
4, yy ];
```

Mer information om att använda inline-laddningar finns i [Använda inline-laddningar för att ladda data](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm).

Resultat

Resulterande tabell

| Column1 | Column2 | Column3 |
| --- | --- | --- |
| A | B | C |
| 1 | aa | xx |

Det här exemplet demonstrerar utdata för Inner Join där endast värden som finns i både den första (vänstra) och den andra (högra) tabellen kopplas.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på inner join: Reducera beställningar till endast skickade

Översikt

Du har beställningar och en lista över skickade beställningar. Du vill bara ha de beställningar som har skickats.

Laddningsskript

```
Orders:
Load * inline [
OrderID, Amount
1, 200
2, 150
3, 400
];

Shipped:
Inner Join (Orders)
Load * inline [
OrderID, ShipDate
2, 2022-05-01
3, 2022-05-02
4, 2022-05-03
];
```

Resultat

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabell i datamodellvyn

| OrderID | Amount | ShipDate |
| --- | --- | --- |
| 2 | 150 | 2022-05-01 |
| 3 | 400 | 2022-05-02 |

Endast OrderID 2 och 3 visas, eftersom de finns i båda tabellerna.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på inner join: Kombinera endast matchande poster

Översikt

Öppna dataladdningsredigeraren och lägg till laddningsskriptet nedan i ett nytt delavsnitt.

Laddningsskriptet innehåller:

* En datauppsättning som representerar ändringsposter, som laddas in i en tabell med namnet Changes.

* En andra datauppsättning som representerar ändringsposter som härrör från källsystemet JIRA. Denna laddas och kombineras med de ursprungliga posterna genom att koppla den med ett Inner Join-laddningsprefix.

Denna Inner Join säkerställer att endast de fem ändringsposter som finns i båda datauppsättningarna behålls.

Laddningsskript

```
Changes:
Load * inline [
Change ID	Status ID	Scheduled Start Date	Scheduled End Date	Business Impact
10030	4	19/01/2022	23/02/2022	None
10015	3	04/01/2022	15/02/2022	Low
10103	1	02/04/2022	29/05/2022	Medium
10185	2	23/06/2022	08/09/2022	None
10323	1	08/11/2022	26/11/2022	High
10326	2	11/11/2022	05/12/2022	None
10138	2	07/05/2022	03/08/2022	None
10031	3	20/01/2022	25/03/2022	Low
10040	1	29/01/2022	22/04/2022	None
10134	1	03/05/2022	08/07/2022	Low
10334	2	19/11/2022	06/02/2023	Low
10220	2	28/07/2022	06/09/2022	None
10264	1	10/09/2022	17/10/2022	Medium
10116	1	15/04/2022	24/04/2022	None
10187	2	25/06/2022	24/08/2022	Low
] (delimiter is '\t');

JIRA_changes:
Inner Join (Changes)
Load
  [Ticket ID] AS [Change ID],
  [Source System]
inline
[
Ticket ID	Source System
10000	JIRA					
10030	JIRA
10323	JIRA
10134	JIRA
10334	JIRA
10220	JIRA
20000	TFS
] (delimiter is '\t');
```

Resultat

Ladda data och öppna ett ark. Skapa en ny tabell och lägg till dessa fält som dimensioner:

* Source System

* Change ID

* Business Impact

Nu kan du inspektera de fem resulterande posterna. Den resulterande tabellen från en Inner Join kommer endast att inkludera poster med matchande information i båda datauppsättningarna.

Resultattabell

| Source System | Change ID | Business Impact |
| --- | --- | --- |
| JIRA | 10030 | None |
| JIRA | 10134 | Low |
| JIRA | 10220 | None |
| JIRA | 10323 | High |
| JIRA | 10334 | Low |

## Exempel på laddningsskript - Outer join

En outer join behåller alla poster från båda tabellerna. Där det inte finns någon matchning lämnas fälten tomma.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Outer join: Grundläggande exempel

Laddningsskript

Lägg till exempelskriptet i din applikation och kör det. När du vill se resultatet lägger du till fälten som listas i resultatkolumnen i ett ark i din applikation.

```
Table1:
Load * inline [
Column1, Column2
A, B
1, aa
2, cc
3, ee ];

Table2:
Outer Join Load * inline [
Column1, Column3
A, C
1, xx
4, yy ]; 
```

Mer information om att använda inline-laddningar finns i [Använda inline-laddningar för att ladda data](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm).

Resultat

Resulterande tabell

| Column1 | Column2 | Column3 |
| --- | --- | --- |
| A | B | C |
| 1 | aa | xx |
| 2 | cc | - |
| 3 | ee | - |
| 4 | - | yy |

I det här exemplet slås de två tabellerna, Table1 och Table2, samman till en enda tabell med namnet Table1. I fall som detta används ofta prefixet outer för att koppla flera tabeller till en enda tabell för att utföra aggregeringar över värdena i en enda tabell.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Outer join: Skapa en fullständig lista över alla kunder och beställningar

Översikt

Du vill ha en komplett lista över alla kunder och beställningar, även om vissa kunder inte har några beställningar och vissa beställningar inte har någon kundpost.

Laddningsskript

```
Orders:
Load * inline [
OrderID, CustomerID
1, 101
2, 102
3, 104
];

Customers:
Outer Join (Orders)
Load * inline [
CustomerID, Name
101, Alice
102, Bob
103, Carol
];
```

Resultat

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabell i datamodellvyn

| OrderID | CustomerID | Name |
| --- | --- | --- |
| 1 | 101 | Alice |
| 2 | 102 | Bob |
| 3 | 104 | - |
| - | 103 | Carol |

OrderID 3 har ingen matchande kund (Name är tomt).

CustomerID 103 (Carol) har ingen matchande beställning (OrderID är tomt).

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Outer join: Kombinera överlappande postuppsättningar

Översikt

Öppna dataladdningsredigeraren och lägg till laddningsskriptet nedan i ett nytt delavsnitt.

Laddningsskriptet innehåller:

* En datauppsättning som representerar ändringsposter, som laddas in i en tabell med namnet Changes.

* En andra datauppsättning som representerar ändringsposter som härrör från källsystemet JIRA, som laddas och kombineras med de ursprungliga posterna genom att koppla den med ett Outer Join-laddningsprefix.

Detta säkerställer att alla överlappande ändringsposter från båda datauppsättningarna behålls.

Laddningsskript

```
// 8 Change records

Changes:
Load * inline [
Change ID	Status ID	Scheduled Start Date	Scheduled End Date	Business Impact
10030	4	19/01/2022	23/02/2022	None
10015	3	04/01/2022	15/02/2022	Low
10138	2	07/05/2022	03/08/2022	None
10031	3	20/01/2022	25/03/2022	Low
10040	1	29/01/2022	22/04/2022	None
10134	1	03/05/2022	08/07/2022	Low
10334	2	19/11/2022	06/02/2023	Low
10220	2	28/07/2022	06/09/2022	None
] (delimiter is '\t');

// 6 Change records

JIRA_changes:
Outer Join (Changes)
Load
  [Ticket ID] AS [Change ID],
  [Source System]
inline
[
Ticket ID	Source System
10030	JIRA
10323	JIRA
10134	JIRA
10334	JIRA
10220	JIRA
10597	JIRA
] (delimiter is '\t');
```

Resultat

Ladda data och öppna ett ark. Skapa en ny tabell och lägg till dessa fält som dimensioner:

* Source System

* Change ID

* Business Impact

Nu kan du inspektera de 10 resulterande posterna.

Resultattabell

| Source System | Change ID | Business Impact |
| --- | --- | --- |
| JIRA | 10030 | None |
| JIRA | 10134 | Low |
| JIRA | 10220 | None |
| JIRA | 10323 | - |
| JIRA | 10334 | Low |
| JIRA | 10597 | - |
| - | 10015 | Low |
| - | 10031 | Low |
| - | 10040 | None |
| - | 10138 | None |

## Exempel på laddningsskript - Right join

En right join behåller alla poster från källtabellen och lägger till matchande information från måltabellen. Om måltabellen inte har någon matchning är fälten från den tomma.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Right join: grundläggande exempel

Laddningsskript

Lägg till exempelskriptet i din applikation och kör det. När du vill se resultatet lägger du till fälten som listas i resultatkolumnen i ett ark i din applikation.

```
Table1:
Load * inline [
Column1, Column2
A, B
1, aa
2, cc
3, ee ];

Table2:
Right Join Load * inline [
Column1, Column3
A, C
1, xx
4, yy ];
```

Mer information om att använda inline-laddningar finns i [Använda inline-laddningar för att ladda data](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm).

Resultat

Resulterande tabell

| Column1 | Column2 | Column3 |
| --- | --- | --- |
| A | B | C |
| 1 | aa | xx |
| 4 | - | yy |

Det här exemplet demonstrerar utdata för Right Join där endast värden som finns i den andra (högra) tabellen kopplas.

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på right join: kombinera alla kunder med matchande beställningar

Översikt

Din källtabell är en lista över kunder; du vill ha alla kunder, plus eventuella matchande beställningar.

Laddningsskript

```
Orders:
Load * inline [
OrderID, CustomerID
1, 101
2, 102
3, 104
];

Customers:
Right Join (Orders)
Load * inline [
CustomerID, Name
101, Alice
102, Bob
103, Carol
];
```

Resultat

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabell i datamodellvyn

| CustomerID | Name | OrderID |
| --- | --- | --- |
| 101 | Alice | 1 |
| 102 | Bob | 2 |
| 103 | Carol | - |

Alla kunder visas. Carol har inga beställningar (OrderID är tomt).

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på right join: trimma ner en måltabell med en sekundär huvuddatauppsättning

Översikt

Öppna dataladdningsredigeraren och lägg till laddningsskriptet nedan i ett nytt delavsnitt.

Laddningsskriptet innehåller:

* En datauppsättning som representerar ändringsposter, som laddas in i en tabell med namnet Changes.

* En andra datauppsättning som representerar ändringsposter som härrör från källsystemet Teamwork. Denna laddas och kombineras med de ursprungliga posterna genom att koppla den med ett Right Join-laddningsprefix.

Detta säkerställer att endast Teamwork-ändringsposter behålls, samtidigt som inga Teamwork-poster går förlorade om måltabellen inte har ett matchande Change ID.

Laddningsskript

```
Changes:

Load * inline [
Change ID	Status ID	Scheduled Start Date	Scheduled End Date	Business Impact
10030	4	19/01/2022	23/02/2022	None
10015	3	04/01/2022	15/02/2022	Low
10103	1	02/04/2022	29/05/2022	Medium
10185	2	23/06/2022	08/09/2022	None
10323	1	08/11/2022	26/11/2022	High
10326	2	11/11/2022	05/12/2022	None
10138	2	07/05/2022	03/08/2022	None
10031	3	20/01/2022	25/03/2022	Low
10040	1	29/01/2022	22/04/2022	None
10134	1	03/05/2022	08/07/2022	Low
10334	2	19/11/2022	06/02/2023	Low
10220	2	28/07/2022	06/09/2022	None
10264	1	10/09/2022	17/10/2022	Medium
10116	1	15/04/2022	24/04/2022	None
10187	2	25/06/2022	24/08/2022	Low
] (delimiter is '\t');

Teamwork_changes:
Right Join (Changes)
Load
  [Ticket ID] AS [Change ID],
  [Source System]
inline
[
Ticket ID	Source System
10040	Teamwork
10015	Teamwork
10103	Teamwork
10031	Teamwork
50231	Teamwork
] (delimiter is '\t');
```

Resultat

Ladda data och öppna ett ark. Skapa en ny tabell och lägg till dessa fält som dimensioner:

* Source System

* Change ID

* Business Impact

Nu kan du inspektera de fem resulterande posterna.

Resultattabell

| Source System | Change ID | Business Impact |
| --- | --- | --- |
| Teamwork | 10015 | Low |
| Teamwork | 10031 | Low |
| Teamwork | 10040 | None |
| Teamwork | 10103 | Medium |
| Teamwork | 50231 | - |

## Felsökning - Cross join

[](https://help.qlik.com/en-US/sense/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Join.htm)

#### Exempel på felsökning av laddningsskript: inga gemensamma fältnamn

Översikt

Om du kopplar två tabeller utan matchande fältnamn kommer varje rad från den första tabellen att kombineras med varje rad från den andra — vilket potentiellt producerar ett enormt antal poster (en kartesisk produkt) och leder till oväntade dataassociationer.

Laddningsskript

```
TableA:
Load * inline [
A_ID, ValueA
1, foo
2, bar
];

TableB:
Join (TableA)
Load * inline [
B_ID, ValueB
10, baz
11, qux
];
```

Resultat

Om du expanderar förhandsgranskningsfönstret i datamodellvyn ser du en del av hela resultatuppsättningen organiserad i en tabell:

Förhandsgranskning av tabell i datamodellvyn

| A\_ID | ValueA | B\_ID | ValueB |
| --- | --- | --- | --- |
| 1 | foo | 10 | baz |
| 1 | foo | 11 | qux |
| 2 | bar | 10 | baz |
| 2 | bar | 11 | qux |

Varje A\_ID paras ihop med varje B\_ID (totalt 4 rader).

Anteckning om tipsKontrollera alltid att dina fältnamn matchar som avsett innan du kör en koppling.

[Load](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)

[Select](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Select.htm)

[Inner](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Inner.htm)

[Outer](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Outer.htm)

[Left](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Left.htm)

[Right](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Right.htm)

[Keep](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptPrefixes/Keep.htm)

[Kombinera tabeller med Join och Keep](https://help.qlik.com/sv-SE/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/combine-tables-join-keep.htm)