Operatore join

  • Articolo
  • 11 minuti per la lettura

Consente di unire le righe di due tabelle in modo da formare una nuova tabella, facendo corrispondere i valori delle colonne specificate da ogni tabella.

Table1 | join (Table2) on CommonColumn, $left.Col1 == $right.Col2

Sintassi

LeftTable|join [JoinParameters] (RightTable)onAttributi

Argomenti

  • LeftTable: tabella o espressione tabulare a sinistra, a volte definita tabella esterna, di cui devono essere unite le righe. Indicata come $left.

  • RightTable: tabella o espressione tabulare a destra, a volte definita tabella interna, di cui devono essere unite le righe. Indicata come $right.

  • Attributes: una o più regole delimitate da virgole che descrivono il modo in cui le righe di LeftTable vengono associate alle righe di RightTable. Vengono valutate più regole mediante l'operatore logico and.

    Sono disponibili i tipi seguenti di regola:

    Tipo di regola Sintassi Predicate
    Uguaglianza in base al nome ColumnName whereLeftTable. Columnname==RightTable. Columnname
    Uguaglianza in base al valore $left.LeftColumn==$right.RightColumn where$left.LeftColumn==$right.RightColumn

    Nota

    Per 'uguaglianza in base al valore' i nomi di colonna devono essere qualificati con la tabella proprietaria applicabile indicata dalle notazioni $left e $right.

  • JoinParameters: zero o più parametri delimitati da spazi sotto forma di Valore nome= che controllano il comportamento dell'operazione di corrispondenza di riga e del piano di esecuzione. Sono supportati i seguenti parametri:

    Nome dei parametri Valori Descrizione
    kind Tipi di join Vedere Tipi di join
    hint.remote auto, left, local, right Vedere Join tra cluster
    hint.strategy=broadcast Specifica il modo in cui condividere il carico di query nei nodi del cluster. Vedere broadcast join
    hint.shufflekey=<key> La shufflekey query condivide il carico delle query nei nodi del cluster, usando una chiave per partizionare i dati. Vedere la query casuale
    hint.strategy=shuffle La shuffle query di strategia condivide il carico di query nei nodi del cluster, in cui ogni nodo elabora una partizione dei dati. Vedere la query casuale
    Nome Valori Descrizione
    kind Tipi di join Vedere Tipi di join
    hint.remote auto, left, local, right
    hint.strategy=broadcast Specifica il modo in cui condividere il carico di query nei nodi del cluster. Vedere broadcast join
    hint.shufflekey=<key> La shufflekey query condivide il carico delle query nei nodi del cluster, usando una chiave per partizionare i dati. Vedere la query casuale
    hint.strategy=shuffle La shuffle query di strategia condivide il carico di query nei nodi del cluster, in cui ogni nodo elabora una partizione dei dati. Vedere la query casuale

Avviso

Se kind non è specificato, il tipo di join predefinito è innerunique. Questo approccio è diverso rispetto ad altri prodotti di analisi che usano inner come tipo predefinito. Vedere join-flavor per comprendere le differenze e assicurarsi che la query restituisca i risultati previsti.

Restituisce

Lo schema di output dipende dal tipo di join:

Tipo di join Schema di output.
kind=leftanti, kind=leftsemi La tabella risultante contiene le colonne solo del lato sinistro.
kind=rightanti, kind=rightsemi La tabella risultante contiene le colonne solo del lato destro.
kind=innerunique, kind=inner, kind=leftouter, kind=rightouter, kind=fullouter Una colonna per ogni colonna in ognuna delle due tabelle, incluse le chiavi corrispondenti. Le colonne del lato destro verranno automaticamente rinominate in caso di conflitti tra i nomi.

I record di output dipendono dal tipo di join:

Nota

Se sono presenti più righe con gli stessi valori per tali campi, si otterranno righe per tutte le combinazioni. Una corrispondenza è una riga selezionata da una tabella che ha lo stesso valore per tutti i campi on di una riga nell'altra tabella.

Tipo di join Record di output
kind=leftanti, kind=leftantisemi Restituisce tutti i record del lato sinistro che non hanno corrispondenze a destra.
kind=rightanti, kind=rightantisemi Restituisce tutti i record del lato destro che non hanno corrispondenze a sinistra.
kind non specificato, kind=innerunique Solo una riga del lato sinistro viene associata a ogni valore della chiave on . L'output contiene una riga per ogni corrispondenza di questa riga con le righe a destra.
kind=leftsemi Restituisce tutti i record del lato sinistro che hanno corrispondenze a destra.
kind=rightsemi Restituisce tutti i record del lato destro che hanno corrispondenze a sinistra.
kind=inner Restituisce tutti i record corrispondenti dai lati sinistro e destro.
kind=fullouter Restituisce tutti i record per tutti i record dai lati sinistro e destro. Le celle senza corrispondenza contengono valori Null.
kind=leftouter Restituisce tutti i record dal lato sinistro e solo i record corrispondenti dal lato destro.
kind=rightouter Restituisce tutti i record dal lato destro e solo i record corrispondenti dal lato sinistro.

