Un guide de base pour les débutants

Table des matières

Souhaitez-vous assembler plusieurs colonnes de texte en une seule en SQL ? Cet article vous explique comment employer la fonction SQL CONCAT pour joindre des chaînes de caractères.

Lors de l’interrogation d’une base de données, il est parfois nécessaire de fusionner plusieurs colonnes de texte plutôt que de simplement afficher une seule colonne. Cette opération est particulièrement utile pour améliorer la lisibilité des résultats.

Par exemple, vous pouvez créer un champ « nom_complet » en combinant les champs « prénom » et « nom ». De même, vous pouvez assembler l’adresse complète à partir des colonnes « rue », « ville », « état », etc.

En SQL, la fonction CONCAT est votre alliée pour cette tâche. Ce guide vous présentera les points suivants :

La structure de la fonction SQL CONCAT
Des exemples d’utilisation concrets
La gestion des valeurs NULL lors de l’assemblage de colonnes

C’est parti !

Syntaxe de la fonction SQL CONCAT

Voici comment se présente la syntaxe de la fonction SQL CONCAT :

CONCAT(chaine_1, chaine_2, ..., chaine_n);

Ici, `chaine_1`, `chaine_2`, …, `chaine_n` représentent les chaînes que vous souhaitez assembler. Il peut s’agir de texte littéral, de noms de colonnes, ou d’un mélange des deux.

Assembler des chaînes littérales avec CONCAT

La fonction CONCAT peut aussi être utilisée avec du texte. Voyons un exemple simple :

Nous allons combiner les chaînes « Bonjour » et « le monde ! » pour créer une phrase de salutation :

SELECT CONCAT('Bonjour, ', 'le monde!') AS salutation;

L’exécution de cette requête donnera le résultat ci-dessous :

  
  +---------------+
  | salutation    |
  +---------------+
  | Bonjour, le monde! |
  +---------------+
  1 ligne dans le jeu (0.00 sec)

En pratique, vous aurez plus souvent besoin d’assembler des colonnes de tables plutôt que du simple texte. Voici donc quelques exemples d’utilisation de CONCAT en SQL avec des données réelles.

Comment assembler des colonnes en SQL

Passons maintenant à l’interrogation d’une table de base de données.

📑 Les requêtes présentées dans ce tutoriel sont exécutées sur une base de données MySQL. Vous pouvez les adapter à votre SGBDR préféré.

Création d’une table avec des données

Commençons par créer une base de données pour nos exemples :

CREATE DATABASE db1;

use db1;

Créons ensuite une table nommée `employes` avec les colonnes suivantes et leurs types :

CREATE TABLE employes (
  ID INT AUTO_INCREMENT PRIMARY KEY,
  prenom VARCHAR(50),
  nom VARCHAR(50),
  rue VARCHAR(100),
  ville VARCHAR(50),
  etat VARCHAR(2),
  nom_utilisateur VARCHAR(20)
  );

Ajoutons quelques enregistrements à cette table :

INSERT INTO employes (prenom, nom, rue, ville, etat, nom_utilisateur) VALUES
  ('Jean', 'Dupont', '123 rue Principale', 'Paris', 'FR', 'jean123'),
  ('Alice', 'Martin', '456 rue des Lilas', 'Lyon', 'FR', 'alice456'),
  ('Bob', 'Lefevre', '789 avenue des Chênes', 'Marseille', 'FR', 'bob789'),
  ('Marie', 'Garcia', '321 rue du Pin', 'Toulouse', 'FR', 'marie456'),
  ('Jacques', 'Bernard', '555 avenue des Cèdres', 'Nice', 'FR', 'jacques789'),
  ('Emilie', 'Thomas', '777 rue des Erables', 'Bordeaux', 'FR', 'emilie123'),
  ('Michel', 'Robert', '999 rue des Bouleaux', 'Nantes', 'FR', 'michel456'),
  ('Julie', 'Richard', '111 rue du Noyer', 'Strasbourg', 'FR', 'julie789'),
  ('Guillaume', 'Petit', '222 rue des Cerisiers', 'Lille', 'FR', 'guillaume123'),
  ('Sophie', 'Durand', '444 rue des Pins', 'Montpellier', 'FR', 'sophie456');

