SQL - Funções de String
As funções de string SQL são usadas principalmente para manipulação de string. A tabela a seguir detalha as funções de string importantes -
| Sr. Não. | Descrição da função |
|---|---|
| 1 | ASCII () Retorna o valor numérico do caractere mais à esquerda |
| 2 | BIN () Retorna uma representação de string do argumento |
| 3 | BIT_LENGTH () Retorna o comprimento do argumento em bits |
| 4 | CHAR_LENGTH () Retorna o número de caracteres no argumento |
| 5 | CARACTERES() Retorna o caractere para cada inteiro passado |
| 6 | CHARACTER_LENGTH () Um sinônimo para CHAR_LENGTH () |
| 7 | CONCAT_WS () Retorna concatenar com separador |
| 8 | CONCAT () Retorna string concatenada |
| 9 | CONV () Converte números entre diferentes bases numéricas |
| 10 | ELT () Retorna string no número do índice |
| 11 | EXPORT_SET () Retorna uma string tal que para cada bit definido nos bits de valor, você obtém uma string on e para cada bit não definido, você obtém uma string off |
| 12 | CAMPO() Retorna o índice (posição) do primeiro argumento nos argumentos subsequentes |
| 13 | FIND_IN_SET () Retorna a posição do índice do primeiro argumento dentro do segundo argumento |
| 14 | FORMATO() Retorna um número formatado com o número especificado de casas decimais |
| 15 | HEX () Retorna uma representação de string de um valor hexadecimal |
| 16 | INSERIR() Insere uma substring na posição especificada até o número especificado de caracteres |
| 17 | INSTR () Retorna o índice da primeira ocorrência de substring |
| 18 | LCASE () Sinônimo de LOWER () |
| 19 | ESQUERDA() Retorna o número mais à esquerda de caracteres conforme especificado |
| 20 | COMPRIMENTO() Retorna o comprimento de uma string em bytes |
| 21 | LOAD_FILE () Carrega o arquivo nomeado |
| 22 | LOCALIZAR() Retorna a posição da primeira ocorrência de substring |
| 23 | MAIS BAIXO() Retorna o argumento em minúsculas |
| 24 | LPAD () Retorna o argumento da string, preenchido à esquerda com a string especificada |
| 25 | LTRIM () Remove espaços principais |
| 26 | MAKE_SET () Retorna um conjunto de strings separadas por vírgulas que têm o bit correspondente em bits definido |
| 27 | MID () Retorna uma substring começando na posição especificada |
| 28 | OCT () Retorna uma representação de string do argumento octal |
| 29 | OCTET_LENGTH () Um sinônimo para LENGTH () |
| 30 | ORD () Se o caractere mais à esquerda do argumento for um caractere multibyte, retorna o código desse caractere |
| 31 | POSIÇÃO() Um sinônimo para LOCATE () |
| 32 | CITAR() Escapa do argumento para uso em uma instrução SQL |
| 33 | REGEXP Correspondência de padrões usando expressões regulares |
| 34 | REPETIR() Repete uma string o número especificado de vezes |
| 35 | SUBSTITUIR() Substitui as ocorrências de uma string especificada |
| 36 | REVERTER() Inverte os caracteres em uma string |
| 37 | DIREITO() Retorna o número especificado de caracteres mais à direita |
| 38 | RPAD () Anexa string o número especificado de vezes |
| 39 | RTRIM () Remove espaços à direita |
| 40 | SOUNDEX () Retorna uma string soundex |
| 41 | SOA COMO Compara sons |
| 42 | ESPAÇO() Retorna uma string com o número especificado de espaços |
| 43 | STRCMP () Compara duas strings |
| 44 | SUBSTRING_INDEX () Retorna uma substring de uma string antes do número especificado de ocorrências do delimitador |
| 45 | SUBSTRING (), SUBSTR () Retorna a substring conforme especificado |
| 46 | APARAR() Remove espaços à esquerda e à direita |
| 47 | UCASE () Sinônimo de UPPER () |
| 48 | UNHEX () Converte cada par de dígitos hexadecimais em um caractere |
| 49 | SUPERIOR() Converte para maiúsculas |
ASCII (str)
Retorna o valor numérico do caractere mais à esquerda da string str. Retorna 0 se str for a string vazia. Retorna NULL se str for NULL. ASCII () funciona para caracteres com valores numéricos de 0 a 255.
SQL> SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIN (N)
Retorna uma representação de string do valor binário de N, onde N é um número longo (BIGINT). Isso é equivalente a CONV (N, 10,2). Retorna NULL se N for NULL.
SQL> SELECT BIN(12);
+---------------------------------------------------------+
| BIN(12) |
+---------------------------------------------------------+
| 1100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (str)
Retorna o comprimento da string str em bits.
SQL> SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR (N, ... [USING charset_name])
CHAR () interpreta cada argumento N como um inteiro e retorna uma string que consiste nos caracteres fornecidos pelos valores de código desses inteiros. Os valores NULL são ignorados.
SQL> SELECT CHAR(77,121,83,81,'76');
+---------------------------------------------------------+
| CHAR(77,121,83,81,'76') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (str)
Retorna o comprimento da string str medida em caracteres. Um caractere multibyte conta como um único caractere. Isso significa que para uma string contendo cinco caracteres de dois bytes, LENGTH () retorna 10, enquanto CHAR_LENGTH () retorna 5.
SQL> SELECT CHAR_LENGTH("text");
+---------------------------------------------------------+
| CHAR_LENGTH("text") |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (str)
CHARACTER_LENGTH () é um sinônimo para CHAR_LENGTH ().
CONCAT (str1, str2, ...)
Retorna a string que resulta da concatenação dos argumentos. Pode ter um ou mais argumentos. Se todos os argumentos forem strings não binárias, o resultado será uma string não binária. Se os argumentos incluem cadeias binárias, o resultado é uma cadeia binária. Um argumento numérico é convertido em sua forma de string binária equivalente; se você quiser evitar isso, você pode usar uma conversão de tipo explícito, como neste exemplo -
SQL> SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (separador, str1, str2, ...)
CONCAT_WS () significa Concatenate With Separator e é uma forma especial de CONCAT (). O primeiro argumento é o separador para o resto dos argumentos. O separador é adicionado entre as strings a serem concatenadas. O separador pode ser uma string, assim como o resto dos argumentos. Se o separador for NULL, o resultado será NULL.
SQL> SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name,Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONV (N, from_base, to_base)
Converte números entre diferentes bases numéricas. Retorna uma representação de string do número N, convertido de base de_base para to_base. Retorna NULL se qualquer argumento for NULL. O argumento N é interpretado como um inteiro, mas pode ser especificado como um inteiro ou string. A base mínima é 2 e a base máxima é 36. Se to_base for um número negativo, N é considerado um número com sinal. Caso contrário, N é tratado como sem sinal. CONV () funciona com precisão de 64 bits.
SQL> SELECT CONV('a',16,2);
+---------------------------------------------------------+
| CONV('a',16,2) |
+---------------------------------------------------------+
| 1010 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ELT (N, str1, str2, str3, ...)
Retorna str1 se N = 1, str2 se N = 2 e assim por diante. Retorna NULL se N for menor que 1 ou maior que o número de argumentos. ELT () é o complemento de FIELD ().
SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| ELT(1, 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| ej |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXPORT_SET (bits, ligado, desligado [, separador [, número_de_bits]])
Retorna uma string de forma que para cada bit definido nos bits de valor, você obtém uma string on e para cada bit não definido no valor, você obtém uma string off. Os bits em bits são examinados da direita para a esquerda (dos bits de ordem inferior para os de ordem superior). As strings são adicionadas ao resultado da esquerda para a direita, separadas pela string separadora (o padrão é a vírgula.,.). O número de bits examinados é dado por number_of_bits (o padrão é 64).
SQL> SELECT EXPORT_SET(5,'Y','N',',',4);
+---------------------------------------------------------+
| EXPORT_SET(5,'Y','N',',',4) |
+---------------------------------------------------------+
| Y,N,Y,N |
+---------------------------------------------------------+
1 row in set (0.00 sec)CAMPO (str, str1, str2, str3, ...)
Retorna o índice (posição começando com 1) de str na lista str1, str2, str3, ... Retorna 0 se str não for encontrado.
SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FIND_IN_SET (str, strlist)
Retorna um valor no intervalo de 1 a N se a string str estiver na lista de strings strlist consistindo em N substrings.
SQL> SELECT FIND_IN_SET('b','a,b,c,d');
+---------------------------------------------------------+
| SELECT FIND_IN_SET('b','a,b,c,d') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMATO (X, D)
Formata o número X em um formato como '#, ###, ###. ##', arredondado para D casas decimais e retorna o resultado como uma string. Se D for 0, o resultado não terá ponto decimal ou parte fracionária.
SQL> SELECT FORMAT(12332.123456, 4);
+---------------------------------------------------------+
| FORMAT(12332.123456, 4) |
+---------------------------------------------------------+
| 12,332.1235 |
+---------------------------------------------------------+
1 row in set (0.00 sec)HEX (N_ou_S)
Se N_ou_S for um número, retorna uma representação de string do valor hexadecimal de N, onde N é um número longo (BIGINT). Isso é equivalente a CONV (N, 10,16).
Se N_or_S for uma string, retorna uma representação de string hexadecimal de N_ou_S onde cada caractere em N_ou_S é convertido em dois dígitos hexadecimais.
SQL> SELECT HEX(255);
+---------------------------------------------------------+
| HEX(255) |
+---------------------------------------------------------+
| FF |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT 0x616263;
+---------------------------------------------------------+
| 0x616263 |
+---------------------------------------------------------+
| abc |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSERT (str, pos, len, newstr)
Retorna a string str, com a substring começando na posição pos e len caracteres substituídos pela string newstr. Retorna a string original se pos não estiver dentro do comprimento da string. Substitui o resto da string da posição pos se len não estiver dentro do comprimento do resto da string. Retorna NULL se qualquer argumento for NULL.
SQL> SELECT INSERT('Quadratic', 3, 4, 'What');
+---------------------------------------------------------+
| INSERT('Quadratic', 3, 4, 'What') |
+---------------------------------------------------------+
| QuWhattic |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSTR (str, substr)
Retorna a posição da primeira ocorrência de substring substr na string str. É o mesmo que a forma de dois argumentos de LOCATE (), exceto que a ordem dos argumentos é invertida.
SQL> SELECT INSTR('foobarbar', 'bar');
+---------------------------------------------------------+
| INSTR('foobarbar', 'bar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () é um sinônimo de LOWER ().
LEFT (str, len)
Retorna os caracteres len mais à esquerda da string str ou NULL se algum argumento for NULL.
SQL> SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LENGTH (str)
Retorna o comprimento da string str, medido em bytes. Um caractere multibyte conta como bytes múltiplos. Isso significa que para uma string contendo cinco caracteres de dois bytes, LENGTH () retorna 10, enquanto CHAR_LENGTH () retorna 5.
SQL> SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOAD_FILE (file_name)
Lê o arquivo e retorna o conteúdo do arquivo como uma string. Para usar esta função, o arquivo deve estar localizado no host do servidor, você deve especificar o caminho completo para o arquivo e deve ter o privilégio FILE. O arquivo deve ser lido por todos e seu tamanho deve ser menor que max_allowed_packet bytes.
Se o arquivo não existir ou não puder ser lido porque uma das condições anteriores não foi satisfeita, a função retornará NULL.
A partir do SQL 5.0.19, a variável de sistema character_set_filesystem controla a interpretação de nomes de arquivos fornecidos como strings literais.
SQL> UPDATE table_test
-> SET blob_col=LOAD_FILE('/tmp/picture')
-> WHERE id=1;
...........................................................LOCATE (substr, str), LOCATE (substr, str, pos)
A primeira sintaxe retorna a posição da primeira ocorrência de substring substr na string str. A segunda sintaxe retorna a posição da primeira ocorrência de substring substr na string str, começando na posição pos. Retorna 0 se substr não estiver em str.
SQL> SELECT LOCATE('bar', 'foobarbar');
+---------------------------------------------------------+
| LOCATE('bar', 'foobarbar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOWER (str)
Retorna a string str com todos os caracteres alterados para minúsculas de acordo com o mapeamento do conjunto de caracteres atual.
SQL> SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Retorna a string str, preenchida à esquerda com a string padstr até um comprimento de caracteres len. Se str for maior do que len, o valor de retorno será reduzido para len caracteres.
SQL> SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Retorna a string str com os caracteres de espaço iniciais removidos.
SQL> SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MAKE_SET (bits, str1, str2, ...)
Retorna um valor definido (uma string contendo substrings separadas por.,. Caracteres) consistindo nas strings que têm o bit correspondente em bits definidos. str1 corresponde ao bit 0, str2 ao bit 1 e assim por diante. Valores NULL em str1, str2, ... não são acrescentados ao resultado.
SQL> SELECT MAKE_SET(1,'a','b','c');
+---------------------------------------------------------+
| MAKE_SET(1,'a','b','c') |
+---------------------------------------------------------+
| a |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) é sinônimo de SUBSTRING (str, pos, len).
OCT (N)
Retorna uma representação de string do valor octal de N, onde N é um número longo (BIGINT). Isso é equivalente a CONV (N, 10,8). Retorna NULL se N for NULL.
SQL> SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCTET_LENGTH (str)
OCTET_LENGTH () é um sinônimo para LENGTH ().
ORD (str)
Se o caractere mais à esquerda da string str for um caractere multibyte, retorna o código desse caractere, calculado a partir dos valores numéricos de seus bytes constituintes usando esta fórmula -
(1st byte code)
+ (2nd byte code . 256)
+ (3rd byte code . 2562) ...Se o caractere mais à esquerda não for um caractere multibyte, ORD () retornará o mesmo valor da função ASCII ().
SQL> SELECT ORD('2');
+---------------------------------------------------------+
| ORD('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POSIÇÃO (substr IN str)
POSITION (substr IN str) é um sinônimo para LOCATE (substr, str).
QUOTE (str)
Cita uma string para produzir um resultado que pode ser usado como um valor de dados com escape adequado em uma instrução SQL. A string é retornada entre aspas simples e com cada instância de aspas simples ('), barra invertida (' \ '), ASCII NUL e Control-Z precedida por uma barra invertida. Se o argumento for NULL, o valor de retorno será a palavra 'NULL' sem aspas simples.
SQL> SELECT QUOTE('Don\'t!');
+---------------------------------------------------------+
| QUOTE('Don\'t!') |
+---------------------------------------------------------+
| 'Don\'t!' |
+---------------------------------------------------------+
1 row in set (0.00 sec)NOTE - Por favor, verifique se sua instalação tem algum bug com esta função, então não use esta função.
padrão expr REGEXP
Esta função executa uma correspondência de padrão de expr contra o padrão. Retorna 1 se expr corresponder a pat; caso contrário, retorna 0. Se expr ou pat for NULL, o resultado será NULL. REGEXP não faz distinção entre maiúsculas e minúsculas, exceto quando usado com strings binárias.
SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';
+---------------------------------------------------------+
| 'ABCDEF' REGEXP 'A%C%%' |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Outro exemplo é -
SQL> SELECT 'ABCDE' REGEXP '.*';
+---------------------------------------------------------+
| 'ABCDE' REGEXP '.*' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Vamos ver mais um exemplo -
SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)REPETIR (str, contar)
Retorna uma string que consiste na string str repetidas vezes de contagem. Se a contagem for menor que 1, retorna uma string vazia. Retorna NULL se str ou count forem NULL.
SQL> SELECT REPEAT('SQL', 3);
+---------------------------------------------------------+
| REPEAT('SQL', 3) |
+---------------------------------------------------------+
| SQLSQLSQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)REPLACE (str, from_str, to_str)
Retorna a string str com todas as ocorrências da string from_str substituídas pela string to_str. REPLACE () executa uma correspondência com distinção entre maiúsculas e minúsculas ao pesquisar from_str.
SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
+---------------------------------------------------------+
| REPLACE('www.mysql.com', 'w', 'Ww') |
+---------------------------------------------------------+
| WwWwWw.mysql.com |
+---------------------------------------------------------+
1 row in set (0.00 sec)REVERSE (str)
Retorna a string str com a ordem dos caracteres invertida.
SQL> SELECT REVERSE('abcd');
+---------------------------------------------------------+
| REVERSE('abcd') |
+---------------------------------------------------------+
| dcba |
+---------------------------------------------------------+
1 row in set (0.00 sec)DIREITO (str, len)
Retorna os caracteres len mais à direita da string str, ou NULL se algum argumento for NULL.
SQL> SELECT RIGHT('foobarbar', 4);
+---------------------------------------------------------+
| RIGHT('foobarbar', 4) |
+---------------------------------------------------------+
| rbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)RPAD (str, len, padstr)
Retorna a string str, preenchida à direita com a string padstr até um comprimento de len caracteres. Se str for maior do que len, o valor de retorno será reduzido para len caracteres.
SQL> SELECT RPAD('hi',5,'?');
+---------------------------------------------------------+
| RPAD('hi',5,'?') |
+---------------------------------------------------------+
| hi??? |
+---------------------------------------------------------+
1 row in set (0.00 sec)RTRIM (str)
Retorna a string str com os caracteres de espaço à direita removidos.
SQL> SELECT RTRIM('barbar ');
+---------------------------------------------------------+
| RTRIM('barbar ') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)SOUNDEX (str)
Retorna uma string soundex de str. Duas cordas que soam quase iguais devem ter cordas soundex idênticas. Uma string soundex padrão tem quatro caracteres, mas a função SOUNDEX () retorna uma string arbitrariamente longa. Você pode usar SUBSTRING () no resultado para obter uma string soundex padrão. Todos os caracteres não alfabéticos em str são ignorados. Todos os caracteres alfabéticos internacionais fora da faixa AZ são tratados como vogais.
SQL> SELECT SOUNDEX('Hello');
+---------------------------------------------------------+
| SOUNDEX('Hello') |
+---------------------------------------------------------+
| H400 |
+---------------------------------------------------------+
1 row in set (0.00 sec)expr1 SOA COMO expr2
É o mesmo que SOUNDEX (expr1) = SOUNDEX (expr2).
ESPAÇO (N)
Retorna uma string que consiste em N caracteres de espaço.
SQL> SELECT SPACE(6);
+---------------------------------------------------------+
| SELECT SPACE(6) |
+---------------------------------------------------------+
| ' ' |
+---------------------------------------------------------+
1 row in set (0.00 sec)STRCMP (str1, str2)
Compara duas strings e retorna 0 se ambas as strings forem iguais, ele retorna -1 se o primeiro argumento for menor que o segundo de acordo com a ordem de classificação atual, caso contrário, ele retorna 1.
SQL> SELECT STRCMP('MOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'MOHD') |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Outro exemplo é -
SQL> SELECT STRCMP('AMOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('AMOHD', 'MOHD') |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Vamos ver mais um exemplo -
SQL> SELECT STRCMP('MOHD', 'AMOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'AMOHD') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING (str, pos)
SUBSTRING (str FROM pos)
SUBSTRING (str, pos, len)
SUBSTRING (str FROM pos FOR len)
Os formulários sem um argumento len retornam uma substring da string str começando na posição pos. Os formulários com um argumento len retornam uma substring len caracteres longos da string str, começando na posição pos. Os formulários que usam FROM são sintaxe SQL padrão. Também é possível usar um valor negativo para pos. Nesse caso, o início da substring são os caracteres pos do final da string, em vez do início. Um valor negativo pode ser usado para pos em qualquer uma das formas desta função.
SQL> SELECT SUBSTRING('Quadratically',5);
+---------------------------------------------------------+
| SSUBSTRING('Quadratically',5) |
+---------------------------------------------------------+
| ratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('foobarbar' FROM 4);
+---------------------------------------------------------+
| SUBSTRING('foobarbar' FROM 4) |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('Quadratically',5,6);
+---------------------------------------------------------+
| SUBSTRING('Quadratically',5,6) |
+---------------------------------------------------------+
| ratica |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING_INDEX (str, delim, count)
Retorna a substring da string str antes de contar as ocorrências do delimitador delim. Se a contagem for positiva, tudo à esquerda do delimitador final (contando a partir da esquerda) será retornado. Se a contagem for negativa, tudo à direita do delimitador final (contando a partir da direita) será retornado. SUBSTRING_INDEX () executa uma correspondência com distinção entre maiúsculas e minúsculas ao pesquisar por delim.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
+---------------------------------------------------------+
| SUBSTRING_INDEX('www.mysql.com', '.', 2) |
+---------------------------------------------------------+
| www.mysql |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str)
TRIM ([remstr FROM] str)
Retorna a string str com todos os prefixos ou sufixos remstr removidos. Se nenhum dos especificadores BOTH, LEADING ou TRAILING for fornecido, BOTH será assumido. remstr é opcional e, se não for especificado, os espaços são removidos.
SQL> SELECT TRIM(' bar ');
+---------------------------------------------------------+
| TRIM(' bar ') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(LEADING 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| barxxx |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(BOTH 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
+---------------------------------------------------------+
| TRIM(TRAILING 'xyz' FROM 'barxxyz') |
+---------------------------------------------------------+
| barx |
+---------------------------------------------------------+
1 row in set (0.00 sec)UCASE (str)
UCASE () é sinônimo de UPPER ().
UNHEX (str)
Executa a operação inversa de HEX (str). Ou seja, ele interpreta cada par de dígitos hexadecimais no argumento como um número e o converte no caractere representado pelo número. Os caracteres resultantes são retornados como uma string binária.
SQL> SELECT UNHEX('4D7953514C');
+---------------------------------------------------------+
| UNHEX('4D7953514C') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)Os caracteres na string do argumento devem ser dígitos hexadecimais válidos: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. Se UNHEX () encontrar qualquer dígito não hexadecimal no argumento, ele retornará NULL.
SUPERIOR (str)
Retorna a string str com todos os caracteres alterados para maiúsculas de acordo com o mapeamento do conjunto de caracteres atual.
SQL> SELECT UPPER('Allah-hus-samad');
+---------------------------------------------------------+
| UPPER('Allah-hus-samad') |
+---------------------------------------------------------+
| ALLAH-HUS-SAMAD |
+---------------------------------------------------------+
1 row in set (0.00 sec)