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.

# Référence SQL pour Amazon S3 Select
<a name="s3-select-sql-reference"></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/) 

Cette référence contient une description des éléments du langage de recherche structurée (SQL) pris en charge par Amazon S3 Select.

**Topics**
+ [

# Commande SELECT
](s3-select-sql-reference-select.md)
+ [

# Types de données
](s3-select-sql-reference-data-types.md)
+ [

# Opérateurs
](s3-select-sql-reference-operators.md)
+ [

# Mots-clés réservés
](s3-select-sql-reference-keyword-list.md)
+ [

# Fonctions SQL
](s3-select-sql-reference-sql-functions.md)

# Commande SELECT
<a name="s3-select-sql-reference-select"></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 uniquement la commande SQL `SELECT`. Les clauses standard ANSI suivantes sont prises en charge pour `SELECT` : 


+ `SELECT` liste
+ `FROM`Clause 
+ `WHERE`Clause 
+ `LIMIT`Clause 

**Note**  
Les requêtes Amazon S3 Select ne prennent actuellement pas en charge les sous-requêtes ni les jointures.

## SELECT liste
<a name="s3-select-sql-reference-select-list"></a>

La liste `SELECT` nomme les colonnes, fonctions et expressions que la requête doit renvoyer. La liste représente le résultat de la requête. 

```
SELECT *
SELECT projection1 AS column_alias_1, projection2 AS column_alias_2
```

Le premier format `SELECT` avec `*` (astérisque) renvoie chaque ligne ayant transmis la clause `WHERE`, telle qu’elle. Le second format `SELECT` crée une ligne avec les expressions scalaires de sortie définies par l’utilisateur **`projection1`** et **`projection2`** pour chaque colonne.

## FROMClause
<a name="s3-select-sql-reference-from"></a>

Amazon S3 Select prend en charge les formes suivantes de la clause `FROM` :

```
FROM table_name
FROM table_name alias
FROM table_name AS alias
```

Dans chaque forme de la clause `FROM`, `table_name` est le `S3Object` qui est interrogé. Les utilisateurs provenant de bases de données relationnelles traditionnelles peuvent penser qu’il s’agit d’un schéma de base de données contenant plusieurs vues sur une table.

Dans le langage SQL standard, la clause `FROM` crée des lignes qui sont filtrées dans la clause `WHERE` et projetées dans la liste `SELECT`. 

Pour les objets JSON stockés dans Amazon S3 Select, vous pouvez également utiliser les formes suivantes de la clause `FROM` :

```
FROM S3Object[*].path
FROM S3Object[*].path alias
FROM S3Object[*].path AS alias
```

En utilisant cette forme de la clause `FROM`, vous pouvez effectuer une sélection dans les tableaux ou les objets contenus dans un objet JSON. Vous pouvez spécifier `path` en utilisant l’un des formats suivants :
+ Par nom (dans un objet) : `.name` ou `['name']`
+ Par index (dans un tableau) : `[index]`
+ Par caractère générique (dans un objet) : `.*`
+ Par caractère générique (dans un tableau) : `[*]`

**Note**  
Cette forme de la clause `FROM` fonctionne uniquement avec les objets JSON.
Les caractères génériques émettent toujours au moins un enregistrement. Si aucun enregistrement ne correspond, Amazon S3 Select émet la valeur `MISSING`. Pendant la sérialisation de la sortie (après que la requête a fini de s’exécuter), Amazon S3 Select remplace les valeurs `MISSING` par des enregistrements vides.
Les fonctions d’agrégation (`AVG`, `COUNT`, `MAX`, `MIN` et `SUM`) ignorent les valeurs `MISSING`.
Si, lorsque vous utilisez un caractère générique, vous n’indiquez pas d’alias, vous pouvez faire référence à la ligne en utilisant le dernier élément du chemin. Par exemple, vous pouvez sélectionner tous les prix d’une liste de livres en utilisant la requête `SELECT price FROM S3Object[*].books[*].price`. Si le chemin se termine par un caractère générique plutôt qu’un nom, vous pouvez utiliser la valeur `_1` pour faire référence à la ligne. Par exemple, à la place de `SELECT price FROM S3Object[*].books[*].price`, vous pouvez utiliser la requête `SELECT _1.price FROM S3Object[*].books[*]`.
Amazon S3 Select traite toujours un document JSON comme un tableau de valeurs de niveau racine. Par conséquent, même si l’objet JSON que vous interrogez ne contient qu’un seul élément racine, la clause `FROM` doit commencer par `S3Object[*]`. Toutefois, pour des raisons de compatibilité, Amazon S3 Select vous autorise à omettre le caractère générique si vous n’incluez pas de chemin. Ainsi, la clause complète `FROM S3Object` équivaut à `FROM S3Object[*] as S3Object`. Si vous incluez un chemin, vous devez également utiliser le caractère générique. Autrement dit, `FROM S3Object` et `FROM S3Object[*].path` sont deux clauses valides, mais pas `FROM S3Object.path`.

