Funções e operadores do SQL padrão

Veja nesta página as expressões do BigQuery, incluindo funções e operadores.

Regras de chamada de função

A menos que seja indicado de outra forma na descrição da função, as regras a seguir aplicam-se a todas as funções:

  • Nas funções que aceitam tipos numéricos, se um operando for um ponto flutuante e o outro for um outro tipo numérico, ambos serão convertidos para FLOAT64 antes que a função seja avaliada.
  • Se um operando for NULL, o resultado será , com exceção do operador IS.
  • Nas funções que fazem diferenciação de fuso horário (conforme indicado na descrição da função), se um fuso horário não for especificado, o padrão UTC será usado.

Prefixo SAFE.

Sintaxe:

SAFE.function_name()

Descrição

Se você iniciar uma função com o prefixo SAFE., ela retornará NULL em vez de um erro. O prefixo SAFE. apenas evita erros da função prefixada: ele não evita erros que ocorrem durante a avaliação de expressões de argumentos. O prefixo SAFE. apenas evita erros que ocorrem devido ao valor das entradas da função, como erros de "valor fora do intervalo"; outros erros, como erros internos ou do sistema, ainda podem ocorrer. Se a função não retornar um erro, SAFE. não terá efeito na saída. Se a função nunca retornar um erro, como RAND, SAFE. não tem efeito.

Operadores, como + e =, não são compatíveis com o prefixo SAFE.. Para evitar erros de uma operação de divisão, use SAFE_DIVIDE. Alguns operadores, como IN, ARRAY e UNNEST, são parecidos com funções, mas não são compatíveis com o prefixo SAFE.. As funções CAST e EXTRACT também não são compatíveis com o prefixo SAFE.. Para evitar erros na transmissão, use SAFE_CAST.

Exemplo

No seguinte exemplo, o primeiro uso da função SUBSTR normalmente retorna um erro, porque a função não é compatível com argumentos de comprimento com valores negativos. No entanto, o prefixo SAFE. faz com que a função retorne NULL. O segundo uso da função SUBSTR fornece a saída esperada: o prefixo SAFE. não tem efeito.

SELECT SAFE.SUBSTR('foo', 0, -2) AS safe_output UNION ALL
SELECT SAFE.SUBSTR('bar', 0, 2) AS safe_output;

+-------------+
| safe_output |
+-------------+
| NULL        |
| ba          |
+-------------+

Funções compatíveis

O BigQuery suporta o uso do prefixo SAFE. com a maioria das funções escalares que podem gerar erros, incluindo funções STRING, funções matemáticas, funções DATE, funções DATETIME e funções TIMESTAMP. O BigQuery não suporta o uso do prefixo SAFE. com funções agregadas, analíticas ou definidas pelo usuário.

Como chamar funções definidas pelo usuário (UDFs) persistentes

Depois de criar uma UDF persistente, é possível chamá-la como qualquer outra função, prefixada com o nome do conjunto de dados em que foi definida como prefixo.

Sintaxe

[`project_name`].dataset_name.function_name([parameter_value[, ...]])

Para chamar uma UDF em um projeto diferente do projeto que você está usando para executar a consulta, project_name é obrigatório.

Exemplos

O seguinte exemplo cria uma UDF chamada multiply_by_three e a chama do mesmo projeto.

CREATE FUNCTION my_dataset.multiply_by_three(x INT64) AS (x * 3);

SELECT my_dataset.multiply_by_three(5) AS result; -- returns 15

O exemplo a seguir chama uma UDF persistente de outro projeto.


CREATE `other_project`.other_dataset.other_function(x INT64, y INT64)
  AS (x * y * 2);

SELECT `other_project`.other_dataset.other_function(3, 4); --returns 24

Regras de conversão

A "conversão" inclui, entre outros tipos, cast e coerção.

  • Cast é conversão explícita e usa a função CAST().
  • Coerção é conversão implícita, realizada automaticamente pelo BigQuery nas condições descritas abaixo.
  • Há um terceiro grupo de funções de conversão que tem seus próprios nomes de função, como UNIX_DATE().

A tabela a seguir resume todas as possibilidades de CAST e coerção dos tipos de dados do BigQuery. A coluna "Coerção para" aplica todas as expressões de um determinado tipo de dados (como uma coluna), mas literais e parâmetros também podem ser forçados. Consulte Coerção de literal e Coerção de parâmetro para mais detalhes.

Do tipo CAST para Coerção para
INT64 BOOL
INT64
NUMERIC
FLOAT64
STRING
FLOAT64
NUMERIC
NUMERIC INT64
NUMERIC
FLOAT64
STRING
FLOAT64
FLOAT64 INT64
NUMERIC
FLOAT64
STRING
 
BOOL BOOL
INT64
STRING
 
STRING BOOL
INT64
NUMERIC
FLOAT64
STRING
BYTES
DATE
DATETIME
TIME
TIMESTAMP
 
BYTES BYTES
STRING
 
DATE DATE
DATETIME
STRING
TIMESTAMP
 
DATETIME DATE
DATETIME
STRING
TIME
TIMESTAMP
 
TIME STRING
TIME
 
TIMESTAMP DATE
DATETIME
STRING
TIME
TIMESTAMP
 
ARRAY ARRAY  
STRUCT STRUCT  

Cast

Sintaxe:

CAST(expr AS typename)

Usa-se a sintaxe de cast em uma consulta para indicar que é preciso converter o tipo do resultado de uma expressão em algum outro tipo.

Exemplo:

CAST(x=1 AS STRING)

Isso resulta em "true" se x for 1, "false" para qualquer outro valor que não seja NULL e NULL se x for NULL.

Os casts entre tipos compatíveis que não são mapeados com sucesso do valor original para o domínio de destino produzem erros de ambiente de execução. Por exemplo, o cast de BYTES para STRING em que a sequência de bytes não é um UTF-8 válido resulta em um erro de ambiente de execução.

Quando realizar o cast de uma expressão x dos tipos a seguir, essas regras se aplicam:

De Até Regras ao fazer o cast x
INT64 FLOAT64 Retorna um valor aproximado de FLOAT64, mas potencialmente inexato.
INT64 BOOL Retorna FALSE se x for 0. Caso contrário, retorna TRUE.
NUMERIC Ponto flutuante NUMERIC será convertido no número de ponto flutuante mais próximo com uma possível perda de precisão.
FLOAT64 INT64 Retorna o valor mais próximo de INT64.
Casos em que haja metades, como 1,5 ou -0,5, são arredondados para longe de zero.
FLOAT64 STRING Retorna uma representação de string aproximada.
FLOAT64 NUMERIC Se o número de ponto flutuante tiver mais de nove dígitos depois do ponto decimal, ele será arredondado para metade de zero. Fazer cast de NaN, +inf ou -inf retornará um erro. Fazer cast de um valor fora do intervalo de NUMERIC retornará um erro de estouro.
BOOL INT64 Retorna 1 se x for TRUE. Caso contrário, retorna 0.
BOOL STRING Retorna "true" se x for TRUE. Caso contrário, retorna "false".
STRING FLOAT64 Retorna x como um valor de FLOAT64, interpretando-o como tendo a mesma forma de um FLOAT64 literal válido.
Também aceita casts de "inf", "+inf", "-inf", e "nan".
As conversões não diferenciam maiúsculas de minúsculas.
STRING NUMERIC O literal numérico contido em STRING não pode exceder a precisão máxima ou o intervalo do tipo NUMERIC, ou ocorrerá um erro. Se o número de dígitos depois do ponto decimal exceder nove, o valor resultando NUMERIC será arredondado para metade de zero para ter nove dígitos depois do ponto decimal.
STRING BOOL Retorna TRUE se x for "true" e FALSE se x for "false"
Todos os outros valores de x são inválidos e lançam um erro em vez de fazer o cast para BOOL.
As STRINGs não diferenciam maiúsculas de minúsculas durante a conversão para BOOL.
STRING BYTES As STRINGs são convertidas em BYTES usando a codificação UTF-8. Por exemplo, a STRING "©", quando convertida em BYTES, torna-se uma sequência de dois bytes com os valores hexadecimais C2 e A9.
BYTES STRING Retorna x interpretado como uma STRING UTF-8.
Por exemplo, o literal BYTES b'\xc2\xa9', quando convertido para STRING, é interpretado como UTF-8 e se torna o caractere unicode “©”.
Um erro ocorre se x não é um UTF-8 válido.
ARRAY ARRAY Precisa ser exatamente do mesmo tipo ARRAY.
STRUCT STRUCT Permitido, se as condições a seguir forem atendidas:
  1. Os dois STRUCTs têm o mesmo número de campos.
  2. Os tipos originais de campos STRUCT são convertidos explicitamente para os tipos de campos de destino STRUCT correspondentes (definidos pela ordem e não pelo nome do campo).

Cast seguro

Quando CAST é usado, pode ocorrer falha na consulta se o BigQuery não conseguir executar o cast. Por exemplo, a consulta a seguir gera um erro:

SELECT CAST("apple" AS INT64) AS not_a_number;

Caso queira proteger as consultas contra esses tipos de erros, use SAFE_CAST. é idêntico a CAST, exceto que retorna NULL em vez de gerar um erro.

SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;

+--------------+
| not_a_number |
+--------------+
| NULL         |
+--------------+

Se você estiver fazendo o cast de bytes para strings, também poderá usar a função SAFE_CONVERT_BYTES_TO_STRING. Todos os caracteres UTF-8 inválidos são substituídos pelo caractere de substituição unicode, U+FFFD. Consulte SAFE_CONVERT_BYTES_TO_STRING para mais informações.

Cast de strings hexadecimais em inteiros

Se não estiver trabalhando com strings hex (0x123), faça o cast dessas strings como inteiras:

SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123     | 291        |
+-----------+------------+

SELECT '-0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| -0x123    | -291       |
+-----------+------------+

Cast de tipos de data

O BigQuery é compatível com o cast de tipos de data para/de strings da maneira a seguir:

CAST(date_expression AS STRING)
CAST(string_expression AS DATE)

O cast de um tipo de data para uma string segue o formato YYYY-MM-DD, independentemente do fuso horário. No caso do cast da string para a data, a string precisa seguir o formato literal da data compatível, independentemente do fuso horário. Se a expressão da string for inválida ou representar uma data fora do intervalo mínimo/máximo aceito, ocorrerá um erro.

Cast de tipos de carimbo de data/hora

O BigQuery é compatível com o cast de tipos de carimbo de data/hora para/de strings da maneira a seguir:

CAST(timestamp_expression AS STRING)
CAST(string_expression AS TIMESTAMP)

No cast de tipos de carimbo de data/hora para string, o carimbo é interpretado com o fuso horário padrão, que é o UTC. O número de dígitos de subsegundos produzidos depende do número de zeros à direita na parte de subsegundo. A função CAST truncará nenhum, três ou seis dígitos.

No cast de string para carimbo de data/horastring_expression precisa seguir os formatos compatíveis de literal do carimbo de data/hora. Caso contrário, ocorrerá um erro no ambiente de execução. O próprio string_expression pode conter os time_zone. Consulte fusos horários. Se houver um fuso horário no string_expression, ele será usado para conversão. Caso contrário, será usado o fuso horário padrão, UTC. Se a string tiver menos de seis dígitos, ela será ampliada implicitamente.

Um erro será produzido se string_expression for inválido, tiver mais de seis dígitos de subsegundos (isto é, precisão maior que microssegundos) ou representar um horário fora do intervalo aceito do carimbo de data/hora.

Cast entre tipos de data e carimbo de data/hora

O BigQuery é compatível com cast entre tipos de data e timestamp da seguinte maneira:

CAST(date_expression AS TIMESTAMP)
CAST(timestamp_expression AS DATE)

O cast de uma data para um timestamp interpreta date_expression a partir da meia-noite (início do dia) no fuso horário UTC padrão. O cast de um carimbo de data/hora para uma data trunca efetivamente o carimbo de data/hora a partir do fuso horário padrão.

Coerção

Se necessário, o BigQuery força o tipo de resultado de uma expressão para outro tipo, para corresponder às assinaturas da função. Por exemplo, se a função func() for definida para ter um único argumento do tipo INT64 e uma expressão for usada como um argumento que tenha um tipo de resultado FLOAT64, então o resultado da expressão será forçado para o tipo INT64 antes de func() ser calculado.

Coerção de literal

O BigQuery é compatível com as seguintes coerções de literal:

Tipo de dados de entrada Tipo de dados de resultado Notas
Literal STRING DATE
TIMESTAMP

A coerção de literal é necessária quando o tipo de literal real é diferente do tipo esperado pela função em questão. Por exemplo, se a função func() tiver um argumento DATE e, em seguida, a expressão func("2014-09-27") for válida porque o literal STRING "2014-09-27" for forçado para DATE.

A conversão de literal é avaliada no momento da análise. Se o literal da entrada não for convertido com sucesso para o tipo de destino, ocorrerá um erro.

Observação: os literais de string não são forçados para tipos numéricos.

Coerção de parâmetro

O BigQuery é compatível com as seguintes coerções de parâmetro:

Tipo de dados de entrada Tipo de dados de resultado
Parâmetro STRING

Se o valor do parâmetro não puder ser forçado com sucesso para o tipo de destino, ocorrerá um erro.

Funções de conversão adicionais

O BigQuery oferece as seguintes funções adicionais de conversão:

Funções de agregação

A função de agregação realiza um cálculo em um grupo de valores. COUNT, MIN e MAX são exemplos de funções de agregação.

SELECT COUNT(*) as total_count, COUNT(fruit) as non_null_count,
       MIN(fruit) as min, MAX(fruit) as max
FROM (SELECT NULL as fruit UNION ALL
      SELECT "apple" as fruit UNION ALL
      SELECT "pear" as fruit UNION ALL
      SELECT "orange" as fruit)

+-------------+----------------+-------+------+
| total_count | non_null_count | min   | max  |
+-------------+----------------+-------+------+
| 4           | 3              | apple | pear |
+-------------+----------------+-------+------+

As seções a seguir descrevem as funções de agregação compatíveis com o BigQuery.

ANY_VALUE

ANY_VALUE(expression)  [OVER (...)]

Descrição

Retorna um valor da entrada ou NULL, se houver zero linhas de entrada. O valor retornado não é determinista. Isso significa que o resultado pode ser diferente sempre que essa função é usada.

Tipos de argumentos compatíveis

Qualquer um

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

Corresponde aos tipos de dados de entrada.

Exemplos

SELECT ANY_VALUE(fruit) as any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+-----------+
| any_value |
+-----------+
| apple     |
+-----------+
SELECT
  fruit,
  ANY_VALUE(fruit) OVER (ORDER BY LENGTH(fruit) ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+--------+-----------+
| fruit  | any_value |
+--------+-----------+
| pear   | pear      |
| apple  | pear      |
| banana | apple     |
+--------+-----------+

ARRAY_AGG

ARRAY_AGG([DISTINCT] expression [{IGNORE|RESPECT} NULLS]
          [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

Descrição

Retorna um array de valores expression.

Tipos de argumentos compatíveis

Todos os tipos de dados, exceto ARRAY.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em ARRAY_AGG().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.
  3. IGNORE NULLS ou RESPECT NULLS: se for especificado, os valores NULL serão excluídos do resultado. Se RESPECT NULLS for especificado ou se nenhum for especificado, os valores NULL serão incluídos no resultado (no entanto, um erro será gerado se um array no resultado final da consulta contiver um elemento NULL).
  4. ORDER BY: especifica a ordem dos valores.
    • A direção padrão de cada chave de classificação é ASC.
    • NULLs: no contexto da cláusula ORDER BY, NULLs são os valores mínimos possíveis; isto é, NULLs aparecem primeiro em listagens ASC e, por último, em listagens DESC.
    • Tipos de dados de ponto flutuante: consulte Semântica de ponto flutuante para ler sobre classificação e agrupamento.
    • Se DISTINCT também for especificado, a chave de classificação deverá ser igual a expression.
    • Se ORDER BY não for especificado, a ordem dos elementos no array de saída será não determinística, o que significa que você poderá receber um resultado diferente sempre que usar essa função.
  5. LIMIT: especifica o número máximo de entradas expression no resultado. O limite n precisa ser uma constante INT64.

Tipos de dados retornados

ARRAY

Se houver zero linhas de entrada, essa função retornará NULL.

Exemplos

SELECT FORMAT("%T", ARRAY_AGG(x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [2, 1, -2, 3, -2, 1, 2] |
+-------------------------+
SELECT FORMAT("%T", ARRAY_AGG(DISTINCT x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+---------------+
| array_agg     |
+---------------+
| [2, 1, -2, 3] |
+---------------+
SELECT FORMAT("%T", ARRAY_AGG(x IGNORE NULLS)) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [1, -2, 3, -2, 1] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(x ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [1, 1, 2, -2, -2, 2, 3] |
+-------------------------+
SELECT FORMAT("%T", ARRAY_AGG(x LIMIT 5)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [2, 1, -2, 3, -2] |
+-------------------+
SELECT FORMAT("%T", ARRAY_AGG(DISTINCT x IGNORE NULLS ORDER BY x LIMIT 2)) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-----------+
| array_agg |
+-----------+
| [-2, 1]   |
+-----------+
SELECT
  x,
  FORMAT("%T", ARRAY_AGG(x) OVER (ORDER BY ABS(x))) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+----+-------------------------+
| x  | array_agg               |
+----+-------------------------+
| 1  | [1, 1]                  |
| 1  | [1, 1]                  |
| 2  | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| 2  | [1, 1, 2, -2, -2, 2]    |
| 3  | [1, 1, 2, -2, -2, 2, 3] |
+----+-------------------------+

ARRAY_CONCAT_AGG

ARRAY_CONCAT_AGG(expression  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])

Descrição

Concatena elementos de expression do tipo ARRAY, retornando um único ARRAY como resultado. Essa função ignora matrizes de entrada NULL, mas respeita os elementos NULL em matrizes de entrada diferentes de NULL. No entanto, um erro será gerado se houver um elemento NULL em uma matriz no resultado da consulta final.

Tipos de argumentos compatíveis

ARRAY

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. ORDER BY: especifica a ordem dos valores.
    • A direção padrão de cada chave de classificação é ASC.
    • A ordem do array não é suportada e, portanto, a chave de classificação não pode ser igual a expression.
    • NULLs: no contexto da cláusula ORDER BY, NULLs são os valores mínimos possíveis; isto é, NULLs aparecem primeiro em listagens ASC e, por último, em listagens DESC.
    • Tipos de dados de ponto flutuante: consulte Semântica de ponto flutuante para ler sobre classificação e agrupamento.
    • Se ORDER BY não for especificado, a ordem dos elementos no array de saída será não determinística, o que significa que você poderá receber um resultado diferente sempre que usar essa função.
  2. LIMIT: especifica o número máximo de entradas expression no resultado. O limite é aplicado ao número de arrays de entrada, e não ao número de elementos nos arrays. Um array vazio conta como 1. Um array NULL não é contado. O limite n precisa ser uma constante INT64.

Tipos de dados retornados

ARRAY

Retorna NULL se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas.

Exemplos

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x)) AS array_concat_agg FROM (
  SELECT [NULL, 1, 2, 3, 4] AS x
  UNION ALL SELECT NULL
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [NULL, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
+-----------------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x))) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [5, 6, 7, 8, 9, 1, 2, 3, 4]       |
+-----------------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+--------------------------+
| array_concat_agg         |
+--------------------------+
| [1, 2, 3, 4, 5, 6]       |
+--------------------------+
SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x) LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+------------------+
| array_concat_agg |
+------------------+
| [5, 6, 7, 8, 9]  |
+------------------+

AVG

AVG([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna a média de valores de entrada NULL, ou NaN se a entrada tiver um NaN.

Tipos de argumentos compatíveis

Qualquer tipo de entrada numérica, como INT64. Para tipos de entrada de ponto flutuante, o resultado retornado não é determinista. Isso significa que o resultado pode ser diferente sempre que essa função for usada.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em AVG().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

  • NUMERIC caso o tipo de entrada seja NUMERIC.
  • FLOAT64

Exemplos

SELECT AVG(x) as avg
FROM UNNEST([0, 2, 4, 4, 5]) as x;

+-----+
| avg |
+-----+
| 3   |
+-----+
SELECT AVG(DISTINCT x) AS avg
FROM UNNEST([0, 2, 4, 4, 5]) AS x;

+------+
| avg  |
+------+
| 2.75 |
+------+
SELECT
  x,
  AVG(x) OVER (ORDER BY x ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) AS x;

+------+------+
| x    | avg  |
+------+------+
| NULL | NULL |
| 0    | 0    |
| 2    | 1    |
| 4    | 3    |
| 4    | 4    |
| 5    | 4.5  |
+------+------+

BIT_AND

BIT_AND(expression)

Descrição

Executa uma operação bit a bit AND em expression e retorna o resultado.

Tipos de argumentos compatíveis

  • INT64

Tipos de dados retornados

INT64

Exemplos

SELECT BIT_AND(x) as bit_and FROM UNNEST([0xF001, 0x00A1]) as x;

+---------+
| bit_and |
+---------+
| 1       |
+---------+

BIT_OR

BIT_OR(expression)

Descrição

Executa uma operação bit a bit OR em expression e retorna o resultado.

Tipos de argumentos compatíveis

  • INT64

Tipos de dados retornados

INT64

Exemplos

SELECT BIT_OR(x) as bit_or FROM UNNEST([0xF001, 0x00A1]) as x;

+--------+
| bit_or |
+--------+
| 61601  |
+--------+

BIT_XOR

BIT_XOR([DISTINCT] expression)

Descrição

Executa uma operação bit a bit XOR em expression e retorna o resultado.

Tipos de argumentos compatíveis

  • INT64

Cláusula opcional

DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

INT64

Exemplos

SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+
SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 5678    |
+---------+
SELECT BIT_XOR(DISTINCT x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+

COUNT

1. COUNT(*) [OVER (...)]

2. COUNT([DISTINCT] expression) [OVER (...)]

Descrição

  1. Retorna o número de linhas na entrada.
  2. Retorna o número de linhas com expression avaliado para qualquer valor diferente de NULL.

Tipos de argumentos compatíveis

expression pode ser qualquer tipo de dado.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas.
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

INT64

Exemplos

SELECT
  COUNT(*) AS count_star,
  COUNT(DISTINCT x) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------------+--------------+
| count_star | count_dist_x |
+------------+--------------+
| 4          | 3            |
+------------+--------------+
SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------+------------+--------------+
| x    | count_star | count_dist_x |
+------+------------+--------------+
| 1    | 3          | 2            |
| 4    | 3          | 2            |
| 4    | 3          | 2            |
| 5    | 1          | 1            |
+------+------------+--------------+
SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(x) OVER (PARTITION BY MOD(x, 3)) AS count_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;

+------+------------+---------+
| x    | count_star | count_x |
+------+------------+---------+
| NULL | 1          | 0       |
| 1    | 3          | 3       |
| 4    | 3          | 3       |
| 4    | 3          | 3       |
| 5    | 1          | 1       |
+------+------------+---------+

COUNTIF

COUNTIF(expression)  [OVER (...)]

Descrição

Retorna a contagem de valores TRUE para expression. Retorna 0 se não houver nenhuma linha de entrada ou expression for avaliado como FALSE para todas as linhas.

Tipos de argumentos compatíveis

BOOL

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

INT64

Exemplos

SELECT COUNTIF(x<0) AS num_negative, COUNTIF(x>0) AS num_positive
FROM UNNEST([5, -2, 3, 6, -10, -7, 4, 0]) AS x;

+--------------+--------------+
| num_negative | num_positive |
+--------------+--------------+
| 3            | 4            |
+--------------+--------------+
SELECT
  x,
  COUNTIF(x<0) OVER (ORDER BY ABS(x) ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS num_negative
FROM UNNEST([5, -2, 3, 6, -10, NULL, -7, 4, 0]) AS x;

+------+--------------+
| x    | num_negative |
+------+--------------+
| NULL | 0            |
| 0    | 1            |
| -2   | 1            |
| 3    | 1            |
| 4    | 0            |
| 5    | 0            |
| 6    | 1            |
| -7   | 2            |
| -10  | 2            |
+------+--------------+

LOGICAL_AND

LOGICAL_AND(expression)

Descrição

Retorna a lógica AND de todas as expressões diferentes de NULL. Retorna NULL, se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas.

Tipos de argumentos compatíveis

BOOL

Tipos de dados retornados

BOOL

Exemplos

SELECT LOGICAL_AND(x) AS logical_and FROM UNNEST([true, false, true]) AS x;

+-------------+
| logical_and |
+-------------+
| false       |
+-------------+

LOGICAL_OR

LOGICAL_OR(expression)

Descrição

Retorna a lógica OR de todas as expressões diferentes de NULL. Retorna NULL, se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas.

Tipos de argumentos compatíveis

BOOL

Tipos de dados retornados

BOOL

Exemplos

SELECT LOGICAL_OR(x) AS logical_or FROM UNNEST([true, false, true]) AS x;

+------------+
| logical_or |
+------------+
| true       |
+------------+

MAX

MAX(expression)  [OVER (...)]

Descrição

Retorna o valor máximo de expressões não NULL. Retorna NULL, se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas. Retorna NaN se a entrada contiver um NaN.

Tipos de argumentos compatíveis

Qualquer tipo de dados, exceto: ARRAY STRUCT

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

Igual ao tipo de dados usado como os valores da entrada.

Exemplos

SELECT MAX(x) AS max
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| max |
+-----+
| 55  |
+-----+
SELECT x, MAX(x) OVER (PARTITION BY MOD(x, 2)) AS max
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | max  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 8    |
| 4    | 8    |
| 37   | 55   |
| 55   | 55   |
+------+------+

MIN

MIN(expression)  [OVER (...)]

Descrição

Retorna o valor mínimo de expressões não NULL. Retorna NULL, se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas. Retorna NaN se a entrada contiver um NaN.

Tipos de argumentos compatíveis

Qualquer tipo de dados, exceto: ARRAY STRUCT

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

Igual ao tipo de dados usado como os valores da entrada.

Exemplos

SELECT MIN(x) AS min
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| min |
+-----+
| 4   |
+-----+
SELECT x, MIN(x) OVER (PARTITION BY MOD(x, 2)) AS min
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | min  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 4    |
| 4    | 4    |
| 37   | 37   |
| 55   | 37   |
+------+------+

STRING_AGG

STRING_AGG([DISTINCT] expression [, delimiter]  [ORDER BY key [{ASC|DESC}] [, ... ]]  [LIMIT n])
[OVER (...)]

Descrição

A concatenação de valores não nulos retorna um valor STRING ou BYTES.

Se um delimiter for especificado, os valores concatenados serão separados por esse delimitador; caso contrário, uma vírgula será usada como um delimitador.

Tipos de argumentos compatíveis

STRING BYTES

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em STRING_AGG().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.
  3. ORDER BY: especifica a ordem dos valores.
    • A direção padrão de cada chave de classificação é ASC.
    • NULLs: no contexto da cláusula ORDER BY, NULLs são os valores mínimos possíveis; isto é, NULLs aparecem primeiro em listagens ASC e, por último, em listagens DESC.
    • Tipos de dados de ponto flutuante: consulte Semântica de ponto flutuante para ler sobre classificação e agrupamento.
    • Se DISTINCT também for especificado, a chave de classificação deverá ser igual a expression.
    • Se ORDER BY não for especificado, a ordem dos elementos no array de saída será não determinística, o que significa que você poderá receber um resultado diferente sempre que usar essa função.
  4. LIMIT: especifica o número máximo de entradas expression no resultado. O limite é aplicado ao número de strings de entrada, e não ao número de caracteres ou bytes nas entradas. Uma string vazia conta como 1. Uma string NULL não é contada. O limite n precisa ser uma constante INT64.

Tipos de dados retornados

STRING BYTES

Exemplos

SELECT STRING_AGG(fruit) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+------------------------+
| string_agg             |
+------------------------+
| apple,pear,banana,pear |
+------------------------+
SELECT STRING_AGG(fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| apple & pear & banana & pear |
+------------------------------+
SELECT STRING_AGG(DISTINCT fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+-----------------------+
| string_agg            |
+-----------------------+
| apple & pear & banana |
+-----------------------+
SELECT STRING_AGG(fruit, " & " ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| pear & pear & apple & banana |
+------------------------------+
SELECT STRING_AGG(fruit, " & " LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+--------------+
| string_agg   |
+--------------+
| apple & pear |
+--------------+
SELECT STRING_AGG(DISTINCT fruit, " & " ORDER BY fruit DESC LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+---------------+
| string_agg    |
+---------------+
| pear & banana |
+---------------+
SELECT
  fruit,
  STRING_AGG(fruit, " & ") OVER (ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+--------+------------------------------+
| fruit  | string_agg                   |
+--------+------------------------------+
| NULL   | NULL                         |
| pear   | pear & pear                  |
| pear   | pear & pear                  |
| apple  | pear & pear & apple          |
| banana | pear & pear & apple & banana |
+--------+------------------------------+

SUM

SUM([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna a soma de valores não nulos.

Se a expressão for um valor de ponto flutuante, a soma não será determinista. Isso significa que o resultado pode ser diferente sempre que essa função for usada.

Tipos de argumentos compatíveis

Quaisquer tipos de dados numéricos compatíveis.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas.
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

  • Retorna INT64, se a entrada for um número inteiro.
  • Retorna NUMERIC, se o tipo de entrada for NUMERIC.
  • Retorna FLOAT64, se a entrada for um valor de ponto flutuante.

Retorna NULL, se a entrada contiver apenas s.

Retorna Inf se a entrada contiver .

Retorna -Inf se a entrada contiver .

Retorna NaN se a entrada contiver um .

Retorna NaN se a entrada contiver uma combinação de Inf e -Inf.

Exemplos

SELECT SUM(x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 25  |
+-----+
SELECT SUM(DISTINCT x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 15  |
+-----+
SELECT
  x,
  SUM(x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 6   |
| 3 | 6   |
| 1 | 10  |
| 4 | 10  |
| 4 | 10  |
| 1 | 10  |
| 2 | 9   |
| 5 | 9   |
| 2 | 9   |
+---+-----+
SELECT
  x,
  SUM(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 3   |
| 3 | 3   |
| 1 | 5   |
| 4 | 5   |
| 4 | 5   |
| 1 | 5   |
| 2 | 7   |
| 5 | 7   |
| 2 | 7   |
+---+-----+

Funções de agregação estatística

O BigQuery é compatível com as funções de agregação estatística a seguir.

CORR

CORR(X1, X2)  [OVER (...)]

Descrição

Retorna o coeficiente de correlação de Pearson de um grupo de pares de números. O primeiro número de cada par é a variável dependente e o segundo número é a variável independente. O resultado retornado está entre -1 e 1. Um resultado igual a 0 indica que não há correlação.

Essa função ignora pares de entrada que tenham um ou mais valores NULL. Se houver menos de dois pares de entrada sem valores NULL, a função retornará NULL.

Tipos de entradas compatíveis

FLOAT64

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

FLOAT64

COVAR_POP

COVAR_POP(X1, X2)  [OVER (...)]

Descrição

Retorna a covariância da população de pares de números. O primeiro número é a variável dependente e o segundo é a variável independente. O resultado retornado está entre -Inf e +Inf.

Essa função ignora pares de entrada que tenham um ou mais valores NULL. Se não houver um par de entrada sem valores NULL, esta função retornará NULL. Se houver exatamente um par de entrada sem valores NULL, esta função retornará 0.

Tipos de entradas compatíveis

FLOAT64

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

FLOAT64

COVAR_SAMP

COVAR_SAMP(X1, X2)  [OVER (...)]

Descrição

Retorna a covariância de amostra de um conjunto de pares de números. O primeiro número é a variável dependente e o segundo é a variável independente. O resultado retornado está entre -Inf e +Inf.

Essa função ignora pares de entrada que tenham um ou mais valores NULL. Se houver menos de dois pares de entrada sem valores NULL, a função retornará NULL.

Tipos de entradas compatíveis

FLOAT64

Cláusula opcional

OVER: especifica uma janela. Consulte Funções analíticas.

Tipos de dados retornados

FLOAT64

STDDEV_POP

STDDEV_POP([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna o desvio padrão polarizado da população dos valores. O resultado retornado está entre 0 e +Inf.

Essa função ignora as entradas NULL. Se todas as entradas forem ignoradas, ela retornará NULL.

Mas se ela receber uma única entrada diferente de NULL, retornará 0.

Tipos de entradas compatíveis

FLOAT64

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em STDDEV_POP().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

FLOAT64

STDDEV_SAMP

STDDEV_SAMP([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna o desvio padrão polarizado de amostra dos valores. O resultado retornado está entre 0 e +Inf.

Essa função ignora as entradas NULL. Se houver menos de duas entradas diferentes de NULL, ela retornará NULL.

Tipos de entradas compatíveis

FLOAT64

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em STDDEV_SAMP().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

FLOAT64

STDDEV

STDDEV([DISTINCT] expression)  [OVER (...)]

Descrição

Um sinônimo de STDDEV_SAMP.

VAR_POP

VAR_POP([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna a variância polarizada da população dos valores. O resultado retornado está entre 0 e +Inf.

Essa função ignora as entradas NULL. Se todas as entradas forem ignoradas, ela retornará NULL.

Mas se ela receber uma única entrada diferente de NULL, retornará 0.

Tipos de entradas compatíveis

FLOAT64

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em VAR_POP().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

FLOAT64

VAR_SAMP

VAR_SAMP([DISTINCT] expression)  [OVER (...)]

Descrição

Retorna a variância não polarizada de amostra dos valores. O resultado retornado está entre 0 e +Inf.

Essa função ignora as entradas NULL. Se houver menos de duas entradas diferentes de NULL, ela retornará NULL.

Tipos de entradas compatíveis

FLOAT64

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. OVER: especifica uma janela. Consulte Funções analíticas. No momento, esta cláusula é incompatível com todas as outras cláusulas em VAR_SAMP().
  2. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.

Tipos de dados retornados

FLOAT64

VARIANCE

VARIANCE([DISTINCT] expression)  [OVER (...)]

Descrição

Um sinônimo de VAR_SAMP.

Funções de agregação aproximada

As funções de agregação aproximadas são escaláveis no que diz respeito ao uso e tempo da memória. No entanto, elas produzem resultados aproximados em vez de exatos. Para mais informações, consulte Agregação aproximada.

APPROX_COUNT_DISTINCT

APPROX_COUNT_DISTINCT(expression)

Descrição

Retorna o resultado aproximado para COUNT(DISTINCT expression). O valor retornado é uma estimativa estatística e não necessariamente o valor real.

Essa função é menos exata que COUNT(DISTINCT expression), mas funciona melhor com entradas muito grandes.

Tipos de argumentos compatíveis

Qualquer tipo de dado, exceto: ARRAY STRUCT

Tipos de dados retornados

INT64

Exemplos

SELECT APPROX_COUNT_DISTINCT(x) as approx_distinct
FROM UNNEST([0, 1, 1, 2, 3, 5]) as x;

+-----------------+
| approx_distinct |
+-----------------+
| 5               |
+-----------------+

APPROX_QUANTIL

APPROX_QUANTILES([DISTINCT] expression, number [{IGNORE|RESPECT} NULLS])

Descrição

Retorna os limites aproximados para um grupo de valores expression, sendo que number representa quantos quantis serão criados. Essa função retorna uma matriz de elementos number + 1, em que o primeiro elemento é o mínimo aproximado e o último elemento é o máximo aproximado.

Tipos de argumentos compatíveis

expression pode ser qualquer tipo de dado compatível, exceto: ARRAY STRUCT

number precisa ser INT64.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. DISTINCT: cada valor distinto de expression é agregado apenas uma vez no resultado.
  2. IGNORE NULLS ou RESPECT NULLS: se for especificado ou se nenhum for especificado, os valores NULL serão excluídos do resultado. Se RESPECT NULLS for especificado, os valores NULL serão incluídos no resultado. No entanto, ocorrerá um erro se uma matriz no resultado final da consulta incluir um elemento NULL.

Tipos de dados retornados

Um ARRAY do tipo especificado pelo parâmetro expression.

Retorna NULL se não houver nenhuma linha de entrada ou expression for avaliado como NULL para todas as linhas.

Exemplos

SELECT APPROX_QUANTILES(x, 2) AS approx_quantiles
FROM UNNEST([1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 5, 10]       |
+------------------+
SELECT APPROX_QUANTILES(x, 100)[OFFSET(90)] AS percentile_90
FROM UNNEST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) AS x;

+---------------+
| percentile_90 |
+---------------+
| 9             |
+---------------+
SELECT APPROX_QUANTILES(DISTINCT x, 2) AS approx_quantiles
FROM UNNEST([1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 6, 10]       |
+------------------+
SELECT FORMAT("%T", APPROX_QUANTILES(x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 4, 10]    |
+------------------+
SELECT FORMAT("%T", APPROX_QUANTILES(DISTINCT x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 6, 10]    |
+------------------+

APPROX_TOP_COUNT

APPROX_TOP_COUNT(expression, number)

Descrição

Retorna os elementos principais aproximados de expression. O parâmetro number especifica o número de elementos retornados.

Tipos de argumentos compatíveis

expression pode ser de qualquer tipo de dado compatível com a cláusula GROUP BY.

number precisa ser INT64.

Tipos de dados retornados

Uma ARRAY do tipo STRUCT. O STRUCT contém dois campos. O primeiro campo (chamado value) contém um valor de entrada. O segundo campo (chamado count) contém um INT64 que especifica o número de vezes que o valor foi retornado.

Retorna NULL, se houver linhas de entrada igual a zero.

Exemplos

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST(["apple", "apple", "pear", "pear", "pear", "banana"]) as x;

+-------------------------+
| approx_top_count        |
+-------------------------+
| [{pear, 3}, {apple, 2}] |
+-------------------------+

Tratamento de NULL

APPROX_TOP_COUNT não ignora NULLs na entrada. Por exemplo:

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST([NULL, "pear", "pear", "pear", "apple", NULL]) as x;

+------------------------+
| approx_top_count       |
+------------------------+
| [{pear, 3}, {NULL, 2}] |
+------------------------+

APPROX_TOP_SUM

APPROX_TOP_SUM(expression, weight, number)

Descrição

Retorna os elementos principais aproximados de expression, com base na soma de um weight atribuído. O parâmetro number especifica o número de elementos retornados.

Se a entrada weight for negativa ou NaN, esta função retornará um erro.

Tipos de argumentos compatíveis

expression pode ser de qualquer tipo de dado compatível com a cláusula GROUP BY.

weight precisa atender a uma das seguintes condições:

  • INT64
  • FLOAT64

number precisa ser INT64.

Tipos de dados retornados

Uma ARRAY do tipo STRUCT. O STRUCT contém dois campos: value e sum. O campo value contém o valor da expressão de entrada. O campo sum é do mesmo tipo que weight e é a soma aproximada do peso de entrada associado ao campo value.

Retorna NULL, se houver linhas de entrada igual a zero.

Exemplos

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([
  STRUCT("apple" AS x, 3 AS weight),
  ("pear", 2),
  ("apple", 0),
  ("banana", 5),
  ("pear", 4)
]);

+--------------------------+
| approx_top_sum           |
+--------------------------+
| [{pear, 6}, {banana, 5}] |
+--------------------------+

Tratamento de NULL

APPROX_TOP_SUM não ignora valores NULL para os parâmetros expression e weight.

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, NULL AS weight), ("pear", 0), ("pear", NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{pear, 0}, {apple, NULL}] |
+----------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, 2)]);

+-------------------------+
| approx_top_sum          |
+-------------------------+
| [{NULL, 2}, {apple, 0}] |
+-------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{apple, 0}, {NULL, NULL}] |
+----------------------------+

Funções HyperLogLog++

O BigQuery aceita as funções de agregação aproximada a seguir com o uso do algoritmo HyperLogLog++. Para uma explicação de como as funções de agregação aproximada funcionam, consulte Agregação aproximada.

HLL_COUNT.INIT

HLL_COUNT.INIT(input [, precision])

Descrição

Uma função de agregação que usa um ou mais valores input e os agrega em um sketch de HyperLogLog++ (em inglês). Cada sketch é representado usando o tipo de dados BYTES. Em seguida, é possível mesclar os sketches usando HLL_COUNT.MERGE ou HLL_COUNT.MERGE_PARTIAL. Se nenhuma mesclagem for necessária, será possível extrair do rascunho a contagem final de valores distintos usando HLL_COUNT.EXTRACT.

Essa função suporta um parâmetro opcional, precision. Ele define a precisão da estimativa ao custo da memória adicional necessária para processar os sketches ou armazená-los no disco. A tabela a seguir mostra os valores de precisão permitidos, o tamanho máximo do sketch por grupo e o intervalo de confiança (CI, na sigla em inglês) de precisões típicas:

Precisão Tamanho máx. do sketch (KiB) CI de 65% CI de 95% CI de 99%
10 1 ±1,63% ±3,25% ±6,50%
11 2 ±1,15% ±2,30% ±4,60%
12 4 ±0,81% ±1,63% ±3,25%
13 8 ±0,57% ±1,15% ±1,72%
14 16 ±0,41% ±0,81% ±1,22%
15 (padrão) 32 ±0,29% ±0,57% ±0,86%
16 64 ±0,20% ±0,41% ±0,61%
17 128 ±0,14% ±0,29% ±0,43%
18 256 ±0,10% ±0,20% ±0,41%
19 512 ±0,07% ±0,14% ±0,29%
20 1024 ±0,05% ±0,10% ±0,20%
21 2048 ±0,04% ±0,07% ±0,14%
22 4096 ±0,03% ±0,05% ±0,10%
23 8192 ±0,02% ±0,04% ±0,07%
24 16384 ±0,01% ±0.03% ±0,05%

Se a entrada for NULL, essa função retornará NULL.

Para mais informações, consulte HyperLogLog in Practice: Algorithmic Engineering of a State of The Art Cardinality Estimation Algorithm (em inglês).

Tipos de entradas compatíveis

INT64, NUMERIC, STRING e BYTES

Tipo de retorno

BYTES

Exemplo

SELECT
  HLL_COUNT.INIT(respondent) AS respondents_hll,
  flavor,
  country
FROM UNNEST([
  STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
  (1, "Chocolate", "CH"),
  (2, "Chocolate", "US"),
  (2, "Strawberry", "US")])
GROUP BY flavor, country;

HLL_COUNT.MERGE

HLL_COUNT.MERGE(sketch)

Descrição

Uma função de agregação que retorna a cardinalidade de vários sketches definidos por HyperLogLog++ pelo cálculo da união.

Cada sketch precisa ter a mesma precisão e ser inicializado no mesmo tipo. As tentativas de mesclar sketches com precisões ou tipos diferentes resultam em erro. Por exemplo, não é possível mesclar um sketch inicializado nos dados de INT64 com um inicializado nos dados de STRING.

Essa função ignora os valores NULL ao mesclar sketches. Se a mesclagem acontecer em linhas de zero ou somente em valores NULL, a função retornará 0.

Tipos de entradas compatíveis

BYTES

Tipo de retorno

INT64

Exemplo

SELECT HLL_COUNT.MERGE(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.MERGE_PARTIAL

HLL_COUNT.MERGE_PARTIAL(sketch)

Descrição

Uma função de agregação que usa uma ou mais entradas sketch de HyperLogLog++ (em inglês) e as mescla em um novo sketch.

Essa função retornará NULL, se não houver entrada ou se todas elas forem NULL.

Tipos de entradas compatíveis

BYTES

Tipo de retorno

BYTES

Exemplo

SELECT HLL_COUNT.MERGE_PARTIAL(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.EXTRACT

HLL_COUNT.EXTRACT(sketch)

Descrição

Uma função escalar que extrai uma estimativa da cardinalidade de um único sketch do HyperLogLog++.

Se sketch for NULL, essa função retornará uma estimativa de cardinalidade de 0.

Tipos de entradas compatíveis

BYTES

Tipo de retorno

INT64

Exemplo

SELECT
  flavor,
  country,
  HLL_COUNT.EXTRACT(respondents_hll) AS num_respondents
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country);

+------------+---------+-----------------+
| flavor     | country | num_respondents |
+------------+---------+-----------------+
| Vanilla    | CH      | 1               |
| Chocolate  | CH      | 1               |
| Chocolate  | US      | 1               |
| Strawberry | US      | 1               |
+------------+---------+-----------------+

Funções de numeração

As seções a seguir descrevem as funções de numeração compatíveis com o BigQuery. As funções de numeração são um subconjunto de funções analíticas. Para uma explicação de como são funções analíticas, consulte Conceitos da função analítica. Para uma descrição de como são funções de numeração, consulte os Conceitos da função de numeração.

Requisitos da cláusula OVER:

  • PARTITION BY: opcional.
  • ORDER BY: obrigatório, exceto para ROW_NUMBER().
  • window_frame_clause: não permitido

RANK

Descrição

Retorna a classificação de ordinal (baseada em 1) de cada linha dentro da partição ordenada. Todas as linhas dos pares recebem o mesmo valor da classificação. A linha ou o grupo de linhas de pares seguintes recebem um valor da classificação que aumenta baseado no número de pares com o valor da classificação anterior, em vez de DENSE_RANK, que sempre aumenta em 1.

Tipos de argumentos compatíveis

INT64

DENSE_RANK

Descrição

Retorna a classificação de ordinal (baseada em 1) de cada linha dentro da partição da janela. Todas as linhas de pares recebem o mesmo valor da classificação. O valor seguinte é incrementado em um.

Tipos de argumentos compatíveis

INT64

PERCENT_RANK

Descrição

Retorna a classificação do percentil de uma linha definida como (RK-1)/(NR-1), na qual RK é o RANK da linha e NR é o número de linhas na partição. Retorna 0 se NR = 1.

Tipos de argumentos compatíveis

FLOAT64

CUME_DIST

Descrição

Retorna a classificação relativa de uma linha definida como NP/NR. NP é definido como o número de linhas que precedem ou são pares da linha atual. NR é o número de linhas da partição.

Tipos de argumentos compatíveis

FLOAT64

NTILE

NTILE(constant_integer_expression)

Descrição

Essa função divide as linhas em intervalos constant_integer_expression com base na ordenação de linhas e retorna o número do intervalo com base em 1 que é atribuído a cada linha. O número de linhas nos intervalos pode diferir em 1, no máximo. Os valores restantes, isto é, o número de linhas divididas por intervalos, são distribuídos um para cada intervalo, começando com o intervalo 1. Se constant_integer_expression for avaliado como NULL, 0 ou negativo, um erro será fornecido.

Tipos de argumentos compatíveis

INT64

ROW_NUMBER

Descrição

Não requer a cláusula ORDER BY. Retorna o ordinal da linha sequencial (baseado em 1) de cada linha de cada partição ordenada. Se a cláusula ORDER BY não for especificada, o resultado será não determinístico.

Tipos de argumentos compatíveis

INT64

Funções Bit

O BigQuery é compatível com as funções Bit a seguir.

BIT_COUNT

BIT_COUNT(expression)

Descrição

A entrada, expression, precisa ser um número inteiro ou BYTES.

Retorna o número de bits que estão definidos na entrada expression. No caso de números inteiros com sinal, isso significa o número de bits na forma de complemento de dois.

Tipos de dados retornados

INT64

Exemplo

SELECT a, BIT_COUNT(a) AS a_bits, FORMAT("%T", b) as b, BIT_COUNT(b) AS b_bits
FROM UNNEST([
  STRUCT(0 AS a, b'' AS b), (0, b'\x00'), (5, b'\x05'), (8, b'\x00\x08'),
  (0xFFFF, b'\xFF\xFF'), (-2, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE'),
  (-1, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'),
  (NULL, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF')
]) AS x;

+-------+--------+---------------------------------------------+--------+
| a     | a_bits | b                                           | b_bits |
+-------+--------+---------------------------------------------+--------+
| 0     | 0      | b""                                         | 0      |
| 0     | 0      | b"\x00"                                     | 0      |
| 5     | 2      | b"\x05"                                     | 2      |
| 8     | 1      | b"\x00\x08"                                 | 1      |
| 65535 | 16     | b"\xff\xff"                                 | 16     |
| -2    | 63     | b"\xff\xff\xff\xff\xff\xff\xff\xfe"         | 63     |
| -1    | 64     | b"\xff\xff\xff\xff\xff\xff\xff\xff"         | 64     |
| NULL  | NULL   | b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" | 80     |
+-------+--------+---------------------------------------------+--------+

Funções matemáticas

Todas as funções matemáticas têm os seguintes comportamentos:

  • Elas retornam NULL se algum dos parâmetros de entrada for .
  • Elas retornam NaN se algum dos argumentos for .

ABS

ABS(X)

Descrição

Calcula o valor absoluto. Retornará um erro caso o argumento seja um número inteiro e o valor de saída não possa ser representado como o mesmo tipo. Isso acontece apenas com o maior valor negativo da entrada, sem representação positiva. Retorna +inf para um argumento +/-inf.

SIGN

SIGN(X)

Descrição

Retorna -1, 0 ou +1 para argumentos negativo, zero e positivo, respectivamente. Para argumentos de ponto flutuante, essa função não faz distinção entre zero positivo e negativo. Retorna NaN para um argumento NaN.

IS_INF

IS_INF(X)

Descrição

Retornará TRUE se o valor for um infinito positivo ou negativo. Retorna NULL para entradas NULL.

IS_NAN

IS_NAN(X)

Descrição

Retorna TRUE se o valor for NaN. Retorna NULL para entradas NULL.

IEEE_DIVIDE

IEEE_DIVIDE(X, Y)

Descrição

Divide X por Y e nunca falha. Ela retorna FLOAT64. Ao contrário do operador de divisão (/), não gera erros de divisão por zero ou estouro.

Casos especiais:

  • Se o resultado estourar, retorna +/-inf.
  • Se Y=0 e X=0, retorna NaN.
  • Se Y=0 e X!=0, retorna +/-inf.
  • Se X=+/-inf e Y=, retorna NaN.

O comportamento de IEEE_DIVIDE é ilustrado com mais detalhes na tabela abaixo.

Casos especiais de IEEE_DIVIDE

A tabela a seguir lista os casos especiais de IEEE_DIVIDE.

Tipos de dados do numerador (X) Tipos de dados do denominador (Y) Valor do resultado
Qualquer um, exceto 0 0 +/-inf
0 0 NaN
0 NaN NaN
NaN 0 NaN
+/-inf +/-inf NaN

RAND

RAND()

Descrição

Gera um valor pseudoaleatório do tipo FLOAT64 no intervalo de [0, 1), incluindo 0 e excluindo 1.

SQRT

SQRT(X)

Descrição

Calcula a raiz quadrada de X. Gera um erro se X for menor que 0. Retorna +inf se X for +inf.

POW

POW(X, Y)

Descrição

Retorna o valor de X elevado à potência de Y. Se o resultado estourar e não for representável, a função retornará um valor zero. Retornará um erro se uma das seguintes condições for verdadeira:

  • X é um valor finito menor que 0, e Y é um número não inteiro.
  • X é 0, e Y é um valor finito menor que 0

O comportamento de POW() é ilustrado com mais detalhes na tabela abaixo.

POWER

POWER(X, Y)

Descrição

Sinônimo de POW().

Casos especiais para POW(X, Y) e POWER(X, Y)

Veja a seguir casos especiais para POW(X, Y) e POWER(X, Y).

X Y POW(X, Y) ou POWER(X, Y)
1,0 Qualquer valor, incluindo NaN 1,0
qualquer um, incluindo NaN 0 1,0
-1,0 +/-inf 1,0
ABS(X) < 1 -inf +inf
ABS(X) > 1 -inf 0
ABS(X) < 1 +inf 0
ABS(X) > 1 +inf +inf
-inf Y < 0 0
-inf Y > 0 -inf se Y for um número inteiro ímpar, +inf caso contrário
+inf Y < 0 0
+inf Y > 0 +inf

EXP

EXP(X)

Descrição

Calcula e à potência de X, também chamada de função exponencial natural. Se ocorrer um estouro negativo, essa função retornará zero. Um erro será gerado se o resultado estourar. Se X for +/-inf, essa função retorna +inf ou 0.

LN

LN(X)

Descrição

Calcula o logaritmo natural de X. Um erro será gerado se X for menor ou igual a zero. Se X for +inf, essa função retorna +inf.

LOG

LOG(X [, Y])

Descrição

Se apenas X estiver presente, LOG será um sinônimo de LN. Se Y também estiver presente, calculará o logaritmo de X na base Y. A função gera um erro nos seguintes casos:

  • X é menor ou igual a zero
  • Y é 1,0
  • Y é menor ou igual a zero.

O comportamento de LOG(X, Y) é ilustrado com mais detalhes na tabela abaixo.

Casos especiais de LOG(X, Y)

X Y LOG(X, Y)
-inf Qualquer valor NaN
Qualquer valor +inf NaN
+inf 0,0 Y < 1,0 -inf
+inf Y > 1,0 +inf

LOG10

LOG10(X)

Descrição

Semelhante a LOG, mas calcula o logaritmo de base 10.

GREATEST

GREATEST(X1,...,XN)

Descrição

Retorna NULL se alguma das entradas for . Caso contrário, retorna NaN se alguma das entradas for NaN. Caso contrário, retorna o maior valor entre X1,…, XN de acordo com a comparação.

LEAST

LEAST(X1,...,XN)

Descrição

Retorna NULL se alguma das entradas for . Retorna NaN se alguma das entradas for NaN. Caso contrário, retorna o menor valor entre X1,…, XN de acordo com a comparação.

DIV

DIV(X, Y)

Descrição

Retorna o resultado da divisão de inteiros de X por Y. Divisão por zero retorna um erro. Divisão por -1 pode estourar. Consulte a tabela abaixo para ver possíveis tipos de resultados.

SAFE_DIVIDE

SAFE_DIVIDE(X, Y)

Descrição

Equivalente ao operador de divisão (/), mas retorna NULL se ocorrer um erro como o de divisão por zero.

SAFE_MULTIPLY

SAFE_MULTIPLY(X, Y)

Descrição

Equivalente ao operador de multiplicação (*), mas retorna NULL se ocorrer um estouro.

SAFE_NEGATE

SAFE_NEGATE(X)

Descrição

Equivalente ao operador de menos unário (-), mas retorna NULL se ocorrer um estouro.

SAFE_ADD

SAFE_ADD(X, Y)

Descrição

Equivalente ao operador de adição (+), mas retorna NULL se ocorrer um estouro.

SAFE_SUBTRACT

SAFE_SUBTRACT(X, Y)

Descrição

Equivalente ao operador de subtração (-), mas retorna NULL se ocorrer um estouro.

MOD

MOD(X, Y)

Descrição

Função módulo: retorna o restante da divisão de X por Y. O valor retornado tem o mesmo sinal que X. Um erro será gerado se Y for 0. Consulte a tabela abaixo para ver possíveis tipos de resultados.

ROUND

ROUND(X [, N])

Descrição

Se apenas X estiver presente, ROUND arredondará X para o inteiro mais próximo. Se N estiver presente, ROUND arredondará X para N casas decimais após a vírgula decimal. Se N for negativo, ROUND arredondará os dígitos à esquerda da vírgula decimal. Casos em que haja metades são arredondados para longe de zero. Se ocorrer um estouro, será gerado um erro.

TRUNC

TRUNC(X [, N])

Descrição

Se apenas X estiver presente, TRUNC arredondará X para o inteiro mais próximo cujo valor absoluto não seja maior que o valor absoluto de X. Se N também estiver presente, se comportará como ROUND(X, N), mas sempre arredondará para zero e nunca haverá estouro.

CEIL

CEIL(X)

Descrição

Retorna o menor valor integral (com o tipo FLOAT64) que não é inferior a X.

CEILING

CEILING(X)

Descrição

Sinônimo de CEIL(X)

FLOOR

FLOOR(X)

Descrição

Retorna o maior valor integral (com o tipo FLOAT64) que não é superior a X.

Exemplo de comportamento da função de arredondamento

Exemplo de comportamento de funções de arredondamento do BigQuery:

Entrada "X" ROUND(X) TRUNC(X) CEIL(X) FLOOR(X)
2,0 2,0 2,0 2,0 2,0
2,3 2,0 2,0 3,0 2,0
2,8 3,0 2,0 3,0 2,0
2,5 3,0 2,0 3,0 2,0
-2,3 -2,0 -2,0 -2,0 -3,0
-2,8 -3,0 -2,0 -2,0 -3,0
-2,5 -3,0 -2,0 -2,0 -3,0
0 0 0 0 0
+/-inf +/-inf +/-inf +/-inf +/-inf
NaN NaN NaN NaN NaN

COS

COS(X)

Descrição

Calcula o cosseno de X onde X é especificado em radianos. Nunca falha.

COSH

COSH(X)

Descrição

Calcula o cosseno hiperbólico de X onde X é especificado em radianos. Gera um erro se ocorrer um estouro.

ACOS

ACOS(X)

Descrição

Calcula o valor principal do cosseno inverso de X. O valor retornado está no intervalo [0,π]. Um erro será gerado se X for um valor fora do intervalo [-1, 1].

ACOSH

ACOSH(X)

Descrição

Calcula o cosseno hiperbólico inverso de X. Se X for um valor menor que 1, gera um erro.

SIN

SIN(X)

Descrição

Calcula o seno de X onde X é especificado em radianos. Nunca falha.

SINH

SINH(X)

Descrição

Calcula o seno hiperbólico de X, onde X é especificado em radianos. Gera um erro se ocorrer um estouro.

ASIN

ASIN(X)

Descrição

Calcula o valor principal do seno inverso de X. O valor retornado está no intervalo [-π/2, π/2]. Um erro será gerado se X estiver fora do intervalo [-1, 1].

ASINH

ASINH(X)

Descrição

Calcula o seno hiperbólico inverso de X. Não falha.

TAN

TAN(X)

Descrição

Calcula a tangente de X onde X é especificado em radianos. Gera um erro se ocorrer um estouro.

TANH

TANH(X)

Descrição

Calcula a tangente hiperbólica de X, onde X é especificado em radianos. Não falha.

ATAN

ATAN(X)

Descrição

Calcula o valor principal da tangente inversa de X. O valor retornado está no intervalo [-π/2, π/2]. Não falha.

ATANH

ATANH(X)

Descrição

Calcula a tangente hiperbólica inversa de X. Gera um erro se X estiver fora do intervalo [-1, 1].

ATAN2

ATAN2(Y, X)

Descrição

Calcula o valor principal da tangente inversa de Y/X usando os sinais dos dois argumentos para determinar o quadrante. O valor de retorno está no intervalo [-π, π]. O comportamento dessa função é ilustrado com mais detalhes na tabela abaixo.

Casos especiais de ATAN2()

S X ATAN2(Y, X)
NaN Qualquer valor NaN
Qualquer valor NaN NaN
0 0 0, π ou -π, dependendo do sinal de X e Y
Valor finito -inf π ou -π, dependendo do sinal de Y
Valor finito +inf 0
+/-inf Valor finito π/2 ou π/2, dependendo do sinal de Y
+/-inf -inf ¾π ou -¾π, dependendo do sinal de Y
+/-inf +inf π/4 ou -π/4, dependendo do sinal de Y

Casos especiais de funções trigonométricas e hiperbólicas de arredondamento

X COS(X) COSH(X) ACOS(X) ACOSH(X) SIN(X) SINH(X) ASIN(X) ASINH(X) TAN(X) TANH(X) ATAN(X) ATANH(X)
+/-inf NaN =+inf NaN =+inf NaN =+inf NaN =+inf NaN =+1,0 π/2 NaN
-inf NaN =+inf NaN NaN NaN -inf NaN -inf NaN -1,0 -π/2 NaN
NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN

RANGE_BUCKET

RANGE_BUCKET(point, boundaries_array)

Descrição

RANGE_BUCKET verifica uma matriz classificada e retorna a posição 0 do limite superior do ponto. Isso pode ser útil se você precisar agrupar seus dados para criar partições, histogramas, regras definidas pelo negócio e muito mais.

RANGE_BUCKET segue as seguintes regras:

  • Se o ponto existir na matriz, o índice do próximo valor maior será retornado.

    RANGE_BUCKET(20, [0, 10, 20, 30, 40]) -- 3 is return value
    RANGE_BUCKET(20, [0, 10, 20, 20, 40, 40]) -- 4 is return value
    
  • Se o ponto não existir na matriz, mas ficar entre dois valores, o índice do valor maior será retornado.

    RANGE_BUCKET(25, [0, 10, 20, 30, 40]) -- 3 is return value
    
  • Se o ponto for menor que o primeiro valor na matriz, será retornado 0.

    RANGE_BUCKET(-10, [5, 10, 20, 30, 40]) -- 0 is return value
    
  • Se o ponto for maior ou igual ao último valor na matriz, o comprimento da matriz será retornado.

    RANGE_BUCKET(80, [0, 10, 20, 30, 40]) -- 5 is return value
    
  • Se a matriz estiver vazia, será retornado 0.

    RANGE_BUCKET(80, []) -- 0 is return value
    
  • Se o ponto for NULL ou NaN, será retornado .

    RANGE_BUCKET(NULL, [0, 10, 20, 30, 40]) -- NULL is return value
    
  • O tipo de dados do ponto e da matriz deve ser compatível.

    RANGE_BUCKET('a', ['a', 'b', 'c', 'd']) -- 1 is return value
    RANGE_BUCKET(1.2, [1, 1.2, 1.4, 1.6]) -- 2 is return value
    RANGE_BUCKET(1.2, [1, 2, 4, 6]) -- execution failure
    

A falha na execução ocorre quando:

  • A matriz tem um valor NaN ou NULL.

    RANGE_BUCKET(80, [NULL, 10, 20, 30, 40]) -- execution failure
    
  • A matriz não é classificada em ordem crescente.

    RANGE_BUCKET(30, [10, 30, 20, 40, 50]) -- execution failure
    

Parâmetros

  • point: um valor genérico.
  • boundaries_array: uma matriz genérica de valores.

Valor de retorno

INT64

Exemplos

Em uma tabela chamada students, verifique quantos registros existiriam em cada intervalo de age_group, com base na idade de um aluno:

  • age_group 0 (idade <10 anos)
  • age_group 1 (idade >= 10, idade <20)
  • age_group 2 (idade >= 20, idade <30)
  • age_group 3 (idade >= 30)
WITH students AS
(
  SELECT 9 AS age UNION ALL
  SELECT 20 AS age UNION ALL
  SELECT 25 AS age UNION ALL
  SELECT 31 AS age UNION ALL
  SELECT 32 AS age UNION ALL
  SELECT 33 AS age
)
SELECT RANGE_BUCKET(age, [10, 20, 30]) AS age_group, COUNT(*) AS count
FROM students
GROUP BY 1

+--------------+-------+
| age_group    | count |
+--------------+-------+
| 0            | 1     |
| 2            | 2     |
| 3            | 3     |
+--------------+-------+

As seções a seguir descrevem as funções de navegação compatíveis com o BigQuery. As funções de navegação são um subconjunto de funções analíticas. Para uma explicação de como são funções analíticas, consulte Conceitos da função analítica. Para uma explicação sobre as funções de navegação, consulte Conceitos da função de navegação.

FIRST_VALUE

FIRST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])

Descrição

Retorna o valor de value_expression para a primeira linha no frame da janela atual.

Essa função inclui valores NULL no cálculo, a menos que IGNORE NULLS esteja presente. Se IGNORE NULLS estiver presente, a função excluirá valores NULL do cálculo.

Tipos de argumentos compatíveis

value_expression pode ser qualquer tipo de dados que uma expressão pode retornar.

Tipos de dados retornados

ANY

Exemplos

O exemplo a seguir calcula o tempo mais rápido de cada divisão.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', fastest_time) AS fastest_time,
  TIMESTAMP_DIFF(finish_time, fastest_time, SECOND) AS delta_in_seconds
FROM (
  SELECT name,
  finish_time,
  division,
  FIRST_VALUE(finish_time)
    OVER (PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS fastest_time
  FROM finishers);

+-----------------+-------------+----------+--------------+------------------+
| name            | finish_time | division | fastest_time | delta_in_seconds |
+-----------------+-------------+----------+--------------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | 0                |
| Sophia Liu      | 02:51:45    | F30-34   | 02:51:45     | 0                |
| Nikki Leith     | 02:59:01    | F30-34   | 02:51:45     | 436              |
| Jen Edwards     | 03:06:36    | F30-34   | 02:51:45     | 891              |
| Meghan Lederer  | 03:07:41    | F30-34   | 02:51:45     | 956              |
| Lauren Reasoner | 03:10:14    | F30-34   | 02:51:45     | 1109             |
| Lisa Stelzner   | 02:54:11    | F35-39   | 02:54:11     | 0                |
| Lauren Matthews | 03:01:17    | F35-39   | 02:54:11     | 426              |
| Desiree Berry   | 03:05:42    | F35-39   | 02:54:11     | 691              |
| Suzy Slane      | 03:06:24    | F35-39   | 02:54:11     | 733              |
+-----------------+-------------+----------+--------------+------------------+

LAST_VALUE

LAST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])

Descrição

Retorna o valor de value_expression para a última linha no frame da janela atual.

Essa função inclui valores NULL no cálculo, a menos que IGNORE NULLS esteja presente. Se IGNORE NULLS estiver presente, a função excluirá valores NULL do cálculo.

Tipos de argumentos compatíveis

value_expression pode ser qualquer tipo de dados que uma expressão pode retornar.

Tipos de dados retornados

ANY

Exemplos

O exemplo a seguir calcula o tempo mais lento de cada divisão.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', slowest_time) AS slowest_time,
  TIMESTAMP_DIFF(slowest_time, finish_time, SECOND) AS delta_in_seconds
FROM (
  SELECT name,
  finish_time,
  division,
  LAST_VALUE(finish_time)
    OVER (PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS slowest_time
  FROM finishers);

+-----------------+-------------+----------+--------------+------------------+
| name            | finish_time | division | slowest_time | delta_in_seconds |
+-----------------+-------------+----------+--------------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | 0                |
| Sophia Liu      | 02:51:45    | F30-34   | 03:10:14     | 1109             |
| Nikki Leith     | 02:59:01    | F30-34   | 03:10:14     | 673              |
| Jen Edwards     | 03:06:36    | F30-34   | 03:10:14     | 218              |
| Meghan Lederer  | 03:07:41    | F30-34   | 03:10:14     | 153              |
| Lauren Reasoner | 03:10:14    | F30-34   | 03:10:14     | 0                |
| Lisa Stelzner   | 02:54:11    | F35-39   | 03:06:24     | 733              |
| Lauren Matthews | 03:01:17    | F35-39   | 03:06:24     | 307              |
| Desiree Berry   | 03:05:42    | F35-39   | 03:06:24     | 42               |
| Suzy Slane      | 03:06:24    | F35-39   | 03:06:24     | 0                |
+-----------------+-------------+----------+--------------+------------------+

NTH_VALUE

NTH_VALUE (value_expression, constant_integer_expression [{RESPECT | IGNORE} NULLS])

Descrição

Retorna o valor de value_expression na linha N do frame da janela atual, em que N é definido por constant_integer_expression. Retorna NULL, se não houver linha.

Essa função inclui valores NULL no cálculo, a menos que IGNORE NULLS esteja presente. Se IGNORE NULLS estiver presente, a função excluirá valores NULL do cálculo.

Tipos de argumentos compatíveis

  • value_expression pode ser qualquer tipo de dados que possa ser retornado de uma expressão.
  • constant_integer_expression pode ser qualquer expressão constante que retorna um número inteiro.

Tipos de dados retornados

ANY

Exemplos

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', fastest_time) AS fastest_time,
  FORMAT_TIMESTAMP('%X', second_fastest) AS second_fastest
FROM (
  SELECT name,
  finish_time,
  division,finishers,
  FIRST_VALUE(finish_time)
    OVER w1 AS fastest_time,
  NTH_VALUE(finish_time, 2)
    OVER w1 as second_fastest
  FROM finishers
  WINDOW w1 AS (
    PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING));

+-----------------+-------------+----------+--------------+----------------+
| name            | finish_time | division | fastest_time | second_fastest |
+-----------------+-------------+----------+--------------+----------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | NULL           |
| Sophia Liu      | 02:51:45    | F30-34   | 02:51:45     | 02:59:01       |
| Nikki Leith     | 02:59:01    | F30-34   | 02:51:45     | 02:59:01       |
| Jen Edwards     | 03:06:36    | F30-34   | 02:51:45     | 02:59:01       |
| Meghan Lederer  | 03:07:41    | F30-34   | 02:51:45     | 02:59:01       |
| Lauren Reasoner | 03:10:14    | F30-34   | 02:51:45     | 02:59:01       |
| Lisa Stelzner   | 02:54:11    | F35-39   | 02:54:11     | 03:01:17       |
| Lauren Matthews | 03:01:17    | F35-39   | 02:54:11     | 03:01:17       |
| Desiree Berry   | 03:05:42    | F35-39   | 02:54:11     | 03:01:17       |
| Suzy Slane      | 03:06:24    | F35-39   | 02:54:11     | 03:01:17       |
+-----------------+-------------+----------+--------------+----------------+

LEAD

LEAD (value_expression[, offset [, default_expression]])

Descrição

Retorna o valor de value_expression em uma linha subsequente. Alterar o valor offset altera qual linha subsequente é retornada; o valor padrão é 1, indicando a próxima linha no frame da janela. Um erro ocorre se offset for NULL ou um valor negativo.

O default_expression opcional é usado se não houver uma linha no frame da janela no deslocamento especificado. Essa expressão precisa ser uma expressão constante e seu tipo precisa ser implicitamente coercível para o tipo de value_expression. Se não for especificado, a default_expression padrão será NULL.

Tipos de argumentos compatíveis

  • value_expression pode ser qualquer tipo de dados que possa ser retornado de uma expressão.
  • offset precisa ser um parâmetro ou literal inteiro não negativo.
  • default_expression precisa ser compatível com o tipo de expressão de valor.

Tipos de dados retornados

ANY

Exemplos

O exemplo a seguir ilustra uma utilização básica da função LEAD.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS followed_by
FROM finishers;

+-----------------+-------------+----------+-----------------+
| name            | finish_time | division | followed_by     |
+-----------------+-------------+----------+-----------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL            |
| Sophia Liu      | 02:51:45    | F30-34   | Nikki Leith     |
| Nikki Leith     | 02:59:01    | F30-34   | Jen Edwards     |
| Jen Edwards     | 03:06:36    | F30-34   | Meghan Lederer  |
| Meghan Lederer  | 03:07:41    | F30-34   | Lauren Reasoner |
| Lauren Reasoner | 03:10:14    | F30-34   | NULL            |
| Lisa Stelzner   | 02:54:11    | F35-39   | Lauren Matthews |
| Lauren Matthews | 03:01:17    | F35-39   | Desiree Berry   |
| Desiree Berry   | 03:05:42    | F35-39   | Suzy Slane      |
| Suzy Slane      | 03:06:24    | F35-39   | NULL            |
+-----------------+-------------+----------+-----------------+

Este próximo exemplo usa o parâmetro offset opcional.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name, 2)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_back
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | two_runners_back |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL             |
| Sophia Liu      | 02:51:45    | F30-34   | Jen Edwards      |
| Nikki Leith     | 02:59:01    | F30-34   | Meghan Lederer   |
| Jen Edwards     | 03:06:36    | F30-34   | Lauren Reasoner  |
| Meghan Lederer  | 03:07:41    | F30-34   | NULL             |
| Lauren Reasoner | 03:10:14    | F30-34   | NULL             |
| Lisa Stelzner   | 02:54:11    | F35-39   | Desiree Berry    |
| Lauren Matthews | 03:01:17    | F35-39   | Suzy Slane       |
| Desiree Berry   | 03:05:42    | F35-39   | NULL             |
| Suzy Slane      | 03:06:24    | F35-39   | NULL             |
+-----------------+-------------+----------+------------------+

O exemplo a seguir substitui os valores NULL por um valor padrão.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LEAD(name, 2, 'Nobody')
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_back
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | two_runners_back |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | Nobody           |
| Sophia Liu      | 02:51:45    | F30-34   | Jen Edwards      |
| Nikki Leith     | 02:59:01    | F30-34   | Meghan Lederer   |
| Jen Edwards     | 03:06:36    | F30-34   | Lauren Reasoner  |
| Meghan Lederer  | 03:07:41    | F30-34   | Nobody           |
| Lauren Reasoner | 03:10:14    | F30-34   | Nobody           |
| Lisa Stelzner   | 02:54:11    | F35-39   | Desiree Berry    |
| Lauren Matthews | 03:01:17    | F35-39   | Suzy Slane       |
| Desiree Berry   | 03:05:42    | F35-39   | Nobody           |
| Suzy Slane      | 03:06:24    | F35-39   | Nobody           |
+-----------------+-------------+----------+------------------+

LAG

LAG (value_expression[, offset [, default_expression]])

Descrição

Retorna o valor de value_expression em uma linha anterior. Alterar o valor de offset altera a linha anterior que é retornada; o valor padrão é 1, indicando a linha anterior no frame da janela. Um erro ocorre se offset for NULL ou um valor negativo.

O default_expression opcional é usado se não houver uma linha no frame da janela no deslocamento especificado. Essa expressão precisa ser uma expressão constante e seu tipo precisa ser implicitamente coercível para o tipo de value_expression. Se não for especificado, a default_expression padrão será NULL.

Tipos de argumentos compatíveis

  • value_expression pode ser qualquer tipo de dados que possa ser retornado de uma expressão.
  • offset precisa ser um parâmetro ou literal inteiro não negativo.
  • default_expression precisa ser compatível com o tipo de expressão de valor.

Tipos de dados retornados

ANY

Exemplos

O exemplo a seguir ilustra uma utilização básica da função LAG.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS preceding_runner
FROM finishers;

+-----------------+-------------+----------+------------------+
| name            | finish_time | division | preceding_runner |
+-----------------+-------------+----------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL             |
| Sophia Liu      | 02:51:45    | F30-34   | NULL             |
| Nikki Leith     | 02:59:01    | F30-34   | Sophia Liu       |
| Jen Edwards     | 03:06:36    | F30-34   | Nikki Leith      |
| Meghan Lederer  | 03:07:41    | F30-34   | Jen Edwards      |
| Lauren Reasoner | 03:10:14    | F30-34   | Meghan Lederer   |
| Lisa Stelzner   | 02:54:11    | F35-39   | NULL             |
| Lauren Matthews | 03:01:17    | F35-39   | Lisa Stelzner    |
| Desiree Berry   | 03:05:42    | F35-39   | Lauren Matthews  |
| Suzy Slane      | 03:06:24    | F35-39   | Desiree Berry    |
+-----------------+-------------+----------+------------------+

Este próximo exemplo usa o parâmetro offset opcional.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name, 2)
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_ahead
FROM finishers;

+-----------------+-------------+----------+-------------------+
| name            | finish_time | division | two_runners_ahead |
+-----------------+-------------+----------+-------------------+
| Carly Forte     | 03:08:58    | F25-29   | NULL              |
| Sophia Liu      | 02:51:45    | F30-34   | NULL              |
| Nikki Leith     | 02:59:01    | F30-34   | NULL              |
| Jen Edwards     | 03:06:36    | F30-34   | Sophia Liu        |
| Meghan Lederer  | 03:07:41    | F30-34   | Nikki Leith       |
| Lauren Reasoner | 03:10:14    | F30-34   | Jen Edwards       |
| Lisa Stelzner   | 02:54:11    | F35-39   | NULL              |
| Lauren Matthews | 03:01:17    | F35-39   | NULL              |
| Desiree Berry   | 03:05:42    | F35-39   | Lisa Stelzner     |
| Suzy Slane      | 03:06:24    | F35-39   | Lauren Matthews   |
+-----------------+-------------+----------+-------------------+

O exemplo a seguir substitui os valores NULL por um valor padrão.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  finish_time,
  division,
  LAG(name, 2, 'Nobody')
    OVER (PARTITION BY division ORDER BY finish_time ASC) AS two_runners_ahead
FROM finishers;

+-----------------+-------------+----------+-------------------+
| name            | finish_time | division | two_runners_ahead |
+-----------------+-------------+----------+-------------------+
| Carly Forte     | 03:08:58    | F25-29   | Nobody            |
| Sophia Liu      | 02:51:45    | F30-34   | Nobody            |
| Nikki Leith     | 02:59:01    | F30-34   | Nobody            |
| Jen Edwards     | 03:06:36    | F30-34   | Sophia Liu        |
| Meghan Lederer  | 03:07:41    | F30-34   | Nikki Leith       |
| Lauren Reasoner | 03:10:14    | F30-34   | Jen Edwards       |
| Lisa Stelzner   | 02:54:11    | F35-39   | Nobody            |
| Lauren Matthews | 03:01:17    | F35-39   | Nobody            |
| Desiree Berry   | 03:05:42    | F35-39   | Lisa Stelzner     |
| Suzy Slane      | 03:06:24    | F35-39   | Lauren Matthews   |
+-----------------+-------------+----------+-------------------+

PERCENTILE_CONT

PERCENTILE_CONT (value_expression, percentile [{RESPECT | IGNORE} NULLS])

Descrição

Calcula o valor do percentil especificado para a expressão de valor, com interpolação linear.

Esta função ignora valores NULL se RESPECT NULLS estiver ausente. Se RESPECT NULLS estiver presente:

  • A interpolação entre dois valores NULL retorna .
  • A interpolação entre um valor NULL e um valor não retorna o valor não .

Tipos de argumentos compatíveis

  • value_expression é uma expressão numérica.
  • percentile é um DOUBLE literal no intervalo [0, 1].

Tipos de dados retornados

DOUBLE

Exemplos

O exemplo a seguir calcula o valor de alguns percentis em uma coluna de valores, ignorando os nulos.

SELECT
  PERCENTILE_CONT(x, 0) OVER() AS min,
  PERCENTILE_CONT(x, 0.01) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5) OVER() AS median,
  PERCENTILE_CONT(x, 0.9) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1) OVER() AS max
FROM UNNEST([0, 3, NULL, 1, 2]) AS x LIMIT 1;

+-----+-------------+--------+--------------+-----+
| min | percentile1 | median | percentile90 | max |
+-----+-------------+--------+--------------+-----+
| 0   | 0.03        | 1.5    | 2.7          | 3   |
+-----+-------------+--------+--------------+-----+

O exemplo a seguir calcula o valor de alguns percentis em uma coluna de valores, respeitando os nulos.

SELECT
  PERCENTILE_CONT(x, 0 RESPECT NULLS) OVER() AS min,
  PERCENTILE_CONT(x, 0.01 RESPECT NULLS) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER() AS median,
  PERCENTILE_CONT(x, 0.9 RESPECT NULLS) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1 RESPECT NULLS) OVER() AS max
FROM UNNEST([0, 3, NULL, 1, 2]) AS x LIMIT 1;

+------+-------------+--------+--------------+-----+
| min  | percentile1 | median | percentile90 | max |
+------+-------------+--------+--------------+-----+
| NULL | 0           | 1      | 2.6          | 3   |
+------+-------------+--------+--------------+-----+

PERCENTILE_DISC

PERCENTILE_DISC (value_expression, percentile [{RESPECT | IGNORE} NULLS])

Descrição

Calcula o valor de percentil especificado para um value_expression discreto. O valor retornado é o primeiro valor classificado de value_expression com a distribuição cumulativa maior ou igual ao valor percentile especificado.

Esta função ignora valores NULL a menos que RESPECT NULLS esteja presente.

Tipos de argumentos compatíveis

  • value_expression pode ser qualquer tipo ordenado.
  • percentile é um DOUBLE literal no intervalo [0, 1].

Tipos de dados retornados

ANY

Exemplos

O exemplo a seguir calcula o valor de alguns percentis em uma coluna de valores, ignorando os nulos.

SELECT
  x,
  PERCENTILE_DISC(x, 0) OVER() AS min,
  PERCENTILE_DISC(x, 0.5) OVER() AS median,
  PERCENTILE_DISC(x, 1) OVER() AS max
FROM UNNEST(['c', NULL, 'b', 'a']) AS x;

+------+-----+--------+-----+
| x    | min | median | max |
+------+-----+--------+-----+
| c    | a   | b      | c   |
| NULL | a   | b      | c   |
| b    | a   | b      | c   |
| a    | a   | b      | c   |
+------+-----+--------+-----+

O exemplo a seguir calcula o valor de alguns percentis em uma coluna de valores, respeitando os nulos.

SELECT
  x,
  PERCENTILE_DISC(x, 0 RESPECT NULLS) OVER() AS min,
  PERCENTILE_DISC(x, 0.5 RESPECT NULLS) OVER() AS median,
  PERCENTILE_DISC(x, 1 RESPECT NULLS) OVER() AS max
FROM UNNEST(['c', NULL, 'b', 'a']) AS x;

+------+------+--------+-----+
| x    | min  | median | max |
+------+------+--------+-----+
| c    | NULL | a      | c   |
| NULL | NULL | a      | c   |
| b    | NULL | a      | c   |
| a    | NULL | a      | c   |
+------+------+--------+-----+

Funções de agregação analítica

As seções a seguir descrevem as funções analíticas de agregação compatíveis com o BigQuery. Para uma explicação de como são funções analíticas, consulte Conceitos da função analítica. Para uma explicação de como são funções analíticas de agregação, consulte Conceitos da função analítica de agregação.

O BigQuery é compatível com estas funções de agregação como funções analíticas:

Requisitos da cláusula OVER:

  • PARTITION BY: opcional.
  • ORDER BY: opcional. Não permitido se DISTINCT estiver presente.
  • window_frame_clause: opcional. Não permitido se DISTINCT estiver presente.

Exemplo:

COUNT(*) OVER (ROWS UNBOUNDED PRECEDING)
SUM(DISTINCT x) OVER ()

Funções de hash

FARM_FINGERPRINT

FARM_FINGERPRINT(value)

Descrição

Calcula a impressão digital da entrada STRING ou BYTES usando a função Fingerprint64 da biblioteca de código aberto FarmHash. A saída dessa função para uma entrada em particular nunca muda.

Tipo de retorno

INT64

Exemplos

WITH example AS (
  SELECT 1 AS x, "foo" AS y, true AS z UNION ALL
  SELECT 2 AS x, "apple" AS y, false AS z UNION ALL
  SELECT 3 AS x, "" AS y, true AS z
)
SELECT
  *,
  FARM_FINGERPRINT(CONCAT(CAST(x AS STRING), y, CAST(z AS STRING)))
    AS row_fingerprint
FROM example;
+---+-------+-------+----------------------+
| x | y     | z     | row_fingerprint      |
+---+-------+-------+----------------------+
| 1 | foo   | true  | -1541654101129638711 |
| 2 | apple | false | 2794438866806483259  |
| 3 |       | true  | -4880158226897771312 |
+---+-------+-------+----------------------+

MD5

MD5(input)

Descrição

Calcula o hash da entrada usando o algoritmo MD5. A entrada pode ser STRING ou BYTES. A versão da string trata a entrada como uma matriz de bytes.

Essa função retorna 16 bytes.

Tipo de retorno

BYTES

Exemplo

SELECT MD5("Hello World") as md5;

+-------------------------------------------------+
| md5                                             |
+-------------------------------------------------+
| \xb1\n\x8d\xb1d\xe0uA\x05\xb7\xa9\x9b\xe7.?\xe5 |
+-------------------------------------------------+

SHA1

SHA1(input)

Descrição

Calcula o hash da entrada usando o algoritmo SHA-1. A entrada pode ser STRING ou BYTES. A versão da string trata a entrada como uma matriz de bytes.

Essa função retorna 20 bytes.

Tipo de retorno

BYTES

Exemplo

SELECT SHA1("Hello World") as sha1;

+-----------------------------------------------------------+
| sha1                                                      |
+-----------------------------------------------------------+
| \nMU\xa8\xd7x\xe5\x02/\xabp\x19w\xc5\xd8@\xbb\xc4\x86\xd0 |
+-----------------------------------------------------------+

SHA256

SHA256(input)

Descrição

Calcula o hash da entrada usando o algoritmo SHA-256. A entrada pode ser STRING ou BYTES. A versão da string trata a entrada como uma matriz de bytes.

Essa função retorna 32 bytes.

Tipo de retorno

BYTES

Exemplo

SELECT SHA256("Hello World") as sha256;

SHA512

SHA512(input)

Descrição

Calcula o hash da entrada usando o algoritmo SHA-512. A entrada pode ser STRING ou BYTES. A versão da string trata a entrada como uma matriz de bytes.

Essa função retorna 64 bytes.

Tipo de retorno

BYTES

Exemplo

SELECT SHA512("Hello World") as sha512;

Funções de string

Essas funções funcionam com dois valores diferentes: tipos de dados STRING e BYTES. Os valores de STRING precisam ter a codificação UTF-8 bem formada.

As funções que retornam valores de posição, como STRPOS, codificam essas posições como INT64. O valor 1 indica o primeiro caractere (ou byte), 2 indica o segundo, e assim por diante. O valor 0 indica um índice inválido. Ao trabalhar em tipos STRING, as posições retornadas indicam as posições dos caracteres.

Todas as comparações de string são feitas byte a byte, sem levar em conta a equivalência canônica Unicode.

BYTE_LENGTH

BYTE_LENGTH(value)

Descrição

Retorna o comprimento do valor em bytes, seja qual for o tipo de valor: STRING ou BYTES.

Tipo de retorno

INT64

Exemplos


WITH example AS
  (SELECT "абвгд" AS characters, b"абвгд" AS bytes)

SELECT
  characters,
  BYTE_LENGTH(characters) AS string_example,
  bytes,
  BYTE_LENGTH(bytes) AS bytes_example
FROM example;

+------------+----------------+-------+---------------+
| characters | string_example | bytes | bytes_example |
+------------+----------------+-------+---------------+
| абвгд      | 10             | абвгд | 10            |
+------------+----------------+-------+---------------+

CHAR_LENGTH

CHAR_LENGTH(value)

Descrição

Retorna o comprimento da STRING em caracteres.

Tipo de retorno

INT64

Exemplos


WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  CHAR_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CHARACTER_LENGTH

CHARACTER_LENGTH(value)

Descrição

Sinônimo para CHAR_LENGTH.

Tipo de retorno

INT64

Exemplos


WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  CHARACTER_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CODE_POINTS_TO_BYTES

CODE_POINTS_TO_BYTES(ascii_values)

Descrição

Usa uma matriz de pontos de código (em inglês) ASCII estendidos (ARRAY de INT64) e retorna BYTES.

Para converter de BYTES em uma matriz de pontos de código, consulte TO_CODE_POINTS.

Tipo de retorno

BYTES

Exemplos

Veja a seguir um exemplo básico usando CODE_POINTS_TO_BYTES.

SELECT CODE_POINTS_TO_BYTES([65, 98, 67, 100]) AS bytes;

+-------+
| bytes |
+-------+
| AbCd  |
+-------+

O exemplo a seguir utiliza um algoritmo ROT13 (rotacionar 13 posições) para codificar uma string.

SELECT CODE_POINTS_TO_BYTES(ARRAY_AGG(
  (SELECT
      CASE
        WHEN chr BETWEEN b'a' and b'z'
          THEN TO_CODE_POINTS(b'a')[offset(0)] +
            MOD(code+13-TO_CODE_POINTS(b'a')[offset(0)],26)
        WHEN chr BETWEEN b'A' and b'Z'
          THEN TO_CODE_POINTS(b'A')[offset(0)] +
            MOD(code+13-TO_CODE_POINTS(b'A')[offset(0)],26)
        ELSE code
      END
   FROM
     (SELECT code, CODE_POINTS_TO_BYTES([code]) chr)
  ) ORDER BY OFFSET)) AS encoded_string
FROM UNNEST(TO_CODE_POINTS(b'Test String!')) code WITH OFFSET;

+----------------+
| encoded_string |
+----------------+
| Grfg Fgevat!   |
+----------------+

CODE_POINTS_TO_STRING

CODE_POINTS_TO_STRING(value)

Descrição

Usa uma série de pontos de código Unicode (ARRAY de INT64) e retorna STRING.

Para converter uma string em uma matriz de pontos de código, consulte TO_CODE_POINTS.

Tipo de retorno

STRING

Exemplo

Veja a seguir um exemplo básico usando CODE_POINTS_TO_STRING.

SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;

+--------+
| string |
+--------+
| AÿȁЀ   |
+--------+

O exemplo a seguir calcula a frequência das letras em um grupo de palavras.

WITH Words AS (
  SELECT word
  FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word
)
SELECT
  CODE_POINTS_TO_STRING([code_point]) AS letter,
  COUNT(*) AS letter_count
FROM Words,
  UNNEST(TO_CODE_POINTS(word)) AS code_point
GROUP BY 1
ORDER BY 2 DESC;

+--------+--------------+
| letter | letter_count |
+--------+--------------+
| a      | 5            |
| f      | 3            |
| r      | 2            |
| b      | 2            |
| l      | 2            |
| o      | 2            |
| g      | 1            |
| z      | 1            |
| e      | 1            |
| m      | 1            |
| i      | 1            |
+--------+--------------+

CONCAT

CONCAT(value1[, ...])

Descrição

Concatena um ou mais valores em um único resultado.

Tipo de retorno

STRING ou BYTES

Exemplos


With Employees AS
  (SELECT
    "John" AS first_name,
    "Doe" AS last_name
  UNION ALL
  SELECT
    "Jane" AS first_name,
    "Smith" AS last_name
  UNION ALL
  SELECT
    "Joe" AS first_name,
    "Jackson" AS last_name)

SELECT
  CONCAT(first_name, " ", last_name)
  AS full_name
FROM Employees;

+---------------------+
| full_name           |
+---------------------+
| John Doe            |
| Jane Smith          |
| Joe Jackson         |
+---------------------+

ENDS_WITH

ENDS_WITH(value1, value2)

Descrição

Usa dois valores. Retorna TRUE, se o segundo valor for um sufixo do primeiro.

Tipo de retorno

BOOL

Exemplos


WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  ENDS_WITH(item, "e") as example
FROM items;

+---------+
| example |
+---------+
|    True |
|   False |
|    True |
+---------+

FORMAT

O BigQuery é compatível com a função FORMAT() para formatação de strings. Essa função é semelhante à função C printf. Ela produz uma STRING a partir de uma string de formato que contém zero ou mais especificadores de formato e uma lista de comprimentos variáveis de argumentos extras que correspondem aos especificadores. Veja alguns exemplos:

Descrição Instrução Resultado
Inteiro simples format("%d", 10) 10
Inteiro com preenchimento vazio à esquerda format("|%10d|", 11) |           11|
Inteiro com preenchimento com zero à esquerda format("+%010d+", 12) +0000000012+
Inteiro com vírgulas format("%'d", 123456789) 123,456,789
STRING format("-%s-", 'abcd efg') -abcd efg-
FLOAT64 format("%f %E", 1.1, 2.2) 1.100000 2.200000E+00
DATE format("%t", date "2015-09-01") 2015-09-01
TIMESTAMP format("%t", timestamp "2015-09-01 12:34:56 America/Los_Angeles") 2015‑09‑01 19:34:56+00

A função FORMAT() não oferece formato totalmente personalizável para todos os tipos e valores, nem formato sensível à localidade.

Se o formato personalizado for necessário para um tipo, primeiro formate-o usando as funções específicas do tipo, como FORMAT_DATE() ou FORMAT_TIMESTAMP(). Por exemplo:

FORMAT("date: %s!", FORMAT_DATE("%B %d, %Y", date '2015-01-02'));

Retorna

date: January 02, 2015!

Sintaxe

A sintaxe FORMAT() usa uma lista de strings de formato e comprimentos variáveis dos argumentos e produz um resultado STRING:

FORMAT(<format_string>, ...)

A expressão <format_string> pode conter zero ou mais especificadores de formato. Cada especificador de formato é introduzido pelo símbolo % e precisa ser mapeado para um ou mais dos argumentos restantes. Em geral, esse é um mapeamento um para um, exceto quando o especificador * está presente. Por exemplo, %.*i realiza o mapeamento para dois argumentos: um de comprimento e um de número inteiro com sinal. Se o número de argumentos relacionados com os especificadores de formato não for o mesmo número de argumentos, ocorrerá um erro.

Especificadores de formatos compatíveis

O especificador de formato da função FORMAT() segue este protótipo:

%[flags][width][.precision]specifier

Os especificadores de formatos compatíveis estão identificados na tabela a seguir. As extensões de printf() são identificadas em itálico.

Especificador Descrição Exemplos Tipos
d ou i Decimal inteiro. 392 INT64
o Octal 610
INT64*
x Inteiro hexadecimal 7fa
INT64*
X Inteiro hexadecimal (maiúsculas) 7FA
INT64*
f Ponto flutuante decimal, minúsculas. 392.65
inf NaN
NUMERIC
FLOAT64
F Ponto flutuante decimal, maiúsculas. 392.65
inf NAN
NUMERIC
FLOAT64
e Notação científica (mantissa/expoente), minúsculas. 3.9265e+2
inf NaN
NUMERIC
FLOAT64
E Notação científica (mantissa/expoente), maiúsculas. 3.9265E+2
inf NAN
NUMERIC
FLOAT64
g Usa a menor representação, %e ou %f. 392.65
FLOAT64
G Usa a menor representação, %E ou %F. 392.65
FLOAT64
s String de caracteres. amostra STRING
t Retorna uma string para impressão que representa o valor. Geralmente é semelhante a transmitir o argumento para STRING. Consulte a seção %t abaixo. amostra
2014‑01‑01
<any>
T Produz uma string que é uma constante válida do BigQuery, com um tipo semelhante ao do valor (talvez mais amplo ou string). Consulte a seção %T abaixo. 'amostra'
b'amostra de bytes'
1234
2.3
data '2014‑01‑01'
<any>
% '%%' produz um único '%' % n/d

*Os especificadores o, x e X geram um erro caso valores negativos sejam usados.

O formato do especificador também pode conter os subespecificadores identificados acima no protótipo do especificador.

Esses subespecificadores precisam seguir estas especificações.

Sinalizações
Sinalizações Descrição
- Justificada à esquerda dentro da largura do campo. O padrão é a justificação à direita (informe-se sobre subespecificador de largura).
+ Força o resultado a ser precedido por um sinal de mais ou menos (+ ou -), mesmo para números positivos. Por padrão, apenas os números negativos são precedidos por um sinal -.
<space> Se nenhum sinal for gravado, um espaço em branco será inserido antes do valor
# Usado com os especificadores o, x ou X. Precede valores diferentes de zero com 0, 0x ou 0X, respectivamente
0 Quando o preenchimento é especificado, coloca zeros (0) à esquerda do número, em vez de espaços (consulte sobre subespecificador de largura)
'

Formata inteiros usando o caractere de agrupamento adequado. Exemplo:

  • FORMAT("%'d", 12345678) retorna 12,345,678.
  • FORMAT("%'x", 12345678) retorna bc:614e
  • FORMAT("%'o", 55555) retorna 15,4403
  • Essa sinalização só é relevante para valores decimais, hexadecimais e octais.

As sinalizações podem ser especificadas em qualquer ordem. Sinalizações duplicadas não são um erro. As sinalizações são ignoradas quando não são relevantes para algum tipo de elemento.

Largura
Largura Descrição
<número> O número mínimo de caracteres a ser impresso. Se o valor a ser impresso for mais curto do que esse número, o resultado será preenchido com espaços em branco. O valor não é truncado mesmo que o resultado seja maior
* A largura não é especificada na string de formato, mas como um argumento de valor inteiro complementar precedendo o argumento que precisa ser formatado
Precisão
Precisão Descrição
.<number> Para os especificadores inteiros (d, i, o, u, X, X): a precisão especifica o número mínimo de dígitos a serem gravados. Se o valor a ser gravado for menor que esse número, o resultado será preenchido com zeros à direita. O valor não será truncado mesmo que o resultado seja maior. Uma precisão de 0 significa que nenhum caractere é gravado para o valor 0. Para os especificadores a, A, e, E, f e F: esse é o número de dígitos a serem impressos depois do ponto decimal (por padrão, é 6)
.* A precisão não é especificada na string de formato, mas como um argumento de valor inteiro complementar precedendo o argumento que precisa ser formatado

Comportamento de %t e %T

Os especificadores de formato %t e %T são definidos para todos os tipos. A largura, precisão e sinalizações atuam assim como para %s: width é a largura mínima e o tipo STRING será preenchido com esse tamanho, enquanto precision é a largura máxima do conteúdo a ser exibido e STRING será truncado para esse tamanho, antes do preenchimento da largura.

%t sempre será uma forma legível do valor.

%T é sempre um literal SQL válido de um tipo semelhante, como um tipo numérico mais amplo. O literal não inclui casts ou um nome de tipo, exceto no caso especial de valores de ponto flutuante não finitos.

A STRING é formatada como a seguir:

Tipo %t %T
NULL de qualquer tipo NULL NULL
INT64
123 123
NUMERIC 123.0 (sempre com .0)NUMERIC "123,0"
FLOAT64 123.0 (sempre com .0)
123e+10
inf
-inf
NaN
123.0 (sempre com .0)
123e+10
CAST("inf" AS <type>)
CAST("-inf" AS <type>)
CAST("nan" AS <type>)
STRING valor da string sem aspas literal da string com aspas
BYTES bytes escapados sem aspas
por exemplo, abc\x01\x02
bytes literais com aspas
por exemplo, b"abc\x01\x02"
DATE 2011-02-03 DATE "2011-02-03"
TIMESTAMP 2011-02-03 04:05:06+00 TIMESTAMP "2011-02-03 04:05:06+00"
ARRAY [valor, valor, ...]
onde os valores são formatados com %t
[valor, valor, ...]
onde os valores são formatados com %T
STRUCT (valor, valor, ...)
onde os campos são formatados com %t
(valor, valor, ...)
em que os campos são formatados com %T Casos especiais: Nenhum campo: STRUCT() Um campo: STRUCT(value)

Condições de erro

Se um especificador de formato for inválido ou não compatível com o tipo de argumento relacionado, ou forem fornecidos o número ou os argumentos incorretos, ocorrerá um erro. Por exemplo, as seguintes expressões <format_string> são inválidas:

FORMAT('%s', 1)
FORMAT('%')

Tratamento do argumento NULL

Uma string de formato NULL resulta em uma STRING de saída . Outros argumentos são ignorados, neste caso.

Em geral, a função produz um valor NULL se um argumento estiver presente. Por exemplo, FORMAT('%i', <NULL expression>) produz uma STRING NULL como saída.

No entanto, há algumas exceções: se o especificador de formato for %t ou %T (que produzem STRINGs que efetivamente correspondem à semântica do valor literal e CAST), um valor NULL produzirá 'NULL' (sem as aspas) na STRING de resultado. Por exemplo, a função:

FORMAT('00-%t-00', <NULL expression>);

Retorna

00-NULL-00

Outras regras semânticas

Os valores de FLOAT64 podem ser +/-inf ou NaN. Quando um argumento tem um desses valores, o resultado dos especificadores de formato %f, %F, %e, %E, %g, %G e %t são inf, -inf ou nan (ou o mesmo em maiúsculas), conforme apropriado. Isso é consistente com a forma como o BigQuery transmite esses valores para STRING. Para %T, o BigQuery retorna strings entre aspas para valores FLOAT64 que não têm representações literais que não sejam de string.

FROM_BASE32

FROM_BASE32(string_expr)

Descrição

Converte no formato BYTES a entrada codificada em base32 string_expr. Para converter BYTES em uma string codificada em base32, use TO_BASE32().

Tipo de retorno

BYTES

Exemplo

SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;

+-----------+
| byte_data |
+-----------+
| abcde\xff |
+-----------+

FROM_BASE64

FROM_BASE64(string_expr)

Descrição

Converte no formato BYTES a entrada codificada em base64 string_expr. Para converter BYTES em uma string codificada em base64, use TO_BASE64().

Tipo de retorno

BYTES

Exemplo

SELECT FROM_BASE64('3q2+7w==') AS byte_data;

+------------------+
| byte_data        |
+------------------+
| \xde\xad\xbe\xef |
+------------------+

FROM_HEX

FROM_HEX(string)

Descrição

Converte em formato BYTES uma STRING codificada em hexadecimal. Retorna um erro se a STRING de entrada contiver caracteres fora do intervalo (0..9, A..F, a..f). Não importa se os caracteres estão em maiúsculas ou minúsculas. Se a STRING de entrada tiver um número ímpar de caracteres, a função age como se a entrada tivesse um 0 à esquerda. Para converter BYTES em uma STRING codificada em hexadecimal, use TO_HEX.

Tipo de retorno

BYTES

Exemplo

WITH Input AS (
  SELECT '00010203aaeeefff' AS hex_str UNION ALL
  SELECT '0AF' UNION ALL
  SELECT '666f6f626172'
)
SELECT hex_str, FROM_HEX(hex_str) AS bytes_str
FROM Input;
+------------------+----------------------------------+
| hex_str          | bytes_str                        |
+------------------+----------------------------------+
| 0AF              | \x00\xaf                         |
| 00010203aaeeefff | \x00\x01\x02\x03\xaa\xee\xef\xff |
| 666f6f626172     | foobar                           |
+------------------+----------------------------------+

LENGTH

LENGTH(value)

Descrição

Retorna o comprimento do valor. O valor retornado está em caracteres para argumentos STRING e em bytes para o argumento BYTES.

Tipo de retorno

INT64

Exemplos


WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  LENGTH(characters) AS string_example,
  LENGTH(CAST(characters AS BYTES)) AS bytes_example
FROM example;

+------------+----------------+---------------+
| characters | string_example | bytes_example |
+------------+----------------+---------------+
| абвгд      |              5 |            10 |
+------------+----------------+---------------+

LPAD

LPAD(original_value, return_length[, pattern])

Descrição

Retorna um valor que consiste em original_value precedido por pattern. O return_length é um INT64 que especifica o comprimento do valor retornado. Se original_value for BYTES, return_length será o número de bytes. Se original_value for STRING, return_length será o número de caracteres.

O valor padrão de pattern é um espaço em branco.

Tanto original_value quanto pattern precisam ser do mesmo tipo de dados.

Se return_length for menor ou igual ao comprimento de original_value, essa função retornará o valor original_value, truncado para o valor de . Por exemplo, LPAD("hello world", 7); retorna "hello w".

Se original_value, return_length ou pattern for NULL, essa função retornará NULL.

Essa função retornará um erro se:

  • return_length for negativo;
  • pattern estiver vazio.

Tipo de retorno

STRING ou BYTES

Exemplos

SELECT t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);
t len LPAD
abc 5 "  abc"
abc 2 "ab"
例子 4 "  例子"
SELECT t, len, pattern, FORMAT("%T", LPAD(t, len, pattern)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);
t len padrão LPAD
abc 8 def "defdeabc"
abc 5 - "--abc"
例子 5 中文 "中文中例子"
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);
t len LPAD
b"abc" 5 b"  abc"
b"abc" 2 b"ab"
b"\xab\xcd\xef" 4 b" \xab\xcd\xef"
SELECT
  FORMAT("%T", t) AS t,
  len,
  FORMAT("%T", pattern) AS pattern,
  FORMAT("%T", LPAD(t, len, pattern)) AS LPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);
t len padrão LPAD
b"abc" 8 b"def" b"defdeabc"
b"abc" 5 b"-" b"--abc"
b"\xab\xcd\xef" 5 b"\x00" b"\x00\x00\xab\xcd\xef"

LOWER

LOWER(value)

Descrição

Para argumentos STRING, retorna a string original com todos os caracteres alfabéticos em minúsculas. O mapeamento entre maiúsculas e minúsculas é feito de acordo com o banco de dados de caracteres Unicode. Os mapeamentos específicos do idioma não são considerados.

Para argumentos BYTES, o argumento é tratado como texto ASCII, com todos os bytes superiores a 127 intactos.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT
    "FOO" as item
  UNION ALL
  SELECT
    "BAR" as item
  UNION ALL
  SELECT
    "BAZ" as item)

SELECT
  LOWER(item) AS example
FROM items;

+---------+
| example |
+---------+
| foo     |
| bar     |
| baz     |
+---------+

LTRIM

LTRIM(value1[, value2])

Descrição

Idêntico a TRIM, mas remove apenas os caracteres iniciais.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT "   apple   " as item
  UNION ALL
  SELECT "   banana   " as item
  UNION ALL
  SELECT "   orange   " as item)

SELECT
  CONCAT("#", LTRIM(item), "#") as example
FROM items;

+-------------+
| example     |
+-------------+
| #apple   #  |
| #banana   # |
| #orange   # |
+-------------+

WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  LTRIM(item, "*") as example
FROM items;

+-----------+
| example   |
+-----------+
| apple***  |
| banana*** |
| orange*** |
+-----------+

WITH items AS
  (SELECT "xxxapplexxx" as item
  UNION ALL
  SELECT "yyybananayyy" as item
  UNION ALL
  SELECT "zzzorangezzz" as item
  UNION ALL
  SELECT "xyzpearxyz" as item)

SELECT
  LTRIM(item, "xyz") as example
FROM items;

+-----------+
| example   |
+-----------+
| applexxx  |
| bananayyy |
| orangezzz |
| pearxyz   |
+-----------+

NORMALIZE

NORMALIZE(value[, normalization_mode])

Descrição

Usa uma STRING, value, e a retorna como uma string normalizada.

A normalização (em inglês) é utilizada para garantir que duas strings sejam equivalentes. Em geral, a normalização é usada em situações em que duas strings são renderizadas da mesma maneira na tela, mas têm diferentes pontos de código Unicode.

NORMALIZE é compatível com quatro modos de normalização opcionais:

Valor Nome Descrição
NFC Composição canônica do Formulário de normalização Decompõe e recompõe caracteres por equivalência canônica.
NFKC Composição de Compatibilidade do Formulário de Normalização Decompõe caracteres por compatibilidade e os recompõe por equivalência canônica.
NFD Decomposição canônica do Formulário de normalização Decompõe caracteres por equivalência canônica. Vários caracteres de combinação são organizados em uma ordem específica.
NFKD Decomposição de compatibilidade do Formulário de normalização Decompõe caracteres por compatibilidade. Vários caracteres de combinação são organizados em uma ordem específica.

O modo de normalização padrão é NFC.

Tipo de retorno

STRING

Exemplos

SELECT a, b, a = b as normalized
FROM (SELECT NORMALIZE('\u00ea') as a, NORMALIZE('\u0065\u0302') as b)
AS normalize_example;

+---+---+------------+
| a | b | normalized |
+---+---+------------+
| ê | ê | true       |
+---+---+------------+

O exemplo a seguir normaliza diferentes caracteres de espaços.

WITH EquivalentNames AS (
  SELECT name
  FROM UNNEST([
      'Jane\u2004Doe',
      'John\u2004Smith',
      'Jane\u2005Doe',
      'Jane\u2006Doe',
      'John Smith']) AS name
)
SELECT
  NORMALIZE(name, NFKC) AS normalized_name,
  COUNT(*) AS name_count
FROM EquivalentNames
GROUP BY 1;

+-----------------+------------+
| normalized_name | name_count |
+-----------------+------------+
| John Smith      | 2          |
| Jane Doe        | 3          |
+-----------------+------------+

NORMALIZE_AND_CASEFOLD

NORMALIZE_AND_CASEFOLD(value[, normalization_mode])

Descrição

Usa uma STRING, value, e executa as mesmas ações que NORMALIZE, assim como realiza casefold (em inglês) de operações que não diferenciam maiúsculas de minúsculas.

NORMALIZE_AND_CASEFOLD é compatível com quatro modos de normalização opcionais:

Valor Nome Descrição
NFC Composição canônica do Formulário de normalização Decompõe e recompõe caracteres por equivalência canônica.
NFKC Composição de Compatibilidade do Formulário de Normalização Decompõe caracteres por compatibilidade e os recompõe por equivalência canônica.
NFD Decomposição canônica do Formulário de normalização Decompõe caracteres por equivalência canônica. Vários caracteres de combinação são organizados em uma ordem específica.
NFKD Decomposição de compatibilidade do Formulário de normalização Decompõe caracteres por compatibilidade. Vários caracteres de combinação são organizados em uma ordem específica.

O modo de normalização padrão é NFC.

Tipo de retorno

STRING

Exemplo

WITH Strings AS (
  SELECT '\u2168' AS a, 'IX' AS b UNION ALL
  SELECT '\u0041\u030A', '\u00C5'
)
SELECT a, b,
  NORMALIZE_AND_CASEFOLD(a, NFD)=NORMALIZE_AND_CASEFOLD(b, NFD) AS nfd,
  NORMALIZE_AND_CASEFOLD(a, NFC)=NORMALIZE_AND_CASEFOLD(b, NFC) AS nfc,
  NORMALIZE_AND_CASEFOLD(a, NFKD)=NORMALIZE_AND_CASEFOLD(b, NFKD) AS nkfd,
  NORMALIZE_AND_CASEFOLD(a, NFKC)=NORMALIZE_AND_CASEFOLD(b, NFKC) AS nkfc
FROM Strings;

+---+----+-------+-------+------+------+
| a | b  | nfd   | nfc   | nkfd | nkfc |
+---+----+-------+-------+------+------+
| Ⅸ | IX | false | false | true | true |
| Å | Å  | true  | true  | true | true |
+---+----+-------+-------+------+------+

REGEXP_CONTAINS

REGEXP_CONTAINS(value, regex)

Descrição

Retorna TRUE se value for uma correspondência parcial para a expressão regular, regex.

Se o argumento regex for inválido, a função retornará um erro.

É possível pesquisar uma correspondência total usando ^ (início do texto) e $ (fim do texto). Devido à precedência do operador de expressão regular, é recomendável usar parênteses em torno de tudo entre ^ e $.

Tipo de retorno

BOOL

Exemplos

SELECT
  email,
  REGEXP_CONTAINS(email, r"@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+") AS is_valid
FROM
  (SELECT
    ["foo@example.com", "bar@example.org", "www.example.net"]
    AS addresses),
  UNNEST(addresses) AS email;

+-----------------+----------+
| email           | is_valid |
+-----------------+----------+
| foo@example.com | true     |
| bar@example.org | true     |
| www.example.net | false    |
+-----------------+----------+

# Performs a full match, using ^ and $. Due to regular expression operator
# precedence, it is good practice to use parentheses around everything between ^
# and $.
SELECT
  email,
  REGEXP_CONTAINS(email, r"^([\w.+-]+@foo\.com|[\w.+-]+@bar\.org)$")
    AS valid_email_address,
  REGEXP_CONTAINS(email, r"^[\w.+-]+@foo\.com|[\w.+-]+@bar\.org$")
    AS without_parentheses
FROM
  (SELECT
    ["a@foo.com", "a@foo.computer", "b@bar.org", "!b@bar.org", "c@buz.net"]
    AS addresses),
  UNNEST(addresses) AS email;

+----------------+---------------------+---------------------+
| email          | valid_email_address | without_parentheses |
+----------------+---------------------+---------------------+
| a@foo.com      | true                | true                |
| a@foo.computer | false               | true                |
| b@bar.org      | true                | true                |
| !b@bar.org     | false               | true                |
| c@buz.net      | false               | false               |
+----------------+---------------------+---------------------+

REGEXP_EXTRACT

REGEXP_EXTRACT(value, regex)

Descrição

Retorna a primeira substring em value que corresponde à expressão regular, regex. Retorna NULL se não houver correspondência.

Se a expressão regular contiver um grupo de captura, a função retornará a substring que corresponde a esse grupo. Se a expressão não contiver um grupo de captura, a função retornará toda a substring correspondente.

Retorna um erro se:

  • a expressão regular for inválida;
  • a expressão regular tiver mais de um grupo de captura.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH email_addresses AS
  (SELECT "foo@example.com" as email
  UNION ALL
  SELECT "bar@example.org" as email
  UNION ALL
  SELECT "baz@example.net" as email)

SELECT
  REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+")
  AS user_name
FROM email_addresses;

+-----------+
| user_name |
+-----------+
| foo       |
| bar       |
| baz       |
+-----------+

WITH email_addresses AS
  (SELECT "foo@example.com" as email
  UNION ALL
  SELECT "bar@example.org" as email
  UNION ALL
  SELECT "baz@example.net" as email)

SELECT
  REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.([a-zA-Z0-9-.]+$)")
  AS top_level_domain
FROM email_addresses;

+------------------+
| top_level_domain |
+------------------+
| com              |
| org              |
| net              |
+------------------+

REGEXP_EXTRACT_ALL

REGEXP_EXTRACT_ALL(value, regex)

Descrição

Retorna uma matriz de todas as substrings de value que correspondem à expressão regular, regex.

A função REGEXP_EXTRACT_ALL retorna apenas as correspondências não sobrepostas. Por exemplo, o uso dessa função para extrair ana de banana retorna apenas uma substring, não duas.

Tipo de retorno

Uma ARRAY de STRINGs ou BYTES

Exemplos


WITH code_markdown AS
  (SELECT "Try `function(x)` or `function(y)`" as code)

SELECT
  REGEXP_EXTRACT_ALL(code, "`(.+?)`") AS example
FROM code_markdown;

+----------------------------+
| example                    |
+----------------------------+
| [function(x), function(y)] |
+----------------------------+

REGEXP_REPLACE

REGEXP_REPLACE(value, regex, replacement)

Descrição

Retorna uma STRING em que todas as substrings de value que correspondam à expressão regular regex são substituídas por replacement.

Use dígitos de escape com barra invertida (\1 a \9) no argumento replacement para inserir um texto correspondente ao grupo entre parênteses no padrão regex. Use \0 para indicar o texto correspondente inteiro.

A função REGEXP_REPLACE substitui apenas as correspondências não sobrepostas. Por exemplo, substituir ana em banana resulta em apenas uma substituição, não duas.

Se o argumento regex não for uma expressão regular válida, essa função retornará um erro.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH markdown AS
  (SELECT "# Heading" as heading
  UNION ALL
  SELECT "# Another heading" as heading)

SELECT
  REGEXP_REPLACE(heading, r"^# ([a-zA-Z0-9\s]+$)", "<h1>\\1</h1>")
  AS html
FROM markdown;

+--------------------------+
| html                     |
+--------------------------+
| <h1>Heading</h1>         |
| <h1>Another heading</h1> |
+--------------------------+

REPLACE

REPLACE(original_value, from_value, to_value)

Descrição

Substitui todas as ocorrências de from_value por to_value em original_value. Se from_value estiver vazio, nenhuma substituição será feita.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH desserts AS
  (SELECT "apple pie" as dessert
  UNION ALL
  SELECT "blackberry pie" as dessert
  UNION ALL
  SELECT "cherry pie" as dessert)

SELECT
  REPLACE (dessert, "pie", "cobbler") as example
FROM desserts;

+--------------------+
| example            |
+--------------------+
| apple cobbler      |
| blackberry cobbler |
| cherry cobbler     |
+--------------------+

REPEAT

REPEAT(original_value, repetitions)

Descrição

Retorna um valor que consiste em original_value repetido. O parâmetro repetitions especifica o número de vezes para repetir original_value. Retorna NULL se original_value ou repetitions forem NULL.

Essa função retornará um erro se o valor repetitions for negativo.

Tipo de retorno

STRING ou BYTES

Exemplos

SELECT t, n, REPEAT(t, n) AS REPEAT FROM UNNEST([
  STRUCT('abc' AS t, 3 AS n),
  ('例子', 2),
  ('abc', null),
  (null, 3)
]);
t n REPEAT
abc 3 abcabcabc
例子 2 例子例子
abc NULL NULL
NULL 3 NULL

REVERSE

REVERSE(value)

Descrição

Retorna o inverso de STRING ou BYTES da entrada.

Tipo de retorno

STRING ou BYTES

Exemplos

WITH example AS (
  SELECT "foo" AS sample_string, b"bar" AS sample_bytes UNION ALL
  SELECT "абвгд" AS sample_string, b"123" AS sample_bytes
)
SELECT
  sample_string,
  REVERSE(sample_string) AS reverse_string,
  sample_bytes,
  REVERSE(sample_bytes) AS reverse_bytes
FROM example;

+---------------+----------------+--------------+---------------+
| sample_string | reverse_string | sample_bytes | reverse_bytes |
+---------------+----------------+--------------+---------------+
| foo           | oof            | bar          | rab           |
| абвгд         | дгвба          | 123          | 321           |
+---------------+----------------+--------------+---------------+

RPAD

RPAD(original_value, return_length[, pattern])

Descrição

Retorna um valor que consiste em original_value seguido de pattern. O return_length é um INT64 que especifica o comprimento do valor retornado. Se original_value for BYTES, return_length será o número de bytes. Se original_value for STRING, return_length será o número de caracteres.

O valor padrão de pattern é um espaço em branco.

Tanto original_value quanto pattern precisam ser do mesmo tipo de dados.

Se return_length for menor ou igual ao comprimento de original_value, essa função retornará o valor original_value, truncado para o valor de . Por exemplo, RPAD("hello world", 7); retorna "hello w".

Se original_value, return_length ou pattern for NULL, essa função retornará NULL.

Essa função retornará um erro se:

  • return_length for negativo;
  • pattern estiver vazio.

Tipo de retorno

STRING ou BYTES

Exemplos

SELECT t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);
t len RPAD
abc 5 "abc  "
abc 2 "ab"
例子 4 "例子  "
SELECT t, len, pattern, FORMAT("%T", RPAD(t, len, pattern)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);
t len padrão RPAD
abc 8 def "abcdefde"
abc 5 - "abc--"
例子 5 中文 "例子中文中"
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);
t len RPAD
b"abc" 5 b"abc  "
b"abc" 2 b"ab"
b"\xab\xcd\xef" 4 b"\xab\xcd\xef "
SELECT
  FORMAT("%T", t) AS t,
  len,
  FORMAT("%T", pattern) AS pattern,
  FORMAT("%T", RPAD(t, len, pattern)) AS RPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);
t len padrão RPAD
b"abc" 8 b"def" b"abcdefde"
b"abc" 5 b"-" b"abc--"
b"\xab\xcd\xef" 5 b"\x00" b"\xab\xcd\xef\x00\x00"

RTRIM

RTRIM(value1[, value2])

Descrição

Idêntico a TRIM, mas remove somente caracteres finais.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  RTRIM(item, "*") as example
FROM items;

+-----------+
| example   |
+-----------+
| ***apple  |
| ***banana |
| ***orange |
+-----------+

WITH items AS
  (SELECT "applexxx" as item
  UNION ALL
  SELECT "bananayyy" as item
  UNION ALL
  SELECT "orangezzz" as item
  UNION ALL
  SELECT "pearxyz" as item)

SELECT
  RTRIM(item, "xyz") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

SAFE_CONVERT_BYTES_TO_STRING

SAFE_CONVERT_BYTES_TO_STRING(value)

Descrição

Converte uma sequência de bytes em uma string. Todos os caracteres UTF-8 inválidos são substituídos pelo caractere de substituição Unicode, U+FFFD.

Tipo de retorno

STRING

Exemplos

A declaração a seguir retorna o caractere de substituição Unicode �.

SELECT SAFE_CONVERT_BYTES_TO_STRING(b'\xc2') as safe_convert;

SPLIT

SPLIT(value[, delimiter])

Descrição

Divide value usando o argumento delimiter.

Para STRING, o delimitador padrão é a vírgula (,).

Para BYTES, especifique um delimitador.

A divisão em um delimitador vazio produz uma matriz de caracteres UTF-8 para valores STRING, e uma matriz de BYTES para valores BYTES.

A divisão em uma STRING vazia retorna uma ARRAY com uma única STRING vazia.

Tipo de retorno

ARRAY do tipo STRING ou ARRAY do tipo BYTES

Exemplos


WITH letters AS
  (SELECT "a b c d" as letter_group
  UNION ALL
  SELECT "e f g h" as letter_group
  UNION ALL
  SELECT "i j k l" as letter_group)

SELECT SPLIT(letter_group, " ") as example
FROM letters;

+----------------------+
| example              |
+----------------------+
| [a, b, c, d]         |
| [e, f, g, h]         |
| [i, j, k, l]         |
+----------------------+

STARTS_WITH

STARTS_WITH(value1, value2)

Descrição

Usa dois valores. Retorna TRUE se o segundo valor for um prefixo do primeiro.

Tipo de retorno

BOOL

Exemplos


WITH items AS
  (SELECT "foo" as item
  UNION ALL
  SELECT "bar" as item
  UNION ALL
  SELECT "baz" as item)

SELECT
  STARTS_WITH(item, "b") as example
FROM items;

+---------+
| example |
+---------+
|   False |
|    True |
|    True |
+---------+

STRPOS

STRPOS(string, substring)

Descrição

Retorna o índice com base em 1 da primeira ocorrência de substring em string. Retorna 0 se substring não for encontrado.

Tipo de retorno

INT64

Exemplos


WITH email_addresses AS
  (SELECT
    "foo@example.com" AS email_address
  UNION ALL
  SELECT
    "foobar@example.com" AS email_address
  UNION ALL
  SELECT
    "foobarbaz@example.com" AS email_address
  UNION ALL
  SELECT
    "quxexample.com" AS email_address)

SELECT
  STRPOS(email_address, "@") AS example
FROM email_addresses;

+---------+
| example |
+---------+
|       4 |
|       7 |
|      10 |
|       0 |
+---------+

SUBSTR

SUBSTR(value, position[, length])

Descrição

Retorna uma substring do valor fornecido. O argumento position é um número inteiro que especifica a posição inicial da substring, com posição = 1 indicando o primeiro caractere ou byte. O argumento length é o número máximo de caracteres para argumentos STRING ou de bytes para argumentos BYTES.

Se position for negativo, a função contará a partir do final de value, com -1 indicando o último caractere.

Se position for uma posição fora do lado esquerdo de STRING ( = 0 ou <-LENGTH(value)), a função começa a partir da posição = 1. Se length exceder o comprimento de value, retorna menos caracteres do que length.

Se length for menor que zero, a função retornará um erro.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, 2) as example
FROM items;

+---------+
| example |
+---------+
| pple    |
| anana   |
| range   |
+---------+

WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, 2, 2) as example
FROM items;

+---------+
| example |
+---------+
| pp      |
| an      |
| ra      |
+---------+

WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, -2) as example
FROM items;

+---------+
| example |
+---------+
| le      |
| na      |
| ge      |
+---------+

TO_BASE32

TO_BASE32(bytes_expr)

Descrição

Converte uma sequência de BYTES em uma STRING codificada em base32. Para converter em BYTES uma STRING codificada em base32, use FROM_BASE32.

Tipo de retorno

STRING

Exemplo

SELECT TO_BASE32(b'abcde\xFF') AS base32_string;

+------------------+
| base32_string    |
+------------------+
| MFRGGZDF74====== |
+------------------+

TO_BASE64

TO_BASE64(bytes_expr)

Descrição

Converte uma sequência de BYTES em uma STRING codificada em base64. Para converter em BYTES uma STRING codificada em base64, use FROM_BASE64().

Tipo de retorno

STRING

Exemplo

SELECT TO_BASE64(b'\xde\xad\xbe\xef') AS base64_string;

+---------------+
| base64_string |
+---------------+
| 3q2+7w==      |
+---------------+

TO_CODE_POINTS

TO_CODE_POINTS(value)

Descrição

Usa um valor e retorna uma matriz de INT64.

  • Se value for uma STRING, cada elemento na matriz retornada representará um ponto de código (em inglês). Cada ponto de código está dentro do intervalo de [0, 0xD7FF] e [0xE000, 0x10FFFF].
  • Se value for BYTES, cada elemento na matriz será um valor de caractere ASCII estendido no intervalo de [0, 255].

Para converter uma matriz de pontos de código em STRING ou BYTES, consulte CODE_POINTS_TO_STRING ou CODE_POINTS_TO_BYTES.

Tipo de retorno

ARRAY de INT64

Exemplos

O exemplo a seguir mostra os pontos de código de cada elemento em uma matriz de palavras.

SELECT word, TO_CODE_POINTS(word) AS code_points
FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word;

+---------+------------------------------------+
| word    | code_points                        |
+---------+------------------------------------+
| foo     | [102, 111, 111]                    |
| bar     | [98, 97, 114]                      |
| baz     | [98, 97, 122]                      |
| giraffe | [103, 105, 114, 97, 102, 102, 101] |
| llama   | [108, 108, 97, 109, 97]            |
+---------+------------------------------------+

O exemplo a seguir converte as representações de inteiros de BYTES para os valores de caracteres ASCII correspondentes.

SELECT word, TO_CODE_POINTS(word) AS bytes_value_as_integer
FROM UNNEST([b'\x00\x01\x10\xff', b'\x66\x6f\x6f']) AS word;

+------------------+------------------------+
| word             | bytes_value_as_integer |
+------------------+------------------------+
| \x00\x01\x10\xff | [0, 1, 16, 255]        |
| foo              | [102, 111, 111]        |
+------------------+------------------------+

O exemplo a seguir demonstra a diferença entre os resultados BYTES e STRING.

SELECT TO_CODE_POINTS(b'Ā') AS b_result, TO_CODE_POINTS('Ā') AS s_result;

+------------+----------+
| b_result   | s_result |
+------------+----------+
| [196, 128] | [256]    |
+------------+----------+

O caractere Ā é representado como uma sequência Unicode de dois bytes. Como resultado, a versão BYTES de TO_CODE_POINTS retorna uma matriz com dois elementos, enquanto a versão STRING retorna uma matriz com um único elemento.

TO_HEX

TO_HEX(bytes)

Descrição

Converte uma sequência de BYTES em uma STRING hexadecimal. Converte cada byte na STRING como dois caracteres hexadecimais no intervalo (0..9, a..f). Para converter em BYTES uma STRING codificada em hexadecimal, use FROM_HEX.

Tipo de retorno

STRING

Exemplo

WITH Input AS (
  SELECT b'\x00\x01\x02\x03\xAA\xEE\xEF\xFF' AS byte_str UNION ALL
  SELECT b'foobar'
)
SELECT byte_str, TO_HEX(byte_str) AS hex_str
FROM Input;
+----------------------------------+------------------+
| byte_string                      | hex_string       |
+----------------------------------+------------------+
| foobar                           | 666f6f626172     |
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
+----------------------------------+------------------+

TRIM

TRIM(value1[, value2])

Descrição

Remove todos os caracteres iniciais e finais correspondentes a value2. Se value2 não for especificado, todos os caracteres de espaço em branco iniciais e finais (conforme definido pelo padrão Unicode) são removidos. Se o primeiro argumento for do tipo BYTES, o segundo argumento será necessário.

Se value2 tiver mais de um caractere ou byte, a função removerá todos os bytes ou caracteres iniciais ou finais contidos em .

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT "   apple   " as item
  UNION ALL
  SELECT "   banana   " as item
  UNION ALL
  SELECT "   orange   " as item)

SELECT
  CONCAT("#", TRIM(item), "#") as example
FROM items;

+----------+
| example  |
+----------+
| #apple#  |
| #banana# |
| #orange# |
+----------+

WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  TRIM(item, "*") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
+---------+

WITH items AS
  (SELECT "xxxapplexxx" as item
  UNION ALL
  SELECT "yyybananayyy" as item
  UNION ALL
  SELECT "zzzorangezzz" as item
  UNION ALL
  SELECT "xyzpearxyz" as item)

SELECT
  TRIM(item, "xyz") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

UPPER

UPPER(value)

Descrição

Para argumentos STRING, retorna a string original com todos os caracteres alfabéticos em maiúsculas. O mapeamento entre maiúsculas e minúsculas é feito de acordo com o banco de dados de caracteres Unicode. Os mapeamentos específicos do idioma não são considerados.

Para argumentos BYTES, o argumento é tratado como texto ASCII, com todos os bytes superiores a 127 intactos.

Tipo de retorno

STRING ou BYTES

Exemplos


WITH items AS
  (SELECT
    "foo" as item
  UNION ALL
  SELECT
    "bar" as item
  UNION ALL
  SELECT
    "baz" as item)

SELECT
  UPPER(item) AS example
FROM items;

+---------+
| example |
+---------+
| FOO     |
| BAR     |
| BAZ     |
+---------+

Funções JSON

O BigQuery é compatível com funções que ajudam você a recuperar dados armazenados nas strings formatadas como JSON e funções que ajudam a transformar dados em strings formatadas como JSON.

JSON_EXTRACT ou JSON_EXTRACT_SCALAR

JSON_EXTRACT(json_string_expr, json_path_string_literal), que retorna valores JSON como STRINGs.

JSON_EXTRACT_SCALAR(json_string_expr, json_path_string_literal), que retorna valores JSON escalares como STRINGs.

Descrição

O parâmetro json_string_expr precisa ser uma string formatada em JSON. Exemplo:

{"class" : {"students" : [{"name" : "Jane"}]}}

O parâmetro json_path_string_literal identifica o valor ou os valores que você quer acessar da string formatada em JSON. Crie esse parâmetro usando o formato JSONPath. O parâmetro que é parte desse formato precisa iniciar com o símbolo $, que indica o nível mais externo da string formatada como JSON. Use uma notação de ponto ou colchete para identificar os valores filho. Se o objeto JSON for uma matriz, use colchetes para especificar o índice da matriz.

JSONPath Descrição
$ Objeto ou elemento raiz
. ou [] Operador filho
[] Operador subscrito

As duas funções retornam NULL se o parâmetro json_path_string_literal não corresponder a um valor em json_string_expr. Se o valor selecionado de JSON_EXTRACT_SCALAR não for escalar, como um objeto ou matriz, a função retornará NULL.

Se o JSONPath for inválido, essas funções gerarão um erro.

Quando a chave JSON usar caracteres inválidos do JSONPath, use aspas simples e colchetes para inserir caracteres de escape, [' ']. Exemplo:

SELECT JSON_EXTRACT_SCALAR('{"a.b": {"c": "world"}}', "$['a.b'].c") as hello;

+-------+
| hello |
+-------+
| world |
+-------+

Exemplos

SELECT JSON_EXTRACT(json_text, '$') AS json_text_string
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

A consulta acima apresenta o resultado a seguir:

+-----------------------------------------------------------+
| json_text_string                                          |
+-----------------------------------------------------------+
| {"class":{"students":[{"name":"Jane"}]}}                  |
| {"class":{"students":[]}}                                 |
| {"class":{"students":[{"name":"John"},{"name":"Jamie"}]}} |
+-----------------------------------------------------------+
SELECT JSON_EXTRACT(json_text, '$.class.students[0]') AS first_student
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

A consulta acima apresenta o resultado a seguir:

+-----------------+
| first_student   |
+-----------------+
| {"name":"Jane"} |
| NULL            |
| {"name":"John"} |
+-----------------+
SELECT JSON_EXTRACT(json_text, '$.class.students[1].name') AS second_student_name
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

A consulta acima apresenta o resultado a seguir:

+-------------------+
| second_student    |
+-------------------+
| NULL              |
| NULL              |
| "Jamie"           |
+-------------------+
SELECT JSON_EXTRACT(json_text, "$.class['students']") AS student_names
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

A consulta acima apresenta o resultado a seguir:

+------------------------------------+
| student_names                      |
+------------------------------------+
| [{"name":"Jane"}]                  |
| []                                 |
| [{"name":"John"},{"name":"Jamie"}] |
+------------------------------------+
SELECT JSON_EXTRACT('{ "name" : "Jakob", "age" : "6" }', '$.name') as json_name,
  JSON_EXTRACT_SCALAR('{ "name" : "Jakob", "age" : "6" }', '$.name') as scalar_name,
  JSON_EXTRACT('{ "name" : "Jakob", "age" : "6" }', '$.age') as json_age,
  JSON_EXTRACT_SCALAR('{ "name" : "Jakob", "age" : "6" }', '$.age') as scalar;

A consulta acima apresenta o resultado a seguir:

+-----------+-------------+----------+--------+
| json_name | scalar_name | json_age | scalar |
+-----------+-------------+----------+--------+
| "Jakob"   | Jakob       | "6"      | 6      |
+-----------+-------------+----------+--------+

TO_JSON_STRING

TO_JSON_STRING(value[, pretty_print])

Descrição

Retorna uma representação de string formatada em JSON de value. Essa função aceita um parâmetro pretty_print opcional. Se pretty_print estiver presente, o valor retornado será formatado para facilitar a leitura.

Tipo de dados de entrada Valor retornado
NULL de qualquer tipo null
BOOL true ou false.
INT64

O mesmo que CAST(value AS STRING) quando value está no intervalo de [-253, 253], que é o intervalo de números inteiros que podem ser representados sem perdas como números de ponto flutuante de precisão dupla IEEE 754. Valores fora desse intervalo são representados como strings entre aspas. Exemplo:

-1
0
12345678901
9007199254740992
-9007199254740992
"9007199254740993"

9007199254740993 é maior que 253, por isso é representado como uma string entre aspas.

NUMERIC

O mesmo que CAST(value AS STRING) quando value está no intervalo de [-253, 253] e não tem parte fracionária. Valores fora desse intervalo são representados como strings entre aspas. Por exemplo:

-1
0
"9007199254740993"
"123.56"
FLOAT64 +/-inf e NaN são representadas como Infinity, -Infinity e NaN, respectivamente.

Caso contrário, é igual a CAST(value AS STRING).

STRING Valor de string entre aspas, com escape de acordo com o padrão JSON. Especificamente, ", \ e os caracteres de controle de U+0000 a U+001F são escapados.
BYTES

Valor de escape de base64 RFC 4648 entre aspas. Exemplo:

"R29vZ2xl" é a representação base64 de bytes b"Google"

DATE

Data entre aspas. Por exemplo:

"2017-03-06"
TIMESTAMP

Data/hora ISO 8601 entre aspas, em que T separa a data e a hora e Zulu/UTC representa o fuso horário. Por exemplo:

"2017-03-06T12:34:56.789012Z"
DATETIME

Data/hora ISO 8601 entre aspas, em que T separa a data e a hora. Por exemplo:

"2017-03-06T12:34:56.789012"
TIME

Hora ISO 8601 entre aspas. Por exemplo:

"12:34:56.789012"
ARRAY

[elem1,elem2,...], onde cada elem é formatado de acordo com o tipo de elemento.

Exemplo com formatação:

[
  elem1,
  elem2,
  ...
]

Onde cada elem é formatado de acordo com o tipo de elemento. A matriz vazia é representada como [].

STRUCT {"field_name1":field_value1,"field_name2":field_value2,...}

Onde cada field_value é formatado de acordo com seu tipo.

Exemplo com formatação:

{
  "field_name1": field_value1,
  "field_name2": field_value2,
  ...
}

Onde cada field_value é formatado de acordo com seu tipo. Se um field_value for um STRUCT ou ARRAY não vazio, os elementos serão recuados para o nível apropriado. A estrutura vazia é representada como {}.

Campos com nomes duplicados podem resultar em JSON não analisáveis. Campos anônimos são representados com "".

Nomes de campos UTF-8 inválidos podem resultar em JSON não analisáveis. Valores de string são escapados de acordo com o padrão JSON. Especificamente, ", \ e os caracteres de controle de U+0000 a U+001F são escapados.

Tipo de retorno

Representação do valor de string JSON.

Exemplos

Converta linhas em uma tabela para JSON.

WITH Input AS (
  SELECT [1, 2] AS x, 'foo' AS y, STRUCT(true AS a, DATE '2017-04-05' AS b) AS s UNION ALL
  SELECT NULL AS x, '' AS y, STRUCT(false AS a, DATE '0001-01-01' AS b) AS s UNION ALL
  SELECT [3] AS x, 'bar' AS y, STRUCT(NULL AS a, DATE '2016-12-05' AS b) AS s
)
SELECT
  t,
  TO_JSON_STRING(t) AS json_row
FROM Input AS t;

A consulta acima apresenta o resultado a seguir:

+-----------------------------------+-------------------------------------------------------+
| t                                 | json_row                                              |
+-----------------------------------+-------------------------------------------------------+
| {[1, 2], foo, {true, 2017-04-05}} | {"x":[1,2],"y":"foo","s":{"a":true,"b":"2017-04-05"}} |
| {NULL, , {false, 0001-01-01}}     | {"x":null,"y":"","s":{"a":false,"b":"0001-01-01"}}    |
| {[3], bar, {NULL, 2016-12-05}}    | {"x":[3],"y":"bar","s":{"a":null,"b":"2016-12-05"}}   |
+-----------------------------------+-------------------------------------------------------+

Converta linhas em uma tabela para JSON com formatação.

WITH Input AS (
  SELECT [1, 2] AS x, 'foo' AS y, STRUCT(true AS a, DATE '2017-04-05' AS b) AS s UNION ALL
  SELECT NULL AS x, '' AS y, STRUCT(false AS a, DATE '0001-01-01' AS b) AS s UNION ALL
  SELECT [3] AS x, 'bar' AS y, STRUCT(NULL AS a, DATE '2016-12-05' AS b) AS s
)
SELECT
  TO_JSON_STRING(t, true) AS json_row
FROM Input AS t;

A consulta acima apresenta o resultado a seguir:

+-----------------------+
| json_row              |
+-----------------------+
| {                     |
|  "x": [               |
|    1,                 |
|    2                  |
|  ],                   |
|  "y": "foo",          |
|  "s": {               |
|    "a": true,         |
|    "b": "2017-04-05"  |
|  }                    |
|}                      |
| {                     |
|  "x": null,           |
|  "y": "",             |
|  "s": {               |
|    "a": false,        |
|    "b": "0001-01-01"  |
|  }                    |
|}                      |
| {                     |
|  "x": [               |
|    3                  |
|  ],                   |
|  "y": "bar",          |
|  "s": {               |
|    "a": null,         |
|    "b": "2016-12-05"  |
|  }                    |
|}                      |
+-----------------------+

Funções de matriz

ARRAY

ARRAY(subquery)

Descrição

A função ARRAY retorna uma com um elemento para cada linha em uma subconsulta.

Se subquery produzir uma tabela SQL, a tabela precisará ter exatamente uma coluna. Cada elemento na ARRAY de saída é o valor da coluna única de uma linha na tabela.

Se subquery produzir uma tabela de valores, cada elemento na ARRAY de saída será toda a linha correspondente da tabela de valores.

Restrições

  • As subconsultas não são ordenadas, portanto, não há garantia de que os elementos da ARRAY de saída preservem qualquer ordem na tabela de origem para a subconsulta. No entanto, se a subconsulta incluir uma cláusula ORDER BY, a função ARRAY retornará um ARRAY que honre essa cláusula.
  • Se a subconsulta retornar mais de uma coluna, a função ARRAY retornará um erro.
  • Se a subconsulta retornar uma coluna de tipo ARRAY ou linhas de tipo , a função retornará um erro: o BigQuery não é compatível com s com elementos do tipo .
  • Se a subconsulta não retornar nenhuma linha, a função ARRAY retornará uma vazia. Ela nunca retorna uma NULL .

Tipo de retorno

ARRAY

Exemplos

SELECT ARRAY
  (SELECT 1 UNION ALL
   SELECT 2 UNION ALL
   SELECT 3) AS new_array;

+-----------+
| new_array |
+-----------+
| [1, 2, 3] |
+-----------+

Para construir um ARRAY a partir de uma subconsulta que contenha várias colunas, altere a subconsulta para usar SELECT AS STRUCT. Agora a função ARRAY retornará ARRAY de STRUCTs. A ARRAY conterá um STRUCT para cada linha na subconsulta e cada um destes STRUCTs conterá um campo para cada coluna nessa linha.

SELECT
  ARRAY
    (SELECT AS STRUCT 1, 2, 3
     UNION ALL SELECT AS STRUCT 4, 5, 6) AS new_array;

+------------------------+
| new_array              |
+------------------------+
| [{1, 2, 3}, {4, 5, 6}] |
+------------------------+

Da mesma forma, para construir um ARRAY a partir de uma subconsulta que contenha um ou mais s, altere a subconsulta para usar SELECT AS STRUCT.

SELECT ARRAY
  (SELECT AS STRUCT [1, 2, 3] UNION ALL
   SELECT AS STRUCT [4, 5, 6]) AS new_array;

+----------------------------+
| new_array                  |
+----------------------------+
| [{[1, 2, 3]}, {[4, 5, 6]}] |
+----------------------------+

ARRAY_CONCAT

ARRAY_CONCAT(array_expression_1 [, array_expression_n])

Descrição

Concatena uma ou mais matrizes com o mesmo tipo de elemento em uma única matriz.

Tipo de retorno

ARRAY

Exemplos

SELECT ARRAY_CONCAT([1, 2], [3, 4], [5, 6]) as count_to_six;

+--------------------------------------------------+
| count_to_six                                     |
+--------------------------------------------------+
| [1, 2, 3, 4, 5, 6]                               |
+--------------------------------------------------+

ARRAY_LENGTH

ARRAY_LENGTH(array_expression)

Descrição

Retorna o tamanho da matriz. Retorna 0 para uma matriz vazia. Retorna NULL se array_expression for NULL.

Tipo de retorno

INT64

Exemplos

WITH items AS
  (SELECT ["coffee", NULL, "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie"] as list)

SELECT list, ARRAY_LENGTH(list) AS size
FROM items
ORDER BY size DESC;

+---------------------------------+------+
| list                            | size |
+---------------------------------+------+
| [coffee, NULL, milk]            | 3    |
| [cake, pie]                     | 2    |
+---------------------------------+------+

ARRAY_TO_STRING

ARRAY_TO_STRING(array_expression, delimiter[, null_text])

Descrição

Retorna uma concatenação dos elementos em array_expression como um STRING. O valor de array_expression pode ser uma matriz de tipos de dados BYTES ou STRING.

Se o parâmetro null_text for usado, a função substituirá todos os valores NULL na matriz pelo valor de .

Se o parâmetro null_text não for usado, a função omitirá o valor NULL e seu delimitador anterior.

Exemplos

WITH items AS
  (SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie", NULL] as list)

SELECT ARRAY_TO_STRING(list, '--') AS text
FROM items;

+--------------------------------+
| text                           |
+--------------------------------+
| coffee--tea--milk              |
| cake--pie                      |
+--------------------------------+
WITH items AS
  (SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie", NULL] as list)

SELECT ARRAY_TO_STRING(list, '--', 'MISSING') AS text
FROM items;

+--------------------------------+
| text                           |
+--------------------------------+
| coffee--tea--milk              |
| cake--pie--MISSING             |
+--------------------------------+

GENERATE_ARRAY

GENERATE_ARRAY(start_expression, end_expression[, step_expression])

Descrição

Retorna uma matriz de valores. Os parâmetros start_expression e end_expression determinam o início e o fim inclusivos da matriz.

A função GENERATE_ARRAY aceita estes tipos de dados como entradas:

  • INT64
  • NUMERIC
  • FLOAT64

O parâmetro step_expression determina o incremento usado para gerar valores de matriz. O valor padrão desse parâmetro é 1.

Essa função retornará um erro se step_expression for definido como 0 ou se alguma entrada for NaN.

Se qualquer argumento for NULL, a função retornará uma matriz .

Tipos de dados retornados

ARRAY

Exemplos

O seguinte retorna uma matriz de números inteiros, com uma etapa padrão de 1.

SELECT GENERATE_ARRAY(1, 5) AS example_array;

+-----------------+
| example_array   |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+

O seguinte retorna uma matriz usando um tamanho do passo especificado pelo usuário.

SELECT GENERATE_ARRAY(0, 10, 3) AS example_array;

+---------------+
| example_array |
+---------------+
| [0, 3, 6, 9]  |
+---------------+

O seguinte retorna uma matriz usando um valor negativo -3 para o tamanho do passo.

SELECT GENERATE_ARRAY(10, 0, -3) AS example_array;

+---------------+
| example_array |
+---------------+
| [10, 7, 4, 1] |
+---------------+

O seguinte retorna uma matriz usando o mesmo valor para start_expression e end_expression.

SELECT GENERATE_ARRAY(4, 4, 10) AS example_array;

+---------------+
| example_array |
+---------------+
| [4]           |
+---------------+

O seguinte retorna uma matriz vazia, porque start_expression é maior que end_expression, e o valor step_expression é positivo.

SELECT GENERATE_ARRAY(10, 0, 3) AS example_array;

+---------------+
| example_array |
+---------------+
| []            |
+---------------+

O seguinte retorna uma matriz NULL porque end_expression é .

SELECT GENERATE_ARRAY(5, NULL, 1) AS example_array;

+---------------+
| example_array |
+---------------+
| NULL          |
+---------------+

O seguinte retorna várias matrizes.

SELECT GENERATE_ARRAY(start, 5) AS example_array
FROM UNNEST([3, 4, 5]) AS start;

+---------------+
| example_array |
+---------------+
| [3, 4, 5]     |
| [4, 5]        |
| [5]           |
+---------------+

GENERATE_DATE_ARRAY

GENERATE_DATE_ARRAY(start_date, end_date[, INTERVAL INT64_expr date_part])

Descrição

Retorna uma matriz de datas. Os parâmetros start_date e end_date determinam o início e o fim inclusivos da matriz.

A função GENERATE_DATE_ARRAY aceita estes tipos de dados como entradas:

  • start_date precisa ser uma DATE
  • end_date precisa ser uma DATE
  • INT64_expr precisa ser um INT64
  • date_part precisa ser DAY, WEEK, MONTH, QUARTER ou YEAR.

O parâmetro INT64_expr determina o incremento usado para gerar datas. O valor padrão dele é de 1 dia.

Essa função retornará um erro se INT64_expr for definido como 0.

Tipos de dados retornados

Um ARRAY contendo 0 ou mais valores DATE.

Exemplos

O seguinte retorna uma matriz de datas, com uma etapa padrão de 1.

SELECT GENERATE_DATE_ARRAY('2016-10-05', '2016-10-08') AS example;

+--------------------------------------------------+
| example                                          |
+--------------------------------------------------+
| [2016-10-05, 2016-10-06, 2016-10-07, 2016-10-08] |
+--------------------------------------------------+

O seguinte retorna uma matriz usando um tamanho do passo especificado pelo usuário.

SELECT GENERATE_DATE_ARRAY(
 '2016-10-05', '2016-10-09', INTERVAL 2 DAY) AS example;

+--------------------------------------+
| example                              |
+--------------------------------------+
| [2016-10-05, 2016-10-07, 2016-10-09] |
+--------------------------------------+

O seguinte retorna uma matriz usando um valor negativo -3 para o tamanho do passo.

SELECT GENERATE_DATE_ARRAY('2016-10-05',
  '2016-10-01', INTERVAL -3 DAY) AS example;

+--------------------------+
| example                  |
+--------------------------+
| [2016-10-05, 2016-10-02] |
+--------------------------+

O seguinte retorna uma matriz usando o mesmo valor para start_date e end_date.

SELECT GENERATE_DATE_ARRAY('2016-10-05',
  '2016-10-05', INTERVAL 8 DAY) AS example;

+--------------+
| example      |
+--------------+
| [2016-10-05] |
+--------------+

O seguinte retorna uma matriz vazia, porque start_date é maior que end_date, e o valor step é positivo.

SELECT GENERATE_DATE_ARRAY('2016-10-05',
  '2016-10-01', INTERVAL 1 DAY) AS example;

+---------+
| example |
+---------+
| []      |
+---------+

O seguinte retorna uma matriz NULL, porque uma das entradas é .

SELECT GENERATE_DATE_ARRAY('2016-10-05', NULL) AS example;

+---------+
| example |
+---------+
| NULL    |
+---------+

O seguinte retorna uma matriz de datas, usando MONTH como o intervalo date_part:

SELECT GENERATE_DATE_ARRAY('2016-01-01',
  '2016-12-31', INTERVAL 2 MONTH) AS example;

+--------------------------------------------------------------------------+
| example                                                                  |
+--------------------------------------------------------------------------+
| [2016-01-01, 2016-03-01, 2016-05-01, 2016-07-01, 2016-09-01, 2016-11-01] |
+--------------------------------------------------------------------------+

O seguinte usa datas não constantes para gerar uma matriz.

SELECT GENERATE_DATE_ARRAY(date_start, date_end, INTERVAL 1 WEEK) AS date_range
FROM (
  SELECT DATE '2016-01-01' AS date_start, DATE '2016-01-31' AS date_end
  UNION ALL SELECT DATE "2016-04-01", DATE "2016-04-30"
  UNION ALL SELECT DATE "2016-07-01", DATE "2016-07-31"
  UNION ALL SELECT DATE "2016-10-01", DATE "2016-10-31"
) AS items;

+--------------------------------------------------------------+
| date_range                                                   |
+--------------------------------------------------------------+
| [2016-01-01, 2016-01-08, 2016-01-15, 2016-01-22, 2016-01-29] |
| [2016-04-01, 2016-04-08, 2016-04-15, 2016-04-22, 2016-04-29] |
| [2016-07-01, 2016-07-08, 2016-07-15, 2016-07-22, 2016-07-29] |
| [2016-10-01, 2016-10-08, 2016-10-15, 2016-10-22, 2016-10-29] |
+--------------------------------------------------------------+

GENERATE_TIMESTAMP_ARRAY

GENERATE_TIMESTAMP_ARRAY(start_timestamp, end_timestamp,
                         INTERVAL step_expression date_part)

Descrição

Retorna uma ARRAY de TIMESTAMPS separada por um determinado intervalo. Os parâmetros start_timestamp e end_timestamp determinam os limites inferior e superior inclusivos de ARRAY.

A função GENERATE_TIMESTAMP_ARRAY aceita estes tipos de dados como entradas:

  • start_timestamp: TIMESTAMP
  • end_timestamp: TIMESTAMP
  • step_expression: INT64
  • Os valores date_part permitidos são:

    MICROSECOND, MILLISECOND,

    SECOND, MINUTE, HOUR ou DAY.

O parâmetro step_expression determina o incremento usado para gerar carimbos de data/hora.

Tipos de dados retornados

Uma ARRAY contendo 0 ou mais valores de TIMESTAMP.

Exemplos

O exemplo a seguir retorna um ARRAY de TIMESTAMPs em intervalos de 1 dia.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', '2016-10-07 00:00:00',
                                INTERVAL 1 DAY) AS timestamp_array;

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-05 00:00:00+00, 2016-10-06 00:00:00+00, 2016-10-07 00:00:00+00] |
+--------------------------------------------------------------------------+

O exemplo a seguir retorna uma ARRAY de TIMESTAMPs em intervalos de 1 segundo.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', '2016-10-05 00:00:02',
                                INTERVAL 1 SECOND) AS timestamp_array;

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-05 00:00:00+00, 2016-10-05 00:00:01+00, 2016-10-05 00:00:02+00] |
+--------------------------------------------------------------------------+

O exemplo a seguir retorna uma ARRAY de TIMESTAMPS com um intervalo negativo.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-06 00:00:00', '2016-10-01 00:00:00',
                                INTERVAL -2 DAY) AS timestamp_array;

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-06 00:00:00+00, 2016-10-04 00:00:00+00, 2016-10-02 00:00:00+00] |
+--------------------------------------------------------------------------+

O exemplo a seguir retorna um ARRAY com um único elemento, porque start_timestamp e end_timestamp têm o mesmo valor.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', '2016-10-05 00:00:00',
                                INTERVAL 1 HOUR) AS timestamp_array;

+--------------------------+
| timestamp_array          |
+--------------------------+
| [2016-10-05 00:00:00+00] |
+--------------------------+

O exemplo a seguir retorna um ARRAY vazio, porque start_timestamp é posterior a end_timestamp.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-06 00:00:00', '2016-10-05 00:00:00',
                                INTERVAL 1 HOUR) AS timestamp_array;

+-----------------+
| timestamp_array |
+-----------------+
| []              |
+-----------------+

O exemplo a seguir retorna uma ARRAY nula, porque uma das entradas é NULL.

SELECT GENERATE_TIMESTAMP_ARRAY('2016-10-05 00:00:00', NULL, INTERVAL 1 HOUR)
  AS timestamp_array;

+-----------------+
| timestamp_array |
+-----------------+
| NULL            |
+-----------------+

O exemplo a seguir gera ARRAYs de TIMESTAMPs a partir de colunas que contêm valores para start_timestamp e end_timestamp.

SELECT GENERATE_TIMESTAMP_ARRAY(start_timestamp, end_timestamp, INTERVAL 1 HOUR)
  AS timestamp_array
FROM
  (SELECT
    TIMESTAMP '2016-10-05 00:00:00' AS start_timestamp,
    TIMESTAMP '2016-10-05 02:00:00' AS end_timestamp
   UNION ALL
   SELECT
    TIMESTAMP '2016-10-05 12:00:00' AS start_timestamp,
    TIMESTAMP '2016-10-05 14:00:00' AS end_timestamp
   UNION ALL
   SELECT
    TIMESTAMP '2016-10-05 23:59:00' AS start_timestamp,
    TIMESTAMP '2016-10-06 01:59:00' AS end_timestamp);

+--------------------------------------------------------------------------+
| timestamp_array                                                          |
+--------------------------------------------------------------------------+
| [2016-10-05 00:00:00+00, 2016-10-05 01:00:00+00, 2016-10-05 02:00:00+00] |
| [2016-10-05 12:00:00+00, 2016-10-05 13:00:00+00, 2016-10-05 14:00:00+00] |
| [2016-10-05 23:59:00+00, 2016-10-06 00:59:00+00, 2016-10-06 01:59:00+00] |
+--------------------------------------------------------------------------+

OFFSET e ORDINAL

array_expression[OFFSET(zero_based_offset)]
array_expression[ORDINAL(one_based_offset)]

Descrição

Acessa um elemento ARRAY por posição e retorna o elemento. OFFSET significa que a numeração começa em zero e ORDINAL, que a numeração começa em 1.

Uma matriz pode ser interpretada como sendo baseada em 0 ou em 1. Quando acessar um elemento de matriz, preceda a posição da matriz com OFFSET ou ORDINAL, respectivamente. Não há comportamento padrão.

OFFSET e ORDINAL geram um erro se o índice estiver fora do intervalo.

Tipo de retorno

Varia de acordo com os elementos em ARRAY.

Exemplos

WITH items AS
  (SELECT ["apples", "bananas", "pears", "grapes"] as list
  UNION ALL
  SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie"] as list)

SELECT list, list[OFFSET(1)] as offset_1, list[ORDINAL(1)] as ordinal_1
FROM items;

+----------------------------------+-----------+-----------+
| list                             | offset_1  | ordinal_1 |
+----------------------------------+-----------+-----------+
| [apples, bananas, pears, grapes] | bananas   | apples    |
| [coffee, tea, milk]              | tea       | coffee    |
| [cake, pie]                      | pie       | cake      |
+----------------------------------+-----------+-----------+

ARRAY_REVERSE

ARRAY_REVERSE(value)

Descrição

Retorna o ARRAY de entrada com elementos na ordem inversa.

Tipo de retorno

ARRAY

Exemplos

WITH example AS (
  SELECT [1, 2, 3] AS arr UNION ALL
  SELECT [4, 5] AS arr UNION ALL
  SELECT [] AS arr
)
SELECT
  arr,
  ARRAY_REVERSE(arr) AS reverse_arr
FROM example;

+-----------+-------------+
| arr       | reverse_arr |
+-----------+-------------+
| [1, 2, 3] | [3, 2, 1]   |
| [4, 5]    | [5, 4]      |
| []        | []          |
+-----------+-------------+

SAFE_OFFSET e SAFE_ORDINAL

array_expression[SAFE_OFFSET(zero_based_offset)]
array_expression[SAFE_ORDINAL(one_based_offset)]

Descrição

Idênticos a OFFSET e ORDINAL, exceto por retornar NULL se o índice estiver fora do intervalo.

Tipo de retorno

Varia de acordo com os elementos em ARRAY.

Exemplo

WITH items AS
  (SELECT ["apples", "bananas", "pears", "grapes"] as list
  UNION ALL
  SELECT ["coffee", "tea", "milk" ] as list
  UNION ALL
  SELECT ["cake", "pie"] as list)

SELECT list,
  list[SAFE_OFFSET(3)] as safe_offset_3,
  list[SAFE_ORDINAL(3)] as safe_ordinal_3
FROM items;

+----------------------------------+---------------+----------------+
| list                             | safe_offset_3 | safe_ordinal_3 |
+----------------------------------+---------------+----------------+
| [apples, bananas, pears, grapes] | grapes        | pears          |
| [coffee, tea, milk]              | NULL          | milk           |
| [cake, pie]                      | NULL          | NULL           |
+----------------------------------+---------------+----------------+

Funções de data

O BigQuery é compatível com as seguintes funções DATE.

CURRENT_DATE

CURRENT_DATE([time_zone])

Descrição

Retorna a data atual a partir do fuso horário especificado ou padrão.

Esta função aceita um parâmetro time_zone opcional. Esse parâmetro é uma string que representa o fuso horário a ser usado. Se nenhum fuso horário for especificado, será usado o padrão UTC. Para informações sobre como especificar um fuso horário, consulte Definições de fuso horário.

Se o parâmetro time_zone for avaliado como NULL, essa função retornará NULL.

Tipos de dados retornados

DATE

Exemplo

SELECT CURRENT_DATE() as the_date;

+--------------+
| the_date     |
+--------------+
| 2016-12-25   |
+--------------+

EXTRACT

EXTRACT(part FROM date_expression)

Descrição

Retorna o valor correspondente à parte da data especificada. O part precisa ser um dos seguintes:

  • DAYOFWEEK: retorna valores no intervalo [1,7] com domingo como primeiro dia da semana.
  • DAY
  • DAYOFYEAR
  • WEEK: retorna o número da semana da data no intervalo [0, 53]. As semanas começam no domingo. Os dias anteriores ao primeiro domingo do ano estão na semana 0.
  • WEEK(<WEEKDAY>): retorna o número da semana da data no intervalo [0, 53]. As semanas começam em WEEKDAY. As datas anteriores ao primeiro WEEKDAY do ano estão na semana 0. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: retorna o número da semana ISO 8601 de date_expression. As ISOWEEKs começam na segunda-feira. Os valores de retorno estão no intervalo [1, 53]. O primeiro ISOWEEK de cada ano ISO começa na segunda-feira anterior à primeira quinta-feira do ano do calendário gregoriano.
  • MONTH
  • QUARTER: retorna valores na faixa [1,4].
  • YEAR
  • ISOYEAR: retorna o ano da numeração da semana ISO 8601, que é o ano do calendário gregoriano que contém a quinta-feira da semana à qual date_expression pertence.

Tipos de dados retornados

INT64

Exemplos

No exemplo a seguir, EXTRACT retorna um valor correspondente à parte de hora de DAY.

SELECT EXTRACT(DAY FROM DATE '2013-12-25') as the_day;

+---------+
| the_day |
+---------+
| 25      |
+---------+

No exemplo a seguir, EXTRACT retorna valores correspondentes a diferentes partes de hora de uma coluna de datas próximas ao final do ano.

SELECT
  date,
  EXTRACT(ISOYEAR FROM date) AS isoyear,
  EXTRACT(ISOWEEK FROM date) AS isoweek,
  EXTRACT(YEAR FROM date) AS year,
  EXTRACT(WEEK FROM date) AS week
FROM UNNEST(GENERATE_DATE_ARRAY('2015-12-23', '2016-01-09')) AS date
ORDER BY date;
+------------+---------+---------+------+------+
| date       | isoyear | isoweek | year | week |
+------------+---------+---------+------+------+
| 2015-12-23 | 2015    | 52      | 2015 | 51   |
| 2015-12-24 | 2015    | 52      | 2015 | 51   |
| 2015-12-25 | 2015    | 52      | 2015 | 51   |
| 2015-12-26 | 2015    | 52      | 2015 | 51   |
| 2015-12-27 | 2015    | 52      | 2015 | 52   |
| 2015-12-28 | 2015    | 53      | 2015 | 52   |
| 2015-12-29 | 2015    | 53      | 2015 | 52   |
| 2015-12-30 | 2015    | 53      | 2015 | 52   |
| 2015-12-31 | 2015    | 53      | 2015 | 52   |
| 2016-01-01 | 2015    | 53      | 2016 | 0    |
| 2016-01-02 | 2015    | 53      | 2016 | 0    |
| 2016-01-03 | 2015    | 53      | 2016 | 1    |
| 2016-01-04 | 2016    | 1       | 2016 | 1    |
| 2016-01-05 | 2016    | 1       | 2016 | 1    |
| 2016-01-06 | 2016    | 1       | 2016 | 1    |
| 2016-01-07 | 2016    | 1       | 2016 | 1    |
| 2016-01-08 | 2016    | 1       | 2016 | 1    |
| 2016-01-09 | 2016    | 1       | 2016 | 1    |
+------------+---------+---------+------+------+

No exemplo a seguir, date_expression cai em um domingo. EXTRACT calcula a primeira coluna usando semanas que começam no domingo e calcula a segunda coluna usando semanas que começam na segunda-feira.

WITH table AS (SELECT DATE('2017-11-05') AS date)
SELECT
  date,
  EXTRACT(WEEK(SUNDAY) FROM date) AS week_sunday,
  EXTRACT(WEEK(MONDAY) FROM date) AS week_monday FROM table;

+------------+-------------+-------------+
| date       | week_sunday | week_monday |
+------------+-------------+-------------+
| 2017-11-05 | 45          | 44          |
+------------+-------------+-------------+

DATE

1. DATE(year, month, day)
2. DATE(timestamp_expression[, timezone])
3. DATE(datetime_expression)

Descrição

  1. Cria uma DATE com os valores INT64 que representam o ano, o mês e o dia.
  2. Extrai a DATE de uma expressão TIMESTAMP. Aceita um parâmetro opcional para especificar um fuso horário. Se nenhum fuso horário for especificado, será usado o padrão UTC.
  3. Extrai a DATE de uma expressão DATETIME.

Tipos de dados retornados

DATE

Exemplo

SELECT
  DATE(2016, 12, 25) as date_ymd,
  DATE(DATETIME "2016-12-25 23:59:59") as date_dt,
  DATE(TIMESTAMP "2016-12-25 05:30:00+07", "America/Los_Angeles") as date_tstz;

+------------+------------+------------+
| date_ymd   | date_dt    | date_tstz  |
+------------+------------+------------+
| 2016-12-25 | 2016-12-25 | 2016-12-24 |
+------------+------------+------------+

DATE_ADD

DATE_ADD(date_expression, INTERVAL INT64_expr date_part)

Descrição

Adiciona um intervalo de tempo especificado a uma DATE.

DATE_ADD aceita os seguintes valores date_part:

  • DAY
  • WEEK. Equivalente a 7 DAYs.
  • MONTH
  • QUARTER
  • YEAR

Será necessário um tratamento especial para as partes MONTH, QUARTER e YEAR quando a data for o último dia do mês ou estiver perto dele. Se o mês resultante tiver menos dias do que a data original, o dia resultante será o último dia do mês novo.

Tipos de dados retornados

DATE

Exemplo

SELECT DATE_ADD(DATE "2008-12-25", INTERVAL 5 DAY) as five_days_later;

+--------------------+
| five_days_later    |
+--------------------+
| 2008-12-30         |
+--------------------+

DATE_SUB

DATE_SUB(date_expression, INTERVAL INT64_expr date_part)

Descrição

Subtrai um intervalo de tempo especificado de uma DATE.

DATE_SUB aceita os seguintes valores date_part:

  • DAY
  • WEEK. Equivalente a 7 DAYs.
  • MONTH
  • QUARTER
  • YEAR

Será necessário um tratamento especial para as partes MONTH, QUARTER e YEAR quando a data for o último dia do mês ou estiver perto dele. Se o mês resultante tiver menos dias do que a data original, o dia resultante será o último dia do mês novo.

Tipos de dados retornados

DATE

Exemplo

SELECT DATE_SUB(DATE "2008-12-25", INTERVAL 5 DAY) as five_days_ago;

+---------------+
| five_days_ago |
+---------------+
| 2008-12-20    |
+---------------+

DATE_DIFF

DATE_DIFF(date_expression, date_expression, date_part)

Descrição

Retorna o número de limites de date_part entre as duas date_expressions. Se a primeira data ocorrer antes da segunda data, o resultado não será positivo.

DATE_DIFF aceita os seguintes valores date_part:

  • DAY
  • WEEK: essa parte da data começa no domingo.
  • WEEK(<WEEKDAY>): essa parte da data começa em WEEKDAY. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: usa limites da semana ISO 8601. As semanas ISO começam na segunda-feira.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: usa o limite de ano de numeração da semana ISO 8601. O limite do ano ISO é a segunda-feira da primeira semana que contém a quinta-feira pertencente ao ano do calendário gregoriano correspondente.

Tipos de dados retornados

INT64

Exemplo

SELECT DATE_DIFF(DATE '2010-07-07', DATE '2008-12-25', DAY) as days_diff;

+-----------+
| days_diff |
+-----------+
| 559       |
+-----------+

SELECT
  DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', DAY) as days_diff,
  DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', WEEK) as weeks_diff;

+-----------+------------+
| days_diff | weeks_diff |
+-----------+------------+
| 1         | 1          |
+-----------+------------+

O exemplo acima mostra o resultado de DATE_DIFF para dois dias consecutivos. DATE_DIFF com a parte da data WEEK retorna 1 porque DATE_DIFF conta o número de limites da parte da data nesse intervalo de datas. Cada WEEK começa no domingo, então há um limite da parte da data entre sábado, 2017-10-14 e domingo, 2017-10-15.

No exemplo a seguir, mostraremos o resultado de DATE_DIFF para duas datas em anos diferentes. DATE_DIFF com a parte da data YEAR retorna 3 porque conta o número de limites do ano do calendário gregoriano entre as duas datas. DATE_DIFF com a parte da data ISOYEAR retorna 2 porque a segunda data pertence ao ano ISO 2015. A primeira quinta-feira do ano-calendário de 2015 foi 2015-01-01, então o ano ISO 2015 começa na segunda-feira anterior, 2014-12-29.

SELECT
  DATE_DIFF('2017-12-30', '2014-12-30', YEAR) AS year_diff,
  DATE_DIFF('2017-12-30', '2014-12-30', ISOYEAR) AS isoyear_diff;

+-----------+--------------+
| year_diff | isoyear_diff |
+-----------+--------------+
| 3         | 2            |
+-----------+--------------+

O exemplo a seguir mostra o resultado de DATE_DIFF para dois dias consecutivos. A primeira data cai em uma segunda-feira e a segunda data cai em um domingo. DATE_DIFF com a parte da data WEEK retorna 0 porque esta parte do tempo usa semanas que começam no domingo. DATE_DIFF com a parte da data WEEK(MONDAY) retorna 1. DATE_DIFF com a parte da data ISOWEEK também retorna 1 porque as semanas ISO começam na segunda-feira.

SELECT
  DATE_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
  DATE_DIFF('2017-12-18', '2017-12-17', WEEK(MONDAY)) AS week_weekday_diff,
  DATE_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;

+-----------+-------------------+--------------+
| week_diff | week_weekday_diff | isoweek_diff |
+-----------+-------------------+--------------+
| 0         | 1                 | 1            |
+-----------+-------------------+--------------+

DATE_TRUNC

DATE_TRUNC(date_expression, date_part)

Descrição

Trunca a data com a granularidade especificada.

DATE_TRUNC aceita os seguintes valores para date_part:

  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): trunca date_expression no limite da semana anterior, em que as semanas começam em WEEKDAY. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: trunca date_expression no limite da semana ISO 8601 anterior. s começam na segunda-feira. A primeira ISOWEEK de cada ano ISO contém a primeira quinta-feira do ano do calendário gregoriano correspondente. Qualquer date_expression anterior a esta vai truncar na segunda-feira anterior.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: trunca date_expression no limite do ano de numeração da semana ISO 8601 anterior. O limite do ano ISO é a segunda-feira da primeira semana que contém a quinta-feira pertencente ao ano do calendário gregoriano correspondente.

Tipos de dados retornados

DATE

Exemplos

SELECT DATE_TRUNC(DATE '2008-12-25', MONTH) as month;

+------------+
| month      |
+------------+
| 2008-12-01 |
+------------+

No exemplo a seguir, a data original cai em um domingo. Como date_part é WEEK(MONDAY), DATE_TRUNC retorna a DATE da segunda-feira anterior.

SELECT date AS original, DATE_TRUNC(date, WEEK(MONDAY)) AS truncated
FROM (SELECT DATE('2017-11-05') AS date);

+------------+------------+
| original   | truncated  |
+------------+------------+
| 2017-11-05 | 2017-10-30 |
+------------+------------+

No exemplo a seguir, a date_expression original está no ano do calendário gregoriano de 2015. No entanto, DATE_TRUNC com a parte da data ISOYEAR trunca a date_expression no início do ano ISO, não no ano do calendário gregoriano. A primeira quinta-feira do ano-calendário de 2015 foi 2015-01-01, então o ano ISO 2015 começa na segunda-feira anterior, 2014-12-29. Portanto, o limite do ano ISO anterior a date_expression 2015-06-15 é 2014-12-29.

SELECT
  DATE_TRUNC('2015-06-15', ISOYEAR) AS isoyear_boundary,
  EXTRACT(ISOYEAR FROM DATE '2015-06-15') AS isoyear_number;

+------------------+----------------+
| isoyear_boundary | isoyear_number |
+------------------+----------------+
| 2014-12-29       | 2015           |
+------------------+----------------+

DATE_FROM_UNIX_DATE

DATE_FROM_UNIX_DATE(INT64_expression)

Descrição

Interpreta INT64_expression como o número de dias desde 01-01-1970.

Tipos de dados retornados

DATE

Exemplo

SELECT DATE_FROM_UNIX_DATE(14238) as date_from_epoch;

+-----------------+
| date_from_epoch |
+-----------------+
| 2008-12-25      |
+-----------------+

FORMAT_DATE

FORMAT_DATE(format_string, date_expr)

Descrição

Formata date_expr de acordo com a format_string especificada.

Consulte Elementos de formatos compatíveis com DATE para ver uma lista de elementos de formato aceitos por essa função.

Tipos de dados retornados

STRING

Exemplos

SELECT FORMAT_DATE("%x", DATE "2008-12-25") as US_format;

+------------+
| US_format  |
+------------+
| 12/25/08   |
+------------+
SELECT FORMAT_DATE("%b-%d-%Y", DATE "2008-12-25") AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec-25-2008 |
+-------------+
SELECT FORMAT_DATE("%b %Y", DATE "2008-12-25") AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec 2008    |
+-------------+

PARSE_DATE

PARSE_DATE(format_string, date_string)

Descrição

Usa uma format_string e a representação de string de uma data para retornar um objeto DATE.

Ao usar PARSE_DATE, tenha em mente os seguintes itens:

  • Campos não especificados. Qualquer campo não especificado é inicializado em 1970-01-01.
  • Nomes que não diferenciam maiúsculas e minúsculas. Nomes, como Monday, February e outros, não diferenciam maiúsculas de minúsculas.
  • Espaço em branco. Um ou mais espaços em branco consecutivos na string de formato correspondem a zero ou mais espaços em branco consecutivos na string de data. Além disso, espaços em branco à esquerda e à direita na string de data sempre são permitidos, mesmo que não estejam na string de formato.
  • Precedência de formato. Quando dois (ou mais) elementos de formato têm informações sobrepostas (por exemplo, %F e %Y afetam o ano), o último geralmente substitui os anteriores.

Tipos de dados retornados

DATE

Exemplo

SELECT PARSE_DATE("%x", "12/25/08") as parsed;

+------------+
| parsed     |
+------------+
| 2008-12-25 |
+------------+

UNIX_DATE

UNIX_DATE(date_expression)

Descrição

Retorna o número de dias desde 1970-01-01.

Tipos de dados retornados

INT64

Exemplo

SELECT UNIX_DATE(DATE "2008-12-25") as days_from_epoch;

+-----------------+
| days_from_epoch |
+-----------------+
| 14238           |
+-----------------+

Elementos de formatos compatíveis com DATE

Salvo indicação em contrário, as funções DATE que usam strings de formato aceitam os seguintes elementos:

Elemento de formato Descrição
%A O nome completo do dia da semana.
%a O nome abreviado do dia da semana.
%B O nome completo do mês.
%b ou %h O nome abreviado do mês.
%C O século (um ano dividido por 100 e truncado como um inteiro) como número decimal (00-99).
%D A data no formato %m/%d/%y.
%d O dia do mês como número decimal (01-31).
%e O dia do mês como número decimal (1-31). Dígitos únicos são precedidos por um espaço.
%F A data no formato %Y-%m-%d.
%G O ano ISO 8601 com o século como número decimal. Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %G e %Y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%g O ano ISO 8601 sem o século como número decimal (00-99). Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %g e %y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%j O dia do ano como número decimal (001-366).
%m O mês como número decimal (01-12).
%n Um caractere de nova linha.
%Q O trimestre como um número decimal (de 1–4).
%t Um caractere de tabulação.
%U O número da semana do ano (domingo como o primeiro dia da semana) como número decimal (00-53).
%u O dia da semana (segunda-feira como o primeiro dia da semana) como número decimal (1-7).
%V O número da semana ISO 8601 do ano (segunda-feira como o primeiro dia da semana) como um número decimal (01–53). Se a semana que tem 1 de janeiro tiver quatro ou mais dias no ano novo, então será a semana 1. Caso contrário, será a semana 53 do ano anterior e a semana seguinte será a semana 1.
%W O número da semana do ano (segunda-feira como o primeiro dia da semana) como número decimal (00-53).
%w O dia da semana (domingo como o primeiro dia da semana) como número decimal (0-6).
%x A representação de data no formato MM/DD/YY.
%Y O ano com o século como número decimal.
%y O ano sem o século como número decimal (00-99), com um zero opcional à esquerda. Pode ser misturado com %C. Se %C não for especificado, os anos 00-68 são os 2000, enquanto os anos 69-99 são os 1900.
%E4Y Anos com quatro caracteres (0001 ... 9999). %Y produz quantos caracteres forem necessários para processar totalmente o ano.

Funções DateTime

O BigQuery é compatível com as seguintes funções DATETIME.

CURRENT_DATETIME

CURRENT_DATETIME([timezone])

Descrição

Retorna a hora atual como um objeto DATETIME.

Esta função aceita um parâmetro timezone opcional. Para informações sobre como especificar um fuso horário, consulte Definições de fuso horário.

Tipos de dados retornados

DATETIME

Exemplo

SELECT CURRENT_DATETIME() as now;

+----------------------------+
| now                        |
+----------------------------+
| 2016-05-19 10:38:47.046465 |
+----------------------------+

DATETIME

1. DATETIME(year, month, day, hour, minute, second)
2. DATETIME(date_expression, time_expression)
3. DATETIME(timestamp_expression [, timezone])

Descrição

  1. Cria um objeto DATETIME usando valores INT64 que representam o ano, mês, dia, hora, minuto e segundo.
  2. Cria um objeto DATETIME usando um objetos DATE e TIME.
  3. Cria um objeto DATETIME usando um objeto TIMESTAMP. Aceita um parâmetro opcional para especificar um fuso horário. Se nenhum fuso horário for especificado, será usado o padrão UTC.

Tipos de dados retornados

DATETIME

Exemplo

SELECT
  DATETIME(2008, 12, 25, 05, 30, 00) as datetime_ymdhms,
  DATETIME(TIMESTAMP "2008-12-25 05:30:00+00", "America/Los_Angeles") as datetime_tstz;

+---------------------+---------------------+
| datetime_ymdhms     | datetime_tstz       |
+---------------------+---------------------+
| 2008-12-25 05:30:00 | 2008-12-24 21:30:00 |
+---------------------+---------------------+

DATETIME_ADD

DATETIME_ADD(datetime_expression, INTERVAL INT64_expr part)

Descrição

Adiciona unidades INT64_expr de part ao objeto DATETIME.

DATETIME_ADD aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK. Equivalente a 7 DAYs.
  • MONTH
  • QUARTER
  • YEAR

Será necessário um tratamento especial para as partes MONTH, QUARTER e YEAR quando a data for o último dia do mês ou estiver perto dele. Se o mês resultante tiver menos dias do que DATETIME original, então o dia resultante será o último dia do novo mês.

Tipos de dados retornados

DATETIME

Exemplo

SELECT
  DATETIME "2008-12-25 15:30:00" as original_date,
  DATETIME_ADD(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as later;

+-----------------------------+------------------------+
| original_date               | later                  |
+-----------------------------+------------------------+
| 2008-12-25 15:30:00         | 2008-12-25 15:40:00    |
+-----------------------------+------------------------+

DATETIME_SUB

DATETIME_SUB(datetime_expression, INTERVAL INT64_expr part)

Descrição

Subtrai unidades INT64_expr de part de DATETIME.

DATETIME_SUB aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK. Equivalente a 7 DAYs.
  • MONTH
  • QUARTER
  • YEAR

Será necessário um tratamento especial para as partes MONTH, QUARTER e YEAR quando a data for o último dia do mês ou estiver perto dele. Se o mês resultante tiver menos dias do que DATETIME original, então o dia resultante será o último dia do novo mês.

Tipos de dados retornados

DATETIME

Exemplo

SELECT
  DATETIME "2008-12-25 15:30:00" as original_date,
  DATETIME_SUB(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as earlier;

+-----------------------------+------------------------+
| original_date               | earlier                |
+-----------------------------+------------------------+
| 2008-12-25 15:30:00         | 2008-12-25 15:20:00    |
+-----------------------------+------------------------+

DATETIME_DIFF

DATETIME_DIFF(datetime_expression, datetime_expression, part)

Descrição

Retorna o número de part limites entre os dois datetime_expressions. Se a primeira DATETIME ocorrer antes da segunda DATETIME, o resultado não será positivo. Lança um erro se o cálculo estoura o tipo de resultado, como se a diferença em microssegundos entre os dois objetos DATETIME estourasse um valor INT64.

DATETIME_DIFF aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK: esta parte da data começa no domingo.
  • WEEK(<WEEKDAY>): esta parte da data começa em WEEKDAY. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: usa limites da semana ISO 8601. As semanas ISO começam na segunda-feira.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: usa o limite de ano de numeração da semana ISO 8601. O limite do ano ISO é a segunda-feira da primeira semana que contém a quinta-feira pertencente ao ano do calendário gregoriano correspondente.

Tipos de dados retornados

INT64

Exemplo

SELECT
  DATETIME "2010-07-07 10:20:00" as first_datetime,
  DATETIME "2008-12-25 15:30:00" as second_datetime,
  DATETIME_DIFF(DATETIME "2010-07-07 10:20:00",
    DATETIME "2008-12-25 15:30:00", DAY) as difference;

+----------------------------+------------------------+------------------------+
| first_datetime             | second_datetime        | difference             |
+----------------------------+------------------------+------------------------+
| 2010-07-07 10:20:00        | 2008-12-25 15:30:00    | 559                    |
+----------------------------+------------------------+------------------------+

SELECT
  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
    DATETIME '2017-10-14 00:00:00', DAY) as days_diff,
  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
    DATETIME '2017-10-14 00:00:00', WEEK) as weeks_diff;

+-----------+------------+
| days_diff | weeks_diff |
+-----------+------------+
| 1         | 1          |
+-----------+------------+

O exemplo acima mostra o resultado de DATETIME_DIFF para dois DATETIMEs que estão separados por 24 horas. DATETIME_DIFF com a parte WEEK retorna 1 porque DATETIME_DIFF conta o número de limites das partes nesse intervalo de DATETIMEs. Cada WEEK começa no domingo, então há um limite de parte entre sábado, 2017-10-14 00:00:00 e domingo, 2017-10-15 00:00:00.

No exemplo a seguir, mostraremos o resultado de DATETIME_DIFF para duas datas em anos diferentes. DATETIME_DIFF com a parte da data YEAR retorna 3 porque conta o número de limites do ano do calendário gregoriano entre as duas DATETIMEs. DATETIME_DIFF com a parte da data ISOYEAR retorna 2 porque a segunda DATETIME pertence ao ano ISO 2015. A primeira quinta-feira do ano calendário de 2015 foi 2015-01-01, então o ano ISO 2015 começa na segunda-feira anterior, 2014-12-29.

SELECT
  DATETIME_DIFF('2017-12-30 00:00:00',
    '2014-12-30 00:00:00', YEAR) AS year_diff,
  DATETIME_DIFF('2017-12-30 00:00:00',
    '2014-12-30 00:00:00', ISOYEAR) AS isoyear_diff;

+-----------+--------------+
| year_diff | isoyear_diff |
+-----------+--------------+
| 3         | 2            |
+-----------+--------------+

O exemplo a seguir mostra o resultado de DATETIME_DIFF para dois dias consecutivos. A primeira data cai em uma segunda-feira e a segunda data cai em um domingo. DATETIME_DIFF com a parte da data WEEK retorna 0 porque esta parte do tempo usa semanas que começam no domingo. DATETIME_DIFF com a parte da data WEEK(MONDAY) retorna 1. DATETIME_DIFF com a parte da data ISOWEEK também retorna 1 porque as semanas ISO começam na segunda-feira.

SELECT
  DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
  DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK(MONDAY)) AS week_weekday_diff,
  DATETIME_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;

+-----------+-------------------+--------------+
| week_diff | week_weekday_diff | isoweek_diff |
+-----------+-------------------+--------------+
| 0         | 1                 | 1            |
+-----------+-------------------+--------------+

DATETIME_TRUNC

DATETIME_TRUNC(datetime_expression, part)

Descrição

Trunca um objeto DATETIME para a granularidade de part.

DATETIME_TRUNC aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): trunca datetime_expression no limite da semana anterior, em que as semanas começam em WEEKDAY. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: trunca datetime_expression no limite da semana ISO 8601 anterior. s começam na segunda-feira. A primeira ISOWEEK de cada ano ISO contém a primeira quinta-feira do ano do calendário gregoriano correspondente. Qualquer date_expression anterior a esta vai truncar na segunda-feira anterior.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: trunca datetime_expression no limite do ano de numeração da semana ISO 8601 anterior. O limite do ano ISO é a segunda-feira da primeira semana que contém a quinta-feira pertencente ao ano do calendário gregoriano correspondente.

Tipos de dados retornados

DATETIME

Exemplos

SELECT
  DATETIME "2008-12-25 15:30:00" as original,
  DATETIME_TRUNC(DATETIME "2008-12-25 15:30:00", DAY) as truncated;

+----------------------------+------------------------+
| original                   | truncated              |
+----------------------------+------------------------+
| 2008-12-25 15:30:00        | 2008-12-25 00:00:00    |
+----------------------------+------------------------+

No exemplo a seguir, o DATETIME original cai em um domingo. Como part é WEEK(MONDAY), DATE_TRUNC retorna o DATETIME da segunda-feira anterior.

SELECT
 datetime AS original,
 DATETIME_TRUNC(datetime, WEEK(MONDAY)) AS truncated
FROM (SELECT DATETIME(TIMESTAMP '2017-11-05 00:00:00') AS datetime);

+---------------------+---------------------+
| original            | truncated           |
+---------------------+---------------------+
| 2017-11-05 00:00:00 | 2017-10-30 00:00:00 |
+---------------------+---------------------+

No exemplo a seguir, o datetime_expression original está no ano letivo gregoriano de 2015. No entanto, DATETIME_TRUNC com a parte da data ISOYEAR trunca a datetime_expression no início do ano ISO, não no ano do calendário gregoriano. A primeira quinta-feira do ano calendário de 2015 foi 2015-01-01, então o ano ISO 2015 começa na segunda-feira anterior, 2014-12-29. Portanto, o limite do ano ISO anterior a datetime_expression 2015-06-15 00:00:00 é 2014-12-29.

SELECT
  DATETIME_TRUNC('2015-06-15 00:00:00', ISOYEAR) AS isoyear_boundary,
  EXTRACT(ISOYEAR FROM DATETIME '2015-06-15 00:00:00') AS isoyear_number;

+---------------------+----------------+
| isoyear_boundary    | isoyear_number |
+---------------------+----------------+
| 2014-12-29 00:00:00 | 2015           |
+---------------------+----------------+

FORMAT_DATETIME

FORMAT_DATETIME(format_string, datetime_expression)

Descrição

Formata um objeto DATETIME de acordo com o format_string especificado. Consulte Elementos de formatos compatíveis de DATETIME para ver uma lista de elementos de formato aceitos por essa função.

Tipos de dados retornados

STRING

Exemplos

SELECT
  FORMAT_DATETIME("%c", DATETIME "2008-12-25 15:30:00")
  AS formatted;

+--------------------------+
| formatted                |
+--------------------------+
| Thu Dec 25 15:30:00 2008 |
+--------------------------+
SELECT
  FORMAT_DATETIME("%b-%d-%Y", DATETIME "2008-12-25 15:30:00")
  AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec-25-2008 |
+-------------+
SELECT
  FORMAT_DATETIME("%b %Y", DATETIME "2008-12-25 15:30:00")
  AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec 2008    |
+-------------+

PARSE_DATETIME

PARSE_DATETIME(format_string, string)

Descrição

Usa um format_string e uma representação de STRING de um DATETIME para retornar um DATETIME. Consulte Elementos de formatos compatíveis de DATETIME para ver uma lista de elementos de formato aceitos por essa função.

PARSE_DATETIME analisa string de acordo com as seguintes regras:

  • Campos não especificados. Qualquer campo não especificado é inicializado em 1970-01-01 00:00:00.0. Por exemplo, se o ano não for especificado, o padrão será 1970.
  • Nomes que não diferenciam maiúsculas e minúsculas. Os nomes, como Monday e February, diferenciam maiúsculas de minúsculas.
  • Espaço em branco. Um ou mais espaços em branco consecutivos na string de formato correspondem a zero ou mais espaços em branco consecutivos na string DATETIME. Espaços em branco à esquerda e à direita na string DATETIME sempre são permitidos, mesmo que não estejam na string de formato.
  • Precedência de formato. Quando dois ou mais elementos de formato têm informações de sobreposição, o último geralmente modifica os anteriores. Por exemplo, %F e %Y afetam o ano, de modo que o elemento anterior modifica o último. Consulte as descrições de %s, %C e %y em elementos de formato compatíveis para DATETIME.

Exemplos

O exemplo a seguir analisa um literal STRING como DATETIME.

SELECT PARSE_DATETIME('%Y-%m-%d %H:%M:%S', '1998-10-18 13:45:55') AS datetime;

A consulta acima retorna o resultado a seguir:

+---------------------+
| datetime            |
+---------------------+
| 1998-10-18 13:45:55 |
+---------------------+

O exemplo a seguir analisa um literal STRING que contém uma data em um formato de linguagem natural como DATETIME.

SELECT PARSE_DATETIME('%A, %B %e, %Y','Wednesday, December 19, 2018')
  AS datetime;

A consulta acima retorna o resultado a seguir:

+---------------------+
| datetime            |
+---------------------+
| 2018-12-19 00:00:00 |
+---------------------+

Tipos de dados retornados

DATETIME

Elementos de formatos compatíveis de DATETIME

Salvo indicação em contrário, as funções DATETIME que usam strings de formato aceitam os seguintes elementos:

Elemento de formato Descrição
%A O nome completo do dia da semana.
%a O nome abreviado do dia da semana.
%B O nome completo do mês.
%b ou %h O nome abreviado do mês.
%C O século (um ano dividido por 100 e truncado para um inteiro) como um número decimal (00–99).
%c A representação de data e hora.
%D A data no formato %m/%d/%y.
%d O dia do mês como número decimal (01-31).
%e O dia do mês como número decimal (1-31). Dígitos únicos são precedidos por um espaço.
%F A data no formato %Y-%m-%d.
%G O ano ISO 8601 com o século como número decimal. Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %G e %Y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%g O ano ISO 8601 sem o século como número decimal (00–99). Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %g e %y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%H A hora em um relógio de 24 horas como número decimal (00-23).
%I A hora em um relógio de 12 horas como número decimal (01-12).
%j O dia do ano como número decimal (001-366).
%k A hora em um relógio de 24 horas como número decimal (0-23). Dígitos únicos são precedidos por um espaço.
%l A hora em um relógio de 12 horas como número decimal (1-12). Dígitos únicos são precedidos por um espaço.
%M O minuto como número decimal (00-59).
%m O mês como número decimal (01-12).
%n Um caractere de nova linha.
%P am ou pm.
%p AM ou PM.
%Q O trimestre como um número decimal (de 1–4).
%R A hora no formato %H:%M.
%r A hora em um relógio de 12 horas usando a notação AM/PM.
%S O segundo como número decimal (00-60).
%s O número de segundos desde 1970-01-01 00:00:00. Sempre modifica todos os outros elementos de formato, seja qual for o local onde %s aparece na string. Se vários elementos %s aparecerem, o último terá precedência.
%T A hora no formato %H:%M:%S.
%t Um caractere de tabulação.
%U O número da semana do ano (domingo como o primeiro dia da semana) como número decimal (00-53).
%u O dia da semana (segunda-feira como o primeiro dia da semana) como número decimal (1-7).
%V O número da semana ISO 8601 do ano (segunda-feira como o primeiro dia da semana) como um número decimal (01–53). Se a semana que tem 1 de janeiro tiver quatro ou mais dias no ano novo, então será a semana 1. Caso contrário, será a semana 53 do ano anterior e a semana seguinte será a semana 1.
%W O número da semana do ano (segunda-feira como o primeiro dia da semana) como número decimal (00-53).
%w O dia da semana (domingo como o primeiro dia da semana) como número decimal (0-6).
%X A representação da hora no formato HH:MM:SS.
%x A representação de data no formato MM/DD/YY.
%Y O ano com o século como número decimal.
%y O ano sem o século como número decimal (00-99), com um zero opcional à esquerda. Pode ser misturado com %C. Se %C não for especificado, os anos 00-68 são os 2000, enquanto os anos 69-99 são os 1900.
%% Um único caractere %.
%E#S Segundos com # dígitos de precisão fracionária.
%E*S Segundos com precisão fracionária total (um literal '*').
%E4Y Anos com quatro caracteres (0001 ... 9999). %Y produz quantos caracteres forem necessários para processar o ano totalmente.

Funções de hora

O BigQuery é compatível com as seguintes funções TIME.

CURRENT_TIME

CURRENT_TIME()

Descrição

Retorna a hora atual como um objeto de TIME.

Tipos de dados retornados

TIME

Exemplo

SELECT CURRENT_TIME() as now;

+----------------------------+
| now                        |
+----------------------------+
| 15:31:38.776361            |
+----------------------------+

TIME

1. TIME(hour, minute, second)
2. TIME(timestamp, [timezone])
3. TIME(datetime)

Descrição

  1. Cria um objeto TIME usando valores INT64 que representam a hora, o minuto e o segundo.
  2. Cria um objeto TIME usando um objeto TIMESTAMP. Aceita um parâmetro opcional para especificar um fuso horário. Se nenhum fuso horário for especificado, será usado o padrão UTC.
  3. Cria um objeto TIME usando um objeto DATETIME.

Tipos de dados retornados

TIME

Exemplo

SELECT
  TIME(15, 30, 00) as time_hms,
  TIME(TIMESTAMP "2008-12-25 15:30:00+08", "America/Los_Angeles") as time_tstz;
+----------+-----------+
| time_hms | time_tstz |
+----------+-----------+
| 15:30:00 | 23:30:00  |
+----------+-----------+
SELECT
  TIME(DATETIME "2008-12-25 15:30:00.000000") AS time_dt;
+----------+
| time_dt  |
+----------+
| 15:30:00 |
+----------+

TIME_ADD

TIME_ADD(time_expression, INTERVAL INT64_expr part)

Descrição

Adiciona unidades INT64_expr de part ao objeto TIME.

TIME_ADD aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

Essa função ajusta automaticamente os valores quando recaem fora do limite de 00:00:00 a 24:00:00. Por exemplo, se você adicionar uma hora a 23:30:00, o valor retornado será 00:30:00.

Tipos de dados retornados

TIME

Exemplo

SELECT
  TIME "15:30:00" as original_time,
  TIME_ADD(TIME "15:30:00", INTERVAL 10 MINUTE) as later;

+-----------------------------+------------------------+
| original_time               | later                  |
+-----------------------------+------------------------+
| 15:30:00                    | 15:40:00               |
+-----------------------------+------------------------+

TIME_SUB

TIME_SUB(time_expression, INTERVAL INT_expr part)

Descrição

Subtrai unidades INT64_expr de part do objeto TIME.

TIME_SUB aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

Essa função ajusta automaticamente os valores quando recaem fora do limite de 00:00:00 a 24:00:00. Por exemplo, se você subtrair uma hora de 00:30:00, o valor retornado será 23:30:00.

Tipos de dados retornados

TIME

Exemplo

SELECT
  TIME "15:30:00" as original_date,
  TIME_SUB(TIME "15:30:00", INTERVAL 10 MINUTE) as earlier;

+-----------------------------+------------------------+
| original_date                | earlier                |
+-----------------------------+------------------------+
| 15:30:00                    | 15:20:00               |
+-----------------------------+------------------------+

TIME_DIFF

TIME_DIFF(time_expression, time_expression, part)

Descrição

Retorna o número de intervalos part especificados inteiros entre dois objetos TIME. Lança um erro se o cálculo estourar o tipo de resultado, como se a diferença em microssegundos entre os dois objetos de tempo estourasse um valor INT64.

TIME_DIFF aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

Tipos de dados retornados

INT64

Exemplo

SELECT
  TIME "15:30:00" as first_time,
  TIME "14:35:00" as second_time,
  TIME_DIFF(TIME "15:30:00", TIME "14:35:00", MINUTE) as difference;

+----------------------------+------------------------+------------------------+
| first_time                 | second_time            | difference             |
+----------------------------+------------------------+------------------------+
| 15:30:00                   | 14:35:00               | 55                     |
+----------------------------+------------------------+------------------------+

TIME_TRUNC

TIME_TRUNC(time_expression, part)

Descrição

Trunca um objeto TIME para a granularidade de part.

TIME_TRUNC aceita os seguintes valores para part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR

Tipos de dados retornados

TIME

Exemplo

SELECT
  TIME "15:30:00" as original,
  TIME_TRUNC(TIME "15:30:00", HOUR) as truncated;

+----------------------------+------------------------+
| original                   | truncated              |
+----------------------------+------------------------+
| 15:30:00                   | 15:00:00               |
+----------------------------+------------------------+

FORMAT_TIME

FORMAT_TIME(format_string, time_object)

Descrição Formata um objeto TIME de acordo com o format_string especificado. Consulte Elementos de formatos compatíveis de TIME para ver uma lista de elementos de formato aceitos por essa função.

Tipos de dados retornados

STRING

Exemplo

SELECT FORMAT_TIME("%R", TIME "15:30:00") as formatted_time;

+----------------+
| formatted_time |
+----------------+
| 15:30          |
+----------------+

PARSE_TIME

PARSE_TIME(format_string, string)

Descrição

Usa um format_string e uma string para retornar um objeto TIME. Consulte Elementos de formatos compatíveis de TIME para ver uma lista de elementos de formato aceitos por essa função.

Ao usar PARSE_TIME, tenha em mente os seguintes itens:

  • Campos não especificados. Qualquer campo não especificado é inicializado em 00:00:00.0. Por exemplo, se seconds não for especificado, o padrão será 00 e assim por diante.
  • Espaço em branco. Um ou mais espaços em branco consecutivos na string de formato correspondem a zero ou mais espaços em branco consecutivos na string TIME. Além disso, espaços em branco à esquerda e à direita na string TIME sempre são permitidos, mesmo que não estejam na string de formato.
  • Precedência de formato. Quando dois ou mais elementos de formato têm informações de sobreposição, o último geralmente modifica os anteriores.

Tipos de dados retornados

TIME

Exemplo

SELECT PARSE_TIME("%H", "15") as parsed_time;

+-------------+
| parsed_time |
+-------------+
| 15:00:00    |
+-------------+

Elementos de formatos compatíveis de TIME

Salvo indicação em contrário, as funções TIME que usam strings de formato aceitam os seguintes elementos:

Elemento de formato Descrição
%H A hora em um relógio de 24 horas como número decimal (00-23).
%I A hora em um relógio de 12 horas como número decimal (01-12).
%j O dia do ano como número decimal (001-366).
%k A hora em um relógio de 24 horas como número decimal (0-23). Dígitos únicos são precedidos por um espaço.
%l A hora em um relógio de 12 horas como número decimal (1-12). Dígitos únicos são precedidos por um espaço.
%M O minuto como número decimal (00-59).
%n Um caractere de nova linha.
%P am ou pm.
%p AM ou PM.
%R A hora no formato %H:%M.
%r A hora em um relógio de 12 horas usando a notação AM/PM.
%S O segundo como número decimal (00-60).
%T A hora no formato %H:%M:%S.
%t Um caractere de tabulação.
%X A representação da hora no formato HH:MM:SS.
%% Um único caractere %.
%E#S Segundos com # dígitos de precisão fracionária.
%E*S Segundos com precisão fracionária total (um literal '*').

Funções de carimbo de data/hora

O BigQuery é compatível com as seguintes funções TIMESTAMP.

OBSERVAÇÃO: essas funções retornam um erro de execução, se ocorrer um estouro. Os valores dos resultados são limitados até os valores mínimo e máximo da data e do timestamp definidos.

CURRENT_TIMESTAMP

CURRENT_TIMESTAMP()

Descrição

O uso de parênteses é opcional. Essa função trata os segundos bissextos distribuindo-os em um intervalo de 20 horas em torno do ajuste inserido. CURRENT_TIMESTAMP() produz um valor TIMESTAMP que é contínuo, não ambíguo, tem exatamente 60 segundos por minuto e não repete valores durante o segundo.

Tipos de entradas compatíveis

Não aplicável

Tipo de dados de resultado

TIMESTAMP

Exemplo

SELECT CURRENT_TIMESTAMP() as now;

+-------------------------------+
| now                           |
+-------------------------------+
| 2016-05-16 18:12:47.145482+00 |
+-------------------------------+

EXTRACT

EXTRACT(part FROM timestamp_expression [AT TIME ZONE tz_spec])

Descrição

Retorna um valor INT64 que corresponde ao part especificado de um timestamp_expression fornecido.

Os valores part permitidos são:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAYOFWEEK
  • DAY
  • DAYOFYEAR
  • WEEK: retorna o número da semana da data no intervalo [0, 53]. As semanas começam no domingo. Os dias anteriores ao primeiro domingo do ano estão na semana 0.
  • WEEK(<WEEKDAY>): retorna o número da semana de timestamp_expression no intervalo [0, 53]. As semanas começam em WEEKDAY. datetimes antes da primeira WEEKDAY do ano são na semana zero. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: retorna o número da semana ISO 8601 de datetime_expression. As ISOWEEKs começam na segunda-feira. Os valores de retorno estão no intervalo [1, 53]. O primeiro ISOWEEK de cada ano ISO começa na segunda-feira anterior à primeira quinta-feira do ano do calendário gregoriano.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: retorna o ano da numeração da semana ISO 8601, que é o ano do calendário gregoriano que contém a quinta-feira da semana à qual date_expression pertence.
  • DATE
  • DATETIME
  • TIME

Os valores retornados truncam períodos menores de tempo. Por exemplo, ao extrair segundos, EXTRACT trunca os valores de milissegundos e microssegundos.

Para informações sobre como especificar um fuso horário, consulte Definições de fuso horário.

Tipos de dados retornados

Geralmente, INT64 Retorna DATE se part for DATE.

Exemplos

No exemplo a seguir, EXTRACT retorna um valor correspondente à parte de hora de DAY.

SELECT EXTRACT(DAY
  FROM TIMESTAMP "2008-12-25 15:30:00" AT TIME ZONE "America/Los_Angeles")
  AS the_day;

+------------+
| the_day    |
+------------+
| 25         |
+------------+

No exemplo a seguir, EXTRACT retorna valores correspondentes a diferentes partes da hora de uma coluna de carimbos de data/hora.

WITH Timestamps AS (
  SELECT TIMESTAMP '2005-01-03 12:34:56' AS timestamp UNION ALL
  SELECT TIMESTAMP '2007-12-31' UNION ALL
  SELECT TIMESTAMP '2009-01-01' UNION ALL
  SELECT TIMESTAMP '2009-12-31' UNION ALL
  SELECT TIMESTAMP '2017-01-02' UNION ALL
  SELECT TIMESTAMP '2017-05-26'
)
SELECT
  timestamp,
  EXTRACT(ISOYEAR FROM timestamp) AS isoyear,
  EXTRACT(ISOWEEK FROM timestamp) AS isoweek,
  EXTRACT(YEAR FROM timestamp) AS year,
  EXTRACT(WEEK FROM timestamp) AS week
FROM Timestamps
ORDER BY timestamp;

+------------------------+---------+---------+------+------+
| timestamp              | isoyear | isoweek | year | week |
+------------------------+---------+---------+------+------+
| 2005-01-03 12:34:56+00 | 2005    | 1       | 2005 | 1    |
| 2007-12-31 00:00:00+00 | 2008    | 1       | 2007 | 52   |
| 2009-01-01 00:00:00+00 | 2009    | 1       | 2009 | 0    |
| 2009-12-31 00:00:00+00 | 2009    | 53      | 2009 | 52   |
| 2017-01-02 00:00:00+00 | 2017    | 1       | 2017 | 1    |
| 2017-05-26 00:00:00+00 | 2017    | 21      | 2017 | 21   |
+------------------------+---------+---------+------+------+

No exemplo a seguir, timestamp_expression cai em um domingo. EXTRACT calcula a primeira coluna usando semanas que começam no domingo e calcula a segunda coluna usando semanas que começam na segunda-feira.

WITH table AS (SELECT TIMESTAMP('2017-11-05 00:00:00') AS timestamp)
SELECT
  timestamp,
  EXTRACT(WEEK(SUNDAY) FROM timestamp) AS week_sunday,
  EXTRACT(WEEK(MONDAY) FROM timestamp) AS week_monday
FROM table;

+------------------------+-------------+---------------+
| timestamp              | week_sunday | week_monday   |
+------------------------+-------------+---------------+
| 2017-11-05 00:00:00+00 | 45          | 44            |
+------------------------+-------------+---------------+

STRING

STRING(timestamp_expression[, timezone])

Descrição

Converte um timestamp_expression em um tipo de dados STRING. Aceita um parâmetro opcional para especificar um fuso horário. Para informações sobre como especificar um fuso horário, consulte Definições de fuso horário.

Tipos de dados retornados

STRING

Exemplo

SELECT STRING(TIMESTAMP "2008-12-25 15:30:00", "America/Los_Angeles") as string;

+-------------------------------+
| string                        |
+-------------------------------+
| 2008-12-25 07:30:00-08        |
+-------------------------------+

TIMESTAMP

TIMESTAMP(
  string_expression[, timezone] |
  date_expression[, timezone] |
  datetime_expression[, timezone]
)

Descrição

  • string_expression[, timezone]: converte uma expressão STRING em um tipo de dados TIMESTAMP. string_expression precisa incluir um literal de carimbo de data e hora. Se string_expression incluir um fuso horário no literal de carimbo data/hora, não inclua um argumento timezone explícito.
  • date_expression[, timezone]: converte um objeto DATE em um tipo de dados TIMESTAMP.
  • datetime_expression[, timezone]: converte um objeto DATETIME para um tipo de dados TIMESTAMP.

Esta função suporta um parâmetro opcional para especificar um fuso horário. Se nenhum fuso horário for especificado, será usado o padrão UTC.

Tipos de dados retornados

TIMESTAMP

Exemplos

Nesses exemplos, um fuso horário é especificado.

SELECT CAST(
  TIMESTAMP("2008-12-25 15:30:00", "America/Los_Angeles") AS STRING
) AS timestamp_str;

+------------------------+
| timestamp_str          |
+------------------------+
| 2008-12-25 23:30:00+00 |
+------------------------+
SELECT CAST(
  TIMESTAMP("2008-12-25 15:30:00 America/Los_Angeles") AS STRING
) AS timestamp_str_timezone;

+------------------------+
| timestamp_str_timezone |
+------------------------+
| 2008-12-25 23:30:00+00 |
+------------------------+
SELECT CAST(
  TIMESTAMP(DATETIME "2008-12-25 15:30:00", "America/Los_Angeles") AS STRING
) AS timestamp_datetime;

+------------------------+
| timestamp_datetime     |
+------------------------+
| 2008-12-25 23:30:00+00 |
+------------------------+
SELECT CAST(
  TIMESTAMP(DATE "2008-12-25", "America/Los_Angeles") AS STRING
) AS timestamp_date;

+------------------------+
| timestamp_date         |
+------------------------+
| 2008-12-25 08:00:00+00 |
+------------------------+

Nesses exemplos, suponha que o fuso horário padrão seja UTC.

SELECT CAST(
  TIMESTAMP("2008-12-25 15:30:00") AS STRING
) AS timestamp_str;

+------------------------+
| timestamp_str          |
+------------------------+
| 2008-12-25 15:30:00+00 |
+------------------------+
SELECT CAST(
  TIMESTAMP(DATE "2008-12-25") AS STRING
) AS timestamp_date;

+------------------------+
| timestamp_date         |
+------------------------+
| 2008-12-25 00:00:00+00 |
+------------------------+

TIMESTAMP_ADD

TIMESTAMP_ADD(timestamp_expression, INTERVAL int64_expression date_part)

Descrição

Adiciona unidades int64_expression de date_part ao carimbo de data/hora, independentemente de qualquer fuso horário.

TIMESTAMP_ADD aceita os seguintes valores para date_part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR: equivalente a 60 MINUTEs
  • DAY. Equivalente a 24 HOURs.

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT
  TIMESTAMP "2008-12-25 15:30:00 UTC" as original,
  TIMESTAMP_ADD(TIMESTAMP "2008-12-25 15:30:00 UTC", INTERVAL 10 MINUTE) AS later;

+------------------------+------------------------+
| original               | later                  |
+------------------------+------------------------+
| 2008-12-25 15:30:00+00 | 2008-12-25 15:40:00+00 |
+------------------------+------------------------+

TIMESTAMP_SUB

TIMESTAMP_SUB(timestamp_expression, INTERVAL int64_expression date_part)

Descrição

Subtrai unidades int64_expression de date_part do carimbo de data/hora, independentemente de qualquer fuso horário.

TIMESTAMP_SUB aceita os seguintes valores para date_part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR: equivalente a 60 MINUTEs
  • DAY. Equivalente a 24 HOURs.

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT
  TIMESTAMP "2008-12-25 15:30:00 UTC" as original,
  TIMESTAMP_SUB(TIMESTAMP "2008-12-25 15:30:00 UTC", INTERVAL 10 MINUTE) AS earlier;

+------------------------+------------------------+
| original               | earlier                |
+------------------------+------------------------+
| 2008-12-25 15:30:00+00 | 2008-12-25 15:20:00+00 |
+------------------------+------------------------+

TIMESTAMP_DIFF

TIMESTAMP_DIFF(timestamp_expression, timestamp_expression, date_part)

Descrição

Retorna o número de intervalos date_part especificados entre os dois carimbos de data/hora. O primeiro timestamp_expression representa a data posterior; se o primeiro timestamp_expression for anterior ao segundo timestamp_expression, a saída será negativa. Lança um erro se o cálculo estourar o tipo de resultado, como se a diferença em nanossegundos entre os dois carimbos de data/hora estourasse um valor INT64.

TIMESTAMP_DIFF aceita os seguintes valores para date_part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR: equivalente a 60 MINUTEs
  • DAY. Equivalente a 24 HOURs.

Tipos de dados retornados

INT64

Exemplo

SELECT
  TIMESTAMP "2010-07-07 10:20:00 UTC" as later_timestamp,
  TIMESTAMP "2008-12-25 15:30:00 UTC" as earlier_timestamp,
  TIMESTAMP_DIFF(TIMESTAMP "2010-07-07 10:20:00 UTC",
    TIMESTAMP "2008-12-25 15:30:00 UTC", HOUR) AS hours;

+------------------------+------------------------+-------+
| later_timestamp        | earlier_timestamp      | hours |
+------------------------+------------------------+-------+
| 2010-07-07 10:20:00+00 | 2008-12-25 15:30:00+00 | 13410 |
+------------------------+------------------------+-------+

No exemplo a seguir, o primeiro carimbo de data/hora ocorre antes do segundo, resultando em uma saída negativa.

SELECT TIMESTAMP_DIFF(TIMESTAMP "2018-08-14", TIMESTAMP "2018-10-14", DAY);

+---------------+
| negative_diff |
+---------------+
| -61           |
+---------------+

TIMESTAMP_TRUNC

TIMESTAMP_TRUNC(timestamp_expression, date_part[, time_zone])

Descrição

Trunca um carimbo de data/hora para a granularidade de date_part.

TIMESTAMP_TRUNC aceita os seguintes valores para date_part:

  • MICROSECOND
  • MILLISECOND
  • SECOND
  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>): trunca timestamp_expression para o limite da semana anterior, onde as semanas começam em WEEKDAY. Os valores válidos para WEEKDAY são SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY e SATURDAY.
  • ISOWEEK: trunca timestamp_expression no limite da semana ISO 8601 anterior. s começam na segunda-feira. A primeira ISOWEEK de cada ano ISO contém a primeira quinta-feira do ano do calendário gregoriano correspondente. Qualquer date_expression anterior a esta vai truncar na segunda-feira anterior.
  • MONTH
  • QUARTER
  • YEAR
  • ISOYEAR: trunca timestamp_expression no limite do ano de numeração da semana ISO 8601 anterior. O limite do ano ISO é a segunda-feira da primeira semana que contém a quinta-feira pertencente ao ano do calendário gregoriano correspondente.

