Ottimizza le question di dati lente con le strategie di unire Doris

Nel mondo dell’analisi dei dati, le “question lente” sono come mal di testa sul posto di lavoro che non scompariranno.
Di recente, ho incontrato alcuni analisti dei dati che si lamentano delle question in esecuzione per ore senza risultati, lasciandole fissando impotente alla barra di avanzamento di rotazione. La scorsa settimana, mi sono imbattuto in un vecchio amico che stava lottando con l’esecuzione di un grande tavolo.

“La velocità di question è più lenta di una lumaca e il mio capo mi sta facendo impazzire …” ha detto con un aspetto frustrato.
Come esperto di ottimizzazione del database esperto con anni di esperienza in prima linea, non ho potuto fare a meno di sorridere: “Unisciti alla efficiency è lenta perché non capisci la sua natura. Proprio come nelle arti marziali, capire come usare la forza può fare la differenza”.

Oggi, immergiamoti nel mondo delle operazioni Doris E guarda come puoi trasformare le tue domande in operazioni “fulmine-fast” che impressionano il tuo capo!

Doris Be part of Secret: l’ottimizzazione delle prestazioni inizia con la scelta della strategia di be a part of giusta

L’analista di dati Xiao Zhang ha recentemente riscontrato un problema difficile. Stava lavorando a un’attività di analisi dei dati su larga scala che richiedeva l’adesione a various tabelle enormi. Inizialmente, ha usato il metodo di be a part of più convenzionale, ma la velocità della question period dolorosamente lenta, impiegando ore per essere completate. Questo lo ha lasciato in un punto difficile: il suo capo aveva bisogno del rapporto con urgenza e la pressione si è alzata.

Xiao Zhang si rivolse al suo vecchio amico ed esperto di Doris, Previous Li, per chiedere aiuto. Il vecchio Li sorrise e disse: “La chiave per unirsi alla efficiency è la scelta della strategia di be a part of giusta. Doris supporta implementazioni di be a part of e condividerò alcuni segreti con te”.

L’essenza di be a part of

Nei database distribuiti, Iscriviti alle operazioni Può sembrare semplice, ma in realtà coinvolgono complessità nascoste. Non devono solo unire le tabelle, ma anche coordinare il flusso di dati e il calcolo in un ambiente distribuito.

Advert esempio, hai due tabelle di grandi dimensioni distribuite su diversi nodi e per eseguire un be a part of, è necessario risolvere un problema di base: come riunire i dati. Ciò comporta strategie di ridistribuzione dei dati.

Doris ‘unirsi all’Arsenal

Doris impiega due principali implementazioni fisiche per le operazioni di be a part of: Hash Be part of e Nest Loop Be part of. Hash Be part of è come la spada rapida di un artista marziale, completando i giunti con la velocità della luce; Nest Loop Be part of è come un’abilità di base per uno spadaccino, semplice ma ampiamente applicabile.

Hash Be part of costruisce una tabella hash in memoria e può completare rapidamente le operazioni EQUIN. È come trovare compagni di squadra in una partita di League of Legends: a ogni giocatore viene assegnato un ID unico e, quando necessario, il sistema li individua direttamente, raggiungendo naturalmente un’elevata efficienza.

Nest Loop Be part of, d’altra parte, utilizza il metodo più semplice: l’iterazione. È come visitare i parenti durante il Competition di primavera, andando porta a porta, il che è più lento ma assicura che nessuno sia mancato. Questo metodo è applicabile a tutti gli scenari di be a part of, inclusi non pezzi-join.

Le quattro strategie di distribuzione dei dati nel mondo

Come database MPP distribuito, Apache Doris deve mescolare i dati durante il processo di be a part of hash per garantire la correttezza dei risultati di be a part of. Previous Li ha tirato fuori un diagramma e ha mostrato Xiao Zhang le quattro strategie di distribuzione dei dati per le operazioni di take part Doris:

Broadcast Be part of: The Dominant Participant

Broadcast Be part of è come un CEO di prepotente che duplicate i dati della tabella di destra su ogni nodo di calcolo. È semplice e brutale, ampiamente applicabile. Quando il quantity dei dati della tabella destra è piccolo, questo metodo è efficiente. Gli sovraccarichi di rete crescono linearmente con il numero di nodi.

Come mostrato nella figura, il be a part of di trasmissione prevede l’invio di tutti i dati dalla tabella destra a tutti i nodi che partecipano al calcolo del be a part of, inclusi i nodi che scansionano i dati della tabella sinistra, mentre i dati della tabella sinistra rimangono stazionari. Ogni nodo riceve una copia completa dei dati della tabella destra (quantity di dati totali T (R)), garantendo che tutti i nodi abbiano i dati necessari per eseguire l’operazione di be a part of.

