Funções de string suportadas pelo Lindorm SQL - Lindorm: Central de Documentação do Alibaba Cloud

Funções de string suportadas

Categoria	Função	Descrição
Manipulação geral	CONCAT	Concatena várias strings em uma única string
	LENGTH	Retorna o número de caracteres em uma string
	REPLACE	Substitui todas as ocorrências de uma substring
	REVERSE	Inverte uma string
	SUBSTR	Extrai uma substring por posição e comprimento
	TRIM	Remove espaços à esquerda e à direita
Conversão de maiúsculas/minúsculas	LOWER	Converte todas as letras para minúsculas
	UPPER	Converte todas as letras para maiúsculas
Expressões regulares	REGEXP_REPLACE	Substitui substrings correspondentes a uma expressão regular
	REGEXP_SUBSTR	Extrai a primeira substring correspondente a uma expressão regular
Correspondência de prefixo	START_WITH	Retorna true se uma string começar com um determinado prefixo
Busca full-text	MATCH	Compara valores de coluna com uma expressão de busca usando um índice de busca
Hashes criptográficos	MD5	Retorna o hash MD5 de uma string
	SHA256	Retorna o hash SHA256 de uma string

CONCAT

Concatena duas ou mais strings em uma única string. Nenhum delimitador é adicionado entre os valores.

Sintaxe

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

Parâmetros

Parâmetro	Obrigatório	Descrição
`'string1', 'string2', ..., 'stringN'`	Sim	Strings a concatenar. Informe dois ou mais valores de string.

Exemplo

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

Resultado:

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

LENGTH

Retorna o número de caracteres em uma string.

Sintaxe

