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 SQL
<a name="s3-select-sql-reference-sql-functions"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge les fonctions SQL suivantes.

**Topics**
+ [Fonctions d’agrégation](s3-select-sql-reference-aggregate.md)
+ [Fonctions conditionnelles](s3-select-sql-reference-conditional.md)
+ [Fonctions de conversion](s3-select-sql-reference-conversion.md)
+ [Fonctions de date](s3-select-sql-reference-date.md)
+ [Fonctions de chaîne](s3-select-sql-reference-string.md)

# Fonctions d’agrégation
<a name="s3-select-sql-reference-aggregate"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge les fonctions d’agrégation suivantes.


| Fonction | Type d’argument | Type de retour | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` pour un argument `INT`, `FLOAT` pour un argument de virgule flottante ; sinon, la même chose que le type de données d’argument. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | Identique au type d’arguments. | 
| `MIN(expression)` | `INT`, `DECIMAL` | Identique au type d’arguments. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` pour un argument `INT`, `FLOAT` pour un argument de virgule flottante ; sinon, la même chose que le type de données d’argument. | 

## Exemple de SUM
<a name="s3-select-sql-reference-aggregate-case-examples"></a>

Pour agréger la taille totale des objets d’un dossier dans un [rapport S3 Inventory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html), utilisez une expression `SUM`.

Le rapport S3 Inventory suivant est un fichier CSV compressé avec GZIP. Il comprend trois colonnes.
+ La première colonne est le nom du compartiment S3 (*`DOC-EXAMPLE-BUCKET`*) auquel le rapport S3 Inventory est destiné.
+ La deuxième colonne est le nom de clé d’objet qui identifie de façon unique l’objet dans le compartiment.

  La valeur `example-folder/` de la première ligne correspond au dossier `example-folder`. Dans Amazon S3, lorsque vous créez un dossier dans votre compartiment, S3 crée un objet de 0 octet dont la clé est définie par le nom de dossier que vous avez fourni.

  La valeur `example-folder/object1` de la deuxième ligne correspond à l’objet `object1` du dossier `example-folder`.

  La valeur `example-folder/object2` de la troisième ligne correspond à l’objet `object2` du dossier `example-folder`.

  Pour plus d’informations sur les dossiers S3, consultez [Organisation des objets dans la console Amazon S3 à l’aide de dossiers](using-folders.md).
+ La troisième colonne renvoie la taille des objets en octets.

```
"DOC-EXAMPLE-BUCKET","example-folder/","0"
"DOC-EXAMPLE-BUCKET","example-folder/object1","2011267"
"DOC-EXAMPLE-BUCKET","example-folder/object2","1570024"
```

Pour utiliser une expression `SUM` afin de calculer la taille totale du dossier `example-folder`, exécutez la requête SQL avec Amazon S3 Select.

```
SELECT SUM(CAST(_3 as INT)) FROM s3object s WHERE _2 LIKE 'example-folder/%' AND _2 != 'example-folder/';
```

Résultat de la requête : 

```
3581291
```

# Fonctions conditionnelles
<a name="s3-select-sql-reference-conditional"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge les fonctions conditionnelles suivantes.

