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éecloudsql.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étriqueappengine.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ésproject_id
,instance_id
etzone
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étriqueappengine.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étriqueappengine.googleapis.com/memcache/operation_count
comporte une colonne de valeur nomméeoperation_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 ouBy
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 fonctionstart()
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 unbase_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 unID
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 debasic_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 lagrouped_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érationgrouped_table_op
.Une
shortcut_table_op
est une notation de raccourci (décrite ici) pour unebasic_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 chaquequery
de l'opérationgrouped_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 chaquequery
dans unegrouped_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. Unemap
contient une ou plusieursexpr
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)
etval()
. 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égationsum
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 exemple33 'By'
pour 33 octets.Une chaîne
string
est constituée d'un ou de plusieurs jetonsSTRING
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 listearg_list
suivante.Par exemple,
add(error_count, 1)
applique la fonctionadd
à deux arguments :column_meta_name
error_count
etliteral
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. Sicall
comporte unearg_list
, la listearg_list
fournit des arguments supplémentaires.Par exemple,
.div
appliqué à une table avec des colonnes de valeursnum
etden
équivaut àdiv(num, den)
ou seulementnum / den
. L'expression.add(3)
appliquée à une table avec une colonne de valeurs uniquecount
équivaut àadd(count, 3)
ou seulementcount + 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. Sicall
comporte unearg_list
, la listearg_list
fournit des arguments supplémentaires.Par exemple,
.mul(3).div(4)
appliqué à une table avec une colonne de valeurs uniqueerror_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 unmaplet
de lamap
. Le nom de la colonne est soit explicitement donné par unID
ou uneQUOTED_COLUMN
, soit dérivé du format de l'expressionexpr
. La valeur de la colonne dans la ligne de sortie est la valeur de l'expressionexpr
.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 valeursmap
à une table, avec des colonnes de valeursnum
etden
, résulterait en une table de sortie avec une colonne de valeursratio
, où la valeur de colonneratio
correspond au ratio des deux colonnes d'entrée.L'application de
[zone]
en tant qu'identifiant de série temporellemap
à une table avec des colonnes d'identifiant de série temporelleproject_id
,zone
etinstance
résulterait en une table avec simplement une colonne d'identifiant de série temporellezone
dont la valeur est identique celle de la colonne de table d'entréezone
.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 chaquemaplet
de lamap
, il existe une colonne de sortie supplémentaire dont le nom et la valeur sont fournis par lemaplet
.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 valeurmap
à une table avec des colonnes de valeursnum
etden
résulterait en une table de sortie avec des colonnes de valeursnum
,den
etratio
, où la valeur de colonneratio
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'unmaplet
de lamap
sont incluses dans la ligne de sortie. En outre, pour chaquemaplet
de lamap
, il existe une colonne de sortie supplémentaire dont le nom et la valeur sont fournis par lemaplet
.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
etzone
résulterait en une table de sortie avec une colonne d'identifiant de série temporelleuser
,job
,zone
etkind
.drop
Chaquemaplet
doit être constitué d'une expressionexpr
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 expressionexpr
dumaplet
.Tous les
maplet
ne doivent pas avoir uncolumn_name
, et l'expressionexpr
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 temporellemap
à une table avec des colonnes d'identifiant de série temporelleuser
,job
etzone
résulterait en une table de sortie avec une colonne d'identifiant de série temporellezone
.ignore
Chaquemaplet
doit être constitué d'une expressionexpr
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 colonnemaplet
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 uneexpr
dumaplet
.Tous les
maplet
ne doivent pas avoir uncolumn_name
, et l'expressionexpr
doit simplement constituer un nom de colonne, sans toutefois être le nom d'une colonne de la table d'entrée. Si lemaplet
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 temporellemap
à une table avec des colonnes d'identifiant de série temporelleuser
,job
etzone
résulterait en une table de sortie avec des colonnes d'identifiant de série temporelleuser
etzone
(et l'instance
du maplet est ignorée).rename
Chaquemaplet
doit comporter uncolumn_name
explicite et une expressionexpr
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 unmaplet
par un nouveau nom donné par lecolumn_name
dumaplet
.Le
column_name
de chaquemaplet
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 valeursmap
à une table d'entrée avec des colonnes de valeursnum
,den
etratio
résulterait en une table de sortie avec des colonnes de valeursnumerator
,denominator
etratio
.
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
etmetric
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émentexpr
, 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émentexpr
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
ettime
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
etcast_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émentexpr
ev
ayant l'unité "KiBy" (kibi-octets), l'application descale(ev, "By")
conduit à multiplierev
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 deev
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
etBy
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 bases
, 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
etor_else
) , l'un des arguments peut être un appel à la fonctionscale
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 fonctionscale
, le deuxième argument de la fonctionscale
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. Sicache_size
possède l'unitéBy
etheap_size
l'unitéMiBy
, l'expressionscale(cache_size) + heap_size
équivaut à l'expressionscale(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'expressioncache_size < 3 "KiBy"
est équivalente à l'expressioncache_size < 3072 "By"
. Notez que ce n'est pas la même chose que l'expressioncache_size < scale(3 "KiBy", "By")
sicache_size
est de type Int, carscale
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 dediv
, 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'utiliserscale
, 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émentsarg
qui suivent (qui sont tous au formatexpr
) 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 pourvalue [.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 lamap
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 tableresource
,metric
oufetch
, selon le genre d'éléments que letable_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 tablefilter
.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 tablegroup_by
. Il peut être suivi d'unarg
qui constitue unemap
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 tablegroup_by
. Il doit être suivi d'unarg
qui constitue unemap
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'unarg
. Il devient une opération de tablefor
, 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
oubottom
. - WindowDuration Une Duration, potentiellement annotée par
window
ousliding
. - 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 lamap
doit uniquement être constitué d'une expressionexpr
qui désigne une colonne (ID
oucolumn_name
). Par exemple,[zone, name]
implique que les colonnes de sortie ne contiennent que les colonnes d'identifiant de série temporelle d'entréezone
etname
, 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
oubottom
)
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.
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 :
| 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.
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_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.
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 :
| 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 tablealign
;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 tablealign
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'expressionwindow()
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
. Cettemap
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
etmax
. 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
etmax
. 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 tablewindow
.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é.
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 ).
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
- Arithmétique
- Mathématiques
- String
concatenate
Concaténation de chaînesstring_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_aligner
Alignez 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
- 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.FirstArgKindolder(
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, older
renvoie 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.Deltaif(
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é.
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
.
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.Deltaadd(
Num,
Num )
→ Numadd(
Durée,
Durée )
→ Duréeadd(
Date,
Durée )
→ Dateadd(
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.Deltasub(
Num,
Num )
→ Numsub(
Durée,
Durée )
→ Duréesub(
Date,
Durée )
→ Datesub(
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.Deltamul(
lit-Num,
Num.Delta )
→ Num.Deltamul(
Num,
Num )
→ Nummul(
Durée,
Num )
→ Duréemul(
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.Deltadiv(
Num,
Num )
→ Doublediv(
Durée,
Num )
→ Duréediv(
Durée,
Durée )
→ Doublediv(
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 )
→ Intint_div(
Durée,
Int )
→ Duréeint_div(
Durée,
Durée )
→ Intint_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.
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.
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 )
→ Numneg(
Durée )
→ Durée
La fonction neg
renvoie le négatif de son argument.
pos
Identité des entrées numériques.
Signature : pos(
Num )
→ Numpos(
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
etrow_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
etfraction_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.FirstArgKindsum(
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.FirstArgKindaggregate(
Distribution )
→ Distribution.FirstArgKindaggregate(
Bool )
→ Boolaggregate(
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
etint_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.
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.
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_by
window(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_by
sliding(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.
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).
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_aligner
Alignez 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înescondition
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 naturellower
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 autrepowers_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.