\0

Um caracter ASCII 0 (NUL).

\'

Um caracter de aspas simples (?'?).

\"

Um caracter de aspas duplas (?"?).

\b

Um caracter de backspace.

\n

Um caracter de nova linha.

\r

Um caracter de retorno de carro.

\t

Um caracter de tabulação.

\z

ASCII(26) (Control-Z). Este caracter pode ser codificado para permitir que você contorne o problema que o ASCII(26) possui comoEND-OF-FILE ou EOF (Fim do arquivo) no Windows. (ASCII(26) irá causar problemas se você tentar usar mysql banco_dados < nome_arquivo).

\\

O caracter de barra invertida (?\?) character.

\%

Um caracter ?%?. Ele pode ser usado para pesquisar por instâncias literais de ?%? em contextos onde ?%? deve, de outra maneira, ser interpretado como um meta caracter. See Secção 6.3.2.1, ?Funções de Comparação de Strings?.

\_

Um caracter ?_?. Ele é usado para pesquisar por instâncias literais de ?_? em contextos onde ?_? deve, de outra maneira, ser intrerpretado como um meta caracter. See Secção 6.3.2.1, ?Funções de Comparação de Strings?.

Um ?'? dentro de uma string com ?'? pode ser escrita como ''''.

Um ?"? dentro de uma string com ?"? pode ser escrita como '""'.

Você pode preceder o caracter de aspas com um caracter de escape (?\?).

Um ?'? dentro de uma string com ?"? não precisa de tratamento especial e não precisa ser duplicada ou utilizada com caracter de escape. Da mesma maneira, ?"? dentro de uma string com ?'? não necessita de tratamento especial.

NUL

ASCII 0. Você deve representá-lo como '\0' (uma barra invertida e um caractere ?0?).

\

ASCII 92, barra invertida. Representado como '\\'.

'

ASCII 39, aspas simples. Representado como '\''.

"

ASCII 34, aspas duplas. Representado como '\"'.

Valores de ano na faixa 00-69 são convertidos para 2000-2069.

Valores de anos na faixa 70-99 são convertidos para 1970-1999.

A coluna não é explicitamente especificada em uma instrução INSERT ou LOAD DATA INFILE.

A coluna não é explicitamente especificada em uma instrução UPDATE e e alguma outra coluna muda o valor. (Note que um UPDATE que coloca em uma coluna o mesmo valor que ele já possui não irá causar a atualização da coluna TIMESTAMP, porque se você atribui a uma coluna o seu valor atual, MySQL ignora a atualização para maior eficiência).

Você define explicitamente a uma coluna TIMESTAMP o valor NULL.

Deixe o MySQL definir a coluna quando o registro é criado. Isto irá inicializa-la com a data e hora atuais.

Quando você realizar subsequentes atualizações em outras colunas do registro, defina explicitamente a coluna TIMESTAMP com o valor atual.

Como uma string nos formatos 'YYYY-MM-DD HH:MM:SS' ou 'YY-MM-DD HH:MM:SS'. Uma sintaxe ``relaxada'' é permitida---nenhum caracter de pontuação pode ser usado como um delimitador entre parte de data ou hora. Por exemplo, '98-12-31 11:30:45', '98.12.31 11+30+45', '98/12/31 11*30*45', e '98@12@31 11^30^45' são equivalentes.

Como uma string nos formatos 'YYYY-MM-DD' ou 'YY-MM-DD'. Uma sintaxe ``relaxada'' é permitida aqui também. Por exemplo, '98-12-31', '98.12.31', '98/12/31', e '98@12@31' são equivalentes.

Como uma string sem delimitadores nos formatos 'YYYYMMDDHHMMSS' ou 'YYMMDDHHMMSS', desde que a string faça sentido como data. Por example, '19970523091528' e '970523091528' são interpretadas com '1997-05-23 09:15:28', mas '971122129015' é ilegal (tem uma parte de minutos sem sentido) e se torna '0000-00-00 00:00:00'.

Como uma string sem delimitadores nos formatos 'YYYYMMDD' ou 'YYMMDD', desde que a string tenha sentido com data. Por exemplo, '19970523' e '970523' são interpretedas como '1997-05-23', mas '971332' é ilegal (tem uma parte de mês sem sentido) e se torna '0000-00-00'.

Como um número nos formatos YYYYMMDDHHMMSS ou YYMMDDHHMMSS, desde que o número faça sentido como uma data. Por exemplo, 19830905132800 e 830905132800 são interpretedos como '1983-09-05 13:28:00'.

Como um número nos formatos YYYYMMDD ou YYMMDD, desde que o número faça sentido como data. Por exemplo, 19830905 e 830905 são interpretedos como '1983-09-05'.

Como o resultado de uma função que retorne uma valor aceitavel em um contexto DATETIME, DATE ou TIMESTAMP, tal como NOW() ou CURRENT_DATE.

Sempre especifique o ano, mês e dia, mesmo se seus tipos de coluna são TIMESTAMP(4) ou TIMESTAMP(2). De outra forma, os valores não serão datas legais date e um 0 será armazenado.

Se você usa ALTER TABLE para aumentar uma coluna TIMESTAMP, informações serão mostradas como se antes estivessem ``escondidas''.

De forma similar, reduzindo o tamanho de uma coluna TIMESTAMP não causa perda de informação, exceto no sentido de que menos informação aparece quando os valores são mostrados.

Embora os valores TIMESTAMP sejam armazenados com precisão total, a única função que opera diretamente com o valor armazenado é UNIX_TIMESTAMP(). OUtras funções operam com o formato do valor recuperado Isto significa que não se pode usar funções como HOUR() or SECOND() a menos que a parte relevante do valor TIMESTAMP esteja incluído no valor formatado. POr exemplo, a parte HH de uma coluna TIMESTAMP não é mostrada a menos que o tamanho do display seja de pelo menos 10, logo tentar usar HOUR() em um valor TIMESTAMP menor produz um resultado sem significado.

Se você atribuir um valor de DATE value a um objeto DATETIME ou TIMESTAMP, a parte da hora do valor resultante é definido como '00:00:00', porque o vlaor DATE não contém informações de hora.

Se você atribuir um valor DATETIME ou TIMESTAMP para um objeto DATE, a parte da hora do valor resultante é deletado, pois o tipo DATE não armazena informações de hora.

Lembre-se de que embora todos os valores DATETIME, DATE, e TIMESTAMP possam ser especificados usando o mesmo conjunto de formatos, os tipos não tem a mesa faixa de valores. Por exemplo, valores TIMESTAMP não podem ser anteriores a 1970 ou posteriores a 2037. Isto significia que datas como '1968-01-01', são permitidas como valores DATETIME ou DATE, mas não são válidas para valores TIMESTAMP e serão covertidas para 0 se atribuidas para tais objetos.

A forma ``relaxada'' permitida em valores especificados com strings podem causar certas confusões. Por exemplo, um valor como '10:11:12' pode parecer com um valor de hora devido ao limitador ?:?, mas se usado em um contexto de data será interpretado como o ano '2010-11-12'. O valor '10:45:15' será convertido para '0000-00-00' pois '45' não é um valor de mês permitido.

O servidor MySQL funciona basicamente checando a validade da data: dias entre 00-31, mês entre 00-12, anos entre 1000-9999. Qualquer data que não esteja nesta faixa será revetida para 0000-00-00. Por favor, note que isto ainda lhe permite armazenar datas invalidas tais como 2002-04-31. Isto permite a aplicações web armazenar dados de um formulário sem verificações adicionais. Para assegurar que a data é valida, faça a checagem em sua aplicação.

Valores de anos especificados com 2 digitos são ambíguos, pois o século não é conhecido. MySQL interpreta valores de anos com dois digitos usando as seguintes regras:

Como uma string no formato 'D HH:MM:SS.fração' . (Note que o MySQL não armazena ainda frações para a coluna time.) Pode-se também utilizar uma das seguintes sintaxes ``relaxadas'':

HH:MM:SS.fração, HH:MM:SS, HH:MM, D HH:MM:SS, D HH:MM, D HH ou SS. Aqui D é um dia entre 0-33.

Como uma string sem delimitadores no formato 'HHMMSS', desde que ela tenha sentido como uma hora. Por exemplo, '101112' é esntendido como '10:11:12', mas '109712' é ilegal (a parte dos minutos não tem nenhum sentido) e se torna '00:00:00'.

Como um número no formato HHMMSS, desde que tenha sentido como uma hora. Por exemplo, 101112 é entendido com '10:11:12'. Os formatos alternativos seguintes também são entendidos: SS, MMSS, HHMMSS e HHMMSS.fração. Note que o MySQL ainda não armazena frações.

Como o resultado de uma função que retorne um valor que é aceitável em um contexto do tipo TIME, tal como CURRENT_TIME.

Como uma string de 4 digitos na faixa de '1901' até '2155'.

Como um número de 4 dígitos na faixa de 1901 até 2155.

Como uma string de dis dígitos na faixa '00' até '99'. Valores na faixa de '00' até '69' e '70' até '99' são convetidas para valores YEAR na faixa de 2000 até 2069 e 1970 até 1999.

Como um número de 2 digitos na faixa de 1 até 99. Valores na faixa de 1 até 69 e 70 até 99 são convertidos para valores YEAR na faixa de 2001 até 2069 e 1970 até 1999. Note que a faixa para números de dois dígitos é um pouco diferente da faixa de strings de dois dígitos, pois não se pode especificar zero diretamente como um número e tê-lo interpretado com 2000. Você deve especificá-lo como uma string '0' ou '00' ou ele será interpretado com 0000.

Como o resultado de uma função que retorna um valor que é aceitável em um contexto do tipo YEAR, tal como NOW().

Você pode ter indices em um campo BLOB e TEXT no MySQL Versão 3.23.2 e mais novas. Versões antigas do MySQL não suportam isto.

Não há remoção de espaços extras para campos BLOB e TEXT quando os valores são armazenados, como há em campos VARCHAR.

Colunas BLOB e TEXT não podem ter valores padrões.

Se você quiser utilizar GROUP BY ou ORDER BY em um campo BLOB ou TEXT, você deve converte-los em objetos de tamanho fixo. O modo padrão de se fazer isto é com a função SUBSTRING. Por exemplo:

mysql> SELECT comentario FROM nome_tabela,SUBSTRING(comentario,20) AS substr
    ->                 ORDER BY substr;

Se você não fizer isto, só os primeiros max_sort_length bytes de uma coluna serão utilizados na ordenação. O valor padrão de max_sort_length é 1024; este calor pode ser alterado utilizando-se a opção -O quando o servidor é inicializado. Você pode agrupar uma expressão envolvendo valores BLOB ou TEXT especificando a posição da coluna ou utilizando apelidos (alias):

mysql> SELECT id,SUBSTRING(col_blob,1,100) FROM nome_tabela GROUP BY 2;
mysql> SELECT id,SUBSTRING(col_blob,1,100) AS b FROM nome_tabela GROUP BY b;

O tamanho máximo de uma objeto BLOB ou TEXTé determinado pelo seu tipo, mas o maior valor que você pode, atualmente, transmitir entre o cliente e o servidor é determinado pela quantidade de memória disponível e o tamanho dos buffers de comunicação. Você pode mudar o tamanho do buffer de mensagem (max_allowed_packet), mas você deve faze-lo no servidor e no cliente. See Secção 5.5.2, ?Parâmetros de Sintonia do Servidor?.

Se você inserir um valor inválido em um ENUM (isto é, uma string que não está presente na lista de valores permitidos), a string vazia é inserida no lugar como um valor especial de erro. Esta string pode se diferenciar de um string vazia 'norma' pelo fato de que esta string tem uo valor numérico 0. Veremos mais sobre este assunto mais tarde.

Se um ENUM é declarado NULL, NULL é também um valor permitido para a coluna, e o valor padrao é NULL. Se um ENUM é decalarado NOT NULL, o valor padrão é o primeiro elemento da lista de valores permitidos.

Valores da lista de elementos permitidos na especificação da coluna são números começados com 1.

O valor de índice de uma string vazia que indique erro é 0. Isto significa que você pode usar a seguinte instrução SELECT para encontrar linhas nas quais valores ENUM inválidos forma atribuidos:

mysql> SELECT * FROM nome_tabela WHERE col_enum=0;

O índice de um valor NULL é NULL.

Se um ou ambos os argumentos são NULL, o resultado da comparação é NULL, exceto para o operador <=>.

Se ambos os argumentos em uma comparação são strings, eles são comparados como strings.

Se ambos os argumentos são inteiros, eles são comparados como inteiros.

Valores hexadecimais são tratados como strings binárias se não comparadas a um número.

Se uma dos argumentos é uma coluna TIMESTAMP ou DATETIME e o outro argumento é uma constante, a constante é convertida para um timestamp antes da comparação ser realizada. Isto ocorre para ser mais amigável ao ODBC.

Em todos os outros casos, os argumentos são coparados como números de ponto flutuante (real).

=

Igual:

mysql> SELECT 1 = 0;
        -> 0
mysql> SELECT '0' = 0;
        -> 1
mysql> SELECT '0.0' = 0;
        -> 1
mysql> SELECT '0.01' = 0;
        -> 0
mysql> SELECT '.01' = 0.01;
        -> 1

<>, !=

Diferente:

mysql> SELECT '.01' <> '0.01';
        -> 1
mysql> SELECT .01 <> '0.01';
        -> 0
mysql> SELECT 'zapp' <> 'zappp';
        -> 1

<=

Menor que ou igual:

mysql> SELECT 0.1 <= 2;
        -> 1

<

Menor que:

mysql> SELECT 2 < 2;
        -> 0

>=

Maior que ou igual:

mysql> SELECT 2 >= 2;
        -> 1

>

Maior que:

mysql> SELECT 2 > 2;
        -> 0

<=>

Igual para NULL:

mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
        -> 1 1 0

IS NULL, IS NOT NULL

Teste para saber se um valor é ou não NULL:

mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
        -> 0 0 1
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
        -> 1 1 0

Para estar apto a funcionar bem com outros programas, MySQL suporta os seguintes recursos extras quando utiliza-se IS NULL:

expr BETWEEN min AND max

Se expr é maior que ou igual a min e expr é menor que ou igual a max, BETWEEN retorna 1, senão é retornado 0. Isto é equivalente a expressão (min <= expr AND expr <= max) se todos os argumentos são do mesmo tipo. Senão os tipos são convertidos, conforme as regras acima, e aplicadas a todos os três argumentos. Note que antes da versão 4.0.5 argumentos eram convertidos para o tipo da expr.

mysql> SELECT 1 BETWEEN 2 AND 3;
        -> 0
mysql> SELECT 'b' BETWEEN 'a' AND 'c';
        -> 1
mysql> SELECT 2 BETWEEN 2 AND '3';
        -> 1
mysql> SELECT 2 BETWEEN 2 AND 'x-3';
        -> 0

expr NOT BETWEEN min AND max

O mesmo que NOT (expr BETWEEN min AND max).

expr IN (valor,...)

Retorna 1 se expr é qualquer dos valores na lista IN, senão retorna 0. Se todos os valores são constantes, então os valores são avaliados de acordo com o tipo da expr e ordenado. A busca do item é então feita usando pesquisa binária. Isto significa que IN é muito rápido se os valores da lista IN forem todos contantes. Se expr é uma expressão strig em caso-sensitivo, a comparação é realizadas no modo caso-sensitvo:

mysql> SELECT 2 IN (0,3,5,'wefwf');
        -> 0
mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
        -> 1

O número de valores na lista IN é limitada apenas pelo valor max_allowed_packet.

Na versão 4.1 (para se adequar ao padrão SQL-99), IN returna NULL não apeans se a expressão a sua esquerda é NULL, mas também se nenhuma correspondência é encontrada na lista e uma de suas expressões é NULL.

A partir do MySQL versão 4.1, uma cláusula IN() também pode conter uma subquery. See Secção 6.4.2.3, ?Subqueries with ANY, IN, and SOME?.

expr NOT IN (valor,...)

O mesmo que NOT (expr IN (valor,...)).

ISNULL(expr)

Se expr é NULL, ISNULL() retorna 1, senão retorna 0:

mysql> SELECT ISNULL(1+1);
        -> 0
mysql> SELECT ISNULL(1/0);
        -> 1

Note que a compração de valores NULL usando = sempre será falso!

COALESCE(lista)

Retorna o primeiro elemento não NULL na lista:

mysql> SELECT COALESCE(NULL,1);
        -> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
        -> NULL

INTERVAL(N,N1,N2,N3,...)

Retorna 0 se N < N1, 1 se N < N2 e assim por diante ou -1 se N é NULL. Todos os argumentos são tratados como inteiros. Isto exige que N1 < N2 < N3 < ... < Nn para que esta função funcione corretamente. Isto ocorre devido a utilização pesquisa binária (muito rápida):

mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
        -> 3
mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
        -> 2
mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
        -> 0

NOT, !

NOT logico. Avalia como 1 se o operador é 0, como 0 se o operador é diferente de zero, e NOT NULL retorna NULL.

mysql> SELECT NOT 10;
        -> 0
mysql> SELECT NOT 0;
        -> 1
mysql> SELECT NOT NULL;
        -> NULL
mysql> SELECT ! (1+1);
        -> 0
mysql> SELECT ! 1+1;
        -> 1

O último exemplo produz 1 pois a a expressão é avaliada como (!1)+1.

AND, &&

AND lógico. Avalia como 1 se todos os operandos são diferentes de zero e não é NULL, como 0 se um ou mais operandos são 0, senão retorna NULL.

mysql> SELECT 1 && 1;
        -> 1
mysql> SELECT 1 && 0;
        -> 0
mysql> SELECT 1 && NULL;
        -> NULL
mysql> SELECT 0 && NULL;
        -> 0
mysql> SELECT NULL && 0;
        -> 0

Por favor note que as versões do MySQL anteriores a versão 4.0.5 param a avaliação quando um valor NULL é encontrado, e não continua o processo buscando por possíveis 0s. Isto significa que nessa versão, SELECT (NULL AND 0) retorna NULL ao invés de 0. Na versão 4.0.5 o código tem sido re-elaborado para que o resultado sempre seja como prescrito pelo padrão SQL utilizando a otimização sempre que possível.

OR, ||

OR lógico. Avalia como 1 se algum operando é diferente de zero e como NULL se algum operando for NULL, senão 0 é retornado.

mysql> SELECT 1 || 1;
        -> 1
mysql> SELECT 1 || 0;
        -> 1
mysql> SELECT 0 || 0;
        -> 0
mysql> SELECT 0 || NULL;
        -> NULL
mysql> SELECT 1 || NULL;
        -> 1

XOR

XOR lógico. Retorna NULL se o operando também é NULL. Para operandos não NULL, avalia como 1 se um número ímpar de operandos é diferente de zero, senão 0 é retornado.

mysql> SELECT 1 XOR 1;
        -> 0
mysql> SELECT 1 XOR 0;
        -> 1
mysql> SELECT 1 XOR NULL;
        -> NULL
mysql> SELECT 1 XOR 1 XOR 1;
        -> 1

a XOR b é matematicamente igual a (a AND (NOT b)) OR ((NOT a) and b).

XOR foi adicionado na versão 4.0.2.

CASE valor WHEN [valor comparado] THEN resultado [WHEN [valor comparado] THEN resultado ...] [ELSE resultado] END, CASE WHEN [condição] THEN result [WHEN [condição] THEN resultado ...] [ELSE resultado] END

A primeira expressão retorna o resultado onde valor=valor comparado. A segunda expressão retorna o o resultado da primeira condição, a qual é verdadeira. Se não existe nenhum resultado correspondente, então o resultado depois do ELSE é retornado. Se não existe parte ELSE então é retornado NULL is returned:

mysql> SELECT CASE 1 WHEN 1 THEN "um"
           WHEN 2 THEN "dois" ELSE "mais" END;
       -> "one"
mysql> SELECT CASE WHEN 1>0 THEN "verdadeiro" ELSE "falso" END;
       -> "true"
mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
       -> NULL

O tipo do valor de retorno (INTEGER, DOUBLE ou STRING) é do mesmo tipo do primeiro valor retornado (a expressão depois do primeiro THEN).

IF(expr1,expr2,expr3)

Se expr1 é VERDADEIRA (expr1 <> 0 e expr1 <> NULL) então IF() retorna expr2, senão ela retorna expr3. IF() returna um valor numérico ou string, dependendo do contexto no qual é usado.

mysql> SELECT IF(1>2,2,3);
        -> 3
mysql> SELECT IF(1<2,'sim','não');
        -> 'sim'
mysql> SELECT IF(STRCMP('teste','teste1'),'não','sim');
        -> 'não'

Se expr2 ou expr3 é explicitamente NULL então o tipo resultante da função IF() é o tipo da coluna não NULL. (Este comportamento é novo na versão 4.0.3 do MySQL).

expr1 é avaliada como um valor inteiro, o qual significa que se você está testando valores de ponto flutuante ou strings, você de fazê-lo usando um operando de comparação:

mysql> SELECT IF(0.1,1,0);
        -> 0
mysql> SELECT IF(0.1<>0,1,0);
        -> 1

No primeiro caso acima, IF(0.1) retorna 0 porque 0.1 é convertido para um valor inteiro, resultando um um teste IF(0). Isto pode não ser o que você esperava. No segundo caso, a comparação testa se o valor de ponto flutuante não é zero. O resultado da comparação converte o termo em um interiro.

O tipo de retorno padrão de IF() (o que pode importar quando ele é armazenado em uma tabela temporária) é calculado na versão 3.23 do MySQL de seguinte forma:

Se expr2 e expr3 são strings, então o resultado é caso-insensitivo se ambas strings são caso insensitivo. (A patir da versão 3.23.51)

IFNULL(expr1,expr2)

Se expr1 não é NULL, IFNULL() retorna expr1, senão retorna expr2. IFNULL() retorna um valor numérico ou string, dependendo do contexto no qual é usado:

mysql> SELECT IFNULL(1,0);
        -> 1
mysql> SELECT IFNULL(NULL,10);
        -> 10
mysql> SELECT IFNULL(1/0,10);
        -> 10
mysql> SELECT IFNULL(1/0,'yes');
        -> 'yes'

Na versão 4.0.6 e acima o valor resultante padrão de IFNULL(expr1,expr2) é o mais geral das duas expressões, na seguinte ordem: STRING, REAL ou INTEGER. A diferença das versões anteriores é mais notável quando se cria uma tabela baseada em uma expressão ou o MySQL tem que armazenar internamente um valor de IFNULL() em uma tabela temporária.

CREATE TABLE foo SELECT IFNULL(1,"teste") as teste;

Na versão 4.0.6 do MySQL o tipo da coluna 'teste' é CHAR(4) enquanto nas versões anteriores ela seria do tipo BIGINT.

NULLIF(expr1,expr2)

Se expr1 = expr2 for verdadeiro, é retornado NULL senão é retornado expr1. Isto é o mesmo que CASE WHEN x = y THEN NULL ELSE x END:

mysql> SELECT NULLIF(1,1);
        -> NULL
mysql> SELECT NULLIF(1,2);
        -> 1

Note que expr1 é avaliada duas vezes no MySQL se os argumentos não são iguais.

expr LIKE pad [ESCAPE 'car-escape']

Correspondência de padrões usando uma simples expressão de comparações SQL. Retorna 1 (VERDADEIRO) ou 0 (FALSO). Com LIKE você pode usar os seguintes meta-caracteres no padrao:

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

Para testar instâncias literais de um meta caracter, preceda o caracter com o carcter de escape. Se você não especificar o caracter de ESCAPE, assume-se ?\?:

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

Para especificar um caracter de escape diferebte, use a cláusula ESCAPE:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

As seguintes instruções mostram que a comparação de strings são caso-insensitivo, a menos que um dos operandos seja uma string binária:

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

LIKE é permitido em uma expressão numérica! (Esta é uma extensão MySQL para o LIKE do SQL-99.)

mysql> SELECT 10 LIKE '1%';
        -> 1

Nota: Como MySQL usa sintaxe de escape do C em strings (por exemplo, '\n'), você deve dobrar qualquer ?\? que você usar em sua string LIKE. Por exemplo, para pesquisar por '\n', especifique-o como '\\n'. Para buscar por ?\?, especifique-o como '\\\\' (as barras invertidas são eliminadas uma vez pelo analizador e outra vez quando a correspondência de padrões é feita, deixando uma únicas barra invertida para ser verificada).

Note: O LIKE atual não é um caracter multi-byte. Comparaçãoes são feitas caracter por caracter.

expr NOT LIKE pad [ESCAPE 'car-escape']

O mesmo que NOT (expr LIKE pad [ESCAPE 'car-escape']).

expr SOUNDS LIKE expr

O mesmo que SOUNDEX(expr)=SOUNDEX(expr) (disponível apenas na versão 4.1 ou posterior).

expr REGEXP pad, expr RLIKE pad

Realiza a busca de padrões em uma expressã string com base no padrão pad. O padrão pode ser uma expressão regular extendida. See Apêndice G, Sintaxe de Expressões Regulares do MySQL. Retorna 1 se expr conincide com pad, senão retorna 0. RLIKE é um sinônimo para REGEXP, fornecido para compatibilidade com mSQL. Nota: Como MySQL usa a sintaxe de escape do C em strings (por exemplo, '\n'), você deve dobrar qualquer ?\? que você use em sua string REGEXP. Como na versão 3.23.4 do MySQL, REGEXP é caso- insensitivo para strings normais (não binárias).

mysql> SELECT 'Monty!' REGEXP 'm%y%%';
        -> 0
mysql> SELECT 'Monty!' REGEXP '.*';
        -> 1
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
        -> 1
mysql> SELECT "a" REGEXP "A", "a" REGEXP BINARY "A";
        -> 1  0
mysql> SELECT "a" REGEXP "^[a-d]";
        -> 1

REGEXP e RLIKE usam o conjunto de caracteres atual (ISO-8859-1 Latin1 por padrão) para decidir o tipo de caracter.

expr NOT REGEXP pad, expr NOT RLIKE pad

O mesmo que NOT (expr REGEXP pad).

STRCMP(expr1,expr2)

STRCMP() retorna 0 se as string são a mesma, -1 se o primeiro argumento é menor que o segundo de acordo com a ordenação atual e 1 em caso contrário:

mysql> SELECT STRCMP('texto', 'texto2');
        -> -1
mysql> SELECT STRCMP('texto2', 'texto');
        -> 1
mysql> SELECT STRCMP('texto', 'texto');
        -> 0

MATCH (col1,col2,...) AGAINST (expr [IN BOOLEAN MODE | WITH QUERY EXPANSION] )

MATCH ... AGAINST() é usado para busca de textos completos e retorna a relvância - similaridade medidad entre o texto nas colunas (col1,col2,...) e a consulta expr. Relevância é um número de ponto flutuante. Relevância zero significa que não houve nenhuma similaridade. MATCH ... AGAINST() está disponível na versão 3.23.23 ou posterior do MySQL. A extensão IN BOOLEAN MODE foi adicionada na versão 4.0.1, WITH QUERY EXPANSION foi adicionado na versão 4.1.1. Para detalhes e exemplos de uso, veja Secção 6.8, ?Pesquisa Full-text no MySQL?.

BINARY

O operador BINARY transforma uma string em uma string binária. Este é um modo fácil de forçar a comparação para se caso-sensitivo mesmo se a coluna não seja definida como BINARY ou BLOB:

mysql> SELECT "a" = "A";
        -> 1
mysql> SELECT BINARY "a" = "A";
        -> 0

BINARY string é um atalho para CAST(string AS BINARY). See Secção 6.3.5, ?Funções de Conversão?. BINARY foi introduzida na versão 3.23.0 do MySQL.

Note que em alguns contextos MySQL não estará apto a usar o índice de forma eficiente quando se transformar uma coluna índice em BINARY.

+

Adição:

mysql> SELECT 3+5;
        -> 8

-

Subtração:

mysql> SELECT 3-5;
        -> -2

*

Multiplicação:

mysql> SELECT 3*5;
        -> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
        -> 0

O resultado da última expressão é incorreta porque o resultado da multiplicação de inteiros excede a faixa de 64-bits dos cálculos BIGINT.

/

Divisão:

mysql> SELECT 3/5;
        -> 0.60

Divisões por zero produz um resultado NULL:

mysql> SELECT 102/(1-1);
        -> NULL

Uma divisão será calculada com aritimética BIGINT somente se executada em um contexto no qual o resultado é convertido para um interiro!

-

Menos unario. Muda o sinal do argumento:

mysql> SELECT - 2;
        -> -2

Note que se este operador é utilizando com um BIGINT, o valor retornado é um BIGINT! Isto significa que você deve evitar usar - em inteiros que pode ter o valor de -2^63!

ABS(X)

Retorna o valor absoluto de X:

mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32

O uso desta função é seguro com valores BIGINT.

SIGN(X)

Retorna o sinal do argumento como -1, 0, ou 1, dependendo de quando X é negativo, zero, ou positivo:

mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1

MOD(N,M), %

Modulo (como o operador % em C). Retorna o resto de N dividido por M:

mysql> SELECT MOD(234, 10);
        -> 4
mysql> SELECT 253 % 7;
        -> 1
mysql> SELECT MOD(29,9);
        -> 2
mysql> SELECT 29 MOD 9;
        -> 2

O uso desta função é seguro com valores BIGINT. O último exemplo só funciona no MySQL 4.1

FLOOR(X)

Retorna o maior valor inteiro não maior que X:

mysql> SELECT FLOOR(1.23);
        -> 1
mysql> SELECT FLOOR(-1.23);
        -> -2

Note que o valor retornado é convertido para um BIGINT!

CEILING(X), CEIL(X)

Retorna o menor valor inteiro não menor que X:

mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEIL(-1.23);
        -> -1

O alias CEIL() foi adicionado versão 4.0.6.

Note que o valor retornado é convertido para um BIGINT!

ROUND(X), ROUND(X,D)

Retorna o argumeto X, arredondado para o inteiro mais próximo. Com dois argumentos o arredandamento é feito para um número com D decimais.

mysql> SELECT ROUND(-1.23);
        -> -1
mysql> SELECT ROUND(-1.58);
        -> -2
mysql> SELECT ROUND(1.58);
        -> 2
mysql> SELECT ROUND(1.298, 1);
        -> 1.3
mysql> SELECT ROUND(1.298, 0);
        -> 1
mysql> SELECT ROUND(23.298, -1);
        -> 20

Note que o comportamento de ROUND() quando o argumento está no meio do caminho entre dois inteiros depende da implementação da biblioteca C. Alguns arredondamentos para o número mais próximo, são sempre para baixo, para cima ou são zero. Se você precisa de um tipo de arredondamento, você deve usar uma função bem definida como TRUNCATE() ou FLOOR().

DIV

Divisão de inteiros. Similar ao FLOOR() mas seguro com valores BIGINT.

mysql> SELECT 5 DIV 2
  -> 2

DIV é novo no MySQL 4.1.0.

EXP(X)

Retorna o valor de e (the base of natural logarithms) raised to the power of X:

mysql> SELECT EXP(2);
        -> 7.389056
mysql> SELECT EXP(-2);
        -> 0.135335

LN(X)

Retorna o logaritmo natural de X:

mysql> SELECT LN(2);
        -> 0.693147
mysql> SELECT LN(-2);
        -> NULL

Esta função foi adicionada na versão 4.0.3 do MySQL. É sinônimo de LOG(X) no MySQL.

LOG(X), LOG(B,X)

Se chamado com um parâmetro, esta função retorna o logarítmo natural de X:

mysql> SELECT LOG(2);
        -> 0.693147
mysql> SELECT LOG(-2);
        -> NULL

Se chamado com dois parâmetros, esta função retorna o logarítmo natural de X para uma base arbitraria B:

mysql> SELECT LOG(2,65536);
        -> 16.000000
mysql> SELECT LOG(1,100);
        -> NULL

A opção de base arbitrária foi adicionada na versão 4.0.3 do MySQL. LOG(B,X) é equivalente a LOG(X)/LOG(B).

LOG2(X)

Returna o logarítmo na base 2 de X:

mysql> SELECT LOG2(65536);
        -> 16.000000
mysql> SELECT LOG2(-100);
        -> NULL

LOG2() é útil para descobrir quantos bits um número necessitaria para ser armazenado. Esta função foi adicionada na versão 4.0.3 do MySQL. Em versões anteriores, você pode usar LOG(X)/LOG(2).

LOG10(X)

Returna o logarítmo na base 10 de X:

mysql> SELECT LOG10(2);
        -> 0.301030
mysql> SELECT LOG10(100);
        -> 2.000000
mysql> SELECT LOG10(-100);
        -> NULL

POW(X,Y), POWER(X,Y)

Retorna o valor de X elevado a potência de Y:

mysql> SELECT POW(2,2);
        -> 4.000000
mysql> SELECT POW(2,-2);
        -> 0.250000

SQRT(X)

Retorna o a raiz quadrada não negativa de X:

mysql> SELECT SQRT(4);
        -> 2.000000
mysql> SELECT SQRT(20);
        -> 4.472136

PI()

Retorna o valor de PI. A quantidade de números decimais padrão é 5, mas o MySQL usa internamente a precisão dupla completa para PI.

mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116

COS(X)

Retorna o cosseno de X, onde X é dado em radianos:

mysql> SELECT COS(PI());
        -> -1.000000

SIN(X)

Retorna o seno de X, onde X é dado em radianos:

mysql> SELECT SIN(PI());
        -> 0.000000

TAN(X)

Retorna a tangente de X, onde X é dado em radianos:

mysql> SELECT TAN(PI()+1);
        -> 1.557408

ACOS(X)

Retorna o arco cosseno X, isto é, o valor cujo cosseno é X. Retorna NULL se X não está na faixa de -1 a 1:

mysql> SELECT ACOS(1);
        -> 0.000000
mysql> SELECT ACOS(1.0001);
        -> NULL
mysql> SELECT ACOS(0);
        -> 1.570796

ASIN(X)

Retorna o arco seno X, isto é, o valor cujo seno é X. Retorna NULL se X não está na faixa de -1 a 1:

mysql> SELECT ASIN(0.2);
        -> 0.201358
mysql> SELECT ASIN('foo');
        -> 0.000000

ATAN(X)

Retorna o arco tangente X, isto é, o valor cuja tangente é X. X:

mysql> SELECT ATAN(2);
        -> 1.107149
mysql> SELECT ATAN(-2);
        -> -1.107149

ATAN(Y,X), ATAN2(Y,X)

Retorna o arco tangente de duas variaveis X e Y. É similar ao caclculo do arco tengente de Y / X, exceto que os sinais de ambos argumentos são usados para determinas o quadrante do resultado:

mysql> SELECT ATAN(-2,2);
        -> -0.785398
mysql> SELECT ATAN2(PI(),0);
        -> 1.570796

COT(X)

Returns a cotangente de X:

mysql> SELECT COT(12);
        -> -1.57267341
mysql> SELECT COT(0);
        -> NULL

CRC32(expr)

Calcula um valor de verificação de redundância cíclica e retorna um valor unsigned de 32 bits. O resultado é NULL se o argumento é NULL. O argumento esperado é uma string e será tratado como tal se não for.

mysql> SELECT CRC32('MySQL');
        -> 3259397556

CRC32() está disponível a partir do MySQL 4.1.0.

RAND(), RAND(N)

Retorna um valor de ponto flutuante aleatório na faixa de 0 a 1.0. Se um argumento inteiro N é especificado, ele é usado como uma semente (produzindo uma sequência repetitiva):

mysql> SELECT RAND();
        -> 0.9233482386203
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND();
        -> 0.63553050033332
mysql> SELECT RAND();
        -> 0.70100469486881

Você não pode usar uma coluna com valores RAND() em uma cláusula ORDER BY, pois ORDER BY avaliaria a coluna múltiplas vezes. Na versão 3.23 você pode fazer: SELECT * FROM nome_tabela ORDER BY RAND()

Isto é útil para obter um amostra aleatória de um conjunto SELECT * FROM tabela1,tabela2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000.

Note que um RAND() em uma cláusula WHERE será reavliado toda vez que WHERE é executado.

RAND() não é um gerador de números aletatórios perfeito, mas é um modo rápido de se gerar números aleatórios ad hoc que serão portáveis entre plataformas para a mesma versão do MySQL.

LEAST(X,Y,...)

Com dois ou mais argumentos, retorna o menor (valor-mínimo) argumento. Os argumentos são comparados usando as seguintes regras:

mysql> SELECT LEAST(2,0);
        -> 0
mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
        -> 3.0
mysql> SELECT LEAST("B","A","C");
        -> "A"

Em versões do MySQL anteriores a versão 3.22.5, você pode usar MIN() no lugar de LEAST.

GREATEST(X,Y,...)

Retorna o maior (valor máximo) argumento. Os argumentos são comparados usando as mesmas regras do LEAST:

mysql> SELECT GREATEST(2,0);
        -> 2
mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
        -> 767.0
mysql> SELECT GREATEST("B","A","C");
        -> "C"

Em versões do MySQL anteriores a versão 3.22.5, você pode usar MAX() no lugar de GRATEST.

DEGREES(X)

Retorna o argumento X, convertido de radianos para graus:

mysql> SELECT DEGREES(PI());
        -> 180.000000

RADIANS(X)

Retorna o argumento X, convertido de graus para radianos:

mysql> SELECT RADIANS(90);
        -> 1.570796

TRUNCATE(X,D)

Retiorna o número X, truncado para D casas decimais. Se D é 0, o resultado não terá ponto deciaml ou prate fracionária:

mysql> SELECT TRUNCATE(1.223,1);
        -> 1.2
mysql> SELECT TRUNCATE(1.999,1);
        -> 1.9
mysql> SELECT TRUNCATE(1.999,0);
        -> 1
mysql> SELECT TRUNCATE(-1.999,1);
        -> -1.9

A partir do MySQL 3.23.51 todos o números são arredondados para zero.

Se D é negativo, então D numeros da parte inteira são zerados:

mysql> SELECT TRUNCATE(122,-2);
       -> 100

Note que como os números decimais não são normalmente armazenados como números exatos, mas como valores de dupla precisão, você pode obter o seguinte resultado:

mysql> SELECT TRUNCATE(10.28*100,0);
       -> 1027

O resultado acima acontece porque 10.28 é, na verdade, armazenado como 10.2799999999999999.

|

Operador binário OR

mysql> SELECT 29 | 15;
        -> 31

O resultado é um inteiro sem sinal de 64 bits.

&

Operado binário AND

mysql> SELECT 29 & 15;
        -> 13

O resultado é um inteiro sem sinal de 64 bits.

^

Operado binário XOR

mysql> SELECT 1 ^ 1;
        -> 0
mysql> SELECT 1 ^ 0;
        -> 1
mysql> SELECT 11 ^ 3;
        -> 8

O resultado é um inteiro sem sinal de 64 bits.

XOR foi adicionado na versão 4.0.2.

<<

Desloca um número BIGINT (muito grande) a esquerda:

mysql> SELECT 1 << 2;
        -> 4

O resultado é um inteiro sem sinal de 64 bits.

>>

Desloca um número BIGINT (muito grande) a direita:

mysql> SELECT 4 >> 2;
        -> 1

O resultado é um inteiro sem sinal de 64 bits.

~

Inverte todos os bits:

mysql> SELECT 5 & ~1;
        -> 4

O resultado é um inteiro sem sinal de 64 bits.

BIT_COUNT(N)

Retorna o número de bits que são passados no argumento N:

mysql> SELECT BIT_COUNT(29);
        -> 4

DATABASE()

Retorna o nome do banco de dados atual:

mysql> SELECT DATABASE();
        -> 'test'

Se nenhum banco de dados estiver selecionado, DATABASE() retorna NULL a partir do MySQL 4.1.1, e uma string vazia em versões anteriores.

USER(), SYSTEM_USER(), SESSION_USER()

Retorna o nome do usuário MySQL e nome de máquina atual:

mysql> SELECT USER();
        -> 'davida@localhost'

O valor indica o nome do usuário que você especificou ao conectar ao servidor e a máquina cliente da qual você se conectou. (Antes do MySQL versão 3.22.11, o valor da função não inclui o nome da máquina cliente.)

Você pode extrair apenas a parte do nome do usuário, desconsiderando se o valor inclui a parte do nome de máquina, desta forma:

mysql> SELECT SUBSTRING_INDEX(USER(),"@",1);
        -> 'davida'

CURRENT_USER()

Retorna o nome do usuário e o nome de máquina com os quais a sessão atual foi autenticada. Este valor corresponde a conta que é usada para acessar seu privilégio de acessos. Ela pode ser diferente do valor de USER().

mysql> SELECT USER();
        -> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
        -> ERROR 1044: Access denied for user: '@localhost' to database 'mysql'
mysql> SELECT CURRENT_USER();
        -> '@localhost'

O exemplo ilustra que embora o cliente tenha especificado um nome de usuário davida (como indicado pelo valor da função USER()), o servidor autenticou o cliente usando uma conta de usuário anônimo (como visto pela parte vazia no nome de usuário do valor CURRENT_USER()). Um modos de isto ocorrer é que não haja uma conta listada na tabela de permissões para davida.

PASSWORD(str), OLD_PASSWORD(str)

Calcula a senha a partir de senha str em texto puro. Está é a função que é utilizada para criptografar a senha do MySQL para armazenamento na coluna Password da tabela de permissões user

mysql> SELECT PASSWORD('badpwd');
        -> '7f84554057dd964b'

A criptografia de PASSWORD() não e reversível.

PASSWORD() não realiza a criptografia da senha da mesa maneira que as senhas Unix são criptografadas. Veja ENCRYPT().

Note: A função PASSWORD() é usada pelo sistema de autentificação no servidor MySQL, você NÃO deve uitlizá-las em suas próprias aplicações. Para este propósito utilize MD5() ou SHA1(). Veja também RFC-2195 para maiores informações sobre o tratamento de senha e autenticação segura em suas aplicações.

ENCRYPT(str[,salt])

Criptografa str utilizando a chamada de sistema crypt() do Unix. O argumento salt deve ser uma string com dois caracteres. (Na versão 3.22.16 do MySQL, salt deve ser maior que dois caracteres.)

mysql> SELECT ENCRYPT("hello");
        -> 'VxuFAJXVARROc'

ENCRYPT() ignora tudo depois dos primeiros 8 caracteres de str, pelo menos em alguns sistemas. Este comportamento é determinado pela implementação da chamada de sistema crypt().

Se crypt() não estiver disponível no seu sistema, ENCRYPT() sempre retorna NULL. Devido a isto recomendamos que você use MD5() ou SHA1() em vez dos existentes em sua plataforma.

ENCODE(str,senha_str)

Criptografa str usando senha_str como a senha. Para descriptografar o resultado, utilize DECODE().

O resultado é uma string binária do mesmo tamanho de str. Se você deseja salvá-la em uma coluna, use uma coluna do tipo BLOB.

DECODE(cript_str,senha_str)

Descriptografa o string criptografada cript_str usando senha_str como a senha. cript_str deve ser uma string retornada de ENCODE().

MD5(string)

Calcula um checksum MD5 de 128 bits para a string. O valor é retornado como um número hexadecimal de 32 digitos que pode, por exemplo, ser usado como uma chave hash:

mysql> SELECT MD5("testing");
        -> 'ae2b1fca515949e5d54fb22b8ed95575'

Este é o "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

SHA1(string), SHA(string)

Calcula um checksum SHA1 de 160 bit para a string, como descrito no RFC 3174 (Algoritmo Hash de Segurança). O valor é retornado como um número hexadecial de 40 digitos, or NULL no caso do argumento ser NULL . Uma das possibilidades para o uso desta função é a chave hash. Você também pode usá-lo como uma função segura de criptografia para armazenar senhas.

mysql> SELECT SHA1("abc");
        -> 'a9993e364706816aba3e25717850c26c9cd0d89d'

SHA1() foi adicionado na versão 4.0.2, e pode ser considerada um equivalente ao MD5() com criptografia mais segura. SHA() é um sinônimo para SHA1().

AES_ENCRYPT(string,string_chave), AES_DECRYPT(string,string_chave)

Estas funções permitem criptografia/descriptografia de dados usando o algoritmo oficial AES (Padrão Avançado de Criptografia), antes conhecido como Rijndael. Criptgrafia com uma chave de 128 bits podem ser usadas, mas você pode extendê-la para 256 bits através da fonte. Nós escolhemos 128 bits porque é muito mais rápido e é bastante seguro.

Os argumentos de entrada podem ser de qualquer tamanho. Se ambos argumentos são NULL, o resultado desta função tam bém será NULL.

Como o AES é um algorítimo de nível de bloco, padding é usado para codificar strings de tamanho ímpares e então a string resultante pode ser calculada como 16*(trunc(tamanho_string/16)+1).

Se AES_DECRYPT() detectar dados inválidos ou padding incorreto, ela retorna NULL. No entanto, é possível para o AES_DECRYPT() retornar um valor não-NULL (possivelmente lixo) se os dados de entrada ou a chave eram inválidos

Você pode usar as funções AES para armazenar dados de forma criptografada modificando as suas consultas:

INSERT INTO t VALUES (1,AES_ENCRYPT('text','password'));

Você pode obter mais segurança não transferindo a chave em suas conexões a cada consulta, o que pode ser conseguido armazenando-o em varáveis do lado do servidor na hora das conexão.

SELECT @password:='my password';
INSERT INTO t VALUES (1,AES_ENCRYPT('text',@password));

AES_ENCRYPT() e AES_DECRYPT() foram adicionados na versão 4.0.2, e podem ser considerados a função de criptografia mais segura atualmente disponível no MySQL.

DES_ENCRYPT(string_para_ciptografar [, (numero_chave | chave_string) ] )

Criptografa a string com a chave dada utilizando o algortimo Triplo-DES.

Note que esta função só funciona se o MySQL tiver sido configurado com suporte a SSL. See Secção 4.4.10, ?Usando Conexões Seguras?.

A chave de criptografia utilizada é escolhida da seguinte forma: