Jointure de fichiers Linux

Introduction

Ce laboratoire vous présente la commande join sous Linux, un outil puissant qui vous permet de combiner des données issues de deux fichiers en fonction d'un champ commun. Tout comme la jointure de tables dans une base de données, cette commande est particulièrement utile pour les tâches de traitement et d'analyse de données dans les environnements Linux.

Au cours de ce laboratoire, vous apprendrez à utiliser la commande join avec différentes options pour fusionner des données issues de fichiers distincts, gérer différents séparateurs de champ et comprendre les principes de base des opérations de jointure de fichiers sous Linux. Ces compétences se révèleront précieuses lors de la manipulation de données structurées dans des fichiers texte, une tâche courante en administration système et en analyse de données.

Comprendre la commande de jointure de base

Dans cette étape, vous apprendrez la syntaxe et l'utilisation de base de la commande join. La commande join sous Linux combine les lignes de deux fichiers en fonction d'un champ commun, de la même manière que l'on joint des tables dans une base de données.

Créons deux fichiers d'exemple pour travailler. Nous allons créer des fichiers contenant des données météorologiques - plus précisément les dates d'événements de tempête et les directions du vent correspondantes.

Tout d'abord, créez un fichier appelé storms.txt avec des identifiants de tempête et des dates :

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

Maintenant, créez un autre fichier appelé winds.txt avec des identifiants de tempête et des directions du vent :

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

Examinons le contenu de ces fichiers pour comprendre leur structure :

cat ~/project/storms.txt

Vous devriez voir la sortie suivante :

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

Maintenant, regardons le fichier des vents :

cat ~/project/winds.txt

Vous devriez voir la sortie suivante :

1:NW
2:SE
3:NE

