Este artículo contiene ejemplos de consultas SQL básicas que los principiantes pueden usar para recuperar datos de sus bases de datos.
Básico SELECT Consulta
Aquí hay un ejemplo de posiblemente, la consulta más utilizada en SQL:
SELECT *
FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Esta consulta selecciona todas las filas y todas las columnas de Pets mesa. Esto se debe a que el asterisco (* ) comodín selecciona todas las columnas.
Seleccionar nombres de columna
Por motivos de rendimiento, normalmente es mejor evitar seleccionar todas las columnas a menos que realmente las necesite. Por lo general, es mejor seleccionar solo las columnas que necesita.
He aquí un ejemplo.
SELECT PetId, PetName
FROM Pets;Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtrar los resultados
Puedes agregar un WHERE cláusula para filtrar los resultados solo a las filas que necesita.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Este es otro ejemplo de cómo filtrar los resultados. Esta vez usamos el operador mayor que (> ) para filtrarlo por fecha.
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 | +-----------+------------+
Puede cambiar el operador mayor que a otros operadores, como el operador mayor que o igual a (>= ), operador menor que (< ), o operador menor o igual que (<= ).
También puedes usar el BETWEEN operador para filtrar los resultados a un rango específico (por ejemplo, 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 | +-----------+------------+
Ordenar los resultados
Puede agregar un ORDER BY cláusula para ordenar las filas que devuelve la consulta.
Orden Ascendente
Usa el ASC palabra clave para ordenar los resultados en orden ascendente. Este es el valor predeterminado, por lo que también puede omitir esta palabra clave si desea obtener los resultados en orden ascendente.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;O:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Orden descendente
Usa el DESC palabra clave para ordenar los resultados en orden descendente.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Ordenar por varias columnas
Puede ordenar por varias columnas enumerando cada columna, separadas por una coma.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected) +---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 6 | Fluffy | | 1 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected)
Podemos ver que los dos Fluffys están en un orden diferente en cada resultado (podemos saberlo mirando su PetId valores). Esto se debe a que PetName la columna se ordenó primero, luego el PetId ordenó los duplicados de la primera clasificación.
Ordenar por columnas ocultas
Puede ordenar por columnas que no están incluidas en SELECT lista.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
En este caso, podemos inferir de estos resultados que Tweet es la mascota más joven y Meow es el más antiguo. Esto se debe a que ordenamos por fecha de nacimiento (DOB ) columna en orden descendente.
Solo para estar seguro, aquí está de nuevo con el DOB columna incluida en el SELECT lista.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 5 | Tweet | 2020-11-28 | | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 4 | Wag | 2020-03-15 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 7 | Bark | NULL | | 8 | Meow | NULL | +---------+-----------+------------+
En realidad, ahora podemos ver que Meow y Bark tienen NULL valores en el DOB columna. Por lo tanto, no sabemos si en realidad son mayores o menores.
Pero esto demuestra que NULL los valores se tratan como los valores más bajos posibles. Tenga en cuenta NULL valores al ejecutar consultas.
Coincidencia de patrones
Puedes usar el LIKE operador para utilizar la coincidencia de patrones.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Resultado:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
En este ejemplo, buscamos todas las mascotas cuyos nombres comiencen con la letra F . El signo de porcentaje (% ) es un carácter comodín que 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.
Aquí hay otro ejemplo.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Resultado:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Seleccionar de una lista
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 | +---------+-----------+------------+
Subconsultas
Puedes usar el IN operador al realizar una subconsulta (una consulta anidada dentro de otra consulta).
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 | +-------------+-----------+
Esto devolvió columnas de una tabla (PetTypes ), pero solo cuando había al menos una fila correspondiente en otra tabla (Pets ) que coincidía con el PetTypeId columna.
Para demostrar esto aún más, el contenido relevante de estas dos tablas se muestra a continuación.
Los PetTypes tabla:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Las Pets tabla:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Podemos ver que los PetTypes la tabla contiene un tipo de mascota de Rabbit , pero ninguna de las mascotas en Pets A la tabla se le ha asignado ese tipo (es decir, no hay valor de 4 en el Pets.PetTypeId columna).
Consulte 12 operadores de SQL de uso común y esta lista de operadores de SQL para obtener más información sobre los operadores en SQL.
Únete
Es discutible si las uniones SQL se consideran "consultas SQL básicas", pero de todos modos incluiré una unión aquí.
Entonces, para completar este artículo, aquí hay un ejemplo de una unión interna.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
En este caso, usamos un INNER JOIN para devolver todos los nombres de mascotas con sus respectivos tipos de mascotas. Usamos el ON cláusula para especificar el predicado que se evaluará para cada par de filas unidas. En este caso, el p.PetTypeId columna es una clave foránea del pt.PetTypeId columna, que es la clave principal para PetTypes mesa.
En este ejemplo, también usé alias en las tablas, lo que ayudó a mantener el código agradable y conciso.
Consulte mi Tutorial de uniones SQL para obtener más ejemplos de uniones.
