Estas funciones de string funcionan en dos valores diferentes: tipos de datos STRING
y BYTES
. Los valores STRING
deben ser UTF-8 y tener el formato correcto.
Las funciones que muestran valores de posición, como STRPOS, codifican esas posiciones como INT64
. El valor 1
se refiere al primer carácter (o byte), 2
se refiere al segundo, y así sucesivamente.
El valor 0
indica un índice no válido. Cuando se trabaja en los tipos de STRING
, las posiciones que se muestran hacen referencia a las posiciones de los caracteres.
Todas las comparaciones de string se realizan byte a byte, sin importar la equivalencia canónica Unicode.
ASCII
ASCII(value)
Descripción
Muestra el código ASCII del primer carácter o byte en value
. Muestra 0
si el value
está vacío o el código ASCII es 0
para el primer carácter o byte.
Tipo de datos que se muestra
INT64
Ejemplos
SELECT ASCII('abcd') as A, ASCII('a') as B, ASCII('') as C, ASCII(NULL) as D;
+-------+-------+-------+-------+
| A | B | C | D |
+-------+-------+-------+-------+
| 97 | 97 | 0 | NULL |
+-------+-------+-------+-------+
BYTE_LENGTH
BYTE_LENGTH(value)
Descripción
Muestra la longitud del valor STRING
o BYTES
en BYTES
, sin importar si el tipo de valor es STRING
o BYTES
.
Tipo de datos que se muestra
INT64
Ejemplos
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)
Descripción
Muestra la longitud de STRING
en caracteres.
Tipo de datos que se muestra
INT64
Ejemplos
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)
Descripción
Sinónimo de CHAR_LENGTH.
Tipo de datos que se muestra
INT64
Ejemplos
WITH example AS
(SELECT "абвгд" AS characters)
SELECT
characters,
CHARACTER_LENGTH(characters) AS char_length_example
FROM example;
+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд | 5 |
+------------+---------------------+
CHR
CHR(value)
Descripción
Toma un punto de código Unicode y muestra el carácter que coincide con el punto de código. Cada punto de código válido debe estar dentro del rango de [0, 0xD7FF] y [0xE000, 0x10FFFF]. Muestra una string vacía si el punto de código es 0
. Se muestra un error si se especifica un punto de código Unicode no válido.
Para trabajar con un arreglo de puntos de código Unicode, consulta CODE_POINTS_TO_STRING
.
Tipo de datos que se muestra
STRING
Ejemplos
SELECT CHR(65) AS A, CHR(255) AS B, CHR(513) AS C, CHR(1024) AS D;
+-------+-------+-------+-------+
| A | B | C | D |
+-------+-------+-------+-------+
| A | ÿ | ȁ | Ѐ |
+-------+-------+-------+-------+
SELECT CHR(97) AS A, CHR(0xF9B5) AS B, CHR(0) AS C, CHR(NULL) AS D;
+-------+-------+-------+-------+
| A | B | C | D |
+-------+-------+-------+-------+
| a | 例 | | NULL |
+-------+-------+-------+-------+
CODE_POINTS_TO_BYTES
CODE_POINTS_TO_BYTES(ascii_values)
Descripción
Toma un arreglo de puntos de código ASCII extendidos (ARRAY
de INT64
) y muestra BYTES
.
Para convertir BYTES
en un arreglo de puntos de código, consulta TO_CODE_POINTS.
Tipo de datos que se muestra
BYTES
Ejemplos
El siguiente es un ejemplo básico que usa CODE_POINTS_TO_BYTES
.
SELECT CODE_POINTS_TO_BYTES([65, 98, 67, 100]) AS bytes;
-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'AbCd' is the result.
+----------+
| bytes |
+----------+
| QWJDZA== |
+----------+
En el siguiente ejemplo, se usa un algoritmo de rotación por 13 lugares (ROT13) para codificar una 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;
-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'Grfg Fgevat!' is the result.
+------------------+
| encoded_string |
+------------------+
| R3JmZyBGZ2V2YXQh |
+------------------+
CODE_POINTS_TO_STRING
CODE_POINTS_TO_STRING(value)
Descripción
Toma un arreglo de puntos de código Unicode (ARRAY
de INT64
) y muestra STRING
. Si un punto de código es 0, no muestra un carácter para él en la STRING
.
Para convertir una string en un arreglo de puntos de código, consulta TO_CODE_POINTS.
Tipo de datos que se muestra
STRING
Ejemplos
Los siguientes son ejemplos básicos del uso de CODE_POINTS_TO_STRING
.
SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;
+--------+
| string |
+--------+
| AÿȁЀ |
+--------+
SELECT CODE_POINTS_TO_STRING([97, 0, 0xF9B5]) AS string;
+--------+
| string |
+--------+
| a例 |
+--------+
SELECT CODE_POINTS_TO_STRING([65, 255, NULL, 1024]) AS string;
+--------+
| string |
+--------+
| NULL |
+--------+
En el siguiente ejemplo, se calcula la frecuencia de las letras en un conjunto de palabras.
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[, ...])
Descripción
Concatena uno o más valores en un solo resultado. Todos los valores deben ser BYTES
o tipos de datos que se puedan convertir en STRING
.
La función muestra NULL
si algún argumento de entrada es NULL
.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
SELECT CONCAT("T.P.", " ", "Bar") as author;
+---------------------+
| author |
+---------------------+
| T.P. Bar |
+---------------------+
SELECT CONCAT("Summer", " ", 1923) as release_date;
+---------------------+
| release_date |
+---------------------+
| Summer 1923 |
+---------------------+
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)
Descripción
Toma dos valores STRING
o BYTES
. Muestra TRUE
si el segundo valor es un sufijo del primero.
Tipo de datos que se muestra
BOOL
Ejemplos
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
BigQuery admite una función FORMAT()
para formatear strings. Esta función es similar a la función printf
de C. Produce una STRING
a partir de una string de formato que contiene cero o más especificadores de formato, junto con una lista de longitud variable de argumentos adicionales que coincide con los especificadores de formato.
A continuación, se incluyen algunos ejemplos:
Descripción | Statement | Resultado |
---|---|---|
Número entero simple | FORMAT("%d", 10) | 10 |
Número entero con relleno en blanco a la izquierda | FORMAT("|%10d|", 11) | | 11| |
Número entero con relleno de ceros a la izquierda | FORMAT("+%010d+", 12) | +0000000012+ |
Número entero con comas | 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 |
La función FORMAT()
no proporciona un formato personalizable por completo para todos los tipos y valores, ni un formato sensible a la configuración regional.
Si el formato personalizado es necesario para un tipo, primero debes formatearlo con funciones de formato específicas del tipo, como FORMAT_DATE()
o FORMAT_TIMESTAMP()
.
Por ejemplo:
SELECT FORMAT("date: %s!", FORMAT_DATE("%B %d, %Y", date '2015-01-02'));
Muestra
date: January 02, 2015!
Sintaxis
La sintaxis FORMAT()
toma una string de formato y una lista de argumentos de longitud variable y produce un resultado de STRING
:
FORMAT(format_string, ...)
La expresión format_string
puede contener cero o más especificadores de formato.
Cada especificador de formato se ingresa mediante el símbolo %
y debe asignarse a uno o más de los argumentos restantes. En general, esta es una asignación uno a uno, excepto cuando está presente el especificador *
. Por ejemplo, %.*i
se asigna a dos argumentos: uno de longitud y uno de número entero con signo. Si el número de argumentos relacionado con los especificadores de formato no es el mismo que el número de argumentos, se genera un error.
Especificadores de formato admitidos
El especificador de formato de función FORMAT()
sigue este prototipo:
%[flags][width][.precision]specifier
Los especificadores de formato admitidos se identifican en la siguiente tabla. Las desviaciones de printf() se identifican en cursiva.
Especificador | Descripción | Ejemplos | Tipos |
d o i |
Número entero decimal | 392 | INT64 |
o |
Octal | 610 | INT64* |
x |
Número entero hexadecimal | 7fa | INT64* |
X |
Número entero hexadecimal (mayúsculas) | 7FA | INT64* |
f |
Notación decimal, en [-](parte de número entero).(parte fraccionaria) para valores finitos y en minúsculas para valores no finitos | 392.650000 inf nan |
NUMERIC FLOAT64 |
F |
Notación decimal, en [-](parte de número entero).(parte fraccionaria) para valores finitos y en mayúsculas para valores no finitos | 392.650000 INF NAN |
NUMERIC FLOAT64 |
e |
Notación científica (mantisa/exponente), minúsculas | 3.926500e+02 inf nan |
NUMERIC FLOAT64 |
E |
Notación científica (mantisa/exponente), mayúsculas | 3.926500E+02 INF NAN |
NUMERIC FLOAT64 |
g |
Notación decimal o científica, según el exponente del valor de entrada y la precisión especificada. Minúscula. Consulta el comportamiento de %g y %G para obtener más detalles. | 392.65 3.9265e+07 inf nan |
NUMERIC FLOAT64 |
G |
Notación decimal o científica, según el exponente del valor de entrada y la precisión especificada. Mayúscula. Consulta el comportamiento de %g y %G para obtener más detalles. |
392.65 3.9265E+07 INF NAN |
NUMERIC FLOAT64 |
s |
String de caracteres | sample | STRING |
t |
Muestra una string imprimible que representa el valor. A menudo, se parece a convertir el tipo del argumento en STRING .
Consulta el comportamiento de %t y %T.
|
muestra 2014‑01‑01 |
<any> |
T |
Genera una string que es una constante válida de BigQuery con un tipo similar al tipo del valor (puede ser más amplio o una string). Consulta el comportamiento de %t y %T. |
'sample' b'bytes sample' 1234 2.3 date '2014‑01‑01' |
<any> |
% |
“%%” genera un solo “%” | % | No corresponde |
* Los especificadores %o
, %x
y %X
generan un error si se usan valores negativos.
El especificador de formato puede contener de forma opcional los subespecificadores identificados antes en el prototipo del especificador.
Estos subespecificadores deben cumplir con las siguientes especificaciones.
Marcas
Marcas | Descripción |
- |
Justificar a la izquierda dentro del ancho de campo dado; la justificación a la derecha es la predeterminada (ver subespecificador de ancho) |
+ |
Obliga a anteponer un signo más o menos al resultado (+ o - ) incluso para números positivos. De forma predeterminada, solo los números negativos van precedidos de un signo - |
<space> | Si no se va a escribir ningún signo, se inserta un espacio en blanco antes del valor. |
# |
|
0 |
Rellena a la izquierda del número con ceros (0) en lugar de espacios cuando se especifica el relleno (ver subespecificador de ancho). |
' |
Da formato a números enteros con el carácter de agrupación apropiado. Por ejemplo:
Esta marca solo es relevante para valores decimales, hexadecimales y octales. |
Las marcas se pueden especificar en cualquier orden. Las marcas duplicadas no son un error. Cuando las marcas no son relevantes para algún tipo de elemento, se ignoran.
Ancho
Ancho | Descripción |
<number> | Cantidad mínima de caracteres que se deben imprimir. Si el valor que se debe imprimir es más corto que este número, el resultado se rellena con espacios en blanco. El valor no se trunca aunque el resultado sea mayor. |
* |
El ancho no se especifica en la string de formato, sino como un argumento de número entero adicional que precede al argumento al que se debe dar formato. |
Precisión
Precisión | Descripción |
. <number> |
|
.* |
La precisión no se especifica en la string de formato, sino como un argumento de número entero adicional que precede al argumento al que se debe dar formato. |
Comportamiento de %g y %G
Los especificadores de formato %g
y %G
eligen la notación decimal (como los especificadores %f
y %F
) o la notación científica (como los especificadores %e
y %E
), según el exponente del valor de entrada y la precisión especificada.
Supongamos que p representa la precisión especificada (el valor predeterminado es 6; 1 si la precisión especificada es menor que 1). Primero el valor de entrada se convierte en notación científica con precisión = (p - 1). Si la parte x del exponente resultante es menor que -4 o no menor que p, se usa la notación científica con precisión = (p - 1); de lo contrario, se usa la notación decimal con precisión = (p - 1 - x).
A menos que esté presente la marca #
, se quitan los ceros finales después del punto decimal y el punto decimal si no hay dígitos después de este.
Comportamiento de %t y %T
Los especificadores de formato %t
y %T
están definidos para todos los tipos. El ancho, la precisión y las marcas actúan como lo hacen en %s
: el ancho es el ancho mínimo, la STRING
se rellenará hasta llegar a ese tamaño; y la precisión es el ancho máximo de contenido que se mostrará, la STRING
se truncará a ese tamaño, antes de rellenar el ancho.
El especificador %t
siempre debe ser un formato legible del valor.
El especificador %T
siempre es un literal de SQL válido de un tipo similar, como un tipo numérico más amplio.
El literal no incluirá conversiones de tipos o un nombre de tipo, excepto en el caso especial de los valores de punto flotante no finitos.
Se le da formato a la STRING
de la siguiente manera:
Tipo | %t | %T |
NULL de cualquier tipo |
NULL |
NULL |
INT64 |
123 | 123 |
NUMERIC | 123.0 (siempre con .0) | NUMERIC "123.0" |
FLOAT64 |
123.0 (siempre con .0) 123e+10 inf -inf NaN
|
123.0 (siempre con .0) 123e+10 CAST("inf" AS <type>) CAST("-inf" AS <type>) CAST("nan" AS <type>) |
STRING | valor de string sin comillas | literal de string entre comillas |
BYTES |
bytes escapados sin comillas p. ej., abc\x01\x02 |
literal de bytes entre comillas, p. ej., 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 | [value, value, …] ; aquí, los valores se formatean con %t |
[value, value, …] ; aquí, los valores se formatean con %T |
STRUCT | [value, value, …] ; aquí, los campos se formatean con %t |
[value, value, …] ; aquí, los campos se formatean con %T Casos especiales: cero campos: STRUCT() Un campo: STRUCT(value) |
Condiciones de error
Si un especificador de formato no es válido o no es compatible con el tipo de argumento relacionado, o si se proporciona número o argumentos incorrectos, se genera un error. Por ejemplo, las siguientes expresiones <format_string>
no son válidas:
FORMAT('%s', 1)
FORMAT('%')
Control de argumentos NULL
Una string de formato NULL
da como resultado una STRING
de resultado NULL
. Cualquier otro argumento se ignora en este caso.
Por lo general, la función produce un valor NULL
si hay un argumento NULL
presente.
Por ejemplo, FORMAT('%i', NULL_expression)
produce una NULL STRING
como resultado.
Sin embargo, existen algunas excepciones: si el especificador de formato es %t o %T (ambos producen STRING
s que coinciden de forma efectiva con la semántica de valores literales y CAST), un valor NULL
produce “NULL” (sin comillas) en la STRING
de resultado. Por ejemplo, la siguiente función:
FORMAT('00-%t-00', NULL_expression);
Muestra
00-NULL-00
Reglas semánticas adicionales
Los valores de FLOAT64
pueden ser +/-inf
o NaN
.
Cuando un argumento tiene uno de esos valores, el resultado de los especificadores de formato %f
, %F
, %e
, %E
, %g
, %G
y %t
son inf
, -inf
o nan
(o lo mismo en mayúsculas), según corresponda. Esto es coherente con la forma en que BigQuery convierte el tipo de estos valores en STRING
. En %T
, BigQuery muestra strings entre comillas para los valores FLOAT64
que no tienen representaciones literales que no sean de string.
FROM_BASE32
FROM_BASE32(string_expr)
Descripción
Convierte la entrada codificada en base32 string_expr
en el formato BYTES
. Para convertir BYTES
en una STRING
codificada en base32, usa TO_BASE32.
Tipo de datos que se muestra
BYTES
Ejemplo
SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;
-- Note that the result of FROM_BASE32 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| YWJjZGX/ |
+-----------+
FROM_BASE64
FROM_BASE64(string_expr)
Descripción
Convierte la string_expr
de entrada codificada en base64 en formato BYTES
. Para convertir BYTES
en una STRING
codificada en base64, usa TO_BASE64.
Tipo de datos que se muestra
BYTES
Ejemplo
SELECT FROM_BASE64('3q2+7w==') AS byte_data;
-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| 3q2+7w== |
+-----------+
FROM_HEX
FROM_HEX(string)
Descripción
Convierte una STRING
con codificación hexadecimal en formato BYTES
. Muestra un error si la STRING
de entrada contiene caracteres fuera del rango (0..9, A..F, a..f)
. No importa si los caracteres están en mayúsculas o minúsculas. Si la STRING
de entrada tiene una cantidad impar de caracteres, la función actúa como si la entrada tuviera un 0
inicial adicional. Para convertir BYTES
en una STRING
con codificación hexadecimal, usa TO_HEX.
Tipo de datos que se muestra
BYTES
Ejemplo
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;
-- Note that the result of FROM_HEX is of type BYTES, displayed as a base64-encoded string.
+------------------+--------------+
| hex_str | bytes_str |
+------------------+--------------+
| 0AF | AAECA6ru7/8= |
| 00010203aaeeefff | AK8= |
| 666f6f626172 | Zm9vYmFy |
+------------------+--------------+
INITCAP
INITCAP(value[, delimiters])
Descripción
Toma una STRING
y la muestra con el primer carácter en cada palabra en mayúsculas y todos los demás caracteres en minúsculas. Los caracteres que no son alfanuméricos no se modifican.
delimiters
es un argumento de string opcional que se usa para anular el conjunto predeterminado de caracteres usados a fin de separar palabras. Si no se especifica delimiters
, tomará de forma predeterminada los siguientes caracteres:
<whitespace> [ ] ( ) { } / | \ < > ! ? @ " ^ # $ & ~ _ , . : ; * % + -
Si value
o delimiters
es NULL
, la función mostrará NULL
.
Tipo de datos que se muestra
STRING
Ejemplos
WITH example AS
(
SELECT "Hello World-everyone!" AS value UNION ALL
SELECT "tHe dog BARKS loudly+friendly" AS value UNION ALL
SELECT "apples&oranges;&pears" AS value UNION ALL
SELECT "καθίσματα ταινιών" AS value
)
SELECT value, INITCAP(value) AS initcap_value FROM example
+-------------------------------+-------------------------------+
| value | initcap_value |
+-------------------------------+-------------------------------+
| Hello World-everyone! | Hello World-Everyone! |
| tHe dog BARKS loudly+friendly | The Dog Barks Loudly+Friendly |
| apples&oranges;&pears | Apples&Oranges;&Pears |
| καθίσματα ταινιών | Καθίσματα Ταινιών |
+-------------------------------+-------------------------------+
WITH example AS
(
SELECT "hello WORLD!" AS value, "" AS delimiters UNION ALL
SELECT "καθίσματα ταιντιώ@ν" AS value, "τ@" AS delimiters UNION ALL
SELECT "Apples1oranges2pears" AS value, "12" AS delimiters UNION ALL
SELECT "tHisEisEaESentence" AS value, "E" AS delimiters
)
SELECT value, delimiters, INITCAP(value, delimiters) AS initcap_value FROM example;
+----------------------+------------+----------------------+
| value | delimiters | initcap_value |
+----------------------+------------+----------------------+
| hello WORLD! | | Hello world! |
| καθίσματα ταιντιώ@ν | τ@ | ΚαθίσματΑ τΑιντΙώ@Ν |
| Apples1oranges2pears | 12 | Apples1Oranges2Pears |
| tHisEisEaESentence | E | ThisEIsEAESentence |
+----------------------+------------+----------------------+
INSTR
INSTR(source_value, search_value[, position[, occurrence]])
Descripción
Muestra el índice basado en 1 más bajo de search_value
en source_value
. 0 se muestra cuando no se encuentra ninguna coincidencia. source_value
y search_value
deben ser del mismo tipo, STRING
o BYTES
.
Si se especifica la position
, la búsqueda comienza en esta posición en source_value
; de lo contrario, empieza al principio del source_value
. Si la position
es negativa, la función busca hacia atrás desde el final del source_value
, con -1 que indica el último carácter. position
no puede ser 0.
Si se especifica occurrence
, la búsqueda muestra la posición de una instancia específica de search_value
en source_value
. De lo contrario, mostrará el índice del primer caso. Si occurrence
es mayor que la cantidad de coincidencias encontradas, se mostrará 0. Para occurrence
> 1, la función busca casos superpuestos, es decir, la función busca casos adicionales que comienzan con el segundo carácter en el caso anterior.
occurrence
no puede ser 0 ni negativo.
Tipo de datos que se muestra
INT64
Ejemplos
WITH example AS
(SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 2 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 3 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 3 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, -1 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, -3 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'ann' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'helloooo' as source_value, 'oo' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'helloooo' as source_value, 'oo' as search_value, 1 as position, 2 as
occurrence
)
SELECT source_value, search_value, position, occurrence, INSTR(source_value,
search_value, position, occurrence) AS instr
FROM example;
+--------------+--------------+----------+------------+-------+
| source_value | search_value | position | occurrence | instr |
+--------------+--------------+----------+------------+-------+
| banana | an | 1 | 1 | 2 |
| banana | an | 1 | 2 | 4 |
| banana | an | 1 | 3 | 0 |
| banana | an | 3 | 1 | 4 |
| banana | an | -1 | 1 | 4 |
| banana | an | -3 | 1 | 4 |
| banana | ann | 1 | 1 | 0 |
| helloooo | oo | 1 | 1 | 5 |
| helloooo | oo | 1 | 2 | 6 |
+--------------+--------------+----------+------------+-------+
LEFT
LEFT(value, length)
Descripción
Muestra un valor STRING
o BYTES
que consiste en la cantidad especificada de caracteres o bytes más a la izquierda de value
. length
es un INT64
que especifica la longitud del valor que se muestra. Si el value
es del tipo BYTES
, la length
es la cantidad de bytes que se encuentran más a la izquierda y que se mostrarán. Si value
es STRING
, la length
es la cantidad de caracteres más a la izquierda que se mostrarán.
Si la length
es 0, se mostrará un valor de STRING
o BYTES
vacío. Si la length
es negativa, se mostrará un error. Si la length
excede la cantidad de caracteres o bytes del value
, se mostrará el value
original.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
WITH examples AS
(SELECT 'apple' as example
UNION ALL
SELECT 'banana' as example
UNION ALL
SELECT 'абвгд' as example
)
SELECT example, LEFT(example, 3) AS left_example
FROM examples;
+---------+--------------+
| example | left_example |
+---------+--------------+
| apple | app |
| banana | ban |
| абвгд | абв |
+---------+--------------+
WITH examples AS
(SELECT b'apple' as example
UNION ALL
SELECT b'banana' as example
UNION ALL
SELECT b'\xab\xcd\xef\xaa\xbb' as example
)
SELECT example, LEFT(example, 3) AS left_example
FROM examples;
-- Note that the result of LEFT is of type BYTES, displayed as a base64-encoded string.
+----------+--------------+
| example | left_example |
+----------+--------------+
| YXBwbGU= | YXBw |
| YmFuYW5h | YmFu |
| q83vqrs= | q83v |
+----------+--------------+
LENGTH
LENGTH(value)
Descripción
Muestra la longitud del valor STRING
o BYTES
. El valor mostrado está en caracteres para los argumentos de STRING
y en bytes para el argumento de BYTES
.
Tipo de datos que se muestra
INT64
Ejemplos
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])
Descripción
Muestra un valor de STRING
o BYTES
que consta de original_value
con pattern
antepuesto. return_length
es un INT64
que especifica la longitud del valor mostrado. Si original_value
es del tipo BYTES
, return_length
es la cantidad de bytes. Si original_value
es del tipo STRING
, return_length
es la cantidad de caracteres.
El valor predeterminado de pattern
es un espacio en blanco.
original_value
y pattern
deben tener el mismo tipo de datos.
Si return_length
es menor o igual que la longitud de original_value
, esta función muestra el valor original_value
, truncado al valor de return_length
. Por ejemplo, LPAD("hello world", 7);
muestra "hello w"
.
Si original_value
, return_length
o pattern
es NULL
, esta función muestra NULL
.
Esta función muestra un error si se da una de estas condiciones:
return_length
es negativo.pattern
está vacía.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 | pattern | 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 | pattern | 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)
Descripción
Para los argumentos de STRING
, muestra la string original con todos los caracteres alfabéticos en minúsculas. La asignación entre minúsculas y mayúsculas se realiza de acuerdo con la base de datos de caracteres Unicode, sin tener en cuenta las asignaciones específicas del lenguaje.
Para los argumentos de BYTES
, el argumento se trata como texto ASCII, con todos los bytes mayores a 127 intactos.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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])
Descripción
Es idéntico a TRIM, pero solo quita caracteres iniciales.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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])
Descripción
Toma un valor de string y lo muestra como una string normalizada.
La normalización se usa para garantizar que dos strings sean equivalentes. La normalización suele usarse en situaciones en las que dos strings se renderizan de la misma forma en la pantalla, pero tienen puntos de código Unicode diferentes.
NORMALIZE
admite cuatro modos de normalización opcionales:
Valor | Nombre | Descripción |
---|---|---|
NFC | Composición canónica de la forma normalizada | Descompone y recompone los caracteres por equivalencia canónica. |
NFKC | Composición de compatibilidad de la forma normalizada | Descompone los caracteres por compatibilidad y los recompone por equivalencia canónica. |
NFD | Descomposición canónica de la forma normalizada | Descompone los caracteres por equivalencia canónica, y múltiples caracteres de combinación se organizan en un orden específico. |
NFKD | Descomposición de compatibilidad de la forma normalizada | Descompone los caracteres por compatibilidad, y múltiples caracteres de combinación se organizan en un orden específico. |
El modo de normalización predeterminado es NFC
.
Tipo de datos que se muestra
STRING
Ejemplos
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 |
+---+---+------------+
En el siguiente ejemplo, se normalizan diferentes caracteres de espacio.
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])
Descripción
Toma una STRING
, value
, y realiza las mismas acciones que NORMALIZE
, además de la combinación de mayúsculas y minúsculas para operaciones que no distinguen entre mayúsculas y minúsculas.
NORMALIZE_AND_CASEFOLD
admite cuatro modos de normalización opcionales:
Valor | Nombre | Descripción |
---|---|---|
NFC | Composición canónica de la forma normalizada | Descompone y recompone los caracteres por equivalencia canónica. |
NFKC | Composición de compatibilidad de la forma normalizada | Descompone los caracteres por compatibilidad y los recompone por equivalencia canónica. |
NFD | Descomposición canónica de la forma normalizada | Descompone los caracteres por equivalencia canónica, y múltiples caracteres de combinación se organizan en un orden específico. |
NFKD | Descomposición de compatibilidad de la forma normalizada | Descompone los caracteres por compatibilidad, y múltiples caracteres de combinación se organizan en un orden específico. |
El modo de normalización predeterminado es NFC
.
Tipo de datos que se muestra
STRING
Ejemplo
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 |
+---+----+-------+-------+------+------+
OCTET_LENGTH
OCTET_LENGTH(value)
Alias de BYTE_LENGTH
.
REGEXP_CONTAINS
REGEXP_CONTAINS(value, regexp)
Descripción
Muestra TRUE
si value
es una coincidencia parcial para la expresión regular, regexp
.
Si el argumento regexp
no es válido, la función muestra un error.
Puedes buscar una coincidencia completa con ^
(principio del texto) y $
(final del texto). Debido a la precedencia del operador de expresión regular, es una buena práctica encerrar entre paréntesis todo lo que está entre ^
y $
.
Tipo de datos que se muestra
BOOL
Ejemplos
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, regexp[, position[, occurrence]])
Descripción
Muestra la substring en el value
que coincide con la expresión regular, regexp
.
Muestra NULL
si no hay coincidencia.
Si la expresión regular contiene un grupo de captura, la función muestra la substring que coincide con él. Si la expresión no contiene un grupo de captura, la función muestra toda la substring coincidente.
Si se especifica la position
, la búsqueda comienza en esta posición en value
; de lo contrario, empieza al principio del value
. El valor position
debe ser un número entero positivo y no puede ser 0. Si el valor position
es mayor que la longitud de value
, se muestra NULL
.
Si se especifica occurrence
, la búsqueda mostrará un caso específico de regexp
en value
. De lo contrario, muestra la primera coincidencia. Si occurrence
es mayor que la cantidad de coincidencias encontradas, se mostrará NULL
. Para occurrence
> 1, la función busca casos adicionales que comienzan con el carácter que sigue al caso anterior.
Muestra un error si se da una de estas condiciones:
- La expresión regular no es válida.
- La expresión regular tiene más de un grupo de captura.
position
no es un número entero positivo.occurrence
no es un número entero positivo.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 |
+------------------+
WITH example AS
(SELECT 'Hello Helloo and Hellooo' AS value, 'H?ello+' AS regex, 1 as position,
1 AS occurrence UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 2 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 3 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 4 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 2, 1 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 1 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 2 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 3 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 20, 1 UNION ALL
SELECT 'cats&dogs&rabbits' ,'\\w+&', 1, 2 UNION ALL
SELECT 'cats&dogs&rabbits', '\\w+&', 2, 3
)
SELECT value, regex, position, occurrence, REGEXP_EXTRACT(value, regex,
position, occurrence) AS regexp_value FROM example;
+--------------------------+---------+----------+------------+--------------+
| value | regex | position | occurrence | regexp_value |
+--------------------------+---------+----------+------------+--------------+
| Hello Helloo and Hellooo | H?ello+ | 1 | 1 | Hello |
| Hello Helloo and Hellooo | H?ello+ | 1 | 2 | Helloo |
| Hello Helloo and Hellooo | H?ello+ | 1 | 3 | Hellooo |
| Hello Helloo and Hellooo | H?ello+ | 1 | 4 | NULL |
| Hello Helloo and Hellooo | H?ello+ | 2 | 1 | ello |
| Hello Helloo and Hellooo | H?ello+ | 3 | 1 | Helloo |
| Hello Helloo and Hellooo | H?ello+ | 3 | 2 | Hellooo |
| Hello Helloo and Hellooo | H?ello+ | 3 | 3 | NULL |
| Hello Helloo and Hellooo | H?ello+ | 20 | 1 | NULL |
| cats&dogs&rabbits | \w+& | 1 | 2 | dogs& |
| cats&dogs&rabbits | \w+& | 2 | 3 | NULL |
+--------------------------+---------+----------+------------+--------------+
REGEXP_EXTRACT_ALL
REGEXP_EXTRACT_ALL(value, regexp)
Descripción
Muestra un arreglo de todas las substrings de value
que coinciden con la expresión regular, regexp
.
La función REGEXP_EXTRACT_ALL
solo muestra coincidencias no superpuestas. Por ejemplo, usar esta función para extraer ana
de banana
muestra solo una substring, no dos.
Tipo de datos que se muestra
Un ARRAY
de STRING
o BYTES
Ejemplos
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_INSTR
REGEXP_INSTR(source_value, regexp [, position[, occurrence, [occurrence_position]]])
Descripción
Muestra el índice basado en 1 más bajo de una expresión regular, regexp
, en source_value
. Muestra 0
cuando no se encuentra ninguna coincidencia o la expresión regular está vacía. Muestra un error si la expresión regular no es válida o si tiene más de un grupo de captura. source_value
y regexp
deben ser del mismo tipo, STRING
o BYTES
.
Si se especifica la position
, la búsqueda comienza en esta posición en source_value
; de lo contrario, empieza al principio del source_value
. Si la position
es negativa, la función busca hacia atrás desde el final del source_value
, con -1 que indica el último carácter. position
no puede ser 0.
Si se especifica occurrence
, la búsqueda muestra la posición de una instancia específica de regexp
en source_value
. De lo contrario, mostrará el índice del primer caso. Si occurrence
es mayor que la cantidad de coincidencias encontradas, se mostrará 0. Para occurrence
> 1, la función busca casos superpuestos, es decir, la función busca casos adicionales que comienzan con el segundo carácter en el caso anterior.
occurrence
no puede ser 0 ni negativo.
De forma opcional, puedes usar occurrence_position
para especificar dónde comienza una posición en relación con un occurrence
. Tus opciones son las siguientes: + 0
, que muestra la posición inicial del caso, y
+ 1
, que muestra la primera posición después del final del caso. Si el final del caso también es el final de la entrada, se muestra uno al final del caso. Por ejemplo, la longitud de una string + 1.
Tipo de datos que se muestra
INT64
Ejemplos
WITH example AS (
SELECT 'ab@gmail.com' AS source_value, '@[^.]*' AS regexp UNION ALL
SELECT 'ab@mail.com', '@[^.]*' UNION ALL
SELECT 'abc@gmail.com', '@[^.]*' UNION ALL
SELECT 'abc.com', '@[^.]*')
SELECT source_value, regexp, REGEXP_INSTR(source_value, regexp) AS instr
FROM example;
+---------------+--------+-------+
| source_value | regexp | instr |
+---------------+--------+-------+
| ab@gmail.com | @[^.]* | 3 |
| ab@mail.com | @[^.]* | 3 |
| abc@gmail.com | @[^.]* | 4 |
| abc.com | @[^.]* | 0 |
+---------------+--------+-------+
WITH example AS (
SELECT 'a@gmail.com b@gmail.com' AS source_value, '@[^.]*' AS regexp, 1 AS position UNION ALL
SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 2 UNION ALL
SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 3 UNION ALL
SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 4)
SELECT
source_value, regexp, position,
REGEXP_INSTR(source_value, regexp, position) AS instr
FROM example;
+-------------------------+--------+----------+-------+
| source_value | regexp | position | instr |
+-------------------------+--------+----------+-------+
| a@gmail.com b@gmail.com | @[^.]* | 1 | 2 |
| a@gmail.com b@gmail.com | @[^.]* | 2 | 2 |
| a@gmail.com b@gmail.com | @[^.]* | 3 | 14 |
| a@gmail.com b@gmail.com | @[^.]* | 4 | 14 |
+-------------------------+--------+----------+-------+
WITH example AS (
SELECT 'a@gmail.com b@gmail.com c@gmail.com' AS source_value,
'@[^.]*' AS regexp, 1 AS position, 1 AS occurrence UNION ALL
SELECT 'a@gmail.com b@gmail.com c@gmail.com', '@[^.]*', 1, 2 UNION ALL
SELECT 'a@gmail.com b@gmail.com c@gmail.com', '@[^.]*', 1, 3)
SELECT
source_value, regexp, position, occurrence,
REGEXP_INSTR(source_value, regexp, position, occurrence) AS instr
FROM example;
+-------------------------------------+--------+----------+------------+-------+
| source_value | regexp | position | occurrence | instr |
+-------------------------------------+--------+----------+------------+-------+
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1 | 1 | 2 |
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1 | 2 | 14 |
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1 | 3 | 26 |
+-------------------------------------+--------+----------+------------+-------+
WITH example AS (
SELECT 'a@gmail.com' AS source_value, '@[^.]*' AS regexp,
1 AS position, 1 AS occurrence, 0 AS o_position UNION ALL
SELECT 'a@gmail.com', '@[^.]*', 1, 1, 1)
SELECT
source_value, regexp, position, occurrence, o_position,
REGEXP_INSTR(source_value, regexp, position, occurrence, o_position) AS instr
FROM example;
+--------------+--------+----------+------------+------------+-------+
| source_value | regexp | position | occurrence | o_position | instr |
+--------------+--------+----------+------------+------------+-------+
| a@gmail.com | @[^.]* | 1 | 1 | 0 | 2 |
| a@gmail.com | @[^.]* | 1 | 1 | 1 | 8 |
+--------------+--------+----------+------------+------------+-------+
REGEXP_REPLACE
REGEXP_REPLACE(value, regexp, replacement)
Descripción
Muestra una STRING
en la que todas las substrings de value
que coinciden con la expresión regular regexp
se reemplazan por replacement
.
Puedes usar dígitos con escape de barras invertidas (de \1 a \9) dentro del argumento replacement
para insertar texto que coincida con el grupo entre paréntesis correspondiente en el patrón regexp
. Usa \0 para hacer referencia a todo el texto coincidente.
La función REGEXP_REPLACE
solo reemplaza las coincidencias no superpuestas. Por ejemplo, si se reemplaza ana
dentro de banana
, ocurre un solo reemplazo, no dos.
Si el argumento regexp
no es una expresión regular válida, esta función muestra un error.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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> |
+--------------------------+
REGEXP_SUBSTR
REGEXP_SUBSTR(value, regexp[, position[, occurrence]])
Descripción
Sinónimo de REGEXP_EXTRACT
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
WITH example AS
(SELECT 'Hello World Helloo' AS value, 'H?ello+' AS regex, 1 AS position, 1 AS
occurrence
)
SELECT value, regex, position, occurrence, REGEXP_SUBSTR(value, regex,
position, occurrence) AS regexp_value FROM example;
+--------------------+---------+----------+------------+--------------+
| value | regex | position | occurrence | regexp_value |
+--------------------+---------+----------+------------+--------------+
| Hello World Helloo | H?ello+ | 1 | 1 | Hello |
+--------------------+---------+----------+------------+--------------+
REPLACE
REPLACE(original_value, from_value, to_value)
Descripción
Reemplaza todos los casos de from_value
por to_value
en original_value
.
Si from_value
está vacío, no se realiza ningún reemplazo.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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)
Descripción
Muestra un valor STRING
o BYTES
que consta de original_value
, repetido.
El parámetro repetitions
especifica la cantidad de veces que se debe repetir original_value
. Muestra NULL
si original_value
o repetitions
son NULL
.
Esta función muestra un error si el valor de repetitions
es negativo.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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)
Descripción
Muestra la inversa de STRING
o BYTES
de entrada.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 |
+---------------+----------------+--------------+---------------+
RIGHT
RIGHT(value, length)
Descripción
Muestra un valor STRING
o BYTES
que consiste en la cantidad especificada de caracteres o bytes más a la derecha de value
. length
es un INT64
que especifica la longitud del valor que se muestra. Si value
es BYTES
, length
es la cantidad de bytes que se muestran más a la derecha. Si value
es STRING
, length
es la cantidad de caracteres más a la derecha que se muestran.
Si la length
es 0, se mostrará un valor de STRING
o BYTES
vacío. Si la length
es negativa, se mostrará un error. Si la length
excede la cantidad de caracteres o bytes del value
, se mostrará el value
original.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
WITH examples AS
(SELECT 'apple' as example
UNION ALL
SELECT 'banana' as example
UNION ALL
SELECT 'абвгд' as example
)
SELECT example, RIGHT(example, 3) AS right_example
FROM examples;
+---------+---------------+
| example | right_example |
+---------+---------------+
| apple | ple |
| banana | ana |
| абвгд | вгд |
+---------+---------------+
WITH examples AS
(SELECT b'apple' as example
UNION ALL
SELECT b'banana' as example
UNION ALL
SELECT b'\xab\xcd\xef\xaa\xbb' as example
)
SELECT example, RIGHT(example, 3) AS right_example
FROM examples;
-- Note that the result of RIGHT is of type BYTES, displayed as a base64-encoded string.
+----------+---------------+
| example | right_example |
+----------+---------------+
| YXBwbGU= | cGxl |
| YmFuYW5h | YW5h |
| q83vqrs= | 76q7 |
+----------+---------------+
RPAD
RPAD(original_value, return_length[, pattern])
Descripción
Muestra un valor STRING
o BYTES
que consta de original_value
con pattern
agregado. El parámetro return_length
es un INT64
que especifica la longitud del valor mostrado. Si original_value
es BYTES
, return_length
es la cantidad de bytes. Si original_value
es STRING
, return_length
es la cantidad de caracteres.
El valor predeterminado de pattern
es un espacio en blanco.
original_value
y pattern
deben tener el mismo tipo de datos.
Si return_length
es menor o igual que la longitud de original_value
, esta función muestra el valor original_value
, truncado al valor de return_length
. Por ejemplo, RPAD("hello world", 7);
muestra "hello w"
.
Si original_value
, return_length
o pattern
es NULL
, esta función muestra NULL
.
Esta función muestra un error si se da una de estas condiciones:
return_length
es negativo.pattern
está vacía.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 | pattern | 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 | pattern | 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])
Descripción
Es idéntico a TRIM, pero solo quita caracteres finales.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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)
Descripción
Convierte una secuencia de BYTES
en una STRING
. Los caracteres UTF-8 no válidos se reemplazan por el carácter de reemplazo de Unicode, U+FFFD
.
Tipo de datos que se muestra
STRING
Ejemplos
La siguiente instrucción muestra el carácter de reemplazo de Unicode, �.
SELECT SAFE_CONVERT_BYTES_TO_STRING(b'\xc2') as safe_convert;
SOUNDEX
SOUNDEX(value)
Descripción
Muestra una STRING
que representa el código de Soundex del value
.
SOUNDEX produce una representación fonética de una string. Indexa palabras por sonido, como se pronuncia en inglés. Por lo general, se usa para determinar si dos strings, por ejemplo, nombres de familias, como Levine o Lavine, o las palabras to y too, tienen una pronunciación similar en inglés.
El resultado de SOUNDEX consta de una letra seguida de 3 dígitos. Los caracteres que no sean latinos se ignorarán. Si la string restante está vacía después de quitar los caracteres que no son latinos, se mostrará una STRING
vacía.
Tipo de datos que se muestra
STRING
Ejemplos
WITH example AS (
SELECT 'Ashcraft' AS value UNION ALL
SELECT 'Raven' AS value UNION ALL
SELECT 'Ribbon' AS value UNION ALL
SELECT 'apple' AS value UNION ALL
SELECT 'Hello world!' AS value UNION ALL
SELECT ' H3##!@llo w00orld!' AS value UNION ALL
SELECT '#1' AS value UNION ALL
SELECT NULL AS value
)
SELECT value, SOUNDEX(value) AS soundex
FROM example;
+----------------------+---------+
| value | soundex |
+----------------------+---------+
| Ashcraft | A261 |
| Raven | R150 |
| Ribbon | R150 |
| apple | a140 |
| Hello world! | H464 |
| H3##!@llo w00orld! | H464 |
| #1 | |
| NULL | NULL |
+----------------------+---------+
SPLIT
SPLIT(value[, delimiter])
Descripción
Divide value
mediante el argumento delimiter
.
Para STRING
, el delimitador predeterminado es la coma ,
.
Para BYTES
, debes especificar un delimitador.
La división en un delimitador vacío produce un arreglo de caracteres UTF-8 para los valores de STRING
y un arreglo de BYTES
para los valores de BYTES
.
Dividir una STRING
vacía muestra un ARRAY
con una única STRING
vacía.
Tipo de datos que se muestra
ARRAY
de tipo STRING
o ARRAY
de tipo BYTES
Ejemplos
WITH letters AS
(SELECT "" as letter_group
UNION ALL
SELECT "a" as letter_group
UNION ALL
SELECT "b c d" as letter_group)
SELECT SPLIT(letter_group, " ") as example
FROM letters;
+----------------------+
| example |
+----------------------+
| [] |
| [a] |
| [b, c, d] |
+----------------------+
STARTS_WITH
STARTS_WITH(value1, value2)
Descripción
Toma dos valores STRING
o BYTES
. Muestra TRUE
si el segundo valor es un prefijo del primero.
Tipo de datos que se muestra
BOOL
Ejemplos
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)
Descripción
Muestra el índice basado en 1 del primer caso de substring
dentro de string
. Muestra 0
si no se encuentra substring
.
Tipo de datos que se muestra
INT64
Ejemplos
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])
Descripción
Muestra una substring del valor STRING
o BYTES
proporcionado. El argumento position
es un número entero que especifica la posición inicial de la substring, en el que position = 1 indica el primer carácter o byte. El argumento length
es la cantidad máxima de caracteres para los argumentos STRING
o bytes para los argumentos BYTES
.
Si position
es negativo, la función cuenta desde el final de value
, y -1 indica el último carácter.
Si position
es una posición más allá del extremo izquierdo de la STRING
(position
= 0 o position
< -LENGTH(value)
), la función comienza desde position = 1. Si length
excede la longitud de value
, la función muestra menos caracteres que length
.
Si length
es menor que 0, la función muestra un error.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 |
+---------+
SUBSTRING
SUBSTRING(value, position[, length])
Alias de SUBSTR
.
TO_BASE32
TO_BASE32(bytes_expr)
Descripción
Convierte una secuencia de BYTES
en una STRING
codificada en base32. Para convertir una STRING
codificada en base32 en BYTES
, usa FROM_BASE32.
Tipo de datos que se muestra
STRING
Ejemplo
SELECT TO_BASE32(b'abcde\xFF') AS base32_string;
+------------------+
| base32_string |
+------------------+
| MFRGGZDF74====== |
+------------------+
TO_BASE64
TO_BASE64(bytes_expr)
Descripción
Convierte una secuencia de BYTES
en una STRING
codificada en base64. Para convertir una STRING
codificada en base64 en BYTES
, usa FROM_BASE64.
Tipo de datos que se muestra
STRING
Ejemplo
SELECT TO_BASE64(b'\xde\xad\xbe\xef') AS base64_string;
+---------------+
| base64_string |
+---------------+
| 3q2+7w== |
+---------------+
TO_CODE_POINTS
TO_CODE_POINTS(value)
Descripción
Toma un valor y muestra un arreglo de INT64
.
- Si
value
es unaSTRING
, cada elemento del arreglo que se muestra representa un punto de código. Cada punto de código está dentro del rango entre [0, 0xD7FF] y [0xE000, 0x10FFFF]. - Si
value
esBYTES
, cada elemento del arreglo es un valor de caracteres ASCII extendido en el rango [0, 255].
Para convertir un arreglo de puntos de código en STRING
o BYTES
, consulta CODE_POINTS_TO_STRING o CODE_POINTS_TO_BYTES.
Tipo de datos que se muestra
ARRAY
de INT64
Ejemplos
En el siguiente ejemplo, se obtienen los puntos de código para cada elemento de un arreglo de palabras.
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] |
+---------+------------------------------------+
En el siguiente ejemplo, se convierten representaciones de números enteros de BYTES
en sus valores de caracteres ASCII correspondientes.
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] |
+------------------+------------------------+
En el siguiente ejemplo, se muestra la diferencia entre un resultado de BYTES
y un resultado de STRING
.
SELECT TO_CODE_POINTS(b'Ā') AS b_result, TO_CODE_POINTS('Ā') AS s_result;
+------------+----------+
| b_result | s_result |
+------------+----------+
| [196, 128] | [256] |
+------------+----------+
Observa que el carácter, Ā, se representa como una secuencia Unicode de dos bytes. Como resultado, la versión BYTES
de TO_CODE_POINTS
muestra un arreglo con dos elementos, mientras que la versión STRING
muestra un arreglo con un solo elemento.
TO_HEX
TO_HEX(bytes)
Descripción
Convierte una secuencia de BYTES
en una STRING
hexadecimal. Convierte cada byte de la STRING
en dos caracteres hexadecimales dentro del rango (0..9, a..f)
. Para convertir una STRING
con codificación hexadecimal en BYTES
, usa FROM_HEX.
Tipo de datos que se muestra
STRING
Ejemplo
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 |
+----------------------------------+------------------+
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
| foobar | 666f6f626172 |
+----------------------------------+------------------+
TRANSLATE
TRANSLATE(expression, source_characters, target_characters)
Descripción
En expression
, reemplaza cada carácter de source_characters
por el carácter correspondiente en target_characters
. Todas las entradas deben ser del mismo tipo, STRING
o BYTES
.
- Cada carácter en
expression
se traduce una vez como máximo. - Un carácter en
expression
que no está presente ensource_characters
se deja sin cambios enexpression
. - Un carácter en
source_characters
sin un carácter correspondiente entarget_characters
se omite del resultado. - Un carácter duplicado en
source_characters
genera un error.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
WITH example AS (
SELECT 'This is a cookie' AS expression, 'sco' AS source_characters, 'zku' AS
target_characters UNION ALL
SELECT 'A coaster' AS expression, 'co' AS source_characters, 'k' as
target_characters
)
SELECT expression, source_characters, target_characters, TRANSLATE(expression,
source_characters, target_characters) AS translate
FROM example;
+------------------+-------------------+-------------------+------------------+
| expression | source_characters | target_characters | translate |
+------------------+-------------------+-------------------+------------------+
| This is a cookie | sco | zku | Thiz iz a kuukie |
| A coaster | co | k | A kaster |
+------------------+-------------------+-------------------+------------------+
TRIM
TRIM(value1[, value2])
Descripción
Quita todos los caracteres iniciales y finales que coinciden con value2
. Si no se especifica value2
, se quitan todos los caracteres de espacio en blanco iniciales y finales (como se define en el estándar Unicode). Si el primer argumento es de tipo BYTES
, el segundo argumento es obligatorio.
Si value2
contiene más de un carácter o byte, la función quita todos los caracteres o bytes iniciales o finales que contiene value2
.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 |
+---------+
UNICODE
UNICODE(value)
Descripción
Muestra el punto de código Unicode para el primer carácter en value
. Muestra 0
si value
está vacío o si el punto de código Unicode resultante es 0
.
Tipo de datos que se muestra
INT64
Ejemplos
SELECT UNICODE('âbcd') as A, UNICODE('â') as B, UNICODE('') as C, UNICODE(NULL) as D;
+-------+-------+-------+-------+
| A | B | C | D |
+-------+-------+-------+-------+
| 226 | 226 | 0 | NULL |
+-------+-------+-------+-------+
UPPER
UPPER(value)
Descripción
Para los argumentos de STRING
, muestra la string original con todos los caracteres alfabéticos en mayúsculas. La asignación entre mayúsculas y minúsculas se realiza de acuerdo con la base de datos de caracteres Unicode, sin tener en cuenta las asignaciones específicas del lenguaje.
Para los argumentos de BYTES
, el argumento se trata como texto ASCII, con todos los bytes mayores a 127 intactos.
Tipo de datos que se muestra
STRING
o BYTES
Ejemplos
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 |
+---------+