Agregação com matrizes e agrupamento no awk

No awk, uma matriz associativa é um armazenamento de pares chave-valor em que as chaves podem ser qualquer texto ou número. Diferentemente das matrizes indexadas da maioria das linguagens, as matrizes do awk são, internamente, tabelas de dispersão — perfeitas para agrupar e agregar dados por valores de campos.

• Declare implicitamente: basta atribuir arr[key] = value
• As chaves são textos por padrão (os números são convertidos)
• Não há limite de tamanho — o awk aumenta a matriz conforme necessário
• Ideais para calcular somas, contagens e agregações por grupo em uma única passagem

Não é necessário inicializar uma chave antes de incrementá-la — o awk trata automaticamente uma chave não definida como zero ou como uma cadeia vazia.

O padrão de agregação mais comum é contar quantas vezes cada valor exclusivo de um campo aparece. Use o campo $1 (ou qualquer outro campo) como chave da matriz e incremente um contador a cada linha correspondente.

O bloco END é executado depois que toda a entrada é consumida — é nele que os resultados acumulados são impressos.

count[$1]++

Após o processamento, count contém o número total de linhas para cada valor exclusivo de $1.

Contar é apenas uma forma de agregação. Para somar um campo numérico agrupado por outro campo, acumule o valor numérico em uma matriz indexada pelo campo do grupo.

O padrão é:

• Chave = o campo usado para agrupar (por exemplo, $1 para o nome de usuário)
• Valor = total acumulado do campo numérico (por exemplo, $2 para bytes)

Isso calcula uma soma completa por grupo em uma única passagem do awk — não é necessário ordenar nem fazer pré-processamento.

O awk permite manter várias matrizes simultaneamente, fornecendo a contagem e a soma (e, portanto, a média) de cada grupo em uma única leitura do arquivo. Isso é muito mais eficiente do que executar o fluxo duas vezes.

• count[key]++ — acompanha as ocorrências
• total[key] += $N — acompanha a soma acumulada
• Em END, divida total[k] / count[k] para obter a média por grupo

Você pode criar uma chave composta concatenando vários campos com um separador. Isso fornece um agrupamento bidimensional sem nenhuma sintaxe especial.

Escolha um separador que não possa aparecer nos dados (por exemplo, SUBSEP, o separador de registros integrado do awk \034 ou uma barra vertical literal |).

• Chave composta: arr[$1 SUBSEP $2] ou arr[$1"|"$2]
• Divida novamente a chave ao imprimir: split(key, parts, "|")

As matrizes associativas facilitam o acompanhamento dos valores mínimo e máximo por grupo. O segredo é inicializar somente na primeira ocorrência de cada chave usando a condição especial !(key in arr).

• !(key in min_arr) é verdadeiro na primeira vez que uma chave é encontrada
• Após a inicialização, compare e substitua usando a verificação padrão de menor que / maior que

Esse padrão evita um zero indevido que corromperia o valor mínimo.

Uma tarefa comum no mundo real é encontrar os N valores mais frequentes. O awk faz a contagem; canalize a saída por sort e head para classificar e limitar os resultados.

Este padrão de canalização é idiomático na engenharia de shell:

1. O awk conta as ocorrências em uma matriz e imprime count key em END
2. sort -rn ordena numericamente em ordem decrescente
3. head -n 5 mantém apenas os 5 primeiros

Manter o awk concentrado na agregação e delegar a ordenação a sort segue a filosofia Unix.

Ao processar vários arquivos, os valores integrados NR (total de registros lidos) e FNR (registros do arquivo atual) permitem identificar de qual arquivo cada registro veio usando FILENAME.

• FILENAME — nome do arquivo que está sendo lido no momento
• FNR == 1 — é acionado no início de cada novo arquivo (útil para ignorar cabeçalhos)

Isso permite fazer a agregação por grupo, arquivo a arquivo, em um diretório inteiro de registros, com uma única execução do awk.

O laço for (key in array) do awk não garante uma ordem. Para obter resultados determinísticos, canalize a impressão de END do awk por sort ou reúna os valores e ordene-os dentro do awk usando as funções asorti / asort (somente no GNU awk).

A abordagem portátil de canalização do shell geralmente é preferível em scripts multiplataforma:

• sort -k1,1 — ordena alfabeticamente pelo primeiro campo (a chave do grupo)
• sort -k2,2rn — ordena numericamente em ordem decrescente pelo segundo campo (contagem/soma)

Às vezes, é necessário redefinir o estado da agregação durante o fluxo — por exemplo, ao processar arquivos de registros em que cada seção é separada por uma linha em branco ou por um valor sentinela.

• delete arr[key] — remove uma única entrada
• delete arr — limpa a matriz inteira (GNU awk)
• Verifique a existência com (key in arr) antes de acessar a chave, para evitar a criação de entradas fantasmas

Essa técnica permite fazer agregações por janela deslizante ou por seção sem reiniciar o awk.

Reunindo tudo — aqui está uma agregação de nível de produção, feita em uma única passagem do awk, sobre um registro no formato combinado do Nginx. Ela calcula a contagem de solicitações, o total de bytes e a taxa de erros por host virtual em uma única leitura.

Principais técnicas usadas:

• Chave composta: vhost extraído de um campo
• Matrizes paralelas: reqs[], bytes[], errors[]
• Acumulação condicional: $9 >= 400 para contar apenas respostas com erro
• Tabela formatada com printf em END

Teste sua compreensão de uma armadilha comum na agregação com awk.

Você aprendeu os principais padrões para calcular agregações por grupo inteiramente dentro do awk:

• Contagem: count[$key]++ — incremente a cada linha e imprima em END
• Soma: total[$key] += $N — acumule campos numéricos por grupo
• Média: mantenha count[] e total[] e divida em END
• Mínimo/máximo: inicialize na primeira ocorrência usando !(key in arr) e depois compare
• Chaves compostas: concatene campos com um separador para fazer agrupamentos multidimensionais
• Resultados ordenados: canalize a impressão de END do awk por sort para obter uma ordem determinística
• Redefinição de seções: use delete arr para limpar o estado entre seções lógicas da entrada

Esses padrões permitem substituir consultas pesadas a bancos de dados ou várias passagens de canalização por uma única execução eficiente do awk — uma habilidade essencial para a engenharia de shell em ambientes de produção.