LENGTH('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a ser medida.

Exemplo

SELECT length('abc') AS len;

Resultado:

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

LOWER

Converte todas as letras de uma string para minúsculas. Caracteres não alfabéticos permanecem inalterados.

Sintaxe

LOWER('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a converter.

Exemplos

Exemplo 1: Converter ABC para minúsculas.

SELECT lower('ABC') AS val;

Resultado:

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

Exemplo 2: Converter uma string com caixa mista para minúsculas.

SELECT lower('Abc') AS val;

Resultado:

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

UPPER

Converte todas as letras de uma string para maiúsculas. Caracteres não alfabéticos permanecem inalterados.

Sintaxe

UPPER('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a converter.

Exemplos

Exemplo 1: Converter abc para maiúsculas.

SELECT upper('abc') AS val;

Resultado:

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

Exemplo 2: Converter uma string com caixa mista para maiúsculas.

SELECT upper('aBC') AS val;

Resultado:

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

TRIM

Remove espaços à esquerda e à direita de uma string. Os espaços internos são preservados.

Sintaxe

TRIM('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a ser aparada.

Exemplo

SELECT trim(' abc    ') AS str;

Resultado:

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

REPLACE

Substitui todas as ocorrências de uma substring em uma string.

Sintaxe

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

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String de origem.
`from_str`	Sim	Substring a encontrar e substituir.
`to_str`	Sim	Substring de substituição.

Exemplos

Exemplo 1: Substituir bc em abc por cd.

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

Resultado:

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

Exemplo 2: Substituir todas as ocorrências de bc em abcbc por cd.

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

Resultado:

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

REVERSE

Inverte os caracteres de uma string.

Sintaxe

REVERSE('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a inverter.

Exemplo

SELECT reverse('abc') AS val;

Resultado:

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

SUBSTR

Extrai uma substring a partir de uma posição específica, com limite opcional de comprimento.

Sintaxe

SUBSTR(string, position [, length])

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String de origem.
`position`	Sim	Posição inicial da extração (base 1). Deve ser um inteiro >= 1.
`length`	Não	Número de caracteres a extrair. Deve ser um inteiro >= 1. Padrão: extrai da `position` até o final da string.

Exemplos

Exemplo 1: Extrair da posição 2 até o final da string.

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

Resultado:

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

Exemplo 2: Extrair 2 caracteres a partir da posição 1.

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

Resultado:

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

START_WITH

Retorna true se uma string começar com o prefixo especificado e false caso contrário.

Sintaxe

START_WITH('string', 'prefix')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String a verificar.
`prefix`	Sim	Prefixo a comparar com o início da `string`.

Exemplos

Exemplo 1: Verificar se abc começa com ab.

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

Resultado:

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

Exemplo 2: Verificar se abc começa com bc.

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

Resultado:

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

REGEXP_REPLACE

Substitui substrings correspondentes a uma expressão regular, iniciando a busca em uma posição especificada.

Sintaxe

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

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String de origem.
`pattern`	Sim	Padrão de expressão regular que define a regra de correspondência.
`replacement`	Sim	String substituta para cada correspondência.
`position`	Não	Posição do caractere (base 1) para iniciar a busca. Deve ser um inteiro >= 1. Padrão: `1` (inicia no primeiro caractere).

Exemplos

Exemplo 1: Substituir todas as correspondências de b em abc por c (posição padrão).

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

Resultado:

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

Exemplo 2: Substituir correspondências de b em abcbc a partir da posição 2.

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

Resultado:

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

Exemplo 3: Substituir correspondências de b em abcbc a partir da posição 3. O b na posição 2 não é substituído.

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

Resultado:

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

REGEXP_SUBSTR

Retorna a primeira substring correspondente a uma expressão regular, iniciando a busca em uma posição especificada.

Sintaxe

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

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String de origem.
`pattern`	Sim	Padrão de expressão regular que define a regra de correspondência.
`position`	Não	Posição do caractere (base 1) para iniciar a busca. Deve ser um inteiro >= 1. Padrão: `1` (inicia no primeiro caractere).

Exemplos

Exemplo 1: Buscar b em abc a partir do primeiro caractere (padrão).

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

Resultado:

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

Exemplo 2: Buscar b em abc a partir da posição 3. Nenhuma correspondência é encontrada porque b está na posição 2.

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

Resultado:

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

MD5

Retorna o hash MD5 de uma string.

Sintaxe

MD5('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String para gerar hash.

Exemplo

SELECT md5('abc') AS val;

Resultado:

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

SHA256

Retorna o hash SHA256 de uma string.

Sintaxe

SHA256('string')

Parâmetros

Parâmetro	Obrigatório	Descrição
`string`	Sim	String para gerar hash.

Exemplo

Este exemplo cria uma tabela de amostra, insere uma linha e consulta o hash SHA256 de um valor de coluna.

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

Função CONTAINS

Verifica se uma string contém uma substring especificada.

Sintaxe

`CONTAINS`('string1', 'string2')

Importante

contains é uma palavra-chave não reservada em SQL e deve estar entre crases ( ).

Parâmetros

Parâmetro	Obrigatório	Descrição
string1	Sim	String onde buscar.
string2	Sim	Substring a procurar.

Exemplos

Exemplo 1: Verificar se a string abc contém a substring bc.

SELECT `contains`('abc', 'bc') AS val;

Resultado:

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

Exemplo 2: Verificar se a string abc contém a substring cd.

SELECT `contains`('abc', 'cd') AS val;

Resultado:

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

MATCH

Busca valores de coluna usando uma expressão de busca full-text e um índice de busca. Por padrão, os resultados são classificados por relevância em ordem decrescente.

Importante

MATCH exige LindormTable 2.7.2 ou posterior. Para atualizar, consulte as Notas de versão do LindormTable e Atualize sua instância.
MATCH funciona apenas com índices de busca. Se houver uma condição MATCH e um índice de busca, o sistema usará o índice automaticamente.

Notas de uso

Colunas não indexadas: O sistema recupera primeiro as linhas pelo índice de busca e depois filtra as colunas não indexadas linha a linha. Isso pode degradar o desempenho em grandes conjuntos de dados. Para evitar esse problema, use a instrução ADD COLUMN para adicionar as colunas relevantes ao índice de busca.
Tabelas primárias e índices secundários: MATCH não é suportado em tabelas primárias ou índices secundários. Nesses casos, use LIKE para consultas fuzzy. Consultas fuzzy têm desempenho inferior às consultas tokenizadas.
Combinação de MATCH e LIKE: Ao usar ambas na mesma consulta, configure as colunas relevantes como colunas tokenizadas no índice de busca.

Sintaxe

MATCH (column_identifiers) AGAINST (search_expr)

Use MATCH apenas na cláusula WHERE de uma instrução SELECT.

Parâmetros

Parâmetro	Obrigatório	Descrição
`column_identifiers`	Sim	Um ou mais nomes de coluna para buscar, separados por vírgulas. Se houver múltiplas colunas, seus valores serão combinados e comparados. Devem existir índices de busca para todas as colunas especificadas, com analisadores configurados para segmentação de palavras. Consulte Ativar o recurso de índice de busca e CREATE INDEX.
`search_expr`	Sim	Constante de string que define a regra de correspondência. Consulte a seção Sintaxe de regras de correspondência abaixo.

Sintaxe de regras de correspondência

Uma regra de correspondência consiste em uma ou mais condições separadas por espaços. Cada condição pode ser:

Uma única palavra — corresponde a linhas que contêm essa palavra. Exemplo: hello
Uma frase entre aspas — corresponde a linhas que contêm a frase exata, sem segmentação de palavras. Exemplo: "hello world"
Uma sub-regra entre parênteses — corresponde a linhas que satisfazem a regra incluída. Exemplo: (another "hello world")

Adicione um símbolo antes de uma condição para alterar seu comportamento:

Símbolo	Significado
`+`	A condição deve ser atendida (AND)
`-`	A condição não deve ser atendida (NOT)
(nenhum)	A condição é opcional, mas as linhas correspondentes têm classificação mais alta

Exemplos

Os exemplos a seguir usam esta tabela de amostra:

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

Exemplo 1: Retornar linhas onde c1 contenha hello ou world (ou ambos). Linhas correspondentes a ambos os termos têm classificação mais alta.

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

Exemplo 2: Retornar linhas onde c1 deve conter world e opcionalmente contenha hello. Linhas com ambos os termos têm classificação mais alta.

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

Resultado:

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

Exemplo 3: Retornar linhas onde c1 contenha world, mas não hello.

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

Resultado:

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

Exemplo 4: Retornar linhas onde c1 contenha a frase exata hello world.

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

Resultado:

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

Exemplo 5: Retornar linhas onde c1 deve conter hello e pelo menos um dos termos you ou me.

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

Resultado:

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