A função TIMESTAMP_TRUNC suporta um parâmetro time_zone opcional. Esse parâmetro se aplica aos seguintes date_parts:

  • MINUTE
  • HOUR
  • DAY
  • WEEK
  • WEEK(<WEEKDAY>)
  • MONTH
  • QUARTER
  • YEAR

Use esse parâmetro para um fuso horário diferente do UTC padrão, como parte da operação de truncamento.

Ao truncar um TIMESTAMP para MINUTE ou HOUR, TIMESTAMP_TRUNC determina o tempo civil do no fuso horário especificado (ou padrão) e subtrai os minutos e segundos (ao truncar para HOUR) ou os segundos (ao truncar para MINUTE) a partir desse . Na maioria dos casos, esse procedimento fornece resultados intuitivos, exceto próximo a transições de horário de verão que não são alinhadas por hora.

Tipos de dados retornados

TIMESTAMP

Exemplos

SELECT
  TIMESTAMP_TRUNC(TIMESTAMP '2008-12-25 15:30:00', DAY, 'UTC') as utc,
  TIMESTAMP_TRUNC(TIMESTAMP '2008-12-25 15:30:00', DAY, 'America/Los_Angeles') as la;

+------------------------+------------------------+
| utc                    | la                     |
+------------------------+------------------------+
| 2008-12-25 00:00:00+00 | 2008-12-25 08:00:00+00 |
+------------------------+------------------------+

