Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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
**Topics**
+ [Opérateur (concaténation) \$1\$1](r_concat_op.md)
+ [Fonction ASCII](r_ASCII.md)
+ [Fonction BPCHARCMP](r_BPCHARCMP.md)
+ [Fonction BTRIM](r_BTRIM.md)
+ [Fonction BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Fonction CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Fonction CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Fonction CHARINDEX](r_CHARINDEX.md)
+ [Fonction CHR](r_CHR.md)
+ [Fonction COLLATE](r_COLLATE.md)
+ [Fonction CONCAT](r_CONCAT.md)
+ [CRC32 fonction](crc32-function.md)
+ [Fonction DIFFERENCE](DIFFERENCE.md)
+ [Fonction INITCAP](r_INITCAP.md)
+ [Fonctions LEFT et RIGHT](r_LEFT.md)
+ [Fonction LEN](r_LEN.md)
+ [Fonction LENGTH](r_LENGTH.md)
+ [Fonction LOWER](r_LOWER.md)
+ [Fonctions LPAD et RPAD](r_LPAD.md)
+ [Fonction LTRIM](r_LTRIM.md)
+ [Fonction OCTETINDEX](OCTETINDEX.md)
+ [Fonction OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Fonction POSITION](r_POSITION.md)
+ [Fonction QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Fonction QUOTE\$1LITERAL](r_QUOTE_LITERAL.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](r_REPEAT.md)
+ [Fonction REPLACE](r_REPLACE.md)
+ [Fonction REPLICATE](r_REPLICATE.md)
+ [Fonction REVERSE](r_REVERSE.md)
+ [Fonction RTRIM](r_RTRIM.md)
+ [Fonction SOUNDEX](SOUNDEX.md)
+ [Fonction SPLIT\$1PART](SPLIT_PART.md)
+ [Fonction STRPOS](r_STRPOS.md)
+ [Fonction STRTOL](r_STRTOL.md)
+ [Fonction SUBSTRING](r_SUBSTRING.md)
+ [Fonction TEXTLEN](r_TEXTLEN.md)
+ [Fonction TRANSLATE](r_TRANSLATE.md)
+ [Fonction TRIM](r_TRIM.md)
+ [Fonction UPPER](r_UPPER.md)
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.
**Fonctions de nœud principal uniquement obsolètes**
Les fonctions de chaîne suivantes sont obsolètes, car elles s’exécutent uniquement sur le nœud principal. Pour plus d'informations, consultez [Fonctions exécutées uniquement sur le nœud principal](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# Opérateur (concaténation) \$1\$1
Concatène deux expressions de chaque côté du symbole `||` et renvoie l’expression concaténée.
Similaire à [Fonction CONCAT](r_CONCAT.md).
**Note**
Si l’une des expressions (ou les deux) a la valeur null, le résultat de la concaténation est `NULL`.
## Syntaxe
```
expression1 || expression2
```
## Arguments
*expression1*
Chaîne `CHAR`, chaîne `VARCHAR`, expression binaire ou expression évaluée à l’un de ces types.
*expression2*
Chaîne `CHAR`, chaîne `VARCHAR`, expression binaire ou expression évaluée à l’un de ces types.
## Type de retour
Le type de retour de la chaîne est le même que celui des arguments d’entrée. Par exemple, la concaténation de deux chaînes de type `VARCHAR` renvoie une chaîne de type `VARCHAR`.
## Exemples
Les exemples suivants utilisent les tables USERS et VENUE de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour concaténer les champs FIRSTNAME et LASTNAME de la table USERS de l’exemple de base de données, utilisez l’exemple suivant.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Pour concaténer des colonnes susceptibles de contenir des valeurs nulles, utilisez l’expression [Fonctions NVL et COALESCE](r_NVL_function.md). L’exemple suivant utilise NVL pour renvoyer `0` chaque fois que la valeur `NULL` est rencontrée.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
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 ASCII
La fonction ASCII renvoie le code ASCII, ou le point de code Unicode, du premier caractère de la chaîne que vous spécifiez. La fonction renvoie `0` si la chaîne est vide. Elle renvoie `NULL` si la chaîne a la valeur null.
## Syntaxe
```
ASCII('string')
```
## Argument
*string*
Chaîne `CHAR` ou chaîne `VARCHAR`.
## Type de retour
INTEGER
## Exemples
Pour renvoyer `NULL`, utilisez l’exemple suivant. La fonction NULLIF renvoie `NULL` si les deux arguments sont identiques, si bien que l’argument d’entrée de la fonction ASCII est `NULL`. Pour plus d’informations, consultez [Fonction NULLIF](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Pour renvoyer le code ASCII 0, utilisez l’exemple suivant.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Pour renvoyer le code ASCII 97 pour la première lettre du mot amazon, utilisez l’exemple suivant.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Pour renvoyer le code ASCII 65 pour la première lettre du mot Amazon, utilisez l’exemple suivant.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Fonction BPCHARCMP
Compare la valeur de deux chaînes et renvoie un nombre entier. Si les chaînes sont identiques, la fonction renvoie `0`. Si la première chaîne est supérieure dans l’ordre alphabétique, la fonction renvoie `1`. Si la seconde chaîne est supérieure, la fonction renvoie `-1`.
Pour les caractères à plusieurs octets, la comparaison est basée sur l’encodage en octets.
Synonyme de [Fonction BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md).
## Syntaxe
```
BPCHARCMP(string1, string2)
```
## Arguments
*string1*
Chaîne `CHAR` ou chaîne `VARCHAR`.
*string2*
Chaîne `CHAR` ou chaîne `VARCHAR`.
## Type de retour
INTEGER
## Exemples
Les exemples suivants utilisent la table USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour déterminer si le prénom d’un utilisateur est alphabétiquement supérieur au nom de famille de l’utilisateur pour les dix premières entrées de la table USERS, utilisez l’exemple suivant. Pour les entrées où la chaîne FIRSTNAME est située plus loin dans l’ordre alphabétique que la chaîne LASTNAME, la fonction renvoie `1`. Si LASTNAME est situé plus loin dans l’ordre alphabétique que FIRSTNAME, la fonction renvoie `-1`.
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Pour renvoyer toutes les entrées de la table USERS si la fonction renvoie `0`, utilisez l’exemple suivant. La fonction renvoie `0` lorsque FIRSTNAME est identique à LASTNAME.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 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 BTTEXT\$1PATTERN\$1CMP
Synonyme de la fonction BPCHARCMP.
Consultez [Fonction BPCHARCMP](r_BPCHARCMP.md) pour plus de détails.
# Fonction CHAR\$1LENGTH
Synonyme de la fonction LEN.
Consultez [Fonction LEN](r_LEN.md).
# Fonction CHARACTER\$1LENGTH
Synonyme de la fonction LEN.
Consultez [Fonction LEN](r_LEN.md).
# Fonction CHARINDEX
Renvoie l’emplacement de la sous-chaîne spécifiée dans une chaîne.
Consultez [Fonction POSITION](r_POSITION.md) et [Fonction STRPOS](r_STRPOS.md) pour des fonctions similaires.
## Syntaxe
```
CHARINDEX( substring, string )
```
## Arguments
*substring*
Sous-chaîne à rechercher dans la *chaîne*.
*string*
Chaîne ou colonne à rechercher.
## Type de retour
INTEGER
La fonction CHARINDEX renvoie un `INTEGER` correspondant à la position de la sous-chaîne (de base 1, pas de 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. CHARINDEX renvoie `0` si la sous-chaîne ne figure pas dans la chaîne.
## Exemples
Pour renvoyer la position de la chaîne `fish` dans le mot `dog`, utilisez l’exemple suivant.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Pour renvoyer la position de la chaîne `fish` dans le mot `dogfish`, utilisez l’exemple suivant.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
L’exemple suivant utilise la table SALES de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer le nombre de transactions de vente distinctes avec une commission supérieure à 999,00 dans la table SALES, utilisez l’exemple suivant. Cette commande compte les commissions supérieures à 999,00 en vérifiant si la décimale est à plus de 4 positions du début de la valeur de la commission.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Fonction CHR
La fonction CHR renvoie le caractère qui correspond à la valeur du point de code ASCII spécifiée par le paramètre d’entrée.
## Syntaxe
```
CHR(number)
```
## Argument
*number*
Le paramètre d’entrée est un `INTEGER` qui représente une valeur de point de code ASCII.
## Type de retour
CHAR
La fonction CHR renvoie une chaîne `CHAR` si un caractère ASCII correspond à la valeur d’entrée. Si le nombre en entrée n’a aucun équivalent ASCII, la fonction renvoie `NULL`.
## Exemples
Pour renvoyer le caractère correspondant au point de code ASCII 0, utilisez l’exemple suivant. Notez que la fonction CHR renvoie `NULL` pour l’entrée `0`.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Pour renvoyer le caractère correspondant au point de code ASCII 65, utilisez l’exemple suivant.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Pour renvoyer les noms d’événements distincts qui commencent par un A majuscule (point de code ASCII 65), utilisez l’exemple suivant. L’exemple suivant utilise la table EVENT de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Fonction COLLATE
La fonction COLLATE remplace le classement d’une colonne ou d’une expression de chaîne.
Pour plus d'informations sur la création de tables à l'aide du classement de bases de données, consultez [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Pour plus d'informations sur la création de bases de données à l'aide du classement de bases de données, consultez [CREATE DATABASE](r_CREATE_DATABASE.md).
## Syntaxe
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Arguments
*string*
Colonne de chaîne ou expression que vous voulez remplacer.
*’case\$1sensitive’* \$1 *’cs’* \$1 *’case\$1insensitive’* \$1 *’ci’*
Constante de chaîne d’un nom de classement. Amazon Redshift prend uniquement en charge les valeurs suivantes pour ce paramètre :
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* et *cs* sont interchangeables et donnent les mêmes résultats. De même, *case\$1insensitive* et *ci* sont interchangeables et donnent les mêmes résultats.
## Type de retour
La fonction COLLATE renvoie `VARCHAR`, `CHAR` ou `SUPER` en fonction du premier type d’expression en entrée. Cette fonction ne modifie que le classement du premier argument d’entrée et ne modifie pas sa valeur de sortie.
## Exemples
Pour créer la table T et définir col1 dans la table T comme `case_sensitive`, utilisez l’exemple suivant.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Lorsque vous exécutez la première requête, Amazon Redshift renvoie uniquement `john`. Après l’exécution de la fonction COLLATE sur col1, le classement devient `case_insensitive`. La deuxième requête renvoie à la fois `john` et `JOHN`.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Pour créer la table A et définir col1 dans la table A comme `case_insensitive`, utilisez l’exemple suivant.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Lorsque vous exécutez la première requête, Amazon Redshift renvoie à la fois `john` et `JOHN`. Après l’exécution de la fonction COLLATE sur col1, le classement devient `case_sensitive`. La deuxième requête renvoie uniquement `john`.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# 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.
## 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, Amazon Redshift essaie de « convertir » implicitement l’une des expressions. Si des valeurs ne peuvent pas être converties, une erreur est renvoyée.
## Notes d’utilisation
+ 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.
## 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';
?column?
-------------------
December 25, 2008
(1 row)
```
L’exemple suivant utilise une fonction CONCAT imbriquée dans une autre fonction 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 NULLs, utilisez le[Fonctions NVL et COALESCE](r_NVL_function.md), qui renvoie une valeur donnée lorsqu'il rencontre la valeur NULL. 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)
```
L’exemple suivant concatène deux expressions binaires. Où `abc` est une valeur binaire (avec une représentation hexadécimale de `616263`) et `def` est une valeur binaire (avec une représentation hexadécimale de `646566`). Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la valeur binaire.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 fonction
CRC32 est une fonction utilisée pour détecter les erreurs. La fonction utilise un CRC32 algorithme pour détecter les changements entre les données source et cible. La CRC32 fonction convertit une chaîne de longueur variable en une chaîne de 8 caractères qui est une représentation textuelle de la valeur hexadécimale d'une séquence binaire de 32 bits. Pour détecter les modifications entre les données source et cible, utilisez la CRC32 fonction sur les données source et stockez la sortie. Utilisez ensuite la CRC32 fonction sur les données cibles et comparez cette sortie à la sortie des données source. Les sorties seront les mêmes si les données n’ont pas été modifiées, et les sorties seront différentes si les données ont été modifiées.
## Syntaxe
```
CRC32(string)
```
## Arguments
*string*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
## Type de retour
La CRC32 fonction renvoie une chaîne de 8 caractères qui est une représentation textuelle de la valeur hexadécimale d'une séquence binaire de 32 bits. La CRC32 fonction Amazon Redshift est basée sur le polynôme CRC-32C.
## Exemples
Pour montrer la valeur de 8 bits de la chaîne `Amazon Redshift`.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Fonction DIFFERENCE
La fonction DIFFERENCE compare les codes Soundex américains de deux chaînes. La fonction renvoie un `INTEGER` pour indiquer le nombre de caractères correspondants entre les codes Soundex.
Un code Soundex est une chaîne de quatre caractères. Un code Soundex représente la sonorité d’un mot plutôt que son orthographe. Par exemple, `Smith` et `Smyth` ont le même code Soundex.
## Syntaxe
```
DIFFERENCE(string1, string2)
```
## Arguments
*string1*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
*string2*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
## Type de retour
INTEGER
La fonction DIFFERENCE renvoie une valeur `INTEGER` comprise entre 0 et 4 qui compte le nombre de caractères correspondants dans les codes Soundex américains des deux chaînes. Un code Soundex comporte 4 caractères, donc la fonction DIFFERENCE renvoie `4` quand les 4 caractères des valeurs de code Soundex américain des chaînes sont identiques. DIFFERENCE renvoie `0` si l’une des deux chaînes est vide. La fonction renvoie `1` si aucune des chaînes ne contient de caractères valides. La fonction DIFFERENCE convertit uniquement les caractères ASCII alphabétiques anglais minuscules ou majuscules, y compris a–z et A–Z. DIFFERENCE ignore les autres caractères.
## Exemples
Pour comparer les valeurs Soundex des chaînes `%` et `@`, utilisez l’exemple suivant. La fonction renvoie `1` car aucune des chaînes ne contient de caractères valides.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Pour comparer les valeurs Soundex de `Amazon` et d’une chaîne vide, utilisez l’exemple suivant. La fonction renvoie `0` car l’une des deux chaînes est vide.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Pour comparer les valeurs Soundex des chaînes `Amazon` et `Ama`, utilisez l’exemple suivant. La fonction renvoie `2` car 2 caractères des valeurs Soundex des chaînes sont identiques.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Pour comparer les valeurs Soundex des chaînes `Amazon` et `+-*/%Amazon`, utilisez l’exemple suivant. La fonction renvoie `4` car les quatre caractères des valeurs Soundex des chaînes sont identiques. Notez que la fonction ignore les caractères non valides `+-*/%` dans la deuxième chaîne.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Pour comparer les valeurs Soundex des chaînes `AC/DC` et `Ay See Dee See`, utilisez l’exemple suivant. La fonction renvoie `4` car les quatre caractères des valeurs Soundex des chaînes sont identiques.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Fonction INITCAP
Met en majuscules la première lettre de chaque mot d’une chaîne spécifiée. INITCAP prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère.
## Syntaxe
```
INITCAP(string)
```
## Argument
*string*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
## Type de retour
VARCHAR
## Notes d’utilisation
La fonction INITCAP met la première lettre de chaque mot d’une chaîne en majuscules, et les lettres suivantes en minuscules (ou à gauche). Par conséquent, il est important de comprendre quels caractères (autres que l’espace) servent de séparateurs de mots. Un caractère *séparateur de mots* est tout caractère non alphanumérique, y compris des signes de ponctuation, des symboles et des caractères de contrôle. Tous les caractères suivants sont des séparateurs de mots :
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Tabulation, caractères de nouvelle de ligne, sauts de page, sauts de ligne et les retours à la ligne sont également des séparateurs de mots.
## Exemples
Les exemples suivants utilisent les données des tables CATEGORY et USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour mettre en majuscules les initiales de chaque mot dans la colonne CATDESC, utilisez l’exemple suivant.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Pour montrer que la fonction INITCAP ne conserve pas les majuscules quand celles-ci ne figurent pas au début des mots, utilisez l’exemple suivant. Par exemple, la chaîne `MLB` devient `Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Pour montrer que les caractères non alphanumériques autres que les espaces servent de séparateurs de mots, utilisez l’exemple suivant. Plusieurs lettres de chaque chaîne seront mises en majuscules.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# 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 `CHAR`, chaîne `VARCHAR` ou expression qui équivaut à une chaîne `CHAR` ou `VARCHAR`.
*integer*
Nombre entier positif.
## Type de retour
VARCHAR
## Exemples
L’exemple suivant utilise les données de la table EVENT de l’exemple de base de données TICKIT. Pour de plus amples informations, veuillez consulter [Exemple de base de données](c_sampledb.md).
Pour renvoyer les 5 caractères les plus à gauche et les 5 caractères les plus à droite des noms d'événements dont l'événement est IDs compris entre 1 000 et 1 005, utilisez l'exemple suivant.
```
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 |
+---------+----------------+--------+---------+
```
# Fonction LEN
Renvoie la longueur de la chaîne spécifiée en tant que nombre de caractères.
## Syntaxe
LEN est synonyme de [Fonction LENGTH](r_LENGTH.md), [Fonction CHAR\$1LENGTH](r_CHAR_LENGTH.md), [Fonction CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md), et [Fonction TEXTLEN](r_TEXTLEN.md).
```
LEN(expression)
```
## Argument
*expression*
Chaîne `CHAR`, chaîne `VARCHAR`, expression `VARBYTE` ou expression qui équivaut implicitement à un type `CHAR`, `VARCHAR` ou `VARBYTE`.
## Type de retour
INTEGER
La fonction LEN renvoie un nombre entier indiquant le nombre de caractères dans la chaîne d’entrée.
Si la chaîne d’entrée est une chaîne de caractères, la fonction LEN renvoie le nombre de caractères dans les chaînes de plusieurs octets, pas le nombre d’octets. Par exemple, une colonne `VARCHAR(12)` est nécessaire pour stocker trois caractères chinois de quatre octets. La fonction LEN renvoie `3` pour cette même chaîne. Pour obtenir la longueur d’une chaîne en octets, utilisez la fonction [OCTET\$1LENGTH](r_OCTET_LENGTH.md).
## Notes d’utilisation
Si *expression* est une chaîne `CHAR`, les espaces de fin ne sont pas comptés.
Si *expression* est une chaîne `VARCHAR`, les espaces de fin sont comptés.
## Exemples
Pour renvoyer le nombre d’octets et le nombre de caractères dans la chaîne `français`, utilisez l’exemple suivant.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Pour renvoyer le nombre d’octets et le nombre de caractères dans la chaîne `français` sans utiliser la fonction OCTET\$1LENGTH, utilisez l’exemple suivant. Pour de plus amples informations, veuillez consulter [Fonction CAST](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Pour renvoyer le nombre de caractères dans les chaînes `cat` sans les espaces de fin, `cat ` avec trois espaces de fin, `cat ` avec trois espaces de fin convertis en `CHAR` de longueur 6, et `cat ` avec trois espaces de fin convertis en `VARCHAR` de longueur 6, utilisez l’exemple suivant. Notez que la fonction ne compte pas les espaces de fin des chaînes `CHAR`, mais qu’elle compte les espaces de fin des chaînes `VARCHAR`.
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
L’exemple suivant utilise les données de la table VENUE de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer les 10 noms de lieux les plus longs de la table VENUE, utilisez l’exemple suivant.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Fonction LENGTH
Synonyme de la fonction LEN.
Consultez [Fonction LEN](r_LEN.md).
# 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*
Chaîne `VARCHAR` ou expression qui équivaut au type `VARCHAR`.
## Type de retour
chaîne
La fonction LOWER renvoie une chaîne qui est du même type que la chaîne en entrée. Par exemple, si l’entrée est une chaîne `CHAR`, la fonction renvoie une chaîne `CHAR`.
## Exemples
L’exemple suivant utilise les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour convertir les chaînes `VARCHAR` de la colonne CATNAME en minuscules, utilisez l’exemple suivant.
```
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 |
+-----------+-----------+
```
# 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 `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
*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 égal à zéro ou est un nombre négatif, le résultat de la fonction est une chaîne vide.
*string2*
(Facultatif) Un ou plusieurs caractères ajoutés en préfixe ou en suffixe à *string1*. Si cet argument n’est pas spécifié, les espaces sont utilisés.
## Type de retour
VARCHAR
## Exemples
Les exemples suivants utilisent les données de la table EVENT de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour tronquer un ensemble spécifié de noms d’événements à 20 caractères et ajouter en préfixe des espaces aux noms plus courts, utilisez l’exemple suivant.
```
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 |
+-----------------------+
```
Pour tronquer le même ensemble de noms d’événements à 20 caractères, mais ajouter `0123456789` comme suffixe aux noms plus courts, utilisez l’exemple suivant.
```
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 |
+----------------------+
```
# 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. La suppression est terminée lorsqu’un caractère supprimé n’apparaît pas 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 OCTETINDEX
La fonction OCTETINDEX renvoie l’emplacement d’une sous-chaîne dans une chaîne sous la forme d’un nombre d’octets.
## Syntaxe
```
OCTETINDEX(substring, string)
```
## Arguments
*substring*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
*string*
Chaîne `CHAR`, chaîne `VARCHAR` ou expression qui équivaut implicitement à un type `CHAR` ou `VARCHAR`.
## Type de retour
INTEGER
La fonction OCTETINDEX renvoie une valeur `INTEGER` correspondant à la position de *substring* dans *string* sous la forme d’un nombre d’octets, où le premier caractère de *string* est compté comme 1. Si *string* ne contient pas de caractères multioctets, le résultat est égal au résultat de la fonction CHARINDEX. Si *string* ne contient pas *substring*, la fonction renvoie `0`. Si *substring* est vide, la fonction renvoie `1`.
## Exemples
Pour renvoyer la position de la sous-chaîne `q` dans la chaîne`Amazon Redshift`, utilisez l'exemple suivant. Cet exemple renvoie `0` parce que *substring* ne figure pas dans *string*.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Pour renvoyer la position d'une sous-chaîne vide dans la chaîne`Amazon Redshift`, utilisez l'exemple suivant. Cet exemple renvoie `1` parce que *substring* est vide.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Pour renvoyer la position de la sous-chaîne `Redshift` dans la chaîne`Amazon Redshift`, utilisez l'exemple suivant. Cet exemple renvoie `8` car *substring* commence au huitième octet de *string*.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Pour renvoyer la position de la sous-chaîne `Redshift` dans la chaîne`Amazon Redshift`, utilisez l'exemple suivant. Cet exemple renvoie `21` car les six premiers caractères de *string* sont des caractères à deux octets.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Fonction OCTET\$1LENGTH
Renvoie la longueur de la chaîne spécifiée en tant que nombre d’octets.
## Syntaxe
```
OCTET_LENGTH(expression)
```
## Argument
*expression*
Chaîne `CHAR`, chaîne `VARCHAR`, expression `VARBYTE` ou expression qui équivaut implicitement à un type `CHAR`, `VARCHAR` ou `VARBYTE`.
## Type de retour
INTEGER
La fonction OCTET\$1LENGTH renvoie un nombre entier indiquant le nombre d’octets dans la chaîne d’entrée.
Si la chaîne d’entrée est une chaîne de caractères, la fonction [LEN](r_LEN.md) renvoie le nombre de caractères dans des chaînes de plusieurs octets, pas le nombre d’octets. Par exemple, une colonne `VARCHAR(12)` est nécessaire pour stocker trois caractères chinois de quatre octets. La fonction OCTET\$1LENGTH renvoie `12` pour cette chaîne et la fonction LEN renvoie `3` pour cette même chaîne.
## Notes d’utilisation
Si *expression* est une chaîne `CHAR`, la fonction renvoie la longueur de la chaîne `CHAR`. Par exemple, la sortie d’une entrée `CHAR(6)` est un `CHAR(6)`.
Si *expression* est une chaîne `VARCHAR`, les espaces de fin sont comptés.
## Exemples
Pour renvoyer le nombre d’octets lorsque la chaîne `francais` avec trois espaces de fin est convertie en type `CHAR` et `VARCHAR`, utilisez l’exemple suivant. Pour de plus amples informations, veuillez consulter [Fonction CAST](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Pour renvoyer le nombre d’octets et le nombre de caractères dans la chaîne `français`, utilisez l’exemple suivant.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Pour renvoyer le nombre d’octets lorsque la chaîne `français` est convertie en `VARBYTE`, utilisez l’exemple suivant.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Fonction POSITION
Renvoie l’emplacement de la sous-chaîne spécifiée dans une chaîne.
Consultez [Fonction CHARINDEX](r_CHARINDEX.md) et [Fonction STRPOS](r_STRPOS.md) pour des fonctions similaires.
## 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 `INTEGER` correspondant à la position de la sous-chaîne (de base 1, pas de 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. POSITION renvoie `0` si la sous-chaîne ne figure pas dans la chaîne.
## Exemples
Pour renvoyer la position de la chaîne `fish` dans le mot `dog`, utilisez l’exemple suivant.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Pour renvoyer la position de la chaîne `fish` dans le mot `dogfish`, utilisez l’exemple suivant.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
L’exemple suivant utilise la table SALES de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer le nombre de transactions de vente distinctes avec une commission supérieure à 999,00 dans la table SALES, utilisez l’exemple suivant. Cette commande compte les commissions supérieures à 999,00 en vérifiant si la décimale est à plus de 4 positions du début de la valeur de la commission.
```
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 |
+-----------+-------+
```
# Fonction QUOTE\$1IDENT
La fonction QUOTE\$1IDENT renvoie la chaîne spécifiée sous forme de chaîne entourée de guillemets doubles. La sortie de la fonction peut être utilisée comme identificateur dans une instruction SQL. La fonction double de manière appropriée tous les guillemets doubles intégrés.
QUOTE\$1IDENT ajoute des guillemets doubles uniquement lorsque cela est nécessaire pour créer un identifiant valide, lorsque la chaîne contient des caractères ne faisant pas partie d’un identifiant ou lorsqu’elle serait autrement convertie en minuscules. Pour renvoyer systématiquement une chaîne avec des guillemets simples, utilisez [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md).
## Syntaxe
```
QUOTE_IDENT(string)
```
## Argument
*string*
Chaîne `CHAR` ou `VARCHAR`.
## Type de retour
La fonction QUOTE\$1IDENT renvoie le même type de chaîne que celui de l’argument *string* en entrée.
## Exemples
Pour renvoyer la chaîne `"CAT"` avec des guillemets doublés, utilisez l’exemple suivant.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
L’exemple suivant utilise les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer la colonne CATNAME entourée de guillemets, utilisez l’exemple suivant.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Fonction QUOTE\$1LITERAL
La fonction QUOTE\$1LITERAL renvoie la chaîne spécifiée sous forme de chaîne entre guillemets simples pour qu’elle puisse être utilisée comme littéral de chaîne dans une instruction SQL. Si le paramètre d’entrée est un nombre, QUOTE\$1LITERAL le traite comme une chaîne. Double de manière appropriée les barres obliques inverses et les guillemets simples imbriqués.
## Syntaxe
```
QUOTE_LITERAL(string)
```
## Argument
*string*
Chaîne `CHAR` ou `VARCHAR`.
## Type de retour
La fonction QUOTE\$1LITERAL renvoie une chaîne `CHAR` ou `VARCHAR` qui est du même type de données que l’argument *string* en entrée.
## Exemples
Pour renvoyer la chaîne `''CAT''` avec des guillemets SIMPLES, utilisez l’exemple suivant.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
Les exemples suivants utilisent les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer la colonne CATNAME entourée de guillemets simples, utilisez l’exemple suivant.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Pour renvoyer la colonne CATID entourée de guillemets simples, utilisez l’exemple suivant.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# Fonction REGEXP\$1COUNT
Recherche un modèle d’expression régulière dans une chaîne et renvoie un entier indiquant le nombre de fois où le modèle spécifié apparaît dans la chaîne. Si aucune correspondance n’est trouvée, la fonction renvoie `0`. Pour plus d’informations sur les expressions régulières, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md) et [Expression régulière](https://en.wikipedia.org/wiki/Regular_expression) sur Wikipedia.
## Syntaxe
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Arguments
*source\$1string*
Chaîne `CHAR` ou `VARCHAR`.
*pattern*
Chaîne littérale UT-8 qui représente un modèle d’expression régulière. Pour plus d’informations, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md).
*position*
(Facultatif) `INTEGER` positif qui indique la position dans *source\$1string* où 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*
(Facultatif) 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). Pour plus d’informations sur les PCRE, consultez [Expressions régulières compatibles avec Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) sur Wikipedia.
## Type de retour
INTEGER
## Exemples
Pour compter le nombre de fois qu’une séquence de trois lettres apparaît, utilisez l’exemple suivant.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Pour compter les occurrences de la chaîne `FOX` en utilisant une correspondance respectant la casse, utilisez l’exemple suivant.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Pour utiliser un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule, utilisez l’exemple suivant. Cet exemple utilise l’opérateur `?=`, qui a une connotation « anticipée » spécifique dans une 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 |
+--------------+
```
Pour utiliser un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule, utilisez l’exemple suivant. 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 |
+--------------+
```
L’exemple suivant utilise les données de la table USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour compter le nombre de fois que le nom de domaine de niveau supérieur est `org` ou `edu`, utilisez l’exemple suivant.
```
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 |
+-----------------------------------------------+--------------+
```
# 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](r_POSITION.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne. Pour plus d’informations sur les expressions régulières, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md) et [Expression régulière](https://en.wikipedia.org/wiki/Regular_expression) sur Wikipedia.
## 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 UT-8 qui représente un modèle d’expression régulière. Pour plus d’informations, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md).
*position*
(Facultatif) `INTEGER` positif qui indique la position dans *source\$1string* où 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*
(Facultatif) `INTEGER` 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 dans *source\$1string*, la recherche est ignorée et le résultat est `0`.
*option*
(Facultatif) 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`). Une valeur non nulle est identique à `1`. La valeur par défaut est `0`.
*parameters*
(Facultatif) 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). Pour plus d’informations sur les PCRE, consultez [Expressions régulières compatibles avec Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) sur Wikipedia.
## Type de retour
Entier
## Exemples
Les exemples suivants utilisent les données de la table USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour rechercher le caractère `@` qui commence un nom de domaine et renvoyer la position de début de la première correspondance, utilisez l’exemple suivant.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Pour rechercher des variantes du mot `Center` et renvoyer la position de début de la première correspondance, utilisez l’exemple suivant.
```
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 |
+-----------------------+--------------+
```
Pour rechercher la position de début de la première occurrence de la chaîne `FOX`, à l’aide d’une logique de correspondance respectant la casse, utilisez l’exemple suivant.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Pour utiliser un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule, utilisez l’exemple suivant. 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 |
+--------------+
```
Pour utiliser un modèle écrit en PCRE pour localiser des mots contenant au moins un chiffre et une lettre minuscule, utilisez l’exemple suivant. 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](r_REPLACE.md), mais vous permet de rechercher un modèle d’expression régulière dans une chaîne. Pour plus d’informations sur les expressions régulières, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md) et [Expression régulière](https://en.wikipedia.org/wiki/Regular_expression) sur Wikipedia.
REGEXP\$1REPLACE est similaire à la [Fonction TRANSLATE](r_TRANSLATE.md) et la [Fonction REPLACE](r_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 `CHAR` ou `VARCHAR`, comme un nom de colonne, à rechercher.
*pattern*
Chaîne littérale UT-8 qui représente un modèle d’expression régulière. Pour plus d’informations, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md).
*replace\$1string*
(Facultatif) Expression de chaîne `CHAR` ou `VARCHAR`, comme un nom de colonne, qui va remplacer chaque occurrence de modèle. La valeur par défaut est une chaîne vide ( "" ).
*position*
(Facultatif) Entier positif qui indique la position dans *source\$1string* où 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*
(Facultatif) 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). Pour plus d’informations sur les PCRE, consultez [Expressions régulières compatibles avec Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) sur Wikipedia.
## Type de retour
VARCHAR
Si *pattern* ou *replace\$1string* a la valeur `NULL`, la fonction renvoie `NULL`.
## Exemples
Pour remplacer toutes les occurrences de la chaîne `FOX` dans la valeur `quick brown fox`, à l’aide d’une correspondance respectant la casse, utilisez l’exemple suivant.
```
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. Pour remplacer chaque occurrence d’un tel mot par la valeur `[hidden]`, utilisez l’exemple suivant.
```
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. Pour remplacer chaque occurrence d’un tel mot par la valeur `[hidden]` (diffère de l’exemple précédent car une correspondance ne respectant pas la casse est utilisée), utilisez l’exemple suivant.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
Les exemples suivants utilisent les données de la table USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour supprimer le caractère `@` et le nom de domaine des adresses e-mail, utilisez l’exemple suivant.
```
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 |
+-----------------------------------------------+-----------------------+
```
Pour remplacer les noms de domaine des adresses e-mail par `internal.company.com`, utilisez l’exemple suivant.
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# 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](r_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. Pour plus d’informations sur les expressions régulières, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md) et [Expression régulière](https://en.wikipedia.org/wiki/Regular_expression) sur Wikipedia.
## Syntaxe
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Arguments
*source\$1string*
Expression de chaîne à rechercher.
*pattern*
Chaîne littérale UT-8 qui représente un modèle d’expression régulière. Pour plus d’informations, consultez [Opérateurs POSIX](pattern-matching-conditions-posix.md).
*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 vide.
*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). Pour plus d’informations sur les PCRE, consultez [Expressions régulières compatibles avec Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) sur Wikipedia.
## Type de retour
VARCHAR
## Exemples
L’exemple suivant renvoie la partie d’une adresse e-mail comprise entre le caractère @ et l’extension du domaine. Les données `users` interrogées proviennent des exemples de données Amazon Redshift. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
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 ne respectant pas la casse.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
L’exemple suivant renvoie la partie de l’entrée correspondant à la deuxième occurrence de la chaîne `FOX` à l’aide d’une correspondance ne respectant pas la casse. Le résultat est vide (non null, longueur 0), car il n’existe pas de deuxième occurrence.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
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.
Synonyme de [Fonction REPLICATE](r_REPLICATE.md).
## 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 `INTEGER` indiquant combien de fois répéter la chaîne.
## Type de retour
VARCHAR
## Exemples
L’exemple suivant utilise les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour répéter la valeur de la colonne CATID dans la table CATEGORY à trois reprises, utilisez l’exemple suivant.
```
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 |
+-------+--------+
```
L'exemple suivant montre comment générer des chaînes allant jusqu'à 16 000 000 octets :
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# 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](r_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(string, 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 utilise les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour convertir la chaîne `Shows` en `Theatre` dans le champ CATGROUP, utilisez l’exemple suivant.
```
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 |
+-------+----------+----------+
```
# Fonction REPLICATE
Synonyme de la fonction REPEAT.
Consultez [Fonction REPEAT](r_REPEAT.md).
# 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 sont implicitement converties en chaînes `VARCHAR`. Les espaces de fin des chaînes `CHAR` sont ignorés.
## Type de retour
VARCHAR
## Exemples
Les exemples suivants utilisent les données des tables USERS et SALES de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour sélectionner cinq noms de ville distincts et leur noms inversés correspondants à partir de la table USERS, utilisez l’exemple suivant.
```
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 |
+----------+----------+
```
Pour sélectionner cinq ventes IDs et leur transformation inversée correspondante IDs sous forme de chaînes de caractères, utilisez l'exemple suivant.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# 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. La suppression est terminée lorsqu’un caractère supprimé n’apparaît pas 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 SOUNDEX
La fonction SOUNDEX renvoie la valeur Soundex américaine consistant en la première lettre de la chaîne en entrée, suivie d’un codage à 3 chiffres des sons qui représentent la prononciation anglaise de la chaîne que vous spécifiez. Par exemple, `Smith` et `Smyth` ont la même valeur Soundex.
## Syntaxe
```
SOUNDEX(string)
```
## Arguments
*string*
Vous spécifiez une chaîne `CHAR` ou `VARCHAR` que vous souhaitez convertir en une valeur de code Soundex américain.
## Type de retour
VARCHAR(4)
## Notes d’utilisation
La fonction SOUNDEX convertit uniquement les caractères alphabétiques en minuscules et majuscules ASCII, y compris a–z et A–Z. SOUNDEX ignore les autres caractères. SOUNDEX renvoie une valeur Soundex unique pour une chaîne de mots multiples séparés par des espaces.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX renvoie une chaîne vide si la chaîne d’entrée ne contient pas de lettres anglaises.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Exemples
Pour renvoyer la valeur Soundex pour `Amazon`, utilisez l’exemple suivant.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Pour renvoyer la valeur Soundex pour `smith` et `smyth`, utilisez l’exemple suivant. Notez que les valeurs Soundex sont identiques.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# 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 STRPOS
Renvoie la position d’une sous-chaîne dans une chaîne spécifiée.
Consultez [Fonction CHARINDEX](r_CHARINDEX.md) et [Fonction POSITION](r_POSITION.md) pour des fonctions similaires.
## Syntaxe
```
STRPOS(string, substring )
```
## Arguments
*string*
Le premier paramètre d’entrée est la chaîne `CHAR` ou `VARCHAR` à rechercher.
*substring*
Le deuxième paramètre est la sous-chaîne à rechercher dans la *chaîne*.
## Type de retour
INTEGER
La fonction STRPOS renvoie un `INTEGER` correspondant à la position de l’argument *substring* (de base 1, pas de 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
STRPOS renvoie `0` si *substring* n’est pas trouvé dans *string*.
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Exemples
Pour montrer la position de `fish` dans `dogfish`, utilisez l’exemple suivant.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
L’exemple suivant utilise les données de la table SALES de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour renvoyer le nombre de transactions de vente avec une COMMISSION de plus de 999,00 à partir de la table SALES, utilisez l’exemple suivant.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Fonction STRTOL
Convertit une expression de chaîne d’un nombre de la base spécifiée en la valeur de nombre entier équivalente. La valeur convertie doit est comprise dans la plage de 64 bits signée.
## Syntaxe
```
STRTOL(num_string, base)
```
## Arguments
*num\$1string*
Expression de chaîne d’un nombre à convertir. Si *num\$1string* est vide ( `''` ) ou commence par le caractère null (`'\0'`), la valeur convertie est `0`. Si *num\$1string* est une colonne contenant une valeur NULL, STRTOL renvoie `NULL`. La chaîne peut commencer par n’importe quelle quantité d’espace vide, éventuellement suivie d’un signe plus « `+` » ou moins « `-` » pour indiquer si elle est positive ou négative. La valeur par défaut est « `+` ». Si la *base* est `16`, la chaîne peut éventuellement commencer par « `0x` ».
*base*
`INTEGER` entre 2 et 36.
## Type de retour
BIGINT
Si *num\$1string* a pour valeur null, la fonction renvoie `NULL`.
## Exemples
Pour convertir des paires de valeur de chaîne et de base en entiers, utilisez les exemples suivants.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# 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(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Arguments
*character\$1string*
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.
*number\$1characters*
Nombre de caractères à extraire (longueur de la sous-chaîne). Le nombre de caractères *number\$1characters* 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. Ce numéro ne peut pas être négatif.
*binary\$1expression*
binary\$1expression du type de données VARBYTE à rechercher.
*start\$1byte*
Position au sein de l’expression binaire à laquelle commencer l’extraction, à partir de 1. Ce numéro peut être négatif.
*number\$1bytes*
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 ou VARBYTE selon l’entrée.
## Notes d’utilisation
Vous trouverez ci-dessous quelques exemples de la façon dont vous pouvez utiliser *start\$1position* et *number\$1characters* pour extraire des sous-chaînes à partir de différentes positions d’une chaîne.
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 *start\$1position* \$1 *number\$1characters* dépasse la longueur de la *chaîne*, SUBSTRING renvoie une sous-chaîne commençant par *start\$1position* 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 `number_characters` -1. Par exemple :
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Si `start_position` \$1 `number_characters` -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 illustre une position de départ négative d’une valeur binaire `abc`. Comme la position de départ est -3, la sous-chaîne est extraite du début de la valeur binaire. Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la sous-chaîne binaire.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
L’exemple suivant montre un 1 pour la position de départ d’une valeur binaire `abc`. Comme aucune longueur n’est spécifiée, la chaîne est extraite de la position de départ jusqu’à la fin de la chaîne. Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la sous-chaîne binaire.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
L’exemple suivant montre un 3 pour la position de départ d’une valeur binaire `abc`. Comme aucune longueur n’est spécifiée, la chaîne est extraite de la position de départ jusqu’à la fin de la chaîne. Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la sous-chaîne binaire.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
L’exemple suivant montre un 2 pour la position de départ d’une valeur binaire `abc`. La chaîne est extraite de la position de départ à la position 10, mais la fin de la chaîne est à la position 3. Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la sous-chaîne binaire.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
L’exemple suivant montre un 2 pour la position de départ d’une valeur binaire `abc`. La chaîne est extraite de la position de départ pour 1 octet. Le résultat est automatiquement affiché sous forme de représentation hexadécimale de la sous-chaîne binaire.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
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 TEXTLEN
Synonyme de la fonction LEN.
Consultez [Fonction LEN](r_LEN.md).
# 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](r_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
Pour remplacer plusieurs caractères dans une chaîne, utilisez l’exemple suivant.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
Les exemples suivants utilisent les données de la table USERS de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour remplacer le signe arobase (@) par un point dans toutes les valeurs d’une colonne, utilisez l’exemple suivant.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Pour remplacer des espaces par des traits de soulignement et supprimer les points de toutes les valeurs d’une colonne, utilisez l’exemple suivant.
```
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 ou les caractères spécifiés.
## Syntaxe
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Arguments
BOTH \$1 LEADING \$1 TRAILING
(Facultatif) Spécifie l’emplacement à partir duquel les caractères doivent être tronqués. Utilisez BOTH pour supprimer les caractères de début et de fin, utilisez LEADING pour supprimer uniquement les caractères de début et utilisez TRAILING pour supprimer uniquement les caractères de fin. Si ce paramètre est omis, les caractères de début et de fin sont tronqués.
*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, Amazon Redshift convertit implicitement les résultats en `VARCHAR`. Si vous utilisez la fonction TRIM dans la liste SELECT dune fonction SQL et qu’Amazon Redshift ne convertit pas implicitement les résultats, vous devrez peut-être effectuer une conversion explicite pour éviter une erreur de décalage de type de données. Pour plus d’informations sur les conversions explicites, consultez les fonctions [Fonction CAST](r_CAST_function.md) et [Fonction CONVERT](r_CONVERT_function.md).
## Exemples
Pour tronquer les espaces de début et de fin de la chaîne ` dog `, utilisez l’exemple suivant.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Pour tronquer les espaces de début et de fin de la chaîne ` dog `, utilisez l’exemple suivant.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Pour supprimer les guillemets doubles ouvrants de la chaîne `"dog"`, utilisez l’exemple suivant.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Pour supprimer les guillemets doubles fermants de la chaîne `"dog"`, utilisez l’exemple suivant.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM supprime les caractères de *trim\$1chars* qui apparaissent au début ou à la fin de l’argument *string*. L’exemple suivant tronque les caractères « C », « D » et « G » lorsqu’ils figurent au début ou à la fin de VENUENAME, qui est une colonne `VARCHAR`. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T 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. Par exemple, la fonction renvoie une chaîne `VARCHAR` si l’entrée est une chaîne `VARCHAR`.
## Exemples
L’exemple suivant utilise les données de la table CATEGORY de l’exemple de base de données TICKIT. Pour plus d’informations, consultez [Exemple de base de données](c_sampledb.md).
Pour convertir le champ CATNAME en majuscules, utilisez ce qui suit.
```
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 |
+-----------+-----------+
```