Buscar..


Introducción

La instrucción SELECT está en el corazón de la mayoría de las consultas SQL. Define qué conjunto de resultados debe devolver la consulta, y casi siempre se usa junto con la cláusula FROM, que define qué parte (s) de la base de datos debe consultarse.

Sintaxis

  • SELECCIONAR [DISTINTO] [columna1] [, [columna2] ...]
    DE [tabla]
    [DONDE condición]
    [GRUPO POR [columna1] [, [columna2] ...]

    [HAVING [column1] [, [column2] ...]

    [ORDENAR POR ASC | DESC]

Observaciones

SELECT determina los datos de las columnas que deben devolverse y en qué orden DE DESDE una tabla determinada (dado que coinciden con los otros requisitos en su consulta específicamente: dónde y con filtros y uniones).

SELECT Name, SerialNumber
FROM ArmyInfo

solo devolverá los resultados de las columnas Name y Serial Number , pero no de la columna denominada Rank , por ejemplo

SELECT *
FROM ArmyInfo

Indica que todas las columnas serán devueltas. Sin embargo, tenga en cuenta que es una mala práctica SELECT * ya que literalmente está devolviendo todas las columnas de una tabla.

Utilizando el carácter comodín para seleccionar todas las columnas en una consulta.

Considere una base de datos con las siguientes dos tablas.

Tabla de empleados:

Carné de identidad FName LName DeptId
1 James Herrero 3
2 Juan Johnson 4

Mesa de departamentos:

Carné de identidad Nombre
1 Ventas
2 Márketing
3 Financiar
4 ESO

Declaración de selección simple

* es el carácter comodín utilizado para seleccionar todas las columnas disponibles en una tabla.

Cuando se utiliza como sustituto de los nombres de columna explícitos, devuelve todas las columnas en todas las tablas en las que una consulta selecciona FROM . Este efecto se aplica a todas las tablas a las que accede la consulta a través de sus cláusulas JOIN .

Considere la siguiente consulta:

SELECT * FROM Employees

Devolverá todos los campos de todas las filas de la tabla Employees :

Carné de identidad FName LName DeptId
1 James Herrero 3
2 Juan Johnson 4

Notación de puntos

Para seleccionar todos los valores de una tabla específica, el carácter comodín se puede aplicar a la tabla con notación de puntos .

Considere la siguiente consulta:

SELECT 
    Employees.*, 
    Departments.Name
FROM 
    Employees
JOIN 
    Departments 
    ON Departments.Id = Employees.DeptId

Esto devolverá un conjunto de datos con todos los campos en la tabla Employee , seguido solo por el campo Name en la tabla Departments :

Carné de identidad FName LName DeptId Nombre
1 James Herrero 3 Financiar
2 Juan Johnson 4 ESO

Advertencias contra el uso

En general, se recomienda que se evite el uso de * en el código de producción siempre que sea posible, ya que puede causar una serie de problemas potenciales, entre ellos:

  1. Exceso de E / S, carga de red, uso de memoria, etc., debido a que el motor de la base de datos lee datos que no son necesarios y los transmite al código frontal. Esto es particularmente preocupante cuando puede haber campos grandes como los que se usan para almacenar notas largas o archivos adjuntos.
  2. Un exceso adicional de carga de IO si la base de datos necesita poner en cola los resultados internos en el disco como parte del procesamiento de una consulta más compleja que SELECT <columns> FROM <table> .
  3. Procesamiento adicional (y / o incluso más IO) si algunas de las columnas innecesarias son:
    • Columnas computadas en bases de datos que las soportan.
    • en el caso de seleccionar de una vista, las columnas de una tabla / vista que el optimizador de consultas podría optimizar de otra manera
  4. El potencial de errores inesperados si las columnas se agregan a las tablas y vistas más adelante resulta en nombres de columnas ambiguos. Por ejemplo, SELECT * FROM orders JOIN people ON people.id = orders.personid ORDER BY displayname : si se agrega una columna llamada nombre de displayname a la tabla de pedidos para permitir a los usuarios dar nombres significativos a sus pedidos para futuras referencias, entonces aparecerá el nombre de la columna dos veces en la salida, por lo que la cláusula ORDER BY será ambigua, lo que puede causar errores ("nombre de columna ambiguo" en las últimas versiones de MS SQL Server), y si no, en este ejemplo, el código de la aplicación puede comenzar a mostrar el nombre del orden donde se encuentra el nombre de la persona previsto porque la nueva columna es el primero de ese nombre devuelto, y así sucesivamente.

¿Cuándo se puede usar * , teniendo en cuenta la advertencia anterior?

Aunque es mejor evitarlo en el código de producción, usar * está bien como una abreviatura cuando se realizan consultas manuales en la base de datos para investigación o trabajo de prototipo.

A veces, las decisiones de diseño en su aplicación lo hacen inevitable (en tales circunstancias, prefiera tablealias.* lugar de * solo cuando sea posible).

Cuando se utiliza EXISTS , como SELECT A.col1, A.Col2 FROM A WHERE EXISTS (SELECT * FROM B where A.ID = B.A_ID) , no SELECT A.col1, A.Col2 FROM A WHERE EXISTS (SELECT * FROM B where A.ID = B.A_ID) ningún dato de B. Por lo tanto, una combinación no es necesaria, y el motor sabe que no se deben devolver los valores de B, por lo que no hay un impacto de rendimiento para usar * . De manera similar, COUNT(*) está bien, ya que tampoco devuelve ninguna de las columnas, por lo que solo necesita leer y procesar aquellas que se utilizan para fines de filtrado.

Seleccionando con Condicion

La sintaxis básica de SELECT con la cláusula WHERE es:

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

La [condición] puede ser cualquier expresión SQL, especificada mediante operadores de comparación u lógicos como>, <, =, <>,> =, <=, LIKE, NOT, IN, BETWEEN, etc.

La siguiente declaración devuelve todas las columnas de la tabla 'Coches' donde la columna de estado es 'LISTO':

SELECT * FROM Cars WHERE status = 'READY'

Vea DÓNDE y HABER para más ejemplos.

Seleccionar columnas individuales

SELECT 
    PhoneNumber, 
    Email, 
    PreferredContact 
FROM Customers

Esta declaración devolverá las columnas PhoneNumber , Email y PreferredContact de todas las filas de la tabla Customers . Además, las columnas se devolverán en la secuencia en la que aparecen en la cláusula SELECT .

El resultado será:

Número de teléfono Email Contacto preferido
3347927472 [email protected] TELÉFONO
2137921892 [email protected] CORREO ELECTRÓNICO
NULO [email protected] CORREO ELECTRÓNICO

Si se unen varias tablas, puede seleccionar columnas de tablas específicas especificando el nombre de la tabla antes del nombre de la columna: [table_name].[column_name]

SELECT 
    Customers.PhoneNumber, 
    Customers.Email, 
    Customers.PreferredContact,
    Orders.Id AS OrderId
FROM 
    Customers
LEFT JOIN 
    Orders ON Orders.CustomerId = Customers.Id

* AS OrderId significa que el campo Id de la tabla de Orders se devolverá como una columna denominada OrderId . Consulte la selección con alias de columna para obtener más información.

Para evitar usar nombres largos de tablas, puede usar alias de tablas. Esto mitiga el dolor de escribir nombres de tablas largas para cada campo que seleccione en las combinaciones. Si está realizando una unión automática (una unión entre dos instancias de la misma tabla), debe usar alias de tabla para distinguir sus tablas. Podemos escribir un alias de tabla como Customers c o Customers AS c . Aquí c funciona como un alias para los Customers y podemos seleccionar, digamos, Email como este: c.Email . Email .

SELECT 
    c.PhoneNumber, 
    c.Email, 
    c.PreferredContact,
    o.Id AS OrderId
FROM 
    Customers c
LEFT JOIN 
    Orders o ON o.CustomerId = c.Id

SELECCIONAR utilizando alias de columna

Los alias de columna se utilizan principalmente para acortar el código y hacer que los nombres de columna sean más legibles.

El código se acorta, ya que los nombres de tablas largas y la identificación innecesaria de columnas (por ejemplo, puede haber 2 ID en la tabla, pero solo se usa una en la declaración) se pueden evitar. Junto con los alias de tablas, esto le permite usar nombres descriptivos más largos en la estructura de su base de datos mientras mantiene las consultas sobre esa estructura concisa.

Además, a veces se requieren , por ejemplo, en vistas, para nombrar salidas computadas.

Todas las versiones de SQL

Los alias se pueden crear en todas las versiones de SQL usando comillas dobles ( " ).

SELECT 
    FName AS "First Name", 
    MName AS "Middle Name",
    LName AS "Last Name"
FROM Employees  

Diferentes versiones de SQL

Puede usar comillas simples ( ' ), comillas dobles ( " ) y corchetes ( [] ) para crear un alias en Microsoft SQL Server.

SELECT 
    FName AS "First Name", 
    MName AS 'Middle Name',
    LName AS [Last Name]
FROM Employees  

Ambos resultarán en:

Nombre de pila Segundo nombre Apellido
James Juan Herrero
Juan James Johnson
Miguel Marcus Williams

Esta declaración volverá FName y LName columnas con un nombre dado (un alias). Esto se logra utilizando el operador AS seguido del alias, o simplemente escribiendo el alias directamente después del nombre de la columna. Esto significa que la siguiente consulta tiene el mismo resultado que el anterior.

SELECT 
    FName "First Name", 
    MName "Middle Name",
    LName "Last Name"
FROM Employees 
Nombre de pila Segundo nombre Apellido
James Juan Herrero
Juan James Johnson
Miguel Marcus Williams

Sin embargo, la versión explícita (es decir, usar el operador AS ) es más legible.

Si el alias tiene una sola palabra que no es una palabra reservada, podemos escribirla sin comillas simples, comillas dobles o corchetes:

SELECT 
    FName AS FirstName, 
    LName AS LastName
FROM Employees  
Nombre de pila Apellido
James Herrero
Juan Johnson
Miguel Williams

Una variación adicional disponible en MS SQL Server entre otras es <alias> = <column-or-calculation> , por ejemplo:

SELECT FullName = FirstName + ' ' + LastName, 
       Addr1    = FullStreetAddress,
       Addr2    = TownName
FROM CustomerDetails  

que es equivalente a:

SELECT FirstName + ' ' + LastName As FullName
       FullStreetAddress          As Addr1,
       TownName                   As Addr2
FROM CustomerDetails  

Ambos resultarán en:

Nombre completo Addr1 Addr2
James Smith 123 AnyStreet Ciudadville
John Johnson 668 MyRoad Cualquier pueblo
Michael Williams 999 High End Dr Williamsburgh

Algunos encuentran que usar = lugar de As más fácil de leer, aunque muchos recomiendan este formato, principalmente porque no es estándar, por lo que no todas las bases de datos lo admiten ampliamente. Puede causar confusión con otros usos del carácter = .

Todas las versiones de SQL

Además, si necesita usar palabras reservadas, puede usar corchetes o comillas para escapar:

SELECT
    FName as "SELECT",
    MName as "FROM",
    LName as "WHERE"
FROM Employees

Diferentes versiones de SQL

Del mismo modo, puede escapar de las palabras clave en MSSQL con todos los enfoques diferentes:

SELECT 
    FName AS "SELECT", 
    MName AS 'FROM',
    LName AS [WHERE]
FROM Employees  
SELECCIONAR DESDE DÓNDE
James Juan Herrero
Juan James Johnson
Miguel Marcus Williams

Además, se puede usar un alias de columna en cualquiera de las cláusulas finales de la misma consulta, como ORDER BY :

SELECT 
    FName AS FirstName, 
    LName AS LastName
FROM 
    Employees 
ORDER BY 
    LastName DESC

Sin embargo, usted no puede usar

SELECT
    FName AS SELECT,
    LName AS FROM
FROM 
    Employees
ORDER BY 
    LastName DESC

Para crear un alias a partir de estas palabras reservadas ( SELECT y FROM ).

Esto causará numerosos errores en la ejecución.

Selección con resultados ordenados

SELECT * FROM Employees ORDER BY LName

Esta declaración devolverá todas las columnas de la tabla Employees .

Carné de identidad FName LName Número de teléfono
2 Juan Johnson 2468101214
1 James Herrero 1234567890
3 Miguel Williams 1357911131
SELECT * FROM Employees ORDER BY LName DESC

O

 SELECT * FROM Employees ORDER BY LName ASC

Esta declaración cambia la dirección de clasificación.

Uno también puede especificar múltiples columnas de clasificación. Por ejemplo:

SELECT * FROM Employees ORDER BY LName ASC, FName ASC

Este ejemplo ordenará los resultados primero por LName y luego, para los registros que tengan el mismo LName , ordene por FName . Esto le dará un resultado similar al que encontraría en una guía telefónica.

Para guardar volver a escribir el nombre de la columna en la cláusula ORDER BY , es posible usar el número de la columna. Tenga en cuenta que los números de columna comienzan desde 1.

SELECT Id, FName, LName, PhoneNumber FROM Employees ORDER BY 3

También puede incrustar una sentencia CASE en la cláusula ORDER BY .

SELECT Id, FName, LName, PhoneNumber FROM Employees ORDER BY CASE WHEN LName='Jones` THEN 0 ELSE 1 END ASC

Esto ordenará sus resultados para tener todos los registros con el LName de "Jones" en la parte superior.

Seleccionar columnas que tengan nombres de palabras clave reservadas

Cuando un nombre de columna coincide con una palabra clave reservada, el estándar de SQL requiere que lo incluya entre comillas dobles:

SELECT 
    "ORDER",
    ID 
FROM ORDERS

Tenga en cuenta que hace que el nombre de la columna distinga entre mayúsculas y minúsculas.

Algunos DBMS tienen formas propietarias de citar nombres. Por ejemplo, SQL Server utiliza corchetes para este propósito:

SELECT 
    [Order],
    ID 
FROM ORDERS

mientras que MySQL (y MariaDB) por defecto usan backticks:

SELECT 
    `Order`,
    id 
FROM orders

Selección del número especificado de registros

El estándar SQL 2008 define la cláusula FETCH FIRST para limitar el número de registros devueltos.

SELECT Id, ProductName, UnitPrice, Package 
FROM Product 
ORDER BY UnitPrice DESC
FETCH FIRST 10 ROWS ONLY

Este estándar solo se admite en versiones recientes de algunos RDMS. La sintaxis no estándar específica del proveedor se proporciona en otros sistemas. Progress OpenEdge 11.x también admite la sintaxis FETCH FIRST <n> ROWS ONLY .

Además, OFFSET <m> ROWS antes de FETCH FIRST <n> ROWS ONLY permite saltar filas antes de buscar filas.

SELECT Id, ProductName, UnitPrice, Package 
FROM Product 
ORDER BY UnitPrice DESC
OFFSET 5 ROWS
FETCH FIRST 10 ROWS ONLY

La siguiente consulta es compatible con SQL Server y MS Access:

SELECT TOP 10 Id, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC

Para hacer lo mismo en MySQL o PostgreSQL, se debe usar la palabra clave LIMIT :

SELECT Id, ProductName, UnitPrice, Package
FROM Product
ORDER BY UnitPrice DESC
LIMIT 10

En Oracle se puede hacer lo mismo con ROWNUM :

SELECT Id, ProductName, UnitPrice, Package
FROM Product
WHERE ROWNUM <= 10
ORDER BY UnitPrice DESC    

Resultados : 10 registros.

Id    ProductName               UnitPrice             Package
38    Côte de Blaye             263.50                12 - 75 cl bottles
29    Thüringer Rostbratwurst   123.79                50 bags x 30 sausgs.
9    Mishi Kobe Niku            97.00                 18 - 500 g pkgs.
20    Sir Rodney's Marmalade    81.00                 30 gift boxes
18    Carnarvon Tigers          62.50                 16 kg pkg.
59    Raclette Courdavault      55.00                 5 kg pkg.
51    Manjimup Dried Apples     53.00                 50 - 300 g pkgs.
62    Tarte au sucre            49.30                 48 pies
43    Ipoh Coffee               46.00                 16 - 500 g tins
28    Rössle Sauerkraut         45.60                 25 - 825 g cans

Matices de proveedores:

Es importante tener en cuenta que el TOP en Microsoft SQL funciona después de la cláusula WHERE y devolverá el número especificado de resultados si existen en cualquier lugar de la tabla, mientras que ROWNUM funciona como parte de la cláusula WHERE por lo que si no existen otras condiciones en el al especificar la cantidad de filas al comienzo de la tabla, obtendrá cero resultados cuando podría haber otras.

Seleccionando con alias de tabla

SELECT e.Fname, e.LName 
FROM Employees e

La tabla Empleados recibe el alias 'e' directamente después del nombre de la tabla. Esto ayuda a eliminar la ambigüedad en escenarios en los que varias tablas tienen el mismo nombre de campo y debe ser específico en cuanto a la tabla de la que desea devolver los datos.

SELECT e.Fname, e.LName, m.Fname AS ManagerFirstName 
FROM Employees e 
    JOIN Managers m ON e.ManagerId = m.Id

Tenga en cuenta que una vez que define un alias, ya no puede usar el nombre de la tabla canónica. es decir,

SELECT e.Fname, Employees.LName, m.Fname AS ManagerFirstName 
FROM Employees e 
JOIN Managers m ON e.ManagerId = m.Id

lanzaría un error.

Vale la pena señalar que los alias de tablas, más formalmente "variables de rango", se introdujeron en el lenguaje SQL para resolver el problema de las columnas duplicadas causadas por INNER JOIN . El estándar SQL de 1992 corrigió este defecto de diseño anterior al introducir NATURAL JOIN (implementado en mySQL, PostgreSQL y Oracle, pero aún no en SQL Server), cuyo resultado nunca tiene nombres de columna duplicados. El ejemplo anterior es interesante ya que las tablas se unen en columnas con diferentes nombres ( Id y ManagerId ), pero no se supone que deben estar unidos en las columnas con el mismo nombre ( LName , FName ), lo que requiere el cambio de nombre de las columnas para llevar a cabo antes de la unión:

SELECT Fname, LName, ManagerFirstName 
FROM Employees
     NATURAL JOIN
     ( SELECT Id AS ManagerId, Fname AS ManagerFirstName
       FROM Managers ) m;

Tenga en cuenta que aunque se debe declarar una variable de alias / rango para la tabla dividida (de lo contrario, SQL generará un error), nunca tiene sentido utilizarla en la consulta.

Seleccionar filas de tablas múltiples

SELECT *
FROM
    table1,
    table2
SELECT
    table1.column1,
    table1.column2,
    table2.column1
FROM
    table1,
    table2

Esto se llama producto cruzado en SQL, es igual que producto cruzado en conjuntos

Estas declaraciones devuelven las columnas seleccionadas de varias tablas en una consulta.

No hay una relación específica entre las columnas devueltas de cada tabla.

Seleccionando con funciones agregadas

Promedio

La función agregada AVG() devolverá el promedio de los valores seleccionados.
SELECT AVG(Salary) FROM Employees
Las funciones agregadas también se pueden combinar con la cláusula where.
SELECT AVG(Salary) FROM Employees where DepartmentId = 1
Las funciones agregadas también se pueden combinar con una cláusula por grupo.

Si el empleado está categorizado con varios departamentos y queremos encontrar un salario promedio para cada departamento, podemos usar la siguiente consulta.

SELECT AVG(Salary) FROM Employees GROUP BY DepartmentId

Mínimo

La función agregada MIN() devolverá el mínimo de valores seleccionados.
SELECT MIN(Salary) FROM Employees

Máximo

La función agregada MAX() devolverá el máximo de los valores seleccionados.
SELECT MAX(Salary) FROM Employees

Contar

La función agregada COUNT() devolverá el conteo de los valores seleccionados.
SELECT Count(*) FROM Employees
También se puede combinar con las condiciones donde se obtiene el recuento de filas que satisfacen condiciones específicas.
SELECT Count(*) FROM Employees where ManagerId IS NOT NULL
También se pueden especificar columnas específicas para obtener el número de valores en la columna. Tenga en cuenta que los valores NULL no se cuentan.
Select Count(ManagerId) from Employees
El recuento también se puede combinar con la palabra clave distinta para un recuento distinto.
Select Count(DISTINCT DepartmentId) from Employees

Suma

La función agregada SUM() devuelve la suma de los valores seleccionados para todas las filas.
SELECT SUM(Salary) FROM Employees

Seleccionando con nulo

SELECT Name FROM Customers WHERE PhoneNumber IS NULL

La selección con nulos toma una sintaxis diferente. No use = , use IS NULL o IS NOT NULL lugar.

Seleccionando con CASO

Cuando los resultados deben tener alguna lógica aplicada "al vuelo", se puede usar la declaración CASE para implementarla.

SELECT CASE WHEN Col1 < 50 THEN 'under' ELSE 'over' END threshold
FROM TableName 

también puede ser encadenado

SELECT 
    CASE WHEN Col1 < 50 THEN 'under' 
         WHEN Col1 > 50 AND Col1 <100 THEN 'between' 
         ELSE 'over' 
    END threshold
FROM TableName 

También se puede tener CASE dentro de otra sentencia CASE .

SELECT 
    CASE WHEN Col1 < 50 THEN 'under' 
         ELSE 
            CASE WHEN Col1 > 50 AND Col1 <100 THEN Col1 
            ELSE 'over' END 
    END threshold
FROM TableName 

Seleccionando sin bloquear la mesa

A veces, cuando las tablas se usan principalmente (o solo) para lecturas, la indexación ya no ayuda y cada bit cuenta, uno puede usar selecciones sin BLOQUEO para mejorar el rendimiento.


servidor SQL

SELECT * FROM TableName WITH (nolock)

MySQL

SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT * FROM TableName;
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

Oráculo

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT * FROM TableName;

DB2

SELECT * FROM TableName WITH UR;

donde UR significa "lectura no comprometida".


Si se utiliza en la tabla que tiene modificaciones de registro en curso, puede tener resultados impredecibles.

Seleccione distinto (solo valores únicos)

SELECT DISTINCT ContinentCode
FROM Countries;

Esta consulta devolverá todos los valores DISTINCT (únicos, diferentes) de ContinentCode columna ContinentCode de la tabla de Countries

Código Continente
jefe
UE
COMO
N / A
AF

Demostración de SQLFiddle

Seleccione con la condición de múltiples valores de la columna

SELECT * FROM Cars  WHERE status IN ( 'Waiting', 'Working' )

Esto es semánticamente equivalente a

SELECT * FROM Cars  WHERE ( status = 'Waiting' OR status = 'Working' )

es decir, el value IN ( <value list> ) es una abreviatura de disyunción ( OR lógico).

Obtener resultado agregado para grupos de filas

Recuento de filas basadas en un valor de columna específico:

SELECT category, COUNT(*) AS item_count
FROM item
GROUP BY category;

Obtención de ingresos medios por departamento:

SELECT department, AVG(income)
FROM employees
GROUP BY department;

Lo importante es seleccionar solo las columnas especificadas en la cláusula GROUP BY o utilizadas con funciones agregadas .


La cláusula WHERE también se puede utilizar con GROUP BY , pero WHERE filtra los registros antes de que se realice la agrupación:

SELECT department, AVG(income)
FROM employees
WHERE department <> 'ACCOUNTING'
GROUP BY department;

Si necesita filtrar los resultados después de que se haya realizado la agrupación, por ejemplo, para ver solo los departamentos cuyo ingreso promedio es mayor a 1000, debe usar la cláusula HAVING :

SELECT department, AVG(income)
FROM employees
WHERE department <> 'ACCOUNTING'
GROUP BY department
HAVING avg(income) > 1000;

Seleccionando con más de 1 condición.

La palabra clave AND se utiliza para agregar más condiciones a la consulta.

Nombre Años Género
Sam 18 METRO
Juan 21 METRO
Mover 22 METRO
María 23 F
SELECT name FROM persons WHERE gender = 'M' AND age > 20;

Esto volverá:

Nombre
Juan
Mover

usando la palabra clave OR

SELECT name FROM persons WHERE gender = 'M' OR age < 20;

Esto volverá:

nombre
Sam
Juan
Mover

Estas palabras clave se pueden combinar para permitir combinaciones de criterios más complejas:

SELECT name
FROM persons
WHERE (gender = 'M' AND age < 20)
   OR (gender = 'F' AND age > 20);

Esto volverá:

nombre
Sam
María


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow