Français

Bases de MySQL

Base de données MySQL

Utilisateurs MySQL

Tables MySQL

Requêtes MySQL

MySQL Vues

Indexes MySQL

Opérateurs et clauses MySQL

Jointures MySQL

Clés MySQL

Déclencheurs MySQL

Types de données MySQL

MySQL Expressions régulières

Recherche fulltext MySQL

Fonctions et Opérateurs MySQL

Concepts Divers de MySQL

Ressources Utiles MySQL

MySQL - Référence des Instructions

Bienvenue, futurs mage de la base de données ! Aujourd'hui, nous plongeons dans le monde magique des instructions MySQL. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - d'ici la fin de ce tutoriel, vous invoquerez des sorts de base de données comme un pro !

MySQL - Statements Reference

Instructions de Définition de Données

Commençons par les briques de notre royaume de base de données : les Instructions de Définition de Données. Ce sont les commandes que nous utilisons pour créer, modifier et supprimer la structure de notre base de données.

CREATE TABLE

Imaginez que vous construisez une bibliothèque. La première chose dont vous avez besoin, ce sont des étagères, n'est-ce pas ? En MySQL, nos "étagères" sont des tables. Créons-en une !

CREATE TABLE books (
id INT PRIMARY KEY AUTO_INCREMENT,
title VARCHAR(100) NOT NULL,
author VARCHAR(50),
publication_year INT
);

Cette incantation... je veux dire, instruction, crée une table appelée "books" avec quatre colonnes :

  • id : Un identifiant unique pour chaque livre
  • title : Le titre du livre (jusqu'à 100 caractères)
  • author : L'auteur du livre (jusqu'à 50 caractères)
  • publication_year : L'année de publication du livre

ALTER TABLE

Oups ! Nous avons oublié d'ajouter une colonne pour le genre du livre. Pas de souci, nous pouvons modifier notre table :

ALTER TABLE books
ADD COLUMN genre VARCHAR(30);

Cela ajoute une nouvelle colonne appelée "genre" à notre table "books".

DROP TABLE

Si nous décidons que nous n'avons plus besoin de notre table (peut-être que nous passons aux ebooks ?), nous pouvons la supprimer :

DROP TABLE books;

Soyez prudent avec celui-ci, cependant ! C'est comme mettre le feu à votre étagère - il n'y a pas de retour en arrière !

Instructions de Manipulation de Données

Maintenant que nous avons notre structure, mettons-y des données !

INSERT

Il est temps d'ajouter des livres à notre bibliothèque :

INSERT INTO books (title, author, publication_year, genre)
VALUES ('Gatsby le Magnifique', 'F. Scott Fitzgerald', 1925, 'Classique');

Cela ajoute un livre à notre table. Vous pouvez ajouter plusieurs livres en une seule fois :

INSERT INTO books (title, author, publication_year, genre)
VALUES
('Ne tirez pas sur l'oiseau moqueur', 'Harper Lee', 1960, 'Roman'),
('1984', 'George Orwell', 1949, 'Science Fiction');

SELECT

Voyons maintenant quels livres nous avons :

SELECT * FROM books;

Cela récupère toutes les colonnes (*) de la table "books". Vous pouvez être plus précis :

SELECT title, author FROM books WHERE publication_year < 1950;

Cela récupère uniquement le titre et l'auteur des livres publiés avant 1950.

UPDATE

Oups, nous avons fait une erreur ! "1984" est en fait de la science-fiction dystopique :

UPDATE books
SET genre = 'Science Fiction Dystopique'
WHERE title = '1984';

Cela change le genre pour le livre intitulé "1984".

DELETE

Disons que nous voulons supprimer tous les livres publiés avant 1930 :

DELETE FROM books
WHERE publication_year < 1930;

Soyez prudent avec DELETE - comme DROP, c'est définitif !

Instructions Transactionnelles et de Verrouillage

Parfois, nous devons nous assurer qu'une série d'opérations se produit toutes en une fois, ou pas du tout. C'est là que les transactions entrent en jeu.

START TRANSACTION

START TRANSACTION;
INSERT INTO books (title, author, publication_year, genre)
VALUES ('Orgueil et Préjugés', 'Jane Austen', 1813, 'Roman');
UPDATE books SET publication_year = 1960 WHERE title = 'Ne tirez pas sur l'oiseau moqueur';
COMMIT;

Cela garantit que l'INSERT et l'UPDATE se produisent ensemble. Si une erreur se produit, ni l'un ni l'autre n'auront d'effet.

ROLLBACK

Si nous changeons d'avis au milieu d'une transaction :

START TRANSACTION;
DELETE FROM books WHERE publication_year < 1900;
-- Oups, nous ne voulions pas faire cela !
ROLLBACK;

ROLLBACK annule toutes les modifications apportées depuis START TRANSACTION.

Instructions Préparées

Les instructions préparées sont comme des recettes - vous les configurez une fois, puis vous les utilisez plusieurs fois avec différents ingrédients.

PREPARE stmt FROM 'SELECT * FROM books WHERE author = ?';
SET @a = 'George Orwell';
EXECUTE stmt USING @a;

Cela prépare une instruction pour trouver des livres par un auteur spécifique, puis l'exécute pour George Orwell.

Instructions Composées

Les instructions composées nous permettent de regrouper plusieurs instructions ensemble. Elles sont souvent utilisées dans les procédures stockées et les fonctions.

DELIMITER //
CREATE PROCEDURE CountBooks()
BEGIN
DECLARE bookCount INT;
SELECT COUNT(*) INTO bookCount FROM books;
SELECT CONCAT('Il y a ', bookCount, ' livres dans la bibliothèque.') AS Message;
END //
DELIMITER ;

CALL CountBooks();

Cette procédure compte les livres et affiche un message.

Variables dans les Programmes Stockés

Les variables dans les programmes stockés sont comme des boîtes où nous pouvons stocker des informations temporairement.

DELIMITER //
CREATE PROCEDURE OldestBook()
BEGIN
DECLARE oldestYear INT;
DECLARE oldestTitle VARCHAR(100);

SELECT MIN(publication_year), title
INTO oldestYear, oldestTitle
FROM books;

SELECT CONCAT('Le plus ancien livre est ', oldestTitle, ' publié en ', oldestYear) AS Message;
END //
DELIMITER ;

CALL OldestBook();

Cette procédure trouve le plus ancien livre et nous en informe.

Instructions de Contrôle de Flux MySQL

Les instructions de contrôle de flux nous aident à prendre des décisions dans notre code.

DELIMITER //
CREATE PROCEDURE CategoryByYear(IN pub_year INT)
BEGIN
DECLARE category VARCHAR(20);
IF pub_year < 1900 THEN
SET category = 'Très Ancien';
ELSEIF pub_year < 2000 THEN
SET category = 'Classique';
ELSE
SET category = 'Moderne';
END IF;
SELECT category AS 'Catégorie du Livre';
END //
DELIMITER ;

CALL CategoryByYear(1925);

Cela catégorise un livre en fonction de son année de publication.

Instructions de Curseurs MySQL

Les curseurs nous permettent d'itérer à travers un jeu de résultats une ligne à la fois.

DELIMITER //
CREATE PROCEDURE ListBooks()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE book_title VARCHAR(100);
DECLARE cur CURSOR FOR SELECT title FROM books;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

OPEN cur;

read_loop: LOOP
FETCH cur INTO book_title;
IF done THEN
LEAVE read_loop;
END IF;
SELECT book_title;
END LOOP;

CLOSE cur;
END //
DELIMITER ;

CALL ListBooks();

Cette procédure liste tous les titres de livres un par un.

Instructions de Gestion des Conditions MySQL

Les gestionnaires de conditions nous permettent de gérer les erreurs et les avertissements avec grâce.

DELIMITER //
CREATE PROCEDURE SafeInsert(IN book_title VARCHAR(100), IN book_author VARCHAR(50))
BEGIN
DECLARE EXIT HANDLER FOR 1062
BEGIN
SELECT 'Erreur : Entrée en double' AS Message;
END;

INSERT INTO books (title, author) VALUES (book_title, book_author);
SELECT 'Livre ajouté avec succès' AS Message;
END //
DELIMITER ;

CALL SafeInsert('Gatsby le Magnifique', 'F. Scott Fitzgerald');

Cette procédure ajoute un livre en toute sécurité, en gérant le cas où le livre pourrait déjà exister.

Et voilà ! Vous avez appena fait vos premiers pas dans le monde des instructions MySQL. Souvenez-vous, la pratique fait la maîtresse, donc n'ayez pas peur d'expérimenter avec ces commandes. Avant de savoir, vous gérerez les bases de données comme un pro !

Credits: Image by storyset

Tutoriel précédent:
MySQL - Fonctions Utiles