Os operadores de comparação são uma parte importante da maioria das linguagens de programação.
Os operadores de comparação são usados para comparar duas expressões. O resultado é
true ou false . Também pode ser desconhecido. Isso também pode ser representado por 1 , 0 , ou NULL , dependendo do idioma. Estes são normalmente conhecidos como “expressões booleanas”. Quando usados com bancos de dados, os operadores de comparação podem ser usados dentro de suas consultas SQL para filtrar dados de acordo com determinados critérios.
Operadores de comparação comuns
A maioria das linguagens de programação suporta os seguintes operadores de comparação de uma forma ou de outra:
| OPERADOR | SIGNIFICADO |
|---|---|
= | Igual a |
> | Maior que |
< | Menor que |
>= | Maior ou igual a |
<= | Menor ou igual a |
<> | Não é igual a |
SQL usa a mesma sintaxe listada na tabela acima.
Algumas linguagens usam uma sintaxe diferente para evitar confusão com operadores de atribuição. Por exemplo, Python e JavaScript usam
== em vez de = . ColdFusion, por outro lado, usa eq . Diferentes tipos de dados
Algumas linguagens possuem um operador especial para especificar que ambos os valores devem ser do mesmo tipo de dados.
Por exemplo, JavaScript também inclui o
=== operador que especifica que ambos os valores são iguais e que eles devem ser do mesmo tipo de dados. Mas se o tipo de dados for irrelevante, use == em vez de. Exemplos
Maior que o Operador
Aqui está um exemplo de uso do operador Greater Than em uma consulta T-SQL.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Resultado:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
Neste exemplo eu usei o operador Greater Than (
> ) para selecionar apenas países com população superior a 1.000.000.000. Igual a Operador
Aqui está outro exemplo, onde eu uso o operador igual
(= ) para retornar dados exatamente iguais a um determinado valor. SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Resultado:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
Neste caso, retorno apenas as cidades cujo código do país é igual a
AFG . Isso demonstra que os operadores de comparação não se limitam apenas a tipos de dados numéricos.
Datas
Você também pode usar operadores de comparação em datas, por exemplo:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Resultado:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | +------------+----------------+--------------+
Como você pode ver, os únicos resultados retornados são aqueles maiores que (após) a data especificada.
Maior ou igual ao operador
Posso usar o operador Maior que ou Igual a para incluir a data especificada nos resultados.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Resultado:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+----------------+--------------+
Nesse caso, uma linha extra é retornada (a última linha).
Menos que Operador
Aqui está o que acontece se eu alterar minha consulta para usar um operador Less Than.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Resultado:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | +------------+------------------------+--------------+
Recebo todas as linhas que são menores que a data especificada.
Comparando valores NULL
NULL valores podem complicar um pouco as coisas ao usar operadores de comparação. Em poucas palavras, você pode obter um resultado diferente, dependendo de como seu ambiente está configurado. Por exemplo, no SQL Server, se você usar o operador Equals (
= ) ou o operador Diferente (<> ) para testar com NULL , seu resultado dependerá de seu ANSI_NULLS configuração (ou seja, se está ON ou OFF ). Para testar com
NULL valores, o SQL Server também fornece o IS NULL predicado, que funciona de forma consistente, independentemente do seu ANSI_NULLS contexto. Isso também inclui o IS NOT NULL variação para teste contra não NULL valores. Abaixo está um exemplo que demonstra o que quero dizer.
ANSI_NULLS ON
Primeiro definimos
ANSI_NULLS para ON , em seguida, execute alguns testes em NULL . SET ANSI_NULLS ON;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Resultado:
(0 rows affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) (0 rows affected)
ANSI_NULLS OFF
Agora definimos
ANSI_NULLS para OFF , em seguida, execute os mesmos testes. SET ANSI_NULLS OFF;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Resultado:
+--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected)
