En MariaDB, CONCAT_WS() es una función de cadena incorporada que significa Concatenar con separador.
CONCAT_WS() realiza una concatenación de cadenas en sus argumentos, siendo el primer argumento el separador de los argumentos restantes.
La concatenación es la operación de unir dos o más cadenas de un extremo a otro.
CONCAT_WS() acepta dos o más argumentos (aunque proporcionar solo dos argumentos daría como resultado que no se concatene nada, debido a que el primer argumento es el separador y el segundo es una sola cadena que se concatena con... nada más).
Sintaxis
La sintaxis es así:
CONCAT_WS(separator,str1,str2,...)
Donde separator es la cadena que se utilizará como separador, y str1, str2, … representan los argumentos de cadena para los cuales concatenar.
Ejemplo
He aquí un ejemplo básico:
SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread');Resultado:
+---------------------------------------------+ | CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread') | +---------------------------------------------+ | Milk, Cheese, Bread | +---------------------------------------------+
En este caso, concatenamos tres cadenas usando una coma y un espacio como separador.
Aquí hay otro que usa un separador diferente:
SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green');Resultado:
+----------------------------------------+
| CONCAT_WS('-', 'Blue', 'Red', 'Green') |
+----------------------------------------+
| Blue-Red-Green |
+----------------------------------------+
CONCAT_WS() es similar a CONCAT() función. Uno de los beneficios de CONCAT_WS() sobre CONCAT() se hace evidente cuando se concatenan muchas cadenas.
Para hacer el ejemplo anterior con CONCAT() , necesitaríamos repetir el separador entre cada cadena.
Así:
SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');Resultado:
+------------------------------------------+
| CONCAT('Blue', '-', 'Red', '-', 'Green') |
+------------------------------------------+
| Blue-Red-Green |
+------------------------------------------+ Esto podría volverse difícil de manejar si tuviéramos muchas cadenas para concatenar.
Sin separador
Proporcionar una cadena vacía como separador concatena las cadenas sin un separador:
SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');Resultado:
+---------------------------------------+
| CONCAT_WS('', 'Blue', 'Red', 'Green') |
+---------------------------------------+
| BlueRedGreen |
+---------------------------------------+
En este caso obtenemos el mismo resultado que obtendríamos al usar CONCAT() para concatenar esas tres cadenas.
Es importante proporcionar un separador, incluso si está vacío. Si no proporciona un separador, la primera cadena de concatenación se utilizará como separador, lo que probablemente no sea lo que desea.
Ejemplo:
SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');Resultado:
+---------------------------------------------+
| CONCAT_WS('Blue', 'Red', 'Green', 'Orange') |
+---------------------------------------------+
| RedBlueGreenBlueOrange |
+---------------------------------------------+
En este caso, Blue es el primer argumento, por lo que termina usándose como separador.
Concatenación de argumentos nulos
Otro beneficio que CONCAT_WS() tiene sobre CONCAT() es que es null -a salvo.
Si alguno de los argumentos a concatenar es null , CONCAT_WS() los ignora. El CONCAT() la función por otro lado, devuelve null (a menos que esté en modo Oracle, en cuyo caso ignora null argumentos).
Llamemos a CONCAT_WS() con un null argumento:
SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');Resultado:
+---------------------------------------+
| CONCAT_WS('-', 'Blue', NULL, 'Green') |
+---------------------------------------+
| Blue-Green |
+---------------------------------------+
Como era de esperar, CONCAT_WS() omitió el argumento nulo y concatenó los argumentos restantes.
Esto significa que, si proporcionamos una cadena vacía como separador, podemos usar CONCAT_WS() como un null -versión segura de CONCAT() :
SELECT CONCAT_WS('', 'Blue', NULL, 'Green');Resultado:
+--------------------------------------+
| CONCAT_WS('', 'Blue', NULL, 'Green') |
+--------------------------------------+
| BlueGreen |
+--------------------------------------+ Separador nulo
Proporcionar un null separador es una historia diferente. Hacer esto devuelve null .
SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');Resultado:
+-----------------------------------------+ | CONCAT_WS(NULL, 'Blue', 'Red', 'Green') | +-----------------------------------------+ | NULL | +-----------------------------------------+
Cadenas binarias
Si alguno de los argumentos es una cadena binaria, el resultado es una cadena binaria:
SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');Resultado:
+-------------------------------------------+
| CONCAT_WS(', ', BINARY 'Apple', 'Orange') |
+-------------------------------------------+
| Apple, Orange |
+-------------------------------------------+
Podemos usar COLLATION() función para verificar la intercalación del resultado:
SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));Resultado:
+------------------------------------------------------+
| COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange')) |
+------------------------------------------------------+
| binary |
+------------------------------------------------------+
Si eliminamos el BINARY operador, obtenemos un resultado diferente:
SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));Resultado:
+-----------------------------------------------+
| COLLATION(CONCAT_WS(', ', 'Apple', 'Orange')) |
+-----------------------------------------------+
| utf8_general_ci |
+-----------------------------------------------+ Argumento único
Llamando a CONCAT_WS() con un solo argumento devuelve un error:
SELECT CONCAT_WS('Blue');Resultado:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'
Argumentos faltantes
Llamando a CONCAT_WS() sin pasar ningún argumento da como resultado un error:
SELECT CONCAT_WS();Resultado:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'
