Los operadores se representan mediante caracteres especiales o palabras clave; no se usa la sintaxis de llamada a funciones. Un operador manipula cualquier cantidad de entradas de datos, también llamados operandos, y muestra un resultado.
Convenciones comunes:
- A menos que se especifique lo contrario, todos los operadores muestran
NULL
cuando uno de los operandos esNULL
. - Todos los operadores mostrarán un error si el cálculo arroja demasiados resultados.
- Para todas las operaciones de punto flotante,
+/-inf
yNaN
solo se pueden mostrar si uno de los operandos es+/-inf
oNaN
. En otros casos, se muestra un error.
En la siguiente tabla, se enumeran todos los operadores de BigQuery desde la prioridad más alta a la más baja, es decir, en el orden en que se evaluarán en una declaración.
Orden de prioridad | Operador | Tipos de datos de entrada | Nombre | Aridad del operador |
---|---|---|---|---|
1 | . | STRUCT |
Operador de acceso de campo del miembro | Binario |
[ ] | ARRAY | Posición del arreglo. Se debe usar con OFFSET o con ORDINAL; consulta Funciones de arreglo. | Binario | |
2 | - | Todos los tipos numéricos | Menos unario | Unario |
~ | Número entero o BYTES | NOT a nivel de bits | Unario | |
3 | * | Todos los tipos numéricos | Multiplicación | Binario |
/ | Todos los tipos numéricos | División | Binario | |
|| | STRING, BYTES o ARRAY <T> | Operador de concatenación | Binario | |
4 | + | Todos los tipos numéricos INT64 y DATE |
Suma | Binario |
- | Todos los tipos numéricos INT64 y DATE |
Resta | Binario | |
5 | << | Número entero o BYTES | Desplazamiento de bits a la izquierda | Binario |
>> | Número entero o BYTES | Desplazamiento de bits a la derecha | Binario | |
6 | & | Número entero o BYTES | AND a nivel de bits | Binario |
7 | ^ | Número entero o BYTES | XOR a nivel de bits | Binario |
8 | | | Número entero o BYTES | OR a nivel de bits | Binario |
9 (Operadores de comparación) | = | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | Igual | Binario |
< | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | Menor que | Binario | |
> | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | Mayor que | Binario | |
<= | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | Menor o igual que | Binario | |
>= | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | Mayor o igual que | Binario | |
!=, <> | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | No igual | Binario | |
[NOT] LIKE | STRING y byte | El valor [no] coincide con el patrón especificado | Binario | |
[NOT] BETWEEN | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | El valor [no] está dentro del rango especificado | Binario | |
[NOT] IN | Cualquier tipo comparable. Consulta Tipos de datos para ver una lista completa. | El valor [no] está en el conjunto de valores especificado | Binario | |
IS [NOT] NULL |
Todos | El valor [no] es NULL |
Unario | |
IS [NOT] TRUE | BOOL | El valor [no] es VERDADERO | Unario | |
IS [NOT] FALSE | BOOL | El valor [no] es FALSO | Unario | |
10 | NOT | BOOL | NOT lógico | Unario |
11 | AND | BOOL | AND lógico | Binario |
12 | OR | BOOL | OR lógico | Binario |
Los operadores con la misma prioridad son asociativos a la izquierda. Esto significa que esos operadores se agrupan juntos de izquierda a derecha. Por ejemplo, la expresión:
x AND y AND z
se interpreta como
( ( x AND y ) AND z )
La expresión:
x * y / z
se interpreta como:
( ( x * y ) / z )
Todos los operadores de comparación tienen la misma prioridad, pero no son asociativos. Por lo tanto, se requieren paréntesis para resolver la ambigüedad. Por ejemplo:
(x < y) IS FALSE
Operadores de acceso a elementos
Operador | Sintaxis | Tipos de datos de entrada | Tipo de datos del resultado | Descripción |
---|---|---|---|---|
. | expression.fieldname1… | STRUCT |
Tipo T almacenado en fieldname1 | Operador de punto. Puede usarse para acceder a campos anidados, por ejemplo, expression.fieldname1.fieldname2... |
[ ] | array_expression [position_keyword (int_expression ) ] | Consulta las funciones de ARRAY | Tipo T almacenado en ARRAY | position_keyword es OFFSET o bien ORDINAL. Consulta Funciones de ARRAY para ver las dos funciones que usan este operador. |
Operadores aritméticos
Todos los operadores aritméticos aceptan la entrada del tipo numérico T, y el tipo de resultado tiene el tipo T, a menos que se indique lo contrario en la siguiente descripción:
Nombre | Sintaxis |
---|---|
Suma | X + Y |
Resta | X - Y |
Multiplicación | X * Y |
División | X / Y |
Menos unario | - X |
NOTA: Las operaciones de dividir por cero muestran un error. Para que se muestre un resultado diferente considera usar las funciones IEEE_DIVIDE o SAFE_DIVIDE.
Tipos de resultados para suma, resta y multiplicación:
INPUT | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
Tipos de resultados para división:
INPUT | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | FLOAT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
Tipos de resultados para menos unario:
INPUT | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
OUTPUT | INT64 | NUMERIC | FLOAT64 |
Operadores aritméticos de fecha
Los operadores “+” y “-” se pueden usar para las operaciones aritméticas con fechas.
date_expression + int64_expression
int64_expression + date_expression
date_expression - int64_expression
Descripción
Agrega días int64_expression
a date_expression
o se los resta. Esto es equivalente a las funciones DATE_ADD
o DATE_SUB
, cuando el intervalo se expresa en días.
Tipo de datos mostrados
DATE
Ejemplo
SELECT DATE "2020-09-22" + 1 AS day_later, DATE "2020-09-22" - 7 AS week_ago
+------------+------------+
| day_later | week_ago |
+------------+------------+
| 2020-09-23 | 2020-09-15 |
+------------+------------+
Operadores a nivel de bits
Todos los operadores a nivel de bits muestran el mismo tipo y la misma longitud que el primer operando.
Nombre | Sintaxis | Tipo de datos de entrada | Descripción |
---|---|---|---|
NOT a nivel de bits | ~ X | Número entero o BYTES | Realiza una negación lógica en cada bit y forma el complemento a uno del valor binario dado. |
OR a nivel de bits | X | Y | X: número entero o BYTES Y: mismo tipo que X |
Toma dos patrones de bits de igual longitud y realiza la operación OR inclusiva lógica en cada par de los bits correspondientes. Este operador muestra un error si Y y X son BYTES de diferentes longitudes. |
XOR a nivel de bits | X ^ Y | X: número entero o BYTES Y: mismo tipo que X |
Toma dos patrones de bits de igual longitud y realiza la operación OR exclusiva lógica en cada par de los bits correspondientes. Este operador muestra un error si Y y X son BYTES de diferentes longitudes. |
AND a nivel de bits | X & Y | X: número entero o BYTES Y: mismo tipo que X |
Toma dos patrones de bits de igual longitud y realiza la operación lógica AND en cada par de los bits correspondientes. Este operador muestra un error si Y y X son BYTES de diferentes longitudes. |
Desplazamiento a la izquierda | X << Y | X: Número entero o BYTES Y: INT64 |
Desplaza el primer operando X a la izquierda. Este operador muestra 0 o una secuencia de bytes de b'\x00' si el segundo operando Y es igual o mayor que el largo de bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador muestra un error si Y es negativo. |
Desplazamiento a la derecha | X >> Y | X: Número entero o BYTES Y: INT64 |
Desplaza el primer operando X a la derecha. Este operador no realiza la extensión de signo con un tipo de signo (es decir, llena los bits vacantes de la izquierda con 0). Este operador muestra 0 o una secuencia de bytes de b'\x00' si el segundo operando Y es igual o mayor que el largo de bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador muestra un error si Y es negativo. |
Operadores lógicos
BigQuery es compatible con los operadores lógicos AND
, OR
y NOT
.
Los operadores lógicos solo permiten la entrada BOOL o NULL
y usan la lógica trivalente para producir un resultado. El resultado puede ser TRUE
, FALSE
o NULL
:
x | y | x AND y | x OR y |
---|---|---|---|
VERDADERO | VERDADERO | VERDADERO | VERDADERO |
VERDADERO | FALSO | FALSO | VERDADERO |
VERDADERO | NULL | NULL | VERDADERO |
FALSO | VERDADERO | FALSO | VERDADERO |
FALSO | FALSO | FALSO | FALSO |
FALSO | NULL | FALSO | NULL |
NULL | VERDADERO | NULL | VERDADERO |
NULL | FALSO | FALSO | NULL |
NULL | NULL | NULL | NULL |
x | NOT X |
---|---|
VERDADERO | FALSO |
FALSO | VERDADERO |
NULL | NULL |
Ejemplos
En los ejemplos de esta sección, se hace referencia a una tabla llamada entry_table
:
+-------+
| entry |
+-------+
| a |
| b |
| c |
| NULL |
+-------+
SELECT 'a' FROM entry_table WHERE entry = 'a'
-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL
+-------+
| entry |
+-------+
| a |
+-------+
SELECT entry FROM entry_table WHERE NOT (entry = 'a')
-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL
+-------+
| entry |
+-------+
| b |
| c |
+-------+
SELECT entry FROM entry_table WHERE entry IS NULL
-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE
+-------+
| entry |
+-------+
| NULL |
+-------+
Operadores de comparación
Las comparaciones siempre muestran BOOL. Por lo general, las comparaciones requieren que ambos operandos sean del mismo tipo. Si los operandos son de tipos diferentes y si BigQuery puede convertir los valores de esos tipos en un tipo común sin que se pierda la precisión, BigQuery, en general, los coerciona a ese tipo común para la comparación. Con frecuencia, BigQuery coerciona los literales al tipo de los no literales, cuando están presentes. Los tipos de datos comparables se definen en Tipos de datos.
Los STRUCT solo admiten 4 operadores de comparación: igual (=), no igual (!= Y <>) y también IN.
Las siguientes reglas se aplican cuando se comparan estos tipos de datos:
- FLOAT64: todas las comparaciones con NaN muestran FALSO, excepto
!=
y<>
, que muestran VERDADERO. - BOOL: FALSO es menor que VERDADERO.
- STRING: las strings se comparan punto de código por punto de código, lo que significa que solo se garantiza que las strings canónicamente equivalentes se comparen como iguales si se normalizaron primero.
NULL
: aquí se mantiene la convención; cualquier operación con una entradaNULL
mostrará el valorNULL
.
Nombre | Sintaxis | Descripción |
---|---|---|
Menor que | X < Y | Muestra TRUE si X es menor que Y. |
Menor o igual que | X <= Y | Muestra TRUE si X es menor o igual que Y. |
Mayor que | X > Y | Muestra TRUE si X es mayor que Y. |
Mayor o igual que | X >= Y | Muestra TRUE si X es mayor o igual que Y. |
Igual | X = Y | Muestra TRUE si X es igual que Y. |
No igual | X != Y X <> Y |
Muestra TRUE si X no es igual que Y. |
BETWEEN | X [NOT] BETWEEN Y AND Z | Muestra TRUE si X [no] está dentro del rango especificado. El resultado de "X BETWEEN Y AND Z" es equivalente a "Y <= X AND X <= Z", pero X se evalúa solo una vez en el primer caso. |
LIKE | X [NOT] LIKE Y | Comprueba si la STRING del primer operando X coincide con un patrón especificado por el segundo operando Y. Las expresiones pueden contener estos caracteres:
|
IN | Múltiple: ver a continuación | Muestra FALSE si el operando derecho está vacío. Muestra NULL si el operando izquierdo es NULL . Muestra TRUE o NULL , nunca FALSE, si el operando derecho contiene NULL . Los argumentos a ambos lados de IN son expresiones generales. No se requiere que ninguno de los operandos sea literal, aunque lo más común es usar un literal del lado derecho. X se evalúa una sola vez. |
Cuando se evalúan valores que tienen un tipo de datos STRUCT para determinar la igualdad, es posible que uno o más campos sea NULL
. En esos casos:
- Si todos los valores que no son NULL son iguales, la comparación muestra NULL.
- Si el valor de algún campo no NULL no es igual, la comparación muestra FALSE.
En la siguiente tabla, se muestra cómo los tipos de datos STRUCT se comparan cuando tienen campos con 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
El operador IN
es compatible con las siguientes sintaxis:
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.
Los argumentos a ambos lados del operador IN
son expresiones generales.
Es habitual el uso de literales en la expresión de la derecha; sin embargo, esto no es obligatorio.
La semántica de
x IN (y, z, ...)
se define como equivalente a
(x = y) OR (x = z) OR ...
y las formas de subconsulta y arreglo se definen de forma similar.
x NOT IN ...
es equivalente a lo siguiente:
NOT(x IN ...)
El formulario UNNEST trata un análisis de arreglo como UNNEST
en la cláusula FROM:
x [NOT] IN UNNEST(<array expression>)
Este formulario se suele usar con parámetros ARRAY. Por ejemplo:
x IN UNNEST(@array_parameter)
Nota: Un ARRAY NULL
se tratará de forma equivalente a un ARRAY vacío.
Consulta el tema Arreglos para obtener información sobre cómo usar esta sintaxis.
Cuando se usa el operador IN
, se aplica la siguiente semántica:
IN
con una expresión vacía del lado derecho siempre es FALSEIN
con una expresiónNULL
del lado izquierdo y una expresión no vacía del lado derecho siempre esNULL
IN
conNULL
en la lista deIN
solo puede mostrar TRUE oNULL
, nunca FALSENULL IN (NULL)
muestraNULL
IN UNNEST(<NULL array>)
muestra FALSE (noNULL
)NOT IN
con unNULL
en la listaIN
solo puede mostrar FALSE oNULL
, nunca TRUE
IN
se puede usar con claves de varias partes mediante la sintaxis del constructor de struct.
Por ejemplo:
(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )
Consulta la sección Tipo Struct del tema Tipos de datos para obtener más información sobre la sintaxis.
Operadores IS
Los operadores IS muestran TRUE o FALSE para la condición que prueban. Nunca muestran NULL
, ni siquiera para entradas NULL
, a diferencia de la función IS_INF y la función IS_NAN que se definen en Funciones matemáticas. Si NOT está presente, el valor BOOL de salida se invierte.
Sintaxis de la función | Tipo de datos de entrada | Tipo de datos del resultado | Descripción |
---|---|---|---|
X IS [NOT] NULL |
Cualquier tipo de valor | BOOL | Muestra TRUE si el operando X se evalúa como NULL ; de lo contrario, muestra FALSE. |
X IS [NOT] TRUE |
BOOL | BOOL | Muestra TRUE si el operando BOOL se evalúa como TRUE. De lo contrario, muestra FALSE. |
X IS [NOT] FALSE |
BOOL | BOOL | Muestra TRUE si el operando BOOL se evalúa como FALSE. De lo contrario, muestra FALSE. |
Operador de concatenación
El operador de concatenación combina varios valores en uno.
Sintaxis de la función | Tipo de datos de entrada | Tipo de datos del resultado |
---|---|---|
STRING || STRING [ || ... ] |
STRING | STRING |
BYTES || BYTES [ || ... ] |
BYTES | STRING |
ARRAY<T> || ARRAY<T> [ || ... ] |
ARRAY<T> | ARRAY<T> |