Questo metodo è adatto per una varietà di scenari generali ma non è applicabile a semi di be a part of di hash, a destra, e semi di hash. Il sovraccarico di rete è il numero di nodi di be a part of n moltiplicati per il quantity dei dati della tabella destra T (R).

Partizione Shuffle: l’approccio convenzionale

La partizione Shuffle impiega una strategia di distribuzione bidirezionale, hashing e distribuzione di entrambe le tabelle in base alla chiave di be a part of. Il sovraccarico di rete è uguale alla somma dei volumi di dati delle due tabelle. Questo metodo è come Tai Chi, sottolineando l’equilibrio ed è adatto per scenari in cui i volumi di dati delle due tabelle sono simili.

Questo metodo prevede il calcolo dei valori di hash in base alla condizione di be a part of e la partizionamento dei dati di conseguenza. In particolare, i dati delle tabelle sinistro e destro sono partizionati in base ai valori di hash calcolati dalla condizione di be a part of e quindi inviati ai nodi di partizione corrispondenti (come mostrato nella figura).

Il sovraccarico di rete per questo metodo embrace il costo di trasmissione dei dati dei dati della tabella sinistra e il costo di trasmissione dei dati T (R) della tabella destra. Questo metodo supporta solo le operazioni di be a part of hash perché si basa sulla condizione di be a part of per eseguire il partizionamento dei dati.

Bucket Shuffle: l’approccio economico

La shuffle del secchio sfrutta le caratteristiche del secchio delle tabelle, che richiedono ridistribuzione dei soli dati della tabella destra. Il sovraccarico di rete è semplicemente il quantity dei dati della tabella giusta. È come un artista marziale che usa la forza dell’avversario contro di loro, facendo buon uso dei loro vantaggi. Questo metodo è particolarmente efficiente quando la tabella sinistra è già seccata dalla chiave di be a part of.

Quando la condizione di be a part of embrace la colonna di benna della tabella sinistra, i dati della tabella sinistra rimangono fissi e i dati della tabella destra vengono ridistribuiti ai nodi della tabella sinistra per be a part of, riducendo il sovraccarico di rete.

Quando un lato della tabella che partecipa all’operazione di be a part of ha dati già distribuiti in base alla colonna della condizione di be a part of, possiamo scegliere di mantenere invariata la posizione dei dati di questo lato e spostare e ridistribuire solo l’altro lato della tabella. (Qui, la “tabella” non si limita a tabelle memorizzate fisicamente ma può anche essere il risultato di output di qualsiasi operatore in una question SQL e possiamo scegliere in modo flessibile di mantenere invariata la posizione dei dati della tabella sinistra o destra e spostare solo l’altro lato.)

Prendendo le tabelle fisiche di Doris come esempio, poiché i dati della tabella vengono archiviati attraverso i calcoli della distribuzione di hash, possiamo utilizzare direttamente questa caratteristica per ottimizzare il processo di shuffle dei dati durante le operazioni di be a part of. Supponiamo di avere due tabelle che devono essere unite e la colonna di be a part of è la colonna di secchio della tabella sinistra. In questo caso, non abbiamo bisogno di spostare i dati della tabella sinistra; Dobbiamo solo ridistribuire i dati della tabella destra in base alle informazioni di secchio della tabella sinistra per completare il calcolo di be a part of (come mostrato nella figura).

Il sovraccarico di rete per questo processo deriva principalmente dal movimento dei dati della tabella destra, cioè, t (r).

Colocate be a part of: The Final Skilled

Colocate Be part of è l’ottimizzazione definitiva, in cui i dati vengono pre-distribuiti allo stesso modo e non è richiesto alcun movimento dei dati durante il be a part of. È come una partnership perfettamente sincronizzata, con una cooperazione senza soluzione di continuità. Zero spese generali di rete e prestazioni ottimali, ma ha i requisiti più rigorosi.

Simile a Winbet Shuffle Be part of, se entrambi i lati della tabella che partecipano al be a part of sono distribuiti hash in base alla colonna della condizione di be a part of, possiamo saltare il processo di shuffle ed eseguire direttamente il calcolo di be a part of a livello locale. Ecco una semplice illustrazione usando le tabelle fisiche:

Quando Doris crea tavoli con DISTRIBUTED BY HASHi dati vengono distribuiti in base alla chiave di distribuzione hash durante l’importazione dei dati. Se la chiave di distribuzione hash delle due tabelle corrisponde alla colonna della condizione di be a part of, possiamo considerare che i dati di queste due tabelle sono stati pre-distribuiti in base ai requisiti di be a part of, advert esempio, non è necessaria alcuna operazione di shuffle aggiuntiva. Pertanto, durante la question effettiva, possiamo eseguire direttamente il calcolo di be a part of su queste due tabelle.

Colocate un advert esempio esempio

Dopo aver introdotto i quattro tipi di hash unire a Doris, scegli Colocate Be part of, The Final Skilled, per una resa dei conti:

Nell’esempio seguente, entrambe le tabelle t1 E t2 sono stati elaborati dal GROUP BY operatore e output nuove tabelle (a questo punto, entrambe tx E ty sono distribuiti da hash secondo c2). La successiva condizione di be a part of è tx.c2 = ty.c2che soddisfa perfettamente le condizioni per Colocate.

clarify choose *
from 
    (
        -- Desk t1 is hash-distributed by c1. After the GROUP BY operator, the information distribution turns into hash-distributed by c2.
        choose c2 as c2, sum(c1) as c1
        from t1
        group by c2 
    ) tx
be a part of 
    (
        -- Desk t2 is hash-distributed by c1. After the GROUP BY operator, the information distribution turns into hash-distributed by c2.
        choose c2 as c2, sum(c1) as c1
        from t2
        group by c2 
    ) ty
on tx.c2 = ty.c2;

Dal risultato del piano di esecuzione di spiegazione seguente, possiamo vedere che il nodo figlio sinistro del nodo di be a part of di 8 ° hash è il settimo nodo di aggregazione e il nodo figlio destro è il terzo nodo di aggregazione, senza che non appare il nodo di scambio.

Ciò indica che i dati dei nodi figlio sinistro e destro dopo l’aggregazione rimangono nella sua posizione originale senza alcun movimento dei dati e possono eseguire direttamente l’operazione di be a part of hash successiva localmente.

+------------------------------------------------------------+

| Clarify String(Nereids Planner)                            |

+------------------------------------------------------------+

| PLAN FRAGMENT 0                                            |

|   OUTPUT EXPRS:                                            |

