Junção de Arquivos no Linux

Introdução

Este laboratório apresenta o comando join no Linux, um utilitário poderoso que permite combinar dados de dois arquivos com base em um campo comum. Semelhante à junção de tabelas em um banco de dados, este comando é particularmente útil para tarefas de processamento e análise de dados em ambientes Linux.

Ao longo deste laboratório, você aprenderá a usar o comando join com diferentes opções para mesclar dados de arquivos separados, lidar com diferentes separadores de campo e entender os princípios básicos das operações de junção de arquivos no Linux. Essas habilidades serão valiosas ao trabalhar com dados estruturados em arquivos de texto, uma tarefa comum em administração de sistemas e análise de dados.

Entendendo o Comando join Básico

Nesta etapa, você aprenderá a sintaxe básica e o uso do comando join. O comando join no Linux combina linhas de dois arquivos com base em um campo comum, semelhante à junção de tabelas em um banco de dados.

Vamos criar dois arquivos de exemplo para trabalhar. Criaremos arquivos contendo dados meteorológicos - especificamente datas de eventos de tempestades e suas respectivas direções do vento.

Primeiro, crie um arquivo chamado storms.txt com IDs de tempestades e datas:

echo -e "1:2023-04-01\n2:2023-04-15\n3:2023-05-02" > ~/project/storms.txt

Agora, crie outro arquivo chamado winds.txt com IDs de tempestades e direções do vento:

echo -e "1:NW\n2:SE\n3:NE" > ~/project/winds.txt

Vamos examinar o conteúdo desses arquivos para entender sua estrutura:

cat ~/project/storms.txt

Você deve ver a seguinte saída:

1:2023-04-01
2:2023-04-15
3:2023-05-02

Agora, vamos olhar para o arquivo de ventos:

cat ~/project/winds.txt

Você deve ver a seguinte saída:

1:NW
2:SE
3:NE

Observe que ambos os arquivos têm um primeiro campo comum (o ID da tempestade) que pode ser usado para uni-los. Agora, vamos usar o comando join para combinar esses arquivos com base nesse campo comum:

join -t: ~/project/storms.txt ~/project/winds.txt

A opção -t: informa ao comando join que o separador de campo em ambos os arquivos é dois pontos (:). Por padrão, join procura o campo comum na primeira coluna de cada arquivo.

Você deve ver a seguinte saída:

1:2023-04-01:NW
2:2023-04-15:SE
3:2023-05-02:NE

Esta saída mostra os dados unidos de ambos os arquivos. Cada linha contém:

• O ID da tempestade (o campo comum)
• A data (do primeiro arquivo)
• A direção do vento (do segundo arquivo)

O comando join combinou as linhas com o mesmo ID de tempestade e as combinou em linhas únicas na saída.

Juntando Arquivos com Diferentes Separadores de Campo

Em cenários do mundo real, você frequentemente encontra arquivos que usam diferentes caracteres como separadores de campo. Esta etapa mostra como juntar esses arquivos usando o comando join com processamento de texto adicional.

Vamos criar dois arquivos com diferentes separadores de campo:

Primeiro, crie um arquivo chamado storms_dash.txt com IDs de tempestades e datas, usando um traço (-) como separador:

echo -e "1-2023-04-10\n2-2023-04-20\n3-2023-05-05" > ~/project/storms_dash.txt

Em seguida, crie outro arquivo chamado winds_comma.txt com IDs de tempestades e direções do vento, usando uma vírgula (,) como separador:

echo -e "1,NW\n2,SE\n3,NE" > ~/project/winds_comma.txt

Vamos examinar o conteúdo desses arquivos:

cat ~/project/storms_dash.txt

Você deve ver:

1-2023-04-10
2-2023-04-20
3-2023-05-05

Agora, vamos olhar para o arquivo winds_comma:

cat ~/project/winds_comma.txt

Você deve ver:

1,NW
2,SE
3,NE

O desafio aqui é que o comando join espera que ambos os arquivos usem o mesmo separador de campo. Para resolver este problema, precisamos pré-processar um dos arquivos para corresponder ao separador do outro. Podemos usar o comando tr para traduzir caracteres:

join -t- ~/project/storms_dash.txt <(tr ',' '-' < ~/project/winds_comma.txt)

Este comando realiza as seguintes operações:

1. tr ',' '-' < ~/project/winds_comma.txt - Converte todas as vírgulas em traços no conteúdo de winds_comma.txt
2. <(...) - Substituição de processo (process substitution), que trata a saída do comando incluído como um arquivo
3. join -t- ~/project/storms_dash.txt - Junta o arquivo storms_dash.txt com os dados transformados, usando o traço (-) como separador de campo

