operador join

Artigo
07/05/2022
10 minutos para ler

Fundir as linhas de duas tabelas para formar uma nova tabela, combinando valores das colunas especificadas de cada tabela.

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

Syntax

Mesa de Esquerdajoin [join] (()on)

Argumentos

Mesa de Esquerda: A mesa esquerda ou a expressão tabular, por vezes chamada mesa exterior , cujas linhas devem ser fundidas. Denotado como $left.
Tabela Direita: A mesa certa ou expressão tabular, às vezes chamada de tabela interna , cujas linhas devem ser fundidas. Denotado como $right.

Atributos: Uma ou mais regras separadas por vírgula que descrevem como as linhas do LeftTable são correspondidas às linhas da RightTable. Várias regras são avaliadas usando o and operador lógico.

Uma regra pode ser uma de:

Tipo de regra	Syntax	Predicado
Igualdade pelo nome	Nome da coluna	`wherewhere`. Nome da colunaMesa de Direita. Nome da coluna
Igualdade por valor	`$left.$left.==$right.==`	`where$left.where==$right.$left.`

Nota

Para "igualdade por valor", os nomes das colunas devem ser qualificados com a tabela de proprietários aplicável denotada por e $right notações.

JoinParameters: Parâmetros zero ou mais separados pelo espaço sob a forma de NameValue que controlam o comportamento da operação de jogo de linha e plano de execução. São suportados os seguintes parâmetros:

Nome dos parâmetros	Valores	Descrição
`kind`	Junte sabores	Ver Sabores de Junção
`hint.remote`	`auto`, `left`, `local`, `right`	Ver Cross-Cluster Juntar-se
`hint.strategy=broadcast`	Especifica a forma de partilhar a carga de consulta nos nós do cluster.	Ver transmissão aderir
`hint.shufflekey=<key>`	A `shufflekey` consulta partilha a carga de consulta nos nós do cluster, utilizando uma chave para os dados de partição.	Ver consulta de baralhar
`hint.strategy=shuffle`	A `shuffle` consulta de estratégia partilha a carga de consulta nos nós de cluster, onde cada nó irá processar uma partição dos dados.	Ver consulta de baralhar

Name	Valores	Descrição
`kind`	Junte sabores	Ver Sabores de Junção
`hint.remote`	`auto`, `left`, `local`, `right`
`hint.strategy=broadcast`	Especifica a forma de partilhar a carga de consulta nos nós do cluster.	Ver transmissão aderir
`hint.shufflekey=<key>`	A `shufflekey` consulta partilha a carga de consulta nos nós do cluster, utilizando uma chave para os dados de partição.	Ver consulta de baralhar
`hint.strategy=shuffle`	A `shuffle` consulta de estratégia partilha a carga de consulta nos nós de cluster, onde cada nó irá processar uma partição dos dados.	Ver consulta de baralhar

Aviso

Se kind não for especificado, o sabor de união padrão é innerunique. Isto é diferente de alguns outros produtos de análise que têm inner como sabor padrão. Consulte os sabores de junção para entender as diferenças e certifique-se de que a consulta produz os resultados pretendidos.

Devoluções

O esquema de saída depende do sabor da junção:

Junte o sabor	Esquema de saída
`kind=leftanti`, `kind=leftsemi`	A tabela de resultados contém apenas colunas do lado esquerdo.
`kind=rightanti`, `kind=rightsemi`	A tabela de resultados contém apenas colunas do lado direito.
`kind=innerunique`, `kind=inner`, `kind=leftouter`, `kind=rightouter`, `kind=fullouter`	Uma coluna para cada coluna em cada uma das duas tabelas, incluindo as teclas correspondentes. As colunas do lado direito serão automaticamente renomeadas se houver confrontos de nomes.

Os registos de saída dependem do sabor da junção:

Nota

Se houver várias linhas com os mesmos valores para esses campos, você terá filas para todas as combinações. Uma partida é uma linha selecionada de uma tabela que tem o mesmo valor para todos os on campos como uma linha na outra tabela.

Junte o sabor	Registos de saída
`kind=leftanti`, `kind=leftantisemi`	Devolve todos os registos do lado esquerdo que não têm fósforos da direita
`kind=rightanti`, `kind=rightantisemi`	Devolve todos os registos do lado direito que não têm fósforos da esquerda.
`kind` não especificado, `kind=innerunique`	Apenas uma linha do lado esquerdo é igualada por cada valor da `on` chave. A saída contém uma linha para cada partida desta linha com linhas da direita.
`kind=leftsemi`	Devolve todos os registos do lado esquerdo que têm fósforos da direita.
`kind=rightsemi`	Devolve todos os registos do lado direito que têm fósforos da esquerda.
`kind=inner`	Devolve todos os registos correspondentes dos lados esquerdo e direito.
`kind=fullouter`	Devolve todos os registos de todos os registos dos lados esquerdo e direito. Células incomparáveis contêm nulos.
`kind=leftouter`	Devolve todos os registos do lado esquerdo e apenas os registos correspondentes do lado direito.
`kind=rightouter`	Devolve todos os registos do lado direito e apenas os registos correspondentes do lado esquerdo.

Dica

Para um melhor desempenho, se uma mesa for sempre menor que a outra, use-a como lado esquerdo (canalizado) da junta.

Exemplo

Obtenha atividades alargadas a partir de um login que algumas entradas marcam como o início e o fim de uma atividade.

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

Junte sabores

O sabor exato do operador de união é especificado com a palavra-chave amável . São suportados os seguintes sabores do operador de aderiá:

Junte-se ao tipo/sabor	Description
`innerunique` (ou vazio como padrão)	Unidos interno com deduplica do lado esquerdo
`inner`	Aderir interior padrão
`leftouter`	Associação externa à esquerda
`rightouter`	Associação externa à direita
`fullouter`	Associação externa completa
`leftanti`, `antileftantisemi`	Anti-associação à esquerda
`rightanti` ou `rightantisemi`	Anti-associação à direita
`leftsemi`	Semi-esquerda aderir
`rightsemi`	Semi direito

Sabor de junção padrão

O sabor de união padrão é uma união interior com deduplica do lado esquerdo. A implementação de adesão por defeito é útil em cenários típicos de análise de registo/rastreio onde pretende correlacionar dois eventos, cada um correspondendo a algum critério de filtragem, sob o mesmo ID de correlação. Queres recuperar todas as aparências do fenómeno, e ignorar múltiplas aparições dos registos de vestígios que contribuem.

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

As duas tabelas de amostras seguintes são utilizadas para explicar o funcionamento da junta.

Tabela X

Chave	Valor1
um	1
b	2
b	3
c	4

Mesa Y

Chave	Valor2
b	10
c	20
c	30
d	40

A junção padrão faz uma união interna após desduplicar o lado esquerdo na chave de união (a deduplica mantém o primeiro registo).

Dada esta declaração: X | join Y on Key

o lado esquerdo eficaz da junção, tabela X após a desduplicação, seria:

Chave	Valor1
um	1
b	2
c	4

e o resultado da junção seria:

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

Chave	Valor1	Chave1	Valor2
b	2	b	10
c	4	c	20
c	4	c	30

Nota

As teclas 'a' e 'd' não aparecem na saída, uma vez que não havia chaves correspondentes nos lados esquerdo e direito.

Sabor de união interior

A função de união interna é como a união interior padrão do mundo SQL. Um registo de saída é produzido sempre que um recorde no lado esquerdo tem a mesma chave de junção que o recorde do lado direito.

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

Chave	Valor1	Chave1	Valor2
b	3	b	10
b	2	b	10
c	4	c	20
c	4	c	30

Nota

(b,10) do lado direito, juntou-se duas vezes: com ambos (b,2) e (b,3) à esquerda.
(c,4) no lado esquerdo, juntou-se duas vezes: com ambos (c,20) e (c,30) à direita.

Sabor innerunique-join

Use o sabor innerunique-join para desduplicar as teclas do lado esquerdo. O resultado será uma linha na saída de cada combinação de teclas esquerda deduplicadas e teclas direitas.

Nota

sabor interior pode produzir duas saídas possíveis e ambas estão corretas. Na primeira saída, o operador de junção selecionou aleatoriamente a primeira chave que aparece no t1, com o valor "val1.1" e combinou-a com as teclas T2. Na segunda saída, o operador de junção selecionou aleatoriamente a segunda chave que aparece em t1, com o valor "val1.2" e combinou-a com as teclas 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

key	valor	chave1	valor1
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

key	valor	chave1	valor1
1	val1.2	1	val1.3
1	val1.2	1	val1.4

Kusto é otimizado para empurrar filtros que vêm depois do join, para o lado apropriado de união, esquerda ou direita, quando possível.
Às vezes, o sabor usado é interior e o filtro é propagado para o lado esquerdo da junta. O sabor será automaticamente propagado e as teclas que se aplicam a esse filtro aparecerão sempre na saída.
Utilize o exemplo acima e adicione um filtro where value == "val1.2" . Dará sempre o segundo resultado e nunca dará o primeiro resultado para os conjuntos de dados:

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"

key	valor	chave1	valor1
1	val1.2	1	val1.3
1	val1.2	1	val1.4

Sabor de união externa esquerda

O resultado de uma junção exterior esquerda para as mesas X e Y contém sempre todos os registos da mesa esquerda (X), mesmo que a condição de junção não encontre qualquer registo correspondente na tabela direita (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

Chave	Valor1	Chave1	Valor2
um	1
b	2	b	10
b	3	b	10
c	4	c	20
c	4	c	30

Sabor de união externa direita

O sabor exterior direito assemelha-se à parte externa esquerda, mas o tratamento das mesas é invertido.

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

Chave	Valor1	Chave1	Valor2
b	2	b	10
b	3	b	10
c	4	c	20
c	4	c	30
		d	40

Sabor completo de união exterior

Uma união exterior completa combina o efeito da aplicação de juntas exteriores tanto à esquerda como à direita. Sempre que os registos nas tabelas combinadas não corresponderem, o conjunto de resultados terá null valores para cada coluna da tabela que não tenha uma linha correspondente. Para os registos que correspondem, uma única linha será produzida no conjunto de resultados, contendo campos povoados de ambas as mesas.

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

Chave	Valor1	Chave1	Valor2
um	1
b	2	b	10
b	3	b	10
c	4	c	20
c	4	c	30
		d	40

Sabor anti-junção esquerdo

O anti-join esquerdo devolve todos os registos do lado esquerdo que não correspondem a qualquer registo do lado direito.

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

Chave	Valor1
um	1

Nota

Modelos anti-junção a consulta "NÃO IN".

Sabor anti-junção direito

O anti-join direito devolve todos os registos do lado direito que não correspondem a nenhum registo do lado esquerdo.

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

Chave	Valor2
d	40

Nota

Modelos anti-junção a consulta "NÃO IN".

Sabor semi-junção esquerda

Semi-join esquerdo devolve todos os registos do lado esquerdo que correspondem a um recorde do lado direito. Apenas são devolvidas colunas do lado esquerdo.

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

Chave	Valor1
b	2
b	3
c	4

Sabor semi-junção direito

Semi-join direito devolve todos os registos do lado direito que correspondem a um recorde do lado esquerdo. Apenas são devolvidas colunas do lado direito.

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

Chave	Valor2
b	10
c	20
c	30

Cross-join

Kusto não fornece um sabor de cross-join. Não pode marcar o operador com o kind=cross. Para simular, use uma chave falsa.

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

Junte dicas

O join operador suporta uma série de pistas que controlam a forma como uma consulta funciona. Estas dicas não mudam a semântica de join, mas podem afetar o seu desempenho.

As dicas de junção são explicadas nos seguintes artigos:

hint.shufflekey=<key> e hint.strategy=shuffle - hint.shufflekey=<key>
hint.strategy=broadcast - hint.strategy=broadcast
hint.remote=<strategy> - hint.remote=<strategy>