No exemplo a seguir, timestamp_expression tem um deslocamento de fuso horário de +12. A primeira coluna mostra timestamp_expression na hora UTC. A segunda coluna mostra a saída de TIMESTAMP_TRUNC usando semanas que começam na segunda-feira. Porque o timestamp_expression cai em um domingo em UTC, TIMESTAMP_TRUNC trunca a segunda-feira anterior. A terceira coluna mostra a mesma função com o argumento de Definição de fuso horário opcional "Pacific/Auckland". Aqui, a função trunca o timestamp_expression usando o horário de verão neozelandês, em que ele cai na segunda-feira.

SELECT
  timestamp,
  TIMESTAMP_TRUNC(timestamp, WEEK(MONDAY)) AS utc_truncated,
  TIMESTAMP_TRUNC(timestamp, WEEK(MONDAY), 'Pacific/Auckland') AS nzdt_truncated
FROM (SELECT TIMESTAMP('2017-11-06 00:00:00+12') AS timestamp);

+------------------------+------------------------+------------------------+
| timestamp              | utc_truncated          | nzdt_truncated         |
+------------------------+------------------------+------------------------+
| 2017-11-05 12:00:00+00 | 2017-10-30 00:00:00+00 | 2017-11-05 11:00:00+00 |
+------------------------+------------------------+------------------------+

