Funções de string - AnalyticDB: Central de Documentação do Alibaba Cloud

ASCII

ascii(str)

Retorna o valor decimal ASCII do caractere mais à esquerda de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada ou caractere único

Tipo de retorno: BIGINT

Exemplos:

SELECT ascii('2');

+------------+
| ascii('2') |
+------------+
|         50 |
+------------+

SELECT ascii('dx');

+-------------+
| ascii('dx') |
+-------------+
|         100 |
+-------------+

BIN

bin(N)

Retorna a representação em string binária de N.

Parâmetro	Tipo	Descrição
`N`	BIGINT	Inteiro a converter

Tipo de retorno: VARCHAR

Notas de uso:

Se N for NULL, a função retorna NULL.

Exemplo:

SELECT bin(12);

+---------+
| bin(12) |
+---------+
| 1100    |
+---------+

BIT_LENGTH

bit_length(str)

Retorna o comprimento de str em bits.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: BIGINT

Exemplos:

SELECT bit_length('text');

+--------------------+
| bit_length('text') |
+--------------------+
|                 32 |
+--------------------+

SELECT bit_length('China');

+---------------------+
| bit_length('China') |
+---------------------+
|                  40 |
+---------------------+

CHAR

char(N1, N2, ...)

Retorna uma string composta pelos caracteres correspondentes aos códigos ASCII decimais de N1, N2 e assim por diante.

Parâmetro	Tipo	Descrição
`N1, N2, ...`	BIGINT	Um ou mais códigos ASCII inteiros

Tipo de retorno: VARBINARY

Exemplo:

SELECT char(97,110,97,108,121,116,105,99,100,98);

+-------------------------------------------+
| char(97,110,97,108,121,116,105,99,100,98) |
+-------------------------------------------+
| analyticdb                                |
+-------------------------------------------+

CHAR_LENGTH ou CHARACTER_LENGTH

char_length(str)
character_length(str)

Retorna o comprimento de str em caracteres.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: BIGINT

Notas de uso:

Cada caractere chinês conta como 1.

Exemplos:

SELECT char_length('China');

+----------------------+
| char_length('China') |
+----------------------+
|                    5 |
+----------------------+

SELECT char_length('abc');

+--------------------+
| char_length('abc') |
+--------------------+
|                  3 |
+--------------------+

CONCAT

concat(str1, ..., strN)

Concatena várias strings em uma única string.

Parâmetro	Tipo	Descrição
`str1, ..., strN`	VARCHAR	Duas ou mais strings para concatenar

Tipo de retorno: VARCHAR

Notas de uso:

Se qualquer argumento for NULL, o valor retornado será NULL.

Exemplos:

SELECT concat('aliyun', ', ', 'analyticdb');

+--------------------------------------+
| concat('aliyun', ', ', 'analyticdb') |
+--------------------------------------+
| aliyun, analyticdb                   |
+--------------------------------------+

SELECT concat('abc', null, 'def');

+--------------------------+
| concat('abc',null,'def') |
+--------------------------+
| NULL                     |
+--------------------------+

CONCAT_WS

concat_ws(separator, str1, ..., strN)

Concatena várias strings usando um separador especificado. Valores NULL entre os argumentos de string são ignorados.

Parâmetro	Tipo	Descrição
`separator`	VARCHAR	Delimitador inserido entre cada string
`str1, ..., strN`	VARCHAR	Strings a concatenar

Tipo de retorno: VARCHAR

Notas de uso:

Argumentos de string NULL são ignorados e não produzem separadores duplos nem valores vazios na saída.

Exemplos:

SELECT concat_ws(',', 'First name', 'Second name', 'Last Name') AS result;

+----------------------------------+
| result                           |
+----------------------------------+
| First name,Second name,Last Name |
+----------------------------------+

SELECT concat_ws(',', 'First name', NULL, 'Last Name') AS result;

+----------------------+
| result               |
+----------------------+
| First name,Last Name |
+----------------------+

ELT

elt(N, str1, ..., strN)

Retorna a enésima string da lista, conforme o índice N.

Parâmetro	Tipo	Descrição
`N`	BIGINT	Índice baseado em 1 na lista de strings
`str1, ..., strN`	VARCHAR	Lista de strings

Tipo de retorno: VARCHAR

Notas de uso:

A função retorna NULL se N < 1 ou se N for maior que o número de argumentos de string.

Exemplo:

SELECT elt(4, 'Aa', 'Bb', 'Cc', 'Dd');