**Example**  
**Exemples :**  
*Exemple 1*  
Cet exemple affiche les résultats quand le jeu de données et la requête suivants sont utilisés :  

```
{ "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]}
{ "created": "June 27", "modified": "July 6" }
```

```
SELECT id FROM S3Object[*].Rules[*].id
```

```
{"id":"1"}
{}
{"id":"2"}
{}
```
Amazon S3 Select génère chaque résultat pour les raisons suivantes :  
+ `{"id":"id-1"}` : `S3Object[0].Rules[0].id` a produit une correspondance.
+ `{}` : `S3Object[0].Rules[1].id` n’a pas produit de correspondance. Amazon S3 Select a donc émis `MISSING`, qui a ensuite été changé en enregistrement vide pendant la sérialisation de la sortie avant d’être renvoyé.
+ `{"id":"id-2"}` : `S3Object[0].Rules[2].id` a produit une correspondance.
+ `{}` : `S3Object[1]` n’a pas produit de correspondance sur `Rules`. Amazon S3 Select a donc émis `MISSING`, qui a ensuite été changé en enregistrement vide pendant la sérialisation de la sortie avant d’être renvoyé.
Si vous ne voulez pas qu’Amazon S3 Select renvoie des enregistrements vides en l’absence de correspondance, vous pouvez faire un test avec la valeur `MISSING`. La requête suivante renvoie les mêmes résultats que la requête précédente, à la différence près que les valeurs vides sont omises :  

```
SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING
```

```
{"id":"1"}
{"id":"2"}
```
*Exemple 2*  
Cet exemple affiche les résultats quand le jeu de données et les requêtes suivants sont utilisés :  

```
{ "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" }
{ "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" }
```

```
SELECT d.dir_name, d.files FROM S3Object[*] d
```

```
{"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]}
{"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]}
```

```
SELECT _1.dir_name, _1.owner FROM S3Object[*]
```

```
{"dir_name":"important_docs","owner":"Amazon S3"}
{"dir_name":"other_docs","owner":"User"}
```

## WHEREClause
<a name="s3-select-sql-reference-where"></a>

La clause `WHERE` suit la syntaxe suivante : 

```
WHERE condition
```

La clause `WHERE` filtre les lignes en fonction de la `condition`. Une condition est une expression générant un résultat booléen. Seules les lignes pour lesquelles la condition a la valeur `TRUE` sont renvoyées dans les résultats.

## LIMITClause
<a name="s3-select-sql-reference-limit"></a>

La clause `LIMIT` suit la syntaxe suivante : 

```
LIMIT number
```

La clause `LIMIT` limite le nombre d’enregistrements que la requête devra renvoyer en fonction du `number`.

## Accès aux attributs
<a name="s3-select-sql-reference-attribute-access"></a>

Les clauses `SELECT` et `WHERE` peuvent faire référence à des enregistrements à l’aide d’une des méthodes présentées dans les sections suivantes, la méthode utilisée variant selon le format du fichier interrogé (CSV ou JSON).

### CSV
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **Numéros de colonne** : vous pouvez faire référence à la *Nième* colonne d’une ligne avec un nom de colonne `_N`, où *`N`* correspond à la position de la colonne. Le compte de la position commence à 1. Par exemple, la première colonne est appelée `_1` et la deuxième colonne est appelée `_2`.

  Vous pouvez faire référence à une colonne sous la forme `_N` ou `alias._N`. Par exemple, `_2` et `myAlias._2` sont deux manières valides de faire référence à une colonne de la liste `SELECT` et la clause `WHERE`.
+ **En-têtes de colonne** – Concernant les objets au format CSV ayant une ligne d’en-tête, les en-têtes sont disponibles pour la liste `SELECT` et la clause `WHERE`. Comme dans le SQL traditionnel, dans les expressions de clause `SELECT` et `WHERE`, vous pouvez faire référence aux colonnes via `alias.column_name` ou `column_name`.

### JSON
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **Document** – Vous pouvez accéder aux champs du document JSON sous la forme `alias.name`. Vous pouvez aussi accéder au champs imbriqués ; par exemple, `alias.name1.name2.name3`.
+ **Liste** : vous pouvez accéder aux éléments d’une liste JSON en utilisant des index de base zéro avec l’opérateur `[]`. Par exemple, vous pouvez accéder au second élément d’une liste sous la forme `alias[1]`. Vous pouvez combiner l’accès aux éléments de la liste avec des champs, par exemple, `alias.name1.name2[1].name3`.
+ **Exemples :** Considérez cet objet JSON comme un exemple de jeu de données :

  ```
  {"name": "Susan Smith",
  "org": "engineering",
  "projects":
      [
       {"project_name":"project1", "completed":false},
       {"project_name":"project2", "completed":true}
      ]
  }
  ```

  *Exemple 1*

  La requête suivante renvoie ces résultats :

  ```
  Select s.name from S3Object s
  ```

  ```
  {"name":"Susan Smith"}
  ```

  *Exemple 2*

  La requête suivante renvoie ces résultats :

  ```
  Select s.projects[0].project_name from S3Object s
  ```

  ```
  {"project_name":"project1"}
  ```

## Sensibilité à la casse des noms d’en-tête et d’attribut
<a name="s3-select-sql-reference-case-sensitivity"></a>

Avec Amazon S3 Select, vous pouvez utiliser des guillemets doubles pour indiquer que les en-têtes de colonne (pour les objets CSV) et les attributs (pour les objets JSON) sont sensibles à la casse. Sans guillemets doubles, les en-têtes et les attributs d’objet sont sensibles à la casse. Une erreur est envoyée en cas d’ambiguïté.

Les exemples suivants sont 1) des objets Amazon S3 au format CSV avec les en-têtes de colonne spécifiés et avec `FileHeaderInfo` défini sur `"Use"` pour la demande de requête ou 2) des objets Amazon S3 au format JSON avec les attributs spécifiés.

*Exemple n°1 :* l’objet interrogé possède l’en-tête ou l’attribut `NAME`.
+ L’expression suivante renvoie avec succès les valeurs de l’objet. Comme il n’y a pas de guillemets, la requête est sensible à la casse.

  ```
  SELECT s.name from S3Object s
  ```
+ L’expression suivante renvoie une erreur 400 `MissingHeaderName`. Comme il y a des guillemets, la requête est sensible à la casse. 

  ```
  SELECT s."name" from S3Object s
  ```

*Exemple n°2 :* l’objet Amazon S3 interrogé possède un en-tête ou un attribut avec `NAME` et un autre en-tête ou attribut avec `name`.
+ L'expression suivante renvoie une erreur 400 `AmbiguousFieldName`. Comme il n’y a pas de guillemets doubles, la requête est sensible à la casse, mais il y a deux correspondances : l’erreur est renvoyée.

  ```
  SELECT s.name from S3Object s
  ```
+ L'expression suivante renvoie avec succès les valeurs de l'objet. Comme il y a des guillemets, la requête est sensible à la casse sans qu’il y ait d’ambiguïté.

  ```
  SELECT s."NAME" from S3Object s
  ```

## Utilisation de mots-clés réservés comme termes définis par l’utilisateur
<a name="s3-select-sql-reference-using-keywords"></a>

Amazon S3 Select dispose d’un ensemble de mots-clés réservés nécessaires pour exécuter les expressions SQL utilisées pour interroger le contenu d’un objet. Les mots-clés réservés peuvent être des noms de fonctions, des types de données, des opérateurs, etc. Dans certains cas, les termes définis par l’utilisateur comme les en-têtes de colonnes (pour les fichiers CSV) ou les attributs (pour les objets JSON) peuvent entrer en conflit avec un mot-clé réservé. Lorsque cela se produit, vous devez utiliser des guillemets doubles pour indiquer que vous utilisez intentionnellement un terme défini par l’utilisateur qui est en conflit avec un mot-clé réservé. Si vous ne le faites pas, un erreur d’analyse 400 est émise.

Pour obtenir la liste complète des mots-clés réservés, consultez [Mots-clés réservés](s3-select-sql-reference-keyword-list.md).

L’exemple suivant est 1) un objet Amazon S3 au format CSV avec les en-têtes de colonne spécifiés et avec `FileHeaderInfo` défini sur `"Use"` pour la demande de requête ou 2) un objet Amazon S3 au format JSON avec les attributs spécifiés.