No exemplo a seguir, o timestamp_expression original está no ano letivo gregoriano de 2015. No entanto, TIMESTAMP_TRUNC com a parte da data ISOYEAR trunca o timestamp_expression para o início do ano ISO, não o ano calendário gregoriano. A primeira quinta-feira do ano calendário de 2015 foi 2015-01-01, então o ano ISO 2015 começa na segunda-feira anterior, 2014-12-29. Portanto, o limite do ano ISO anterior a timestamp_expression 2015-06-15 00:00:00 + 00 é 2014-12-29.

SELECT
  TIMESTAMP_TRUNC('2015-06-15 00:00:00+00', ISOYEAR) AS isoyear_boundary,
  EXTRACT(ISOYEAR FROM TIMESTAMP '2015-06-15 00:00:00+00') AS isoyear_number;

+------------------------+----------------+
| isoyear_boundary       | isoyear_number |
+------------------------+----------------+
| 2014-12-29 00:00:00+00 | 2015           |
+------------------------+----------------+

FORMAT_TIMESTAMP

FORMAT_TIMESTAMP(format_string, timestamp[, time_zone])

Descrição

Formata um carimbo de data e hora de acordo com o format_string especificado.

Consulte Elementos de formatos compatíveis de TIMESTAMP para ver uma lista de elementos de formato aceitos por essa função.

