Funciones de string

Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

SQL estándar de Google para BigQuery es compatible con las funciones de string. 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 una posición no válida. 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_code_points)

Descripción

Toma un array de puntos de código ASCII extendidos como ARRAY<INT64> y muestra BYTES.

Para convertir BYTES en un array 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(unicode_code_points)

Descripción

Toma un array de puntos de código Unicode como ARRAY<INT64> y muestra STRING.

Para convertir una string en un array 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            |
+--------+--------------+

COLLATE

COLLATE(value, collate_specification)

Toma una STRING y una especificación de intercalación. Muestra un STRING con una especificación de intercalación. Si collate_specification está vacío, muestra un valor con intercalación quitada de STRING.

La especificación de intercalación define cómo la STRING resultante se puede comparar y ordenar. Para obtener más información, consulta Trabaja con intercalación.

  • collation_specification debe ser un literal de string; de lo contrario, se muestra un error.
  • Muestra NULL si value es NULL.

Tipo de datos que se muestra

STRING

Ejemplos

En este ejemplo, el peso de a es menor que el peso de Z. Esto se debe a que la especificación de intercalación und:ci asigna más peso a Z.

WITH Words AS (
  SELECT
    COLLATE('a', 'und:ci') AS char1,
    COLLATE('Z', 'und:ci') AS char2
)
SELECT ( Words.char1 < Words.char2 ) AS a_less_than_Z
FROM Words;

+----------------+
| a_less_than_Z  |
+----------------+
| TRUE           |
+----------------+

En este ejemplo, el peso de a es mayor que el peso de Z. Esto se debe a que la especificación de intercalación predeterminada asigna más peso a a.

WITH Words AS (
  SELECT
    'a' AS char1,
    'Z' AS char2
)
SELECT ( Words.char1 < Words.char2 ) AS a_less_than_Z
FROM Words;

+----------------+
| a_less_than_Z  |
+----------------+
| FALSE          |
+----------------+

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         |
+---------------------+

CONTAINS_SUBSTR

CONTAINS_SUBSTR(expression, search_value_literal)

Descripción

Realiza una búsqueda normalizada que no distingue entre mayúsculas y minúsculas para ver si existe un valor en una expresión. Muestra TRUE si el valor existe; de lo contrario, muestra FALSE.

El valor de búsqueda debe ser un literal STRING, pero no el literal NULL.

La expresión puede ser una referencia de columna o tabla. Una referencia de tabla se evalúa como STRUCT cuyos campos son las columnas de la tabla. Una referencia de columna se evalúa como uno de los siguientes tipos de datos:

  • STRING
  • INT64
  • BOOL
  • NUMERIC
  • BIGNUMERIC
  • TIMESTAMP
  • TIME
  • DATE
  • DATETIME
  • ARRAY
  • STRUCT

Cuando se evalúa la expresión, el resultado se convierte en un STRING, y luego la función busca el valor de la búsqueda en el resultado. Si el valor de búsqueda es NULL, se produce un error. Si la expresión es NULL, el valor que se muestra es NULL.

Puedes realizar una búsqueda de campo cruzado en una expresión que se evalúa como STRUCT o ARRAY. Si la expresión se evalúa como STRUCT, la búsqueda de campo cruzado es recurrente y, además, incluye todos los subcampos dentro de STRUCT.

En una búsqueda de campo cruzado, cada campo y subcampo se convierte de manera individual en una string y se busca por el valor. La función muestra TRUE si al menos un campo incluye el valor de búsqueda. De lo contrario, si al menos un campo es NULL, muestra NULL. De no ser así, si no se encuentra el valor de búsqueda y todos los campos no son NULL, muestra FALSE.

Antes de comparar los valores, se normalizan y se combinan con la normalización NFKC. No se admiten las búsquedas con comodines.

Tipo de datos que se muestra

BOOL

Ejemplos

En la siguiente consulta, se muestra TRUE porque se encontró esta coincidencia que no distingue entre mayúsculas y minúsculas: blue house y Blue house.

SELECT CONTAINS_SUBSTR('the blue house', 'Blue house') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

La siguiente consulta muestra FALSE porque no se encontró blue en the red house.

SELECT CONTAINS_SUBSTR('the red house', 'blue') AS result;

+--------+
| result |
+--------+
| false  |
+--------+

En la siguiente consulta, se muestra TRUE porque y IX representan el mismo valor normalizado.

SELECT '\u2168 day' AS a, 'IX' AS b, CONTAINS_SUBSTR('\u2168', 'IX') AS result;

+----------------------+
| a      | b  | result |
+----------------------+
| Ⅸ day | IX | true   |
+----------------------+

La siguiente consulta muestra TRUE porque 35 se encontró dentro de un campo STRUCT.

SELECT CONTAINS_SUBSTR((23, 35, 41), '35') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

La siguiente consulta muestra TRUE, ya que se encontró jk durante una búsqueda recurrente dentro de una STRUCT.

SELECT CONTAINS_SUBSTR(('abc', ['def', 'ghi', 'jkl'], 'mno'), 'jk');

+--------+
| result |
+--------+
| true   |
+--------+

La siguiente consulta muestra TRUE porque las NULL se ignoran cuando se encuentra una coincidencia dentro de un STRUCT o ARRAY.

SELECT CONTAINS_SUBSTR((23, NULL, 41), '41') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

La siguiente consulta muestra NULL porque un NULL existía en una STRUCT que no generó una coincidencia.

SELECT CONTAINS_SUBSTR((23, NULL, 41), '35') AS result;

+--------+
| result |
+--------+
| null   |
+--------+

En la siguiente consulta, se genera un error porque el valor de búsqueda no puede ser un literal NULL.

SELECT CONTAINS_SUBSTR('hello', NULL) AS result;
-- Throws an error

En los siguientes ejemplos, se hace referencia a una tabla llamada Recipes que puedes emular con una cláusula WITH que se de la siguiente manera:

WITH Recipes AS
 (SELECT 'Blueberry pancakes' as Breakfast, 'Egg salad sandwich' as Lunch, 'Potato dumplings' as Dinner UNION ALL
  SELECT 'Potato pancakes', 'Toasted cheese sandwich', 'Beef stroganoff' UNION ALL
  SELECT 'Ham scramble', 'Steak avocado salad', 'Tomato pasta' UNION ALL
  SELECT 'Avocado toast', 'Tomato soup', 'Blueberry salmon' UNION ALL
  SELECT 'Corned beef hash', 'Lentil potato soup', 'Glazed ham')
SELECT * FROM Recipes;

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Bluberry pancakes | Egg salad sandwich      | Potato dumplings |
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
| Ham scramble      | Steak avocado salad     | Tomato pasta     |
| Avocado toast     | Tomato soup             | Blueberry samon  |
| Corned beef hash  | Lentil potato soup      | Glazed ham       |
+-------------------+-------------------------+------------------+

La siguiente consulta busca en todas las columnas de la tabla Recipes el valor toast y muestra las filas que contienen este valor.

SELECT * FROM Recipes WHERE CONTAINS_SUBSTR(Recipes, 'toast');

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
| Avocado toast     | Tomato soup             | Blueberry samon  |
+-------------------+-------------------------+------------------+

La siguiente consulta busca en las columnas Lunch y Dinner de la tabla Recipe el valor potato y muestra la fila si alguna de las columnas contiene este valor.

SELECT * FROM Recipes WHERE CONTAINS_SUBSTR((Lunch, Dinner), 'potato');

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Bluberry pancakes | Egg salad sandwich      | Potato dumplings |
| Corned beef hash  | Lentil potato soup      | Glazed ham       |
+-------------------+-------------------------+------------------+

Las siguientes consultas realizan búsquedas en todas las columnas de la tabla Recipes, excepto en las columnas Lunch y Dinner. Muestran las filas de cualquier columna que no sea Lunch o Dinner que contienen el valor potato.

SELECT *
FROM Recipes
WHERE CONTAINS_SUBSTR(
  (SELECT AS STRUCT Recipes.* EXCEPT (Lunch, Dinner)),
  'potato'
);

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
+-------------------+-------------------------+------------------+

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.

Esta función admite la especificación de la intercalación.

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

FORMAT(format_string_expression, data_type_expression[, ...])

Descripción

FORMAT da formato a una expresión de tipo de datos como una string.

  • format_string_expression: 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.
  • data_type_expression: El valor que se va a formatear como una string. Puede ser cualquier tipo de datos de SQL estándar de Google.

Tipo de datos que se muestra

STRING

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!

Especificadores de formato admitidos

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

Un especificador de formato agrega formato cuando se convierte un valor en una string. De forma opcional, puede contener estos subespecificadores:

Información adicional sobre los especificadores de formato:

Especificadores de formato
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
BIGNUMERIC
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
BIGNUMERIC
FLOAT64
e Notación científica (mantisa/exponente), minúsculas 3.926500e+02
inf
nan
NUMERIC
BIGNUMERIC
FLOAT64
E Notación científica (mantisa/exponente), mayúsculas 3.926500E+02
INF
NAN
NUMERIC
BIGNUMERIC
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
BIGNUMERIC
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
BIGNUMERIC
FLOAT64
p Produce una string imprimible de una línea que representa JSON. Consulta el comportamiento de %p y %P.

{"month":10,"year":2019}
JSON
P Produce una string imprimible de varias líneas que representa JSON. Consulta el comportamiento de %p y %P.

{
  "month": 10,
  "year": 2019
}
JSON
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. sample
2014‑01‑01
<any>
T Genera una string que es una constante SQL estándar de Google válida con un tipo similar al tipo del valor (quizás más ancho o tal vez 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%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.
#
  • Para “%o”, “%x” y “%X”, esta marca significa que se debe anteponer 0, 0x o 0X a los valores distintos de cero, de forma respectiva.
  • Para “%f”, “%F”, “%e” y “%E”, esta marca significa que se debe agregar el punto decimal, incluso cuando no hay una parte fraccionaria, a menos que el valor sea no finito.
  • En el caso de “%g” y “%G”, esta marca significa que se debe agregar el punto decimal, incluso cuando no hay una parte fraccionaria, a menos que el valor sea no finito, y que nunca se deben quitar los ceros finales después del punto decimal.
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:

  • FORMAT("%'d", 12345678) muestra 12,345,678
  • FORMAT("%'x", 12345678) muestra bc:614e
  • FORMAT("%'o", 55555) muestra 15,4403
  • 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>
  • Para especificadores de números enteros “%d”, “%i”, “%o”, “%u”, “%x” y “%X”: la precisión especifica la cantidad mínima de dígitos que se escribirán. Si el valor que se debe escribir es más corto que este número, el resultado se rellena con ceros finales. El valor no se trunca aunque el resultado sea más largo. Una precisión de 0 significa que no se escribe ningún carácter para el valor 0.
  • Para los especificadores “%a”, “%A”, “%e”, “%E”, “%f” y “%F”: esta es la cantidad de dígitos que se imprimirán después del punto decimal. El valor predeterminado es 6.
  • Para los especificadores “%g” y “%G”: esta es la cantidad de dígitos significativos que se imprimirán antes de quitar los ceros finales después del punto decimal. El valor predeterminado es 6.
.* 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 %p y %P

El especificador de formato %p produce una string imprimible de una línea. El especificador de formato %P produce una string imprimible de varias líneas. Puedes usar estos especificadores de formato con los siguientes tipos de datos:

Tipo %p %P
JSON

Entrada de JSON:


JSON '
{
  "month": 10,
  "year": 2019
}
'

Produce una string imprimible de una línea que representa JSON:


{"month":10,"year":2019}

Entrada de JSON:


JSON '
{
  "month": 10,
  "year": 2019
}
'

Produce una string imprimible de varias líneas que representa JSON:


{
  "month": 10,
  "year": 2019
}
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"
INTERVAL 1-2 3 4:5:6.789 INTERVAL "1-2 3 4:5:6.789" YEAR TO SECOND
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)
JSON String imprimible de una línea que representa JSON.

{"name":"apple","stock":3}
String imprimible de una línea que representa un literal de JSON.

JSON '{"name":"apple","stock":3}'
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 STRINGs 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 SQL estándar de Google envía estos valores a la STRING. Para %T, SQL estándar de Google muestra strings entrecomilladas para los valores FLOAT64 que no tienen representaciones literales que no son 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.

Hay varias codificaciones en base64 en uso común que varían exactamente en qué alfabeto de 65 caracteres ASCII se usa para codificar los 64 dígitos y el relleno. Consulta RFC 4648 para obtener más detalles. Esta función espera el alfabeto [A-Za-z0-9+/=].

Tipo de datos que se muestra

BYTES

Ejemplo

SELECT FROM_BASE64('/+A=') AS byte_data;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| /+A=      |
+-----------+

