Aggregazione con array e raggruppamenti in awk

In awk, un array associativo è una struttura chiave-valore in cui le chiavi possono essere stringhe o numeri. A differenza degli array indicizzati della maggior parte dei linguaggi, gli array di awk sono in realtà tabelle hash: sono perfetti per raggruppare e aggregare i dati in base ai valori dei campi.

• Dichiarazione implicita: basta assegnare arr[key] = value
• Le chiavi sono stringhe per impostazione predefinita (i numeri vengono convertiti)
• Nessun limite di dimensione: awk espande l'array secondo necessità
• Ideali per calcolare somme, conteggi e raggruppamenti aggregati in un'unica passata

Non è necessario inizializzare una chiave prima di incrementarla: awk considera automaticamente una chiave non impostata come zero o come stringa vuota.

Il pattern di aggregazione più comune consiste nel contare quante volte compare ogni valore univoco di un campo. Utilizzi il campo $1 (o qualsiasi altro campo) come chiave dell'array e incrementi un contatore per ogni riga corrispondente.

Il blocco END viene eseguito dopo aver consumato tutti i dati in input: è qui che stampa i risultati accumulati.

count[$1]++

Dopo l'elaborazione, count contiene il numero totale di righe per ogni valore univoco di $1.

Il conteggio è solo una forma di aggregazione. Per sommare un campo numerico raggruppandolo in base a un altro campo, accumuli il valore numerico in un array indicizzato dal campo del gruppo.

Il pattern è il seguente:

• Chiave = il campo usato per il raggruppamento (ad esempio $1 per il nome utente)
• Valore = il totale progressivo del campo numerico (ad esempio $2 per i byte)

In questo modo calcola la somma completa per gruppo in un'unica passata di awk, senza bisogno di ordinamento o pre-elaborazione.

awk consente di gestire più array contemporaneamente, fornendo conteggio e somma (e quindi anche la media) per ogni gruppo in un'unica scansione del file. È molto più efficiente che eseguire due volte la pipeline.

• count[key]++ — tiene traccia delle occorrenze
• total[key] += $N — tiene traccia della somma progressiva
• In END, divida total[k] / count[k] per ottenere la media del gruppo

È possibile creare una chiave composta concatenando più campi con un separatore. In questo modo si ottiene un raggruppamento su due dimensioni senza alcuna sintassi speciale.

Scelga un separatore che non possa comparire nei dati (ad esempio SUBSEP, il separatore di record integrato di awk \034, oppure una barra verticale letterale |).

• Chiave composta: arr[$1 SUBSEP $2] oppure arr[$1"|"$2]
• Divida nuovamente la chiave durante la stampa: split(key, parts, "|")

Gli array associativi facilitano il rilevamento dei valori min e max per gruppo. Il trucco consiste nell'inizializzare il valore solo alla prima occorrenza di ogni chiave, usando la condizione speciale !(key in arr).

• !(key in min_arr) è vera la prima volta che viene rilevata una chiave
• Dopo l'inizializzazione, confronti e sovrascriva il valore con il normale controllo minore di / maggiore di

Questo pattern evita uno zero spurio che falserebbe il valore minimo.

Un'attività comune nel mondo reale consiste nel trovare i valori più frequenti, fino a N. awk gestisce il conteggio; utilizzi sort e head in una pipeline per ordinare e limitare i risultati.

Questo pattern di pipeline è idiomatico nella gestione delle shell:

1. awk conta le occorrenze in un array e stampa count key in END
2. sort -rn ordina numericamente in ordine decrescente
3. head -n 5 conserva solo i primi 5 risultati

Lasciare ad awk il compito di aggregare e delegare l'ordinamento a sort segue la filosofia Unix.

Durante l'elaborazione di più file, le variabili integrate di awk NR (numero totale di record letti) e FNR (numero di record nel file corrente) consentono di indicare da quale file proviene ogni record usando FILENAME.

• FILENAME — nome del file attualmente in lettura
• FNR == 1 — si attiva all'inizio di ogni nuovo file (utile per saltare le intestazioni)

Questo consente di eseguire aggregazioni per gruppo e per file sull'intero contenuto di una directory di log con una sola invocazione di awk.

Il ciclo for (key in array) di awk non garantisce l'ordine. Per ottenere un output deterministico, passi a sort la stampa del blocco END di awk oppure raccolga i valori e li ordini all'interno di awk usando le funzioni asorti / asort (solo GNU awk).

Per gli script multipiattaforma, di solito si preferisce l'approccio portabile basato su una pipeline della shell:

• sort -k1,1 — ordina alfabeticamente in base al primo campo (la chiave del gruppo)
• sort -k2,2rn — ordina in base al secondo campo (conteggio/somma) numericamente in ordine decrescente

A volte è necessario reimpostare lo stato dell'aggregazione durante l'elaborazione, ad esempio quando si elaborano file di log in cui ogni sezione è separata da una riga vuota o da un valore sentinella.

• delete arr[key] — rimuove una singola voce
• delete arr — cancella l'intero array (GNU awk)
• Verifichi l'esistenza con (key in arr) prima di accedere all'array, per evitare di creare voci fantasma

Questa tecnica consente di eseguire aggregazioni su una finestra scorrevole o per sezione senza riavviare awk.

Mettiamo insieme tutti gli elementi: ecco un'aggregazione awk di livello produttivo, eseguita in un'unica passata sul formato di log combinato di Nginx. Calcola numero di richieste, byte totali e tasso di errore per host virtuale in un'unica scansione.

Tecniche principali utilizzate:

• Chiave composta: vhost estratto da un campo
• Array paralleli: reqs[], bytes[], errors[]
• Accumulo condizionale: $9 >= 400 per contare solo le risposte di errore
• Tabella formattata con printf in END

Verifichi la sua comprensione di un errore comune nell'aggregazione con awk.

Ha appreso i pattern fondamentali per calcolare aggregazioni per gruppo interamente all'interno di awk:

• Conteggio: count[$key]++ — incrementare a ogni riga e stampare in END
• Somma: total[$key] += $N — accumulare i campi numerici per gruppo
• Media: mantenere sia count[] sia total[] e dividere in END
• Minimo/Massimo: inizializzare alla prima occorrenza usando !(key in arr), quindi confrontare
• Chiavi composte: concatenare i campi con un separatore per il raggruppamento su più dimensioni
• Output ordinato: passare a sort la stampa del blocco END di awk per ottenere un ordinamento deterministico
• Reimpostazione delle sezioni: usare delete arr per cancellare lo stato tra sezioni logiche dell'input

Questi pattern consentono di sostituire query di database complesse o più passate nella pipeline con una singola invocazione efficiente di awk: una competenza essenziale per l'ingegneria delle shell in produzione.