Tipos de dados retornados

STRING

Exemplo

SELECT FORMAT_TIMESTAMP("%c", TIMESTAMP "2008-12-25 15:30:00", "America/Los_Angeles")
  AS formatted;

+--------------------------+
| formatted                |
+--------------------------+
| Thu Dec 25 07:30:00 2008 |
+--------------------------+
SELECT FORMAT_TIMESTAMP("%b-%d-%Y", TIMESTAMP "2008-12-25 15:30:00")
  AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec-25-2008 |
+-------------+
SELECT FORMAT_TIMESTAMP("%b %Y", TIMESTAMP "2008-12-25 15:30:00")
  AS formatted;

+-------------+
| formatted   |
+-------------+
| Dec 2008    |
+-------------+

PARSE_TIMESTAMP

PARSE_TIMESTAMP(format_string, string[, time_zone])

Descrição

Usa um format_string e uma representação de string de um carimbo de data e hora para retornar um objeto TIMESTAMP.

Ao usar PARSE_TIMESTAMP, tenha em mente os seguintes itens:

  • Campos não especificados. Qualquer campo não especificado é inicializado em 1970-01-01 00:00:00.0. Esse valor de inicialização usa o fuso horário especificado pelo argumento de fuso horário da função, se houver. Caso contrário, o valor de inicialização usa o fuso horário UTC padrão. Por exemplo, se o ano não for especificado, o padrão será 1970 e assim por diante.
  • Nomes que não diferenciam maiúsculas e minúsculas. Nomes, como Monday, February e outros, não diferenciam maiúsculas de minúsculas.
  • Espaço em branco. Um ou mais espaços em branco consecutivos na string de formato correspondem a zero ou mais espaços em branco consecutivos na string de carimbo de data/hora. Além disso, espaços em branco à esquerda e à direita na string de carimbo de data/hora sempre são permitidos, mesmo que não estejam na string de formato.
  • Precedência de formato. Quando dois (ou mais) elementos de formato têm informações sobrepostas (por exemplo, %F e %Y afetam o ano), o último geralmente modifica os anteriores, com algumas exceções (consulte as descrições de %s, %C e %y).

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008", "America/Los_Angeles") as parsed;

+------------------------+
| parsed                 |
+------------------------+
| 2008-12-25 15:30:00+00 |
+------------------------+

TIMESTAMP_SECONDS

TIMESTAMP_SECONDS(int64_expression)

Descrição

Interpreta int64_expression como o número de segundos desde 1970-01-01 00:00:00 UTC.

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT TIMESTAMP_SECONDS(1230219000) as timestamp;

+------------------------+
| timestamp              |
+------------------------+
| 2008-12-25 15:30:00+00 |
+------------------------+

TIMESTAMP_MILLIS

TIMESTAMP_MILLIS(int64_expression)

Descrição

Interpreta int64_expression como o número de milissegundos desde 1970-01-01 00:00:00 UTC.

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT TIMESTAMP_MILLIS(1230219000000) as timestamp;

+------------------------+
| timestamp              |
+------------------------+
| 2008-12-25 15:30:00+00 |
+------------------------+

TIMESTAMP_MICROS

TIMESTAMP_MICROS(int64_expression)

Descrição

Interpreta int64_expression como o número de microssegundos desde 1970-01-01 00:00:00 UTC.

Tipos de dados retornados

TIMESTAMP

Exemplo

SELECT TIMESTAMP_MICROS(1230219000000000) as timestamp;

+------------------------+
| timestamp              |
+------------------------+
| 2008-12-25 15:30:00+00 |
+------------------------+

UNIX_SECONDS

UNIX_SECONDS(timestamp_expression)

Descrição

Retorna o número de segundos desde 01/01/1970 00:00:00 UTC. Trunca níveis mais elevados de precisão.

Tipos de dados retornados

INT64

Exemplo

SELECT UNIX_SECONDS(TIMESTAMP "2008-12-25 15:30:00 UTC") as seconds;

+------------+
| seconds    |
+------------+
| 1230219000 |
+------------+

UNIX_MILLIS

UNIX_MILLIS(timestamp_expression)

Descrição

Retorna o número de milissegundos desde 1970-01-01 00:00:00 UTC. Trunca níveis maiores de precisão.

Tipos de dados retornados

INT64

Exemplo

SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00 UTC") as millis;

+---------------+
| millis        |
+---------------+
| 1230219000000 |
+---------------+

UNIX_MICROS

UNIX_MICROS(timestamp_expression)

Descrição

Retorna o número de milissegundos desde 1970-01-01 00:00:00 UTC. Trunca níveis maiores de precisão.

Tipos de dados retornados

INT64

Exemplo

SELECT UNIX_MICROS(TIMESTAMP "2008-12-25 15:30:00 UTC") as micros;

+------------------+
| micros           |
+------------------+
| 1230219000000000 |
+------------------+

Elementos de formatos compatíveis de TIMESTAMP

Salvo indicação em contrário, as funções TIMESTAMP que usam strings de formato aceitam os elementos a seguir:

Elemento de formato Descrição
%A O nome completo do dia da semana.
%a O nome abreviado do dia da semana.
%B O nome completo do mês.
%b ou %h O nome abreviado do mês.
%C O século (um ano dividido por 100 e truncado para um inteiro) como um número decimal (00-99).
%c A representação de data e hora no formato %a %b %e %T %Y.
%D A data no formato %m/%d/%y.
%d O dia do mês como número decimal (01-31).
%e O dia do mês como número decimal (1-31). Dígitos únicos são precedidos por um espaço.
%F A data no formato %Y-%m-%d.
%G O ano ISO 8601 com o século como número decimal. Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %G e %Y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%g O ano ISO 8601 com o século como número decimal. Cada ano ISO começa na segunda-feira antes da primeira quinta-feira do ano calendário gregoriano. Observe que %g e %y podem produzir resultados diferentes próximos aos limites do ano gregoriano, em que o ano gregoriano e o ano ISO podem divergir.
%H A hora em um relógio de 24 horas como número decimal (00-23).
%I A hora em um relógio de 12 horas como número decimal (01-12).
%j O dia do ano como número decimal (001-366).
%k A hora em um relógio de 24 horas como número decimal (0-23). Dígitos únicos são precedidos por um espaço.
%l A hora em um relógio de 12 horas como número decimal (1-12). Dígitos únicos são precedidos por um espaço.
%M O minuto como número decimal (00-59).
%m O mês como número decimal (01-12).
%n Um caractere de nova linha.
%P am ou pm.
%p AM ou PM.
%Q O trimestre como um número decimal (de 1–4).
%R A hora no formato %H:%M.
%r A hora em um relógio de 12 horas usando a notação AM/PM.
%S O segundo como número decimal (00-60).
%s O número de segundos desde 1970-01-01 00:00:00 UTC. Sempre modifica todos os outros elementos de formato, seja qual for o local onde %s aparece na string. Se vários elementos %s aparecerem, o último terá precedência.
%T A hora no formato %H:%M:%S.
%t Um caractere de tabulação.
%U O número da semana do ano (domingo como o primeiro dia da semana) como número decimal (00-53).
%u O dia da semana (segunda-feira como o primeiro dia da semana) como número decimal (1-7).
%V O número da semana ISO 8601 do ano (segunda-feira como o primeiro dia da semana) como um número decimal (01–53). Se a semana que tem 1 de janeiro tiver quatro ou mais dias no ano novo, então será a semana 1. Caso contrário, será a semana 53 do ano anterior e a semana seguinte será a semana 1.
%W O número da semana do ano (segunda-feira como o primeiro dia da semana) como número decimal (00-53).
%w O dia da semana (domingo como o primeiro dia da semana) como número decimal (0-6).
%X A representação da hora no formato HH:MM:SS.
%x A representação de data no formato MM/DD/YY.
%Y O ano com o século como número decimal.
%y O ano sem o século como número decimal (00-99), com um zero opcional à esquerda. Pode ser misturado com %C. Se %C não for especificado, os anos 00-68 são os 2000, enquanto os anos 69-99 são os 1900.
%Z O nome do fuso horário.
%z O deslocamento do meridiano de origem no formato +HHMM ou -HHMM conforme o caso, com valores positivos representando locais a leste de Greenwich.
%% Um único caractere %.
%Ez Fuso horário numérico compatível com RFC 3339 (+HH:MM ou -HH:MM).
%E#S Segundos com # dígitos de precisão fracionária.
%E*S Segundos com precisão fracionária total (um literal '*').
%E4Y Anos com quatro caracteres (0001 ... 9999). %Y produz quantos caracteres forem necessários para processar o ano totalmente.

Definições de fuso horário

Determinadas funções de data e carimbo de data/hora permitem substituir o fuso horário padrão e especificar um diferente. É possível especificar um fuso horário por meio do nome do fuso horário (por exemplo, America/Los_Angeles) ou pelo deslocamento de fuso horário de UTC (por exemplo, -08).

Se você escolher usar um ajuste de fuso horário, use este formato:

(+|-)H[H][:M[M]]

Os carimbos data/hora são equivalentes porque o deslocamento do fuso horário para America/Los_Angeles é -08 para a data e a hora especificadas.

SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00 America/Los_Angeles") as millis;
SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00-08:00") as millis;

Funções geográficas

As funções geográficas operam em valores de GEOGRAPHY BigQuery ou os geram. A assinatura de qualquer função geográfica começa com ST_. O BigQuery aceita as funções a seguir que podem ser usadas para analisar dados geográficos, determinar relações espaciais entre características geográficas e criar ou manipular GEOGRAPHYs.

As funções geográficas são agrupadas nas categorias a seguir com base no comportamento delas:

  • Construtores: funções que criam novos valores GEOGRAPHY de coordenadas ou GEOGRAPHYs existentes, como ST_GEOGPOINT.
  • Analisadores: funções que criam GEOGRAPHYs a partir de um formato externo como WKT e GeoJSON. Por exemplo: ST_GEOGFROMTEXT, cria um GEOGRAPHY de WKT.
  • Formatadores: funções que exportam GEOGRAPHYs para um formato externo, como WKT e GeoJSON. Por exemplo: ST_ASTEXT formata um GEOGRAPHY para WKT.
  • Transformações: funções que geram um novo GEOGRAPHY de outros que aderem a alguma propriedade. Os exemplos incluem ST_INTERSECTION e ST_BOUNDARY.
  • Predicados: funções que retornam TRUE ou FALSE para uma relação espacial entre dois GEOGRAPHYs ou para alguma propriedade de uma região geográfica. Essas funções são muito usadas em cláusulas de filtro. Por exemplo: ST_DWITHIN é um predicado.
  • Acessadores: funções que concedem acesso a propriedades de um GEOGRAPHY sem efeitos colaterais, como ST_NUMPOINTS.
  • Medidas: funções que calculam as medidas de um ou mais GEOGRAPHY, por exemplo ST_DISTANCE.
  • Funções agregadas: funções de agregação específicas de geografia, como ST_UNION_AGG.

Todas as funções geográficas do BigQuery retornam NULL se algum argumento de entrada é .

ST_GEOGPOINT

ST_GEOGPOINT(longitude, latitude)

Descrição

Cria um GEOGRAPHY com um único ponto. ST_GEOGPOINT cria um ponto com base nos parâmetros de longitude e latitude FLOAT64 especificados e retorna esse ponto em um valor de GEOGRAPHY.

