MySQL :: Manual de Referência do MySQL 4.1

Manual de Referência do MySQL 4.1 :: 6 Referência de Linguagem do MySQL :: 6.3 Funções para Uso em Cláusulas SELECT e WHERE :: 6.3.2 Funções String

« 6.3.1.4 Funções de Fluxo de Controle

6.3.2.1 Funções de Comparação de Strings »

Section Navigation [Toggle]

6.3.2. Funções String

[+/-]

6.3.2.1. Funções de Comparação de Strings
6.3.2.2. Caso Sensitivo

Funções string retornam NULL se o tamanho do resultado for maior que o parâmetro do servidor max_allowed_packet. See Secção 5.5.2, “Parâmetros de Sintonia do Servidor”.

Para funções que operam com as posições de uma string, a primeira posição é numerada como 1.

ASCII(str)

Retorna o valor do código ASCII do caracter mais a esquerda da string str. Retorna 0 se str é uma string vazia. Retorna NULL se str é NULL:
```
mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100
```
Veja também a função ORD().
BIN(N)

Retorna um representação string do valor binário de N, onde N é um número muito grande (BIGINT). Isto é equivalente a CONV(N,10,2). Retorna NULL se N é NULL:
```
mysql> SELECT BIN(12);
        -> '1100'
```

BIT_LENGTH(str)

Retorna o tamanho da string str em bits:

mysql> SELECT BIT_LENGTH('text');
        -> 32

CHAR(N,...)

CHAR() interpretia os argumentos como inteiros e retorna uma string com caracteres dados pelo valor do código ASCII referentes a estes inteiros. Valores NULL são desconsiderados:
```
mysql> SELECT CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
        -> 'MMM'
```
CONCAT(str1,str2,...)

Retorna a string resultante da concatenação dos argumentos. Retorna NULL se qualquer dos argumentos for NULL. Pode ter mais de 2 argumentos. Um argumento numérico é convertido para sua forma string equivalente:
```
mysql> SELECT CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
        -> NULL
mysql> SELECT CONCAT(14.3);
        -> '14.3'
```
CONCAT_WS(separador, str1, str2,...)

CONCAT_WS() significa CONCAT With Separator (CONCAT com separador) e é uma forma especial do CONCAT(). O primeiro argumento é o separador para os outros argumentos. O separador é adicionado entre as strings a serem concatenadas: O separador pode ser uma string assim como os outros argumentos. Se o separador é NULL, o resultado será NULL. A função irá desconsiderar qualquer NULL depois do argumento do separador.
```
mysql> SELECT CONCAT_WS(",","First name","Second name","Last Name");
       -> 'First name,Second name,Last Name'
mysql> SELECT CONCAT_WS(",","First name",NULL,"Last Name");
       -> 'First name,Last Name'
```
Antes do MySQL 4.1.1, CONCAT_WS() desconsiderava strings vazias assim como valores NULL.
CONV(N,da_base,para_base)

Converte números entre diferentes bases. Retorna uma representação string do número N, convertido da base da_base para base para_base. Retorna NULL se qualquer argumento é NULL. O argumento N é interpretado como um inteiro, mas pode ser especificado como um inteiro ou uma string. A base mínima é 2 e a máxima é 36. Se para_base é um número negativo, N é considerado como um número com sinal. Caso contrário, N é tratado como um número sem sinal. CONV funciona com precisão de 64-bit:
```
mysql> SELECT CONV("a",16,2);
        -> '1010'
mysql> SELECT CONV("6E",18,8);
        -> '172'
mysql> SELECT CONV(-17,10,-18);
        -> '-H'
mysql> SELECT CONV(10+"10"+'10'+0xa,10,10);
        -> '40'
```
ELT(N,str1,str2,str3,...)

Retorna str1 se N = 1, str2 se N = 2, e assim por diante. Retorna NULL se N é menor que 1 ou maior que o número de argumentos. ELT() é o complemento de FIELD():
```
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
        -> 'ej'
mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
        -> 'foo'
```
EXPORT_SET(bits,on,off,[separador,[numero_de_bits]])

Retorna uma string onde para todo bit 1 em 'bit', você obtém uma string 'on' e para cada bit 0 você obtem uma string 'off', Cada string é separada com 'separador' (padrão,',') e só 'número_de_bits' (padrão 64) de 'bits' é usado:
```
mysql> SELECT EXPORT_SET(5,'S','N',',',4)
        -> S,N,S,N
```

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

Retorna o índice de str na lista str1, str2, str3, .... Retorns 0 se str não for encontrada. FIELD() é o complemento de ELT():

mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 0

FIND_IN_SET(str,strlista)

