Los operadores de comparación son una parte importante de la mayoría de los lenguajes de programación.
Los operadores de comparación se utilizan para comparar dos expresiones. El resultado es true o false . También podría ser desconocido. Esto también podría estar representado por 1 , 0 o NULL , dependiendo del idioma. Por lo general, se conocen como "expresiones booleanas".
Cuando se usan con bases de datos, los operadores de comparación se pueden usar dentro de sus consultas SQL para filtrar datos según ciertos criterios.
Operadores de comparación comunes
La mayoría de los lenguajes de programación admiten los siguientes operadores de comparación de una forma u otra:
| OPERADOR | SIGNIFICADO |
|---|---|
= | Igual a |
> | Mayor que |
< | Menos de |
>= | Mayor o igual que |
<= | Menor o igual que |
<> | No es igual a |
SQL usa la misma sintaxis que se muestra en la tabla anterior.
Algunos lenguajes usan una sintaxis diferente para evitar confusiones con los operadores de asignación. Por ejemplo, Python y JavaScript usan == en lugar de = . ColdFusion, por otro lado, usa eq .
Diferentes tipos de datos
Algunos idiomas tienen un operador especial para especificar que ambos valores deben ser del mismo tipo de datos.
Por ejemplo, JavaScript también incluye el === operador que especifica que ambos valores son iguales y que deben ser del mismo tipo de datos. Pero si el tipo de datos es irrelevante, use == en cambio.
Ejemplos
Operador mayor que
Este es un ejemplo del uso del operador Mayor que en una 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 | +--------------------+--------------+
En este ejemplo, utilicé el operador Mayor que (> ) para seleccionar solo países con una población superior a 100000000.
Operador Igual
Aquí hay otro ejemplo, donde uso el operador igual (= ) para devolver datos que son exactamente iguales a un valor dado.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Resultado:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
En este caso devuelvo solo aquellas ciudades cuyo código de país sea igual a AFG .
Esto demuestra que los operadores de comparación no se limitan solo a tipos de datos numéricos.
Fechas
También puede usar operadores de comparación en fechas, por ejemplo:
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 puede ver, los únicos resultados devueltos son aquellos posteriores a (posteriores) a la fecha especificada.
Operador mayor o igual que
Puedo usar el operador Mayor que o Igual a para incluir la fecha especificada en los 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 | +------------+----------------+--------------+
En este caso, se devuelve una fila extra (la última fila).
Operador menor que
Esto es lo que sucede si cambio mi consulta para usar un operador Menor que.
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 | +------------+------------------------+--------------+
Obtengo todas las filas que son anteriores a la fecha especificada.
Comparación de valores NULL
NULL Los valores pueden complicar un poco las cosas cuando se usan operadores de comparación. En pocas palabras, puede obtener un resultado diferente, dependiendo de cómo esté configurado su entorno.
Por ejemplo, en SQL Server, si usa el operador Igual a (= ) o el operador No igual (<> ) para probar contra NULL , su resultado dependerá de su ANSI_NULLS configuración (es decir, si está ON o OFF ).
Para probar contra NULL valores, SQL Server también proporciona el IS NULL predicado, que funciona consistentemente, independientemente de su ANSI_NULLS entorno. Esto también incluye el IS NOT NULL variación para probar contra no NULL valores.
A continuación se muestra un ejemplo que demuestra lo que quiero decir.
ANSI_NULLS ON
Primero configuramos ANSI_NULLS a ON , luego ejecute algunas pruebas contra 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
Ahora configuramos ANSI_NULLS a OFF , luego ejecute las mismas pruebas.
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)
