String functions supported by Lindorm SQL - Lindorm - Centro de documentación de Alibaba Cloud

Lindorm SQL incluye un conjunto de funciones de cadenas para manipular, buscar y generar hash de valores de texto. Todas las funciones descritas en esta página requieren LindormTable 2.5.1.1 o posterior.

Para comprobar su versión actual o actualizarla, consulte Release notes of LindormTable y Upgrade the minor engine version of a Lindorm instance .

Funciones de cadenas compatibles

Categoría	Función	Descripción
Manipulación general	CONCAT	Concatena varias cadenas en una sola
	LENGTH	Devuelve el número de caracteres de una cadena
	REPLACE	Reemplaza todas las apariciones de una subcadena
	REVERSE	Invierte una cadena
	SUBSTR	Extrae una subcadena por posición y longitud
	TRIM	Elimina los espacios al inicio y al final
Conversión de mayúsculas y minúsculas	LOWER	Convierte todas las letras a minúsculas
	UPPER	Convierte todas las letras a mayúsculas
Expresiones regulares	REGEXP_REPLACE	Reemplaza subcadenas que coinciden con una expresión regular
	REGEXP_SUBSTR	Extrae la primera subcadena que coincide con una expresión regular
Coincidencia de prefijos	START_WITH	Devuelve true si una cadena comienza con un prefijo dado
Búsqueda de texto completo	MATCH	Compara valores de columna con una expresión de búsqueda mediante un índice de búsqueda
Hash criptográficos	MD5	Devuelve el hash MD5 de una cadena
	SHA256	Devuelve el hash SHA256 de una cadena

CONCAT

Concatena dos o más cadenas en una sola. No se agrega ningún delimitador entre los valores.

Sintaxis

CONCAT('string1', 'string2', ..., 'stringN')

Parámetros

Parámetro	Obligatorio	Descripción
`'string1', 'string2', ..., 'stringN'`	Sí	Las cadenas que se van a concatenar. Pase dos o más valores de cadena.

Ejemplo

SELECT concat('a', 'b', 'c') AS val;

Resultado:

+-----+
| val |
+-----+
| abc |
+-----+

LENGTH

Devuelve el número de caracteres de una cadena.

Sintaxis