+--------------------------------+
| elt(4, 'Aa', 'Bb', 'Cc', 'Dd') |
+--------------------------------+
| Dd                             |
+--------------------------------+

ENCRYPT

encrypt(x, y)

Criptografa x usando y como valor de salt.

Parâmetro	Tipo	Descrição
`x`	VARBINARY	String a criptografar
`y`	VARCHAR	Valor de salt

Tipo de retorno: VARBINARY

Exemplo:

SELECT encrypt('abdABC123', 'key');

+--------------------------------------------------------+
| encrypt('abdABC123','key')                             |
+--------------------------------------------------------+
| 0x6B657A617A6D63496F2E614377                           |
+--------------------------------------------------------+

EXPORT_SET

export_set(bits, onstr, offstr [, separator [, number_of_bits]])

Converte bits para sua representação binária e retorna uma string construída pela substituição de cada posição de bit por onstr (para bit 1) ou offstr (para bit 0), separados por separator. A verificação dos bits ocorre da direita para a esquerda.

Parâmetro	Tipo	Descrição
`bits`	BIGINT	Inteiro a converter para binário
`onstr`	VARCHAR	String usada para o valor de bit `1`
`offstr`	VARCHAR	String usada para o valor de bit `0`
`separator`	VARCHAR	(Opcional) Delimitador entre os valores de saída
`number_of_bits`	BIGINT	(Opcional) Número de bits a verificar, da direita para a esquerda. O padrão é `64`

Tipo de retorno: VARCHAR

Notas de uso:

Se number_of_bits for maior que 64, o valor é limitado a 64.
Quando number_of_bits é -1, a função utiliza o valor padrão 64.

Exemplos:

Converta 5 para binário e verifique os dois bits mais à direita. Substitua 1 por a e 0 por b, separados por vírgulas:

SELECT export_set(5, 'a', 'b', ',', 2);

+-----------------------------+
| export_set(5,'a','b',',',2) |
+-----------------------------+
| a,b                         |
+-----------------------------+

Converta 6 para binário e verifique os 10 bits mais à direita. Substitua 1 por 1 e 0 por 0, separados por vírgulas:

SELECT export_set(6, '1', '0', ',', 10);

+------------------------------+
| export_set(6,'1','0',',',10) |
+------------------------------+
| 0,1,1,0,0,0,0,0,0,0          |
+------------------------------+

FIELD

FIELD(str, str1, str2, ..., strN)

Retorna a posição de str na lista str1, str2, ..., strN.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String a buscar
`str1, ..., strN`	VARCHAR	Lista de strings onde buscar

Tipo de retorno: BIGINT

Notas de uso:

Retorna 0 caso str não seja encontrada na lista.

Exemplo:

SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');

+-------------------------------------------+
| FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff') |
+-------------------------------------------+
|                                         2 |
+-------------------------------------------+

FIND_IN_SET

find_in_set(str, strlist)

Retorna a posição de str na lista separada por vírgulas strlist.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String a buscar
`strlist`	VARCHAR	Lista de strings separadas por vírgula

Tipo de retorno: BIGINT

Notas de uso:

Retorna 0 se str não existir em strlist ou se strlist for uma string vazia.
Retorna NULL quando str ou strlist for NULL.

Exemplo:

SELECT find_in_set('b', 'a,b,c,d');

+----------------------------+
| find_in_set('b','a,b,c,d') |
+----------------------------+
|                          2 |
+----------------------------+

FORMAT

format(X, D)

Formata o número X no estilo #,###,###.##, arredondado para D casas decimais, e retorna o resultado como string.

Parâmetro	Tipo	Descrição
`X`	DOUBLE	Número a formatar
`D`	BIGINT	Número de casas decimais

Tipo de retorno: VARCHAR

Notas de uso:

Se D for 0, o resultado não terá ponto decimal nem parte fracionária.

Exemplo:

SELECT format(12332.123456, 4) AS result1,
       format(12332.1, 4)    AS result2,
       format(12332.2, 0)    AS result3;

+-------------+-------------+---------+
| result1     | result2     | result3 |
+-------------+-------------+---------+
| 12,332.1235 | 12,332.1000 | 12,332  |
+-------------+-------------+---------+

FROM_BASE64

from_base64(x)

Decodifica uma string codificada em Base64 e retorna o resultado decodificado.

Parâmetro	Tipo	Descrição
`x`	VARBINARY ou VARCHAR	Entrada codificada em Base64

Tipo de retorno: VARBINARY

Notas de uso:

O valor retornado é do tipo VARBINARY. Para obter um resultado VARCHAR, converta-o usando um dos métodos a seguir:

