Dans MariaDB, CONCAT_WS() est une fonction de chaîne intégrée qui signifie concaténer avec séparateur.
CONCAT_WS() effectue une concaténation de chaînes sur ses arguments, le premier argument étant le séparateur des arguments restants.
La concaténation est l'opération consistant à joindre deux ou plusieurs chaînes de bout en bout.
CONCAT_WS() accepte deux arguments ou plus (bien que fournir seulement deux arguments n'entraînerait aucune concaténation, car le premier argument est le séparateur et le second une chaîne unique à concaténer avec… rien d'autre).
Syntaxe
La syntaxe ressemble à ceci :
CONCAT_WS(separator,str1,str2,...)
Où separator est la chaîne à utiliser comme séparateur, et str1, str2, … représentent les arguments de chaîne pour lesquels concaténer.
Exemple
Voici un exemple de base :
SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread'); Résultat :
+---------------------------------------------+ | CONCAT_WS( ', ', 'Lait', 'Fromage', 'Pain') |+------------------------------ ---------------+| Lait, Fromage, Pain |+------------------------------------------------------- --+
Dans ce cas, nous avons concaténé trois chaînes en utilisant une virgule et un espace comme séparateur.
En voici un autre qui utilise un séparateur différent :
SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green'); Résultat :
+---------------------------------------------+| CONCAT_WS('-', 'Bleu', 'Rouge', 'Vert') |+------------------------------ ----------+| Bleu-Rouge-Vert |+----------------------------------------+
CONCAT_WS() est similaire à CONCAT() une fonction. L'un des avantages de CONCAT_WS() sur CONCAT() devient évident lors de la concaténation de plusieurs chaînes.
Pour faire l'exemple précédent avec CONCAT() , nous aurions besoin de répéter le séparateur entre chaque chaîne.
Comme ceci :
SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');
Résultat :
+-------------------------------------------------------+| CONCAT('Bleu', '-', 'Rouge', '-', 'Vert') |+-------------------------- ----------------+| Bleu-Rouge-Vert |+-------------------------------------------------------+
Cela pourrait devenir compliqué si nous avions beaucoup de chaînes à concaténer.
Pas de séparateur
Fournir une chaîne vide comme séparateur concatène les chaînes sans séparateur :
SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');
Résultat :
+--------------------------------------------------+| CONCAT_WS('', 'Bleu', 'Rouge', 'Vert') |+------------------------------- --------+| BleuRougeVert |+-----------------------------------------------------+
Dans ce cas, nous obtenons le même résultat que nous obtiendrions en utilisant CONCAT() pour concaténer ces trois chaînes.
Il est important de prévoir un séparateur, même s'il est vide. Si vous ne fournissez pas de séparateur, la première chaîne de concaténation sera utilisée comme séparateur, ce qui n'est probablement pas ce que vous souhaitez.
Exemple :
SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');
Résultat :
+---------------------------------------------+ | CONCAT_WS('Bleu', 'Rouge', 'Vert', 'Orange') |+------------------------------ ---------------+| RougeBleuVertBleuOrange |+---------------------------------------------+
Dans ce cas, Blue est le premier argument, et il finit donc par être utilisé comme séparateur.
Concaténer des arguments nuls
Un autre avantage que CONCAT_WS() a plus de CONCAT() c'est qu'il est null -sûr.
Si l'un des arguments à concaténer est null , CONCAT_WS() les ignore. Le CONCAT() fonction d'autre part, renvoie null (sauf s'il est en mode Oracle, auquel cas il ignore null arguments).
Appelons CONCAT_WS() avec un null argument :
SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');
Résultat :
+--------------------------------------------------+| CONCAT_WS('-', 'Bleu', NULL, 'Vert') |+-------------------------------- -------+| Bleu-Vert |+--------------------------------------------------+
Comme prévu, CONCAT_WS() ignoré l'argument nul et concaténé les arguments restants.
Cela signifie que, si nous fournissons une chaîne vide comme séparateur, nous pouvons utiliser CONCAT_WS() comme null -version sécurisée de CONCAT() :
SELECT CONCAT_WS('', 'Blue', NULL, 'Green');
Résultat :
+--------------------------------------------------+| CONCAT_WS('', 'Bleu', NULL, 'Vert') |+--------------------------------------------- -----+| BleuVert |+--------------------------------------------------+ Séparateur nul
Fournir un null séparateur est une autre histoire. Cela renvoie null .
SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');
Résultat :
+-------------------------------------------------------+| CONCAT_WS(NULL, 'Bleu', 'Rouge', 'Vert') |+-------------------------------- ---------+| NULL |+-----------------------------------------+
Chaînes binaires
Si l'un des arguments est une chaîne binaire, le résultat est une chaîne binaire :
SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');
Résultat :
+------------------------------------------------+| CONCAT_WS(', ', BINARY 'Pomme', 'Orange') |+--------------------------------- ----------+| Pomme, Orange |+------------------------------------------------+
Nous pouvons utiliser le COLLATION() fonction pour vérifier la collation du résultat :
SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));
Résultat :
+------------------------------------------------------------ --------+| COLLATION(CONCAT_WS(', ', BINAIRE 'Pomme', 'Orange')) |+------------------------------ ------------------------+| binaire |+------------------------------------------------------------ -------+
Si nous supprimons le BINARY opérateur, nous obtenons un résultat différent :
SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));
Résultat :
+------------------------------------------------------------ -+| COLLATION(CONCAT_WS(', ', 'Pomme', 'Orange')) |+------------------------------- ----------------+| utf8_general_ci |+------------------------------------------------------------ + Argument unique
Appel de CONCAT_WS() avec un seul argument renvoie une erreur :
SELECT CONCAT_WS('Blue');
Résultat :
ERREUR 1582 (42000) :Nombre de paramètres incorrect dans l'appel à la fonction native 'CONCAT_WS'
Arguments manquants
Appel de CONCAT_WS() sans passer d'arguments entraîne une erreur :
SELECT CONCAT_WS();
Résultat :
ERREUR 1582 (42000) :Nombre de paramètres incorrect dans l'appel à la fonction native 'CONCAT_WS'
