Tutoriel SQL pour débutants

Dans ce didacticiel SQL pour débutants, vous allez créer votre propre base de données, insérer des données dans cette base de données, puis exécuter des requêtes sur cette base de données.

Ce tutoriel SQL vous permettra d'exécuter des requêtes SQL en un rien de temps !

Exemple SQL

Voici un exemple d'instruction SQL :

SELECT * 
FROM Pets;

C'est un parfait exemple de la facilité avec laquelle il est possible d'écrire du SQL. Cette simple instruction SQL fait beaucoup. Il renvoie toute la table. Il renvoie toutes les colonnes et toutes les lignes de la table appelée Pets .

L'astérisque (* ) est un caractère générique, qui signifie "toutes les colonnes". C'est un moyen simple et rapide d'obtenir toutes les colonnes sans avoir à les taper toutes.

C'est l'une des belles choses à propos de SQL. Les requêtes SQL les plus simples sont généralement les plus puissantes. Si nous voulions renvoyer moins de données, nous aurions en fait besoin d'en écrire plus .

Par exemple, si nous ne voulions que des animaux nommés Récupérer , nous ajouterions un WHERE clause qui stipulait cette exigence.

Comme ceci :

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

Le WHERE La clause filtre notre requête uniquement sur les lignes où le PetName la colonne a une valeur de Fetch .

Cette requête suppose qu'il existe une colonne appelée PetName et une table appelée Pets dans la base de données.

Dans ce didacticiel SQL, je vais vous montrer comment créer une telle base de données à l'aide de SQL.

Je vais également vous montrer comment insérer des données dans cette base de données, mettre à jour des données, supprimer des données et exécuter des requêtes dessus.

Qu'est-ce que SQL ?

SQL est un acronyme pour Structured Query Language.

SQL est le langage de requête standard utilisé pour travailler avec des bases de données relationnelles.

SQL est utilisé par tous les principaux systèmes de gestion de bases de données relationnelles (RDBMS), notamment :

• Microsoft Access
• SQL Server
• Oracle
• PostgreSQL
• MySQL
• SQLite

Que puis-je faire avec SQL ?

Vous pouvez utiliser SQL pour exécuter des requêtes sur une base de données, insérer des enregistrements, mettre à jour des enregistrements et supprimer des enregistrements. Vous pouvez également créer de nouveaux objets de base de données tels que des bases de données et des tables. Vous pouvez également effectuer des tâches d'administration de base de données, telles que la création de connexions, des tâches automatisées, des sauvegardes de base de données et bien plus encore.

Même lorsque vous faites des choses à l'aide d'une interface utilisateur graphique (GUI), votre système de gestion de base de données (SGBD) utilisera presque certainement SQL dans les coulisses pour effectuer cette tâche.

Par exemple, lorsque vous créez une base de données en cliquant sur Créer une base de données et en saisissant les détails de la nouvelle base de données dans une boîte de dialogue, une fois que vous avez cliqué sur OK ou Créer ou quelle que soit la lecture du bouton, votre système de base de données utilisera le SQL CREATE DATABASE pour continuer et créer la base de données comme spécifié.

Il en va de même pour d'autres tâches, telles que l'exécution de requêtes, l'insertion de données, etc.

SQL vous permet également d'effectuer des actions plus avancées telles que la création de procédures stockées (scripts autonomes), des vues (requêtes prédéfinies) et la définition d'autorisations sur des objets de base de données (tels que des tables, des procédures stockées et des vues).

Cela dit, vous n'avez pas besoin d'apprendre tous les éléments avancés pour démarrer avec SQL. L'avantage de SQL est que certaines des tâches les plus courantes sont les plus faciles à écrire.

Norme SQL

SQL a été normalisé en ANSI X3.135 en 1986 et, en quelques mois, il a été adopté par l'ISO en tant qu'ISO 9075-1987. La norme internationale (maintenant ISO/IEC 9075) a été révisée périodiquement depuis, et elle existe actuellement en 9 parties.

La plupart des principaux fournisseurs de bases de données ont tendance à adhérer au standard SQL. L'avantage est que vous n'avez pas besoin d'apprendre un nouveau langage de requête à chaque fois que vous découvrez un nouveau SGBD.

En pratique cependant, il existe des variations entre la façon dont chaque fournisseur de base de données implémente la norme SQL. Par conséquent, le code que vous écrivez dans un SGBD peut ne pas toujours fonctionner dans un autre sans nécessiter de modifications.

La bonne nouvelle est que tous les principaux SGBD prennent en charge les tâches les plus courantes généralement de la même manière.

Prononciation SQL

SQL se prononce généralement de l'une des deux manières suivantes :

• "ess-que-el " (c'est-à-dire épeler chaque lettre)
• "suite ” (comme dans l'orthographe/prononciation d'origine).

Voir Est-ce prononcé S-Q-L ou Sequel si vous vous demandez pourquoi.

De quoi ai-je besoin pour ce didacticiel SQL ?

Pour vraiment bénéficier de ce didacticiel SQL, vous devez suivre les exemples. Cela signifie que vous aurez besoin d'un endroit pour entrer les requêtes SQL. Vous aurez besoin de quelque chose comme ceci :

Si vous comptez exécuter des requêtes SQL, vous aurez besoin de :

• Un SGBDR installé (tel que SQL Server, MySQL, PostgreSQL, SQLite, etc.).
• Un outil de base de données qui vous permet d'exécuter des requêtes SQL sur ce RDBMS (tel que MySQL WorkBench, Azure Data Studio (photo), DBeaver et SSMS).

Si vous en avez déjà installé un de chaque, c'est parfait ! Vous pouvez continuer avec le tutoriel.

Si vous ne les avez pas installés, consultez De quoi ai-je besoin pour exécuter SQL ? pour obtenir des instructions sur l'installation d'un SGBDR et de son outil de gestion de base de données approprié, avant de revenir à ce didacticiel SQL.

Créer une base de données

Une fois que vous avez installé votre SGBDR et l'outil de base de données approprié, vous êtes prêt à créer une base de données :

CREATE DATABASE PetHotel;

Fait!

Cette déclaration a en fait créé une base de données. Une base de données vide, mais une base de données quand même.

Cette base de données contiendra les tables et les données utilisées dans ce didacticiel SQL. Lorsque nous créons une table ou insérons des données, nous le ferons à l'intérieur de cette base de données.

Je dois mentionner que SQLite utilise une syntaxe différente pour créer des bases de données. Si vous utilisez SQLite, voici comment créer une base de données dans SQLite.

Se connecter à la base de données

Avant de commencer à créer des tables, à insérer des données, etc., vous devez vous assurer que vous êtes dans la bonne base de données. La création d'une base de données (comme nous venons de le faire) ne vous connecte pas nécessairement à cette base de données.

Dans de nombreux SGBD (tels que SQL Server , MySQL et MariaDB ), nous pouvons utiliser ce qui suit pour basculer vers la base de données spécifiée :

USE PetHotel;

Cela fait de PetHotel la base de données actuelle.

En SQLite , vous êtes probablement déjà dans la base de données après l'avoir créée. Sinon, vous pouvez joindre la base de données (qui la créera également si elle n'existe pas déjà) :

ATTACH DATABASE 'PetHotel.db' AS Pets;

Dans PostgreSQL , si vous utilisez l'outil psql, vous pouvez utiliser ce qui suit :

\connect PetHotel

Ou la version abrégée :

\c PetHotel

Je dois mentionner que le processus de création et de connexion aux bases de données peut différer considérablement d'un SGBD à l'autre.

Heureusement, la plupart des outils GUI vous permettent de vous connecter à une base de données soit en double-cliquant sur la base de données, soit en cliquant avec le bouton droit sur le nom de la base de données et en sélectionnant un nouvel onglet de requête dans le menu contextuel. Si vous vous retrouvez bloqué à cette étape, utilisez simplement l'interface graphique pour créer et/ou vous connecter à votre base de données.

Créer un tableau

Maintenant que vous êtes connecté à la bonne base de données, vous pouvez continuer et créer des tables.

Pour créer une table en SQL, utilisez le CREATE TABLE déclaration.

Lorsque vous créez une table, vous devez spécifier quelles colonnes seront dans la table, ainsi que leurs types de données. Vous pouvez également spécifier d'autres détails, mais ne nous précipitons pas.

Créons un tableau :

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

Dans ce cas, nous créons une table appelée PetTypes . Nous le savons, car le nom de la table vient immédiatement après le CREATE TABLE bit.

Vient ensuite une liste de colonnes, entre parenthèses.

Le tableau ci-dessus contient les colonnes suivantes :

• PetIdId
• PetType

Chaque colonne est suivie de son type de données :

• int signifie que cette colonne accepte des entiers. Autant que je sache, la plupart des principaux SGBD prennent en charge la déclaration de colonnes en tant que int . Si vous rencontrez des problèmes, essayez d'utiliser integer .
• varchar(60) signifie que cette colonne accepte des chaînes jusqu'à 60 caractères. varchar les colonnes sont des chaînes de longueur variable. Un autre type de données de chaîne est char (qui est une chaîne de longueur fixe). Si vous rencontrez des problèmes pour définir une colonne en tant que varchar(60) , essayez d'utiliser char(60) .

NOT NULL Contraintes

Dans cet exemple, les deux colonnes sont définies avec NOT NULL contraintes. Le NOT NULL contrainte signifie que cette colonne ne peut pas être vide. Lorsqu'une nouvelle ligne est insérée, tout NOT NULL les colonnes doivent contenir une valeur. D'autres colonnes peuvent rester vides s'il n'y a pas de données pour ces colonnes.

Si NULL les valeurs sont autorisées dans la colonne, vous pouvez soit omettre le NOT NULL part, ou déclarez-le comme NULL (c'est-à-dire NULL les valeurs sont autorisées dans cette colonne).

Certains SGBD (tels que DB2) ne prennent pas en charge le NULL de toute façon, et vous devrez donc l'omettre lorsque vous travaillez avec de tels SGBD.

Clés primaires

Nous avons également créé le PetTypeId colonne la clé primaire. La clé primaire est une ou plusieurs colonnes qui identifient de manière unique chaque ligne du tableau. Vous spécifiez la/les colonne(s) sélectionnée(s) comme clé primaire en utilisant une contrainte de clé primaire. Vous pouvez le faire dans le CREATE TABLE (comme nous l'avons fait ici), ou vous pouvez en ajouter une plus tard avec un ALTER TABLE déclaration.

Les clés primaires doivent contenir des valeurs uniques. Autrement dit, pour chaque ligne de cette table, la valeur dans la ou les colonnes de clé primaire doit être différente dans chaque ligne. Cela pourrait être aussi simple que d'avoir des nombres incrémentés (comme 1, 2, 3… etc) ou cela pourrait être un code de produit (comme pr4650, pr2784, pr5981… etc).

De plus, les clés primaires doivent contenir une valeur. Il ne peut pas être NULL .

Bien que les clés primaires ne soient pas obligatoires, il est généralement considéré comme une bonne pratique de définir une clé primaire sur chaque table.

Créer plus de tableaux

Créons deux tables supplémentaires :

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Ces deux tableaux sont similaires au premier, sauf qu'ils ont plus de lignes et quelques pièces supplémentaires, que j'expliquerai ci-dessous.

Si vous êtes intéressé, consultez SQL CREATE TABLE for Beginners pour quelques exemples simples de création de tables en SQL.

Relations

Lorsque nous avons créé nos Pets table, nous avons en fait créé une relation entre les trois tables.

Cette relation est illustrée dans le diagramme suivant.

Les relations de base de données sont une partie cruciale de SQL. Les relations nous permettent d'interroger plusieurs tables pour obtenir des données associées et d'obtenir des résultats précis et cohérents.

Dans notre cas, nous voulons pouvoir rechercher des animaux par propriétaire, ou des animaux par type d'animal, etc. Et nous voulons que nos résultats soient précis et cohérents.

Pour y parvenir, nous devons insister pour que tous les animaux domestiques soient entrés avec leur propriétaire et leur type d'animal. Par conséquent, nous devons nous assurer que, chaque fois qu'un nouvel animal est ajouté au Pets table, il y a déjà un propriétaire correspondant dans le Owners table, et un type d'animal correspondant dans le PetTypes table.

Fondamentalement, nos exigences sont les suivantes :

• Toute valeur dans Pets.PetTypeId la colonne doit correspondre à une valeur dans PetTypes.PetTypeId colonne.
• Toute valeur dans Pets.OwnerId la colonne doit correspondre à une valeur dans Owners.OwnerId colonne.

Nous pouvons garantir les exigences ci-dessus en créant une contrainte de clé étrangère sur les colonnes applicables. Une clé étrangère La contrainte est utilisée pour spécifier qu'une certaine colonne fait référence à la clé primaire d'une autre table.

Le code ci-dessus a en effet créé deux contraintes de clé étrangère sur les Pets tableau.

Notez que le PetTypeId et OwnerId les colonnes ont du code supplémentaire qui commence par REFERENCES... . Ce sont les parties qui ont créé les deux clés étrangères.

Lorsque nous avons créé les Pets table, son PetTypeId la colonne a un peu qui va REFERENCES PetTypes (PetTypeId) . Cela signifie que le Pets.PetTypeId la colonne référence le PetTypeId colonne dans PetTypes tableau.

C'est la même chose pour le OwnerId colonne. Il référence le OwnerId colonne des Owners tableau.

Dans la plupart des SGBD, les clés étrangères peuvent également être créées sur une table existante, en utilisant ALTER TABLE déclaration, mais nous ne reviendrons pas là-dessus. Voir Comment créer une relation en SQL pour en savoir plus à ce sujet.

Quoi qu'il en soit, nos clés étrangères ont été créées. Désormais, chaque fois que quelqu'un insère un nouvel animal de compagnie dans Pets table, le PetTypeId et OwnerId les valeurs devront avoir une valeur correspondante dans le PetTypes et Owners tableaux respectivement. Si l'un d'entre eux ne le fait pas, la base de données renverra une erreur.

C'est l'avantage des clés étrangères. Cela aide à empêcher la saisie de mauvaises données. Il aide à maintenir l'intégrité des données et plus précisément l'intégrité référentielle.

Vérifier les contraintes

Une contrainte de vérification est un autre type de contrainte dont vous devez être conscient. Une contrainte de vérification vérifie les données avant qu'elles n'entrent dans la base de données. Lorsqu'une table a une contrainte de vérification activée, les données ne peuvent entrer dans la table que si elles ne violent pas cette contrainte. Les données qui violent la contrainte ne peuvent pas entrer dans la table.

Par exemple, vous pouvez créer une contrainte de vérification sur un Price colonne pour s'assurer qu'elle n'accepte que les valeurs supérieures à zéro. Ou nous pourrions appliquer une contrainte de vérification à nos Pets tableau pour s'assurer que le DOB colonne n'est pas dans le futur.

Pour un exemple, voir Qu'est-ce qu'une contrainte CHECK ?

Espace blanc

Vous avez peut-être remarqué que mes exemples incluent des espaces. Par exemple, j'ai espacé le code sur plusieurs lignes, et j'ai utilisé des tabulations pour indenter les types de données, etc.

Ceci est parfaitement valable en SQL. Vous pouvez le faire en toute sécurité, et cela n'affectera pas le résultat. SQL vous permet de répartir votre code sur plusieurs lignes si vous le souhaitez, et il vous permet d'utiliser plusieurs espaces ou tabulations pour améliorer la lisibilité.

Commentaires

Vous pouvez également inclure des commentaires dans votre code. Les commentaires peuvent être utiles une fois que vous commencez à écrire des scripts SQL plus longs. Une fois qu'un script devient assez long, les commentaires peuvent faciliter l'identification rapide de ce que fait chaque partie.

Commentaires intégrés

Vous pouvez créer des commentaires en ligne en préfixant votre commentaire avec deux traits d'union (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

Dans cet exemple, les deux requêtes s'exécuteront sans aucun problème. Les commentaires seront ignorés par le SGBD.

Commentaires multilignes

Vous pouvez répartir les commentaires sur plusieurs lignes en entourant le commentaire de /* et */ :

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

Dans cet exemple, les deux requêtes s'exécuteront sans aucun problème. Les commentaires seront ignorés par le SGBD.

MySQL

Si vous utilisez MySQL, vous pouvez également utiliser le signe dièse/dièse (# ) pour les commentaires sur une seule ligne.

# This is a comment
SELECT * FROM Pets;

Code de commentaire

Un autre avantage intéressant des commentaires est que vous pouvez commenter code. Par exemple, si vous avez un long script SQL qui fait beaucoup de choses, mais que vous ne voulez en exécuter qu'une ou deux parties, vous pouvez commenter le reste du script.

Voici un exemple :

-- SELECT * FROM Pets;

SELECT * FROM Owners;

Dans ce cas, le premier SELECT déclaration a été commentée, et donc seul le second SELECT l'instruction sera exécutée.

Vous pouvez également utiliser des commentaires multilignes pour cette technique.

Insérer des données

Maintenant que nous avons créé trois tables et créé les clés étrangères appropriées, nous pouvons continuer et ajouter des données.

La façon la plus courante d'insérer des données dans SQL est avec le INSERT déclaration. Ça donne quelque chose comme ça :

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

Vous remplacez simplement MyTable avec le nom de la table dans laquelle vous insérez des données. De même, vous remplacez Column1 , etc avec les noms de colonne, et Value1 , etc avec les valeurs qui vont dans ces colonnes.

Par exemple, nous pourrions faire ceci :

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Chaque valeur est dans le même ordre que la colonne est spécifiée.

Notez que les noms de colonne correspondent aux noms que nous avons utilisés lors de la création de la table.

Vous pouvez omettre les noms de colonne si vous insérez des données dans toutes les colonnes. Nous pourrions donc modifier l'exemple ci-dessus pour qu'il ressemble à ceci :

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Pour ce didacticiel, nous allons ajouter quelques lignes supplémentaires, nous allons donc ajouter plus de INSERT INTO déclarations - une pour chaque ligne que nous voulons insérer.

Alors allons-y et remplissons nos tables.

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Notez que nous avons rempli le champ Pets table en dernier. Il y a une raison à cela.

Si nous avions essayé d'insérer des données dans le Pets table avant de remplir les deux autres, nous aurions reçu une erreur, due à notre contrainte de clé étrangère. Et pour une bonne raison. Après tout, nous aurions essayé d'insérer des valeurs dans les colonnes de clé étrangère qui n'existaient pas encore dans les colonnes de clé primaire des autres tables. C'est un gros "non non" quand il s'agit de clés étrangères.

Donc en renseignant les Owners et PetTypes tables d'abord, nous nous sommes assurés que les valeurs appropriées étaient déjà dans les colonnes de clé primaire avant de remplir les colonnes de clé étrangère dans le Pets tableau.

Voir SQL INSERT pour les débutants pour plus d'exemples d'insertion de données dans des tables.

Vérifiez nos données

Phew! Enfin, nous pouvons commencer à exécuter des requêtes sur notre base de données.

Vérifions les données dans toutes nos tables.

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

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       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

Parfait, il semble donc que les données ont été insérées avec succès.

Sélectionner des colonnes spécifiques

Il est généralement considéré comme une mauvaise pratique de sélectionner toutes les lignes et toutes les colonnes d'un tableau (comme nous l'avons fait dans l'exemple précédent), sauf si vous en avez vraiment besoin. Cela peut avoir un impact sur les performances de votre serveur de base de données, surtout s'il y a beaucoup de lignes dans la table.

Ce n'est pas un problème lorsque vous utilisez de petits ensembles de données comme nous sommes ici, ou si vous êtes dans un environnement de développement ou similaire. Sinon, il est généralement préférable de sélectionner uniquement les colonnes dont vous avez besoin.

Par conséquent, si nous voulions les identifiants, les noms et les dates de naissance de tous les animaux de compagnie, nous pourrions faire ceci :

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       |
+---------+-----------+------------+

Si nous voulions les identifiants et la date de naissance de tous les animaux nommés Fluffy, nous pourrions utiliser ceci :

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

Résultat :

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

Vous pouvez également utiliser le SELECT instruction pour renvoyer des données sans table. Autrement dit, il peut renvoyer des données qui ne sont pas stockées dans une table. Voir SQL SELECT Déclaration pour les débutants pour voir un exemple.

Trier

SQL fournit le ORDER BY clause qui nous permet de trier les données.

Nous pouvons ajouter un ORDER BY clause à notre exemple précédent pour que les animaux soient triés par leur nom :

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

Résultat :

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

Le ASC partie signifie ascendant . Lorsque vous utilisez le ORDER BY clause, elle est par défaut ascendante, vous pouvez donc omettre le ASC partie si vous le souhaitez.

Pour le trier en décroissant commande, utilisez DESC .

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

Résultat :

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Vous pouvez également trier les résultats en utilisant plusieurs colonnes. Il triera par la première colonne spécifiée, puis s'il y a des doublons dans cette colonne, il triera ces doublons par la deuxième colonne spécifiée, et ainsi de suite.

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

Résultat :

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Voyez comment les deux Fluffys ont échangé leur position.

Si vous n'utilisez pas le ORDER BY clause, il n'y a aucune garantie dans quel ordre vos résultats seront. Bien que cela puisse regarder comme votre base de données trie les résultats par une colonne particulière, cela peut ne pas être le cas. En général, sans ORDER BY clause, les données seront triées dans l'ordre dans lequel elles ont été chargées dans la table. Cependant, si des lignes ont été supprimées ou mises à jour, l'ordre sera affecté par la façon dont le SGBD réutilise l'espace de stockage récupéré.

Par conséquent, ne comptez pas sur le SGBD pour trier les résultats dans un ordre significatif.

Conclusion :si vous souhaitez que vos résultats soient triés, utilisez ORDER BY .

Voir SQL ORDER BY Clause pour les débutants pour plus d'exemples.

Compter les lignes dans un ensemble de résultats

Vous pouvez utiliser le COUNT() fonction d'agrégation pour compter les lignes qui seront renvoyées dans une requête.

SELECT COUNT(*) AS Count
FROM Pets;

Résultat :

+---------+
| Count   |
|---------|
| 8       |
+---------+

Cela nous indique qu'il y a 8 lignes dans le tableau. Nous le savons car nous avons sélectionné toutes les lignes et toutes les colonnes.

Vous pouvez utiliser COUNT() sur n'importe quelle requête, par exemple les requêtes qui utilisent un WHERE clause pour filtrer les résultats.

Vous pouvez également spécifier une colonne particulière à compter. Le COUNT() la fonction ne compte que les non-NULL résultats, donc si vous spécifiez une colonne qui contient NULL valeurs, ces valeurs ne seront pas comptées.

Voici un exemple pour illustrer ce que je veux dire.

SELECT COUNT(DOB) AS Count
FROM Pets;

Résultat :

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Vous vous souvenez peut-être que les Pets table contient deux NULL valeurs dans le DOB colonne (deux animaux n'ont pas fourni leur date de naissance), et donc COUNT(DOB) renvoie 6, au lieu de 8 lorsque nous utilisions COUNT(*) . La raison COUNT(*) renvoyé toutes les lignes, c'est parce que ces deux lignes l'ont fait avoir des données dans les autres colonnes.

Dans mon exemple, mon SGBD a également renvoyé un avertissement à ce sujet. Vous pouvez ou non recevoir un avertissement, selon votre SGBD et votre configuration spécifique.

Voir SQL COUNT pour les débutants pour plus d'exemples.

Les autres fonctions d'agrégat incluent :AVG() , SUM() , MIN() , et MAX() .

Grouper par

Une autre clause utile est le GROUP BY clause. Cela fait à peu près ce que son nom promet. Il vous permet de regrouper les résultats par une colonne donnée.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Résultat :

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

Dans cet exemple, nous comptons le nombre d'animaux que nous avons pour chaque type d'animal, puis nous le trions par ordre décroissant (avec le plus grand nombre en haut).

Voir SQL GROUP BY Clause pour les débutants pour plus d'exemples.

Le HAVING Article

Nous pouvons utiliser le HAVING clause pour filtrer les résultats dans le GROUP BY clause. Le HAVING La clause renvoie les lignes où les valeurs agrégées remplissent les conditions spécifiées.

Voici un exemple.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Résultat :

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

Dans ce cas, nous avons renvoyé des données uniquement pour les types d'animaux qui ont plus de 2 animaux assignés à ce type.

Voir SQL HAVING Clause pour les débutants pour plus d'exemples.

Joints

En SQL, une jointure est l'endroit où vous exécutez une requête qui combine les données de plusieurs tables.

Les deux exemples précédents sont corrects, mais ils seraient préférables s'ils renvoyaient les types d'animaux réels (par exemple, chat, chien, oiseau, etc.) plutôt que l'ID (par exemple, 1, 2, 3, etc.).

Le seul problème est que les Pets table ne contient pas ces données. Ces données sont dans les PetTypes tableau.

Heureusement pour nous, nous pouvons faire une jointure entre ces deux tables. Voici un exemple qui utilise un LEFT JOIN :

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       |
+-----------+---------+

Cet ensemble de résultats est beaucoup plus facile à lire que les précédents. Il est plus facile de comprendre combien de chaque type d'animal de compagnie se trouve dans le tableau.

La syntaxe utilise le type de jointure (dans ce cas LEFT JOIN ), suivi du premier tableau (de gauche), suivi de ON , suivi de la condition de jointure.

Utilisons un INNER JOIN pour renvoyer tous les noms d'animaux avec leurs types d'animaux respectifs.

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

Résultat :

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

Les jointures ouvrent vraiment nos options, car nous pouvons désormais récupérer des données de plusieurs tables et les présenter comme s'il s'agissait d'une seule table.

Vous remarquerez que dans les exemples de jointure, nous qualifions nos noms de colonne avec les noms de table. La raison pour laquelle nous faisons cela est d'éviter toute ambiguïté concernant les noms de colonne de colonne entre les tables. Les deux tables peuvent avoir des colonnes du même nom (comme dans notre exemple), et dans de tels cas, le SGBD ne saura pas à quelle colonne vous faites référence. Préfixer les noms de colonne avec leurs noms de table garantit que vous faites référence à la bonne colonne et évite toute erreur pouvant résulter d'une ambiguïté sur la colonne à laquelle vous faites référence.

Voir mon didacticiel sur les jointures SQL pour plus d'exemples et une explication des différents types de jointure.

Alias

Nous pouvons aller plus loin et attribuer un alias à chaque nom de table et nom de colonne.

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Résultat :

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

Cela a abouti à de nouveaux en-têtes de colonne, et le code est plus concis.

Un alias permet d'attribuer temporairement un autre nom à une table ou une colonne pendant la durée d'un SELECT requête. Cela peut être particulièrement utile lorsque les tables et/ou les colonnes ont des noms très longs ou complexes.

Un alias est attribué via l'utilisation de AS mot-clé, bien que ce mot-clé soit facultatif, vous pouvez donc l'omettre en toute sécurité. Notez qu'Oracle ne prend pas en charge le AS mot clé sur les alias de table (mais c'est le cas sur les alias de colonne).

Dans l'exemple ci-dessus, j'ai inclus le AS mot-clé lors de l'attribution des alias de colonne, mais l'a omis lors de l'attribution des alias de table.

Un nom d'alias peut être n'importe quoi, mais il est généralement court pour des raisons de lisibilité.

Dans notre cas, nous avons changé les deux tables en p et pt , et les noms de colonne à Pet et PetType . Notez que j'ai entouré PetType entre guillemets doubles. Je l'ai fait, car il y a un espace dans le nom. Pour les alias sans espaces, vous n'avez pas besoin de le faire. Dans SQL Server, vous pouvez également utiliser des crochets ([] ) au lieu des guillemets doubles (bien qu'il prenne également en charge les guillemets doubles).

La pratique consistant à utiliser des espaces dans les colonnes et les alias est généralement déconseillée, car elle peut entraîner toutes sortes de problèmes avec certaines applications clientes.

Notez que nous devions toujours utiliser les noms de colonne complets lors de leur référencement dans la jointure (après le ON mot-clé).

Je dois souligner que l'attribution d'un alias ne renomme pas réellement la colonne ou la table.

Voir Explication des alias SQL pour plus d'exemples.

Mise à jour des données

Vous pouvez utiliser la UPDATE pour mettre à jour les données de vos tables.

La syntaxe de base est assez simple :

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

Dans cet exemple, nous mettons à jour le LastName colonne pour avoir une nouvelle valeur de Stallone où le OwnerId est 3 .

Pour mettre à jour plusieurs colonnes, utilisez une virgule pour séparer chaque paire colonne/valeur.

But whatever you do, don’t forget the WHERE clause (unless you actually intend to update every row in the table with the same value).

See SQL UPDATE for Beginners for more examples and a more detailed explanation.

Deleting Data

You can use the DELETE statement to delete data from your tables.

The basic syntax is even more simple than the UPDATE déclaration :

DELETE FROM Owners
WHERE OwnerId = 5;

Here, we’re deleting owner number 5 from the Owners tableau.

As with the UPDATE statement, don’t forget the WHERE clause (unless you intend to delete every row in the table ).

See SQL DELETE for Beginners for more examples and a detailed explanation.

Dropping Objects

While we’re on the subject of deleting things, when you delete a database object (such as a table, view, stored procedure, etc), it’s said that you “drop” that object. For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:

DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

Opérateurs SQL

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. Les éléments de données sont appelés opérandes ou arguments . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ). We also ran a query that used the Greater Than operator (> ). These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables .

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW syntaxe.

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

Résultat :

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY clause.

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

Résultat :

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE déclaration. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL déclaration.

EXEC uspGetPetById @PetId = 3;

Résultat :

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE , or DELETE déclarations.

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

• Create a DML Trigger in SQL Server
• Create a “last modified” column
• Automatically send an email when someone tries to delete a record
• Update a column’s value whenever another column is updated
• Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION 

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

• SQL Server String Functions
• SQL Server Mathematical Functions
• SQL Server Date &Time Functions

MySQL

• MySQL String Functions
• MySQL Mathematical Functions

PostgreSQL

• PostgreSQL Date &Time Functions
• PostgreSQL Math Functions

SQLite

• SQLite Aggregate Functions
• SQLite Date &Time Functions