LENGTH('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena que se va a medir.

Ejemplo

SELECT length('abc') AS len;

Resultado:

+-----+
| len |
+-----+
| 3   |
+-----+

LOWER

Convierte todas las letras de una cadena a minúsculas. Los caracteres que no son letras no se ven afectados.

Sintaxis

LOWER('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena que se va a convertir.

Ejemplos

Ejemplo 1: Convertir ABC a minúsculas.

SELECT lower('ABC') AS val;

Resultado:

+-----+
| val |
+-----+
| abc |
+-----+

Ejemplo 2: Convertir una cadena con mayúsculas y minúsculas combinadas a minúsculas.

SELECT lower('Abc') AS val;

Resultado:

+-----+
| val |
+-----+
| abc |
+-----+

UPPER

Convierte todas las letras de una cadena a mayúsculas. Los caracteres que no son letras no se ven afectados.

Sintaxis

UPPER('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena que se va a convertir.

Ejemplos

Ejemplo 1: Convertir abc a mayúsculas.

SELECT upper('abc') AS val;

Resultado:

+-----+
| val |
+-----+
| ABC |
+-----+

Ejemplo 2: Convertir una cadena con mayúsculas y minúsculas combinadas a mayúsculas.

SELECT upper('aBC') AS val;

Resultado:

+-----+
| val |
+-----+
| ABC |
+-----+

TRIM

Elimina los espacios al inicio y al final de una cadena. Los espacios dentro de la cadena se conservan.

Sintaxis

TRIM('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena a la que se le eliminarán los espacios.

Ejemplo

SELECT trim(' abc    ') AS str;

Resultado:

+-----+
| str |
+-----+
| abc |
+-----+

REPLACE

Reemplaza todas las apariciones de una subcadena dentro de una cadena.

Sintaxis

REPLACE('string', 'from_str', 'to_str')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de origen.
`from_str`	Sí	La subcadena que se va a buscar y reemplazar.
`to_str`	Sí	La subcadena de reemplazo.

Ejemplos

Ejemplo 1: Reemplazar bc en abc por cd.

SELECT replace('abc', 'bc', 'cd') AS val;

Resultado:

+-----+
| val |
+-----+
| acd |
+-----+

Ejemplo 2: Reemplazar todas las apariciones de bc en abcbc por cd.

SELECT replace('abcbc', 'bc', 'cd') AS val;

Resultado:

+-------+
|  val  |
+-------+
| acdcd |
+-------+

REVERSE

Invierte los caracteres de una cadena.

Sintaxis

REVERSE('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena que se va a invertir.

Ejemplo

SELECT reverse('abc') AS val;

Resultado:

+-----+
| val |
+-----+
| cba |
+-----+

SUBSTR

Extrae una subcadena a partir de una posición dada, con un límite de longitud opcional.

Sintaxis

SUBSTR(string, position [, length])

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de origen.
`position`	Sí	La posición base 1 donde comienza la extracción. Debe ser un entero >= 1.
`length`	No	El número de caracteres que se van a extraer. Debe ser un entero >= 1. Valor predeterminado: extrae desde `position` hasta el final de la cadena.

Ejemplos

Ejemplo 1: Extraer desde la posición 2 hasta el final de la cadena.

SELECT substr('abc', 2) AS val;

Resultado:

+-----+
| val |
+-----+
| bc  |
+-----+

Ejemplo 2: Extraer 2 caracteres a partir de la posición 1.

SELECT substr('abc', 1, 2) AS val;

Resultado:

+-----+
| val |
+-----+
| ab  |
+-----+

START_WITH

Devuelve true si una cadena comienza con el prefijo especificado, y false en caso contrario.

Sintaxis

START_WITH('string', 'prefix')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena que se va a comprobar.
`prefix`	Sí	El prefijo que se comparará con el inicio de `string`.

Ejemplos

Ejemplo 1: Comprobar si abc comienza con ab.

SELECT start_with('abc', 'ab') AS val;

Resultado:

+------+
| val  |
+------+
| true |
+------+

Ejemplo 2: Comprobar si abc comienza con bc.

SELECT start_with('abc', 'bc') AS val;

Resultado:

+-------+
| val   |
+-------+
| false |
+-------+

REGEXP_REPLACE

Reemplaza las subcadenas que coinciden con una expresión regular, comenzando la búsqueda desde una posición especificada.

Sintaxis

REGEXP_REPLACE('string', pattern, replacement [, position])

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de origen.
`pattern`	Sí	El patrón de expresión regular que define la regla de coincidencia.
`replacement`	Sí	La cadena que sustituirá cada coincidencia.
`position`	No	La posición de carácter base 1 donde se inicia la búsqueda. Debe ser un entero >= 1. Valor predeterminado: `1` (comienza desde el primer carácter).

Ejemplos

Ejemplo 1: Reemplazar todas las coincidencias de b en abc por c (posición predeterminada).

SELECT regexp_replace('abc', 'b', 'c') AS val;

Resultado:

+-----+
| val |
+-----+
| acc |
+-----+

Ejemplo 2: Reemplazar las coincidencias de b en abcbc a partir de la posición 2.

SELECT regexp_replace('abcbc', 'b', 'c', 2) AS val;

Resultado:

+-------+
|  val  |
+-------+
| acccc |
+-------+

Ejemplo 3: Reemplazar las coincidencias de b en abcbc a partir de la posición 3. La b en la posición 2 no se reemplaza.

SELECT regexp_replace('abcbc', 'b', 'c', 3) AS val;

Resultado:

+-------+
|  val  |
+-------+
| abccc |
+-------+

REGEXP_SUBSTR

Devuelve la primera subcadena que coincide con una expresión regular, comenzando la búsqueda desde una posición especificada.

Sintaxis

REGEXP_SUBSTR('string', pattern [, position])

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de origen.
`pattern`	Sí	El patrón de expresión regular que define la regla de coincidencia.
`position`	No	La posición de carácter base 1 donde se inicia la búsqueda. Debe ser un entero >= 1. Valor predeterminado: `1` (comienza desde el primer carácter).

Ejemplos

Ejemplo 1: Buscar b en abc desde el primer carácter (valor predeterminado).

SELECT regexp_substr('abc', 'b') AS val;

Resultado:

+-----+
| val |
+-----+
| b   |
+-----+

Ejemplo 2: Buscar b en abc a partir de la posición 3. No se encuentra ninguna coincidencia porque b está en la posición 2.

SELECT regexp_substr('abc', 'b', 3) AS val;

Resultado:

+-----+
| val |
+-----+
|     |
+-----+

MD5

Devuelve el hash MD5 de una cadena.

Sintaxis

MD5('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de la que se obtendrá el hash.

Ejemplo

SELECT md5('abc') AS val;

Resultado:

+----------------------------------+
|               val                |
+----------------------------------+
| 900150983cd24fb0d6963f7d28e17f72 |
+----------------------------------+

SHA256

Devuelve el hash SHA256 de una cadena.

Sintaxis

SHA256('string')

Parámetros

Parámetro	Obligatorio	Descripción
`string`	Sí	La cadena de la que se obtendrá el hash.

Ejemplo

Este ejemplo crea una tabla de muestra, inserta una fila y luego consulta el hash SHA256 del valor de una columna.

-- Create a sample table.
CREATE TABLE tb (id INT, name VARCHAR, address VARCHAR, PRIMARY KEY(id, name));

-- Insert a row.
UPSERT INTO tb (id, name, address) VALUES (1, 'jack', 'hz');

-- Query the SHA256 hash of the name column.
SELECT sha256(name) AS sc FROM tb WHERE id = 1;

Resultado:

+------------------------------------------------------------------+
|                                sc                                |
+------------------------------------------------------------------+
| 31611159e7e6ff7843ea4627745e89225fc866621cfcfdbd40871af4413747cc |
+------------------------------------------------------------------+

MATCH

Busca valores de columna mediante una expresión de búsqueda de texto completo y un índice de búsqueda. Los resultados se ordenan por relevancia en orden descendente de forma predeterminada.

Importante

MATCH requiere LindormTable 2.7.2 o posterior. Para actualizar, consulte Release notes of LindormTable y upgrade your instance.
MATCH solo funciona con índices de búsqueda. Cuando existen tanto una condición MATCH como un índice de búsqueda, el sistema utiliza el índice de búsqueda automáticamente.

Notas de uso

Columnas no indexadas: El sistema primero recupera filas mediante el índice de búsqueda y luego filtra las columnas no indexadas fila por fila. Esto puede degradar el rendimiento en conjuntos de datos grandes. Para evitarlo, utilice la instrucción ADD COLUMN para agregar las columnas relevantes al índice de búsqueda.
Tablas principales e índices secundarios: MATCH no es compatible con tablas principales ni índices secundarios. Para estos casos, utilice LIKE para consultas difusas. Las consultas difusas ofrecen un rendimiento inferior al de las consultas tokenizadas.
Combinación de MATCH y LIKE: Al usar ambos en la misma consulta, configure las columnas relevantes como tokenized columns en el índice de búsqueda.

Sintaxis

MATCH (column_identifiers) AGAINST (search_expr)

MATCH solo se puede utilizar en la cláusula WHERE de una instrucción SELECT.

Parámetros

Parámetro	Obligatorio	Descripción
`column_identifiers`	Sí	Uno o más nombres de columna donde buscar, separados por comas. Si se especifican varias columnas, sus valores se combinan y se comparan juntos. Deben existir índices de búsqueda para todas las columnas especificadas, con analizadores configurados para la segmentación de palabras. Consulte Enable the search index feature y CREATE INDEX.
`search_expr`	Sí	Una constante de cadena que define la regla de coincidencia. Consulte Match rule syntax a continuación.

Sintaxis de reglas de coincidencia

Una regla de coincidencia consta de una o más condiciones separadas por espacios. Cada condición puede ser:

Una sola palabra: coincide con filas que contienen esa palabra. Ejemplo: hello
Una frase entre comillas: coincide con filas que contienen la frase exacta sin segmentación de palabras. Ejemplo: "hello world"
Una subregla entre paréntesis: coincide con filas que satisfacen la regla encerrada. Ejemplo: (another "hello world")

Anteponga un símbolo a una condición para cambiar su comportamiento:

Símbolo	Significado
`+`	La condición debe cumplirse (AND)
`-`	La condición no debe cumplirse (NOT)
(ninguno)	La condición es opcional, pero las filas coincidentes tienen mayor clasificación

Ejemplos

Los siguientes ejemplos utilizan esta tabla de muestra:

-- Create a sample table.
CREATE TABLE tb (id INT, c1 VARCHAR, PRIMARY KEY(id));

-- Create a search index. Enable the search index feature before running this statement.
CREATE INDEX idx USING SEARCH ON tb (c1(type=text));

-- Insert rows.
UPSERT INTO tb (id, c1) VALUES (1, 'hello');
UPSERT INTO tb (id, c1) VALUES (2, 'world');
UPSERT INTO tb (id, c1) VALUES (3, 'hello world');
UPSERT INTO tb (id, c1) VALUES (4, 'hello my world');
UPSERT INTO tb (id, c1) VALUES (5, 'hello you');
UPSERT INTO tb (id, c1) VALUES (6, 'hello you and me');
UPSERT INTO tb (id, c1) VALUES (7, 'you and me');

Ejemplo 1: Devolver filas donde c1 contenga hello o world (o ambos). Las filas que coinciden con ambos términos tienen mayor clasificación.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('hello world');

Resultado:

+----+------------------+
| id |        c1        |
+----+------------------+
| 3  | hello world      |
| 2  | world            |
| 4  | hello my world   |
| 5  | hello you        |
| 1  | hello            |
| 6  | hello you and me |
+----+------------------+

Ejemplo 2: Devolver filas donde c1 deba contener world y opcionalmente contenga hello. Las filas con ambos términos tienen mayor clasificación.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('hello +world');

Resultado:

+----+----------------+
| id |       c1       |
+----+----------------+
| 3  | hello world    |
| 2  | world          |
| 4  | hello my world |
+----+----------------+

Ejemplo 3: Devolver filas donde c1 contenga world pero no hello.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('-hello +world');

Resultado:

+----+-------+
| id |  c1   |
+----+-------+
| 2  | world |
+----+-------+

Ejemplo 4: Devolver filas donde c1 contenga la frase exacta hello world.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('"hello world"');

Resultado:

+----+-------------+
| id |     c1      |
+----+-------------+
| 3  | hello world |
+----+-------------+

Ejemplo 5: Devolver filas donde c1 deba contener hello y al menos uno de you o me.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('+hello +(you me)');

Resultado:

+----+------------------+
| id |        c1        |
+----+------------------+
| 6  | hello you and me |
| 5  | hello you        |
+----+------------------+