Comment concaténer deux colonnes en SQL - Guide détaillé

En SQL, la concaténation est l'opération qui consiste à joindre des chaînes de caractères, ou des éléments d'information textuelle. Apprenez à concaténer deux colonnes en SQL grâce à ce guide détaillé.

La concaténation SQL est le processus qui consiste à combiner deux ou plusieurs chaînes de caractères, colonnes ou expressions en une seule chaîne. Par exemple, la concaténation de 'Kate', ' ' et 'Smith' donne 'Kate Smith'.

La concaténation SQL peut être utilisée dans de nombreuses situations où il est nécessaire de combiner plusieurs chaînes de caractères en une seule. Voici quelques cas d'utilisation courants

• Créer des noms complets ou d'autres chaînes composites à partir de plusieurs colonnes d'une table - par exemple, concaténer le prénom et le nom de famille d'un utilisateur pour créer un nom complet.
• Création d'étiquettes ou de titres personnalisés en concaténant plusieurs valeurs de chaînes.
• Création d'un identifiant unique par concaténation de plusieurs colonnes - par exemple, un numéro d'identification de client et un numéro de commande.
• Créer des adresses électroniques en concaténant un nom d'utilisateur (katesmith) et un nom de domaine (learnSQL.com).

Il ne s'agit là que de quelques exemples, mais la concaténation SQL peut être utilisée dans de nombreuses autres situations où il est nécessaire de combiner plusieurs chaînes de caractères.

La meilleure façon de pratiquer le langage SQL, y compris la concaténation SQL, est notre programme interactif Exercices Pratiques de SQL. Il contient près de 90 exercices pratiques, répartis en cinq sections thématiques. Ce cours est un excellent moyen de rafraîchir vos connaissances en SQL. Chaque exercice résolu vous permet de prendre confiance en vos compétences.

Comment concaténer deux colonnes en SQL

La syntaxe de la concaténation SQL peut varier en fonction du dialecte SQL utilisé. Voici quelques exemples des techniques les plus connues de concaténation en SQL.

L'opérateur ||

Le langage SQL standard utilise l'opérateur || (ainsi que quelques autres options). La plupart des bases de données SQL, à l'exception notable de SQL Server, prennent en charge cet opérateur. L'opérateur || prend deux arguments ou plus et renvoie une seule chaîne concaténée.

Utilisation

Imaginons le cas suivant. Nous disposons d'une table appelée users qui stocke les informations relatives aux utilisateurs :

id	first_name	middle_name	last_name	age	marital_status
--------------------------------------------------------------
1	Derek		Brent		Zoolander	35	S
2	Marty		George	McFly		20	S

Utilisons l'opérateur || pour concaténer le prénom et le nom de famille des utilisateurs et obtenir un nom complet :

SELECT first_name || ' ' || last_name AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Zoolander
Marty McFly

Dans cet exemple, l'opérateur || prend les colonnes first_name et last_name du tableau et les concatène ensemble. users et les concatène ensemble avec un espace entre les deux, ce qui donne un nom complet pour chaque utilisateur. Le résultat est alors aliasé full_name et renvoyé dans les résultats de la requête.

Vous pouvez concaténer plusieurs chaînes à l'aide de l'opérateur || en fournissant plus de deux arguments. Par exemple, l'instruction SQL suivante concatène le prénom, le deuxième prénom et le nom de famille des utilisateurs :

SELECT first_name || ' ' || middle_name || ' ' || last_name AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Brent Zoolander
Marty George McFly

L'opérateur de concaténation || fonctionne également avec les colonnes non textuelles

Les deux exemples précédents ne contiennent que des chaînes de caractères ; qu'en est-il des autres types de données ? Les arguments de l'opérateur || peuvent être des chaînes de caractères, des colonnes de texte, des expressions et d'autres types de données comme des nombres ou des dates. Ils seront automatiquement convertis en chaînes de caractères.

Voici un exemple d'utilisation de l'opérateur || pour concaténer le prénom, le nom et l'âge d'un utilisateur afin de former une nouvelle chaîne :

SELECT 
  first_name || ' ' || last_name || ': ' || age || ' yo' AS user_details 
FROM users;

Le résultat :

user_details
---------------
Derek Zoolander: 35 yo
Marty McFly: 20 yo

Notez que le premier argument de la concaténation doit être de type texte. Si ce n'est pas le cas, vous devez le convertir en un type de données de type texte. Voici un exemple d'utilisation de l'opérateur || pour concaténer l'ID et le prénom d'un utilisateur afin de former un identifiant unique :

SELECT 
  cast(id as VARCHAR) || '_' || first_name AS unique_id 
FROM users;

Le résultat :

unique_id
---------------
1_Derek
2_Marty

Attention aux NULL !

L'opérateur de concaténation | | renvoie NULL pour tout argument NULL.

Imaginez que votre base de données contienne des valeurs vides ou NULL :

id	first_name	middle_name	last_name	age	marital_status
--------------------------------------------------------
3	Terminator			T-1000	1	S
4	Robocop					2	S

Si l'un des arguments de la concaténation est NULL, l'expression entière renvoie NULL. Dans l'exemple suivant, nous allons essayer une concaténation avec un argument NULL:

SELECT 
  first_name || ' ' || last_name AS full_name 
FROM users;

Le résultat :

full_name
---------------
Terminator T-1000
NULL

Le deuxième résultat est NULL: Robocop a un prénom, mais ses deuxième et dernier noms sont NULL. Si vous concaténé 'Robocop' avec NULL, vous obtenez NULL.

Remarque : dans le cas d'Oracle, une chaîne NULL est une chaîne vide. La concaténation "ignore" la chaîne NULL et les arguments concaténés sont renvoyés. Oracle renvoie le résultat suivant :

full_name
---------------
Terminator T-1000
Robocop

Utiliser la fonction COALESCE() pour concaténer des valeurs NULL

Une astuce incroyable pour éviter les valeurs NULL consiste à utiliser la fonction COALESCE(). La fonction COALESCE() en SQL est une fonction intégrée qui renvoie la première valeur non NULL dans une liste d'expressions. La fonction prend un ou plusieurs arguments et renvoie le premier argument qui n'est pas NULL.

Dans l'exemple suivant, supposons que le champ last_name puisse être NULL. Pour éviter une mauvaise concaténation, nous utilisons la fonction COALESCE():

SELECT 
  first_name || ' ' || COALESCE(last_name, '') AS full_name 
FROM users;

Le résultat :

full_name
---------------
Terminator T-1000
Robocop

Ci-dessus, COALESCE() renvoie le nom de famille si celui-ci n'est pas NULL. Si le nom de famille est NULL, il renvoie la chaîne vide ‘’. Cela nous permet d'éviter de concaténer la valeur NULL du nom de famille de Robocop et d'obtenir un résultat NULL.

L'opérateur +

L'opérateur + est utilisé pour concaténer des chaînes de caractères dans MS SQL Server. Il prend deux arguments ou plus et renvoie une seule chaîne concaténée.

Voici un exemple d'utilisation de l'opérateur + pour concaténer le nom et le prénom d'un utilisateur :

SELECT 
  first_name + ' ' + last_name AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Zoolander
Marty McFly

Avec l'opérateur +, aucun des arguments n'est converti automatiquement. Chaque argument de l'expression doit être du type VARCHAR pour que la concaténation réussisse. Pour concaténer des valeurs de types différents, nous utilisons la fonction CAST():

SELECT 
  first_name + ' ' + last_name + ': ' + CAST(age AS VARCHAR) + ' yo' AS user_details 
FROM users;

Le résultat :

user_details
---------------
Derek Zoolander: 35 yo
Marty McFly: 20 yo

Sans CAST(), SQL Server génère l'erreur suivante :

