Aggregering med awk-arrays og gruppering

Optælling er kun én form for aggregering. Hvis du vil summere et numerisk felt grupperet efter et andet felt, skal du akkumulere den numeriske værdi i en array, der bruger gruppefeltet som nøgle.

Mønsteret er:

• Nøgle = feltet, der bruges til gruppering (f.eks. $1 for brugernavn)
• Værdi = den løbende total for det numeriske felt (f.eks. $2 for bytes)

Dette beregner en komplet grupperet sum i én awk-gennemgang — sortering eller forbehandling er ikke nødvendig.

awk lader dig vedligeholde flere arrays samtidigt, så du kan beregne antal og sum (og dermed gennemsnit) for hver gruppe i én gennemgang af filen. Det er langt mere effektivt end at køre datakæden to gange.

• count[key]++ — holder styr på forekomster
• total[key] += $N — holder styr på den løbende sum
• I END dividerer du total[k] / count[k] for at få gennemsnittet pr. gruppe

Du kan oprette en sammensat nøgle ved at sammenkæde flere felter med et skilletegn. Det giver dig en todimensionel gruppering uden særlig syntaks.

Vælg et skilletegn, der ikke kan forekomme i dataene (f.eks. SUBSEP, det indbyggede awk-postskilletegn \034 eller en bogstavelig lodret streg |).

• Sammensat nøgle: arr[$1 SUBSEP $2] eller arr[$1"|"$2]
• Opdel nøglen igen under udskrivning: split(key, parts, "|")

Associative arrays gør det nemt at spore min- og max-værdier pr. gruppe. Tricket er kun at initialisere ved den første forekomst af hver nøgle ved hjælp af den særlige betingelse !(key in arr).

• !(key in min_arr) er sand første gang, en nøgle ses
• Efter initialiseringen sammenligner du og overskriver med det almindelige tjek for mindre end / større end

Dette mønster undgår et misvisende nul, som ellers ville ødelægge din minimumsværdi.

En almindelig opgave fra virkeligheden er at finde de N hyppigst forekommende værdier. awk håndterer optællingen; send resultatet gennem sort og head for at rangordne og begrænse det.

Dette datakædemønster er idiomatisk i shell-udvikling:

1. awk tæller forekomster i en array og udskriver count key i END
2. sort -rn sorterer numerisk i faldende rækkefølge
3. head -n 5 beholder kun de 5 øverste

Ved at lade awk fokusere på aggregering og overlade sorteringen til sort følger du Unix-filosofien.

Når du behandler flere filer, kan awks indbyggede NR (det samlede antal læste poster) og FNR (poster i den aktuelle fil) sammen med FILENAME fortælle, hvilken fil hver post kom fra.

• FILENAME — navnet på den fil, der læses i øjeblikket
• FNR == 1 — udløses ved starten af hver ny fil (nyttigt til at springe overskrifter over)

Det gør det muligt at aggregere grupper pr. fil på tværs af en hel mappe med logfiler i én awk-påkaldelse.

Løkken for (key in array) i awk garanterer ikke nogen rækkefølge. Hvis du vil have deterministisk output, kan du sende awks END-udskrivning gennem sort eller samle værdierne og sortere dem i awk ved hjælp af funktionerne asorti / asort (kun GNU awk).

Den portable shell-datakædetilgang foretrækkes normalt til scripts på tværs af platforme:

• sort -k1,1 — sortér efter det første felt (gruppenøgle) alfabetisk
• sort -k2,2rn — sortér efter det andet felt (antal/sum) numerisk i faldende rækkefølge

Nogle gange skal du nulstille aggregeringstilstanden undervejs — f.eks. når du behandler logfiler, hvor hver sektion er adskilt af en tom linje eller en markørværdi.

• delete arr[key] — fjerner en enkelt post
• delete arr — rydder hele arrayen (GNU awk)
• Kontrollér, om nøglen findes, med (key in arr), før du tilgår den, for at undgå at oprette spøgelsesposter

Denne teknik gør det muligt at aggregere med skydevindue eller pr. sektion uden at genstarte awk.

Her samler vi det hele — en produktionsklar awk-aggregering i én gennemgang af et Nginx-logformat med kombinerede felter. Den beregner antal forespørgsler, samlet antal bytes og fejlfrekvens pr. virtuel vært i én gennemgang.

Anvendte nøgleteknikker:

• Sammensat nøgle: vhost udtrukket fra et felt
• Parallelle arrays: reqs[], bytes[], errors[]
• Betinget akkumulering: $9 >= 400 for kun at tælle fejlsvar
• Formateret printf-tabel i END

Du har lært de grundlæggende mønstre til at beregne grupperede aggregeringer udelukkende i awk:

• Optælling: count[$key]++ — øg ved hver række, og udskriv i END
• Summering: total[$key] += $N — akkumulér numeriske felter pr. gruppe
• Gennemsnit: vedligehold både count[] og total[], og divider i END
• Min./maks.: initialisér ved den første forekomst med !(key in arr), og sammenlign derefter
• Sammensatte nøgler: sammenkæd felter med et skilletegn for flerdimensionel gruppering
• Sorteret output: send awks END-udskrivning gennem sort for deterministisk rækkefølge
• Nulstilling af sektioner: brug delete arr til at rydde tilstanden mellem logiske sektioner i inputtet

Disse mønstre lader dig erstatte tunge databaseforespørgsler eller flere gennemløb af datakæden med én effektiv awk-påkaldelse — en vigtig færdighed inden for produktionsklar shell-udvikling.