Retorna um valor 1 para N se a string str está na lista strlist contendo N substrings. A lista de string é composta de substrings separadas pelo caracter ‘,’. Se o primeiro argumento é uma string constante e o segundo é uma coluna do tipo SET, a função FIND_IN_SET() é otimizada para usar aritmética binária! Retorna 0 se str não está na strlista ou se strlista é uma string vazia. Retorna NULL se os argumentos são NULL. Esta função não irá funcionar adequadamente se o primeiro argumento contém uma vírgula (‘,’):
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
```
HEX(N_ou_S)

Se N_OU_S é um número, é retornado um representação string do valor hexadecimal de N, onde N é um número muito grande (BIGINT). Isto é equivalente a CONV(N,10,16).

Se N_OU_S é uma string, é retornado uma string hexadecimal de N_OU_S onde cada caracter de N_OU_S é convertido para 2 dígitos hexadecimais. Isto é o inverso da string 0xff.
```
mysql> SELECT HEX(255);
        -> 'FF'
mysql> SELECT HEX("abc");
        -> 616263
mysql> SELECT 0x616263;
        -> "abc"
```
INSTR(str,substr)

Retorna a posição da primeira ocorrência da substring substr na string str. É o mesmo que as o LOCATE() com dois argumentos, exceto pelo fato de que os argumentos estão tracados:
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
Esta função é multi-byte. Na versão 3.23 do MySQL esta função é caso sensitivo, enquanto na versão 4.0 ela só é caso-sensitivo se os argumentos são uma string binária.
INSERT(str,pos,tam,novastr)

Retorna a string str, com a a substring começando na posição pos e contendo tam caracteres substituida pela string novastr:
```
mysql> SELECT INSERT('Quadratico', 3, 4, 'Onde');
        -> 'QuOndetico'
```
Esta função é multi-byte.
LCASE(str), LOWER(str)

Retorna a string str com todos caracteres alterados para letra minúsculas de acordo com o conjunto de caracteres atual (o padrão é ISO-8859-1 Latin1):
```
mysql> SELECT LCASE('MYSQL');
        -> 'mysql'
```
Esta é uma função multi-byte.
LEFT(str,tam)

Retorna os tam caracteres mais a esquerda da string str:
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
Esta função é multi-byte.
LOAD_FILE(nome_arquivo)

Lêb o arquivo e retona o conteudo do arquivo como uma string. O arquivo beve estar no servidor, você deve especificar o caminho completo para o arquivo, e você deve ter o privilégio FILE. O arquivo deve ser legível para todos e ser menor que o especificado em max_allowed_packet.

Se o arquivo não existe ou não pode ser lido devido a alguma das razões acima, a função retornará NULL:
```
mysql> UPDATE nome_tabela
           SET coluna_blob=LOAD_FILE("/tmp/picture")
           WHERE id=1;
```
Se você não está usando a versão 3.23 MySQL, você tem que fazer a leitura do arquivo dentro do seu aplicativo e criar uma instrução INSERT para atualizar o banco de dados com a informação do arquivo. Um modo de se fazer isto, se você estiver usando a biblioteca MySQL++, pode ser encontrada em http://www.mysql.com/documentation/mysql++/mysql++-examples.html.
LOCATE(substr,str), LOCATE(substr,str,pos)

A primeira sintaxe retorna a posição da primeira ocorrência da substring substr na string str. A segunda sintaxe retorna a posição da primeira ocorrência da substring substr na string str, iniciando na posição pos. Retornam 0 se substr não está em str:
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
```
LTRIM(str)

Retorna a string str com caracteres de espaços extras iniciais removidos:
```
mysql> SELECT LTRIM('  barbar');
        -> 'barbar'
```
MAKE_SET(bits,str1,str2,...)

Retorna um conjunto (uma string contendo substrings separadas por ‘,’) contendo as strings que tem o bit correspondente em bits definido . str1 corresponde ao bit 1, str2 ao bit 2, etc. Strings NULL em str1, str2, ... não são adicionadas ao resultado:
```
mysql> SELECT MAKE_SET(1,'a','b','c');
        -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'Oi','meu','mundo');
        -> 'Oi,mundo'
mysql> SELECT MAKE_SET(0,'a','b','c');
        -> ''
```
OCT(N)

Retorna uma representação string do valor octal de N, onde N é um número muito grande. Isto é equivalente a CONV(N,10,8). Retorna NULL se N é NULL:
```
mysql> SELECT OCT(12);
        -> '14'
```
ORD(str)

Se o caracter mais a esquerda da string str é um caracter multi-byte, é retornado o código para este caracter, calculado a partir dos valores do código ASCII dos seus caracteres contituintes utizando-se a seguinte fórmula: ((primeiro byte do código ASCII)*256+(segundo byte do código ASCII))[*256+terceiro byte do código ASCII...]. Se o caracter mais a esquerda não é multi-byte, é retornado o mesmo valor que a função ASCII() retorna:
```
mysql> SELECT ORD('2');
        -> 50
```
LENGTH(str), OCTET_LENGTH(str), CHAR_LENGTH(str), CHARACTER_LENGTH(str)

Retorna o tamanho da string str:
```
mysql> SELECT LENGTH('text');
        -> 4
mysql> SELECT OCTET_LENGTH('text');
        -> 4
```
LENGTH() e OCTET_LENGTH() são sinônimos e medem o tamanho da length em bytes (octets). Um caracter multi-byte conta é considerado vários bytes. CHAR_LENGTH() e CHARACTER_LENGTH() são sinônimos e medem o tamanho da string em caracteres. Um caracter multi-byte conta como um único caracter. Isto significa que para uma string contendo cinco caracteres de dois bytes, LENGTH() retorna 10, enquanto CHAR_LENGTH() retorna 5.
MID(str,pos,len)

MID(str,pos,len) é um sinônimo para SUBSTRING(str,pos,len).
POSITION(substr IN str)

POSITION(substr IN str) é um sinônimo para LOCATE(substr,str).
QUOTE(str)

Coloca uma string entre aspas para produzir um resultado que possa ser usada em uma intrução SQL como um valor de dados com o caracter de escape correto. A string é retornada entre aspas simples e cada instâqncia de aspas simples (‘'’), barra invertida (‘\’), ASCII NUL, e Control-Z é precedida por uma barra invertida. Se o argumento é NULL, o valor retornado é a palavra ``NULL'' sem aspas simples.

A função QUOTE() foi adicionada na versão 4.0.3 do MySQL.
```
mysql> SELECT QUOTE("Don't");
        -> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
        -> NULL
```
REPEAT(str,cont)

Retorna uma string consistindo da string str repetida cont vezes. Se cont <= 0, é retornado uma string vazia. É retornado NULL se str ou cont são NULL:
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
REPLACE(str,da_str,para_str)

Retorna a string str com todas ocorrências da string da_str substituida pela string para_str:
```
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'
```
Esta função é multi-byte.
REVERSE(str)

Returns the string str with the order of the characters reversed:
```
mysql> SELECT REVERSE('abc');
        -> 'cba'
```
Esta função é multi-byte.

RIGHT(str,tem)

mysql> SELECT RIGHT('foobarbar', 4);
        -> 'rbar'

Esta função é multi-byte.

RPAD(str,tam,strpreech)

Retorna a string str, preenchida a direita com a string strpreench para um tamanho de tam caracteres. Se str é maior que tam, o valor retornado é reduzido para tam caracteres.
```
mysql> SELECT RPAD('hi',5,'?');
        -> 'hi???'
```
RTRIM(str)

Retourna a string str com caracteres de espaços extras finais removidos:
```
mysql> SELECT RTRIM('barbar   ');
        -> 'barbar'
```
Esta função é multi-byte.
SOUNDEX(str)

Retorna uma string 'soundex' de str. Duas strings que parecidas fonéticamentea devem ter strings 'soundex' iguais. Uma string soundex padrão possui 4 caracteres, mas a função SOUNDEX() retorna uma string de tamanho arbitrário. Você posde usar SUBSTRING() no resultado para obter uma string 'soundex' padrão. Todos os caracteres não alfanuméricos são ignorados na string dada. Todas caracteres internacionais fora da faixa A-Z são tratados como vogais:
```
mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'
```
SPACE(N)

Retorna uma string contendo N caracteres de espaço:
```
mysql> SELECT SPACE(6);
        -> '      '
```
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,tam), SUBSTRING(str FROM pos FOR tam)

A forma sem um argumento tam retorna uma substring da string str iniciando na posição pos. A forma com um argumento tam retorna a substring com tam caracteres da string str, iniciando da posição pos. A forma variante que utiliza FROM é a sintaxe SQL-92:
```
mysql> SELECT SUBSTRING('Quadratically',5);
        -> 'ratically'
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
        -> 'barbar'
mysql> SELECT SUBSTRING('Quadratically',5,6);
        -> 'ratica'
```
Esta função é multi-byte.
SUBSTRING_INDEX(str,delim,cont)

Retorna a substring da string str antes de cont ocorrencias do delimitador delim. Se cont é positivo, tudo a esquerda do delimitador final (contando a partir da esquerda) é retornado. Se cont é negativo, tudo a direita do delimitador final (contando a partir da direita) é retornado.
```
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
```
Esta função é multi-byte.
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)

Retorna a string str com todos prefixos e/ou sufixos remstr removidos. Se nenhum dos especificadores BOTH, LEADING ou TRAILING são dados, é considerado BOTH. Se remstr não é especificada, espaços são removidos:
```
mysql> SELECT TRIM('  bar   ');
        -> 'bar'
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
        -> 'barxxx'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
        -> 'bar'
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
        -> 'barx'
```
Esta função é multi-byte.
UCASE(str), UPPER(str)

Retorna a string str com todos caracteres alterados para letra maiúsculas de acordo com o conjunto de caracteres atual (o padrão é ISO-8859-1 Latin1):
```
mysql> SELECT UCASE('Hej');
        -> 'HEJ'
```
Esta é uma função multi-byte.

This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.

Top / Previous / Next / Up / Table of Contents