SQL string functions are used primarily for string manipulation. The following table details the important string functions −
| Sr.No., SUBSTR()
Returns the substring as specified |
|
|---|---|
| 46 | TRIM()
Removes leading and trailing spaces |
| 47 | UCASE()
Synonym for UPPER() |
| 48 | UNHEX()
Converts each pair of hexadecimal digits to a character |
| 49 | UPPER()
Converts to uppercase |
ASCII(str)
Returns the numeric value of the leftmost character of the string str., Devolve 0 se o str for o texto vazio. Devolve nulo se o str for nulo. 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)
devolve uma representação em cadeia do valor binário de N, onde N é um número de longlong (BIGINT). Isto é equivalente a CONV (n, 10, 2). Devolve nulo se N for nulo.
SQL> SELECT BIN(12);+---------------------------------------------------------+| BIN(12) |+---------------------------------------------------------+| 1100 |+---------------------------------------------------------+1 row in set (0.00 sec)
BIT_LENGTH(str)
Devolve o comprimento do texto str em bits.
SQL> SELECT BIT_LENGTH('text');+---------------------------------------------------------+| BIT_LENGTH('text') |+---------------------------------------------------------+| 32 |+---------------------------------------------------------+1 row in set (0.00 sec)
CHAR (n,…, )
CHAR () interpreta cada argumento N como um inteiro e retorna uma cadeia que consiste dos caracteres dados pelos valores de código desses inteiros. Os valores nulos 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)
Devolve o comprimento do texto str medido em caracteres. Um personagem multi-byte conta como um único personagem. Isto significa que para um texto que contém cinco caracteres de dois bytes, o LENGTH() devolve 10, enquanto o CHAR_LENGTH() devolve 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,…)
Devolve a cadeia de caracteres que resulta da concatenação dos argumentos. Pode ter um ou mais argumentos. Se todos os argumentos são strings não-binárias, o resultado é uma string não-binária. Se os argumentos incluem quaisquer strings Binárias, o resultado é uma string binária. Um argumento numérico é convertido para a sua forma de cadeia binária equivalente; se você quiser evitar isso, você pode usar um molde 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 Concatenato com separador e é uma forma especial de CONCAT (). O primeiro argumento é o separador para o resto dos argumentos. O separador é adicionado entre as cadeias a concatenar. O separador pode ser uma cadeia, assim como o resto dos argumentos. Se o separador for nulo, o resultado é nulo.
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 de números. Devolve uma representação de cadeia de caracteres do número N, convertida da base DE_ base para a_ base. Devolve nulo se qualquer argumento for nulo., O argumento N é interpretado como um inteiro, mas pode ser especificado como um inteiro ou uma string. A base mínima é 2 e a base máxima é 36. Se to_base é um número negativo, N é considerado como um número assinado. Caso contrário, N é tratado como não assinado. 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,…)
Devolve str1 se N = 1, str2 se N = 2, e assim por diante. Devolve NULL se N for inferior a 1 ou superior ao número de argumentos. ELT () é o complemento do campo ().,
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,on,off])
Devolve um texto tal que, para cada bit definido nos bits de valor, você obtém um texto on e para cada bit não definido no valor, você obtém um texto off. Bits em bits são examinados da direita para a esquerda (de bits de ordem baixa para bits de Ordem alta). As cadeias de caracteres são adicionadas ao resultado da esquerda para a direita, separadas pela cadeia de separadores (o padrão é o carácter vírgula .,.). O número de bits examinados é dado por number_of_bits (por omissão, 64).
campo (str, str1,str2, str3,…,)
Devolve o índice (posição que começa com 1) de str no str1, str2, str3 … lista. Devolve 0 se o 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)
Devolve um valor na gama de 1 A n Se a Str estiver na lista de cadeias de caracteres que consiste em n substratos.
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)
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 é um número, retorna uma representação string do valor hexadecimal de N, onde N é um longlong (BIGINT) número. Isto é equivalente a CONV (n, 10, 16).,
Se N_or_S é uma cadeia de caracteres, devolve uma representação hexadecimal de cadeia de caracteres N_or_S onde cada carácter em N_or_S é convertido para 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)
inserir(str,pos,len,newstr)
Devolve o texto str, com o texto a começar na posição pos e os caracteres len a serem substituídos pelo texto newstr. Devolve o texto original se pos não estiver dentro do comprimento do texto. Substitui o resto da cadeia da posição pos se len não estiver dentro do comprimento do resto da cadeia. Devolve nulo se qualquer argumento for nulo.,
SQL> SELECT INSERT('Quadratic', 3, 4, 'What');+---------------------------------------------------------+| INSERT('Quadratic', 3, 4, 'What') |+---------------------------------------------------------+| QuWhattic |+---------------------------------------------------------+1 row in set (0.00 sec)
INSTR(str,substr)
Devolve a posição da primeira ocorrência de substr do texto str. Esta é a mesma 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)
devolve os caracteres len mais à esquerda do texto str, ou NULL se algum argumento for nulo.
SQL> SELECT LEFT('foobarbar', 5);+---------------------------------------------------------+| LEFT('foobarbar', 5) |+---------------------------------------------------------+| fooba |+---------------------------------------------------------+1 row in set (0.00 sec)
comprimento(str)
Devolve o comprimento do texto str, medido em bytes., Um personagem multi-byte conta como múltiplos bytes. Isto significa que para um texto que contém cinco caracteres de dois bytes, o LENGTH() devolve 10, enquanto o CHAR_LENGTH() devolve 5.
SQL> SELECT LENGTH('text');+---------------------------------------------------------+| LENGTH('text') |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
LOAD_ file(nome do ficheiro)
lê o ficheiro e devolve o conteúdo do ficheiro como um texto. Para usar esta função, o arquivo deve ser localizado na máquina do servidor, você deve especificar a localização completa do arquivo, e você deve ter o privilégio de arquivo. O ficheiro deve ser legível por todos e o seu tamanho inferior a bytes max_ allowed_packet.,
Se o ficheiro não existir ou não puder ser lido porque uma das condições anteriores não está satisfeita, a função devolve nulo.
A partir de SQL 5.0.19, a variável character_set_filesystem system controla a interpretação dos nomes de ficheiros que são dados como cadeias 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 devolve a posição da primeira ocorrência de sub-sequência no texto str. A segunda sintaxe retorna a posição da primeira ocorrência de sub-sequência em str string, começando na posição pos., Devolve 0 se o substr não estiver no str.
SQL> SELECT LOCATE('bar', 'foobarbar');+---------------------------------------------------------+| LOCATE('bar', 'foobarbar') |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
LOWER(str)
Devolve a str de texto com todos os caracteres alterados para minúsculas de acordo com o mapeamento do conjunto de caracteres actual.
SQL> SELECT LOWER('QUADRATICALLY');+---------------------------------------------------------+| LOWER('QUADRATICALLY') |+---------------------------------------------------------+| quadratically |+---------------------------------------------------------+1 row in set (0.00 sec)
LPAD(str,len,padstr)
Devolve o texto str, com o texto padstr preenchido com um comprimento de caracteres len. Se o str for mais longo que o len, o valor de retorno é encurtado para caracteres len.
SQL> SELECT LPAD('hi',4,'??');+---------------------------------------------------------+| LPAD('hi',4,'??') |+---------------------------------------------------------+| ??hi |+---------------------------------------------------------+1 row in set (0.00 sec)
LTRIM(str)
Devolve o texto str com os caracteres espaciais principais removidos.,
SQL> SELECT LTRIM(' barbar');+---------------------------------------------------------+| LTRIM(' barbar') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
MAKE_SET(bits,str1,str2,…)
Devolve um valor definido (uma cadeia que contém substratos separados por .,. caracteres) consistindo das cadeias de caracteres que têm o bit correspondente em bits definidos. str1 corresponde ao bit 0, str2 ao bit 1, e assim por diante. Valores nulos em str1, str2,… não são anexados 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) é um sinônimo para SUBSTRING(str,pos,len).
OCT (N)
devolve uma representação em cadeia do valor octal de N, onde o N é um número longo (BIGINT)., Isto é equivalente a CONV (n, 10, 8). Devolve nulo se N for nulo.
SQL> SELECT OCT(12);+---------------------------------------------------------+| OCT(12) |+---------------------------------------------------------+| 14 |+---------------------------------------------------------+1 row in set (0.00 sec)
OCTET_LENGTH(str)
OCTET_LENGTH() é um sinónimo de comprimento().
ORD(str)
Se o caractere mais à esquerda da string str é uma de caracteres multi-byte, retorna o código do caractere, calculado a partir dos valores numéricos de seus constituintes bytes usando esta fórmula −
(1st byte code)+ (2nd byte code . 256)+ (3rd byte code . 2562) ...
Se o caractere mais à esquerda não é um de caracteres multi-byte, ORD() retorna o mesmo valor como o ASCII() função.,
SQL> SELECT ORD('2');+---------------------------------------------------------+| ORD('2') |+---------------------------------------------------------+| 50 |+---------------------------------------------------------+1 row in set (0.00 sec)
POSITION(substr IN str)
POSITION(substr IN str) is a synonym for LOCATE(substr,str).
QUOTE (str)
cita uma cadeia de caracteres para produzir um resultado que pode ser usado como um valor de dados escapado corretamente em uma declaração SQL. A string é devolvida entre aspas simples e com cada instância de uma única citação (‘), barra invertida (‘\’), ASCII NUL, e Control-Z precedida por uma barra invertida. Se o argumento for nulo, o valor de retorno é a palavra ‘nulo’ sem incluir aspas simples.,
SQL> SELECT QUOTE('Don\'t!');+---------------------------------------------------------+| QUOTE('Don\'t!') |+---------------------------------------------------------+| 'Don\'t!' |+---------------------------------------------------------+1 row in set (0.00 sec)
Nota − Por favor verifique se a sua instalação tem algum erro com esta função, então não use esta função.
padrão de expressão regular
Esta função realiza uma correspondência padrão de expressão com padrão. Devolve 1 Se o expr corresponder ao pat; caso contrário, devolve 0. Se expr ou pat é nulo, o resultado é nulo. A expressão regular não é sensível à capitalização, exceto quando usada 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)
REPEAT(str,contagem)
Retorna uma string contendo a string str repetidos o tempo de contagem. Se a contagem for inferior a 1, devolve um texto vazio. Devolve nulo se o str ou a contagem forem nulos.
SQL> SELECT REPEAT('SQL', 3);+---------------------------------------------------------+| REPEAT('SQL', 3) |+---------------------------------------------------------+| SQLSQLSQL |+---------------------------------------------------------+1 row in set (0.00 sec)
REPLACE(str,from_ Str,to_ Str)
Devolve o texto str com todas as ocorrências do texto from_ Str substituído pelo texto to_ Str. O REPLACE () efectua uma correspondência com distinção de maiúsculas ao procurar pelo 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)
Devolve o texto str com a ordem dos caracteres invertidos.
SQL> SELECT REVERSE('abcd');+---------------------------------------------------------+| REVERSE('abcd') |+---------------------------------------------------------+| dcba |+---------------------------------------------------------+1 row in set (0.00 sec)
RIGHT(str,len)
devolve os caracteres len mais à direita do texto str, ou nulo se algum argumento for nulo.
SQL> SELECT RIGHT('foobarbar', 4);+---------------------------------------------------------+| RIGHT('foobarbar', 4) |+---------------------------------------------------------+| rbar |+---------------------------------------------------------+1 row in set (0.00 sec)
RPAD(str,len,padstr)
Devolve o texto str, com o texto padstr, até um comprimento de caracteres len. Se o str for mais longo que o len, o valor de retorno é encurtado para caracteres len.,
SQL> SELECT RPAD('hi',5,'?');+---------------------------------------------------------+| RPAD('hi',5,'?') |+---------------------------------------------------------+| hi??? |+---------------------------------------------------------+1 row in set (0.00 sec)
RTRIM(str)
Devolve o str de texto com os caracteres de espaço posterior removidos.
SQL> SELECT RTRIM('barbar ');+---------------------------------------------------------+| RTRIM('barbar ') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
SOUNDEX(str)
devolve uma sequência de soundex de str. Duas strings que soam quase a mesma devem ter strings soundex idênticas. Uma string padrão soundex é de 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 do intervalo A-Z são tratados como vogais.
SQL> SELECT SOUNDEX('Hello');+---------------------------------------------------------+| SOUNDEX('Hello') |+---------------------------------------------------------+| H400 |+---------------------------------------------------------+1 row in set (0.00 sec)
expr1 SOUNDS LIKE expr2
This is the same as SOUNDEX(expr1) = SOUNDEX(expr2).
espaço (N)
devolve uma cadeia de caracteres constituída por N espaços.
SQL> SELECT SPACE(6);+---------------------------------------------------------+| SELECT SPACE(6) |+---------------------------------------------------------+| ' ' |+---------------------------------------------------------+1 row in set (0.00 sec)
STRCMP(str1, str2)
compara duas cadeias de caracteres e devolve 0 se ambas as cadeias forem iguais, devolve-1 se o primeiro argumento for menor que o segundo, de acordo com a ordem de ordenação actual, caso contrário devolve 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 a PARTIR pos)
SUBSTRING(str a PARTIR de pos PARA len)
A forma sem um argumento tam retorna uma substring da string str iniciando na posição pos. As formas com um argumento len retornam caracteres Len substring de longo de STR string, começando na posição pos. As formas que usam são sintaxe SQL padrão. Também é possível usar um valor negativo para pos., Neste caso, o início da sub-sequência são caracteres pos do fim da cadeia, em vez do início. Um valor negativo pode ser usado para pos em qualquer uma das formas desta função.
SUBSTRING_ Index (str,delim,count)
Devolve o sub-texto do 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) é devolvido. Se a contagem for negativa, tudo à direita do delimitador final (contando da direita) é devolvido., SUBSTRING_ Index () efectua uma correspondência sensível à capitalização ao procurar 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( FROM] str)
Devolve a Str string com todos os prefixos ou sufixos de remstr removidos. Se nenhum dos especificadores ambos, liderando ou seguindo é dado, ambos são assumidos. remstr é opcional e, se não for especificado, os espaços são removidos.
UCASE (str)
UCASE () é um sinónimo de UPPER ().
UNHEX(str)
executa a operação inversa de HEX (str)., Isto é, ele interpreta cada par de dígitos hexadecimais no argumento como um número e converte-o para o caráter representado pelo número. Os caracteres resultantes são devolvidos como uma string binária.
SQL> SELECT UNHEX('4D7953514C');+---------------------------------------------------------+| UNHEX('4D7953514C') |+---------------------------------------------------------+| SQL |+---------------------------------------------------------+1 row in set (0.00 sec)
superior(str)
Devolve a Str de texto com todos os caracteres alterados para maiúsculas de acordo com o mapeamento do conjunto de caracteres actual.
SQL> SELECT UPPER('Allah-hus-samad');+---------------------------------------------------------+| UPPER('Allah-hus-samad') |+---------------------------------------------------------+| ALLAH-HUS-SAMAD |+---------------------------------------------------------+1 row in set (0.00 sec)