Referência da linguagem de consulta do Monitoring

Este é um manual de referência para a linguagem de consulta do Monitoring do Cloud Monitoring. Ele abrange os seguintes tópicos:

  • O modelo de dados subjacente ao banco de dados de série temporal que a linguagem de consulta do Monitoring acessa.

  • A estrutura e a semântica das consultas.

  • Uma descrição de cada uma das operações e funções a partir das quais uma consulta é criada.

Modelo de dados

O Cloud Monitoring usa um banco de dados de série temporal que contém todas as medições que ele processou sobre cada item monitorado (conhecido como recurso monitorado). Descreve a estrutura lógica desse banco de dados.

O elemento fundamental é uma série temporal com dados que consistem em observações do recurso monitorado.

A série temporal no banco de dados é organizada de maneira lógica em tabelas relacionais, cada uma contendo séries temporais com significados e estruturas em comum. As tabelas são referenciadas por consultas que retornam dados, geram gráficos e calculam alertas.

O banco de dados também inclui metadados, que estão mudando lentamente os valores associados a um recurso monitorado e definidos pela configuração do usuário ou pelo serviço que implementa o tipo de recurso monitorado.

Série temporal

Uma série temporal é uma sequência nomeada de pontos, cada um sendo um valor medido e o tempo ao qual o valor se aplica. Uma série temporal consiste em três partes: um tipo, que especifica a estrutura da série temporal, um identificador, que nomeia exclusivamente a série temporal e um histórico, que contém os dados da série temporal. Cada uma dessas três partes é explicada nesta seção.

Um tipo de série temporal especifica a estrutura do identificador de série temporal e o histórico da série temporal. Ele consiste em duas partes:

  • A tipo de recurso monitorado (listado aqui) que nomeie um tipo específico de recurso monitorado, como uma instância do Compute Engine (gce_instance) ou um banco de dados do Cloud SQL (cloudsql_database). Ele tem um conjunto de descritores de rótulo que identificam exclusivamente uma instância desse tipo de recurso monitorado.

  • Um tipo de métrica (listado aqui) que descreve um tipo específico de medição que pode ser realizada em um recurso monitorado, por exemplo, bytes lidos do disco por uma instância do Compute Engine é medida pela métrica chamada compute.googleapis.com/instance/disk/read_bytes_count, e a utilização de dados de um banco de dados do Cloud SQL é medida pela métrica chamada cloudsql.googleapis.com/database/disk/bytes_used. O tipo de métrica especifica o tipo de valor da medida, as unidades da medida e o tipo de série temporal. Ele pode especificar descritores de rótulos que diferenciem séries temporais que medem diferentes aspectos da mesma coisa. Por exemplo, command que indica qual comando é contado na métrica appengine.googleapis.com/memcache/operation_count.

Observe que um tipo de recurso monitorado e um tipo de métrica são descritos por um MonitoredResourceDescriptor e um MetricDescriptor, respectivamente. Eles descrevem os tipos. Cada um deles contém um campo chamado type, que contém o nome desse recurso monitorado ou tipo de métrica.

Um identificador de série temporal é o nome da série temporal, identificando-a exclusivamente entre todas as séries temporais com o mesmo tipo. Ele consiste em um conjunto de valores, um para cada um dos descritores de rótulo especificados nos tipos de recurso monitorado e métrica que compõem o tipo de série temporal.

  • Os rótulos do tipo de recurso monitorado identificam exclusivamente a instância específica do tipo de recurso monitorado de onde as medições da série temporal foram tiradas. Por exemplo, o recurso monitorado gce_instance tem rótulos project_id, instance_id e zone que identificam exclusivamente uma máquina virtual do Google Compute Engine.

  • Cada rótulo do tipo de métrica identifica qual tipo específico de medida para a métrica especificada é representado na série temporal. Por exemplo, status que indica o status dos comandos contados na métrica appengine.googleapis.com/memcache/operation_count pode ter o valor 'HIT' para uma série temporal que conta ocorrências e 'MISS' para outra série temporal que conta erros.

Um histórico de série temporal é uma sequência ordenada por tempo de pontos, cada um representando uma medição simultânea de um ou vários valores (para exemplo, carga da CPU ou temperatura e umidade) em algum momento ou em um intervalo de tempo. Um ponto tem dois elementos:

  • A extensão de um ponto consiste em um horário de término, que está sempre presente, e um horário de início que pode ou não estar presente. Se o horário de início não estiver presente, a extensão do ponto será um único horário no horário de término. Se o horário de início for especificado, ele precisará ser anterior ao horário de término, e a extensão do ponto será o intervalo de tempo que começa no horário de início e termina no horário de término.

    Dois pontos em uma série temporal não podem ter a mesma extensão. Além disso, as extensões dos pontos em uma série temporal são limitadas pelo tipo de série temporal fornecido pelo tipo de métrica, conforme descrito abaixo.

  • O valor de um ponto representa uma medição simultânea de um ou, possivelmente, vários valores (por exemplo, carga da CPU ou temperatura e umidade) que se aplicam ao tempo fornecido pela extensão do ponto. O tipo de métrica descreve cada valor de avaliação, fornecendo um nome e um tipo de valor para cada um. Se houver vários valores de avaliação, eles estarão em uma ordem específica e poderão ser referenciados pelo índice nessa ordem.

    Uma série temporal típica armazenada no banco de dados de séries temporais tem um único valor em cada ponto. O nome da métrica no tipo de série temporal é um URI, e o nome do valor único é a parte do nome da métrica após o último /. Por exemplo, a métrica appengine.googleapis.com/memcache/operation_count tem uma coluna de valor chamada operation_count.

    Uma série temporal que é a saída de uma consulta pode ter vários pontos com tipo, nome e ordem fornecidos pela consulta.

    O tipo de métrica também pode especificar unidades de medida para o valor da série temporal se for do tipo Int, Double ou Distribution. As unidades são fornecidas usando um subconjunto do Código unificado para unidades de medida (em inglês). Por exemplo, ms para milissegundos ou By para bytes. Consulte Unidades de medida para mais detalhes.

Cada valor em um ponto tem um tipo de valor específico, que é especificado pelo tipo de métrica no tipo de série temporal. Além disso, cada rótulo no identificador de série temporal tem um tipo de valor, fornecido pelo descritor de rótulo no recurso monitorado ou no tipo de métrica. Os tipos de valor são os seguintes.

  • Int: um número inteiro assinado de 64 bits.

  • String: uma string Unicode codificada em UTF-8.

  • Bool: um valor booleano.

  • Double: um valor de ponto flutuante IEEE de 64 bits.

  • Distribution: um valor complexo contendo um histograma e estatísticas que fornecem uma descrição resumida de uma população (conjunto) dos valores Double. As partes desse valor são as seguintes:

    • Uma contagem do número de valores na população.
    • A soma dos valores na população.
    • a soma do desvio ao quadrado dos valores na população
    • Uma especificação de bucket que indica os limites entre buckets no histograma. Um bucket contém uma contagem dos valores que se enquadram entre os limites inferior e superior do bucket.
    • Um histograma que fornece o número de valores que se enquadram em cada bucket.

    Essas partes são suficientes para calcular adicionalmente a média, variância, desvio padrão e estimativas de percentis da população.

O tipo de valor de um ponto pode ser qualquer um dos itens acima. Um tipo de rótulo de identificador de série temporal só pode ser String, Int ou Bool

Além desses tipos, há dois outros tipos que estão no horário de início e término de um ponto ou são usados para descrever tempos e durações em consultas.

  • Date: um determinado ponto no tempo medido como a distância desde o início da era Unix. É uma representação independente de fuso horário de um ponto no tempo. Os horários de início e término de um ponto são desse tipo.

  • Duration: um período. Esse período não tem uma unidade de medida específica (mesmo que a resolução seja para o nível de microssegundos), mas assume uma unidade específica (por exemplo, segundos) quando convertido em um Int ou Double.

O conjunto de valores para cada tipo (exceto Date e Duration) inclui um valor chamado nenhum valor, que indica que não há um valor específico. Isso é usado em dois casos:

  • Quando nenhum valor específico é conhecido, por exemplo, quando há um erro (como a divisão por 0) que impede o cálculo de um valor.

  • "Nenhum valor" será o valor de um rótulo em um identificador de série temporal quando o rótulo for exigido pelo tipo de série temporal, mas nenhum valor for conhecido por ele. Isso pode acontecer quando nenhum valor é conhecido quando a métrica é coletada ou se a série temporal foi gerada por uma consulta e o cálculo que gerou o valor do rótulo não produziu um valor. Observe que "nenhum valor" é um valor distinto e, portanto, distingue o identificador de série temporal de qualquer outro que tenha um valor real para o rótulo fornecido.

"Nenhum valor" é diferente de um IEEE NaN e de um valor de string vazio. Não é possível que algum valor em um ponto seja "nenhum valor".

O tipo de série temporal descreve o significado dos valores dos pontos em uma série temporal e restringe as extensões de cada ponto. Existem três tipos de série temporal:

  • Gauge: o valor de um ponto em uma série temporal Gauge é uma medida feita no horário de término do ponto. Um ponto em um stream Gauge não tem um horário de início, portanto, sua extensão é um único ponto no tempo. O valor de um ponto pode representar uma das seguintes coisas:

    • Uma amostra de alguma variável (como o comprimento de uma fila ou uma quantidade de memória em uso).

    • Uma qualidade de estado que é verdadeira no momento do ponto e permanecerá verdadeira até o momento do próximo ponto.

    • Um resumo de alguma quantidade (média, máx. etc.) que se aplica ao período entre o ponto e o próximo ponto anterior da série temporal.

  • Delta:   para valores numéricos (Int ou Double), cada ponto representa a alteração em algum valor medido sobre a extensão do ponto, ou seja, entre o horário de início do ponto, se houver, e o horário de término. Para o valor de Distribution, ele tem uma população dos valores numéricos que surgiram durante a extensão do ponto. Um tipo de série temporal Delta precisa ter um tipo de valor Int, Double ou Distribution.

    Para uma série temporal Delta, as extensões de dois pontos não podem se sobrepor. Portanto, cada ponto representa uma alteração independente no valor medido (numérico) ou na população separada de valores (Distribution). O ideal é que a extensão de cada ponto comece imediatamente após a extensão do próximo ponto anterior. Portanto, a série temporal é uma descrição completa do intervalo de tempo que abrange.

  • Cumulative: esse tipo de série pode ser considerado uma série temporal do tipo Delta com extensões sobrepostas. A restrição é que, se dois pontos tiverem extensões sobrepostas, eles precisarão ter o mesmo horário de início. Assim, cada ponto representa um aumento cumulativo em algum valor medido no último ponto com um horário de início comum.

    As métricas do tipo do Cumulative são uma maneira sólida de coletar séries temporais de uma fonte de dados externa:

    • A fonte não é necessária para redefinir contadores ou acumuladores cada vez que um valor é coletado, e pode ser facilmente monitorada em vários períodos.

    • As contagens acumuladas não serão perdidas se alguns pontos faltarem. O ponto seguinte tem todas as contagens desde o horário de início, incluindo aquelas que estariam no ponto que falta. Apenas a resolução temporal é perdida.

    No entanto, nas consultas, as séries temporais cumulativas não são observadas com frequência. Para tornar as operações em séries temporais retornadas de consultas mais simples, quando uma série temporal cumulativa é buscada, ela é convertida automaticamente em uma série temporal delta, fazendo com que cada ponto comece no momento do próximo ponto anterior e tornando o valor a alteração desde o próximo ponto mais anterior. Isso não altera as informações presentes, mas torna cada ponto independente dos outros. Isso pode ser substituído por fetch_cumulative.

    Para uma série temporal com pontos que têm mais de um valor, cada valor tem um tipo de série temporal que só pode ser Gauge ou Delta. Se algum valor tiver o tipo Delta, a métrica geral terá o tipo Delta (e, portanto, cada ponto terá um horário de início e de término). Caso contrário, a métrica terá o tipo Gauge (e apenas o horário de término).

Tabelas

Todas as séries temporais com o mesmo tipo de série temporal (tipo de recurso monitorado e tipo de métrica) são organizadas logicamente em uma tabela relacional. A tabela tem um nome de tabela que consiste no nome do tipo de recurso monitorado seguido pelo nome do tipo de métrica.

Uma tabela tem uma linha para cada ponto em cada uma das séries temporais incluídas nela. A tabela tem os tipos de colunas a seguir:

  • Colunas de identificador de série temporal, uma coluna para cada rótulo de identificador de série temporal, conforme especificado pelos tipos de métrica e recurso monitorado. O nome da coluna é o nome do rótulo (a chave) e o tipo da coluna é o tipo de valor do rótulo. Se um rótulo de recurso monitorado e um rótulo de métrica tiverem o mesmo nome, o nome da coluna do rótulo de métrica terá metric. anexado a ele.

    Uma série temporal é composta por todas as linhas em uma tabela com o mesmo valor para cada uma das colunas correspondentes do identificador de série temporal.

  • Coluna(s) Time, derivada da extensão dos pontos na série temporal. Sempre há uma coluna de horário de término acessada pela função end() (na verdade, não nomeamos a coluna). Se a métrica for do tipo de série temporal Delta, haverá uma coluna de horário de início acessada pela função start(). Também há uma coluna de horário de início para métricas com tipo de série temporal Cumulative. Ambas as colunas têm valores do tipo Date.

  • Colunas Value, uma para cada valor no value dos pontos da série temporal. Cada coluna tem o nome e o tipo dados desse valor, e as colunas de valor estão na mesma ordem informada pelo tipo de métrica. Se houver um recurso monitorado ou um rótulo de métrica com o mesmo nome de um valor, o nome do valor fornecido pelo tipo de métrica será prefixado com value. para formar o nome da coluna.

Todos os pontos em uma série temporal têm o mesmo valor nas colunas do identificador de série temporal, e essas colunas identificam exclusivamente a série temporal. As colunas da série temporal mais a coluna do horário de término compõem a chave primária da tabela, que identifica de maneira exclusiva uma linha e, portanto, um ponto.

A descrição acima refere-se a uma tabela armazenada que consiste em séries temporais armazenadas no banco de dados. Uma consulta usa tabelas armazenadas como entradas iniciais e executa operações de tabela consecutivas (filtragem, agregação, mesclagem etc.), produzindo tabelas derivadas intermediárias como saída dessas operações de tabela.

Uma tabela derivada tem a mesma estrutura de uma tabela armazenada, mas com as seguintes diferenças:

  • A tabela ainda será associada a um tipo de recurso monitorado se a transformação que a produziu preservar todas as colunas do rótulo de recurso monitorado. Caso contrário, ela não está associada a um tipo de recurso monitorado. Isso é importante para metadados (descrito na próxima seção).

  • A tabela é descrita por um tipo de tabela, e não por um tipo de recurso monitorado e um tipo de métrica. O tipo de tabela é o mesmo do tipo de métrica, porém o conjunto de marcadores inclui todas as colunas do identificador da série temporal. Dependendo da derivação real da tabela, as colunas do identificador de série temporal podem não ter relação com as colunas especificadas por qualquer tipo de recurso monitorado ou métrica.

  • Uma tabela derivada não tem um nome.

Metadata

Um tipo de recurso monitorado pode ter tipos de metadados, cada um associando um valor a cada instância desse tipo de recurso monitorado específico. Cada tipo de metadados tem um nome e um tipo de valor (que é String, Int ou Bool).

Há dois tipos de metadados:

  • Metadados do sistema originados pelo serviço que cria e gerencia o recurso monitorado. Os metadados do sistema têm um nome no formato metadata.system_labels.<key>, em que <key> identifica um tipo específico de metadados.

  • Metadados do usuário, presentes quando um serviço permite que o usuário anexe rótulos a um recurso monitorado específico. Os metadados do usuário têm um nome no formato metadata.user_labels.<key>, em que <key> é a chave do rótulo que o usuário anexou à entidade. Por exemplo, metadata.user_labels.my_key. O valor dos metadados do usuário é sempre do tipo String.

Uma tabela (armazenada ou derivada) associada a um recurso monitorado pode ser considerada como colunas de valor virtual adicionais, uma para cada tipo de metadados associado ao tipo de recurso monitorado. Para cada linha na tabela, uma coluna de metadados tem o valor desses metadados no momento da coluna de hora de término da linha. Essas colunas de metadados adicionais não fazem parte da tabela, mas podem ser referenciadas em expressões de consulta fornecendo o nome dos metadados nas expressões que operam em uma linha da tabela.

Alinhamento

Uma série temporal é alinhada temporariamente (ou apenas alinhada) se a hora de término dos pontos ocorrer apenas em intervalos regulares. Dizemos que uma série temporal está alinhada em relação a um período e período base de alinhamento específico se cada ponto da série temporal tiver um horário de término que seja um múltiplo do período de alinhamento antes ou depois do horário base do alinhamento. Por exemplo, com um horário de alinhamento de 10h03 e um período de alinhamento de 5 minutos, 9h48, 9h53, 9h58, 10h03 seriam todos os horários de término válidos para pontos.

Se a série temporal de uma tabela tiver o tipo de série temporal Delta, o horário de início de cada ponto precisará ser anterior ao horário de término pela duração do período, tornando a duração de cada ponto igual. Uma tabela com horários de início cumulativos não pode ser alinhada porque, em geral, não é possível alinhar os horários de início de pontos entre séries temporais diferentes.

Se todas as séries temporais que compõem uma tabela estiverem alinhadas com o mesmo horário e período de alinhamento, a tabela será alinhada com esse horário e período.

Quando uma tabela é alinhada, os pontos em diferentes séries temporais se alinham no horário de cada um. Isso possibilita realizar operações combinando diferentes séries temporais. Por exemplo, se quisermos a série temporal que é a soma de algumas métricas em todos os nossos recursos monitorados, precisamos dos pontos da série temporal individual para "alinhar", ou seja, ter o mesmo alinhamento. Em seguida, o valor dos pontos na série temporal resultante é a soma dos valores dos pontos no mesmo horário na série temporal individual.

Sintaxe e semântica

Elementos léxicos