Suggerimento

Per assicurare prestazioni migliori, se una tabella è sempre più piccola dell'altra, usarla come lato sinistro (pipe inviata) del join.

Esempio

Ottenere le attività estese da login in cui alcune voci contrassegnano come inizio e fine di un'attività.

let Events = MyLogTable | where type=="Event" ;
Events
| where Name == "Start"
| project Name, City, ActivityId, StartTime=timestamp
| join (Events
    | where Name == "Stop"
        | project StopTime=timestamp, ActivityId)
    on ActivityId
| project City, ActivityId, StartTime, StopTime, Duration = StopTime - StartTime

let Events = MyLogTable | where type=="Event" ;
Events
| where Name == "Start"
| project Name, City, ActivityIdLeft = ActivityId, StartTime=timestamp
| join (Events
        | where Name == "Stop"
        | project StopTime=timestamp, ActivityIdRight = ActivityId)
    on $left.ActivityIdLeft == $right.ActivityIdRight
| project City, ActivityId, StartTime, StopTime, Duration = StopTime - StartTime

Tipi di join

Il tipo di operatore join viene specificato con la parola chiave kind. Sono supportati i tipi seguenti di operatore di join:

Tipo di join Descrizione
innerunique (o vuoto in base all'impostazione predefinita) Inner join con deduplicazione del lato sinistro
inner Inner join standard
leftouter Left outer join
rightouter Right outer join
fullouter Full outer join
leftanti, antio leftantisemi Left anti-join
rightanti o rightantisemi Right anti-join
leftsemi Semi join di sinistra
rightsemi Semi join di destra

Tipo di join predefinito

Il tipo di join predefinito è un inner join con deduplicazione del lato sinistro. L'implementazione di un join predefinito risulta utile in scenari tipici di analisi di log/traccia in cui si vogliono correlare due eventi, ognuno dei quali corrisponde a un criterio di filtro con lo stesso ID di correlazione. Si vuole che vengano restituiti tutti gli aspetti del fenomeno e che vengano ignorati più aspetti dei record di traccia interessati.

X | join Y on Key
 
X | join kind=innerunique Y on Key

Le due tabelle di esempio seguenti vengono usate per spiegare l'operazione del join.

Tabella X

Chiave Value1
a 1
b 2
b 3
c 4

Tabella Y

Chiave Value2
b 10
c 20
c 30
d 40

Il join predefinito esegue un inner join dopo la deduplicazione del lato sinistro nella chiave di join (la deduplicazione mantiene il primo record).

Se si considera l'istruzione seguente: X | join Y on Key

l'effettivo lato sinistro del join, ovvero la tabella X dopo la deduplicazione, sarà:

Chiave Value1
a 1
b 2
c 4

e il risultato del join sarà:

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join Y on Key

Output

Chiave Value1 Chiave1 Value2
b 2 b 10
c 4 c 20
c 4 c 30

Nota

Le chiavi 'a' e 'd' non vengono visualizzate nell'output poiché non sono presenti chiavi corrispondenti su entrambi i lati destro e sinistro.

Tipo di inner join

La funzione inner join è analoga all'inner join standard di SQL. Un record di output viene generato ogni volta che un record sul lato sinistro ha la stessa chiave di join del record sul lato destro.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=inner Y on Key

Output

Chiave Value1 Chiave1 Value2
b 3 b 10
b 2 b 10
c 4 c 20
c 4 c 30

Nota

  • È stato eseguito due volte il join di (b,10) dal lato destro: con (b,2) e (b,3) a sinistra.
  • È stato eseguito due volte il join di (c,4) nel lato sinistro: con (c,20) e (c,30) a destra.

Tipo di join innerunique

Usare il tipo di join innerunique per deduplicare le chiavi dal lato sinistro. Il risultato sarà una riga dell'output da ogni combinazione di chiavi di sinistra e chiavi di destra deduplicate.

Nota

Il tipo innerunique può restituire due output possibili ed entrambi sono corretti. Nel primo output l'operatore di join ha selezionato in modo casuale la prima chiave visualizzata in t1, con valore "val1.1", e la ha associata con le chiavi t2. Nel secondo output l'operatore di join ha selezionato in modo casuale la seconda chiave visualizzata in t1, con valore "val1.2", e la ha associata con le chiavi t2.

let t1 = datatable(key:long, value:string)  
[
1, "val1.1",  
1, "val1.2"  
];
let t2 = datatable(key:long, value:string)  
[  
1, "val1.3",
1, "val1.4"  
];
t1
| join kind = innerunique
    t2
on key

Output

Key Valore key1 value1
1 val1.1 1 val1.3
1 val1.1 1 val1.4 
let t1 = datatable(key:long, value:string)  
[
1, "val1.1",  
1, "val1.2"  
];
let t2 = datatable(key:long, value:string)  
[  
1, "val1.3", 
1, "val1.4"  
];
t1
| join kind = innerunique
    t2
on key

Output

Key Valore key1 value1
1 val1.2 1 val1.3
1 val1.2 1 val1.4

  • Kusto è ottimizzato per il push di filtri che si trovano dopo join, verso il lato appropriato del join, a destra o sinistra, quando possibile.

  • Il tipo usato è a volte innerunique e il filtro viene propagato al lato sinistro del join. Il tipo verrà propagato automaticamente e le chiavi applicabili a tale filtro verranno visualizzate sempre nell'output.

  • Usare l'esempio precedente e aggiungere un filtro where value == "val1.2" . Restituirà sempre il secondo risultato e non restituirà mai il primo risultato per i set di dati:

let t1 = datatable(key:long, value:string)  
[
1, "val1.1",  
1, "val1.2"  
];
let t2 = datatable(key:long, value:string)  
[  
1, "val1.3", 
1, "val1.4"  
];
t1
| join kind = innerunique
    t2
on key
| where value == "val1.2"

Output

Key Valore key1 value1
1 val1.2 1 val1.3
1 val1.2 1 val1.4

Tipo left outer join

Il risultato di un left outer join per le tabelle X e Y contiene sempre tutti i record della tabella di sinistra (X), anche se la condizione di join non rileva alcun record corrispondente nella tabella di destra (Y).

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=leftouter Y on Key

Output

Chiave Value1 Chiave1 Value2
a 1
b 2 b 10
b 3 b 10
c 4 c 20
c 4 c 30

Tipo right outer join

Il tipo right outer join è simile a left outer join, ma il trattamento delle tabelle è invertito.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=rightouter Y on Key

Output

Chiave Value1 Chiave1 Value2
b 2 b 10
b 3 b 10
c 4 c 20
c 4 c 30
d 40

Tipo full outer join

Un full outer join corrisponde all'applicazione di entrambi left outer join e right outer join. Se i record nelle tabelle di cui è stato eseguito il join non corrispondono, il set di risultati includerà valori null per ogni colonna della tabella che non contiene una riga corrispondente. Per i record corrispondenti, verrà generata una singola riga nel set di risultati, contenente i campi popolati da entrambe le tabelle.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=fullouter Y on Key

Output

Chiave Value1 Chiave1 Value2
a 1
b 2 b 10
b 3 b 10
c 4 c 20
c 4 c 30
d 40

Tipo left anti join

Left anti join restituisce tutti i record del lato sinistro che non corrispondono ad alcun record del lato destro.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=leftanti Y on Key

Output

Chiave Value1
a 1

Nota

Anti-join definisce la query "NOT IN".

Tipo right anti join

Right anti join restituisce tutti i record del lato destro che non corrispondono ad alcun record del lato sinistro.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=rightanti Y on Key

Output

Chiave Value2
d 40

Nota

Anti-join definisce la query "NOT IN".

Tipo left semi join

Left semi join restituisce tutti i record del lato sinistro che corrispondono a un record del lato destro. Vengono restituite solo le colonne dal lato sinistro.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=leftsemi Y on Key

Output

Chiave Value1
b 2
b 3
c 4

Tipo right semi join

Right semi join restituisce tutti i record del lato destro che corrispondono a un record del lato sinistro. Vengono restituite solo le colonne del lato destro.

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X | join kind=rightsemi Y on Key

Output

Chiave Value2
b 10
c 20
c 30

Cross join

Kusto non fornisce un tipo cross join in modalità nativa. Non è possibile contrassegnare l'operatore con kind=cross. Per la simulazione, usare una chiave fittizia.

X | extend dummy=1 | join kind=inner (Y | extend dummy=1) on dummy

Hint di join

L'operatore join supporta alcuni hint che controllano la modalità di esecuzione di una query. Questi hint non cambiano la semantica di join, ma potrebbero influire sulle rispettive prestazioni.

Gli hint di join vengono illustrati negli articoli seguenti: