No MariaDB,
CONCAT_WS() é uma função de string interna que significa Concatenate With Separator. CONCAT_WS() executa uma concatenação de string em seus argumentos, com o primeiro argumento sendo o separador para os argumentos restantes. Concatenação é a operação de unir duas ou mais strings de ponta a ponta.
CONCAT_WS() aceita dois ou mais argumentos (embora fornecer apenas dois argumentos resultaria em nada sendo concatenado, devido ao primeiro argumento ser o separador e o segundo ser uma única string a ser concatenada com... nada mais). Sintaxe
A sintaxe fica assim:
CONCAT_WS(separator,str1,str2,...) Onde
separator é a string a ser usada como separador e str1, str2, … representam os argumentos de string para os quais concatenar. Exemplo
Segue um exemplo básico:
SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread'); Resultado:
+---------------------------------------------+ | CONCAT_WS( ', ', 'Leite', 'Queijo', 'Pão') |+------------------------------ ---------------+| Leite, Queijo, Pão |+------------------------------------------- --+
Nesse caso, concatenamos três strings usando uma vírgula e um espaço como separador.
Aqui está outro que usa um separador diferente:
SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green'); Resultado:
+----------------------------------------+| CONCAT_WS('-', 'Azul', 'Vermelho', 'Verde') |+------------------------------ ----------+| Azul-Vermelho-Verde |+---------------------------------------------------+
CONCAT_WS() é semelhante ao CONCAT() função. Um dos benefícios de CONCAT_WS() sobre CONCAT() torna-se aparente ao concatenar muitas strings.
Para fazer o exemplo anterior com CONCAT() , precisaríamos repetir o separador entre cada string.
Assim:
SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');
Resultado:
+------------------------------------------+| CONCAT('Azul', '-', 'Vermelho', '-', 'Verde') |+-------------------------- ----------------+| Azul-Vermelho-Verde |+------------------------------------------+
Isso poderia ficar complicado se tivéssemos muitas strings para concatenar.
Sem separador
Fornecer uma string vazia como separador concatena as strings sem separador:
SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');
Resultado:
+---------------------------------------+| CONCAT_WS('', 'Azul', 'Vermelho', 'Verde') |+------------------------------------------ --------+| AzulVermelhoVerde |+--------------------------------------------------+
Neste caso, obtemos o mesmo resultado que obteríamos ao usar CONCAT() para concatenar essas três strings.
É importante fornecer um separador, mesmo que esteja vazio. A falha em fornecer um separador fará com que a primeira string de concatenação seja usada como separador, o que provavelmente não é o que você deseja.
Exemplo:
SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');
Resultado:
+---------------------------------------------+ | CONCAT_WS('Azul', 'Vermelho', 'Verde', 'Laranja') |+----------------------------------------- ---------------+| VermelhoAzulVerdeAzulLaranja |+--------------------------------------------------------+
Neste caso, Blue é o primeiro argumento, e por isso acaba sendo usado como separador.
Concatenando argumentos nulos
Outro benefício que CONCAT_WS() tem mais de CONCAT() é que é null -seguro.
Se algum dos argumentos a serem concatenados for null , CONCAT_WS() os ignora. O CONCAT() por outro lado, retorna null (a menos que esteja no modo Oracle, nesse caso ele ignora null argumentos).
Vamos chamar CONCAT_WS() com um null argumento:
SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');
Resultado:
+---------------------------------------+| CONCAT_WS('-', 'Azul', NULL, 'Verde') |+-------------------------------- -------+| Azul-Verde |+--------------------------------------------------+
Como esperado, CONCAT_WS() pulou o argumento nulo e concatenou os argumentos restantes.
Isso significa que, se fornecermos uma string vazia como separador, podemos usar CONCAT_WS() como um null -versão segura de CONCAT() :
SELECT CONCAT_WS('', 'Blue', NULL, 'Green');
Resultado:
+--------------------------------------+| CONCAT_WS('', 'Azul', NULL, 'Verde') |+------------------------------------------------ -----+| Azul Verde |+-------------------------------------------------+ Separador Nulo
Fornecendo um null separador é uma história diferente. Fazer isso retorna null .
SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');
Resultado:
+-----------------------------------------+| CONCAT_WS(NULL, 'Azul', 'Vermelho', 'Verde') |+-------------------------------- ---------+| NULL |+-----------------------------------------+
Strings binárias
Se algum dos argumentos for uma string binária, o resultado será uma string binária:
SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');
Resultado:
+-------------------------------------------+| CONCAT_WS(', ', BINÁRIO 'Maçã', 'Laranja') |+--------------------------------- ----------+| Maçã, Laranja |+-------------------------------------------+
Podemos usar o COLLATION() função para verificar o agrupamento do resultado:
SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));
Resultado:
+---------------------------------------------- --------+| COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange')) |+------------------------------ ------------------------+| binário |+---------------------------------------------------------- -------+
Se removermos o BINARY operador, obtemos um resultado diferente:
SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));
Resultado:
+---------------------------------------------- -+| COLLATION(CONCAT_WS(', ', 'Apple', 'Orange')) |+------------------------------------------ ----------------+| utf8_general_ci |+---------------------------------------------------------- + Argumento único
Chamando CONCAT_WS() com apenas um argumento retorna um erro:
SELECT CONCAT_WS('Blue');
Resultado:
ERRO 1582 (42000):contagem de parâmetro incorreta na chamada para a função nativa 'CONCAT_WS'
Argumentos ausentes
Chamando CONCAT_WS() sem passar nenhum argumento resulta em um erro:
SELECT CONCAT_WS();
Resultado:
ERRO 1582 (42000):contagem de parâmetro incorreta na chamada para a função nativa 'CONCAT_WS'
