In MariaDB, CONCAT_WS() è una funzione di stringa incorporata che sta per Concatenate With Separator.
CONCAT_WS() esegue una concatenazione di stringhe sui suoi argomenti, con il primo argomento che funge da separatore per gli argomenti rimanenti.
La concatenazione è l'operazione di unione di due o più stringhe end-to-end.
CONCAT_WS() accetta due o più argomenti (sebbene fornire solo due argomenti non comporterebbe la concatenazione di nulla, poiché il primo argomento è il separatore e il secondo è una singola stringa da concatenare con... nient'altro).
Sintassi
La sintassi è questa:
CONCAT_WS(separator,str1,str2,...)
Dove separator è la stringa da utilizzare come separatore e str1, str2, … rappresentano gli argomenti stringa per i quali concatenare.
Esempio
Ecco un esempio di base:
SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread');Risultato:
+---------------------------------------------+ | CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread') | +---------------------------------------------+ | Milk, Cheese, Bread | +---------------------------------------------+
In questo caso, abbiamo concatenato tre stringhe usando una virgola e uno spazio come separatore.
Eccone un altro che utilizza un separatore diverso:
SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green');Risultato:
+----------------------------------------+
| CONCAT_WS('-', 'Blue', 'Red', 'Green') |
+----------------------------------------+
| Blue-Red-Green |
+----------------------------------------+
CONCAT_WS() è simile a CONCAT() funzione. Uno dei vantaggi di CONCAT_WS() su CONCAT() diventa evidente quando si concatenano molte stringhe.
Per fare l'esempio precedente con CONCAT() , dovremmo ripetere il separatore tra ogni stringa.
In questo modo:
SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');Risultato:
+------------------------------------------+
| CONCAT('Blue', '-', 'Red', '-', 'Green') |
+------------------------------------------+
| Blue-Red-Green |
+------------------------------------------+ Questo potrebbe diventare ingombrante se avessimo molte stringhe da concatenare.
Nessun separatore
Fornire una stringa vuota come separatore concatena le stringhe senza un separatore:
SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');Risultato:
+---------------------------------------+
| CONCAT_WS('', 'Blue', 'Red', 'Green') |
+---------------------------------------+
| BlueRedGreen |
+---------------------------------------+
In questo caso otteniamo lo stesso risultato che otterremmo usando CONCAT() per concatenare queste tre stringhe.
È importante fornire un separatore, anche se è vuoto. La mancata fornitura di un separatore comporterà l'utilizzo della prima stringa di concatenazione come separatore, che probabilmente non è quello che desideri.
Esempio:
SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');Risultato:
+---------------------------------------------+
| CONCAT_WS('Blue', 'Red', 'Green', 'Orange') |
+---------------------------------------------+
| RedBlueGreenBlueOrange |
+---------------------------------------------+
In questo caso, Blue è il primo argomento, quindi finisce per essere usato come separatore.
Concatenazione di argomenti nulli
Un altro vantaggio che CONCAT_WS() ha più di CONCAT() è che è null -sicuro.
Se uno degli argomenti da concatenare è null , CONCAT_WS() li ignora. Il CONCAT() funzione d'altra parte, restituisce null (a meno che non sia in modalità Oracle, nel qual caso ignora null argomenti).
Chiamiamo CONCAT_WS() con un null argomento:
SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');Risultato:
+---------------------------------------+
| CONCAT_WS('-', 'Blue', NULL, 'Green') |
+---------------------------------------+
| Blue-Green |
+---------------------------------------+
Come previsto, CONCAT_WS() ha saltato l'argomento null e ha concatenato gli argomenti rimanenti.
Ciò significa che, se forniamo una stringa vuota come separatore, possiamo utilizzare CONCAT_WS() come null -versione sicura di CONCAT() :
SELECT CONCAT_WS('', 'Blue', NULL, 'Green');Risultato:
+--------------------------------------+
| CONCAT_WS('', 'Blue', NULL, 'Green') |
+--------------------------------------+
| BlueGreen |
+--------------------------------------+ Separatore nullo
Fornire un null separatore è un'altra storia. In questo modo viene restituito null .
SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');Risultato:
+-----------------------------------------+ | CONCAT_WS(NULL, 'Blue', 'Red', 'Green') | +-----------------------------------------+ | NULL | +-----------------------------------------+
Stringhe binarie
Se uno qualsiasi degli argomenti è una stringa binaria, il risultato è una stringa binaria:
SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');Risultato:
+-------------------------------------------+
| CONCAT_WS(', ', BINARY 'Apple', 'Orange') |
+-------------------------------------------+
| Apple, Orange |
+-------------------------------------------+
Possiamo usare il COLLATION() funzione per controllare la collazione del risultato:
SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));Risultato:
+------------------------------------------------------+
| COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange')) |
+------------------------------------------------------+
| binary |
+------------------------------------------------------+
Se rimuoviamo il BINARY operatore, otteniamo un risultato diverso:
SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));Risultato:
+-----------------------------------------------+
| COLLATION(CONCAT_WS(', ', 'Apple', 'Orange')) |
+-----------------------------------------------+
| utf8_general_ci |
+-----------------------------------------------+ Singolo argomento
Chiamando CONCAT_WS() con un solo argomento restituisce un errore:
SELECT CONCAT_WS('Blue');Risultato:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'
Argomenti mancanti
Chiamando CONCAT_WS() senza passare alcun argomento genera un errore:
SELECT CONCAT_WS();Risultato:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'