Restrições

  • As latitudes precisam estar no intervalo [-90, 90]. Latitudes fora desse intervalo resultarão em um erro.
  • Longitudes fora do intervalo [-180, 180] são permitidas. ST_GEOGPOINT usa o módulo de longitude de entrada 360 para conseguir uma longitude dentro de [-180, 180].

Tipo de retorno

GEOGRAPHY

ST_MAKELINE

ST_MAKELINE(geography_1, geography_2)
ST_MAKELINE(array_of_geography)

Descrição

Cria um GEOGRAPHY com uma cadeia de linhas única, concatenando os vértices de ponto ou linha de cada de entrada na ordem em que são inseridos.

ST_MAKELINE vem em duas variantes. Para a primeira variante, a entrada precisa ser duas GEOGRAPHYs. Para o segundo, a entrada precisa ser um ARRAY do tipo GEOGRAPHY. Em cada variante, cada entrada GEOGRAPHY precisa consistir em um dos seguintes valores:

  • Exatamente um ponto
  • Exatamente uma cadeia de linhas

Para a primeira variante de ST_MAKELINE, se uma das entradas GEOGRAPHY é NULL, retorna NULL. Para a segunda variante, se a entrada ARRAY ou qualquer elemento na entrada ARRAY é NULL, retorna NULL.

Restrições

Cada aresta precisa abranger estritamente menos de 180 graus.

OBSERVAÇÃO: o processo de ajuste do BigQuery pode descartar arestas suficientemente curtas e ajustar os dois endpoints juntos. Por exemplo, se cada GEOGRAPHY de entrada contiver um ponto e os dois pontos estiverem separados por uma distância menor que o raio de ajuste, os pontos serão ajustados juntos. Nesse caso, o resultado será um GEOGRAPHY com exatamente um ponto.

Tipo de retorno

GEOGRAPHY

ST_MAKEPOLYGON

ST_MAKEPOLYGON(geography_expression)
ST_MAKEPOLYGON(geography_expression, array_of_geography)

Descrição

Cria um GEOGRAPHY que contém um único polígono de entradas de cadeia de linhas, em que cada cadeia é usada para construir um anel poligonal.

ST_MAKEPOLYGON vem em duas variantes. Para a primeira variante, a entrada da cadeia de linhas é fornecida por um único GEOGRAPHY contendo exatamente uma cadeia de linhas. Para a segunda variante, a entrada consiste em um único GEOGRAPHY e uma matriz de GEOGRAPHYs, cada um contendo exatamente uma cadeia de linhas. O primeiro GEOGRAPHY em qualquer uma das variantes é usado para construir a concha poligonal. GEOGRAPHYs adicionais fornecidos na entrada ARRAY especificam um buraco poligonal. Para cada GEOGRAPHY de entrada contendo exatamente uma cadeia de linha, os itens a seguir precisam ser verdadeiros:

  • A cadeia de linhas precisa consistir em pelo menos três vértices distintos.
  • A cadeia de linhas precisa ser fechada, ou seja, o primeiro e o último vértices precisam ser os mesmos. Se o primeiro e o último vértices forem diferentes, a função criará uma aresta final do primeiro vértice ao último.

Para a primeira variante de ST_MAKEPOLYGON, se uma das entradas GEOGRAPHY for NULL, retorna NULL. Para a segunda variante, se a entrada ARRAY ou qualquer elemento na ARRAY for NULL, retorna NULL.

OBSERVAÇÃO: ST_MAKEPOLYGON aceita um GEOGRAPHY vazio como entrada. ST_MAKEPOLYGON interpreta um GEOGRAPHY vazio como tendo uma cadeia de linhas vazia, o que criará um ciclo completo, ou seja, um polígono que abrange toda a Terra.

Restrições

Juntos, os anéis de entrada precisam formar um polígono válido:

  • A concha poligonal precisa cobrir cada um dos buracos poligonais.
  • Só pode haver uma concha poligonal (que precisa ser o primeiro anel de entrada). Isso significa que os buracos poligonais não podem ser aninhados.
  • Anéis poligonais só podem se cruzar em um vértice no limite de ambos os anéis.

Cada aresta precisa abranger estritamente menos de 180 graus.

Cada anel poligonal divide a esfera em duas regiões. A primeira cadeia de linhas de entrada para ST_MAKEPOLYGON forma a concha poligonal, e a parte interna é escolhida para ser a menor das duas regiões. Cada cadeia de linhas de entrada subsequente especifica um buraco poligonal, portanto, o interior do polígono já está bem definido. Para definir uma concha poligonal de maneira que o interior do polígono seja a maior das duas regiões, consulte ST_MAKEPOLYGONORIENTED.

OBSERVAÇÃO: o processo de ajuste do BigQuery pode descartar arestas suficientemente curtas e ajustar os dois endpoints juntos. Portanto, quando os vértices são ajustados juntos, é possível que um buraco poligonal que seja suficientemente pequeno possa desaparecer ou que o GEOGRAPHY de saída possa conter apenas uma linha ou um ponto.

Tipo de retorno

GEOGRAPHY

ST_MAKEPOLYGONORIENTED

ST_MAKEPOLYGONORIENTED(array_of_geography)

Descrição

Similar a ST_MAKEPOLYGON, mas a ordem dos vértices de cada cadeia de linhas de entrada determina a orientação de cada anel poligonal. A orientação de um anel poligonal define o interior do polígono da seguinte maneira: se alguém caminha ao longo do limite do polígono na ordem dos vértices de entrada, o interior do polígono fica à esquerda. Isso se aplica a todos os anéis poligonais fornecidos.

Essa variante do construtor de polígonos é mais flexível, porque ST_MAKEPOLYGONORIENTED pode criar um polígono de maneira que o interior fique em cada lado do anel poligonal. No entanto, a orientação adequada dos anéis poligonais é fundamental para a criação do polígono desejado.

Se a entrada ARRAY ou qualquer elemento em for NULL, ST_MAKEPOLYGONORIENTED retornará NULL.

OBSERVAÇÃO: o argumento de entrada de ST_MAKEPOLYGONORIENTED pode conter um GEOGRAPHY vazio. interpreta um GEOGRAPHY vazio como tendo uma cadeia de linhas vazia, o que criará um ciclo completo, ou seja, um polígono que abrange toda a Terra.

Restrições

Juntos, os anéis de entrada precisam formar um polígono válido:

  • A concha poligonal precisa cobrir cada um dos buracos poligonais.
  • Só pode haver uma concha poligonal, que precisa ser o primeiro anel de entrada. Isso significa que os buracos poligonais não podem ser aninhados.
  • Anéis poligonais só podem se cruzar em um vértice no limite de ambos os anéis.

Cada aresta precisa abranger estritamente menos de 180 graus.

ST_MAKEPOLYGONORIENTED depende da ordenação dos vértices de entrada de cada cadeia de linhas para determinar a orientação do polígono. Isso se aplica à concha poligonal e a qualquer buraco poligonal. ST_MAKEPOLYGONORIENTED espera que todos os buracos poligonais tenham a orientação oposta da concha. Consulte ST_MAKEPOLYGON para um construtor de polígono alternativo e outras restrições na construção de um polígono válido.

OBSERVAÇÃO: por causa do processo de ajuste do BigQuery, as arestas com comprimento suficientemente curto serão descartadas e os dois endpoints serão ajustados em um único ponto. Portanto, é possível que os vértices em uma cadeia de linhas sejam ajustados de modo que uma ou mais arestas desapareçam. Assim, é possível que um buraco poligonal que seja suficientemente pequeno possa desaparecer ou que o GEOGRAPHY resultante possa conter apenas uma linha ou um ponto.

Tipo de retorno

GEOGRAPHY

ST_GEOGFROMGEOJSON

ST_GEOGFROMGEOJSON(geojson_string)

Descrição

Retorna um valor GEOGRAPHY que corresponde à representação GeoJSON de entrada.

ST_GEOGFROMGEOJSON aceita entrada em conformidade com o RFC 7946.

Um BigQuery GEOGRAPHY tem bordas geodésicas esféricas, enquanto um objeto GeoJSON Geometry explicitamente tem bordas planas. Para fazer uma conversão entre esses dois tipos de arestas, o BigQuery adiciona pontos à linha conforme necessário, de modo que a sequência de arestas permaneça no máximo a dez metros da aresta original.

Consulte ST_ASGEOJSON para formatar um GEOGRAPHY como GeoJSON.

Restrições

A entrada está sujeita às restrições a seguir:

  • ST_GEOGFROMGEOJSON aceita somente fragmentos de geometria JSON e não pode ser usado para processar um documento JSON inteiro.
  • O fragmento JSON de entrada precisa consistir de um tipo de geometria GeoJSON, que inclui Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon e GeometryCollection. Qualquer outro tipo de GeoJSON, como Feature ou FeatureCollection, resultará em um erro.
  • Uma posição no membro coordinates de um tipo de geometria GeoJSON precisa consistir em exatamente dois elementos. O primeiro é longitude e o segundo é latitude. Portanto, ST_GEOGFROMGEOJSON não suporta o terceiro elemento opcional para uma posição no membro coordinates.

Tipo de retorno

GEOGRAPHY

ST_GEOGFROMTEXT

ST_GEOGFROMTEXT(wkt_string)
ST_GEOGFROMTEXT(wkt_string, oriented)

Descrição

Retorna um valor GEOGRAPHY que corresponde à representação WKT de entrada.

Esta função suporta um parâmetro opcional do tipo BOOL, oriented. Se esse parâmetro for definido como TRUE, todos os polígonos na entrada serão orientados da seguinte maneira: se alguém caminhar ao longo do limite do polígono na ordem dos vértices de entrada, o interior do polígono estará à esquerda. Isso permite que WKT represente polígonos maiores que um hemisfério. Se oriented for FALSE ou omitido, essa função retornará o polígono com a área menor. Consulte também ST_MAKEPOLYGONORIENTED, que é semelhante a ST_GEOGFROMTEXT com oriented=TRUE.

Para formatar GEOGRAPHY como WKT, use ST_ASTEXT.

Restrições

Todas as arestas de entrada são consideradas geodésicas esféricas e não linhas retas planas. Para ler dados em uma projeção plana, considere usar ST_GEOGFROMGEOJSON. Para mais informações sobre as diferenças entre geodésicas esféricas e linhas planas, consulte Limites e sistemas coordenados.

Tipo de retorno

GEOGRAPHY

Exemplo

A consulta a seguir lê a string WKT POLYGON((0 0, 0 2, 2 2, 0 2, 0 0)) como um polígono não orientado e como um polígono orientado e verifica se cada resultado contém o ponto (1, 1).

WITH polygon AS (SELECT 'Polygon((0 0, 0 2, 2 2, 2 0, 0 0))' AS p)
SELECT
  ST_CONTAINS(ST_GEOGFROMTEXT(p), ST_GEOGPOINT(1, 1)) AS fromtext_default,
  ST_CONTAINS(ST_GEOGFROMTEXT(p, FALSE), ST_GEOGPOINT(1, 1)) AS non_oriented,
  ST_CONTAINS(ST_GEOGFROMTEXT(p, TRUE),  ST_GEOGPOINT(1, 1)) AS oriented
FROM polygon;

+-------------------+---------------+-----------+
| fromtext_default  | non_oriented  | oriented  |
+-------------------+---------------+-----------+
| true              | true          | false     |
+-------------------+---------------+-----------+

ST_GEOGFROMWKB

ST_GEOGFROMWKB(wkb_bytes)

Descrição

Retorna um valor GEOGRAPHY que corresponde à representação WKB de entrada.

Para formatar GEOGRAPHY como WKB, use ST_ASBINARY.

Restrições

Todas as arestas de entrada são consideradas geodésicas esféricas e não linhas retas planas. Para ler dados em uma projeção plana, considere usar ST_GEOGFROMGEOJSON.

Tipo de retorno

GEOGRAPHY

ST_GEOGPOINTFROMGEOHASH

ST_STGEOGPOINTFROMGEOHASH(geohash)

Descrição

Retorna um valor GEOGRAPHY que corresponde a um ponto no meio de uma caixa delimitadora definida no GeoHash.

Tipo de retorno

GEOGRAPHY

ST_ASGEOJSON

ST_ASGEOJSON(geography_expression)

Descrição

Retorna a representação GeoJSON em conformidade com RFC 7946 do GEOGRAPHY de entrada.

Um BigQuery GEOGRAPHY tem bordas geodésicas esféricas, enquanto um objeto GeoJSON Geometry explicitamente tem bordas planas. Para fazer uma conversão entre esses dois tipos de arestas, o BigQuery adiciona pontos à linha conforme necessário, de modo que a sequência de arestas permaneça no máximo a dez metros da aresta original.

Consulte ST_GEOGFROMGEOJSON para construir um GEOGRAPHY a partir de GeoJSON.

Tipo de retorno

STRING

ST_ASTEXT

ST_ASTEXT(geography_expression)

Descrição

Retorna a representação WKT de uma entrada GEOGRAPHY.

Consulte ST_GEOGFROMTEXT para construir um GEOGRAPHY a partir de WKT.

Tipo de retorno

STRING

ST_GEOHASH

ST_GEOHASH(geography_expression, maxchars)

Descrição

Retorna uma representação GeoHash de geography_expression. O GeoHash resultante conterá no máximo maxchars caracteres. Menos caracteres correspondem a uma precisão menor (ou, descrito de maneira diferente, a uma faixa delimitadora maior).

ST_GeoHash em um objeto GEOGRAPHY vazio retorna NULL.

Restrições

  • Apenas objetos GEOGRAPHY que representam pontos únicos são aceitos.
  • O valor máximo de maxchars é 20.

Exemplo

Retorna um GeoHash do Seattle Center com dez caracteres de precisão.

SELECT ST_GEOHASH(ST_GEOGPOINT(-122.35, 47.62), 10) geohash

+--------------+
| geohash      |
+--------------+
| c22yzugqw7   |
+--------------+

Tipo de retorno

STRING

ST_ASBINARY

ST_ASBINARY(geography_expression)

Descrição

Retorna a representação WKB de uma entrada GEOGRAPHY.

Consulte ST_GEOGFROMWKB para construir um GEOGRAPHY a partir de WKB.

Tipo de retorno

BYTES

ST_BOUNDARY

ST_BOUNDARY(geography_expression)

Descrição

Retorna um único GEOGRAPHY que contém a união dos limites de cada componente no de entrada fornecido.

O limite de cada componente de um GEOGRAPHY é definido da seguinte maneira:

  • O limite de um ponto fica vazio.
  • O limite de uma cadeia de linhas consiste nos pontos de extremidade da cadeia de linhas.
  • O limite de um polígono consiste nas cadeias de linhas que formam a concha poligonal e em cada um dos buracos poligonais.

Tipo de retorno

GEOGRAPHY

ST_CENTROID

ST_CENTROID(geography_expression)

Descrição

Retorna o centroide da entrada GEOGRAPHY como um ponto GEOGRAPHY único.

O centroide de um GEOGRAPHY é a média ponderada dos centroides dos componentes de maior dimensão do GEOGRAPHY. O centroide para componentes em cada dimensão é definido da seguinte maneira:

  • O centroide de pontos é a média aritmética das coordenadas de entrada.
  • O centroide das cadeias de linhas é o centroide de todas as arestas ponderadas pelo comprimento. O centroide de cada aresta é o ponto médio geodésico da aresta.
  • O centroide de um polígono é o centro de massa dele.

Se o GEOGRAPHY de entrada estiver vazio, um vazio será retornado.

Restrições

No caso improvável de o centroide de um GEOGRAPHY não poder ser definido por um único ponto na superfície da Terra, um ponto determinístico arbitrário será retornado. Isso só pode acontecer se o centroide estiver exatamente no centro da Terra, como o centroide de um par de pontos antipodais, e a probabilidade de isso acontecer é muito pequena.

Tipo de retorno

GEOGRAPHY

ST_CLOSESTPOINT

ST_CLOSESTPOINT(geography_1, geography_2)
ST_CLOSESTPOINT(geography_1, geography_2, use_spheroid)

Descrição

Retorna um GEOGRAPHY contendo um ponto em geography_1 com a menor distância possível para geography_2. Isso significa que a distância entre o ponto retornado por ST_CLOSESTPOINT e geography_2 é menor ou igual à distância entre qualquer outro ponto em geography_1 e geography_2.

Se qualquer um dos GEOGRAPHYs de entrada estiver vazio, ST_CLOSESTPOINT retornará NULL.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

GEOGRAPHY

ST_DIFFERENCE

ST_DIFFERENCE(geography_1, geography_2)

Descrição

Retorna um GEOGRAPHY que representa a diferença do conjunto de pontos de geography_1 e geography_2.

Se geometry_1 for completamente contido em geometry_2, então ST_DIFFERENCE retornará um GEOGRAPHY vazio.

Restrições

Os objetos geométricos subjacentes representados por um GEOGRAPHY do BigQuery correspondem a um conjunto de pontos fechados. Portanto, ST_DIFFERENCE é a interdição da diferença do conjunto de pontos de geography_1 e geography_2. Isso significa que se geography_1 e geography_2 se cruzam, uma parte do limite de geography_2 pode estar na diferença.

Tipo de retorno

GEOGRAPHY

ST_INTERSECTION

ST_INTERSECTION(geography_1, geography_2)

Descrição

Retorna um GEOGRAPHY que representa a interseção do conjunto de pontos dos dois s de entrada. Assim, cada ponto na interseção aparece em geography_1 e geography_2.

Se os dois GEOGRAPHYs são separados, isto é, não há pontos que apareçam na entrada geometry_1 e geometry_2, um espaço em branco é retornado.

Consulte ST_INTERSECTS, ST_DISJOINT para funções de predicado relacionadas.

Tipo de retorno

GEOGRAPHY

ST_SNAPTOGRID

ST_SNAPTOGRID(geography_expression, grid_size)

Descrição

Retorna o GEOGRAPHY de entrada, em que cada vértice foi alinhada a uma grade de longitude/latitude. O tamanho da grade é determinado pelo parâmetro grid_size, que é fornecido em graus.

Restrições

Tamanhos de grade arbitrários não são aceitos. O parâmetro grid_size é arredondado para que fique no formato \(10^n \), em que \(- 10 <n <0 \).

Tipo de retorno

GEOGRAPHY

ST_UNION

ST_UNION(geography_1, geography_2)
ST_UNION(array_of_geography)

Descrição

Retorna um GEOGRAPHY que representa a união do conjunto de pontos de todos os s de entrada.

ST_UNION vem em duas variantes. Para a primeira variante, a entrada precisa ser duas GEOGRAPHYs. Para a segunda, a entrada é um ARRAY do tipo GEOGRAPHY.

Para a primeira variante de ST_UNION, se uma entrada GEOGRAPHY for NULL, retorna NULL. Para a segunda variante, se o valor da entrada ARRAY é NULL, retorna NULL. Para uma entrada ARRAY que não seja NULL, a união é calculada e elementos NULL são ignorados para que não afetem a saída.

Consulte ST_UNION_AGG para a versão agregada de ST_UNION.

Tipo de retorno

GEOGRAPHY

ST_X

ST_X(geography_expression)

Descrição

Retorna a longitude em graus do GEOGRAPHY de entrada de ponto único.

Para qualquer entrada GEOGRAPHY que não seja de ponto único, incluindo um vazio, ST_X retornará um erro. Use o prefixo SAFE. para receber NULL.

Tipo de retorno

FLOAT64

Exemplo

O exemplo a seguir usa ST_X e ST_Y para extrair coordenadas de geografias de ponto único.

WITH points AS
   (SELECT ST_GEOGPOINT(i, i + 1) AS p FROM UNNEST([0, 5, 12]) AS i)
 SELECT
   p,
   ST_X(p) as longitude,
   ST_Y(p) as latitude
FROM points;

+--------------+-----------+----------+
| p            | longitude | latitude |
+--------------+-----------+----------+
| POINT(0 1)   | 0.0       | 1.0      |
| POINT(5 6)   | 5.0       | 6.0      |
| POINT(12 13) | 12.0      | 13.0     |
+--------------+-----------+----------+

ST_Y

ST_Y(geography_expression)

Descrição

Retorna a latitude em graus da entrada GEOGRAPHY de ponto único.

Para qualquer entrada GEOGRAPHY que não seja de ponto único, incluindo um vazio, ST_Y retornará um erro. Use o prefixo SAFE. para retornar NULL em vez disso.

Tipo de retorno

FLOAT64

Exemplo

Consulte ST_X para exemplos de uso.

ST_CONTAINS

ST_CONTAINS(geography_1, geography_2)

Descrição

Retorna TRUE se nenhum ponto de geography_2 está fora de geography_1, e os interiores se cruzam; retorna FALSE caso contrário.

OBSERVAÇÃO: um GEOGRAPHY não contém seu próprio limite. Compare com ST_COVERS.

Tipo de retorno

BOOL

Exemplo

A consulta a seguir testa se o polígono POLYGON((1 1, 20 1, 10 20, 1 1)) contém cada um dos três pontos (0, 0), (1, 1) e (10, 10), que estão no exterior, no limite e no interior do polígono, respectivamente.

SELECT
  ST_GEOGPOINT(i, i) AS p,
  ST_CONTAINS(ST_GEOGFROMTEXT('POLYGON((1 1, 20 1, 10 20, 1 1))'),
              ST_GEOGPOINT(i, i)) AS `contains`
FROM UNNEST([0, 1, 10]) AS i;

+--------------+----------+
| p            | contains |
+--------------+----------+
| POINT(0 0)   | false    |
| POINT(1 1)   | false    |
| POINT(10 10) | true     |
+--------------+----------+

ST_COVEREDBY

ST_COVEREDBY(geography_1, geography_2)

Descrição

Retorna FALSE se geography_1 ou geography_2 estiver vazio. Retorna TRUE se nenhum ponto de geography_1 estiver na parte externa de geography_2.

Dado dois GEOGRAPHYs a e b, ST_COVEREDBY(a, b) retorna o mesmo resultado que ST_COVERS(b, a). Observe a ordem oposta dos argumentos.

Tipo de retorno

BOOL

ST_COVERS

ST_COVERS(geography_1, geography_2)

Descrição

Retorna FALSE se geography_1 ou geography_2 estiver vazio. Retorna TRUE se nenhum ponto de geography_2 estiver na parte externa de geography_1.

Tipo de retorno

BOOL

Exemplo

A consulta a seguir testa se o polígono POLYGON((1 1, 20 1, 10 20, 1 1)) abrange cada um dos três pontos (0, 0), (1, 1) e (10, 10), que ficam no exterior, no limite e no interior do polígono, respectivamente.

SELECT
  ST_GEOGPOINT(i, i) AS p,
  ST_COVERS(ST_GEOGFROMTEXT('POLYGON((1 1, 20 1, 10 20, 1 1))'),
            ST_GEOGPOINT(i, i)) AS `covers`
FROM UNNEST([0, 1, 10]) AS i;

+--------------+--------+
| p            | covers |
+--------------+--------+
| POINT(0 0)   | false  |
| POINT(1 1)   | true   |
| POINT(10 10) | true   |
+--------------+--------+

ST_DISJOINT

ST_DISJOINT(geography_1, geography_2)

Descrição

Retorna TRUE se o cruzamento de geography_1 e geography_2 estiver vazio, ou seja, nenhum ponto em geography_1 também aparece em geography_2.

ST_DISJOINT é a negação lógica de ST_INTERSECTS.

Tipo de retorno

GEOGRAPHY

ST_DWITHIN

ST_DWITHIN(geography_1, geography_2, distance)
ST_DWITHIN(geography_1, geography_2, distance, use_spheroid)

Descrição

Retorna TRUE se a distância entre pelo menos um ponto geography_1 e um ponto em geography_2 é menor ou igual à distância fornecida pelo argumento distance; caso contrário, retorna FALSE. Se a entrada GEOGRAPHY estiver vazia, ST_DWithin retornará FALSE. O distance especificado está em metros na superfície da Terra.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

BOOL

ST_EQUALS

ST_EQUALS(geography_1, geography_2)

Descrição

Retorna TRUE se geography_1 e geography_2 representarem o mesmo valor que GEOGRAPHY. Mais precisamente, isso significa que uma das condições a seguir é válida:

  • ST_COVERS(geography_1, geography_2) = TRUE e ST_COVERS(geography_2, geography_1) = TRUE
  • Ambos geography_1 e geography_2 estão vazios.

Portanto, dois GEOGRAPHYs poderão ser iguais, mesmo se a ordenação de pontos ou vértices for diferente, desde que eles ainda representem a mesma estrutura geométrica.

Restrições

Não é garantido que ST_EQUALS seja uma função transitiva.

Tipo de retorno

BOOL

ST_INTERSECTS

ST_INTERSECTS(geography_1, geography_2)

Descrição

Retorna TRUE se o cruzamento de ponto de geography_1 e geography_2 não estiver vazio. Assim, esta função retornará TRUE se houver pelo menos um ponto que apareça nos dois GEOGRAPHYs de entrada.

Se ST_INTERSECTS retorna TRUE, isso significa que ST_DISJOINT retorna FALSE.

Tipo de retorno

BOOL

ST_INTERSECTSBOX

ST_INTERSECTSBOX(geography, lng1, lat1, lng2, lat2)

Descrição

Retorna TRUE se geography cruzar o retângulo entre [lng1, lng2] e [lat1, lat2]. As bordas do retângulo seguem linhas constantes de longitude e latitude. lng1 e lng2 especificam as linhas de longitude mínima e máxima que delimitam o retângulo, e lat1 e lat2 especificam as linhas de latitude constantes mínima e máxima que ligam o retângulo.

Especifique todos os argumentos de longitude e latitude em graus.

Restrições

Os argumentos de entrada estão sujeitos às restrições a seguir:

  • As latitudes precisam estar no intervalo de [-90, 90] graus.
  • As longitudes precisam estar no intervalo de [-180, 180] graus.

Tipo de retorno

BOOL

ST_TOUCHES

ST_TOUCHES(geography_1, geography_2)

Descrição

Retornará TRUE desde que as duas condições a seguir sejam satisfeitas:

  1. geography_1 cruza geography_2.
  2. O interior de geography_1 e o interior de geography_2 são separados.

Tipo de retorno

BOOL

ST_WITHIN

ST_WITHIN(geography_1, geography_2)

Descrição

Retorna TRUE se nenhum ponto de geography_1 está fora de geography_2 e os interiores de geography_1 e geography_2 se cruzam.

Dados dois locais geográficos a e b, ST_WITHIN(a, b) retorna o mesmo resultado de ST_CONTAINS(b, a). Observe a ordem oposta dos argumentos.

Tipo de retorno

BOOL

ST_ISEMPTY

ST_ISEMPTY(geography_expression)

Descrição

Retornará TRUE se o GEOGRAPHY inserido estiver vazio, ou seja, o GEOGRAPHY não contiver pontos, linhas ou polígonos.

OBSERVAÇÃO: um GEOGRAPHY do BigQuery vazio não está associado a uma forma geométrica específica. Por exemplo, os resultados das expressões ST_GEOGFROMTEXT('POINT EMPTY') e ST_GEOGFROMTEXT('GEOMETRYCOLLECTION EMPTY') são idênticos.

Tipo de retorno

BOOL

ST_ISCOLLECTION

ST_ISCOLLECTION(geography_expression)

Descrição

Retornará TRUE se o número total de pontos, cadeias de linhas e polígonos for maior que um.

Um GEOGRAPHY vazio não é uma coleção.

Tipo de retorno

BOOL

ST_DIMENSION

ST_DIMENSION(geography_expression)

Descrição

Retorna a dimensão do elemento de maior dimensão no GEOGRAPHY de entrada.

A dimensão de cada elemento possível é a seguinte:

  • A dimensão de um ponto é 0.
  • A dimensão de uma cadeia de linhas é 1.
  • A dimensão de um polígono é 2.

Se a entrada GEOGRAPHY estiver vazia, ST_DIMENSION retornará -1.

Tipo de retorno

INT64

ST_NUMPOINTS

ST_NUMPOINTS(geography_expression)

Descrição

Retornará o número de vértices no GEOGRAPHY de entrada. Isso inclui o número de pontos, de vértices da cadeia de linhas e de vértices do polígono.

OBSERVAÇÃO: o primeiro e o último vértices de um anel poligonal são contados como vértices distintos.

Tipo de retorno

INT64

ST_AREA

ST_AREA(geography_expression)
ST_AREA(geography_expression, use_spheroid)

Descrição

Retorna a área em metros quadrados coberta pelos polígonos no GEOGRAPHY de entrada.

Se geography_expression for um ponto ou uma linha, retornará zero. Se geography_expression for uma coleção, retorna a área dos polígonos nela; se a coleção não contiver polígonos, retornará zero.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

FLOAT64

ST_DISTANCE

ST_DISTANCE(geography_1, geography_2)
ST_DISTANCE(geography_1, geography_2, use_spheroid)

Descrição

Retorna a menor distância em metros entre dois GEOGRAPHYs não vazios.

Se qualquer um dos GEOGRAPHYs de entrada estiver vazio, ST_DISTANCE retornará NULL.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

FLOAT64

ST_LENGTH

ST_LENGTH(geography_expression)
ST_LENGTH(geography_expression, use_spheroid)

Descrição

Retorna o comprimento total em metros das linhas no GEOGRAPHY de entrada.

Se geography_expression for um ponto ou um polígono, retornará zero. Se geography_expression for uma coleção, retorna o tamanho das linhas nela; se a coleção não contém linhas, retorna zero.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

FLOAT64

ST_MAXDISTANCE

ST_MAXDISTANCE(geography_1, geography_2)
ST_MAXDISTANCE(geography_1, geography_2, use_spheroid)

Retorna a maior distância em metros entre dois GEOGRAPHYs não vazios, ou seja, a distância entre dois vértices em que o primeiro está no primeiro e o segundo está no segundo . Se geography_1 e geography_2 forem o mesmo , a função retornará a distância entre os dois vértices mais distantes naquele .

Se qualquer um dos GEOGRAPHYs de entrada estiver vazio, ST_MAXDISTANCE retornará NULL.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

FLOAT64

ST_PERIMETER

ST_PERIMETER(geography_expression)
ST_PERIMETER(geography_expression, use_spheroid)

Descrição

Retorna o comprimento em metros do limite dos polígonos no GEOGRAPHY de entrada.

Se geography_expression for um ponto ou uma linha, retornará zero. Se geography_expression for uma coleção, retorna o perímetro dos polígonos nela; se a coleção não contiver polígonos, retornará zero.

O parâmetro use_spheroid opcional determina como esta função mede a distância. Se use_spheroid for FALSE, a função mede a distância na superfície de uma esfera perfeita.

No momento, o parâmetro use_spheroid suporta apenas o valor FALSE. O valor padrão de use_spheroid é FALSE.

Tipo de retorno

FLOAT64

ST_UNION_AGG

ST_UNION_AGG(geography)

Descrição

Retorna um GEOGRAPHY que representa a união do conjunto de pontos de todos os s de entrada.

ST_UNION_AGG ignora valores GEOGRAPHY de entrada NULL.

Consulte ST_UNION para a versão não agregada de ST_UNION_AGG.

Tipo de retorno

GEOGRAPHY

ST_CENTROID_AGG

ST_CENTROID_AGG(geography)

Descrição

Calcula o centroide do conjunto de GEOGRAPHYs de entrada como um de único ponto.

O centroide sobre o conjunto de entradas GEOGRAPHYs é a média ponderada do centroide de cada indivíduo GEOGRAPHY. Apenas os GEOGRAPHYs com a dimensão mais alta presente na entrada contribuem para o centroide de todo o conjunto. Por exemplo, se a entrada contiver GEOGRAPHYs com linhas e GEOGRAPHYs apenas com pontos, ST_CENTROID_AGG retornará a média ponderada dos GEOGRAPHYs com linhas, desde que eles tenham dimensão máxima. Neste exemplo, ST_CENTROID_AGG ignora GEOGRAPHYs apenas com pontos ao calcular o centroide agregado.

ST_CENTROID_AGG ignora valores GEOGRAPHY de entrada NULL.

Consulte ST_CENTROID para a versão não agregada de ST_CENTROID_AGG e a definição de centroide para um valor GEOGRAPHY individual.

Tipo de retorno

GEOGRAPHY

Exemplo

As consultas a seguir calculam o centroide agregado sobre um conjunto de valores de GEOGRAPHY. A entrada para a primeira consulta contém apenas pontos e, portanto, cada valor contribui para o centroide agregado. Observe também que ST_CENTROID_AGG não é equivalente a chamar ST_CENTROID no resultado de ST_UNION_AGG. As duplicatas são removidas pela união, ao contrário de ST_CENTROID_AGG. A entrada para a segunda consulta tem dimensões mistas, e apenas os valores com a maior dimensão no conjunto, as linhas, afetam o centroide agregado.

SELECT ST_CENTROID_AGG(points) AS st_centroid_agg,
ST_CENTROID(ST_UNION_AGG(points)) AS centroid_of_union
FROM UNNEST([ST_GEOGPOINT(1, 5),
             ST_GEOGPOINT(1, 2),
             ST_GEOGPOINT(1, -1),
             ST_GEOGPOINT(1, -1)]) points;

+---------------------------+-------------------+
| st_centroid_agg           | centroid_of_union |
+---------------------------+-------------------+
| POINT(1 1.24961422620969) | POINT(1 2)        |
+---------------------------+-------------------+

SELECT ST_CENTROID_AGG(points) AS st_centroid_agg
FROM UNNEST([ST_GEOGPOINT(50, 26),
             ST_GEOGPOINT(34, 33.3),
             ST_GEOGFROMTEXT('LINESTRING(0 -1, 0 1)')
             ST_GEOGFROMTEXT('LINESTRING(0 1, 0 3)')]) points;

+-----------------+
| st_centroid_agg |
+-----------------+
| POINT(0 1)      |
+-----------------+

Funções de segurança

O BigQuery é compatível com as seguintes funções de segurança:

SESSION_USER

SESSION_USER()

Descrição

Retorna o endereço de email do usuário que está executando a consulta.

Tipos de dados retornados

STRING

Exemplo

SELECT SESSION_USER() as user;

+----------------------+
| user                 |
+----------------------+
| jdoe@example.com     |
+----------------------+

Funções UUID

O BigQuery aceita as funções de identificador universalmente exclusivo (UUID, na sigla em inglês) a seguir.

GENERATE_UUID

GENERATE_UUID()

Descrição

Retorna um identificador universalmente aleatório exclusivo (UUID) como uma STRING. A STRING retornada consiste em 32 dígitos hexadecimais em cinco grupos separados por hifens no formato 8-4-4-4-12. Os dígitos hexadecimais representam 122 bits aleatórios e 6 bits fixos, em conformidade com a seção 4.4 da RFC 4122. A STRING retornada está em letras minúsculas.

Tipos de dados retornados

STRING

Exemplo

A consulta a seguir gera um UUID aleatório.

SELECT GENERATE_UUID() AS uuid;

A consulta acima gera um resultado como o abaixo:

+--------------------------------------+
| uuid                                 |
+--------------------------------------+
| 4192bff0-e1e0-43ce-a4db-912808c32493 |
+--------------------------------------+

Funções de rede

NET.IP_FROM_STRING

NET.IP_FROM_STRING(addr_str)

Descrição

Converte um endereço IPv4 ou IPv6 do formato de texto (STRING) para o formato binário (BYTES) na ordem de bytes da rede.

Esta função suporta os seguintes formatos para addr_str:

  • IPv4: formato "dotted-quad" (quádruplo com ponto). Por exemplo, 10.1.2.3.
  • IPv6: formato separado por dois-pontos. Por exemplo, 1234:5678:90ab:cdef:1234:5678:90ab:cdef. Para mais exemplos, consulte Arquitetura de endereçamento de IP versão 6 (em inglês).

Essa função não é compatível com a notação CIDR, como 10.1.2.3/32.

Se ela receber uma entrada NULL, retornará . Se a entrada for considerada inválida, ocorrerá um erro OUT_OF_RANGE.

Tipos de dados retornados

BYTES

Exemplo

SELECT
  addr_str, FORMAT("%T", NET.IP_FROM_STRING(addr_str)) AS ip_from_string
FROM UNNEST([
  '48.49.50.51',
  '::1',
  '3031:3233:3435:3637:3839:4041:4243:4445',
  '::ffff:192.0.2.128'
]) AS addr_str;
addr_str ip_from_string
48.49.50.51 b"0123"
::1 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"
3031:3233:3435:3637:3839:4041:4243:4445 b"0123456789@ABCDE"
::ffff:192.0.2.128 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80"

NET.SAFE_IP_FROM_STRING

NET.SAFE_IP_FROM_STRING(addr_str)

Descrição

Semelhante a NET.IP_FROM_STRING, mas retorna NULL em vez de gerar um erro se a entrada for inválida.

Tipos de dados retornados

BYTES

Exemplo

SELECT
  addr_str,
  FORMAT("%T", NET.SAFE_IP_FROM_STRING(addr_str)) AS safe_ip_from_string
FROM UNNEST([
  '48.49.50.51',
  '::1',
  '3031:3233:3435:3637:3839:4041:4243:4445',
  '::ffff:192.0.2.128',
  '48.49.50.51/32',
  '48.49.50',
  '::wxyz'
]) AS addr_str;
addr_str safe_ip_from_string
48.49.50.51 b"0123"
::1 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"
3031:3233:3435:3637:3839:4041:4243:4445 b"0123456789@ABCDE"
::ffff:192.0.2.128 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80"
48.49.50.51/32 NULL
48.49.50 NULL
::wxyz NULL

NET.IP_TO_STRING

