MySQL :: Manual de Referência do MySQL 4.1 :: 6.3.1.2 Operadores de Comparação

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.1 Operadores e Funções de Tipos não Especificados :: 6.3.1.2 Operadores de Comparação

« 6.3.1.1 Parenteses

6.3.1.3 Operadores Logicos »

Section Navigation [Toggle]

6.3.1 Operadores e Funções de Tipos não Especificados
6.3.1.1 Parenteses
6.3.1.2 Operadores de Comparação
6.3.1.3 Operadores Logicos
6.3.1.4 Funções de Fluxo de Controle

6.3.1.2. Operadores de Comparação

Operações de comparação resultam em um valor 1 (VERDADEIRO), 0 (FALSO), ou NULL. Estas funções funcionam tanto para tipos numéricos quanto para tipos strings. Strings são convertidas automaticamente para números e números para strings quando necessário (como em Perl).

MySQL realiza comparações de acordo com as seguintes regras:

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).

Por padrão, comparações de string são feita de modo independente do caso, usando o conjunto de caracteres atual (ISO-8859-1 Latin1 por padrão, o qual também funciona de forma excelente para o Inglês).

Se você está comparando strings em caso insensitivo com qualquer dos operadores padrões (=, <>..., mas não o LIKE) espaços em branco no fim da string (espaços, tabs e quebra de linha) serão ignorados.

mysql> SELECT "a" ="A \n";
        -> 1

Os seguintes exemplos ilustram a conversão de strings para números para operações de comparação:

mysql> SELECT 1 > '6x';
         -> 0
mysql> SELECT 7 > '6x';
         -> 1
mysql> SELECT 0 > 'x6';
         -> 0
mysql> SELECT 0 = 'x6';
         -> 1

Note que quando você está comparando uma coluna string com um número, o MySQL não pode usar índices para encontrar o valor rapidamente:

SELECT * FROM table_name WHERE string_key=1

A razão para isto é que existem muitas strings diferentes que podem retornar o valor 1: "1", " 1", "1a" ...

=

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:
- Você pode encontrar o último registro inserido com:
```
SELECT * FROM nome_tabela WHERE auto_col IS NULL
```
  Isto pode ser desabilitado configurando SQL_AUTO_IS_NULL=0. See Secção 5.5.6, “Sintaxe de SET”.
- Para colunas DATE e DATETIME NOT NULL você pode encontrar a data especial 0000-00-00 utilizando:
```
SELECT * FROM nome_tabela WHERE coluna_data IS NULL
```
  Isto é necessário para que algums aplicações ODBC funcionem (já que ODBC não tem suporte a data 0000-00-00)
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
```

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