Documentation de référence sur le langage MQL (Monitoring Query Language)

Il s'agit d'un manuel de référence pour le langage MQL Cloud Monitoring. Il aborde les sujets suivants :

le modèle de données sous-jacent à la base de données de séries temporelles à laquelle le langage MQL accède ;
la structure et la sémantique des requêtes ;
une description de chacune des opérations et fonctions à partir desquelles une requête est créée.

Modèle de données

Cloud Monitoring utilise une base de données de séries temporelles qui contient toutes les mesures ingérées concernant chaque élément surveillé (appelé ressource surveillée). Il décrit la structure logique de cette base de données.

L'élément principal est une série temporelle dont les données sont constituées d'observations de la ressource surveillée.

Les séries temporelles de la base de données sont organisées de manière logique en tables relationnelles, chacune contenant des séries temporelles ayant une signification et une structure communes. Les tables sont référencées par des requêtes qui renvoient des données, génèrent des graphiques et calculent des alertes.

La base de données comprend également des métadonnées qui modifient lentement les valeurs associées à une ressource surveillée et qui sont définies par la configuration utilisateur ou par le service qui met en œuvre le type de ressource surveillée.

Série temporelle

Une série temporelle est une séquence nommée de points, chacun constituant une valeur mesurée et l'heure à laquelle la valeur s'applique. Une série temporelle se compose de trois parties : un type, qui spécifie la structure de la série temporelle, un identifiant, qui attribue un nom unique à la série temporelle, ainsi qu'un historique, qui contient les données de la série temporelle. Chacune de ces trois parties est expliquée dans la présente section.

Un type de série temporelle spécifie la structure de l'identifiant et de l'historique d'une série temporelle. Il se compose de deux parties :

Un type de ressource surveillée (répertorié ici) qui désigne un genre particulier de ressource surveillée, telle qu'une instance Compute Engine (gce_instance) ou une base de données Cloud SQL (cloudsql_database). Il comporte un ensemble de descripteurs de libellés qui identifient de manière unique une instance de ce type de ressource surveillée.
Un type de métrique (répertorié ici) qui décrit un genre de mesure particulier pouvant être réalisé sur un ressource surveillée. Par exemple, les octets lus à partir du disque par une instance Compute Engine sont mesurés par la métrique nommée compute.googleapis.com/instance/disk/read_bytes_count, et l'utilisation des données d'une base de données Cloud SQL est mesurée par la métrique nommée cloudsql.googleapis.com/database/disk/bytes_used. Le type de métrique spécifie le type de la valeur de la mesure, les unités de la mesure et le genre de série temporelle. Il peut spécifier des descripteurs de libellés qui distinguent les séries temporelles mesurant différents aspects d'un même élément. Par exemple, command indiquant quelle commande est comptabilisée dans la métrique appengine.googleapis.com/memcache/operation_count.

Notez qu'un type de ressource surveillée et un type de métrique sont respectivement décrits par un MonitoredResourceDescriptor et un MetricDescriptor. Ceux-ci décrivent les types. Ils contiennent chacun un champ nommé type, qui contient le nom de la ressource surveillée ou du type de métrique.

Un identifiant de série temporelle est le nom de la série temporelle, qui l'identifie de manière unique parmi toutes les séries temporelles du même type. Il se compose d'un ensemble de valeurs, une pour chaque descripteur de libellé spécifié dans la ressource surveillée et les types de métriques qui constituent le type de série temporelle.

Les libellés du type de ressource surveillée identifient de manière unique l'instance spécifique du genre de ressource surveillée à partir de laquelle les mesures de la série temporelle ont été effectuées. Par exemple, la ressource surveillée gce_instance possède des libellés project_id, instance_id et zone qui identifient de manière unique une machine virtuelle Google Compute Engine spécifique.
Chaque libellé du type de métrique identifie le genre de mesure spécifique pour la métrique donnée qui est représenté dans la série temporelle. Par exemple, status indiquant l'état des commandes comptabilisées dans la métrique appengine.googleapis.com/memcache/operation_count peut avoir la valeur 'HIT' pour une série temporelle qui comptabilise les appels et 'MISS' pour une autre série temporelle qui comptabilise les échecs.

Un historique de séries temporelles est une séquence chronologique de points, chacun représentant une mesure simultanée d'une ou de plusieurs valeurs (par exemple, la charge du processeur ou la température et l'humidité) à un moment donné ou sur une période donnée. Un point comporte deux éléments :

L'étendue d'un point se compose d'une heure de fin, qui est toujours indiquée, et d'une heure de début qui peut ou non être indiquée. Si l'heure de début n'est pas indiquée, l'étendue du point correspond à un moment unique défini par l'heure de fin. Si l'heure de début est indiquée, elle doit être antérieure à l'heure de fin et l'étendue du point correspond à l'intervalle de temps qui commence à l'heure de début et se termine à l'heure de fin.

