El SELECT es casi sin duda, la declaración más utilizada en SQL.
El SELECT declaración se utiliza para recuperar datos de la base de datos. Puede especificar qué filas desea que se devuelvan y qué columnas.
Ejemplo
Aquí hay un ejemplo para demostrar el SELECT declaración.
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 | +---------+-------------+-----------+-----------+------------+
En este ejemplo usamos el asterisco (* ) comodín para devolver todas las columnas. También usamos el FROM cláusula para especificar de qué tabla obtener datos.
Entonces esta consulta devuelve todas las filas y todas las columnas de Pets mesa.
Especifique las Columnas
Puede especificar las columnas que desea que se devuelvan.
Para hacer esto, reemplace el asterisco comodín con los nombres de las columnas, cada uno separado por una coma, en el orden en que desea que se devuelvan.
SELECT PetId, PetName, DOB
FROM Pets;Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 4 | Wag | 2020-03-15 | | 5 | Tweet | 2020-11-28 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | | 8 | Meow | NULL | +---------+-----------+------------+
En general, se considera una buena práctica hacerlo de esta manera y devolver solo las columnas que realmente necesita. El uso del comodín asterisco para devolver todas las columnas puede tener un impacto adverso en el rendimiento, especialmente en bases de datos más grandes.
Especifique las filas
Hay muchas formas de filtrar los resultados solo a las filas que le interesan. La forma más común es usar WHERE cláusula. Esta cláusula le permite especificar una condición que una fila debe cumplir para calificar.
Aquí hay un ejemplo para demostrarlo.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
En nuestro caso, hubo dos filas que cumplieron con nuestra condición de búsqueda.
Nuestra condición de búsqueda utiliza el operador igual (= ) para especificar que el valor de PetName la columna debe coincidir con el valor especificado (Fluffy ) exactamente.
Hay muchos otros operadores que puede utilizar en sus condiciones de búsqueda. Por ejemplo, podría usar el LIKE operador para devolver mascotas cuyo nombre comienza con F o Fluff o lo que sea.
Puede agregar más condiciones al WHERE cláusula mediante el uso de operadores como AND y OR operadores.
He aquí un ejemplo.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR DOB < '2020-01-01';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
En este ejemplo, devolvimos todas las filas donde el nombre de la mascota es Fluffy o donde la fecha de nacimiento de la mascota (especificada en el DOB columna) es anterior a una fecha determinada. Usamos el operador menor que (< ) para especificar eso.
Devolución de datos que no son de tabla
El SELECT La declaración también se puede usar para devolver datos que no están almacenados en una tabla. Por ejemplo, es perfectamente legal hacer esto:
SELECT 'Hey there!';Resultado:
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Note que cuando hacemos eso, la columna no tiene nombre. Podríamos usar un alias para dar un nombre al campo resultante.
Aquí hay algunos ejemplos más de cómo seleccionar datos que no son de tabla y proporcionar un alias para cada campo devuelto:
SELECT
2 + 3 AS "2 + 3",
'Fluffy' + ' ' + 'Smith' AS FullName,
SYSDATETIME() AS "Date/time";Resultado:
+---------+--------------+-----------------------------+ | 2 + 3 | FullName | Date/time | |---------+--------------+-----------------------------| | 5 | Fluffy Smith | 2020-12-04 23:58:55.8483734 | +---------+--------------+-----------------------------+
Aquí hay un resumen rápido:
- La primera columna simplemente agregó dos números.
- La segunda columna concatenó tres cadenas (incluido un carácter de espacio). También puede concatenar cadenas con números si es necesario.
- La tercera columna usó el
SYSDATETIME()función para devolver la fecha y la hora actuales. Esta función está disponible en SQL Server. Otros DBMS tienen sus propias funciones de fecha y hora. Consulte Funciones de fecha/hora de SQLite, Funciones de fecha/hora de SQL Server y Funciones de fecha/hora de PostgreSQL para obtener una lista de las funciones de fecha y hora disponibles en esos DBMS.
Subconsultas
Es posible tener múltiples SELECT declaraciones en una sola consulta. Podemos hacer esto usando una subconsulta.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
En este ejemplo, usamos el IN operador para especificar una subconsulta. Esa subconsulta seleccionó datos de otra tabla, y el IN el operador lo relacionó con la consulta externa.
Ordenar los resultados
Puedes usar el ORDER BY cláusula para ordenar los resultados.
Por ejemplo, podríamos ordenar los resultados anteriores por PetTypeId columna en orden descendente:
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets )
ORDER BY PetTypeId DESC;Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 3 | Dog | | 2 | Cat | | 1 | Bird | +-------------+-----------+
Ver SQL ORDER BY Cláusula para principiantes para obtener más ejemplos y una explicación detallada.
Más avanzado SELECT Declaraciones
El SELECT es una declaración muy simple, pero se puede usar para crear consultas muy complejas.
Aquí hay una consulta que es un poco más compleja que las anteriores.
SELECT
PetTypes.PetType,
COUNT(Pets.PetTypeId) AS Count
FROM Pets
LEFT JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;Resultado:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
En el mundo de las consultas SQL, esto sigue siendo bastante simple, sin embargo, contiene muchos de los elementos que a menudo se ven en consultas más complejas.
Por ejemplo, esta consulta utiliza una combinación para recuperar datos de varias tablas. También utiliza el GROUP BY cláusula para dividir las filas en grupos.
Ver SQL GROUP BY Cláusula para principiantes para ver más ejemplos de GROUP BY cláusula.
Consulte el Tutorial de uniones SQL para ver cómo recuperar datos de varias tablas y devolverlos como un conjunto de resultados.
El SELECT INTO Declaración
Algunos DBMS admiten SELECT INTO declaración. Esto es ligeramente diferente a los ejemplos anteriores, ya que afecta los datos en la base de datos.
El SELECT INTO La declaración crea una nueva tabla e inserta datos en ella desde otra tabla.
Básicamente, es así:
SELECT * INTO Table2
FROM Table1;
En este ejemplo, creamos una nueva tabla llamada Table2 e inserte todos los datos de Table1 en ello. Table2 tendrá la misma definición que Table1 .
Ver SQL SELECT INTO Declaración para ver más ejemplos.
Como mencioné, no todos los DBMS admiten esta declaración. Si su DBMS no es compatible con SELECT INTO declaración, intente usar CREATE TABLE ... AS SELECT declaración en su lugar.
Esas declaraciones crean una nueva tabla como parte de su operación. Para insertar datos en una tabla que ya existe, intente usar INSERT INTO ... SELECT declaración en su lugar.