Exemple 1 : Afficher les noms complets

Commençons par assembler les colonnes `prenom` et `nom` pour obtenir le `nom_complet`. Voici comment utiliser la fonction SQL CONCAT :

SELECT CONCAT(prenom, ' ', nom) AS nom_complet FROM employes;

Voici le résultat :

  
  +----------------+
  | nom_complet    |
  +----------------+
  | Jean Dupont     |
  | Alice Martin    |
  | Bob Lefevre     |
  | Marie Garcia    |
  | Jacques Bernard |
  | Emilie Thomas   |
  | Michel Robert   |
  | Julie Richard   |
  | Guillaume Petit |
  | Sophie Durand   |
  +----------------+
  10 lignes dans le jeu (0.00 sec)

Notez l’utilisation de la chaîne » » comme séparateur pour insérer un espace entre le prénom et le nom.

Exemple 2 : Construire les adresses

Prenons un autre exemple.

Nous disposons des colonnes `rue`, `ville` et `etat`. Nous pouvons les assembler pour créer l’`adresse_complete` en utilisant une virgule comme séparateur :

SELECT CONCAT(rue, ', ', ville, ', ', etat) AS adresse_complete FROM employes;

Voici le résultat :

  
  +---------------------------+
  | adresse_complete          |
  +---------------------------+
  | 123 rue Principale, Paris, FR |
  | 456 rue des Lilas, Lyon, FR    |
  | 789 avenue des Chênes, Marseille, FR  |
  | 321 rue du Pin, Toulouse, FR  |
  | 555 avenue des Cèdres, Nice, FR   |
  | 777 rue des Erables, Bordeaux, FR |
  | 999 rue des Bouleaux, Nantes, FR   |
  | 111 rue du Noyer, Strasbourg, FR   |
  | 222 rue des Cerisiers, Lille, FR |
  | 444 rue des Pins, Montpellier, FR  |
  +---------------------------+
  10 lignes dans le jeu (0.00 sec)

Exemple 3 : Créer des URL de profil

Rappelons que nous avons une colonne `nom_utilisateur` dans la table `employes`.

Imaginons que votre site web soit `https://www.exemple.com/` et que les profils utilisateurs soient accessibles via `https://www.exemple.com/utilisateur/`. Nous pouvons générer l’`url_profil` grâce à la fonction CONCAT comme ceci :

SELECT CONCAT('https://www.exemple.com/utilisateur/', nom_utilisateur) AS url_profil
  FROM employes;

Voici les URL de profil de tous les employés :

  
  +-----------------------------------------+
  | url_profil                              |
  +-----------------------------------------+
  | https://www.exemple.com/utilisateur/jean123    |
  | https://www.exemple.com/utilisateur/alice456   |
  | https://www.exemple.com/utilisateur/bob789     |
  | https://www.exemple.com/utilisateur/marie456    |
  | https://www.exemple.com/utilisateur/jacques789   |
  | https://www.exemple.com/utilisateur/emilie123   |
  | https://www.exemple.com/utilisateur/michel456 |
  | https://www.exemple.com/utilisateur/julie789 |
  | https://www.exemple.com/utilisateur/guillaume123 |
  | https://www.exemple.com/utilisateur/sophie456   |
  +-----------------------------------------+
  10 lignes dans le jeu (0.00 sec)

Gestion des valeurs NULL

Dans notre table `employes`, toutes les lignes ont des valeurs pour chaque colonne. Mais que se passe-t-il si certaines colonnes contiennent des valeurs NULL ?

Modifions un enregistrement pour tester cela. Nous allons mettre à jour la ligne avec l’ID = 2 en assignant NULL à la colonne `rue` :