NET.IP_TO_STRING(addr_bin)

Descrição Converte um endereço IPv4 ou IPv6 do formato binário (BYTES) na ordem de bytes da rede para o formato de texto (STRING).

Se a entrada for de 4 bytes, essa função retornará um endereço IPv4 como uma STRING. Se a entrada for de 16 bytes, ela retornará um endereço IPv6 como uma STRING.

Se receber uma entrada NULL, essa função retornará . Se a entrada tiver um comprimento diferente de 4 ou 16, ocorrerá um erro OUT_OF_RANGE.

Tipos de dados retornados

STRING

Exemplo

SELECT FORMAT("%T", x) AS addr_bin, NET.IP_TO_STRING(x) AS ip_to_string
FROM UNNEST([
  b"0123",
  b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01",
  b"0123456789@ABCDE",
  b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80"
]) AS x;
addr_bin ip_to_string
b"0123" 48.49.50.51
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" ::1
b"0123456789@ABCDE" 3031:3233:3435:3637:3839:4041:4243:4445
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xc0\x00\x02\x80" ::ffff:192.0.2.128

NET.IP_NET_MASK

NET.IP_NET_MASK(num_output_bytes, prefix_length)

Descrição

Retorna uma máscara de rede: uma sequência de bytes com comprimento igual a num_output_bytes, em que os primeiros prefix_length bits são definidos como um e os outros bits são definidos como zero. num_output_bytes e prefix_length são INT64. Esta função gera um erro se num_output_bytes não for 4 (para IPv4) ou 16 (para IPv6). Ele também gera um erro se prefix_length for negativo ou maior que 8 * num_output_bytes.

Tipos de dados retornados

BYTES

Exemplo

SELECT x, y, FORMAT("%T", NET.IP_NET_MASK(x, y)) AS ip_net_mask
FROM UNNEST([
  STRUCT(4 as x, 0 as y),
  (4, 20),
  (4, 32),
  (16, 0),
  (16, 1),
  (16, 128)
]);
x y ip_net_mask
4 0 b"\x00\x00\x00\x00"
4 20 b"\xff\xff\xf0\x00"
4 32 b"\xff\xff\xff\xff"
16 0 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
16 1 b"\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
16 128 b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"

NET.IP_TRUNC

NET.IP_TRUNC(addr_bin, prefix_length)

Descrição Obtém addr_bin, um endereço IPv4 ou IPv6 no formato binário (BYTES) na ordem de bytes da rede e retorna um endereço de sub-rede no mesmo formato. O resultado tem o mesmo comprimento que addr_bin, onde os primeiros prefix_length bits são iguais aos addr_bin e os bits restantes são 0

Esta função gera um erro se LENGTH(addr_bin) não for 4 ou 16, ou se prefix_len for negativo ou maior que LENGTH(addr_bin) * 8.

Tipos de dados retornados

BYTES

Exemplo

SELECT
  FORMAT("%T", x) as addr_bin, prefix_length,
  FORMAT("%T", NET.IP_TRUNC(x, prefix_length)) AS ip_trunc
FROM UNNEST([
  STRUCT(b"\xAA\xBB\xCC\xDD" as x, 0 as prefix_length),
  (b"\xAA\xBB\xCC\xDD", 11), (b"\xAA\xBB\xCC\xDD", 12),
  (b"\xAA\xBB\xCC\xDD", 24), (b"\xAA\xBB\xCC\xDD", 32),
  (b'0123456789@ABCDE', 80)
]);
addr_bin prefix_length ip_trunc
b"\xaa\xbb\xcc\xdd" 0 b"\x00\x00\x00\x00"
b"\xaa\xbb\xcc\xdd" 11 b"\xaa\xa0\x00\x00"
b"\xaa\xbb\xcc\xdd" 12 b"\xaa\xb0\x00\x00"
b"\xaa\xbb\xcc\xdd" 24 b"\xaa\xbb\xcc\x00"
b"\xaa\xbb\xcc\xdd" 32 b"\xaa\xbb\xcc\xdd"
b"0123456789@ABCDE" 80 b"0123456789\x00\x00\x00\x00\x00\x00"

NET.IPV4_FROM_INT64

NET.IPV4_FROM_INT64(integer_value)

Descrição

Converte um endereço IPv4 do formato inteiro para binário (BYTES) na ordem de bytes da rede. Na entrada do inteiro, o bit menos significativo do endereço IP é armazenado no bit menos significativo do inteiro, independentemente da arquitetura do host ou do cliente. Por exemplo, 1 significa 0.0.0.1 e 0x1FF significa 0.0.1.255.

Essa função verifica se todos os 32 bits mais significativos são 0, ou se todos os 33 bits mais significativos são 1 (estendido por sinal de um inteiro de 32 bits). Em outras palavras, a entrada precisa estar no intervalo [-0x80000000, 0xFFFFFFFF]. Caso contrário, esta função gerará um erro.

Essa função não aceita IPv6.

Tipos de dados retornados

BYTES

Exemplo

SELECT x, x_hex, FORMAT("%T", NET.IPV4_FROM_INT64(x)) AS ipv4_from_int64
FROM (
  SELECT CAST(x_hex AS INT64) x, x_hex
  FROM UNNEST(["0x0", "0xABCDEF", "0xFFFFFFFF", "-0x1", "-0x2"]) AS x_hex
);
x x_hex ipv4_from_int64
0 0x0 b"\x00\x00\x00\x00"
11259375 0xABCDEF b"\x00\xab\xcd\xef"
4294967295 0xFFFFFFFF b"\xff\xff\xff\xff"
-1 -0x1 b"\xff\xff\xff\xff"
-2 -0x2 b"\xff\xff\xff\xfe"

NET.IPV4_TO_INT64

NET.IPV4_TO_INT64(addr_bin)

Descrição

Converte um endereço IPv4 do formato binário (BYTES) na ordem de bytes da rede para inteiro. Na saída do número inteiro, o bit menos significativo do endereço IP é armazenado no bit menos significativo do número inteiro, independentemente da arquitetura do host ou do cliente. Por exemplo, 1 significa 0.0.0.1, e 0x1FF significa 0.0.1.255. A saída está no intervalo [0, 0xFFFFFFFF].

Se o comprimento de entrada não for 4, esta função gerará um erro.

Essa função não aceita IPv6.

Tipos de dados retornados

INT64

Exemplo

SELECT
  FORMAT("%T", x) AS addr_bin,
  FORMAT("0x%X", NET.IPV4_TO_INT64(x)) AS ipv4_to_int64
FROM
UNNEST([b"\x00\x00\x00\x00", b"\x00\xab\xcd\xef", b"\xff\xff\xff\xff"]) AS x;
addr_bin ipv4_to_int64
b"\x00\x00\x00\x00" 0x0
b"\x00\xab\xcd\xef" 0xABCDEF
b"\xff\xff\xff\xff" 0xFFFFFFFF

NET.HOST

NET.HOST(url)

Descrição

Toma uma URL como uma STRING e retorna o host como uma STRING. Para os melhores resultados, os valores de URL precisam obedecer ao formato conforme definido pelo RFC 3986. Se não estiverem em conformidade com a formatação RFC 3986, a função analisará a entrada da melhor maneira possível e retornará um resultado relevante. Se não for possível analisar a entrada, será retornado NULL.

Nota: a função não realiza a normalização.

Tipos de dados retornados

STRING

Exemplo

SELECT
  FORMAT("%T", input) AS input,
  description,
  FORMAT("%T", NET.HOST(input)) AS host,
  FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
  FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
  SELECT "" AS input, "invalid input" AS description
  UNION ALL SELECT "http://abc.xyz", "standard URL"
  UNION ALL SELECT "//user:password@a.b:80/path?query",
                   "standard URL with relative scheme, port, path and query, but no public suffix"
  UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
  UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
  UNION ALL SELECT "    www.Example.Co.UK    ",
                   "non-standard URL with spaces, upper case letters, and without scheme"
  UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
entrada descrição host sufixo domínio
"" entrada inválida NULL NULL NULL
"http://abc.xyz" URL padrão "abc.xyz" "xyz" "abc.xyz"
"//user:password@a.b:80/path?query" URL padrão com esquema, porta, caminho e consulta relativos, mas sem sufixo público "a.b" NULL NULL
"https://[::1]:80" URL padrão com host IPv6 "[::1]" NULL NULL
"http://例子.卷筒纸.中国" URL padrão com nome de domínio internacionalizado "例子.卷筒纸.中国" "中国" "卷筒纸.中国"
"    www.Example.Co.UK    " URL não padrão com espaços, letras maiúsculas e sem esquema "www.Example.Co.UK" "Co.UK" "Example.Co.UK"
"mailto:?to=&subject=&body=" URI, e não URL, não compatível "mailto" NULL NULL

NET.PUBLIC_SUFFIX

NET.PUBLIC_SUFFIX(url)

Descrição

Toma uma URL como uma STRING e retorna o sufixo público (como com, org ou net) como uma STRING. Um sufixo público é um domínio da ICANN registrado em publicsuffix.org. Para os melhores resultados, os valores de URL precisam obedecer ao formato conforme definido pelo RFC 3986. Se não estiverem em conformidade com a formatação RFC 3986, a função analisará a entrada da melhor maneira possível e retornará um resultado relevante.

A função retornará NULL, se qualquer uma das seguintes situações for verdadeira:

  • Não é possível analisar o host com a entrada.
  • O host analisado contém pontos adjacentes no meio (não à esquerda ou direita).
  • O host analisado não contém um sufixo público.

Antes de pesquisar o sufixo público, essa função normalizará temporariamente o host convertendo letras em inglês em maiúsculas para minúsculas e codificando todos os caracteres não ASCII com Punycode. Depois, ela retornará o sufixo público como parte do host original em vez do host normalizado:

Observação: a função não realiza a normalização Unicode.

Observação: os dados de sufixo público em publicsuffix.org também contêm domínios privados. Essa função ignora os domínios privados.

Observação: os dados do sufixo público podem mudar ao longo do tempo. Por conseguinte, a entrada que produz um resultado NULL no momento pode produzir um valor não NULL no futuro.

Tipos de dados retornados

STRING

Exemplo

SELECT
  FORMAT("%T", input) AS input,
  description,
  FORMAT("%T", NET.HOST(input)) AS host,
  FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
  FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
  SELECT "" AS input, "invalid input" AS description
  UNION ALL SELECT "http://abc.xyz", "standard URL"
  UNION ALL SELECT "//user:password@a.b:80/path?query",
                   "standard URL with relative scheme, port, path and query, but no public suffix"
  UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
  UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
  UNION ALL SELECT "    www.Example.Co.UK    ",
                   "non-standard URL with spaces, upper case letters, and without scheme"
  UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
entrada descrição host sufixo domínio
"" entrada inválida NULL NULL NULL
"http://abc.xyz" URL padrão "abc.xyz" "xyz" "abc.xyz"
"//user:password@a.b:80/path?query" URL padrão com esquema, porta, caminho e consulta relativos, mas sem sufixo público "a.b" NULL NULL
"https://[::1]:80" URL padrão com host IPv6 "[::1]" NULL NULL
"http://例子.卷筒纸.中国" URL padrão com nome de domínio internacionalizado "例子.卷筒纸.中国" "中国" "卷筒纸.中国"
"    www.Example.Co.UK    " URL não padrão com espaços, letras maiúsculas e sem esquema "www.Example.Co.UK" "Co.UK" "Example.Co.UK
"mailto:?to=&subject=&body=" URI, e não URL, não compatível "mailto" NULL NULL

NET.REG_DOMAIN

NET.REG_DOMAIN(url)

Descrição

Toma uma URL como uma STRING e retorna o domínio registrado ou registrável (o sufixo público mais um rótulo precedente), como uma STRING. Para os melhores resultados, os valores de URL precisam obedecer ao formato conforme definido pelo RFC 3986. Se não estiverem em conformidade com a formatação RFC 3986, a função analisará a entrada da melhor maneira possível e retornará um resultado relevante.

A função retornará NULL, se qualquer uma das seguintes situações for verdadeira:

  • Não é possível analisar o host com a entrada.
  • O host analisado contém pontos adjacentes no meio (não à esquerda ou direita).
  • O host analisado não contém um sufixo público.
  • O host analisado contém somente um sufixo público sem rótulo precedente.

Antes de pesquisar o sufixo público, essa função normalizará temporariamente o host convertendo letras em inglês em maiúsculas para minúsculas e codificando todos os caracteres não ASCII com Punycode. Depois, ela retornará o domínio registrado ou registrável como parte do host original em vez do host normalizado.

Observação: a função não realiza a normalização Unicode.

Observação: os dados de sufixo público em publicsuffix.org também contêm domínios privados. Essa função não trata um domínio privado como um sufixo público. Por exemplo, se "us.com" for um domínio privado nos dados de sufixo público, NET.REG_DOMAIN ("foo.us.com") retornará "us.com" (o sufixo público "com" mais o rótulo anterior "us ") em vez de "foo.us.com" (o domínio privado "us.com" mais o rótulo anterior "foo").

Observação: os dados do sufixo público podem mudar ao longo do tempo. Por conseguinte, a entrada que produz um resultado NULL no momento pode produzir um valor não NULL no futuro.

Tipos de dados retornados

STRING

Exemplo

SELECT
  FORMAT("%T", input) AS input,
  description,
  FORMAT("%T", NET.HOST(input)) AS host,
  FORMAT("%T", NET.PUBLIC_SUFFIX(input)) AS suffix,
  FORMAT("%T", NET.REG_DOMAIN(input)) AS domain
FROM (
  SELECT "" AS input, "invalid input" AS description
  UNION ALL SELECT "http://abc.xyz", "standard URL"
  UNION ALL SELECT "//user:password@a.b:80/path?query",
                   "standard URL with relative scheme, port, path and query, but no public suffix"
  UNION ALL SELECT "https://[::1]:80", "standard URL with IPv6 host"
  UNION ALL SELECT "http://例子.卷筒纸.中国", "standard URL with internationalized domain name"
  UNION ALL SELECT "    www.Example.Co.UK    ",
                   "non-standard URL with spaces, upper case letters, and without scheme"
  UNION ALL SELECT "mailto:?to=&subject=&body=", "URI rather than URL--unsupported"
);
entrada descrição host sufixo domínio
"" entrada inválida NULL NULL NULL
"http://abc.xyz" URL padrão "abc.xyz" "xyz" "abc.xyz"
"//user:password@a.b:80/path?query" URL padrão com esquema, porta, caminho e consulta relativos, mas sem sufixo público "a.b" NULL NULL
"https://[::1]:80" URL padrão com host IPv6 "[::1]" NULL NULL
"http://例子.卷筒纸.中国" URL padrão com nome de domínio internacionalizado "例子.卷筒纸.中国" "中国" "卷筒纸.中国"
"    www.Example.Co.UK    " URL não padrão com espaços, letras maiúsculas e sem esquema "www.Example.Co.UK" "Co.UK" "Example.Co.UK"
"mailto:?to=&subject=&body=" URI, e não URL, não compatível "mailto" NULL NULL

Operadores

Os operadores são representados por caracteres especiais ou palavras-chave. Eles não usam a sintaxe de chamada de função. Um operador manipula qualquer número de entradas de dados, também chamados de operandos, e retorna um resultado.

Convenções comuns:

  • A menos que especificado em contrário, todos os operadores retornam NULL quando um dos operandos é .
  • Todos os operadores geram um erro se o resultado do cálculo estourar.
  • Para todas as operações de ponto flutuante, +/-inf e NaN só poderão ser retornadas se um dos operandos for ou NaN. Em outros casos, um erro é retornado.

A tabela a seguir lista todos os operadores do BigQuery da precedência mais alta à mais baixa, isto é, na ordem em que são avaliados em uma declaração.

Ordem de precedência Operador Tipos de dados de entrada Nome Arity do operador
1 . STRUCT
Operador de acesso ao campo do membro Binário
  [ ] ARRAY Posição da matriz. Precisa ser usado com OFFSET ou ORDINAL. Consulte Funções ARRAY. Binário
2 - Todos os tipos numéricos Unário menos Unário
  ~ Inteiro ou BYTES Bit a bit NOT Unário
3 * Todos os tipos numéricos Multiplicação Binário
  / Todos os tipos numéricos Divisão Binário
4 + Todos os tipos numéricos Adição Binário
  - Todos os tipos numéricos Subtração Binário
5 << Inteiro ou BYTES Bit a bit deslocado para a esquerda Binário
  >> Inteiro ou BYTES Bit a bit deslocado para a direita Binário
6 & Inteiro ou BYTES Bit a bit and Binário
7 ^ Inteiro ou BYTES Bit a bit xor Binário
8 | Inteiro ou BYTES Bit a bit or Binário
9 (operadores de comparação) = Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Igual Binário
  < Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Menor que Binário
  > Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Maior que Binário
  <= Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Menor que ou igual a Binário
  >= Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Maior que ou igual a Binário
  !=, <> Qualquer tipo comparável. Para ver uma lista completa, consulte Tipos de dados. Diferente Binário
  [NOT] LIKE STRING e byte O valor [não] corresponde ao padrão especificado Binário
  [NOT] BETWEEN Qualquer tipo comparável. Para ver a lista, consulte "Tipos de dados". O valor [não] está dentro do intervalo especificado Binário
  [NOT] IN Qualquer tipo comparável. Para ver a lista, consulte "Tipos de dados". O valor [não] está no grupo de valores especificados Binário
  IS [NOT] NULL Todos O valor [não] é NULL Unário
  IS [NOT] TRUE BOOL O valor [não] é TRUE. Unário
  IS [NOT] FALSE BOOL O valor [não] é FALSE. Unário
10 NOT BOOL Lógico NOT Unário
11 AND BOOL Lógico AND Binário
12 OR BOOL Lógico OR Binário

Os operadores com a mesma precedência são associativos da esquerda, ou seja, são agrupados da esquerda para a direita. Por exemplo, a expressão:

x AND y AND z

é interpretada como

( ( x AND y ) AND z )

A expressão:

x * y / z

é interpretada como:

( ( x * y ) / z )

Todos os operadores de comparação têm a mesma prioridade, mas eles não são associativos. Portanto, é preciso usar parênteses para resolver ambiguidade. Exemplo:

(x < y) IS FALSE

Operadores de acesso ao elemento

Operador Sintaxe Tipos de dados de entrada Tipo de dados de resultado Descrição
. expression.fieldname1... STRUCT
Tipo T armazenado em nomedocampo1 Operador de ponto. Pode ser usado para acessar campos aninhados, como expressão.nomedocampo1.nomedocampo2...
[ ] matriz_expressão [posição_palavra-chave (int_expressão ) ] Consulte Funções ARRAY Tipo T armazenado em ARRAY position_keyword pode ser OFFSET ou ORDINAL. Consulte Funções ARRAY para saber mais sobre as duas funções que usam esse operador.

Operadores aritméticos

Todos os operadores aritméticos aceitam a entrada do tipo numérico T, também presente no tipo de resultado, a menos que indicado de outra forma na descrição abaixo:

Nome Sintaxe
Adição X + Y
Subtração X - Y
Multiplicação X * Y
Divisão X / Y
Unário menos - X

NOTA: as operações de divisão por zero retornam um erro. Para retornar um resultado diferente, considere as funções IEEE_DIVIDE ou SAFE_DIVIDE.

Tipos de resultados para adição e multiplicação:

 INT64NUMERICFLOAT64
INT64INT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

Tipos de resultados para subtração:

 INT64NUMERICFLOAT64
INT64INT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

Tipos de resultados para divisão:

 INT64NUMERICFLOAT64
INT64FLOAT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

Tipos de resultados para Unário menos:

Tipo de dados de entrada Tipo de dados de resultado
INT64 INT64
NUMERIC NUMERIC
FLOAT64 FLOAT64

Operadores bit a bit

Todos os operadores bit a bit retornam o mesmo tipo e comprimento do primeiro operando.

Nome Sintaxe Tipo de dados de entrada Descrição
Bit a bit not ~ X Inteiro ou BYTES Executa a negação lógica em cada bit, formando o complemento dos números um do valor binário.
Bit a bit or X | Y X: número inteiro ou BYTES
Y: o mesmo tipo que X
Toma dois padrões de bits de comprimento igual e executa a operação lógica OR inclusiva em cada par dos bits correspondentes. Esse operador gerará um erro se X e Y forem BYTES de comprimentos diferentes.
Bit a bit xor X ^ Y X: número inteiro ou BYTES
Y: o mesmo tipo que X
Toma dois padrões de bits de comprimento igual e executa a operação lógica OR exclusiva em cada par dos bits correspondentes. Esse operador gerará um erro se X e Y forem BYTES de comprimentos diferentes.
Bit a bit and X & Y X: número inteiro ou BYTES
Y: o mesmo tipo que X
Toma dois padrões de bits de comprimento igual e executa a operação lógica AND em cada par dos bits correspondentes. Esse operador gerará um erro se X e Y forem BYTES de comprimentos diferentes.
Deslocado para a esquerda X << Y X: número inteiro ou BYTES
Y: INT64
Desloca o primeiro operando X para a esquerda. Esse operador retorna 0 ou uma sequência de bytes de b'\x00' se o segundo operando, Y, for maior ou igual ao comprimento do bit do primeiro operando, X, (por exemplo, 64, se X tiver o tipo INT64). Esse operador gerará um erro se Y for negativo.
Deslocado para a direita X >> Y X: número inteiro ou BYTES
Y: INT64
Desloca o primeiro operando X para a direita. Esse operador não faz a extensão de bit de sinal com um tipo com sinal. Isso significa que ele preenche com 0 os bits vagos à esquerda. Esse operador retorna 0 ou uma sequência de bytes de b'\x00' se o segundo operando, Y, for maior ou igual ao comprimento do bit do primeiro operando, X, (por exemplo, 64, se X tiver o tipo INT64). Esse operador gerará um erro se Y for negativo.

Operadores lógicos

Todos os operadores lógicos permitem apenas a entrada BOOL.

Nome Sintaxe Descrição
Lógico NOT NOT X Retorna FALSE se a entrada for TRUE. Retorna TRUE se a entrada for FALSE. Caso contrário, retorna NULL.
Lógico AND X AND Y Retorna FALSE se pelo menos uma entrada for FALSE. Retorna TRUE se X e Y forem TRUE. Caso contrário, retorna NULL.
Lógico OR X OR Y Retorna FALSE se X e Y forem FALSE. Retorna TRUE se pelo menos uma entrada for TRUE. Caso contrário, retorna NULL.

Operadores de comparação

As comparações sempre retornam BOOL. Elas geralmente exigem que os dois operandos sejam do mesmo tipo. Se os operandos são de tipos diferentes e o BigQuery pode converter os valores deles em um tipo comum sem perda de precisão, ele geralmente os força a esse tipo comum para a comparação. O BigQuery geralmente coage literais ao tipo não literal, quando o primeiro tipo está presente. Os tipos de dados comparáveis são definidos na seção Tipos de dados.

STRUCTs aceitam apenas quatro operadores de comparação: igual (=), diferente (!= e <>) e IN.

As regras a seguir são aplicadas na comparação desses tipos de dados:

  • FLOAT64: todas as comparações com NaN retornam FALSE, exceto != e <>, que retornam TRUE.
  • BOOL: FALSE é menor que TRUE.
  • STRING: as strings são comparadas ponto de código a ponto de código. Isso significa que strings canonicamente equivalentes somente serão comparadas como iguais se tiverem sido normalizadas primeiro.
  • NULL: A convenção é válida aqui: qualquer operação com uma entrada retorna .
Nome Sintaxe Descrição
Menor que X < Y Retorna TRUE, se X for menor que Y.
Menor que ou igual a X <= Y Retorna TRUE, se X for menor que ou igual a Y.
Maior que X > Y Retorna TRUE, se X for maior que Y.
Maior que ou igual a X >= Y Retorna TRUE, se X for maior que ou igual a Y.
Igual X = Y Retorna TRUE, se X for igual a Y.
Diferente X != Y
X <> Y
Retorna TRUE, se X não for igual a Y.
BETWEEN X [NOT] BETWEEN Y AND Z Retorna TRUE, se X [não] estiver dentro do intervalo especificado. O resultado de "X BETWEEN Y AND Z" é equivalente a "Y <= X AND X <= Z", mas X é avaliado somente uma vez no primeiro.
LIKE X [NOT] LIKE Y Verifica se a STRING no primeiro operando, X, corresponde a um padrão especificado pelo segundo operando, Y. As expressões podem conter estes caracteres:
  • Um sinal de porcentagem "%" corresponde a qualquer número de caracteres ou bytes.
  • Um sublinhado "_" corresponde a um único caractere ou byte.
  • É possível inserir um caractere de escape em "\", "_" ou "%" usando duas barras invertidas. Por exemplo, "\\%". Se você estiver usando strings brutas, basta uma barra invertida. Por exemplo, r"\%";
IN Várias - veja abaixo Retorna FALSE se o operando à direita estiver vazio. Retorna NULL se o operando à esquerda for NULL. Retorna TRUE ou NULL, nunca FALSE, se o operando à direita contiver NULL. Os argumentos em qualquer lado do operador IN são expressões gerais. Nenhum operando precisa ser um literal, embora seja mais comum usar um literal à direita. X é avaliado apenas uma vez.

Quando a igualdade dos valores com tipo de dados STRUCT é testada, é possível que um ou mais campos sejam NULL. Nesses casos:

  • Se todos os valores de campo não NULL forem iguais, a comparação retornará NULL.
  • Se qualquer valor de campo não NULL for diferente, a comparação retornará FALSE.

A tabela a seguir demonstra como os tipos de dados STRUCT são comparados quando têm campos com valores NULL.

Struct1 Struct2 Struct1 = Struct2
STRUCT(1, NULL) STRUCT(1, NULL) NULL
STRUCT(1, NULL) STRUCT(2, NULL) FALSE
STRUCT(1,2) STRUCT(1, NULL) NULL

Operadores IN

O operador IN aceita estas sintaxes:

x [NOT] IN (y, z, ... ) # Requires at least one element
x [NOT] IN (<subquery>)
x [NOT] IN UNNEST(<array expression>) # analysis error if the expression
                                      # does not return an ARRAY type.

Os argumentos em qualquer lado do operador IN são expressões gerais. É comum o uso de literais na expressão do lado direito. No entanto, isso não é obrigatório.

A semântica de:

x IN (y, z, ...)

é definida como equivalente a

(x = y) OR (x = z) OR ...

e os formatos de subconsulta e matriz são definidos de maneira semelhante.

x NOT IN ...

é equivalente a:

NOT(x IN ...)

O formato UNNEST trata uma varredura de matriz como UNNEST na cláusula FROM:

x [NOT] IN UNNEST(<array expression>)

Esse formato é usado muitas vezes com parâmetros ARRAY. Por exemplo:

x IN UNNEST(@array_parameter)

Observação: um ARRAY NULL será tratado de maneira equivalente a um ARRAY vazio.

Consulte o tópico Matrizes para mais informações sobre como usar essa sintaxe.

Quando o operador IN é usado, aplica-se a seguinte semântica:

  • IN com uma expressão vazia do lado direito é sempre FALSE.
  • IN com uma expressão NULL do lado esquerdo e uma expressão não vazia do lado direito é sempre NULL.
  • IN com NULL na lista retorna somente TRUE ou NULL, nunca FALSE.
  • NULL IN (NULL) retorna NULL.
  • IN UNNEST(<NULL array>) retorna FALSE (não NULL).
  • NOT IN com NULL na lista IN retorna somente FALSE ou NULL, nunca TRUE.

IN pode ser usado com chaves de várias partes usando a sintaxe struct do construtor. Por exemplo:

(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )

Para mais informações sobre essa sintaxe, consulte a seção Tipo struct do tópico "Tipos de dados".

Operadores IS

Os operadores IS retornam TRUE ou FALSE para a condição que estão testando. Eles nunca retornam NULL, mesmo para entradas NULL, ao contrário das funções IS_INF e IS_NAN, definidas em Funções matemáticas. Se NOT estiver presente, o valor de saída BOOL será invertido.

Sintaxe da função Tipo de dados de entrada Tipo de dados de resultado Descrição

X IS [NOT] NULL
Qualquer tipo de valor BOOL Retorna TRUE se o operando X for avaliado como NULL. Caso contrário, retorna FALSE.

X IS [NOT] TRUE
BOOL BOOL Retorna TRUE, se o operando BOOL for avaliado como TRUE. Caso contrário, retorna FALSE.

X IS [NOT] FALSE
BOOL BOOL Retorna TRUE, se o operando BOOL for avaliado como FALSE. Caso contrário, retorna FALSE.

Expressões condicionais

As expressões condicionais impõem restrições na ordem de avaliação das entradas. Em essência, elas são avaliadas da esquerda para a direita, com curto-circuito, e somente avaliam o valor da saída escolhida. Por outro lado, todas as entradas das funções regulares são avaliadas antes de chamar a função. O curto-circuito em expressões condicionais pode ser explorado para o tratamento de erros ou ajuste do desempenho.

Sintaxe Tipos de dados de entrada Tipo de dados de resultado Descrição

CASE expr
  WHEN value THEN result
  [WHEN ...]
  [ELSE else_result]
  END
expr e value: qualquer tipo result e else_result: supertipo de tipos de entrada. Compara expr ao valor de cada cláusula sucessiva WHEN e retorna o primeiro resultado em que essa comparação retorna verdadeiro. As cláusulas WHEN restantes e else_result não são avaliadas. Se a comparação expr = value retornar falso ou NULL para todas as cláusulas WHEN, retorna else_result se presente; se não estiver presente, retorna NULL. Expressões expr e value devem ser implicitamente coercíveis a um supertipo comum; comparações de igualdade são feitas em valores forçados. Expressões result e else_result devem ser coercíveis a um supertipo em comum.

CASE
  WHEN cond1 THEN result
  [WHEN cond2...]
  [ELSE else_result]
  END
cond: BOOL result e else_result: supertipo de tipos de entrada. Avalia a condição cond de cada cláusula sucessiva WHEN e retorna o primeiro resultado em que a condição é verdadeira; todas as cláusulas WHEN restantes e else_result não são avaliadas. Se todas as condições forem falsas ou NULL, retorna else_result se presente; se não estiver presente, retorna NULL. Expressões result e else_result precisam ser implicitamente coercíveis a um supertipo comum.
COALESCE(expr1, ..., exprN) Qualquer tipo Supertipo de tipos de entrada Retorna o valor da primeira expressão não nula. As expressões restantes não são avaliadas. Todas as expressões de entrada precisam ser coercíveis implicitamente para um supertipo comum.
IF(cond, true_result, else_result) cond: BOOL true_result e else_result: qualquer tipo. Se cond for verdadeiro, retorna true_result, caso contrário, retorna else_result. else_result não é avaliado se cond é verdadeiro. true_result não será avaliado se cond for falso ou NULL. true_result e else_result precisam ser coercíveis a um supertipo comum.
IFNULL(expr, null_result) Qualquer tipo Qualquer tipo ou supertipo de tipos de entrada. Se expr for NULL, retorna null_result. Caso contrário, retorna expr. Se expr não for NULL, null_result não será avaliado. expr e null_result precisam ser implicitamente coercíveis para um supertipo em comum. Sinônimo de COALESCE(expr, null_result).
NULLIF(expression, expression_to_match) Qualquer tipo T ou subtipo de T Qualquer tipo T ou subtipo de T Retorna NULL se expression = expression_to_match for verdadeiro. Caso contrário, retorna expression. expression e expression_to_match precisam ser implicitamente coercíveis para um supertipo comum; a comparação de igualdade é feita em valores forçados.

Subconsultas de expressão

Há quatro tipos de subconsultas de expressão, isto é, subconsultas que são usadas como expressões. As subconsultas de expressão retornam NULL ou um único valor, ao contrário de uma coluna ou tabela, e precisam estar entre parênteses. Consulte Subconsultas para ver uma discussão mais completa sobre subconsultas.

Tipo de subconsulta Tipo de dados de resultado Descrição
Escalar Qualquer tipo T Uma subconsulta entre parênteses dentro de uma expressão (por exemplo, na lista SELECT ou na cláusula WHERE) é interpretada como uma subconsulta escalar. A lista SELECT em uma subconsulta escalar precisa ter exatamente um campo. Se a subconsulta retornar exatamente uma linha, esse único valor será o resultado da subconsulta escalar. Se a subconsulta retornar zero linhas, o valor da subconsulta escalar será NULL. Se a subconsulta retornar mais de uma linha, a consulta falhará com um erro de ambiente de execução. Quando a subconsulta é escrita com SELECT AS STRUCT, ela pode incluir várias colunas, e o valor retornado é o STRUCT construído. Selecionar várias colunas sem usar SELECT AS é um erro.
ARRAY ARRAY Pode usar SELECT AS STRUCT para criar matrizes de estruturas e, por outro lado, selecionar várias colunas sem usar SELECT AS é um erro. Retorna um ARRAY vazio se a subconsulta não retornar linha alguma. Nunca retorna um ARRAY NULL.
IN BOOL Ocorre em uma expressão seguindo o operador IN. A subconsulta precisa produzir uma única coluna cujo tipo é compatível em igualdade com a expressão do lado esquerdo do operador IN. Retorna FALSE, se a subconsulta retornar zero linhas. x IN () é equivalente a x IN (value, value, ...). Veja o operador IN em Operadores de comparação para a semântica completa.
EXISTS BOOL Retorna TRUE, se a subconsulta produzir uma ou mais linhas. Retorna FALSE, se a subconsulta produzir zero linhas. Nunca retorna NULL. Ao contrário de todas as outras subconsultas de expressão, não há regras sobre a lista de colunas. Qualquer número de colunas pode ser selecionado. Isso não afetará o resultado da consulta.

Exemplos

Os seguintes exemplos de subconsultas de expressão presumem que t.int_array tem tipo ARRAY<INT64>.

Tipo Subconsulta Tipo de dados de resultado Notas
Escalar (SELECT COUNT(*) FROM t.int_array) INT64  
(SELECT DISTINCT i FROM t.int_array i) INT64, possivelmente erro de tempo de execução  
(SELECT i FROM t.int_array i WHERE i=5) INT64, possivelmente erro de tempo de execução  
(SELECT ARRAY_AGG(i) FROM t.int_array i) ARRAY Usa a função de agregação ARRAY_AGG para retornar uma ARRAY.
(SELECT 'xxx' a) STRING  
(SELECT 'xxx' a, 123 b) Erro Retorna um erro porque há mais de uma coluna
(SELECT AS STRUCT 'xxx' a, 123 b) STRUCT  
(SELECT AS STRUCT 'xxx' a) STRUCT  
ARRAY ARRAY(SELECT COUNT(*) FROM t.int_array) ARRAY de tamanho 1  
ARRAY(SELECT x FROM t) ARRAY  
ARRAY(SELECT 5 a, COUNT(*) b FROM t.int_array) Erro Retorna um erro porque há mais de uma coluna
ARRAY(SELECT AS STRUCT 5 a, COUNT(*) b FROM t.int_array) ARRAY  
ARRAY(SELECT AS STRUCT i FROM t.int_array i) ARRAY Cria uma ARRAY de STRUCTs de um campo
ARRAY(SELECT AS STRUCT 1 x, 2, 3 x) ARRAY Retorna uma ARRAY de STRUCTs com campos anônimos ou duplicados.
ARRAY(SELECT AS TypeName SUM(x) a, SUM(y) b, SUM(z) c from t) array<NomeDoTipo> Seleção de um tipo nomeado. Supõe que NomeDoTipo é um tipo de STRUCT com os campos a,b,c.
STRUCT (SELECT AS STRUCT 1 x, 2, 3 x) STRUCT Cria um STRUCT com campos anônimos ou duplicados.
EXISTS EXISTS(SELECT x,y,z FROM table WHERE y=z) BOOL  
NOT EXISTS(SELECT x,y,z FROM table WHERE y=z) BOOL  
IN x IN (SELECT y FROM table WHERE z) BOOL  
x NOT IN (SELECT y FROM table WHERE z) BOOL  

Funções de depuração

O BigQuery aceita as funções de depuração a seguir.

ERROR

ERROR(error_message)

Descrição

Retorna um erro. O argumento error_message é uma STRING.

O BigQuery trata ERROR da mesma maneira como uma expressão qualquer que pode resultar em um erro: não há garantia especial de ordem de avaliação.

Tipos de dados retornados

O BigQuery infere o tipo de retorno em contexto.

Exemplos

No exemplo a seguir, a consulta retornará uma mensagem de erro se o valor da linha não corresponder a um dos dois valores definidos.

SELECT
  CASE
    WHEN value = 'foo' THEN 'Value is foo.'
    WHEN value = 'bar' THEN 'Value is bar.'
    ELSE ERROR(concat('Found unexpected value: ', value))
  END AS new_value
FROM (
  SELECT 'foo' AS value UNION ALL
  SELECT 'bar' AS value UNION ALL
  SELECT 'baz' AS value);

Found unexpected value: baz

No exemplo a seguir, o BigQuery pode avaliar a função ERROR antes ou depois do x > 0 porque o BigQuery geralmente não fornece garantias de ordem entre condições de cláusula WHERE e não há garantias especiais para a função .

SELECT *
FROM (SELECT -1 AS x)
WHERE x > 0 AND ERROR('Example error');

No próximo exemplo, a cláusula WHERE avalia uma condição IF, que garante que o BigQuery avaliará apenas a função ERROR se a condição falhar.

SELECT *
FROM (SELECT -1 AS x)
WHERE IF(x > 0, true, ERROR(FORMAT('Error: x must be positive but is %t', x)));'

Error: x must be positive but is -1