Para trabajar con una codificación mediante un alfabeto base64 diferente, es posible que debas componer FROM_BASE64 con la función REPLACE. Por ejemplo, la codificación segura para URL y nombres de archivo, base64url, que se usa comúnmente en la programación web, usa -_= como los últimos caracteres en lugar de +/=. Para decodificar una string codificada en base64url, reemplaza - y _ por + y /, respectivamente.

SELECT FROM_BASE64(REPLACE(REPLACE('_-A=', '-', '+'), '_', '/')) AS binary;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+--------+
| binary |
+--------+
| /+A=   |
+--------+

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 la posición 1 más baja de search_value en source_value. 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 en 1, que es el comienzo de source_value. Si la position es negativa, la función busca hacia atrás desde el final del source_value, con -1 indicando el último carácter. position es del tipo INT64 y 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. Si no se especifica, el valor predeterminado de occurrence es 1 y muestra la posición del primer caso. Para occurrence > 1, la función incluye casos superpuestos. occurrence es del tipo INT64 y debe ser positivo.

Esta función admite la especificación de la intercalación.

Muestra 0 si se cumplen estas condiciones:

  • No se encontró ninguna coincidencia.
  • Si occurrence es mayor que la cantidad de coincidencias encontradas.
  • Si position es mayor que la longitud de source_value.

Muestra NULL si se cumplen estas condiciones:

  • Cualquier argumento de entrada es NULL.

Muestra un error si se da una de estas condiciones:

  • position es 0.
  • occurrence es 0 o 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. Si no proporcionas un modo de normalización, se usa NFC.

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.

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);

+---+---+------------+
| 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 un valor de string y lo muestra como una string normalizada. Si no proporcionas un modo de normalización, se usa NFC.

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.

El establecimiento de mayúsculas o minúsculas se usa para la comparación de strings sin mayúsculas. Si necesitas comparar strings y no se debe considerar el uso de mayúsculas o minúsculas, usa NORMALIZE_AND_CASEFOLD. De lo contrario, usa NORMALIZE.

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.

Tipo de datos que se muestra

STRING

Ejemplos

SELECT
  a, b,
  NORMALIZE(a) = NORMALIZE(b) as normalized,
  NORMALIZE_AND_CASEFOLD(a) = NORMALIZE_AND_CASEFOLD(b) as normalized_with_case_folding
FROM (SELECT 'The red barn' AS a, 'The Red Barn' AS b);

+--------------+--------------+------------+------------------------------+
| a            | b            | normalized | normalized_with_case_folding |
+--------------+--------------+------------+------------------------------+
| The red barn | The Red Barn | false      | true                         |
+--------------+--------------+------------+------------------------------+
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<STRING> o ARRAY<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 la posición basada en 1 más bajo de una expresión regular, regexp, en source_value. 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 en 1, que es el comienzo de source_value. position es del tipo INT64 y debe ser positivo.

Si se especifica occurrence, la búsqueda muestra la posición de una instancia específica de regexp en source_value. Si no se especifica, el valor predeterminado de occurrence es 1 y muestra la posición del primer caso. Para occurrence > 1, la función busca el siguiente caso que no se superpone. occurrence es del tipo INT64 y debe ser positivo.

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: Muestra la posición de inicio de occurrence.
  • 1: Muestra la posición final de occurrence + 1. Si el final del caso está al final de source_value, se muestra LENGTH(source_value) + 1.

Muestra 0 si se cumplen estas condiciones:

  • No se encontró ninguna coincidencia.
  • Si occurrence es mayor que la cantidad de coincidencias encontradas.
  • Si position es mayor que la longitud de source_value.
  • La expresión regular está vacía.

Muestra NULL si se cumplen estas condiciones:

  • position es NULL.
  • occurrence es NULL.

Muestra un error si se da una de estas condiciones:

  • position es 0 o negativo.
  • occurrence es 0 o negativo.
  • occurrence_position no es 0 ni 1.
  • La expresión regular no es válida.
  • La expresión regular tiene más de un grupo de captura.

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.

Para agregar una barra inversa a tu expresión regular, primero debes escaparla. Por ejemplo, SELECT REGEXP_REPLACE('abc', 'b(.)', 'X\\1'); muestra aXc. También puedes usar strings sin procesar para quitar una capa de escape, por ejemplo, SELECT REGEXP_REPLACE('abc', 'b(.)', r'X\1');.

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.

Esta función admite la especificación de la intercalación.

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(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 ,.</