**Topics**
+ [CASE](#s3-select-sql-reference-case)
+ [COALESCE](#s3-select-sql-reference-coalesce)
+ [NULLIF](#s3-select-sql-reference-nullif)

## CASE
<a name="s3-select-sql-reference-case"></a>

L’expression `CASE` est une expression conditionnelle similaire aux instructions `if/then/else` trouvées dans d’autres langues. `CASE` est utilisé pour spécifier un résultat lorsqu’il y a plusieurs conditions. Il existe deux types d’expressions `CASE` : simple et recherchée.

Dans les expressions `CASE` simples, une expression est comparée à une valeur. Lorsqu’une correspondance est trouvée, l’action spécifiée dans la clause `THEN` est appliquée. Si aucune correspondance n’est trouvée, l’action de la clause `ELSE` est appliquée.

Dans les expressions `CASE` recherchées, chaque `CASE` est évaluée en fonction d’une expression booléenne et l’instruction `CASE` renvoie la première expression `CASE` correspondante. Si aucune correspondance `CASE` n’est trouvée parmi les clauses `WHEN`, l’action contenue dans la clause `ELSE` est renvoyée.

### Syntaxe
<a name="s3-select-sql-reference-case-syntax"></a>

**Note**  
Actuellement, Amazon S3 Select ne prend pas en charge `ORDER BY` ou les requêtes contenant de nouvelles lignes. Veillez à utiliser des requêtes sans saut de ligne.

Voici une instruction `CASE` simple qui est utilisée pour faire correspondre les conditions :

```
CASE expression WHEN value THEN result [WHEN...] [ELSE result] END					
```

Voici une instruction `CASE` recherchée utilisée pour évaluer chaque condition :

```
CASE WHEN boolean condition THEN result [WHEN ...] [ELSE result] END					
```

### Exemples
<a name="s3-select-sql-reference-case-examples"></a>

**Note**  
Si vous utilisez la console Amazon S3 pour exécuter les exemples suivants et que votre fichier CSV contient une ligne d’en-tête, sélectionnez **Exclure la première ligne de données CSV**. 

**Exemple 1 :** utilisez une simple expression `CASE` pour remplacer `New York City` par `Big Apple` dans une requête. Remplacer tous les autres noms de villes par `other`.

```
SELECT venuecity, CASE venuecity WHEN 'New York City' THEN 'Big Apple' ELSE 'other' END FROM S3Object;
```

Résultat de la requête : 

```
venuecity        |   case
-----------------+-----------
Los Angeles      | other
New York City    | Big Apple
San Francisco    | other
Baltimore        | other
...
```

**Exemple 2 :** utilisez une expression `CASE` recherchée pour affecter des numéros de groupes basés sur la valeur `pricepaid` pour les ventes de billets individuels :

```
SELECT pricepaid, CASE WHEN CAST(pricepaid as FLOAT) < 10000 THEN 'group 1' WHEN CAST(pricepaid as FLOAT) > 10000 THEN 'group 2' ELSE 'group 3' END FROM S3Object;					
```

Résultat de la requête : 

```
pricepaid |  case
-----------+---------
12624.00 | group 2
10000.00 | group 3
10000.00 | group 3
9996.00 | group 1
9988.00 | group 1
...
```

## COALESCE
<a name="s3-select-sql-reference-coalesce"></a>

`COALESCE` évalue les arguments dans l’ordre et renvoie la première valeur non inconnue, c’est-à-dire la première valeur non nulle ou non manquante. Cette fonction ne propage pas les valeurs nulles ou manquantes.

### Syntaxe
<a name="s3-select-sql-reference-coalesce-syntax"></a>

```
COALESCE ( expression, expression, ... )
```

### Parameters
<a name="s3-select-sql-reference-coalesce-parameters"></a>

 *`expression`*   
Expression cible sur laquelle la fonction opère.

### Exemples
<a name="s3-select-sql-reference-coalesce-examples"></a>

```
COALESCE(1)                -- 1
COALESCE(null)             -- null
COALESCE(null, null)       -- null
COALESCE(missing)          -- null
COALESCE(missing, missing) -- null
COALESCE(1, null)          -- 1
COALESCE(null, null, 1)    -- 1
COALESCE(null, 'string')   -- 'string'
COALESCE(missing, 1)       -- 1
```

## NULLIF
<a name="s3-select-sql-reference-nullif"></a>

Pour deux expressions données, `NULLIF` renvoie `NULL` si les deux expressions ont la même valeur. Sinon, `NULLIF` renvoie le résultat de l’évaluation de la première expression.

### Syntaxe
<a name="s3-select-sql-reference-nullif-syntax"></a>

```
NULLIF ( expression1, expression2 )
```

### Parameters
<a name="s3-select-sql-reference-nullif-parameters"></a>

 `expression1, expression2`   
Expressions cible sur lesquelles la fonction opère.

### Exemples
<a name="s3-select-sql-reference-nullif-examples"></a>

```
NULLIF(1, 1)             -- null
NULLIF(1, 2)             -- 1
NULLIF(1.0, 1)           -- null
NULLIF(1, '1')           -- 1
NULLIF([1], [1])         -- null
NULLIF(1, NULL)          -- 1
NULLIF(NULL, 1)          -- null
NULLIF(null, null)       -- null
NULLIF(missing, null)    -- null
NULLIF(missing, missing) -- null
```

# Fonctions de conversion
<a name="s3-select-sql-reference-conversion"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge la fonction conversationnelle suivante.

**Topics**
+ [CAST](#s3-select-sql-reference-cast)

## CAST
<a name="s3-select-sql-reference-cast"></a>

La fonction `CAST` convertit une entité, comme une expression analysée comme valeur unique, d’un type à un autre. 

### Syntaxe
<a name="s3-select-sql-reference-cast-syntax"></a>

```
CAST ( expression AS data_type )
```

### Parameters
<a name="s3-select-sql-reference-cast-parameters"></a>

 *`expression`*   
Combinaison d’un(e) ou de plusieurs valeurs, opérateurs ou fonctions SQL qui correspondent à une valeur.

 *`data_type`*   
Type de données cible, comme `INT`, dans lequel imbriquer l’expression. Pour afficher la liste des types de données pris en charge, consultez [Types de données](s3-select-sql-reference-data-types.md).

### Exemples
<a name="s3-select-sql-reference-cast-examples"></a>

```
CAST('2007-04-05T14:30Z' AS TIMESTAMP)
CAST(0.456 AS FLOAT)
```

# Fonctions de date
<a name="s3-select-sql-reference-date"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge les fonctions de date suivantes.

**Topics**
+ [DATE\$1ADD](#s3-select-sql-reference-date-add)
+ [DATE\$1DIFF](#s3-select-sql-reference-date-diff)
+ [EXTRACT](#s3-select-sql-reference-extract)
+ [TO\$1STRING](#s3-select-sql-reference-to-string)
+ [TO\$1TIMESTAMP](#s3-select-sql-reference-to-timestamp)
+ [UTCNOW](#s3-select-sql-reference-utcnow)

## DATE\$1ADD
<a name="s3-select-sql-reference-date-add"></a>

À partir d’une partie de date, d’une quantité et d’un horodatage donnés, `DATE_ADD` renvoie un horodatage mis à jour en remplaçant la partie de date par la quantité.

### Syntaxe
<a name="s3-select-sql-reference-date-add-syntax"></a>

```
DATE_ADD( date_part, quantity, timestamp )
```

### Parameters
<a name="s3-select-sql-reference-date-add-parameters"></a>

*`date_part`*   
Spécifie quelle partie de la date modifier. Il peut s’agir de l’une des parties suivantes :  
+ year
+ month
+ day
+ hour
+ minute
+ second

 *`quantity`*   
Valeur à appliquer à l’horodatage mis à jour. Les valeurs positives de `quantity` s’ajoutent à l’élément date\$1part de l’horodatage et les valeurs négatives se soustraient.

 *`timestamp`*   
Horodatage cible sur lequel la fonction opère.

### Exemples
<a name="s3-select-sql-reference-date-add-examples"></a>

```
DATE_ADD(year, 5, `2010-01-01T`)                -- 2015-01-01 (equivalent to 2015-01-01T)
DATE_ADD(month, 1, `2010T`)                     -- 2010-02T (result will add precision as necessary)
DATE_ADD(month, 13, `2010T`)                    -- 2011-02T
DATE_ADD(day, -1, `2017-01-10T`)                -- 2017-01-09 (equivalent to 2017-01-09T)
DATE_ADD(hour, 1, `2017T`)                      -- 2017-01-01T01:00-00:00
DATE_ADD(hour, 1, `2017-01-02T03:04Z`)          -- 2017-01-02T04:04Z
DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
```

## DATE\$1DIFF
<a name="s3-select-sql-reference-date-diff"></a>

À partir d’une partie de date et de deux horodatages valides donnés, `DATE_DIFF` renvoie la différence entre les parties de date. La valeur renvoyée est un entier négatif lorsque la valeur `date_part` de `timestamp1` est supérieure à la valeur `date_part` de `timestamp2`. La valeur renvoyée est un entier positif lorsque la valeur `date_part` de `timestamp1` est inférieure à la valeur `date_part` de `timestamp2`.

### Syntaxe
<a name="s3-select-sql-reference-date-diff-syntax"></a>

```
DATE_DIFF( date_part, timestamp1, timestamp2 )
```

### Parameters
<a name="s3-select-sql-reference-date-diff-parameters"></a>

 **`date_part`**   
Spécifie la partie des horodatages à comparer. Pour obtenir la définition de `date_part`, consultez [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
Premier horodatage à comparer.

 **`timestamp2`**   
Deuxième horodatage à comparer.

### Exemples
<a name="s3-select-sql-reference-date-diff-examples"></a>

```
DATE_DIFF(year, `2010-01-01T`, `2011-01-01T`)            -- 1
DATE_DIFF(year, `2010T`, `2010-05T`)                     -- 4 (2010T is equivalent to 2010-01-01T00:00:00.000Z)
DATE_DIFF(month, `2010T`, `2011T`)                       -- 12
DATE_DIFF(month, `2011T`, `2010T`)                       -- -12
DATE_DIFF(day, `2010-01-01T23:00`, `2010-01-02T01:00`) -- 0 (need to be at least 24h apart to be 1 day apart)
```

## EXTRACT
<a name="s3-select-sql-reference-extract"></a>

À partir d’une partie de date et d’un horodatage donnés, `EXTRACT` renvoie la valeur de la partie de date de l’horodatage.

### Syntaxe
<a name="s3-select-sql-reference-extract-syntax"></a>

```
EXTRACT( date_part FROM timestamp )
```

### Parameters
<a name="s3-select-sql-reference-extract-parameters"></a>

 **`date_part`**   
Spécifie la partie des horodatages à extraire. Il peut s’agir de l’une des parties suivantes :  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
Horodatage cible sur lequel la fonction opère.

### Exemples
<a name="s3-select-sql-reference-extract-examples"></a>

```
EXTRACT(YEAR FROM `2010-01-01T`)                           -- 2010
EXTRACT(MONTH FROM `2010T`)                                -- 1 (equivalent to 2010-01-01T00:00:00.000Z)
EXTRACT(MONTH FROM `2010-10T`)                             -- 10
EXTRACT(HOUR FROM `2017-01-02T03:04:05+07:08`)             -- 3
EXTRACT(MINUTE FROM `2017-01-02T03:04:05+07:08`)           -- 4
EXTRACT(TIMEZONE_HOUR FROM `2017-01-02T03:04:05+07:08`)    -- 7
EXTRACT(TIMEZONE_MINUTE FROM `2017-01-02T03:04:05+07:08`)  -- 8
```

## TO\$1STRING
<a name="s3-select-sql-reference-to-string"></a>

À partir d’un horodatage et d’un modèle de format donnés, `TO_STRING` renvoie une représentation sous forme de chaîne de l’horodatage au format donné.

### Syntaxe
<a name="s3-select-sql-reference-size-syntax"></a>

```
TO_STRING ( timestamp time_format_pattern )
```

### Parameters
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
Horodatage cible sur lequel la fonction opère.

 *`time_format_pattern`*   
Chaîne qui possède les interprétations de caractères spéciaux suivantes :      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Exemples
<a name="s3-select-sql-reference-size-examples"></a>

```
TO_STRING(`1969-07-20T20:18Z`,  'MMMM d, y')                    -- "July 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMM d, yyyy')                   -- "Jul 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'M-d-yy')                        -- "7-20-69"
TO_STRING(`1969-07-20T20:18Z`, 'MM-d-y')                        -- "07-20-1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMMM d, y h:m a')               -- "July 20, 1969 8:18 PM"
TO_STRING(`1969-07-20T20:18Z`, 'y-MM-dd''T''H:m:ssX')           -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00Z`, 'y-MM-dd''T''H:m:ssX')     -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXX')   -- "1969-07-20T20:18:00+0800"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T20:18:00+08:00"
```

## TO\$1TIMESTAMP
<a name="s3-select-sql-reference-to-timestamp"></a>

À partir d’une chaîne donnée, `TO_TIMESTAMP` le convertit en un horodatage. `TO_TIMESTAMP` est l’opération inverse de `TO_STRING`.

### Syntaxe
<a name="s3-select-sql-reference-to-timestamp-syntax"></a>

```
TO_TIMESTAMP ( string )
```

### Parameters
<a name="s3-select-sql-reference-to-timestamp-parameters"></a>

 *`string`*   
Chaîne cible sur laquelle la fonction opère.

### Exemples
<a name="s3-select-sql-reference-to-timestamp-examples"></a>

```
TO_TIMESTAMP('2007T')                         -- `2007T`
TO_TIMESTAMP('2007-02-23T12:14:33.079-08:00') -- `2007-02-23T12:14:33.079-08:00`
```

## UTCNOW
<a name="s3-select-sql-reference-utcnow"></a>

`UTCNOW` renvoie l’heure actuelle au format UTC sous forme d’horodatage.

### Syntaxe
<a name="s3-select-sql-reference-utcnow-syntax"></a>

```
UTCNOW()
```

### Parameters
<a name="s3-select-sql-reference-utcnow-parameters"></a>

`UTCNOW` n’accepte aucun paramètre.

### Exemples
<a name="s3-select-sql-reference-utcnow-examples"></a>

```
UTCNOW() -- 2017-10-13T16:02:11.123Z
```

# Fonctions de chaîne
<a name="s3-select-sql-reference-string"></a>

**Important**  
Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) 

Amazon S3 Select prend en charge les fonctions de chaîne suivantes.

**Topics**
+ [CHAR\$1LENGTH, CHARACTER\$1LENGTH](#s3-select-sql-reference-char-length)
+ [LOWER](#s3-select-sql-reference-lower)
+ [SUBSTRING](#s3-select-sql-reference-substring)
+ [TRIM](#s3-select-sql-reference-trim)
+ [UPPER](#s3-select-sql-reference-upper)

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
<a name="s3-select-sql-reference-char-length"></a>

`CHAR_LENGTH` (ou `CHARACTER_LENGTH`) compte le nombre de caractères dans la chaîne spécifiée.

**Note**  
`CHAR_LENGTH` et `CHARACTER_LENGTH` sont synonymes.

### Syntaxe
<a name="s3-select-sql-reference-char-length-syntax"></a>

```
CHAR_LENGTH ( string )
```

### Parameters
<a name="s3-select-sql-reference-char-length-parameters"></a>

 *`string`*   
Chaîne cible sur laquelle la fonction opère.

### Exemples
<a name="s3-select-sql-reference-char-length-examples"></a>

```
CHAR_LENGTH('')          -- 0
CHAR_LENGTH('abcdefg')   -- 7
```

## LOWER
<a name="s3-select-sql-reference-lower"></a>

À partir d’une chaîne donnée, `LOWER` convertit tous les caractères majuscules en minuscules. Les caractères qui ne sont pas en majuscules restent inchangés.

### Syntaxe
<a name="s3-select-sql-reference-lower-syntax"></a>

```
LOWER ( string )
```

### Parameters
<a name="s3-select-sql-reference-lower-parameters"></a>

 **`string`**   
Chaîne cible sur laquelle la fonction opère.

### Exemples
<a name="s3-select-sql-reference-lower-examples"></a>

```
LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
```

## SUBSTRING
<a name="s3-select-sql-reference-substring"></a>

À partir d’une chaîne, d’un index de début et éventuellement d’une longueur donnés, `SUBSTRING` renvoie la sous-chaîne de l’index de début à la fin de la chaîne ou à la fin de la longueur précisée.

**Note**  
Le premier caractère de la chaîne d’entrée possède la position d’index 1.  
 Si `start` est < 1, sans longueur spécifiée, la position d’index est définie sur 1. 
 Si `start` est < 1, avec une longueur spécifiée, la position d’index est définie sur `start + length -1`. 
 Si `start + length -1` est < 0, une chaîne vide est renvoyée. 
 Si `start + length -1` est > = 0, la sous-chaîne commençant à la position d’index 1 dont la longueur est `start + length - 1` est renvoyée. 

### Syntaxe
<a name="s3-select-sql-reference-substring-syntax"></a>

```
SUBSTRING( string FROM start [ FOR length ] )
```

### Parameters
<a name="s3-select-sql-reference-substring-parameters"></a>

 **`string`**   
Chaîne cible sur laquelle la fonction opère.

 **`start`**   
Position de début de la chaîne.

 **`length`**   
Longueur de la sous-chaîne à renvoyer. En cas d’absence du paramètre, le traitement s’effectue jusqu’à la fin de la chaîne.

### Exemples
<a name="s3-select-sql-reference-substring-examples"></a>

```
SUBSTRING("123456789", 0)      -- "123456789"
SUBSTRING("123456789", 1)      -- "123456789"
SUBSTRING("123456789", 2)      -- "23456789"
SUBSTRING("123456789", -4)     -- "123456789"
SUBSTRING("123456789", 0, 999) -- "123456789" 
SUBSTRING("123456789", 1, 5)   -- "12345"
```

## TRIM
<a name="s3-select-sql-reference-trim"></a>

Supprime les caractères de tête ou de fin d’une chaîne. Le caractère par défaut à supprimer est un espace (`' '`).

### Syntaxe
<a name="s3-select-sql-reference-trim-syntax"></a>

```
TRIM ( [[LEADING | TRAILING | BOTH remove_chars] FROM] string )
```

### Parameters
<a name="s3-select-sql-reference-trim-parameters"></a>

 **`string`**   
Chaîne cible sur laquelle la fonction opère.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Ce paramètre indique s’il faut supprimer les caractères de tête ou de fin ou les deux.

 **`remove_chars`**   
Jeu de caractères à supprimer. `remove_chars` peut être une chaîne de longueur > 1. Cette fonction renvoie la chaîne avec n’importe quel caractère de `remove_chars` se trouvant au début ou à la fin de la chaîne qui a été supprimée.

### Exemples
<a name="s3-select-sql-reference-trim-examples"></a>

```
TRIM('       foobar         ')               -- 'foobar'
TRIM('      \tfoobar\t         ')            -- '\tfoobar\t'
TRIM(LEADING FROM '       foobar         ')  -- 'foobar         '
TRIM(TRAILING FROM '       foobar         ') -- '       foobar'
TRIM(BOTH FROM '       foobar         ')     -- 'foobar'
TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
```

## UPPER
<a name="s3-select-sql-reference-upper"></a>

À partir d’une chaîne donnée, `UPPER` convertit tous les caractères minuscules en majuscules. Les caractères qui ne sont pas en minuscules restent inchangés.

### Syntaxe
<a name="s3-select-sql-reference-upper-syntax"></a>

```
UPPER ( string )
```

### Parameters
<a name="s3-select-sql-reference-upper-parameters"></a>

 **`string`**   
Chaîne cible sur laquelle la fonction opère.

### Exemples
<a name="s3-select-sql-reference-upper-examples"></a>

```
UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
```