UPDATE employes
  SET rue = NULL
  WHERE ID = 2; -- Modification de l'enregistrement avec l'ID 2

Requête OK, 1 ligne modifiée (0.05 sec)
  Lignes trouvées : 1   Modifiées : 1   Avertissements : 0

Utilisons maintenant CONCAT pour sélectionner l’`adresse_complete` :

SELECT CONCAT(rue, ', ', ville, ', ', etat) AS adresse_complete FROM employes;

Voici le résultat :

  
  +---------------------------+
  | adresse_complete          |
  +---------------------------+
  | 123 rue Principale, Paris, FR |
  | NULL                       |
  | 789 avenue des Chênes, Marseille, FR  |
  | 321 rue du Pin, Toulouse, FR  |
  | 555 avenue des Cèdres, Nice, FR   |
  | 777 rue des Erables, Bordeaux, FR |
  | 999 rue des Bouleaux, Nantes, FR   |
  | 111 rue du Noyer, Strasbourg, FR   |
  | 222 rue des Cerisiers, Lille, FR |
  | 444 rue des Pins, Montpellier, FR  |
  +---------------------------+
  10 lignes dans le jeu (0.00 sec)

Comme vous le voyez, la deuxième ligne a pour résultat NULL.

Nous aurions préféré voir la ville et l’état, au moins pour avoir une idée de l’adresse. La fonction CONCAT_WS offre une solution à ce problème. Voyons comment l’utiliser.

Utiliser CONCAT_WS pour gérer les valeurs NULL pendant l’assemblage

CONCAT_WS est une alternative à CONCAT qui permet de mieux gérer les valeurs NULL.

Voici sa syntaxe :

CONCAT_WS(separateur, chaine_1, chaine_2,..., chaine_n)

Exécutons maintenant cette requête :

SELECT CONCAT_WS(', ', rue, ville, etat) AS adresse_complete FROM employes;

Voici le résultat :

  
  +---------------------------+
  | adresse_complete          |
  +---------------------------+
  | 123 rue Principale, Paris, FR |
  | Lyon, FR               |
  | 789 avenue des Chênes, Marseille, FR  |
  | 321 rue du Pin, Toulouse, FR  |
  | 555 avenue des Cèdres, Nice, FR   |
  | 777 rue des Erables, Bordeaux, FR |
  | 999 rue des Bouleaux, Nantes, FR   |
  | 111 rue du Noyer, Strasbourg, FR   |
  | 222 rue des Cerisiers, Lille, FR |
  | 444 rue des Pins, Montpellier, FR  |
  +---------------------------+
  10 lignes dans le jeu (0.01 sec)

Comme vous le constatez, la deuxième ligne affiche maintenant « Lyon, FR » car la colonne `rue` est NULL.

⚠ Lors de l’utilisation de CONCAT_WS, il est impératif de spécifier le séparateur. Si aucun séparateur n’est spécifié, le résultat est NULL si l’une des colonnes est NULL (comme avec CONCAT).

Pour conclure

Récapitulons ce que nous avons appris :

Lors de l’extraction de données d’une base de données, il est parfois utile d’assembler plusieurs colonnes de texte pour obtenir des résultats plus clairs. La fonction SQL CONCAT permet cela avec la syntaxe `CONCAT(chaine_1, chaine_2, …, chaine_n)`.
Vous pouvez assembler du texte littéral, des colonnes, ou un mélange des deux. Cependant, si l’une des valeurs est NULL, le résultat sera également NULL. Pour gérer cela, utilisez `CONCAT_WS` avec la syntaxe `CONCAT_WS(separateur, chaine_1, chaine_2,…, chaine_n)`.
CONCAT_WS gère les valeurs NULL en ne concaténant que les chaînes non NULL, et en utilisant le séparateur spécifié.

Pour un rappel rapide des commandes SQL, vous pouvez ajouter cette antisèche SQL à vos favoris.

0 Partages