AnalyticDB for MySQL V3.1.4 ou posterior: Use CAST AS VARCHAR. Para mais informações, consulte Funções CAST.
Anterior à V3.1.4: Utilize a função FROM_UTF8. Para mais informações, consulte FROM_UTF8.

Exemplos:

Entrada como string VARCHAR:

SELECT from_base64('Q2hpbmE=');

+--------------------------------------------------+
| from_base64('Q2hpbmE=')                          |
+--------------------------------------------------+
| 0x4368696E61                                     |
+--------------------------------------------------+

Para obter o valor VARCHAR original, faça o cast do resultado:

SELECT cast(from_base64('Q2hpbmE=') AS varchar);

+------------------------------------------+
| cast(from_base64('Q2hpbmE=') AS varchar) |
+------------------------------------------+
| China                                    |
+------------------------------------------+

Entrada como valor VARBINARY:

SELECT from_base64(cast(to_base64('China') AS varbinary));

+--------------------------------------------------------------------------------------------------------+
| from_base64(cast(to_base64('China') AS varbinary))                                                     |
+--------------------------------------------------------------------------------------------------------+
| 0x4368696E61                                                                                           |
+--------------------------------------------------------------------------------------------------------+

FROM_UTF8

from_utf8(x)
from_utf8(x, y)

Decodifica um valor binário codificado em UTF-8 e retorna uma string VARCHAR.

from_utf8(x) — Decodifica x e retorna o resultado decodificado.
from_utf8(x, y) — Decodifica x e substitui quaisquer sequências de bytes inválidas por y.

Parâmetro	Tipo	Descrição
`x`	VARBINARY	Entrada codificada em UTF-8 a decodificar
`y`	VARCHAR ou BIGINT	(Opcional) Caractere de substituição para bytes inválidos. Aceita o próprio caractere (por exemplo, `#`) ou seu código ASCII (por exemplo, `35`). Se omitido, o padrão é string vazia

Tipo de retorno: VARCHAR

Exemplos:

Decodifique uma string válida codificada em UTF-8:

SELECT from_utf8(to_utf8('hello'));

+-----------------------------+
| from_utf8(to_utf8('hello')) |
+-----------------------------+
| hello                       |
+-----------------------------+

Decodifique um valor não codificado em UTF-8 (bytes inválidos são substituídos por string vazia por padrão):

SELECT from_utf8(unhex('58BF'));

+--------------------------+
| from_utf8(unhex('58BF')) |
+--------------------------+
| X                       |
+--------------------------+

Substitua bytes inválidos por #:

SELECT from_utf8(unhex('58BF'), '#');

+-------------------------------+
| from_utf8(unhex('58BF'), '#') |
+-------------------------------+
| X#                            |
+-------------------------------+

Substitua bytes inválidos usando o código ASCII 35 (equivalente a #):

SELECT from_utf8(unhex('58BF'), '35');

+-------------------------------+
| from_utf8(unhex('58BF'), '35') |
+-------------------------------+
| X#                            |
+-------------------------------+

HEX

hex(x)

Retorna a representação em string hexadecimal de x.

Parâmetro	Tipo	Descrição
`x`	BIGINT ou VARCHAR	Inteiro ou string a converter

Tipo de retorno: VARCHAR

Exemplos:

Entrada inteira:

SELECT hex(16);

+---------+
| hex(16) |
+---------+
| 10      |
+---------+

Entrada string:

SELECT hex('16');

+-----------+
| hex('16') |
+-----------+
| 3136      |
+-----------+

INSTR

instr(str, substr)

Retorna a posição da primeira ocorrência de substr dentro de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String onde buscar
`substr`	VARCHAR	Substring a buscar

Tipo de retorno: BIGINT

Exemplo:

SELECT instr('foobarbar', 'bar');

+---------------------------+
| instr('foobarbar', 'bar') |
+---------------------------+
|                         4 |
+---------------------------+

LEFT

LEFT(str, len)

Retorna os len caracteres mais à esquerda de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`len`	BIGINT	Número de caracteres a retornar

Tipo de retorno: VARCHAR

Notas de uso:

Retorna NULL se str ou len for NULL.

Exemplo:

SELECT LEFT('foobarbar', 5);

+----------------------+
| LEFT('foobarbar', 5) |
+----------------------+
| fooba                |
+----------------------+

LENGTH ou OCTET_LENGTH

length(str)
octet_length(str)

Retorna o comprimento de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: BIGINT

Exemplo:

SELECT length('aliyun');

+------------------+
| length('aliyun') |
+------------------+
|                6 |
+------------------+

LIKE

expression [NOT] LIKE pattern [ESCAPE 'escape_char']

Compara expression com pattern. Retorna 1 se houver correspondência e 0 caso contrário.

Parâmetro	Tipo	Descrição
`expression`	VARCHAR	String a comparar
`pattern`	VARCHAR	Padrão com curingas. Use `%` para corresponder a qualquer sequência de caracteres e `_` para corresponder a um único caractere
`escape_char`	VARCHAR	(Opcional) Caractere de escape que trata o `%` ou `_` seguinte como caractere literal, em vez de curinga

Tipo de retorno: BIGINT

Exemplos:

Correspondência básica com curingas:

SELECT 'David!' LIKE 'David_'   AS result1,
       'David!' NOT LIKE 'David_' AS result2,
       'David!' LIKE '%D%v%'    AS result3;

+---------+---------+---------+
| result1 | result2 | result3 |
+---------+---------+---------+
|       1 |       0 |       1 |
+---------+---------+---------+

Uso de caractere de escape para corresponder a um underscore literal:

SELECT 'David_' LIKE 'David|_' ESCAPE '|';

+----------------------------------+
| David_' LIKE 'David|_' ESCAPE '| |
+----------------------------------+
|                                1 |
+----------------------------------+

LOCATE

locate(substr, str)
locate(substr, str, pos)

Retorna a posição da primeira ocorrência de substr em str. Opcionalmente, inicia a busca a partir da posição pos.

Parâmetro	Tipo	Descrição
`substr`	VARCHAR	Substring a buscar
`str`	VARCHAR	String onde buscar
`pos`	BIGINT	(Opcional) Posição inicial para a busca

Tipo de retorno: BIGINT

Notas de uso:

Retorna 0 caso substr não seja encontrada em str.
Retorna NULL se substr ou str for NULL.

Exemplos:

Busca desde o início:

SELECT locate('bar', 'foobarbar');

+----------------------------+
| locate('bar', 'foobarbar') |
+----------------------------+
|                          4 |
+----------------------------+

Busca iniciando na posição 7:

SELECT locate('bar', 'foobarbar', 7);

+-------------------------------+
| locate('bar', 'foobarbar', 7) |
+-------------------------------+
|                             7 |
+-------------------------------+

LOWER ou LCASE

lower(str)
lcase(str)

Converte todas as letras de str para minúsculas.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT lower('Aliyun');

+-----------------+
| lower('Aliyun') |
+-----------------+
| aliyun          |
+-----------------+

LPAD

lpad(str, len, padstr)

Preenche str à esquerda com padstr até atingir o comprimento total de len caracteres.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String a preencher
`len`	BIGINT	Comprimento total desejado
`padstr`	VARCHAR	String de preenchimento

Tipo de retorno: VARCHAR

Notas de uso:

Se str for maior que len, o valor retornado é truncado para len caracteres.

Exemplo:

SELECT lpad('Aliyun', 9, '#');

+----------------------+
| lpad('Aliyun',9,'#') |
+----------------------+
| ###Aliyun            |
+----------------------+

LTRIM

ltrim(str)

Remove todos os espaços à esquerda de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT ltrim('  abc');

+----------------+
| ltrim('  abc') |
+----------------+
| abc            |
+----------------+

MAKE_SET

make_set(bits, str1, str2, ...)

Retorna um conjunto de strings separadas por vírgulas, selecionadas pelas posições de bit definidas em bits. str1 corresponde ao bit 0, str2 ao bit 1 e assim por diante.

Parâmetro	Tipo	Descrição
`bits`	BIGINT	Máscara de bits que seleciona quais strings incluir
`str1, str2, ...`	VARCHAR	Strings correspondentes a cada posição de bit

Tipo de retorno: VARCHAR

Notas de uso:

Valores NULL na lista de strings não são incluídos no resultado.

Exemplos:

SELECT make_set(5, 'hello', 'nice', 'world');

+------------------------------------+
| make_set(5,'hello','nice','world') |
+------------------------------------+
| hello,world                        |
+------------------------------------+

5 em binário é 101, portanto os bits 0 e 2 estão definidos, selecionando hello e world.

SELECT make_set(1 | 4, 'hello', 'nice', NULL, 'world') AS result;

+--------+
| result |
+--------+
| hello  |
+--------+

1 | 4 = 5 (binário 101), logo os bits 0 e 2 estão definidos. A string na posição de bit 2 é NULL, então apenas hello é retornado.

MD5_MUR

MD5_MUR(x)

Calcula o hash MD5 de x e depois o converte em um valor de hash LONG usando o algoritmo MurmurHash3. Em comparação com CRC32, esta função apresenta menor taxa de colisão.

Parâmetro	Tipo	Descrição
`x`	VARCHAR	String de entrada

Tipo de retorno: LONG

Pré-requisitos: Requer versão de kernel 3.2.5 ou posterior.

Exemplo:

SELECT MD5_MUR('TEST') AS result;

+--------------------------+
| result                   |
+--------------------------+
| -6711128042951586494     |
+--------------------------+

MID

mid(str, pos, len)

Retorna uma substring de comprimento len de str, começando na posição pos. Esta função equivale a SUBSTR e SUBSTRING.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`pos`	BIGINT	Posição inicial (baseada em 1). Use um valor negativo para contar a partir do final da string
`len`	BIGINT	Número de caracteres a retornar

Tipo de retorno: VARCHAR

Exemplos:

SELECT mid('Quadratically', 5, 6);

+--------------------------+
| mid('Quadratically',5,6) |
+--------------------------+
| ratica                   |
+--------------------------+

SELECT mid('Sakila', -5, 3);

+----------------------+
| mid('Sakila', -5, 3) |
+----------------------+
| aki                  |
+----------------------+

OCT

oct(N)

Retorna a representação em string octal de N.

Parâmetro	Tipo	Descrição
`N`	BIGINT	Inteiro a converter

Tipo de retorno: VARCHAR

Notas de uso:

Retorna NULL se N for NULL.

Exemplo:

SELECT oct(12);

+---------+
| oct(12) |
+---------+
| 14      |
+---------+

ORD

ord(x)

Retorna o código do caractere mais à esquerda de x se este for um caractere multibyte.

Parâmetro	Tipo	Descrição
`x`	VARBINARY ou VARCHAR	String de entrada

Tipo de retorno: LONG

Exemplos:

Entrada VARCHAR:

SELECT ord('China');

+--------------+
| ord('China') |
+--------------+
|           67 |
+--------------+

Entrada VARBINARY:

SELECT ord(cast('China' AS varbinary));

+---------------------------------+
| ord(cast('China' AS varbinary)) |
+---------------------------------+
|                              67 |
+---------------------------------+

POSITION

position(substr IN str)

Retorna a posição da primeira ocorrência de substr em str. As posições são baseadas em 1.

Parâmetro	Tipo	Descrição
`substr`	VARCHAR	Substring a buscar
`str`	VARCHAR	String onde buscar

Tipo de retorno: BIGINT

Notas de uso:

Retorna 0 caso substr não seja encontrada.

Exemplo:

SELECT position('bar' IN 'foobarbar');

+--------------------------------+
| position('bar' in 'foobarbar') |
+--------------------------------+
|                              4 |
+--------------------------------+

REPEAT

repeat(str, count)

Retorna str repetida count vezes.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String a repetir
`count`	BIGINT	Número de repetições

Tipo de retorno: VARCHAR

Notas de uso:

Retorna uma string vazia se count < 1.
Retorna NULL quando str ou count for NULL.

Exemplos:

SELECT repeat('a', 3);

+----------------+
| repeat('a', 3) |
+----------------+
| aaa            |
+----------------+

SELECT repeat('abc', null);

+---------------------+
| repeat('abc', null) |
+---------------------+
| NULL                |
+---------------------+

SELECT repeat(null, 3);

+-----------------+
| repeat(null, 3) |
+-----------------+
| NULL            |
+-----------------+

REPLACE

replace(str, from_str, to_str)

Substitui todas as ocorrências de from_str em str por to_str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`from_str`	VARCHAR	Substring a substituir
`to_str`	String de substituição

Tipo de retorno: VARCHAR

Exemplo:

SELECT replace('WWW.aliyun.com', 'W', 'w');

+-------------------------------------+
| replace('WWW.aliyun.com', 'W', 'w') |
+-------------------------------------+
| www.aliyun.com                      |
+-------------------------------------+

REVERSE

reverse(str)

Retorna str com os caracteres em ordem inversa.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT reverse('123456');

+-------------------+
| reverse('123456') |
+-------------------+
| 654321            |
+-------------------+

RIGHT

RIGHT(str, len)

Retorna os len caracteres mais à direita de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`len`	BIGINT	Número de caracteres a retornar

Tipo de retorno: VARCHAR

Notas de uso:

Retorna NULL se str ou len for NULL.

Exemplo:

SELECT RIGHT('abc', 3);

+----------------+
| RIGHT('abc',3) |
+----------------+
| abc            |
+----------------+

RLIKE ou REGEXP

expression RLIKE pattern
expression REGEXP pattern

Retorna 1 se expression corresponder à expressão regular pattern e 0 caso contrário.

Parâmetro	Tipo	Descrição
`expression`	VARCHAR	String a comparar
`pattern`	VARCHAR	Padrão de expressão regular

Tipo de retorno: BOOLEAN

Notas de uso:

Retorna NULL se expression ou pattern for NULL.

Exemplos:

SELECT 'Michael!' REGEXP '.*';

+----------------------+
| Michael!' REGEXP '.* |
+----------------------+
|                    1 |
+----------------------+

SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';

+-------------------------------------+
| new*\n*line' REGEXP 'new\\*.\\*line |
+-------------------------------------+
|                                   0 |
+-------------------------------------+

SELECT 'c' REGEXP '^[a-d]';

+-------------------+
| c' REGEXP '^[a-d] |
+-------------------+
|                 1 |
+-------------------+

RPAD

rpad(str, len, padstr)

Preenche str à direita com padstr até atingir o comprimento total de len caracteres.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String a preencher
`len`	BIGINT	Comprimento total desejado
`padstr`	VARCHAR	String de preenchimento

Tipo de retorno: VARCHAR

Notas de uso:

Se str for maior que len, o valor retornado é truncado para len caracteres.

Exemplo:

SELECT rpad('Aliyun', 9, '#');

+----------------------+
| rpad('Aliyun',9,'#') |
+----------------------+
| Aliyun###            |
+----------------------+

RTRIM

rtrim(str)

Remove todos os espaços à direita de str.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT rtrim('barbar   ');

+--------------------+
| rtrim('barbar   ') |
+--------------------+
| barbar             |
+--------------------+

SPACE

space(N)

Retorna uma string com N caracteres de espaço.

Parâmetro	Tipo	Descrição
`N`	BIGINT	Número de espaços

Tipo de retorno: VARCHAR

Notas de uso:

Combine com concat() para inserir espaços em uma string maior.

Exemplo:

SELECT concat('#', space(6), '#');

+----------------------------+
| concat("#", space(6), "#") |
+----------------------------+
| #      #                   |
+----------------------------+

SPLIT

split(string, delimiter)

Divide string em cada ocorrência de delimiter e retorna as partes como um array.

Parâmetro	Tipo	Descrição
`string`	VARCHAR	String de entrada
`delimiter`	VARCHAR	Delimitador para divisão

Tipo de retorno: ARRAY\<varchar\>

Exemplo:

SELECT split('1#2#3', '#'),
       split('#1#2#3#', '#'),
       split('123', '#');

+---------------------+-----------------------+-------------------+
| split('1#2#3', '#') | split('#1#2#3#', '#') | split('123', '#') |
+---------------------+-----------------------+-------------------+
| ["1","2","3"]       | ["","1","2","3",""]   | ["123"]           |
+---------------------+-----------------------+-------------------+

SPLIT_PART

split_part(string, delimiter, index)

Divide string pelo delimiter e retorna o elemento na posição index. O índice é baseado em 1.

Parâmetro	Tipo	Descrição
`string`	VARCHAR	String de entrada
`delimiter`	VARCHAR	Delimitador para divisão
`index`	BIGINT	Posição baseada em 1 do elemento a retornar

Tipo de retorno: VARCHAR

Notas de uso:

Retorna NULL se index for maior que o número de campos resultantes.

Exemplo:

SELECT split_part('A#B#C', '#', 2),
       split_part('A#B#C', '#', 4);

+-----------------------------+-----------------------------+
| split_part('A#B#C', '#', 2) | split_part('A#B#C', '#', 4) |
+-----------------------------+-----------------------------+
| B                           | NULL                        |
+-----------------------------+-----------------------------+

SPLIT_TO_MAP

split_to_map(string, entryDelimiter, keyValueDelimiter)

Divide string em pares chave-valor e retorna um mapa. entryDelimiter separa os pares individuais e keyValueDelimiter separa cada chave de seu valor.

Parâmetro	Tipo	Descrição
`string`	VARCHAR	String de entrada
`entryDelimiter`	VARCHAR	Delimitador entre pares chave-valor
`keyValueDelimiter`	VARCHAR	Delimitador entre chave e valor dentro de cada par

Tipo de retorno: MAP\<varchar, varchar\>

Exemplo:

SELECT split_to_map('k1:v1,k2:v2', ',', ':'),
       split_to_map('', ',', ':');

+---------------------------------------+----------------------------+
| split_to_map('k1:v1,k2:v2', ',', ':') | split_to_map('', ',', ':') |
+---------------------------------------+----------------------------+
| {"k1":"v1","k2":"v2"}                 | {}                         |
+---------------------------------------+----------------------------+

STRCMP

strcmp(str1, str2)

Compara str1 e str2 com base na ordem de classificação atual.

Parâmetro	Tipo	Descrição
`str1`	VARCHAR	Primeira string
`str2`	VARCHAR	Segunda string

Tipo de retorno: BIGINT

Retorna:

0 se as strings forem idênticas
-1 se str1 for menor que str2
1 se str1 for maior que str2

Exemplo:

SELECT strcmp('text', 'text2');

+-------------------------+
| strcmp('text', 'text2') |
+-------------------------+
|                      -1 |
+-------------------------+

SUBSTR ou SUBSTRING

substr(str, pos)
substr(str FROM pos)
substr(str, pos, len)
substr(str FROM pos FOR len)
substring(str, pos)
substring(str FROM pos)
substring(str, pos, len)
substring(str FROM pos FOR len)

Retorna uma substring de str começando na posição pos, opcionalmente limitada a len caracteres.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`pos`	BIGINT	Posição inicial (baseada em 1). Um valor negativo conta a partir do final da string
`len`	BIGINT	(Opcional) Número máximo de caracteres a retornar. Se omitido, retorna todos os caracteres de `pos` até o final

Tipo de retorno: VARCHAR

Exemplos:

Retorne tudo da posição 6 até o final:

SELECT substr('helloworld', 6);

+-------------------------+
| substr('helloworld', 6) |
+-------------------------+
| world                   |
+-------------------------+

Usando a sintaxe FROM:

SELECT substr('helloworld' FROM 6);

+-----------------------------+
| substr('helloworld' FROM 6) |
+-----------------------------+
| world                       |
+-----------------------------+

Retorne 3 caracteres começando na posição 6:

SELECT substr('helloworld', 6, 3);

+----------------------------+
| substr('helloworld', 6, 3) |
+----------------------------+
| wor                        |
+----------------------------+

Usando a sintaxe FROM ... FOR:

SELECT substr('helloworld' FROM 6 FOR 3);

+-----------------------------------+
| substr('helloworld' FROM 6 FOR 3) |
+-----------------------------------+
| wor                               |
+-----------------------------------+

SUBSTRING_INDEX

substring_index(str, delim, count)

Retorna uma substring de str cortada na enésima ocorrência de delim, definida por count.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`delim`	VARCHAR	Delimitador a buscar (diferencia maiúsculas de minúsculas)
`count`	BIGINT	Número de ocorrências do delimitador. Valores positivos contam da esquerda e retornam tudo à esquerda da correspondência; valores negativos contam da direita e retornam tudo à direita

Tipo de retorno: VARCHAR

Notas de uso:

A busca por delim diferencia maiúsculas de minúsculas.

Exemplo:

Retorne tudo antes do segundo .:

SELECT substring_index('www.aliyun.com', '.', 2);

+-------------------------------------------+
| substring_index('www.aliyun.com', '.', 2) |
+-------------------------------------------+
| www.aliyun                                |
+-------------------------------------------+

TO_BASE64

to_base64(x)

Retorna a forma codificada em Base64 de x.

Parâmetro	Tipo	Descrição
`x`	VARBINARY ou VARCHAR	Entrada a codificar

Tipo de retorno: VARCHAR

Exemplos:

Entrada VARCHAR:

SELECT to_base64('China');

+--------------------+
| to_base64('China') |
+--------------------+
| Q2hpbmE=           |
+--------------------+

Entrada VARBINARY:

SELECT to_base64(cast('China' AS varbinary));

+---------------------------------------+
| to_base64(cast('China' AS varbinary)) |
+---------------------------------------+
| Q2hpbmE=                              |
+---------------------------------------+

TO_UTF8

to_utf8(x)

Retorna a forma codificada em UTF-8 de x.

Parâmetro	Tipo	Descrição
`x`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT from_utf8(to_utf8('China'));

+-----------------------------+
| from_utf8(to_utf8('China')) |
+-----------------------------+
| China                       |
+-----------------------------+

TRIM

trim([remstr FROM] str)
trim([{BOTH | LEADING | TRAILING} [remstr] FROM] str)

Remove espaços à esquerda e à direita de str ou remove caracteres correspondentes a remstr do(s) lado(s) especificado(s).

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada
`remstr`	VARCHAR	(Opcional) Caractere(s) a remover. O padrão é espaço
`BOTH	LEADING	TRAILING`	—	(Opcional) Lado de onde remover caracteres. O padrão é `BOTH`

Tipo de retorno: VARCHAR

Exemplos:

Remova espaços à esquerda e à direita:

SELECT trim('  bar   ');

+------------------+
| trim('  bar   ') |
+------------------+
| bar              |
+------------------+

Remova um caractere específico de ambos os lados:

SELECT trim(BOTH 'x' FROM 'xxxbarxxx');

+---------------------------------+
| trim(BOTH 'x' FROM 'xxxbarxxx') |
+---------------------------------+
| bar                             |
+---------------------------------+

Remova apenas do lado esquerdo:

SELECT trim(LEADING 'x' FROM 'xxxbarxxx');

+------------------------------------+
| trim(LEADING 'x' FROM 'xxxbarxxx') |
+------------------------------------+
| barxxx                             |
+------------------------------------+

Remova apenas do lado direito:

SELECT trim(TRAILING 'x' FROM 'xxxbarxxx');

+-------------------------------------+
| trim(TRAILING 'x' from 'xxxbarxxx') |
+-------------------------------------+
| xxxbar                              |
+-------------------------------------+

UNHEX

unhex(x)

Interpreta cada par de dígitos hexadecimais em x como um valor de byte e retorna a string binária correspondente.

Parâmetro	Tipo	Descrição
`x`	VARBINARY ou VARCHAR	String hexadecimal a decodificar

Tipo de retorno: VARBINARY

Notas de uso:

O valor retornado é do tipo VARBINARY. Para obter um resultado VARCHAR, converta-o usando um dos métodos a seguir:

AnalyticDB for MySQL V3.1.4 ou posterior: Use CAST AS VARCHAR. Para mais informações, consulte Funções CAST.
Anterior à V3.1.4: Utilize a função FROM_UTF8. Para mais informações, consulte FROM_UTF8.

Se a entrada contiver caracteres não hexadecimais, a função retorna NULL.

Exemplos:

Entrada VARCHAR — use CAST para obter o resultado VARCHAR:

SELECT unhex(hex('China'));

+------------------------------------------+
| unhex(hex('China'))                      |
+------------------------------------------+
| China                                    |
+------------------------------------------+

Para obter o valor VARCHAR explicitamente:

SELECT cast(unhex(hex('China')) AS varchar);

+--------------------------------------+
| cast(unhex(hex('China')) AS varchar) |
+--------------------------------------+
| China                                |
+--------------------------------------+

Entrada VARBINARY:

SELECT unhex(cast(hex('China') AS varbinary));

+------------------------------------------+
| unhex(cast(hex('China') AS varbinary))   |
+------------------------------------------+
| China                                    |
+------------------------------------------+

UPPER ou UCASE

upper(str)
ucase(str)

Converte todas as letras de str para maiúsculas.

Parâmetro	Tipo	Descrição
`str`	VARCHAR	String de entrada

Tipo de retorno: VARCHAR

Exemplo:

SELECT upper('Aliyun');

+-----------------+
| upper('Aliyun') |
+-----------------+
| ALIYUN          |
+-----------------+

Categoria	Funções
Comprimento e informações de caracteres	ASCII, BIT_LENGTH, CHAR_LENGTH ou CHARACTER_LENGTH, LENGTH ou OCTET_LENGTH, ORD
Conversão de maiúsculas e minúsculas	LOWER ou LCASE, UPPER ou UCASE
Concatenação e formatação	CONCAT, CONCAT_WS, FORMAT, REPEAT, SPACE
Substrings e extração	LEFT, MID, RIGHT, SUBSTR ou SUBSTRING, SUBSTRING_INDEX
Busca e posição	FIELD, FIND_IN_SET, INSTR, LOCATE, POSITION
Correspondência de padrões	LIKE, RLIKE ou REGEXP
Preenchimento e remoção de espaços	LPAD, LTRIM, RPAD, RTRIM, TRIM
Divisão	SPLIT, SPLIT_PART, SPLIT_TO_MAP
Codificação e decodificação	BIN, CHAR, FROM_BASE64, FROM_UTF8, HEX, OCT, TO_BASE64, TO_UTF8, UNHEX
Comparação	STRCMP
Operações de conjunto	ELT, EXPORT_SET, MAKE_SET
Substituição e inversão	REPLACE, REVERSE
Criptografia e hash	ENCRYPT, MD5_MUR