Referencia de lenguaje de consulta de supervisión

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 llamada cloudsql.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étrica appengine.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 etiquetas project_id, instance_id y zone 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étrica appengine.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étrica appengine.googleapis.com/memcache/operation_count tiene una columna de valores llamada operation_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 o By 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ón start(). (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 un base_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 rR, 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 un ID 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 de basic_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 de grouped_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 de grouped_table_op.

  • Un shortcut_table_op es una notación de acceso directo (descrita aquí) para una basic_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 de query en la grouped_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 cada query en una grouped_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. Un map contiene uno o más expr 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) y val(). 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ón sum 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 ejemplo 33 'By' para 33 bytes.

    • Una string está compuesta por uno o más tokens STRING 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 la expr.

  • 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 con expr en la siguiente arg_list.

    Por ejemplo, add(error_count, 1) aplica la función add a dos argumentos: column_meta_name error_count y literal 1. Esto sería equivalente a error_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 la call tiene una arg_list, el arg_list proporciona argumentos adicionales.

    Por ejemplo, .div aplicado a una tabla con columnas de valores num y den sería equivalente a div(num, den) o solo num / den. La expresión .add(3) aplicada a una tabla con una columna de valor único count sería equivalente a add(count, 3) o solo a count + 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 la call tiene una arg_list, el arg_list proporciona argumentos adicionales.

    Por ejemplo, .mul(3).div(4) aplicada a una tabla con una columna de valor único error_count sería equivalente a div(.mul(3), 4), que es equivalente a div(mul(error_count, 3), 4), que es equivalente a error_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 un maplet en el map. El nombre de la columna se proporciona de forma explícita mediante un ID o unaQUOTED_COLUMN, o bien deriva de la forma de la expr. El valor de la columna en la fila de salida es el valor de la expr.

    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 valor map a una tabla con columnas de valores num y den daría como resultado una tabla de salida con la columna de valor ratio, en el que el valor de la columna ratio es la proporción de las dos columnas de entrada.

    Aplicar [zone] como un identificador de serie temporal map a una tabla con columnas de identificadores de series temporales project_id, zone y instance daría como resultado una tabla con solo una columna de identificador de serie temporal zone cuyo valor es el mismo que el de la columna de tabla de entrada zone.

  • 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 cada maplet en el map, hay una columna de salida adicional cuyo nombre y valor se proporcionan mediante el maplet.

    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 valor map a una tabla con las columnas de valor num y den, obtendrás una tabla de salida con las columnas de valor num, den y ratio, donde el valor de la columna ratio 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 un maplet del map se incluyen en la fila de salida. Además, para cada maplet en el map, hay una columna de salida adicional cuyo nombre y valor se proporcionan mediante el maplet.

    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, y zone, generaría una tabla de salida con columnas de identificadores de series temporales user, job, zone, y kind.

  • drop Cada maplet debe constar de una expr 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 una expr en el maplet.

    Cada maplet no debe tener un column_name y la expr solo debe nombrar una columna del tipo correspondiente en la tabla de entrada.

    Por ejemplo, aplicar drop [job, user] como un identificador de series temporales map a una tabla con columnas de identificador de series temporales user, job y zone daría como resultado una tabla de salida con la columna de identificador de series temporales zone.

  • ignore cada maplet debe constar de una expr 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 columna maplet no nombra una columna de tabla de entrada del tipo correspondiente, ese maplet 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 una expr en el maplet.

    Cada maplet no debe tener un column_name, y la expr debe ser solo un nombre de columna, pero no es necesario que sea el nombre de una columna en la tabla de entrada. Si el maplet 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 temporal map a una tabla con columnas de identificadores de serie temporal user, job y zone daría como resultado una tabla de salida con identificador de serie temporal columnas user y zone (con el maplet instance ignorado).

  • rename Cada maplet debe tener un column_name explícito y una expr 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 un maplet con un nombre nuevo proporcionado por column_name en el maplet.

    El column_name en cada maplet 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 valor map a una tabla de entrada con columnas de valores num , den y ratio daría como resultado una tabla de salida con columnas de valores numerator , denominator y ratio.

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 y metric 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 esa expr 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 un expr 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 unidad By y time tiene la unidad s, entonces amount / time tiene la unidad By/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 y cast_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, para expr ev con la unidad "KiBy" (kibi-bytes), scale(ev, "By") dará como resultado la multiplicación de ev por 1,024 y le dará la unidad de resultado By. Es equivalente a ev * 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 de ev, sin cambios, pero con la unidad By/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 ./. 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 y By 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ásica s 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 cada component 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 y or_else) , uno de los argumentos puede ser una llamada en la función scale 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ón scale, el segundo argumento de la función scale 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. Si cache_size tiene la unidad By y heap_size tiene la unidad MiBy, la expresión scale(cache_size) + heap_size es equivalente a la expresión scale(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ón cache_size < 3 "KiBy" es equivalente a la expresión cache_size < 3072 "By". Ten en cuenta que esto no es lo mismo que cache_size < scale(3 "KiBy", "By") sicache_size es el tipo Int, porque scale 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 de div, 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 usar scale, 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 1m60000ms. 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'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 elementos arg que siguen (que son todos de forma expr). 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 para value [.add(3)]| 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 el map 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 para resource, metric o fetch según qué tipo de operación nombra table_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 tabla filter.

    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 tabla group_by. Debe estar seguida de un arg que sea un map 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 tabla group_by. Debe estar seguida de un arg que sea un map 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 siga arg. Se convierte en una operación de tabla for, 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 o bottom.
  • WindowDuration Una Duration , posiblemente anotada por window o sliding.
  • 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 el map debe constar solo de una expr que nombre una columna (ID o column_name). Por ejemplo, [zone, name] hace que las columnas de salida consten solo de las columnas de identificador de serie temporal de entrada zone y name, 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 o bottom).

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ón
    • top_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 tabla
    • time_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 consulta
    • graph_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
    • conditionAgrega una columna de condición booleana a la tabla de entrada
    • absent_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 tabla align.

  • 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 tabla align 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ón window() 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, que map 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 y max. 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 y max. 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 tabla window.

  • 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 booleano
    • and El valor lógico y de dos valores booleanos
    • or El valor lógico o de dos valores booleanos
    • true El valor booleano es verdadero.
    • false El valor booleano es falso
    • has Verdadero si un argumento de conjunto contiene un valor particular
    • has_value Verdadero si una expresión de argumento calcula un valor
    • if Un valor se elige condicionalmente entre dos valores.
    • or_else Un valor o, si no es un valor, otro valor.
  • Comparison
    • eq Igual
    • ne No igual
    • ge Superior o igual a
    • gt Mayor que
    • le Menos o igual que
    • lt Menor que
  • Aritmética
    • add La suma de dos números
    • sub La diferencia de dos números
    • mul El producto de dos números
    • div La proporción de dos números
    • int_div El cociente de la división de dos números enteros
    • abs Valor absoluto
    • neg Negativo de un número
    • pos Identidad para entradas numéricas
    • rem El resto de la división de dos números enteros
  • Math
    • sqrt Raíz cuadrada
    • log Algoritmo natural
    • exp e elevado a una potencia.
    • power Un número al poder de otro
    • int_round Número entero más cercano
    • int_floor Número entero vinculado inferior
    • int_ceil Número entero de límite superior
  • Sting
  • Expresiones regulares
    • re_full_match Verdadero si una expresión regular coincide con el valor completo de una string
    • re_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 string
    • re_replace Reemplaza la primera coincidencia de una expresión regular en otra string
    • re_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éricos
    • distribution Una distribución de un grupo de valores numéricos o de distribución
    • count Recuento de la cantidad de valores en un grupo de valores
    • row_count La cantidad de filas de entrada encontradas
    • count_true La cantidad de valores verdaderos en un grupo de valores booleanos
    • min El mínimo de un grupo de valores numéricos
    • max El máximo de un grupo de valores numéricos
    • diameter El máximo menos el mínimo de un grupo de valores numéricos
    • mean La media de un grupo de valores numéricos
    • stddev La desviación estándar de un grupo de valores
    • variance La varianza de un grupo de valores numéricos
    • covariance La covarianza de un grupo de valores
    • median La mediana de un grupo de valores numéricos o de distribución
    • percentile   Un percentil de un grupo de valores numéricos o de distribución
    • fraction_less_than La fracción de un grupo de valores inferior a un valor fijo
    • fraction_true La fracción de un grupo de valores booleanos que son verdaderos
    • any_true La disyunción de un grupo de valores booleanos
    • all_true La combinación de un grupo de valores booleanos
    • pick_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 elemento
    • unique 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 tipo
    • weighted_distribution Una distribución de un grupo de valores ponderados
  • Alineación
    • rate Calcula una tasa de cambio en puntos alineados en el tiempo
    • delta Calcula el cambio de valor en puntos alineados en el tiempo
    • any_true_aligner Para alinear una serie temporal Bool, encuentra un valor verdadero en una ventana
    • count_true_aligner Alinea una serie temporal Bool cuando cuenta los valores verdaderos en una ventana
    • delta_gauge Calcula el cambio en el valor en puntos temporales alineados como una serie temporal de Indicador
    • fraction_true_aligner Alinea una serie temporal Bool con la fracción de valores verdaderos en una ventana
    • int_mean_aligner Para alinear, busca la media de los valores Int en una ventana
    • interpolate Calcula valores interpolados en puntos alineados en el tiempo
    • mean_aligner Alinea mediante la búsqueda de la media de los valores en una ventana
    • next_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
    • window Indica una ventana que es igual al período de alineación
    • sliding Indica una ventana deslizante (superpuesta) en lugar de disjunta
  • Distribución
    • count_from La cantidad de valores en un valor de distribución
    • sum_from La suma de los valores en un valor de distribución
    • mean_from La media de los valores en un valor de distribución
    • stddev_from La desviación estándar de los valores en un valor de distribución
    • variance_from La varianza de los valores en un valor de distribución
    • median_from La mediana de los valores en un valor de distribución
    • percentile_from Es un percentil de los valores de un valor de distribución
    • fraction_less_than_from La fracción de valores en una distribución que es menor que un valor fijo
    • bounded_percentile_from Un percentil de los valores dentro de un límite en un valor de distribución
    • rebucket 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 exponencialmente
    • fixed_width Una especificación de depósito con depósitos de igual tamaño
    • custom Una especificación de depósito de una lista de límites de depósitos
    • num_buckets Establece la cantidad de depósitos en una especificación de depósito
    • bounds Establece el límite inferior del primer depósito y el límite superior del último
    • lower Establece el límite inferior del primer depósito en una especificación de depósito
  • Varios
    • cast_double Convierte el valor Int en Double
    • cast_gauge Transmite un valor de serie temporal acumulado o delta a Indicador
    • within 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.FirstArgKind
older(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.

eqIgual


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.

neNo 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.

gtSuperior 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.

ltMenor 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.

absValor 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 y row_count cuyos resultados tienen la unidad 1.

  • variance cuyo resultado es el cuadrado de entrada.

  • covariance cuyo resultado es el producto de las unidades de las dos entradas.

  • fraction_less_than y fraction_true dan su resultado a la unidad 10^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.FirstArgKind
sum(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.

aggregateValor 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.FirstArgKind
aggregate(Distribution )Distribution.FirstArgKind
aggregate(Bool )Bool
aggregate(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 unidad 1.

    • El resultado de fraction_true_aligner tiene la unidad 10^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