Você deve ver a seguinte saída:

1-2023-04-10-NW
2-2023-04-20-SE
3-2023-05-05-NE

Esta saída mostra os dados unidos de ambos os arquivos, com o traço (-) como separador de campo em todo o processo. A substituição de processo é um recurso poderoso no bash que permite que você trate a saída de um comando como um arquivo, sem precisar criar arquivos temporários.

Opções Avançadas do Comando join

Em tarefas reais de processamento de dados, você frequentemente precisa de operações de junção mais avançadas, como lidar com dados não emparelhados ou selecionar campos específicos. Esta etapa apresenta essas opções avançadas do comando join.

Vamos criar mais dois arquivos complexos para nossos exemplos:

echo -e "1:2023-04-01:Thunderstorm\n2:2023-04-15:Hurricane\n3:2023-05-02:Tornado\n4:2023-05-10:Blizzard" > ~/project/storms_types.txt
echo -e "1:High\n2:Medium\n5:Low" > ~/project/severity.txt

Vamos examinar o conteúdo desses arquivos:

cat ~/project/storms_types.txt

Você deve ver:

1:2023-04-01:Thunderstorm
2:2023-04-15:Hurricane
3:2023-05-02:Tornado
4:2023-05-10:Blizzard

cat ~/project/severity.txt

Você deve ver:

1:High
2:Medium
5:Low

Observe que esses arquivos não têm uma correspondência perfeita de IDs:

• severity.txt tem uma entrada para o ID da tempestade 5, que não existe em storms_types.txt
• storms_types.txt tem entradas para os IDs de tempestade 3 e 4, que não existem em severity.txt

Por padrão, join só gera linhas onde o campo de junção corresponde em ambos os arquivos:

join -t: ~/project/storms_types.txt ~/project/severity.txt

Você deve ver:

1:2023-04-01:Thunderstorm:High
2:2023-04-15:Hurricane:Medium

Apenas os IDs de tempestade 1 e 2 aparecem na saída porque são os únicos que existem em ambos os arquivos.

Lidando com Linhas Não Emparelhadas

Para incluir linhas não emparelhadas na saída, você pode usar a opção -a:

join -t: -a 1 -a 2 ~/project/storms_types.txt ~/project/severity.txt

A opção -a 1 informa ao join para incluir linhas não emparelhadas do primeiro arquivo, e -a 2 faz o mesmo para o segundo arquivo.

Você deve ver:

1:2023-04-01:Thunderstorm:High
2:2023-04-15:Hurricane:Medium
3:2023-05-02:Tornado:
4:2023-05-10:Blizzard:
5::Low

Observe como as linhas não emparelhadas têm campos vazios onde os dados do outro arquivo estariam.

Selecionando Campos Específicos

Você também pode selecionar campos específicos de cada arquivo para incluir na saída usando a opção -o:

join -t: -o 1.1,1.3,2.2 ~/project/storms_types.txt ~/project/severity.txt

A opção -o 1.1,1.3,2.2 especifica quais campos gerar:

• 1.1: Primeiro campo do primeiro arquivo (ID da tempestade)
• 1.3: Terceiro campo do primeiro arquivo (tipo de tempestade)
• 2.2: Segundo campo do segundo arquivo (severidade)

Você deve ver:

1:Thunderstorm:High
2:Hurricane:Medium

Esta saída inclui apenas o ID da tempestade, o tipo de tempestade e o nível de severidade, omitindo as informações da data. Isso é particularmente útil ao trabalhar com arquivos que têm muitos campos, mas você só precisa de campos específicos na sua saída.

Resumo

Neste laboratório, você aprendeu como usar o comando join no Linux para combinar dados de diferentes arquivos com base em um campo comum. Esta é uma habilidade essencial para processamento e análise de dados em ambientes Linux.

Você praticou o uso do comando join com várias opções:

• A sintaxe básica para juntar arquivos com o mesmo separador de campo
• Lidar com arquivos com diferentes separadores de campo usando substituição de processo (process substitution) e o comando tr
• Usar a opção -a para incluir linhas não emparelhadas na saída
• Usar a opção -o para selecionar campos específicos de cada arquivo para a saída

O comando join é particularmente útil ao trabalhar com dados de texto estruturados, arquivos de log ou qualquer situação em que você precise combinar informações de diferentes fontes com base em um identificador comum. Essa habilidade complementa outros comandos de processamento de texto do Linux, como grep, sed e awk, fornecendo a você um conjunto de ferramentas poderoso para manipulação de dados na linha de comando.