Aggregering med awk-tabeller og gruppering

I awk er en assosiativ matrise en nøkkel-verdi-lagring der nøklene kan være en hvilken som helst streng eller et tall. I motsetning til indekserte matriser i de fleste språk er matriser i awk egentlig hash-tabeller — perfekt for å gruppere og aggregere data etter feltverdier.

• Deklareres implisitt: tilordne ganske enkelt arr[key] = value
• Nøkler er strenger som standard (tall konverteres)
• Ingen størrelsesbegrensning — awk utvider matrisen etter behov
• Ideelt for å beregne summer, antall og gruppevise oppsummeringer i én gjennomgang

Du trenger ikke å initialisere en nøkkel før du øker den — awk behandler automatisk en nøkkel som ikke er satt, som null eller en tom streng.

Det vanligste aggregeringsmønsteret er å telle hvor mange ganger hver unike verdi i et felt forekommer. Bruk feltet $1 (eller et hvilket som helst annet felt) som matrise­nøkkel, og øk en teller for hver rad som samsvarer.

END-blokken kjøres etter at all input er lest — det er der du skriver ut de akkumulerte resultatene.

count[$1]++

Etter behandlingen inneholder count det totale antallet linjer for hver unike verdi av $1.

Å telle er bare én form for aggregering. Hvis du vil summere et numerisk felt gruppert etter et annet felt, akkumulerer du den numeriske verdien i en matrise som er nøkkelbestemt av gruppefeltet.

Mønsteret er:

• Nøkkel = feltet det grupperes etter (for eksempel $1 for brukernavn)
• Verdi = løpende total for det numeriske feltet (for eksempel $2 for byte)

Dette beregner en full gruppevis sum i én awk-gjennomgang — ingen sortering eller forhåndsbehandling er nødvendig.

awk lar deg vedlikeholde flere matriser samtidig, slik at du får antall og sum (og dermed gjennomsnitt) for hver gruppe i én gjennomgang av filen. Dette er langt mer effektivt enn å kjøre rørledningen to ganger.

• count[key]++ — holder oversikt over forekomster
• total[key] += $N — holder oversikt over den løpende summen
• I END deler du total[k] / count[k] for å finne gjennomsnittet per gruppe

Du kan opprette en sammensatt nøkkel ved å sette sammen flere felt med et skilletegn. Dette gir deg en todimensjonal gruppering uten spesiell syntaks.

Velg et skilletegn som ikke kan forekomme i dataene (for eksempel SUBSEP, det innebygde awk-postskilletegnet \034, eller en bokstavelig loddrett strek |).

• Sammensatt nøkkel: arr[$1 SUBSEP $2] eller arr[$1"|"$2]
• Del nøkkelen opp igjen ved utskrift: split(key, parts, "|")

Assosiative matriser gjør det enkelt å holde oversikt over min- og max-verdier per gruppe. Trikset er å initialisere bare første gang hver nøkkel forekommer, ved hjelp av den spesielle betingelsen !(key in arr).

• !(key in min_arr) er sann første gang en nøkkel registreres
• Etter initialiseringen sammenligner du og overskriver med den vanlige testen for mindre enn / større enn

Dette mønsteret unngår en misvisende nullverdi som ellers ville ødelagt minimumsverdien.

En vanlig oppgave i praksis er å finne de N mest frekvente verdiene. awk håndterer opptellingen; send resultatet gjennom sort og head for å rangere og begrense det.

Dette rørledningsmønsteret er idiomatisk i skallprogrammering:

1. awk teller forekomster i en matrise og skriver ut count key i END
2. sort -rn sorterer numerisk i synkende rekkefølge
3. head -n 5 beholder bare de fem øverste

Ved å la awk fokusere på aggregering og overlate sorteringen til sort følger du Unix-filosofien.

Når du behandler flere filer, lar awks innebygde NR (totalt antall leste poster) og FNR (antall poster i gjeldende fil) deg merke hvilken fil hver post kom fra ved hjelp av FILENAME.

• FILENAME — navnet på filen som leses nå
• FNR == 1 — utløses ved starten av hver nye fil (nyttig for å hoppe over overskrifter)

Dette gjør det mulig å aggregere grupper per fil på tvers av en hel katalog med logger i én awk-kjøring.

for (key in array)-løkken i awk garanterer ikke rekkefølgen. For deterministiske resultater kan du sende awks END-utskrift gjennom sort, eller samle inn verdier og sortere dem i awk ved hjelp av funksjonene asorti / asort (bare GNU awk).

Den portable tilnærmingen med en skallrørledning foretrekkes vanligvis for skript på tvers av plattformer:

• sort -k1,1 — sorter alfabetisk etter det første feltet (gruppenøkkelen)
• sort -k2,2rn — sorter numerisk etter det andre feltet (antall/sum) i synkende rekkefølge

Noen ganger må du tilbakestille aggregeringstilstanden underveis — for eksempel når du behandler loggfiler der hver seksjon er skilt med en tom linje eller en markørverdi.

• delete arr[key] — fjerner én oppføring
• delete arr — tømmer hele matrisen (GNU awk)
• Kontroller om nøkkelen finnes med (key in arr) før du bruker den, for å unngå å opprette spøkelsesoppføringer

Denne teknikken gjør det mulig å aggregere med glidende vindu eller per seksjon uten å starte awk på nytt.

Her setter vi alt sammen — en produksjonsklar awk-aggregering i én gjennomgang av et Nginx-format med kombinerte logger. Den beregner antall forespørsler, totalt antall byte og feilrate per virtuell vert i én gjennomgang.

Viktige teknikker:

• Sammensatt nøkkel: vhost hentet fra et felt
• Parallelle matriser: reqs[], bytes[], errors[]
• Betinget akkumulering: $9 >= 400 for å telle bare feilsvar
• Formatert printf-tabell i END

Du har lært de grunnleggende mønstrene for å beregne gruppevise aggregeringer helt i awk:

• Opptelling: count[$key]++ — øk for hver rad, og skriv ut i END
• Summering: total[$key] += $N — akkumuler numeriske felt per gruppe
• Gjennomsnitt: vedlikehold både count[] og total[], og divider i END
• Min/maks: initialiser ved første forekomst med !(key in arr), og sammenlign deretter
• Sammensatte nøkler: sett sammen felt med et skilletegn for flerdimensjonal gruppering
• Sortert resultat: send awks END-utskrift gjennom sort for en deterministisk rekkefølge
• Tilbakestilling av seksjoner: bruk delete arr for å tømme tilstanden mellom logiske seksjoner i inputen

Med disse mønstrene kan du erstatte tunge databasespørringer eller flere rørledningsgjennomganger med én effektiv awk-kjøring — en viktig ferdighet innen produksjonsrettet skallprogrammering.