SQL
SELECCIONAR

Introducción

Sintaxis

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

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

  [ORDENAR POR ASC | DESC]

Observaciones

SELECT Name, SerialNumber
FROM ArmyInfo

SELECT *
FROM ArmyInfo

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:

Mesa de departamentos:

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 :

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 :

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á:

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:

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 

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  

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:

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  

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 .

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

SELECT AVG(Salary) FROM Employees

SELECT AVG(Salary) FROM Employees where DepartmentId = 1

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

SELECT MIN(Salary) FROM Employees

Máximo

SELECT MAX(Salary) FROM Employees

Contar

SELECT Count(*) FROM Employees

SELECT Count(*) FROM Employees where ManagerId IS NOT NULL

Select Count(ManagerId) from Employees

Select Count(DISTINCT DepartmentId) from Employees

Suma

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

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.

SELECT name FROM persons WHERE gender = 'M' AND age > 20;

Esto volverá:

usando la palabra clave OR

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

Esto volverá:

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á: