PostgreSQL - Fonction de chaîne
Les fonctions de chaîne PostgreSQL sont principalement utilisées pour la manipulation de chaînes. Le tableau suivant détaille les fonctions de chaîne importantes -
| S. Non. | Nom et description |
|---|---|
| 1 | ASCII () Renvoie la valeur numérique du caractère le plus à gauche |
| 2 | BIT_LENGTH () Renvoie la longueur de l'argument en bits |
| 3 | CHAR_LENGTH () Renvoie le nombre de caractères dans l'argument |
| 4 | CHARACTER_LENGTH () Un synonyme de CHAR_LENGTH () |
| 5 | CONCAT_WS () Renvoie concaténer avec séparateur |
| 6 | CONCAT () Renvoie une chaîne concaténée |
| sept | LCASE () Synonyme de LOWER () |
| 8 | LA GAUCHE() Renvoie le nombre de caractères le plus à gauche comme spécifié |
| 9 | LONGUEUR() Renvoie la longueur d'une chaîne en octets |
| dix | INFÉRIEUR() Renvoie l'argument en minuscules |
| 11 | LPAD () Renvoie l'argument de chaîne, complété à gauche avec la chaîne spécifiée |
| 12 | LTRIM () Supprime les espaces principaux |
| 13 | MILIEU() Renvoie une sous-chaîne à partir de la position spécifiée |
| 14 | POSITION() Un synonyme de LOCATE () |
| 15 | CITATION() Échappe l'argument à utiliser dans une instruction SQL |
| 16 | REGEXP Correspondance de modèles à l'aide d'expressions régulières |
| 17 | RÉPÉTER() Répète une chaîne le nombre de fois spécifié |
| 18 | REMPLACER() Remplace les occurrences d'une chaîne spécifiée |
| 19 | INVERSER() Inverser les caractères dans une chaîne |
| 20 | DROITE() Renvoie le nombre de caractères le plus à droite spécifié |
| 21 | RPAD () Ajoute la chaîne le nombre de fois spécifié |
| 22 | RTRIM () Supprime les espaces de fin |
| 24 | SUBSTRING (), SUBSTR () Renvoie la sous-chaîne comme spécifié |
| 25 | RÉDUIRE() Supprime les espaces de début et de fin |
| 26 | UCASE () Synonyme de UPPER () |
| 27 | PLUS HAUT() Convertit en majuscules |
ASCII (chaîne)
Renvoie la valeur numérique du caractère le plus à gauche de la chaîne str. Renvoie 0 si str est une chaîne vide. Renvoie NULL si str est NULL. ASCII () fonctionne pour les caractères avec des valeurs numériques de 0 à 255.
testdb=# SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
testdb=# SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (chaîne)
Renvoie la longueur de la chaîne str en bits.
testdb=# SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (chaîne)
Renvoie la longueur de la chaîne str, mesurée en caractères. Un caractère multi-octets compte comme un caractère unique. Cela signifie que pour une chaîne contenant cinq caractères de deux octets, LENGTH () renvoie 10, tandis que CHAR_LENGTH () renvoie 5.
testdb=# SELECT CHAR_LENGTH('text');
+---------------------------------------------------------+
| CHAR_LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (chaîne)
CHARACTER_LENGTH () est un synonyme de CHAR_LENGTH ().
CONCAT (str1, str2, ...)
Renvoie la chaîne qui résulte de la concaténation des arguments. Il peut avoir un ou plusieurs arguments. Si tous les arguments sont des chaînes non binaires, le résultat est une chaîne non binaire. Si les arguments incluent des chaînes binaires, le résultat est une chaîne binaire. Un argument numérique est converti en sa forme de chaîne binaire équivalente; si vous voulez éviter cela, vous pouvez utiliser un cast de type explicite, comme dans cet exemple -
testdb=# SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (séparateur, str1, str2, ...)
CONCAT_WS () signifie Concatenate With Separator et est une forme spéciale de CONCAT (). Le premier argument est le séparateur du reste des arguments. Le séparateur est ajouté entre les chaînes à concaténer. Le séparateur peut être une chaîne, tout comme le reste des arguments. Si le séparateur est NULL, le résultat est NULL.
testdb=# SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name, Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () est un synonyme de LOWER ().
GAUCHE (str, len)
Renvoie les caractères len les plus à gauche de la chaîne str, ou NULL si un argument est NULL.
testdb=# SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LONGUEUR (str)
Renvoie la longueur de la chaîne str, mesurée en octets. Un caractère multi-octets compte pour plusieurs octets. Cela signifie que pour une chaîne contenant cinq caractères de deux octets, LENGTH () renvoie 10, tandis que CHAR_LENGTH () renvoie 5.
testdb=# SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INFÉRIEUR (str)
Renvoie la chaîne str avec tous les caractères modifiés en minuscules en fonction du mappage du jeu de caractères actuel.
testdb=# SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Renvoie la chaîne str, complétée à gauche avec la chaîne padstr à une longueur de caractères len. Si str est plus long que len, la valeur de retour est raccourcie en caractères len.
testdb=# SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Renvoie la chaîne str avec les espaces de début supprimés.
testdb=# SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) est un synonyme de SUBSTRING (str, pos, len).
POSITION (substr IN str)
POSITION (substr IN str) est un synonyme de LOCATE (substr, str).
QUOTE_IDENT (chaîne de texte), QUOTE_LITERAL (chaîne de texte), QUOTE_LITERAL (valeur anyelement), QUOTE_NULLABLE (valeur anyelement)
Toutes ces fonctions renvoient la chaîne donnée correctement entre guillemets pour être utilisée comme identifiant dans une chaîne d'instruction SQL. Dans la fonction QUOTE_IDENT, les devis ne sont ajoutés que si nécessaire. Dans la fonction QUOTE_LITERAL, les guillemets simples et les barres obliques inverses incorporés sont correctement doublés. Si une valeur est transmise, forcez la valeur donnée en texte, puis la cite comme un littéral. La fonction QUOTE_NULLABLE, contraint la valeur donnée en texte, puis la cite comme littéral; ou, si l'argument est nul, renvoie NULL.
Voici les exemples de toutes ces fonctions -
testdb=# SELECT QUOTE_IDENT('Foo bar');
quote_ident
-------------
"Foo bar"
(1 row)
testdb=# SELECT QUOTE_LITERAL(E'O\'Reilly');
quote_literal
---------------
'O''Reilly'
(1 row)
testdb=# SELECT QUOTE_LITERAL(42.5);
quote_literal
---------------
'42.5'
(1 row)
testdb=# SELECT QUOTE_NULLABLE(42.5);
quote_nullable
----------------
'42.5'
(1 row)expression REGEXP modèle
La fonction REGEXP_MATCHES (texte de chaîne, texte de modèle [, texte de drapeaux]) effectue une correspondance de modèle de expr par rapport à modèle. Renvoie 1 si expr correspond à pat; sinon, il renvoie 0. Si expr ou pat est NULL, le résultat est NULL. REGEXP_MATCHES n'est pas sensible à la casse, sauf lorsqu'il est utilisé avec des chaînes binaires.
REGEXP_REPLACE (texte de chaîne, texte de modèle, texte de remplacement [, texte de drapeaux]) remplace la ou les sous-chaînes correspondant à une expression régulière POSIX.
REGEXP_SPLIT_TO_ARRAY (string text, pattern text [, flags text]), Split string en utilisant une expression régulière POSIX comme délimiteur.
REGEXP_SPLIT_TO_TABLE (texte de chaîne, texte de modèle [, texte de drapeaux]), fractionne la chaîne en utilisant une expression régulière POSIX comme délimiteur.
Voici les exemples de toutes ces fonctions -
testdb=# SELECT REGEXP_MATCHES('ABCDEF','A%C%%');
regexp_matches
----------------
(0 rows)
testdb=# SELECT REGEXP_REPLACE('Thomas', '.[mN]a.', 'M');
regexp_replace
----------------
ThM
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_ARRAY('hello world', E'\\s+');
regexp_split_to_array
-----------------------
{hello,world}
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_TABLE('hello world', E'\\s+');
regexp_split_to_table
-----------------------
hello
world
(2 rows)REPEAT (str, count)
Renvoie une chaîne composée de la chaîne str répétée nombre de fois. Si count est inférieur à 1, renvoie une chaîne vide. Renvoie NULL si str ou count sont NULL.
testdb=# SELECT REPEAT('SQL', 3);
repeat
-----------
SQLSQLSQL
(1 row)REMPLACER (str, from_str, to_str)
Renvoie la chaîne str avec toutes les occurrences de la chaîne from_str remplacées par la chaîne to_str. REPLACE () effectue une correspondance sensible à la casse lors de la recherche de from_str.
testdb=# SELECT REPLACE('www.mysql.com', 'w', 'Ww');
replace
------------------
WwWwWw.mysql.com
(1 row)INVERSE (str)
Renvoie la chaîne str avec l'ordre des caractères inversé.
testdb=# SELECT REVERSE('abcd');
reverse
---------
dcba
(1 row)DROITE (str, len)
Renvoie les caractères len les plus à droite de la chaîne str, ou NULL si un argument est NULL.
testdb=# SELECT RIGHT('foobarbar', 4);
right
-------
rbar
(1 row)RPAD (str, len, padstr)
Renvoie la chaîne str, complétée à droite avec la chaîne padstr à une longueur de len caractères. Si str est plus long que len, la valeur de retour est raccourcie en caractères len.
testdb=# SELECT RPAD('hi',5,'?');
rpad
-------
hi???
(1 row)RTRIM (str)
Renvoie la chaîne str avec les espaces de fin supprimés.
testdb=# SELECT RTRIM('barbar ');
rtrim
--------
barbar
(1 row)SUBSTRING (str, pos), SUBSTRING (str FROM pos), SUBSTRING (str, pos, len), SUBSTRING (str FROM pos FOR len)
Les formulaires sans argument len renvoient une sous-chaîne à partir de la chaîne str à partir de la position pos. Les formulaires avec un argument len renvoient une sous-chaîne len caractères longue à partir de la chaîne str, en commençant à la position pos. Les formulaires qui utilisent FROM sont la syntaxe SQL standard. Il est également possible d'utiliser une valeur négative pour pos. Dans ce cas, le début de la sous-chaîne correspond aux caractères pos à partir de la fin de la chaîne, plutôt qu'au début. Une valeur négative peut être utilisée pour pos dans n'importe laquelle des formes de cette fonction.
testdb=# SELECT SUBSTRING('Quadratically',5);
substring
-----------
ratically
(1 row)
testdb=# SELECT SUBSTRING('foobarbar' FROM 4);
substring
-----------
barbar
(1 row)
testdb=# SELECT SUBSTRING('Quadratically',5,6);
substring
-----------
ratica
(1 row)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM ([remstr FROM] str)
Renvoie la chaîne str avec tous les préfixes ou suffixes remstr supprimés. Si aucun des spécificateurs BOTH, LEADING ou TRAILING n'est indiqué, BOTH est supposé. remstr est facultatif et, s'il n'est pas spécifié, les espaces sont supprimés.
testdb=# SELECT TRIM(' bar ');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
ltrim
--------
barxxx
(1 row)
testdb=# SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
rtrim
-------
bar
(1 row)UCASE (str)
UCASE () est un synonyme de UPPER ().
SUPÉRIEUR (str)
Renvoie la chaîne str avec tous les caractères modifiés en majuscules en fonction du mappage du jeu de caractères actuel.
testdb=# SELECT UPPER('manisha');
upper
---------
MANISHA
(1 row)