SQL
SÉLECTIONNER

Introduction

Syntaxe

• SELECT [DISTINCT] [colonne1] [, [colonne2] ...]
  DE [table]
  [OERE condition]
  [GROUP BY [colonne1] [, [colonne2] ...]

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

  [COMMANDE PAR ASC | DESC]

Remarques

SELECT Name, SerialNumber
FROM ArmyInfo

SELECT *
FROM ArmyInfo

Utiliser le caractère générique pour sélectionner toutes les colonnes d'une requête.

Considérons une base de données avec les deux tableaux suivants.

Table d'employés:

Table des départements:

Déclaration de sélection simple

* est le caractère générique utilisé pour sélectionner toutes les colonnes disponibles dans une table.

Utilisé comme substitut pour les noms de colonne explicites, il renvoie toutes les colonnes de toutes les tables qu'une requête sélectionne FROM . Cet effet s'applique à toutes les tables auxquelles la requête accède via ses clauses JOIN .

Considérez la requête suivante:

SELECT * FROM Employees

Il retournera tous les champs de toutes les lignes de la table Employees :

Notation par points

Pour sélectionner toutes les valeurs d'une table spécifique, le caractère générique peut être appliqué à la table avec une notation par points .

Considérez la requête suivante:

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

Cela renverra un ensemble de données avec tous les champs de la table Employee , suivi uniquement du champ Name dans la table Departments :

Avertissements contre l'utilisation

Il est généralement conseillé d’utiliser * si possible dans le code de production, car cela peut causer un certain nombre de problèmes potentiels, notamment:

1. Excès d'E / S, charge du réseau, utilisation de la mémoire, etc., car le moteur de base de données lit les données inutiles et les transmet au code frontal. Ceci est particulièrement préoccupant lorsque de grands champs peuvent être utilisés, tels que ceux utilisés pour stocker de longues notes ou des fichiers joints.
2. Le surplus d'E / S se charge si la base de données doit spouler les résultats internes sur le disque dans le cadre du traitement d'une requête plus complexe que SELECT <columns> FROM <table> .
3. Traitement supplémentaire (et / ou même plus IO) si certaines des colonnes inutiles sont:
   • colonnes calculées dans les bases de données qui les supportent
   • dans le cas d'une sélection dans une vue, les colonnes d'une table / vue que l'optimiseur de requête pourrait sinon optimiser
4. Potentiel d'erreurs inattendues si des colonnes sont ajoutées aux tables et aux vues ultérieurement, ce qui entraîne des noms de colonnes ambigus. Par exemple SELECT * FROM orders JOIN people ON people.id = orders.personid ORDER BY displayname - si une colonne appelée displayname est ajoutée à la table des commandes pour permettre aux utilisateurs de donner des noms significatifs à leurs commandes pour référence ultérieure, le nom de la colonne apparaîtra. deux fois dans la sortie de sorte que la clause ORDER BY soit ambiguë, ce qui peut provoquer des erreurs ("nom de colonne ambigu" dans les versions récentes de MS SQL Server) et si ce n'est pas le cas, le code de l'application prévu parce que la nouvelle colonne est le premier de ce nom renvoyé, et ainsi de suite.

Quand pouvez-vous utiliser * , en tenant compte de l'avertissement ci-dessus?

Bien qu’il soit préférable de l’éviter dans le code de production, l’utilisation de * convient parfaitement pour effectuer des requêtes manuelles sur la base de données pour des travaux d’investigation ou de prototypage.

Parfois, les décisions de conception dans votre application le rendent inévitable (dans de telles circonstances, préférez les tablealias.* Plus que * si possible).

Lorsque vous utilisez EXISTS , tel que SELECT A.col1, A.Col2 FROM A WHERE EXISTS (SELECT * FROM B where A.ID = B.A_ID) , nous ne SELECT A.col1, A.Col2 FROM A WHERE EXISTS (SELECT * FROM B where A.ID = B.A_ID) aucune donnée de B. Ainsi, une jointure est inutile et le moteur sait qu'aucune valeur de B ne doit être retournée, donc pas de performance pour l'utilisation de * . De même, COUNT(*) est correct car il ne renvoie pas non plus de colonnes, il suffit donc de lire et de traiter celles qui sont utilisées à des fins de filtrage.

Sélection avec condition

La syntaxe de base de SELECT avec la clause WHERE est la suivante:

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

La [condition] peut être toute expression SQL, spécifiée en utilisant des opérateurs de comparaison ou des opérateurs logiques tels que>, <, =, <>,> =, <=, LIKE, NOT, IN, BETWEEN etc.

L'instruction suivante renvoie toutes les colonnes de la table 'Cars' où la colonne status est 'READY':

SELECT * FROM Cars WHERE status = 'READY'

Voir WHERE et HAVING pour plus d'exemples.

Sélectionner des colonnes individuelles

SELECT 
    PhoneNumber, 
    Email, 
    PreferredContact 
FROM Customers

Cette instruction renvoie les colonnes PhoneNumber , Email et PreferredContact de toutes les lignes de la table Customers . Les colonnes seront également renvoyées dans l'ordre dans lequel elles apparaissent dans la clause SELECT .

Le résultat sera:

Si plusieurs tables sont jointes, vous pouvez sélectionner des colonnes à partir de tables spécifiques en spécifiant le nom de la table avant le nom de la colonne: [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 signifie que le champ Id de la table Orders sera renvoyé sous la forme d'une colonne nommée OrderId . Voir la sélection avec l'alias de colonne pour plus d'informations.

Pour éviter d'utiliser des noms de table longs, vous pouvez utiliser des alias de table. Cela atténue la difficulté d'écrire des noms de table longs pour chaque champ que vous sélectionnez dans les jointures. Si vous effectuez une auto-jointure (une jointure entre deux instances de la même table), vous devez utiliser des alias de table pour distinguer vos tables. Nous pouvons écrire un alias de table comme Customers c ou Customers AS c . Ici, c fonctionne comme un alias pour les Customers et nous pouvons sélectionner, par exemple, Email comme ceci: c.Email .

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

SELECT utilisant des alias de colonne

Les alias de colonne sont principalement utilisés pour raccourcir le code et rendre les noms de colonne plus lisibles.

Le code devient plus court que les noms de table longs et l'identification inutile des colonnes (par exemple, il peut y avoir 2 ID dans la table, mais une seule est utilisée dans l'instruction) . En plus des alias de table, cela vous permet d'utiliser des noms descriptifs plus longs dans la structure de votre base de données tout en conservant des requêtes concises sur cette structure.

En outre, ils sont parfois nécessaires , par exemple dans les vues, pour nommer les sorties calculées.

Toutes les versions de SQL

Les alias peuvent être créés dans toutes les versions de SQL en utilisant des guillemets ( " ).

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

Différentes versions de SQL

Vous pouvez utiliser des guillemets simples ( ' ), des guillemets doubles ( " ) et des crochets ( [] ) pour créer un alias dans Microsoft SQL Server.

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

Les deux résulteront en:

Cette instruction LName colonnes FName et LName avec un nom donné (un alias). Ceci est réalisé en utilisant l'opérateur AS suivi de l'alias, ou en écrivant simplement un alias directement après le nom de la colonne. Cela signifie que la requête suivante a le même résultat que ci-dessus.

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

Cependant, la version explicite (c.-à-d., En utilisant l'opérateur AS ) est plus lisible.

Si l'alias a un seul mot qui n'est pas un mot réservé, nous pouvons l'écrire sans guillemets simples, guillemets ou crochets:

SELECT 
    FName AS FirstName, 
    LName AS LastName
FROM Employees  

Une autre variante disponible dans MS SQL Server, entre autres, est <alias> = <column-or-calculation> , par exemple:

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

ce qui équivaut à:

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

Les deux résulteront en:

Certains trouvent que l'utilisation de = plutôt que de As plus facile à lire, bien que beaucoup recommandent ce format, principalement parce qu'il n'est pas standard, donc pas largement pris en charge par toutes les bases de données. Cela peut entraîner une confusion avec d'autres utilisations du caractère = .

Toutes les versions de SQL

De plus, si vous devez utiliser des mots réservés, vous pouvez utiliser des parenthèses ou des guillemets pour échapper:

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

Différentes versions de SQL

De même, vous pouvez échapper des mots-clés dans MSSQL avec toutes les approches différentes:

SELECT 
    FName AS "SELECT", 
    MName AS 'FROM',
    LName AS [WHERE]
FROM Employees  

En outre, un alias de colonne peut être utilisé pour toutes les clauses finales de la même requête, telles que ORDER BY :

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

Cependant, vous ne pouvez pas utiliser

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

Pour créer un alias à partir de ces mots réservés ( SELECT et FROM ).

Cela provoquera de nombreuses erreurs d'exécution.

Sélection avec résultats triés

SELECT * FROM Employees ORDER BY LName

Cette instruction retournera toutes les colonnes de la table Employees .

SELECT * FROM Employees ORDER BY LName DESC

Ou

 SELECT * FROM Employees ORDER BY LName ASC

Cette déclaration modifie le sens du tri.

On peut également spécifier plusieurs colonnes de tri. Par exemple:

SELECT * FROM Employees ORDER BY LName ASC, FName ASC

Cet exemple va trier les résultats d'abord par LName , puis, pour les enregistrements qui ont le même LName , trier par FName . Cela vous donnera un résultat similaire à ce que vous trouveriez dans un annuaire téléphonique.

Pour enregistrer le nouveau nom de la colonne dans la clause ORDER BY , il est possible d'utiliser le numéro de la colonne. Notez que les numéros de colonne commencent à 1.

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

Vous pouvez également incorporer une instruction CASE dans la clause ORDER BY .

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

Cela va trier vos résultats pour avoir tous les enregistrements avec le LName de "Jones" en haut.

Sélectionner les colonnes nommées d'après les mots-clés réservés

Lorsqu'un nom de colonne correspond à un mot clé réservé, le SQL standard requiert que vous le placiez entre guillemets doubles:

SELECT 
    "ORDER",
    ID 
FROM ORDERS

Notez que le nom de la colonne est sensible à la casse.

Certains SGBD ont des méthodes propriétaires pour citer des noms. Par exemple, SQL Server utilise des crochets à cet effet:

SELECT 
    [Order],
    ID 
FROM ORDERS

alors que MySQL (et MariaDB) utilisent par défaut des backticks:

SELECT 
    `Order`,
    id 
FROM orders

Sélection du nombre spécifié d'enregistrements

Le standard SQL 2008 définit la clause FETCH FIRST pour limiter le nombre d'enregistrements renvoyés.

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

Cette norme est uniquement prise en charge dans les versions récentes de certains RDMS. La syntaxe non standard spécifique au fournisseur est fournie dans d'autres systèmes. Progress OpenEdge 11.x prend également en charge la syntaxe FETCH FIRST <n> ROWS ONLY .

En outre, OFFSET <m> ROWS avant FETCH FIRST <n> ROWS ONLY permet d'ignorer les lignes avant d'extraire les lignes.

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

La requête suivante est prise en charge dans SQL Server et MS Access:

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

Pour faire la même chose dans MySQL ou PostgreSQL, le mot-clé LIMIT doit être utilisé:

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

Dans Oracle, on peut faire la même chose avec ROWNUM :

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

Résultats : 10 enregistrements.

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

Vendor Nuances:

Il est important de noter que le TOP de Microsoft SQL fonctionne après la clause WHERE et renverra le nombre de résultats spécifié s’il existe dans la table, tandis que ROWNUM fonctionne dans le cadre de la clause WHERE si d’autres conditions n’existent pas dans la table. nombre spécifié de lignes au début de la table, vous obtiendrez des résultats nuls s’il pouvait y en avoir d’autres à trouver.

Sélection avec alias de table

SELECT e.Fname, e.LName 
FROM Employees e

La table Employees reçoit l'alias 'e' directement après le nom de la table. Cela permet d'éliminer l'ambiguïté dans les scénarios où plusieurs tables ont le même nom de champ et vous devez spécifier la table à partir de laquelle vous souhaitez renvoyer des données.

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

Notez qu'une fois que vous avez défini un alias, vous ne pouvez plus utiliser le nom de la table canonique. c'est à dire,

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

serait jeter une erreur.

Il convient de noter les alias de tables - plus formellement les «variables de plage» - ont été introduits dans le langage SQL pour résoudre le problème des colonnes en double provoquées par INNER JOIN . Le standard SQL de 1992 corrigeait ce défaut de conception en introduisant NATURAL JOIN (implémenté dans mySQL, PostgreSQL et Oracle mais pas encore dans SQL Server), dont le résultat ne comporte jamais de noms de colonnes en double. L'exemple ci-dessus est intéressant en ce sens que les tables sont jointes sur des colonnes avec des noms différents ( Id et ManagerId ) mais ne sont pas supposées être jointes sur les colonnes du même nom ( LName , FName ), nécessitant le changement de nom des colonnes avant l'adhésion:

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

Notez que même si une variable alias / range doit être déclarée pour la table dervied (sinon SQL lancera une erreur), il n’est jamais logique de l’utiliser dans la requête.

Sélectionnez des lignes dans plusieurs tables

SELECT *
FROM
    table1,
    table2

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

Ceci est appelé produit croisé dans SQL, il est identique à produit croisé dans les ensembles

Ces instructions renvoient les colonnes sélectionnées de plusieurs tables dans une requête.

Il n'y a pas de relation spécifique entre les colonnes renvoyées par chaque table.

Sélection avec les fonctions d'agrégat

Moyenne

SELECT AVG(Salary) FROM Employees

SELECT AVG(Salary) FROM Employees where DepartmentId = 1

Si l'employé est classé avec plusieurs départements et que nous voulons trouver un salaire moyen pour chaque service, nous pouvons utiliser la requête suivante.

SELECT AVG(Salary) FROM Employees GROUP BY DepartmentId

Le minimum

SELECT MIN(Salary) FROM Employees

Maximum

SELECT MAX(Salary) FROM Employees

Compter

SELECT Count(*) FROM Employees

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

Select Count(ManagerId) from Employees

Select Count(DISTINCT DepartmentId) from Employees

Somme

SELECT SUM(Salary) FROM Employees

Sélection avec null

SELECT Name FROM Customers WHERE PhoneNumber IS NULL

La sélection avec des valeurs NULL a une syntaxe différente. N'utilisez pas = , utilisez IS NULL ou IS NOT NULL place.

Sélection avec CASE

Lorsque les résultats doivent avoir une logique appliquée «à la volée», on peut utiliser l'instruction CASE pour l'implémenter.

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

peut également être enchaîné

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

on peut aussi avoir CASE dans une autre déclaration 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 

Sélectionner sans verrouiller la table

Parfois, lorsque les tables sont utilisées principalement (ou uniquement) pour les lectures, l'indexation n'aide plus et chaque bit compte, on peut utiliser selects sans LOCK pour améliorer les performances.

serveur SQL

SELECT * FROM TableName WITH (nolock)

MySQL

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

Oracle

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

DB2

SELECT * FROM TableName WITH UR;

où UR signifie "lecture non validée".

S'il est utilisé sur une table dont les modifications d'enregistrement sont en cours, les résultats risquent d'être imprévisibles.

Sélectionnez distinct (valeurs uniques uniquement)

SELECT DISTINCT ContinentCode
FROM Countries;

Cette requête renvoie toutes les valeurs DISTINCT (uniques, différentes) de ContinentCode colonne ContinentCode du tableau Countries

Démo SQLFiddle

Sélectionnez avec la condition de plusieurs valeurs de la colonne

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

Ceci est sémantiquement équivalent à

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

la value IN ( <value list> ) est un raccourci pour la disjonction ( OR logique).

Obtenir un résultat agrégé pour les groupes de lignes

Comptage des lignes en fonction d'une valeur de colonne spécifique:

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

Obtenir un revenu moyen par département:

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

L'important est de ne sélectionner que les colonnes spécifiées dans la clause GROUP BY ou utilisées avec les fonctions d'agrégat .

La clause WHERE peut également être utilisée avec GROUP BY , mais WHERE filtre les enregistrements avant tout regroupement:

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

Si vous devez filtrer les résultats après le regroupement, par exemple pour ne voir que les départements dont le revenu moyen est supérieur à 1000, vous devez utiliser la clause HAVING :

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

Sélection avec plus d'une condition

Le mot clé AND est utilisé pour ajouter plus de conditions à la requête.

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

Cela va retourner:

en utilisant le mot clé OR

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

Cela va retourner:

Ces mots-clés peuvent être combinés pour permettre des combinaisons de critères plus complexes:

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

Cela va retourner: