Este es un manual de referencia para el lenguaje de consulta de supervisión de Cloud Monitoring. Abarca los siguientes temas:
El modelo de datos subyacente a la base de datos de series temporales a la que accede el lenguaje de consulta de supervisión.
La estructura y la semántica de las consultas.
Una descripción de cada una de las operaciones y funciones a partir de las cuales se compila una consulta.
Modelo de datos
Cloud Monitoring usa una base de datos de series temporales que contiene todas las mediciones que transfirió sobre cada elemento que supervisa (conocido como recurso supervisado). Esto describe la estructura lógica de esa base de datos.
El elemento fundamental es una serie temporal cuyos datos constan de observaciones del recurso supervisado.
Las series temporales en la base de datos están organizadas de manera lógica en tablas relacionales, cada una con series temporales con un significado y una estructura comunes. Se hace referencia a las tablas mediante consultas que muestran datos, generan gráficos y calculan alertas.
La base de datos también incluye metadatos, que son valores que cambian lento asociados a un recurso supervisado y que se establecen según la configuración del usuario o el servicio que implementa el tipo de recurso supervisado.
Serie temporal
Una serie temporal es una secuencia asignada con puntos, cada uno de los cuales es un valor medido y el tiempo al que se aplica el valor. Una serie temporal consta de tres partes: un tipo, que especifica la estructura de la serie temporal, un identificador, que asigna un nombre único a la serie temporal, y un historial, que contiene los datos de la serie temporal. Cada una de estas tres partes se explica en esta sección.
Un tipo de serie temporal especifica la estructura del identificador y el historial de series temporales. Está compuesto por dos partes:
Un tipo de recurso supervisado (descrito aquí) que nombra un tipo de recurso supervisado en particular, como una instancia de Compute Engine (
gce_instance
) o una base de datos de Cloud SQL (cloudsql_database
). Tiene un conjunto de descriptores de etiquetas que identifican de forma única una instancia de ese tipo de recurso supervisado.Un tipo de métrica (indicado aquí) que describe una categoría de medida en particular que se puede tomar en un recurso supervisado, por ejemplo, los bytes leídos del disco por una instancia de Compute Engine se miden según la métrica con el nombre
compute.googleapis.com/instance/disk/read_bytes_count
, y el uso de datos de una base de datos de Cloud SQL se mide según la métrica llamadacloudsql.googleapis.com/database/disk/bytes_used
. El tipo de métrica especifica el tipo del valor de la medición, las unidades de la medición y las categorías de series temporales. Puede especificar descriptores de etiquetas que distingan series temporales diferentes para medir distintos aspectos de lo mismo. Por ejemplo,command
, que indica qué comando se cuenta en la métricaappengine.googleapis.com/memcache/operation_count
.
Ten en cuenta que un tipo de recurso supervisado y un tipo de métrica se describen mediante un MonitoredResourceDescriptor
y un MetricDescriptor
, respectivamente. Estos describen los tipos. Cada uno contiene un campo llamado type
que contiene el nombre de ese recurso o tipo de métrica supervisado.
Un identificador de series temporales es el nombre de la serie temporal y se identifica de forma única entre todas las series temporales con el mismo tipo. Consiste en un conjunto de valores, uno para cada descriptor de etiqueta especificado en el recurso supervisado y los tipos de métricas que conforman el tipo de serie temporal.
Las etiquetas del tipo de recurso supervisado identifican de solo la instancia particular del tipo de recurso supervisado del que se tomaron las mediciones en la serie temporal. Por ejemplo, el recurso supervisado
gce_instance
tiene etiquetasproject_id
,instance_id
yzone
que identifican solo una máquina virtual de Google Compute Engine.Cada etiqueta del tipo de métrica identifica qué tipo específico de medición para la métrica determinada se representa en la serie temporal. Por ejemplo,
status
, que indica el estado de los comandos contados en la métricaappengine.googleapis.com/memcache/operation_count
podría tener valor'HIT'
para una serie temporal que cuenta hits y'MISS'
para otra serie temporal que cuenta los errores.
Un historial de series temporales es una secuencia ordenada de puntos, cada uno de los cuales representa una medición simultánea de uno o varios valores (por ejemplo, carga de CPU o temperatura y humedad) en algún momento o en un intervalo de tiempo determinado. En un punto hay dos elementos:
La extensión de un punto en el tiempo consiste en una hora de finalización, que siempre está presente y una hora de inicio que puede o no estar presente. Si la hora de inicio no está presente, la extensión del punto es un solo punto en el tiempo determinado por la hora de finalización. Si se proporciona la hora de inicio, debe ser anterior a la hora de finalización y la extensión del punto es el intervalo que comienza en la hora de inicio y termina en la hora de finalización.
No puede haber dos puntos de la misma extensión en una serie temporal. Además, la extensión de los puntos en una serie temporal está restringida por el tipo de serie temporal que le da el tipo de métrica, como se indica a continuación.
Un valor del dato representa una medición simultánea de uno o varios valores (por ejemplo, carga de CPU o temperatura y humedad) que se aplican al tiempo determinado por la extensión del punto. El tipo de métrica describe cada valor de medición, mediante un nombre y un tipo de valor para cada uno. Si hay varios valores de medición, están en un orden en particular y pueden hacer referencia a ellos por su índice en ese orden.
Una serie temporal típica almacenada en la base de datos de series temporales tiene un valor único en cada punto. El nombre de la métrica en el tipo de serie temporal es un URI y el nombre del único valor es la parte del nombre de la métrica después del último
/
. Por ejemplo, la métricaappengine.googleapis.com/memcache/operation_count
tiene una columna de valores llamadaoperation_count
.Una serie temporal que es el resultado de una consulta puede tener varios puntos cuyo tipo, nombre y orden son proporcionados por la consulta.
El tipo de métrica también puede especificar unidades de medida para el valor de serie temporal si es de tipo Int, Double o Distribution. Las unidades se proporcionan mediante un subconjunto del Código unificado para unidades de medida (UCUM). Por ejemplo,
ms
para milisegundos oBy
para bytes. Para obtener más información, consulta Unidades de medida.
Cada valor en un punto tiene un tipo de valor particular, que se especifica mediante el tipo de métrica en el tipo de serie temporal. Además, cada etiqueta en el identificador de la serie temporal tiene un tipo de valor, proporcionado por el descriptor de etiqueta en el recurso supervisado o el tipo de métrica del tipo de serie temporal. Los tipos de valores son los siguientes.
Int: un número entero de 64 bits con firma.
String: una string Unicode codificada en UTF-8.
Bool: un valor booleano.
Double: un valor de punto flotante de IEEE de 64 bits.
Distribution: un valor complejo que contiene un histograma y estadísticas que proporcionan una descripción resumida de una población (conjunto) de valores Double. Las partes de este valor son las siguientes:
- Un recuento de la cantidad de valores en la población.
- La suma de los valores en la población.
- La suma de la desviación al cuadrado de los valores de la población.
- Una especificación de depósito que indica los límites entre los depósitos en el histograma. Un depósito contiene un recuento de los valores que se encuentran entre el límite inferior y superior del depósito.
- Un histograma que proporciona la cantidad de valores que se encuentran en cada depósito.
Además, estas partes son suficientes para calcular la población media , varianza , desviación estándar y estimaciones de percentiles.
El tipo de valor de un punto puede ser cualquiera de los anteriores. Un tipo de etiqueta de identificador de serie temporal solo puede ser String, Int o Bool.
Además de estos tipos, hay dos tipos más que se encuentran en la hora de inicio y de finalización de un punto o que se usan para describir los tiempos y las duraciones en las consultas.
Date: un momento en particular medido como la distancia desde el desde el punto de inicio del tiempo UNIX. Es una representación de un punto en el tiempo independiente de la zona horaria. La hora de inicio y de finalización de un punto son de este tipo.
Duración: Lo que dura un período. Esta vez no tiene una unidad de medida particular (aunque la resolución es a nivel de microsegundos), pero toma una unidad en particular (p. ej., segundos) cuando se convierte en un Int o Double.
El conjunto de valores para cada tipo (excepto Date y Duration) incluye un valor llamado no-value, que indica que no hay un valor específico. Este se usa en dos situaciones:
Cuando no se conoce ningún valor específico, por ejemplo, cuando hay un error (como dividir por 0) que impide el cálculo de un valor.
No-value será el valor de una etiqueta en un identificador de series temporales cuando el tipo de serie temporal requiere la etiqueta, pero no se conoce ningún valor para ella. Esto puede suceder en casos en los que no se conoce ningún valor cuando se recopila la métrica o si una consulta generó la serie temporal y el procesamiento que generó el valor de la etiqueta no produjo un valor. Ten en cuenta que no-value es un valor distinto y, por lo tanto, distingue el identificador de serie temporal de cualquier otro que tenga un valor real para la etiqueta determinada.
Sin valor es distinto de un NAN de IEEE y de un valor de string que es la string vacía. No es posible que sinvalor de un punto sea sin valor.
El tipo de serie temporal describe el significado de los valores de los puntos en una serie temporal y restringe las extensiones de cada punto. Existen tres tipos de series temporales:
Indicador: El valor de un punto de una serie temporal de Indicador es una medida que se toma en cuenta a la hora de finalización del punto. Un punto en una transmisión de Indicador no tiene una hora de inicio, por lo que su extensión es un punto único en el tiempo. El valor de un punto puede representar una de las siguientes opciones:
Un ejemplo tomado de alguna variable (como la longitud de una cola o una cantidad de memoria en uso).
Una calidad de estado que es verdadera a la hora del punto y que seguirá siendo verdadera hasta el siguiente punto.
Un resumen de alguna cantidad (media, máximo, etc.) que se aplica al período entre el punto y el siguiente punto más antiguo de la serie temporal
Delta: para valores numéricos (Int o Double), cada punto representa el cambio en algún valor medido sobre la extensión del punto, es decir, entre la hora de inicio del punto (si está presente) y la hora de finalización. Para el valor de una Distribution, tiene una propagación de los valores numéricos que aumentaron durante la extensión del punto. Un tipo de serie temporal Delta debe tener un tipo de valor Int, Double o Distribution.
Para una serie temporal Delta, las extensiones de dos puntos no pueden superponerse, por lo que cada punto representa un cambio independiente en el valor medido (numérico) o la propagación inconexa de valores (Distribution). Lo ideal es que el alcance de cada punto comience de inmediato después de la extensión del siguiente punto más antiguo, por lo que la serie temporal es una descripción completa del rango de tiempo que abarca.
Acumulativa: Esto se puede considerar como una serie temporal de Delta con extensiones superpuestas. La restricción es que, si dos puntos tienen extensiones superpuestas, deben tener la misma hora de inicio. Por lo tanto, cada punto representa un aumento acumulativo en algún valor medido en el último punto con una hora de inicio común.
Las métricas Cumulative son una forma sólida de recopilar series temporales de una fuente de datos externa:
No es necesario que la fuente restablezca los contadores o acumuladores cada vez que se recopila un valor y se puede supervisar fácilmente en varios períodos.
Los recuentos acumulados no se pierden si faltan algunos puntos. El siguiente punto tiene todos los conteos desde la hora de inicio, incluidos los del punto faltante. Solo se pierde la resolución temporal.
Sin embargo, a menudo, no se observan series temporales acumulativas. Para que las operaciones en las series temporales que se muestran desde las consultas más sencillas, cuando se obtiene una serie temporal acumulativa, se convierte automáticamente en una serie temporal delta al hacer que cada extensión del punto comience en el momento del siguiente punto anterior y hacer que su valor sea el cambio desde ese punto anterior. Esto no cambia la información presente, pero hace que cada punto sea independiente de los demás. (
fetch_cumulative
puede anularla).Para una serie temporal cuyos puntos tienen más de un valor, cada valor tiene un tipo de serie temporal que solo puede ser Gauge o delta. Si algún valor tiene la categoría delta, la métrica general tiene el tipo delta (y, por lo tanto, cada punto tiene una hora de inicio y finalización). De lo contrario, la métrica tiene el tipo Indicador (y solo la hora de finalización).
Tablas
Todas las series temporales con el mismo tipo de serie temporal (tipo de recurso supervisado y tipo de métrica) se organizan de forma lógica en una tabla relacional. La tabla tiene un nombre de tabla que consiste en el nombre del tipo de recurso supervisado seguido del nombre del tipo de métrica.
Una tabla tiene una fila para cada punto de cada una de las series temporales incluidas en ella. La tabla tiene los siguientes tipos de columnas:
Columnas del identificador de serie temporal: una columna para cada etiqueta identificador de serie temporal según lo especificado por los recursos supervisados y los tipos de métricas. El nombre de la columna es el nombre de la etiqueta (su clave) y el tipo de la columna es el tipo de valor de la etiqueta. Si una etiqueta de recurso supervisado y una etiqueta de métrica tienen el mismo nombre, el nombre de la columna de etiqueta de la métrica
metric.
se le antepone.Una serie temporal está compuesta por todas las filas de una tabla con el mismo valor para cada una de las columnas de identificador de las series temporales correspondientes.
Columnas Time, derivadas de la extensión de los puntos de las series temporales. Siempre hay una columna de hora de finalización a la que accede la función
end()
(en realidad, no le damos un nombre a la columna). Si la métrica es del tipo de serie temporal Delta, hay una columna de hora de inicio a la que accede la funciónstart()
. (También hay una columna de hora de inicio para las métricas con el tipo de serie temporal acumulativa). Ambas columnas tienen valores de tipo Fecha.Columnas de valor, una para cada valor en el valor de los puntos de la serie temporal. Cada columna tiene el nombre y el tipo de ese valor, y las columnas de valor están en el mismo orden que el dado por el tipo de métrica. Si hay un recurso supervisado o una etiqueta de métrica con el mismo nombre que un nombre de valor, el nombre del valor proporcionado por el tipo de métrica tiene el prefijo
value.
para formar el nombre de la columna.
Todos los puntos de una serie temporal tienen el mismo valor en las columnas de identificador de serie temporal y estas columnas identifican solo las series temporales. Las columnas de series temporales más la columna de hora de finalización conforman la clave primaria de la tabla, que identifica solo una fila y, por lo tanto, un punto.
En el ejemplo anterior, se describe una tabla almacenada que consta de series temporales que se almacenan en la base de datos. Una consulta toma tablas almacenadas como entradas iniciales y realiza operaciones sucesivas de tablas (filtrado, agregación, unión, etc.), y genera tablas derivadas intermedia como resultado de estas operaciones de la tabla.
Una tabla derivada tiene la misma estructura que una tabla almacenada, con las siguientes diferencias:
La tabla seguirá asociada a un tipo de recurso supervisado si la transformación que lo generó conserva todas las columnas de etiquetas de recursos supervisados. De lo contrario, no está asociado con un tipo de recurso supervisado. Esto es importante para los metadatos (que se describen en la sección siguiente).
La tabla se describe mediante un tipo de tabla, en lugar de un tipo de recurso supervisado y un tipo de métrica. El tipo de tabla es igual que un tipo de métrica, excepto que el conjunto de etiquetas incluye todas las columnas del identificador de la serie temporal. Según la derivación real de la tabla, las columnas del identificador de series temporales pueden no tener relación con las columnas especificadas por cualquier tipo de recurso supervisado o tipo de métrica real.
Una tabla derivada no tiene un nombre.
Metadata
Un tipo de recurso supervisado puede tener tipos de metadatos, cada uno de los cuales asocia un valor con cada instancia de ese tipo particular de recurso supervisado. Cada tipo de metadatos tiene un nombre y un tipo de valor (que es String, Int o Bool).
Existen dos tipos de metadatos:
Metadatos del sistema creados por el servicio que crea y administra el recurso supervisado. Los metadatos del sistema tienen un nombre con el formato
metadata.system_labels.<key>
, en el que<key>
identifica un tipo específico de metadatos.Los metadatos de los usuarios, que están presentes cuando un servicio permite al usuario adjuntar etiquetas a un recurso supervisado específico. Los metadatos de usuario tienen un nombre con el formato
metadata.user_labels.<key>
, en el que<key>
es la clave de la etiqueta que el usuario adjuntó a la entidad. Por ejemplo:metadata.user_labels.my_key
. El valor de los metadatos del usuario es siempre del tipo String.
Una tabla (almacenada o derivada) que está asociada con un recurso supervisado podría tener columnas de valor virtuales adicionales, una para cada tipo de metadatos asociado con el tipo de recurso supervisado. Para cada fila de la tabla, una columna de metadatos tiene el valor de esos metadatos a la hora de la columna de hora de finalización de la fila. Estas columnas de metadatos adicionales no son parte realmente de la tabla, pero se puede hacer referencia a estas en las expresiones de consulta como si lo fueran si asignas el nombre del metadatos en las expresiones que operan en una fila de la tabla.
Alineación
Una serie temporal está alineada de forma temporal (o simplemente alineada) si la hora de finalización de sus puntos ocurre solo en intervalos regulares. Decimos que una serie temporal está alineada con respecto a una hora y un período base de alineación específicos si cada punto de la serie temporal tiene un múltiplo del período de alineación anterior (o posterior) a la hora base de alineación. Por ejemplo, con un tiempo base de alineación de 10:03 y un período de alineación de 5 minutos, 09:48, 09:53, 09:58, 10:03, 10:08 serían todas horas de finalización válidas.
Si las series temporales de una tabla tienen el tipo de serie temporal Delta, la hora de inicio de cada punto debe ser anterior a la hora de finalización según la duración del período, lo que hace que la duración de cada punto tenga la misma longitud. Una tabla con horas de inicio acumulativas no se puede alinear porque, en general, no es posible que las horas de inicio de los puntos se ajusten entre diferentes series temporales.
Si todas las series temporales que conforman una tabla están alineadas con respecto a la misma hora y al mismo período de alineación, entonces la tabla está alineada con respecto a ese tiempo y período.
Cuando una tabla está alineada, los puntos de las diferentes series temporales se alinean entre sí. Esto permite realizar operaciones que combinan distintas series temporales. Por ejemplo, si queremos obtener la serie temporal que es la suma de algunas métricas sobre todos nuestros recursos supervisados, necesitamos que los puntos de la serie temporal individual estén “alineados”, es decir, que tengan la misma alineación. Luego, el valor de los puntos en las series temporales resultantes es la suma de los valores de los puntos a la misma hora en las series temporales individuales.
Sintaxis y semántica
Elementos léxicos
El texto de una consulta se compone de una secuencia de tokens que se describen en la siguiente gramática con estas reglas:
- En la gramática que se muestra a continuación, se describe un token mediante uno de los símbolos no terminal en mayúscula.
- Un token que no sea
base_string
no tiene espacio en blanco. El espacio en blanco es espacio, tabulación, salto de línea y comentarios. Un comentario es cualquier texto, no en unbase_string
que comienza con#
y termina con un salto de línea. - El espacio en blanco entre tokens se ignora, excepto para separar tokens.
- Dos tokens adyacentes deben estar separados por espacios en blanco si esta gramática permitiría que se reconocieran como un solo token distinto de
BARE_NAME
(que solo se reconoce en ciertos contextos).
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 `"'.
Los identificadores (ID
) se usan para nombrar las operaciones y funciones integradas de la tabla que forman parte del lenguaje de consulta de supervisión y para nombrar columnas y metadatos en expresiones. La sintaxis distingue entre un lugar en el que un ID
puede ser una operación de tabla o un nombre de función y un lugar en el que un ID
puede ser un nombre de columna, por lo que no hay identificadores “reservados” que no se puedan usar como nombres de columna. Se usa una QUOTED_COLUMN
para dar el nombre de una columna que no se analizará como un identificador. Ejemplo: c'total cpu'
Los tokens NUMBER
, STRING
, DURATION
y DATE
identifican valores literales.
Una NUMBER
puede estar seguida por un unit
que brinda las unidades de medición de ese valor literal como una STRING
.
Un objeto STRING
puede contener caracteres Unicode. Si no tiene el prefijo r
o R
, se reconocerán las secuencias de escape normales. El sufijo de una DURATION
indica cómo se denota la duración del tiempo: segundos, milisegundos, microsegundos, minutos, horas, días o semanas. La base_string
en una fecha contiene una fecha con el formato 2010/06/23-19:32:15-07:00
, en la que el primer -
puede ser un espacio y se puede descartar la zona horaria (-07:00
) (también los segundos, minutos o horas).
Los tokens restantes son signos de puntuación y de operador que aparecen entre comillas en la siguiente gramática (p. ej., '^'
o '<='
). Estos tokens son ^
, <=
, <
, ==
, =
, =~
, >=
, >
, ||
, |
, _
, -
, ,
, ;
, ::
, :
, !=
, <>
, !~
, !
, //
, /
, .
, (
, )
, [
, ]
, {
, }
, *
, &&
, %
, +
.
Estructura de la consulta
Una consulta está compuesta por una secuencia de operaciones de tabla (table_op
), unidas por operadores de barra vertical (|
). Cada operación de tabla toma tablas como entradas y produce tablas como salida. Las tablas de salida por una operación de tabla se dividen por una barra vertical en la siguiente operación de tabla, que las consume para producir su propio resultado de tabla.
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 } '}' .
Hay tres tipos de operaciones de tabla (table_op
):
Una
basic_table_op
comienza con unID
que nombre el tipo de operación que se realizará (como se describe aquí). Esto va seguido de argumentos (arg
) que proporcionan detalles sobre lo que hará la operación de tabla. Cada tipo debasic_table_op
toma ninguna, una o varias tablas como entrada y produce una tabla como resultado.Una
grouped_table_op
consiste en una lista ordenada de consultas. Cada una de las consultas genera una tabla y el resultado degrouped_table_op
es una lista ordenada de estas tablas. Cada una de las consultas toma como entrada los mismos ceros o más tablas de entrada que son la entrada degrouped_table_op
.Un
shortcut_table_op
es una notación de acceso directo (descrita aquí) para unabasic_table_op
.
Las tablas que son el resultados de una table_op
se pasan mediante el operador de canalización (|
) como entrada para la siguiente table_op
. Las siguientes son las reglas para pasar tablas que son resultado de una operación de tabla a la izquierda de un operador de barra vertical (llamada productor) hacia una operación de tabla a la derecha del operador de barra vertical (llamado consumidor):
Una operación de tabla que no toma entradas de tabla no puede ser un consumidor.
En el caso de un productor que genera una sola tabla y un consumidor que toma una sola tabla, la tabla de salida del productor es una entrada para el consumidor.
En el caso de un productor que genera varias tablas y un consumidor que toma una sola tabla, el consumidor se aplica por separado a cada tabla de entrada y el resultado de la operación de tabla del consumidor es una tabla para cada tabla de entrada.
Si es un productor que genera varias tablas y un consumidor que toma varias tablas, todas las tablas producidas son entradas para el consumidor.
Para un productor que produce una sola tabla y un consumidor que es un
grouped_table_op
, la única tabla es la entrada a la primera operación de tabla dequery
en lagrouped_table_op
.No es válido que un
grouped_table_op
sea un consumidor para un productor de varias tablas.El último
table_op
de cadaquery
en unagrouped_table_op
debe producir solo una tabla.
Los elementos “arg” de la operación de tabla proporcionan información a la operación de tabla sobre cómo debe procesar sus tablas de entrada en una tabla de salida.
Un elemento arg
puede ser una de tres opciones:
Un nombre de tabla (
table_name
), que asigna un nombre a una tabla o que es parte del nombre de una tabla que se va a recuperar de la base de datos de Cloud Monitoring.Una expresión (
expr
), que es una fórmula para calcular un valor. Puede ser un valor literal conocido de forma estática o puede ser un valor calculado a partir de los valores de columna de una o más filas de la tabla de entrada o tablas de la operación de tabla.Un mapa (
map
), que describe cómo calcular las columnas en la tabla de salida de una operación de tabla. Unmap
contiene uno o másexpr
que calculan los valores de las columnas.
Nombres de tablas
Un table_name
nombra un tipo de recurso supervisado, un tipo de métrica, un grupo o una tabla. Se usan en operaciones de tabla que recuperan tablas de la base de datos de series temporales para su procesamiento posterior.
table_name : name { '::' name } .
name : string | BARE_NAME | ID .
Un solo name
se refiere a un tipo de recurso supervisado o un tipo de métrica, por ejemplo, el tipo de recurso supervisado gce_instance
o aws_dynamodb_table
, o el tipo de métrica loadbalancing.googleapis.com/http/backend_latencies
.
Un tipo de recurso supervisado también se puede nombrar con un nombre de grupo o mediante un nombre de tipo de recurso supervisado seguido de ::
y un nombre de grupo. La primera se puede usar cuando el grupo especifica un solo tipo de recurso supervisado y este último se usa cuando el grupo no lo hace.
Una tabla almacenada se proporciona mediante un nombre de tipo de recurso supervisado seguido de ::
y un nombre de tipo de métrica. Por ejemplo gce_instance :: loadbalancing.googleapis.com/http/backend_latencies
.
Expresiones
Una expresión (expr
) es una fórmula para calcular un valor. Se usa como argumento para una operación de tabla y ayuda a describir la transformación que realizará la operación en la tabla o entrada de tabla. Una expr
puede ser una expresión literal o puede ser una expresión dinámica.
Si un expr
es literal, se compone solo de valores literales y llamadas de función simples cuyos argumentos son literales. El valor de tal expresión se determina antes de que la consulta se aplique a cualquiera de las tablas.
Si una expr
es dinámica, puede contener referencias a las columnas de la tabla y se usa para calcular un valor de una o más filas de la tabla de entrada.
Existen tres tipos de expresiones dinámicas:
Expresión de valor. Una expresión de valor produce un valor para cada fila de la tabla de entrada a la que se aplica. Puede contener referencias a las columnas de la tabla y, cuando se evalúa para una fila de entrada, esas referencias se evalúan en los valores de columna correspondientes en la fila.
Expresión de agregación. Una expresión de agregación produce un valor para un conjunto de filas de la tabla de entrada. Se puede dividir en tres partes:
Una o más expresiones de valor que se aplican de forma individual a cada fila de entrada a fin de producir un valor para cada fila. Estas expresiones de valor son argumentos para las funciones de agregación.
Una o más funciones de agregación que toman una colección de valores de entrada producidos por las expresiones de valor y los reducen a un solo valor resultante.
Una expresión externa sobre las funciones de agregación que toman los valores resultantes de las funciones de agregación y produce el valor de la expresión en su totalidad.
Por ejemplo, en la expresión de agregación
sum(if(status >= 500, val(), 0)) / sum(val())
, las partes son las siguientes:Las expresiones de valor son
if(status >= 500, val(), 0)
yval()
. Estos se aplicarán a cada fila de entrada para crear dos colecciones de valores.Los agregadores son las dos llamadas a función
sum
, cada una de ellas como entradas de valores producidos por la expresión de valor que es su argumento.La expresión externa es el operador de división (
/
), que se aplicará al resultado final de cada una de las funciones de agregaciónsum
para producir el valor de la expresión general.
Expresión de alineación. Una expresión de alineación consiste en una sola llamada en una función de alineación. La función de alineación produce un valor de salida de una serie temporal de entrada y lo usa
align
para producir una tabla alineada.
Cada expresión está compuesta por elementos opnd
(definidos a continuación) conectados por operadores.
expr : term { infix_op term } .
term : { prefix_op } opnd .
infix_op : '&&' | '||' | '^'
| '==' | '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | '=~' | '!~'
| '+' | '-'
| '*' | '/' | '//' | '%' .
prefix_op : '+' | '-' | '!' .
Los operadores se comportan de la manera habitual según la prioridad. En la siguiente tabla, se organizan los operadores en cinco grupos. Todos los operadores de un grupo tienen la misma prioridad, y los grupos más altos se vinculan más estrechamente. Los operadores con la misma prioridad se aplican de izquierda a derecha. Cada operador corresponde a una función, proporcionada en la tabla, que se aplica a sus operandos.
operador | función | operación |
---|---|---|
* / // % |
mul div div rem |
Multiplicación División División del número entero Resta del número entero |
+ - |
add sub |
Suma Resta |
== = != <> <= >= > < =~ !~ |
eq ne le ge gt lt re_full_match ! re_full_match |
Comparación de igualdad Comparación de desigualdad Comparación menor o igual Comparación mayor o igual Mayor que comparación Menor que comparación Concordancia completa de expresión regular La expresión regular no coincide completamente |
&& |
and |
Lógica y |
|| |
or |
O lógico |
Los operadores de prefijo +
, -
y !
corresponden a las funciones unary pos
, neg
y not
, respectivamente, y se aplican antes de cualquier operador infix.
Por lo tanto, a < b && a + b + c / -d == 5
es equivalente a (a < b) && (((a + b) + (c / (-d))) == 5)
, que a su vez, es equivalente a and(lt(a, b), eq(add(add(a, b), div(c, neg(d))), 5))
.
Los operadores funcionan en operandos (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 .
Cada opnd
corresponde a una forma particular de calcular un valor.
literal
es el valor del token literal dado.Un literal de NUMBER puede estar seguido por una
unit
que otorga las unidades de medida del valor literal, por ejemplo33 'By'
para 33 bytes.Una
string
está compuesta por uno o más tokensSTRING
que se concatenan en un valor de string. Por lo tanto,'a-' 'b'
tiene el mismo valor que'a-b'
.
column_meta_name
nombra una columna o una columna de metadatos virtuales en la tabla de entrada y se evalúa como el valor de esa columna en la fila de entrada a la que se aplica la expresión._
representa el valor predeterminado. Solo se puede proporcionar como argumento real a un argumento formal opcional.'(' expr ')'
es una expresión entre paréntesis que es solo el valor de laexpr
.call_chain
es una llamada a función encadenada o más de una:
call_chain : [ ID arg_list ] { '.' call } .
arg_list : '(' [ expr { ',' expr } [ ',' ] ] ')' .
call : ID [ arg_list ] .
Cada ID
de una cadena de llamada asigna un nombre a una función que se aplica a ningún o más argumentos. Los argumentos de una llamada a una función pueden provenir de las columnas de valores de la tabla de entrada, del resultado de una call
anterior en la cadena de llamadas o del valor de expr
en un arg_list
.
Si la cadena de llamadas comienza con un
ID
(y no con un.
antes), los argumentos de la función llamada se proporcionan conexpr
en la siguientearg_list
.Por ejemplo,
add(error_count, 1)
aplica la funciónadd
a dos argumentos:column_meta_name
error_count
yliteral
1
. Esto sería equivalente aerror_count + 1
.Si una
call_chain
comienza con un'.' call
, las columnas de valores de la tabla de entrada son el primer argumento para la función llamada. Si lacall
tiene unaarg_list
, elarg_list
proporciona argumentos adicionales.Por ejemplo,
.div
aplicado a una tabla con columnas de valoresnum
yden
sería equivalente adiv(num, den)
o solonum / den
. La expresión.add(3)
aplicada a una tabla con una columna de valor únicocount
sería equivalente aadd(count, 3)
o solo acount + 3
.La función a la que llama una
call
distinta de la primera en una cadena de llamadas la toma como primer argumento, el resultado de la función antes llamada en la cadena de llamadas. Si lacall
tiene unaarg_list
, elarg_list
proporciona argumentos adicionales.Por ejemplo,
.mul(3).div(4)
aplicada a una tabla con una columna de valor únicoerror_count
sería equivalente adiv(.mul(3), 4)
, que es equivalente adiv(mul(error_count, 3), 4)
, que es equivalente aerror_count * 3 / 4
o(error_count * 3) / 4
.
Ten en cuenta que las columnas de hora de inicio y finalización de una tabla no tienen nombres de columnas.
Se puede acceder al valor de las columnas de tiempo mediante las funciones end
y start
.
Maps
Un map
calcula los valores de las columnas en una fila de salida y les asigna nombres.
Según dónde se use la map
, será un identificador de series temporales map
que calcula las columnas de identificador de la serie temporal de la fila de salida o un valor map
que calcula el valor de las columnas de la fila de salida.
map : [ modifier ] '[' [ maplet { ',' maplet } ] ']' .
modifier : ID .
maplet : [ column_name ':' ] expr .
column_name : ID | QUOTED_COLUMN .
Cada expr
en maplet
calcula el valor de una columna de resultado y column_name
proporciona el nombre de la columna. Si no se proporciona un column_name
, uno se construye a partir de expr
. Si expr
es solo el nombre de una columna de entrada, column_name
es el mismo. Si se aplican funciones, estas se agregan al nombre. Por ejemplo, sum(error_count / 3)
obtendrá el nombre error_count_div_sum
.
Las columnas de salida que calcula map
(identificador de serie temporal o valor) provienen de los maplet
en el map
y del tipo de columna correspondiente (identificador de serie temporal o valor) de la tabla de entrada. La forma en que se hace esto depende del modifier
:
No
modifier
Las columnas correspondientes de la fila de salida constan exactamente de esas columnas especificadas por unmaplet
en elmap
. El nombre de la columna se proporciona de forma explícita mediante unID
o unaQUOTED_COLUMN
, o bien deriva de la forma de laexpr
. El valor de la columna en la fila de salida es el valor de laexpr
.Cada
maplet
debe tener un nombre de columna (explícito o derivado) que sea único entre todas las columnas de la tabla de salida.Por ejemplo, cuando se aplica
[ratio: num/den]
como una columna de valormap
a una tabla con columnas de valoresnum
yden
daría como resultado una tabla de salida con la columna de valorratio
, en el que el valor de la columnaratio
es la proporción de las dos columnas de entrada.Aplicar
[zone]
como un identificador de serie temporalmap
a una tabla con columnas de identificadores de series temporalesproject_id
,zone
yinstance
daría como resultado una tabla con solo una columna de identificador de serie temporalzone
cuyo valor es el mismo que el de la columna de tabla de entradazone
.add
Todas las columnas del tipo correspondiente (valor o identificador de serie temporal) de la fila de entrada se incluyen en la fila de salida. Además, para cadamaplet
en elmap
, hay una columna de salida adicional cuyo nombre y valor se proporcionan mediante elmaplet
.Cada
maplet
debe tener un nombre de columna (explícito o derivado) que sea único entre todas las columnas de la tabla de salida.Por ejemplo, si aplicas
add[ratio: num/den]
como un valormap
a una tabla con las columnas de valornum
yden
, obtendrás una tabla de salida con las columnas de valornum
,den
yratio
, donde el valor de la columnaratio
es la proporción de las otras dos columnas.update
Todas las columnas del tipo correspondiente (valor o identificador de serie temporal) de la fila de entrada cuyo nombre de columna no es el mismo que el de unmaplet
delmap
se incluyen en la fila de salida. Además, para cadamaplet
en elmap
, hay una columna de salida adicional cuyo nombre y valor se proporcionan mediante elmaplet
.Cada
maplet
debe tener un nombre de columna (explícito o derivado) que sea único entre todas las columnas de la tabla de salida. Puede asignar el nombre a una columna del tipo correspondiente en la entrada que reemplaza.Por ejemplo, el siguiente es un
map
de identificador de serie temporal:update[job: re_extract(job, '[^-]*-(.*)', r'\1'), kind: re_extract(job, '([^-]*)-.*', r'\1')]
Cuando se usa en una tabla con columnas de identificador de serie temporal
user
,job
, yzone
, generaría una tabla de salida con columnas de identificadores de series temporalesuser
,job
,zone
, ykind
.drop
Cadamaplet
debe constar de unaexpr
que sea solo el nombre de una columna de entrada del tipo correspondiente. Las columnas de salida constan de todas las columnas de entrada del tipo correspondiente, excepto las que se nombran en unaexpr
en elmaplet
.Cada
maplet
no debe tener uncolumn_name
y laexpr
solo debe nombrar una columna del tipo correspondiente en la tabla de entrada.Por ejemplo, aplicar
drop [job, user]
como un identificador de series temporalesmap
a una tabla con columnas de identificador de series temporalesuser
,job
yzone
daría como resultado una tabla de salida con la columna de identificador de series temporaleszone
.ignore
cadamaplet
debe constar de unaexpr
que es solo un nombre de columna. Si el nombre es el nombre de una columna de entrada del tipo correspondiente, esa columna no aparece en las columnas de resultado. Si el nombre de la columnamaplet
no nombra una columna de tabla de entrada del tipo correspondiente, esemaplet
no tiene efecto. Por lo tanto, las columnas de salida constan de todas las columnas de entrada del tipo correspondiente, excepto las que se nombran en unaexpr
en elmaplet
.Cada
maplet
no debe tener uncolumn_name
, y laexpr
debe ser solo un nombre de columna, pero no es necesario que sea el nombre de una columna en la tabla de entrada. Si elmaplet
no asigna un nombre a una columna en la tabla de entrada, se ignora.Por ejemplo, aplicar
ignore [job, instance]
como un identificador de serie temporalmap
a una tabla con columnas de identificadores de serie temporaluser
,job
yzone
daría como resultado una tabla de salida con identificador de serie temporal columnasuser
yzone
(con el mapletinstance
ignorado).rename
Cadamaplet
debe tener uncolumn_name
explícito y unaexpr
que solo haga referencia a una columna del tipo correspondiente en la tabla de entrada. Las columnas de resultado son todas las columnas del tipo correspondiente en la tabla de entrada, pero si se hace referencia a unmaplet
con un nombre nuevo proporcionado porcolumn_name
en elmaplet
.El
column_name
en cadamaplet
debe ser único entre los nombres de columna de la tabla de salida.Por ejemplo, cuando se aplica
rename[numerator : num, denominator : den]
como una columna de valormap
a una tabla de entrada con columnas de valoresnum
,den
yratio
daría como resultado una tabla de salida con columnas de valoresnumerator
,denominator
yratio
.
Unidades de medición
Cada valor numérico (Int, Double y Distribution) puede tener una unidad de medida asociada, lo que indica la unidad de medida usada por ese valor. Las unidades se representan mediante strings que siguen un subconjunto del Código unificado para unidades de medida (UCUM). Por ejemplo, un valor que indique una cantidad de bytes tendrá la unidad “By” y otra, lo que indica una tasa de bytes transferidos, unidad “By/s”.
Las unidades se conectan a las columnas de las tablas producidas por las operaciones de tabla y al valor de las expresiones. Se asocian de forma estática con la columna o expresión de la misma manera que el tipo. Cualquier columna o expresión con un tipo numérico puede tener unidades asociadas, pero no es necesario.
Las unidades conectadas a las columnas en las tablas provienen de estas fuentes:
Los descriptores de métricas pueden especificar las unidades para el valor de una métrica, y estas se encuentran en la documentación que describe las métricas (por ejemplo, aquí). Las columnas de valores de las tablas producidas por las operaciones de las tablas
fetch
ymetric
tienen las unidades que especifica el descriptor de métrica.Las columnas de la tabla de salida que son solo una copia de la columna de la tabla de entrada tienen las mismas unidades que la columna de la tabla de entrada. Por ejemplo, la operación de la tabla
filter
no cambia las unidades de ninguna columna de la tabla de entrada y las pasa al resultado.La operación de la tabla
union
combina varias tablas en una, y todas las tablas deben tener las mismas columnas. Cada columna de valor en una tabla de entrada no debe tener unidades adjuntas o unidades que sean equivalentes a las unidades, si las hay, adjuntas a esa columna en todas las otras tablas de entrada. Si se proporcionan unidades para una columna en cualquiera de las tablas de entrada, esa columna tiene esas unidades en la tabla de salida. Si ninguna de las tablas de entrada tiene unidades especificadas para una columna, esa columna no tiene unidades en el resultado.Para las operaciones de tabla que contienen una
expr
que calcula un valor de columna de la tabla de salida, las unidades en la columna de resultado tienen las unidades conectadas a esaexpr
como se describe a continuación.
Las unidades conectadas a una expr
dependen del formato de la expr
:
Los valores literales por sí solos no tienen unidades. Pero los literales numéricos (Int o Double) pueden obtenerse unidades según el valor con una string que especifica la unidad. Por lo tanto,
3 "By"
es unexpr
con el valor 3, cuyo tipo es Int y cuya unidad es bytes (By
).Las expresiones de referencia de columna obtienen unidades de la columna con nombre en la tabla de entrada, si tiene unidades.
Las funciones y los operadores derivan la unidad de medición de sus valores de salida a partir de la unidad de sus valores de entrada. Por lo tanto, si
amount
tiene la unidadBy
ytime
tiene la unidads
, entoncesamount / time
tiene la unidadBy/s
. Las funciones que toman dos argumentos numéricos, por lo general, requieren que ambos argumentos tengan unidades o ningún argumento para tener unidades. En la documentación de cada función, se describe el tratamiento de las unidades de medida de esa función.Muchas funciones tienen un requisito sobre el acuerdo de unidades. Por ejemplo,
add
requiere que ambos de sus operandos, si tienen unidades, tengan la misma unidad. Estos requisitos se describen en la documentación de cada función.Las funciones
scale
ycast_units
tienen funcionalidades específicas para las unidades.La función
scale
multiplicará un valor con una unidad por un factor de escala que lo convierta en un valor con una unidad diferente. Por lo tanto, paraexpr
ev
con la unidad "KiBy" (kibi-bytes),scale(ev, "By")
dará como resultado la multiplicación deev
por 1,024 y le dará la unidad de resultadoBy
. Es equivalente aev * 1024 'By/KiBy'
.La función
cast_units
muestra su argumento con una unidad determinada, independientemente de la unidad original del argumento, si corresponde. Por lo tanto,cast_units(ev, 'By/s')
da como resultado el valor deev
, sin cambios, pero con la unidadBy/s
.
El subconjunto de unidades UCUM compatibles con MQL se proporciona a través de valores de string que siguen esta gramática:
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 }
Una simple_unit
especifica una unidad determinada por un ATOM_SYMBOL
con un prefijo opcional, mediante un factor de escala determinado por un PREFIX_SYMBOL
Un ATOM_SYMBOL
proporciona una unidad de medida básica:
text | significado |
---|---|
s | segundo |
min | minuto (60 segundos) |
h | hora (60 minutos) |
d | día (24 horas) |
sm | semana (7 días) |
bit | bit |
De | byte (8 bits) |
% | 10^-2 (proporción sin dimensión ajustada al %) |
m | metro |
g | gramo |
K | kelvin |
C | culombio |
Hz | hercio (1/s) |
J | julio (kg.m.m/s/s) |
W | vatio (kg.m.m/s/s/s) (J/s) |
A | amperaje (C/s) |
V | voltio (kg.m.m/s/s/C) (J/C) |
Un PREFIX_SYMBOL
otorga un factor de escala para la unidad básica que precede:
text | significado | escalar |
---|---|---|
k | kilo | 10^3 |
millones | mega | 10^6 |
G | giga | 10^9 |
T | tera | 10^12 |
P | peta | 10^15 |
E | exa | 10^18 |
Z | zetta | 10^21 |
S | yotta | 10^24 |
m | mili | 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 | mebi | 2^20 |
Gi | gibi | 2^30 |
Ti | tebi | 2^40 |
Pi | pebi | 2^50 |
Una unidad sin dimensión se puede proporcionar como 1
o como una potencia de 10 (10^ exponent
como 10^2
). La unidad 1
es la unidad otorgada a la mayoría de las métricas de contador. Esto también es compatible con la proporción sin dimensión ajustada al porcentaje %
. Por lo tanto, 10^-2
y %
son las mismas unidades. Dicho de otra manera, agregar 3 a un porcentaje equivale a agregar .03 a la proporción correspondiente. exponent
está limitado al rango de -128 a 127.
Una annotation
es un comentario que puede adjuntarse a un annotatable
(simple_unit
o potencia de 10) y no cambia el significado de la unidad. Una anotación que no se adjunta a una unidad se trata como si la adjuntará a la unidad 1
. Por lo tanto, {queries}/s
es equivalente a 1/s
, con la unidad 1
decorada con {queries}
.
Una string de unidad puede constar de varias strings component
, conectadas por .
o /
. El conector .
indica la multiplicación de las unidades y el conector /
, la división. La multiplicación y la división se aplican de izquierda a derecha. El subconjunto de unidades UCUM que admite MQL requiere que todos los conectores de división aparezcan después de los conectores de multiplicación. Esto evita el problema de escribir las unidades de aceleración como m/s.s
cuando se busca m/s/s
.
Ten en cuenta que en unidades UCUM, m/s.s
es lo mismo que m.s/s
o solo m
.
Dos strings de unidad son equivalentes si tienen la misma dimensión y escalamiento, independientemente de las anotaciones. La dimensión y el escalamiento se determinan de la manera convencional:
Cada
component
no tiene dimensión o tiene una dimensión que combina la combinación de tiempo, longitud, datos, masa o cargos. Por ejemplo,bit
yBy
tienen datos de dimensión. Para encontrar las dimensiones de una string de unidad, debes convertir cada anotable en su dimensión, multiplicar y dividirlas según lo determinado por la string de unidades y cancelar las dimensiones que aparecen en el numerador y denominador. Por lo tanto,b.h/s
(hora por segundo por segundo) tiene las dimensiones datos por tiempo dividido por la hora y la dimensión de tiempo se cancela para salir de los datos de dimensión.Cada anotación tiene la relativa a las unidades básicas de su dimensión. Por ejemplo,
h
(hora) tiene dimensión de hora con la unidad básicas
y un factor de escala de 3,600 (cada hora es de 3,600 segundos). El factor de escala de una string de unidad es la combinación de los factores de escala de cadacomponent
combinado por multiplicación y división.
Los literales numéricos pueden obtener unidades según el valor con la string para la unidad de medida deseada. Por lo tanto, 3 "m/s"
es el valor 3
con la unidad m/s
y 10.8 "km/h"
representa la misma velocidad que el valor 10.8
con la unidad km/h
.
Se puede escalar un valor con una unidad para tener una unidad diferente con la misma dimensión mediante la función scale
. Por ejemplo, MiBy
y By
tienen la dimensión datos con el factor de escala 8 x 1,024 y 8, respectivamente (en relación con la unidad base de datos de dimensión datos, que es bit
). Un valor x
con unidad MiBy
se puede escalar a un valor con la unidad By
por la expresión scale(x, "By")
. Esto multiplica x
por 1,024 y da como resultado un valor con la unidad By
. Es equivalente a la expresión x * 1024 "By/MiBy"
, size * 1024 "By/MiBy"
y la unidad de la expresión resultante es MiBy.By/MiBy
o solo By
.
La función scale
comprueba que la unidad solicitada tenga la misma dimensión que la unidad del valor que se escala.
Si size
es una columna cuyo valor tiene la unidad “KiBy”, la expresión scale(size, "By")
es la misma que size * 1024 "By/KiBy"
y la unidad de la expresión resultante es MiBy.By/MiBy
o solo By
.
Hay una cantidad limitada de casos en los que MQL ajustará o proporcionará unidades de forma automática para un valor.
Para una función f que requiere dos argumentos con unidades equivalentes (
add
,sub
, cualquiera de los operadores de comparación numéricos,if
yor_else
) , uno de los argumentos puede ser una llamada en la funciónscale
sin el segundo argumento de unidad. Si la unidad del otro argumento para f tiene la misma dimensión que la unidad del argumento para la funciónscale
, el segundo argumento de la funciónscale
será se establecerá automáticamente en las unidades del otro argumento en f. De esta manera, las unidades de dos argumentos como f serán equivalentes y f podrá operar.Por ejemplo, el operador
+
requiere que sus argumentos tengan unidades equivalentes, ya que no tiene sentido agregar dos números con unidades diferentes. Sicache_size
tiene la unidadBy
yheap_size
tiene la unidadMiBy
, la expresiónscale(cache_size) + heap_size
es equivalente a la expresiónscale(cache_size, "MiBy") + heap_size
.Para cualquier función de comparación, si un argumento es un literal con una unidad que tiene la misma dimensión, pero diferente escalamiento, en comparación con el otro argumento, el literal se escala para tener el mismo escalamiento.
Por ejemplo, si “cache_size” tiene la unidad
By
, la expresióncache_size < 3 "KiBy"
es equivalente a la expresióncache_size < 3072 "By"
. Ten en cuenta que esto no es lo mismo quecache_size < scale(3 "KiBy", "By")
sicache_size
es el tipo Int, porquescale
convertirá el resultado en tipo Double, lo que podría reducir la precisión de la comparación. El escalamiento de números enteros en este caso tiene en cuenta el redondeo y el manejo adecuados del desbordamiento para la comparación realizada en particular.Para cualquiera de los argumentos de
mul
o el divisor dediv
, un literal sin una unidad se le asignará la unidad “1”. Esto tiene en cuenta las operaciones de escalamiento que no están destinadas a cambiar las unidades (por ejemplo, preguntar qué pasa si la tasa fuese el doble de lo que es). Para cambiar las unidades, es mejor usarscale
, que seleccionará automáticamente el factor de escala correcto para la conversión.
Los errores de unidad se tratan como advertencias cuando se evalúa una consulta, por lo que la consulta seguirá generando resultados. Cuando se define una alerta, los errores de unidad se tratan como errores reales y no se definirá la alerta.
Es importante saber que Duration y Date NO son tipos numéricos y no tienen unidades. El valor 60s
de Duración es una duración no numérica, exactamente la misma cantidad de tiempo que 1m
o 60000ms
. La expresión 60s
== 60000ms
es válida y verdadera.
Un valor numérico con unidad de tiempo es diferente. Los números 3 'min'
y 180 's'
son dos valores numéricos diferentes (3 y 180) con unidades diferentes. Sin escalamiento, no es válido compararlas.
La función scale
convertirá los valores Duration y Date en valores Double con unidades. Por ejemplo, scale(60s, "min")
, scale(1m, "min")
y scale(60000ms, "min")
mostrarán el valor doble 1.0
con la unidad min
.
Tabla de accesos directos de operaciones
Un acceso directo es una forma simplificada de especificar una operación de tabla básica.
shortcut_table_op : shortcut { ',' arg } .
shortcut : table_name | '(' expr ')' | map | DURATION .
Hay varias formas de operaciones de tabla de acceso directo, cada una de las cuales designa un tipo de operación de tabla básica:
Un acceso directo de promoción de función parece una operación de tabla normal, pero la operación de tabla comienza con un
ID
que asigna un nombre a una función en lugar de los elementosarg
que siguen (que son todos de formaexpr
). son los argumentos de la función.La función se promociona cuando se proporciona una operación de tabla para la que la función se convierte en un argumento. La columna de valores o columnas de la tabla de entrada se convierten en los primeros argumentos en la función, como si un operador
.
los precediera. A continuación, se detallan las promociones específicas:Una función normal se convierte en el argumento de una operación de tabla
value
, que calcula la columna de valor único de su tabla de salida.Por ejemplo,
| add 3
es un acceso directo paravalue [.add(3)]
y| div
es un acceso directo para| value [.div]
.Una función de agregación se convierte en el segundo argumento de una operación de tabla
group_by
cuyo primer argumento es elmap
vacío ([ ]
). Por lo tanto, la función calcula la columna de valor único de una tabla de salida sin columnas de identificador de serie temporal (una tabla con una sola serie temporal).Por ejemplo,
| min
es un acceso directo para| group_by [], [.min]
.Una función de alineación se convierte en el argumento en una operación de tabla
align
, por lo que realiza su tipo de alineación designado en la serie temporal de la tabla de entrada.Por ejemplo,
| delta 10m
es un acceso directo para la operación de tabla| align [.delta(10m)]
.
Un acceso directo de nombre comienza con un
table_name
que se usa como argumento pararesource
,metric
ofetch
según qué tipo de operación nombratable_name
.Por ejemplo,
| gce_instance
es un acceso directo para la operación de tabla| resource gce_instance
y| gce_instance :: compute/instance/cpu/usage_time
es un acceso directo para| fetch gce_instance :: compute/instance/cpu/usage_time
.Un acceso directo de filtrado consiste en una
expr
entre paréntesis que se convierte en el predicado en una operación de tablafilter
.Por ejemplo,
| (job == 'search')
es un acceso directo para| filter job == 'search'
.Un acceso directo de agrupación comienza con un
map
, que se convierte en el primer argumento para una operación de tablagroup_by
. Debe estar seguida de unarg
que sea unmap
que describa la agregación que calcula las columnas de valores de la tabla de salida.Por ejemplo,
| [zone]
es un acceso directo para| group_by [zone]
,Un acceso directo de sistema de ventanas comienza con una
DURATION
, que se convierte en el primer argumento para una operación de tablagroup_by
. Debe estar seguida de unarg
que sea unmap
que describa la agregación que calcula las columnas de valores de la tabla de salida.Por ejemplo,
| 10m, [.sum]
es un acceso directo para| group_by 10m, [.sum]
.Un acceso directo de duración comienza con una
DURATION
sin que sigaarg
. Se convierte en una operación de tablafor
, que proporciona la extensión general en el tiempo de la operación de consulta.Por ejemplo,
| 10m
es un acceso directo para| for 10m
.
Operación de tabla y descripciones de las funciones
Cada operación de tabla y descripción de la tabla del lenguaje de consulta de Monitoring comienza con una firma de documentación que indica las entradas de la tabla (para las operaciones de tabla) y los tipos de argumentos que se pueden proporcionar para la operación o función de la tabla. En esta sección, se describe la forma de estas firmas.
Ten en cuenta que estas firmas NO son parte del lenguaje de consulta de supervisión. Se usan para describir el lenguaje de consulta de supervisión.
Una firma de operación de tabla comienza de forma opcional con un tipo que describe las tablas de entrada a las operaciones de tabla seguidas del nombre de la operación de tabla seguida de una lista de argumentos que describe los argumentos válidos para la tabla. . Por ejemplo, la firma de la operación de tabla pick
:
Tabla | pick
lit-Int,
[TSIDSEL],
[Windowed(Num)]
Esta operación de tabla toma una Table
como entrada (el caso más común) y tiene 3 argumentos potenciales, descritos por lit-Int , [TSIDSel] y [Windowed(Num)].
La tabla de entrada y |
son opcionales y, si no se proporciona, la operación de la tabla no toma una tabla de entrada. La especificación de la tabla de entrada es una de las siguientes opciones:
- Table La entrada para la operación de tabla es una sola tabla.
- Table ++ La operación de tabla toma dos o más tablas como entrada.
- Resource La operación de tabla toma una colección de tablas especificadas por un tipo de recurso supervisado (todas las tablas que contienen series temporales que incluyen un tipo de recurso supervisado en particular).
- ResourceOrTable Se permite Tabla o Recurso como entrada.
Cada descriptor de argumentos en la lista de argumentos que sigue al nombre de la operación de tabla tiene las siguientes partes:
Se puede encerrar entre
[
]
, en cuyo caso es opcional y el argumento real se puede proporcionar como_
o se puede omitir si el argumento real se posiciona después de todos los argumentos proporcionados de forma explícita.Puede tener un prefijo
lit-
que indique que el valor del argumento debe ser un valor constante conocido antes de evaluar la consulta.Siempre tiene el nombre de un tipo de valor o una clase de tipos (que se describe a continuación) que describe el tipo permitido del argumento real.
Es posible que tenga un sufijo que proporcione un tipo de serie temporal que limite el tipo de serie temporal del valor de entrada.
El nombre del tipo de descriptor de argumento puede ser uno de los tipos reales que se describen aquí: Bool, Int, Double, Distribution, String, Duration o date. En ese caso, el argumento real debe ser una expresión del mismo tipo.
A continuación, se indica que el argumento real debe ser un table_name
que nombra una métrica, un recurso supervisado o una tabla, respectivamente:
- MetricName
- ResourceName
- TableName
Es posible que un descriptor de argumento nombre una categoría que indique que el argumento real puede ser una expresión de uno de los siguientes tipos:
- Num, ya sea un Int o Double.
- Summable Tipos de valores que se pueden sumar: Int, Double o Distribution.
- Comparable: Tipos de valores que se pueden comparar: Int, Double, String, Bool 1}, Duration, Date.
- ColumnValue: Tipos que son valores de columna válidos: Int, Double, String, Bool o Distribution.
- Windowed(Num) Un Num, posiblemente anotado por funciones
within
,ago
obottom
. - WindowDuration Una Duration , posiblemente anotada por
window
osliding
. - BucketSpecification: Especificación de un depósito para una distribution.
Una operación de tabla puede requerir un argumento map
que especifique las columnas de identificador de la serie temporal de filas de salida o las columnas de valor. Esto se indica mediante una de las siguientes opciones:
- RowToTSID: Un mapa que describe las columnas de identificadores de series temporales de la tabla de salida.
- TSIDSel: Un mapa que nombra las columnas de serie temporal que se conservarán. Cada
maplet
en elmap
debe constar solo de unaexpr
que nombre una columna (ID
ocolumn_name
). Por ejemplo,[zone, name]
hace que las columnas de salida consten solo de las columnas de identificador de serie temporal de entradazone
yname
, con el resto de las columnas de entrada descartadas. - RowToVal Un mapa que describe las columnas de valores de la tabla de salida. Si se proporciona una expresión que no sea de un mapa como un argumento real, se convierte en un mapa con un solo elemento con esa expresión.
- RowSetToVal Un mapa que describe las columnas de valores de la tabla de salida por agregación. Si se proporciona una expresión que no sea de un mapa como un argumento real, se convierte en un mapa con un solo elemento con esa expresión.
- DefaultColumns Un mapa que describe las columnas de valores predeterminados para una
outer_join
. Si se proporciona una expresión que no sea de un mapa como un argumento real, se convierte en un mapa con un solo elemento con esa expresión.
Una firma de función comienza con el nombre de la función seguida de una lista de argumentos entre paréntesis, que describe los argumentos válidos de la función seguida de un tipo de datos que se muestra que describe el valor que muestra la función. Por ejemplo, la firma de la función fraction_less_than
:
fraction_less_than(
Sumable,
lit-Num)
→ Double
Esta función toma dos argumentos que se describen en Summable y lit-Num y muestra un valor de tipo Double. La lista de argumentos tiene los mismos elementos descritos antes para las operaciones de la tabla. El tipo de datos que se muestra puede ser un tipo de valor específico, el cual indica que el valor mostrado será de ese tipo o uno de los siguientes:
- Num: si alguno de los argumentos de la función es Double, entonces Double; de lo contrario, es Int.
- ColumnValue: el mismo tipo que el primer argumento real para la función.
- LastArgType: El mismo tipo que el último argumento real para la función.
- Windowed(): el mismo tipo que el argumento real Windowed, anotado con el tipo Windowed (si el argumento real Windowed era Int, el tipo de datos que se muestra es Windowed(Int) (consulta las funciones
within
,ago
obottom
).
Un descriptor de argumentos de función o tipo de datos que se muestra pueden tener un indicador que controle el tipo de serie temporal del argumento o del resultado. Estos aparecen como uno de los siguientes sufijos en el tipo:
- .Cumulative, .Delta o .Gauge indican que el argumento real debe tener el tipo de serie temporal dado.
- .CumulativeOK significa que un argumento real puede ser acumulativo.
- .FirstArgKind significa, solo para los tipos de datos que se muestran, el mismo tipo de serie temporal que el primer argumento de la función.
Si un argumento no tiene sufijo de tipo de serie temporal, el argumento debe ser de tipo Gauge o Delta. Si un tipo de datos que se muestra no tiene un sufijo de tipo de serie temporal, será Gauge.
Una firma de función también puede tener una o más de las siguientes notas:
- (entrada de fila implícita). Esto indica que la función toma la fila completa como una entrada implícita. Por ejemplo, la función
hash_tsid
produce un hash de las columnas de identificadores de series temporales de su fila de entrada, pero no toma esos valores de columnas como argumentos explícitos. - (solo temporal) Se usa en la firma de funciones de agregación para indicar que la firma de la función solo se aplica cuando se realiza la agregación temporal (de lo contrario, se aplican otras firmas para la función). Ten en cuenta que esto incluye el caso de que la agregación temporal y la agregación espacial se lleven a cabo en la misma operación de tabla.
- (solo para uso temporal variable). Esto se usa en la firma de funciones de agregación a fin de indicar que la firma de la función solo se aplica cuando se realiza la agregación temporal variable (de lo contrario, se aplican otras firmas para la función). Ten en cuenta que esto incluye el caso de la agregación temporal y la agregación espacial que se llevan adelante en la misma operación de tabla.
Operaciones de la tabla
En esta sección, se describe cada una de las operaciones básicas de tabla en el lenguaje de consulta de Monitoring.
- Recuperación
fetch
Genera una tabla a partir de la base de datos.metric
Produce la tabla para un tipo de métrica específico a partir de un conjunto de tablas.fetch_cumulative
Produce una tabla de series temporales acumulativas a partir de la base de datos.
- Selección
filter
Filtra las filas de una tabla de entrada según un predicado.top
Selecciona las series temporales principales según una expresión de valor de clasificación.bottom
Selecciona la serie temporal inferior por una expresión de valor de clasificacióntop_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.bottom_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.
- Modificación de filas
map
Vuelve a escribir el identificador de serie temporal y las columnas de valor de cada fila en una tabla.value
Vuelve a escribir las columnas de valores de cada fila en una tablatime_shift
Cambia las series temporales en el tiempo
- Alineación de series temporales
align
Produce una tabla alineada mediante una función de alineación.
- Agregación
group_by
Agrega filas según un identificador de serie temporal asignado y un período.union_group_by
Agrega filas desde varias tablas.unaligned_group_by
Agrega filas según un identificador de serie temporal sin alineación.
- Combinaciones y uniones
join
Unión natural de varias tablas.outer_join
Unión natural externa de dos tablas.union
Unión de varias tablas
- Horizonte temporal y período
every
Especifica el período para el resultado de la tabla alineada.within
Especifica el intervalo de tiempo del resultado de la consultagraph_period
Especifica el período de salida preferido para dibujar gráficos de serie temporal.window
Especifica la ventana para las operaciones de alineación
- Alertas
condition
Agrega una columna de condición booleana a la tabla de entradaabsent_for
Crea una condición para la ausencia de la entrada.
- Varios
ident
Operación de tabla de identidad: sin cambios en la tabla de entrada.ratio
Calcula la proporción de las columnas de valor de dos tablas de entrada alineadas.filter_ratio
Calcula la proporción de dos sumas filtradas de la columna de valores de entrada.filter_ratio_by
Calcula una proporción agrupada de dos sumas filtradas de la columna de valores de entrada.
Recuperación
El resultado de una operación de tabla fetch
es una tabla recuperada por el nombre de la base de datos de series temporales de Cloud Monitoring.
El resultado de la operación de la tabla resource
es el conjunto de todas las tablas que tienen el tipo de recurso supervisado por nombre en su nombre. Cada resource
debe estar seguido por una operación de tabla metric
que selecciona la única tabla cuyo nombre contiene esa métrica. Antes de la operación de tabla metric
, es posible que haya operaciones de tabla filter
que restrinjan las filas incluidas en las tablas resultantes.
fetch
Genera una tabla a partir de la base de datos.
Firma: fetch
lit-TableName
La operación fetch
recupera de la base de datos de series temporales la tabla cuyo nombre es el nombre de tabla proporcionado en el argumento TableName.
Es un error si el nombre de la tabla contiene un nombre de tipo de recurso supervisado o tipo de métrica desconocido.
Esta tabla estará vacía si no se recopiló una métrica del tipo determinado del recurso supervisado del tipo dado.
Si la métrica es acumulativa, las series temporales que conforman la tabla se convierten de manera efectiva en series temporales Delta, en las que cada punto representa el cambio en el valor desde el punto siguiente.
La operación fetch
también puede recuperar el conjunto de todas las tablas que se basan en un recurso supervisado en particular, solo proporcionando el nombre del recurso supervisado y no da un nombre de métrica. Esta operación fetch
debe estar seguida de una operación metric
que selecciona la tabla específica que contiene los datos de una métrica específica. La única operación que puede producirse entre un fetch
y el metric
posterior es una operación filter
, que filtra según las columnas del recurso supervisado.
Esta forma de fetch
es útil si queremos recuperar más de una métrica para un recurso supervisado dado, como en este ejemplo:
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
Esto equivale a
{ 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
Produce la tabla para un tipo de métrica específico a partir de un conjunto de tablas.
Firma: Resource | metric
lit-MetricName
La operación de la tabla metric
toma un conjunto de tablas producidas por una operación de tabla fetch
que no dio un nombre de métrica.
Selecciona la tabla que contiene los datos de la métrica proporcionada por el argumento lit-MetricName y produce esa tabla como su resultado.
Es un error si no hay una definición de métrica con el nombre determinado. Si no hay una tabla de entrada con datos para el nombre de la métrica, genera una tabla vacía.
fetch_cumulative
Produce una tabla de series temporales acumulativas a partir de la base de datos.
Firma: fetch_cumulative
lit-TableName
La operación de tabla fetch_cumulative
es la misma que la operación de tabla fetch
, excepto que las métricas acumulativas no se convierten de forma automática en métricas delta cuando se recupera.
Selección
Las operaciones de la tabla de selección seleccionan filas de la tabla de entrada para su inclusión en la tabla de salida. El tipo de la tabla de salida es exactamente el mismo que el de la tabla de entrada.
filter
Filtra las filas de una tabla de entrada según un predicado.
Firma: ResourceOrTable | filter
Bool
La operación filter
evalúa su expresión de argumento Bool para cada fila en una sola tabla de entrada o en la colección de tablas que nombra una operación resource
. Esas filas en la tabla o tablas de entrada en las que esta expresión se evalúa como verdadera se conservan en la tabla o tablas de salida.
Si la entrada es una colección de tablas, solo se puede hacer referencia a las etiquetas de recursos supervisados (que son comunes a todas las tablas) en el predicado.
top
Selecciona la serie temporal principal según una expresión de valor de clasificación.
Firma: Table | top
lit-Int,
[Windowed(Num)]
La operación de tabla top
calcula un valor de clasificación para cada serie temporal en su tabla de entrada y selecciona la cantidad de series temporales dadas por su argumento Int con el valor de orden más grande. La expresión del argumento Windowed calcula el valor de clasificación.
El argumento Windowed(Num) se aplica a las filas de una serie temporal que se incluyen dentro de una ventana de valor. La ventana de tiempo del valor predeterminado es la misma que la de la consulta. Si la expresión es una expresión de agregación (p. ej., .min
), es una agregación en todas las filas cuya marca de tiempo de finalización esté dentro de la ventana de valor. Si la expresión es un valor (p. ej., .val(0)/.val(1)
), se aplica a la fila más joven, si existe alguna, dentro de la ventana de valor. Si no hay filas dentro de la ventana de valor para una serie temporal, o si el argumento Windowed(Num) no produce un valor con ese fin, no se considera la inclusión esa serie temporal en el resultado.
La función within
se puede usar en el argumento Windowed(Num) para modificar la ventana de valor con una hora de inicio, una duración o una hora de finalización para la ventana.
Ejemplos:
| top 3
Selecciona 3 series temporales con el valor más alto para el punto más nuevo de la serie temporal.
| top 7, .max
Selecciona 7 series temporales con el valor más alto para el máximo de todos los puntos en la serie temporal dentro de la ventana de consulta.
| top 3, .min.within(-10h, 1h)
Esto selecciona 3 series temporales con el valor más grande del reductor min
aplicado a las filas de cada serie temporal que comienzan en 10 horas y duran 1 hora.
bottom
Selecciona la serie temporal inferior según una expresión de valor de clasificación.
Firma: Table | bottom
lit-Int,
[Windowed(Num)]
La operación de tabla bottom
calcula un valor de clasificación para cada serie temporal en su tabla de entrada y selecciona la cantidad de series temporales dadas por su argumento Int con el valor de orden más pequeño. La expresión del argumento Windowed calcula el valor de clasificación.
El argumento Windowed(Num) se aplica a las filas de una serie temporal que se incluyen dentro de una ventana de valor. La ventana de tiempo del valor predeterminado es la misma que la de la consulta. Si la expresión es una expresión de agregación (p. ej., .min
), es una agregación en todas las filas cuya marca de tiempo de finalización esté dentro de la ventana de valor. Si la expresión es un valor (p. ej., .val(0)/.val(1)
), se aplica a la fila más joven, si existe alguna, dentro de la ventana de valor. Si no hay filas dentro de la ventana de valor para una serie temporal, o si el argumento Windowed(Num) no produce un valor con ese fin, no se considera la inclusión esa serie temporal en el resultado.
La función within
se puede usar en el argumento Windowed(Num) para modificar la ventana de valor con una hora de inicio, una duración o una hora de finalización para la ventana.
Ejemplos:
| bottom 3
Selecciona 3 series temporales con el valor más pequeño para el punto más nuevo de la serie temporal.
| bottom 7, .min
Selecciona 7 series temporales con el valor más pequeño para el mínimo de todos los puntos en la serie temporal dentro de la ventana de consulta.
| bottom 3, .max.within(10h)
Esto selecciona 3 series temporales con el valor más pequeño del reductor max
aplicado a las filas de cada serie temporal que comienzan en 10 horas y duran hasta ahora.
top_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.
Firma: Table | top_by
lit-Int,
lit-Int ,
[Windowed(Num)]
La operación de tabla top_by
agrupa las series temporales que tienen el mismo identificador de serie temporal calculado por el argumento TSIDSel. Dentro de cada grupo, selecciona series temporales mediante el mismo método que top
cuando recibe los mismos argumentos Int y Windowed. En cada grupo, calcula un valor de orden para cada serie temporal en un grupo y selecciona el número de series temporales proporcionadas por su argumento Int con el valor de clasificación más grande. La expresión del argumento Windowed calcula el valor de clasificación.
El argumento Windowed(Num) se aplica a las filas de una serie temporal que se incluyen dentro de una ventana de valor. La ventana de tiempo del valor predeterminado es la misma que la de la consulta. Si la expresión es una expresión de agregación (p. ej., .min
), es una agregación en todas las filas cuya marca de tiempo de finalización esté dentro de la ventana de valor. Si la expresión es un valor (p. ej., .val(0)/.val(1)
), se aplica a la fila más joven, si existe alguna, dentro de la ventana de valor. Si no hay filas dentro de la ventana de valor para una serie temporal, o si el argumento Windowed(Num) no produce un valor con ese fin, no se considera la inclusión esa serie temporal en el resultado.
La función within
se puede usar en el argumento Windowed(Num) para modificar la ventana de valor con una hora de inicio, una duración o una hora de finalización para la ventana.
Ejemplos:
| top_by [zone], 1
Para cada grupo temporal con el mismo valor de la columna “zona”, se selecciona la serie temporal con el valor más alto para el punto más joven de la serie temporal.
| top_by [project_id], 2, .max
Para cada grupo de series temporales con el mismo valor de la columna “project_id”, esto selecciona las 2 series temporales con el valor más alto para el máximo de todos los puntos en la ventana de consulta.
| top_by [zone], 1, .min.within(-10h, 1h)
Para cada grupo de serie temporal con el mismo valor de la columna “zona”, se selecciona la serie temporal con el valor más grande del reductor min
aplicado a las filas de cada serie temporal que se dividen en una ventana que comenzó hace 10 horas y con una duración de 1 hora.
bottom_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.
Firma: Table | bottom_by
lit-Int,
lit-Int ,
[Windowed(Num)]
La operación de tabla bottom_by
agrupa las series temporales que tienen el mismo identificador de serie temporal calculado por el argumento TSIDSel. Dentro de cada grupo, selecciona series temporales mediante el mismo método que bottom
cuando recibe los mismos argumentos Int y Windowed. Por cada grupo, calcula un valor de orden para cada serie temporal en un grupo y selecciona el número de series temporales proporcionadas por su argumento Int con el valor de orden más pequeño. La expresión del argumento Windowed calcula el valor de clasificación.
El argumento Windowed(Num) se aplica a las filas de una serie temporal que se incluyen dentro de una ventana de valor. La ventana de tiempo del valor predeterminado es la misma que la de la consulta. Si la expresión es una expresión de agregación (p. ej., .min
), es una agregación en todas las filas cuya marca de tiempo de finalización esté dentro de la ventana de valor. Si la expresión es un valor (p. ej., .val(0)/.val(1)
), se aplica a la fila más joven, si existe alguna, dentro de la ventana de valor. Si no hay filas dentro de la ventana de valor para una serie temporal, o si el argumento Windowed(Num) no produce un valor con ese fin, no se considera la inclusión esa serie temporal en el resultado.
La función within
se puede usar en el argumento Windowed(Num) para modificar la ventana de valor con una hora de inicio, una duración o una hora de finalización para la ventana.
Ejemplos:
| bottom_by [zone], 1
Para cada grupo temporal con el mismo valor de la columna “zona”, se selecciona la serie temporal con el valor más pequeño para el punto más joven de la serie temporal.
| bottom_by [project_id], 2, .max
Para cada grupo de series temporales con el mismo valor de la columna “project_id”, esto selecciona las 2 series temporales con el valor más pequeño para el máximo de todos los puntos en la ventana de consulta.
| bottom_by [zone], 1, .min.within(1h)
Para cada grupo de serie temporal con el mismo valor de la columna “zona”, se selecciona la serie temporal con el valor más pequeño del reductor min
aplicado a las filas de cada serie temporal que se dividen en una ventana que comenzó hace 10 horas y con una duración de 1 hora.
Modificación de filas
map
Vuelve a escribir el identificador de serie temporal y las columnas de valor de cada fila en una tabla.
Firma: Table | map
[RowToTSID],
[RowToVal]
Para cada fila en la tabla de entrada, se aplican dos transformaciones:
Si se proporciona el mapa RowToTSID, se aplica a las columnas de identificadores de series temporales de esa fila para producir las columnas de identificadores de series temporales de la fila de salida correspondiente. Si no se proporciona el mapa RowToTSID (o se proporciona como
_
), las columnas de identificadores de series temporales son las mismas que las de entrada.Si se asigna el mapa RowToVal, se aplica a las columnas de valores de la fila de entrada para producir las columnas de valores de la fila de salida. Si no se proporciona el mapa RowToVal, las columnas del valor de salida son las mismas que las entradas.
Es un error dinámico si las filas de dos series temporales diferentes en la entrada se mapean a la misma serie temporal en el resultado. En este caso, las filas derivadas de una de las series temporales de entrada se descartan del resultado y aparecerá un mensaje de error.
Si el mapa RowToTSID contiene referencias a columnas de valores o columnas de tiempo, es posible que divida una serie temporal de entrada en varias series temporales de salida. Por este motivo, cuando el mapa RowToTSID contiene referencias a columnas de valores o columnas de tiempo, solo se puede aplicar a tablas cuyas columnas de valores sean series temporales Gauge o Delta.
value
Vuelve a escribir las columnas de valores de cada fila en una tabla.
Firma: Table | value
RowToVal
Para cada fila de la Tabla de entrada, se aplica el mapa RowToVal a las columnas de esa fila a fin de producir las columnas de valor de la fila de salida correspondiente. Cada fila de salida tiene el mismo identificador de serie temporal y las mismas columnas de tiempo que la fila de entrada desde la que se produjo y tiene las columnas de valor producidas por el mapa RowToVal.
time_shift
Cambia las series temporales en el tiempo.
Firma: Table | time_shift
lit-Duration
Cada fila de la tabla de entrada tiene el importe proporcionado por el argumento Duration agregado a la columna o columnas de tiempo. Esto tiene el efecto de mover cada serie temporal en la tabla hacia delante en el tiempo.
Si la tabla de entrada está alineada, la cantidad de cambios debe ser un múltiplo par del período de alineación, lo que mantiene la alineación de la tabla de entrada.
Alineación de series temporales
align
Produce una tabla alineada mediante una función de alineación.
Firma: Tabla | align
[Alineador]
La operación de tabla align
usa la función de alineación proporcionada para su argumento Alineador a fin de crear una serie temporal alineada de cada serie temporal en su entrada, y genera las series temporales en su tabla de salida.
El tiempo base de la alineación es la hora de finalización de la ventana de consulta y el período de alineación se establece mediante uno de los tres puntos siguientes:
Una operación de tabla
every
que establece el período para esta operación de tablaalign
.La función de alineador requiere que el período de alineación sea igual al ancho de su ventana (consulta
delta
).Una interfaz de gráficos externa requiere un período de alineación particular.
El método particular para producir series temporales alineadas se describe para la función de alineación que se le da al argumento Alineador.
Agregación
Una operación de tabla de agregación divide las filas de la tabla de entrada en grupos. En cada grupo de filas de entrada, calcula un identificador común de series temporales y columnas de tiempo para el grupo, agrega las filas de entrada a fin de crear las columnas de resultados de valor y muestra una sola fila con el identificador de las series temporales resultantes, la hora y el valor de las columnas.
Hay tres tipos de agregación:
Agregación espacial. Esta forma de agregación calcula nuevas columnas de ID de series temporales para cada fila de entrada y agrupa todas las filas con las mismas columnas de ID de serie temporal y hora de finalización. Este tipo de agregación generalmente requiere una entrada alineada para que las filas de diferentes series temporales se alineen en el tiempo para agruparse.
Agregación temporal. Esta forma de agregación calcula un conjunto de horas de salida alineadas válidas y calcula una hora de finalización nueva para cada fila, lo que le da la hora de finalización alineada más antigua que no es más temprano que la hora de finalización original de la fila. Las filas con el mismo identificador de serie temporal y hora de finalización se agrupan.
Agregación temporal variable. Esta forma de agregación es similar a la agregación temporal, con la excepción de que una fila puede incluirse en más de un grupo. Esto calcula un conjunto de períodos, cada uno con un borde posterior a una hora de finalización alineada válida y con el mismo ancho fijo. Una fila recibe una hora de finalización que es el borde posterior de cada período en el que entra y la fila se agrupa con cualquier otra fila que tenga el mismo identificador de serie temporal y hora de finalización nueva. Cuando las ventanas se superponen, una fila puede tener más de una hora de finalización nueva y, por lo tanto, puede incluirse en más de un grupo.
Es posible combinar la agregación espacial con una de las dos formas de agregación temporal en una operación de tabla.
Una distinción importante entre la agregación temporal variable y no variable es que algunos agregadores (p.ej., suma) producen valores con series temporales Delta para la agregación temporal no variable, pero el tipo Gauge para la agregación temporal variable. La razón de esto es que las extensiones de tiempo para dos puntos en una serie temporal Delta no pueden superponerse, por lo que las ventanas de entrada superpuestas de agregación temporal de deslizamiento no se pueden representar en las columnas de tiempo de las filas de salida de series temporales Delta.
Cuando se calcula un identificador de series temporales nuevo para una fila, un argumento mapa calcula el nuevo identificador de series temporales. Las columnas de valores para la fila de salida se calculan mediante un argumento map con una expresión de agregación que calcula cada columna de valor.
group_by
Agrega filas según un identificador de serie temporal asignado y un período.
Firma: Tabla | group_by
RowToTSID,
[RowSetToVal]
Tabla | group_by
RowToTSID,
lit-WindowDuration,
[RowSetToVal]
Tabla | group_by
lit-WindowDuration,
[RowSetToVal]
La operación de tabla group_by
agrupa las filas si mapeas las columnas del identificador de serie temporal, las columnas de tiempo o ambas:
Si se proporciona el argumento RowToTSID y el argumento WindowDuration no, se calcula el identificador de serie temporal producido por ese argumento de mapa para cada fila en la tabla de entrada y se agrupan todas con el mismo identificador de serie temporal y la misma hora de finalización.
En este caso,
group_by
requiere una tabla alineada como entrada, de modo que diferentes series temporales tengan puntos con la misma hora de finalización. Si la tabla de entrada no está alineada, se insertará automáticamente una operación de tablaalign
para proporcionar alineación.Si se proporciona el argumento WindowDuration y el argumento RowToTSID no, se produce un grupo de filas para cada identificador de serie temporal y cada punto de salida del período alineado. Las filas de un grupo son todas las filas con el identificador de la serie temporal determinado cuyo tiempo de finalización se encuentra dentro del período entre el tiempo de salida y la hora anterior a la duración.
Si el argumento Duration tiene una llamada a la función
sliding
(p. ej.,sliding(1h)
), la ventana puede ser diferente que el período de alineación. De lo contrario, el argumento Duration debe ser el mismo que el período de alineación. La expresiónwindow()
representa una duración que es la misma que el período de alineación. Si se elige una Duration que no es confiable, se fuerza el período para que sea el mismo si no se otorgó ningún período de forma explícita.Si se proporcionan los argumentos RowToTSID y WindowDuration, se calcula un identificador de serie temporal asignado nuevo para cada fila y se crea un grupo para todas las filas con el mismo identificador de serie temporal asignado cuya hora de finalización se encuentra en un período entre el tiempo de salida y la hora anterior a la duración.
Se produce una fila de salida para cada grupo con el identificador de serie temporal común de las filas del grupo y una marca de tiempo que es el tiempo de salida del grupo (se proporcionó WindowDuration) o la hora de finalización común de las filas del grupo (no se le proporcionó WindowDuration). Las columnas de valor en el grupo se producen mediante el argumento RowSetToVal. Cada expresión de agregación se aplica a las filas del conjunto y el resultado es la columna de valor de la fila de salida.
Algunas expresiones de agregación (p. ej., sum
) producirán columnas de valores de salida con el tipo de serie temporal Delta o Gauge, según el tipo de agregación. Esto depende de si se realiza o no la agregación temporal no deseada. Para este propósito, la agregación se trata como la agregación temporal si combina la agregación temporal y espacial.
Una operación de tabla group_by
siempre produce tablas de resultados alineadas. Si no se proporciona un argumento WindowDuration, la tabla de entrada debe alinearse y la tabla de salida tendrá la misma alineación. Si se proporciona el argumento WindowDuration, un punto de salida solo se produce en un momento de alineación y la tabla de salida está alineada.
Ten en cuenta que, si el argumento de mapa RowToTSID incluye columnas de valor o tiempo en sus expresiones, es posible que las series temporales en la tabla de entrada se dividan en varias series temporales en la tabla de salida.
union_group_by
Agrega filas de varias tablas.
Firma: Tabla ++ | union_group_by
RowToTSID,
[RowSetToVal]
Tabla ++ | union_group_by
RowToTSID,
lit-WindowDuration,
[RowSetToVal]
Tabla ++ | union_group_by
lit-WindowDuration,
[RowSetToVal]
La función union_group_by
agrega filas de entrada exactamente como la función group_by
, con la excepción de que toma sus filas de entrada de varias tablas de entrada.
Todas las tablas de entrada de una union_group_by
deben tener las mismas columnas (el mismo nombre, el mismo tipo y, para las columnas de valor, el mismo tipo de serie temporal). Si las tablas de entrada alineadas son obligatorias para los argumentos de “union_group_by” (no se proporciona el argumento WindowDuration), todas las tablas de entrada deben estar alineadas con el mismo período.
unaligned_group_by
Agrega filas según un identificador de serie temporal sin alineación.
Firma: Table | unaligned_group_by
TSIDSel,
[RowSetToVal]
La operación de tabla unaligned_group_by
hace lo mismo que la operación de tabla group_by
, pero no requiere que su tabla de entrada esté alineada.
Esto calcula el identificador de series temporales producida por TSIDSel para cada fila en la tabla de entrada y agrupa todas las filas con el mismo identificador de serie temporal resultante y hora de finalización. Todas las filas del grupo tienen la misma hora de finalización y deben tener la misma hora de inicio. Si dos filas de un grupo tienen una hora de inicio diferente, emite un error dinámico y, luego, elige una de las filas de forma arbitraria y la quita del grupo.
Produce una fila de salida para cada grupo del grupo de filas anterior. La fila de salida tiene el identificador de serie temporal producido por el argumento de mapa TSIDSel y la misma hora de finalización y (si existe) la hora de inicio que las filas de entrada en el grupo. Tiene columnas de valor producidas por el argumento del mapa RowSetToVal que se aplica a todas las filas del grupo.
La operación de tabla unaligned_group_by
no requiere que su tabla de entrada esté alineada, lo que significa que es poco probable que haya varias filas en un grupo para agregar. Requiere que las filas recopiladas en una serie temporal de salida (todas con el mismo identificador de serie temporal) no tengan horas de finalización cuya densidad proporcione más de una fila por segundo.
Combinaciones y uniones
join
Unión natural de varias tablas.
Firma: Tabla ++ | join
La operación de tabla join
toma dos o más tablas de entrada y combina las filas en una sola tabla de salida mediante una unión interna natural en el identificador de serie temporal y las columnas de hora de finalización de las tablas de entrada.
Además de estar alineadas, todas las tablas de entrada deben estar alineadas con el mismo período y deben ser de los tipos de series temporales Delta o Gauge.
La tabla de salida tendrá los siguientes elementos:
Una columna de identificador de series temporales para cada columna de identificador de serie temporal única en cualquiera de las tablas de entrada. Cada columna tendrá el mismo tipo que la columna correspondiente en las tablas de entrada. Si dos tablas tienen columnas de identificador de serie temporal con el mismo nombre, pero tipos diferentes, es un error.
Una columna de hora de finalización. Si alguna de las tablas de entrada es de tipo de serie temporal Delta, la tabla de salida también será del tipo de serie temporal Delta y tendrá una columna de hora de inicio.
Una columna de valores para cada columna de valores de la tabla de entrada. El orden es el orden de las tablas de entrada en la
grouped_table_op
que las generó. Es un error si dos tablas de entrada diferentes tienen columnas de valores con el mismo nombre.
La unión considera cada tupla que consta de una fila de cada tabla de entrada. Se crea una fila de salida para cada tupla que cumple con las siguientes condiciones:
Para cada nombre de columna de identificador de serie temporal que aparece en cualquiera de las tablas de entrada, esa columna tiene el mismo valor para cada fila de la tupla que tiene esa columna.
Cada fila de la tupla tiene la misma hora de finalización.
Cada fila de salida tendrá los siguientes valores de columna:
Cada columna de serie temporal tendrá el valor para esa columna como cada fila en la tupla que tiene esa columna.
Cada columna de tiempo tendrá el mismo valor que las filas de la tupla de entrada.
Cada columna de valor tendrá el mismo valor que la fila en la tupla de la que proviene la columna de valores.
outer_join
Unión natural externa de dos tablas.
Firma: Tabla++ | outer_join
[DefaultColumns],
[DefaultColumns]
La operación de tabla outer_join
toma dos tablas de entrada y combina las filas en una sola tabla de salida mediante una unión externa natural en el identificador de serie temporal y las columnas de hora de finalización de las tablas de entrada.
Se debe proporcionar uno o ambos argumentos DefaultColumns. Cada uno corresponde a una tabla de entrada y, cuando se le asigna a una tabla, esa tabla tendrá filas creadas si no tiene algunas filas que coinciden con una fila en la otra tabla. Con las DefaultColumns, se especifican las columnas de valores de la fila creada. Si se proporciona una DefaultColumns para una tabla, las columnas del identificador de series temporales en esa tabla deben ser un subconjunto de las series temporales de las otras tablas que solo pueden tener el tipo de serie temporal Delta si la otra tabla tiene el tipo de serie temporal Delta.
Además de estar alineadas, todas las tablas de entrada deben estar alineadas con el mismo período y deben ser de los tipos de series temporales Delta o Gauge.
Al igual que con join
, la tabla de salida tendrá los siguientes elementos:
Una columna de identificador de series temporales para cada columna de identificador de serie temporal única en cualquiera de las tablas de entrada. Cada columna tendrá el mismo tipo que la columna correspondiente en las tablas de entrada. Si dos tablas tienen columnas de identificador de serie temporal con el mismo nombre, pero tipos diferentes, es un error.
Una columna de hora de finalización. Si alguna de las tablas de entrada es de tipo de serie temporal Delta, la tabla de salida también será del tipo de serie temporal Delta y tendrá una columna de hora de inicio.
Una columna de valores para cada columna de valores de la tabla de entrada. El orden es el orden de las tablas de entrada en la
grouped_table_op
que las generó. Es un error si dos tablas de entrada diferentes tienen columnas de valores con el mismo nombre.
La combinación considera cada par consiste en una fila de cada tabla de entrada. Se crea una fila de salida para cada par que cumpla con las siguientes condiciones:
Para cada nombre de columna del identificador de serie temporal que aparece en cualquiera de las tablas de entrada, esa columna tiene el mismo valor por cada fila del par que tiene esa columna.
Cada fila del par tiene la misma hora de finalización.
Cada fila de salida tendrá los siguientes valores de columna:
Cada columna de serie temporal tendrá el valor para esa columna como cada fila en el par que tiene esa columna.
Cada columna de tiempo tendrá el mismo valor que las filas del par de entrada.
Cada columna de valor tendrá el mismo valor que la fila del par de la cual surgió.
Además de los pares anteriores, si una fila de una tabla no puede formar un par con ninguna fila en la otra tabla y la otra tabla tiene un DefaultColumns determinado, entonces se crea un par con la fila de la primera tabla y una fila predeterminada para la otra tabla. La fila predeterminada se construye de la siguiente manera:
Cada una de las columnas del identificador de serie temporal y columnas de tiempo tiene el mismo valor que la columna correspondiente en la primera fila de la tabla.
Las columnas de valores de la fila predeterminada se construyen con DefaultColumns
map
, quemap
deben especificar un valor para cada columna de valores en la tabla predeterminada.
union
Unión de varias tablas.
Firma: Table ++ | union
La operación de tabla union
toma dos o más tablas de entrada y genera una sola tabla de salida que contiene filas de todas las tablas de entrada.
Las tablas de entrada deben tener las mismas columnas (el mismo nombre, mismo tipo y, para las columnas de valores, la misma categoría de serie temporal). La tabla resultante tendrá las mismas columnas que las tablas de entrada. La tabla de resultados solo está alineada si todas las tablas de entrada están alineadas con un período común.
Es un error dinámico si las transmisiones de dos o más tablas diferentes tienen el mismo identificador de serie temporal. En este caso, una de las transmisiones con un identificador de serie temporal duplicado se elige de manera arbitraria para que se incluya en la salida y el resto se descarta.
Horizonte temporal y período
El período que se usa cuando se alinea la serie temporal en la tabla mediante el comando every
.
La consulta producirá todos sus resultados como puntos cuya hora de finalización se encuentre dentro de un período de consulta. La operación de tabla within
establece la duración de la ventana de consulta, que puede especificar una hora de inicio, una hora de finalización o una duración.
every
Especifica el período para el resultado de la tabla alineada.
Firma: Table | every
lit-Duration
La operación de tabla every
requiere una tabla de entrada que esté alineada con un período de entrada dado por el argumento Duration. Esto se maneja de una de las siguientes maneras:
Si la tabla de entrada no está alineada, se inserta una operación
align
con una función de alineador apropiada para la tabla de entrada. El argumento Duration en la función de alineador es el valor predeterminado para el período dado.Si la tabla está alineada, pero no tiene un período requerido específico, la consulta que se ingresa en la operación de tabla
every
se ajusta para producir ese período.Es un error si la tabla de entrada está alineada con un período específico y ese período es diferente del que especifica el argumento Duration.
within
Especifica el intervalo de tiempo del resultado de la consulta.
Firma: Table | within
lit-DateOrDuration,
[lit-DateOrDuration ]
La operación de tabla within
especifica el intervalo de tiempo del resultado de la consulta.
Para ello, especifica uno o dos de los tres valores: el tiempo más antiguo (inicio) del período, el tiempo más reciente (final) del período o la duración del período.
Si alguno de los dos argumentos de within
es un Duration positiva, se establece el ancho de la ventana. Como máximo, uno de los argumentos puede ser una Duration positiva.
Si el primer argumento es una Date, eso especifica la hora de inicio. Si el segundo argumento es una Date, eso especifica la hora de finalización. Si ambos son valores de Date, el segundo debe ser posterior al primero. Un argumento Date se puede proporcionar como un literal Date o con un literal Duration negativo. En el caso posterior, la hora es la Duration especificada antes del tiempo en que se emitió la consulta (ahora).
Si solo se proporciona un argumento, el segundo argumento se establece de forma predeterminada en el momento en que se emitió la consulta (ahora). En este caso, el primer argumento debe ser una Duration positiva o una Date que sea anterior a la hora en que se emite la consulta.
graph_period
Especifica el período de salida preferido para dibujar gráficos de serie temporal.
Firma: Table | graph_period
lit-Duration
La operación de tabla graph_period
transforma su tabla de entrada a fin de que sea adecuada para la presentación como un gráfico. Su argumento Duration indica el período entre puntos adecuado para el gráfico.
Esta operación se inserta automáticamente en las consultas proporcionadas al Explorador de métricas si el usuario no agrega explícitamente una a la consulta. En ambos casos, el Explorador de métricas establece el valor del argumento Duration a fin de que sea apropiado para el período real del gráfico. Agregar de manera explícita graph_period
como parte de una consulta solo tiene sentido si la consulta se asigna a la API.
La operación graph_period
compara su argumento Duration con el período de la tabla de entrada y realiza una de las siguientes acciones:
Si el período de la tabla de entrada es inferior a la mitad del argumento Duration, la operación
graph_period
actúa como un reductor temporal cuya ventana y período de salida se proporcionan por Duration. Cada columna de valor en la tabla de entrada se agrega según su tipo.Para una columna de valor de tipo numérico, se colocan tres columnas en la tabla de salida, cada una producida por la agregación de la columna de entrada con agregadores
min
,mean
ymax
. Los nombres de las columnas de resultado son el nombre de la columna de entrada con, respectivamente,.min
,.mean
y.max
adjuntos.Para una columna de valor de tipo Bool, se colocan tres columnas en la tabla de salida, cada una producida por agregar la columna de entrada con agregadores
min
,mean
ymax
. Los nombres de las columnas de resultado son el nombre de la columna de entrada con, respectivamente,.all_true
,.mean
y.any_true
adjuntos.Para una columna de tipo Distribución, se crea una sola columna con el mismo nombre mediante la agregación
distribution
a fin de combinar las poblaciones de todos los valores de entrada de distribución que corresponden a cada ventana del gráfico del gráfico.
Si el período de la tabla de entrada es más del doble del argumento Duration, para cada punto en la tabla de entrada, las copias se realizan para los puntos de tiempo que requiere el período de salida.
Si el período de la tabla de entrada es menor que el doble del argumento Duration y más de la mitad del argumento Duration, la tabla de entrada se copia en el resultado.
Ten en cuenta que si la tabla de entrada tiene más de una columna de valor o tiene una columna de valores String, su comportamiento es indefinido. El Explorador de métricas solo puede mostrar una columna o mostrar un error si no hay una columna que se pueda mostrar.
window
Especifica la ventana para las operaciones de alineación.
Firma: Table | window
lit-Duration
La operación de tabla window
requiere una tabla de entrada que esté alineada por una función de alineador cuyo argumento Duración sea el mismo que el argumento Duración dado en esta operación de tabla window
. Esto se maneja de una de las siguientes maneras:
Si la tabla de entrada no está alineada, se inserta una operación
align
con una función de alineador apropiada para la tabla de entrada. El argumento Duration de la función de alineador se proporciona mediante el argumento Duration de esta operación de tablawindow
.Si la tabla está alineada, pero la operación de tabla que la alineó no tiene una ventana de alineación específica, se usa la Duración de este argumento
window
como el argumento de la ventana de alineador.Es un error si la tabla de entrada está alineada y la operación de tabla que realizó la alineación especifica una Duration de ventana que es diferente del argumento Duration de esta operación de tabla
window
.
Alertas
Las operaciones de alerta se usan para definir políticas de alertas. Usa estas operaciones solo para instalar alertas, no como parte de una consulta.
De forma abstracta, estas operaciones proporcionan formas de crear consultas que generan una tabla con dos columnas de valores: uno booleano que indica si la alerta debe estar en un estado de activación o no y un valor del mismo tipo que la entrada que otorga el valor más reciente de la entrada.
condition
Agrega una columna de condición booleana a la tabla de entrada.
Firma: Tabla | condition
Bool
La operación de la tabla condition
agrega una columna de valores booleanos a cada fila de la tabla de entrada para crear su tabla de salida. El valor de esta columna es el valor del argumento Bool aplicado a la fila.
Esto se puede usar para crear una consulta de alerta. La tabla de salida tiene una columna booleana que indica que se cumple la condición de la alerta. La función de alerta usará esto para determinar si se debe activar o detener una alerta y cuándo hacerlo.
La operación condition
requiere que su tabla de entrada esté alineada y que la genere una consulta con un período de alineación explícito. Esto se proporciona mediante un argumento de período para una operación de alineación (p. ej., | align rate(10m)
) o mediante una operación de tabla window
.
Ejemplos:
fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
| window 5m
| condition val() < .5
Esto producirá una tabla con dos columnas de valores. La primera columna es una columna Bool que será verdadera si la columna de valor usage_time
de la tabla de entrada es menor que .5
. La segunda columna es una copia de la columna de valor usage_time
de la entrada.
absent_for
Crea una condición para la ausencia de la entrada.
Firma: Table | absent_for
lit-Duration
La operación de tabla absent_for
genera una tabla con dos columnas de valores, active
y signal
. La columna active
es verdadera cuando hay datos faltantes de la tabla de entrada y es falsa en caso contrario. Esto es útil a fin de crear una consulta de condición que se usará para alertar sobre la ausencia de entradas.
Para cada serie temporal de entrada, absent_for
crea una serie temporal de salida alineada con el mismo identificador de serie temporal que la entrada. El período de alineación se puede dar mediante un every
siguiente o es el período predeterminado.
El argumento Duration da como resultado un límite de tiempo. La columna active
para un punto de salida será falsa si hay un punto en la serie temporal de entrada que está dentro de este límite de tiempo antes de la hora del punto de salida. Si no hay ese punto de entrada, la columna active
será verdadera, lo que indica una ausencia de entrada dentro del límite de tiempo.
Si la tabla de entrada tiene columnas de valores, la columna signal
contendrá el valor de la primera columna de valor del punto de entrada más reciente (dentro del límite o no) en la serie temporal de entrada. Si la tabla de entrada no tiene columnas de valores, la columna signal
en el punto de resultado será un número entero que proporcionará la cantidad de minutos desde el último punto de entrada.
En cada tiempo de punto de salida, la operación de tabla absent_for
buscará un punto de entrada en las 24 horas anteriores a ese momento. Si no hay ningún punto de entrada en las 24 horas anteriores, no se dará el resultado de ningún punto para esa hora.
Ejemplos:
fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
| absent_for 8h
Para cada serie temporal usage_time
de una máquina virtual (gce_instance
), el absent_for
generará una serie temporal alineada cuyos puntos de salida tendrán una columna active
que es verdadera si hay un punto de entrada dentro de las últimas 24 horas, pero ningún punto dentro de las últimas 8 horas (8h
). Esta es una consulta de alerta adecuada.
fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time
| value [] | absent_for 8h
Esto es similar al ejemplo anterior, pero | value []
quita las columnas de valor de la entrada a la operación absent_for
, por lo que la columna signal
se establece en el tiempo (en minutos) desde el último punto de entrada.
Varios
ident
Operación de tabla de identidad: sin cambios en la tabla de entrada.
Firma: Tabla ++ | ident
La operación de tabla ident
produce una tabla de entrada sin cambios.
Ejemplo:
fetch gce_instance :: compute.googleapis.com/instance/cpu/usage_time |
{ ident ; group_by [zone] } |
join | value [zone_fraction: val(0) / val(1)]
Por cada fila de la tabla dada, calcula la proporción de su valor con el total de ese valor en todas las instancias en la zona en la que se encuentra.
ratio
Calcula la proporción de las columnas de valor de dos tablas de entrada alineadas.
Firma: Table ++ | ratio
La operación de tabla ratio
toma dos tablas de entrada alineadas, la entrada de la tabla del numerador y la entrada de la tabla de denominador, respectivamente. Ambas entradas de tabla deben tener exactamente una columna de valor de un tipo numérico.
Las columnas de identificador de series temporales de la tabla de denominador deben ser un subconjunto de las columnas de identificador de series temporales de la tabla de numerador. Si ambas tablas tienen las mismas columnas de identificador de serie temporal (nombre y tipo), se usará un valor predeterminado de cero para cuando el numerador calcula las proporciones.
filter_ratio
Calcula la proporción de dos sumas filtradas de la columna de valores de entrada.
Firma: Tabla | filter_ratio
Bool,
[Bool]
La operación de la tabla filter_ratio
toma una tabla de entrada que tiene exactamente una columna de valores de un tipo numérico. Si la tabla de entrada no está alineada, se insertará automáticamente una operación de tabla align
para proporcionar alineación.
La operación filter_ratio
agrega todas las filas de entrada en una marca de tiempo determinada, calcula una suma de numerador y denominador, y produce una serie temporal con la proporción de estas sumas en cada marca de tiempo. El primer argumento Bool controla lo que ingresa en la suma del numerador y el segundo argumento Bool controla lo que ingresa en la suma del denominador. El segundo argumento es opcional y su valor predeterminado es true
si no se especifica.
Los argumentos Bool se evalúan para cada fila y, si son verdaderos, la columna de valor de esa fila se incluye en la suma del numerador (primer Bool) o del denominador (segundo Bool).
filter_ratio_by
Calcula una proporción agrupada de dos sumas filtradas de la columna de valores de entrada.
Firma: Tabla | filter_ratio_by
RowToTSID,
Bool,
[Bool]
La operación de la tabla filter_ratio_by
toma una tabla de entrada que tiene exactamente una columna de valores de un tipo numérico. Si la tabla de entrada no está alineada, se insertará automáticamente una operación de tabla align
para proporcionar alineación.
La operación filter_ratio_by
agrupa las filas que tienen el mismo identificador de serie temporal calculado por el argumento RowToTSID. Para cada grupo, procesa una suma de numerador y denominador, y produce una serie temporal con la proporción de estas sumas en cada marca de tiempo. El primer argumento Bool controla lo que ingresa en la suma del numerador y el segundo argumento Bool controla lo que ingresa en la suma del denominador. El segundo argumento es opcional y su valor predeterminado es true
si no se especifica.
Los argumentos Bool se evalúan para cada fila y, si son verdaderos, la columna de valor de esa fila se incluye en la suma del numerador (primer Bool) o del denominador (segundo Bool).
Las series temporales se calculan para cada grupo y el identificador de serie temporal se calcula con el argumento RowToTSID.
Funciones
En esta sección, se describe cada una de las funciones que se pueden usar en expresiones (expr
) en el lenguaje de consulta de supervisión.
- Columnas de fila de entrada
val
El valor de una columna de valores en el punto de entrada (fila).end
La hora de finalización del punto de entrada (fila)start
La hora de inicio del punto de entrada (fila).older
Un valor del siguiente punto más antiguo (fila) de una serie temporal.adjacent_delta
El cambio en el valor entre un punto de entrada y el punto siguiente más antiguo.adjacent_rate
La velocidad de cambio entre la entrada y los siguientes puntos más antiguos (filas).hash_tsid
Muestra un hash de las columnas de identificador de serie temporal.
- Logical
not
La negación lógica de un valor booleanoand
El valor lógico y de dos valores booleanosor
El valor lógico o de dos valores booleanostrue
El valor booleano es verdadero.false
El valor booleano es falsohas
Verdadero si un argumento de conjunto contiene un valor particularhas_value
Verdadero si una expresión de argumento calcula un valorif
Un valor se elige condicionalmente entre dos valores.or_else
Un valor o, si no es un valor, otro valor.
- Comparison
- Aritmética
add
La suma de dos númerossub
La diferencia de dos númerosmul
El producto de dos númerosdiv
La proporción de dos númerosint_div
El cociente de la división de dos números enterosabs
Valor absolutoneg
Negativo de un númeropos
Identidad para entradas numéricasrem
El resto de la división de dos números enteros
- Math
- Sting
concatenate
Concatenación de stringstring_to_double
Convierte String en Doublestring_to_int64
Convierte String en Intascii_to_lower
Cambia los caracteres ASCII a minúsculasascii_to_upper
Cambia los caracteres de las letras ASCII a mayúsculasutf8_normalize
String Unicode adecuada para la comparación de mayúsculas y minúsculas.
- Expresiones regulares
re_full_match
Verdadero si una expresión regular coincide con el valor completo de una stringre_partial_match
Verdadero si una expresión regular coincide con alguna parte del valor de la string.re_extract
Extrae valores que coincidan con una expresión regular en otra stringre_replace
Reemplaza la primera coincidencia de una expresión regular en otra stringre_global_replace
Reemplaza todas las coincidencias de una expresión regular en otra string
- Agregación
sum
La suma de un grupo de valores numéricosdistribution
Una distribución de un grupo de valores numéricos o de distribucióncount
Recuento de la cantidad de valores en un grupo de valoresrow_count
La cantidad de filas de entrada encontradascount_true
La cantidad de valores verdaderos en un grupo de valores booleanosmin
El mínimo de un grupo de valores numéricosmax
El máximo de un grupo de valores numéricosdiameter
El máximo menos el mínimo de un grupo de valores numéricosmean
La media de un grupo de valores numéricosstddev
La desviación estándar de un grupo de valoresvariance
La varianza de un grupo de valores numéricoscovariance
La covarianza de un grupo de valoresmedian
La mediana de un grupo de valores numéricos o de distribuciónpercentile
Un percentil de un grupo de valores numéricos o de distribuciónfraction_less_than
La fracción de un grupo de valores inferior a un valor fijofraction_true
La fracción de un grupo de valores booleanos que son verdaderosany_true
La disyunción de un grupo de valores booleanosall_true
La combinación de un grupo de valores booleanospick_any
El valor de cualquier elemento de un grupo de valores (elegido arbitrariamente)singleton
El valor del elemento de un grupo de valores con un solo elementounique
El valor común de un grupo de valores (que deben ser todos iguales)aggregate
Valor agregado predeterminado de un grupo de valores de cualquier tipoweighted_distribution
Una distribución de un grupo de valores ponderados
- Alineación
rate
Calcula una tasa de cambio en puntos alineados en el tiempodelta
Calcula el cambio de valor en puntos alineados en el tiempoany_true_aligner
Para alinear una serie temporal Bool, encuentra un valor verdadero en una ventanacount_true_aligner
Alinea una serie temporal Bool cuando cuenta los valores verdaderos en una ventanadelta_gauge
Calcula el cambio en el valor en puntos temporales alineados como una serie temporal de Indicadorfraction_true_aligner
Alinea una serie temporal Bool con la fracción de valores verdaderos en una ventanaint_mean_aligner
Para alinear, busca la media de los valores Int en una ventanainterpolate
Calcula valores interpolados en puntos alineados en el tiempomean_aligner
Alinea mediante la búsqueda de la media de los valores en una ventananext_older
Puntos alineados en el tiempo cuando se pasa de un tiempo anterior a otro posterior.next_younger
Puntos temporales alineados en el tiempo cuando se pasa de un tiempo posterior a otro anterior.
- Manipula unidades
scale
Escala un valor a una unidad de medida diferente.cast_units
Establece la unidad de medida de un valor.
- Ventana de período
- Distribución
count_from
La cantidad de valores en un valor de distribuciónsum_from
La suma de los valores en un valor de distribuciónmean_from
La media de los valores en un valor de distribuciónstddev_from
La desviación estándar de los valores en un valor de distribuciónvariance_from
La varianza de los valores en un valor de distribuciónmedian_from
La mediana de los valores en un valor de distribuciónpercentile_from
Es un percentil de los valores de un valor de distribuciónfraction_less_than_from
La fracción de valores en una distribución que es menor que un valor fijobounded_percentile_from
Un percentil de los valores dentro de un límite en un valor de distribuciónrebucket
Valor de distribución convertido en una especificación de depósito nueva.
- Especificador de depósitos
powers_of
Una especificación de depósito con límites de depósito que aumentan exponencialmentefixed_width
Una especificación de depósito con depósitos de igual tamañocustom
Una especificación de depósito de una lista de límites de depósitosnum_buckets
Establece la cantidad de depósitos en una especificación de depósitobounds
Establece el límite inferior del primer depósito y el límite superior del últimolower
Establece el límite inferior del primer depósito en una especificación de depósito
- Varios
cast_double
Convierte el valor Int en Doublecast_gauge
Transmite un valor de serie temporal acumulado o delta a Indicadorwithin
Especifica la ventana del cálculo del valor de orden
Columnas de fila de entrada
Las expresiones de una consulta operan en las columnas de una fila de entrada. Por lo general, se accede a una columna mediante su nombre. Las funciones de esta sección proporcionan formas alternativas de acceder a columnas.
Las columnas de tiempo no tienen nombres de columna y se accede a ellas mediante las funciones start
y end
.
Se puede acceder a las columnas de valores por nombre o por posición mediante la función val
.
La función older
otorga acceso a una columna en la fila siguiente más antigua en una serie temporal.
val
El valor de una columna de valor en el punto de entrada (fila).
Firma: ImplicRowInput val(
[lit-Int] )
→ InputType (entrada de fila implícita)
La función val
proporciona una alternativa al uso del nombre de columna cuando accedes a las columnas de valores de una fila de entrada. Su argumento Int (valor predeterminado 0) indexa el conjunto ordenado de columnas de valores (comienza con 0 para la primera columna de valor) y muestra el valor de la columna de valor indexado. Este es el mismo valor que se produce cuando se usa el nombre de la columna de valor.
Es un error estático si la función val
indica un índice negativo o que es igual o mayor que la cantidad de columnas de valores.
end
La hora de finalización del punto de entrada (fila)
Firma: ImplicitRowInput end(
)
→ Date.Gauge (entrada de fila implícita)
La función end
muestra el valor de fecha en la columna de hora de finalización de la fila de entrada actual.
start
La hora de inicio del punto de entrada (fila).
Firma: ImplicitRowInput start(
)
→ Date.Gauge (entrada de fila implícita)
La función start
muestra el valor Date en la columna de hora de inicio de la fila de entrada actual. Si la fila no tiene una hora de inicio (porque solo contiene datos Gauge), la hora de inicio muestra no-value.
older
Un valor del siguiente punto más antiguo (fila) de una serie temporal.
Firma: older(
ColumnValue.CumulativeOKar )
→ FirstArgType.FirstArgKindolder(
Date )
→ Date.FirstArgKind
El argumento de older
debe ser un nombre de columna o una función que designe un valor de columna (val
, end
, start
). El valor que se muestra es el valor de esa columna en la siguiente más antigua a la fila de entrada en la misma serie temporal. Si no hay tal más antigua en la misma serie temporal, older
muestra no-value.
La columna a la que se hace referencia puede ser una columna de identificador de serie temporal, valor o tiempo. Si es una columna de identificador de serie temporal older
, se mostrará el mismo valor que la expresión del argumento, incluso si no hay una fila anterior en la misma serie temporal.
adjacent_delta
El cambio de valor entre un punto de entrada y el siguiente punto más antiguo.
Signature:
ImplicitRowInput adjacent_delta(
)
→
InputType (implicit row input)
La función adjacent_delta
opera en tablas con una sola columna numérica (Int o Double) o una columna de valor de distribución.
Si se aplica a una serie temporal de Indicador, adjacent_delta
muestra la diferencia entre el valor de la columna de valor en la fila de entrada actual y la columna de valor en la fila siguiente anterior de la misma serie temporal, si existe. Si no hay tal más antigua en la misma serie temporal, adjacent_delta
muestra no-value. El resultado tiene el tipo de serie temporal Gauge.
Si se aplica a una serie temporal Delta, adjacent_delta
muestra el valor de la columna de valores, que sigue siendo un tipo de serie temporal Delta. Cada punto de salida tiene el mismo valor, hora de inicio y hora de finalización que el punto de entrada en el que se generó.
Aunque las series temporales acumulativas no se usan en las consultas, si se aplican a una serie temporal acumulativa, adjacent_delta
muestra uno de dos valores:
Si la hora de inicio del punto de entrada es anterior a la hora de finalización del siguiente punto más antiguo,
adjacent_delta
muestra el valor del punto de entrada menos el valor del siguiente punto más antiguo.Si la hora de inicio del punto de entrada es posterior a la hora de finalización del siguiente punto más antiguo,
adjacent_delta
muestra el valor de puntos de entrada (efectivamente un valor de 0 en la hora de inicio).
Las series temporales resultantes tienen un tipo de serie temporal Delta y cada punto tiene una hora de inicio que es la hora de inicio original o la hora de finalización del próximo punto de entrada más antiguo, lo que suceda después.
adjacent_rate
Es la frecuencia de cambio entre la entrada y los siguientes puntos más antiguos (filas).
Signature: ImplicitRowInput adjacent_rate(
)
→
Double.Gauge (implicit row input)
La función adjacent_rate
opera en tablas con una sola columna numérica (Int o Double) o una columna de valor de distribución.
Si se aplica a una serie temporal Gauge o Cumulative, adjacent_rate
muestra la tasa de cambio entre el valor de la columna de valor en la fila de entrada actual y la columna de valor en la fila siguiente anterior de la misma serie temporal, si la hay. Esta es la diferencia en los valores dividido por la diferencia en la hora de finalización de las dos filas. Si no hay una fila posterior a la siguiente en la misma serie temporal, adjacent_rate
muestra no-value. El resultado tiene el tipo de serie temporal Gauge.
Si se aplica a una serie temporal Delta, adjacent_rate
muestra la columna de valores de la fila de entrada actual dividida por la diferencia entre la hora de inicio y la hora de finalización de esa fila.
hash_tsid
Muestra un hash de las columnas de identificador de serie temporal
Firma: ImplicRowInput hash_tsid(
[lit-Int] )
→ Int (entrada de fila implícita)
La función hash_tsid
muestra un hash de los valores en los campos del identificador de la serie temporal de la fila de entrada actual. Se le proporciona un argumento como un valor inicial para el hash.
Lógica
not
La negación lógica de un valor booleano
Firma: not(
Bool )
→ Bool
La función not
toma un valor booleano y muestra verdadero si ese argumento es falso y muestra falso si ese argumento es verdadero. Si el argumento de entrada es no-value, ese es el resultado.
and
El valor lógico y de dos valores booleanos.
Firma:
and(
Bool,
Bool )
→ Bool
La función and
muestra “true” si ambas entradas son verdaderas y “false” en caso contrario. Si alguna de las entradas es no-value, and
siempre muestra no-value.
or
El valor lógico o de dos valores booleanos.
Firma:
or(
Bool,
Bool )
→ Bool
La función or
muestra verdadero si alguna de sus entradas es verdadera y falso en caso contrario. Si alguna de las entradas es no-value, or
siempre muestra no-value.
true
El valor booleano es verdadero.
Firma: ImplicitRowInput true(
)
→ lit-Bool (entrada de fila implícita)
Esta función muestra el valor Bool true
literal.
false
El valor booleano es falso
Firma: ImplicitRowInput false(
)
→ lit-Bool (entrada de fila implícita)
Esta función muestra el valor Bool literal false
has
Verdadero si un argumento de conjunto contiene un valor particular
Firma: has(
Set,
lit-ColumnValue )
→ Bool
La función has
muestra el valor verdadero si su primer conjunto de argumentos tiene el segundo argumento como elemento.
has_value
Verdadero si una expresión de argumento calcula un valor.
Firma:
has_value(
ColumnValue )
→ Bool
La función has_value
muestra verdadero si su argumento se evalúa como un valor y muestra falso si se evalúa como no-value.
if
Un valor se elige condicionalmente entre dos valores.
Firma: if(
Bool,
ColumnValue.Delta,
ColumnValue.Delta(same) )
→ LastArgType.Delta
if(
Bool,
ColumnValue,
ColumnValue(same) )
- LastArgType
La función if
muestra su segundo o tercer argumento, según el valor (true
o false
) de su primer argumento.
if
evalúa su primer argumento Bool. Si es no-value, entonces ningún valor es el resultado. Si el primer argumento es verdadero, el segundo argumento se muestra y, si el primer argumento es falso, se muestra el tercer argumento.
El segundo o el tercer argumento pueden ser no-value, pero el resultado de if
solo será no-value si el argumento Bool es no-value o si el argumento que se muestra es no-value. El argumento que no está seleccionado puede ser no-value sin que el resultado sea sin valor.
Si el segundo y el tercer argumento de if
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro if
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de if
tiene la unidad de su segundo argumento, posiblemente escalada.
or_else
Un valor o, si no es un valor, otro valor.
Signature:
or_else(
ColumnValue,
ColumnValue(igual) )
→ LastArgType
La función or_else
muestra el valor del primer argumento, a menos que sea no-value, en cuyo caso se muestra el valor de su segundo argumento.
La función or_else
solo muestra no-value si ambos argumentos son no-value.
Si los argumentos de or_else
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro or_else
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de or_else
tiene la unidad del primer argumento, posiblemente escalada.
Comparación
Los operadores de comparación comparan dos valores del mismo tipo o dos valores numéricos (Int o *Double) y muestran un valor de Bool. A diferencia de la mayoría de las funciones, los operadores de comparación nunca muestran no-value. Si una entrada no tiene valor, se considera un valor específico que es mayor que cualquier otro valor.
eq
Igual
Firma:
eq(
Num,
Num )
→ Bool
eq(
Comparable,
Comparable(same) )
→ Bool
Esto compara su primer argumento Comparable con el segundo argumento Comparable y muestra true
si son iguales y false
si no lo son. Si un argumento es Int y el otro es Double, el argumento Int se convierte en un valor Double antes de comparar.
Si alguna de las entradas es no-value, la comparación se realiza y se muestra un argumento Bool, true
si ambos valores son no-value y false
en caso contrario. (Esto trata a no-value igual a sí mismo).
Para una comparación de argumentos numéricos, si alguno de los argumentos tiene unidades, ambos argumentos deben tener unidades y las unidades deben ser equivalentes. El resultado, que será del tipo Bool, no tendrá unidades.
Si los argumentos para eq
tienen unidades no equivalentes que tienen la misma dimensión, un argumento puede tener su unidad escalada de forma automática para que las unidades de ambos argumentos sean equivalentes.
Si los argumentos de eq
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro eq
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de “eq”, de tipo Bool, no tendrá unidades.
Una comparación entre la columna resource.project_id
y una string literal tiene un tratamiento especial para tratar con la diferencia entre los números de proyecto y los nombres de proyecto, como se describe en Coincidencia de columna resource.project_id
.
ne
No igual
Firma:
ne(
Num,
Num )
→ Bool
ne(
Comparable,
Comparable(same) )
→ Bool
Esto compara su primer argumento Comparable con el segundo argumento Comparable y muestra false
si son iguales y true
si no lo son. Si un argumento es Int y el otro es Double, el argumento Int se convierte en un valor Double antes de comparar.
Si alguna de las entradas es no-value, la comparación se realiza y se muestra un argumento Bool, false
si ambos valores son no-value y false
en caso contrario. (Esto trata a no-value igual a sí mismo).
Si los argumentos de ne
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro ne
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de “ne”, del tipo Bool, no tendrá unidades.
Una comparación entre la columna resource.project_id
y una string literal tiene un tratamiento especial para tratar con la diferencia entre los números de proyecto y los nombres de proyecto, como se describe en Coincidencia de columna resource.project_id
.
ge
Superior o igual a
Firma:
ge(
Num,
Num )
→ Bool
ge(
Comparable,
Comparable(same) )
→ Bool
Esto compara su primer Comparable de argumento con el segundo argumento Comparable y muestra true
si el primero es mayor o igual que el segundo y false
en caso contrario. Si un argumento es Int y el otro Double, el argumento Int se convierte en un valor Double antes de comparar.
Si alguna de las entradas es no-value, la comparación se realiza y se muestra un argumento Bool, true
si el primer valor es no-value y false
en caso contrario (se considera que el no-valor es mayor que cualquier otro valor).
Si los argumentos de ge
son numéricos, si algún argumento tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, las unidades deben ser equivalentes. Si las unidades no son equivalentes, pero tienen la misma dimensión, uno de los argumentos puede escalar automáticamente para tener las mismas unidades que las otras que se describe aquí. Sería un error si solo uno de los argumentos tiene unidades o si los argumentos tienen unidades no equivalentes y no se escala.
El resultado de “ge”, del tipo Bool, no tendrá unidades.
gt
Superior a
Firma:
gt(
Num,
Num )
→ Bool
gt(
Comparable,
Comparable(same) )
→ Bool
Esto compara su primer argumento Comparable con el segundo argumento Comparable y muestra true
si el primero es mayor que el segundo y false
en caso contrario. Si un argumento es Int y el otro Double, el argumento Int se convierte en un valor Double antes de comparar.
Si alguna entrada es no-value, se realiza la comparación y se muestra un argumento Bool, false
si el segundo valor es no-value y true
en caso contrario (se considera que el no-valor es mayor que cualquier otro valor).
Si los argumentos de gt
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro gt
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de “gt”, del tipo Bool, no tendrá unidades.
le
(Menos o igual que)
Firma:
le(
Num,
Num )
→ Bool
le(
Comparable,
Comparable(same) )
→ Bool
Esta compara su primer argumento Comparable con el segundo argumento Comparable y muestra true
si el primero es menor o igual que el segundo y false
en caso contrario. Si un argumento es Int y el otro Double, el argumento Int se convierte en un valor Double antes de comparar.
Si alguna entrada es no-value, se realiza la comparación y se muestra un argumento Bool, true
si el segundo valor es no-value y false
en caso contrario (se considera que el no-valor es mayor que cualquier otro valor).
Si los argumentos de le
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro le
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de “le”, del tipo Bool, no tendrá unidades.
lt
Menor que
Firma:
lt(
Num,
Num )
→ Bool
lt(
Comparable,
Comparable(same) )
→ Bool
Esta compara su primer argumento Comparable con el segundo argumento Comparable y muestra true
si el primero es menor que el segundo y false
en caso contrario. Si un argumento es Int y el otro Double, el argumento Int se convierte en un valor Double. antes de realizar de comparar.
Si alguna de las entradas es no-value, la comparación se realiza y se muestra un argumento Bool, false
si el primer valor es no-value y true
en caso contrario (se considera que el no-valor es mayor que cualquier otro valor).
Si los argumentos de lt
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro lt
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de “lt”, del tipo Bool, no tendrá unidades.
Aritmética
Funciones que implementan los operadores aritméticos.
add
La suma de dos números
Firma: add(
Num.Delta,
Num.Delta )
→ Num.Delta
add(
Num,
Num )
→ Num
add(
Duration,
Duration )
→ Duration
add(
Date,
Duration )
→ Date
add(
Duration,
Date )
→ Date
La función add
en dos argumentos Num muestra la suma de sus argumentos, como un valor Double si alguna de las entradas es Double y como un valor Int en caso contrario. Si ambas entradas son del tipo de serie temporal Delta, entonces el resultado es el tipo de serie temporal Delta. De lo contrario, el resultado es el tipo de serie temporal Gauge.
La función add
en dos argumentos Duration muestra la duración que es su suma.
La función add
en un argumento Date y Duration muestra la fecha que es la Duration posterior al argumento Date. Si la Duration es negativa, el resultado será anterior a la Date de entrada (retrocede en el tiempo).
Si los argumentos de add
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro add
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de add
tiene la unidad del primer argumento, posiblemente escalada.
sub
La diferencia de dos números
Firma: sub(
Num.Delta,
Num.Delta )
→ Num.Delta
sub(
Num,
Num )
→ Num
sub(
Duration,
Duration )
→ Duration
sub(
Date,
Duration )
→ Date
sub(
Date,
Date )
→ Duration
La función sub
en dos argumentos Num muestra el primer argumento menos el segundo argumento, como un valor Doble si alguna de las entradas es Doble y como un Int de lo contrario. Si ambas entradas son del tipo de serie temporal Delta, entonces el resultado es el tipo de serie temporal Delta. De lo contrario, el resultado es el tipo de serie temporal Gauge.
La función sub
en dos argumentos Duration muestra la duración que es la diferencia numérica de ambos.
La función sub
en un argumento Date y Duration muestra la fecha que es la Duration anterior al argumento Date. Si el argumento Duration es negativo, el resultado es posterior al argumento Date.
Si los argumentos de sub
son numéricos y cualquiera de los argumentos tiene unidades, ambos argumentos deben tener unidades. Si los argumentos tienen unidades, deben ser equivalentes o las reglas proporcionadas aquí, deben permitir que uno de los argumentos se escale antes de aplicar el parámetro sub
de modo que las unidades sean equivalentes.
Sería un error si solo un argumento tiene unidades o si ambos argumentos tienen unidades que no pueden ser equivalentes.
El resultado de sub
tiene la unidad del primer argumento, posiblemente escalada.
mul
El producto de dos números
Firma: mul(
Num.Delta,
lit-Num )
→ Num.Delta
mul(
lit-Num,
Num.Delta )
→ Num.Delta
mul(
Num,
Num )
→ Num
mul(
Duration,
Num )
→ Duration
mul(
Num,
Duration )
→ Duration
La función mul
en dos argumentos Num muestra el producto de los dos argumentos, como un valor Double si alguna de las entradas es Double y como un valor Int en caso contrario. Si una entrada es del tipo de serie temporal Delta y la otra es un literal, la salida es del tipo de serie temporal Delta. De lo contrario, el resultado es el tipo de serie temporal Gauge.
La función mul
en un Num y Duración es la Duración multiplicada por el Num como una Duración.
Si algún argumento numérico tiene unidades, ambos argumentos deben tener unidades y deben ser equivalentes. La unidad del resultado, si los argumentos tienen unidades, será el producto de las unidades de los dos argumentos. La excepción es la multiplicación por un literal: es posible que el literal no tenga una unidad de medida proporcionada explícitamente; por lo tanto, si el otro argumento tiene una unidad de medida, se le dará la unidad 1
al literal, lo que hace que el resultado tenga las unidades del otro argumento.
div
La proporción de dos números
Firma: div(
Num.Delta,
lit-Num )
→ Double.Delta
div(
Num,
Num )
→ Double
div(
Duration,
Num )
→ Duration
div(
Duration,
Duration )
→ Double
div(
Date,
Duration )
→ Double
La función div
divide su primer argumento Num por su segundo argumento Num y muestra la proporción como un valor Double.
No produce un resultado si el segundo argumento Num es 0.
La función div
divide su primer argumento por el segundo argumento y muestra la proporción como un valor Double. Cuando un argumento es una Date o Duration, el valor se representa como un valor doble que es la Date o Duration en unidades que representan la precisión interna completa de esos valores. Si el resultado es una fecha o una duración, la proporción se interpreta como un valor con las mismas unidades, redondeado al valor más cercano al que una Fecha o Duración puede representar.
En el caso de que un valor Date se divida por un valor Duration, el resultado es el valor Double, que es el número de ese período de Duration desde la época de Unix (d'1970/01/01-00:00:00+00:00'
). Por lo tanto, d'2020/06/01-01:20:03' / 1s
es la cantidad de segundos desde d'1970/01/01-00:00:00+00:00'
en d'2020/06/01-01:20:03'
.
La función div
no produce un resultado si el segundo argumento es 0.
Si algún argumento numérico tiene unidades, ambos argumentos deben tener unidades. La unidad del resultado, si los argumentos tienen unidades, será la división de la unidad del primer argumento por la unidad del segundo. La única excepción es la división por un literal: es posible que el literal no tenga una unidad de medida proporcionada explícitamente; por lo tanto, si el otro argumento tiene una unidad de medida, se le dará la unidad 1
al literal, lo que hace que el resultado tenga las unidades del otro argumento.
int_div
El cociente de la división de dos números enteros
Firma: int_div(
Int,
Int )
→ Int
int_div(
Duration,
Int )
→ Duration
int_div(
Duration,
Duration )
→ Int
int_div(
Date,
Duration )
→ Int
La función int_div
divide su primer argumento por el segundo argumento y muestra el cociente como un valor Int. Cuando un argumento es una Date o Duration, el valor se representa como un valor de número entero que es la Date o Duration en unidades que representan la precisión interna completa de dichos valores. Si el resultado es una Date o Duration, el cociente numérico se interpreta como un valor con las mismas unidades.
En el caso de que un valor Date se divida por un valor Duration, el resultado es el valor Int que es el número de ese período de Duration desde la época de Unix (d'1970/01/01-00:00:00+00:00'
). Por lo tanto, d'2020/06/01-01:20:03' / 1s
es la cantidad de segundos desde d'1970/01/01-00:00:00+00:00'
en d'2020/06/01-01:20:03'
.
La función int_div
no produce un resultado si el segundo argumento es 0.
Si algún argumento numérico tiene unidades, ambos argumentos deben tener unidades. La unidad del resultado, si los argumentos tienen unidades, será la división de la unidad del primer argumento por la unidad del segundo. La única excepción es la división por un literal: es posible que el literal no tenga una unidad de medida proporcionada explícitamente; por lo tanto, si el otro argumento tiene una unidad de medida, se le dará la unidad 1
al literal, lo que hace que el resultado tenga las unidades del otro argumento.
abs
Valor absoluto
Firma: abs(
Num )
→ Num
La función abs
toma una entrada numérica (Int o *Double) y muestra un valor del mismo tipo que tiene la misma magnitud que la entrada y que no es negativo.
El resultado de abs
tiene la misma unidad de medida.
neg
Negativo de un número
Firma: neg(
Num )
→ Num
neg(
Duration )
→ Duration
La función neg
muestra el negativo de su argumento.
pos
Identidad para entradas numéricas
Firma: pos(
Num )
→ Num
pos(
Duration )
→ Duration
La función pos
muestra su único argumento.
rem
El resto de la división de dos números enteros
Firma: rem(
Int,
Int )
→ Int
rem(
Duration,
Duration )
→ Duration
La función rem
divide su primer argumento Int por su segundo argumento Int, lo que muestra el resto como un valor Int.
No produce un resultado si el segundo argumento Num es 0.
La unidad de medida conectada al resultado de Rem
es la misma que la unidad, si existe, del primer argumento.
Matemáticas
Algunas funciones matemáticas.
sqrt
Raíz cuadrada
Firma: sqrt(
Num )
→ Double
La función sqrt
muestra la raíz cuadrada del argumento Num como un valor Double.
sqrt
no produce un resultado si el argumento Num es menor que 0.
El resultado de sqrt
no tiene una unidad de medida.
log
Algoritmo natural
Firma: log(
Num )
→ Double
La función log
muestra el logaritmo natural del argumento Num como un valor Double.
log
no produce un resultado si el argumento Num es menor o igual que 0.
El resultado de log
no tiene una unidad de medida.
exp
e elevado a una potencia.
Firma: exp(
Num )
→ Double
La exp
muestra e (la base de logaritmos naturales) generada a la potencia del argumento Num como un valor Double.
Las funciones exp
muestran el valor Double infinito en el desbordamiento.
El resultado de exp
no tiene una unidad de medida.
power
Un número a la potencia de otro
Firma: power(
Num,
Num )
→ Double
Esto muestra el valor del primer argumento Num, elevado al poder del segundo argumento Num, representado por un valor Double. Si algún argumento es un Int, se convierte en un Double antes de la operación.
El resultado de power
no tiene una unidad de medida.
int_round
Número entero más cercano
Firma: int_round(
Double )
→ Int
La función int_round
toma un valor Double, lo redondea hacia el valor de número entero más cercano y lo muestra como un valor Int. Si la entrada no es un valor o el resultado no se puede representar como un valor Int, el resultado es no-value.
El resultado de int_round
tiene la misma unidad de medida que su entrada.
int_floor
Límite inferior de número entero
Firma: int_floor(
Double )
→ Int
La función int_floor
toma un valor Double, lo redondea hacia el menos infinito al valor de número entero más cercano y lo muestra como un valor Int. Si la entrada no es un valor o el resultado no se puede representar como un valor Int, el resultado es no-value.
El resultado de int_floor
tiene la misma unidad de medida que su entrada.
int_ceil
Límite superior de número entero
Firma: int_ceil(
Double )
→ Int
La función int_ceil
toma un valor Double, lo redondea hacia el menos infinito al valor entero más cercano y lo muestra como un valor Int. Si la entrada es no-value o el resultado no puede representarse como un valor Int, el resultado es no-value.
El resultado de int_ceil
no tiene una unidad de medida.
String
Funciones que procesan valores de String.
concatenate
Concatenación de string
Firma: concatenate(
String,
String )
→ String
La función concatenate
muestra la concatenación de sus dos argumentos de String.
string_to_double
Convierte String en Double.
Firma:
string_to_double(
String )
→ Double
La función string_to_double
analiza su argumento de entrada String como un número de punto flotante y muestra el resultado como un valor Double.
Si la string no es un valor de punto flotante válido, el resultado es no-value.
El resultado de string_to_double
no tiene una unidad de medida.
string_to_int64
Convierte String en Int.
Firma:
string_to_int64(
String )
→ Int
La función string_to_int64
analiza su argumento de entrada String como un número entero y muestra el resultado como un valor Int. Si la string no es un valor de número entero válido o no se puede representar como un valor Int, el resultado es no-value.
El resultado de string_to_int64
no tiene una unidad de medida.
ascii_to_lower
Cambia los caracteres ASCII a minúsculas
Signature:
ascii_to_lower(
String )
→ String
La función ascii_to_upper
toma un argumento String y muestra un valor String que es el mismo, excepto que se convierte cada letra ASCII en mayúscula a la letra ASCII minúscula correspondiente. Los demás caracteres no se modifican.
ascii_to_upper
Cambia los caracteres de las letras ASCII a mayúsculas
Signature:
ascii_to_upper(
String )
→ String
La función ascii_to_upper
toma un argumento String y muestra un valor String que es el mismo, excepto que cada letra ASCII en minúscula se convirtió en la letra ASCII mayúscula correspondiente. Los demás caracteres no se modifican.
utf8_normalize
String Unicode adecuada para la comparación de mayúsculas y minúsculas.
Signature:
utf8_normalize(
String )
→ String
La función utf8_normalize
toma un argumento String y muestra un valor String adecuado para la comparación de mayúsculas y minúsculas del valor de entrada si se supone que la entrada es una string codificada utf8 válida.
Expresiones regulares
Funciones que buscan coincidencias, extraen y modifican mediante expresiones regulares RE2.
re_full_match
Verdadero si una expresión regular coincide con el valor completo de una string
Firma: re_full_match(
String,
lit-String )
→ Bool
La función re_partial_match
toma una entrada de string y una expresión regular de string literal y muestra true
si toda la string de entrada coincide con la expresión regular. Muestra false
en caso contrario, incluso si el argumento de string de entrada es no-value.
Una coincidencia de expresión regular en la columna resource.project_id
tiene un tratamiento especial para tratar con la diferencia entre los números de proyecto y los nombres de proyecto, como se describe en Coincidencia de columna resource.project_id
.
re_partial_match
Verdadero si una expresión regular coincide con alguna parte del valor de la string.
Firma: re_partial_match(
String,
lit-String )
→ Bool
La función re_partial_match
toma una entrada de string y una expresión regular de string literal y muestra true
si alguna parte de la string de entrada coincide con la expresión regular. Muestra false
en caso contrario, incluso si el argumento de string es no-value.
re_extract
Extrae valores que coincidan con una expresión regular en otra string
Firma: re_extract(
String,
[lit-String],
[lit-String] )
→ String
La función re_extract
toma un argumento String de entrada y dos argumentos literales de String: una expresión regular y un valor de reemplazo. El resultado se obtiene cuando haces coincidir la string de entrada con la expresión regular y los grupos de captura de reemplazo en la string de reemplazo.
El resultado es la string de reemplazo con los grupos de captura reemplazados.
Si no se proporciona el argumento de expresión regular, el valor predeterminado es “(.*)”, por lo que se incluye toda la primera string de argumento en un grupo de captura.
Si no se proporciona el argumento de string de reemplazo, la configuración predeterminada es R“\1”, por lo que el primer grupo de reemplazo es la string de salida.
Si la string de entrada es no-value, si la expresión regular no coincidió o no funcionó la sustitución de grupos de captura, no se muestra ningún valor.
re_replace
Reemplaza la primera coincidencia de una expresión regular en otra string
Firma: re_replace(
String,
lit-String,
lit-String )
→ String
La función re_replace
toma un argumento String de entrada y dos argumentos literales de String: una expresión regular y un valor de reemplazo. Si la expresión regular coincide con cualquier parte de la string de entrada, el valor mostrado se forma mediante el reemplazo la primera coincidencia en la string de entrada con la string de reemplazo.
Si la string de entrada es no-value o si no hay una coincidencia, la string de entrada es el valor que se muestra.
re_global_replace
Reemplaza todas las coincidencias de una expresión regular en otra string
Firma: re_global_replace(
String,
lit-String,
lit-String )
→ String
La función re_global_replace
toma un argumento String de entrada y dos argumentos literales de String: una expresión regular y un valor de reemplazo.
El resultado se forma a partir de la string de entrada mediante el reemplazo de cada coincidencia inconexa de la expresión regular (de izquierda a derecha) con la string de reemplazo.
Si la string de entrada es no-value o si no hay una coincidencia, la string de entrada es el valor que se muestra.
Agregación
Una función de agregación combina un conjunto de valores de entrada en un valor de salida final. Se usan cuando una cantidad de filas de entrada se agrupa y se agregan en una sola fila de salida.
Una función de agregación mantiene un estado de agregación interna. La expresión de argumento a la función de agregación se evalúa una vez para cada una de las filas de entrada agrupadas y el valor resultante (si existe) se pasa a la función de agregación que se acumulará en su estado interno. Una vez que esto se hizo para todas las filas en el grupo, la función de agregación produce su valor de resultado que se usará en la creación de columnas de valores en la fila de salida única.
Por ejemplo, mean(memory_usage)
se aplica a un conjunto de filas con una columna memory_usage
, evalúa la expresión de argumento, memory_usage
, para cada fila e incorpora el valor resultante (si se produce alguno) en el estado interno de la función de agregación mean
(que puede ser una suma de valores y un recuento de valores).
Una vez que se procesaron todas las filas, el reductor mean
genera un valor desde su estado interno (la suma dividida por el recuento).
La mayoría de las funciones de agregación que operan sobre valores numéricos o de distribución proporcionan la unidad de medida de su entrada al resultado. Estas son las excepciones:
count
yrow_count
cuyos resultados tienen la unidad1
.variance
cuyo resultado es el cuadrado de entrada.covariance
cuyo resultado es el producto de las unidades de las dos entradas.fraction_less_than
yfraction_true
dan su resultado a la unidad10^2.%
.
sum
La suma de un grupo de valores numéricos
Firma: sum(
Num )
→ Num.Delta
(solo temporal)sum(
Distribución )
→ Double.Delta
(solo temporal)sum(
Num )
→ Num.Gauge
(solo para el deslizamiento temporal)sum(
Distribución )
→ Double.Gauge
(solo para el avance temporal)sum(
Num )
→ Num.FirstArgKindsum(
Distribución )
→ Double.FirstArgKind
Si la expresión del argumento es numérica (Int o *Double), muestra la suma de los valores que se le pasan.
Si la expresión de argumento es un valor Distribution, esta muestra la suma de los valores de población en todos los valores Distribution que se le pasan.
Si, para alguna fila de entrada, la expresión del argumento no se evalúa como un valor o se evalúa como un valor Double no finito, esa fila de entrada no afecta la suma.
Para las entradas numéricas (Int o Double), el resultado es el mismo tipo (Int* o Double) que la expresión de entrada. Para los valores de entrada de Distribution, el tipo de resultado es Double.
El resultado tiene un tipo de serie temporal Delta si se realizan agregaciones temporales no variables o si solo se realiza una agregación espacial y el tipo de serie temporal de entrada también es Delta..
La unidad de medida conectada al resultado de sum
es la misma que la unidad de la entrada.
distribution
Una distribución de un grupo de valores numéricos o de distribución
Firma: distribution(
Num,
lit-BucketSpecification )
→ Distribution.Delta (temporal only)
distribution(
Num,
lit-BucketSpecification )
→ Distribution.Gauge
distribution(
Distribution )
→ Distribution.Delta (temporal only)
distribution(
Distribution )
→ Distribution.Gauge (sliding temporal only)
distribution(
Distribution )
→ Distribution.FirstArgKind
Si el primer argumento es un valor Num, los valores de entrada se recopilan en un resultado de distribución cuya especificación de depósito se proporciona mediante el argumento lit-Bucketer.
Si el primer argumento es un valor de Distribution, las distribuciones se combinan en un resultado de distribución que incluye la población de todas las distribuciones de entrada. La especificación del bucket de distribución resultante se determina a partir de las especificaciones del depósito de distribución de entrada. Si todas las especificaciones del depósito son iguales, se usa esa especificación de bucket. Si hay una especificación de bucket diferente, se usa una nueva especificación de bucket combinada. Esta especificación combinada suele no ser más precisa que la especificación del bucket de entrada con la misma exactitud.
Si para alguna fila de entrada, la primera expresión de argumento no se evalúa como un valor o se evalúa como un Double no finito, esa fila de entrada no afecta el percentil.
La unidad de medida conectada al resultado de distribution
es la misma que la unidad de la entrada.
count
Recuento de la cantidad de valores en un grupo de valores
Firma: count(
ColumnValue )
→ Int.Delta (temporal only)
count(
ColumnValue )
→ Int.Gauge
Muestra el recuento de la cantidad de valores que se pasaron a él. Si la expresión de argumento no se evalúa como un valor para una fila de entrada o se evalúa como un valor Double no finito, no se cuenta.
El resultado tendrá una serie temporal Delta cuando se realice la agregación temporal no variable.
La unidad de medida conectada al resultado de count
es 1
.
row_count
Cantidad de filas de entrada encontradas
Firma: ImplicitRowSetInput row_count(
)
→ Int.Delta (temporal only)
ImplicitRowSetInput row_count(
)
→ Int.Gauge
La función de agregación row_count
muestra el recuento de la cantidad de filas que se agregan. A diferencia de count
, row_count
no toma un argumento y no le importa si un valor se puede calcular a partir de la fila.
El resultado tendrá una serie temporal Delta cuando se realice la agregación temporal no variable.
La unidad de medida conectada al resultado de count
es 1
.
count_true
Cantidad de valores verdaderos en un grupo de valores booleanos
Firma: count_true(
Bool )
→ Int.Delta (solo temporal)count_true(
Bool )
→ Int.
Se recopilan los valores booleanos de entrada y el resultado es la cantidad de valores de entrada que son verdaderos.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
El resultado tendrá una serie temporal Delta cuando se realice la agregación temporal no variable.
La unidad de medida conectada al resultado de count_true
es 1
.
min
El mínimo de un grupo de valores numéricos
Firma: min(
Num )
→ Num
Esto recopila los valores numéricos que se le pasan y muestra el valor mínimo si el tipo de resultado es el mismo que el tipo de entrada.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de min
es la misma que la unidad de la entrada.
max
El máximo de un grupo de valores numéricos
Firma: max(
Num )
→ Num
Esto recopila los valores numéricos que se le pasan y muestra el valor máximo si el tipo de resultado es el mismo que el tipo de entrada.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de max
es la misma que la unidad de la entrada.
diameter
El máximo menos el mínimo de un grupo de valores numéricos
Firma: diameter(
Num )
→ Num
Esto recopila los valores numéricos que se pasan a este y muestra la diferencia entre el máximo de los valores y el mínimo si el tipo de resultado es el mismo que el tipo de entrada (Int o Double).
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de diameter
es la misma que la unidad de la entrada.
mean
La media de un grupo de valores numéricos
Firma: mean(
Summable )
→ Double
Si la expresión de argumento es numérica (Int o *Double), esta muestra la media de los valores que se pasan a ella.
Si la expresión de argumento es del tipo Distribution, muestra la media de todos los valores en todas las distribuciones.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor Double no finita, esa fila de entrada no afecta la media.
La unidad de medida conectada al resultado de mean
es la misma que la unidad de la entrada.
stddev
La desviación estándar de un grupo de valores
Firma: stddev(
Summable )
→ Double
Si la expresión de argumento es numérica (Int o *Double), esto muestra la desviación estándar de los valores que se le pasan.
Si la expresión de argumento es un valor Distribution, esto muestra la desviación estándar de todos los valores en todas las distribuciones.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor o se evalúa como Double no finito, esa fila de entrada no afecta la desviación estándar.
La unidad de medida conectada al resultado de stddev
es la misma que la unidad de la entrada.
variance
La varianza de un grupo de valores numéricos
Firma: variance(
Summable )
→ Double
Si la expresión del argumento es numérica (Int o *Double), esta muestra la varianza de los valores que se le pasan.
Si la expresión de argumento es del tipo Distribution, esta muestra la variación de todos los valores en todas las distribuciones.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor Double no finita, esa fila de entrada no afecta la varianza.
No hay una unidad de medida conectada al resultado de la función variance
.
covariance
La covarianza de un grupo de valores
Firma: covariance(
Num,
Num )
→ Double
Esta muestra la covarianza de los pares de valores numéricos (Int o *Double) que se le pasan.
Si para alguna fila de entrada, alguna expresión de argumento no se evalúa como un valor o se evalúa como un valor Double no finito, esa fila de entrada no afecta la covarianza.
No hay una unidad de medida conectada al resultado de la función covariance
.
median
La media de un grupo de valores numéricos o de distribución
Firma: median(
Summable )
→ Double
Si la expresión del argumento es numérica (Int o *Double), esto muestra una estimación de la mediana sobre la población de valores que se le pasa. La mediana se calcula mediante la creación de un valor de distribución a partir de los valores de la población con límites de depósito que están separados por un 10%, lo que limita el error en la estimación.
La especificación de bucket que se usa a fin de acumular un valor Distribution a partir de una entrada numérica para una estimación de la media es powers_of(1.05).num_buckets(500).lower(.01)
. Esto incluye un rango de valores de .01
a aproximadamente 4e+8
. Si bien esto controla muchos casos de uso, podría ser necesario usar la función scale
para ajustar la entrada, por ejemplo, de By
a MiBy
o “MBy” si el rango de la cantidad de bytes estará en el rango de gigabytes o terabytes.
Si la expresión del argumento es un valor Distribution, esto muestra una estimación de la media de la propagación combinada de valores de todas las distribuciones. La media se calcula mediante la combinación de todas las distribuciones de entrada en una distribución y la estimación de la media. La precisión de la media dependerá de los límites del depósito de las distribuciones de entrada.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor o se evalúa como Double no finito, esa fila de entrada no afecta la desviación estándar.
La unidad de medida conectada al resultado de median
es la misma que la unidad de la entrada.
percentile
Un percentil de un grupo de valores numéricos o de distribución.
Firma: percentile(
Sumable,
lit-Num )
→ Double
El argumento lit-Num proporciona un percentil (en el rango de 0 a 100).
Si la primera expresión de argumento es numérica (Int o Double), esto muestra una estimación de ese percentil de la población de valores que se le pasan. El percentil se calcula mediante la creación de un valor de distribución a partir de los valores de la población con límites de depósitos que tienen un 10% de diferencia, lo que limita el error en la estimación por esa cantidad.
La especificación de bucket que se usa para acumular un valor Distribution a partir de una entrada numérica a fin de estimar un percentil es powers_of(1.05).num_buckets(500).lower(.01)
. Esto incluye un rango de valores de .01
a aproximadamente 4e+8
. Si bien esto controla muchos casos de uso, podría ser necesario usar la función scale
para ajustar la entrada, por ejemplo, de By
a MiBy
o “MBy” si el rango de la cantidad de bytes estará en el rango de gigabytes o terabytes.
Si la expresión de argumento es Distribution, esto muestra una estimación del percentil de la población combinada de valores de todas las distribuciones. El percentil se calcula mediante la combinación de todas las distribuciones de entrada en una distribución y la estimación del percentil. La precisión de la media dependerá de los límites del bucket de las distribuciones de entrada.
Si para alguna fila de entrada, la primera expresión de argumento no se evalúa como un valor o se evalúa como un Double no finito, esa fila de entrada no afecta el percentil.
La unidad de medida conectada al resultado de percentile
es la misma que la unidad de la entrada.
fraction_less_than
La fracción de un grupo de valores inferior a un valor fijo
Firma: fraction_less_than(
Summable,
lit-Num )
→ Double
Si el primer argumento es un valor numérico (Int o *Double), esto muestra la fracción de la colección de valores pasados al primer argumento que es menor que el argumento lit-Num. En el cálculo de esta fracción, ignora valores no finitos Double y valores not-a-value Int. y Double.
Si el primer argumento es un valor de Distribution, se combinan las poblaciones de todas las distribuciones que se pasan y se hace una estimación de la fracción de los valores en la población de esa distribución agregada que son menores que el valor del argumento lit-Num.
La unidad de medida conectada al resultado de fraction_less_than
es 10^2.%
.
fraction_true
La fracción de un grupo de valores booleanos que son verdaderos
Firma:
fraction_true(
Bool )
→ Double
Se recopilan los valores booleanos de entrada y el resultado es un Double en el rango de 0 a 1, que es la fracción de los valores de entrada que son verdaderos.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de fraction_true
es 10^2.%
.
any_true
La disyunción de un grupo de valores booleanos
Firma: any_true(
Bool )
→ Bool
La función any_true
calcula el valor true
si todos sus valores de entrada son true
y muestra false
en caso contrario.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
all_true
La combinación de un grupo de valores booleanos
Firma: all_true(
Bool )
→ Bool
La función all_true
calcula el valor true
si todos sus valores de entrada son true
y muestra false
en caso contrario.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
pick_any
El valor de cualquier elemento de un grupo de valores (elegido arbitrariamente)
Firma: pick_any(
ColumnValue )
→ FirstArgType
Esta función muestra uno de los valores asignados, elegidos de manera arbitraria.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de pick_any
es la misma que la unidad de la entrada, si existe.
singleton
El valor del elemento de un grupo de valores con un solo elemento
Firma: singleton(
ColumnValue )
→ FirstArgType
Esta función muestra el valor de la expresión del argumento como se evalúa en una sola fila. Es un error si su expresión de argumento se evalúa y produce un valor para más de una fila, incluso si se evalúa como un valor producido con antes.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de singleton
es la misma que la unidad de la entrada.
unique
El valor común de un grupo de valores (que deben ser todos iguales)
Firma:
unique(
Comparable )
→ FirstArgType
La función unique
muestra el valor que es igual a cada valor que se le otorgó. Si no existe ese valor (se le proporcionó al menos dos valores diferentes), genera un error y muestra uno de los valores dados.
Si para alguna fila de entrada, la expresión del argumento no se evalúa como un valor, esa fila de entrada no afecta el resultado.
La unidad de medida conectada al resultado de unique
es la misma que la unidad de la entrada.
aggregate
Valor agregado predeterminado de un grupo de valores de cualquier tipo.
Firma: aggregate(
Num )
→ Num.Delta (solo temporal)aggregate(
Distribution )
→ Distribution.Delta (solo temporal)aggregate(
Num )
→ Num.Gauge (solo temporal)aggregate(
Distribution )
→ Distribution.Gauge (solo temporal no variable)aggregate(
Num )
→ Num.FirstArgKindaggregate(
Distribution )
→ Distribution.FirstArgKindaggregate(
Bool )
→ Boolaggregate(
String )
→ String
La función aggregate
realiza una agregación que depende del tipo de la entrada.
En el caso de las entradas Int y Double, es lo mismo que el agregador
sum
.En el caso de la entrada Distribution, es lo mismo que el agregador
distribution
.En el caso de la entrada Distribution, es lo mismo que el agregador
any_true
.En el caso de la entrada Distribution, es lo mismo que el agregador
pick_any
.
weighted_distribution
Una distribución de un grupo de valores ponderados
Firma: weighted_distribution(
Num,
Int.,
lit-BucketSpecification )
→ Distribution.Delta (solo temporal)weighted_distribution(
Num,
Int.,
lit-BucketSpecification )
→ Distribution.Gauge
Los valores de entrada se recopilan en un resultado de distribución cuya especificación del bucket se proporciona mediante el argumento lit-Bucketer. El primer argumento es el valor que se agregará a la distribución y el segundo argumento es el peso de ese valor. Un valor N
con un peso de M
se representa mediante instancias M
de valor N
en la distribución.
Si en una fila de entrada, la primera o la segunda expresión de argumento no se evalúa como un valor o se evalúa como Double no finito, esa fila de entrada no afecta el percentil.
La unidad de medida conectada al resultado de weighted_distribution
es la misma que la unidad de la entrada.
Alineación
La operación de tabla align
utiliza las funciones de alineación para producir una tabla alineada, una con series temporales que tengan puntos con marcas de tiempo en intervalos regulares.
Además de su argumento Duration explícito, una función de alineador toma una serie temporal de entrada y un punto en el tiempo y produce un punto de salida para ese momento en particular.
La función de alineación interpolate
produce un valor en un momento determinado mediante la interpolación de un valor de dos puntos de entrada adyacentes cuyas marcas de tiempo abarcan la marca de tiempo de salida.
Las funciones de alineación next_older
y next_younger
producen el valor desde el único punto de la serie temporal de entrada cuya marca de tiempo está justo antes o después de la marca de tiempo de salida.
Las funciones de alineador delta
, rate
ydelta_gauge
calculan su resultado según el cambio en el valor de las series temporales de entrada durante el período entre la hora de finalización del punto de salida y el argumento Duration anterior. Ese cambio de valor se calcula de la siguiente manera:
Por lo tanto, el valor de la serie temporal de entrada en cualquier momento puede calcularse por la interpolación lineal entre el punto más cercano antes y el punto más cercano después del tiempo de salida. El cambio de valor en una ventana determinada es la diferencia entre el valor interpolado en el límite anterior de la ventana y el límite posterior.
La cantidad de cambio en la ventana es la suma del valor de todos los puntos cuya extensión se encuentra completamente dentro de la ventana y la proporción prorrateada del valor de la extensión que se superpone parcialmente en la ventana.
Para una serie temporal Cumulative, la interpolación de un valor entre dos puntos adyacentes con la misma hora de inicio se realiza mediante la interpolación lineal entre los dos valores. La interpolación entre dos puntos adyacentes con diferentes horas de inicio (para que la hora de inicio del punto posterior se encuentre entre la hora de finalización de los dos puntos) se maneja de la siguiente manera:
Si el tiempo de salida se encuentra entre la hora de finalización del punto anterior y la hora de inicio del punto posterior, el resultado es el valor del punto anterior (no habrá cambios entre el punto anterior y el tiempo de restablecimiento).
Si el tiempo de salida está entre los puntos de inicio y hora de finalización posteriores, el valor es la interpolación lineal entre cero (a la hora de inicio) y el valor del punto.
Para obtener una serie temporal Acumulativa, el cambio en el valor en un período determinado es la diferencia entre el valor interpolado en el borde anterior del período y el borde posterior, más una corrección para los restablecimientos. Por cada tiempo de restablecimiento que se encuentre dentro del período, se agrega el valor del punto justo antes de ese tiempo de restablecimiento al valor del cambio para considerar que el valor de la serie temporal se restablece a 0 en ese momento.
Las funciones de alineador agregadas,
mean_aligner
,int_mean_aligner
, aplican una función de agregación a los puntos de entrada que se encuentran dentro de un período determinado por el argumento Duration y cuyo borde posterior es la marca de tiempo del punto de salida. El resultado de esa agregación es el valor del punto de salida.La unidad de medida del resultado de una función de alineación suele ser la misma que la de la entrada. Estas son las excepciones:
El resultado de
rate
tiene la unidad de entrada, dividida por la unidad “s”.El resultado de
count_true_aligner
tiene la unidad1
.El resultado de
fraction_true_aligner
tiene la unidad10^2.%
.
rate
Calcula una tasa de cambio en puntos alineados en el tiempo
Firma: ImplicRowInput rate(
[lit-Duration ] )
→ Double.Gauge (entrada de fila implícita)
El alineador rate
opera en series temporales de entrada con una sola columna de valor de tipo numérico (Int o *Double). Produce una tabla de salida con una sola columna de valor de tipo Double y de tipo de serie temporal Gauge.
El alineador rate
calcula el cambio en el valor de las series temporales durante su período (como se describe aquí) y lo divide por el ancho de la ventana en segundos. La ventana se extiende desde el momento del punto de salida al tiempo del parámetro Duration anterior.
El valor predeterminado para el argumento Duration es el período de alineación. A diferencia de la función del alineador “delta”, no es necesario que el período de alineación y el ancho de la ventana coincidan.
delta
Calcula el cambio de valor en puntos alineados en el tiempo
Firma: ImplicRowInput delta(
[duración-lit ] )
→ InputType.Delta (entrada de fila implícita)
El alineador delta
opera en series temporales de entrada con una columna de valor único de tipo Summable (Int, Double o Distribution) y el resultado es una serie temporal cuya columna de valores es del mismo tipo, pero tiene un tipo de serie temporal Delta.
El alineador “delta_gauge” calcula el cambio en el valor de las series temporales de entrada durante el período de salida entre el tiempo de salida y el argumento Duration anterior. La hora de inicio del punto de salida es el argumento Duration anterior a la hora de salida (la hora de finalización del punto).
El alineador delta
tiene el requisito de que su argumento de Duration sea el mismo que el período de alineación con el que se alinea. El valor predeterminado para el argumento Duration es ese período de alineación.
any_true_aligner
Alinea una serie temporal Bool si encuentra algún valor verdadero en una ventana.
Firma: ImplicitRowInput any_true_aligner(
[lit-Duration] )
→ Bool.Gauge (implicit row input)
La función any_true_aligner
opera en una tabla de entrada con una columna de valor único de tipo Bool y produce una tabla de salida con una columna de valor único de tipo Bool y tipo de serie temporal Gauge.
El argumento Duration proporciona el ancho de un período de ventana para cada punto de salida que finaliza a la hora de ese punto de salida. Si no se proporciona el argumento Duration, se establece de forma predeterminada en el período de alineación. El valor de un punto de salida es true
si algún punto de entrada en la ventana es verdadero y es false
en caso contrario.
count_true_aligner
Alinea una serie temporal Bool mediante el conteo de los valores verdaderos en una ventana.
Firma: ImplicitRowInput count_true_aligner(
[lit-Duration] )
→ Int.Gauge (implicit row input)
La función count_true_aligner
opera en una tabla de entrada con una columna de valor único de tipo Bool y produce una tabla de salida con una columna de valor único de tipoInt y tipo de serie temporal Gauge.
El argumento Duration proporciona el ancho de un período de ventana para cada punto de salida que finaliza a la hora de ese punto de salida. Si no se proporciona el argumento Duration, se establece de forma predeterminada en el período de alineación. El valor de un punto de salida es la cantidad de puntos de entrada en la ventana con el valor true
.
delta_gauge
Calcula el cambio en el valor en puntos temporales alineados como una serie temporal de Gauge
Firma: ImplicRowInput delta_gauge(
[duración-lit ] )
→ InputType.Gauge (entrada de fila implícita)
El alineador delta_gauge
opera en series temporales de entrada con una columna de valor único de tipo Summable (Int, Double o Distribution) y el resultado es una serie temporal cuya columna de valor es del mismo tipo, pero tiene un tipo de serie temporal Gauge.
El alineador delta_gauge
calcula el cambio en el valor de la serie temporal de entrada en su período (como se describe aquí). El período se extiende desde el tiempo del punto de salida al parámetro Duration anterior.
El valor predeterminado para el argumento Duration es el período de alineación. A diferencia de la función del alineador “delta”, no es necesario que el período de alineación y el ancho de la ventana coincidan.
fraction_true_aligner
Alinea una serie temporal Bool con la fracción de valores verdaderos en una ventana.
Firma: ImplicRowInput fraction_true_aligner(
[lit-Duration] )
→ Double.Gauge (entrada de fila implícita)
La función fraction_true_aligner
opera en una tabla de entrada con una columna de valor único de tipo Bool y produce una tabla de salida con una columna de valor único de tipo Double y el tipo de serie temporal Gauge.
El argumento Duration proporciona el ancho de un período de ventana para cada punto de salida que finaliza a la hora de ese punto de salida. Si no se proporciona el argumento Duration, se establece de forma predeterminada en el período de alineación. El valor de un punto de salida es la fracción de todos los puntos de entrada en la ventana que tienen el valor true
.
int_mean_aligner
Alinea según la media de los valores Int en una ventana.
Firma: ImplicitRowInput int_mean_aligner(
[lit-Duration] )
→ Int.Gauge (implicit row input)
La función int_mean_aligner
opera en una tabla de entrada con una columna de valor único de tipo Int y del tipo de serie temporal Gauge o Delta. Produce una tabla de salida con una columna de valor único de tipo Int y tipo de serie temporal Gauge.
El argumento Duration proporciona el ancho de un período de ventana para cada punto de salida que finaliza a la hora de ese punto de salida. Si no se proporciona el argumento Duration, se establece de forma predeterminada en el período de alineación. El valor de un punto de salida es la media de los puntos de valor de la tabla de entrada que se encuentran dentro de la ventana anterior, redondeados al valor entero más cercano.
interpolate
Calcula valores interpolados en puntos alineados en el tiempo
Firma: ImplicRowInput interpolate(
[duración-lit ] )
→ InputType.Gauge (entrada de fila implícita)
El alineador interpolate
opera en una tabla de entrada con una columna de valor único de tipo numérico (Int o *Double) y tipo de serie temporal Gauge.
Produce una tabla de salida con una sola columna de valor del mismo tipo y del mismo tipo de serie temporal.
Si el tiempo de salida de la función de alineador interpolate
es el mismo que la hora de finalización de un punto en la serie temporal de entrada, que se usa para el punto de salida. De lo contrario, el alineador interpolate
considera los puntos de entrada cuya hora de finalización son las fechas anteriores y posteriores al tiempo de salida. Si estos puntos están dentro del argumento Duration de cada uno, el valor de salida es la interpolación lineal entre esos puntos en el tiempo de salida. Si no hay ningún punto de entrada anterior al tiempo de salida o ningún punto de entrada posterior al tiempo de salida o si los dos puntos de entrada no están dentro del argumento Duration de cada uno, no se produce ningún valor de salida.
El valor predeterminado para el argumento Duration es el doble del período de alineación.
mean_aligner
Alinea según la media de los valores de una ventana.
Firma: ImplicRowInput mean_aligner(
[lit-Duration ] )
→ Double.Gauge (entrada de fila implícita)
La función mean_aligner
opera en una tabla de entrada con una columna de valor único de tipo numérico (Int o Double) y tipo de serie temporal Gauge o Delta. Produce una tabla de salida con una sola columna de valor de tipo Double y de tipo de serie temporal Gauge.
El argumento Duration proporciona el ancho de un período de ventana para cada punto de salida que finaliza a la hora de ese punto de salida. Si no se proporciona el argumento Duration, se establece de forma predeterminada en el período de alineación. El valor de un punto de salida es la media de los puntos de valor de la tabla de entrada que se encuentran dentro de esta ventana anterior.
next_older
Puntos alineados en el tiempo pasando de un momento a otro posterior.
Firma: ImplicRowInput next_older(
[duración-lit ] )
→ InputType.Gauge (entrada de fila implícita)
El alineador next_older
opera en series temporales con cualquier cantidad de columnas de valores de cualquier tipo, pero todas tienen un tipo de serie temporal Gauge. Produce columnas de salida del mismo tipo y del mismo tipo de serie temporal.
El alineador next_older
crea un punto de salida cuando encuentra el último punto de entrada cuya hora de finalización no es posterior a la hora de salida y la hora de finalización no más es lejana al tiempo de salida que el argumento Duration. Si no existe ese punto de entrada, no se crea ningún punto de salida.
El valor predeterminado para el argumento Duration es el doble del período de alineación.
next_younger
Puntos alineados en el tiempo cuando se pasa de un tiempo anterior a uno más reciente.
Firma: ImplicRowInput next_younger(
[duración-lit ] )
→ InputType.Gauge (entrada de fila implícita)
El alineador next_younger
opera en series temporales con cualquier cantidad de columnas de valores de cualquier tipo, pero todas tienen un tipo de serie temporal Gauge. Produce columnas de salida del mismo tipo y del mismo tipo de serie temporal.
El alineador next_younger
crea un punto de salida cuando encuentra el punto de entrada más conveniente, cuya hora de finalización no es anterior a la hora de salida y cuya hora de finalización no es más lejana del tiempo de salida que el atributo Duration. Si no existe ese punto de entrada, no se crea ningún punto de salida.
El valor predeterminado para el argumento Duration es el doble del período de alineación.
Manipula unidades
Estas funciones cambian las unidades de las expresiones a las que se aplican.
scale
Escala un valor a una unidad de medida diferente.
Firma:
scale(
Num,
[ lit-String ] )
→
Double
scale(
Duration,
[ lit-String ] )
→
Double
scale(
Date,
[ lit-String ] )
→
Double
La función scale
muestra el valor del primer argumento, convertido en doble, si es necesario, y es posible que se escale para que tenga las unidades proporcionadas por el segundo argumento.
Si el segundo argumento no está dado, entonces la función scale
simplemente convierte su primer argumento para duplicar, sin cambiar las unidades, en los casos en que se invoca el ajuste de escala automático como se describe aquí. En ese caso, el segundo argumento se suministra de manera implícita y scale
se comporta como lo hace normalmente con dos argumentos.
El segundo argumento, si se proporciona, debe ser una string de código UCUM válida para la unidad a la que se debe escalar el primer argumento. En este caso, el valor mostrado indica la misma cantidad física que el valor de entrada, pero expresada en las unidades que proporciona el segundo argumento. Para ello, se multiplica el argumento por el factor de escalamiento adecuado.
Por ejemplo, la expresión scale(3 "min", "s")
convertirá el valor 3
con minutos de unidades (min
) en el valor 180
con segundos de unidades (s
). La misma cantidad de tiempo, expresada en unidades diferentes.
Se trata de un error si el primer argumento no tiene ninguna unidad o si la unidad del primer argumento no tiene la misma dimensión que el código de unidad dado como segundo argumento, si se proporciona. Si no tienen la misma dimensión, no es posible escalar el primer argumento para que tenga la dimensión proporcionada por el segundo argumento.
Por ejemplo, es un error decir scale(3 "km", "m/s")
, que solicita escalar 3 kilómetros en una cantidad de metros por segundo, ya que los kilómetros tienen la dimensión “distance” y metros por segundo tienen la dimensión “distancia por tiempo” (velocidad). No existe un factor de escala que pueda convertir la distancia en velocidad. Uno tendría que dividir la distancia por un valor con unidades de tiempo para hacer este trabajo. Por ejemplo, scale(3 "km" / 10
"min", "m/s")
escalará .3 "km/min"
a 5 "m/s"
.
Si el primer argumento es un argumento Date o Duration, el segundo argumento debe darle una unidad de tiempo (por ejemplo, "s"
, "h"
o "wk"
). El valor que se muestra será un valor Double que designa la cantidad de tiempo del valor del primer argumento en las unidades proporcionadas por el segundo argumento. Para un valor Date, será la cantidad de tiempo desde la época de Unix.
Por ejemplo, scale(1m, "s")
dará como resultado un valor de 60.0
con las unidades s
, y scale(d'1970/01/01-01:00:00+00', "h")
generará un valor de 1.0
con las unidades “h” (una hora en la época Unix).
cast_units
Establece la unidad de medida de un valor.
Firma:
cast_units(
Summable,
lit-String )
→
FirstArgType
La función cast_units
muestra el valor sin modificar del primer argumento, pero establece que la unidad de medida para ese valor la proporcione la segunda string de argumento.
La string debe ser una string de código UCUM para la unidad deseada. Se ignorará cualquier unidad que el primer argumento haya tenido antes de aplicar esta función.
Ventana de periódo
Las funciones analíticas periódicas se usan para anotar un argumento Duration real que se pasa a un argumento WindowDuration que especifica un ancho de período usado para seleccionar puntos de entrada en un cálculo periódico. Este argumento se pasa a la operación de tabla group_by
que da como resultado series temporales alineadas. Las funciones window
y sliding
limitan el ancho del período de entrada según el período de alineación de salida.
La función window
indica que el período de alineación y el ancho de la ventana deben ser iguales, lo que hace que las ventanas de punto de entrada no se superpongan.
La función sliding
indica que el período de alineación puede ser más pequeño que el ancho del período, lo que hace que los períodos de entrada se superpongan.
window
Indica una ventana que es igual al período de alineación
Firma: window(
[lit-Duration ] )
→ lit-WindowDuration
El window
anota un argumento Duration real pasado a un argumento WindowDuration que especifica un ancho de ventana usado en un cálculo que produce series temporales alineadas. Requiere que el ancho del período y el período de alineación de salida sean los mismos que los del argumento Duration.
Si no se proporciona el argumento Duration, especifica que el ancho de la ventana es el período de alineación de salida, sin embargo, eso está definido.
Por ejemplo, la operación de tabla |
group_by
window(5m), .mean
produce puntos de salida que son el valor medio de los puntos de entrada que se encuentran dentro de una ventana de 5 m de la hora de finalización de salida. La función window
anota el ancho del período 5m
para requerir que el período de alineación de group_by
también sea 5 minutos. La operación de tabla | group_by window(), .mean
también requiere que el ancho del período sea el mismo que el período de alineación de salida, pero no especifica cuál debe ser.
sliding
Indica una ventana deslizante (superpuesta) en lugar de disjunta
Firma: sliding(
lit-Duration )
→ lit-SlideDuration
El sliding
anota un argumento Duration real pasado a un argumento WindowDuration que especifica un ancho de período usado en un cálculo que produce series temporales alineadas. Requiere que el ancho de la ventana sea el argumento Duration y que el período de alineación no sea mayor (pero permite que sea más pequeño).
Por ejemplo, la operación de tabla |
group_by
sliding(5m), .mean
produce puntos de salida que son el valor medio de los puntos de entrada que se encuentran dentro de una ventana de 5 m de la hora de finalización de salida. La función sliding
que anota el ancho de la ventana 5m
indica que el período de alineación de group_by
no puede ser superior a 5 minutos. Si hay una operación de tabla | every 1m
que indica una alineación de 1 minuto, los 4 minutos de cada período de 5 minutos se superpondrán con el período del punto de salida siguiente más actual.
Distribución
count_from
La cantidad de valores en un valor de distribución
Firma: count_from(
Distributoin.CumulativeOK )
→ Int.FirstArgKind
La función count_from
muestra el tamaño de la población de valores en su valor Distribution de entrada.
La unidad de medida conectada al resultado de count_from
es 1
.
sum_from
La suma de los valores en un valor de distribución
Firma: sum_from(
Distribution.CumulativeOK )
→ Double.FirstArgKind
La función sum_from
muestra la suma de todos los valores contenidos en su valor Distribution de entrada.
El resultado de sum_from
tiene la misma unidad de medida que la entrada.
mean_from
La media de los valores en un valor de distribución
Firma: mean_from(
Distribution )
→ Double
La función mean_from
muestra la media aritmética de todos los valores contenidos en su valor Distribution de entrada.
El resultado de mean_from
tiene la misma unidad de medida que la entrada.
stddev_from
La desviación estándar de los valores en un valor de distribución
Firma: stddev_from(
Distribution )
→ Double
La función stddev_from
muestra la varianza de la población a los valores que contiene en su valor de distribución de entrada.
El resultado de stddev_from
tiene la misma unidad de medida que la entrada.
variance_from
La varianza de los valores en un valor de distribución
Firma: variance_from(
Distribution )
→ Double
La función variance_from
muestra la varianza de la población a los valores que contiene en su valor de distribución de entrada.
El resultado de la función “varianza_from” no tiene una unidad de medida.
median_from
La mediana de los valores en un valor de distribución
Firma: median_from(
Distribution )
→ Double
La función median_from
muestra una estimación de la media de la población de los valores contenidos en su valor de distribución de entrada.
El resultado de median_from
tiene la misma unidad de medida que la entrada.
percentile_from
Un percentil de los valores de un valor de distribución
Firma: percentile_from(
Distribution,
lit-Num )
→ Double
La función percentile_from
muestra una estimación del percentil de la población de los valores contenidos en su valor de distribución de entrada. El argumento Num proporciona el percentil para estimar como un número entre 0 y 100.
El resultado de percentile_from
tiene la misma unidad de medida que la entrada.
fraction_less_than_from
La fracción de valores en una distribución que es menor que un valor fijo
Firma: fraction_less_than_from(
Distribution,
lit-Num )
→ Double
La función fraction_less_than_from
muestra una estimación de la fracción de la población de los valores contenidos en su valor Distribution de entrada que son menores que su argumento Num.
La unidad de medida conectada al resultado de fraction_less_than
es 10^2.%
.
bounded_percentile_from
Un percentil de los valores dentro de un límite en un valor de distribución
Firma: bounded_percentile_from(
Distribution,
lit-Num,
[lit-Num ],
[lit-Num ] )
→ Double
La función bounded_percentile_from
opera en un subconjunto del valor contenido en la distribución de entrada. Se realiza una estimación de la población de valores superiores al segundo parámetro Num, si se proporciona, y menores o iguales que el tercer parámetro Num, si se lo proporciona. Se debe proporcionar al menos uno del segundo o el tercer argumento Num y, si se proporcionan ambos, el segundo debe ser menor que el tercero.
Esto muestra una estimación del percentil de esa propagación estimada de valores. El primer argumento Num proporciona el percentil para estimar como un número entre 0 y 100.
El resultado de bounded_percentile_from
tiene la misma unidad de medida que la entrada.
rebucket
Valor de distribución convertido en una nueva especificación de depósito.
Firma: rebucket(
Distribution,
lit-BucketSpecification )
→ Distribution
Esto convierte el valor de distribución de entrada en un valor de distribución cuya especificación de depósito es la que se proporciona en el segundo argumento BucketSpecification.
Esto distribuye los recuentos de cada bucket en la distribución de entrada a los buckets de distribución de salida en el supuesto de que los valores contados en un depósito se distribuyen de manera uniforme en el rango del depósito. La distribución de salida tiene el mismo recuento total que la distribución de entrada, pero los recuentos se distribuyen de manera diferente en los buckets de distribución de salida. La distribución de salida tiene la misma suma, media y desviación estándar que la distribución de entrada.
Especificador de depósitos
Un valor de distribución tiene un histograma compuesto por buckets. Cada bucket está asociado con un rango de valores y contiene un recuento de los valores en la distribución que pertenecen a ese rango. Cada distribución tiene una especificación de bucket que describe los límites para los buckets en un valor de distribución. Las funciones de esta sección generan definiciones de bucket.
powers_of
Una especificación de depósito con límites de depósito que aumentan exponencialmente
Firma: powers_of(
lit-Num )
→
lit-BucketSpecization
La función powers_of
muestra especificaciones de depósito en las que el límite superior de cada depósito es un factor fijo (proporcionado por el argumento Num) multiplicado por el límite inferior. Por lo tanto, el tamaño del depósito aumenta exponencialmente y el error para calcular los percentiles está limitado por un factor constante del valor verdadero.
Esto no establece la cantidad de depósitos o el límite inferior del primer depósito, que deben especificarse (por “num_buckets” y “menor”) o tomarán los valores predeterminados (30 depósitos, límite inferior de 1.0).
Si powers_of
proporciona la especificación del depósito, el límite inferior debe ser mayor que 0.
En el siguiente ejemplo, se proporciona una especificación de depósito con 50 depósitos cuyo tamaño crece exponencialmente a una velocidad de 1.1, a partir del valor 100. Los límites del depósito son 1, 1.1, 1.21, 1.331, etcétera.
powers_of(1.1).num_buckets(30).lower(100.0)
fixed_width
Una especificación de depósito con depósitos de igual tamaño
Firma: fixed_width(
lit-Num )
→
lit-BucketSpecization
La función fixed_width
muestra especificaciones del bucket en las que el límite superior de cada depósito es un factor fijo (proporcionado por el argumento Num) multiplicado por el límite inferior. Por lo tanto, el tamaño del bucket es fijo.
Esto no establece la cantidad de depósitos o el límite inferior del primer depósito, que deben especificarse (por “num_buckets” y “menor”) o tomarán los valores predeterminados (30 depósitos, límite inferior de 1.0).
En el ejemplo siguiente, se brinda una especificación de depósito con 100 buckets de tamaño 1, con una estrella de 1. Esta es una buena especificación para una distribución de valores de porcentaje.
fixed_width(1).num_buckets(100)
custom
Una especificación de depósito de una lista de límites de depósitos
Firma: custom(
lit-Num… )
→ lit-BucketSpecification
La función custom
muestra una especificación de bucket con límites de bucket especificados de manera explícita. La función toma varios argumentos numéricos que se deben proporcionar en orden creciente. El último límite del primer bucket se proporciona mediante el primer argumento y el último límite del último bucket es el último. Cada argumento intermedio otorga el límite superior del bucket anterior y el límite superior del siguiente bucket.
Esto determina por completo la especificación del bucket, lo que da como resultado la cantidad de buckets y el límite exacto de cada uno.
En el ejemplo siguiente, se proporciona una especificación de depósito con 3 depósitos. El primero tiene el límite 3 y 27, el segundo 27 y 105 y el tercero 105 y 277.
custom(3,27,105,277)
num_buckets
Establece la cantidad de depósitos en una especificación de depósito
Firma:
num_buckets(
lit-BucketSpecification,
lit-Num )
→ lit-BucketSpecification
Cuando se aplica a una especificación de depósito que no tiene el número de depósitos determinado, la función num_buckets
muestra una especificación de depósito con un número de depósitos dado por su argumento Num. Se conservan todos los demás aspectos de la especificación de depósito de entrada.
Sería un error aplicar num_buckets
a una especificación de depósito que ya tenga la cantidad de depósitos determinada.
bounds
Establece el límite inferior del primer depósito y el límite superior del último
Firma: bounds(
lit-BucketSpecification,
lit-Num,
lit-Num )
→ lit-BucketSpecification
Cuando se aplica en una especificación de depósito que no tiene el límite inferior del primer depósito o el límite superior del último depósito determinado, la función bounds
muestra una especificación de depósito con el límite inferior. de su primer depósito dado por su primer argumento Num y el límite superior de su último depósito dado por el segundo argumento Num. Se conservan todos los demás aspectos de la especificación de depósito de entrada.
Es un error aplicar bounds
a una especificación de depósito que ya tiene el límite inferior del primer depósito o límite superior del último depósito determinados.
lower
Establece el límite inferior del primer depósito en una especificación de depósito
Firma:
lower(
lit-BucketSpecification,
lit-Num )
→ lit-BucketSpecification
Cuando se aplica en una especificación de depósito que no tiene el límite inferior del primer depósito determinado, la función num_buckets
muestra una especificación de depósito con el límite inferior de su primer depósito dado por el argumento Num. Se conservan todos los demás aspectos de la especificación de depósito de entrada.
Es un error aplicar lower
a una especificación de bucket que ya tiene el límite inferior del primer bucket determinado.
Varios
cast_double
Convierte el valor Int en Double
Firma: cast_double(
Num.CumulativeOK )
→ Double.FirstArgKind
La función cast_double
toma un único argumento Int y muestra el valor Double más cercano.
El resultado de cast_double
tiene la misma unidad de medida que la entrada.
cast_gauge
Transmite un valor de serie temporal acumulativa o Delta a Gauge.
Firma: cast_gauge(
ColumnValue.CumulativeOK )
→ FirstArgType.Gauge
La función cast_gauge
muestra el valor de su argumento, pero cambian el tipo de serie temporal del valor a Gauge.
Si esto genera una tabla de salida sin columnas de valor que tienen un tipo de serie temporal Delta, la tabla de salida no tendrá una columna de hora de inicio.
El resultado de cast_gauge
tiene la misma unidad de medida que la entrada.
within
Especifica la ventana del cálculo del valor de orden
Firma: within(
ColumnValue,
[lit-DateOrDuration ],
[lit-DateOrDuration ] )
→ Windowed.FirstArgKind
La función within
decora la expresión vinculada al argumento de valor de orden Windowed(Num) de la operación de tabla top
o bottom
. Especifica la ventana en la que se evalúa la expresión de valor de clasificación; para ello, especifica uno o dos de los tres valores: el tiempo más antiguo (de inicio) de la ventana, el tiempo más reciente (final) de la ventana.
Si alguno de los dos argumentos de within
es un Duration positiva, se establece el ancho de la ventana. Como máximo, uno de los argumentos puede ser una Duration.
Si el primer argumento es una Date, eso especifica la hora de inicio.
Si el segundo argumento es una Date, eso especifica la hora de finalización. Si ambos son valores Date, la segunda debe ser posterior a la primera hora. Un argumento Date se puede proporcionar como un literal Date o con un literal Duration negativo. En el último caso, la hora es la Duration especificada antes de la hora de finalización del período de consulta externo (consulta la operación de tabla within
).
Si no se proporciona el primer argumento, el valor predeterminado es la hora de inicio de la ventana de consulta externa. Si no se proporciona un segundo argumento, el valor predeterminado es la hora de finalización de la ventana de consulta externa.
Por ejemplo, .mean().within(1h,-2h)
indica que el reductor max
debe aplicarse a todos los puntos en la serie temporal de entrada cuya hora de finalización está dentro de una ventana de 1 hora de ancho y termina en 2 horas.
El agregador mean
se aplica a todos los puntos de entrada cuyo tiempo de finalización está en esta ventana.
Por ejemplo, max(val()).within(10m)
indica que el reductor max
debe aplicarse a todas en las series temporales de entrada cuya hora de finalización se encuentre dentro del intervalo de tiempo entre la hora de finalización de la consulta y 10 minutos antes.
El agregador max
se aplica a todos los puntos de entrada cuyo tiempo de finalización está en esta ventana.
Índice de operaciones y funciones de tablas
Un índice para todas las operaciones y funciones de tabla.
abs
Valor absolutoabsent_for
Crea una condición para la ausencia de la entrada.add
La suma de dos númerosadjacent_delta
El cambio en el valor entre un punto de entrada y el punto siguiente más antiguo.adjacent_rate
La velocidad de cambio entre la entrada y los siguientes puntos más antiguos (filas).aggregate
Valor agregado predeterminado de un grupo de valores de cualquier tipoalign
Produce una tabla alineada mediante una función de alineación.all_true
La combinación de un grupo de valores booleanosand
El valor lógico y de dos valores booleanosany_true
La disyunción de un grupo de valores booleanosany_true_aligner
Para alinear una serie temporal Bool, encuentra un valor verdadero en una ventanaascii_to_lower
Cambia los caracteres ASCII a minúsculasascii_to_upper
Cambia los caracteres de las letras ASCII a mayúsculasbottom
Selecciona la serie temporal inferior por una expresión de valor de clasificaciónbottom_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.bounded_percentile_from
Un percentil de los valores dentro de un límite en un valor de distribuciónbounds
Establece el límite inferior del primer depósito y el límite superior del últimocast_double
Convierte el valor Int en Doublecast_gauge
Transmite un valor de serie temporal acumulado o delta a Indicadorcast_units
Establece la unidad de medida de un valor.concatenate
Concatenación de stringcondition
Agrega una columna de condición booleana a la tabla de entradacount
Recuento de la cantidad de valores en un grupo de valorescount_from
La cantidad de valores en un valor de distribucióncount_true
La cantidad de valores verdaderos en un grupo de valores booleanoscount_true_aligner
Alinea una serie temporal Bool cuando cuenta los valores verdaderos en una ventanacovariance
La covarianza de un grupo de valorescustom
Una especificación de depósito de una lista de límites de depósitosdelta
Calcula el cambio de valor en puntos alineados en el tiempodelta_gauge
Calcula el cambio en el valor en puntos temporales alineados como una serie temporal de Indicadordiameter
El máximo menos el mínimo de un grupo de valores numéricosdistribution
Una distribución de un grupo de valores numéricos o de distribucióndiv
La proporción de dos númerosend
La hora de finalización del punto de entrada (fila)eq
Igualevery
Especifica el período para el resultado de la tabla alineada.exp
e elevado a una potencia.false
El valor booleano es falsofetch
Genera una tabla a partir de la base de datos.fetch_cumulative
Produce una tabla de series temporales acumulativas a partir de la base de datos.filter
Filtra las filas de una tabla de entrada según un predicado.filter_ratio
Calcula la proporción de dos sumas filtradas de la columna de valores de entrada.filter_ratio_by
Calcula una proporción agrupada de dos sumas filtradas de la columna de valores de entrada.fixed_width
Una especificación de depósito con depósitos de igual tamañofraction_less_than
La fracción de un grupo de valores inferior a un valor fijofraction_less_than_from
La fracción de valores en una distribución que es menor que un valor fijofraction_true
La fracción de un grupo de valores booleanos que son verdaderosfraction_true_aligner
Alinea una serie temporal Bool con la fracción de valores verdaderos en una ventanage
Superior o igual.graph_period
Especifica el período de salida preferido para dibujar gráficos de serie temporal.group_by
Agrega filas según un identificador de serie temporal asignado y un período.gt
Mayor quehas
Verdadero si un argumento de conjunto contiene un valor particularhas_value
Verdadero si una expresión de argumento calcula un valorhash_tsid
Muestra un hash de las columnas de identificador de serie temporal.ident
Operación de tabla de identidad: sin cambios en la tabla de entrada.if
Un valor se elige condicionalmente entre dos valores.int_ceil
Número entero de límite superiorint_div
El cociente de la división de dos números enterosint_floor
Número entero vinculado inferiorint_mean_aligner
Para alinear, busca la media de los valores Int en una ventanaint_round
Número entero más cercanointerpolate
Calcula valores interpolados en puntos alineados en el tiempojoin
Unión natural de varias tablas.le
Menos o igual quelog
Algoritmo naturallower
Establece el límite inferior del primer depósito en una especificación de depósitolt
Menor quemap
Vuelve a escribir el identificador de serie temporal y las columnas de valor de cada fila en una tablamax
El máximo de un grupo de valores numéricosmean
La media de un grupo de valores numéricosmean_aligner
Alinea mediante la búsqueda de la media de los valores en una ventanamean_from
La media de los valores en un valor de distribuciónmedian
La mediana de un grupo de valores numéricos o de distribuciónmedian_from
La mediana de los valores en un valor de distribuciónmetric
Produce la tabla para un tipo de métrica específico a partir de un conjunto de tablas.min
El mínimo de un grupo de valores numéricosmul
El producto de dos númerosne
No igualneg
Negativo de un númeronext_older
Puntos alineados en el tiempo cuando se pasa de un tiempo anterior a otro posterior.next_younger
Puntos temporales alineados en el tiempo cuando se pasa de un tiempo posterior a otro anterior.not
La negación lógica de un valor booleanonum_buckets
Establece la cantidad de depósitos en una especificación de depósitoolder
Un valor del siguiente punto más antiguo (fila) de una serie temporal.or
El valor lógico o de dos valores booleanosor_else
Un valor o, si no es un valor, otro valor.outer_join
Unión natural externa de dos tablas.percentile
Un percentil de un grupo de valores numéricos o de distribuciónpercentile_from
Es un percentil de los valores de un valor de distribuciónpick_any
El valor de cualquier elemento de un grupo de valores (elegido arbitrariamente)pos
Identidad para entradas numéricaspower
Un número al poder de otropowers_of
Una especificación de depósito con límites de depósito que aumentan exponencialmenterate
Calcula una tasa de cambio en puntos alineados en el tiemporatio
Calcula la proporción de las columnas de valor de dos tablas de entrada alineadas.re_extract
Extrae valores que coincidan con una expresión regular en otra stringre_full_match
Verdadero si una expresión regular coincide con el valor completo de una stringre_global_replace
Reemplaza todas las coincidencias de una expresión regular en otra stringre_partial_match
Verdadero si una expresión regular coincide con alguna parte del valor de la string.re_replace
Reemplaza la primera coincidencia de una expresión regular en otra stringrebucket
Valor de distribución convertido en una especificación de depósito nueva.rem
El resto de la división de dos números enterosrow_count
La cantidad de filas de entrada encontradasscale
Escala un valor a una unidad de medida diferente.singleton
El valor del elemento de un grupo de valores con un solo elementosliding
Indica una ventana deslizante (superpuesta) en lugar de disjuntasqrt
Raíz cuadradastart
La hora de inicio del punto de entrada (fila).stddev
La desviación estándar de un grupo de valoresstddev_from
La desviación estándar de los valores en un valor de distribuciónstring_to_double
Convierte String en Doublestring_to_int64
Convierte String en Intsub
La diferencia de dos númerossum
La suma de un grupo de valores numéricossum_from
La suma de los valores en un valor de distribucióntime_shift
Cambia las series temporales en el tiempotop
Selecciona las series temporales principales según una expresión de valor de clasificación.top_by
Selecciona series temporales según una expresión de valor de clasificación en diferentes grupos.true
El valor booleano es verdadero.unaligned_group_by
Agrega filas según un identificador de serie temporal sin alineación.union
Unión de varias tablasunion_group_by
Agrega filas desde varias tablas.unique
El valor común de un grupo de valores (que deben ser todos iguales)utf8_normalize
String Unicode adecuada para la comparación de mayúsculas y minúsculas.val
El valor de una columna de valores en el punto de entrada (fila).value
Vuelve a escribir las columnas de valores de cada fila en una tablavariance
La varianza de un grupo de valores numéricosvariance_from
La varianza de los valores en un valor de distribuciónweighted_distribution
Una distribución de un grupo de valores ponderadoswindow
Indica una ventana que es igual al período de alineaciónwindow
Especifica la ventana para las operaciones de alineaciónwithin
Especifica la ventana del cálculo del valor de ordenwithin
Especifica el intervalo de tiempo del resultado de la consulta