*Exemple :* l’objet interrogé possède un en-tête ou un attribut `CAST`, qui est un mot-clé réservé.
+ L'expression suivante renvoie avec succès les valeurs de l'objet. Comme les guillemets sont utilisés dans la requête, S3 Select utilise l’en-tête ou l’attribut défini par l’utilisateur.

  ```
  SELECT s."CAST" from S3Object s
  ```
+ L’expression suivante renvoie une erreur d’analyse 400. Comme aucun guillemet n’est utilisé dans la requête, `CAST` entre en conflit avec un mot-clé réservé.

  ```
  SELECT s.CAST from S3Object s
  ```

## Expressions scalaires
<a name="s3-select-sql-reference-scalar"></a>

Au sein de la clause `WHERE` et de la liste `SELECT`, vous pouvez disposez d’*expressions scalaires* SQL, qui sont des expressions qui renvoient des valeurs scalaires. Elles sont au format suivant :
+ ***`literal`*** 

  Littéral SQL. 
+ ***`column_reference`*** 

  Référence à une colonne au format `column_name` ou `alias.column_name`. 
+ **`unary_op`** **`expression`** 

  Dans ce cas, ****`unary_op`**** est un opérateur unaire SQL.
+ **`expression`** **`binary_op`** ***`expression`*** 

   Dans ce cas, ****`binary_op`**** est un opérateur binaire SQL. 
+ **`func_name`** 

   Dans ce cas, **`func_name`** est le nom de la fonction scalaire à invoquer. 
+ ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`****
+ ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]

# Types de données
<a name="s3-select-sql-reference-data-types"></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 plusieurs types de données primitifs.

## Conversions du type de données
<a name="s3-select-sql-reference-data-conversion"></a>

La règle générale consiste à suivre la fonction `CAST` si elle est définie. Si `CAST` n’est pas défini, toutes les données d’entrée sont considérées comme une chaîne. Dans ce cas, vous devez convertir vos données d’entrée dans les types de données concernés au besoin.

Pour plus d’informations sur la fonction `CAST`, consultez [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Types de données pris en charge
<a name="s3-select-sql-reference-supported-data-types"></a>

Amazon S3 Select prend en charge l’ensemble de types de données primitifs suivant.


|  Nom  |  Description  |  Exemples  | 
| --- | --- | --- | 
| `bool` | Une valeur booléenne, `TRUE` ou `FALSE`. | `FALSE` | 
| `int`, `integer` | Un entier signé sur 8 octets dans la plage -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807.  | `100000` | 
| `string` | Chaîne de UTF8 longueur variable codée. La limite par défaut est de un caractère. La limite de caractères maximale est de 2 147 483 647.  | `'xyz'` | 
| `float` | Un nombre à virgule flottante de 8 octets.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Un nombre de base 10, avec une précision maximale de 38 (c’est-à-dire, le nombre maximal de chiffres significatifs) et avec une échelle dans la plage de -231 à 231-1 (c’est-à-dire, l’exposant de base 10).  Amazon S3 Select ignore l’échelle et la précision lorsque vous fournissez les deux en même temps.   | `123.456 ` | 
| `timestamp` |  Les horodatages représentent un moment spécifique dans le temps, incluent toujours un décalage local, et sont capables de précision arbitraire. Dans le format de texte, les horodatages suivent la [remarque de W3C sur les formats de date et d’heure](https://www.w3.org/TR/NOTE-datetime), mais ils doivent se terminer par le `T` littéral si la précision des horodatages n’est pas d’une journée complète. Les fractions de seconde sont autorisées, avec une précision d’au moins un chiffre et un maximum illimité. Les décalages en heure locale peuvent être représentés sous forme de décalages heure:minute en UTC, ou en tant que `Z` littéral pour indiquer une heure locale en UTC. Les décalages en heure locale sont obligatoires sur les horodatages incluant l’heure et ne sont pas autorisés sur les valeurs de date.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Types Parquet pris en charge
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

Amazon S3 Select prend en charge les types Parquet suivants.
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**Note**  
Pour les sorties de type `LIST` Parquet, Amazon S3 Select ne prend en charge que le format JSON. Cependant, si la requête limite les données à des valeurs simples, le type `LIST` Parquet peut également être interrogé au format CSV.
+ `STRING`
+ Précision prise en charge par `TIMESTAMP` (`MILLIS`/`MICROS`/`NANOS`)
**Note**  
Les horodatages enregistrés au format `INT(96)` ne sont pas pris en charge.   
En raison de la plage du type `INT(64)`, les horodatages utilisant l’unité `NANOS` ne peuvent représenter que des valeurs comprises entre `1677-09-21 00:12:43` et `2262-04-11 23:47:16`. Les valeurs en dehors de cette plage ne peuvent pas être représentées par l’unité `NANOS`.

### Mappage des types Parquet aux types de données pris en charge dans Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Types Parquet | Types de données pris en charge | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Chaque type Parquet de la liste est mappé au type de données correspondant.  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

# Opérateurs
<a name="s3-select-sql-reference-operators"></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 opérateurs suivants.

## Opérateurs logiques
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Opérateurs de comparaison
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN` – Par exemple : `IN ('a', 'b', 'c')`

  

## Opérateurs de correspondance de modèles
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (met en correspondance n’importe quel caractère)
+ `%` (met en correspondance n’importe quelle séquence de caractères)

## Opérateurs unaires
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Opérateurs mathématiques
<a name="s3-select-sql-referencemath-ops"></a>

L’addition, la soustraction, la multiplication, la division et les opérateurs modulo sont pris en charge, comme suit :
+ \$1
+ -
+ \$1
+ /
+ %

## Priorité des opérateurs
<a name="s3-select-sql-reference-op-Precedence"></a>

Le tableau suivant indique la priorité des opérateurs par ordre décroissant.


|  Opérateur ou élément  |  Associativité |  Obligatoire  | 
| --- | --- | --- | 
| `-`  | droite  | moins unaire  | 
| `*`, `/`, `%`  | gauche  | multiplication, division, opérateur modulo  | 
| `+`, `-`  | gauche  | addition, soustraction  | 
| `IN` |  | appartenance à un ensemble  | 
| `BETWEEN` |  | limitation à une plage  | 
| `LIKE` |  | mise en correspondance de modèle de chaîne  | 
| `<``>` |  | inférieur à, supérieur à  | 
| `=` | droite  | égalité, affectation | 
| `NOT` | droite | négation logique  | 
| `AND` | gauche | conjonction logique  | 
| `OR` | gauche | disjonction logique  | 

# Mots-clés réservés
<a name="s3-select-sql-reference-keyword-list"></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/) 

Voici la liste des mots-clés réservés pour Amazon S3 Select. Ces mot-clés comprennent des noms de fonctions, des types de données, des opérateurs, etc. nécessaires pour exécuter les expressions SQL utilisées pour interroger le contenu d’un objet.

```
absolute
action
add
all
allocate
alter
and
any
are
as
asc
assertion
at
authorization
avg
bag
begin
between
bit
bit_length
blob
bool
boolean
both
by
cascade
cascaded
case
cast
catalog
char
char_length
character
character_length
check
clob
close
coalesce
collate
collation
column
commit
connect
connection
constraint
constraints
continue
convert
corresponding
count
create
cross
current
current_date
current_time
current_timestamp
current_user
cursor
date
day
deallocate
dec
decimal
declare
default
deferrable
deferred
delete
desc
describe
descriptor
diagnostics
disconnect
distinct
domain
double
drop
else
end
end-exec
escape
except
exception
exec
execute
exists
external
extract
false
fetch
first
float
for
foreign
found
from
full
get
global
go
goto
grant
group
having
hour
identity
immediate
in
indicator
initially
inner
input
insensitive
insert
int
integer
intersect
interval
into
is
isolation
join
key
language
last
leading
left
level
like
limit
list
local
lower
match
max
min
minute
missing
module
month
names
national
natural
nchar
next
no
not
null
nullif
numeric
octet_length
of
on
only
open
option
or
order
outer
output
overlaps
pad
partial
pivot
position
precision
prepare
preserve
primary
prior
privileges
procedure
public
read
real
references
relative
restrict
revoke
right
rollback
rows
schema
scroll
second
section
select
session
session_user
set
sexp
size
smallint
some
space
sql
sqlcode
sqlerror
sqlstate
string
struct
substring
sum
symbol
system_user
table
temporary
then
time
timestamp
timezone_hour
timezone_minute
to
trailing
transaction
translate
translation
trim
true
tuple
union
unique
unknown
unpivot
update
upper
usage
user
using
value
values
varchar
varying
view
when
whenever
where
with
work
write
year
zone
```

# 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!@#$'
```