O texto de uma consulta é composto por uma sequência de tokens, que são descritos de acordo com a gramática e as regras a seguir:

  • Um token é descrito por um dos símbolos não terminais, totalmente em maiúsculas, de acordo com a gramática abaixo.
  • Um token diferente de base_string não tem espaços em branco. O espaço em branco refere-se a espaço, tabulação, nova linha e comentários. Um comentário é qualquer texto, não em um base_string começando com # e terminando com uma nova linha.
  • O espaço em branco entre tokens é ignorado, exceto para separar tokens.
  • É necessário que dois tokens adjacentes sejam separados por um espaço em branco, se a gramática permitir que eles sejam reconhecidos como um único token diferente de BARE_NAME (que é reconhecido apenas em determinados 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 `"'.

Os identificadores (ID) são usados para nomear as operações e funções da tabela integrada que fazem parte da linguagem de consulta do Monitoring e para nomear colunas e metadados em expressões. A sintaxe faz a distinção entre uma ocorrência em que ID pode ser um nome de operação ou função da tabela e uma ocorrência em que ID pode ser um nome de coluna. Portanto, não há identificadores "reservados" que não podem ser usados como nome de coluna. Usa-se um QUOTED_COLUMN para nomear uma coluna que não será analisada como um identificador. Exemplo: c'total cpu'

Os tokens NUMBER, STRING, DURATION e DATE identificam valores literais. Um NUMBER pode ser seguido por um unit que fornece as unidades de medida desse valor literal como uma STRING. Uma STRING pode conter caracteres Unicode. Se não for prefixado por r ou R, as sequências de escape normais serão reconhecidas. O sufixo de uma DURATION indica como uma duração de tempo é denominada: segundos, milissegundos, microssegundos, minutos, horas, dias ou semanas. O base_string em uma data contém uma data no formato 2010/06/23-19:32:15-07:00, em que o primeiro - pode ser um espaço e o fuso horário (-07:00) pode ser descartado (assim como os segundos, minutos, ou horas).

Os tokens restantes são de pontuação e operador que aparecem entre aspas na gramática a seguir (por exemplo, '^' ou '<='). Esses tokens são   ^,   <=,   <, ==,   =   =~,   >=,   >,   ||,   |,   _,   -,   ,,   ;,   ::,   :,   !=,   <>,   !~,   !,   //,   /, .,   (,   ),   [,   ],   {,   },   *,   &&,   %,   +.

Estrutura da consulta

Uma consulta é composta por uma sequência de operações de tabela (table_op), unidas por operadores de barra vertical (|). Cada operação de tabela usa tabelas como entradas e produz tabelas como saída. As tabelas de saída produzidas por cada operação de tabela são transportadas para a próxima operação da tabela, que as consome para produzir as próprias tabelas de saída.

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 } '}' .

Há três tipos de operações de tabela (table_op):

  • Um basic_table_op começa com um ID que nomeia o tipo de operação a ser realizada (conforme descrito aqui). Isso é seguido por argumentos (arg) que fornecem detalhes sobre o que a operação de tabela fará. Cada tipo de basic_table_op usa zero, uma ou muitas tabelas como entrada e produz uma tabela como saída.

  • Um grouped_table_op consiste em uma lista ordenada de consultas. Cada uma das consultas produz uma tabela, e o resultado de grouped_table_op é uma lista ordenada dessas tabelas. Cada uma das consultas usa como entrada a mesma ou mais tabelas de entrada que são a entrada para o grouped_table_op.

  • Um shortcut_table_op é uma notação de atalho (descrita aqui) para um basic_table_op.

A saída das tabelas por um table_op é passada pelo operador de barra vertical (|) como entrada para o próximo table_op. A seguir, descrevemos as regras para passar tabelas de saída de uma operação de tabela à esquerda de um operador de barra vertical (chamada de produtora) para uma operação de tabela à direita do operador de barra vertical (chamada de consumidora):

  • Uma operação de tabela que não usa qualquer tabela como entrada não pode ser consumidora.

  • Quando uma operação de tabela produtora produz uma única tabela e uma consumidora também usa uma única tabela, a tabela de saída da produtora é a tabela de entrada da consumidora.

  • Quando uma operação de tabela produtora produz várias tabelas e uma consumidora consume uma única tabela, a operação consumidora é aplicada separadamente a cada tabela de entrada, produzindo uma tabela de saída para cada entrada.

  • Quando uma operação de tabela produtora produz várias tabelas de saída e uma consumidora também usa várias tabelas, todas as tabelas produzidas são entradas da operação consumidora.

  • Quando uma operação de tabela produtora produz uma única tabela de saída e uma consumidora que é grouped_table_op, a tabela única é a entrada para a primeira operação de tabela de cada query no grouped_table_op.

  • Não é válido que um grouped_table_op seja um consumidor para uma operação que produz várias tabelas.

  • O último table_op em cada query em um grouped_table_op precisa produzir apenas uma tabela.

Os elementos "arg" da operação de tabela fornecem informações à operação de tabela sobre como ela precisa processar as tabelas de entrada em uma tabela de saída. Um arg pode ser um destes três:

  • Um nome de tabela (table_name), que nomeia uma tabela ou faz parte do nome de uma tabela a ser buscada no banco de dados do Cloud Monitoring.

  • Uma expressão (expr), que é uma fórmula para calcular um valor. Pode ser um valor literal conhecido estaticamente ou calculado a partir dos valores de coluna de uma ou mais linhas da tabela de entrada ou das tabelas da operação de tabela.

  • Um map (map), que descreve como calcular as colunas na tabela de saída de uma operação de tabela. Um map contém um ou mais expr que calculam os valores das colunas.

Nomes de tabela

Um table_name nomeia um tipo de recurso monitorado, um tipo de métrica, um grupo ou uma tabela. Eles são usados em operações de tabela que buscam tabelas do banco de dados de série temporal para processamento adicional.

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

Um único name refere-se a um tipo de recurso monitorado ou a um tipo de métrica, por exemplo, o tipo de recurso monitorado gce_instance ou aws_dynamodb_table ou o tipo de métrica loadbalancing.googleapis.com/http/backend_latencies.

Um tipo de recurso monitorado também pode ser nomeado usando um nome de grupo ou um nome de tipo de recurso monitorado seguido por :: e um nome de grupo. O primeiro pode ser usado quando o grupo especifica um único tipo de recurso monitorado e o último é usado quando o grupo não especifica.

Uma tabela armazenada é fornecida por um nome de tipo de recurso monitorado seguido por :: e um nome de tipo de métrica. Por exemplo: gce_instance :: loadbalancing.googleapis.com/http/backend_latencies.

Expressões

Uma expressão (expr) é uma fórmula para calcular um valor. Ela é usada como um argumento para uma operação de tabela e ajuda a descrever a transformação que a operação de tabela executará nas tabelas de entrada. Uma expr pode ser uma expressão literal ou uma expressão dinâmica.

Se um expr for literal, ele será composto apenas de valores literais e chamadas de função simples em que os argumentos são valores literais. O valor dessa expressão é determinado antes da consulta ser aplicada a qualquer tabela.

Se um expr for dinâmico, ele poderá conter referências a colunas da tabela e será usado para calcular um valor de uma ou mais linhas da tabela de entrada. Há três tipos de expressões dinâmicas:

  • Expressão de valor Uma expressão de valor produz um valor para cada linha da tabela de entrada à qual é aplicado. Ela pode conter referências a colunas de tabela e, quando avaliadas para uma linha de entrada, essas referências são avaliadas para os valores de coluna correspondentes na linha.

  • Expressão de agregação Uma expressão de agregação produz um valor para um conjunto de linhas da tabela de entrada. Pode ser dividida em três partes:

    • Uma ou mais expressões de valor, que são aplicadas individualmente a cada linha de entrada para produzir um valor para cada linha. Essas expressões de valor são argumentos para funções de agregação.

    • Uma ou mais funções de agregação que pegam uma coleção de valores de entrada produzidos pelas expressões de valor e os reduzem a um único valor resultante.

    • Uma expressão externa que toma os valores resultantes das funções de agregação e produz o valor da expressão como um todo.

    Por exemplo, na expressão de agregação sum(if(status >= 500, val(), 0)) / sum(val()), as partes são as seguintes:

    • As expressões de valor são if(status >= 500, val(), 0) e val(). Elas serão aplicadas a cada linha de entrada para criar duas coleções de valores.

    • Os agregadores são as duas chamadas de função sum, sendo que cada uma usa como entrada as coleções de valores produzidas pela expressão de valor que é o argumento correspondente.

    • A expressão externa é o operador de divisão (/) que será aplicado à saída final de cada uma das funções de agregação sum para produzir o valor da expressão geral.

  • Expressão de alinhamento; Uma expressão de alinhamento consiste em uma única chamada em uma função de alinhamento. A função de alinhamento produz um valor de saída de uma série temporal de entrada e é usada pelo align para produzir uma tabela alinhada.

Cada expressão é composta por opnd elementos (definidos abaixo) conectados por operadores.

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

Os operadores se comportam da maneira habitual de acordo com a precedência. A tabela a seguir organiza os operadores em cinco grupos. Todos os operadores em um grupo têm a mesma precedência, com grupos mais altos vinculando com mais força. Os operadores da mesma precedência são aplicados da esquerda para a direita. Cada operador corresponde a uma função, fornecida na tabela, que é aplicada aos operandos.

operador Função operação
*
/
//
%
mul
div
div
rem
Multiplicação
Divisão
Divisão do número inteiro
Resto inteiro
+
-
add
sub
Adição
Subtração
==   =
!=   <>
<=
>=
>
<
=~
!~
eq
ne
le
ge
gt
lt
re_full_match
! re_full_match
Comparação de igualdade
Comparação de desigualdade
Comparação menor ou igual
Comparação maior ou igual
Maior que comparação
Menor que comparação
Correspondência completa de expressão regular
Correspondência incompleta de expressão regular
&& and "E" lógico
|| or Lógico ou

Os operadores de prefixo +, - e ! correspondem às funções unárias pos , neg e not e são aplicados antes de qualquer operador infix.

Assim, a < b && a + b + c / -d == 5 é equivalente a (a < b) && (((a + b) + (c / (-d))) == 5), que, por sua vez, equivale a and(lt(a, b), eq(add(add(a, b), div(c, neg(d))), 5)).

Os operadores operam em 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 uma maneira específica de calcular um valor.

  • literal é o valor do token literal fornecido.

    • Um NÚMERO literal pode ser seguido por um unit que fornece as unidades de medida do valor literal, por exemplo, 33 'By' para 33 bytes.

    • Um string é composto por um ou mais tokens STRING que são concatenados em um valor de string. Assim, 'a-' 'b' tem o mesmo valor que 'a-b'.

  • column_meta_name nomeia uma coluna ou uma coluna de metadados virtual na tabela de entrada e avalia o valor dessa coluna na linha de entrada à qual a expressão é aplicada.

  • _ representa o valor padrão. Isso só pode ser fornecido como um argumento real para um argumento formal opcional.

  • '(' expr ')' é uma expressão entre parênteses que é apenas o valor de expr.

  • call_chain é uma ou mais chamadas de função encadeadas:

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

Cada ID em uma call_chain nomeia uma função, que pode ser aplicada a nenhum, um ou mais argumentos. Os argumentos para uma chamada de função podem vir das colunas de valor da tabela de entrada, do resultado de um call anterior na cadeia de chamadas ou do valor de expr em um arg_list.

  • Se a cadeia de chamadas começar com um ID (e nenhum . antes), os argumentos para a função chamada serão fornecidos pelo expr no arg_list a seguir.

    Por exemplo, add(error_count, 1) aplica a função add a dois argumentos: column_meta_name error_count e literal 1. Isso seria equivalente a error_count + 1.

  • Se um call_chain começar com um '.' call, as colunas de valor da tabela de entrada serão o primeiro argumento para a função chamada. Se o call tiver um arg_list, o arg_list fornecerá argumentos adicionais.

    Por exemplo, .div aplicado a uma tabela com colunas de valor num e den seria equivalente a div(num, den) ou apenas num / den. A expressão .add(3) aplicada a uma tabela com uma única coluna de valor count seria equivalente a add(count, 3) ou apenas count + 3

  • A função chamada por um call diferente do primeiro em uma cadeia de chamadas usa como primeiro argumento a saída da função chamada anteriormente na cadeia de chamadas. Se o call tiver um arg_list, o arg_list fornecerá argumentos adicionais.

    Por exemplo, .mul(3).div(4) aplicado a uma tabela com uma única coluna de valor error_count seria equivalente a div(.mul(3), 4), que é equivalente a div(mul(error_count, 3), 4), que é equivalente a error_count * 3 / 4 ou (error_count * 3) / 4.

As colunas de horário de término e de início em uma tabela não têm nomes de coluna. O valor das colunas de tempo é acessado usando as funções end e start.

Maps

Um map calcula e nomeia os valores das colunas em uma linha de saída. Dependendo do local em que o map é usado, ele será um map de identificador de série temporal, que calcula as colunas do identificador da série temporal da linha de saída, ou um map de valor, que calcula as colunas de valores da linha de saída.

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

Cada expr no maplet calcula o valor de uma coluna de saída e o column_name fornece o nome da coluna. Se nenhum column_name for fornecido, um será criado a partir do expr. Se expr for apenas o nome de uma coluna de entrada, o column_name será o mesmo. Se funções forem aplicadas, elas serão adicionadas ao nome. Por exemplo, sum(error_count / 3) receberia o nome error_count_div_sum.

As colunas de saída que o map calcula (identificador de série temporal ou valor) vêm de maplets no map e do tipo correspondente de colunas (identificador de série temporal ou valor) na tabela de entrada. A maneira como isso é feito depende do modifier:

  • Nenhum modifier As colunas correspondentes da linha de saída consistem exatamente nas colunas especificadas por um maplet no map. O nome da coluna é fornecido explicitamente por um ID ou QUOTED_COLUMN ou é derivado da forma do expr. O valor da coluna na linha de saída é o valor de expr.

    Cada maplet precisa ter um nome de coluna (explícito ou derivado) que seja exclusivo entre todas as colunas na tabela de saída.

    Por exemplo, aplicar [ratio: num/den] como uma coluna de valor map a uma tabela com colunas de valor num e den resultaria em uma tabela de saída com coluna de valor ratio, em que o ratio o valor da coluna é a proporção das duas colunas de entrada.

    Aplicar [zone] como um identificador de série temporal map a uma tabela com colunas de identificador de série temporal project_id, zone e instance resultaria em uma tabela com apenas um zone da coluna do identificador de série temporal com valor igual à coluna da tabela de entrada zone.

  • add Todas as colunas do tipo correspondente (identificador de série temporal ou valor) da linha de entrada são incluídas na linha de saída. Além disso, para cada maplet no map há uma coluna de saída adicional com nome e valor fornecidos pelo maplet.

    Cada maplet precisa ter um nome de coluna (explícito ou derivado) que seja exclusivo entre todas as colunas na tabela de saída.

    Por exemplo, aplicar add[ratio: num/den] como um valor map a uma tabela com colunas de valor num e den resultaria em uma tabela de saída com colunas de valor num, den e ratio, em que o valor da coluna ratio é a proporção das outras duas colunas.

  • update Todas as colunas do tipo correspondente (identificador de série temporal ou valor) da linha de entrada com nome de coluna diferente de um maplet no map estão incluídos na linha de saída. Além disso, para cada maplet no map, há uma coluna de saída adicional com nome e valor fornecidos pelo maplet.

    Cada maplet precisa ter um nome de coluna (explícito ou derivado) que seja exclusivo entre todas as colunas na tabela de saída. O maplet poderá nomear uma coluna do tipo correspondente na entrada que substitui.

    Por exemplo, o seguinte é um identificador de série temporal map:

      update[job: re_extract(job, '[^-]*-(.*)', r'\1'),
             kind: re_extract(job, '([^-]*)-.*', r'\1')]
    

    Quando usado em uma tabela com colunas de identificador de série temporal user, job e zone, resultará em uma tabela de saída com coluna de identificador de série temporal user, job, zone e kind.

  • drop Cada maplet precisa consistir em um expr que seja apenas o nome de uma coluna de entrada do tipo correspondente. As colunas de saída consistem em todas as colunas de entrada do tipo correspondente, exceto aquelas que são nomeadas em um expr no maplet.

    Cada maplet não pode ter um column_name, e o expr precisa simplesmente nomear uma coluna do tipo correspondente na tabela de entrada.

    Por exemplo, aplicar drop [job, user] como um identificador de série temporal map a uma tabela com colunas de identificador de série temporal user, job e zone resultaria em uma tabela de saída com coluna de identificador de série temporal zone.

  • ignore Cada maplet precisa consistir em um expr que seja apenas um nome de coluna. Se for nome de uma coluna de entrada do tipo correspondente, essa coluna não aparecerá nas colunas de saída. Se o nome da coluna do maplet não nomear uma coluna da tabela de entrada do tipo correspondente, esse maplet não terá efeito. As colunas de saída consistem em todas as colunas de entrada do tipo correspondente, exceto aquelas que são nomeadas em um expr no maplet.

    Cada maplet não pode ter um column_name e o expr precisa ser simplesmente um nome de coluna, mas não precisa ser o nome de uma coluna na tabela de entrada. Se o maplet não nomear uma coluna na tabela de entrada, ele será ignorado.

    Por exemplo, aplicar ignore [job, instance] como um identificador de série temporal map a uma tabela com colunas de identificador de série temporal user, job e zone, resultaria em uma tabela de saída com colunas de identificador de série temporal user e zone (com o maplet instance ignorado)

  • rename Cada maplet precisa ter um column_name explícito e um expr que apenas faça referência a uma coluna do tipo correspondente na tabela de entrada. As colunas de saída são todas as colunas do tipo correspondente na tabela de entrada, mas se referenciadas em um maplet com um novo nome fornecido pelo column_name no maplet.

    O column_name em cada maplet precisa ser exclusivo entre os nomes das colunas da tabela de saída.

    Por exemplo, aplicar rename[numerator : num, denominator : den] como uma coluna de valor map a uma tabela de entrada com colunas de valor num, den e ratio resultaria em uma tabela de saída com colunas de valor numerator, denominator e ratio.

Unidades de medida

Cada valor numérico (Int, Double e Distribution) pode ter uma unidade de medida associada a ele, indicando a unidade de medida usada por esse valor. As unidades são representadas por strings que seguem um subconjunto do Código unificado para unidades de medida (UCUM, na sigla em inglês). Por exemplo, um valor que denota um número de bytes terá a unidade "By" e o outro indicando uma taxa de bytes transferidos, "By/s".

As unidades são anexadas às colunas das tabelas produzidas pelas operações da tabela e ao valor das expressões. Eles são associados estaticamente à coluna ou expressão da mesma forma que o tipo. Qualquer coluna ou expressão com um tipo numérico pode ter unidades associadas a ela, mas não necessariamente.

As unidades anexadas às colunas em tabelas vêm destas fontes:

  • Os descritores de métrica podem especificar as unidades para o valor de uma métrica. Elas são vistas na documentação que descreve as métricas (por exemplo, aqui). As colunas de valor das tabelas produzidas pelas operações da tabela fetch e metric têm as unidades especificadas pelo descritor de métricas.

  • As colunas da tabela de saída que são apenas uma cópia da coluna da tabela de entrada têm as mesmas unidades que a tabela de entrada. Por exemplo, a operação de tabela filter não altera as unidades em nenhuma coluna da tabela de entrada e as transmite para a saída.

  • A operação de tabela union combina várias tabelas em uma, e todas as tabelas precisam ter as mesmas colunas. Cada coluna de valor em uma tabela de entrada não pode ter nenhuma unidade anexada ou unidades equivalentes às unidades. Se houver, estará anexada a essa coluna em todas as outras tabelas de entrada. Se forem especificadas unidades para uma coluna em qualquer uma das tabelas de entrada, a coluna terá essas unidades na tabela de saída. Se nenhuma das tabelas de entrada tiver unidades especificadas para uma coluna, significa que não há unidades na saída.

  • Para operações de tabela que contêm um expr que calcula um valor de coluna da tabela de saída, as unidades na coluna de saída têm as unidades anexadas a expr, conforme descrito abaixo.

As unidades anexadas a um expr dependem da forma de expr:

  • Os valores literais, por si só, não têm unidades. No entanto, literais numéricos (Int ou Double) podem receber unidades seguindo o valor com uma string que especifica a unidade. Assim, 3 "By" é um expr com o valor 3 do tipo Int, e a unidade é bytes (By).

  • As expressões de referência de coluna recebem unidades da coluna nomeada na tabela de entrada, se ela tiver unidades.

  • Funções e operadores derivam a unidade de medida para os valores de saída a partir da unidade de valores de entrada. Portanto, se amount tiver a unidade By e time tiver a unidade s, então amount / time terá a unidade By/s. As funções que aceitam dois argumentos numéricos normalmente exigem que as unidades tenham unidades ou que nenhum argumento tenha unidades. A documentação de cada função descreve o tratamento de unidades de medida por essa função.

    Muitas funções têm um requisito sobre o contrato unitário. Por exemplo, add requer que os dois operandos, se eles tiverem unidades, tenham a mesma unidade. Esses requisitos estão descritos na documentação de cada função.

  • As funções scale e cast_units têm funcionalidades específicas às unidades.

    A função scale multiplica um valor com uma unidade por um fator de escalonamento que o converte em um valor com uma unidade diferente. Portanto, para expr ev com a unidade "KiBy" (kibi-bytes), o resultado de scale(ev, "By") será a multiplicação de ev por 1024 com a unidade resultante By. Isso equivale a ev * 1024 'By/KiBy'.

    A função cast_units retorna o argumento com uma determinada unidade, independentemente da unidade original do argumento, se houver. Portanto, cast_units(ev, 'By/s') resulta no valor de ev, inalterado, mas com a unidade By/s.

O subconjunto de unidades UCUM compatíveis com MQL é fornecido por valores de string que seguem essa 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 }

Um simple_unit especifica uma unidade fornecida por um ATOM_SYMBOL, opcionalmente prefixado por um fator de escalonamento fornecido por um PREFIX_SYMBOL.

Um ATOM_SYMBOL oferece uma unidade básica de medida:

text significado
s second
min minuto (60 segundos)
h hora (60 minutos)
d dia (24 horas)
sem semana (7 dias)
bit bit
Por byte (8 bits)
% 10^-2 (proporção sem dimensão escalonada para %)
m metro
g grama
K kelvin
C coulomb
Hz hertz (1/s)
J joule (kg.m.m/s/s)
W watt (kg.m.m/s/s/s) (J/s)
A amp (C/s)
V volt (kg.mm/s/s/C) (J/C)

Um PREFIX_SYMBOL fornece um fator de escalonamento para a unidade básica que ele precede:

text significado escalonar
k quilo 10^3
milhões mega 10^6
G giga 10^9
T tera 10^12
P peta 10^15
E exa 10^18
Z zetta 10^21
Y 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

Uma unidade sem dimensão pode ser fornecida como 1 ou com potência de 10 (10^ exponent como 10^2). A unidade 1 é a unidade fornecida à maioria das métricas de contador. Também é compatível com a proporção sem dimensão dimensionada para porcentagem %. Portanto, 10^-2 e % são as mesmas unidades. Em outras palavras, adicionar 3 a uma porcentagem é igual a adicionar 0,03 à proporção correspondente. O exponent é limitado ao intervalo de -128 a 127.

Um annotation é um comentário que pode ser anexado a um annotatable (simple_unit ou potência de 10) e não muda o significado da unidade. Uma anotação não anexada a uma unidade será tratada como se fosse anexada à unidade 1. Assim, {queries}/s é equivalente a 1/s, com a unidade 1 decorada com {queries}.

Uma string de unidade pode ser composta de várias strings component, conectadas por . ou /. O conector . indica a multiplicação de unidades, e o conector /, divisão. A multiplicação e a divisão são aplicadas da esquerda para a direita. O subconjunto de unidades da UCUM compatível com o MQL permite que todos os conectores de divisão venham depois dos conectores de multiplicação. Isso evita o problema de escrever as unidades de aceleração como m/s.s quando m/s/s é o esperado. Em unidades UCUM, m/s.s é igual a m.s/s ou apenas m.

Duas strings de unidade são equivalentes se tiverem a mesma dimensão e escala, independentemente das anotações. A dimensão e a escala são determinadas da maneira convencional:

  • Cada component não tem dimensões ou tem uma dimensão que é uma combinação de tempo, tamanho, dados, massa ou carga. Por exemplo, bit e By têm a dimensão dados. As dimensões de uma string de unidade são encontradas ao converter cada anotação à dimensão, multiplicando-as e dividindo-as conforme fornecidas pela string de unidade e cancelando dimensões que aparecem no numerador e no denominador. Assim, b.h/s (bit-hora por segundo) tem a dimensão dados vezes tempo dividido por tempo, e a dimensão tempo é cancelada para sair da dimensão dados.

  • Cada anotação tem uma escala em relação às unidades básicas da dimensão. Por exemplo, h (hora) tem dimensão hora com a unidade básica s e um fator de escalonamento de 3.600 (cada hora tem 3.600 segundos). O fator de escala de uma string de unidade é a combinação dos fatores de escalonamento de cada component combinados pela multiplicação e divisão.

Literais numéricos podem receber unidades ao seguir o valor com a string da unidade de medida desejada. Portanto, 3 "m/s" é o valor 3 com a unidade m/s e 10.8 "km/h" representa a mesma velocidade que o valor 10.8 com a unidade km/h.

Um valor com uma unidade pode ser dimensionado para ter uma unidade diferente com a mesma dimensão usando a função scale. Por exemplo, MiBy e By têm a dimensão dados com o fator de escala 8*1024 e 8, respectivamente, (em relação à unidade base dos dados de dimensão, que é bit). Um valor x com a unidade MiBy pode ser dimensionado para um valor com unidade By pela expressão scale(x, "By"). Isso multiplica x por 1024 e resulta em um valor com a unidade By. É equivalente à expressão x * 1024 "By/MiBy", size * 1024 "By/MiBy", e a unidade da expressão resultante é MiBy.By/MiBy ou apenas By.

A função scale verifica se a unidade solicitada tem a mesma dimensão que a unidade do valor que está sendo escalonado.

Se size for uma coluna com o valor que tem a unidade "KiBy", a expressão scale(size, "By") será igual a size * 1024 "By/KiBy", e a unidade da expressão resultante será MiBy.By/MiBy ou apenas By.

Há um número limitado de casos em que o MQL ajustará ou fornecerá automaticamente unidades para um valor.

  • Para uma função f que requer dois argumentos com unidades equivalentes (add, sub, qualquer um dos operadores de comparação numéricos, if e or_else), um dos argumentos pode ser uma chamada na função scale sem o segundo argumento de unidade. Se a unidade do outro argumento para f tiver a mesma dimensão que a unidade do argumento para a função scale, o segundo argumento da função scale será definido automaticamente para as unidades do outro argumento como f. Isso faz com que as unidades de dois argumentos para f sejam equivalentes e que f possa ser operado.

    Por exemplo, o operador + requer que os argumentos tenham unidades equivalentes, porque não faz sentido adicionar dois números com unidades diferentes. Se cache_size tiver a unidade By e heap_size tiver a unidade MiBy, a expressão scale(cache_size) + heap_size será equivalente à expressão scale(cache_size, "MiBy") + heap_size

  • Para qualquer função de comparação, se um argumento for um literal com uma unidade que tenha a mesma dimensão, mas uma escala diferente do outro argumento, o literal será dimensionado para ter a mesma escala.

    Por exemplo, se "cache_size" tiver a unidade By, a expressão cache_size < 3 "KiBy" será equivalente à expressão cache_size < 3072 "By". Isso não é o mesmo que cache_size < scale(3 "KiBy", "By") se cache_size for o tipo Int, porque scale converterá o resultado do tipo Double, o que pode reduzir a precisão da comparação. Nesse caso, o escalonamento de números inteiros considera o arredondamento e o tratamento adequados do estouro para a comparação específica.

  • Para o argumento mul ou o divisor div, um literal sem uma unidade receberá a unidade "1". Isso considera as operações de escalonamento que não estão destinadas a alterar as unidades (por exemplo, perguntando se a taxa era o dobro da taxa). Para alterar as unidades, é melhor usar scale, que selecionará automaticamente o fator de escalonamento correto para a conversão.

Os erros de unidade são tratados como avisos ao avaliar uma consulta. Portanto, a consulta ainda produzirá resultados. Ao definir um alerta, os erros de unidade são tratados como erros reais e impedem que o alerta seja definido.

É importante perceber que Duration e Data NÃO são tipos numéricos e não têm unidades. O valor de Duration 60s é um período não numérico, exatamente a mesma duração de 1m ou 60000ms. A expressão 60s == 60000ms é válida e verdadeira.

Um valor numérico com a unidade de tempo é diferente. Os números 3 'min' e 180 's' são dois valores numéricos diferentes (3 e 180) com unidades diferentes. Não é válido compará-los sem escalonamento.

A função scale converterá os valores de Duration e Data em valores para Double com unidades. Por exemplo, scale(60s, "min"), scale(1m, "min") e scale(60000ms, "min") retornarão o valor dobrado 1.0 com a unidade min.

Atalhos de operações de tabela

Um atalho é uma maneira simplificada de especificar uma operação de tabela básica.

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

Há vários formatos de atalhos de operações de tabela, sendo que cada um é atribuído a um tipo de operação de tabela básica:

  • Um atalho de promoção de função parece uma operação de tabela normal. No entanto, a operação de tabela é iniciada por um ID que nomeia uma função, em vez de uma operação de tabela, e os elementos arg que se seguem (todos no formato expr) são os argumentos da função.

    A função é promovida por meio do fornecimento de uma operação de tabela de que a função será um argumento. As colunas de valor da tabela de entrada se tornam os primeiros argumentos da função, como se fossem precedidas de um operador .. As promoções específicas são as seguintes:

    • Uma função comum se torna o argumento de uma operação de tabela value, calculando a coluna de valor único da tabela de saída.

      Por exemplo,   | add 3 é um atalho para value [.add(3)] e | div é um atalho para | value [.div].

    • Uma função de agregação se torna o segundo argumento de uma operação de tabela group_by cujo primeiro argumento é o map ([ ]) vazio. Assim, a função calcula a coluna de valor único de uma tabela de saída sem colunas de identificador de série temporal (uma tabela com uma única série temporal).

      Por exemplo, | min é um atalho para | group_by [], [.min].

    • Uma função de alinhamento se torna o argumento para uma operação de tabela align, realizando o tipo de alinhamento designado na série temporal da tabela de entrada.

      Por exemplo,   | delta 10m é um atalho para a operação de tabela | align [.delta(10m)].

  • Um atalho de nomenclatura começa com um table_name que é usado como argumento para a operação de tabelaresource, metric ou fetch, dependendo do tipo de elemento o table_name nomeia.

    Por exemplo,   | gce_instance é um atalho para a operação de tabela | resource gce_instance e | gce_instance :: compute/instance/cpu/usage_time é um atalho para | fetch gce_instance :: compute/instance/cpu/usage_time.

  • Um atalho de filtro consiste em um expr entre parênteses que se torna o predicado em uma operação de tabela filter.

    Por exemplo,   | (job == 'search') é um atalho para | filter job == 'search'.

  • Um atalho de agrupamento começa com um map que se torna o primeiro argumento para uma operação de tabela group_by. O atalho pode ser seguido de um arg que é um map que descreve a agregação que calcula as colunas de valor da tabela de saída.

    Por exemplo,   | [zone] é um atalho para | group_by [zone].

  • Um atalho de gestão de janelas começa com um DURATION que se torna o primeiro argumento para uma operação de tabela group_by. Ele precisa ser seguido por um arg que é um map que descreva a agregação que calcula as colunas de valor da tabela de saída.

    Por exemplo,   | 10m, [.sum] é um atalho para | group_by 10m, [.sum].

  • Um atalho de duração é iniciado por uma DURATION sem um arg. Ele se torna uma operação de tabela for, que fornece a extensão de tempo geral da operação de consulta.

    Por exemplo,   | 10m é um atalho para | for 10m.

Descrição da operação e da tabela

Cada operação de tabela e descrição de função da linguagem de consulta do Monitoring começa com uma assinatura de documentação que indica as entradas da tabela (para operações de tabela) e os tipos de argumentos que podem ser fornecidos para a operação ou função da tabela. Nesta seção, descrevemos o formato dessas assinaturas.

Essas assinaturas NÃO fazem parte da linguagem de consulta do Monitoring. Elas são usadas para descrever a linguagem de consulta do Monitoring.

Uma assinatura de operação de tabela opcionalmente começa com um tipo que descreve as tabelas de entrada para as operações de tabela seguidas por uma lista de argumentos descrevendo os argumentos válidos para a operação de tabela. Por exemplo, a assinatura da operação de tabela pick:

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

Esta operação de tabela usa um Table como entrada (o caso mais comum) e tem três argumentos em potencial, descritos por lit-Int, [TSIDSel ] e [ Windowed(Num) ].

A tabela de entrada e | são opcionais e, se não forem fornecidas, a operação de tabela não usará uma tabela de entrada. A especificação da tabela de entrada é uma das seguintes:

  • Table: a entrada da operação de tabela é uma única tabela.
  • Table++: a operação de tabela usa duas ou mais tabelas como entradas.
  • Resource A operação de tabela usa uma coleção de tabelas especificada por um tipo de recurso monitorado (todas as tabelas que contêm séries temporais cujo tipo inclui um tipo de recurso monitorado específico).
  • ResourceOrTable É permitido usar Table ou Resource como entrada.

Cada descritor de argumento na lista de argumentos que segue o nome da operação de tabela tem as seguintes partes:

  • Ele pode ser colocado em [ ]. Nesse caso, é opcional e o argumento real pode ser fornecido como _ ou omitido se o argumento real for posicionado após todos os argumentos fornecidos explicitamente.

  • Ele pode ter um prefixo lit- que indica que o valor do argumento precisa ser um valor constante conhecido antes de avaliarmos a consulta.

  • Ele sempre tem o nome de um tipo de valor ou uma classe de tipos (descritos abaixo) que descreve o tipo permitido do argumento real.

  • Ele pode ter um sufixo que fornece um tipo de série temporal que restringe o tipo de série temporal do valor de entrada.

O nome do tipo de descritor de argumento pode ser um dos tipos reais descritos aqui: Bool , Int , Double , Distribution , String , Duration ou Date. Nesse caso, o argumento real precisa ser uma expressão do mesmo tipo.

Os itens a seguir indicam que o argumento real precisa ser um table_name que nomeie uma métrica, recurso monitorado, ou tabela, respectivamente:

  • MetricName
  • ResourceName
  • TableName

Um descritor de argumento pode nomear uma categoria que indique que o argumento real pode ser uma expressão de um dos tipos variados:

  • Num   um Int ou Double.
  • Summable Tipos de valores que podem ser somados: Int, Double ou Distribution.
  • Comparable Tipos de valores que podem ser comparados: Int, Double, String, Bool Duration, Date.
  • ColumnValue Tipos que são valores de coluna válidos: Int, Double, String, Bool ou Distribution.
  • Windowed(Num)   um Num, potencialmente anotado pelas funções within, ago, ou bottom.
  • WindowDuration A Duration , possivelmente anotado por window ou sliding.
  • BucketSpecification uma especificação de bucket para uma Distribution.

Uma operação de tabela pode exigir um argumento map especificando as colunas do identificador de série temporal da linha de saída ou colunas de valor. Isso é indicado por uma das seguintes opções:

  • RowToTSID: um map que descreve as colunas de identificador de série temporal da tabela de saída.
  • TSIDSel: um map que nomeia as colunas de identificador de série temporal a serem mantidas. Cada maplet no map precisa consistir apenas em um expr que nomeie uma coluna (ID ou column_name). Por exemplo, [zone, name] faz com que as colunas de saída consistam apenas nas colunas de identificador de série temporal zone e name, com todas as outras colunas de entrada descartadas.
  • RowToVal: um map que descreve as colunas de valor da tabela de saída. Se uma expressão não relacionada ao map for fornecida como um argumento real, ela será promovida para ser um map de elemento único com essa expressão.
  • RowSetToVal: um map que descreve as colunas de valor da tabela de saída por agregação. Se uma expressão não relacionada ao map for fornecida como um argumento real, ela será promovida para ser um map de elemento único com essa expressão.
  • DefaultColumns: um map que descreve as colunas de valor padrão de um outer_join. Se uma expressão não relacionada ao map for fornecida como um argumento real, ela será promovida para ser um map de elemento único com essa expressão.

Uma assinatura de função começa com o nome da função seguido por uma lista de argumentos entre parênteses que descreve os argumentos válidos para a função seguidos por um tipo de retorno que descreve o valor retornado pela função. Por exemplo, a assinatura da função fraction_less_than:

fraction_less_than(Summable,   lit-Num)   → Double

Essa função usa dois argumentos descritos por Summable e lit-Num e retorna um valor do tipo Double. A lista de argumentos tem os mesmos elementos descritos acima para operações de tabela. O tipo de retorno pode ser um tipo de valor específico, indicando que o valor retornado será desse tipo ou um dos seguintes:

  • Num: se algum dos argumentos da função for Double, depois Double. Caso contrário, Int.
  • ColumnValue: o mesmo tipo que o primeiro argumento real da função.
  • LastArgType: o mesmo tipo que o último argumento real da função.
  • Windowed(): o mesmo tipo que o argumento real Windowed, anotado com o tipo Windowed. Se o argumento real Windowed for do tipo Int, o tipo de retorno será Windowed(Int). Consulte as funções within, ago ou bottom.

Um descritor de argumento de função ou tipo de retorno pode ter um indicador que controla o tipo de série temporal do argumento ou resultado. Eles aparecem como um dos seguintes sufixos para o tipo:

  • .Cumulative, .Delta ou .Gauge indicam que o argumento real precisa ter o tipo de série temporal fornecido.
  • .CumulativeOK significa que um argumento real pode ser Cumulative.
  • .FirstArgKind significa, apenas para tipos de retorno, o mesmo tipo de série temporal que o primeiro argumento para a função.

Se um argumento não tiver um sufixo de tipo de série temporal, ele precisará ser do tipo Gauge ou Delta. Se um tipo de retorno não tiver sufixo de tipo de série temporal, ele será Gauge.

Uma assinatura de função também pode ter uma ou mais das seguintes observações:

  • (entrada implícita de linha) Indica que a função usa toda a linha como uma entrada implícita. Por exemplo, a função hash_tsid produz um hash das colunas do identificador de série temporal da linha de entrada, mas não usa esses valores de coluna como argumentos explícitos.
  • (somente temporal) É usado na assinatura de funções de agregação para indicar que a assinatura de função se aplica somente ao fazer agregação temporal. Outras assinaturas para a função se aplicam de outra forma. Isso inclui o caso da agregação temporal e da agregação espacial que estão sendo feitas na mesma operação de tabela.
  • (somente temporal deslizante) É usado na assinatura de funções de agregação para indicar que a assinatura de função só se aplica ao fazer agregação temporal deslizante. Outras assinaturas para a função se aplicam de outra forma. Isso inclui o caso de agregação temporal deslizante e agregação espacial realizadas na mesma operação de tabela.

Operações de tabela

Esta seção descreve cada uma das operações básicas da tabela na linguagem de consulta do Monitoring.

  • Busca
    • fetch Produz uma tabela do banco de dados.
    • metric Produz a tabela para um tipo de métrica específico a partir de um conjunto de tabelas.
    • fetch_cumulative Produz uma tabela de séries temporais Cumulative do banco de dados.
  • Seleção
    • filter Filtra as linhas de uma tabela de entrada por um predicado.
    • top Seleciona a série temporal principal por uma expressão de valor de classificação.
    • bottom Seleciona a série temporal inferior por uma expressão de valor de classificação.
    • top_by Seleciona séries temporais por uma expressão de classificação em diferentes grupos.
    • bottom_by Seleciona séries temporais por uma expressão de classificação em diferentes grupos.
  • Modificação de linha
    • map    Reescreve as colunas de identificador de série temporal e de valor de todas as linhas de uma tabela.
    • value Reescreve as colunas de valor de cada linha em uma tabela.
    • time_shift Avance as séries temporais no tempo.
  • Alinhamento de série temporal
    • align Produz uma tabela alinhada usando uma função de alinhamento.
  • Agregação
    • group_by Agrega linhas por identificador de série temporal mapeada e janela de tempo.
    • union_group_by Agrega linhas de várias tabelas.
    • unaligned_group_by Agrega linhas por identificador de série temporal mapeada sem alinhamento.
  • União e junção
    • join União natural de várias tabelas.
    • outer_join União natural externa de duas tabelas.
    • union União de várias tabelas.
  • Horizonte e período de tempo
    • every Especifica o período de saída da tabela alinhada.
    • within Especifica o período da saída da consulta.
    • graph_period    Especifica o período de saída preferido para desenhar gráficos de séries temporais.
    • window Especifica a janela para operações de alinhamento.
  • Alertas
    • condition Adicione uma coluna de condição booleana à tabela de entrada.
    • absent_for Crie uma condição para a ausência de entrada.
  • Disposições Gerais
    • ident operação da tabela de identidade: sem alterações na tabela de entrada.
    • ratio Calcula a proporção de colunas de valor de duas tabelas de entrada alinhadas.
    • filter_ratio Calcula a proporção de duas somas filtradas da coluna de valor de entrada.
    • filter_ratio_by Calcula uma proporção agrupada de duas somas filtradas da coluna de valor de entrada.

Busca

A saída de uma operação de tabela fetch é uma tabela recuperada por nome do banco de dados de séries temporais do Cloud Monitoring.

A saída da operação de tabela resource é o conjunto de todas as tabelas que têm o tipo de recurso monitorado nomeado. Cada resource precisa ser seguido por uma operação de tabela metric que seleciona a tabela cujo nome contém essa métrica. Antes da operação de tabela metric, pode haver operações de tabela filter que restringem as linhas incluídas nas tabelas resultantes.

fetch Produz uma tabela do banco de dados.


Assinatura: fetch   lit-TableName

A operação fetch busca no banco de dados de séries temporais a tabela cujo nome é o nome da tabela fornecido no argumento TableName. Será um erro se o nome da tabela contiver um nome de recurso monitorado ou de tipo de métrica desconhecido.

Essa tabela será vazia se nenhuma métrica do tipo fornecido for coletada do recurso monitorado do tipo fornecido.

Se a métrica for Cumulative, as séries temporais que compõem a tabela serão convertidas em séries temporais Delta, em que cada ponto representa a alteração no valor. desde o ponto anterior.

A operação fetch também pode buscar o conjunto de todas as tabelas baseadas em um recurso monitorado específico, basta fornecer o nome do recurso monitorado e não fornecer um nome de métrica. Essa operação fetch precisa ser seguida por uma operação metric que seleciona a tabela específica que contém os dados de uma métrica específica. A única operação que pode vir entre esse fetch e o metric subsequente é uma operação filter, que filtra com base nas colunas de recursos monitorados.

Essa forma de fetch é útil se quisermos buscar mais de uma métrica para um determinado recurso monitorado, como neste exemplo:

  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

É equivalente 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 Produz a tabela para um tipo de métrica específico a partir de um conjunto de tabelas.


Assinatura: Resource   | metric   lit-MetricName

A operação de tabela metric usa um conjunto de tabelas produzidas por uma operação de tabela fetch que não forneceu um nome de métrica. Ele seleciona a tabela que contém os dados da métrica fornecidos pelo argumento lit-MetricName e produz essa tabela como saída. É um erro se não houver uma definição de métrica com o nome fornecido. Ela produzirá uma tabela vazia se não houver uma tabela de entrada com dados para o nome de métrica fornecido.

fetch_cumulative Produz uma tabela de séries temporais Cumulative do banco de dados.


Assinatura: fetch_cumulative   lit-TableName

A operação de tabela fetch_cumulative é igual à operação de tabela fetch, exceto que as métricas Cumulative não são convertidas automaticamente em métricas Delta quando buscado.

Seleção

As operações da tabela de seleção selecionam linhas da tabela de entrada para inclusão na tabela de saída. O tipo da tabela de saída é exatamente igual ao da tabela de entrada.

filter Filtra as linhas de uma tabela de entrada por um predicado.


Assinatura: ResourceOrTable   | filter   Bool

A operação filter avalia a expressão Bool do argumento para cada linha em uma única tabela de entrada ou na coleção de tabelas nomeada por uma operação resource. São exatamente essas linhas nas tabelas de entrada em que essa expressão é avaliada como verdadeira que serão mantidas nas de saída.

Se a entrada for uma coleção de tabelas, somente os rótulos de recursos monitorados (que são comuns a todas as tabelas) poderão ser referenciados no predicado.

top Seleciona a série temporal principal por uma expressão de valor de classificação.


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

A operação de tabela top calcula um valor de classificação para cada série temporal na tabela de entrada e seleciona o número de séries temporais fornecido pelo argumento Int com o maior valor de classificação. O argumento Windowed calcula o valor de classificação.

O argumento Windowed(Num) é aplicado a linhas em uma série temporal que se enquadram em uma janela de tempo de valor. A janela de tempo do valor padrão é igual à janela de tempo da consulta. Se a expressão for uma expressão de agregação (por exemplo, .min), ela será uma agregação em todas as linhas cujo carimbo de data/hora de término esteja dentro da janela de valor. Se a expressão for uma expressão de valor (por exemplo, .val(0)/.val(1)), ela será aplicada à linha mais recente, se houver, na janela de valor. Se não houver linhas dentro da janela de valor de uma série temporal ou se o argumento Windowed(Num) não produzir um valor para uma série temporal, essa série temporal não será considerada para inclusão na saída.

A função within pode ser usada no argumento Windowed(Num) para modificar a janela de valor fornecendo uma hora de início, uma duração e/ou um horário de término para a janela.

Exemplos:

  | top 3

Selecione três séries temporais com o maior valor para o ponto mais recente da série temporal.

  | top 7, .max

Selecione sete séries temporais com o maior valor para o máximo de todos os pontos da série temporal na janela de consulta.

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

Isso seleciona três séries temporais com o maior valor do redutor min aplicado às linhas em cada série temporal que se enquadram em uma janela iniciada há 10 horas e com duração de uma hora.

bottom Seleciona a série temporal inferior por uma expressão de valor de classificação.


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

A operação de tabela bottom calcula um valor de classificação para cada série temporal na tabela de entrada e seleciona o número de séries temporais fornecido pelo argumento Int com o menor valor de classificação. O argumento Windowed calcula o valor de classificação.

O argumento Windowed(Num) é aplicado a linhas em uma série temporal que se enquadram em uma janela de tempo de valor. A janela de tempo do valor padrão é igual à janela de tempo da consulta. Se a expressão for uma expressão de agregação (por exemplo, .min), ela será uma agregação em todas as linhas cujo carimbo de data/hora de término esteja dentro da janela de valor. Se a expressão for uma expressão de valor (por exemplo, .val(0)/.val(1)), ela será aplicada à linha mais recente, se houver, na janela de valor. Se não houver linhas dentro da janela de valor de uma série temporal ou se o argumento Windowed(Num) não produzir um valor para uma série temporal, essa série temporal não será considerada para inclusão na saída.

A função within pode ser usada no argumento Windowed(Num) para modificar a janela de valor fornecendo uma hora de início, uma duração e/ou um horário de término para a janela.

Exemplos:

  | bottom 3

Selecione três séries temporais com o menor valor para o ponto mais jovem da série temporal.

  | bottom 7, .min

Selecione sete séries temporais com o menor valor para o mínimo de todos os pontos da série temporal na janela de consulta.

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

Isso seleciona três séries temporais com o menor valor do redutor max aplicado às linhas de cada série temporal que se enquadram em uma janela iniciada há 10 horas.

top_by Seleciona séries temporais por uma expressão de valor de classificação em grupos diferentes.


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

A operação de tabela top_by agrupa séries temporais que têm o mesmo identificador de série temporal calculado pelo argumento TSIDSel. Dentro de cada grupo, ele seleciona séries temporais pelo mesmo método que top faz quando recebe os mesmos argumentos Int e Windowed. Para cada grupo, ele calcula um valor de classificação para cada série temporal em um grupo e seleciona o número de séries temporais fornecido pelo argumento Int com o maior valor de classificação. O argumento Windowed calcula o valor de classificação.

O argumento Windowed(Num) é aplicado a linhas em uma série temporal que se enquadram em uma janela de tempo de valor. A janela de tempo do valor padrão é igual à janela de tempo da consulta. Se a expressão for uma expressão de agregação (por exemplo, .min), ela será uma agregação em todas as linhas cujo carimbo de data/hora de término esteja dentro da janela de valor. Se a expressão for uma expressão de valor (por exemplo, .val(0)/.val(1)), ela será aplicada à linha mais recente, se houver, na janela de valor. Se não houver linhas dentro da janela de valor de uma série temporal ou se o argumento Windowed(Num) não produzir um valor para uma série temporal, essa série temporal não será considerada para inclusão na saída.

A função within pode ser usada no argumento Windowed(Num) para modificar a janela de valor fornecendo uma hora de início, uma duração e/ou um horário de término para a janela.

Exemplos:

  | top_by [zone], 1

Para cada grupo de séries temporais com o mesmo valor da coluna "zone", isso seleciona a série temporal com o maior valor para o ponto mais recente da série temporal.

  | top_by [project_id], 2, .max

Para cada grupo de séries temporais com o mesmo valor da coluna "project_id", isso seleciona as duas séries temporais com o maior valor para o máximo de todos os pontos da série temporal na janela de consulta.

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

Para cada grupo de séries temporais com o mesmo valor da coluna "zone", isso seleciona a série temporal com o maior valor do redutor min aplicado às linhas em cada série temporal que se enquadram em uma janela iniciada há 10 horas e com duração de uma hora.

bottom_by Seleciona séries temporais por uma expressão de valor de classificação em grupos diferentes.


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

A operação de tabela bottom_by agrupa séries temporais que têm o mesmo identificador de série temporal calculado pelo argumento TSIDSel. Dentro de cada grupo, ele seleciona séries temporais pelo mesmo método que bottom faz quando recebe os mesmos argumentos Int e Windowed. Para cada grupo, ele calcula um valor de classificação para cada série temporal em um grupo e seleciona o número de séries temporais fornecido pelo argumento Int com o menor valor de classificação. O argumento Windowed calcula o valor de classificação.

O argumento Windowed(Num) é aplicado a linhas em uma série temporal que se enquadram em uma janela de tempo de valor. A janela de tempo do valor padrão é igual à janela de tempo da consulta. Se a expressão for uma expressão de agregação (por exemplo, .min), ela será uma agregação em todas as linhas cujo carimbo de data/hora de término esteja dentro da janela de valor. Se a expressão for uma expressão de valor (por exemplo, .val(0)/.val(1)), ela será aplicada à linha mais recente, se houver, na janela de valor. Se não houver linhas dentro da janela de valor de uma série temporal ou se o argumento Windowed(Num) não produzir um valor para uma série temporal, essa série temporal não será considerada para inclusão na saída.

A função within pode ser usada no argumento Windowed(Num) para modificar a janela de valor fornecendo uma hora de início, uma duração e/ou um horário de término para a janela.

Exemplos:

  | bottom_by [zone], 1

Para cada grupo de séries temporais com o mesmo valor da coluna "zone", isso seleciona a série temporal com o menor valor para o ponto mais recente da série temporal.

  | bottom_by [project_id], 2, .max

Para cada grupo de séries temporais com o mesmo valor da coluna "project_id", isso seleciona as duas séries temporais com o menor valor para o máximo de todos os pontos da série temporal na janela de consulta.

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

Para cada grupo de séries temporais com o mesmo valor da coluna "zone", isso seleciona a série temporal com o menor valor do redutor min aplicado às linhas em cada série temporal que se enquadram em uma janela iniciada há 10 horas. e com duração de uma hora.

Modificação de linha

map   Reescreve as colunas de identificador de série temporal e de valor de todas as linhas de uma tabela.


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

São aplicadas duas transformações a cada linha na Table de entrada:

  • Se o map RowToTSID for fornecido, ele será aplicado às colunas de identificador de série temporal dessa linha para produzir as colunas de identificador de série temporal da linha de saída correspondente. Se o map RowToTSID não for fornecido (ou fornecido como _), as colunas do identificador de série temporal de saída serão as mesmas da entrada.

  • Se o map RowToVal for fornecido, ele será aplicado às colunas de valor da linha de entrada para produzir as colunas de valor da linha de saída. Caso o map RowToVal não seja fornecido, as colunas de valor de saída serão as mesmas que as de entrada.

É um erro dinâmico se as linhas de duas séries temporais diferentes na entrada forem mapeadas para a mesma série temporal na saída. Nesse caso, as linhas derivadas de uma das séries temporais de entrada são descartadas da saída e uma mensagem de erro é fornecida.

Se o map RowToTSID contiver referências a colunas de valor ou colunas de tempo, será possível dividir uma única série temporal de entrada em várias séries temporais de saída. Por esse motivo, quando o map RowToTSID contém referências a colunas de valor ou colunas de tempo, ele só pode ser aplicado a tabelas cujas colunas de valor são do tipo de série temporal Gauge ou Delta.

value Reescreve as colunas de valor de cada linha em uma tabela.


Assinatura:   Table   | value   RowToVal

Na Table de entrada, o map RowToVal é aplicado às colunas de cada linha para produzir as colunas de valor da linha de saída correspondente. Cada linha de saída tem as mesmas colunas de identificador de série temporal e de tempo da linha de entrada que lhe deu origem, bem como as colunas de valor produzidas pelo map RowToVal.

time_shift Avance as séries temporais no tempo.


Assinatura:   Table   | time_shift   lit-Duration

Cada linha na tabela de entrada tem o valor fornecido pelo argumento Duration adicionado às colunas de tempo. Isso tem o efeito de mudar cada série temporal na tabela para frente no tempo.

Se a tabela de entrada estiver alinhada, o valor da mudança deverá ser um múltiplo uniforme do período de alinhamento, que mantém o alinhamento da tabela de entrada.

Alinhamento de série temporal

align Produz uma tabela alinhada usando uma função de alinhamento.


Assinatura:   Table   | align   [ Aligner ]

A operação de tabela align usa a função de alinhamento fornecida para o argumento Aligner para criar uma série temporal alinhada de cada série temporal na entrada produzindo a série temporal na tabela de saída.

O horário base de alinhamento é o horário de término da janela de consulta, e o período de alinhamento é definido por um dos três itens a seguir:

  • Uma operação de tabela every que define o período dessa operação de tabela align.

  • A função de alinhador exige que o período de alinhamento seja igual à largura da janela (consulte delta).

  • Uma interface gráfica externa requer um período de alinhamento específico.

O método específico de produção de séries temporais alinhadas é descrito para a função de alinhamento fornecida ao argumento Aligner.

Agregação

Uma operação de tabela de agregação divide as linhas da tabela de entrada em grupos. Para cada grupo de linhas de entrada, ele calcula um identificador de série temporal comum e colunas de tempo para o grupo, agrega as linhas de entrada para criar as colunas de saída de valor e gera uma única linha com o identificador de série temporal, as colunas de tempo e valor resultantes.

Existem três tipos de agregação

  • Agregação espacial.   Essa forma de agregação calcula novas colunas de código de série temporal para cada linha de entrada e agrupa todas as linhas com as mesmas novas colunas de código de série temporal e a hora de término. Esse tipo de agregação normalmente requer entrada alinhada para que as linhas de diferentes séries temporais sejam alinhadas no tempo para serem agrupadas.

  • Agregação temporária.   Essa forma de agregação calcula um conjunto de horários de saída alinhados válidos e calcula um novo horário de término para cada linha, fornecendo a hora de término alinhada mais antiga, que é superior ao horário de término original da linha. As linhas com o mesmo identificador de série temporal e horário de término são agrupadas.

  • Agregação temporal variável.   Essa forma de agregação é semelhante à agregação temporal, exceto que uma linha pode ser incluída em mais de um grupo. Isso calcula um conjunto de janelas de tempo, cada uma com uma borda posterior em um horário de término alinhado e cada uma com a mesma largura fixa. Uma linha recebe um horário de término que é a borda posterior de cada janela em que ela se encontra, e a linha é agrupada com outras linhas que tenham o mesmo identificador de série temporal e novo horário de término. Quando as janelas se sobrepõem, uma linha pode receber mais de um novo horário de término e, portanto, pode ser incluída em mais de um grupo.

É possível combinar a agregação espacial com uma das duas formas de agregação temporal em uma operação de tabela.

Uma distinção importante entre agregação temporal variável e invariável é que alguns agregadores (por exemplo, soma) produzirão valores com o tipo de série temporal Delta para agregação temporal invariável, mas com o tipo Gauge para agregação temporal variável. O motivo para isso é que a extensão de tempo para dois pontos em uma série temporal Delta não podem se sobrepor. Portanto, as janelas de entrada sobrepostas de agregação temporal variável não podem ser representadas nas colunas das linhas de saída da série temporal Delta.

Quando um novo identificador de série temporal é calculado para uma linha, o novo identificador de série temporal é calculado por um argumento map. As colunas de valor da linha de saída são calculadas por um argumento map com uma expressão de agregação que calcula cada coluna de valor.

group_by Agrega linhas por identificador de série temporal mapeada e janela de tempo.


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

A operação da tabela group_by agrupa as linhas mapeando as colunas do identificador de série temporal, as colunas de tempo ou ambas:

  • Se o argumento RowToTSID for fornecido e o argumento WindowDuration não for, ele calculará o identificador de série temporal produzido por esse argumento map para cada linha na tabela de entrada e agrupará todas as linhas com o mesmo identificador de série temporal produzido e o horário de término.

    Nesse caso, group_by requer uma tabela alinhada como entrada para que diferentes séries temporais tenham pontos com o mesmo horário de término. Se a tabela de entrada não estiver alinhada, uma operação de tabela align será inserida automaticamente para fornecer o alinhamento.

  • Se o argumento WindowDuration for fornecido e o argumento RowToTSID não for, um grupo de linhas será produzido para cada identificador de série temporal e cada ponto de saída de período alinhado. As linhas de um grupo são todas as linhas com o identificador de série temporal fornecido em que o horário de término está incluso em uma janela de tempo entre o horário de saída e o horário anterior da duração.

    Se o argumento Duration tiver uma chamada de função sliding (por exemplo, sliding(1h)), a janela poderá ser diferente do período de alinhamento. Caso contrário, o argumento Duration precisa ser igual ao período de alinhamento. A expressão window() representa uma duração igual ao período de alinhamento. Se uma Duration invariável for fornecida explicitamente, ela obrigará que o período seja igual a ela, caso nenhum seja explicitado.

  • Se os argumentos RowToTSID e WindowDuration forem fornecidos, um novo identificador de série temporal mapeado será calculado para cada linha e um grupo será criado para todas as linhas com o mesmo identificador de série temporal mapeado, em que o horário de término está em uma janela entre o horário de saída e o horário que é a duração mais antiga.

É produzida uma linha de saída para cada grupo com o mesmo identificador de série temporal das linhas no grupo. Também é produzido um carimbo de data/hora, que representa o horário do ponto de saída do grupo (quando WindowDuration é fornecido) ou o horário de término em comum das linhas do grupo (quando WindowDuration não é fornecido). As colunas de valor no grupo são produzidas pelo argumento RowSetToVal. Cada expressão de agregação é aplicada às linhas no conjunto, resultando na coluna de valor da linha de saída.

Algumas expressões de agregação (por exemplo, sum) produzirão colunas de valor de saída com o tipo de série temporal Delta ou Gauge, dependendo do tipo de agregação que está sendo feito. Isso depende se a agregação temporal variável ou não está sendo feita. Para essa finalidade, a agregação é tratada como agregação temporal se combinar agregação temporal e espacial.

Uma operação de tabela group_by sempre produz tabelas de saída alinhadas. Se nenhum argumento WindowDuration for fornecido, a tabela de entrada precisará estar alinhada, resultando em uma tabela de saída com o mesmo alinhamento. Se o argumento WindowDuration for fornecido, será produzido um ponto de saída somente no ponto do horário de alinhamento, resultando em uma tabela de saída alinhada.

Se o argumento de map RowToTSID incluir colunas de valor ou tempo nas expressões, é possível que as séries temporais na tabela de entrada sejam fragmentadas em várias séries temporais na tabela de saída.

union_group_by Agrega linhas de várias tabelas.


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

A função union_group_by agrega linhas de entrada exatamente como a função group_by, exceto pelas linhas de entrada de várias tabelas de entrada.

Todas as tabelas de entrada inseridas em um union_group_by precisam ter as mesmas colunas (mesmo nome, mesmo tipo e, para colunas de valor, o mesmo tipo de série temporal). Se as tabelas de entrada alinhadas forem exigidas pelos argumentos para "union_group_by" (nenhum argumento WindowDuration fornecido), todas as tabelas de entrada precisarão ser alinhadas com o mesmo ponto.

unaligned_group_by Agrega linhas por identificador de série temporal mapeada sem alinhamento.


Assinatura:   Table   | unaligned_group_by   TSIDSel,   [ RowSetToVal ]

A operação de tabela unaligned_group_by faz o mesmo que a operação de tabela group_by, mas não exige que a tabela de entrada esteja alinhada.

Isso calcula o identificador de série temporal produzido por TSIDSel para cada linha na tabela de entrada e agrupa todas as linhas com o mesmo identificador de série temporal e horário de término. Todas as linhas do grupo têm o mesmo horário de término e precisam ter o mesmo horário de início. Se duas linhas de um grupo tiverem horários de início diferentes, será emitido um erro dinâmico e uma das linhas do grupo será removida arbitrariamente.

A operação produz uma linha de saída para cada grupo de linhas mencionado acima. A linha de saída tem o identificador de série temporal produzido pelo argumento map TSIDSel e a mesma hora de término e (se presente) as linhas de entrada no grupo. O resultado também contém as colunas de valor produzidas pelo argumento do map RowSetToVal aplicado a todas as linhas do grupo.

A operação de tabela unaligned_group_by não exige que a tabela de entrada esteja alinhada, o que pode significar que é improvável que haja várias linhas em um grupo para agregar. No entanto, essa operação requer que as linhas coletadas em uma série temporal de saída (todas com o mesmo identificador de série temporal) não tenham horários de término cuja densidade forneça mais de uma linha por segundo.

União e junção

join União natural de várias tabelas.


Assinatura: Table ++   | join

A operação de tabela join usa duas ou mais tabelas de entrada e combina as linhas dessas tabelas em linhas em uma única tabela de saída fazendo uma junção interna natural no identificador de série temporal e nas colunas de horário de término das tabelas de entrada.

Também é necessário que as tabelas de entrada estejam alinhadas no mesmo período, bem como ser do tipo de série temporal Gauge ou Delta.

A tabela de saída terá os elementos a seguir:

  • Uma coluna de identificador de série temporal para cada coluna de identificador de série temporal exclusiva em qualquer uma das tabelas de entrada. Cada coluna terá o mesmo tipo da coluna correspondente nas tabelas de entrada. Se duas tabelas tiverem colunas de identificador de série temporal com o mesmo nome, mas tipos diferentes, isso constituirá um erro;

  • uma coluna de horário de término. Se qualquer uma das tabelas de entrada for do tipo de série temporal Delta, a tabela de saída também será do mesmo tipo Delta e terá uma coluna de horário de início.

  • uma coluna de valor para cada coluna de valor das tabelas de entrada. A ordem é a ordem das tabelas de entrada no grouped_table_op que as produziu. Se duas tabelas de entrada diferentes tiverem colunas de valor com o mesmo nome, isso constituirá um erro.

A junção considera todas as tuplas que consistem em uma linha de cada tabela de entrada. Para cada tupla que atenda às seguintes condições, uma linha de saída será criada:

  • para cada nome de coluna de identificador de série temporal que aparece em qualquer das tabelas de entrada, a coluna terá o mesmo valor de todas as linhas na tupla que a contém.

  • todas as linhas na tupla têm o mesmo horário de término.

Cada linha de saída terá os seguintes valores de coluna:

  • todas as colunas de série temporal terão valores iguais aos das linhas da tupla que contêm a coluna;

  • todas as colunas de tempo terão o mesmo valor das linhas na tupla de entrada;

  • todas as colunas de valor terão o mesmo valor da linha da tupla de origem da coluna de valor.

outer_join União natural externa de duas tabelas.


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

A operação de tabela outer_join usa duas tabelas de entrada e combina as linhas dessas tabelas em linhas em uma única tabela de saída fazendo uma junção externa natural no identificador de série temporal e nas colunas de horário de término das tabelas de entrada.

Um ou ambos os argumentos DefaultColumns precisam ser fornecidos. Cada um corresponde a uma tabela de entrada e, quando fornecida para uma tabela, essa tabela terá linhas criadas se não tiver alguma linha que corresponda a uma linha na outra tabela. O DefaultColumns especifica as colunas de valor da linha criada. Se um DefaultColumns é fornecido para uma tabela, as colunas do identificador de série temporal nessa tabela precisam ser um subconjunto das séries temporais da outra tabela e só podem ter o tipo de série temporal Delta se a outra tabela tiver o tipo de série temporal Delta.

Também é necessário que as tabelas de entrada estejam alinhadas no mesmo período, bem como ser do tipo de série temporal Gauge ou Delta.

Assim como em join, a tabela de saída terá os seguintes elementos:

  • Uma coluna de identificador de série temporal para cada coluna de identificador de série temporal exclusiva em qualquer uma das tabelas de entrada. Cada coluna terá o mesmo tipo da coluna correspondente nas tabelas de entrada. Se duas tabelas tiverem colunas de identificador de série temporal com o mesmo nome, mas tipos diferentes, isso constituirá um erro;

  • uma coluna de horário de término. Se qualquer uma das tabelas de entrada for do tipo de série temporal Delta, a tabela de saída também será do mesmo tipo Delta e terá uma coluna de horário de início.

  • uma coluna de valor para cada coluna de valor das tabelas de entrada. A ordem é a ordem das tabelas de entrada no grouped_table_op que as produziu. Se duas tabelas de entrada diferentes tiverem colunas de valor com o mesmo nome, isso constituirá um erro.

A junção considera todos os pares que consistem em uma linha de cada tabela de entrada. Para cada par que atenda às seguintes condições, uma linha de saída será criada:

  • para cada nome de coluna de identificador de série temporal que aparece em qualquer das tabelas de entrada, a coluna terá o mesmo valor de todas as linhas no par que a contém.

  • Cada linha no par tem o mesmo horário de término.

Cada linha de saída terá os seguintes valores de coluna:

  • todas as colunas de série temporal terão valores iguais aos das linhas do par que contêm a coluna;

  • cada coluna de tempo terá o mesmo valor das linhas no par de entrada;

  • todas as colunas de valor terão o mesmo valor da linha do par de origem da coluna de valor.

Além dos pares acima, se uma linha em uma tabela não puder formar um par com nenhuma linha na outra tabela e a outra tabela tiver um DefaultColumns fornecido, um par será criado com a linha da primeira tabela e uma linha padrão para a outra tabela. A linha padrão é criada da seguinte maneira:

  • Cada coluna de identificador de série temporal e coluna de tempo tem o mesmo valor da coluna correspondente na primeira linha da tabela.

  • As colunas de valor da linha padrão são construídas pelo DefaultColumns map Esse map precisa especificar um valor para cada coluna de valor na tabela padrão.

union União de várias tabelas.


Assinatura: Table ++   | union

A operação de tabela union usa duas ou mais tabelas de entrada e produz uma única tabela de saída contendo linhas de todas as tabelas de entrada.

As tabelas de entrada precisam ter as mesmas colunas (mesmo nome, mesmo tipo e, para colunas de valor, o mesmo tipo de série temporal). A tabela de saída gerada terá as mesmas colunas das tabelas de entrada. A tabela de saída será alinhada somente se todas as tabelas de entrada estiverem alinhadas com um período comum.

É um erro dinâmico se os streams de duas ou mais tabelas diferentes tiverem o mesmo identificador de série temporal. Nesse caso, um dos streams com um identificador de série temporal duplicado é escolhido arbitrariamente para ser incluído na saída, e o restante é descartado.

Horizonte e período de tempo

O período a ser usado ao alinhar a série temporal na tabela é definido pelo comando every.

A consulta produzirá todos os resultados como pontos cujo horário de término esteja dentro de uma janela de consulta. A duração da janela de consulta é definida pela operação da tabela within, que pode especificar qualquer hora de início, de término ou de duração.

every Especifica o período de saída da tabela alinhada.


Assinatura:   Table   | every   lit-Duration

A operação de tabela every requer uma tabela de entrada alinhada com um período de entrada fornecido pelo argumento Duration. Isso é tratado de uma das seguintes maneiras:

  • Se a tabela de entrada não estiver alinhada, uma operação align será inserida com uma função de alinhador apropriada para a tabela de entrada. O argumento Duration para a função do alinhador é o valor padrão para o período especificado.

  • Se a tabela estiver alinhada, mas não tiver um período obrigatório específico, a consulta inserida na operação da tabela every será ajustada para produzir esse período.

  • Caso a tabela de entrada esteja alinhada com um determinado período diferente daquele especificado pelo argumento Duration, isso constituirá um erro.

within Especifica o período da saída da consulta.


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

A operação de tabela within especifica o período da saída da consulta. Isso é feito especificando um ou dois dos três valores: o horário mais antigo (inicial) da janela, o mais novo (final) ou a duração da janela.

Se um dos dois argumentos de within for uma Duration positiva, isso definirá a largura da janela. No máximo, um dos argumentos pode ser uma Duration positiva.

Se o primeiro argumento for Date, isso especificará o horário de início. Se o segundo argumento for Date, isso especificará o horário de término. Se ambos forem valores Date, o segundo precisará ser posterior ao primeiro. Um argumento Date pode ser fornecido como um literal de Date ou com um literal de Duration negativo. No último caso, a hora é a Duration especificada antes da hora em que a consulta foi emitida (agora).

Se apenas um argumento for fornecido, o segundo argumento usará como padrão a hora em que a consulta foi emitida (agora). Nesse caso, o primeiro argumento precisa ser uma Duração positiva ou uma Data anterior ao momento em que a consulta é emitida.

graph_period   especifica o período de saída preferido para desenhar gráficos de séries temporais.


Assinatura:   Table   | graph_period   lit-Duration

A operação de tabela graph_period transforma a tabela de entrada para torná-la adequada à apresentação em gráfico. O argumento Duration indica o período entre os pontos adequados para o gráfico.

Essa operação é inserida automaticamente em consultas fornecidas ao Metrics Explorer se o usuário não adicionar explicitamente uma operação à consulta. Em qualquer um dos eventos, o Metrics Explorer define o valor do argumento Duration para que seja adequado à janela de tempo real do gráfico. Dar explicitamente a adição de graph_period como parte de uma consulta só faz sentido se a consulta for fornecida à API.

A operação graph_period compara o argumento Duration com o período da tabela de entrada e realiza uma das seguintes ações:

  • Se o período da tabela de entrada for menor que a metade do argumento Duration, a operação graph_period atuará como um redutor temporal que terá a janela e o período de saída fornecidos por Duration. Cada coluna de valor na tabela de entrada é agregada de acordo com o tipo.

    • Para uma coluna de valor de tipo numérico, três colunas são colocadas na tabela de saída, cada uma produzida pela agregação da coluna de entrada com os agregadores min, mean e max. Os nomes das colunas de saída são os nomes da coluna de entrada com, respectivamente, .min, .mean e .max anexados.

    • Para uma coluna de valor do tipo Bool, três colunas são colocadas na tabela de saída, cada uma produzida pela agregação da coluna de entrada com os agregadores min, mean e max. Os nomes das colunas de saída são os nomes da coluna de entrada com, respectivamente, .all_true, .mean e .any_true anexados.

    • Para uma coluna do tipo Distribution, é criada uma única coluna com o mesmo nome usando agregação distribution para combinar os preenchimentos de todos os valores de entrada de distribuição que se enquadram em cada janela de período do gráfico.

  • Se o período da tabela de entrada for mais que o dobro do argumento Duration, para cada ponto na tabela de entrada, serão feitas cópias para os pontos de tempo exigidos pelo período de saída.

  • Se o período da tabela de entrada for menor que o dobro do argumento Duration e mais da metade do argumento Duration, a tabela de entrada será copiada para a saída.

Observe que, se a tabela de entrada tiver mais de uma coluna de valor ou tiver uma coluna de valor String, o comportamento dela será indefinido. O Metrics Explorer poderá exibir apenas uma única coluna ou gerar um erro se não houver coluna que possa ser exibida.

window Especifica a janela para operações de alinhamento.


Assinatura:   Table   | window   lit-Duration

A operação de tabela window requer uma tabela de entrada alinhada por uma função de alinhador cujo argumento Duration da janela seja igual ao argumento Duration fornecido nesta operação de tabela window. Isso é tratado de uma das seguintes maneiras:

  • Se a tabela de entrada não estiver alinhada, uma operação align será inserida com uma função de alinhador apropriada para a tabela de entrada. O argumento Duration para a função do alinhador é fornecido pelo argumento Duration da operação da tabela window.

  • Se a tabela estiver alinhada, mas a operação dela não tiver uma janela de alinhamento específica, a Duration desse argumento window será usada como argumento da janela do alinhador.

  • Será um erro se a tabela de entrada estiver alinhada e a operação de tabela alinhada especificar uma janela Duration diferente do argumento Duration dessa operação de tabela window.

Alertas

As operações de alerta são usadas para definir políticas de alerta. Use essas operações somente para instalar alertas, não como parte de uma consulta.

Por outro lado, essas operações oferecem maneiras de criar consultas que resultam em uma tabela com duas colunas de valor: um booleano que indica se o alerta deve ou não estar em um estado de disparo e um valor do mesmo tipo que o campo de entrada que fornece o valor mais recente da entrada.

condition Adicione uma coluna de condição booleana à tabela de entrada.


Assinatura:   Table   | condition   Bool

A operação de tabela condition adiciona uma coluna de valor booleano a cada linha da tabela de entrada para criar a tabela de saída. O valor dessa coluna é o valor do argumento Bool aplicado à linha.

Pode ser usado para criar uma consulta de alerta. A tabela de saída tem uma coluna booleana para indicar que a condição de alerta é satisfeita. A instalação de alertas usará isso para determinar se e quando um alerta precisa ser disparado ou interrompido.

A operação condition requer que a tabela de entrada esteja alinhada e seja gerada por uma consulta com uma janela de alinhamento explícita. Isso é fornecido por um argumento de janela para uma operação de alinhamento (por exemplo, | align rate(10m)) ou por uma operação de tabela window.

Exemplos:

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

Isso produzirá uma tabela com duas colunas de valor. A primeira coluna é Bool que será verdadeira se a coluna de valor usage_time da tabela de entrada for menor que .5. A segunda coluna é uma cópia da coluna de valor usage_time da entrada.

absent_for Crie uma condição para a ausência de entrada.


Assinatura:   Table   | absent_for   lit-Duration

A operação de tabela absent_for gera uma tabela com duas colunas de valor, active e signal. A coluna active é verdadeira quando há dados ausentes na entrada da tabela e falsa quando não há. Isso é útil para criar uma consulta de condição a ser usada para alertar sobre a ausência de entradas.

Para cada série temporal de entrada, absent_for cria uma série temporal alinhada com o mesmo identificador de série temporal que a entrada. O período de alinhamento é fornecido por um every a seguir ou é o período padrão.

O argumento Duration fornece um limite de tempo. A coluna active de um ponto de saída será falsa se houver um ponto na série temporal de entrada que esteja dentro desse limite de tempo antes do horário do ponto de saída. Se não houver um ponto de entrada assim, a coluna active será verdadeira, indicando uma ausência de entrada dentro do limite de tempo.

Se a tabela de entrada tiver colunas de valor, a coluna signal conterá o valor da primeira coluna de valor do ponto de entrada mais recente (dentro do limite ou não) na série temporal de entrada. Se a tabela de entrada não tiver colunas de valor, a coluna signal no ponto de saída será um número inteiro, fornecendo o número de minutos desde o último ponto de entrada.

Para cada hora do ponto de saída, a operação da tabela absent_for analisará um ponto de entrada 24 horas antes dessa hora. Se não houver um ponto de entrada nas últimas 24 horas, nenhum ponto será gerado.

Exemplos:

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

Para cada série temporal usage_time de uma máquina virtual (gce_instance), o absent_for gerará uma série temporal alinhada cujos pontos de saída terão uma coluna active que será verdadeira se houver um ponto de entrada nas últimas 24 horas, mas nenhum ponto nas últimas 8 horas (8h). Essa é uma consulta de alerta adequada.

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

Isso é semelhante ao exemplo anterior, mas o | value [] remove as colunas de valor da entrada para a operação absent_for. Assim, a coluna signal é definida para o tempo (em minutos ) desde o último ponto de entrada.

Diversos

ident operação da tabela de identidade: nenhuma alteração na tabela de entrada


Assinatura: Table   | ident

A operação de tabela ident produz uma tabela de entrada inalterada.

Exemplo:

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

Para cada linha na tabela fornecida, é calculada a razão entre o valor da linha e o valor total de todas as instâncias computa na zona em que a tabela se encontra.

ratio Calcula a proporção de colunas de valor de duas tabelas de entrada alinhadas.


Assinatura: Table ++   | ratio

A operação de tabela ratio usa duas tabelas de entrada alinhadas, a de numerador e a de denominador, respectivamente. As duas entradas de tabela precisam ter exatamente uma coluna de valor de um tipo numérico.

As colunas de identificador de série temporal da tabela de denominadores precisam ser um subconjunto das colunas de identificador de série temporal da tabela de numeradores hte. Se as duas tabelas tiverem as mesmas colunas de identificador de série temporal (nome e tipo), um valor padrão de zero será usado para o numerador ao calcular proporções.

filter_ratio Calcula a proporção de duas somas filtradas da coluna de valor de entrada.


Assinatura:   Table   | filter_ratio   Bool,   [ Bool ]

A operação de tabela filter_ratio usa uma tabela de entrada que tem exatamente uma coluna de valor de um tipo numérico. Se a tabela de entrada não estiver alinhada, então uma operação de tabela align será inserida automaticamente para realizar o alinhamento.

A operação filter_ratio agrega todas as linhas de entrada em um determinado carimbo de data/hora, calcula uma soma de numerador e denominador e produz uma série temporal com a proporção dessas somas em cada carimbo de data/hora. O primeiro argumento Bool controla o que vai para a soma do numerador e o segundo argumento Bool controla o que vai para a soma do denominador. O segundo argumento é opcional e o padrão é true, se não for fornecido.

Os argumentos Bool são avaliados para cada linha e, se verdadeiro, a coluna de valor dessa linha é incluída no numerador (primeiro Bool) ou denominador (segundo Bool) soma.

filter_ratio_by Calcula uma proporção agrupada de duas somas filtradas da coluna de valor de entrada.


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

A operação de tabela filter_ratio_by usa uma tabela de entrada que tem exatamente uma coluna de valor de um tipo numérico. Se a tabela de entrada não estiver alinhada, então uma operação de tabela align será inserida automaticamente para realizar o alinhamento.

A operação filter_ratio_by agrupa linhas que têm o mesmo identificador de série temporal calculado pelo argumento RowToTSID. Para cada grupo, ele calcula uma soma de numerador e denominador e produz uma série temporal com a proporção dessas somas em cada carimbo de data/hora. O primeiro argumento Bool controla o que vai para a soma do numerador e o segundo argumento Bool controla o que vai para a soma do denominador. O segundo argumento é opcional e o padrão é true, se não for fornecido.

Os argumentos Bool são avaliados para cada linha e, se verdadeiro, a coluna de valor dessa linha é incluída no numerador (primeiro Bool) ou denominador (segundo Bool) soma.

Uma série temporal é calculada para cada grupo, com o identificador de série temporal calculado pelo argumento RowToTSID.

Funções

Nesta seção, descrevemos cada uma das funções que podem ser usadas em expressões (expr) na linguagem de consulta do Monitoring.

  • Colunas de linha de entrada
    • val O valor de uma coluna de valor no ponto de entrada (linha).
    • end O horário de término do ponto de entrada (linha).
    • start O horário de início do ponto de entrada (linha).
    • older    Um valor do próximo ponto (linha) em uma série temporal.
    • adjacent_delta    A alteração no valor entre um ponto de entrada e um ponto anterior.
    • adjacent_rate    A taxa de alteração entre o ponto de entrada e o ponto anterior mais próximo (linhas).
    • hash_tsid Retorne um hash das colunas do identificador de série temporal.
  • Lógica
    • not A negação lógica de um valor booleano.
    • and A lógica e de dois valores booleanos.
    • or A lógica ou de dois valores booleanos.
    • true O valor booleano verdadeiro.
    • false O valor booleano falso.
    • has Verdadeiro se um argumento set contiver um valor específico.
    • has_value Verdadeiro se uma expressão de argumento calcular um valor.
    • if Um valor condicionalmente escolhido entre dois valores.
    • or_else Um valor ou, se não for um valor, outro valor.
  • Comparação
    • eq    Igual.
    • ne    Diferente.
    • ge    Maior que ou igual.
    • gt    Maior que.
    • le    Menor que ou igual.
    • lt    Menor que.
  • Aritmética
    • add A soma de dois números.
    • sub A diferença de dois números.
    • mul O produto de dois números.
    • div A proporção de dois números.
    • int_div O quociente da divisão de dois números inteiros.
    • abs    Valor absoluto.
    • neg O negativo de um número.
    • pos Identidade para entradas numéricas.
    • rem O restante da divisão de dois números inteiros.
  • Math
    • sqrt    Raiz quadrada.
    • log    Logaritmo natural.
    • exp e elevado a uma potência.
    • power Um número à potência de outro.
    • int_round    Número inteiro mais próximo.
    • int_floor Inteiro de limite inferior.
    • int_ceil Inteiro do limite superior.
  • String
  • Expressões regulares
    • re_full_match Verdadeiro se uma expressão regular corresponder a todo um valor de string.
    • re_partial_match Verdadeiro se uma expressão regular corresponder a alguma parte do valor da string.
    • re_extract Extraia valores correspondentes a uma expressão regular em outra string.
    • re_replace Substitua a primeira correspondência de uma expressão regular em outra string.
    • re_global_replace Substitua todas as correspondências de uma expressão regular em outra string.
  • Agregação
    • sum A soma de um grupo de valores numéricos.
    • distribution Uma distribuição de um grupo de valores numéricos ou de distribuição.
    • count A contagem do número de valores em um grupo de valores.
    • row_count O número de linhas de entrada encontradas.
    • count_true O número de valores verdadeiros em um grupo de valores booleanos.
    • min O mínimo de um grupo de valores numéricos.
    • max O máximo de um grupo de valores numéricos.
    • diameter O máximo menos o mínimo de um grupo de valores numéricos.
    • mean A média de um grupo de valores numéricos.
    • stddev O desvio padrão de um grupo de valores.
    • variance A variação de um grupo de valores numéricos.
    • covariance A covariância de um grupo de pares de valores.
    • median A mediana de um grupo de valores numéricos ou de distribuição.
    • percentile Um percentil de um grupo de valores numéricos ou de distribuição.
    • fraction_less_than A fração de um grupo de valores menor que um valor fixo.
    • fraction_true A fração de um grupo de valores booleanos que são verdadeiros.
    • any_true A disjeção de um grupo de valores booleanos.
    • all_true A combinação de um grupo de valores booleanos.
    • pick_any O valor de qualquer elemento de um grupo de valores (escolhido arbitrariamente).
    • singleton O valor do elemento de um grupo de valores com apenas um elemento.
    • unique O valor comum de um grupo de valores (que precisam ser todos iguais).
    • aggregate Valor agregado padrão de um grupo de valores de qualquer tipo.
    • weighted_distribution Uma distribuição de um grupo de valores ponderados.
  • Alinhamento
    • rate Calcule uma taxa de alteração em pontos alinhados no tempo.
    • delta Calcule a alteração no valor em pontos alinhados no tempo.
    • any_true_aligner    Para alinhar uma série temporal Bool, encontre qualquer valor verdadeiro em uma janela.
    • count_true_aligner    Para alinhar uma série temporal Bool, conte os valores verdadeiros em uma janela.
    • delta_gauge Calcule a alteração no valor em pontos alinhados no tempo como uma série temporal Gauge.
    • fraction_true_aligner    Alinhe uma série temporal Bool com a fração de valores verdadeiros em uma janela.
    • int_mean_aligner    Para alinhar, encontre a média dos valores Int em uma janela.
    • interpolate Calcule valores interpolados em pontos alinhados no tempo.
    • mean_aligner    Para alinhar, encontre a média dos valores em uma janela.
    • next_older    Pontos alinhados no horário ao passar de um período anterior para um posterior.
    • next_younger    Pontos alinhados no tempo ao mudar de um momento posterior para o anterior.
  • Como manipular unidades
    • scale    Dimensione um valor para uma unidade de medida diferente.
    • cast_units    Define a unidade de medida de um valor.
  • Janela periódica
    • window Indica uma janela igual ao período de alinhamento.
    • sliding Indica uma janela variável (sobreposta) em vez de separada.
  • Distribution
    • count_from O número de valores em um valor de distribuição.
    • sum_from A soma dos valores em um valor de distribuição.
    • mean_from A média dos valores em um valor de distribuição.
    • stddev_from O desvio padrão dos valores em um valor de distribuição.
    • variance_from A variação dos valores em um valor de distribuição.
    • median_from A mediana dos valores em um valor de distribuição.
    • percentile_from Um percentil dos valores em um valor de distribuição.
    • fraction_less_than_from A fração de valores em uma distribuição menor que um valor fixo.
    • bounded_percentile_from Um percentil dos valores dentro de um limite em um valor de distribuição.
    • rebucket Valor de distribuição convertido em uma nova especificação de bucket.
  • Especificadora de bucket
    • powers_of Uma especificação de bucket com limites exponenciais de bucket.
    • fixed_width Uma especificação de bucket com buckets de tamanho igual.
    • custom Uma especificação de bucket de uma lista de limites de bucket.
    • num_buckets Define o número de buckets em uma especificação de bucket.
    • bounds Define o limite inferior do primeiro bucket e o limite superior do último.
    • lower Define o limite inferior do primeiro bucket em uma especificação de bucket.
  • Disposições Gerais
    • cast_double Converta o valor Int em Double.
    • cast_gauge Transmita um valor de série temporal Cumulative ou Delta para Gauge.
    • within Especifica a janela do cálculo do valor de classificação.

Colunas de linha de entrada

As expressões em uma consulta operam nas colunas de uma linha de entrada. Uma coluna é normalmente acessada por meio do nome dela. As funções nesta seção fornecem maneiras alternativas de acessar colunas.

As colunas de tempo não têm nomes de coluna e são acessadas pelas funções start e end.

As colunas de valor podem ser acessadas por nome ou posição usando a função val.

A função older fornece acesso a uma coluna na linha seguinte em uma série temporal.

val O valor de uma coluna de valor no ponto de entrada (linha).


Assinatura: ImplicitRowInput   val([lit-Int ] )InputType     (entrada implícita de linha)

A função val fornece uma alternativa ao uso do nome da coluna ao acessar as colunas de valor de uma linha de entrada. O argumento Int (valor padrão 0) indexa o conjunto ordenado de colunas de valor (começando com 0 para a primeira coluna de valor) e retorna o valor da coluna de valor indexado. Esse é o mesmo valor resultante do uso do nome da coluna de valor.

Será um erro estático se a função val indicar um índice negativo ou for igual ou maior que ou igual ao número de colunas de valor.

end O horário de término do ponto de entrada (linha).


Assinatura: ImplicitRowInput   end( )Date.Gauge     (entrada implícita de linha)

A função end retorna o valor de data na coluna de hora de término da linha de entrada atual.

start O horário de início do ponto de entrada (linha).


Assinatura: ImplicitRowInput   start( )Date.Gauge     (entrada implícita de linha)

A função start retorna o valor de data na coluna de horário de início da linha de entrada atual. Se a linha não tiver um horário de início (porque ela contém apenas dados de Gauge), o horário de início retornará no-value.

older   Um valor do próximo ponto (linha) anterior em uma série temporal.


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

O argumento para older precisa ser um nome de coluna ou uma função que designa um valor de coluna (val, end, start). O valor retornado é o valor dessa coluna na linha que é posterior à linha de entrada na mesma série temporal. Se não houver uma linha anterior na mesma série temporal, older retornará no-value.

A coluna referenciada pode ser uma coluna de valor, hora ou identificador de série temporal. Se for uma coluna identificadora de série temporal, older retornará o mesmo valor da expressão do argumento, mesmo que não haja linha anterior na mesma série temporal.

adjacent_delta   A alteração no valor entre um ponto de entrada e um ponto anterior.


Assinatura: ImplicitRowInput   adjacent_delta( )InputType     (entrada de linha implícita)

A função adjacent_delta opera em tabelas com uma única coluna de valor numérica (Int ou Double) ou Distribution.

Se aplicado a uma série temporal Gauge, adjacent_delta retorna a diferença entre o valor da coluna de valor na linha de entrada atual e a coluna de valor na linha anterior mais próxima na mesma série temporal, se houver. Se não houver uma linha anterior na mesma série temporal, adjacent_delta retornará no-value. O resultado tem o tipo de série temporal Gauge.

Se aplicado a uma série temporal Delta, adjacent_delta retorna o valor da coluna de valor, que permanece um tipo de série temporal Delta. Cada ponto de saída tem o mesmo valor, horário de início e horário de término que o ponto de entrada foi gerado.

Embora as séries temporais Cumulative sejam raramente usadas em consultas, se aplicadas a uma série temporal Cumulative, adjacent_delta retorna um dos dois valores:

  • Se o horário de início do ponto de entrada for anterior ao horário de término do próximo ponto anterior, adjacent_delta retornará o valor do ponto de entrada menos o valor do ponto anterior.

  • Se o horário de início do ponto de entrada for posterior ao horário de término do ponto seguinte, adjacent_delta retornará o valor de pontos de entrada (subtraindo o valor de 0 no horário de início).

A série temporal resultante tem um tipo de série temporal Delta, e cada um indica uma hora de início que é a hora de início ou a data de término original do próximo ponto de entrada anterior, o que ocorrer depois.

adjacent_rate   A taxa de alteração entre o ponto de entrada e o ponto anterior mais próximo (linhas).


Assinatura: ImplicitRowInput   adjacent_rate( )Double.Gauge     (entrada implícita de linha)

A função adjacent_rate opera em tabelas com uma única coluna de valor numérica (Int ou Double) ou Distribution.

Se aplicado a uma série temporal Gauge ou Cumulative, adjacent_rate retorna a taxa de alteração entre o valor da coluna de valor na linha de entrada atual e a coluna de valor na linha anterior na série temporal, se houver. Essa é a diferença nos valores dividida pela diferença no horário de término das duas linhas. Se não houver linha anterior na mesma série temporal,adjacent_rate retornará no-value. O resultado tem o tipo de série temporal Gauge.

Se aplicado a uma série temporal Delta, adjacent_rate retornará a coluna de valor da linha de entrada atual dividida pela diferença entre a hora de início e a hora de término dessa linha.

hash_tsid Retorne um hash das colunas do identificador de série temporal.


Assinatura: ImplicitRowInput   hash_tsid([lit-Int ] )Int     (entrada implícita de linha)

A função hash_tsid retorna um hash dos valores nos campos do identificador de série temporal da linha de entrada atual. Se receber um argumento, ele será usado como uma sugestão para o hash.

Lógica

not A negação lógica de um valor booleano.


Assinatura: not(Bool )Bool

A função not usa um valor booleano e retorna verdadeiro se esse argumento for falso e retorna falso se esse argumento for verdadeiro. Se o argumento de entrada for nenhum valor, esse será o resultado.

and A lógica e de dois valores booleanos.


Assinatura: and(Bool,   Bool )Bool

A função and retornará verdadeiro se as duas entradas forem verdadeiras. Caso contrário, a função será falso. Se uma entrada for nenhum valor, and sempre retornará nenhum valor.

or A lógica ou de dois valores booleanos.


Assinatura: or(Bool,   Bool )Bool

A função or retornará verdadeiro se as duas entradas forem verdadeiras. Caso contrário, a função será falsa. Se uma entrada for nenhum valor, or sempre retornará nenhum valor.

true O valor booleano verdadeiro.


Assinatura: ImplicitRowInput   true( )lit-Bool     (entrada implícita de linha)

Essa função retorna o valor literal Bool true.

false O valor booleano false.


Assinatura: ImplicitRowInput   false( )lit-Bool     (entrada implícita de linha)

Essa função retorna o valor literal Bool false.

has Verdadeiro se um argumento de conjunto contiver um valor específico.


Assinatura: has(Set,   lit-ColumnValue )Bool

A função has retornará verdadeiro se o primeiro conjunto de argumentos tiver o segundo argumento como um elemento.

has_value Verdadeiro se uma expressão de argumento calcular um valor.


Assinatura: has_value(ColumnValue )Bool

A função has_value retorna verdadeiro se o argumento for avaliado como um valor e retorna falso se for avaliado como nenhum valor.

if Um valor condicionalmente escolhido entre dois valores.


Assinatura: if(Booleano,   ColumnValue.Delta,   ColumnValue.Delta(o mesmo) )LastArgType.Delta
if(Booleano,   ColumnValue,   ColumnValue(o mesmo) )LastArgType

A função if retorna o segundo ou terceiro argumento, dependendo do valor (true ou false) do primeiro argumento.

if avalia o primeiro argumento Bool. Se for nenhum valor, nenhum valor será o resultado. Se o primeiro argumento for verdadeiro, o segundo argumento será retornado e, se o primeiro argumento for falso, o terceiro argumento será retornado.

O segundo ou terceiro argumento pode ser sem valor, mas o resultado de if só será sem valor se o argumento Bool for sem valor ou se o argumento retornado for nenhum valor. O argumento que não está selecionado pode ser nenhum valor sem o resultado ser nenhum valor.

Se o segundo e o terceiro argumentos de if forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de if para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de if tem a unidade do segundo argumento, possivelmente escalonada.

or_else Um valor ou, se não for um valor, outro valor.


Assinatura: or_else(ColumnValue,   ColumnValue(o mesmo) )LastArgType

A função or_else retorna o valor do primeiro argumento, a menos que seja nenhum valor. Nesse caso, o valor do segundo argumento é retornado.

A função or_else só retorna nenhum valor se os dois argumentos forem nenhum valor.

Se os argumentos de or_else forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de or_else para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de or_else tem a unidade do primeiro argumento, possivelmente escalonada.

Comparação

Os operadores de comparação comparam dois valores do mesmo tipo ou dois valores numéricos (Int ou *Double) e retornam um valor Bool. Ao contrário da maioria das funções, os operadores de comparação nunca retornam nenhum valor. Se uma entrada não tiver valor, ela será considerada um valor específico maior do que qualquer outro valor.

eq   Igual.


Assinatura:   eq(Num,   Num )   →   Bool
          eq(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo Comparable e retorna true se forem iguais e false se não forem iguais. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, true se ambos os valores forem nenhum valor e false caso contrário. Isso trata nenhum valor igual a si mesmo.

Para uma comparação sobre argumentos numéricos, se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades, e as unidades precisarão ser equivalentes. Como resultado, o tipo Bool não terá unidades. Se os argumentos de eq têm unidades não equivalentes que têm a mesma dimensão, um argumento poderá ter a unidade dele escalonada automaticamente para que as unidades dos dois argumentos sejam equivalentes.

Se os argumentos de eq forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de eq para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de "eq", do tipo Bool, não terá unidades.

Uma comparação entre a coluna resource.project_id e uma string literal tem tratamento especial para lidar com a diferença entre os números e os nomes dos projetos, conforme descrito em Correspondência da coluna resource.project_id.

ne   Diferente.


Assinatura:   ne(Num,   Num )   →   Bool
          ne(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo Comparable e retorna false se forem iguais e true se não forem iguais. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, false se ambos os valores forem nenhum valor e false caso contrário. Isso trata nenhum valor igual a si mesmo.

Se os argumentos de ne forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de ne para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de "ne", do tipo Bool, não terá unidades.

Uma comparação entre a coluna resource.project_id e uma string literal tem tratamento especial para lidar com a diferença entre os números e os nomes dos projetos, conforme descrito em Correspondência da coluna resource.project_id.

ge Maior que ou igual.


Assinatura:   ge(Num,   Num )   →   Bool
          ge(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo argumento Comparable e retorna true se o primeiro for maior ou igual ao segundo e false caso contrário. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, true se o primeiro valor for nenhum valor e false caso contrário. Isso trata nenhum valor como maior que qualquer outro valor.

Se os argumentos de ge forem numéricos e um deles tiver unidades, ambos precisarão ter unidades. Se os argumentos tiverem unidades, elas precisarão ser equivalentes. Se as unidades não forem equivalentes, mas tiverem a mesma dimensão, um dos argumentos pode ser dimensionado automaticamente para ter as mesmas unidades que as outras descritas aqui. Será um erro se apenas um dos argumentos tiver unidades ou se os argumentos tiverem unidades não equivalentes e nenhuma alteração for feita.

O resultado de "ge", do tipo Bool, não terá unidades.

gt   Maior que.


Assinatura:   gt(Num,   Num )   →   Bool
          gt(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo argumento Comparable e retorna true se o primeiro for maior que o segundo e false caso contrário. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, false se o segundo valor for nenhum valor e true caso contrário. Isso trata nenhum valor como maior que qualquer outro valor.

Se os argumentos de gt forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de gt para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de "gt", do tipo Bool, não terá unidades.

le Menor que ou igual.


Assinatura:   le(Num,   Num )   →   Bool
          le(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo argumento Comparable e retorna true se o primeiro for menor ou igual ao segundo e false caso contrário. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, true se o segundo valor for nenhum valor e false caso contrário. Isso trata nenhum valor como maior que qualquer outro valor.

Se os argumentos de le forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de le para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de "le", do tipo Bool, não terá unidades.

lt   Menor que.


Assinatura:   lt(Num,   Num )   →   Bool
          lt(Comparável,   Comparável(igual) )   →   Bool

Isso compara o primeiro argumento Comparable com o segundo argumento Comparable e retorna true se o primeiro for menor que o segundo e false caso contrário. Se um argumento for Int e o outro Double, o argumento Int será convertido em um valor Double antes da comparação.

Se uma entrada for nenhum valor, a comparação será feita e um argumento Bool será retornado, false se o primeiro valor for nenhum valor e true caso contrário. Isso trata nenhum valor como maior que qualquer outro valor.

Se os argumentos de lt forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de lt para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de "lt", do tipo Bool, não terá unidades.

Aritmética

Funções que implementam os operadores aritméticos.

add A soma de dois números.


Assinatura:   add(Num.Delta,   Num.Delta )   →   Num.Delta
          add(Num,   Num )   →   Num
          add(Duration,   Duration )   →   Duration
          add(Date,   Duration )   →   Date
          add(Duration,   Date )   →   Date

A função add em dois argumentos Num retorna a soma dos argumentos, como um valor Double se uma entrada for um valor Double e como um valor Int caso contrário. Se as duas entradas forem do tipo de série temporal Delta, a saída será do tipo Delta. Caso contrário, a saída será do tipo de série temporal Gauge.

A função add nos dois argumentos Duration retorna a duração que é a soma.

A função add em um argumento Date e Duration retorna a data que é a duração posterior à data. Se a Duration for negativa, o resultado será anterior a Date de entrada (volta no tempo).

Se os argumentos de add forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de add para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de add tem a unidade do primeiro argumento, possivelmente escalonada.

sub A diferença de dois números.


Assinatura:   sub(Num.Delta,   Num.Delta )   →   Num.Delta
          sub(Num,   Num )   →   Num
          sub(Duration,   Duration )   →   Duration
          sub(Date,   Duration )   →   Date
          sub(Date,   Date )   →   Duration

A função sub em dois argumentos Num retorna o primeiro argumento menos o segundo argumento, como um valor Double se uma entrada for um Double e como Int caso contrário. Se as duas entradas forem do tipo de série temporal Delta, a saída será do tipo Delta. Caso contrário, a saída será do tipo de série temporal Gauge.

Os argumentosDuration da função sub dois retorna a duração que é a diferença numérica deles.

A função sub em um argumento Date e Duration retorna a data que é a Duration anterior ao argumento Date. Se o argumento Duration for negativo, o resultado será posterior ao argumento Date.

Se os argumentos de sub forem numéricos e se qualquer um deles tiver unidades, os dois argumentos precisarão ter unidades. Se os argumentos tiverem unidades, eles precisarão ser equivalentes ou as regras aqui precisarão permitir que um dos argumentos seja dimensionado antes da aplicação de sub para que as unidades sejam equivalentes. Será um erro se apenas um argumento tiver unidades ou se os dois argumentos tiverem unidades que não podem se tornar equivalentes.

O resultado de sub tem a unidade do primeiro argumento, possivelmente escalonada.

mul O produto de dois números.


Assinatura:   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

A função mul em dois argumentos Num retorna o produto dos dois argumentos, como um valor Double se uma entrada for um valor Double e como um valor Int caso contrário. Se uma entrada for do tipo Delta e a outra for um literal, a saída será Delta. Caso contrário, a saída será do tipo de série temporal Gauge.

A função mul em um Num e Duration é a Duration multiplicado pelo valor Num como um tipo Duration.

Se um argumento numérico tiver unidades, os dois argumentos precisarão ter unidades e as unidades precisarão ser equivalentes. A unidade do resultado, se os argumentos tiverem unidades, será o produto das unidades dos dois argumentos. A única exceção é a multiplicação por um literal: o literal pode não ter uma unidade de medida fornecida explicitamente. Portanto, se o outro argumento tiver uma unidade de medida, a unidade 1 será fornecida para o literal, fazendo com que o resultado tenha as unidades do outro argumento.

div A proporção de dois números.


Assinatura:   div(Num.Delta,   lit-Num )   →   Double.Delta
          div(Num,   Num )   →   Double
          div(Duration,   Num )   →   Duration
          div(Duration,   Duration )   →   Double
          div(Date,   Duration )   →   Double

A função div divide o primeiro argumento Num pelo segundo argumento Num, retornando a proporção como um valor Double.

Ele não produzirá um resultado se o segundo argumento Num for 0.

A função div divide o primeiro argumento pelo segundo, retornando a proporção como um valor Double. Quando um argumento é um Date ou Duration, o valor é representado como um valor duplo que é Date ou Duration em unidades que representam a precisão interna total desses valores. Se o resultado for Date ou Duration, a proporção será interpretada como um valor com as mesmas unidades, arredondado para o valor mais próximo que uma Date ou Duration possa representar.

No caso de um valor Date dividido por um valor de Duration, o resultado é o valor Double, que é o número do período dessa Duration desde a época Unix (d'1970/01/01-00:00:00+00:00'). Então, d'2020/06/01-01:20:03' / 1s é o número de segundos desde d'1970/01/01-00:00:00+00:00' em d'2020/06/01-01:20:03'.

A função div não produzirá um resultado se o segundo argumento for 0.

Se qualquer argumento numérico tiver unidades, os dois argumentos precisarão ter unidades. A unidade do resultado, se os argumentos tiverem unidades, será a divisão da unidade do primeiro argumento pela unidade do segundo. A única exceção é a divisão por um literal: o literal pode não ter uma unidade de medida fornecida explicitamente. Portanto, se o outro argumento tiver uma unidade de medida, a unidade 1 será fornecida para o literal, fazendo com que o resultado tenha as unidades do outro argumento.

int_div O quociente da divisão de dois números inteiros.


Assinatura:   int_div(Int,   Int )   →   Int
          int_div(Duration,   Int )   →   Duration
          int_div(Duration,   Duration )   →   Int
          int_div(Date,   Duration )   →   Int

A função int_div divide o primeiro argumento pelo segundo argumento, retornando o quociente como um valor Int. Quando um argumento é um Date ou Duration, o valor é representado como um valor inteiro que é Date ou Duration em unidades que representam a precisão interna total desses valores. Se o resultado for Date ou Duration, o quociente numérico será interpretado como um valor com as mesmas unidades.

No caso de um valor Date dividido por um valor de Duration, o resultado é o valor Int, que é o número do período dessa Duration desde a época Unix (d'1970/01/01-00:00:00+00:00'). Então, d'2020/06/01-01:20:03' / 1s é o número de segundos desde d'1970/01/01-00:00:00+00:00' em d'2020/06/01-01:20:03'.

A função int_div não produzirá um resultado se o segundo argumento for 0.

Se qualquer argumento numérico tiver unidades, os dois argumentos precisarão ter unidades. A unidade do resultado, se os argumentos tiverem unidades, será a divisão da unidade do primeiro argumento pela unidade do segundo. A única exceção é a divisão por um literal: o literal pode não ter uma unidade de medida fornecida explicitamente. Portanto, se o outro argumento tiver uma unidade de medida, a unidade 1 será fornecida para o literal, fazendo com que o resultado tenha as unidades do outro argumento.

abs Valor absoluto.


Assinatura:   abs(Num )   →   Num

A função abs usa uma entrada numérica (Int ou *Double) e retorna um valor do mesmo tipo que tem a mesma magnitude que a entrada e não é negativo.

O resultado de abs tem a mesma unidade de medida.

neg O negativo de um número.


Assinatura:   neg(Num )   →   Num
          neg(Duration )   →   Duration

A função neg retorna o negativo do argumento.

pos Identidade para entradas numéricas.


Assinatura:   pos(Num )   →   Num
          pos(Duration )   →   Duration

A função pos retorna um único argumento

rem O restante da divisão de dois números inteiros.


Assinatura:   rem(Int,   Int )   →   Int
          rem(Duration,   Duration )   →   Duration

A função rem divide o primeiro argumento Int pelo segundo argumento Int, retornando o restante como um valor Int.

Ele não produzirá um resultado se o segundo argumento Num for 0.

A unidade de medida anexada ao resultado de Rem é a mesma que a unidade, se houver, do primeiro argumento.

Matemática

Algumas funções matemáticas.

sqrt   Raiz quadrada.


Assinatura:   sqrt(Num )   →   Double

A função sqrt retorna a raiz quadrada do argumento Num como um valor Double.

A sqrt não produzirá um resultado se o argumento Num for menor que 0.

O resultado de sqrt não tem uma unidade de medida.

log   Logaritmo natural.


Assinatura:   log(Num )   →   Double

A função log retorna o logaritmo natural do argumento Num como um valor Double.

O log não produzirá um resultado se o argumento Num for menor ou igual a 0.

O resultado de log não tem uma unidade de medida.

exp "E" elevado a uma potência.


Assinatura:   exp(Num )   →   Double

O exp retorna "e" (a base de logaritmos naturais) elevado à potência do argumento Num como um valor Double.

As funções exp retornam o infinito de valor duplo no overflow.

O resultado de exp não tem uma unidade de medida.

power Um número à potência de outro.


Assinatura:   power(Num,   Num )   →   Double

Isso retorna o valor do primeiro argumento Num, elevado à potência do segundo argumento Num, representado como um valor Double. Se um dos argumentos for um Int, ele será convertido em um Double antes da operação.

O resultado de power não tem uma unidade de medida.

int_round   Número inteiro mais próximo.


Assinatura:   int_round(Double )   →   Int

A função int_round usa um valor Double, o arredonda para o valor inteiro mais próximo e o retorna como um valor Int. Se a entrada não for um valor ou o resultado não puder ser representado como um valor Int, o resultado será nenhum valor.

O resultado de int_round tem a mesma unidade de medida da entrada.

int_floor Inteiro do limite inferior.


Assinatura:   int_floor(Double )   →   Int

A função int_floor usa um valor Double, arredondando-o para o valor infinito mais próximo e o retorna como um valor Int. Se a entrada não for um valor ou o resultado não puder ser representado como um valor Int, o resultado será nenhum valor.

O resultado de int_floor tem a mesma unidade de medida da entrada.

int_ceil Número inteiro do limite superior.


Assinatura:   int_ceil(Double )   →   Int

A função int_ceil usa um valor Double, o arredonda para o infinito mais próximo e o retorna como um valor Int. Se a entrada for nenhum valor ou o resultado não puder ser representado como um valor Int, o resultado será nenhum valor.

O resultado de int_ceil não tem uma unidade de medida.

String

Funções que processam valores String.

concatenate Concatenação de strings.


Assinatura:   concatenate(String,   String )   →   String

A função concatenate retorna a concatenação dos dois argumentos String.

string_to_double Converte String em Double.


Assinatura:   string_to_double(String )   →   Double

A função string_to_double analisa o argumento String de entrada como um número de ponto flutuante e retorna o resultado como um valor Double. Se a string não for um valor de ponto flutuante válido, o resultado será nenhum valor.

O resultado de string_to_double não tem uma unidade de medida.

string_to_int64 Converte String em Int.


Assinatura:   string_to_int64(String )   →   Int

A função string_to_int64 analisa o argumento String de entrada como um número inteiro e retorna o resultado como um valor Int. Se a string não for um valor inteiro válido ou não puder ser representada como um valor Int, o resultado será nenhum valor.

O resultado de string_to_int64 não tem uma unidade de medida.

ascii_to_lower Altere caracteres de letras maiúsculas ASCII para minúsculas.


Assinatura:   ascii_to_lower(String )   →   String

A função ascii_to_upper usa um argumento String e retorna um valor String que é o mesmo, exceto que cada letra ASCII maiúscula foi convertida na letra ASCII minúscula correspondente. Todos os outros caracteres permanecem inalterados.

ascii_to_upper Altere caracteres de letras minúsculas ASCII para maiúsculas.


Assinatura:   ascii_to_upper(String )   →   String

A função ascii_to_upper usa um argumento String e retorna um valor String que é o mesmo, exceto que cada letra ASCII minúscula foi convertida na letra ASCII maiúscula correspondente. Todos os outros caracteres permanecem inalterados.

utf8_normalize String Unicode adequada para comparação de letras maiúsculas e minúsculas.


Assinatura:   utf8_normalize(String )   →   String

A função utf8_normalize usa um argumento String e retorna um valor String adequado para comparação entre maiúsculas e minúsculas do valor de entrada sob a suposição de que a entrada é codificada em utf8 string.

Expressões regulares

Funções que fazem correspondência, extração e modificação usando expressões regulares RE2.

re_full_match Verdadeiro se uma expressão regular corresponder a todo o valor de uma string.


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

A função re_partial_match usa uma entrada de string e uma expressão regular de string literal e retorna true se toda a string de entrada for correspondida pela expressão regular. Caso contrário, ele retorna false, mesmo que o argumento da string de entrada seja nenhum valor.

Uma correspondência de expressão regular na coluna resource.project_id tem um tratamento especial para lidar com a diferença entre os números e os nomes do projeto, conforme descrito em Como fazer correspondência com resource.project_id a coluna.

re_partial_match Verdadeiro se uma expressão regular corresponder a alguma parte do valor da string.


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

A função re_partial_match usa uma entrada de string e uma expressão regular de string literal e retorna true se qualquer parte da string de entrada for correspondida pela expressão regular. Caso contrário, retorna false, mesmo que o argumento da string seja nenhum valor.

re_extract Extraia valores correspondentes a uma expressão regular em outra string.


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

A função re_extract usa um argumento String de entrada e dois argumentos String literais: uma expressão regular e uma string de substituição. O resultado é formado pela correspondência da string de entrada com a expressão regular e pelos grupos de captura substitutos na expressão na string de substituição. A string de substituição com os grupos de captura substituídos é o resultado.

Se o argumento de expressão regular não for fornecido, o padrão será "(.*)", Incluindo toda a primeira string de argumento em um grupo de captura.

Se o argumento da string de substituição não for fornecido, o padrão será R"\ 1", tornando o primeiro grupo de substituição a string de saída.

Se a string de entrada for nenhum valor, se a expressão regular não corresponder ou se a substituição de grupos de captura não funcionar, nenhum valor será retornado.

re_replace Substitua a primeira correspondência de uma expressão regular em outra string.


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

A função re_replace usa um argumento String de entrada e dois argumentos String literais: uma expressão regular e um valor de substituição. Se a expressão regular corresponder a qualquer parte da string de entrada, o valor retornado será formado substituindo a primeira correspondência na string de entrada pela string de substituição.

Se a string de entrada for no-value ou se não houver correspondência, a string de entrada será o valor retornado.

re_global_replace Substitua todas as correspondências de uma expressão regular em outra string.


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

A função re_global_replace usa um argumento String de entrada e dois argumentos String literais: uma expressão regular e um valor de substituição. O resultado é formado a partir da string de entrada substituindo cada correspondência separada da expressão regular (da esquerda para a direita) pela string de substituição.

Se a string de entrada for nenhum valor ou se não houver correspondência, a string de entrada será o valor retornado.

Agregação

Uma função de agregação combina um conjunto de valores de entrada em um valor de saída final. Eles são usados quando várias linhas de entrada são agrupadas e agregadas em uma única linha de saída.

Uma função de agregação mantém um estado interno de agregação. A expressão do argumento para a função de agregação é avaliada uma vez para cada uma das linhas de entrada agrupadas e o valor resultante (se houver) é passado para a função de agregação a ser acumulada no estado interno. Depois que isso for feito para todas as linhas do grupo, a função de agregação produzirá o valor de saída a ser usado na criação de colunas de valor na linha de saída única.

Por exemplo, mean(memory_usage) aplicado a um conjunto de linhas com uma coluna memory_usage, avalia a expressão de argumento, memory_usage, para cada linha e incorpora o valor resultante (se um for produzido) no estado interno da função de agregação mean (que pode ser uma soma de valores e uma contagem de valores). Depois que todas as linhas forem processadas, o redutor mean produzirá um valor a partir do estado interno dele (a soma dividida pela contagem).

A maioria das funções de agregação que operam em valores numéricos ou de distribuição oferecem a unidade de medida da entrada para a saída. Veja a seguir as exceções:

  • count e row_count com saída que tem a unidade 1.

  • variance em que a saída é o quadrado da entrada?

  • covariance em que a saída é o produto das unidades das duas entradas.

  • fraction_less_than e fraction_true atribuem a unidade 10^2.% à saída.

sum A soma de um grupo de valores numéricos.


Assinatura:   sum(Num )   →   Num.Delta     (somente temporais)
          sum(Distribution )   →   Double.Delta     (somente temporais)
          sum(Num )   →   Num.Gauge     (sliding temporal only)
          sum(Distribution )   →   Double.Gauge     (somente temporais variáveis)
          sum(Num )   →   Num.FirstArgKind
          sum(Distribution )   →   Double.FirstArgKind

Se a expressão do argumento for numérica (Int ou *Double), isso retornará a soma dos valores passados para ela.

Se a expressão do argumento for um valor do tipo Distribution, a função retornará a soma dos valores de população em todos os valores Distribution que são passados para ela.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará a soma.

Para entrada numérica (Int ou Double), o resultado é do mesmo tipo ( Int* ou Double) que a expressão de entrada. Para valores de entrada de Distribution, o tipo de resultado é Double.

A saída tem o tipo de série temporal Delta se agregações temporais invariáveis ou apenas agregação espacial e o tipo de série temporal de entrada também é Delta.

A unidade de medida anexada ao resultado de sum é a mesma que a unidade da entrada.

distribution Uma distribuição de um grupo de valores numéricos ou de distribuição.


Assinatura:   distribution(Num,   lit-BucketSpecification )   →   Distribution.Delta     (somente temporais)
          distribution(Num,   lit-BucketSpecification )   →   Distribution.Gauge
          distribution(Distribution )   →   Distribution.Delta     (somente temporais)
          distribution(Distribution )   →   Distribution.Gauge     (somente temporais variáveis)
          distribution(Distribution )   →   Distribution.FirstArgKind

Se o primeiro argumento for um valor Num, os valores de entrada serão coletados em um resultado de distribuição cuja especificação de bucket é fornecida pelo argumento lit-Bucketer.

Se o primeiro argumento for um valor Distribution, as distribuições serão mescladas em um resultado de distribuição que inclui a população de todas as distribuições de entrada. A especificação do bucket de distribuição resultante é determinada a partir das especificações do bucket de distribuição de entrada. Se as especificações do bucket forem todas iguais, essa especificação será usada. Se houver uma especificação de bucket diferente, uma nova especificação mesclada será usada. Essa especificação mesclada normalmente não é mais precisa do que a especificação do bucket de entrada menos precisa.

Se, para alguma linha de entrada, a primeira expressão de argumento não for avaliada para um valor ou para um Double não finito, essa linha de entrada não afetará o percentil.

A unidade de medida anexada ao resultado de distribution é a mesma que a unidade de entrada.

count A contagem do número de valores em um grupo de valores.


Assinatura:   count(ColumnValue )   →   Int.Delta     (somente temporais)
          count(ColumnValue )   →   Int.Gauge

Retorna a contagem do número de valores que foram passados para a função. Se a expressão do argumento não for avaliada como um valor para alguma linha de entrada ou for avaliada como um valor Double não finito, ela não será contada.

A saída terá o tipo de série temporal Delta quando a agregação temporária não variável estiver sendo feita.

A unidade de medida anexada ao resultado de count é 1.

row_count O número de linhas de entrada encontradas.


Assinatura:   ImplicitRowSetInput   row_count( )   →   Int.Delta     (somente temporal)
          ImplicitRowSetInput   row_count( )   →   Int.Gauge

A função de agregação row_count retorna a contagem do número de linhas que estão sendo agregadas. Ao contrário de count, row_count não aceita um argumento e não se importa se um valor pode ser calculado a partir da linha.

A saída terá o tipo de série temporal Delta quando a agregação temporária não variável estiver sendo feita.

A unidade de medida anexada ao resultado de count é 1.

count_true O número de valores verdadeiros em um grupo de valores booleanos.


Assinatura:   count_true(Bool )   →   Int.Delta     (somente temporal)
          count_true(Bool )   →   Int

Os valores booleanos de entrada são coletados, e o resultado é o número de valores de entrada verdadeiros.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A saída terá o tipo de série temporal Delta quando a agregação temporária não variável estiver sendo feita.

A unidade de medida anexada ao resultado de count_true é 1.

min O mínimo de um grupo de valores numéricos.


Assinatura:   min(Num )   →   Num

Isso coleta os valores numéricos que são passados para ele e retorna o valor mínimo. Se o tipo de resultado for o mesmo que o tipo de entrada.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de min é a mesma que a unidade de entrada.

max O máximo de um grupo de valores numéricos.


Assinatura:   max(Num )   →   Num

Coleta os valores numéricos que são transmitidos e retorna o valor máximo. Se o tipo de resultado for o mesmo que o tipo de entrada.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de max é a mesma que a unidade de entrada.

diameter O máximo menos o mínimo de um grupo de valores numéricos.


Assinatura:   diameter(Num )   →   Num

Isso coleta os valores numéricos que são passados para ele e retorna a diferença entre o máximo dos valores e o mínimo dos valores. Se o tipo de resultado for o mesmo que o tipo de entrada (Int ou Double).

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de diameter é a mesma que a unidade de entrada.

mean A média de um grupo de valores numéricos.


Assinatura:   mean(Summable )   →   Double

Se a expressão do argumento for numérica (Int ou *Double), isso retornará a média dos valores passados para ela.

Se a expressão do argumento for do tipo Distribution, isso retornará a média de todos os valores em todas as distribuições.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará a média.

A unidade de medida anexada ao resultado de mean é a mesma que a unidade da entrada.

stddev O desvio padrão de um grupo de valores.


Assinatura:   stddev(Summable )   →   Double

Se a expressão do argumento for numérica (Int ou *Double), isso retornará o desvio padrão dos valores que são passados para ela.

Se a expressão do argumento for um valor de Distribution, isso retornará o desvio padrão de todos os valores em todas as distribuições.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará o desvio padrão.

A unidade de medida anexada ao resultado de stddev é a mesma que a unidade da entrada.

variance A variação de um grupo de valores numéricos.


Assinatura:   variance(Summable )   →   Double

Se a expressão do argumento for numérica (Int ou *Double), isso retornará a variação dos valores passados para ela.

Se a expressão do argumento for do tipo Distribution, isso retornará a variação de todos os valores em todas as distribuições.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará a variância.

Não há uma unidade de medida anexada ao resultado da função variance.

covariance A covariância de um grupo de pares de valores.


Assinatura:   covariance(Num,   Num )   →   Double

Isso retorna a covariância dos pares de valores numéricos (Int ou *Double) que são passados para ele.

Se, para alguma linha de entrada, qualquer expressão de argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará a covariância.

Não há uma unidade de medida anexada ao resultado da função covariance.

median A mediana de um grupo de valores numéricos ou de distribuição.


Assinatura:   median(Summable )   →   Double

Se a expressão do argumento for numérica (Int ou *Double), isso retornará uma estimativa da mediana da população de valores que são passados para ela. A mediana é calculada criando um valor de distribuição a partir dos valores na população com limites de intervalo que são 10% separados, o que limita o erro na estimativa por esse valor.

A especificação de bucket usada para acomodar um valor de Distribuição da entrada numérica para estimar que um metan é powers_of(1.05).num_buckets(500).lower(.01). Isso inclui um intervalo de valores de .01 a cerca de 4e+8. Embora isso processe muitos casos de uso, pode ser necessário usar a função scale para ajustar a entrada, por exemplo, de By para MiBy ou "MBy" se o intervalo de número de bytes estará no intervalo de gigabytes ou terabytes.

Se a expressão do argumento for um valor de Distribution, isso retornará uma estimativa da mediana da população mesclada de valores de todas as distribuições. A mediana é calculada mesclando todas as distribuições de entrada em uma distribuição e estimando a mediana. A precisão da mediana dependerá dos limites do bucket das distribuições de entrada.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor ou for avaliada como um valor Double não finito, essa linha de entrada não afetará o desvio padrão.

A unidade de medida anexada ao resultado de median é a mesma que a unidade da entrada.

percentile Um percentil de um grupo de valores numéricos ou de distribuição.


Assinatura:   percentile(Summable,   lit-Num )   →   Double

O argumento lit-Num fornece um percentil (no intervalo de 0 a 100).

Se a primeira expressão de argumento for numérica (Int ou Double), isso retornará uma estimativa desse percentil da população de valores passados para ela. O percentil é calculado com a criação de um valor de distribuição a partir dos valores na população com limites de bucket que são 10% separados, o que limita o erro na estimativa por esse valor.

A especificação do bucket usada para acomodar um valor de Distribuição da entrada numérica para estimar um percentil é powers_of(1.05).num_buckets(500).lower(.01). Isso inclui um intervalo de valores de .01 a cerca de 4e+8. Embora isso processe muitos casos de uso, pode ser necessário usar a função scale para ajustar a entrada, por exemplo, de By para MiBy ou "MBy" se o intervalo de número de bytes estará no intervalo de gigabytes ou terabytes.

Se a expressão do argumento for um valor de Distribuição, isso retornará uma estimativa do percentil da população mesclada de valores de todas as distribuições. O percentil é calculado mesclando todas as distribuições de entrada em uma distribuição e estimando o percentil. A precisão do percentil dependerá dos limites do bucket das distribuições de entrada.

Se, para alguma linha de entrada, a primeira expressão de argumento não for avaliada para um valor ou para um Double não finito, essa linha de entrada não afetará o percentil.

A unidade de medida anexada ao resultado de percentile é a mesma que a unidade de entrada.

fraction_less_than A fração de um grupo de valores menor que um valor fixo.


Assinatura:   fraction_less_than(Summable,   lit-Num )   →   Double

Se o primeiro argumento for numérico (Int ou *Double), isso retorna a fração da coleção de valores passados para o primeiro argumento que é menor que o argumento lit-Num. Ao calcular essa fração, a função ignora os valores do tipo Double não finitos e valores Int e Double que não são valores.

Se o primeiro argumento for um valor de Distribution, ele combina as populações de todas as distribuições que são passadas e faz uma estimativa da fração dos valores na distribuição dessa distribuição agregada que são menores que o valor do argumento lit-Num.

A unidade de medida anexada ao resultado de fraction_less_than é 10^2.%.

fraction_true A fração de um grupo de valores booleanos que são verdadeiros.


Assinatura:   fraction_true(Bool )   →   Double

Os valores booleanos de entrada são coletados, e o resultado é um Double no intervalo de 0 a 1, que é a fração dos valores de entrada verdadeiros.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de fraction_true é 10^2.%.

any_true A disjunção de um grupo de valores booleanos.


Assinatura: any_true(Bool )Bool

A função any_true calculará o valor true se todos os valores de entrada forem true e retornará false.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

all_true A combinação de um grupo de valores booleanos.


Assinatura: all_true(Bool )Bool

A função all_true calculará o valor true se todos os valores de entrada forem true e retornará false.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

pick_any O valor de qualquer elemento de um grupo de valores (escolhido arbitrariamente).


Assinatura:   pick_any(ColumnValue )   →   FirstArgType

Essa função retorna um dos valores que lhe foram fornecidos, escolhido arbitrariamente.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de pick_any é a mesma que a unidade de entrada, se houver.

singleton O valor do elemento de um grupo de valores com apenas um elemento.


Assinatura:   singleton(ColumnValue )   →   FirstArgType

Essa função retorna o valor da expressão do argumento, conforme avaliado em uma única linha. É um erro se a expressão do argumento for avaliada e produzir um valor para mais de uma linha, mesmo que ela seja avaliada como um valor produzido anteriormente.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de singleton é a mesma que a unidade de entrada.

unique O valor comum de um grupo de valores (que precisam ser todos iguais).


Assinatura:   unique(Comparable )   →   FirstArgType

A função unique retorna o valor que é igual a cada valor que foi fornecido a ela. Se esse valor não existir, caso dois valores diferentes, pelo menos, foram fornecidos, ela gerará um erro e retornará um dos valores.

Se, para alguma linha de entrada, a expressão do argumento não for avaliada como um valor, essa linha de entrada não afetará o resultado.

A unidade de medida anexada ao resultado de unique é a mesma que a unidade da entrada.

aggregate Valor agregado padrão de um grupo de valores de qualquer tipo.


Assinatura:   aggregate(Num )   →   Num.Delta     (somente temporal)
          aggregate(Distribution )   →   Distribution.Delta     (somente temporal)
          aggregate(Num )   →   Num.Gauge     (somente temporal variável)
          aggregate(Distribution )   →   Distribution.Gauge     (somente temporal variável)
          aggregate(Num )   →   Num.FirstArgKind
          aggregate(Distribution )   →   Distribution.FirstArgKind
          aggregate(Bool )   →   Bool
          aggregate(String )   →   String

A função aggregate faz uma agregação que depende do tipo de entrada.

  • Para as entradas Int e Double, é igual ao agregador sum.

  • Para a entrada Distribution, é igual ao agregador distribution.

  • Para a entrada Bool, é igual ao agregador any_true.

  • Para a entrada String, é igual ao agregador pick_any.

weighted_distribution Uma distribuição de um grupo de valores ponderados.


Assinatura:   weighted_distribution(Num,   Int,   lit-BucketSpecification )   →   Distribution.Delta     (somente temporal)
          weighted_distribution(Num,   Int,   lit-BucketSpecification )   →   Distribution.Gauge

Os valores de entrada são coletados em um resultado de distribuição cuja especificação de bucket é fornecida pelo argumento lit-Bucketer. O primeiro argumento é o valor a ser adicionado à distribuição, e o segundo argumento é o peso desse valor. Um valor N com ponderação M é representado por M instâncias de valor N na distribuição.

Se, para alguma linha de entrada, a primeira ou a segunda expressão do argumento não for avaliada como um valor ou for avaliada como um Double não finito, essa linha de entrada não afetará o percentil.

A unidade de medida anexada ao resultado de weighted_distribution é a mesma que a unidade de entrada.

Alinhamento

As funções de alinhamento são usadas pela operação de tabela align para produzir uma tabela alinhada, uma série cujas pontuações temporais têm pontos com carimbos de data/hora em intervalos regulares.

Além do seu argumento Duration explícito, uma função de alinhador usa uma série temporal de entrada e um ponto no tempo e produz um ponto de saída para esse tempo específico.

A função de alinhamento interpolate produz um valor em um determinado momento. Para isso, interpola um valor de dois pontos de entrada adjacentes que têm carimbos de data/hora contendo o carimbo de data/hora de saída.

As funções de alinhamento next_older e next_younger produzem o valor do ponto único na série temporal de entrada com o carimbo de data/hora seguinte anterior ao carimbo de data/hora de saída.

As funções de alinhador delta, rate e delta_gauge calculam a saída de acordo com a alteração no valor da série temporal de entrada na janela de tempo entre o horário de término do ponto de saída e o argumento Duration anterior. Essa alteração no valor é calculada da seguinte forma:

  • Assim, o valor da série temporal de entrada a qualquer momento pode ser computado por interpolação linear entre o ponto mais próximo antes e o ponto mais próximo após o tempo de saída. A alteração no valor de uma determinada janela é a diferença entre o valor interpolado na borda anterior da janela e na borda posterior.

  • A quantidade de alterações na janela é a soma do valor de todos os pontos cuja extensão está totalmente dentro da janela e a parcela proporcional do valor dos pontos cuja extensão se sobrepõe parcialmente à janela.

  • Para uma série temporal Cumulative, a interpolação de um valor entre dois pontos adjacentes com o mesmo horário de início é feita pela interpolação linear entre os dois valores. A interpolação entre dois pontos adjacentes com tempos de início diferentes, de modo que o horário de início do ponto posterior está entre os horários de término dos dois pontos, é tratado desta forma:

    • Se o tempo de saída estiver entre o horário de término do ponto anterior e o horário de início do ponto posterior, o resultado será o valor do ponto anterior. Não há nenhuma alteração entre o ponto anterior e o horário de redefinição.

    • Se o tempo de saída estiver entre os horários de início e término dos pontos posteriores, o valor será a interpolação linear entre zero (no horário de início) e o valor do ponto.

    Para conseguir séries temporais Cumulative, a alteração no valor em uma determinada janela é a diferença entre o valor interpolado na borda anterior da janela e a borda posterior, além de uma correção para redefinições. Para cada tempo de redefinição que se enquadra na janela, o valor do ponto imediatamente antes desse horário de redefinição é adicionado ao valor de alteração para contabilizar o valor série temporal, que será redefinido como 0 no momento.

    As funções de alinhador de agregação, mean_aligner e int_mean_aligner, aplicam uma função de agregação aos pontos de entrada que se enquadram em uma janela de tempo em que a largura é fornecida pelo argumento Duration e em que a borda posterior é o carimbo de data/hora do ponto de saída. O resultado dessa agregação é o valor do ponto de saída.

    A unidade de medida da saída de uma função de alinhamento geralmente é a mesma da entrada. Veja a seguir as exceções:

    • A saída de rate tem a unidade de entrada dividida pelo "s" da unidade.

    • A saída de count_true_aligner tem a unidade 1.

    • A saída de fraction_true_aligner tem a unidade 10^2.%

rate Calcule uma taxa de alteração em pontos alinhados no tempo.


Assinatura:   ImplicitRowInput   rate([ lit-Duration ] )   →   Double.Gauge     (entrada implícita de linha)

O alinhador rate opera em séries temporais de entrada com uma única coluna de valor do tipo numérico (Int ou *Double). Ela sempre produz uma tabela de saída com uma única coluna de valor do tipo Double e Gauge .

O alinhador rate calcula a alteração no valor da série temporal na janela (conforme descrito aqui) e a divide pela largura da janela em segundos. A janela se estende do tempo do ponto de saída até o tempo anterior do parâmetro Duration.

O valor padrão do argumento Duration é o período de alinhamento. Ao contrário da função de alinhamento 'delta', não há necessidade de correspondência entre o período de alinhamento e a largura da janela.

delta Calcule a alteração no valor em pontos alinhados no tempo.


Assinatura:   ImplicitRowInput   delta([ lit-Duration ] )   →   InputType.Delta     (entrada implícita de linha)

O alinhador delta opera em séries temporais de entrada com uma única coluna de valor do tipo Sumable (Int, Double ou Distribution) e a saída é uma série temporal cuja coluna de valor é do mesmo tipo, mas tem um tipo de série temporal Delta.

O alinhador "delta_gauge" calcula a alteração no valor da série temporal de entrada na janela de tempo entre o tempo de saída e o argumento Duration anterior. O horário de início do ponto de saída é o argumento Duration anterior ao horário de saída (o horário de término do ponto).

O alinhador delta tem o requisito de que o argumento Duration é igual ao período de alinhamento ao qual ele é usado para se alinhar. O valor padrão do argumento Duration é o período de alinhamento.

any_true_aligner   Para alinhar uma série temporal Bool, encontre qualquer valor verdadeiro em uma janela.


Assinatura:   ImplicitRowInput   any_true_aligner([ lit-Duration ] )   →   Bool.Gauge     (entrada de linha implícita)

A função any_true_aligner opera em uma tabela de entrada com uma única coluna de valor do tipo Bool e produz uma tabela de saída com uma única coluna de valor do tipo Bool e tipo de série temporal Gauge.

O argumento Duration fornece a largura de uma janela de tempo para cada ponto de saída que termina no momento desse ponto de saída. Se o argumento Duration não for fornecido, o padrão será o período de alinhamento. O valor de um ponto de saída será true se qualquer ponto de entrada na janela for verdadeiro. Caso contrário, será false.

count_true_aligner   Para alinhar uma série temporal Bool, conte os valores verdadeiros em uma janela.


Assinatura:   ImplicitRowInput   count_true_aligner([ lit-Duration ] )   →   Int.Gauge     entrada de linha implícita)

A função count_true_aligner opera em uma tabela de entrada com uma única coluna de valor do tipo Bool e produz uma tabela de saída com uma única coluna de valor do tipo Int e tipo de série temporal Gauge.

O argumento Duration fornece a largura de uma janela de tempo para cada ponto de saída que termina no momento desse ponto de saída. Se o argumento Duration não for fornecido, o padrão será o período de alinhamento. O valor de um ponto de saída é o número de pontos de entrada na janela com o valor true.

delta_gauge Calcule a alteração no valor em pontos alinhados no tempo como uma série temporal Gauge.


Assinatura:   ImplicitRowInput   delta_gauge([ lit-Duration ] )   →   InputType.Gauge     (entrada implícita de linha)

O alinhador delta_gauge opera em séries temporais de entrada com uma única coluna de valor do tipo Sumable (Int, Double ou Distribution) e a saída é uma série temporal cuja coluna de valor é do mesmo tipo, mas tem um tipo de série temporal Gauge.

O alinhador delta_gauge calcula a alteração no valor da série temporal de entrada na janela (conforme descrito aqui). A janela se estende do tempo do ponto de saída até o tempo anterior do parâmetro Duration.

O valor padrão do argumento Duration é o período de alinhamento. Ao contrário da função de alinhamento 'delta', não há necessidade de correspondência entre o período de alinhamento e a largura da janela.

fraction_true_aligner   Alinhe uma série temporal Bool com a fração de valores verdadeiros em uma janela.


Assinatura:   ImplicitRowInput   fraction_true_aligner([ lit-Duration ] )   →   Double.Gauge     (entrada implícita de linha)

A função fraction_true_aligner opera em uma tabela de entrada com uma única coluna de valor do tipo Bool e produz uma tabela de saída com uma única coluna de valor do tipo Double e tipo de série temporal Gauge.

O argumento Duration fornece a largura de uma janela de tempo para cada ponto de saída que termina no momento desse ponto de saída. Se o argumento Duration não for fornecido, o padrão será o período de alinhamento. O valor de um ponto de saída é a fração de todos os pontos de entrada na janela que tem o valor true.

int_mean_aligner   Para alinhar, encontre a média dos valores Int em uma janela.


Assinatura:   ImplicitRowInput   int_mean_aligner([ lit-Duration ] )   →   Int.Gauge     entrada de linha implícita)

A função int_mean_aligner opera em uma tabela de entrada com uma única coluna de valor de tipo Int e tipo de séries temporais Gauge ou Delta. Uma tabela de saída é produzida com uma única coluna de valor de tipo Int e tipo de séries temporais Gauge.

O argumento Duration fornece a largura de uma janela de tempo para cada ponto de saída que termina no momento desse ponto de saída. Se o argumento Duration não for fornecido, o padrão será o período de alinhamento. O valor de um ponto de saída é a média dos pontos de valor da tabela de entrada que se enquadram nessa janela, arredondada para o valor inteiro mais próximo.

interpolate Calcule valores interpolados em pontos alinhados no tempo.


Assinatura:   ImplicitRowInput   interpolate([ lit-Duration ] )   →   InputType.Gauge     (entrada implícita de linha)

O alinhador interpolate opera em uma tabela de entrada com uma única coluna de valor com o tipo numérico (Int ou *Double) e tipo de séries temporais Gauge. Ele produz uma tabela de saída com uma única coluna de valor do mesmo tipo e tipo de série temporal.

Se o horário de saída da função de alinhamento interpolate for o mesmo horário de término de um ponto na série temporal de entrada, ele será usado para o ponto de saída. Caso contrário, o alinhador interpolate considera os pontos de entrada em que o horário de término são os pontos anteriores e posteriores mais próximos ao tempo de saída. Se esses pontos estiverem dentro do argumento Duration, o valor de saída será a interpolação linear entre esses pontos e o tempo de saída. Se não houver um ponto de entrada anterior ao tempo de saída ou nenhum ponto de entrada posterior ao do resultado da saída, ou se os dois pontos de entrada não estiverem dentro do argumento Duration de cada um, nenhum valor de saída é produzido.

O padrão para o argumento Duration é o dobro do período de alinhamento.

mean_aligner   Para alinhar, encontre a média dos valores em uma janela.


Assinatura:   ImplicitRowInput   mean_aligner([ lit-Duration ] )   →   Double.Gauge     (entrada implícita de linha)

A função mean_aligner opera em uma tabela de entrada com uma única coluna de valor de tipo numérico. (Int ou Double) e tipo de séries temporais Gauge ou Delta. Ela produz uma tabela de saída com uma única coluna de valor do tipo Double e de tipo de séries temporais Gauge.

O argumento Duration fornece a largura de uma janela de tempo para cada ponto de saída que termina no momento desse ponto de saída. Se o argumento Duration não for fornecido, o padrão será o período de alinhamento. O valor de um ponto de saída é a média dos pontos de valor da tabela de entrada que se enquadram na janela acima.

next_older   Pontos alinhados no tempo ao mover de um período anterior para um posterior.


Assinatura:   ImplicitRowInput   next_older([ lit-Duration ] )   →   InputType.Gauge     (entrada implícita de linha)

O alinhador next_older opera em séries temporais com qualquer número de colunas de valor de qualquer tipo, mas todas com o tipo de série temporal Gauge. Ela produz colunas de saída do mesmo tipo e tipo de série temporal.

Para criar um ponto de saída, o alinhador next_older encontra o ponto de entrada mais recente em que o horário de término não seja posterior ao horário de saída e que não esteja mais longe do horário de saída do que o argumento Duration. Se não houver esse ponto de entrada, nenhum ponto de saída será criado.

O padrão para o argumento Duration é o dobro do período de alinhamento.

next_younger   Pontos alinhados no tempo ao mover de um momento posterior para o anterior.


Assinatura:   ImplicitRowInput   next_younger([ lit-Duration ] )   →   InputType.Gauge     (entrada implícita de linha)

O alinhador next_younger opera em séries temporais com qualquer número de colunas de valor de qualquer tipo, mas todas com o tipo de série temporal Gauge. Ela produz colunas de saída do mesmo tipo e tipo de série temporal.

O alinhador next_younger cria um ponto de saída encontrando o ponto de entrada mais novo em que o horário de término não seja mais recente que o horário de saída e que não esteja mais longe do horário de saída do que o argumento Duration. Se não houver esse ponto de entrada, nenhum ponto de saída será criado.

O padrão para o argumento Duration é o dobro do período de alinhamento.

Como manipular unidades

Essas funções alteram as unidades das expressões a que são aplicadas.

scale   Dimensione um valor para uma unidade de medida diferente.


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

A função scale retorna o valor do primeiro argumento, convertido em duplo, se necessário, e possivelmente escalonado. Assim, ele tem as unidades fornecidas pelo segundo argumento.

Se o segundo argumento não for fornecido, a função scale converte o primeiro argumento para que seja dobrado, sem alterar as unidades, exceto nos casos em que o escalonamento automático é invocado conforme descrito aqui. Nesse caso, o segundo argumento é fornecido de forma implícita, e scale se comporta normalmente como com dois argumentos.

O segundo argumento, se fornecido, precisa ser uma string de código UCUM válida para a unidade a que o primeiro argumento será dimensionado. Nesse caso, o valor retornado indica a mesma quantidade física que o valor de entrada, mas expresso nas unidades fornecidas pelo segundo argumento. Isso é feito ao multiplicar o argumento pelo fator de escalonamento apropriado.

Por exemplo, a expressão scale(3 "min", "s") converterá o valor 3 com unidades minutos em minutos (min) para o valor 180 com unidades de segundos (s). A mesma quantidade de tempo, expressa em unidades diferentes.

Será um erro se o primeiro argumento não tiver uma unidade ou se a unidade do primeiro argumento não tiver a mesma dimensão do código da unidade fornecido como o segundo argumento, se determinado. Se eles não tiverem a mesma dimensão, não será possível escalonar o primeiro argumento para que tenha a dimensão atribuída pelo segundo argumento.

Outro exemplo: é um erro dizer scale(3 "km", "m/s"), que solicita o escalonamento de 3 quilômetros em um número de metros por segundo, porque os quilômetros têm a dimensão "distância" e os metros por segundo têm a dimensão "distância por tempo" (velocidade). Não há fator de escala que possa aumentar a velocidade. Seria necessário dividir a distância por um valor com unidades de tempo para que isso funcione. Por exemplo, scale(3 "km" / 10 "min", "m/s") será escalonado de .3 "km/min" para 5 "m/s".

Se o primeiro argumento for Date ou Duration, o segundo argumento precisará fornecer uma unidade de tempo (por exemplo, "s", "h" ou "wk"). O valor retornado será um valor Double para designar o tempo do primeiro valor de argumento nas unidades fornecidas pelo segundo. Para um valor Date, esta será a duração desde a época do Unix.

Por exemplo, scale(1m, "s") resultará em um valor de 60.0 com as unidades s e scale(d'1970/01/01-01:00:00+00', "h") resulta em um valor de 1.0 com as unidades "h" (uma hora na época do Unix).

cast_units   Define a unidade de medida de um valor.


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

A função cast_units retorna o valor inalterado do primeiro argumento, mas define a unidade de medida para esse valor como o fornecido pela segunda string de argumentos.

A string precisa ser um valor da string de código UCUM para a unidade desejada. Qualquer unidade que o primeiro argumento pode ter antes de aplicar essa função é ignorada.

Janela periódica

As funções de janela periódicas são usadas para anotar um argumento real de Duration passado para um argumento WindowDuration que especifica uma largura de janela usada para selecionar pontos de entrada para um cálculo periódico. Esse argumento é passado para a operação de tabela group_by que gera séries temporais alinhadas. As funções window e sliding restringem a largura da janela de entrada de acordo com o período de alinhamento da saída.

A função window indica que o período de alinhamento e a largura da janela precisam ser os mesmos, tornando as janelas de ponto de entrada não sobrepostas.

A função sliding indica que o período de alinhamento pode ser menor que a largura da janela, fazendo com que as janelas de entrada se sobreponham.

window Indica uma janela igual ao período de alinhamento.


Assinatura:   window([ lit-Duration ] )   →   lit-WindowDuration

A função window anota um argumento real Duration passado para um argumento WindowDuration que especifica uma largura de janela usada em um cálculo que produz séries temporais alinhadas. Ela exige que a largura da janela e o período de alinhamento de saída sejam os mesmos do argumento Duration. Se o argumento Duration não for fornecido, ela especificará que a largura da janela é o período de alinhamento de saída, independentemente de como isso é definido.

Por exemplo, a operação de tabela |group_bywindow(5m), .mean produz pontos de saída que são o valor médio dos pontos de entrada dentro de uma janela de 5m do horário de término da saída. A função window anota a largura da janela 5m para exigir que o período de alinhamento do group_by também seja de 5 minutos. A operação de tabela | group_by window(), .mean também requer que a largura da janela seja igual ao período de alinhamento de saída, mas não especifica qual será.

sliding Indica uma janela variável (sobreposta) em vez de separada.


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

A função sliding anota um argumento real Duration passado para um argumento WindowDuration que especifica uma largura de janela usada em um cálculo que produz séries temporais alinhadas. Ela exige que a largura da janela seja o argumento Duration e que o período de alinhamento não seja maior (mas permite que ele seja menor).

Por exemplo, a operação de tabela |group_bysliding(5m), .mean produz pontos de saída que são o valor médio dos pontos de entrada dentro de uma janela de 5m do horário de término da saída. A função sliding que anota a largura da janela 5m indica que o período de alinhamento do group_by não pode ser superior a 5 minutos. Se houver uma operação de tabela | every 1m indicando um alinhamento de um minuto, os quatro minutos de cada janela de cinco minutos se sobrepõem à janela do ponto de saída seguinte.

Distribuição

count_from O número de valores em um valor de distribuição.


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

A função count_from retorna o tamanho da população de valores no valor Distribution de entrada.

A unidade de medida anexada ao resultado de count_from é 1.

sum_from A soma dos valores em um valor de distribuição.


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

A função sum_from retorna a soma de todos os valores contidos no valor Distribution de entrada.

O resultado de sum_from tem a mesma unidade de medida da entrada.

mean_from A média dos valores em um valor de distribuição.


Assinatura:   mean_from(Distribution )   →   Double

A função mean_from retorna a média aritmética de todos os valores contidos no valor Distribution de entrada.

O resultado de mean_from tem a mesma unidade de medida da entrada.

stddev_from O desvio padrão dos valores em um valor de distribuição.


Assinatura:   stddev_from(Distribution )   →   Double

A função stddev_from retorna a variação da população que os valores contidos no valor Distribution de entrada.

O resultado de stddev_from tem a mesma unidade de medida da entrada.

variance_from A variação dos valores em um valor de distribuição.


Assinatura:   variance_from(Distribution )   →   Double

A função variance_from retorna a variação da população que os valores contidos no valor Distribution de entrada.

O resultado da função "variance_from" não tem unidade de medida.

median_from A mediana dos valores em um valor de distribuição.


Assinatura:   median_from(Distribution )   →   Double

A função median_from retorna uma estimativa da mediana da população dos valores contidos no valor Distribution de entrada.

O resultado de median_from tem a mesma unidade de medida da entrada.

percentile_from Um percentil dos valores em um valor de distribuição.


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

A função percentile_from retorna uma estimativa do percentil da população que os valores contidos no valor Distribution de entrada. O argumento Num fornece o percentil a ser estimado como um número entre 0 e 100.

O resultado de percentile_from tem a mesma unidade de medida da entrada.

fraction_less_than_from A fração de valores em uma distribuição menor que um valor fixo.


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

A função fraction_less_than_from retorna uma estimativa da fração da população dos valores contidos no valor Distribution de entrada e que são menores que o argumento Num.

A unidade de medida anexada ao resultado de fraction_less_than é 10^2.%.

bounded_percentile_from Um percentil dos valores dentro de um limite em um valor de distribuição.


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

A função bounded_percentile_from opera em um subconjunto do valor contido em Distribution de entrada. Uma estimativa é feita da população de valores maiores que o segundo parâmetro Num, se fornecido, e menor ou igual ao terceiro parâmetro Num, se fornecido. Pelo menos um ou outro dos segundos e terceiros argumentos Num precisa ser fornecido e, se ambos forem fornecidos, o segundo precisa ser menor que o terceiro.

Isso retorna uma estimativa do percentil dessa população estimada de valores. O primeiro argumento Num fornece o percentil a ser estimado como um número entre 0 e 100.

O resultado de bounded_percentile_from tem a mesma unidade de medida da entrada.

rebucket Valor de distribuição convertido em uma nova especificação de bucket.


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

Isso converte o valor Distribution de entrada em um valor Distribution cuja especificação de bucket é aquela fornecida no segundo argumento BucketSpecification.

Isso distribui as contagens de cada bucket na Distribution de entrada para os buckets da Distribution de saída, supondo que os valores contados em um bucket sejam distribuídos uniformemente pelo intervalo do bucket. A Distribution de saída tem a mesma contagem total que a Distribution de entrada, mas as contagens são distribuídas de maneira diferente pelos buckets da Distribution de saída. Distribution de saída tem a mesma soma, média e desvio padrão da Distribution de entrada.

Especificadora de intervalos

Um valor de Distribution tem um histograma composto de buckets. Cada bucket é associado a um intervalo de valores e contém uma contagem dos valores em Distribution que se enquadram nesse intervalo. Toda Distribution tem uma especificação de bucket que descreve os limites dos buckets em um valor Distribution. As funções nesta seção geram especificações de bucket.

powers_of Uma especificação de bucket com limites exponenciais de bucket.


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

A função powers_of retorna as especificações de um bucket em que o limite superior de cada bucket é fator fixo (fornecido pelo argumento Num) vezes o limite inferior. Assim, o tamanho do bucket está aumentando exponencialmente e o erro para calcular percentis é limitado por um fator constante do valor verdadeiro.

Isso não define o número de buckets ou o limite inferior do primeiro bucket, que precisam ser especificados (por "num_buckets" e "lower") ou receberão os valores padrão (30 buckets, limite inferior de 1,0). Se a especificação do bucket for fornecida por powers_of, o limite inferior precisará ser maior que 0.

O exemplo a seguir fornece uma especificação de bucket com 50 buckets cujo tamanho cresce exponencialmente a uma taxa de 1,1, começando com o valor 100. Portanto, os limites do bucket são 1, 1.1, 1.21, 1.331 e assim por diante.

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

fixed_width Uma especificação de bucket com buckets de tamanhos iguais.


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

A função fixed_width retorna as especificações de um bucket em que o limite superior de cada bucket é um valor fixo (fornecido pelo argumento Num) mais do que o limite inferior. Assim, o tamanho do bucket é fixo.

Isso não define o número de buckets ou o limite inferior do primeiro bucket, que precisam ser especificados (por "num_buckets" e "lower") ou receberão os valores padrão (30 buckets, limite inferior de 1,0).

O exemplo a seguir fornece uma especificação de bucket com 100 buckets de tamanho 1, observando 1. Essa é uma boa especificação para uma distribuição de valores percentuais.

fixed_width(1).num_buckets(100)

custom Uma especificação de bucket de uma lista de limites de bucket.


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

A função custom retorna uma especificação de bucket com limites de bucket fornecidos explicitamente. A função usa vários argumentos numéricos que precisam ser fornecidos em ordem crescente. O limite inferior do primeiro bucket é fornecido pelo primeiro argumento, e o limite superior do último bucket é fornecido pelo último argumento. Cada argumento intermediário fornece o limite superior do bucket anterior e o limite superior do próximo bucket.

Isso determina completamente a especificação do bucket, fornecendo o número de buckets e o limite exato de cada um.

O exemplo a seguir fornece uma especificação de bucket com três buckets. O primeiro tem os limites 3 e 27, o segundo 27 e 105 e o terceiro 105 e 277.

custom(3,27,105,277)

num_buckets Define o número de buckets em uma especificação de bucket.


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

Quando aplicada a uma especificação de bucket que não tem o número de buckets determinado, a função num_buckets retorna uma especificação de bucket com vários buckets fornecidos pelo argumento Num. Todos os outros aspectos da especificação do bucket de entrada são preservados.

É um erro aplicar num_buckets a uma especificação de bucket que já tenha o número de buckets determinado.

bounds Define o limite inferior do primeiro bucket e o limite superior do último.


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

Quando aplicado a uma especificação de bucket que não tem o limite inferior do primeiro bucket ou o limite superior do último bucket determinado, o bounds retorna uma especificação de bucket com o limite inferior do primeiro bucket fornecido pelo primeiro argumento Num e o limite superior do último bucket fornecido pelo segundo argumento Num. Todos os outros aspectos da especificação do bucket de entrada são preservados.

É um erro aplicar bounds a uma especificação de bucket que já tenha o limite inferior do primeiro bucket ou o limite superior do último bucket determinado.

lower Define o limite inferior do primeiro bucket em uma especificação de bucket.


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

Quando aplicada a uma especificação de bucket que não tem o limite inferior do primeiro bucket determinado, a função num_buckets retorna uma especificação de bucket com o limite inferior do primeiro bucket fornecido pelo argumento Num. Todos os outros aspectos da especificação do bucket de entrada são preservados.

É um erro aplicar lower a uma especificação de bucket que já tenha o limite inferior do primeiro bucket determinado.

Diversos

cast_double Converte o valor Int em Double.


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

A função cast_double usa um único argumento Int e retorna o valor Double mais próximo.

O resultado de cast_double tem a mesma unidade de medida da entrada.

cast_gauge Transmite um valor de série temporal Cumulative ou Delta para Gauge.


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

As funções cast_gauge retornam o valor do argumento, mas alteram o tipo de série temporal do valor para Gauge.

Se isso resultar em uma tabela de saída sem colunas de valor que tenham tipo de série temporal Delta, a tabela de saída não terá coluna de horário de início.

O resultado de cast_gauge tem a mesma unidade de medida da entrada.

within Especifica a janela do cálculo do valor de classificação.


Assinatura:   within(ColumnValue,   [ lit-DateOrDuration ],   [ lit-DateOrDuration ] )   →   Windowed.FirstArgKind

A função within decorará a expressão vinculada ao argumento de valor de classificação Windowed(Num) do top ou bottom operação de tabela. Ele especifica a janela em que a expressão do valor de classificação é avaliada especificando um ou dois dos três valores: o horário mais antigo (inicial) da janela, o mais novo (final) ou a duração da janela.

Se um dos dois argumentos de within for uma Duration positiva, isso definirá a largura da janela. No máximo, um dos argumentos pode ser Duration.

Se o primeiro argumento for Date, isso especificará o horário de início. Se o segundo argumento for Date, isso especificará o horário de término. Se ambos forem valores Date, o segundo precisará ser posterior ao primeiro. Um argumento Date pode ser fornecido como um literal de Date ou com um literal de Duration negativo. No caso posterior, a hora é a Duração especificada antes do horário de término da janela de consulta externa (veja a operação de tabela within).

Se o primeiro argumento não for fornecido, o padrão será o horário de início da janela de consulta externa. Se o segundo argumento não for fornecido, o padrão será o horário de término da janela de consulta externa.

Por exemplo, .mean().within(1h,-2h) indica que o redutor max precisa ser aplicado a todos os pontos da série temporal de entrada cujo horário de término esteja dentro de uma janela de 1 hora, terminando há duas horas. O agregador mean é aplicado a todos os pontos de entrada cujo horário de término está nesta janela.

Por exemplo, max(val()).within(10m) indica que o redutor max precisa ser aplicado a todas as séries de entrada que tenham horário de término no intervalo entre o horário de término da consulta e 10 minutos antes. O agregador max é aplicado a todos os pontos de entrada cujo horário de término está nesta janela.

Índice de operações de tabela e funções

Um índice de todas as operações de tabela e funções.

  • abs    Valor absoluto.
  • absent_for Crie uma condição para a ausência de entrada.
  • add A soma de dois números.
  • adjacent_delta    A alteração no valor entre um ponto de entrada e um ponto anterior.
  • adjacent_rate    A taxa de alteração entre o ponto de entrada e o ponto anterior mais próximo (linhas).
  • aggregate Valor agregado padrão de um grupo de valores de qualquer tipo.
  • align Produz uma tabela alinhada usando uma função de alinhamento.
  • all_true A combinação de um grupo de valores booleanos.
  • and A lógica e de dois valores booleanos.
  • any_true A disjeção de um grupo de valores booleanos.
  • any_true_aligner    Para alinhar uma série temporal Bool, encontre qualquer valor verdadeiro em uma janela.
  • ascii_to_lower Altere caracteres de letras maiúsculas ASCII para minúsculas.
  • ascii_to_upper Altere caracteres de letras minúsculas ASCII para maiúsculas.
  • bottom Seleciona a série temporal inferior por uma expressão de valor de classificação.
  • bottom_by Seleciona séries temporais por uma expressão de classificação em diferentes grupos.
  • bounded_percentile_from Um percentil dos valores dentro de um limite em um valor de distribuição.
  • bounds Define o limite inferior do primeiro bucket e o limite superior do último.
  • cast_double Converta o valor Int em Double.
  • cast_gauge Transmita um valor de série temporal Cumulative ou Delta para Gauge.
  • cast_units    Define a unidade de medida de um valor.
  • concatenate    Concatenação de strings.
  • condition Adicione uma coluna de condição booleana à tabela de entrada.
  • count A contagem do número de valores em um grupo de valores.
  • count_from O número de valores em um valor de distribuição.
  • count_true O número de valores verdadeiros em um grupo de valores booleanos.
  • count_true_aligner    Para alinhar uma série temporal Bool, conte os valores verdadeiros em uma janela.
  • covariance A covariância de um grupo de pares de valores.
  • custom Uma especificação de bucket de uma lista de limites de bucket.
  • delta Calcule a alteração no valor em pontos alinhados no tempo.
  • delta_gauge Calcule a alteração no valor em pontos alinhados no tempo como uma série temporal Gauge.
  • diameter O máximo menos o mínimo de um grupo de valores numéricos.
  • distribution Uma distribuição de um grupo de valores numéricos ou de distribuição.
  • div A proporção de dois números.
  • end O horário de término do ponto de entrada (linha).
  • eq    Igual.
  • every Especifica o período de saída da tabela alinhada.
  • exp e elevado a uma potência.
  • false O valor booleano falso.
  • fetch Produz uma tabela do banco de dados.
  • fetch_cumulative Produz uma tabela de séries temporais Cumulative do banco de dados.
  • filter Filtra as linhas de uma tabela de entrada por um predicado.
  • filter_ratio Calcula a proporção de duas somas filtradas da coluna de valor de entrada.
  • filter_ratio_by Calcula uma proporção agrupada de duas somas filtradas da coluna de valor de entrada.
  • fixed_width Uma especificação de bucket com buckets de tamanho igual.
  • fraction_less_than A fração de um grupo de valores menor que um valor fixo.
  • fraction_less_than_from A fração de valores em uma distribuição menor que um valor fixo.
  • fraction_true A fração de um grupo de valores booleanos que são verdadeiros.
  • fraction_true_aligner    Alinhe uma série temporal Bool com a fração de valores verdadeiros em uma janela.
  • ge    Maior que ou igual.
  • graph_period    Especifica o período de saída preferido para desenhar gráficos de séries temporais.
  • group_by Agrega linhas por identificador de série temporal mapeada e janela de tempo.
  • gt    Maior que.
  • has Verdadeiro se um argumento set contiver um valor específico.
  • has_value Verdadeiro se uma expressão de argumento calcular um valor.
  • hash_tsid Retorne um hash das colunas do identificador de série temporal.
  • ident Operação da tabela de identidade: sem alterações na tabela de entrada.
  • if Um valor condicionalmente escolhido entre dois valores.
  • int_ceil Inteiro do limite superior.
  • int_div O quociente da divisão de dois números inteiros.
  • int_floor Inteiro de limite inferior.
  • int_mean_aligner    Para alinhar, encontre a média dos valores Int em uma janela.
  • int_round    Número inteiro mais próximo.
  • interpolate Calcule valores interpolados em pontos alinhados no tempo.
  • join União natural de várias tabelas.
  • le    Menor que ou igual.
  • log    Logaritmo natural.
  • lower Define o limite inferior do primeiro bucket em uma especificação de bucket.
  • lt    Menor que.
  • map    Reescreve as colunas de identificador de série temporal e de valor de todas as linhas de uma tabela.
  • max O máximo de um grupo de valores numéricos.
  • mean A média de um grupo de valores numéricos.
  • mean_aligner    Para alinhar, encontre a média dos valores em uma janela.
  • mean_from A média dos valores em um valor de distribuição.
  • median A mediana de um grupo de valores numéricos ou de distribuição.
  • median_from A mediana dos valores em um valor de distribuição.
  • metric Produz a tabela para um tipo de métrica específico a partir de um conjunto de tabelas.
  • min O mínimo de um grupo de valores numéricos.
  • mul O produto de dois números.
  • ne    Diferente.
  • neg O negativo de um número.
  • next_older    Pontos alinhados no horário ao passar de um período anterior para um posterior.
  • next_younger    Pontos alinhados no tempo ao mudar de um momento posterior para o anterior.
  • not A negação lógica de um valor booleano.
  • num_buckets Define o número de buckets em uma especificação de bucket.
  • older    Um valor do próximo ponto (linha) em uma série temporal.
  • or A lógica ou de dois valores booleanos.
  • or_else Um valor ou, se não for um valor, outro valor.
  • outer_join União natural externa de duas tabelas.
  • percentile Um percentil de um grupo de valores numéricos ou de distribuição.
  • percentile_from Um percentil dos valores em um valor de distribuição.
  • pick_any O valor de qualquer elemento de um grupo de valores (escolhido arbitrariamente).
  • pos Identidade para entradas numéricas.
  • power Um número à potência de outro.
  • powers_of Uma especificação de bucket com limites exponenciais de bucket.
  • rate Calcule uma taxa de alteração em pontos alinhados no tempo.
  • ratio Calcula a proporção de colunas de valor de duas tabelas de entrada alinhadas.
  • re_extract Extraia valores correspondentes a uma expressão regular em outra string.
  • re_full_match Verdadeiro se uma expressão regular corresponder a todo um valor de string.
  • re_global_replace Substitua todas as correspondências de uma expressão regular em outra string.
  • re_partial_match Verdadeiro se uma expressão regular corresponder a alguma parte do valor da string.