|     c2(#20)                                                |

|     c1(#21)                                                |

|     c2(#22)                                                |

|     c1(#23)                                                |

|   PARTITION: HASH_PARTITIONED: c2(#10)                     |

|                                                            |

|   HAS_COLO_PLAN_NODE: true                                 |

|                                                            |

|   VRESULT SINK                                             |

|      MYSQL_PROTOCAL                                        |

|                                                            |

|   8:VHASH JOIN(373)                                        |

|   |  be a part of op: INNER JOIN(PARTITIONED)()                    |

|   |  equal be a part of conjunct: (c2(#14) = c2(#6))               |

|   |  cardinality=10                                        |

|   |  vec output tuple id: 9                                |

|   |  output tuple id: 9                                    |

|   |  vIntermediate tuple ids: 8                            |

|   |  hash output slot ids: 6 7 14 15                       |

|   |  remaining projections: c2(#16), c1(#17), c2(#18), c1(#19) |

|   |  remaining challenge output tuple id: 9                      |

|   |  distribute expr lists: c2(#14)                        |

|   |  distribute expr lists: c2(#6)                         |

|   |                                                        |

|   |----3:VAGGREGATE (merge finalize)(367)                  |

|   |    |  output: sum(partial_sum(c1)(#3))(#5)             |

|   |    |  group by: c2(#2)                                 |

|   |    |  sortByGroupKey:false                             |

|   |    |  cardinality=5                                    |

|   |    |  remaining projections: c2(#4), c1(#5)                |

|   |    |  remaining challenge output tuple id: 3                 |

|   |    |  distribute expr lists: c2(#2)                    |

|   |    |                                                   |

|   |    2:VEXCHANGE                                         |

|   |       offset: 0                                        |

|   |       distribute expr lists:                           |

|   |                                                        |

|   7:VAGGREGATE (merge finalize)(354)                       |

|   |  output: sum(partial_sum(c1)(#11))(#13)                |

|   |  group by: c2(#10)                                     |

|   |  sortByGroupKey:false                                  |

|   |  cardinality=10                                        |

|   |  remaining projections: c2(#12), c1(#13)                   |

|   |  remaining challenge output tuple id: 7                      |

|   |  distribute expr lists: c2(#10)                        |

|   |                                                        |

|   6:VEXCHANGE                                              |

|      offset: 0                                             |

|      distribute expr lists:                                |

|                                                            |

| PLAN FRAGMENT 1                                            |

|                                                            |

|   PARTITION: HASH_PARTITIONED: c1(#8)                      |

|                                                            |

|   HAS_COLO_PLAN_NODE: false                                |

|                                                            |

|   STREAM DATA SINK                                         |

|     EXCHANGE ID: 06                                        |

|     HASH_PARTITIONED: c2(#10)                              |

|                                                            |

|   5:VAGGREGATE (replace serialize)(348)                     |

|   |  STREAMING                                             |

|   |  output: partial_sum(c1(#8))(#11)                      |

|   |  group by: c2(#9)                                      |

|   |  sortByGroupKey:false                                  |

|   |  cardinality=10                                        |

|   |  distribute expr lists: c1(#8)                         |

|   |                                                        |

|   4:VOlapScanNode(345)                                     |

|      TABLE: tt.t1(t1), PREAGGREGATION: ON                  |

|      partitions=1/1 (t1)                                   |

|      tablets=1/1, tabletList=491188                        |

|      cardinality=21, avgRowSize=0.0, numNodes=1            |

|      pushAggOp=NONE                                        |

|                                                            |

| PLAN FRAGMENT 2                                            |

|                                                            |

|   PARTITION: HASH_PARTITIONED: c1(#0)                      |

|                                                            |

|   HAS_COLO_PLAN_NODE: false                                |

|                                                            |

|   STREAM DATA SINK                                         |

|     EXCHANGE ID: 02                                        |

|     HASH_PARTITIONED: c2(#2)                               |

|                                                            |

|   1:VAGGREGATE (replace serialize)(361)                     |

|   |  STREAMING                                             |

|   |  output: partial_sum(c1(#0))(#3)                       |

|   |  group by: c2(#1)                                      |

|   |  sortByGroupKey:false                                  |

|   |  cardinality=5                                         |

|   |  distribute expr lists: c1(#0)                         |

|   |                                                        |

|   0:VOlapScanNode(358)                                     |

|      TABLE: tt.t2(t2), PREAGGREGATION: ON                  |

|      partitions=1/1 (t2)                                   |

|      tablets=1/1, tabletList=491198                        |

|      cardinality=10, avgRowSize=0.0, numNodes=1            |

|      pushAggOp=NONE                                        |

|                                                            |

|                                                            |

| Statistics                                                 |

|  planed with unknown column statistics                     |

+------------------------------------------------------------+

105 rows in set (0.06 sec)

Il percorso per unirsi alla decisione

Dopo aver ascoltato la spiegazione di Previous Li, Xiao Zhang aveva un’epifania. Iscriviti all’ottimizzazione non riguarda semplicemente la scelta di una soluzione; Si tratta di prendere decisioni flessibili in base alla situazione reale:

Unisciti a un grande tavolo con un tavolino?
Vai all-in con trasmissione.

Tabelle di dimensioni simili?
La partizione shuffle è una scommessa sicura.

Tavolo sinistro secco in modo appropriato?
Bucket Shuffle mostra il suo potere.

Unendo le tabelle nello stesso gruppo?
Colocate unione apre la strada.

Non equa-goin?
Nest Loop Be part of arriva in soccorso.

Dopo aver messo in pratica queste strategie, Xiao Zhang ha compilato una serie di suggerimenti di ottimizzazione di be a part of:

• Pianificare la distribuzione dei dati in anticipo Posare le basi per operazioni di be a part of advert alte prestazioni.
• Sfruttare la potatura della partizione Per ridurre la quantità di dati coinvolti nei be a part of.
• Progettare saggiamente strategie di secchio Per creare condizioni favorevoli per il secchio e Colocate si uniscono.
• Configurare correttamente il parallelismo e la memoria Per massimizzare le prestazioni di be a part of.
• Monitorare attentamente l’utilizzo delle risorse Per identificare i colli di bottiglia delle prestazioni in modo tempestivo.

Ottimizzando le domande basate su queste intuizioni, Xiao Zhang è stato in grado di ridurre i compiti che originariamente hanno impiegato ore a pochi minuti, guadagnando elogi dal suo capo.

Il mondo dell’ottimizzazione di be a part of è vasto e complesso; Ciò che abbiamo esplorato oggi è solo la punta dell’iceberg. Scegliere la strategia di be a part of giusta per diversi scenari è la chiave per trovare l’equilibrio ottimale tra prestazioni e consumo di risorse.