Notez que les deux fichiers ont un premier champ commun (l'identifiant de tempête) qui peut être utilisé pour les joindre. Maintenant, utilisons la commande join pour combiner ces fichiers en fonction de ce champ commun :

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

L'option -t: indique à la commande join que le séparateur de champ dans les deux fichiers est un deux-points (:). Par défaut, join recherche le champ commun dans la première colonne de chaque fichier.

Vous devriez voir la sortie suivante :

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

Cette sortie montre les données jointes des deux fichiers. Chaque ligne contient :

• L'identifiant de tempête (le champ commun)
• La date (du premier fichier)
• La direction du vent (du deuxième fichier)

La commande join a mis en correspondance les lignes ayant le même identifiant de tempête et les a combinées en une seule ligne dans la sortie.

Jointure de fichiers avec différents séparateurs de champ

Dans les scénarios réels, vous rencontrez souvent des fichiers qui utilisent différents caractères comme séparateurs de champ. Cette étape vous montre comment joindre de tels fichiers en utilisant la commande join avec un traitement texte supplémentaire.

Créons deux fichiers avec différents séparateurs de champ :

Tout d'abord, créez un fichier appelé storms_dash.txt avec des identifiants de tempête et des dates, en utilisant un tiret (-) comme séparateur :

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

Ensuite, créez un autre fichier appelé winds_comma.txt avec des identifiants de tempête et des directions du vent, en utilisant une virgule (,) comme séparateur :

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

Examinons le contenu de ces fichiers :

cat ~/project/storms_dash.txt

Vous devriez voir :

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

Maintenant, regardons le fichier winds_comma.txt :

cat ~/project/winds_comma.txt

Vous devriez voir :

1,NW
2,SE
3,NE

Le défi ici est que la commande join s'attend à ce que les deux fichiers utilisent le même séparateur de champ. Pour résoudre ce problème, nous devons prétraiter l'un des fichiers pour qu'il corresponde au séparateur de l'autre. Nous pouvons utiliser la commande tr pour traduire des caractères :

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

Cette commande effectue les opérations suivantes :

1. tr ',' '-' < ~/project/winds_comma.txt - Convertit toutes les virgules en tirets dans le contenu de winds_comma.txt
2. <(...) - Substitution de processus, qui traite la sortie de la commande entre parenthèses comme un fichier
3. join -t- ~/project/storms_dash.txt - Joint le fichier storms_dash.txt avec les données transformées, en utilisant le tiret (-) comme séparateur de champ

Vous devriez voir la sortie suivante :

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

Cette sortie montre les données jointes des deux fichiers, avec le tiret (-) comme séparateur de champ partout. La substitution de processus est une fonctionnalité puissante de bash qui vous permet de traiter la sortie d'une commande comme un fichier, sans avoir besoin de créer des fichiers temporaires.

Options avancées de jointure

Dans les tâches réelles de traitement de données, vous avez souvent besoin d'opérations de jointure plus avancées, telles que la gestion des données non appariées ou la sélection de champs spécifiques. Cette étape vous présente ces options avancées de la commande join.

Créons deux fichiers plus complexes pour nos exemples :

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

Examinons le contenu de ces fichiers :

cat ~/project/storms_types.txt

Vous devriez voir :

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

cat ~/project/severity.txt

Vous devriez voir :

1:High
2:Medium
5:Low

Notez que ces fichiers n'ont pas une correspondance parfaite des identifiants :

• severity.txt a une entrée pour l'identifiant de tempête 5, qui n'existe pas dans storms_types.txt
• storms_types.txt a des entrées pour les identifiants de tempête 3 et 4, qui n'existent pas dans severity.txt

Par défaut, join ne produit que les lignes où le champ de jointure correspond dans les deux fichiers :

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

Vous devriez voir :

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

Seuls les identifiants de tempête 1 et 2 apparaissent dans la sortie car ce sont les seuls qui existent dans les deux fichiers.

Gestion des lignes non appariées

Pour inclure les lignes non appariées dans la sortie, vous pouvez utiliser l'option -a :

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

L'option -a 1 indique à join d'inclure les lignes non appariées du premier fichier, et -a 2 fait de même pour le deuxième fichier.

Vous devriez voir :

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

Notez comment les lignes non appariées ont des champs vides là où les données de l'autre fichier devraient être.

Sélection de champs spécifiques

Vous pouvez également sélectionner des champs spécifiques de chaque fichier à inclure dans la sortie en utilisant l'option -o :

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

L'option -o 1.1,1.3,2.2 spécifie quels champs afficher :

• 1.1 : Premier champ du premier fichier (identifiant de tempête)
• 1.3 : Troisième champ du premier fichier (type de tempête)
• 2.2 : Deuxième champ du deuxième fichier (gravité)

Vous devriez voir :

1:Thunderstorm:High
2:Hurricane:Medium

Cette sortie inclut seulement l'identifiant de tempête, le type de tempête et le niveau de gravité, omettant les informations de date. Cela est particulièrement utile lorsque vous travaillez avec des fichiers qui ont de nombreux champs mais que vous n'en avez besoin que de certains dans votre sortie.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la commande join sous Linux pour combiner des données provenant de différents fichiers en fonction d'un champ commun. Il s'agit d'une compétence essentielle pour le traitement et l'analyse de données dans les environnements Linux.

Vous avez pratiqué l'utilisation de la commande join avec diverses options :

• La syntaxe de base pour joindre des fichiers ayant le même séparateur de champ
• La gestion de fichiers avec différents séparateurs de champ en utilisant la substitution de processus et la commande tr
• L'utilisation de l'option -a pour inclure les lignes non appariées dans la sortie
• L'utilisation de l'option -o pour sélectionner des champs spécifiques de chaque fichier pour la sortie

La commande join est particulièrement utile lorsque vous travaillez avec des données textuelles structurées, des fichiers journaux (logs) ou dans toute situation où vous avez besoin de combiner des informations provenant de différentes sources en fonction d'un identifiant commun. Cette compétence complète d'autres commandes de traitement de texte sous Linux telles que grep, sed et awk, vous offrant ainsi un ensemble d'outils puissant pour la manipulation de données en ligne de commande.