In MariaDB, CONCAT_WS() is een ingebouwde tekenreeksfunctie die staat voor Concatenate With Separator.
CONCAT_WS() voert een tekenreeksaaneenschakeling uit op zijn argumenten, waarbij het eerste argument het scheidingsteken is voor de resterende argumenten.
Concatenatie is de bewerking van het samenvoegen van twee of meer strings end-to-end.
CONCAT_WS() accepteert twee of meer argumenten (hoewel het verstrekken van slechts twee argumenten ertoe zou leiden dat er niets wordt samengevoegd, omdat het eerste argument het scheidingsteken is en het tweede een enkele tekenreeks is die moet worden samengevoegd met ... niets anders).
Syntaxis
De syntaxis gaat als volgt:
CONCAT_WS(separator,str1,str2,...)
Waar separator is de tekenreeks die als scheidingsteken moet worden gebruikt, en str1, str2, … vertegenwoordigen de tekenreeksargumenten waarvoor ze moeten worden samengevoegd.
Voorbeeld
Hier is een eenvoudig voorbeeld:
SELECT CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread');Resultaat:
+---------------------------------------------+ | CONCAT_WS( ', ', 'Milk', 'Cheese', 'Bread') | +---------------------------------------------+ | Milk, Cheese, Bread | +---------------------------------------------+
In dit geval hebben we drie tekenreeksen aaneengeschakeld met een komma en een spatie als scheidingsteken.
Hier is er nog een die een ander scheidingsteken gebruikt:
SELECT CONCAT_WS('-', 'Blue', 'Red', 'Green');Resultaat:
+----------------------------------------+
| CONCAT_WS('-', 'Blue', 'Red', 'Green') |
+----------------------------------------+
| Blue-Red-Green |
+----------------------------------------+
CONCAT_WS() lijkt op de CONCAT() functie. Een van de voordelen van CONCAT_WS() over CONCAT() wordt duidelijk bij het aaneenschakelen van veel strings.
Om het vorige voorbeeld te doen met CONCAT() , moeten we het scheidingsteken tussen elke tekenreeks herhalen.
Zoals dit:
SELECT CONCAT('Blue', '-', 'Red', '-', 'Green');Resultaat:
+------------------------------------------+
| CONCAT('Blue', '-', 'Red', '-', 'Green') |
+------------------------------------------+
| Blue-Red-Green |
+------------------------------------------+ Dit zou onpraktisch kunnen worden als we veel strings moesten samenvoegen.
Geen scheidingsteken
Door een lege tekenreeks als scheidingsteken op te geven, worden de tekenreeksen zonder scheidingsteken samengevoegd:
SELECT CONCAT_WS('', 'Blue', 'Red', 'Green');Resultaat:
+---------------------------------------+
| CONCAT_WS('', 'Blue', 'Red', 'Green') |
+---------------------------------------+
| BlueRedGreen |
+---------------------------------------+
In dit geval krijgen we hetzelfde resultaat als bij gebruik van CONCAT() om die drie strings samen te voegen.
Het is belangrijk om een scheidingsteken op te geven, ook als deze leeg is. Als u geen scheidingsteken opgeeft, wordt de eerste aaneenschakelingstekenreeks als scheidingsteken gebruikt, wat waarschijnlijk niet is wat u wilt.
Voorbeeld:
SELECT CONCAT_WS('Blue', 'Red', 'Green', 'Orange');Resultaat:
+---------------------------------------------+
| CONCAT_WS('Blue', 'Red', 'Green', 'Orange') |
+---------------------------------------------+
| RedBlueGreenBlueOrange |
+---------------------------------------------+
In dit geval Blue is het eerste argument, en dus wordt het uiteindelijk gebruikt als scheidingsteken.
Nullargumenten aaneenschakelen
Een ander voordeel dat CONCAT_WS() heeft meer dan CONCAT() is dat het null . is -veilig.
Als een van de aaneengeschakelde argumenten null . is , CONCAT_WS() negeert ze. De CONCAT() functie aan de andere kant, retourneert null (tenzij het in Oracle-modus is, in welk geval het null negeert argumenten).
Laten we CONCAT_WS() . aanroepen met een null argument:
SELECT CONCAT_WS('-', 'Blue', NULL, 'Green');Resultaat:
+---------------------------------------+
| CONCAT_WS('-', 'Blue', NULL, 'Green') |
+---------------------------------------+
| Blue-Green |
+---------------------------------------+
Zoals verwacht, CONCAT_WS() het null-argument overgeslagen en de overige argumenten aaneengeschakeld.
Dit betekent dat, als we een lege tekenreeks als scheidingsteken opgeven, we CONCAT_WS() kunnen gebruiken als een null -veilige versie van CONCAT() :
SELECT CONCAT_WS('', 'Blue', NULL, 'Green');Resultaat:
+--------------------------------------+
| CONCAT_WS('', 'Blue', NULL, 'Green') |
+--------------------------------------+
| BlueGreen |
+--------------------------------------+ Null-scheidingsteken
Het verstrekken van een null scheidingsteken is een ander verhaal. Als u dit doet, retourneert u null .
SELECT CONCAT_WS(NULL, 'Blue', 'Red', 'Green');Resultaat:
+-----------------------------------------+ | CONCAT_WS(NULL, 'Blue', 'Red', 'Green') | +-----------------------------------------+ | NULL | +-----------------------------------------+
Binaire strings
Als een van de argumenten een binaire string is, is het resultaat een binaire string:
SELECT CONCAT_WS(', ', BINARY 'Apple', 'Orange');Resultaat:
+-------------------------------------------+
| CONCAT_WS(', ', BINARY 'Apple', 'Orange') |
+-------------------------------------------+
| Apple, Orange |
+-------------------------------------------+
We kunnen de COLLATION() . gebruiken functie om de sortering van het resultaat te controleren:
SELECT COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange'));Resultaat:
+------------------------------------------------------+
| COLLATION(CONCAT_WS(', ', BINARY 'Apple', 'Orange')) |
+------------------------------------------------------+
| binary |
+------------------------------------------------------+
Als we de BINARY . verwijderen operator, krijgen we een ander resultaat:
SELECT COLLATION(CONCAT_WS(', ', 'Apple', 'Orange'));Resultaat:
+-----------------------------------------------+
| COLLATION(CONCAT_WS(', ', 'Apple', 'Orange')) |
+-----------------------------------------------+
| utf8_general_ci |
+-----------------------------------------------+ Enkel argument
Aanroepen van CONCAT_WS() met slechts één argument retourneert een fout:
SELECT CONCAT_WS('Blue');Resultaat:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'
Ontbrekende argumenten
Aanroepen van CONCAT_WS() zonder het doorgeven van argumenten resulteert in een fout:
SELECT CONCAT_WS();Resultaat:
ERROR 1582 (42000): Incorrect parameter count in the call to native function 'CONCAT_WS'