Le SELECT est presque sans aucun doute l'instruction la plus couramment utilisée en SQL.
Le SELECT L'instruction est utilisée pour récupérer les données de la base de données. Vous pouvez spécifier les lignes que vous souhaitez renvoyer et les colonnes.
Exemple
Voici un exemple pour illustrer le SELECT déclaration.
SELECT *
FROM Pets;Résultat :
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Dans cet exemple, nous avons utilisé l'astérisque (* ) caractère générique pour renvoyer toutes les colonnes. Nous avons également utilisé le FROM clause pour spécifier la table à partir de laquelle obtenir les données.
Cette requête renvoie donc toutes les lignes et toutes les colonnes de Pets tableau.
Spécifiez les colonnes
Vous pouvez spécifier les colonnes que vous aimeriez voir renvoyées.
Pour ce faire, remplacez le caractère générique astérisque par les noms de colonne, chacun séparé par une virgule, dans l'ordre dans lequel vous souhaitez qu'ils soient renvoyés.
SELECT PetId, PetName, DOB
FROM Pets;Résultat :
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Il est généralement considéré comme une bonne pratique de le faire de cette façon et de ne renvoyer que les colonnes dont vous avez réellement besoin. L'utilisation du caractère générique astérisque pour renvoyer toutes les colonnes peut avoir un impact négatif sur les performances, en particulier dans les bases de données plus volumineuses.
Spécifiez les lignes
Il existe de nombreuses façons de filtrer les résultats uniquement sur les lignes qui vous intéressent. La méthode la plus courante consiste à utiliser le WHERE clause. Cette clause vous permet de spécifier une condition qu'une ligne doit satisfaire pour être qualifiée.
Voici un exemple pour illustrer.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Dans notre cas, il y avait deux lignes qui satisfaisaient notre condition de recherche.
Notre condition de recherche utilise l'opérateur égal (= ) pour spécifier que la valeur du PetName la colonne doit correspondre à la valeur spécifiée (Fluffy ) exactement.
Il existe de nombreux autres opérateurs que vous pouvez utiliser dans vos conditions de recherche. Par exemple, vous pouvez utiliser le LIKE opérateur pour retourner les animaux dont le nom commence par F ou Fluff ou peu importe.
Vous pouvez ajouter plus de conditions au WHERE clause en utilisant des opérateurs tels que AND et OR opérateurs.
Voici un exemple.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR DOB < '2020-01-01';Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Dans cet exemple, nous avons renvoyé toutes les lignes où le nom de l'animal est Fluffy ou où la date de naissance de l'animal (spécifiée dans le DOB colonne) est inférieure à une certaine date. Nous avons utilisé l'opérateur inférieur à (< ) pour le préciser.
Renvoyer des données non tabulaires
Le SELECT peut également être utilisée pour renvoyer des données qui ne sont pas stockées dans une table. Par exemple, il est parfaitement légal de faire ceci :
SELECT 'Hey there!';Résultat :
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Notez que lorsque nous faisons cela, la colonne n'a pas de nom. Nous pourrions utiliser un alias pour donner un nom au champ résultant.
Voici quelques exemples supplémentaires de sélection de données non tabulaires et de fourniture d'un alias à chaque champ renvoyé :
SELECT
2 + 3 AS "2 + 3",
'Fluffy' + ' ' + 'Smith' AS FullName,
SYSDATETIME() AS "Date/time";Résultat :
+---------+--------------+-----------------------------+ | 2 + 3 | FullName | Date/time | |---------+--------------+-----------------------------| | 5 | Fluffy Smith | 2020-12-04 23:58:55.8483734 | +---------+--------------+-----------------------------+
Voici un bref aperçu :
- La première colonne a simplement ajouté deux nombres.
- La deuxième colonne concaténait trois chaînes (y compris un espace). Vous pouvez également concaténer des chaînes avec des nombres si nécessaire.
- La troisième colonne utilise le
SYSDATETIME()fonction pour renvoyer la date et l'heure actuelles. Cette fonction est disponible dans SQL Server. D'autres SGBD ont leurs propres fonctions de date et d'heure. Voir Fonctions de date/heure SQLite, Fonctions de date/heure SQL Server et Fonctions de date/heure PostgreSQL pour une liste des fonctions de date et d'heure disponibles dans ces SGBD.
Sous-requêtes
Il est possible d'avoir plusieurs SELECT déclarations dans une seule requête. Nous pouvons le faire en utilisant une sous-requête.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Résultat :
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dans cet exemple, nous avons utilisé le IN opérateur pour spécifier une sous-requête. Cette sous-requête a sélectionné des données d'une autre table, et le IN l'opérateur l'a lié à la requête externe.
Ordre des résultats
Vous pouvez utiliser le ORDER BY clause pour trier les résultats.
Par exemple, nous pourrions trier les résultats précédents par le PetTypeId colonne par ordre décroissant :
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets )
ORDER BY PetTypeId DESC;Résultat :
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 3 | Dog | | 2 | Cat | | 1 | Bird | +-------------+-----------+
Voir SQL ORDER BY Clause pour les débutants pour plus d'exemples et une explication détaillée.
Plus avancé SELECT Déclarations
Le SELECT instruction est une instruction très simple, mais elle peut être utilisée pour créer des requêtes très complexes.
Voici une requête un peu plus complexe que les précédentes.
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;Résultat :
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Dans le monde des requêtes SQL, c'est encore assez simple, cependant, il contient de nombreux éléments souvent vus dans des requêtes plus complexes.
Par exemple, cette requête utilise une jointure pour extraire des données de plusieurs tables. Il utilise également le GROUP BY clause pour diviser les lignes en groupes.
Voir SQL GROUP BY Clause pour les débutants pour plus d'exemples du GROUP BY clause.
Consultez le didacticiel sur les jointures SQL pour savoir comment récupérer des données à partir de plusieurs tables et les renvoyer sous la forme d'un ensemble de résultats.
Le SELECT INTO Déclaration
Certains SGBD supportent le SELECT INTO déclaration. Ceci est légèrement différent des exemples précédents, en ce sens qu'il affecte les données de la base de données.
Le SELECT INTO L'instruction crée une nouvelle table et y insère des données à partir d'une autre table.
En gros, ça se passe comme ça :
SELECT * INTO Table2
FROM Table1;
Dans cet exemple, nous créons une nouvelle table appelée Table2 , et insérez toutes les données de Table1 dans ça. Table2 aura la même définition que Table1 .
Voir SQL SELECT INTO Déclaration pour plus d'exemples.
Comme je l'ai mentionné, tous les SGBD ne prennent pas en charge cette déclaration. Si votre SGBD ne prend pas en charge le SELECT INTO instruction, essayez d'utiliser la CREATE TABLE ... AS SELECT déclaration à la place.
Ces instructions créent une nouvelle table dans le cadre de leur opération. Pour insérer des données dans une table qui existe déjà, essayez d'utiliser le INSERT INTO ... SELECT déclaration à la place.