MS SQL
Token error: 'Error converting data type varchar to bigint.' 

La fonction CONCAT

CONCAT() est une autre fonction SQL standard intégrée qui concatène deux valeurs ou plus. Tous les systèmes de base de données courants, à l'exception de SQLite, acceptent cette fonction ; SQLite n'accepte que l'opérateur ||.

Les principales différences entre les opérateurs || et + et la fonction CONCAT() sont les suivantes :

• CONCAT() les arguments sont automatiquement convertis en chaînes de caractères, ce qui permet d'utiliser des arguments de différents types de données.
• CONCAT() L'opérateur NULL traite les valeurs NULL comme des chaînes vides et les ignore. MySQL (et, dans une moindre mesure, MariaDB) fait exception à cette règle. Dans MySQL, la fonction CONCAT() est équivalente à l'opérateur ||; les arguments NULL donnent des résultats NULL.

Voici un exemple d'utilisation de CONCAT() pour concaténer les noms et prénoms des utilisateurs :

SELECT 
  CONCAT(first_name, ' ', last_name) AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Zoolander
Marty McFly
Terminator T-1000
Robocop

Dans l'exemple suivant, nous utiliserons CONCAT() pour concaténer l'ID et le prénom des utilisateurs afin de former un identifiant unique. Notez que la fonction CAST() n'est pas nécessaire :

SELECT 
  CONCAT(id, '_', first_name) AS unique_id 
FROM users;

Le résultat :

unique_id
---------------
1_Derek
2_Marty
3_Terminator
4_Robocop

La fonction CONCAT_WS

La fonction CONCAT_WS en SQL est similaire à la fonction CONCAT, mais elle est utilisée pour concaténer deux ou plusieurs chaînes de caractères avec un séparateur. La fonction prend deux arguments : le premier argument est le séparateur, et les autres arguments sont les chaînes que vous voulez concaténer.

Toutes les bases de données courantes, à l'exception d'Oracle et de SQLite, acceptent la fonction CONCAT_WS. Cette fonction ignore NULLs dans les arguments (autres que le séparateur) - même pour MySQL

Utilisons la fonction CONCAT_WS pour concaténer les valeurs first_name et last_name avec un séparateur d'espace :

SELECT 
  CONCAT_WS(' ', first_name, last_name) AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Zoolander
Marty McFly
Terminator T-1000
Robocop

Enfin, essayons de concaténer trois arguments, séparés par des espaces :

SELECT 
  CONCAT_WS(' ', first_name, middle_name, last_name) AS full_name 
FROM users;

Le résultat :

full_name
---------------
Derek Brent Zoolander
Marty George McFly
Terminator T-1000
Robocop

Si vous voulez en savoir plus sur les fonctions SQL étonnantes, je vous recommande vivement de lire l'article 5 fonctions SQL pour manipuler les chaînes de caractères de Marek Pankowski.

Concaténer deux colonnes en SQL est facile !

J'espère que vous avez pris autant de plaisir à lire cet article que j'en ai eu à l'écrire ! Les différences entre les dialectes SQL sont subtiles et il est toujours passionnant d'en savoir plus.

Cet article vous a donné envie d'en savoir plus sur SQL ? N'hésitez pas ! Votre voyage en SQL est déjà bien entamé, et vous avez accès à toutes les ressources et l'aide dont vous avez besoin. LearnSQL.fr dispose de toutes les ressources et de l'aide dont vous avez besoin pour devenir un expert en SQL.

La maîtrise de SQL est une expérience pratique - apprendre les concepts est une chose, mais écrire de bonnes requêtes demande de la pratique. Je recommande sincèrement notre Exercices Pratiques de SQLIl teste vos connaissances de base en SQL et vous montre où vous devez vous améliorer.

Alors, qu'attendez-vous ? Ne vous contentez pas de concaténer des colonnes - apprenez plus de SQL dès aujourd'hui !