Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctions de chaîne
Fonctions de chaîne qui traitent et manipulent des chaînes de caractères ou des expressions qui correspondent à des chaînes de caractères. Lorsque l’argument *string* de ces fonctions est une valeur littérale, il doit être entre guillemets simples. Les types de données pris en charge sont CHAR et VARCHAR.
La section suivante fournit les noms de fonctions, la syntaxe et les descriptions des fonctions prises en charge. Tous les décalages en chaînes sont basés sur un.
**Topics**
+ [Opérateur (concaténation) \$1\$1](concat_op.md)
+ [Fonction BTRIM](BTRIM.md)
+ [Fonction CONCAT](CONCAT.md)
+ [Fonction FORMAT\$1STRING](FORMAT_STRING.md)
+ [Fonctions LEFT et RIGHT](LEFT.md)
+ [Fonction LENGTH](LENGTH.md)
+ [Fonction LOWER](LOWER.md)
+ [Fonctions LPAD et RPAD](LPAD.md)
+ [Fonction LTRIM](LTRIM.md)
+ [Fonction POSITION](POSITION.md)
+ [Fonction REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Fonction REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Fonction REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Fonction REPEAT](REPEAT.md)
+ [Fonction REPLACE](REPLACE.md)
+ [Fonction REVERSE](REVERSE.md)
+ [Fonction RTRIM](RTRIM.md)
+ [Fonction SPLIT](split.md)
+ [Fonction SPLIT\$1PART](SPLIT_PART.md)
+ [Fonction SUBSTRING](SUBSTRING.md)
+ [Fonction TRANSLATE](TRANSLATE.md)
+ [Fonction TRIM](TRIM.md)
+ [Fonction UPPER](UPPER.md)
+ [Fonction UUID](UUID.md)
# Opérateur (concaténation) \$1\$1
Concatène deux expressions de chaque côté du symbole \$1\$1 et renvoie l’expression concaténée.
L'opérateur de concatentation est similaire à. [Fonction CONCAT](CONCAT.md)
**Note**
Pour la fonction CONCAT et l'opérateur de concaténation, si une expression ou les deux ont la valeur null, le résultat de la concaténation est null.
## Syntaxe
```
expression1 || expression2
```
## Arguments
*expression1*, *expression2*
Les deux arguments peuvent être des chaînes de caractères de longueur fixe ou de longueur variable ou des expressions.
## Type de retour
L'opérateur \$1\$1 renvoie une chaîne. Le type de chaîne est identique à celui des arguments d'entrée.
## exemple
L'exemple suivant concatène les champs FIRSTNAME et LASTNAME de la table USERS :
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Pour concaténer des colonnes susceptibles de contenir des valeurs nulles, utilisez l’expression [Fonctions NVL et COALESCE](NVL_function.md). L’exemple suivant utilise NVL pour renvoyer un 0 chaque fois que la valeur NULL est rencontrée.
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# Fonction BTRIM
La fonction BTRIM tronque une chaîne en supprimant les espaces de début et de fin ou en supprimant les caractères de début et de fin qui correspondent à une chaîne spécifiée de manière facultative.
## Syntaxe
```
BTRIM(string [, trim_chars ] )
```
## Arguments
*string*
Chaîne VARCHAR d’entrée à tronquer.
*trim\$1chars*
Chaîne VARCHAR contenant les caractères à mettre en correspondance.
## Type de retour
La fonction BTRIM renvoie une chaîne VARCHAR.
## Exemples
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L’exemple suivant supprime les chaînes `'xyz'` de début et de fin de la chaîne `'xyzaxyzbxyzcxyz'`. Les occurrences de début et de fin de `'xyz'` sont supprimées, mais celles qui se trouvent à l’intérieur de la chaîne sont conservées.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
L’exemple suivant supprime les parties de début et de fin de la chaîne `'setuphistorycassettes'` qui correspondent à l’un des caractères de la liste *trim\$1chars* `'tes'`. Tout caractère `t`, `e` ou `s` précédant un autre caractère qui ne figure pas dans la liste *trim\$1chars* au début ou à la fin de la chaîne d’entrée est supprimé.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Fonction CONCAT
La fonction CONCAT concatène deux expressions et renvoie l’expression résultante. Pour concaténer plus de deux expressions, utilisez les fonction CONCAT imbriquées. L'opérateur de concaténation (`||`) entre deux expressions donne les mêmes résultats que la fonction CONCAT.
**Note**
Pour la fonction CONCAT et l'opérateur de concaténation, si une expression ou les deux ont la valeur null, le résultat de la concaténation est null.
## Syntaxe
```
CONCAT ( expression1, expression2 )
```
## Arguments
*expression1*, *expression2*
Les deux arguments peuvent être une chaîne de caractères de longueur fixe, une chaîne de caractères de longueur variable, une expression binaire ou une expression qui a pour résultat l’une de ces entrées.
## Type de retour
CONCAT renvoie une expression. Le type de données de l’expression est le même que celui des arguments d’entrée.
Si les expressions d'entrée sont de types différents, AWS Clean Rooms essaie de convertir implicitement l'une des expressions. Si des valeurs ne peuvent pas être converties, une erreur est renvoyée.
## Exemples
L’exemple suivant concatène deux littéraux caractères :
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
La requête suivante, utilisant l’opérateur `||` au lieu de CONCAT, produit le même résultat :
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
L'exemple suivant illustre l'utilisation des fonctions CONCAT pour concaténer trois chaînes de caractères :
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Pour concaténer des colonnes susceptibles de contenir des valeurs nulles, utilisez la fonction [Fonctions NVL et COALESCE](NVL_function.md). L’exemple suivant utilise NVL pour renvoyer un 0 chaque fois que la valeur NULL est rencontrée.
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
La requête suivante concatène les valeurs CITY et STATE de la table VENUE :
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
La requête suivante utilise des fonctions CONCAT imbriquées. La requête concatène les valeurs CITY et STATE de la table VENUE, mais délimite la chaîne qui en résulte par une virgule et un espace :
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# Fonction FORMAT\$1STRING
La fonction FORMAT\$1STRING crée une chaîne formatée en remplaçant les espaces réservés dans une chaîne modèle par les arguments fournis. Elle renvoie une chaîne formatée à partir de chaînes de format de style printf.
La fonction FORMAT\$1STRING fonctionne en remplaçant les espaces réservés dans la chaîne du modèle par les valeurs correspondantes passées en arguments. Ce type de formatage de chaîne peut être utile lorsque vous devez créer dynamiquement des chaînes qui incluent un mélange de texte statique et de données dynamiques, par exemple lors de la génération de messages de sortie, de rapports ou d'autres types de texte informatif. La fonction FORMAT\$1STRING fournit un moyen concis et lisible de créer ces types de chaînes formatées, ce qui facilite la maintenance et la mise à jour du code qui génère le résultat.
## Syntaxe
```
format_string(strfmt, obj, ...)
```
## Arguments
*strfmt*
Expression STRING.
*obj*
Une chaîne ou une expression numérique.
## Type de retour
FORMAT\$1STRING renvoie une chaîne.
## exemple
L'exemple suivant contient un modèle de chaîne contenant deux espaces réservés : `%d` pour une valeur décimale (entier) et `%s` pour une valeur de chaîne. L'`%d`espace réservé est remplacé par la valeur décimale (entier) (`100`), et l'espace réservé %s est remplacé par la valeur de chaîne (). `"days"` La sortie est une chaîne modèle dont les espaces réservés sont remplacés par les arguments fournis :`"Hello World 100 days"`.
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Fonctions LEFT et RIGHT
Ces fonctions renvoient le nombre de caractères spécifié le plus à gauche ou le plus à droite dans une chaîne de caractères.
Le chiffre est basé sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls.
## Syntaxe
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Arguments
*string*
Chaîne de caractères ou expression qui a pour valeur une chaîne de caractères.
*integer*
Nombre entier positif.
## Type de retour
LEFT et RIGHT renvoient une chaîne VARCHAR.
## exemple
L'exemple suivant renvoie les 5 caractères les plus à gauche et les 5 caractères les plus à droite à partir de noms d'événements IDs compris entre 1 000 et 1 005 :
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# Fonction LENGTH
# Fonction LOWER
Convertit une chaîne en minuscules. LOWER prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère.
## Syntaxe
```
LOWER(string)
```
## Argument
*string*
Le paramètre d'entrée est une chaîne VARCHAR (ou tout autre type de données, tel que CHAR, qui peut être implicitement converti en VARCHAR).
## Type de retour
La fonction LOWER renvoie une chaîne de caractères qui est du même type que la chaîne d'entrée.
## Exemples
L'exemple suivant convertit le champ CATNAME en minuscules :
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# Fonctions LPAD et RPAD
Ces fonctions ajoutent des caractères en préfixe ou en suffixe à une chaîne, en fonction d’une longueur spécifiée.
## Syntaxe
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Arguments
*string1*
Chaîne de caractères ou expression qui a pour valeur une chaîne de caractères, comme le nom d'une colonne de caractères.
*longueur*
Nombre entier qui définit la longueur du résultat de la fonction. La longueur d’une chaîne est basée sur le nombre de caractères, pas d’octets, afin que les caractères à plusieurs octets soient comptés comme des caractères seuls. Si *string1* dépasse la longueur spécifiée, il est tronqué (à droite). Si *length* est un nombre négatif, le résultat de la fonction est une chaîne vide.
*string2*
Un ou plusieurs caractères ajoutés en préfixe ou en suffixe à *string1*. Cet argument est facultatif. S'il n'est pas spécifié, les espaces sont utilisés.
## Type de retour
Ces fonctions renvoient un type de données VARCHAR.
## Exemples
Tronquez un ensemble spécifié de noms d'événements à 20 caractères et ajoutez des espaces comme préfixes aux noms plus courts :
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
Tronquez le même ensemble de noms d'événements à 20 caractères, mais ajoutez `0123456789` comme suffixe aux noms plus courts.
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# Fonction LTRIM
Supprime les caractères du début d’une chaîne de caractères. Supprime la chaîne la plus longue ne contenant que des caractères de la liste des caractères supprimés. Le découpage est terminé lorsqu'aucun caractère de découpage n'apparaît dans la chaîne d'entrée.
## Syntaxe
```
LTRIM( string [, trim_chars] )
```
## Arguments
*string*
Une colonne de chaîne, une expression ou un littéral de chaîne à supprimer.
*trim\$1chars*
Une colonne, une expression ou un littéral de chaîne qui représente les caractères à supprimer au début de la *chaîne*. Si la valeur n’est pas spécifiée, un espace est utilisé comme caractère de séparation.
## Type de retour
La fonction LTRIM renvoie une chaîne de caractères qui est du même type que la *chaîne* d’entrée (CHAR ou VARCHAR).
## Exemples
L’exemple suivant supprime l’année de la colonne `listime`. Les caractères supprimés dans la chaîne littérale `'2008-'` indiquent les caractères à supprimer à partir de la gauche. Si vous utilisez les caractères de suppression `'028-'`, vous obtiendrez le même résultat.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM supprime les caractères de *trim\$1chars* lorsqu’ils apparaissent au début de la *chaîne*. L’exemple suivant supprime les caractères C, D et G lorsqu’ils figurent au début de VENUENAME, qui est une colonne VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
L’exemple suivant utilise le caractère de suppression `2` qui est extrait de la colonne `venueid`.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
L’exemple suivant ne supprime aucun caractère car `2` est trouvé avant le caractère de suppression `'0'`.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
L’exemple suivant utilise le caractère de suppression d’espace par défaut et supprime les deux espaces du début de la chaîne.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Fonction POSITION
Renvoie l’emplacement de la sous-chaîne spécifiée dans une chaîne.
## Syntaxe
```
POSITION(substring IN string )
```
## Arguments
*substring*
Sous-chaîne à rechercher dans la *chaîne*.
*string*
Chaîne ou colonne à rechercher.
## Type de retour
La fonction POSITION renvoie un nombre entier correspondant à la position de la sous-chaîne (base 1, pas base 0). La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls.
## Notes d’utilisation
POSITION renvoie 0 si la sous-chaîne n'est pas trouvée dans la chaîne POSITION :
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Exemples
L'exemple suivant montre la position de la chaîne `fish` dans le mot `dogfish` :
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
L'exemple suivant renvoie le nombre de transactions commerciales avec une COMMISSION de plus de 999,00 dans la table SALES :
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# Fonction REGEXP\$1COUNT
Recherche un modèle d’expression régulière dans une chaîne et renvoie un nombre entier indiquant le nombre de fois où le modèle est présent dans la chaîne. Si aucune correspondance n'est trouvée, la fonction renvoie 0.
## Syntaxe
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieur au nombre de caractères de *source\$1string*, le résultat est 0.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
Entier
## exemple
L'exemple suivant compte le nombre de fois que se produit une séquence de trois lettres.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
L'exemple suivant compte le nombre de fois que le nom de domaine de niveau supérieur est `org` ou `edu`.
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
L'exemple suivant compte les occurrences de la chaîne `FOX`, en utilisant une correspondance avec respect de la casse.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple compte le nombre d'occurrences de ces mots, avec une correspondance avec respect de la casse.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation spécifique au type PCRE. Cet exemple compte le nombre d'occurrences de ces mots, mais diffère de l'exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Fonction REGEXP\$1INSTR
Recherche un modèle d’expression régulière dans une chaîne et renvoie un nombre entier qui indique la position de début de la sous-chaîne correspondante. Si aucune correspondance n'est trouvée, la fonction renvoie 0. REGEXP\$1SUBSTR est similaire à la fonction [POSITION](POSITION.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne.
## Syntaxe
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieur au nombre de caractères de *source\$1string*, le résultat est 0.
*occurrence*
Nombre entier positif qui indique quelle occurrence du modèle utiliser. REGEXP\$1INSTR ignore les *occurrence* -1 premières correspondances. La valeur par défaut est 1. Si *occurrence* est inférieur à 1 ou supérieur au nombre de caractères de la chaîne *source\$1string*, la recherche est ignorée et le résultat est 0.
*option*
Valeur qui indique s'il faut renvoyer la position du premier caractère de la correspondance (`0`) ou celle du premier caractère après la fin de la correspondance (`1`). Toute valeur de chaîne autre que zéro est similaire à la valeur 1. La valeur par défaut est 0.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ e : extraire une sous-chaîne à l’aide d’une sous-expression.
Si *pattern* inclut une sous-expression, REGEXP\$1INSTR met en correspondance une sous-chaîne à l’aide de la première sous-expression incluse dans *pattern*. REGEXP\$1INSTR considère uniquement la première sous-expression ; les autres sous-expressions sont ignorées. Si le modèle n’inclut pas de sous-expression, REGEXP\$1INSTR ignore le paramètre « e ».
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
Entier
## exemple
L'exemple suivant recherche le caractère `@` qui commence par un nom de domaine et renvoie la position de début de la première correspondance.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
L'exemple suivant recherche des variantes du mot `Center` et renvoie la position du début de la première correspondance.
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
L'exemple suivant recherche la position de départ de la première occurrence de la chaîne `FOX`, à l'aide d'une logique de correspondance avec respect de la casse.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
L'exemple suivant utilise un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple montre comment trouver la position de départ du deuxième mot de ce type.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
L'exemple suivant utilise un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple recherche la position de départ du deuxième mot de ce type, mais diffère de l’exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Fonction REGEXP\$1REPLACE
Recherche un modèle d’expression régulière dans une chaîne et remplace chaque occurrence du modèle par la chaîne spécifiée. REGEXP\$1REPLACE est similaire à la [Fonction REPLACE](REPLACE.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne.
REGEXP\$1REPLACE est similaire à la [Fonction TRANSLATE](TRANSLATE.md) et la [Fonction REPLACE](REPLACE.md), sauf que TRANSLATE fait plusieurs remplacements de caractère unique et REPLACE remplace une chaîne entière par une autre chaîne, tandis que REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne.
## Syntaxe
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*replace\$1string*
Expression de chaîne, comme un nom de colonne, qui va remplacer chaque occurrence de modèle. La valeur par défaut est une chaîne vide ( "" ).
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieure au nombre de caractères de *source\$1string*, le résultat est *source\$1string*.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
VARCHAR
Si *pattern* ou *replace\$1string* a la valeur NULL, le retour est NULL.
## exemple
L'exemple suivant supprime le caractère `@` et le nom de domaine des adresses e-mail.
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
L'exemple suivant remplace les noms de domaine des adresses e-mail par cette valeur : `internal.company.com`.
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
L'exemple suivant remplace toutes les occurrences de la chaîne `FOX` dans la valeur `quick brown fox`, à l'aide d'une correspondance avec respect de la casse.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple remplace chaque occurrence de mot de ce type par la valeur `[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
L'exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple remplace chaque occurrence de mot de ce type par la valeur `[hidden]`, mais diffère de l'exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Fonction REGEXP\$1SUBSTR
Renvoie les caractères d’une chaîne en y recherchant un modèle d’expression régulière. REGEXP\$1SUBSTR est similaire à la fonction [Fonction SUBSTRING](SUBSTRING.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne. Si la fonction ne trouve pas correspondance entre l’expression régulière et aucun caractère de la chaîne, elle renvoie une chaîne vide.
## Syntaxe
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne à rechercher.
*pattern*
Chaîne littérale qui représente un modèle d’expression régulière.
*position*
Nombre entier positif qui indique à quel endroit de *source\$1string* commencer la recherche. La position est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. La valeur par défaut est 1. Si *position* est inférieur à 1, la recherche commence au premier caractère de *source\$1string*. Si *position* est supérieure au nombre de caractères de *source\$1string*, le résultat est une chaîne vide ("").
*occurrence*
Nombre entier positif qui indique quelle occurrence du modèle utiliser. REGEXP\$1SUBSTR ignore les *occurrence* -1 premières correspondances. La valeur par défaut est 1. Si *occurrence* est inférieur à 1 ou supérieur au nombre de caractères de la chaîne *source\$1string*, la recherche est ignorée et le résultat est NULL.
*parameters*
Un ou plusieurs littéraux de chaîne qui indiquent comment la fonction correspond au modèle. Les valeurs possibles sont les suivantes :
+ c : réaliser une correspondance avec respect de la casse. Par défaut, la correspondance avec respect de la casse est utilisée.
+ i : réaliser une correspondance avec non-respect de la casse.
+ e : extraire une sous-chaîne à l’aide d’une sous-expression.
Si *pattern* inclut une sous-expression, REGEXP\$1SUBSTR met en correspondance une sous-chaîne à l’aide de la première sous-expression incluse dans *pattern*. Une sous-expression est une expression dans le modèle qui est mise entre parenthèses. Par exemple, le modèle `'This is a (\\w+)'` met en correspondance la première expression avec la chaîne `'This is a '` suivie d’un mot. Au lieu de renvoyer le *modèle*, REGEXP\$1SUBSTR avec le paramètre `e` renvoie uniquement la chaîne contenue dans la sous-expression.
REGEXP\$1SUBSTR considère uniquement la première sous-expression ; les autres sous-expressions sont ignorées. Si le modèle n’inclut pas de sous-expression, REGEXP\$1SUBSTR ignore le paramètre « e ».
+ p – Interpréter le modèle avec le type d’expression PCRE (Perl Compatible Regular Expression).
## Type de retour
VARCHAR
## exemple
L’exemple suivant renvoie la partie d’une adresse e-mail comprise entre le caractère @ et l’extension du domaine.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
L'exemple suivant renvoie la partie de l'entrée correspondant à la première occurrence de la chaîne `FOX`, à l'aide d'une correspondance avec respect de la casse.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
L'exemple suivant renvoie la première partie de l'entrée qui commence par des lettres minuscules. Il est fonctionnellement identique à la même instruction SELECT sans le paramètre `c`.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l'opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
L’exemple suivant utilise un modèle écrit dans le type PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule. Il utilise l’opérateur `?=`, qui a une connotation « anticipée » spécifique au type PCRE. Cet exemple renvoie la partie de l’entrée correspondant au deuxième mot de ce type, mais diffère de l’exemple précédent car il utilise une correspondance avec non-respect de la casse.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
L’exemple suivant utilise une sous-expression pour rechercher la deuxième chaîne correspondant au modèle `'this is a (\\w+)'` à l’aide d’une correspondance avec respect de la casse. Il renvoie la sous-expression entre parenthèses.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Fonction REPEAT
Répète une chaîne le nombre de fois spécifié. Si le paramètre d’entrée est numérique, REPEAT le traite sous forme de chaîne.
## Syntaxe
```
REPEAT(string, integer)
```
## Arguments
*string*
Le premier paramètre d’entrée est la chaîne à répéter.
*integer*
Le deuxième paramètre est un nombre entier indiquant combien de fois répéter la chaîne.
## Type de retour
La fonction REPEAT renvoie une chaîne.
## Exemples
L'exemple suivant répète la valeur de la colonne CATID dans la table CATEGORY à trois reprises :
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# Fonction REPLACE
Remplace toutes les occurrences d’un jeu de caractères au sein d’une chaîne existante par d’autres caractères spécifiés.
REPLACE est similaire à la [Fonction TRANSLATE](TRANSLATE.md) et la [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md), sauf que TRANSLATE fait plusieurs remplacements de caractère unique et REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne, tandis que REPLACE remplace une chaîne entière par une autre chaîne.
## Syntaxe
```
REPLACE(string1, old_chars, new_chars)
```
## Arguments
*string*
Chaîne CHAR ou VARCHAR à rechercher
*old\$1chars*
Chaîne CHAR ou VARCHAR à remplacer.
*new\$1chars*
Nouvelle chaîne CHAR ou VARCHAR remplaçant l'ancienne chaîne *old\$1string*.
## Type de retour
VARCHAR
Si *old\$1chars* ou *new\$1chars* a la valeur NULL, le retour est NULL.
## Exemples
L'exemple suivant convertit la chaîne `Shows` en `Theatre` dans le champ CATGROUP :
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# Fonction REVERSE
La fonction REVERSE s’applique à une chaîne et renvoie les caractères dans l’ordre inverse. Par exemple, `reverse('abcde')` renvoie `edcba`. Cette fonction s’applique aux types de données numérique et de date, ainsi qu’aux types de données de caractère. Toutefois, dans la plupart des cas, elle a une valeur pratique pour les chaînes de caractères.
## Syntaxe
```
REVERSE ( expression )
```
## Argument
*expression*
Expression avec un type de données de caractère, date, horodatage ou numérique qui représente la cible de l'inversion de caractères. Toutes les expressions régulières sont implicitement converties en chaînes de caractères de longueur variable. Les espaces de fin des chaînes de caractères à largeur fixe sont ignorés.
## Type de retour
REVERSE renvoie un VARCHAR.
## Exemples
Sélectionnez cinq noms de ville distincts et leur noms inversés correspondants à partir de la table USERS :
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
Sélectionnez cinq ventes IDs et leur transformation inversée correspondante IDs sous forme de chaînes de caractères :
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# Fonction RTRIM
La fonction RTRIM supprime un ensemble spécifié de caractères à partir de la fin d’une chaîne. Supprime la chaîne la plus longue ne contenant que des caractères de la liste des caractères supprimés. Le découpage est terminé lorsqu'aucun caractère de découpage n'apparaît dans la chaîne d'entrée.
## Syntaxe
```
RTRIM( string, trim_chars )
```
## Arguments
*string*
Une colonne de chaîne, une expression ou un littéral de chaîne à supprimer.
*trim\$1chars*
Colonne de chaîne, expression ou littéral de chaîne représentant les caractères à supprimer à la fin de la *chaîne*. Si la valeur n’est pas spécifiée, un espace est utilisé comme caractère de séparation.
## Type de retour
Chaîne qui a le même type de données que l’argument *string*.
## exemple
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L’exemple suivant supprime les chaînes `'xyz'` de fin de la chaîne `'xyzaxyzbxyzcxyz'`. Les occurrences de fin de `'xyz'` sont supprimées, mais celles qui se trouvent à l’intérieur de la chaîne sont conservées.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
L’exemple suivant supprime les parties de fin de la chaîne `'setuphistorycassettes'` qui correspondent à l’un des caractères de la liste *trim\$1chars* `'tes'`. Tout caractère `t`, `e` ou `s` précédant un autre caractère qui ne figure pas dans la liste *trim\$1chars* à la fin de la chaîne d’entrée est supprimé.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
L’exemple suivant tronque les caractères « Park » à la fin de VENUENAME le cas échéant :
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Notez que RTRIM supprime les caractères `P`, `a`, `r` ou `k` lorsqu’ils apparaissent à la fin d’un VENUENAME.
# Fonction SPLIT
La fonction SPLIT vous permet d'extraire des sous-chaînes d'une chaîne plus grande et de les utiliser sous forme de tableau. La fonction SPLIT est utile lorsque vous devez décomposer une chaîne en composants individuels en fonction d'un délimiteur ou d'un modèle spécifique.
## Syntaxe
```
split(str, regex, limit)
```
## Arguments
*str*
Expression de chaîne à diviser.
*regex*
Chaîne représentant une expression régulière. La chaîne *regex* doit être une expression régulière Java.
*limit*
Expression entière qui contrôle le nombre de fois que l'expression *régulière est* appliquée.
+ limit > 0 : la longueur du tableau résultant ne sera pas supérieure à la limite, et la dernière entrée du tableau résultant contiendra toutes les entrées au-delà de la dernière *regex* correspondante.
+ limit <= 0 : *regex* sera appliquée autant de fois que possible, et le tableau résultant peut être de n'importe quelle taille.
## Type de retour
La fonction SPLIT renvoie un ARRAY.
Si `limit > 0` : La longueur du tableau résultant ne sera pas supérieure à la limite, et la dernière entrée du tableau résultant contiendra toutes les entrées au-delà de la dernière expression régulière correspondante.
if `limit <= 0` : regex sera appliquée autant de fois que possible, et le tableau résultant peut être de n'importe quelle taille.
## exemple
Dans cet exemple, la fonction SPLIT divise la chaîne d'entrée `'oneAtwoBthreeC'` là où elle rencontre les caractères `'A'``'B'`, ou `'C'` (comme spécifié par le modèle d'expression régulière`'[ABC]'`). Le résultat obtenu est un tableau de quatre éléments : `"one"``"two"`,`"three"`, et une chaîne vide`""`.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Fonction SPLIT\$1PART
Divise une chaîne sur le délimiteur spécifié et renvoie la partie à la position spécifiée.
## Syntaxe
```
SPLIT_PART(string, delimiter, position)
```
## Arguments
*string*
Colonne de chaîne, expression ou littéral de chaîne à fractionner. La chaîne peut être CHAR ou VARCHAR.
*delimiter*
Chaîne de délimiteur indiquant les sections de la *chaîne* d’entrée.
Si *delimiter* est un littéral, mettez-le entre guillemets simples.
*position*
Position de la partie de *chaîne* à renvoyer (à partir de 1). Doit être un nombre entier supérieur à 0. Si la valeur de *position* est supérieure au nombre de parties de chaîne, SPLIT\$1PART renvoie une chaîne vide. Si *délimiteur* est introuvable dans *chaîne*, alors la valeur renvoyée contient le contenu de la partie spécifiée, qui pourrait être la *chaîne* entière ou une valeur vide.
## Type de retour
Chaîne CHAR ou VARCHAR, la même que le paramètre *string*.
## Exemples
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `$` et renvoie la seconde partie.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `$`. Il renvoie une chaîne vide, car la partie `4` est introuvable.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
L’exemple suivant fractionne un littéral de chaîne en différentes parties en utilisant le délimiteur `#`. Il renvoie la chaîne entière, qui correspond à la première partie, car le délimiteur est introuvable.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
L’exemple suivant divise le champ d’horodatage LISTTIME en composants d’année, de mois et de date.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
L’exemple suivant sélectionne le champ d’horodatage LISTTIME et le divise sur le caractère `'-'` pour obtenir le mois (la deuxième partie de la chaîne LISTTIME), puis compte le nombre d’entrées de chaque mois :
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Fonction SUBSTRING
Renvoie le sous-ensemble d’une chaîne sur la base de la position de départ spécifiée.
Si l’entrée est une chaîne de caractères, la position de départ et le nombre de caractères extraits sont basés sur les caractères, pas les octets, afin que les caractères à plusieurs octets soient comptés comme des caractères uniques. Si l’entrée est une expression binaire, la position de départ et la sous-chaîne extraite sont basées sur des octets. Vous ne pouvez pas spécifier de longueur négative, mais vous pouvez spécifier une position de début négative.
## Syntaxe
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Arguments
*chaîne de caractères*
Chaîne à rechercher. Les types de données non-caractères sont traités comme une chaîne.
*start\$1position*
Position au sein de la chaîne à laquelle commencer l’extraction, à partir de 1. La position de début *start\$1position* est basée sur le nombre de caractères, pas d’octets, de sorte que les caractères à plusieurs octets soient comptés comme des caractères seuls. Ce numéro peut être négatif.
*caractères numériques*
Nombre de caractères à extraire (longueur de la sous-chaîne). Le *nombre de caractères* est basé sur le nombre de caractères, et non sur le nombre d'octets, de sorte que les caractères multi-octets sont considérés comme des caractères uniques. Ce numéro ne peut pas être négatif.
*start\$1byte*
Position au sein de l’expression binaire à laquelle commencer l’extraction, à partir de 1. Ce numéro peut être négatif.
*nombre d'octets*
Nombre d’octets à extraire, c’est-à-dire la longueur de la sous-chaîne. Ce numéro ne peut pas être négatif.
## Type de retour
VARCHAR
## Notes d'utilisation pour les chaînes de caractères
L’exemple suivant renvoie une chaîne de quatre caractères commençant par le sixième caractère.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Si le *nombre de caractères* *start\$1position* \$1 dépasse la longueur de la *chaîne, SUBSTRING renvoie une sous-chaîne* commençant par la position de départ jusqu'à la fin de la chaîne.* Par exemple :
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Si `start_position` est négatif ou égal à 0, la fonction SUBSTRING renvoie une sous-chaîne commençant au premier caractère de la chaîne d’une longueur de `start_position` \$1 `numbecharacters` -1. Par exemple :
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Si `start_position` \$1 `numbecharacters` -1 est inférieur ou égal à zéro, SUBSTRING renvoie une chaîne vide. Par exemple :
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Exemples
L’exemple suivant renvoie le mois de la chaîne LISTTIME dans la table LISTING :
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
L’exemple suivant est le même que ci-dessus, mais utilise l’option FROM...FOR :
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Vous ne pouvez pas utiliser SUBSTRING pour extraire de manière prévisible le préfixe d’une chaîne pouvant contenir des caractères à plusieurs octets, car vous devez spécifier la longueur d’une chaîne de plusieurs octets basée sur le nombre d’octets, pas sur le nombre de caractères. Pour extraire le segment de début d’une chaîne en fonction de la longueur en octets, vous pouvez utiliser la fonction CAST sur la chaîne au format VARCHAR(*byte\$1length*) pour tronquer la chaîne, où *byte\$1length* est la longueur requise. L’exemple suivant extrait les 5 premiers octets de la chaîne `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
L’exemple suivant renvoie le prénom `Ana` qui apparaît après le dernier espace de la chaîne d’entrée `Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Fonction TRANSLATE
Pour une expression données, remplace toutes les occurrences de caractères spécifiés par des produits de remplacement spécifiés. Les caractères existants sont mappés à des caractères de remplacement en fonction de leurs positions dans les arguments *characters\$1to\$1replace* et *characters\$1to\$1substitute*. Si le nombre de caractères spécifiés dans l’argument *characters\$1to\$1replace* est supérieur à celui de l’argument *characters\$1to\$1substitute*, les caractères supplémentaires depuis l’argument *characters\$1to\$1replace* sont omis dans la valeur de retour.
TRANSLATE est similaire à la [Fonction REPLACE](REPLACE.md) et la [Fonction REGEXP\$1REPLACE](REGEXP_REPLACE.md), sauf que REPLACE remplace une chaîne entière par une autre chaîne et que REGEXP\$1REPLACE vous permet de rechercher un modèle d’expression régulière dans une chaîne, tandis que TRANSLATE fait plusieurs remplacements de caractère unique.
Si un argument a la valeur null, le retour est NULL.
## Syntaxe
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Arguments
*expression*
Expression à traduire.
*characters\$1to\$1replace*
Chaîne contenant les caractères à remplacer.
*characters\$1to\$1substitute*
Chaîne contenant les caractères à remplacer.
## Type de retour
VARCHAR
## Exemples
L'exemple suivant remplace plusieurs caractères dans une chaîne :
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
L'exemple suivant remplace le signe (@) par un point dans toutes les valeurs d'une colonne :
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
L'exemple suivant remplace des espaces par des traits de soulignement et supprime les périodes de toutes les valeurs d'une colonne :
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# Fonction TRIM
Tronque une chaîne en supprimant les espaces de début et de fin ou en supprimant les caractères de début et de fin qui correspondent à une chaîne spécifiée de manière facultative.
## Syntaxe
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Arguments
*trim\$1chars*
(Facultatif) Caractères à tronquer à partir de la chaîne. Si ce paramètre est oublié, les blancs sont tronqués.
*string*
Chaîne à tronquer.
## Type de retour
La fonction TRIM renvoie une chaîne VARCHAR ou CHAR. Si vous utilisez la fonction TRIM avec une commande SQL, les résultats sont AWS Clean Rooms implicitement convertis en VARCHAR. Si vous utilisez la fonction TRIM dans la liste SELECT pour une fonction SQL, AWS Clean Rooms elle ne convertit pas implicitement les résultats et vous devrez peut-être effectuer une conversion explicite pour éviter une erreur de non-concordance des types de données. Consultez la [Fonction CAST](CAST_function.md) fonction pour plus d'informations sur les conversions explicites.
## exemple
L’exemple suivant tronque les espaces de début et de fin de la chaîne `' abc '` :
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
L'exemple suivant supprime les guillemets qui entourent de la chaîne `"dog"` :
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM supprime les caractères de *trim\$1chars* qui apparaissent au début de la *chaîne*. L'exemple suivant supprime les caractères C, D et G lorsqu'ils figurent au début de VENUENAME, qui est une colonne VARCHAR.
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# Fonction UPPER
Convertit la valeur en majuscules. UPPER prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère.
## Syntaxe
```
UPPER(string)
```
## Arguments
*string*
Le paramètre d'entrée est une chaîne VARCHAR (ou tout autre type de données, tel que CHAR, qui peut être implicitement converti en VARCHAR).
## Type de retour
La fonction UPPER renvoie une chaîne de caractères qui est du même type que la chaîne d'entrée.
## Exemples
L'exemple suivant convertit le champ CATNAME en majuscules :
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# Fonction UUID
La fonction UUID génère un identifiant unique universel (UUID).
UUIDs sont des identifiants uniques à l'échelle mondiale qui sont couramment utilisés pour fournir des identifiants uniques à diverses fins, telles que :
+ Identification des enregistrements de base de données ou d'autres entités de données.
+ Génération de noms ou de clés uniques pour des fichiers, des répertoires ou d'autres ressources.
+ Suivi et corrélation des données entre les systèmes distribués.
+ Fournir des identifiants uniques pour les paquets réseau, les composants logiciels ou d'autres actifs numériques.
La fonction UUID génère une valeur UUID unique avec une probabilité très élevée, même sur des systèmes distribués et sur de longues périodes. UUIDs sont généralement générés à l'aide d'une combinaison de l'horodatage actuel, de l'adresse réseau de l'ordinateur et d'autres données aléatoires ou pseudo-aléatoires, ce qui garantit qu'il est très peu probable que chaque UUID généré entre en conflit avec un autre UUID.
Dans le contexte d'une requête SQL, la fonction UUID peut être utilisée pour générer des identifiants uniques pour les nouveaux enregistrements insérés dans une base de données, ou pour fournir des clés uniques pour le partitionnement des données, l'indexation ou à d'autres fins nécessitant un identifiant unique.
**Note**
La fonction UUID n'est pas déterministe.
## Syntaxe
```
uuid()
```
## Arguments
La fonction UUID ne prend aucun argument.
## Type de retour
UUID renvoie une chaîne d'identifiant unique universel (UUID). La valeur est renvoyée sous la forme d'une chaîne UUID canonique de 36 caractères.
## exemple
L'exemple suivant génère un identifiant unique universel (UUID). La sortie est une chaîne de 36 caractères représentant un identifiant unique universel.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```