Deux points d'une série temporelle ne peuvent pas avoir la même étendue. De plus, les étendues des points d'une série temporelle sont limitées par le genre de série temporelle fourni par le type de métrique, comme décrit ci-dessous.
La valeur d'un point représente une mesure simultanée d'une ou de plusieurs valeurs (par exemple la charge du processeur, la température et l'humidité) qui s'applique aux heures de l'étendue du point. Le type de métrique décrit chaque valeur de mesure, en lui attribuant un nom et un type de valeur. S'il existe plusieurs valeurs de mesure, celles-ci sont classées selon un ordre particulier et peuvent être référencées par leur index dans cet ordre.

Une série temporelle type stockée dans la base de données de séries temporelles possède une valeur unique à chaque point. Le nom de la métrique dans le type de série temporelle est un URI et le nom de la valeur unique est la partie du nom de la métrique après le dernier /. Par exemple, la métrique appengine.googleapis.com/memcache/operation_count comporte une colonne de valeur nommée operation_count.

Une série temporelle qui résulte d'une requête peut avoir plusieurs points dont le type, le nom et l'ordre sont fournis par la requête.

Le type de métrique peut également spécifier des unités de mesure pour la valeur de la série temporelle si elle est de type Int, Double ou Distribution. Les unités sont fournies à l'aide d'un sous-ensemble du Code unifié des unités de mesure (UCUM). Par exemple, ms pour les millisecondes ou By pour les octets. Pour en savoir plus, consultez la section Unités de mesure.

Chaque valeur d'un point est associée à un type de valeur, spécifié par le type de métrique dans le type de série temporelle. En outre, chaque libellé de l'identifiant de série temporelle possède un type de valeur, fourni par le descripteur de libellé dans la ressource surveillée ou le type de métrique du type de série temporelle. Les types de valeurs sont les suivants.

Int : un entier signé de 64 bits.
String : une chaîne Unicode encodée en UTF-8.
Bool : une valeur booléenne.
Double : une valeur à virgule flottante IEEE de 64 bits.
Distribution : une valeur complexe contenant un histogramme et des statistiques qui fournissent une description récapitulative d'une population (ensemble) de valeurs de type Double. Les parties de cette valeur sont les suivantes :
- un décompte du nombre de valeurs dans la population ;
- la somme des valeurs de la population ;
- la somme de l'écart au carré des valeurs de la population ;
- une spécification de bucket indiquant les limites entre les buckets dans l'histogramme. Un bucket contient le nombre de valeurs comprises entre la limite inférieure et supérieure du bucket ;
- un histogramme indiquant le nombre de valeurs incluses dans chaque bucket.
Ces parties suffisent à calculer la moyenne, la variance, l'écart type et les estimations de centiles de la population.

Le type d'une valeur de point peut constituer l'un des éléments ci-dessus. Un type de libellé d'identifiant de série temporelle peut uniquement être String, Int ou Bool

Outre ces types, il existe deux autres types qui correspondent aux heures de début et de fin d'un point ou qui sont utilisés pour décrire les heures et les durées des requêtes.

Date : un point spécifique mesuré en tant que distance depuis l'époque Unix. Il s'agit d'une représentation indépendante d'un fuseau horaire d'un point dans le temps. Les heures de début et de fin d'un point sont de ce type.
Duration : une période de temps. Cette valeur n'a pas d'unité de mesure spécifique (bien que la résolution s'effectue en microsecondes), mais prend en charge une unité spécifique (par exemple, secondes) lorsqu'elle est convertie en Int ou Double.

L'ensemble de valeurs pour chaque type (à l'exception de Date et Duration) comprend une valeur appelée no-value qui indique l'absence de valeur spécifique. Cette valeur est utilisée dans deux cas :

lorsqu'aucune valeur spécifique n'est connue, par exemple lorsqu'une erreur (comme la division par 0) empêche le calcul d'une valeur ;
la valeur no-value sera appliquée à un libellé d'un identifiant de série temporelle lorsque le libellé est requis par le type de série temporelle, mais qu'aucune valeur n'est connue. Cela peut se produire si aucune valeur n'est connue lorsque la métrique est collectée ou si la série temporelle a été générée par une requête et que le calcul générant la valeur du libellé n'a pas généré de valeur. Notez que no-value est une valeur distincte et distingue donc l'identifiant de série temporelle de toute autre valeur ayant une valeur réelle pour le libellé donné.

La valeur no-value est distincte d'un NAN IEEE et d'une valeur de chaîne qui constitue la chaîne vide. Il est impossible qu'une valeur de point soit sans valeur (no-value).

Le genre de série temporelle décrit la signification des valeurs des points d'une série temporelle et limite les étendues de chaque point. Il existe trois genres de séries temporelles :

Gauge : la valeur d'un point d'une série temporelle Gauge est une mesure prise à l'heure de fin du point. Un point d'un flux Gauge ne comporte pas d'heure de début. Son étendue constitue donc un point unique dans le temps. La valeur d'un point peut représenter l'un des éléments suivants :
- un échantillon d'une variable (par exemple, la longueur d'une file d'attente ou une quantité de mémoire utilisée) ;
- une qualité d'état qui affiche "true" à l'heure du point et qui le restera jusqu'à l'heure du point suivant ;
- un résumé d'une certaine quantité (moyenne, valeur maximale, etc.) qui s'applique à la période comprise entre le point et le point immédiatement antérieur de la série temporelle.
Delta : pour les valeurs numériques (Int ou Double), chaque point représente la variation d'une valeur mesurée par rapport à l'étendue du point, c'est-à-dire entre l'heure de début (si indiquée) et l'heure de fin du point. Pour une valeur Distribution, il comprend une population des valeurs numériques qui ont été générées au cours de l'étendue du point. Le genre de série temporelle Delta doit avoir une valeur de type Int, Double ou Distribution.

Pour une série temporelle Delta, les étendues de deux points ne peuvent pas se chevaucher. Chaque point représente donc une modification indépendante de la valeur mesurée (numérique) ou une population disjointe de valeurs (Distribution). Idéalement, l'étendue de chaque point commence immédiatement après l'étendue du point immédiatement antérieur. La série temporelle est donc une description complète de la période couverte.
Cumulative : il s'agit d'une série temporelle Delta dont les étendues se chevauchent. La contrainte est la suivante : si les étendues de deux points se chevauchent, ces points doivent avoir la même heure de début. Ainsi, chaque point représente une augmentation cumulée d'une valeur mesurée sur le dernier point avec une heure de début commune.

Les métriques Cumulatives constituent un moyen efficace de collecter des séries temporelles à partir d'une source de données externe :
- La source n'a pas besoin de réinitialiser les compteurs ou les accumulateurs chaque fois qu'une valeur est collectée et peut être facilement surveillée sur plusieurs périodes.
- Les décomptes cumulés ne sont pas perdus en cas de points manquants ; le point suivant contient tous les décomptes depuis l'heure de début, y compris ceux du point manquant. Seule la résolution temporelle est perdue.
Toutefois, les séries temporelles cumulatives ne s'appliquent pas souvent aux requêtes. Pour simplifier les opérations sur des séries temporelles renvoyées par des requêtes, lorsqu'une série temporelle cumulative est récupérée, elle est automatiquement convertie en série temporelle delta, en faisant commencer l'étendue de chaque point à l'heure du point immédiatement antérieur et en définissant la valeur de ce point comme étant la variation observée depuis le point antérieur. Cela ne modifie pas les informations présentes, mais rend chaque point indépendant des autres. (Cette valeur peut être remplacée par fetch_cumulative.)

Pour une série temporelle dont les points ont plus d'une valeur, chaque valeur possède un genre de série temporelle qui peut uniquement être Gauge ou Delta. Si le genre d'une valeur est Delta, le genre de la métrique globale est Delta (par conséquent, chaque point a une heure de début et de fin). Sinon, le genre de la métrique est Gauge (et uniquement l'heure de fin).

Tables

Toutes les séries temporelles ayant le même type de série temporelle (type de ressource surveillée et type de métrique) sont organisées de manière logique dans une table relationnelle. Le nom de la table est composé du nom du type de ressource surveillée suivi du nom du type de métrique.

Une table comporte une ligne pour chaque point de chacune des séries temporelles incluses. La table comporte les genres de colonnes suivants :

Colonnes d'identifiant de séries temporelles : une colonne pour chaque libellé d'identifiant de série temporelle, comme spécifié par les types de ressources et de métriques surveillées. Le nom de la colonne correspond au nom du libellé (sa clé), et le type de la colonne correspond au type de valeur du libellé. Si un libellé de ressource surveillée et un libellé de métrique portent le même nom, le nom de la colonne de libellé de métrique est précédé de metric..

Une série temporelle est composée de toutes les lignes d'une table ayant la même valeur pour chacune des colonnes d'identifiant de série temporelle correspondantes.
Colonne(s) de temps : colonnes inhérentes à l'extension des points de la série temporelle Il y a toujours une colonne d'heure de fin à laquelle la fonction end() accède (un nom n'est pas attribué à la colonne). Si le genre de série temporelle de la métrique est Delta, la fonction start() accède à une colonne d'heure de début. (Il existe également une colonne d'heure de début pour les métriques dont le genre de série temporelle est de type Cumulative.) Les deux colonnes ont des valeurs de type Date.
Colonnes de valeurs : une colonne pour chaque valeur de la valeur des points de la série temporelle. Chaque colonne possède le nom et le type de cette valeur, et les colonnes de valeurs sont dans le même ordre que celui du type de métrique. Si une ressource surveillée ou un libellé de métrique porte le même nom qu'un nom de valeur, le nom de valeur inhérent au type de métrique est précédé de value. pour former le nom de la colonne.

Tous les points d'une série temporelle ont la même valeur dans les colonnes d'identifiant de série temporelle, et ces colonnes identifient de manière unique les séries temporelles. Les colonnes de séries temporelles et d'heure de fin constituent la clé primaire de la table, identifiant de manière unique une ligne et donc un point.

Le paragraphe ci-dessus décrit une table stockée composée de séries temporelles stockées dans la base de données. Une requête utilise les tables stockées comme entrées initiales et effectue des opérations de table successives (filtrage, agrégation, jointure, etc.). Il en résulte des tables dérivées intermédiaires en tant que sortie de ces opérations de table.

Une table dérivée a la même structure qu'une table stockée, avec toutefois quelques différences :

La table sera toujours associée à un type de ressource surveillée si la transformation qui l'a générée a conservé toutes les colonnes de libellés de ressources surveillées. Dans le cas contraire, elle n'est associée à aucun type de ressource surveillée. Cette information est importante pour les métadonnées (décrites dans la section suivante).
La table est décrite par un type de table plutôt que par un type de ressource surveillée et un type de métrique. Le type de table est identique au type de métrique, sauf que l'ensemble de libellés inclut toutes les colonnes de l'identifiant de série temporelle. Selon la dérivation réelle de la table, il est possible que les colonnes de l'identifiant de série temporelle n'aient pas de relation avec les colonnes spécifiées par un type de métrique ou de ressource surveillée réelle.
Une table dérivée n'a pas de nom.

Metadata

Un type de ressource surveillée peut avoir des types de métadonnées, chacun associant une valeur à chaque instance de ce type de ressource surveillée particulier. Chaque type de métadonnées possède un nom et un type de valeur (String, Int ou Bool).

Il existe deux genres de métadonnées :

Métadonnées système, qui sont créées par le service qui crée et gère la ressource surveillée. Le nom des métadonnées système est au format metadata.system_labels.<key>, où <key> identifie un type de métadonnées spécifique.
Métadonnées utilisateur, qui sont présentes lorsqu'un service permet à l'utilisateur d'associer des libellés à une ressource surveillée spécifique. Le nom des métadonnées utilisateur est au format metadata.user_labels.<key>, où <key> est la clé du libellé que l'utilisateur a associé à l'entité. Exemple : metadata.user_labels.my_key. La valeur des métadonnées utilisateur est toujours de type String.

Une table (stockée ou dérivée) associée à une ressource surveillée peut être considérée comme ayant des colonnes de valeurs virtuelles supplémentaires, une pour chaque type de métadonnées associé au type de ressource surveillée. Pour chaque ligne de la table, une colonne de métadonnées comprend la valeur de ces métadonnées au moment de la colonne d'heure de fin de la ligne. Ces colonnes de métadonnées supplémentaires ne font pas réellement partie de la table, mais elles peuvent être référencées dans des expressions de requête comme si elles l'étaient, en indiquant le nom des métadonnées dans les expressions fonctionnant sur une ligne de table.

Alignement

Une série temporelle est alignée dans le temps (ou simplement alignée) si l'heure de fin de ses points survient uniquement à intervalles réguliers. On dit d'une série temporelle qu'elle est alignée par rapport à une période et à une heure de base d'alignement spécifiques si chaque point de la série temporelle a une heure de fin qui constitue un multiple de la période d'alignement avant (ou après) l'heure de base de l'alignement. Par exemple, avec une heure de base d'alignement de 10:03 et une période d'alignement de 5 minutes, 09:48, 09:53, 09:58, 10:03, 10:08 sont des heures de fin valides pour les points.

Si les séries temporelles d'une table ont un genre de série temporelle Delta, l'heure de début de chaque point doit être antérieure à l'heure de fin par la durée de la période, de sorte que la durée de chaque point soit égale. Une table avec des heures de début de type Cumulative ne peut pas être alignée, car il n'est généralement pas possible d'aligner les heures de début des points entre différentes séries temporelles.

Si toutes les séries temporelles qui composent une table sont alignées par rapport à la même période et heure d'alignement, la table est alignée selon cette heure et cette période.

Lorsqu'une table est alignée, les points de différentes séries temporelles s'alignent les uns avec les autres dans le temps. Cela permet d'effectuer des opérations combinant différentes séries temporelles. Par exemple, si nous voulons obtenir la série temporelle qui correspond à la somme d'une métrique pour toutes nos ressources surveillées, les points de la série temporelle individuelle doivent être alignés, c'est-à-dire avoir le même alignement. Ensuite, la valeur des points de la série temporelle obtenue correspond à la somme des valeurs des points au même moment dans la série temporelle individuelle.

Syntaxe et sémantique

Éléments lexicaux

Le texte d'une requête est constitué d'une séquence de jetons, décrits dans la grammaire suivante, selon les règles suivantes :

Un jeton est décrit par l'un des symboles non terminaux en majuscules, dans la grammaire ci-dessous.
Un jeton autre que base_string ne comporte aucune espace blanche. Les espaces blanches sont des espaces, des tabulations, des sauts de ligne et des commentaires. Un commentaire est un texte qui n'est pas dans un base_string commençant par # et se terminant par un retour à la ligne.
Les espaces blanches entre les jetons sont ignorées, sauf pour séparer les jetons.
Deux jetons adjacents doivent être séparés par une espace si cette grammaire permet de les reconnaître en tant que jeton unique autre que BARE_NAME (qui est uniquement reconnu dans certains contextes).

ID : letter { letter_num_under } .
QUOTED_COLUMN : ( 'c' | 'C' ) base_string .
BARE_NAME : ( '/' | letter_num_under ) { letter_num_under | '.' | '/' | '-' } .
NUMBER : digit { digit } [ fraction | '.' ] [ exponent ] | fraction [exponent] .
STRING : [ 'r' | 'R' ] base_string .
DURATION : digit { digit } ( 's' | 'ms' | 'us' | 'm' | 'h' | 'd' | 'w' ) .
DATE : ( 'd' | 'D' ) base_string .

letter_num_under : letter | digit | '_' .
base_string : '\'' any-but-quote '\'' | '"' any-but-quote-quote '"' .
fraction : '.' digit { digit } .
exponent : ( 'e' | 'E' ) [ '-' | '+' ] digit { digit } .

letter - an ASCII letter
digit  - an ASCII digit
any-but-quote - any Unicode character except the ASCII control codes or `'`.
any-but-quote-quote - any Unicode character except the ASCII control codes or `"'.

Les identifiants (ID) permettent de nommer les opérations et les fonctions de la table intégrée qui font partie du langage MQL, ainsi que les colonnes et les métadonnées dans les expressions. La syntaxe fait la distinction entre un emplacement où un ID peut constituer une opération de table ou un nom de fonction et un emplcament où un ID peut constituer un nom de colonne. Par conséquent, aucun identifiant "réservé" ne peut être utilisé comme nom de colonne. Une QUOTED_COLUMN est utilisée pour attribuer le nom d'une colonne qui ne sera pas analysée comme identifiant. Exemple : c'total cpu'

Les jetons NUMBER, STRING, DURATION et DATE identifient les valeurs littérales. Une valeur NUMBER peut être suivie d'un élément unit qui indique les unités de mesure de cette valeur littérale en tant que STRING. Un jeton STRING peut contenir des caractères Unicode. S'il n'est pas précédé de r ou R, les séquences d'échappement normales sont reconnues. Le suffixe d'un jeton DURATION indique comment une durée est libellée : secondes, millisecondes, microsecondes, minutes, heures, jours ou semaines. L'élément base_string d'une date se compose d'une date au format 2010/06/23-19:32:15-07:00, où le premier - peut être un caractère espace et le fuseau horaire (-07:00) peut être supprimé (tout comme les secondes, les minutes ou les heures).

Les jetons restants sont des signes de ponctuation et des jetons d'opérateur qui apparaissent entre guillemets dans la grammaire suivante (par exemple, '^' ou '<=' ). Ces jetons sont ^, <=, <, ==, = =~, >=, >, ||, |, _, -, ,, ;, ::, :, !=, <>, !~, !, //, /, ., (, ), [, ], {, }, *, &&, %, +.

Structure d'une requête

Une requête est composée d'une séquence d'opérations de table (table_op), reliées par des opérateurs de barre verticale (|). Chaque opération de table utilise les tables en tant qu'entrée et génère des tables en tant que sortie. Les tables générées par une opération de table sont acheminées vers l'opération de table suivante, qui les utilise pour produire sa propre sortie de table.

query : table_op { '|' table_op } .
table_op : basic_table_op | grouped_table_op | shortcut_table_op .

basic_table_op : ID [ arg { ',' arg } ] .
arg : table_name | expr | map .

grouped_table_op:  '{' query { ';' query } '}' .

Il existe trois genres d'opérations de table (table_op) :

Une basic_table_op commence par un ID qui désigne le genre d'opération à effectuer (comme décrit ici). Elle est suivie par des arguments (arg) qui détaillent les actions de l'opération de table. Chaque genre de basic_table_op exploite zéro, une ou plusieurs tables en tant qu'entrée et génère une table en tant que sortie.
Une grouped_table_op est une liste numérotée de requêtes. Chacune des requêtes génère une table, et le résultat de la grouped_table_op est une liste numérotée de ces tables. Chacune des requêtes utilise, en tant qu'entrée, les mêmes tables d'entrée, qu'il y en ait plusieurs ou zéro, qui constituent les entrées de l'opération grouped_table_op.
Une shortcut_table_op est une notation de raccourci (décrite ici) pour une basic_table_op.

Les tables générées par une table_op sont transmises par l'opérateur de barre verticale (|) en tant qu'entrée de la prochaine opération table_op. Les règles suivantes permettent de transmettre des tables générées par une opération de table à gauche d'un opérateur de barre verticale (appelé producteur) à une opération de table à droite de l'opérateur de barre verticale (appelé consommateur) :

Une opération de table n'exploitant aucune entrée de table ne peut pas être un consommateur.
Dans le cas d'un producteur qui génère une seule table et d'un consommateur qui utilise une seule table, la table de sortie du producteur est une entrée pour le consommateur.
Dans le cas d'un producteur qui génère plusieurs tables et d'un consommateur qui utilise une seule table, le consommateur est appliqué séparément à chaque table d'entrée, et la sortie de l'opération de table du consommateur constitue une table pour chaque table d'entrée.
Dans le cas d'un producteur qui génère plusieurs tables et d'un consommateur qui utilise plusieurs tables, toutes les tables générées sont saisies par le consommateur.
Dans le cas d'un producteur qui génère une seule table et d'un consommateur qui est une grouped_table_op, la table unique est l'entrée de la première opération de table de chaque query de l'opération grouped_table_op.
Une grouped_table_op ne peut pas être un consommateur pour un producteur qui génère plusieurs tables.
La dernière table_op de chaque query dans une grouped_table_op ne doit produire qu'une seule table.

Les éléments "arg" de l'opération de table fournissent à l'opération de table des informations sur la manière dont elle doit traiter ses tables d'entrée dans une table de sortie. Un arg peut constituer l'un des trois éléments suivants :

un nom de table (table_name), qui nomme une table ou fait partie du nom d'une table à récupérer de la base de données Cloud Monitoring ;
une expression (expr), qui est une formule permettant de calculer une valeur. Il peut s'agir d'une valeur littérale connue statiquement ou d'une valeur calculée à partir des valeurs de colonne d'une ou de plusieurs lignes des tables d'entrée de l'opération de table ;
une carte (map), qui décrit comment calculer les colonnes de la table de sortie d'une opération de table. Une map contient une ou plusieurs expr qui calculent les valeurs des colonnes.

Noms des tables

Un table_name désigne un type de ressource surveillée, un type de métrique, un groupe ou une table. Ils sont utilisés dans les opérations de table qui récupèrent les tables de la base de données de série temporelle aux fins d'un traitement ultérieur.

table_name : name { '::' name } .
name : string | BARE_NAME | ID .

Un name unique fait référence à un type de ressource surveillée ou à un type de métrique, par exemple le type de ressource surveillée gce_instance ou aws_dynamodb_table ou le type de métrique loadbalancing.googleapis.com/http/backend_latencies.

Un type de ressource surveillée peut également être nommé à l'aide d'un nom de groupe ou d'un nom de type de ressource surveillée suivi de :: et d'un nom de groupe. Le premier peut être utilisé lorsque le groupe spécifie un type de ressource surveillée unique, et le second lorsque ce n'est pas le cas.

Le nom d'une table stockée est constitué du nom d'un type de ressource surveillée suivi de :: et d'un nom de type de métrique. Par exemple, gce_instance :: loadbalancing.googleapis.com/http/backend_latencies.

Expressions

Une expression (expr) est une formule permettant de calculer une valeur. Elle sert d'argument à une opération de table et décrit la transformation que l'opération de table effectuera sur ses tables d'entrée. Une expr peut être une expression littérale ou une expression dynamique.

Si une expression expr est littérale, elle est uniquement composée de valeurs littérales et d'appels de fonction simples dont les arguments constituent des valeurs littérales. Sa valeur est déterminée avant l'application de la requête aux tables.

Si une expression expr est dynamique, elle peut contenir des références à des colonnes de table et est utilisée pour calculer une valeur à partir d'une ou de plusieurs lignes de la table d'entrée. Il existe trois genres d'expressions dynamiques :

Expression de valeur : une expression de valeur génère une valeur pour chaque ligne de la table d'entrée à laquelle elle s'applique. Elle peut contenir des références à des colonnes de table et, lorsqu'elles sont évaluées pour une ligne d'entrée, ces références évaluent les valeurs de colonne correspondantes dans la ligne.
Expression d'agrégation : une expression d'agrégation génère une valeur pour un ensemble de lignes de table d'entrée. Elle peut être décomposée en trois parties :
- une ou plusieurs expressions de valeur appliquées individuellement à chaque ligne d'entrée pour produire une valeur pour chaque ligne. Ces expressions de valeur sont des arguments pour les fonctions d'agrégation ;
- une ou plusieurs fonctions d'agrégation qui exploitent une collection de valeurs d'entrée générées par les expressions de valeur et les réduisent en une valeur unique ;
- une expression externe sur des fonctions d'agrégation qui exploitent les valeurs résultant des fonctions d'agrégation et produisent la valeur de l'expression dans son ensemble.
Par exemple, l'expression d'agrégation sum(if(status >= 500, val(), 0)) / sum(val()) est répartie comme suit :
- Les expressions de valeur sont if(status >= 500, val(), 0) et val(). Celles-ci seront appliquées à chaque ligne d'entrée pour créer deux collections de valeurs.
- Les agrégateurs sont les deux appels de fonction sum, chacun utilisant en tant qu'entrée les collections de valeurs générées par l'expression de valeur constituant son argument.
- L'expression externe est l'opérateur de division (/) qui sera appliqué à la sortie finale de chacune des fonctions d'agrégation sum pour produire la valeur de l'expression globale.
Expression d'alignement : Une expression d'alignement consiste en un appel unique sur une fonction d'alignement. La fonction d'alignement génère une valeur de sortie à partir d'une série temporelle d'entrée et est utilisée par align pour produire une table alignée.

Chaque expression est composée d'éléments opnd (définis ci-dessous) connectés par des opérateurs.

expr : term { infix_op term } .
term : { prefix_op } opnd .
infix_op : '&&' | '||' | '^'
         | '==' | '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | '=~' | '!~'
         | '+' | '-'
         | '*' | '/' | '//' | '%' .
prefix_op : '+' | '-' | '!' .

Les opérateurs se comportent de façon habituelle selon la priorité. La table suivante classe les opérateurs en cinq groupes. Tous les opérateurs d'un groupe ont la même priorité, les groupes les plus élevés étant plus étroitement liés. Les opérateurs ayant la même priorité sont appliqués de gauche à droite. Chaque opérateur correspond à une fonction, donnée dans la table, qui est appliquée à ses opérandes.

opérateur	fonction	opération
`*` `/` `//` `%`	`mul` `div` `div` `rem`	Multiplication Division Division entière Reste entier
`+` `-`	`add` `sub`	Addition Soustraction
`==` `=` `!=` `<>` `<=` `>=` `>` `<` `=~` `!~`	`eq` `ne` `le` `ge` `gt` `lt` `re_full_match` `! re_full_match`	Comparaison d'égalité Comparaison d'inégalité Comparaison inférieure ou égale à Comparaison supérieure ou égale à Comparaison supérieure à Comparaison inférieure à Correspondance complète d'expression régulière Correspondance incomplète d'expression régulière
`&&`	`and`	Opérateur logique "et"
`\|\|`	`or`	Opérateur logique "ou"

Les opérateurs de préfixe +, - et ! correspondent respectivement aux fonctions unaires pos, neg et not et sont appliqués avant tout opérateur infixe.

Ainsi, a < b && a + b + c / -d == 5 équivaut à (a < b) && (((a + b) + (c / (-d))) == 5), ce qui équivaut à and(lt(a, b), eq(add(add(a, b), div(c, neg(d))), 5)).

Les opérateurs agissent sur les l'opérandes (opnd).

opnd : literal | column_meta_name | '_' | '(' expr ')' | call_chain .

literal : NUMBER [ unit ] | string | DURATION | DATE .
unit : STRING
string : STRING { STRING } .

column_meta_name : id { '.' id } .
id : ID | QUOTED_COLUMN .

Chaque opnd correspond à une façon particulière de calculer une valeur.

literal est la valeur du jeton littéral donné.
- Un littéral NUMBER peut être suivi d'un élément unit qui indique les unités de mesure de cette valeur littérale, par exemple 33 'By' pour 33 octets.
- Une chaîne string est constituée d'un ou de plusieurs jetons STRING qui sont concaténés en une valeur de chaîne. Ainsi, 'a-' 'b' possède la même valeur que 'a-b'.
column_meta_name nomme une colonne ou une colonne de métadonnées virtuelles dans la table d'entrée et évalue la valeur de cette colonne dans la ligne d'entrée à laquelle l'expression s'applique.
_ représente la valeur par défaut. Elle peut uniquement être donnée qu'en tant qu'argument réel à un argument formel facultatif.
'(' expr ')' est une expression entre parenthèses qui n'est que la valeur de l'expr.
call_chain correspond à un ou plusieurs appels de fonction en chaîne :

call_chain : [ ID arg_list ] { '.' call } .
arg_list : '(' [ expr { ',' expr } [ ',' ] ] ')' .
call : ID [ arg_list ] .

Chaque ID d'une call_chain désigne une fonction appliquée à zéro ou plusieurs arguments. Les arguments d'un appel de fonction peuvent provenir des colonnes de valeurs de la table d'entrée, du résultat d'un call précédent dans la chaîne d'appel ou de la valeur de l'expr dans une arg_list.

Si la chaîne d'appel commence par un ID (sans . avant), les arguments de la fonction appelée sont fournis par l'expr de la liste arg_list suivante.

Par exemple, add(error_count, 1) applique la fonction add à deux arguments : column_meta_name error_count et literal 1. Cela équivaut à error_count + 1.
Si une call_chain commence par '.' call, les colonnes de valeurs de la table d'entrée constituent le premier argument de la fonction appelée. Si call comporte une arg_list, la liste arg_list fournit des arguments supplémentaires.

Par exemple, .div appliqué à une table avec des colonnes de valeurs num et den équivaut à div(num, den) ou seulement num / den. L'expression .add(3) appliquée à une table avec une colonne de valeurs unique count équivaut à add(count, 3) ou seulement count + 3.
La fonction appelée par un call autre que le premier appel d'une chaîne d'appel utilise, en tant que premier argument, la sortie de la fonction précédemment appelée dans la chaîne d'appel. Si call comporte une arg_list, la liste arg_list fournit des arguments supplémentaires.

Par exemple, .mul(3).div(4) appliqué à une table avec une colonne de valeurs unique error_count équivaut à div(.mul(3), 4), qui équivaut à div(mul(error_count, 3), 4), ce qui équivaut à error_count * 3 / 4 ou (error_count * 3) / 4.

Notez que les colonnes des heures de fin et de début d'une table n'ont pas de nom de colonne. La valeur des colonnes de temps est accessible à l'aide des fonctions end et start.

Maps

Une map calcule les valeurs des colonnes d'une ligne de sortie et leur donne des noms. Selon l'emplacement d'utilisation de la map, il s'agira d'un identifiant de série temporelle map, qui calcule les colonnes d'identifiant de série temporelle de la ligne de sortie, ou d'une valeur map, qui calcule les colonnes de valeurs de la ligne de sortie.

map : [ modifier ] '[' [ maplet { ',' maplet } ] ']' .
modifier : ID .
maplet : [ column_name ':' ] expr .
column_name : ID | QUOTED_COLUMN .

Chaque valeur expr dans maplet calcule la valeur d'une colonne de sortie et le column_name correspond au nom de la colonne. Si aucun column_name n'est fourni, un nom est généré à partir de la fonction expr. Si expr est simplement le nom d'une colonne d'entrée, column_name est identique. Si des fonctions sont appliquées, elles sont ajoutées au nom. Par exemple, le nom de sum(error_count / 3) est error_count_div_sum.

Les colonnes de sortie calculées par la map (valeur ou identifiant de série temporelle) proviennent des maplet de la map et du genre de colonnes correspondant (valeur ou identifiant de série temporelle) dans la table d'entrée. La procédure à suivre dépend du modifier :

Aucun modifier Les colonnes correspondantes de la ligne de sortie se composent exactement des colonnes spécifiées par un maplet de la map. Le nom de la colonne est soit explicitement donné par un ID ou une QUOTED_COLUMN, soit dérivé du format de l'expression expr. La valeur de la colonne dans la ligne de sortie est la valeur de l'expression expr.

Chaque maplet doit comporter un nom de colonne (explicite ou dérivé) unique parmi toutes les colonnes de la table de sortie.

Par exemple, l'application de [ratio: num/den] en tant que colonne de valeurs map à une table, avec des colonnes de valeurs num et den, résulterait en une table de sortie avec une colonne de valeurs ratio, où la valeur de colonne ratio correspond au ratio des deux colonnes d'entrée.

L'application de [zone] en tant qu'identifiant de série temporelle map à une table avec des colonnes d'identifiant de série temporelle project_id, zone et instance résulterait en une table avec simplement une colonne d'identifiant de série temporelle zonedont la valeur est identique celle de la colonne de table d'entrée zone.
add Toutes les colonnes du genre correspondant (valeur ou identifiant de série temporelle) de la ligne d'entrée sont incluses dans la ligne de sortie. En outre, pour chaque maplet de la map, il existe une colonne de sortie supplémentaire dont le nom et la valeur sont fournis par le maplet.

Chaque maplet doit comporter un nom de colonne (explicite ou dérivé) unique parmi toutes les colonnes de la table de sortie.

Par exemple, l'application de add[ratio: num/den] en tant que valeur map à une table avec des colonnes de valeurs num et den résulterait en une table de sortie avec des colonnes de valeurs num, den et ratio, où la valeur de colonne ratio correspond au ratio des deux autres colonnes.
update Toutes les colonnes du genre correspondant (valeur ou identifiant de série temporelle) de la ligne d'entrée dont le nom de colonne est différent de celui d'un maplet de la map sont incluses dans la ligne de sortie. En outre, pour chaque maplet de la map, il existe une colonne de sortie supplémentaire dont le nom et la valeur sont fournis par le maplet.

Chaque maplet doit comporter un nom de colonne (explicite ou dérivé) unique parmi toutes les colonnes de la table de sortie. Il peut désigner une colonne du genre correspondant dans l'entrée qu'il remplace.

L'exemple suivant illustre un identifiant de série temporelle map :
```
  update[job: re_extract(job, '[^-]*-(.*)', r'\1'),
         kind: re_extract(job, '([^-]*)-.*', r'\1')]
```
L'utilisation d'une table avec des colonnes d'identifiant de série temporelle user, job et zone résulterait en une table de sortie avec une colonne d'identifiant de série temporelle user, job, zone et kind.
drop Chaque maplet doit être constitué d'une expression expr qui constitue simplement le nom d'une colonne d'entrée du genre correspondant. Les colonnes de sortie sont constituées de toutes les colonnes d'entrée du genre correspondant, à l'exception de celles désignées dans une expression expr du maplet.

Tous les maplet ne doivent pas avoir un column_name, et l'expression expr doit simplement désigner une colonne du genre correspondant dans la table d'entrée.

Par exemple, l'application de drop [job, user] en tant qu'identifiant de série temporelle map à une table avec des colonnes d'identifiant de série temporelle user, job et zone résulterait en une table de sortie avec une colonne d'identifiant de série temporelle zone.
ignore Chaque maplet doit être constitué d'une expression expr qui ne constitue qu'un nom de colonne. Si le nom est le nom d'une colonne d'entrée du genre correspondant, cette colonne n'apparaît pas dans les colonnes de sortie. Si le nom de la colonne maplet ne désigne pas une colonne de table d'entrée du genre correspondant, maplet n'a aucun effet. Ainsi, les colonnes de sortie sont constituées de toutes les colonnes d'entrée du genre correspondant, à l'exception de celles désignées dans une expr du maplet.

Tous les maplet ne doivent pas avoir un column_name, et l'expression expr doit simplement constituer un nom de colonne, sans toutefois être le nom d'une colonne de la table d'entrée. Si le maplet ne désigne pas une colonne dans la table d'entrée, il est ignoré.

Par exemple, l'application de ignore [job, instance] en tant qu'identifiant de série temporelle map à une table avec des colonnes d'identifiant de série temporelle user, job et zone résulterait en une table de sortie avec des colonnes d'identifiant de série temporelle user et zone (et l'instance du maplet est ignorée).
rename Chaque maplet doit comporter un column_name explicite et une expression expr qui fait simplement référence à une colonne du genre correspondant dans la table d'entrée. Les colonnes de sortie correspondent à toutes les colonnes du genre correspondant dans la table d'entrée, si elles sont référencées dans un maplet par un nouveau nom donné par le column_name du maplet.

Le column_name de chaque maplet doit être unique parmi les noms de colonne de la table de sortie.

Par exemple, l'application de rename[numerator : num, denominator : den] en tant que colonne de valeurs map à une table d'entrée avec des colonnes de valeurs num, den et ratio résulterait en une table de sortie avec des colonnes de valeurs numerator, denominator et ratio.

Unités de mesure

Chaque valeur numérique (Int, Double et Distribution) peut être associée à une unité de mesure indiquant l'unité utilisée par cette valeur. Les unités sont représentées par des chaînes de caractères qui constituent un sous-ensemble du code unifié des unités de mesure (UCUM). Par exemple, une valeur représentant un nombre d'octets aura pour unité "By" et une autre, représentant un taux d'octets transférés, présentera l'unité "By/s".

Les unités sont associées aux colonnes de tables produites par les opérations de table et à la valeur des expressions. Elles sont associées à la colonne ou à l'expression de manière statique, de la même façon que le type. Toute colonne ou expression associée à un type numérique peut être associée à des unités, mais ce n'est pas obligatoire.

Les unités associées aux colonnes des tables proviennent des sources suivantes :

Les descripteurs de métriques peuvent spécifier les unités associées à la valeur d'une métrique. Vous pouvez les consulter dans la documentation décrivant les métriques (par exemple, ici). Les colonnes de valeurs des tables produites par les opérations de table fetch et metric possèdent les unités spécifiées par le descripteur de métrique.
Les colonnes d'une table de sortie qui constituent une simple copie de la table d'entrée possèdent les mêmes unités que les colonne de la table d'entrée. Ainsi, par exemple, l'opération de table filter ne modifie pas les unités des colonnes de la table d'entrée et les transmet telles quelles à la sortie.
L'opération de table union combine plusieurs tables en une seule, et toutes les tables doivent avoir les mêmes colonnes. Chaque colonne de valeur d'une table d'entrée doit être associée soit à aucune unité, soit (le cas échéant) à une unité équivalente à celles associées à cette même colonne dans toutes les autres tables d'entrée. Si des unités sont associées à une colonne de n'importe laquelle des tables d'entrée, la colonne correspondante de la table de sortie possède les mêmes unités. Si aucune des tables d'entrée ne comporte d'unités pour une colonne, la colonne correspondante dans la table de sortie ne présente pas non plus d'unités.
Pour les opérations de table contenant un élément expr qui calcule une valeur de colonne de table de sortie, les unités de la colonne de sortie correspondent aux unités associées à cet élément expr, comme décrit ci-dessous.

Les unités associées à un élément expr dépendent du format de cet élément expr :

Les valeurs littérales elles-mêmes n'ont pas d'unités. Cependant, des littéraux numériques (Int ou Double) peuvent se voir associer des unités en faisant suivre la valeur d'une chaîne de caractères spécifiant ces unités. Ainsi, 3 "By" est un élément expr dont la valeur est 3 (de type Int) et dont l'unité est en octets (By).
Les expressions de référence de colonne récupèrent les unités de la colonne nommée dans la table d'entrée, si celle-ci comporte des unités.
Les fonctions et les opérateurs déterminent l'unité de mesure de leurs valeurs de sortie à partir des unités de leurs valeurs d'entrée. Ainsi, si amount possède l'unité By et time l'unité s, amount / time possède l'unité By/s. Les fonctions utilisant deux arguments numériques nécessitent généralement que ces deux arguments possèdent des unités ou qu'aucun d'eux n'ait d'unité. La documentation de chaque fonction décrit comment celle-ci traite les unités de mesure.

De nombreuses fonctions ont des exigences concernant la concordance des unités. Par exemple, pour add, si les deux opérandes possèdent des unités, celles-ci doivent être identiques. Ces exigences sont décrites dans la documentation de chaque fonction.
Les fonctions scale et cast_units possèdent des fonctionnalités spécifiques aux unités.

La fonction scale multiplie une valeur ayant une unité donnée par un facteur d'échelle qui convertit cette valeur vers une unité différente. Ainsi, avec un élément expr ev ayant l'unité "KiBy" (kibi-octets), l'application de scale(ev, "By") conduit à multiplier ev par 1 024 et à associer au résultat l'unité By. Cela équivaut à ev * 1024 'By/KiBy'.

La fonction cast_units renvoie l'argument avec l'unité fournie, quelle que soit l'unité d'origine de l'argument (s'il y en avait une). Ainsi, cast_units(ev, 'By/s') renvoie la valeur de ev sans modification mais avec l'unité By/s.

Le sous-ensemble d'unités UCUM compatibles avec MQL est constitué des valeurs de chaîne qui suivent la grammaire ci-dessous :

digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
exponent : [ '+' | '-' ] { digit }
simple_unit : [ PREFIX_SYMBOL ] ATOM_SYMBOL
annotatable : '10^' exponent | simple_unit
component : annotatable [ annotation ] | '1'
annotation : “{” ANNOTATION-STRING “}” | annotatable | annotation
unit : component { '.' component } { '/' component }

Un élément simple_unit spécifie une unité donnée par un élément ATOM_SYMBOL, éventuellement précédé d'un facteur de mise à l'échelle indiqué par un PREFIX_SYMBOL.

Un élément ATOM_SYMBOL fournit une unité de mesure de base :

texte	signification
s	seconde
min	minute (60 secondes)
h	heure (60 minutes)
d	jour (24 heures)
wk	semaine (7 jours)
bit	bit
By	octet (8 bits)
%	10^-2 (ratio sans dimensions, ajusté en %)
m	mètre
g	gramme
K	Kelvin
C	Coulomb
Hz	Hertz (1/s)
J	Joule (kg.m.m/s/s)
W	Watt (kg.m.m/s/s/s) (J/s)
A	Ampère (C/s)
V	Volt (kg.m.m/s/s/C) (J/C)

Un élément PREFIX_SYMBOL fournit un facteur d'échelle pour l'unité de base qu'il précède.

texte	signification	échelle
k	kilo	10^3
M	méga	10^6
G	giga	10^9
T	téra	10^12
P	péta	10^15
E	exa	10^18
Z	zetta	10^21
Y	yotta	10^24
m	milli	10^-3
u	micro	10^-6
n	nano	10^-9
p	pico	10^-12
f	femto	10^-15
a	atto	10^-18
z	zepto	10^-21
y	yocto	10^-24
Ki	kibi	2^10
Mi	mébi	2^20
Gi	gibi	2^30
Ti	tébi	2^40
Pi	pebi	2^50

Une unité sans dimension peut être renseignée avec 1 ou avec une puissance de 10 (10^ exponent, par exemple 10^2). L'unité 1 est l'unité attribuée à la plupart des métriques de compteur. Cela permet également d'utiliser des ratios sans dimension exprimés en pourcentages %. Ainsi, 10^-2 correspondent % aux mêmes unités. En d'autres termes, ajouter 3 à un pourcentage revient à ajouter 0,03 au ratio correspondant. La valeur de l'élément exponent est limitée à l'intervalle allant de -128 à 127.

Une annotation est un commentaire qui peut être associé à un élément annotatable (simple_unit ou puissance de 10) et ne modifie pas le sens de l'unité. Une annotation qui n'est pas associée à une unité est traitée comme si elle était associée à l'unité 1. Ainsi, {queries}/s équivaut à 1/s, l'unité 1 étant décorée par {queries}.

Une chaîne d'unité peut être composée de plusieurs chaînes component, connectées par des caractères . ou /. Le connecteur . indique que les unités sont multipliées tandis que le connecteur / indique qu'elles sont divisées. La multiplication et la division sont appliquées de gauche à droite. Le sous-ensemble d'unités UCUM compatibles avec MQL exige que tous les connecteurs de division soient placés après les connecteurs de multiplication. Cela permet d'éviter un problème tel que l'écriture des unités d'accélération sous la forme m/s.s lorsqu'il faut en réalité avoir m/s/s. Notez bien que, dans les unités UCUM, m/s.s est identique à m.s/s ou simplement à m.

Deux chaînes d'unité sont équivalentes si elles possèdent la même dimension et la même échelle, quelle que soient les annotations. La dimension et l'échelle sont déterminées de la manière traditionnelle :

Chaque élément component est sans dimension ou possède une dimension constituée d'une combinaison de temps, longueur, données, masse ou charge. Par exemple, bit et By ont tous deux une dimension données. Les dimensions d'une chaîne d'unité sont déterminées en convertissant chaque élément annotable vers sa dimension, en multipliant et en divisant celles-ci telles qu'elles sont indiquées par la chaîne d'unité, et en annulant les dimensions qui apparaissent au numérateur et au dénominateur. Ainsi, b.h/s (bit-heure par seconde) possède une dimension données multipliée par une dimension temps et divisée par une dimension temps : les dimensions temps s'annulent pour ne laisser que la dimension données.
Chaque élément annotable possède une échelle relative aux aux unités de base de sa dimension. Par exemple, h (heure) possède la dimension temps ayant pour unité de base s, et un facteur d'échelle de 3 600 (chaque heure compte 3 600 secondes). Le facteur d'échelle d'une chaîne d'unité est la combinaison des facteurs d'échelle de chaque composant (component) combinés par multiplication et division.

Les littéraux numériques peuvent se voir attribuer des unités en faisant suivre la valeur de la chaîne correspondant à l'unité de mesure souhaitée. Ainsi, 3 "m/s" correspond à la valeur 3 avec l'unité m/s et 10.8 "km/h" représente la même vitesse, avec pour valeur 10.8 et pour unité km/h.

Une valeur comportant une unité peut être mise à l'échelle vers une unité différente ayant la même dimension à l'aide de la fonction scale. Exemple : MiBy et By sont associées à la dimension données avec comme facteur d'échelle respectif 8*1024 et 8 (par rapport à l'unité de base de la dimension données, c'est-à-dire le bit ). Une valeur x ayant comme unité MiBy peut être mise à l'échelle vers une valeur ayant comme unité By en utilisant l'expression scale(x, "By"). L'opération multiplie x par 1 024 et renvoie une valeur ayant l'unité By. Cela équivaut à l'expression x * 1024 "By/MiBy", size * 1024 "By/MiBy" et l'unité de l'expression résultante est MiBy.By/MiBy ou simplement By.

La fonction scale vérifie que l'unité demandée possède la même dimension que celle de la valeur mise à l'échelle.

Si size est une colonne dont la valeur a l'unité "KiBy", l'expression scale(size, "By") est identique à size * 1024 "By/KiBy" et l'unité de l'expression obtenue est MiBy.By/MiBy ou simplement By.

Dans certains cas limités, MDL adapte ou fournit automatiquement des unités pour une valeur.

Pour une fonction f nécessitant deux arguments avec des unités équivalentes (add, sub, n'importe quel opérateur de comparaison numérique, if et or_else) , l'un des arguments peut être un appel à la fonction scale sans le second argument d'unité. Si l'unité de l'autre argument de f a la même dimension que l'unité de l'argument de la fonction scale, le deuxième argument de la fonction scale sera automatiquement défini avec les unités de l'autre argument de f. Ainsi, les unités de deux arguments de f sont équivalentes et f est en mesure de fonctionner.

Par exemple, l'opérateur + exige que ses arguments aient des unités équivalentes, car il n'est pas logique d'ajouter deux nombres ayant des unités différentes. Si cache_size possède l'unité By et heap_size l'unité MiBy, l'expression scale(cache_size) + heap_size équivaut à l'expression scale(cache_size, "MiBy") + heap_size.
Pour toute fonction de comparaison, si l'un des arguments est un littéral avec une unité ayant la même dimension mais une échelle différente de l'autre argument, ce littéral est mis à l'échelle pour que les deux arguments aient la même échelle.

Par exemple, si "cache_size" possède l'unité By, l'expression cache_size < 3 "KiBy" est équivalente à l'expression cache_size < 3072 "By". Notez que ce n'est pas la même chose que l'expression cache_size < scale(3 "KiBy", "By") si cache_size est de type Int, car scale convertira alors son résultat en type Double, ce qui peut réduire la précision de la comparaison. Dans ce cas, le scaling de nombre entier tient compte de l'arrondi et de la gestion du débordement pour cette comparaison particulière.
Pour chacun des arguments de mul ou le diviseur de div, un littéral sans unité se verra affecter l'unité "1". Cela tient compte des opérations de mise à l'échelle qui ne sont pas destinées à modifier les unités (par exemple, demander la valeur d'un taux s'il était le double de sa valeur actuelle). Pour modifier les unités, il est préférable d'utiliser scale, qui sélectionne automatiquement le facteur d'échelle approprié pour la conversion.

Les erreurs d'unité sont traitées comme des avertissements lors de l'évaluation d'une requête, de sorte que la requête produit toujours des résultats. Lorsque vous définissez une alerte, les erreurs d'unité sont traitées comme des erreurs réelles et cela empêche la définition de l'alerte.

Il est important de comprendre que les types Duration et Date ne sont PAS des types numériques et qu'ils ne possèdent pas d'unités. La valeur 60s de type Duration est une durée non numérique représentant exactement la même durée que 1m ou 60000ms. L'expression 60s == 60000ms est valide et vraie.

Une valeur numérique accompagnée d'une unité de temps est différente. Les nombres 3 'min' et 180 's' sont deux valeurs numériques différentes (3 et 180) ayant des unités différentes. Sans mise à l'échelle, il n'est pas valide de les comparer.

La fonction scale convertit les valeurs Duration et Date en valeurs Double avec des unités. Par exemple, scale(60s, "min"), scale(1m, "min") et scale(60000ms, "min") renvoient tous la valeur 1.0 avec l'unité min.

Raccourcis des opérations de table

Un raccourci est un moyen simplifié de spécifier une opération de table de base.

shortcut_table_op : shortcut { ',' arg } .
shortcut : table_name | '(' expr ')' | map | DURATION .

Il existe plusieurs formes d'opérations de table de raccourci, chacune désignant un genre d'opération de table de base :

Un raccourci de promotion de fonction ressemble à une opération de table normale, mais l'opération de table commence par un ID qui désigne une fonction au lieu d'une opération de table, et les éléments arg qui suivent (qui sont tous au format expr) sont les arguments de la fonction.

La fonction est promue en fournissant une opération de table pour laquelle elle devient un argument. Les colonnes de valeurs de la table d'entrée deviennent les premiers arguments de la fonction, comme si celle-ci avait été précédée d'un opérateur .. Les promotions spécifiques sont les suivantes :
- Une fonction ordinaire devient l'argument d'une opération de table value, en calculant la colonne de valeurs unique de sa table de sortie.
  
  Par exemple, | add 3 est un raccourci pour value [.add(3)], et | div est un raccourci pour | value [.div].
- Une fonction d'agrégation devient le deuxième argument d'une opération de table group_by dont le premier argument est la map vide ([ ]). Ainsi, la fonction calcule la colonne de valeurs unique d'une table de sortie sans colonnes d'identifiant de série temporelle (une table avec une seule série temporelle).
  
  Par exemple, | min est un raccourci pour | group_by [], [.min].
- Une fonction d'alignement devient l'argument d'une opération de table align, effectuant ainsi son genre d'alignement désigné sur la série temporelle de la table d'entrée.
  
  Par exemple, | delta 10m est un raccourci pour l'opération de table | align [.delta(10m)].
Un raccourci de dénomination commence par un table_name qui est utilisé comme argument pour l'opération de table resource, metric ou fetch, selon le genre d'éléments que le table_name désigne.

Par exemple, | gce_instance est un raccourci pour l'opération de table | resource gce_instance et | gce_instance :: compute/instance/cpu/usage_time est un raccourci pour | fetch gce_instance :: compute/instance/cpu/usage_time.
Un raccourci de filtrage est constitué d'une expression expr entre parenthèses, qui devient le prédicat d'une opération de table filter.

Par exemple, | (job == 'search') est un raccourci pour | filter job == 'search'.
Un raccourci de regroupement commence par une map, qui devient le premier argument d'une opération de table group_by. Il peut être suivi d'un arg qui constitue une map décrivant l'agrégation qui calcule les colonnes de valeurs de la table de sortie.

Par exemple, | [zone] est un raccourci pour | group_by [zone].
Un raccourci de fenêtrage commence par une DURATION qui devient le premier argument d'une opération de table group_by. Il doit être suivi d'un arg qui constitue une map décrivant l'agrégation qui calcule les colonnes de valeurs de la table de sortie.

Par exemple, | 10m, [.sum] est un raccourci pour | group_by 10m, [.sum].
Un raccourci de durée commence par une DURATION et n'est pas suivi d'un arg. Il devient une opération de table for, précisant l'étendue globale dans le temps de l'opération de requête.

Par exemple, | 10m est un raccourci pour | for 10m.

Description des fonctions et des opérations de table

Chaque description de fonction et d'opération de table de langage MQL commence par une signature de documentation indiquant les entrées de table (pour les opérations de table) et les types d'arguments pouvant être fournis pour la fonction ou l'opération de table. Cette section décrit le format de ces signatures.

Notez que ces signatures ne font PAS partie du langage MQL même. Elles sont utilisées pour décrire le langage MQL.

Une signature d'opération de table commence éventuellement par un type qui décrit les tables d'entrée des opérations de table, suivi du nom de l'opération de table ainsi que d'une liste d'arguments décrivant les arguments valides pour l'opération de table. Par exemple, la signature de l'opération de table pick :

Table | pick lit-Int, [ TSIDSel ], [ Windowed(Num) ]

Cette opération de table utilise une Table en tant qu'entrée (le cas le plus courant) et comporte trois arguments potentiels, décrits par lit-Int, [ TSIDSel ] et [ Windowed(Num) ].

La table d'entrée et | sont facultatifs. S'ils ne sont pas indiqués, l'opération de table n'exploite pas de table d'entrée. La spécification de la table d'entrée est l'une des suivantes :

Table L'entrée de l'opération de table est une table unique.
Table++ L'opération de table utilise au moins deux tables en tant qu'entrée.
Resource L'opération de table utilise une collection de tables spécifiées par un type de ressource surveillée (toutes les tables contenant des séries temporelles dont le type inclut un type de ressource surveillée particulier).
ResourceOrTable Soit Table, soit Resource est autorisé en tant qu'entrée.

Chaque descripteur d'argument de la liste d'arguments qui suit le nom de l'opération de table se compose des parties suivantes :

Il peut être placé entre [ ], auquel cas il est facultatif et l'argument réel peut être défini comme _ ou omis si l'argument réel est placé après tous les arguments explicitement indiqués.
Il peut comporter un préfixe lit-, qui indique que la valeur de l'argument doit être une valeur constante connue avant l'évaluation de la requête.
Il comporte toujours le nom d'un type de valeur ou d'une classe de types (décrite ci-dessous) qui décrit le type d'argument réel autorisé.
Il peut comporter un suffixe qui précise un genre de série temporelle qui restreint le genre de série temporelle de la valeur d'entrée.

Le nom du type descripteur d'argument peut être l'un des types décrits ici : Bool, Int, Double, Distribution, String, Duration ou Date. Dans ce cas, l'argument réel doit être une expression du même type.

Les éléments suivants indiquent que l'argument réel doit être un table_name désignant une métrique, une ressource surveillée ou une table, respectivement :

MetricName
ResourceName
TableName

Un descripteur d'argument peut désigner une catégorie indiquant que l'argument réel peut constituer une expression de l'un de ces types :

Num Soit Int, soit Double.
Summable Types de valeurs pouvant être additionnées : Int, Double ou Distribution.
Comparable Types de valeurs pouvant être comparées : Int, Double, String, Bool, Duration ou Date.
ColumnValue Types de valeurs de colonne valides : Int, Double, String, Bool ou Distribution.
Windowed(Num) Un Num, potentiellement annoté par les fonctions within, ago ou bottom.
WindowDuration Une Duration, potentiellement annotée par window ou sliding.
BucketSpecification Une spécification de bucket pour une Distribution.

Une opération de table peut nécessiter un argument map spécifiant les colonnes d'identifiant de série temporelle de la ligne de sortie ou les colonnes de valeurs. Ceci est indiqué par l'un des éléments suivants :

RowToTSID Une carte décrivant les colonnes d'identifiant de série temporelle de la table de sortie.
TSIDSel Une carte désignant les colonnes d'identifiant de série temporelle à conserver. Chaque maplet de la map doit uniquement être constitué d'une expression expr qui désigne une colonne (ID ou column_name). Par exemple, [zone, name] implique que les colonnes de sortie ne contiennent que les colonnes d'identifiant de série temporelle d'entrée zone et name, toutes les autres colonnes d'entrée étant supprimées.
RowToVal Une carte décrivant les colonnes de valeurs d'une table de sortie. Si une expression non issue d'une carte est fournie en tant qu'argument réel, elle est promue pour être une carte à élément unique avec cette expression.
RowSetToVal Une carte décrivant les colonnes de valeurs d'une table de sortie par agrégation. Si une expression non issue d'une carte est fournie en tant qu'argument réel, elle est promue pour être une carte à élément unique avec cette expression.
DefaultColumns Une carte décrivant les colonnes de valeurs par défaut pour une outer_join. Si une expression non issue d'une carte est fournie en tant qu'argument réel, elle est promue pour être une carte à élément unique avec cette expression.

Une signature de fonction commence par le nom de la fonction, suivi d'une liste d'arguments entre parenthèses décrivant les arguments valides de la fonction, suivie d'un type renvoyé décrivant la valeur renvoyée par la fonction. Par exemple, la signature de la fonction fraction_less_than :

fraction_less_than(Summable, lit-Num) → Double

Cette fonction exploite deux arguments décrits par Summable et lit-Num et renvoie une valeur de type Double. La liste des arguments contient les mêmes éléments que ceux décrits ci-dessus pour les opérations de table. Le type renvoyé peut constituer un type de valeur spécifique, indiquant que la valeur renvoyée sera de ce type ou l'une des valeurs suivantes :

Num : si l'un des arguments de la fonction est Double, la valeur est Double, sinon, Int.
ColumnValue : le même type que le premier argument réel de la fonction.
LastArgType : le même type que le dernier argument réel de la fonction.
Windowed() : le même type que l'argument réel Windowed, annoté avec le type Windowed. (Si l'argument réel Windowed est de type Int, le type renvoyé est Windowed(Int).) (Voir les fonctions within, ago ou bottom)

Un descripteur d'argument de fonction ou un type renvoyé peut comporter un indicateur qui contrôle le genre de série temporelle de l'argument ou du résultat. Ceux-ci constituent l'un des suffixes suivants :

.Cumulative, .Delta ou .Gauge indiquent que l'argument réel doit avoir le genre de série temporelle donné.
.CumulativeOK signifie qu'un argument réel peut être de type Cumulative.
.FirstArgKind implique, uniquement pour les types renvoyés, le même genre de série temporelle que le premier argument de la fonction.

Si un argument ne possède pas de suffixe de genre de série temporelle, le genre de série temporelle de l'argument doit être de type Gauge ou Delta. Si un type renvoyé n'a pas de suffixe de genre de série temporelle, il sera de type Gauge.

Une signature de fonction peut également comporter une ou plusieurs des annotations suivantes :

(implicit row input) Cette annotation indique que la fonction prend l'ensemble de la ligne en tant qu'entrée implicite. Par exemple, la fonction hash_tsid hache les colonnes d'identifiant de série temporelle de sa ligne d'entrée, mais n'exploite pas ces valeurs de colonne comme arguments explicites.
(temporal only) Cette annotation est utilisée sur la signature des fonctions d'agrégation pour indiquer que la signature de la fonction s'applique uniquement lors de l'agrégation temporelle. (Les autres signatures de la fonction s'appliquent différemment.) Notez que cela inclut l'agrégation temporelle et l'agrégation spatiale exécutées dans la même opération de table.
(sliding temporal only) Cette annotation est utilisée sur la signature des fonctions d'agrégation pour indiquer que la signature de la fonction s'applique uniquement lors de l'agrégation temporelle glissante. (Les autres signatures de la fonction s'appliquent différemment.) Notez que cela inclut l'agrégation temporelle glissante et l'agrégation spatiale exécutées dans la même opération de table.

Opérations de table

Cette section décrit chacune des opérations de table de base dans le langage MQL.

Récupération
- fetch Génère une table à partir de la base de données.
- metric Génère la table pour un type de métrique spécifique à partir d'un ensemble de tables.
- fetch_cumulative Génère une table de séries temporelles de type Cumulative à partir de la base de données.
Sélection
- filter Filtre les lignes d'une table d'entrée en fonction d'un prédicat.
- top Sélectionne la série temporelle supérieure par une expression de valeur de tri.
- bottom Sélectionne la série temporelle inférieure par une expression de valeur de tri.
- top_by Sélectionne les séries temporelles par une expression de valeur de tri dans différents groupes.
- bottom_by Sélectionne les séries temporelles par une expression de valeur de tri dans différents groupes.
Modification de ligne
- map Réécrit les colonnes d'identifiant de série temporelle et de valeur de chaque ligne d'une table.
- value Réécrit les colonnes de valeur de chaque ligne d'une table.
- time_shift Décale les séries temporelles dans le temps.
Alignement des séries temporelles
- align Génère une table alignée à l'aide d'une fonction d'alignement.
Agrégation
- group_by Agrège les lignes par identifiant de série temporelle et fenêtre temporelle mappés.
- union_group_by Agrège les lignes de plusieurs tables.
- unaligned_group_by Agrège les lignes par identifiant de série temporelle mappé sans alignement.
Union et jointure
- join Jointure naturelle de plusieurs tables.
- outer_join Jointure naturelle externe de deux tables.
- union Union de plusieurs tables.
Horizon temporel et période
- every Spécifie la période pour la sortie de table alignée.
- within Spécifie la période de sortie de la requête.
- graph_period Spécifie la période de sortie à privilégier pour la création de graphiques de séries temporelles.
- window Spécifie la fenêtre pour les opérations d'alignement.
Alertes
- condition Ajoute une colonne de condition booléenne à la table d'entrée.
- absent_for Crée une condition pour l'absence d'entrée.
Divers
- ident Opération de table d'identité : aucune modification n'a été apportée à la table d'entrée.
- ratio Calcule le ratio des colonnes de valeurs de deux tables d'entrée alignées.
- filter_ratio Calcule le ratio de deux sommes filtrées de la colonne de valeurs d'entrée.
- filter_ratio_by Calcule un ratio groupé de deux sommes filtrées de la colonne de valeurs d'entrée.

Récupération

La sortie d'une opération de table fetch est une table récupérée par le nom de la base de données de série temporelle Cloud Monitoring.

La sortie de l'opération de table resource est l'ensemble de toutes les tables dont le nom contient le type de ressource surveillée nommé. Chaque resource doit être suivie d'une opération de table metric qui sélectionne la table dont le nom contient cette métrique. Avant l'opération de table metric, il est possible que des opérations de table filter limitent les lignes incluses dans les tables obtenues.

`fetch` génère une table à partir de la base de données.

Signature : fetch lit-TableName

L'opération fetch récupère, à partir de la base de données de série temporelle, la table dont le nom correspond au nom de table indiqué dans l'argument TableName. Il s'agit d'une erreur si le nom de la table contient un type de ressource surveillée inconnu ou un type de métrique inconnu.

Cette table sera vide si aucune métrique du type donné n'a été collectée à partir de la ressource surveillée du type donné.

Si la métrique est de type Cumulative, les séries temporelles qui constituent la table sont converties en séries temporelles de type Delta, où chaque point représente la variation de valeur depuis le point immédiatement antérieur.

L'opération fetch peut également récupérer l'ensemble de toutes les tables basées sur une ressource surveillée particulière, en indiquant simplement le nom de la ressource surveillée et non le nom de la métrique. Une telle opération fetch doit être suivie d'une opération metric qui sélectionne la table spécifique contenant les données d'une métrique spécifique. La seule opération pouvant survenir entre fetch et metric est une opération filter, qui filtre en fonction des colonnes de ressources surveillées.

Ce format de l'opération fetch est utile pour récupérer plusieurs métriques pour une ressource surveillée donnée, comme dans cet exemple :

  fetch gce_instance | filter zone = 'asia-east1-a' |
  { metric compute.googleapis.com/instance/cpu/utilization ;
    metric compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div
  gce_instance | (zone = 'asia-east1-a') |
  { compute.googleapis.com/instance/cpu/utilization ;
    compute.googleapis.com/instance/cpu/reserved_cores
  } | join | div

Cela équivaut à

  { fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization ;
    fetch gce_instance :: compute.googleapis.com/instance/cpu/reserved_cores
  } | filter zone = 'asia-east1-a' | join | div

`metric` Génère la table pour un type de métrique spécifique à partir d'un ensemble de tables.

Signature : Resource | metric lit-MetricName

L'opération de table metric utilise un ensemble de tables générées par une opération de table fetch qui n'a pas donné de nom de métrique. Elle sélectionne la table contenant les données de la métrique donnée par l'argument lit-MetricName et génère cette table en tant que sortie. Il s'agit d'une erreur s'il n'existe aucune définition de métrique avec le nom donné. Elle génère une table vide s'il n'existe aucune table d'entrée contenant des données pour le nom de métrique donné.

`fetch_cumulative` Génère une table de séries temporelles de type Cumulative à partir de la base de données.

Signature : fetch_cumulative lit-TableName

L'opération de table fetch_cumulative est identique à l'opération de table fetch, sauf que les métriques Cumulative ne sont pas automatiquement converties en métriques Delta lors de la récupération.

Sélection

Les opérations de la table de sélection sélectionnent les lignes de la table d'entrée à inclure dans la table de sortie. Le type de la table de sortie est exactement le même que celui de la table d'entrée.

`filter` filtre les lignes d'une table d'entrée en fonction d'un prédicat.

Signature : ResourceOrTable | filter Bool

L'opération filter évalue son expression d'argument Bool pour chaque ligne d'une table d'entrée unique ou dans la collection de tables nommées par une opération resource. Ces lignes des tables d'entrée pour lesquelles cette expression renvoie la valeur "true" sont conservées dans les tables de sortie.

Si l'entrée est une collection de tables, seuls les libellés de ressource surveillée (communs à toutes les tables) peuvent être référencés dans le prédicat.

`top` Sélectionne la série temporelle supérieure selon une expression de valeur de tri.

Signature : Table | top lit-Int, [ Windowed(Num) ]

L'opération de table top calcule une valeur de tri pour chaque série temporelle de sa table d'entrée et sélectionne le nombre de séries temporelles fourni par son argument Int avec la plus grande valeur de tri. L'expression d'argument Windowed calcule la valeur de tri.

L'argument Windowed(Num) s'applique aux lignes d'une série temporelle se trouvant dans une fenêtre temporelle de valeur. La fenêtre temporelle de la valeur par défaut est identique à celle de la requête. Si l'expression est une expression d'agrégation (par exemple, .min), il s'agit d'une agrégation sur toutes les lignes dont l'horodatage de fin est compris dans la fenêtre de valeur. Si l'expression est une expression de valeur (par exemple, .val(0)/.val(1)), elle est appliquée à la ligne la plus récente, le cas échéant, comprise dans la fenêtre de valeur. S'il n'y a pas de lignes comprises dans la fenêtre de valeur d'une série temporelle ou si l'argument Windowed(Num) ne génère pas de valeur pour une série temporelle, cette série temporelle ne sera pas incluse dans la sortie.

La fonction within peut être utilisée dans l'argument Windowed(Num) pour modifier la fenêtre de valeur en indiquant une heure de début, une durée et/ou une heure de fin pour la fenêtre.

Exemples :

  | top 3

Cela permet de sélectionner 3 séries temporelles avec la plus grande valeur pour le point le plus récent de la série temporelle.

  | top 7, .max

Cela permet de sélectionner 7 séries temporelles avec la plus grande valeur pour le maximum de tous les points de la série temporelle dans la fenêtre de requête.

  | top 3, .min.within(-10h, 1h)

Cela permet de sélectionner 3 séries temporelles avec la plus grande valeur du réducteur min appliquée aux lignes de chaque série temporelle comprises dans une fenêtre ayant commencé il y a 10 heures et ayant duré 1 heure.

`bottom` Sélectionne la série temporelle inférieure selon une expression de valeur de tri.

Signature : Table | bottom lit-Int, [ Windowed(Num) ]

L'opération de table bottom calcule une valeur de tri pour chaque série temporelle de sa table d'entrée et sélectionne le nombre de séries temporelles fourni par son argument Int avec la plus petite valeur de tri. L'expression d'argument Windowed calcule la valeur de tri.

La fonction within peut être utilisée dans l'argument Windowed(Num) pour modifier la fenêtre de valeur en indiquant une heure de début, une durée et/ou une heure de fin pour la fenêtre.

Exemples :

  | bottom 3

Cela permet de sélectionner 3 séries temporelles avec la plus petite valeur pour le point le plus récent de la série temporelle.

  | bottom 7, .min

Cela permet de sélectionner 7 séries temporelles avec la plus petite valeur pour le minimum de tous les points de la série temporelle dans la fenêtre de requête.

  | bottom 3, .max.within(10h)

Cela permet de sélectionner 3 séries temporelles avec la plus petite valeur du réducteur max appliquée aux lignes de chaque série temporelle comprises dans une fenêtre ayant commencé il y a 10 heures jusqu'au moment présent.

`top_by` Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

Signature : Table | top_by TSIDSel, lit-Int, [ Windowed(Num) ]

L'opération de table top_by regroupe les séries temporelles ayant le même identifiant de série temporelle calculé par l'argument TSIDSel. Au sein de chaque groupe, elle sélectionne les séries temporelles selon la même méthode que celle utilisée par top pour les mêmes arguments Int et Windowed. Pour chaque groupe, elle calcule une valeur de tri pour chaque série temporelle d'un groupe et sélectionne le nombre de séries temporelles fourni par son argument Int avec la plus grande valeur de tri. L'expression d'argument Windowed calcule la valeur de tri.

La fonction within peut être utilisée dans l'argument Windowed(Num) pour modifier la fenêtre de valeur en indiquant une heure de début, une durée et/ou une heure de fin pour la fenêtre.

Exemples :

  | top_by [zone], 1

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "zone", cette opération sélectionne la série temporelle ayant la plus grande valeur pour le point le plus récent de la série temporelle.

  | top_by [project_id], 2, .max

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "project_id", cette opération sélectionne les deux séries temporelles ayant la plus grande valeur pour le maximum de tous les points de la série temporelle dans la fenêtre de requête.

  | top_by [zone], 1, .min.within(-10h, 1h)

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "zone", cette opération sélectionne la série temporelle avec la plus grande valeur du réducteur min appliquée aux lignes de chaque série temporelle comprise dans une fenêtre ayant commencé il y a 10 heures et ayant duré 1 heure.

`bottom_by` Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

Signature : Table | bottom_by TSIDSel, lit-Int, [ Windowed(Num) ]

L'opération de table bottom_by regroupe les séries temporelles ayant le même identifiant de série temporelle calculé par l'argument TSIDSel. Au sein de chaque groupe, elle sélectionne les séries temporelles selon la même méthode que celle utilisée par bottom pour les mêmes arguments Int et Windowed. Pour chaque groupe, elle calcule une valeur de tri pour chaque série temporelle d'un groupe et sélectionne le nombre de séries temporelles fourni par son argument Int avec la plus petite valeur de tri. L'expression d'argument Windowed calcule la valeur de tri.

La fonction within peut être utilisée dans l'argument Windowed(Num) pour modifier la fenêtre de valeur en indiquant une heure de début, une durée et/ou une heure de fin pour la fenêtre.

Exemples :

  | bottom_by [zone], 1

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "zone", cette opération sélectionne la série temporelle ayant la plus petite valeur pour le point le plus récent de la série temporelle.

  | bottom_by [project_id], 2, .max

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "project_id", cette opération sélectionne les deux séries temporelles ayant la plus petite valeur pour le maximum de tous les points de la série temporelle dans la fenêtre de requête.

  | bottom_by [zone], 1, .min.within(1h)

Pour chaque groupe de séries temporelles ayant la même valeur pour la colonne "zone", cette opération sélectionne la série temporelle avec la plus petite valeur du réducteur min appliquée aux lignes de chaque série temporelle comprise dans une fenêtre ayant commencé il y a 10 heures et ayant duré 1 heure.

Modification de ligne

`map` Réécrit les colonnes d'identifiant de série temporelle et de valeur de chaque ligne d'une table.

Signature : Table | map [ RowToTSID ], [ RowToVal ]

Pour chaque ligne de la Tabled'entrée, deux transformations sont appliquées :

Si la carte RowToTSID est fournie, elle est appliquée aux colonnes d'identifiant de série temporelle de cette ligne pour générer les colonnes d'identifiant de série temporelle de la ligne de sortie correspondante. Si la carte RowToTSID n'est pas spécifiée (ou est spécifiée en tant que _), les colonnes d'identifiant de série temporelle de sortie sont identiques à celles de l'entrée.
Si la carte RowToVal est fournie, elle est appliquée aux colonnes de valeurs de la ligne d'entrée pour produire les colonnes de valeurs de la ligne de sortie. Si la carte RowToVal n'est pas fournie, les colonnes de valeurs de sortie sont identiques à celles de l'entrée.

Il s'agit d'une erreur dynamique si les lignes de deux séries temporelles différentes dans l'entrée sont mappées sur la même série temporelle dans la sortie. Dans ce cas, les lignes dérivées de l'une des séries temporelles d'entrée sont supprimées de la sortie et un message d'erreur est attribué.

Si la carte RowToTSID contient des références à des colonnes de valeurs ou de temps, il est possible qu'elle divise une série temporelle d'entrée unique en plusieurs séries temporelles de sortie. C'est la raison pour laquelle, lorsque la carte RowToTSID contient des références à des colonnes de valeurs ou de temps, elle est uniquement autorisée à l'appliquer à des tables dont le genre de série temporelle des colonnes de valeurs est de type Gauge ou Delta.

`value` Réécrit les colonnes de valeurs de chaque ligne d'une table.

Signature : Table | value RowToVal

Pour chaque ligne de la Table d'entrée, la carte RowToVal est appliquée aux colonnes de cette ligne afin de générer les colonnes de valeurs de la ligne de sortie correspondante. Chaque ligne de sortie possède le même identifiant de série temporelle et les mêmes colonnes de temps que la ligne d'entrée à partir de laquelle elle a été générée. Les colonnes de valeurs sont générées par la carte RowToVal.

`time_shift` Décale les séries temporelles dans le temps.

Signature : Table | time_shift lit-Duration

La quantité précisée par l'argument Duration est ajoutée aux colonnes de temps de chaque ligne de la table d'entrée. Cela a pour effet de décaler chaque série temporelle dans le temps.

Si la table d'entrée est alignée, le décalage doit être un multiple pair de la période d'alignement, ce qui permet de conserver l'alignement de la table d'entrée.

Alignement des séries temporelles

`align` Génère une table alignée à l'aide d'une fonction d'alignement.

Signature : Table | align [ Aligner ]

L'opération de table align utilise la fonction d'alignement fournie pour son argument Aligner afin de créer une série temporelle alignée à partir de chaque série temporelle de sa table d'entrée, ce qui génère les séries temporelles dans sa table de sortie.

L'heure de base de l'alignement correspond à l'heure de fin de la fenêtre de requête, et la période d'alignement est définie par l'un des trois éléments suivants :

une opération de table every qui définit la période pour cette opération de table align ;
la fonction d'alignement qui nécessite que la période d'alignement soit égale à la largeur de la fenêtre (voir delta) ;
une interface graphique externe qui nécessite une période d'alignement particulière.

La méthode spécifique permettant de générer des séries temporelles alignées est décrite pour la fonction d'alignement fournie à l'argument Aligner.

Agrégation

Une opération de table d'agrégation divise les lignes de la table d'entrée en groupes. Pour chaque groupe de lignes d'entrée, elle calcule un identifiant de série temporelle et des colonnes de temps communs pour le groupe, agrège les lignes d'entrée pour créer les colonnes de sortie de valeur et génère une ligne unique avec les colonnes d'identifiant de série temporelle, de temps et de valeurs obtenues.

Il existe trois genres d'agrégation.

Agrégation spatiale. Cette forme d'agrégation calcule de nouvelles colonnes d'identifiant de série temporelle pour chaque ligne d'entrée et regroupe toutes les lignes ayant les mêmes nouvelles colonnes d'identifiant de série temporelle et heure de fin. Ce genre d'agrégation nécessite généralement une entrée alignée afin que les lignes de différentes séries temporelles soient alignées dans le temps pour pouvoir être regroupées.
Agrégation temporelle. Cette forme d'agrégation calcule un ensemble d'heures de sortie alignées et valides et calcule une nouvelle heure de fin pour chaque ligne, en indiquant l'heure de fin alignée la plus ancienne qui n'est pas antérieure à l'heure de fin initiale de la ligne. Les lignes avec le même identifiant de série temporelle et la même heure de fin sont regroupées.
Agrégation temporelle glissante. Cette forme d'agrégation est semblable à l'agrégation temporelle, sauf qu'une ligne peut être incluse dans plusieurs groupes. Cette opération calcule un ensemble de fenêtres temporelles, chacune ayant une borne postérieure située à une heure de fin alignée valide et ayant la même largeur fixe. Une ligne est associée à une heure de fin qui correspond à la borne postérieure de chaque fenêtre dans laquelle elle est comprise. La ligne est regroupée avec toutes les autres lignes ayant le même identifiant de série temporelle et la même nouvelle heure de fin. Lorsque les fenêtres se chevauchent, une ligne peut recevoir plusieurs nouvelles heures de fin. Elle peut donc être incluse dans plusieurs groupes.

Il est possible de combiner l'agrégation spatiale avec l'une des deux formes d'agrégation temporelle en une seule opération de table.

La principale différence entre l'agrégation temporelle glissante et non glissante est que certains agrégateurs (par exemple, sum) généreront des valeurs dont le genre de série temporelle est de type Delta pour l'agrégation temporelle non glissante, mais ils généreront des valeurs dont le genre de série temporelle est de type Gauge pour l'agrégation temporelle glissante. La raison est que les plages de temps de deux points d'une série temporelle de type Delta ne peuvent pas se chevaucher. Par conséquent, les fenêtres d'entrée de l'agrégation temporelle glissante qui se chevauchent ne peuvent pas être représentées dans les colonnes de temps des lignes de sortie de série temporelle Delta.

Lorsqu'un nouvel identifiant de série temporelle est calculé pour une ligne, il est calculé par un argument map. Les colonnes de valeurs de la ligne de sortie sont calculées par un argument map avec une expression d'agrégation calculant chaque colonne de valeur.

`group_by` Agrège les lignes par identifiant de série temporelle et fenêtre temporelle mappés.

Signature : Table | group_by RowToTSID, [ RowSetToVal ]
Table | group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
Table | group_by lit-WindowDuration, [ RowSetToVal ]

L'opération de table group_by regroupe les lignes en mappant les colonnes d'identifiant de série temporelle ou les colonnes de temps, ou les deux :

Si l'argument RowToTSID est donné et que l'argument WindowDuration ne l'est pas, l'opération calcule l'identifiant de série temporelle généré par cet argument de mappage pour chaque ligne de la table d'entrée, et regroupe toutes les lignes ayant le même identifiant de série temporelle et la même heure de fin.

Dans ce cas, pour group_by, une table alignée est requise en tant qu'entrée afin que différentes séries temporelles comportent des points avec la même heure de fin. Si la table d'entrée n'est pas alignée, une opération de table align est automatiquement insérée pour procéder à l'alignement.
Si l'argument WindowDurationest donné et que l'argument RowToTSID ne l'est pas, un groupe de lignes est généré pour chaque identifiant de série temporelle et chaque point de sortie de période alignée. Les lignes d'un groupe sont constituées de toutes les lignes ayant l'identifiant de série temporelle donné et dont l'heure de fin est comprise dans une fenêtre entre l'heure de sortie et l'heure correspondant à la durée antérieure.

Si l'argument Duration comporte un appel de fonction sliding (par exemple, sliding(1h)), la fenêtre peut être différente de la période d'alignement. Dans le cas contraire, l'argument Duration doit être identique à la période d'alignement. L'expression window() représente une durée qui est identique à la période d'alignement. Si un argument Duration non glissant est explicitement spécifié, la période est forcément la même si aucune période n'a été explicitement fournie.
Si les arguments RowToTSID et WindowDuration sont spécifiés, un nouvel identifiant de série temporelle mappé est calculé pour chaque ligne, et un groupe est créé pour toutes les lignes ayant le même identifiant de série temporelle mappé et dont l'heure de fin est comprise dans une fenêtre entre l'heure de sortie et l'heure correspondant à la durée antérieure.

Une ligne de sortie est générée pour chaque groupe avec l'identifiant de série temporelle commun aux lignes du groupe et un horodatage correspondant au point de sortie du groupe (WindowDuration a été donné) ou avec l'heure de fin commune des lignes du groupe (WindowDuration n'a pas été fourni). Les colonnes de valeurs du groupe sont générées par l'argument RowSetToVal. Chaque expression d'agrégation est appliquée aux lignes de l'ensemble et le résultat correspond à la colonne de valeurs des lignes de sortie.

Certaines expressions d'agrégation (par exemple, sum) génèrent des colonnes de valeurs de sortie dont le genre de série temporelle est Delta ou Gauge, selon le type d'agrégation en cours. Cela dépend si l'agrégation temporelle est glissante ou non glissante. À cette fin, l'agrégation est traitée comme une agrégation temporelle si elle combine à la fois une agrégation temporelle et une agrégation spatiale.

Une opération de table group_by génère toujours des tables de sortie alignées. Si aucun argument WindowDuration n'est fourni, la table d'entrée doit être alignée et la table de sortie présentera le même alignement. Si l'argument WindowDuration est donné, un point de sortie est uniquement généré à un moment de l'alignement, et la table de sortie est alignée.

Notez que si l'argument de mappage RowToTSID inclut des colonnes de valeurs ou de temps dans ses expressions, il est possible que les séries temporelles de la table d'entrée soient divisées en plusieurs séries temporelles dans la table de sortie.

`union_group_by` Agrège les lignes de plusieurs tables.

Signature : Table++ | union_group_by RowToTSID, [ RowSetToVal ]
Table++ | union_group_by RowToTSID, lit-WindowDuration, [ RowSetToVal ]
Table++ | union_group_by lit-WindowDuration, [ RowSetToVal ]

La fonction union_group_by agrège les lignes d'entrée exactement comme la fonction group_by, sauf qu'elle extrait ses lignes d'entrée à partir de plusieurs tables d'entrée.

Toutes les tables d'entrée saisies dans union_group_by doivent avoir les mêmes colonnes (même nom, même type et, pour les colonnes de valeurs, même genre de série temporelle). Si les tables d'entrée alignées sont requises par les arguments de "union_group_by" (aucun argument WindowDuration fourni), toutes les tables d'entrée doivent être alignées avec la même période.

`unaligned_group_by` Agrège les lignes par identifiant de série temporelle mappé sans alignement.

Signature : Table | unaligned_group_by TSIDSel, [ RowSetToVal ]

L'opération de table unaligned_group_by effectue la même opération que l'opération de table group_by, mais ne requiert pas l'alignement de sa table d'entrée.

Cela permet de calculer l'identifiant de série temporelle produit par TSIDSel pour chaque ligne de la table d'entrée, ainsi que de regrouper toutes les lignes avec les mêmes identifiant de série temporelle et heure de fin. Toutes les lignes du groupe ont la même heure de fin et doivent avoir la même heure de début. Si deux lignes d'un groupe ont une heure de début différente, émettez une erreur dynamique, choisissez une des lignes de façon arbitraire et supprimez-la du groupe.

Génère une ligne de sortie pour chaque groupe du groupe de lignes ci-dessus. La ligne de sortie possède l'identifiant de série temporelle produit par l'argument de mappage TSIDSel, et a la même heure de fin et (si présente) la même heure de début que les lignes d'entrée du groupe Les colonnes de valeurs générées par l'argument de mappage RowSetToVal sont appliquées à toutes les lignes du groupe.

L'opération de table unaligned_group_by ne requiert pas l'alignement de sa table d'entrée, ce qui signifie qu'il est peu probable que plusieurs lignes d'un groupe soient agrégées. Pour cette opération, les lignes collectées dans une série temporelle de sortie (ayant toutes le même identifiant de série temporelle) ne doivent pas avoir d'heure de fin dont la densité correspond à plus d'une ligne par seconde.

Union et jointure

`join` Jointure naturelle de plusieurs tables.

Signature : Table++ | join

L'opération de table join utilise au moins deux tables d'entrée et combine les lignes de ces tables en lignes d'une table de sortie unique, en effectuant une jointure interne naturelle sur les colonnes d'identifiant de série temporelle et d'heure de fin des tables d'entrée.

En plus d'être alignées, les tables d'entrée doivent toutes être alignées avec la même période et leur genre de série temporelle doit être Delta ou Gauge.

La table de sortie contient les éléments suivants :

Une colonne d'identifiant de série temporelle pour chaque colonne d'identifiant de série temporelle unique dans l'une des tables d'entrée Chaque colonne aura le même type que la colonne correspondante dans les tables d'entrée. Si deux tables contiennent des colonnes d'identifiant de séries temporelles portant le même nom, mais des types différents, cela constitue une erreur.
Une colonne d'heure de fin. Si le genre de l'une des tables d'entrée est Delta, le genre de série temporelle de la table de sortie sera également Delta et la table de sortie aura une colonne d'heure de début.
Une colonne de valeurs pour chaque colonne de valeurs de table d'entrée. L'ordre correspond à l'ordre des tables d'entrée dans l'opération grouped_table_op qui les a générées. Il s'agit d'une erreur si deux tables d'entrée différentes ont des colonnes de valeurs portant le même nom.

La jointure prend en compte chaque tuple constitué d'une ligne de chaque table d'entrée. Pour chaque tuple répondant aux conditions suivantes, une ligne de sortie est créée :

Pour chaque nom de colonne d'identifiant de série temporelle qui apparaît dans l'une des tables d'entrée, cette colonne comporte la même valeur pour chaque ligne du tuple contenant cette colonne.
Chaque ligne du tuple a la même heure de fin.

Chacune de ces lignes de sortie aura les valeurs de colonne suivantes :

Chaque colonne de série temporelle aura la valeur de cette colonne, comme chaque ligne du tuple contenant cette colonne.
Chaque colonne de temps aura la même valeur que les lignes du tuple d'entrée.
Chaque colonne de valeurs aura la même valeur que la ligne du tuple dont elle provient.

`outer_join` Jointure naturelle externe de deux tables.

Signature : Table++ | outer_join [ DefaultColumns ], [ DefaultColumns ]

L'opération de table outer_join utilise au moins deux tables d'entrée et combine les lignes de ces tables en lignes d'une table de sortie unique, en effectuant une jointure externe naturelle sur les colonnes d'identifiant de série temporelle et d'heure de fin des tables d'entrée.

L'un des arguments DefaultColumns, ou les deux, doit être indiqué. Chacun d'entre eux correspond à une table d'entrée. Lorsque ces arguments sont fournis pour une table, des lignes sont créées si aucune ligne ne correspond à une ligne de l'autre table. Les arguments DefaultColumns spécifient les colonnes de valeurs de la ligne créée. Si un argument DefaultColumns est fourni pour une table, les colonnes d'identifiant de série temporelle de cette table doivent constituer un sous-ensemble des séries temporelles de l'autre table. En outre, elles peuvent uniquement comporter un genre de série temporelle de type Delta, si le genre de série temporelle de l'autre table est de type Delta.

En plus d'être alignées, les tables d'entrée doivent toutes être alignées avec la même période et leur genre de série temporelle doit être Delta ou Gauge.

Comme pour join, la table de sortie comporte les éléments suivants :

Une colonne d'identifiant de série temporelle pour chaque colonne d'identifiant de série temporelle unique dans l'une des tables d'entrée Chaque colonne aura le même type que la colonne correspondante dans les tables d'entrée. Si deux tables contiennent des colonnes d'identifiant de séries temporelles portant le même nom, mais des types différents, cela constitue une erreur.
Une colonne d'heure de fin. Si le genre de l'une des tables d'entrée est Delta, le genre de série temporelle de la table de sortie sera également Delta et la table de sortie aura une colonne d'heure de début.
Une colonne de valeurs pour chaque colonne de valeurs de table d'entrée. L'ordre correspond à l'ordre des tables d'entrée dans l'opération grouped_table_op qui les a générées. Il s'agit d'une erreur si deux tables d'entrée différentes ont des colonnes de valeurs portant le même nom.

La jointure prend en compte chaque paire composée d'une ligne de chaque table d'entrée. Pour chaque paire répondant aux conditions suivantes, une ligne de sortie est créée :

Pour chaque nom de colonne d'identifiant de série temporelle qui apparaît dans l'une des deux tables d'entrée, cette colonne comporte la même valeur pour chaque ligne de la paire contenant cette colonne.
Chaque ligne de la paire a la même heure de fin.

Chacune de ces lignes de sortie aura les valeurs de colonne suivantes :

Chaque colonne de série temporelle aura la valeur de cette colonne, comme chaque ligne de la paire contenant cette colonne.
Chaque colonne de temps aura la même valeur que les lignes de la paire d'entrée.
Chaque colonne de valeurs aura la même valeur que la ligne de la paire dont elle provient.

Outre les paires ci-dessus, si une ligne d'une table ne peut pas former de paire avec une ligne de l'autre table et que celle-ci possède un argument DefaultColumns, une paire est créée avec la ligne de la première table, et une ligne par défaut est créée pour l'autre table. La structure de la ligne par défaut se présente comme suit :

Chacune de ses colonnes d'identifiant de série temporelle et de ses colonnes de temps a la même valeur que la colonne correspondante dans la première ligne du tableau.
Les colonnes de valeurs de la ligne par défaut sont créées par DefaultColumns map. Cette map doivent spécifier une valeur pour chaque colonne de valeur de la table par défaut.

`union` Union de plusieurs tables.

Signature : Table++ | union

L'opération de table union utilise au moins deux tables d'entrée et génère une table de sortie unique contenant les lignes de toutes les tables d'entrée.

Les tables d'entrée doivent comporter les mêmes colonnes (même nom, même type et, pour les colonnes de valeurs, même genre de série temporelle). La table de sortie générée aura les mêmes colonnes que les tables d'entrée. La table de sortie est alignée uniquement si toutes les tables d'entrée sont alignées avec une période commune.

Il s'agit d'une erreur dynamique si les flux provenant d'au moins deux tables différentes ont le même identifiant de série temporelle. Dans ce cas, l'un des flux avec un identifiant de série temporelle en double est choisi de manière arbitraire pour être inclus dans la sortie. Le reste est supprimé.

Horizon temporel et période

La période à utiliser lors de l'alignement de la série temporelle dans la table est définie par la commande every.

La requête générera tous ses résultats sous forme de points dont l'heure de fin est comprise dans une fenêtre de requête. La durée de la fenêtre de requête est définie par l'opération de table within, qui peut spécifier une heure de début, une heure de fin ou une durée.

`every` Spécifie la période pour la sortie de table alignée.

Signature : Table | every lit-Duration

L'opération de table every requiert une table d'entrée alignée avec une période d'entrée donnée par l'argument Duration. Cette opération s'effectue de l'une des manières suivantes :

Si la table d'entrée n'est pas alignée, une opération align est insérée avec une fonction d'alignement appropriée pour la table d'entrée. L'argument Duration de la fonction d'alignement est la valeur par défaut pour la période donnée.
Si la table est alignée, mais n'a pas de période requise spécifique, la requête saisie dans l'opération de table every est ajustée pour pouvoir générer cette période.
Il s'agit d'une erreur si la table d'entrée est alignée avec une période spécifique et que cette période est différente de celle spécifiée par l'argument Duration.

`within` Spécifie la période de sortie de la requête.

Signature : Table | within lit-DateOrDuration, [ lit-DateOrDuration ]

L'opération de table within spécifie la période de sortie du résultat de la requête. Pour ce faire, elle spécifie une ou deux valeurs sur trois : la plus ancienne (heure de début), la plus récente (heure de fin) ou la durée de la fenêtre.

Si l'un des deux arguments de within constitue une valeur Duration positive, la largeur de la fenêtre est définie. Au maximum, l'un des arguments peut constituer une valeur Duration positive.

Si le premier argument est une Date, l'heure de début est spécifiée. Si le second argument est une Date, l'heure de fin est spécifiée. Si les deux arguments sont des valeurs Date, le second doit être postérieur au premier. Un argument Date peut être donné en tant que valeur littérale Date, ou avec une valeur littérale Duration négative. Dans le dernier cas, l'heure correspond à la valeur Duration spécifiée avant l'heure à laquelle la requête a été émise (maintenant).

Si un seul argument est fourni, le second argument utilise par défaut l'heure à laquelle la requête a été émise (maintenant). Dans ce cas, le premier argument doit être une valeur Duration positive ou une Date antérieure à l'heure à laquelle la requête est émise.

`graph_period` Spécifie la période de sortie à privilégier pour la création de graphiques de séries temporelles.

Signature : Table | graph_period lit-Duration

L'opération de table graph_period transforme sa table d'entrée afin qu'elle puisse être affichée sous forme de graphique. Son argument Duration indique la période entre les points adaptée au graphique.

Cette opération est automatiquement insérée dans les requêtes adressées à l'Explorateur de métriques si l'utilisateur n'en ajoute pas explicitement une. Dans tous les cas, l'Explorateur de métriques définit la valeur de l'argument Duration de sorte qu'elle soit adaptée à la période réelle du graphique. L'ajout explicite de graph_period dans le cadre d'une requête n'a de sens que si la requête est transmise à l'API.

L'opération graph_period compare son argument Duration à la période de la table d'entrée et effectue l'une des opérations suivantes :

Si la période de la table d'entrée est inférieure à la moitié de l'argument Duration, l'opération graph_period agit comme un réducteur temporel dont la fenêtre et la période de sortie sont fournies par l'argument Duration. Chaque colonne de valeur de la table d'entrée est agrégée en fonction de son type.
- Pour une colonne de valeur de type numérique, trois colonnes sont placées dans la table de sortie, chacune résultant de l'agrégation de la colonne d'entrée avec les agrégateurs min, mean et max. Les noms des colonnes de sortie sont constitués du nom de la colonne d'entrée, auquel est ajouté .min, .mean et .max respectivement.
- Pour une colonne de valeur de type Bool, trois colonnes sont placées dans la table de sortie, chacune résultant de l'agrégation de la colonne d'entrée avec les agrégateurs min, mean et max. Les noms des colonnes de sortie sont constitués du nom de la colonne d'entrée, auquel est ajouté .all_true, .mean et .any_true respectivement.
- Pour une colonne de type Distribution, une colonne unique portant le même nom est créée à l'aide de l'agrégation distribution pour combiner les populations de toutes les valeurs d'entrée de distribution qui appartiennent à chaque fenêtre de période du graphique.
Si la période de la table d'entrée est plus de deux fois supérieure à l'argument Duration, pour chaque point de la table d'entrée, les copies sont effectuées pour les points temporels requis par la période de sortie.
Si la période de la table d'entrée est inférieure au double de l'argument Duration et est supérieure à la moitié de l'argument Duration, la table d'entrée est simplement copiée dans la sortie.

Notez que si la table d'entrée comporte plusieurs colonnes de valeur ou une colonne de valeur String, son comportement n'est pas défini. En l'absence de colonne pouvant être affichée, l'Explorateur de métriques peut n'afficher qu'une seule colonne ou générer une erreur.

`window` Spécifie la fenêtre pour les opérations d'alignement.

Signature : Table | window lit-Duration

L'opération de table window nécessite une table d'entrée alignée par une fonction d'alignement dont l'argument Duration de la fenêtre est identique à l'argument Duration fourni pour cette opération de table window. Cette opération s'effectue de l'une des manières suivantes :

Si la table d'entrée n'est pas alignée, une opération align est insérée avec une fonction d'alignement appropriée pour la table d'entrée. L'argument Duration de la fonction d'alignement est fourni par l'argument Duration de l'opération de table window.
Si la table est alignée, mais que l'opération de table qui l'a alignée n'a pas de fenêtre d'alignement spécifique, la valeur Duration de cet argument window est utilisée comme argument de la fenêtre d'alignement.
Il s'agit d'une erreur si la table d'entrée est alignée et que l'opération de table alignée spécifie une valeur Duration de fenêtre différente de l'argument Duration de cette opération de table window.

Alertes

Les opérations d'alerte sont utilisées pour définir les règles d'alerte. Utilisez ces opérations uniquement pour mettre en place des alertes, et non dans le cadre d'une requête.

Au niveau abstrait, ces opérations fournissent des outils pour créer des requêtes générant une table avec deux colonnes de valeurs : une valeur booléenne indiquant si l'alerte doit se trouver dans un état de déclenchement et une valeur du même type que l'entrée, indiquant la valeur la plus récente de l'entrée.

`condition` Ajoute une colonne de condition booléenne à la table d'entrée.

Signature : Table | condition Bool

L'opération de table condition ajoute une colonne de valeur booléenne à chaque ligne de la table d'entrée pour créer sa table de sortie. La valeur de cette colonne est la valeur de l'argument Bool appliqué à la ligne.

Cela permet de créer une requête d'alerte. La table de sortie comporte une colonne booléenne indiquant que la condition d'alerte est satisfaite. Le système d'alerte l'utilise pour déterminer si et quand une alerte doit se déclencher ou s'arrêter.

L'opération condition nécessite que sa table d'entrée soit alignée et générée par une requête avec une fenêtre d'alignement explicite. Elle est fournie par un argument de fenêtre pour une opération d'alignement (par exemple | align rate(10m)) ou par une opération de table window.

Exemples :

  fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | window 5m
  | condition val() < .5

Cela générera une table avec deux colonnes de valeurs. La première colonne est une colonne Bool qui affichera "true" si la colonne de valeurs usage_time de la table d'entrée est inférieure à .5. La deuxième colonne est une copie de la colonne de valeurs usage_time de l'entrée.

`absent_for` Crée une condition pour l'absence d'entrée.

Signature : Table | absent_for lit-Duration

L'opération de table absent_for génère une table avec deux colonnes de valeur, active et signal. La colonne active renvoie la valeur "true" si des données sont manquantes dans l'entrée de table et "false" dans le cas contraire. Cela est utile pour créer une requête de condition, afin d'envoyer une alerte d'absence d'entrées.

Pour chaque série temporelle d'entrée, absent_for crée une série temporelle de sortie alignée et ayant le même identifiant de série temporelle que l'entrée. La période d'alignement est soit renseignée par une valeur every qui suit, ou utilise la période par défaut.

L'argument Duration fournit un délai. La colonne active pour un point de sortie renverra la valeur "false" s'il existe un point dans la série temporelle d'entrée qui se trouve dans cette limite de temps antérieure au délai du point de sortie. Si ce point d'entrée n'existe pas, la colonne active renvoie la valeur "true", ce qui indique une absence d'entrée dans le délai imparti.

Si la table d'entrée comporte des colonnes de valeurs, la colonne signal contient la valeur de la première colonne de valeurs du point d'entrée le plus récent (qu'il soit dans la limite ou non) de la série temporelle d'entrée. Si la table d'entrée ne comporte aucune colonne de valeurs, la colonne signal du point de sortie sera un entier indiquant le nombre de minutes écoulées depuis le dernier point d'entrée.

Pour chaque heure de point de sortie, l'opération de table absent_for est renvoyée 24 heures avant cette heure pour un point d'entrée. En l'absence de point d'entrée au cours des dernières 24 heures, aucun point ne sera généré pour cette heure.

Exemples :

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | absent_for 8h

Pour chaque série temporelle usage_time issue d'une machine virtuelle (gce_instance), l'élément absent_for génère une série temporelle alignée dont les points de sortie vont posséder une colonne active qui renverra la valeur "true" s'il existe un point d'entrée au cours des dernières 24 heures, mais aucun point au cours des huit dernières heures (8h). Il s'agit d'une requête d'alerte adaptée.

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time
  | value [] | absent_for 8h

Cet exemple ressemble à l'exemple précédent, mais l'élément | value [] supprime les colonnes de valeurs de l'entrée via l'opération absent_for. Ainsi, la colonne signal est définie sur l'heure (en minutes) à partir du dernier point d'entrée.

Divers

`ident` Opération de table d'identité : aucune modification n'a été apportée à la table d'entrée.

Signature : Table | ident

L'opération de table ident génère une table d'entrée non modifiée.

Exemple :

  fetch  gce_instance :: compute.googleapis.com/instance/cpu/usage_time |
    { ident ; group_by [zone] } |
    join | value [zone_fraction: val(0) / val(1)]

Pour chaque ligne de la table donnée, calculez le ratio de sa valeur et le total de cette valeur sur toutes les instances de la zone dans laquelle elle se trouve.

`ratio` Calcule le ratio des colonnes de valeurs de deux tables d'entrée alignées.

Signature : Table++ | ratio

L'opération de table ratio utilise deux tables d'entrée alignées, l'entrée de table de numérateur et l'entrée de table de dénominateur, respectivement. Les deux entrées de table doivent avoir exactement une colonne de valeurs de type numérique.

Les colonnes d'identifiant de série temporelle de la table de dénominateur doivent constituer un sous-ensemble des colonnes d'identifiant de série temporelle de la table de numérateur. Si les deux tables ont les mêmes colonnes d'identifiant de série temporelle (nom et type), une valeur par défaut de zéro est utilisée pour le numérateur lors du calcul des ratios.

`filter_ratio` Calcule le ratio de deux sommes filtrées de la colonne de valeurs d'entrée.

Signature : Table | filter_ratio Bool, [ Bool ]

L'opération de table filter_ratio utilise une table d'entrée ayant exactement une colonne de valeurs de type numérique. Si la table d'entrée n'est pas alignée, une opération de table align est automatiquement insérée pour procéder à l'alignement.

L'opération filter_ratio agrège toutes les lignes d'entrée à un horodatage donné, calcule une somme de numérateur et de dénominateur, et génère une série temporelle avec le ratio de ces sommes à chaque horodatage. Le premier argument Bool contrôle ce qui entre dans la somme du numérateur et le second argument Bool contrôle ce qui entre dans la somme du dénominateur. Le second argument est facultatif et est défini par défaut sur true s'il n'est pas spécifié.

Les arguments Bool sont examinés pour chaque ligne. Si la valeur est "true", la colonne de valeurs de cette ligne est incluse dans le numérateur (premier argument Bool ) ou le dénominateur (second argument Bool ).

`filter_ratio_by` Calcule un ratio groupé de deux sommes filtrées de la colonne de valeurs d'entrée.

Signature : Table | filter_ratio_by RowToTSID, Bool, [ Bool ]

L'opération de table filter_ratio_by utilise une table d'entrée ayant exactement une colonne de valeurs de type numérique. Si la table d'entrée n'est pas alignée, une opération de table align est automatiquement insérée pour procéder à l'alignement.

L'opération filter_ratio_by regroupe les lignes ayant le même identifiant de série temporelle calculé par l'argument RowToTSID. Pour chaque groupe, elle calcule une somme de numérateur et de dénominateur, et génère une série temporelle avec le ratio de ces sommes à chaque horodatage. Le premier argument Bool contrôle ce qui entre dans la somme du numérateur et le second argument Bool contrôle ce qui entre dans la somme du dénominateur. Le second argument est facultatif et est défini par défaut sur true s'il n'est pas spécifié.

Une série unique est calculée pour chaque groupe, et l'identifiant de série temporelle est calculé par l'argument RowToTSID

Functions

Cette section décrit chacune des fonctions pouvant être utilisées dans les expressions (expr) du langage MQL.

Colonnes de ligne d'entrée
- val Valeur d'une colonne de valeur dans le point d'entrée (ligne).
- end Heure de fin du point d'entrée (ligne).
- start Heure de début du point d'entrée (ligne).
- older Valeur du point immédiatement antérieur (ligne) dans une série temporelle.
- adjacent_delta Variation de la valeur entre un point d'entrée et le point immédiatement antérieur.
- adjacent_rate Taux de variation entre le point d'entrée et les point immédiatement antérieurs (lignes).
- hash_tsid Renvoie un hachage des colonnes d'identifiant de série temporelle.
Opérateurs logiques
- not Négation logique d'une valeur booléenne.
- and Valeur logique et de deux valeurs booléennes.
- or Valeur logique ou de deux valeurs booléennes.
- true Valeur booléenne "true".
- false Valeur booléenne "false".
- has Vrai si un argument défini contient une valeur particulière.
- has_value Vrai si une expression d'argument calcule une valeur.
- if Valeur choisie de manière conditionnelle à partir de deux valeurs.
- or_else Une valeur ou, si ce n'est pas une valeur, une autre valeur.
Comparaison
- eq Égal.
- ne Non égal.
- ge Supérieur ou égal.
- gt Supérieur.
- le Inférieur ou égal.
- lt Inférieur.
Arithmétique
- add Somme de deux nombres.
- sub Différence de deux nombres.
- mul Produit de deux nombres.
- div Ratio de deux nombres.
- int_div Quota de la division de deux entiers.
- abs Valeur absolue.
- neg Négatif d'un nombre.
- pos Identité des entrées numériques.
- rem Reste de la division de deux entiers.
Mathématiques
- sqrt Racine carrée.
- log Logarithme naturel
- exp e élevé à une puissance.
- power Un nombre à la puissance d'un autre
- int_round Entier le plus proche.
- int_floor Entier inférieur.
- int_ceil Entier supérieur.
String
- concatenate Concaténation de chaînes
- string_to_double Convertissez String en Double.
- string_to_int64 Convertissez String en Int.
- ascii_to_lower Remplacez les majuscules ASCII par des minuscules.
- ascii_to_upper Remplacez les lettres minuscules ASCII par des majuscules.
- utf8_normalize Chaîne Unicode adaptée à la comparaison de la casse.
Expressions régulières
- re_full_match Vrai si une expression régulière correspond à la totalité d'une valeur de chaîne.
- re_partial_match Vrai si une expression régulière correspond à une partie de la valeur de chaîne.
- re_extract Extrayez les valeurs correspondant à une expression régulière dans une autre chaîne.
- re_replace Remplacez la première correspondance d'une expression régulière dans une autre chaîne.
- re_global_replace Remplacez toutes les correspondances d'une expression régulière dans une autre chaîne.
Agrégation
- sum Somme d'un groupe de valeurs numériques.
- distribution Distribution à partir d'un groupe de valeurs numériques ou de distribution.
- count Nombre de valeurs dans un groupe de valeurs.
- row_count Nombre de lignes d'entrée rencontrées.
- count_true Nombre de valeurs "true" dans un groupe de valeurs booléennes.
- min Minimum d'un groupe de valeurs numériques.
- max Valeur maximale d'un groupe de valeurs numériques.
- diameter Valeur maximale moins le minimum d'un groupe de valeurs numériques.
- mean Moyenne d'un groupe de valeurs numériques.
- stddev Écart type d'un groupe de valeurs.
- variance Variance d'un groupe de valeurs numériques.
- covariance La covariance d'un groupe de paires de valeurs.
- median Médiane d'un groupe de valeurs numériques ou de distribution.
- percentile Centile d'un groupe de valeurs numériques ou de distribution.
- fraction_less_than Fraction d'un groupe de valeurs inférieure à une valeur fixe.
- fraction_true Fraction d'un groupe de valeurs booléennes qui est vraie.
- any_true Disjonction d'un groupe de valeurs booléennes.
- all_true Conjonction d'un groupe de valeurs booléennes.
- pick_any Valeur de n'importe quel élément d'un groupe de valeurs (choisie de manière arbitraire).
- singleton Valeur de l'élément d'un groupe de valeurs comportant un seul élément.
- unique Valeur commune d'un groupe de valeurs (qui doivent toutes être identiques).
- aggregate Valeur globale par défaut d'un groupe de valeurs de tout type.
- weighted_distribution Distribution à partir d'un groupe de valeurs pondérées.
Alignement
- rate Calculez un taux de variation à des moments alignés.
- delta Calculez la variation de la valeur à des moments alignés.
- any_true_alignerAlignez une série temporelle Bool en recherchant n'importe quelle valeur "true" dans une fenêtre.
- count_true_aligner Alignez une série temporelle Bool en comptant les valeurs "true" dans une fenêtre.
- delta_gauge Calculez la variation de valeur à des moments alignés sous la forme d'une série temporelle de type Gauge.
- fraction_true_aligner Alignez une série temporelle Bool sur la fraction des valeurs "true" dans une fenêtre.
- int_mean_aligner Alignez en recherchant la moyenne des valeurs Int dans une fenêtre.
- interpolate Calculez des valeurs d'interpolation à des moments alignés.
- mean_aligner Alignez en recherchant la moyenne des valeurs dans une fenêtre.
- next_older Moments alignés en passant d'un moment antérieur à un moment plus récent.
- next_younger Moments alignés en passant d'un moment récent à un moment plus ancien.
Manipuler les unités
- scale Mettre à l'échelle une valeur vers une unité de mesure différente.
- cast_units Définir l'unité de mesure d'une valeur.
Fenêtre périodique
- window Indique une fenêtre identique à la période d'alignement.
- sliding Indique une fenêtre glissante (qui se chevauche) au lieu d'être disjointe.
Distribution
- count_from Nombre de valeurs dans une valeur de distribution.
- sum_from Somme des valeurs d'une valeur de distribution.
- mean_from Moyenne des valeurs d'une valeur de distribution.
- stddev_from Écart type des valeurs d'une valeur de distribution.
- variance_from Variance des valeurs d'une valeur de distribution.
- median_from Médiane des valeurs d'une valeur de distribution.
- percentile_from Centile des valeurs d'une valeur de distribution.
- fraction_less_than_from Fraction des valeurs d'une distribution inférieure à une valeur fixe.
- bounded_percentile_from Centile des valeurs dans une limite d'une valeur de distribution.
- rebucket Valeur de distribution convertie en une nouvelle spécification de bucket.
Spécificateur de bucket
- powers_of Spécification de bucket dont les limites de bucket augmentent de manière exponentielle.
- fixed_width Spécification de bucket avec des buckets de taille égale.
- custom Spécification de bucket à partir d'une liste de limites de bucket.
- num_buckets Définit le nombre de buckets dans une spécification de bucket.
- bounds Définit la limite inférieure du premier bucket et la limite supérieure du dernier bucket.
- lower Définit la limite inférieure du premier bucket dans une spécification de bucket.
Divers
- cast_double Convertissez la valeur Int en Double.
- cast_gauge Convertissez une valeur de série temporelle Cumulative ou Delta en Gauge.
- within Spécifie la fenêtre de calcul de la valeur de tri.

Colonnes de ligne d'entrée

Les expressions d'une requête fonctionnent sur les colonnes d'une ligne d'entrée. Une colonne est normalement accessible en indiquant son nom. Les fonctions de cette section fournissent d'autres moyens d'accéder aux colonnes.

Les colonnes de temps n'ont pas de nom de colonne et sont accessibles par les fonctions start et end.

Les colonnes de valeurs sont accessibles par nom ou par position à l'aide de la fonction val.

La fonction older donne accès à une colonne de la ligne immédiatement antérieure d'une série temporelle.

`val` Valeur d'une colonne de valeur dans le point d'entrée (ligne).

Signature : ImplicitRowInput val([lit-Int] ) → InputType (entrée de ligne implicite)

La fonction val fournit une alternative à l'utilisation du nom de colonne lors de l'accès aux colonnes de valeur d'une ligne d'entrée. Son argument Int (valeur par défaut 0) indexe l'ensemble ordonné de colonnes de valeur (en commençant par 0 pour la première colonne de valeur) et renvoie la valeur de la colonne de valeur indexée. Il s'agit de la même valeur résultant de l'utilisation du nom de colonne de valeur.

Il s'agit d'une erreur statique si la fonction val indique un index négatif ou égal ou supérieur ou égal au nombre de colonnes de valeurs.

`end` Heure de fin du point d'entrée (ligne).

Signature : ImplicitRowInput end( ) → Date.Gauge (entrée de ligne implicite)

La fonction end renvoie la valeur Date dans la colonne heure de fin de la ligne d'entrée actuelle.

`start` Heure de début du point d'entrée (ligne).

Signature : ImplicitRowInput start( ) → Date.Gauge (entrée de ligne implicite)

La fonction start renvoie la valeur Date dans la colonne d'heure de début de la ligne d'entrée actuelle. Si la ligne n'a pas d'heure de début (car elle ne contient que des données de type Gauge), l'heure de début renvoie no-value.

`older` Valeur du point immédiatement antérieur (ligne) dans une série temporelle.

Signature : older(ColumnValue.CumulativeOK ) → FirstArgType.FirstArgKind
older(Date ) → Date.FirstArgKind

L'argument de older doit être un nom de colonne ou une fonction qui indique une valeur de colonne (val, end, start). La valeur renvoyée correspond à la valeur de cette colonne située sur la ligne immédiatement antérieure à la ligne d'entrée et faisant partie de la même série temporelle. S'il n'existe pas de ligne immédiatement antérieure dans la même série temporelle, older renvoie no-value.

La colonne référencée peut être une colonne de valeur, de temps ou d'identifiant de série temporelle. S'il s'agit d'une colonne d'identifiant de série temporelle, olderrenvoie la même valeur que celle qui serait fournie par l'expression d'argument, même s'il n'existe pas de ligne antérieure dans la même série temporelle.

`adjacent_delta` Variation de la valeur entre un point d'entrée et le point immédiatement antérieur.

Signature : ImplicitRowInput adjacent_delta( ) → InputType (entrée de ligne implicite)

La fonction adjacent_delta s'exécute sur les tables avec une seule colonne numérique (Int ou Double) ou une valeur de distribution.

Si elle est appliquée à une série temporelle Gauge, adjacent_delta renvoie la différence entre la valeur figurant dans la colonne de valeur de la ligne d'entrée actuelle et, le cas échéant, celle figurant dans la colonne de valeur de la ligne immédiatement antérieure de la même série temporelle. S'il n'existe pas de ligne immédiatement antérieure dans la même série temporelle, adjacent_delta renvoie no-value. Le résultat présente le genre de série temporelle Gauge.

Si la valeur est appliquée à une série temporelle Delta, adjacent_delta renvoie la valeur de la colonne de valeur, qui reste un genre de série temporelle Delta. Chaque point de sortie possède la même valeur, l'heure de début et l'heure de fin à partir du point d'entrée à partir duquel il a été généré.

Bien que les séries temporelles Cumulative soient rarement utilisées dans les requêtes, si elles sont appliquées à une série temporelle Cumulative, adjacent_delta renvoie l'une des deux valeurs suivantes :

Si l'heure de début du point d'entrée est antérieure à l'heure de fin du point immédiatement antérieur, adjacent_delta renvoie la valeur du point d'entrée moins la valeur du point immédiatement antérieur.
Si l'heure de début du point d'entrée est postérieure à l'heure de fin du point immédiatement antérieur, adjacent_delta renvoie la valeur des points d'entrée (en soustrayant de fait une valeur de 0 à l'heure de début).

La série temporelle obtenue présente un genre de série temporelle Delta et chaque point possède une heure de début qui est soit son heure de début originelle, soit l'heure de fin du point d'entrée immédiatement antérieur, selon la valeur la plus tardive.

`adjacent_rate` Taux de variation entre le point d'entrée et les points immédiatement antérieurs (lignes).

Signature : ImplicitRowInput adjacent_rate( ) → Double.Gauge (entrée de ligne implicite)

La fonction adjacent_rate s'exécute sur les tables avec une seule colonne numérique (Int ou Double) ou une valeur de distribution.

Si cette fonction est appliquée à une série temporelle Gauge ou Cumulative, adjacent_rate renvoie le taux de variation entre la valeur figurant dans la colonne de valeur de la ligne d'entrée actuelle et, le cas échéant, la valeur figurant dans la colonne de valeur de la ligne immédiatement antérieure de la même série temporelle. Il s'agit de la différence entre les valeurs divisée par la différence entre les heures de fin des deux lignes. S'il n'existe pas de ligne immédiatement antérieure dans la même série temporelle, adjacent_rate renvoie no-value. Le résultat présente le genre de série temporelle Gauge.

Si elle est appliquée à une série temporelle Delta, adjacent_rate renvoie la colonne de valeurs de la ligne d'entrée actuelle divisée par l'heure de début et l'heure de fin de cette ligne.

`hash_tsid` Renvoie un hachage des colonnes d'identifiant de série temporelle.

Signature : ImplicitRowInput hash_tsid([lit-Int] ) → Int (entrée de ligne implicite)

La fonction hash_tsid renvoie un hachage des valeurs dans les champs de l'identifiant de série temporelle de la ligne d'entrée actuelle. Si un argument lui est attribué, il sert de valeur de départ au hachage.

Logique

`not` Négation logique d'une valeur booléenne.

Signature : not(Bool ) → Bool

La fonction not prend une valeur booléenne et renvoie la valeur "true" si cet argument est "false" et renvoie la valeur "false" si cet argument est "true". Si l'argument d'entrée est no-value, il s'agit du résultat.

`and` Valeur logique et de deux valeurs booléennes.

Signature : and(Bool, Bool ) → Bool

La fonction and renvoie la valeur "true" si ses deux entrées sont "true" et "false" dans le cas contraire. Si l'une des entrées est no-value, and renvoie toujours no-value.

`or` Valeur logique ou de deux valeurs booléennes.

Signature : or(Bool, Bool ) → Bool

La fonction or renvoie la valeur "true" si l'une de ses entrées est "true" et la valeur "false" dans le cas contraire. Si l'une des entrées est no-value, or renvoie toujours no-value.

`true` Valeur booléenne "true".

Signature : ImplicitRowInput true( ) → lit-Bool (entrée de ligne implicite)

Cette fonction renvoie la valeur littérale Bool true.

`false` Valeur booléenne "false".

Signature : ImplicitRowInput false( ) → lit-Bool (entrée de ligne implicite)

Cette fonction renvoie la valeur littérale Bool false.

`has` Vrai si un argument défini contient une valeur particulière.

Signature : has(Set, lit-ColumnValue ) → Bool

La fonction has renvoie la valeur "true" si son premier argument contient le deuxième argument en tant qu'élément.

`has_value` Vrai si une expression d'argument calcule une valeur.

Signature : has_value(ColumnValue ) → Bool

La fonction has_value renvoie la valeur "true" si son argument renvoie une valeur et renvoie "false" si elle renvoie la valeur no-value.

`if` Valeur choisie de manière conditionnelle à partir de deux valeurs.

Signature : if(Bool, ColumnValue.Delta, ColumnValue.Delta(identique) ) → LastArgType.Delta
if(Bool, ColumnValue, ColumnValue(identique) ) → LastArgType

La fonction if renvoie son deuxième ou troisième argument, en fonction de la valeur (true ou false) de son premier argument.

if évalue son premier argument Bool. S'il s'agit de no-value, aucune valeur n'est définie comme résultat. Si le premier argument est "true", le deuxième argument est renvoyé et si le premier argument est "false", le troisième argument est renvoyé.

Le deuxième ou troisième argument peut être no-value, mais le résultat de if sera uniquement une valeur si l'argument Bool est no-value ou si l'argument renvoyé est no-value. L'argument qui n'est pas sélectionné peut être no-value, sans que le résultat soit no-value.

Si les deuxième et troisième arguments de if sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de if. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de if possède l'unité de son deuxième argument, éventuellement après mise à l'échelle.

`or_else` Une valeur ou, si ce n'est pas une valeur, une autre valeur.

Signature : or_else(ColumnValue, ColumnValue(identique) ) → LastArgType

La fonction or_else renvoie la valeur de son premier argument, sauf si elle est no-value, auquel cas la valeur de son deuxième argument est renvoyée.

La fonction or_else renvoie no-value si ses deux arguments sont no-value.

Si les arguments de or_else sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de or_else. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de or_else possède l'unité du premier argument, éventuellement après mise à l'échelle.

Comparaison

Les opérateurs de comparaison comparent deux valeurs du même type ou deux valeurs numériques (Int ou *Double) et renvoient une valeur Bool. Contrairement à la plupart des fonctions, les opérateurs de comparaison ne renvoient jamais no-value. Si une entrée est "no-value" elle est considérée comme une valeur spécifique supérieure à toute autre valeur.

`eq` Égal.

Signature : eq(Num, Num ) → Bool
eq(Comparable, Comparable(identique) ) → Bool

Cela permet de comparer son premier argument Comparable au deuxième argument Comparable et renvoie true s'ils sont identiques et false s'ils ne sont pas identiques. Si l'un des arguments est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, true si les deux valeurs sont "no-value" et false dans les autres cas. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Pour effectuer une comparaison sur des arguments numériques, si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités et celles-ci doivent être équivalentes. Le résultat, de type Bool, n'a pas d'unité. Si les arguments de eq ont des unités non équivalentes ayant la même dimension, l'un des arguments peut voir son unité mise à l'échelle échelle automatiquement pour rendre les unités des deux arguments équivalentes.

Si les arguments de eq sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de eq. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de "eq", de type Bool, n'a pas d'unité.

Une comparaison entre la colonne resource.project_id et une chaîne littérale fait l'objet d'un traitement spécial pour gérer la différence entre les numéros de projet et les noms de projet, comme décrit dans la section Mise en correspondance de la colonne resource.project_id.

`ne` Non égal.

Signature : ne(Num, Num ) → Bool
ne(Comparable, Comparable(identique) ) → Bool

Cela permet de comparer son premier argument Comparable au deuxième argument Comparable et renvoie false s'ils sont identiques et true s'ils ne sont pas identiques. Si l'un des arguments est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, false si les deux valeurs sont "no-value" et false dans les autres cas. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Si les arguments de ne sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de ne. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de "ne", de type Bool, n'a pas d'unité.

`ge`Supérieur ou égal.

Signature : ge(Num, Num ) → Bool
ge(Comparable, Comparable(identique) ) → Bool

Cela compare son premier argument Comparable au deuxième argument Comparable et renvoie true si le premier est supérieur ou égal au second et false dans le cas contraire. Si un argument est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, true si la première valeur est "no-valu"e et false dans le cas contraire. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Si les arguments de ge sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, celles-ci doivent être équivalentes. Si les unités ne sont pas équivalentes mais possèdent la même dimension, l'un des arguments peut être automatiquement mis à l'échelle afin de mettre en cohérence les unités, comme décrit ici. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités non équivalentes et qu'aucune mise à l'échelle n'est effectuée.

Le résultat de "ge", de type Bool, n'a pas d'unité.

`gt` Supérieur.

Signature : gt(Num, Num ) → Bool
gt(Comparable, Comparable(identique) ) → Bool

Cette opération compare son premier argument Comparable au deuxième argument Comparable et renvoie true si le premier est supérieur au second et false. dans le cas contraire. Si un argument est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, false si la deuxième valeur est "no-value" et true dans le cas contraire. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Si les arguments de gt sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de gt. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de "gt", de type Bool, n'a pas d'unité.

`le` Inférieur ou égal à

Signature : le(Num, Num ) → Bool
le(Comparable, Comparable(identique) ) → Bool

Cela compare son premier argument Comparable au deuxième argument Comparable et renvoie true si le premier est inférieur ou égal au deuxième et false dans le cas contraire. Si un argument est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, true si la deuxième valeur est "no-value" et false dans le cas contraire. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Si les arguments de le sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de le. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de "le", de type Bool, n'a pas d'unité.

`lt` Inférieur.

Signature : lt(Num, Num ) → Bool
lt(Comparable, Comparable(identique) ) → Bool

Cette opération compare son premier argument Comparable au deuxième argument Comparable et renvoie true si le premier est inférieur au second et false dans le cas contraire. Si l'un des arguments est Int et l'autre Double, l'argument Int est converti en valeur Double avant la comparaison.

Si l'une des entrées est no-value, la comparaison est effectuée et un argument Bool est renvoyé, false si la première valeur est "no-valu"e et true dans le cas contraire. (Aucune valeur n'est considérée comme supérieure à toute autre valeur.)

Si les arguments de lt sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de lt. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de "lt", de type Bool, n'a pas d'unité.

Arithmétique

Fonctions mettant en œuvre les opérateurs arithmétiques.

`add` Somme de deux nombres.

Signature : add(Num.Delta, Num.Delta ) → Num.Delta
add(Num, Num ) → Num
add(Durée, Durée ) → Durée
add(Date, Durée ) → Date
add(Durée, Date ) → Date

La fonction add sur deux arguments Num renvoie la somme de ses arguments, sous la forme d'une valeur Double si l'une des entrées est une valeur Double et en tant que valeur Int. Si les deux entrées correspondent au genre de série temporelle Delta, le résultat est un genre de série temporelle Delta. Dans le cas contraire, le résultat est un genre de série temporelle Gauge.

La fonction add appliquée à deux arguments Duration renvoie la durée correspondant à leur somme.

La fonction add appliquée à un argument Date et un argument Duration renvoie la date correspondant à la date située Duration après l'argument Date. Si l'argument Duration est négatif, le résultat sera antérieur à la Date d'entrée (en remontant dans le temps).

Si les arguments de add sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de add. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de add possède l'unité du premier argument, éventuellement après mise à l'échelle.

`sub` Différence de deux nombres.

Signature : sub(Num.Delta, Num.Delta ) → Num.Delta
sub(Num, Num ) → Num
sub(Durée, Durée ) → Durée
sub(Date, Durée ) → Date
sub(Date, Date ) → Durée

La fonction sub sur deux arguments Num renvoie le premier argument moins le deuxième argument, sous la forme d'une valeur Double si l'une des entrées est Double ou en tant que valeur Int. Si les deux entrées correspondent au genre de série temporelle Delta, le résultat est un genre de série temporelle Delta. Dans le cas contraire, le résultat est un genre de série temporelle Gauge.

La fonction sub de deux arguments Duration renvoie la durée correspondant à leur différence numérique.

La fonction sub appliquée à un argument Date et un argument Duration renvoie la date correspondant à la date située Duration avant l'argument Date. Si l'argument Duration est négatif, le résultat est postérieur à l'argument Date.

Si les arguments de sub sont numériques et si l'un des arguments comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, ils doivent être équivalents, ou les règles indiquées sur cette page doivent autoriser la mise à l'échelle de l'un des arguments pour que les unités soient équivalentes avant toute application de sub. Une erreur se produit si un seul argument comporte des unités ou si les deux arguments comportent des unités qui ne peuvent pas être rendues équivalentes.

Le résultat de sub possède l'unité du premier argument, éventuellement après mise à l'échelle.

`mul` Produit de deux nombres.

Signature : mul(Num.Delta, lit-Num ) → Num.Delta
mul(lit-Num, Num.Delta ) → Num.Delta
mul(Num, Num ) → Num
mul(Durée, Num ) → Durée
mul(Num, Durée ) → Durée

La fonction mul sur deux arguments Num renvoie le produit des deux arguments sous la forme d'une valeur Double si l'une des entrées est une valeur Double et en tant que valeur Int. Si l'une des entrées est du genre de série temporelle Delta et que l'autre est un littéral, le résultat est du genre de série temporelle Delta. Dans le cas contraire, le résultat est un genre de série temporelle Gauge.

La fonction mul sur un nombre et une durée est la durée multipliée par le nombre en tant que type de Durée.

Si l'un des arguments numériques comporte des unités, les deux arguments doivent comporter des unités et celles-ci doivent être équivalentes. Si les arguments comportent des unités, l'unité du résultat sera le produit des unités des deux arguments. La seule exception est la multiplication par un littéral : celui-ci peut ne pas comporter d'unité de mesure explicite. Par conséquent, si l'autre argument possède une unité de mesure, l'unité 1 sera appliquée au littéral et le résultat possédera alors les unités de l'autre argument.

`div` Ratio de deux nombres.

Signature : div(Num.Delta, lit-Num ) → Double.Delta
div(Num, Num ) → Double
div(Durée, Num ) → Durée
div(Durée, Durée ) → Double
div(Date, Durée ) → Double

La fonction div divise son premier argument Num par son deuxième argument Num, renvoyant le ratio en tant que valeur Double.

Elle ne produit pas de résultat si le deuxième argument Num est 0.

La fonction div divise son premier argument par son deuxième argument, en renvoyant le ratio en tant que valeur Double. Lorsqu'un argument est une valeur Date ou Duration, la valeur est représentée par une valeur double Date ou Duration en unités qui représentent la précision interne complète de ces valeurs. Si le résultat est une date ou une durée, le ratio est interprété comme une valeur avec les mêmes unités, arrondie à la valeur la plus proche qu'une date ou une durée peut représenter.

Dans le cas d'une valeur Date divisée par une valeur Duration, le résultat est une valeur Double, c'est-à-dire le nombre de périodes de durée Duration écoulées depuis le début de l'époque Unix (d'1970/01/01-00:00:00+00:00'). Ainsi, d'2020/06/01-01:20:03' / 1s est le nombre de secondes écoulées depuis d'1970/01/01-00:00:00+00:00' à la date d'2020/06/01-01:20:03'.

La fonction div ne produit pas de résultat si le deuxième argument est 0.

Si l'un des arguments numériques comporte des unités, les deux arguments doivent comporter des unités. Si les arguments comportent des unités, l'unité du résultat sera l'unité du premier argument divisée par l'unité du deuxième argument. La seule exception est la division par un littéral : celui-ci peut ne pas comporter d'unité de mesure explicite. Par conséquent, si l'autre argument possède une unité de mesure, l'unité 1 sera appliquée au littéral et le résultat possédera alors les unités de l'autre argument.

`int_div` Quota de la division de deux entiers.

Signature : int_div(Int, Int ) → Int
int_div(Durée, Int ) → Durée
int_div(Durée, Durée ) → Int
int_div(Date, Durée ) → Int

La fonction int_div divise son premier argument par son deuxième argument, en renvoyant le quotient en tant que valeur Int. Lorsqu'un argument est une date ou une durée, la valeur est représentée sous la forme d'un nombre entier de date ou de durée en unités qui représentent la précision interne complète de ces valeurs. Si le résultat est une date ou une durée, le quotient numérique est interprété comme une valeur dotée des mêmes unités.

Dans le cas d'une valeur Date divisée par une valeur Duration, le résultat est une valeur Int, c'est-à-dire le nombre de périodes de durée Duration écoulées depuis le début de l'époque Unix (d'1970/01/01-00:00:00+00:00'). Ainsi, d'2020/06/01-01:20:03' / 1s est le nombre de secondes écoulées depuis d'1970/01/01-00:00:00+00:00' à la date d'2020/06/01-01:20:03'.

La fonction int_div ne produit pas de résultat si le deuxième argument est 0.

`abs` Valeur absolue.

Signature : abs(Num ) → Num

La fonction abs utilise une entrée numérique (Int ou *Double) et renvoie une valeur du même type ayant la même magnitude que l'entrée et non négative.

Le résultat de abs possède la même unité de mesure.

`neg` Négatif d'un nombre.

Signature : neg(Num ) → Num
neg(Durée ) → Durée

La fonction neg renvoie le négatif de son argument.

`pos` Identité des entrées numériques.

Signature : pos(Num ) → Num
pos(Durée ) → Durée

La fonction pos renvoie son argument.

`rem` Le reste de la division de deux entiers.

Signature : rem(Int, Int ) → Int
rem( Durée, Durée ) → Durée

La fonction rem divise son premier argument Int par son deuxième argument Int, renvoyant le reste en tant que valeur Int.

Elle ne produit pas de résultat si le deuxième argument Num est 0.

L'unité de mesure associée au résultat de Rem est identique à l'unité du premier argument (s'il en possède une).

Mathématiques

Certaines fonctions mathématiques.

`sqrt` Racine carrée.

Signature : sqrt(Num ) → Double

La fonction sqrt renvoie la racine carrée de l'argument Num sous la forme d'une valeur Double.

La fonction sqrt ne produit pas de résultat si l'argument Num est inférieur à 0.

Le résultat de sqrt n'a pas d'unité de mesure.

`log` Logarithme naturel.

Signature : log(Num ) → Double

La fonction log renvoie le logarithme naturel de l'argument Num en tant que valeur Double.

La fonction log ne produit pas de résultat si l'argument Num est inférieur ou égal à 0.

Le résultat de log n'a pas d'unité de mesure.

`exp` e élevé à une puissance.

Signature : exp(Num ) → Double

La fonction exp renvoie e (base des logarithmes naturels) élevé à la puissance de l'argument Num en tant que valeur Double.

Les fonctions exp renvoient l'infini de la valeur Double en cas de débordement.

Le résultat de exp n'a pas d'unité de mesure.

`power` Un nombre à la puissance d'un autre.

Signature : power(Num, Num ) → Double

Cette commande renvoie la valeur du premier argument Num, élevée à la puissance du deuxième argument Num, représentée sous la forme d'une valeur Double. Si l'un des arguments est un Int, il est converti en Double avant l'opération.

Le résultat de power n'a pas d'unité de mesure.

`int_round` Entier le plus proche.

Signature : int_round(Double ) → Int

La fonction int_round prend une valeur Double, l'arrondit à l'entier le plus proche et la renvoie sous la forme d'une valeur Int. Si l'entrée n'est pas une valeur ou si le résultat ne peut pas être représenté par une valeur Int, le résultat est no-value.

Le résultat de int_round a la même unité de mesure que son entrée.

`int_floor` Entier inférieur.

Signature : int_floor(Double ) → Int

La fonction int_floor prend une valeur Double, l'arrondit à l'infini inférieur à la valeur entière la plus proche et la renvoie sous forme de valeur Int. Si l'entrée n'est pas une valeur ou si le résultat ne peut pas être représenté par une valeur Int, le résultat est no-value.

Le résultat de int_floor a la même unité de mesure que son entrée.

`int_ceil` Entier supérieur.

Signature : int_ceil(Double ) → Int

La fonction int_ceil prend une valeur Double, l'arrondit à l'infini à la valeur entière la plus proche et la renvoie sous la forme d'une valeur Int. Si l'entrée est no-value ou si le résultat ne peut pas être représenté sous la forme d'une valeur Int, le résultat est "no-value"

Le résultat de int_ceil n'a pas d'unité de mesure.

Chaîne

Fonctions traitant des valeurs String.

`concatenate` Concaténation de chaînes.

Signature : concatenate(String, String ) → String

La fonction concatenate renvoie la concaténation de ses deux arguments String.

`string_to_double` Convertir String en Double.

Signature : string_to_double(String ) → Double

La fonction string_to_double analyse son argument String en tant que nombre à virgule flottante et renvoie le résultat en tant que valeur Double. Si la chaîne n'est pas une valeur à virgule flottante valide, le résultat est no-value.

Le résultat de string_to_double n'a pas d'unité de mesure.

`string_to_int64` Convertir String en Int.

Signature : string_to_int64(String ) → Int

La fonction string_to_int64 analyse son argument d'entrée String sous forme de nombre entier et renvoie le résultat en tant que valeur Int. Si la chaîne n'est pas une valeur entière valide ou ne peut pas être représentée sous la forme d'une valeur Int, le résultat est no-value.

Le résultat de string_to_int64 n'a pas d'unité de mesure.

`ascii_to_lower` Remplacez les majuscules ASCII par des minuscules.

Signature : ascii_to_lower(String ) → String

La fonction ascii_to_upper utilise un argument String et renvoie une valeur String identique, sauf que chaque lettre ASCII en majuscules a été convertie à la lettre ASCII en minuscules correspondante. Tous les autres caractères restent inchangés.

`ascii_to_upper` Remplacez les lettres minuscules ASCII par des majuscules.

Signature : ascii_to_upper(String ) → String

La fonction ascii_to_upper utilise un argument String et renvoie une valeur String identique à celle qui a été convertie en minuscules à la lettre ASCII en majuscules correspondante. Tous les autres caractères restent inchangés.

`utf8_normalize` Chaîne Unicode adaptée à la comparaison de la casse.

Signature : utf8_normalize(String ) → String

La fonction utf8_normalize utilise un argument String et renvoie une valeur String adaptée à la comparaison de la valeur d'entrée dans le cas où l'entrée est une chaine à encodage utf8 valide.

Expressions régulières

Fonctions qui effectuent la mise en correspondance, l'extraction et la modification à l'aide d'expressions régulières RE2.

`re_full_match` Vrai si une expression régulière correspond à la totalité d'une valeur de chaîne.

Signature : re_full_match(String, lit-String ) → Bool

La fonction re_partial_match utilise une entrée de chaîne et une expression régulière de chaîne littérale et renvoie true si l'intégralité de la chaîne d'entrée correspond à l'expression régulière. Elle renvoie false dans le cas contraire, même si l'argument de chaîne d'entrée est no-value.

Une correspondance d'expression régulière sur la colonne resource.project_id fait l'objet d'un traitement spécial pour gérer la différence entre les numéros de projet et les noms de projet, comme décrit dans la section Mise en correspondance de la colonne resource.project_id.

`re_partial_match` Vrai si une expression régulière correspond à une partie de la valeur de chaîne.

Signature : re_partial_match(String, lit-String ) → Bool

La fonction re_partial_match utilise une entrée de chaîne et une expression régulière de chaîne littérale et renvoie true si une partie de la chaîne d'entrée correspond à l'expression régulière. Elle renvoie false dans le cas contraire, même si l'argument de chaîne est no-value.

`re_extract` Extrayez les valeurs correspondant à une expression régulière dans une autre chaîne.

Signature : re_extract(String, [lit-String], [lit-String] ) → String

La fonction re_extract utilise un argument String d'entrée et deux arguments littéraux String : une expression régulière et une chaîne de remplacement. Le résultat est obtenu en faisant correspondre la chaîne d'entrée à l'expression régulière et en remplaçant les groupes de capture de substitution dans l'expression de la chaîne de remplacement. Le résultat est la chaîne de remplacement remplacée par les groupes de capture.

Si l'argument de l'expression régulière n'est pas spécifié, la valeur par défaut est "(.*)", ce qui inclut la chaîne d'argument du premier entier dans un groupe de capture.

Si l'argument de chaîne de remplacement n'est pas spécifié, la valeur par défaut est R"\1", ce qui fait du premier groupe de remplacement la chaîne de sortie.

Si la chaîne d'entrée est no-value, si l'expression régulière ne correspond pas ou si la substitution de groupes de capture n'a pas fonctionné, "no-value" est renvoyé.

`re_replace` Remplacez la première correspondance d'une expression régulière dans une autre chaîne.

Signature : re_replace(String, lit-String, lit-String ) → String

La fonction re_replace utilise un argument d'entrée String et deux arguments littéraux String : une expression régulière et une valeur de remplacement. Si l'expression régulière correspond à une partie de la chaîne d'entrée, la valeur renvoyée est créée en remplaçant la première correspondance de cette chaîne par la chaîne de remplacement.

Si la chaîne d'entrée est no-value ou s'il n'y a pas de correspondance, la chaîne d'entrée est la valeur renvoyée.

`re_global_replace` Remplace toutes les correspondances d'une expression régulière dans une autre chaîne.

Signature : re_global_replace(String, lit-String, lit-String ) → String

La fonction re_global_replace prend un argument d'entrée String et deux arguments littéraux String : une expression régulière et une valeur de remplacement. Le résultat est obtenu à partir de la chaîne d'entrée en remplaçant chaque correspondance disjointe de l'expression régulière (de gauche à droite) par la chaîne de remplacement.

Si la chaîne d'entrée est no-value ou s'il n'y a pas de correspondance, la chaîne d'entrée est la valeur renvoyée.

Agrégation

Une fonction d'agrégation combine un ensemble de valeurs d'entrée en une valeur de sortie finale. Elle est utilisée lorsqu'un certain nombre de lignes d'entrée sont regroupées et agrégées dans une seule ligne de sortie.

Une fonction d'agrégation conserve un état d'agrégation interne. L'expression d'argument de la fonction d'agrégation est évaluée une fois pour chaque ligne d'entrée groupée et la valeur obtenue (le cas échéant) est transmise à la fonction d'agrégation pour être accumulée dans son état interne. Une fois que cette opération a été effectuée pour toutes les lignes du groupe, la fonction d'agrégation génère sa valeur de sortie à utiliser dans la création de colonnes de valeurs sur la seule ligne de sortie.

Par exemple, mean(memory_usage) appliqué à un ensemble de lignes avec une colonne memory_usage, évalue l'expression d'argument memory_usage pour chaque ligne et intègre la valeur obtenue (le cas échéant) à l'état interne de la fonction d'agrégation mean (qui peut être une somme de valeurs et un nombre de valeurs). Une fois toutes les lignes traitées, le réducteur mean produit une valeur à partir de son état interne (il s'agit de la somme divisée par le nombre).

La plupart des fonctions d'agrégation qui opèrent sur des valeurs numériques ou Distribution donnent à leur sortie l'unité de mesure de l'entrée. Exceptions :

count et row_count, dont le résultat possède l'unité 1.
variance, dont le résultat correspond à l'entrée élevée au carré.
covariance, dont le résultat correspond au produit des unités des deux entrées.
fraction_less_than et fraction_true attribuent l'unité 10^2.% à leur sortie.

`sum` Somme d'un groupe de valeurs numériques.

Signature : sum(Num ) → Num.Delta (temporel uniquement)
sum(Distribution ) → Double.Delta (temporel uniquement)
sum(Num ) → Indicateur de nombre (glissement temporel uniquement)
sum(Distribution ) → Double.Gauge (glissement temporel uniquement)
sum(Num ) → Num.FirstArgKind
sum(Distribution ) → Double.FirstArgKind

Si l'expression d'argument est numérique (Int ou *Double), la somme des valeurs qui lui sont transmises est renvoyée.

Si l'expression d'argument est une valeur Distribution, elle renvoie la somme des valeurs de population dans toutes les valeurs Distribution qui lui sont transmises.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur ou une valeur Double non finie, cette ligne d'entrée n'affecte pas la somme.

Pour des valeurs numériques (Int ou Double), le résultat est du même type ( int* ou Double ) que l'expression d'entrée. Pour les valeurs d'entrée Distribution, le type de résultat est Double.

Le résultat présente un genre de série temporelle Delta si des agrégations temporelles non glissantes sont effectuées ou si seule une agrégation spatiale est effectuée, et le genre de série temporelle d'entrée est également Delta.

L'unité de mesure associée au résultat de sum est identique à l'unité de l'entrée.

`distribution` Distribution à partir d'un groupe de valeurs numériques ou de distribution.

Signature : distribution(Num, lit-BucketSpecification ) → Distribution.Delta (temporel uniquement)
distribution(Num, lit-BucketSpecification ) → Distribution.
distribution(Distribution ) → Distribution.Delta (temporel uniquement)
distribution(Distribution ) → Distribution. (glissement temporel uniquement)
distribution(Distribution ) → Distribution.FirstArgKind

Si le premier argument est une valeur Num, les valeurs d'entrée sont collectées dans un résultat de distribution dont la spécification de bucket est donnée par l'argument lit-Bucketer.

Si le premier argument est une valeur Distribution, les distributions sont fusionnées dans un résultat de distribution qui inclut la population de toutes les distributions d'entrée. La spécification de bucket de distribution obtenu est déterminée à partir des spécifications du bucket de distribution d'entrée. Si les spécifications du bucket sont identiques, cette spécification est utilisée. S'il existe différentes spécifications de bucket, une nouvelle spécification de bucket fusionnée est utilisée. Cette spécification fusionnée n'est généralement pas plus précise que la spécification de bucket d'entrée la moins précise.

Si, pour une ligne d'entrée, la première expression d'argument n'évalue pas une valeur ou renvoie une valeur Double non finie, cette ligne d'entrée n'affecte pas le centile.

L'unité de mesure associée au résultat de distribution est identique à l'unité de l'entrée.

`count` Nombre de valeurs dans un groupe de valeurs.

Signature : count(ColumnValue ) → Int.Delta (temporel uniquement)
count(ColumnValue ) → Int.Gauge

Renvoie le nombre de valeurs qui lui ont été transmises. Si l'expression d'argument n'évalue pas une valeur pour une ligne d'entrée ou une valeur Double non finie, elle n'est pas comptabilisée.

La sortie aura le genre de série temporelle Delta lorsque l'agrégation temporelle non glissante est effectuée.

L'unité de mesure associée au résultat de count est 1.

`row_count` Nombre de lignes d'entrée rencontrées.

Signature : ImplicitRowSetInput row_count( ) → Int.Delta (temporel uniquement)
ImplicitRowSetInput 1} row_count( ) → Int.Gauge

La fonction d'agrégation row_count renvoie le nombre de lignes agrégées. Contrairement à count, row_count ne prend pas d'argument et ne se soucie pas de pouvoir calculer une valeur à partir de la ligne.

La sortie aura le genre de série temporelle Delta lorsque l'agrégation temporelle non glissante est effectuée.

L'unité de mesure associée au résultat de count est 1.

`count_true` Nombre de valeurs réelles dans un groupe de valeurs booléennes.

Signature : count_true(Bool ) → Int.Delta (temporel uniquement)
count_true(Bool ) → Int

Les valeurs booléennes d'entrée sont collectées et le résultat correspond au nombre de valeurs d'entrée qui sont "true".

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

La sortie aura le genre de série temporelle Delta lorsque l'agrégation temporelle non glissante est effectuée.

L'unité de mesure associée au résultat de count_true est 1.

`min` Minimum d'un groupe de valeurs numériques.

Signature : min(Num ) → Num

Collecte les valeurs numériques qui leur sont transmises et renvoie la valeur minimale si le type de résultat est identique au type d'entrée.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de min est identique à l'unité de l'entrée.

`max` Valeur maximale d'un groupe de valeurs numériques.

Signature : max(Num ) → Num

Collecte les valeurs numériques qui lui sont transmises et renvoie la valeur maximale. si le type de résultat est identique au type d'entrée.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de max est identique à l'unité de l'entrée.

`diameter` Valeur maximale moins le minimum d'un groupe de valeurs numériques.

Signature : diameter(Num ) → Num

Collecte les valeurs numériques qui lui sont transmises et renvoie la différence entre le maximum des valeurs et le minimum des valeurs si le type de résultat est identique au type d'entrée (Int ou Double).

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de diameter est identique à l'unité de l'entrée.

`mean` Moyenne d'un groupe de valeurs numériques.

Signature : mean(Somme ) → Double

Si l'expression d'argument est numérique (Int ou *Double), renvoie la moyenne des valeurs qui lui sont transmises.

Si l'expression d'argument est de type Distribution, cela renvoie la moyenne de toutes les valeurs de toutes les distributions.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur ou une valeur Double non finie, cette ligne d'entrée n'affecte pas la moyenne.

L'unité de mesure associée au résultat de mean est identique à l'unité de l'entrée.

`stddev` Écart type d'un groupe de valeurs.

Signature : stddev(Somme ) → Double

Si l'expression d'argument est numérique (Int ou *Double), renvoie l'écart type des valeurs qui lui sont transmises.

Si l'expression d'argument est une valeur Distribution, elle renvoie l'écart type de toutes les valeurs de toutes les distributions.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur ou une valeur Double non finie, cette ligne d'entrée n'affecte pas l'écart type.

L'unité de mesure associée au résultat de stddev est identique à l'unité de l'entrée.

`variance` Variance d'un groupe de valeurs numériques.

Signature : variance(Somme ) → Double

Si l'expression d'argument est numérique (Int ou *Double), cela renvoie la variance des valeurs qui lui sont transmises.

Si l'expression d'argument est de type Distribution, cela renvoie la variance de toutes les valeurs de toutes les distributions.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur ou évalue une valeur Double non finie, cette ligne d'entrée n'affecte pas la variance.

Aucune unité de mesure n'est associée au résultat de la fonction variance.

`covariance` Covariance d'un groupe de paires de valeurs.

Signature : covariance(Num, Num ) → Double

Cette fonction renvoie la covariance des paires de valeurs numériques (Int ou *Double) qui lui sont transmises.

Si, pour une ligne d'entrée, une expression d'argument n'évalue pas une valeur ou évalue une valeur Double non finie, cette ligne d'entrée n'affecte pas la covariance.

Aucune unité de mesure n'est associée au résultat de la fonction covariance.

`median` : médiane d'un groupe de valeurs numériques ou de distribution.

Signature : median(Somme ) → Double

Si l'expression d'argument est numérique (Int ou *Double), cela renvoie une estimation de la médiane de la population de valeurs qui lui est transmise. La médiane est calculée en créant une valeur de distribution à partir des valeurs de la population avec des limites de bucket espacées de 10 %, ce qui limite l'erreur dans l'estimation par ce montant.

La spécification de bucket utilisée pour accumuler une valeur de Distribution à partir d'une entrée numérique pour estimer une médiane est powers_of(1.05).num_buckets(500).lower(.01). Cela inclut une plage de valeurs allant de .01 à environ 4e+8. Bien que cela permette de gérer de nombreux cas d'utilisation, il peut être nécessaire d'utiliser la fonction scale pour ajuster l'entrée, par exemple de By à MiBy ou "MBy" si la plage du nombre d'octets sera de l'ordre du gigaoctet ou du téraoctet.

Si l'expression d'argument est une valeur Distribution, cela renvoie une estimation de la médiane de la population fusionnée de valeurs de toutes les distributions. La médiane est calculée en fusionnant toutes les distributions d'entrée en une seule distribution et en estimant la médiane. La précision de la médiane dépend des limites du bucket des distributions d'entrée.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur ou une valeur Double non finie, cette ligne d'entrée n'affecte pas l'écart type.

L'unité de mesure associée au résultat de median est identique à l'unité de l'entrée.

`percentile` Centile d'un groupe de valeurs numériques ou de distribution.

Signature : percentile(Somme, lit-Num ) → Double

L'argument lit-Num donne un centile (compris entre 0 et 100).

Si la première expression d'argument est numérique (Int ou Double), cela renvoie une estimation de ce centile de la population de valeurs qui lui est transmise. Le centile est calculé en créant une valeur de distribution à partir des valeurs de la population avec des limites de bucket espacées de 10 %, ce qui limite l'erreur dans l'estimation par ce montant.

La spécification de bucket utilisée pour accumuler une valeur Distribution à partir d'une entrée numérique pour estimer un centile est powers_of(1.05).num_buckets(500).lower(.01). Cela inclut une plage de valeurs allant de .01 à environ 4e+8. Bien que cela permette de gérer de nombreux cas d'utilisation, il peut être nécessaire d'utiliser la fonction scale pour ajuster l'entrée, par exemple de By à MiBy ou "MBy" si la plage du nombre d'octets sera de l'ordre du gigaoctet ou du téraoctet.

Si l'expression d'argument est une valeur Distribution, cela renvoie une estimation du centile de la population fusionnée de valeurs de toutes les distributions. Le centile est calculé en fusionnant toutes les distributions d'entrée en une seule distribution et en estimant le centile. La précision du centile dépend des limites du bucket des distributions d'entrée.

Si, pour une ligne d'entrée, la première expression d'argument n'évalue pas une valeur ou renvoie une valeur Double non finie, cette ligne d'entrée n'affecte pas le centile.

L'unité de mesure associée au résultat de percentile est identique à l'unité de l'entrée.

`fraction_less_than` Fraction d'un groupe de valeurs inférieure à une valeur fixe.

Signature : fraction_less_than(Somme, lit-Num ) → Double

Si le premier argument est une valeur numérique (Int ou *Double), renvoie la fraction de la collection de valeurs transmises au premier argument qui sont inférieures à la valeur de l'argument lit-Num. Dans le calcul de cette fraction, ignore les valeurs Double non finies et les valeurs Int et Double sans valeur.

Si le premier argument est une valeur de Distribution, cela combine les populations de toutes les Distributions transmises et fait une estimation de la fraction des valeurs de la distribution de cette distribution agrégée qui est inférieure à la valeur de l'argument lit-Num.

L'unité de mesure associée au résultat de fraction_less_than est 10^2.%.

`fraction_true` Fraction d'un groupe de valeurs booléennes qui sont "true".

Signature : fraction_true(Bool ) → Double

Les valeurs booléennes d'entrée sont collectées et le résultat est une valeur Double comprise entre 0 et 1, qui correspond à la fraction de valeurs d'entrée vraies.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de fraction_true est 10^2.%.

`any_true` Disjonction d'un groupe de valeurs booléennes.

Signature : any_true(Bool ) → Bool

La fonction any_true calcule la valeur true si toutes ses valeurs d'entrée sont true et renvoient false.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

`all_true` Conjonction d'un groupe de valeurs booléennes.

Signature : all_true(Bool ) → Bool

La fonction all_true calcule la valeur true si toutes ses valeurs d'entrée sont true et renvoie false dans le cas contraire.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

`pick_any` Valeur de n'importe quel élément d'un groupe de valeurs (choisie de manière arbitraire).

Signature : pick_any(ColumnValue ) → FirstArgType

Cette fonction renvoie l'une des valeurs qui lui sont attribuées, choisies de manière arbitraire.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de pick_any est identique à l'unité de l'entrée, si celle-ci en possède une.

`singleton` Valeur de l'élément d'un groupe de valeurs comportant un seul élément.

Signature : singleton(ColumnValue ) → FirstArgType

Cette fonction renvoie sa valeur d'expression d'argument telle qu'elle est évaluée sur une seule ligne. Il s'agit d'une erreur si son expression d'argument est évaluée et génère une valeur pour plusieurs lignes, même si elle correspond à une valeur générée précédemment.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de singleton est identique à l'unité de l'entrée.

`unique` Valeur commune d'un groupe de valeurs (qui doivent toutes être identiques).

Signature : unique(Comparable ) → FirstArgType

La fonction unique renvoie la valeur qui est identique à chaque valeur qui lui a été attribuée. Si cette valeur n'existe pas (au moins deux valeurs différentes), cela génère une erreur et renvoie l'une des valeurs qui lui sont données.

Si, pour une ligne d'entrée, l'expression d'argument n'évalue pas une valeur, cette ligne d'entrée n'affecte pas le résultat.

L'unité de mesure associée au résultat de unique est identique à l'unité de l'entrée.

`aggregate` Valeur agrégée par défaut d'un groupe de valeurs de tout type.

Signature : aggregate(Num ) → Num.Delta (temporel uniquement)
aggregate(Distribution ) → Distribution.Delta (temporel uniquement)
aggregate(Num ) → Indicateur de nombre (glissement temporel uniquement)
aggregate(Distribution ) → Distribution. (glissement temporel uniquement)
aggregate(Num ) → Num.FirstArgKind
aggregate(Distribution ) → Distribution.FirstArgKind
aggregate(Bool ) → Bool
aggregate(String ) → String

La fonction aggregate effectue une agrégation qui dépend du type de l'entrée.

Pour les entrées Int et Double, cette donnée est identique à l'agrégateur sum.
Pour l'entrée Distribution, cette donnée est identique à l'agrégateur distribution.
Pour l'entrée Bool, cette donnée est identique à l'agrégateur any_true.
Pour l'entrée String, cette donnée est identique à l'agrégateur pick_any.

`weighted_distribution` Distribution à partir d'un groupe de valeurs pondérées.

Signature : weighted_distribution(Num, Int, lit-BucketSpecification ) → Distribution.Delta (temporel uniquement)
weighted_distribution(Num, Int, lit-BucketSpecification ) → Distribution.

Les valeurs d'entrée sont collectées dans un résultat de distribution dont la spécification de bucket est donnée par l'argument lit-Bucketer. Le premier argument est la valeur à ajouter à la distribution et le second argument est la pondération de cette valeur. Une valeur N avec une pondération de M est représentée par M instances de la valeur N dans la distribution.

Si, pour une ligne d'entrée, la première ou la deuxième expression d'argument n'évalue pas une valeur ou évalue une valeur Double non finie, cette ligne d'entrée n'affecte pas le centile.

L'unité de mesure associée au résultat de weighted_distribution est identique à l'unité de l'entrée.

Alignement

Les fonctions d'alignement sont utilisées par l'opération de table align pour produire une table alignée, dont les séries temporelles comportent des points avec des horodatages à intervalles réguliers.

En plus de son argument Duration explicite, une fonction d'alignement prend une série temporelle d'entrée et un moment précis, et génère un point de sortie pour cet instant précis.

La fonction d'alignement interpolate génère une valeur à un moment donné en interpolant une valeur à partir de deux points d'entrée adjacents, dont les horodatages couvrent l'horodatage de sortie.

Les fonctions d'alignement next_older et next_younger génèrent la valeur à partir du point unique de la série temporelle d'entrée dont l'horodatage est immédiatement antérieur ou postérieur à l'horodatage de sortie.

Les fonctions d'aligneur delta, rate et delta_gauge calculent leur sortie en fonction de la variation de la valeur de la série temporelle d'entrée sur la fenêtre temporelle définie par l'heure de fin du point de sortie et le moment situé Duration plus tôt. Cette variation de la valeur est calculée comme suit :

Ainsi, la valeur à tout moment de la série temporelle d'entrée peut être calculée à l'aide d'une interpolation linéaire entre les points immédiatement antérieur et postérieur à l'heure de sortie. La variation de valeur sur une fenêtre donnée est la différence entre les valeurs d'interpolation à la borne antérieure et à la borne postérieure de l'intervalle de temps.
La variation dans la fenêtre correspond à la somme de la valeur de tous les points dont l'étendue se trouve entièrement dans la fenêtre et la part au prorata de la valeur des points dont l'étendue chevauche partiellement la fenêtre.
Pour une série temporelle Cumulative, une interpolation d'une valeur entre deux points alignés avec la même heure de début est effectuée par une interpolation linéaire entre les deux valeurs. L'interpolation entre deux points adjacents ayant des heures de début différentes (de sorte que l'heure de début du point le plus récent se situe entre les heures de fin des deux points) peut être gérée de deux manières :
- Si l'heure de sortie est comprise entre l'heure de fin du point antérieur et l'heure de début du point postérieur, le résultat est la valeur du point antérieur. (Aucune modification entre le point antérieur et l'heure de réinitialisation.)
- Si l'heure de sortie est comprise entre les heures de début et de fin du point postérieur, la valeur correspond à l'interpolation linéaire entre zéro (à l'heure de début) et la valeur du point.
Pour une série temporelle Cumulative, la variation de valeur sur une fenêtre donnée correspond à la différence entre les valeurs d'interpolation à la borne antérieure et à la borne postérieure, avec une correction pour les réinitialisations. Pour chaque heure de réinitialisation comprise dans la fenêtre, la valeur du point immédiatement avant l'heure de réinitialisation est ajoutée à la variation de valeur afin de tenir compte du fait que la valeur de la série temporelle est réinitialisée à 0 à cet instant.

Les fonctions d'alignement agrégé, mean_aligner et int_mean_aligner, appliquent une fonction d'agrégation aux points d'entrée qui se situent dans une fenêtre temporelle dont la largeur est donnée par l'argument Duration et dont la borne postérieure est l'horodatage du point de sortie. Le résultat de cette agrégation correspond à la valeur du point de sortie.

L'unité de mesure du résultat d'une fonction d'alignement est généralement identique à celle de l'entrée. Exceptions :
- La sortie de rate possède l'unité de son entrée divisée par l'unité "s".
- La sortie de count_true_aligner possède l'unité 1.
- La sortie de fraction_true_aligner possède l'unité 10^2.%.

`rate` Calculez un taux de variation à des moments alignés.

Signature : ImplicitRowInput rate([lit-Duration] ) → Double.Gauge (entrée de ligne implicite)

L'alignement rate fonctionne sur les séries temporelles d'entrée avec une colonne à valeur unique de type numérique (Int ou *Double). Il génère toujours une table de sortie avec une colonne de valeur unique de type Double et de genre de série temporelle Gauge.

L'alignement rate calcule la modification de la valeur de la série temporelle sur sa fenêtre (comme décrit ici) et la divise par la largeur de la fenêtre en secondes. La fenêtre s'étend du moment défini par le point de sortie au moment situé Duration plus tôt dans le temps.

La valeur par défaut de l'argument Duration est la période d'alignement. Contrairement à la fonction d'alignement delta, il n'est pas nécessaire que la période d'alignement et la largeur de la fenêtre correspondent.

`delta` Calculez la variation de valeur à des moments alignés.

Signature : ImplicitRowInput delta([lit-Duration] ) → InputType.Delta (entrée de ligne implicite)

L'alignement delta fonctionne sur les séries temporelles d'entrée avec une colonne de valeur unique de type Sommable (Int, Double ou Distribution) et la sortie est une série temporelle dont la colonne de valeur est du même type, mais possède un genre de série temporelle Delta.

L'aligneur "delta_gauge" calcule la variation de valeur de la série temporelle d'entrée sur la fenêtre définie par le point de sortie et le moment situé Duration plus tôt dans le temps. L'heure de début du point de sortie est antérieur à l'heure de sortie (heure de fin du point) d'une durée Duration.

L'aligneur delta exige que l'argument Duration soit identique à la période d'alignement utilisée. La valeur par défaut de l'argument Duration est cette période d'alignement.

`any_true_aligner` Alignez une série temporelle Bool en recherchant n'importe quelle valeur "true" dans une fenêtre.

Signature : ImplicitRowInput any_true_aligner([lit-Duration] ) → Bool.Gauge (entrée de ligne implicite)

L'alignement any_true_aligner fonctionne sur une table d'entrée avec une colonne de valeur unique de type Bool et génère une table de sortie avec une colonne de valeur unique de type Bool et de genre de série temporelle Gauge.

L'argument Duration donne la largeur d'une fenêtre temporelle pour chaque point de sortie se terminant à l'heure de ce point de sortie. Si l'argument Duration n'est pas spécifié, il est défini par défaut sur la période d'alignement. La valeur d'un point de sortie est true si un point d'entrée de la fenêtre est "true" et false dans le cas contraire.

`count_true_aligner` Alignez une série temporelle Bool en comptant les valeurs "true" dans une fenêtre.

Signature : ImplicitRowInput count_true_aligner([lit-Duration] ) → Int.Gauge (entrée de ligne implicite)

L'alignement count_true_aligner fonctionne sur une table d'entrée avec une colonne de valeur unique de type Bool et génère une table de sortie avec une colonne de valeur unique de type Int et de genre de série temporelle Gauge.

L'argument Duration donne la largeur d'une fenêtre temporelle pour chaque point de sortie se terminant à l'heure de ce point de sortie. Si l'argument Duration n'est pas spécifié, il est défini par défaut sur la période d'alignement. La valeur d'un point de sortie correspond au nombre de points d'entrée dans la fenêtre avec la valeur true.

`delta_gauge` Calculez la variation de valeur à des moments alignés sous la forme d'une série temporelle de type Gauje.

Signature : ImplicitRowInput delta_gauge([lit-Duration] ) → InputType.Gauge (entrée de ligne implicite)

L'alignement delta_gauge fonctionne sur les séries temporelles d'entrée avec une colonne de valeur unique de type Sommable (Int, Double ou Distribution) et que la sortie est une série temporelle dont la colonne de valeur est du même type, mais possède un genre de série temporelle Gauge.

La fonction d'alignement delta_gauge calcule la variation de la valeur de la série temporelle d'entrée sur sa fenêtre (comme décrit ici). La fenêtre s'étend du moment défini par le point de sortie au moment situé Duration plus tôt dans le temps.

`fraction_true_aligner` Alignez une série temporelle Bool sur la fraction des valeurs "true" dans une fenêtre.

Signature : ImplicitRowInput fraction_true_aligner([lit-Duration] ) → Double.Gauge (entrée de ligne implicite)

L'alignement fraction_true_aligner fonctionne sur une table d'entrée avec une colonne de valeur unique de type Bool et génère une table de sortie avec une colonne de valeur unique de type Double et de genre de série temporelle Gauge.

L'argument Duration donne la largeur d'une fenêtre temporelle pour chaque point de sortie se terminant à l'heure de ce point de sortie. Si l'argument Duration n'est pas spécifié, il est défini par défaut sur la période d'alignement. La valeur d'un point de sortie est la fraction de tous les points d'entrée de la fenêtre qui ont la valeur true.

`int_mean_aligner` Alignez en recherchant la moyenne des valeurs Int dans une fenêtre.

Signature : ImplicitRowInput int_mean_aligner([ lit-Duration ] ) → Int.Gauge (entrée de ligne implicite)

L'alignement int_mean_aligner fonctionne sur une table d'entrée avec une colonne de valeur unique de type Int et de genre de série temporelle Gauge ou Delta. Il génère une table de sortie avec une seule colonne de valeur de type Int et de genre de série temporelle Gauge.

L'argument Duration donne la largeur d'une fenêtre temporelle pour chaque point de sortie se terminant à l'heure de ce point de sortie. Si l'argument Duration n'est pas spécifié, il est défini par défaut sur la période d'alignement. La valeur d'un point de sortie correspond à la moyenne des points de valeur de la table d'entrée compris dans cette fenêtre, arrondie à la valeur entière la plus proche.

`interpolate` Calculez des valeurs d'interpolation à des moments alignés.

Signature : ImplicitRowInput interpolate([lit-Duration] ) → InputType.Gauge (entrée de ligne implicite)

L'alignement interpolate fonctionne sur une table d'entrée avec une colonne de valeur unique de type numérique (Int ou *Double) et de genre de série temporelle Gauge. Il génère une table de sortie avec une colonne de valeur unique de même type et de même genre de série temporelle.

Si l'heure de sortie de la fonction d'alignement interpolate est identique à l'heure de fin d'un point de la série temporelle d'entrée, elle est utilisée pour le point de sortie. Dans le cas contraire, la fonction d'alignement interpolate prend en compte les points d'entrée immédiatement antérieur et postérieur à l'heure de sortie. S'ils sont séparés d'une durée Duration ou moindre, la valeur de sortie est l'interpolation linéaire entre ces points à l'heure de sortie. S'il n'existe aucun point d'entrée antérieur ou postérieur à l'heure de sortie, ou si les deux points d'entrée sont distants de plus de Duration dans le temps, aucune valeur de sortie n'est générée.

La valeur par défaut de l'argument Duration correspond au double de la période d'alignement.

`mean_aligner` Alignez en recherchant la moyenne des valeurs dans une fenêtre.

Signature : ImplicitRowInput mean_aligner([lit-Duration] ) → Double.Gauge (entrée de ligne implicite)

L'alignement mean_aligner fonctionne sur une table d'entrée avec une colonne à valeur unique de type numérique. (Int ou Double) et genre de série temporelle Gauge ou Delta.) La fonction génère une table de sortie avec une colonne de valeur unique de type Double et de genre de série temporelle Gauge.

L'argument Duration donne la largeur d'une fenêtre temporelle pour chaque point de sortie se terminant à l'heure de ce point de sortie. Si l'argument Duration n'est pas spécifié, il est défini par défaut sur la période d'alignement. La valeur d'un point de sortie correspond à la moyenne des points de valeur de la table d'entrée compris dans cette fenêtre.

`next_older` Moments alignés en passant d'un moment antérieur à un moment plus récent.

Signature : ImplicitRowInput next_older([lit-Duration] ) → InputType.Gauge (entrée de ligne implicite)

L'alignement next_older fonctionne sur les séries temporelles avec n'importe quel nombre de colonnes de valeur de n'importe quel type, mais toutes avec le genre de série temporelle Gauge. La fonction génère une colonne de sortie de même type et de même genre de série temporelle.

L'alignement next_older crée un point de sortie en recherchant le point d'entrée le plus récent dont l'heure de fin ne dépasse pas l'heure de sortie et est distante de l'heure de sortie d'au plus Duration dans le temps. Si ce point d'entrée n'existe pas, aucun point de sortie n'est créé.

La valeur par défaut de l'argument Duration correspond au double de la période d'alignement.

`next_younger` Moments alignés en passant d'un moment récent à un moment plus ancien.

Signature : ImplicitRowInput next_younger([lit-Duration] ) → InputType.Gauge (entrée de ligne implicite)

L'alignement next_younger fonctionne sur les séries temporelles avec n'importe quel nombre de colonnes de valeur de n'importe quel type, mais toutes avec le genre de série temporelle Gauge. La fonction génère une colonne de sortie de même type et de même genre de série temporelle.

L'alignement next_younger crée un point de sortie en recherchant le point d'entrée le plus ancien dont l'heure de fin ne dépasse pas l'heure de sortie et est distante de l'heure de sortie d'au plus Duration dans le temps. Si ce point d'entrée n'existe pas, aucun point de sortie n'est créé.

La valeur par défaut de l'argument Duration correspond au double de la période d'alignement.

Manipuler les unités

Les fonctions suivantes modifient les unités des expressions auxquelles elles sont appliquées.

`scale` Mettre à l'échelle une valeur vers une unité de mesure différente.

Signature : scale(Num, [ lit-String ] ) → Double
scale(Duration, [ lit-String ] ) → Double
scale(Date, [ lit-String ] ) → Double

La fonction scale renvoie la valeur du premier argument, convertie en Double si nécessaire, et éventuellement mise à l'échelle. Les unités sont fournies par le deuxième argument.

Si le deuxième argument n'est pas fourni, la fonction scale convertit simplement son premier argument en Double, sans modifier ses unités, sauf dans les cas où la mise à l'échelle automatique est appelée comme décrit ici. Dans ce cas, le deuxième argument est fourni de manière implicite et scale se comporte comme si elle avait reçu deux arguments.

Le deuxième argument, s'il est spécifié, doit être une chaîne de code UCUM valide pour l'unité vers laquelle le premier argument doit être mis à l'échelle. Dans ce cas, la valeur renvoyée représente la même quantité physique que la valeur d'entrée, mais exprimée dans les unités spécifiées par le deuxième argument. Ce résultat est obtenu en multipliant l'argument par le facteur de mise à l'échelle approprié.

Par exemple, l'expression scale(3 "min", "s") convertit la valeur 3 ayant comme unité les minutes (min) vers la valeur 180 ayant comme unité les secondes (s). Il s'agit de la même durée, exprimée dans des unités différentes.

Une erreur se produit si le premier argument ne présente pas d'unité ou si l'unité du premier argument n'a pas la même dimension que le code d'unité fourni comme deuxième argument, s'il est fourni. Si les unités ne présentent pas la même dimension, il est impossible de mettre à l'échelle le premier argument vers la dimension indiquée par le second argument.

Il est par exemple erroné d'écrire scale(3 "km", "m/s"), ce qui demanderait de mettre à l'échelle trois kilomètres vers une valeur exprimée en mètres par seconde. En effet, les kilomètres ont comme dimension une "distance" tandis que les kilomètres par seconde ont comme dimension une vitesse, c'est-à-dire "distance sur temps". Aucun facteur de mise à l'échelle ne peut transformer une distance en vitesse. Pour cela, il faudrait diviser la distance par une valeur ayant des unités de temps. Par exemple, scale(3 "km" / 10 "min", "m/s") effectuera la mise à l'échelle de .3 "km/min" vers 5 "m/s".

Si le premier argument est de type Date ou Duration, le deuxième argument doit indiquer une unité de temps (par exemple, "s", "h" ou "wk"). La valeur renvoyée est une valeur Double qui représente la durée exprimée par la première valeur d'argument dans les unités spécifiées par le deuxième argument. Pour une valeur Date, il s'agit de la durée écoulée depuis l'epoch Unix.

Par exemple, scale(1m, "s") générera une valeur de 60.0 ayant l'unité s, tandis que scale(d'1970/01/01-01:00:00+00', "h") renvoie une valeur de 1.0 ayant l'unité "h" (une heure écoulée depuis l'epoch Unix).

`cast_units` Définir l'unité de mesure d'une valeur.

Signature : cast_units(Summable, lit-String ) → FirstArgType

La fonction cast_units renvoie la valeur du premier argument sans la modifier, mais en définissant son unité de mesure comme celle renseignée dans la deuxième chaîne d'argument.

La chaîne doit être une valeur de chaîne de code UCUM pour l'unité souhaitée. Toute unité associée au premier argument avant l'application de cette fonction est ignorée.

Fenêtre périodique

Les fonctions de fenêtre périodiques permettent d'annoter un argument réel Duration transmis à un argument WindowDuration qui spécifie une largeur de fenêtre utilisée pour sélectionner des points d'entrée sur une opération de calcul périodique. Cet argument est transmis à l'opération de table group_by qui génère des séries temporelles alignées. Les fonctions window et sliding limitent la largeur de la fenêtre d'entrée en fonction de la période d'alignement de la sortie.

La fonction window indique que la période d'alignement et la largeur de la fenêtre doivent être identiques, de sorte que les fenêtres de point d'entrée ne se chevauchent pas.

La fonction sliding indique que la période d'alignement peut être inférieure à la largeur de la fenêtre, ce qui entraîne le chevauchement des fenêtres d'entrée.

`window` Indique une fenêtre identique à la période d'alignement.

Signature : window([lit-Duration] ) → lit-windowDuration

La fonction window annote un argument réel Duration transmis à un argument WindowDuration qui spécifie une largeur de fenêtre utilisée dans un calcul qui génère une série temporelle alignée. Elle nécessite que la largeur de la fenêtre et la période d'alignement de la sortie soient identiques à celles de l'argument Duration. Si l'argument Duration n'est pas précisé, la largeur de la fenêtre spécifiée correspond à la période d'alignement de la sortie telle que définie.

Par exemple, l'opération de table |group_bywindow(5m), .mean produit des points de sortie correspondant à la valeur moyenne des points d'entrée situés dans une fenêtre de 5 m de l'heure de fin de sortie. La fonction window annote la largeur de la fenêtre 5m pour exiger que la période d'alignement de group_by soit également de 5 minutes. L'opération de table | group_by window(), .mean nécessite également que la largeur de la fenêtre soit identique à la période d'alignement de sortie, mais ne spécifie pas cette information.

`sliding` Indique une fenêtre glissante (qui se chevauche) au lieu d'être disjointe.

Signature : sliding(lit-Duration ) → lit-SlidingDuration

La fonction sliding annote un argument Duration réel transmis à un argument WindowDuration qui spécifie la largeur de fenêtre utilisée dans un calcul qui génère une série temporelle alignée. Elle nécessite que la largeur de la fenêtre soit son argument Duration et que la période d'alignement ne soit pas plus longue (mais peut être plus réduire).

Par exemple, l'opération de table |group_bysliding(5m), .mean produit des points de sortie correspondant à la valeur moyenne des points d'entrée situés dans une fenêtre de 5 m de l'heure de fin de sortie. La fonction sliding annotant la largeur de la fenêtre 5m indique que la période d'alignement de group_by peut être inférieure ou égale à 5 minutes. Si une opération de table | every 1m indique un alignement de 1 minute, les 4 minutes de chaque fenêtre de 5 minutes chevauchent la fenêtre du point de sortie immédiatement antérieur.

Distribution

`count_from` Nombre de valeurs dans une valeur de distribution.

Signature : count_from(Distribution.CumulativeOK ) → Int.FirstArgKind

La fonction count_from renvoie la taille de la population de valeurs dans sa valeur de distribution d'entrée.

L'unité de mesure associée au résultat de count_from est 1.

`sum_from` Somme des valeurs d'une valeur de distribution.

Signature : sum_from(Distribution.CumulativeOK ) → Double.FirstArgKind

La fonction sum_from renvoie la somme de toutes les valeurs contenues dans sa valeur de distribution d'entrée.

Le résultat de sum_from a la même unité de mesure que l'entrée.

`mean_from` Moyenne des valeurs d'une valeur de distribution.

Signature : mean_from(Distribution ) → Double

La fonction mean_from renvoie la moyenne arithmétique de toutes les valeurs contenues dans sa valeur de distribution d'entrée.

Le résultat de mean_from a la même unité de mesure que l'entrée.

`stddev_from` Écart type des valeurs d'une valeur de distribution.

Signature : stddev_from(Distribution ) → Double

La fonction stddev_from renvoie la variance de la population aux valeurs contenues dans sa valeur de distribution d'entrée.

Le résultat de stddev_from a la même unité de mesure que l'entrée.

`variance_from` Variance des valeurs d'une valeur de distribution.

Signature : variance_from(Distribution ) → Double

La fonction variance_from renvoie la variance de la population aux valeurs contenues dans sa valeur de distribution d'entrée.

Le résultat de la fonction 'variance_from' n'a pas d'unité de mesure.

`median_from` Médiane des valeurs d'une valeur de distribution.

Signature : median_from(Distribution ) → Double

La fonction median_from renvoie une estimation de la médiane de la population correspondant aux valeurs contenues dans sa valeur de distribution d'entrée.

Le résultat de median_from a la même unité de mesure que l'entrée.

`percentile_from` Centile des valeurs dans une valeur de distribution.

Signature : percentile_from(Distribution, lit-Num ) → Double

La fonction percentile_from renvoie une estimation du centile de la population correspondant aux valeurs contenues dans sa valeur de distribution d'entrée. L'argument Num donne le centile à estimer sous la forme d'un nombre compris entre 0 et 100.

Le résultat de percentile_from a la même unité de mesure que l'entrée.

`fraction_less_than_from` Fraction des valeurs d'une distribution inférieure à une valeur fixe.

Signature : fraction_less_than_from(Distribution, lit-Num ) → Double

La fonction fraction_less_than_from renvoie une estimation de la fraction de la population dont les valeurs contenues dans sa valeur de distribution d'entrée sont inférieures à son argument Num.

L'unité de mesure associée au résultat de fraction_less_than est 10^2.%.

`bounded_percentile_from` Centile des valeurs dans une limite d'une valeur de distribution.

Signature : bounded_percentile_from(Distribution, lit-Num, [lit-Num], [lit-Num] ) → Double

La fonction bounded_percentile_from opère sur un sous-ensemble des valeurs contenues dans la distribution d'entrée. Une estimation est effectuée à partir de la population de valeurs supérieures au deuxième paramètre Num, le cas échéant, et inférieures ou égales au troisième paramètre Num, le cas échéant. Au moins l'un ou l'autre des deuxième et troisième arguments Num doit être fourni et, si les deux sont indiqués, le deuxième doit être inférieur au troisième.

Cette fonction renvoie une estimation du centile de cette population de valeurs estimée. Le premier argument Num fournit le centile à estimer sous la forme d'un nombre compris entre 0 et 100.

Le résultat de bounded_percentile_from a la même unité de mesure que l'entrée.

`rebucket` Valeur de distribution convertie en une nouvelle spécification de bucket.

Signature : rebucket(Distribution, lit-BucketSpecification ) → Distribution

Cette opération convertit la valeur de distribution d'entrée en valeur de distribution dont la spécification de bucket est indiquée dans le deuxième argument BucketSpecification.

Cela permet de répartir les décomptes de chaque bucket de la distribution d'entrée vers les buckets de la distribution de sortie, en supposant que les valeurs comptabilisées dans un bucket soient réparties de manière égale sur la plage du bucket. La distribution de sortie a le même nombre total que la distribution d'entrée, mais les décomptes sont répartis différemment sur les buckets de distribution de sortie. La distribution de sortie a la même somme, la même moyenne et le même écart type que la distribution d'entrée.

Spécificateur de bucket

Une valeur Distribution possède un histogramme composé de buckets. Chaque bucket est associé à une plage de valeurs et contient un décompte des valeurs de la distribution incluses dans cette plage. Chaque distribution possède une spécification de bucket qui décrit les limites des buckets dans une valeur de distribution. Les fonctions de cette section génèrent des spécifications de bucket.

`powers_of` Spécification de bucket dont les limites de bucket augmentent de manière exponentielle.

Signature : powers_of(lit-Num ) → lit-BucketSpecification

La fonction powers_of renvoie des spécifications de bucket dans lesquelles la limite supérieure de chaque bucket est un facteur fixe (indiqué par l'argument Num) multiplié par la limite inférieure. Ainsi, la taille du bucket augmente de manière exponentielle et l'erreur de calcul des centiles est limitée par un facteur constant de la valeur réelle.

Cela ne définit pas le nombre de buckets ni la limite inférieure du premier bucket, qui doivent tous deux être spécifiés (par "num_buckets" et "inférieur") ou prendront les valeurs par défaut (30 buckets, limite inférieure de 1.0). Si la spécification de bucket est donnée par powers_of, la limite inférieure doit être supérieure à 0.

L'exemple suivant donne une spécification de bucket avec 50 buckets dont la taille augmente de manière exponentielle à un taux de 1,1 à partir de la valeur 100. Les limites du bucket sont donc 1, 1.1, 1.21, 1.331, etc.

powers_of(1.1).num_buckets(30).lower(100.0)

`fixed_width` Spécification de bucket avec des buckets de taille égale.

Signature : fixed_width(lit-Num ) → lit-BucketSpecification

La fonction fixed_width renvoie une spécification de bucket dans laquelle la limite supérieure de chaque bucket est un montant fixe (indiqué par l'argument Num) supérieur à la limite inférieure. La taille du bucket est donc fixe.

L'exemple suivant donne une spécification de bucket avec 100 buckets de taille 1, commençant à 1. Il s'agit d'une bonne spécification pour une distribution de valeurs de pourcentage.

fixed_width(1).num_buckets(100)

`custom` Spécification de bucket à partir d'une liste de limites de bucket.

Signature : custom(lit-Num... ) → lit-BucketSpecification

La fonction custom renvoie une spécification de bucket avec des limites de bucket explicitement données. La fonction utilise plusieurs arguments numériques qui doivent être indiqués par ordre croissant. La limite inférieure du premier bucket est donnée par le premier argument et la limite supérieure du dernier bucket est donnée par le dernier argument. Chaque argument intermédiaire donne la limite supérieure du bucket précédent et la limite supérieure du bucket suivant.

Cela détermine complètement la spécification du bucket, en indiquant le nombre de buckets et la limite exacte de chacun d'eux.

L'exemple suivant donne une spécification de bucket avec 3 buckets. Le premier comporte les limites 3 et 27, le deuxième 27 et 105, et le troisième 105 et 277.

custom(3,27,105,277)

`num_buckets` Définit le nombre de buckets dans une spécification de bucket.

Signature : num_buckets(lit-BucketSpecification, lit-Num ) → lit-BucketSpecification

Lorsqu'elle est appliquée à une spécification de bucket dont le nombre de buckets n'est pas déterminé, la fonction num_buckets renvoie une spécification de bucket avec un nombre de buckets donné par son argument Num. Tous les autres aspects de la spécification du bucket d'entrée sont conservés.

La fonction num_buckets ne doit pas être appliquée à une spécification de bucket dont le nombre de buckets est déjà déterminé.

`bounds` Définit la limite inférieure du premier bucket et la limite supérieure du dernier.

Signature : bounds(lit-BucketSpecification, lit-Num, lit-Num ) → lit-BucketSpecification

Lorsqu'elle est appliquée à une spécification de bucket dont la limite inférieure du premier bucket ou la limite supérieure du dernier bucket n'est pas déterminée, la fonction bounds renvoie une spécification de bucket avec la limite inférieure de son premier bucket donnée par son premier Argument Num et la limite supérieure de son dernier bucket donnée par le deuxième argument Num. Tous les autres aspects de la spécification du bucket d'entrée sont conservés.

La fonction bounds ne doit pas être appliquée à une spécification de bucket dont la limite inférieure ou la limite supérieure du premier sont déjà déterminées.

`lower` Définit la limite inférieure du premier bucket dans une spécification de bucket.

Signature : lower(lit-BucketSpecification, lit-Num ) → lit-BucketSpecification

Lorsqu'elle est appliquée à une spécification de bucket dont la limite inférieure du premier bucket est déterminée, la fonction num_buckets renvoie une spécification de bucket avec la limite inférieure de son premier bucket donnée par son argument Num. Tous les autres aspects de la spécification du bucket d'entrée sont conservés.

La fonction lower ne doit pas être appliquée à une spécification de bucket dont la limite inférieure du premier bucket est déjà déterminée.

Divers

`cast_double` Convertissez la valeur Int en Double.

Signature : cast_double(Num.CumulativeOK ) → Double.FirstArgKind

La fonction cast_double utilise un seul argument Int et renvoie la valeur Double la plus proche.

Le résultat de cast_double a la même unité de mesure que l'entrée.

`cast_gauge` Convertissez une valeur de série temporelle Cumulative ou Delta en Gauge.

Signature : cast_gauge(ColumnValue.CumulativeOK ) → FirstArgType.Gauge

La fonction cast_gauge renvoie la valeur de son argument, mais modifie le type de série temporelle de la valeur en Gauge.

Si cela se traduit par une table de sortie sans colonnes de valeurs ayant le genre de série temporelle Delta, la table de sortie ne comporte aucune colonne d'heure de début.

Le résultat de cast_gauge a la même unité de mesure que l'entrée.

`within` Spécifie la fenêtre de calcul de la valeur de tri.

Signature : within(ColumnValue, [lit-DateOrDuration], [lit-DateOrDuration] ) → Windowed.FirstArgKind

La fonction within décore l'expression liée à l'argument de valeur de tri Windowed(Num) de l'opération de table top ou bottom. Il spécifie la fenêtre dans laquelle l'expression de valeur de tri est évaluée en spécifiant une ou deux valeurs sur trois : la plus ancienne (heure de début), la plus jeune (heure de fin) ou la durée de la fenêtre.

Si l'un des deux arguments de within constitue une valeur Duration positive, la largeur de la fenêtre est définie. Au maximum, l'un des arguments peut être une durée.

Si le premier argument est une Date, l'heure de début est spécifiée. Si le second argument est une Date, l'heure de fin est spécifiée. Si les deux arguments sont des valeurs Date, le second doit être postérieur au premier. Un argument Date peut être fourni en tant que valeur littérale Date, ou avec une valeur littérale Duration négative. Dans le dernier cas, l'heure correspond au moment situé Duration avant l'heure de fin de la fenêtre de requête externe (voir l'opération de table within).

Si le premier argument n'est pas fourni, la valeur par défaut est l'heure de début de la fenêtre de requête externe. Si le deuxième argument n'est pas fourni, il est défini par défaut sur l'heure de fin de la fenêtre de requête externe.

Par exemple, .mean().within(1h,-2h) indique que le réducteur max doit être appliqué à tous les points de la série temporelle d'entrée dont l'heure de fin est comprise dans une fenêtre d'une heure, se terminant il y a 2 heures. L'agrégateur mean est appliqué à tous les points d'entrée dont l'heure de fin se trouve dans cette fenêtre.

Par exemple, max(val()).within(10m) indique que le réducteur max doit être appliqué à toutes les séries temporelles d'entrée dont l'heure de fin est comprise dans l'intervalle de temps défini par l'heure de fin de la requête et le moment situé 10 minutes plus tôt. L'agrégateur max est appliqué à tous les points d'entrée dont l'heure de fin se trouve dans cette fenêtre.

Index des opérations et fonctions sur la table

Index de toutes les opérations et fonctions de table.

abs Valeur absolue.
absent_for Crée une condition pour l'absence d'entrée.
add Somme de deux nombres.
adjacent_delta Variation de la valeur entre un point d'entrée et le point immédiatement antérieur.
adjacent_rate Taux de variation entre le point d'entrée et les point immédiatement antérieurs (lignes).
aggregate Valeur globale par défaut d'un groupe de valeurs de tout type.
align Génère une table alignée à l'aide d'une fonction d'alignement.
all_true Conjonction d'un groupe de valeurs booléennes.
and Valeur logique et de deux valeurs booléennes.
any_true Disjonction d'un groupe de valeurs booléennes.
any_true_alignerAlignez une série temporelle Bool en recherchant n'importe quelle valeur "true" dans une fenêtre.
ascii_to_lower Remplacez les majuscules ASCII par des minuscules.
ascii_to_upper Remplacez les lettres minuscules ASCII par des majuscules.
bottom Sélectionne la série temporelle inférieure par une expression de valeur de tri.
bottom_by Sélectionne les séries temporelles par une expression de valeur de tri dans différents groupes.
bounded_percentile_from Centile des valeurs dans une limite d'une valeur de distribution.
bounds Définit la limite inférieure du premier bucket et la limite supérieure du dernier bucket.
cast_double Convertissez la valeur Int en Double.
cast_gauge Convertissez une valeur de série temporelle Cumulative ou Delta en Gauge.
cast_units Définir l'unité de mesure d'une valeur.
concatenate Concaténation de chaînes
condition Ajoute une colonne de condition booléenne à la table d'entrée.
count Nombre de valeurs dans un groupe de valeurs.
count_from Nombre de valeurs dans une valeur de distribution.
count_true Nombre de valeurs "true" dans un groupe de valeurs booléennes.
count_true_aligner Alignez une série temporelle Bool en comptant les valeurs "true" dans une fenêtre.
covariance La covariance d'un groupe de paires de valeurs.
custom Spécification de bucket à partir d'une liste de limites de bucket.
delta Calculez la variation de la valeur à des moments alignés.
delta_gauge Calculez la variation de valeur à des moments alignés sous la forme d'une série temporelle de type Gauge.
diameter Valeur maximale moins le minimum d'un groupe de valeurs numériques.
distribution Distribution à partir d'un groupe de valeurs numériques ou de distribution.
div Le ratio de deux nombres.
end Heure de fin du point d'entrée (ligne).
eq Égal.
every Spécifie la période pour la sortie de table alignée.
exp e élevé à une puissance.
false Valeur booléenne "false".
fetch Génère une table à partir de la base de données.
fetch_cumulative Génère une table de séries temporelles de type Cumulative à partir de la base de données.
filter Filtre les lignes d'une table d'entrée en fonction d'un prédicat.
filter_ratio Calcule le ratio de deux sommes filtrées de la colonne de valeurs d'entrée.
filter_ratio_by Calcule un ratio groupé de deux sommes filtrées de la colonne de valeurs d'entrée.
fixed_width Spécification de bucket avec des buckets de taille égale.
fraction_less_than Fraction d'un groupe de valeurs inférieure à une valeur fixe.
fraction_less_than_from Fraction des valeurs d'une distribution inférieure à une valeur fixe.
fraction_true Fraction d'un groupe de valeurs booléennes qui est vraie.
fraction_true_aligner Alignez une série temporelle Bool sur la fraction des valeurs "true" dans une fenêtre.
ge Supérieur ou égal.
graph_period Spécifie la période de sortie à privilégier pour la création de graphiques de séries temporelles.
group_by Agrège les lignes par identifiant de série temporelle et fenêtre temporelle mappés.
gt Supérieur.
has Vrai si un argument défini contient une valeur particulière.
has_value Vrai si une expression d'argument calcule une valeur.
hash_tsid Renvoie un hachage des colonnes d'identifiant de série temporelle.
ident Opération de table d'identité : aucune modification n'a été apportée à la table d'entrée.
if Valeur choisie de manière conditionnelle à partir de deux valeurs.
int_ceil Entier supérieur.
int_div Quota de la division de deux entiers.
int_floor Entier inférieur.
int_mean_aligner Alignez en recherchant la moyenne des valeurs Int dans une fenêtre.
int_round Entier le plus proche.
interpolate Calculez des valeurs d'interpolation à des moments alignés.
join Jointure naturelle de plusieurs tables.
le Inférieur ou égal.
log Logarithme naturel
lower Définit la limite inférieure du premier bucket dans une spécification de bucket.
lt Inférieur.
map Réécrit les colonnes d'identifiant de série temporelle et de valeur de chaque ligne d'une table.
max Valeur maximale d'un groupe de valeurs numériques.
mean Moyenne d'un groupe de valeurs numériques.
mean_aligner Alignez en recherchant la moyenne des valeurs dans une fenêtre.
mean_from Moyenne des valeurs d'une valeur de distribution.
median Médiane d'un groupe de valeurs numériques ou de distribution.
median_from Médiane des valeurs d'une valeur de distribution.
metric Génère la table pour un type de métrique spécifique à partir d'un ensemble de tables.
min Minimum d'un groupe de valeurs numériques.
mul Produit de deux nombres.
ne Non égal.
neg Négatif d'un nombre.
next_older Moments alignés en passant d'un moment antérieur à un moment plus récent.
next_younger Moments alignés en passant d'un moment récent à un moment plus ancien.
not Négation logique d'une valeur booléenne.
num_buckets Définit le nombre de buckets dans une spécification de bucket.
older Valeur du point immédiatement antérieur (ligne) dans une série temporelle.
or Valeur logique ou de deux valeurs booléennes.
or_else Une valeur ou, si ce n'est pas une valeur, une autre valeur.
outer_join Jointure naturelle externe de deux tables.
percentile Centile d'un groupe de valeurs numériques ou de distribution.
percentile_from Centile des valeurs d'une valeur de distribution.
pick_any Valeur de n'importe quel élément d'un groupe de valeurs (choisie de manière arbitraire).
pos Identité des entrées numériques.
power Un nombre à la puissance d'un autre
powers_of Spécification de bucket dont les limites de bucket augmentent de manière exponentielle.
rate Calculez un taux de variation à des moments alignés.
ratio Calcule le ratio des colonnes de valeurs de deux tables d'entrée alignées.
re_extract Extrayez les valeurs correspondant à une expression régulière dans une autre chaîne.
re_full_match Vrai si une expression régulière correspond à la totalité d'une valeur de chaîne.
re_global_replace Remplacez toutes les correspondances d'une expression régulière dans une autre chaîne.
re_partial_match Vrai si une expression régulière correspond à une partie de la valeur de chaîne.
re_replace Remplacez la première correspondance d'une expression régulière dans une autre chaîne.
rebucket Valeur de distribution convertie en une nouvelle spécification de bucket.
rem Reste de la division de deux entiers.
row_count Nombre de lignes d'entrée rencontrées.
scale Mettre à l'échelle une valeur vers une unité de mesure différente.
singleton Valeur de l'élément d'un groupe de valeurs comportant un seul élément.
sliding Indique une fenêtre glissante (qui se chevauche) au lieu d'être disjointe.
sqrt Racine carrée.
start Heure de début du point d'entrée (ligne).
stddev Écart type d'un groupe de valeurs.
stddev_from Écart type des valeurs d'une valeur de distribution.
string_to_double Convertissez String en Double.
string_to_int64 Convertissez String en Int.
sub Différence de deux nombres.
sum Somme d'un groupe de valeurs numériques.
sum_from Somme des valeurs d'une valeur de distribution.
time_shift Décale les séries temporelles dans le temps.
top Sélectionne la série temporelle supérieure par une expression de valeur de tri.
top_by Sélectionne les séries temporelles par une expression de valeur de tri dans différents groupes.
true Valeur booléenne "true".
unaligned_group_by Agrège les lignes par identifiant de série temporelle mappé sans alignement.
union Union de plusieurs tables.
union_group_by Agrège les lignes de plusieurs tables.
unique Valeur commune d'un groupe de valeurs (qui doivent toutes être identiques).
utf8_normalize Chaîne Unicode adaptée à la comparaison de la casse.
val Valeur d'une colonne de valeur dans le point d'entrée (ligne).
value Réécrit les colonnes de valeur de chaque ligne d'une table.
variance Variance d'un groupe de valeurs numériques.
variance_from Variance des valeurs d'une valeur de distribution.
weighted_distribution Distribution à partir d'un groupe de valeurs pondérées.
window Indique une fenêtre identique à la période d'alignement.
window Spécifie la fenêtre pour les opérations d'alignement.
within Spécifie la fenêtre de calcul de la valeur de tri.
within Spécifie la période de sortie de la requête.

Documentation de référence sur le langage MQL (Monitoring Query Language)

Modèle de données

Série temporelle

Tables

Metadata

Alignement

Syntaxe et sémantique

Éléments lexicaux

Structure d'une requête

Noms des tables

Expressions

Maps

Unités de mesure

Raccourcis des opérations de table

Description des fonctions et des opérations de table

Opérations de table

Récupération

fetch génère une table à partir de la base de données.

metric Génère la table pour un type de métrique spécifique à partir d'un ensemble de tables.

fetch_cumulative Génère une table de séries temporelles de type Cumulative à partir de la base de données.

Sélection

filter filtre les lignes d'une table d'entrée en fonction d'un prédicat.

top Sélectionne la série temporelle supérieure selon une expression de valeur de tri.

bottom Sélectionne la série temporelle inférieure selon une expression de valeur de tri.

top_by Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

bottom_by Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

Modification de ligne

map Réécrit les colonnes d'identifiant de série temporelle et de valeur de chaque ligne d'une table.

value Réécrit les colonnes de valeurs de chaque ligne d'une table.

time_shift Décale les séries temporelles dans le temps.

Alignement des séries temporelles

align Génère une table alignée à l'aide d'une fonction d'alignement.

Agrégation

group_by Agrège les lignes par identifiant de série temporelle et fenêtre temporelle mappés.

union_group_by Agrège les lignes de plusieurs tables.

unaligned_group_by Agrège les lignes par identifiant de série temporelle mappé sans alignement.

Union et jointure

join Jointure naturelle de plusieurs tables.

outer_join Jointure naturelle externe de deux tables.

union Union de plusieurs tables.

Horizon temporel et période

every Spécifie la période pour la sortie de table alignée.

within Spécifie la période de sortie de la requête.

graph_period Spécifie la période de sortie à privilégier pour la création de graphiques de séries temporelles.

window Spécifie la fenêtre pour les opérations d'alignement.

Alertes

condition Ajoute une colonne de condition booléenne à la table d'entrée.

absent_for Crée une condition pour l'absence d'entrée.

Divers

ident Opération de table d'identité : aucune modification n'a été apportée à la table d'entrée.

ratio Calcule le ratio des colonnes de valeurs de deux tables d'entrée alignées.

filter_ratio Calcule le ratio de deux sommes filtrées de la colonne de valeurs d'entrée.

filter_ratio_by Calcule un ratio groupé de deux sommes filtrées de la colonne de valeurs d'entrée.

Functions

Colonnes de ligne d'entrée

val Valeur d'une colonne de valeur dans le point d'entrée (ligne).

end Heure de fin du point d'entrée (ligne).

start Heure de début du point d'entrée (ligne).

older Valeur du point immédiatement antérieur (ligne) dans une série temporelle.

adjacent_delta Variation de la valeur entre un point d'entrée et le point immédiatement antérieur.

adjacent_rate Taux de variation entre le point d'entrée et les points immédiatement antérieurs (lignes).

hash_tsid Renvoie un hachage des colonnes d'identifiant de série temporelle.

Logique

not Négation logique d'une valeur booléenne.

and Valeur logique et de deux valeurs booléennes.

or Valeur logique ou de deux valeurs booléennes.

true Valeur booléenne "true".

false Valeur booléenne "false".

has Vrai si un argument défini contient une valeur particulière.

has_value Vrai si une expression d'argument calcule une valeur.

if Valeur choisie de manière conditionnelle à partir de deux valeurs.

or_else Une valeur ou, si ce n'est pas une valeur, une autre valeur.

Comparaison

eq Égal.

ne Non égal.

geSupérieur ou égal.

gt Supérieur.

le Inférieur ou égal à

lt Inférieur.

Arithmétique

`fetch` génère une table à partir de la base de données.

`metric` Génère la table pour un type de métrique spécifique à partir d'un ensemble de tables.

`fetch_cumulative` Génère une table de séries temporelles de type Cumulative à partir de la base de données.

`filter` filtre les lignes d'une table d'entrée en fonction d'un prédicat.

`top` Sélectionne la série temporelle supérieure selon une expression de valeur de tri.

`bottom` Sélectionne la série temporelle inférieure selon une expression de valeur de tri.

`top_by` Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

`bottom_by` Sélectionne les séries temporelles selon une expression de valeur de tri dans différents groupes.

`map` Réécrit les colonnes d'identifiant de série temporelle et de valeur de chaque ligne d'une table.

`value` Réécrit les colonnes de valeurs de chaque ligne d'une table.

`time_shift` Décale les séries temporelles dans le temps.

`align` Génère une table alignée à l'aide d'une fonction d'alignement.

`group_by` Agrège les lignes par identifiant de série temporelle et fenêtre temporelle mappés.

`union_group_by` Agrège les lignes de plusieurs tables.

`unaligned_group_by` Agrège les lignes par identifiant de série temporelle mappé sans alignement.

`join` Jointure naturelle de plusieurs tables.

`outer_join` Jointure naturelle externe de deux tables.

`union` Union de plusieurs tables.

`every` Spécifie la période pour la sortie de table alignée.

`within` Spécifie la période de sortie de la requête.

`graph_period` Spécifie la période de sortie à privilégier pour la création de graphiques de séries temporelles.

`window` Spécifie la fenêtre pour les opérations d'alignement.

`condition` Ajoute une colonne de condition booléenne à la table d'entrée.

`absent_for` Crée une condition pour l'absence d'entrée.

`ident` Opération de table d'identité : aucune modification n'a été apportée à la table d'entrée.

`ratio` Calcule le ratio des colonnes de valeurs de deux tables d'entrée alignées.

`filter_ratio` Calcule le ratio de deux sommes filtrées de la colonne de valeurs d'entrée.

`filter_ratio_by` Calcule un ratio groupé de deux sommes filtrées de la colonne de valeurs d'entrée.

`val` Valeur d'une colonne de valeur dans le point d'entrée (ligne).

`end` Heure de fin du point d'entrée (ligne).

`start` Heure de début du point d'entrée (ligne).

`older` Valeur du point immédiatement antérieur (ligne) dans une série temporelle.

`adjacent_delta` Variation de la valeur entre un point d'entrée et le point immédiatement antérieur.

`adjacent_rate` Taux de variation entre le point d'entrée et les points immédiatement antérieurs (lignes).

`hash_tsid` Renvoie un hachage des colonnes d'identifiant de série temporelle.

`not` Négation logique d'une valeur booléenne.

`and` Valeur logique et de deux valeurs booléennes.

`or` Valeur logique ou de deux valeurs booléennes.

`true` Valeur booléenne "true".

`false` Valeur booléenne "false".

`has` Vrai si un argument défini contient une valeur particulière.

`has_value` Vrai si une expression d'argument calcule une valeur.

`if` Valeur choisie de manière conditionnelle à partir de deux valeurs.

`or_else` Une valeur ou, si ce n'est pas une valeur, une autre valeur.

`eq` Égal.

`ne` Non égal.

`ge`Supérieur ou égal.

`gt` Supérieur.

`le` Inférieur ou égal à

`lt` Inférieur.

`add` Somme de deux nombres.

`sub` Différence de deux nombres.

`mul` Produit de deux nombres.

`div` Ratio de deux nombres.

`int_div` Quota de la division de deux entiers.

`abs` Valeur absolue.

`neg` Négatif d'un nombre.

`pos` Identité des entrées numériques.

`rem` Le reste de la division de deux entiers.

`sqrt` Racine carrée.

`log` Logarithme naturel.

`exp` e élevé à une puissance.

`power` Un nombre à la puissance d'un autre.

`int_round` Entier le plus proche.

`int_floor` Entier inférieur.

`int_ceil` Entier supérieur.

`concatenate` Concaténation de chaînes.

`string_to_double` Convertir String en Double.

`string_to_int64` Convertir String en Int.

`ascii_to_lower` Remplacez les majuscules ASCII par des minuscules.

`ascii_to_upper` Remplacez les lettres minuscules ASCII par des majuscules.

`utf8_normalize` Chaîne Unicode adaptée à la comparaison de la casse.

`re_full_match` Vrai si une expression régulière correspond à la totalité d'une valeur de chaîne.

`re_partial_match` Vrai si une expression régulière correspond à une partie de la valeur de chaîne.

`re_extract` Extrayez les valeurs correspondant à une expression régulière dans une autre chaîne.

`re_replace` Remplacez la première correspondance d'une expression régulière dans une autre chaîne.

`re_global_replace` Remplace toutes les correspondances d'une expression régulière dans une autre chaîne.

`sum` Somme d'un groupe de valeurs numériques.

`distribution` Distribution à partir d'un groupe de valeurs numériques ou de distribution.

`count` Nombre de valeurs dans un groupe de valeurs.