En SQL, un operador es un carácter especial o palabra clave que especifica una acción que se realiza en una o más expresiones.
Los operadores de SQL son una parte integral de SQL y nos permiten escribir consultas que arrojan resultados relevantes.
En este artículo, presento 12 de los operadores SQL más utilizados al escribir consultas SQL.
Los Iguales (= ) Operador
El operador Igual (= ) es probablemente el operador más utilizado en SQL. Compara la igualdad de dos expresiones. Incluso si no está más que vagamente familiarizado con SQL, probablemente conocerá este operador.
Imagine que tenemos una base de datos para un hotel de mascotas y queremos obtener información sobre todas las mascotas llamadas Fluffy.
En ese caso, podríamos hacer esto:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Nuestra consulta usa el operador Igual a (= ) para comparar la igualdad del valor de PetName columna y la cadena Fluffy .
En nuestro caso, podemos ver que el hotel de mascotas actualmente tiene dos mascotas llamadas Fluffy.
El mayor que (> ) Operador
El operador Mayor que (> ) compara dos expresiones y devuelve TRUE si el operando izquierdo tiene un valor mayor que el operando derecho; de lo contrario, el resultado es FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
En este caso, está comparando el valor de DOB columna y la fecha 2020-01-01 para ver si el DOB columna es mayor.
El menor que (< ) Operador
El operador Menor que (< ) hace lo contrario. Compara dos expresiones y devuelve TRUE si el operando izquierdo tiene un valor menor que el operando derecho; de lo contrario, el resultado es FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
El mayor o igual que (>= ) Operador
El operador Mayor que o Igual que (>= ) compara dos expresiones y devuelve TRUE si el operando izquierdo tiene un valor mayor o igual que el operando derecho; de lo contrario, devuelve FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Tenga en cuenta que devolvió 2020-09-17 y todas las fechas posteriores a esa. Si hubiéramos usado el operador Mayor que (> ), solo se habrían devuelto las dos primeras filas.
El menor que o igual a (<= ) Operador
El operador Menor que o Igual a (<= ) compara dos expresiones y devuelve TRUE si el operando izquierdo tiene un valor menor o igual que el operando derecho; de lo contrario, el resultado es FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Tenga en cuenta que devolvió 2020-09-17 y todas las fechas menos que eso. Si hubiésemos utilizado el operador Menor que (< ), solo se habrían devuelto las tres primeras filas.
El AND Operador
El AND El operador combina dos expresiones booleanas y devuelve TRUE cuando ambas expresiones son TRUE .
He aquí un ejemplo.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Resultado:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
En este caso, solo obtenemos detalles de las mascotas cuyo nombre es Fluffy y su fecha de nacimiento está entre las dos fechas.
El OR Operador
El OR El operador combina dos expresiones booleanas y devuelve TRUE cuando cualquiera de las condiciones es TRUE .
He aquí un ejemplo.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Esto es básicamente lo opuesto a AND operador. Si hubiéramos usado AND , no se habrían devuelto filas, porque no podemos tener dos valores diferentes en una columna al mismo tiempo.
El BETWEEN Operador
El BETWEEN El operador nos permite especificar un rango para probar. Por ejemplo, podemos usarlo para devolver mascotas que nacieron entre dos fechas.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
El NOT Operador
El NOT El operador niega una entrada booleana (invierte el valor de cualquier expresión booleana). Por lo tanto devuelve TRUE cuando la expresión es FALSE .
Esto es lo que sucede cuando agregamos el NOT operador a nuestro ejemplo anterior.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Esta vez tenemos todas las demás mascotas:las mascotas que no eran nacidos entre esas fechas.
En MariaDB, NOT se limita a negar el IN , BETWEEN y EXISTS cláusulas. La mayoría de los otros DBMS permiten NOT para negar cualquier expresión.
El IN Operador
El IN El operador determina si un valor especificado coincide con cualquier valor en una subconsulta o una lista.
He aquí un ejemplo.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Podríamos lograr el mismo resultado usando dos OR operadores:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Sin embargo, el IN operator es una forma más concisa de hacerlo. El IN El operador es especialmente beneficioso cuando tiene una larga lista de valores con los que comparar.
El IN operador casi siempre se ejecuta más rápido que múltiples OR operadores, especialmente en conjuntos de datos más grandes.
Otro beneficio del IN operador, es que puede contener otro SELECT lista. Esto se conoce como una subconsulta . Una subconsulta es una consulta anidada dentro de otra consulta (o incluso otra subconsulta).
He aquí un ejemplo.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Este ejemplo nos muestra cuántos tipos de mascotas hay en nuestro hotel para mascotas.
Podríamos usar el NOT operador para cambiar esto y ver cuántos tipos de mascotas no en nuestro hotel para mascotas.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Así que nuestra base de datos contiene un tipo de mascota de Rabbit , pero actualmente no tenemos conejos como mascotas.
El + y || Operadores de concatenación de cadenas
El + y || Los operadores de concatenación de cadenas le permiten concatenar cadenas. La concatenación de cadenas es la operación de unir cadenas de caracteres de extremo a extremo.
La razón por la que he enumerado dos operadores que hacen lo mismo es porque el + El operador es compatible con SQL Server y el || El operador es compatible con DB2, Oracle, PostgreSQL, SQLite.
Aquí hay un ejemplo que funciona en SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Resultado:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
En este caso, los propietarios tienen su nombre y apellido almacenados en diferentes columnas. En nuestro SELECT list, primero los recuperamos individualmente, pero también los recuperamos nuevamente, usando un operador de concatenación para unirlos.
Sin embargo, hay un par de problemas con nuestros resultados.
- No hay espacio entre el nombre y el apellido.
- No hay nombre de columna.
Afortunadamente, esto es fácil de solucionar.
Podemos usar la misma operación de concatenación para incluir espacios entre el nombre y el apellido.
Y podemos usar un alias de columna para el resultado concatenado para proporcionar un nombre de columna en el conjunto de resultados.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Resultado:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Si está utilizando DB2, Oracle, PostgreSQL, SQLite, cambie + para || y debería funcionar bien.
Si usa MySQL o MariaDB, deberá usar CONCAT() función para concatenar cadenas.
El LIKE Operador
El LIKE operador le permite hacer coincidencia de patrones. Determina si una cadena de caracteres específica coincide con un patrón específico. Un patrón puede incluir caracteres regulares y caracteres comodín.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Resultado:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
En este ejemplo, utilicé LIKE operador junto con el % operador comodín para devolver los propietarios cuyas direcciones de correo electrónico terminan en .com .
¡Operador adicional! El % Operador comodín
El % El operador comodín coincide con cualquier cadena de cero o más caracteres. Se puede usar como prefijo o sufijo, y también se puede usar en medio de una cadena.
Tiende a usarse más comúnmente como sufijo y tiene un uso limitado en medio de patrones, aunque existen algunos casos de uso válidos para usarlo en medio de un patrón, como los siguientes:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Resultado:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
En este caso, no sabíamos la dirección de correo electrónico de bart, pero sabíamos que empezaba con [email protected] y terminó en .com . Por lo tanto, pudimos usar LIKE junto con el % operador comodín para completar el resto.
Tenga en cuenta que esta técnica puede devolver muchas filas irrelevantes, dependiendo de los datos y de cómo construya su declaración SQL.
También tenga en cuenta que las consultas que contienen LIKE La cláusula puede ejecutarse mucho más lentamente que otras consultas, y probablemente debería evitar usar LIKE cláusula a menos que realmente la necesite. Usando el % operador como prefijo puede ser particularmente lento.
Eso no quiere decir que no debas usarlo en absoluto. El LIKE operator es una parte integral de SQL, y encontrará muchos escenarios en los que será la única opción (o al menos, la mejor opción).
Más operadores SQL
Consulte mi lista completa de operadores de SQL para ver un montón de otros operadores que no están incluidos aquí.
