', default: (\)
```
Lors de l'exportation des données au format CSV, ce champ indique le caractère qui doit être traité comme un caractère d'échappement dans le fichier de données écrit dans le compartiment S3. L'évasion se produit dans les scénarios suivants :
1. Si la valeur elle-même contient le caractère guillemet («), elle sera échappée à l'aide d'un caractère d'échappement. Par exemple, si la valeur est`Time"stream`, où (\$1) est le caractère d'échappement configuré, il sera échappé en tant que`Time\"stream`.
1. Si la valeur contient le caractère d'échappement configuré, il sera échappé. Par exemple, si la valeur est`Time\stream`, elle sera ignorée en tant que`Time\\stream`.
Si la sortie exportée contient des types de données complexes tels que des tableaux, des lignes ou des séries temporelles, elle sera sérialisée sous forme de chaîne JSON. Voici un exemple.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1EN-TÊTE
```
include_header = 'true' , default: 'false'
```
Lorsque vous exportez les données au format CSV, ce champ vous permet d'inclure les noms de colonnes dans la première ligne des fichiers de données CSV exportés.
Les valeurs acceptées sont « vrai » et « faux » et la valeur par défaut est « faux ». Les options de transformation de texte telles que `escaped_by` et `field_delimiter` s'appliquent également aux en-têtes.
Lorsque vous incluez des en-têtes, il est important de ne pas sélectionner un caractère de renvoi (ASCII 13, hexadécimal 0D, texte « \$1 r ») ou un caractère de saut de ligne (ASCII 10, hexadécimal 0A, texte «\$1n»)`FIELD_DELIMITER`, car cela empêcherait de nombreux analyseurs d'analyser correctement les en-têtes dans la sortie CSV résultante.
TAILLE MAXIMALE DU FICHIER
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Ce champ indique la taille maximale des fichiers créés par l'`UNLOAD`instruction dans Amazon S3. L'`UNLOAD`instruction peut créer plusieurs fichiers, mais la taille maximale de chaque fichier écrit sur Amazon S3 sera approximativement celle spécifiée dans ce champ.
La valeur du champ doit être comprise entre 16 Mo et 78 Go inclus. Vous pouvez le spécifier en nombre entier tel que`12GB`, ou en décimaux tels que `0.5GB` ou. `24.7MB` La valeur par défaut est de 78 Go.
La taille réelle du fichier est approximative au moment de l'écriture du fichier, de sorte que la taille maximale réelle peut ne pas être exactement égale au nombre que vous spécifiez.
# Opérateurs logiques
Timestream for LiveAnalytics prend en charge les opérateurs logiques suivants.
| Opérateur | Description | Exemple |
| --- | --- | --- |
| AND | Vrai si les deux valeurs sont vraies | a ET b |
| OU | Vrai si l'une des valeurs est vraie | a OU b |
| NOT | Vrai si la valeur est fausse | PAS un |
+ Le résultat d'une `AND` comparaison peut être `NULL` si l'un ou les deux côtés de l'expression le sont`NULL`.
+ Si au moins un côté d'un `AND` opérateur est, `FALSE` l'expression est évaluée à`FALSE`.
+ Le résultat d'une `OR` comparaison peut être `NULL` si l'un ou les deux côtés de l'expression le sont`NULL`.
+ Si au moins un côté d'un `OR` opérateur est, `TRUE` l'expression est évaluée à`TRUE`.
+ `NULL`C'est le complément logique`NULL`.
Le tableau de vérité suivant illustre le traitement de `NULL` in `AND` et `OR` :
| A | B | A et b | A ou b |
| --- | --- | --- | --- |
| null | null | null | null |
| false | null | false | null |
| null | false | false | null |
| true | null | null | true |
| null | true | null | vrai |
| false | false | false | false |
| vrai | false | false | vrai |
| false | vrai | false | true |
| true | true | true | true |
Le tableau de vérité suivant illustre le traitement de NULL dans NOT :
| A | Ce n'est pas un |
| --- | --- |
| null | null |
| vrai | false |
| false | true |
# Opérateurs de comparaison
Timestream for LiveAnalytics prend en charge les opérateurs de comparaison suivants.
| Opérateur | Description |
| --- | --- |
| < | Inférieur à |
| > | Supérieur à |
| <= | Inférieur ou égal à |
| >= | Supérieur ou égal à |
| = | Égal à |
| <> | Non égal à |
| \$1= | Non égal à |
**Note**
L'`BETWEEN`opérateur vérifie si une valeur se situe dans une plage spécifiée. La syntaxe est la suivante :
```
BETWEEN min AND max
```
La présence de la `NOT BETWEEN` mention `NULL` in a `BETWEEN` or fera en sorte que l'instruction soit évaluée à`NULL`.
`IS NULL `et `IS NOT NULL` les opérateurs vérifient si une valeur est nulle (non définie). L'utilisation `NULL` de with `IS NULL` donne la valeur true.
En SQL, une `NULL` valeur signifie une valeur inconnue.
# Fonctions de comparaison
Timestream for LiveAnalytics prend en charge les fonctions de comparaison suivantes.
**Topics**
+ [
# le plus grand ()
](comparison-functions.greatest.md)
+ [
# le moins ()
](comparison-functions.least.md)
+ [
# TOUS (), TOUS () et CERTAINS ()
](comparison-functions.all-any-some.md)
# le plus grand ()
La fonction **greatest ()** renvoie la plus grande des valeurs fournies. Elle renvoie `NULL` si l'une des valeurs fournies l'est`NULL`. La syntaxe est la suivante.
```
greatest(value1, value2, ..., valueN)
```
# le moins ()
La fonction **least ()** renvoie la plus petite des valeurs fournies. Elle renvoie `NULL` si l'une des valeurs fournies l'est`NULL`. La syntaxe est la suivante.
```
least(value1, value2, ..., valueN)
```
# TOUS (), TOUS () et CERTAINS ()
Les `ALL` `SOME` quantificateurs `ANY` et peuvent être utilisés conjointement avec les opérateurs de comparaison de la manière suivante.
| Expression | Signification |
| --- | --- |
| A = TOUS (...) | Est considéré comme vrai lorsque A est égal à toutes les valeurs. |
| A <> TOUS (...) | Est considéré comme vrai lorsque A ne correspond à aucune valeur. |
| A < TOUS (...) | Est considéré comme vrai lorsque A est inférieur à la plus petite valeur. |
| A = N'IMPORTE LEQUEL (...) | Est considéré comme vrai lorsque A est égal à l'une des valeurs. |
| A <> N'IMPORTE QUEL (...) | Est considéré comme vrai lorsque A ne correspond pas à une ou plusieurs valeurs. |
| A < N'IMPORTE QUEL (...) | Est considéré comme vrai lorsque A est inférieur à la valeur la plus élevée. |
## Exemples et notes d'utilisation
**Note**
Lorsque vous utilisez `ANY` ou `ALL``SOME`, le mot clé `VALUES` doit être utilisé si les valeurs de comparaison sont une liste de littéraux.
## Exemple : `ANY()`
Voici un exemple de requête `ANY()` dans une instruction de requête.
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
Une syntaxe alternative pour la même opération est la suivante.
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
Dans ce cas, est `ANY()` évalué à. `True`
## Exemple : `ALL()`
Voici un exemple de requête `ALL()` dans une instruction de requête.
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
Une syntaxe alternative pour la même opération est la suivante.
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
Dans ce cas, est `ALL()` évalué à. `False`
## Exemple : `SOME()`
Voici un exemple de requête `SOME()` dans une instruction de requête.
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
Une syntaxe alternative pour la même opération est la suivante.
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
Dans ce cas, est `SOME()` évalué à. `True`
# Expressions conditionnelles
Timestream for LiveAnalytics prend en charge les expressions conditionnelles suivantes.
**Topics**
+ [
# La déclaration CASE
](conditional-expressions.CASE.md)
+ [
# La déclaration IF
](conditional-expressions.IF.md)
+ [
# La déclaration COALESCE
](conditional-expressions.COALESCE.md)
+ [
# La déclaration NULLIF
](conditional-expressions.NULLIF.md)
+ [
# La déclaration TRY
](conditional-expressions.TRY.md)
# La déclaration CASE
L'instruction **CASE** recherche chaque expression de valeur de gauche à droite jusqu'à ce qu'elle en trouve une égale`expression`. S'il trouve une correspondance, le résultat correspondant à la valeur correspondante est renvoyé. Si aucune correspondance n'est trouvée, le résultat de la `ELSE` clause est renvoyé s'il existe ; dans le cas contraire, il `null` est renvoyé. La syntaxe est la suivante :
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
Timestream prend également en charge la syntaxe suivante pour les instructions **CASE**. Dans cette syntaxe, le formulaire « recherché » évalue chaque condition booléenne de gauche à droite jusqu'à ce qu'une condition le soit `true` et renvoie le résultat correspondant. Si aucune condition ne l'est`true`, le résultat de la `ELSE` clause est renvoyé s'il existe ; dans le cas contraire, il `null` est renvoyé. Voir ci-dessous pour la syntaxe alternative :
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# La déclaration IF
L'instruction **IF** évalue une condition comme vraie ou fausse et renvoie la valeur appropriée. **Timestream prend en charge les deux représentations syntaxiques suivantes pour IF :**
```
if(condition, true_value)
```
Cette syntaxe évalue et renvoie `true_value` si la condition est `true` ; dans le cas contraire, elle `null` est renvoyée et n'`true_value`est pas évaluée.
```
if(condition, true_value, false_value)
```
Cette syntaxe évalue et renvoie `true_value` si la condition est`true`, sinon évalue et renvoie. `false_value`
## Exemples
```
SELECT
if(true, 'example 1'),
if(false, 'example 2'),
if(true, 'example 3 true', 'example 3 false'),
if(false, 'example 4 true', 'example 4 false')
```
| \$1col0 | \$1col1 | \$1col2 | \$1col3 |
| --- | --- | --- | --- |
| `example 1` | `-` `null` | `example 3 true` | `example 4 false` |
# La déclaration COALESCE
**COALESCE** renvoie la première valeur non nulle d'une liste d'arguments. La syntaxe est la suivante :
```
coalesce(value1, value2[,...])
```
# La déclaration NULLIF
L'instruction **IF** évalue une condition comme vraie ou fausse et renvoie la valeur appropriée. **Timestream prend en charge les deux représentations syntaxiques suivantes pour IF :**
**NULLIF** renvoie null s'il `value1` est égal `value2` ; dans le cas contraire, il renvoie la valeur. `value1` La syntaxe est la suivante :
```
nullif(value1, value2)
```
# La déclaration TRY
La fonction **TRY** évalue une expression et gère certains types d'erreurs en la `null` renvoyant. La syntaxe est la suivante :
```
try(expression)
```
# Fonctions de conversion
Timestream for LiveAnalytics prend en charge les fonctions de conversion suivantes.
**Topics**
+ [
## cast()
](#conversion-functions.cast)
+ [
## try\$1cast ()
](#conversion-functions.try-cast)
## cast()
La syntaxe de la fonction cast permettant de convertir explicitement une valeur en type est la suivante.
```
cast(value AS type)
```
## try\$1cast ()
Timestream for prend LiveAnalytics également en charge la fonction try\$1cast qui est similaire à cast mais renvoie null en cas d'échec du cast. La syntaxe est la suivante.
```
try_cast(value AS type)
```
# Operateurs mathématiques
Timestream for LiveAnalytics prend en charge les opérateurs mathématiques suivants.
| Opérateur | Description |
| --- | --- |
| \$1 | Addition |
| - | Soustraction |
| \$1 | Multiplication |
| / | Division (la division entière effectue la troncature) |
| % | Module (reste) |
# Fonctions mathématiques
Timestream for LiveAnalytics prend en charge les fonctions mathématiques suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| abdos (x) | [identique à l'entrée] | Renvoie la valeur absolue de x. |
| cbrt (x) | double | Renvoie la racine cubique de x. |
| plafond (x) ou plafond (x) | [identique à l'entrée] | Renvoie x arrondi au nombre entier le plus proche. |
| degrés (x) | double | Convertit l'angle x en radians en degrés. |
| e () | double | Renvoie le nombre d'Euler constant. |
| exp (x) | double | Renvoie le nombre d'Euler élevé à la puissance x. |
| étage (x) | [identique à l'entrée] | Renvoie x arrondi à l'entier inférieur le plus proche. |
| from\$1base (chaîne, base) | bigint | Renvoie la valeur d'une chaîne interprétée comme un nombre de base de base. |
| ln (x) | double | Renvoie le logarithme naturel de x. |
| journal 2 (x) | double | Renvoie le logarithme en base 2 de x. |
| journal 10 (x) | double | Renvoie le logarithme en base 10 de x. |
| mode (n, m) | [identique à l'entrée] | Renvoie le module (reste) de n divisé par m. |
| épi () | double | Renvoie la constante Pi. |
| pow (x, p) ou puissance (x, p) | double | Renvoie x élevé à la puissance p. |
| radians (x) | double | Convertit l'angle x en degrés en radians. |
| rand () ou random () | double | Renvoie une valeur pseudo-aléatoire comprise entre 0,0 et 1,0. |
| aléatoire (n) | [identique à l'entrée] | Renvoie un nombre pseudo-aléatoire compris entre 0 et n (exclusif). |
| rond (x) | [identique à l'entrée] | Renvoie x arrondi à l'entier le plus proche. |
| rond (x, d) | [identique à l'entrée] | Renvoie x arrondi à d décimales. |
| signe (x) | [identique à l'entrée] | Renvoie la fonction signum de x, c'est-à-dire : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/timestream/latest/developerguide/mathematical-functions.html) Pour les arguments doubles, la fonction renvoie également : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/timestream/latest/developerguide/mathematical-functions.html) |
| carré (x) | double | Renvoie la racine carrée de x. |
| to\$1base (x, radix) | varchar | Renvoie la représentation en base de x. |
| tronquer (x) | double | Renvoie x arrondi à un entier en supprimant les chiffres après la virgule décimale. |
| macos (x) | double | Renvoie l'arc cosinus de x. |
| ASIN (x) | double | Renvoie l'arc sinusoïdal de x. |
| Satan (x) | double | Renvoie l'arc tangent de x. |
| atan2 (y, x) | double | Renvoie l'arc tangent de y/ x. |
| cos (x) | double | Renvoie le cosinus de x. |
| douillet (x) | double | Renvoie le cosinus hyperbolique de x. |
| péché (x) | double | Renvoie le sinus de x. |
| beige (x) | double | Renvoie la tangente de x. |
| bronzage (x) | double | Renvoie la tangente hyperbolique de x. |
| infini () | double | Renvoie la constante représentant l'infini positif. |
| is\$1fini (x) | boolean | Déterminez si x est fini. |
| is\$1infini (x) | boolean | Déterminez si x est infini. |
| is\$1nan (x) | boolean | Déterminez si x est not-a-number. |
| homme (1) | double | Renvoie la constante représentant not-a-number. |
# Opérateurs de chaîne
Timestream for LiveAnalytics permet à l'`||`opérateur de concaténer une ou plusieurs chaînes.
# Fonctions de chaîne
**Note**
Le type de données d'entrée de ces fonctions est supposé être varchar, sauf indication contraire.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| chr (n) | varchar | Renvoie le point de code Unicode n sous forme de varchar. |
| point de code (x) | entier | Renvoie le point de code Unicode du seul caractère de str. |
| concat (x1,..., xN) | varchar | Renvoie la concaténation de x1, x2,..., xN. |
| hamming\$1distance (x1, x2) | bigint | Renvoie la distance de Hamming de x1 et x2, c'est-à-dire le nombre de positions auxquelles les caractères correspondants sont différents. Notez que les deux entrées varchar doivent avoir la même longueur. |
| longueur (x) | bigint | Renvoie la longueur de x en caractères. |
| levenshtein\$1distance (x1, x2) | bigint | Renvoie la distance d'édition Levenshtein de x1 et x2, c'est-à-dire le nombre minimum de modifications d'un seul caractère (insertions, suppressions ou substitutions) nécessaires pour transformer x1 en x2. |
| inférieur (x) | varchar | Convertit x en minuscules. |
| charge (x1, taille bigint, x2) | varchar | Les blocs gauches sont x1 pour dimensionner les caractères avec x2. Si la taille est inférieure à la longueur de x1, le résultat est tronqué en caractères de taille. La taille ne doit pas être négative et x2 ne doit pas être vide. |
| Ultrim (x) | varchar | Supprime les espaces blancs principaux de x. |
| remplacer (x1, x2) | varchar | Supprime toutes les instances de x2 de x1. |
| remplacer (x1, x2, x3) | varchar | Remplace toutes les instances de x2 par x3 dans x1. |
| Inverser (x) | varchar | Renvoie x avec les caractères dans l'ordre inverse. |
| route (x1, taille bigint, x2) | varchar | Le clavier droit contient x1 pour dimensionner les caractères avec x2. Si la taille est inférieure à la longueur de x1, le résultat est tronqué en caractères de taille. La taille ne doit pas être négative et x2 ne doit pas être vide. |
| garniture (x) | varchar | Supprime les espaces blancs de fin de x. |
| scindé (x1, x2) | array(varchar) | Divise x1 sur le délimiteur x2 et renvoie un tableau. |
| split (x1, x2, limite bigint) | array(varchar) | Divise x1 sur le délimiteur x2 et renvoie un tableau. Le dernier élément du tableau contient toujours tout ce qui reste dans la limite x1. Ce doit être un nombre positif. |
| split\$1part (x1, x2, bigint pos) | varchar | Divise x1 sur le délimiteur x2 et renvoie le champ varchar à pos. Les index de champs commencent par 1. Si pos est supérieur au nombre de champs, la valeur null est renvoyée. |
| sangles (x1, x2) | bigint | Renvoie la position de départ de la première instance de x2 dans x1. Les positions commencent par 1. S'il n'est pas trouvé, 0 est renvoyé. |
| strpos (x1, x2, instance de bigint) | bigint | Renvoie la position de la nième instance de x2 dans x1. L'instance doit être un nombre positif. Les positions commencent par 1. S'il n'est pas trouvé, 0 est renvoyé. |
| strapos (x1, x2) | bigint | Renvoie la position de départ de la dernière instance de x2 dans x1. Les positions commencent par 1. S'il n'est pas trouvé, 0 est renvoyé. |
| strrpos (x1, x2, instance de bigint) | bigint | Renvoie la position de la nième instance de x2 dans x1 à partir de la fin de x1. L'instance doit être un nombre positif. Les positions commencent par 1. S'il n'est pas trouvé, 0 est renvoyé. |
| position (x2 IN x1) | bigint | Renvoie la position de départ de la première instance de x2 dans x1. Les positions commencent par 1. S'il n'est pas trouvé, 0 est renvoyé. |
| substr (x, bigint start) | varchar | Renvoie le reste de x à partir de la position de départ. Les positions commencent par 1. Une position de départ négative est interprétée comme étant relative à la fin de x. |
| substr (x, bigint start, bigint len) | varchar | Renvoie une sous-chaîne à partir de x de longueur len à partir de la position de départ. Les positions commencent par 1. Une position de départ négative est interprétée comme étant relative à la fin de x. |
| garniture (x) | varchar | Supprime les espaces blancs de début et de fin de x. |
| supérieur (x) | varchar | Convertit x en majuscules. |
# Opérateurs de réseaux
Timestream for LiveAnalytics prend en charge les opérateurs de tableau suivants.
| Opérateur | Description |
| --- | --- |
| [] | Accédez à un élément d'un tableau dont le premier index commence à 1. |
| \$1\$1 | Concatène un tableau avec un autre tableau ou élément du même type. |
# Fonctions de tableau
Timestream for LiveAnalytics prend en charge les fonctions de tableau suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| tableau distinct (x) | array | Supprimez les valeurs dupliquées du tableau x. SELECT array_distinct(ARRAY[1,2,2,3])
Exemple de résultat : `[ 1,2,3 ]` |
| array\$1intersect (x, y) | array | Renvoie un tableau des éléments situés à l'intersection de x et y, sans doublons. SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
Exemple de résultat : `[ 3 ]` |
| array\$1union (x, y) | array | Renvoie un tableau des éléments dans l'union de x et y, sans doublons. SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
Exemple de résultat : `[ 1,2,3,4,5 ]` |
| array\$1excepté (x, y) | array | Renvoie un tableau d'éléments en x mais pas en y, sans doublons. SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
Exemple de résultat : `[ 1,2 ]` |
| array\$1join (x, délimiteur, remplacement nul) | varchar | Concatène les éléments du tableau donné à l'aide du délimiteur et d'une chaîne facultative pour remplacer les valeurs nulles. SELECT array_join(ARRAY[1,2,3], ';', '')
Exemple de résultat : `1;2;3` |
| array\$1max (x) | identique aux éléments du tableau | Renvoie la valeur maximale du tableau d'entrée. SELECT array_max(ARRAY[1,2,3])
Exemple de résultat : `3` |
| table\$1min (x) | identique aux éléments du tableau | Renvoie la valeur minimale du tableau d'entrée. SELECT array_min(ARRAY[1,2,3])
Exemple de résultat : `1` |
| array\$1position (x, élément) | bigint | Renvoie la position de la première occurrence de l'élément dans le tableau x (ou 0 s'il est introuvable). SELECT array_position(ARRAY[3,4,5,9], 5)
Exemple de résultat : `3` |
| array\$1remove (x, élément) | array | Supprime tous les éléments qui sont égaux à un élément du tableau x. SELECT array_remove(ARRAY[3,4,5,9], 4)
Exemple de résultat : `[ 3,5,9 ]` |
| array\$1sort (x) | array | Trie et renvoie le tableau x. Les éléments de x doivent être commandables. Les éléments nuls seront placés à la fin du tableau renvoyé. SELECT array_sort(ARRAY[6,8,2,9,3])
Exemple de résultat : `[ 2,3,6,8,9 ]` |
| arrays\$1overlap (x, y) | boolean | Teste si les tableaux x et y ont des éléments non nuls en commun. Renvoie null s'il n'y a aucun élément non nul en commun mais que l'un ou l'autre des tableaux contient des valeurs nulles. SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
Exemple de résultat : `true` |
| cardinalité (x) | bigint | Renvoie la taille du tableau x. SELECT cardinality(ARRAY[6,8,2,9,3])
Exemple de résultat : `5` |
| concat (tableau1, matrice2,..., arrayN) | array | Concatène les tableaux array1, array2,..., arrayN. SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
Exemple de résultat : `[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at (tableau (E), index) | E | Renvoie l'élément du tableau à un index donné. Si index est inférieur à 0, element\$1at accède aux éléments du dernier au premier. SELECT element_at(ARRAY[6,8,2,9,3], 1)
Exemple de résultat : `6` |
| répéter (élément, nombre) | array | Répétez l'élément pour le comptage des fois. SELECT repeat(1, 3)
Exemple de résultat : `[ 1,1,1 ]` |
| inverse (x) | array | Renvoie un tableau dont l'ordre est inversé du tableau x. SELECT reverse(ARRAY[6,8,2,9,3])
Exemple de résultat : `[ 3,9,2,8,6 ]` |
| séquence (démarrage, arrêt) | tableau (bigint) | Générez une séquence d'entiers du début à la fin, en l'incrémentant de 1 si le début est inférieur ou égal à l'arrêt, sinon -1. SELECT sequence(3, 8)
Exemple de résultat : `[ 3,4,5,6,7,8 ]` |
| séquence (démarrage, arrêt, étape) | tableau (bigint) | Générez une séquence d'entiers du début à la fin, en les incrémentant pas à pas. SELECT sequence(3, 15, 2)
Exemple de résultat : `[ 3,5,7,9,11,13,15 ]` |
| séquence (démarrage, arrêt) | tableau (horodatage) | Générez une séquence d'horodatages allant de la date de début à la date de fin, en l'incrémentant d'un jour. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) Exemple de résultat : `[ 2023-04-02 19:26:12.941000000,2023-04-03 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-05 19:26:12.941000000,2023-04-06 19:26:12.941000000 ]` |
| séquence (démarrage, arrêt, étape) | tableau (horodatage) | Générez une séquence d'horodatages du début à la fin, en incrémentant par étapes. Le type de données de l'étape est intervalle. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) Exemple de résultat : `[ 2023-04-02 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-06 19:26:12.941000000,2023-04-08 19:26:12.941000000,2023-04-10 19:26:12.941000000 ]` |
| mélanger (x) | array | Génère une permutation aléatoire du tableau x donné. SELECT shuffle(ARRAY[6,8,2,9,3])
Exemple de résultat : `[ 6,3,2,9,8 ]` |
| tranche (x, début, longueur) | array | Sous-ensembles le tableau x à partir du début de l'index (ou à partir de la fin si le début est négatif) avec une longueur de longueur. SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
Exemple de résultat : `[ 6,8,2 ]` |
| zip (tableau1, tableau2 [,...]) | tableau (ligne) | Fusionne les tableaux donnés, élément par élément, en un seul tableau de lignes. Si les arguments ont une longueur inégale, les valeurs manquantes sont remplies avec la valeur NULL. SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
Exemple de résultat : `[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# Fonctions bitwise
Timestream for LiveAnalytics prend en charge les fonctions binaires suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| bit\$1count (bigint, bigint) | bigint (complément à deux) | Renvoie le nombre de bits dans le premier paramètre bigint où le second paramètre est un entier signé par un bit tel que 8 ou 64. SELECT bit_count(19, 8)
Exemple de résultat : `3` SELECT bit_count(19, 2)
Exemple de résultat : `Number must be representable with the bits specified. 19 can not be represented with 2 bits` |
| bitwise\$1and (bigint, bigint) | bigint (complément à deux) | Renvoie l'AND au niveau du bit des paramètres bigint. SELECT bitwise_and(12, 7)
Exemple de résultat : `4` |
| bitwise\$1not (bigint) | bigint (complément à deux) | Renvoie le NOT au niveau du bit du paramètre bigint. SELECT bitwise_not(12)
Exemple de résultat : `-13` |
| bitwise\$1or (bigint, bigint) | bigint (complément à deux) | Renvoie le OR bit à bit des paramètres bigint. SELECT bitwise_or(12, 7)
Exemple de résultat : `15` |
| bitwise\$1xor (bigint, bigint) | bigint (complément à deux) | Renvoie le XOR bit à bit des paramètres bigint. SELECT bitwise_xor(12, 7)
Exemple de résultat : `11` |
# Fonctions d'expression régulière
Les fonctions d'expression régulière dans Timestream prennent en LiveAnalytics charge la syntaxe des [modèles Java.](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) Timestream for LiveAnalytics prend en charge les fonctions d'expression régulière suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| regexp\$1extract\$1all (chaîne, modèle) | array(varchar) | Renvoie la ou les sous-chaînes correspondant au modèle d'expression régulière dans la chaîne. SELECT regexp_extract_all('example expect complex', 'ex\w') Exemple de résultat : `[ exa,exp ]` |
| regexp\$1extract\$1all (chaîne, modèle, groupe) | array(varchar) | Trouve toutes les occurrences du modèle d'expression régulière dans une chaîne et renvoie le groupe de [numéros du groupe de capture](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber). SELECT regexp_extract_all('example expect complex', '(ex)(\w)', 2) Exemple de résultat : `[ a,p ]` |
| regexp\$1extract (chaîne, modèle) | varchar | Renvoie la première sous-chaîne correspondant au modèle d'expression régulière dans la chaîne. SELECT regexp_extract('example expect', 'ex\w') Exemple de résultat : `exa` |
| regexp\$1extract (chaîne, modèle, groupe) | varchar | Trouve la première occurrence du modèle d'expression régulière dans une chaîne et renvoie le groupe de [numéros du groupe de capture](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber). SELECT regexp_extract('example expect', '(ex)(\w)', 2) Exemple de résultat : `a` |
| regexp\$1like (chaîne, motif) | boolean | Évalue le modèle d'expression régulière et détermine s'il est contenu dans une chaîne. Cette fonction est similaire à l'opérateur LIKE, sauf que le motif doit uniquement être contenu dans une chaîne, au lieu de devoir correspondre à l'ensemble de la chaîne. En d'autres termes, cela effectue une opération de contenu plutôt qu'une opération de correspondance. Vous pouvez faire correspondre la chaîne entière en ancrant le motif en utilisant ^ et \$1. SELECT regexp_like('example', 'ex') Exemple de résultat : `true` |
| regexp\$1replace (chaîne, modèle) | varchar | Supprime toutes les instances de la sous-chaîne correspondant au modèle d'expression régulière de la chaîne. SELECT regexp_replace('example expect', 'expect') Exemple de résultat : `example` |
| regexp\$1replace (chaîne, modèle, remplacement) | varchar | Remplace chaque instance de la sous-chaîne correspondant au modèle regex dans la chaîne par un remplacement. Les groupes de capture peuvent être référencés en remplacement en utilisant \$1g pour un groupe numéroté ou \$1 \$1name\$1 pour un groupe nommé. Un signe dollar (\$1) peut être inclus dans le remplacement en le remplaçant par une barre oblique inverse (\$1 \$1). SELECT regexp_replace('example expect', 'expect', 'surprise') Exemple de résultat : `example surprise` |
| regexp\$1replace (chaîne, modèle, fonction) | varchar | Remplace chaque instance de la sous-chaîne correspondant au modèle d'expression régulière dans une chaîne à l'aide d'une fonction. La fonction [d'expression lambda](https://prestodb.io/docs/current/functions/lambda.html) est invoquée pour chaque correspondance, les groupes de capture étant transmis sous forme de tableau. La capture des numéros de groupe commence par un ; il n'existe aucun groupe pour l'ensemble de la correspondance (si nécessaire, entourez l'expression entière de parenthèses). SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) Exemple de résultat : `EXAMPLE` |
| regexp\$1split (chaîne, modèle) | array(varchar) | Divise la chaîne en utilisant le modèle d'expression régulière et renvoie un tableau. Les chaînes vides de fin sont conservées. SELECT regexp_split('example', 'x') Exemple de résultat : `[ e,ample ]` |
# Opérateurs de date et d'heure
**Note**
Timestream for LiveAnalytics ne prend pas en charge les valeurs temporelles négatives. Toute opération entraînant une durée négative entraîne une erreur.
Timestream for LiveAnalytics prend en charge les opérations suivantes sur `timestamps``dates`, et. `intervals`
| Opérateur | Description |
| --- | --- |
| \$1 | Addition |
| - | Soustraction |
**Topics**
+ [
## Opérations
](#date-time-operators-operations)
+ [
## Addition
](#date-time-operators-addition)
+ [
## Soustraction
](#date-time-operators-subtraction)
## Opérations
Le type de résultat d'une opération est basé sur les opérandes. Des littéraux d'intervalle tels que `1day` et `3s` peuvent être utilisés.
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
Exemple de résultat pour chacun d'entre eux : `2022-05-23`
Les unités d'intervalle incluent `second` `minute``hour`,`day`,`week`,`month`, et`year`. Mais dans certains cas, tous ne sont pas applicables. Par exemple, les secondes, les minutes et les heures ne peuvent pas être ajoutées ou soustraites à une date.
```
SELECT interval '4' year + interval '2' month
```
Exemple de résultat : `4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
Exemple de résultat : `interval year to month`
Le type de résultat des opérations d'intervalle peut être `'interval year to month'` ou `'interval day to second'` dépendre des opérandes. Les intervalles peuvent être ajoutés ou soustraits de `dates` et`timestamps`. Mais un `date` ou `timestamp` ne peut pas être ajouté ou soustrait d'un `date` ou`timestamp`. Pour trouver les intervalles ou les durées liés aux dates ou aux horodatages, voir `date_diff` et les fonctions associées dans. [Intervalle et durée](date-time-functions.md#date-time-functions-interval-duration)
## Addition
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
Exemple de résultat : `2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
Exemple de résultat : `date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
Exemple de résultat : `2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
Exemple de résultat : `interval year to month`
## Soustraction
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
Exemple de résultat : `2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
Exemple de résultat : `timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
Exemple de résultat : `5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
Exemple de résultat : `interval day to second`
# Fonctions de date/heure
**Note**
Timestream for LiveAnalytics ne prend pas en charge les valeurs temporelles négatives. Toute opération entraînant une durée négative entraîne une erreur.
Timestream pour LiveAnalytics utilise le fuseau horaire UTC pour la date et l'heure. Timestream prend en charge les fonctions suivantes pour la date et l'heure.
**Topics**
+ [
## Généralités et conversion
](#date-time-functions-general)
+ [
## Intervalle et durée
](#date-time-functions-interval-duration)
+ [
## Formatage et analyse
](#date-time-functions-formatting-parsing)
+ [
## Extraction
](#date-time-functions-extraction)
## Généralités et conversion
Timestream for LiveAnalytics prend en charge les fonctions générales et de conversion suivantes pour la date et l'heure.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| date\$1actuelle | date | Renvoie la date actuelle en UTC. Aucune parenthèse n'est utilisée. SELECT current_date
Exemple de résultat : `2022-07-07` Il s'agit également d'un mot clé réservé. Pour obtenir la liste des mots clés réservés, consultez[Mots-clés réservés](ts-limits.md#limits.reserved). |
| heure\$1actuelle | time | Renvoie l'heure actuelle en UTC. Aucune parenthèse n'est utilisée. SELECT current_time
Exemple de résultat : `17:41:52.827000000` Il s'agit également d'un mot clé réservé. Pour obtenir la liste des mots clés réservés, consultez[Mots-clés réservés](ts-limits.md#limits.reserved). |
| current\$1timestamp ou now () | timestamp | Renvoie l'horodatage actuel en UTC. SELECT current_timestamp
Exemple de résultat : `2022-07-07 17:42:32.939000000` Il s'agit également d'un mot clé réservé. Pour obtenir la liste des mots clés réservés, consultez[Mots-clés réservés](ts-limits.md#limits.reserved). |
| fuse\$1horaire actuel () | varchar La valeur sera « UTC ». | Timestream utilise le fuseau horaire UTC pour la date et l'heure. SELECT current_timezone()
Exemple de résultat : `UTC` |
| date (varchar (x)), date (horodatage) | date | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
Exemple de résultat : `2022-07-07` |
| dernier\$1jour\$1de\$1mois (horodatage), dernier\$1jour\$1de\$1mois (date) | date | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
Exemple de résultat : `2022-07-31` |
| from\$1iso8601\$1timestamp (chaîne de caractères) | timestamp | Analyse l'horodatage ISO 8601 au format d'horodatage interne. SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') Exemple de résultat : `2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date (chaîne de caractères) | date | Analyse la chaîne de date ISO 8601 au format d'horodatage interne pour UTC 00:00:00 de la date spécifiée. SELECT from_iso8601_date('2022-07-17') Exemple de résultat : `2022-07-17` |
| to\$1iso8601 (horodatage), to\$1iso8601 (date) | varchar | Renvoie une chaîne au format ISO 8601 pour l'entrée. SELECT to_iso8601(from_iso8601_date('2022-06-17')) Exemple de résultat : `2022-06-17` |
| from\$1milliseconds (bigint) | timestamp | SELECT from_milliseconds(1)
Exemple de résultat : `1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds (bigint) | timestamp | select from_nanoseconds(300000001)
Exemple de résultat : `1970-01-01 00:00:00.300000001` |
| from\$1unixtime (double) | timestamp | Renvoie un horodatage qui correspond à l'unixtime fourni. SELECT from_unixtime(1)
Exemple de résultat : `1970-01-01 00:00:01.000000000` |
| heure locale | time | Renvoie l'heure actuelle en UTC. Aucune parenthèse n'est utilisée. SELECT localtime
Exemple de résultat : `17:58:22.654000000` Il s'agit également d'un mot clé réservé. Pour obtenir la liste des mots clés réservés, consultez[Mots-clés réservés](ts-limits.md#limits.reserved). |
| horodatage local | timestamp | Renvoie l'horodatage actuel en UTC. Aucune parenthèse n'est utilisée. SELECT localtimestamp
Exemple de résultat : `2022-07-07 17:59:04.368000000` Il s'agit également d'un mot clé réservé. Pour obtenir la liste des mots clés réservés, consultez[Mots-clés réservés](ts-limits.md#limits.reserved). |
| to\$1milliseconds (intervalle jour par seconde), to\$1milliseconds (horodatage) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Exemple de résultat : `183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
Exemple de résultat : `1655487883771` |
| to\$1nanoseconds (intervalle jour par seconde), to\$1nanoseconds (horodatage) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Exemple de résultat : `183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
Exemple de résultat : `1655487883771000678` |
| to\$1unixtime (horodatage) | double | Renvoie unixtime pour l'horodatage fourni. SELECT to_unixtime('2022-06-17 17:44:43.771000000') Exemple de résultat : `1.6554878837710001E9` |
| date\$1trunc (unité, horodatage) | timestamp | Renvoie l'horodatage tronqué en unité, où l'unité est [seconde, minute, heure, jour, semaine, mois, trimestre ou année]. SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') Exemple de résultat : `2022-06-17 17:44:00.000000000` |
## Intervalle et durée
Timestream for LiveAnalytics prend en charge les fonctions d'intervalle et de durée suivantes pour la date et l'heure.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| date\$1add (unité, bigint, date), date\$1add (unité, bigint, heure), date\$1add (varchar (x), bigint, horodatage) | timestamp | Ajoute un bigint d'unités, où l'unité est l'une des valeurs suivantes : [seconde, minute, heure, jour, semaine, mois, trimestre ou année]. SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') Exemple de résultat : `2022-06-17 09:00:00.000000000` |
| date\$1diff (unité, date, date), date\$1diff (unité, heure, heure), date\$1diff (unité, horodatage, horodatage) | bigint | Renvoie une différence dont l'unité est [seconde, minute, heure, jour, semaine, mois, trimestre ou année]. SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') Exemple de résultat : `1` |
| parse\$1duration (chaîne de caractères) | interval | Analyse la chaîne d'entrée pour renvoyer un `interval` équivalent. SELECT parse_duration('42.8ms') Exemple de résultat : `0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) Exemple de résultat : `interval day to second` |
| bin (horodatage, intervalle) | timestamp | Arrondit la valeur entière du `timestamp` paramètre au multiple le plus proche de la valeur entière du `interval` paramètre. La signification de cette valeur de retour n'est peut-être pas évidente. Il est calculé à l'aide de l'arithmétique des entiers en divisant d'abord le nombre entier d'horodatage par l'entier d'intervalle, puis en multipliant le résultat par l'entier d'intervalle. En gardant à l'esprit qu'un horodatage indique un point UTC exprimé en fractions de seconde écoulées depuis l'époque POSIX (1er janvier 1970), la valeur renvoyée s'alignera rarement sur les unités du calendrier. Par exemple, si vous spécifiez un intervalle de 30 jours, tous les jours écoulés depuis l'époque sont divisés en tranches de 30 jours, et le début de la dernière tranche de 30 jours est renvoyé, ce qui n'a aucun rapport avec les mois du calendrier. Voici quelques exemples : bin(TIMESTAMP '2022-06-17 10:15:20', 5m) ==> 2022-06-17 10:15:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 1d) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 10day) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 30day) ==> 2022-05-28 00:00:00.000000000
|
| il y a (intervalle) | timestamp | Renvoie la valeur correspondant à `interval` current\$1timestamp. SELECT ago(1d)
Exemple de résultat : `2022-07-06 21:08:53.245000000` |
| littéraux d'intervalle tels que 1h, 1d et 30m | interval | Les littéraux d'intervalle sont pratiques pour parse\$1duration (chaîne). Par exemple, `1d` est identique à `parse_duration('1d')`. Cela permet d'utiliser les littéraux partout où un intervalle est utilisé. Par exemple : `ago(1d)` et `bin(, 1m)`. |
Certains littéraux d'intervalle servent de raccourci pour parse\$1duration. Par exemple,`parse_duration('1day')`, `1day``parse_duration('1d')`, et `1d` chaque retour `1 00:00:00.000000000` où se trouve le type`interval day to second`. L'espace est autorisé dans le format fourni à`parse_duration`. Par exemple, les retours sont `parse_duration('1day')` également`00:00:00.000000000`. Mais ce n'`1 day`est pas un intervalle littéral.
Les unités associées `interval day to second` sont ns, nanoseconde, us, microseconde, ms, milliseconde, s, seconde, m, minute, h, heure, d et jour.
Il y en a également`interval year to month`. Les unités associées à l'intervalle d'une année à l'autre sont y, année et mois. Par exemple, les `SELECT 1year` retours`1-0`. `SELECT 12month`revient également`1-0`. `SELECT 8month`retours`0-8`.
Bien que l'unité de `quarter` soit également disponible pour certaines fonctions telles que `date_trunc` et`date_add`, elle n'`quarter`est pas disponible dans le cadre d'un intervalle littéral.
## Formatage et analyse
Timestream for LiveAnalytics prend en charge les fonctions de formatage et d'analyse suivantes pour la date et l'heure.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| date\$1format (horodatage, varchar (x)) | varchar | [Pour plus d'informations sur les spécificateurs de format utilisés par cette fonction, voir \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_format(TIMESTAMP '2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s')
Exemple de résultat : `2019-10-20 10:20:20` |
| date\$1parse (varchar (x), varchar (y)) | timestamp | [Pour plus d'informations sur les spécificateurs de format utilisés par cette fonction, voir \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_parse('2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s') Exemple de résultat : `2019-10-20 10:20:20.000000000` |
| format\$1datetime (horodatage, varchar (x)) | varchar | Pour plus d'informations sur la chaîne de format utilisée par cette fonction, consultez [http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT format_datetime(parse_datetime('1968-01-13 12', 'yyyy-MM-dd HH'), 'yyyy-MM-dd HH') Exemple de résultat : `1968-01-13 12` |
| parse\$1datetime (varchar (x), varchar (y)) | timestamp | Pour plus d'informations sur la chaîne de format utilisée par cette fonction, consultez [http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT parse_datetime('2019-12-29 10:10 PST', 'uuuu-LL-dd HH:mm z') Exemple de résultat : `2019-12-29 18:10:00.000000000` |
## Extraction
Timestream for LiveAnalytics prend en charge les fonctions d'extraction suivantes pour la date et l'heure. La fonction d'extraction est à la base des autres fonctions pratiques.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| extract | bigint | Extrait un champ d'un horodatage, le champ étant l'un des suivants : [YEAR, QUARTER, MONTH, WEEK, DAY, DAY\$1OF\$1MONTH, DAY\$1OF\$1WEEK, DOW, DAY\$1OF\$1YEAR, DOY, YEAR\$1OF\$1WEEK, YOW, HOUR, MINUTE ou SECOND]. SELECT extract(YEAR FROM '2019-10-12 23:10:34.000000000')
Exemple de résultat : `2019` |
| jour (horodatage), jour (date), jour (intervalle de jour à seconde) | bigint | SELECT day('2019-10-12 23:10:34.000000000') Exemple de résultat : `12` |
| jour\$1of\$1month (horodatage), day\$1of\$1month (date), day\$1of\$1month (intervalle d'un jour à une seconde) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') Exemple de résultat : `12` |
| jour\$1de\$1semaine (horodatage), jour\$1de\$1semaine (date) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') Exemple de résultat : `6` |
| jour\$1de\$1année (horodatage), jour\$1de\$1année (date) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') Exemple de résultat : `285` |
| dow (horodatage), dow (date) | bigint | Alias pour day\$1of\$1week |
| doy (horodatage), doy (date) | bigint | Alias pour day\$1of\$1year |
| heure (horodatage), heure (heure), heure (intervalle du jour à la seconde) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') Exemple de résultat : `23` |
| milliseconde (horodatage), milliseconde (heure), milliseconde (intervalle jour par seconde) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') Exemple de résultat : `0` |
| minute (horodatage), minute (heure), minute (intervalle du jour à la seconde) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') Exemple de résultat : `10` |
| mois (horodatage), mois (date), mois (intervalle d'une année à l'autre) | bigint | SELECT month('2019-10-12 23:10:34.000000000') Exemple de résultat : `10` |
| nanoseconde (horodatage), nanoseconde (temps), nanoseconde (intervalle entre un jour et une seconde) | bigint | SELECT nanosecond(current_timestamp)
Exemple de résultat : `162000000` |
| trimestre (horodatage), trimestre (date) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') Exemple de résultat : `4` |
| seconde (horodatage), seconde (heure), seconde (intervalle de jour à seconde) | bigint | SELECT second('2019-10-12 23:10:34.000000000') Exemple de résultat : `34` |
| semaine (horodatage), semaine (date) | bigint | SELECT week('2019-10-12 23:10:34.000000000') Exemple de résultat : `41` |
| semaine\$1de\$1année (horodatage), semaine\$1de\$1année (date) | bigint | Alias pour la semaine |
| année (horodatage), année (date), année (intervalle d'une année à l'autre) | bigint | SELECT year('2019-10-12 23:10:34.000000000') Exemple de résultat : `2019` |
| année\$1de\$1semaine (horodatage), année\$1de\$1semaine (date) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') Exemple de résultat : `2019` |
| yow (horodatage), yow (date) | bigint | Alias pour year\$1of\$1week |
# Fonctions d’agrégation
Timestream for LiveAnalytics prend en charge les fonctions d'agrégation suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| arbitraire (x) | [identique à l'entrée] | Renvoie une valeur arbitraire non nulle de x, s'il en existe une. SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `1` |
| array\$1agg (x) | array< [identique à l'entrée] | Renvoie un tableau créé à partir des éléments x d'entrée. SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `[ 1,2,3,4 ]` |
| moyenne (x) | double | Renvoie la moyenne (moyenne arithmétique) de toutes les valeurs d'entrée. SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `2.5` |
| bool\$1and (boolean) every (booléen) | boolean | Renvoie TRUE si chaque valeur d'entrée est VRAIE, sinon FALSE. SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemple de résultat : `false` |
| bool\$1or (booléen) | boolean | Renvoie TRUE si l'une des valeurs d'entrée est VRAIE, sinon FALSE. SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemple de résultat : `true` |
| compte (\$1) compte (x) | bigint | count (\$1) renvoie le nombre de lignes d'entrée. count (x) renvoie le nombre de valeurs d'entrée non nulles. SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemple de résultat : `4` |
| nombre\$1if (x) | bigint | Renvoie le nombre de valeurs d'entrée TRUE. SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemple de résultat : `3` |
| moyenne géométrique (x) | double | Renvoie la moyenne géométrique de toutes les valeurs d'entrée. SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `2.213363839400643` |
| max\$1by (x, y) | [identique à x] | Renvoie la valeur de x associée à la valeur maximale de y sur toutes les valeurs d'entrée. SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemple de résultat : `d` |
| max\$1by (x, y, n) | réseau< [same as x] > | Renvoie n valeurs de x associées à la plus grande valeur n de toutes les valeurs d'entrée de y par ordre décroissant de y. SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemple de résultat : `[ d,c ]` |
| min\$1by (x, y) | [identique à x] | Renvoie la valeur de x associée à la valeur minimale de y sur toutes les valeurs d'entrée. SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemple de résultat : `a` |
| min\$1by (x, y, n) | réseau< [same as x] > | Renvoie n valeurs de x associées à la n plus petite de toutes les valeurs d'entrée de y dans l'ordre croissant de y. SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemple de résultat : `[ a,b ]` |
| maximum (x) | [identique à l'entrée] | Renvoie la valeur maximale de toutes les valeurs d'entrée. SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `4` |
| maximum (x, n) | réseau< [same as x] > | Renvoie n valeurs les plus élevées de toutes les valeurs d'entrée de x. SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `[ 4,3 ]` |
| minute (x) | [identique à l'entrée] | Renvoie la valeur minimale de toutes les valeurs d'entrée. SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `1` |
| minute (x, n) | réseau< [same as x] > | Renvoie n plus petites valeurs de toutes les valeurs d'entrée de x. SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `[ 1,2 ]` |
| somme (x) | [identique à l'entrée] | Renvoie la somme de toutes les valeurs d'entrée. SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `10` |
| bitwise\$1et\$1agg (x) | bigint | Renvoie l'AND au niveau du bit de toutes les valeurs d'entrée dans une représentation complémentaire à 2 s. SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Exemple de résultat : `1` |
| bitwise\$1or\$1agg (x) | bigint | Renvoie le OR au niveau du bit de toutes les valeurs d'entrée dans une représentation complémentaire à 2 s. SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Exemple de résultat : `-3` |
| approx\$1distinct (x) | bigint | Renvoie le nombre approximatif de valeurs d'entrée distinctes. Cette fonction fournit une approximation du nombre (DISTINCT x). Zéro est renvoyé si toutes les valeurs d'entrée sont nulles. Cette fonction doit produire une erreur type de 2,3 %, qui est l'écart type de la distribution des erreurs (approximativement normale) sur tous les ensembles possibles. Cela ne garantit pas une limite supérieure de l'erreur pour un ensemble d'entrées spécifique. SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Exemple de résultat : `5` |
| approx\$1distinct (x, e) | bigint | Renvoie le nombre approximatif de valeurs d'entrée distinctes. Cette fonction fournit une approximation du nombre (DISTINCT x). Zéro est renvoyé si toutes les valeurs d'entrée sont nulles. Cette fonction doit produire une erreur type ne dépassant pas e, qui est l'écart type de la distribution d'erreur (approximativement normale) sur tous les ensembles possibles. Cela ne garantit pas une limite supérieure de l'erreur pour un ensemble d'entrées spécifique. L'implémentation actuelle de cette fonction nécessite que e soit compris entre [0,0040625, 0,26000]. SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Exemple de résultat : `5` |
| approx\$1percentile (x, pourcentage) | [identique à x] | Renvoie le percentile approximatif pour toutes les valeurs d'entrée de x au pourcentage donné. La valeur du pourcentage doit être comprise entre zéro et un et doit être constante pour toutes les lignes d'entrée. SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `2` |
| approx\$1percentile (x, pourcentages) | réseau< [same as x] > | Renvoie le percentile approximatif pour toutes les valeurs d'entrée de x pour chacun des pourcentages spécifiés. Chaque élément du tableau des pourcentages doit être compris entre zéro et un, et le tableau doit être constant pour toutes les lignes d'entrée. SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `[ 1,4,4 ]` |
| approx\$1percentile (x, w, pourcentage) | [identique à x] | Renvoie le percentile pondéré approximatif pour toutes les valeurs d'entrée de x en utilisant le poids par article w au pourcentage p. Le poids doit être une valeur entière d'au moins un. Il s'agit en fait d'un nombre de réplications pour la valeur x dans l'ensemble de percentiles. La valeur de p doit être comprise entre zéro et un et doit être constante pour toutes les lignes d'entrée. SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `1` |
| approx\$1percentile (x, w, pourcentages) | réseau< [same as x] > | Renvoie le percentile pondéré approximatif pour toutes les valeurs d'entrée de x en utilisant le poids par article w à chacun des pourcentages indiqués dans le tableau. Le poids doit être une valeur entière d'au moins un. Il s'agit en fait d'un nombre de réplications pour la valeur x dans l'ensemble de percentiles. Chaque élément du tableau doit être compris entre zéro et un, et le tableau doit être constant pour toutes les lignes d'entrée. SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `[ 1,4,4 ]` |
| approx\$1percentile (x, w, pourcentage, précision) | [identique à x] | Renvoie le percentile pondéré approximatif pour toutes les valeurs d'entrée de x en utilisant le poids par article w au pourcentage p, avec une erreur de précision de classement maximale. Le poids doit être une valeur entière d'au moins un. Il s'agit en fait d'un nombre de réplications pour la valeur x dans l'ensemble de percentiles. La valeur de p doit être comprise entre zéro et un et doit être constante pour toutes les lignes d'entrée. La précision doit être une valeur supérieure à zéro et inférieure à un, et elle doit être constante pour toutes les lignes en entrée. SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemple de résultat : `1` |
| corr (y, x) | double | Renvoie le coefficient de corrélation des valeurs d'entrée. SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemple de résultat : `1.0` |
| covar\$1pop (y, x) | double | Renvoie la covariance des valeurs d'entrée dans la population. SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemple de résultat : `1.25` |
| covar\$1samp (y, x) | double | Renvoie la covariance de l'échantillon des valeurs d'entrée. SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemple de résultat : `1.6666666666666667` |
| reg\$1interception (y, x) | double | Renvoie l'intersection par régression linéaire des valeurs d'entrée. y est la valeur dépendante. x est la valeur indépendante. SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemple de résultat : `0.0` |
| reg\$1slope (y, x) | double | Renvoie la pente de régression linéaire des valeurs d'entrée. y est la valeur dépendante. x est la valeur indépendante. SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemple de résultat : `1.0` |
| asymétrie (x) | double | Renvoie l'asymétrie de toutes les valeurs d'entrée. SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemple de résultat : `0.8978957037987335` |
| stddev\$1pop (x) | double | Renvoie l'écart type de la population de toutes les valeurs d'entrée. SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemple de résultat : `2.4166091947189146` |
| stddev\$1samp (x) stddev (x) | double | Renvoie l'écart type de l'échantillon de toutes les valeurs d'entrée. SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemple de résultat : `2.701851217221259` |
| var\$1pop (x) | double | Renvoie la variance de population de toutes les valeurs d'entrée. SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemple de résultat : `5.840000000000001` |
| var\$1samp (x) variance (x) | double | Renvoie la variance d'échantillon de toutes les valeurs d'entrée. SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemple de résultat : `7.300000000000001` |
# Fonctions de fenêtrage
Les fonctions de fenêtre effectuent des calculs sur les lignes du résultat de la requête. Ils s'exécutent après la clause HAVING mais avant la clause ORDER BY. L'appel d'une fonction de fenêtre nécessite une syntaxe spéciale utilisant la clause OVER pour spécifier la fenêtre. Une fenêtre comporte trois éléments :
+ Spécification de partition, qui sépare les lignes d'entrée en différentes partitions. Cela est analogue à la façon dont la clause GROUP BY sépare les lignes en différents groupes pour les fonctions d'agrégation.
+ La spécification d'ordre, qui détermine l'ordre dans lequel les lignes d'entrée seront traitées par la fonction de fenêtre.
+ Le cadre de fenêtre, qui indique une fenêtre coulissante de lignes à traiter par la fonction pour une ligne donnée. Si le cadre n'est pas spécifié, sa valeur par défaut est RANGE UNBOUNDED PRECEDING, identique à RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Ce cadre contient toutes les lignes depuis le début de la partition jusqu'au dernier pair de la ligne en cours.
Toutes les fonctions d'agrégation peuvent être utilisées comme fonctions de fenêtre en ajoutant la clause OVER. La fonction d'agrégation est calculée pour chaque ligne au-dessus des lignes du cadre de fenêtre de la ligne en cours. Outre les fonctions d'agrégation, Timestream for LiveAnalytics prend en charge les fonctions de classement et de valeur suivantes.
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| cume\$1dist () | bigint | Renvoie la distribution cumulée d'une valeur dans un groupe de valeurs. Le résultat est le nombre de lignes précédant ou correspondant à la ligne dans l'ordre des fenêtres de la partition de fenêtre divisé par le nombre total de lignes de la partition de fenêtre. Ainsi, toutes les valeurs d'égalité figurant dans l'ordre seront évaluées à la même valeur de distribution. |
| dense\$1rank () | bigint | Renvoie le rang d'une valeur dans un groupe de valeurs. Ceci est similaire à rank (), sauf que les valeurs d'égalité ne produisent pas de lacunes dans la séquence. |
| Titre (n) | bigint | Divise les lignes de chaque partition de fenêtre en n compartiments allant de 1 à n au maximum. Les valeurs des compartiments différeront d'au plus 1. Si le nombre de lignes de la partition ne correspond pas uniformément au nombre de compartiments, les valeurs restantes sont distribuées une par compartiment, en commençant par le premier compartiment. |
| classement en pourcentage () | double | Renvoie le classement en pourcentage d'une valeur dans un groupe de valeurs. Le résultat est (r - 1)/(n - 1) où r est le rang () de la ligne et n est le nombre total de lignes dans la partition de fenêtre. |
| rang () | bigint | Renvoie le rang d'une valeur dans un groupe de valeurs. Le rang est égal à un plus le nombre de lignes précédant la ligne qui ne correspondent pas à la ligne. Ainsi, les valeurs d'égalité dans l'ordre produiront des écarts dans la séquence. Le classement est effectué pour chaque partition de fenêtre. |
| numéro\$1ligne () | bigint | Renvoie un numéro séquentiel unique pour chaque ligne, en commençant par un, en fonction de l'ordre des lignes dans la partition de fenêtre. |
| première\$1valeur (x) | [identique à l'entrée] | Renvoie la première valeur de la fenêtre. Cette fonction est limitée au cadre de la fenêtre. La fonction prend une expression ou une cible comme paramètre. |
| dernière\$1valeur (x) | [identique à l'entrée] | Renvoie la dernière valeur de la fenêtre. Cette fonction est limitée au cadre de la fenêtre. La fonction prend une expression ou une cible comme paramètre. |
| nth\$1value (x, décalage) | [identique à l'entrée] | Renvoie la valeur au décalage spécifié par rapport au début de la fenêtre. Les décalages commencent à 1. Le décalage peut être n'importe quelle expression scalaire. Si le décalage est nul ou supérieur au nombre de valeurs de la fenêtre, nul est renvoyé. Le fait que le décalage soit nul ou négatif est une erreur. La fonction prend une expression ou une cible comme premier paramètre. |
| plomb (x [, offset [, valeur\$1défaut]]) | [identique à l'entrée] | Renvoie la valeur des lignes décalées après la ligne actuelle de la fenêtre. Les décalages commencent à 0, qui correspond à la ligne actuelle. Le décalage peut être n'importe quelle expression scalaire. Le décalage par défaut est 1. Si le décalage est nul ou supérieur à celui de la fenêtre, la valeur par défaut est renvoyée, ou si elle n'est pas spécifiée, null est renvoyée. La fonction prend une expression ou une cible comme premier paramètre. |
| décalage (x [, offset [, valeur\$1défaut]]) | [identique à l'entrée] | Renvoie la valeur des lignes décalées avant la ligne actuelle de la fenêtre Les décalages commencent à 0, qui est la ligne en cours. Le décalage peut être n'importe quelle expression scalaire. Le décalage par défaut est 1. Si le décalage est nul ou supérieur à celui de la fenêtre, la valeur par défaut est renvoyée, ou si elle n'est pas spécifiée, null est renvoyée. La fonction prend une expression ou une cible comme premier paramètre. |
# Exemples de requêtes
Cette section inclut des exemples de cas d'utilisation du langage de requête LiveAnalytics de Timestream for.
**Topics**
+ [
# Requêtes simples
](sample-queries.basic-scenarios.md)
+ [
# Requêtes avec fonctions de séries chronologiques
](sample-queries.devops-scenarios.md)
+ [
# Requêtes avec fonctions d'agrégation
](sample-queries.iot-scenarios.md)
# Requêtes simples
Ce qui suit permet d'obtenir les 10 derniers points de données ajoutés à une table.
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
Ce qui suit permet d'obtenir les 5 points de données les plus anciens pour une mesure spécifique.
```
SELECT * FROM .
WHERE measure_name = ''
ORDER BY time ASC
LIMIT 5
```
Ce qui suit fonctionne avec des horodatages à granularité nanoseconde.
```
SELECT now() AS time_now
, now() - (INTERVAL '12' HOUR) AS twelve_hour_earlier -- Compatibility with ANSI SQL
, now() - 12h AS also_twelve_hour_earlier -- Convenient time interval literals
, ago(12h) AS twelve_hours_ago -- More convenience with time functionality
, bin(now(), 10m) AS time_binned -- Convenient time binning support
, ago(50ns) AS fifty_ns_ago -- Nanosecond support
, now() + (1h + 50ns) AS hour_fifty_ns_future
```
Les valeurs de mesure pour les enregistrements à mesures multiples sont identifiées par le nom de colonne. Les valeurs de mesure pour les enregistrements à mesure unique sont identifiées par`measure_value::`, où se `` trouve l'un des `double` `bigint``boolean`, ou `varchar` comme décrit dans[Types de données pris en charge](supported-data-types.md). Pour plus d'informations sur la façon dont les valeurs de mesure sont modélisées, voir [Table unique ou tables multiples](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords).
Ce qui suit récupère les valeurs d'une mesure appelée `speed` à partir d'enregistrements de plusieurs mesures avec un `measure_name` de. `IoTMulti-stats`
```
SELECT speed FROM . where measure_name = 'IoTMulti-stats'
```
Ce qui suit récupère `double` les valeurs des enregistrements à mesure unique avec un `measure_name` de. `load`
```
SELECT measure_value::double FROM . WHERE measure_name = 'load'
```
# Requêtes avec fonctions de séries chronologiques
**Topics**
+ [
## Exemple de jeu de données et de requêtes
](#sample-queries.devops-scenarios.example)
## Exemple de jeu de données et de requêtes
Vous pouvez utiliser Timestream LiveAnalytics pour comprendre et améliorer les performances et la disponibilité de vos services et applications. Vous trouverez ci-dessous un exemple de table et des exemples de requêtes exécutées sur cette table.
La table `ec2_metrics` stocke les données de télémétrie, telles que l'utilisation du processeur et d'autres mesures provenant d'instances EC2. Vous pouvez consulter le tableau ci-dessous.
| Heure | region | az | Hostname | nom\$1mesure | valeur\$1mesure : double | value\$1mesure : :bigint |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | frontend 01 | utilisation du processeur | 35,1 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | frontend 01 | memory\$1utilization | 55,3 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | frontend 01 | network\$1bytes\$1in | null | 1 500 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | frontend 01 | octets\$1out du réseau | null | 6 700 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | frontend 02 | utilisation du processeur | 38,5 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | frontend 02 | memory\$1utilization | 58,4 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | frontend 02 | network\$1bytes\$1in | null | 23 000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | frontend 02 | octets\$1out du réseau | null | 12 000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | frontend 03 | utilisation du processeur | 45.0 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | frontend 03 | memory\$1utilization | 65,8 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | frontend 03 | network\$1bytes\$1in | null | 15 000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | frontend 03 | octets\$1out du réseau | null | 836 000 |
| 2019-12-04 19:00:05 000 000000 | us-east-1 | us-east-1a | frontend 01 | utilisation du processeur | 55,2 | null |
| 2019-12-04 19:00:05 000 000000 | us-east-1 | us-east-1a | frontend 01 | memory\$1utilization | 75.0 | null |
| 2019-12-04 19:00:05 000 000000 | us-east-1 | us-east-1a | frontend 01 | network\$1bytes\$1in | null | 1 245 |
| 2019-12-04 19:00:05 000 000000 | us-east-1 | us-east-1a | frontend 01 | octets\$1out du réseau | null | 68 432 |
| 2019-12-04 19:00:08 000 000000 | us-east-1 | us-east-1b | frontend 02 | utilisation du processeur | 65,6 | null |
| 2019-12-04 19:00:08 000 000000 | us-east-1 | us-east-1b | frontend 02 | memory\$1utilization | 85,3 | null |
| 2019-12-04 19:00:08 000 000000 | us-east-1 | us-east-1b | frontend 02 | network\$1bytes\$1in | null | 1 245 |
| 2019-12-04 19:00:08 000 000000 | us-east-1 | us-east-1b | frontend 02 | octets\$1out du réseau | null | 68 432 |
| 2019-12-04 19:00:20 000 000000 | us-east-1 | us-east-1c | frontend 03 | utilisation du processeur | 12.1 | null |
| 2019-12-04 19:00:20 000 000000 | us-east-1 | us-east-1c | frontend 03 | memory\$1utilization | 32,0 | null |
| 2019-12-04 19:00:20 000 000000 | us-east-1 | us-east-1c | frontend 03 | network\$1bytes\$1in | null | 1 400 |
| 2019-12-04 19:00:20 000 000000 | us-east-1 | us-east-1c | frontend 03 | octets\$1out du réseau | null | 345 |
| 2019-12-04 19:00:10 000 000000 | us-east-1 | us-east-1a | frontend 01 | utilisation du processeur | 15,3 | null |
| 2019-12-04 19:00:10 000 000000 | us-east-1 | us-east-1a | frontend 01 | memory\$1utilization | 35,4 | null |
| 2019-12-04 19:00:10 000 000000 | us-east-1 | us-east-1a | frontend 01 | network\$1bytes\$1in | null | 23 |
| 2019-12-04 19:00:10 000 000000 | us-east-1 | us-east-1a | frontend 01 | octets\$1out du réseau | null | 0 |
| 2019-12-04 19:00:16 000 000000 | us-east-1 | us-east-1b | frontend 02 | utilisation du processeur | 44.0 | null |
| 2019-12-04 19:00:16 000 000000 | us-east-1 | us-east-1b | frontend 02 | memory\$1utilization | 64,2 | null |
| 2019-12-04 19:00:16 000 000000 | us-east-1 | us-east-1b | frontend 02 | network\$1bytes\$1in | null | 1 450 |
| 2019-12-04 19:00:16 000 000000 | us-east-1 | us-east-1b | frontend 02 | octets\$1out du réseau | null | 200 |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | frontend 03 | utilisation du processeur | 66,4 | null |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | frontend 03 | memory\$1utilization | 86,3 | null |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | frontend 03 | network\$1bytes\$1in | null | 300 |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | frontend 03 | octets\$1out du réseau | null | 423 |
Trouvez l'utilisation moyenne du processeur, p90, p95 et p99 pour un hôte EC2 spécifique au cours des 2 dernières heures :
```
SELECT region, az, hostname, BIN(time, 15s) AS binned_timestamp,
ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.9), 2) AS p90_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.95), 2) AS p95_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.99), 2) AS p99_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY region, hostname, az, BIN(time, 15s)
ORDER BY binned_timestamp ASC
```
Identifiez les hôtes EC2 dont l'utilisation du processeur est supérieure de 10 % ou plus à l'utilisation moyenne du processeur de l'ensemble du parc au cours des 2 dernières heures :
```
WITH avg_fleet_utilization AS (
SELECT COUNT(DISTINCT hostname) AS total_host_count, AVG(measure_value::double) AS fleet_avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
), avg_per_host_cpu AS (
SELECT region, az, hostname, AVG(measure_value::double) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
GROUP BY region, az, hostname
)
SELECT region, az, hostname, avg_cpu_utilization, fleet_avg_cpu_utilization
FROM avg_fleet_utilization, avg_per_host_cpu
WHERE avg_cpu_utilization > 1.1 * fleet_avg_cpu_utilization
ORDER BY avg_cpu_utilization DESC
```
Trouvez l'utilisation moyenne du processeur regroupée à intervalles de 30 secondes pour un hôte EC2 spécifique au cours des 2 dernières heures :
```
SELECT BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
ORDER BY binned_timestamp ASC
```
Trouvez l'utilisation moyenne du processeur regroupée à intervalles de 30 secondes pour un hôte EC2 spécifique au cours des 2 dernières heures, en remplissant les valeurs manquantes à l'aide d'une interpolation linéaire :
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
Trouvez l'utilisation moyenne du processeur regroupée à intervalles de 30 secondes pour un hôte EC2 spécifique au cours des 2 dernières heures, en remplissant les valeurs manquantes à l'aide d'une interpolation basée sur la dernière observation reportée :
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LOCF(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
# Requêtes avec fonctions d'agrégation
Vous trouverez ci-dessous un exemple de jeu de données pour un scénario IoT illustrant des requêtes avec des fonctions agrégées.
**Topics**
+ [
## Exemple de données
](#sample-queries.iot-scenarios.example-data)
+ [
## Exemples de requêtes
](#sample-queries.iot-scenarios.example-queries)
## Exemple de données
Timestream vous permet de stocker et d'analyser les données des capteurs IoT telles que l'emplacement, la consommation de carburant, la vitesse et la capacité de charge d'une ou de plusieurs flottes de camions afin de permettre une gestion efficace de la flotte. Vous trouverez ci-dessous le schéma et certaines des données d'une table iot\$1trucks qui stocke des données télémétriques telles que l'emplacement, la consommation de carburant, la vitesse et la capacité de charge des camions.
| Heure | truck\$1id | Marque | Modèle | Flotte | capacité\$1carburant | capacité\$1charge | nom\$1mesure | valeur\$1mesure : double | valeur\$1mesure : varchar |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | lecture de carburant | 65,2 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | charge | 400,0 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | speed | 90,2 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | location | null | 47,6062 M, 122,3321 W |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | lecture de carburant | 10.1 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | charge | 950,3 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | speed | 50,8 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | location | null | 40,7128 degrés N, 74,0060 degrés W |
## Exemples de requêtes
Obtenez une liste de tous les attributs et valeurs des capteurs surveillés pour chaque camion de la flotte.
```
SELECT
truck_id,
fleet,
fuel_capacity,
model,
load_capacity,
make,
measure_name
FROM "sampleDB".IoT
GROUP BY truck_id, fleet, fuel_capacity, model, load_capacity, make, measure_name
```
Obtenez le dernier relevé de consommation de carburant de chaque camion de la flotte au cours des dernières 24 heures.
```
WITH latest_recorded_time AS (
SELECT
truck_id,
max(time) as latest_time
FROM "sampleDB".IoT
WHERE measure_name = 'fuel-reading'
AND time >= ago(24h)
GROUP BY truck_id
)
SELECT
b.truck_id,
b.fleet,
b.make,
b.model,
b.time,
b.measure_value::double as last_reported_fuel_reading
FROM
latest_recorded_time a INNER JOIN "sampleDB".IoT b
ON a.truck_id = b.truck_id AND b.time = a.latest_time
WHERE b.measure_name = 'fuel-reading'
AND b.time > ago(24h)
ORDER BY b.truck_id
```
Identifiez les camions qui ont consommé peu de carburant (moins de 10 %) au cours des dernières 48 heures :
```
WITH low_fuel_trucks AS (
SELECT time, truck_id, fleet, make, model, (measure_value::double/cast(fuel_capacity as double)*100) AS fuel_pct
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND (measure_value::double/cast(fuel_capacity as double)*100) < 10
AND measure_name = 'fuel-reading'
),
other_trucks AS (
SELECT time, truck_id, (measure_value::double/cast(fuel_capacity as double)*100) as remaining_fuel
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND truck_id IN (SELECT truck_id FROM low_fuel_trucks)
AND (measure_value::double/cast(fuel_capacity as double)*100) >= 10
AND measure_name = 'fuel-reading'
),
trucks_that_refuelled AS (
SELECT a.truck_id
FROM low_fuel_trucks a JOIN other_trucks b
ON a.truck_id = b.truck_id AND b.time >= a.time
)
SELECT DISTINCT truck_id, fleet, make, model, fuel_pct
FROM low_fuel_trucks
WHERE truck_id NOT IN (
SELECT truck_id FROM trucks_that_refuelled
)
```
Trouvez la charge moyenne et la vitesse maximale de chaque camion au cours de la semaine écoulée :
```
SELECT
bin(time, 1d) as binned_time,
fleet,
truck_id,
make,
model,
AVG(
CASE WHEN measure_name = 'load' THEN measure_value::double ELSE NULL END
) AS avg_load_tons,
MAX(
CASE WHEN measure_name = 'speed' THEN measure_value::double ELSE NULL END
) AS max_speed_mph
FROM "sampleDB".IoT
WHERE time >= ago(7d)
AND measure_name IN ('load', 'speed')
GROUP BY fleet, truck_id, make, model, bin(time, 1d)
ORDER BY truck_id
```
Découvrez l'efficacité de chargement de chaque camion au cours de la semaine écoulée :
```
WITH average_load_per_truck AS (
SELECT
truck_id,
avg(measure_value::double) AS avg_load
FROM "sampleDB".IoT
WHERE measure_name = 'load'
AND time >= ago(7d)
GROUP BY truck_id, fleet, load_capacity, make, model
),
truck_load_efficiency AS (
SELECT
a.truck_id,
fleet,
load_capacity,
make,
model,
avg_load,
measure_value::double,
time,
(measure_value::double*100)/avg_load as load_efficiency -- , approx_percentile(avg_load_pct, DOUBLE '0.9')
FROM "sampleDB".IoT a JOIN average_load_per_truck b
ON a.truck_id = b.truck_id
WHERE a.measure_name = 'load'
)
SELECT
truck_id,
time,
load_efficiency
FROM truck_load_efficiency
ORDER BY truck_id, time
```