Exercice

Soit le schéma relationnel suivant:

CREATE TABLE Livres (
    LivreID INT AUTO_INCREMENT PRIMARY KEY,
    Titre VARCHAR(255),
    ISBN VARCHAR(13),
    AnneePublication INT,
    Prix DECIMAL(10, 2),
    CategorieID INT,
    FOREIGN KEY (CategorieID) REFERENCES Categories(CategorieID)
);

CREATE TABLE Auteurs (
    AuteurID INT AUTO_INCREMENT PRIMARY KEY,
    NomAuteur VARCHAR(255),
    Nationalite VARCHAR(255)
);

CREATE TABLE Categories (
    CategorieID INT AUTO_INCREMENT PRIMARY KEY,
    NomCategorie VARCHAR(255)
);


CREATE TABLE Emprunts (
    EmpruntID INT AUTO_INCREMENT PRIMARY KEY,
    ClientID INT,
    LivreID INT,
    DateEmprunt DATE,
    DateRetourPrevue DATE,
    FOREIGN KEY (ClientID) REFERENCES Clients(ClientID),
    FOREIGN KEY (LivreID) REFERENCES Livres(LivreID)
);

Questions & Réponse

Fonction stockée pour récupérer les détails d'un livre par son ID :

DELIMITER //
CREATE FUNCTION GetBookDetails(BookID INT) RETURNS VARCHAR(255)
BEGIN
    DECLARE detailsBook VARCHAR(255);
    SELECT contact('titre :',Titre,'\n ISB: ',ISBN,'\n Annee ',AnneePublication,'\Prix ',Prix,'\Categorie ',CategorieID) INTO detailsBook FROM Livres WHERE LivreID = BookID;
    RETURN detailsBook;
END;
//
DELIMITER ;

Fonction stockée pour calculer le nombre total de livres empruntés par un client donné :

DELIMITER //
CREATE FUNCTION GetTotalBooksBorrowed(ClientID INT) RETURNS INT
BEGIN
    DECLARE TotalBooks INT;
    SELECT COUNT(*) INTO TotalBooks FROM Emprunts WHERE ClientID = ClientID;
    RETURN TotalBooks;
END;
//
DELIMITER ;

Fonction stockée pour récupérer la liste des livres écrits par un auteur spécifique :

DELIMITER //
CREATE FUNCTION GetBooksByAuthor(AuthorName VARCHAR(255)) RETURNS VARCHAR(4000)
BEGIN
    DECLARE BookList VARCHAR(4000);
    SELECT GROUP_CONCAT(Titre SEPARATOR ', ') INTO BookList
    FROM Livres
    WHERE AuteurID = (SELECT AuteurID FROM Auteurs WHERE NomAuteur = AuthorName);
    RETURN BookList;
END;
//
DELIMITER ;

Fonction stockée pour obtenir le nombre total de livres dans une catégorie donnée :

DELIMITER //
CREATE FUNCTION GetTotalBooksInCategory(CategoryName VARCHAR(255)) RETURNS INT
BEGIN
    DECLARE TotalCategoryBooks INT;
    SELECT COUNT(*) INTO TotalCategoryBooks
    FROM Livres
    WHERE CategorieID = (SELECT CategorieID FROM Categories WHERE NomCategorie = CategoryName);
    RETURN TotalCategoryBooks;
END;
//
DELIMITER ;

Fonction stockée pour déterminer si un livre est actuellement emprunté ou disponible :

DELIMITER //
CREATE FUNCTION IsBookAvailable(BookID INT) RETURNS VARCHAR(15)
BEGIN
    DECLARE BookStatus VARCHAR(15);
    IF (EXISTS (SELECT 1 FROM Emprunts WHERE LivreID = BookID)) THEN
        SET BookStatus = 'Emprunté';
    ELSE
        SET BookStatus = 'Disponible';
    END IF;
    RETURN BookStatus;
END;
//
DELIMITER ;

Procédure stockée pour ajouter un nouvel livre à la base de données :

DELIMITER //
CREATE PROCEDURE AddNewBook(IN p_Title VARCHAR(255), IN p_ISBN VARCHAR(13), IN p_AuteurID INT, IN p_AnneePublication INT, IN p_Prix DECIMAL(10, 2), IN p_CategorieID INT)
BEGIN
    INSERT INTO Livres (Titre, ISBN, AuteurID, AnneePublication, Prix, CategorieID)
    VALUES (p_Title, p_ISBN, p_AuteurID, p_AnneePublication, p_Prix, p_CategorieID);
END;
//
DELIMITER ;

Procédure stockée pour mettre à jour les détails d'un livre :

DELIMITER //
CREATE PROCEDURE UpdateBookDetails(IN p_BookID INT, IN p_NewTitle VARCHAR(255), IN p_NewPrice DECIMAL(10, 2))
BEGIN
    UPDATE Livres
    SET Titre = p_NewTitle, Prix = p_NewPrice
    WHERE LivreID = p_BookID;
END;
//
DELIMITER ;

Procédure stockée pour supprimer un livre de la base de données :

DELIMITER //
CREATE PROCEDURE DeleteBook(IN p_BookID INT)
BEGIN
    DELETE FROM Livres WHERE LivreID = p_BookID;
END;
//
DELIMITER ;

Procédure stockée pour enregistrer un nouvel emprunt de livre par un client :

DELIMITER //
CREATE PROCEDURE BorrowBook(IN p_ClientID INT, IN p_BookID INT, IN p_DueDate DATE)
BEGIN
    INSERT INTO Emprunts (ClientID, LivreID, DateEmprunt, DateRetourPrevue)
    VALUES (p_ClientID, p_BookID, CURDATE(), p_DueDate);
END;
//
DELIMITER ;

Procédure stockée pour vérifier la disponibilité d'un livre et mettre à jour son statut :

DELIMITER //
CREATE PROCEDURE CheckAndUpdateBookStatus(IN p_BookID INT)
BEGIN
    DECLARE BookStatus VARCHAR(15);
    
    IF (EXISTS (SELECT 1 FROM Emprunts WHERE LivreID = p_BookID)) THEN
        SET BookStatus = 'Emprunté';
    ELSE
        SET BookStatus = 'Disponible';
    END IF;

    UPDATE Livres
    SET Statut = BookStatus
    WHERE LivreID = p_BookID;
END;
//
DELIMITER ;

une fonction stockée qui utilise un curseur pour calculer une valeur basée sur des données de la table, mais gardez à l'esprit que cette utilisation n'est pas courante pour une fonction stockée. Cette fonction renvoie la somme des prix de tous les livres dans la table "Livres" :

DELIMITER //
CREATE FUNCTION CalculateTotalBookPrice() RETURNS DECIMAL(10, 2)
BEGIN
    DECLARE TotalPrice DECIMAL(10, 2);
    DECLARE BookPrice DECIMAL(10, 2);

    DECLARE cur CURSOR FOR
        SELECT Prix FROM Livres;

    SET TotalPrice = 0;

    OPEN cur;
    FETCH NEXT FROM cur INTO BookPrice;

    WHILE @@FETCH_STATUS = 0 DO
        SET TotalPrice = TotalPrice + BookPrice;
        FETCH NEXT FROM cur INTO BookPrice;
    END WHILE;

    CLOSE cur;

    RETURN TotalPrice;
END;
//
DELIMITER ;

Dans cet exemple, nous utilisons un curseur pour parcourir les prix de tous les livres dans la table "Livres" et calculer la somme totale de ces prix. La fonction renvoie ensuite cette somme totale. Encore une fois, il est important de noter que les fonctions stockées ne sont généralement pas conçues pour utiliser des curseurs, mais plutôt pour effectuer des opérations sur les données et retourner une seule valeur. Les procédures stockées sont plus appropriées pour l'utilisation de curseurs dans MySQL.

un exemple supplémentaire qui calcule le nombre de livres dans une catégorie spécifique en utilisant un curseur :

DELIMITER //
CREATE FUNCTION CountBooksInCategory(CategoryName VARCHAR(255)) RETURNS INT
BEGIN
    DECLARE CategoryID INT;
    DECLARE BookCount INT;

    -- Obtient l'ID de la catégorie à partir du nom
    SELECT CategorieID INTO CategoryID
    FROM Categories
    WHERE NomCategorie = CategoryName;

    -- Déclare un curseur pour compter les livres de la catégorie
    DECLARE cur CURSOR FOR
        SELECT COUNT(*) AS BookCount
        FROM Livres
        WHERE CategorieID = CategoryID;

    OPEN cur;
    FETCH NEXT FROM cur INTO BookCount;
    CLOSE cur;

    RETURN BookCount;
END;
//
DELIMITER ;

Dans cet exemple, la fonction stockée prend en entrée le nom d'une catégorie de livres, obtient l'ID de cette catégorie, puis utilise un curseur pour compter le nombre de livres dans cette catégorie. La fonction renvoie le nombre total de livres dans la catégorie spécifiée.

créer une fonction stockée qui utilise un curseur pour obtenir une liste de tous les livres d'un auteur spécifique :

DELIMITER //
CREATE FUNCTION GetBooksByAuthorName(AuthorName VARCHAR(255)) RETURNS TEXT
BEGIN
    DECLARE BookList TEXT;
    DECLARE Done INT DEFAULT 0;
    DECLARE BookTitle VARCHAR(255);

    DECLARE cur CURSOR FOR
        SELECT Titre FROM Livres
        WHERE AuteurID = (SELECT AuteurID FROM Auteurs WHERE NomAuteur = AuthorName);

    DECLARE CONTINUE HANDLER FOR NOT FOUND SET Done = 1;

    SET BookList = '';

    OPEN cur;

    read_loop: LOOP
        FETCH cur INTO BookTitle;
        IF Done = 1 THEN
            LEAVE read_loop;
        END IF;
        SET BookList = CONCAT(BookList, BookTitle, ', ');
    END LOOP;

    CLOSE cur;

    -- Supprime la dernière virgule et l'espace en trop
    SET BookList = LEFT(BookList, LENGTH(BookList) - 2);

    RETURN BookList;
END;
//
DELIMITER ;

Dans cet exemple, la fonction stockée prend en entrée le nom d'un auteur, utilise un curseur pour récupérer les titres des livres écrits par cet auteur, puis retourne une chaîne de texte contenant la liste des titres de ces livres. La chaîne est construite à l'aide du curseur, puis renvoyée comme résultat de la fonction.

Procédure stockée pour lister tous les livres d'une catégorie spécifique :

DELIMITER //
CREATE PROCEDURE ListBooksInCategory(IN CategoryName VARCHAR(255))
BEGIN
    DECLARE BookTitle VARCHAR(255);
    DECLARE cur CURSOR FOR
        SELECT Titre FROM Livres
        WHERE CategorieID = (SELECT CategorieID FROM Categories WHERE NomCategorie = CategoryName);

    OPEN cur;
    FETCH cur INTO BookTitle;

    WHILE @@FETCH_STATUS = 0 DO
        SELECT BookTitle AS 'Livre';
        FETCH cur INTO BookTitle;
    END WHILE;

    CLOSE cur;
END;
//
DELIMITER ;

Procédure stockée pour lister tous les auteurs et le nombre de livres qu'ils ont écrits :

DELIMITER //
CREATE PROCEDURE ListAuthorsWithBookCount()
BEGIN
    DECLARE AuthorName VARCHAR(255);
    DECLARE BookCount INT;
    DECLARE cur CURSOR FOR
        SELECT NomAuteur, COUNT(*) AS LivresEcrits
        FROM Auteurs
        JOIN Livres ON Auteurs.AuteurID = Livres.AuteurID
        GROUP BY Auteurs.AuteurID;

    OPEN cur;
    FETCH cur INTO AuthorName, BookCount;

    WHILE @@FETCH_STATUS = 0 DO
        SELECT AuthorName AS 'Auteur', BookCount AS 'Livres écrits';
        FETCH cur INTO AuthorName, BookCount;
    END WHILE;

    CLOSE cur;
END;
//
DELIMITER ;

Procédure stockée pour lister tous les clients ayant emprunté des livres et le nombre d'emprunts :

DELIMITER //
CREATE PROCEDURE ListClientsWithLoanCount()
BEGIN
    DECLARE ClientName VARCHAR(255);
    DECLARE LoanCount INT;
    DECLARE cur CURSOR FOR
        SELECT clients.nom, COUNT(*) AS Emprunts
        FROM clients
        JOIN emprunts ON clients.clientID = emprunts.clientID
        GROUP BY clients.clientID;

    OPEN cur;
    FETCH cur INTO ClientName, LoanCount;

    WHILE @@FETCH_STATUS = 0 DO
        SELECT ClientName AS 'Client', LoanCount AS 'Emprunts';
        FETCH cur INTO ClientName, LoanCount;
    END WHILE;

    CLOSE cur;
END;
//
DELIMITER ;

Procédure stockée pour afficher les livres empruntés par un client spécifique :

DELIMITER //
CREATE PROCEDURE ListBooksBorrowedByClient(IN ClientID INT)
BEGIN
    DECLARE BookTitle VARCHAR(255);
    DECLARE cur CURSOR FOR
        SELECT Titre FROM Livres
        WHERE LivreID IN (SELECT LivreID FROM Emprunts WHERE ClientID = ClientID);

    OPEN cur;
    FETCH cur INTO BookTitle;

    WHILE @@FETCH_STATUS = 0 DO
        SELECT BookTitle AS 'Livre emprunté';
        FETCH cur INTO BookTitle;
    END WHILE;

    CLOSE cur;
END;
//
DELIMITER ;

Procédure stockée pour lister tous les livres avec leur statut (disponible ou emprunté) :

DELIMITER //
CREATE PROCEDURE ListBooksStatus()
BEGIN
    DECLARE BookTitle VARCHAR(255);
    DECLARE BookStatus VARCHAR(15);
    DECLARE cur CURSOR FOR
        SELECT Titre, IF(EXISTS (SELECT 1 FROM Emprunts WHERE LivreID = Livres.LivreID), 'Emprunté', 'Disponible') AS Statut
        FROM Livres;

    OPEN cur;
    FETCH cur INTO BookTitle, BookStatus;

    WHILE @@FETCH_STATUS = 0 DO
        SELECT BookTitle AS 'Livre', BookStatus AS 'Statut';
        FETCH cur INTO BookTitle, BookStatus;
    END WHILE;

    CLOSE cur;
END;
//
DELIMITER ;

créer uneprocédure stockée qui utilise une boucle "WHILE" pour calculer la somme des prix de tous les livres dans une catégorie donnée :

DELIMITER //
CREATE PROCEDURE CalculateTotalPriceInCategory(IN CategoryName VARCHAR(255), OUT Total DECIMAL(10, 2))
BEGIN
    DECLARE Done INT DEFAULT 0;
    DECLARE CurrentPrice DECIMAL(10, 2);
    DECLARE CategoryID INT;
    
    -- Obtient l'ID de la catégorie à partir du nom
    SELECT CategorieID INTO CategoryID
    FROM Categories
    WHERE NomCategorie = CategoryName;
    
    DECLARE cur CURSOR FOR
        SELECT Prix FROM Livres
        WHERE CategorieID = CategoryID;
    
    OPEN cur;
    FETCH cur INTO CurrentPrice;
    
    SET Total = 0;
    
    WHILE @@FETCH_STATUS = 0 DO
        SET Total = Total + CurrentPrice;
        FETCH cur INTO CurrentPrice;
    END WHILE;
    
    CLOSE cur;
END;
//
DELIMITER ;

Cette procédure stockée calcule la somme des prix de tous les livres dans une catégorie donnée en utilisant une boucle "WHILE" avec un curseur. La somme est stockée dans la variable "Total" et renvoyée en tant que paramètre OUT.

créer une procédure stockée utilisant une boucle "REPEAT" pour afficher une liste de livres empruntés par un client donné :

DELIMITER //
CREATE PROCEDURE ListBorrowedBooks(IN ClientID INT)
BEGIN
    DECLARE Done INT DEFAULT 0;
    DECLARE BookTitle VARCHAR(255);
    DECLARE BookStatus VARCHAR(15);
    
    DECLARE cur CURSOR FOR
        SELECT Titre, IF(EXISTS (SELECT 1 FROM Emprunts WHERE LivreID = Livres.LivreID AND ClientID = ClientID), 'Emprunté', 'Disponible') AS Statut
        FROM Livres;
    
    OPEN cur;
    
    REPEAT
        FETCH cur INTO BookTitle, BookStatus;
        
        IF NOT Done THEN
            SELECT BookTitle AS 'Livre', BookStatus AS 'Statut';
        END IF;
        
        UNTIL Done
    END REPEAT;
    
    CLOSE cur;
END;
//
DELIMITER ;

Dans cette procédure stockée, nous utilisons une boucle "REPEAT" avec un curseur pour parcourir tous les livres et afficher leur titre et leur statut (emprunté ou disponible) pour un client donné. La boucle "REPEAT" permet de continuer à récupérer les résultats du curseur jusqu'à ce que la variable "Done" soit définie comme "TRUE".

Trigger pour mettre à jour la date de retour prévue lors de l'insertion d'un nouvel emprunt :

DELIMITER //
CREATE TRIGGER UpdateDueDateOnNewLoan
BEFORE INSERT ON Emprunts
FOR EACH ROW
BEGIN
    SET NEW.DateRetourPrevue = DATE_ADD(NEW.DateEmprunt, INTERVAL 14 DAY);
END;
//
DELIMITER ;

Ce trigger met à jour la date de retour prévue en ajoutant automatiquement 14 jours à la date d'emprunt lorsque de nouveaux emprunts sont insérés.

Trigger pour mettre à jour le nombre de livres écrits par un auteur lorsque de nouveaux livres sont insérés :

DELIMITER //
CREATE TRIGGER UpdateBookCountOnNewBook
AFTER INSERT ON Livres
FOR EACH ROW
BEGIN
    UPDATE Auteurs
    SET LivresEcrits = LivresEcrits + 1
    WHERE Auteurs.AuteurID = NEW.AuteurID;
END;
//
DELIMITER ;

Ce trigger met à jour le nombre de livres écrits par un auteur chaque fois qu'un nouveau livre est inséré.

Trigger pour vérifier la disponibilité d'un livre lors de sa mise à jour :

DELIMITER //
CREATE TRIGGER CheckBookAvailabilityOnUpdate
BEFORE UPDATE ON Livres
FOR EACH ROW
BEGIN
    IF NEW.QuantiteStock < 0 THEN
        SIGNAL SQLSTATE '45000'
        SET MESSAGE_TEXT = 'La quantité en stock ne peut pas être négative.';
    END IF;
END;
//
DELIMITER ;

Ce trigger vérifie que la quantité en stock d'un livre ne devient jamais négative lors de sa mise à jour.

Trigger pour supprimer les emprunts liés à un livre lors de sa suppression :

DELIMITER //
CREATE TRIGGER DeleteRelatedLoansOnBookDeletion
AFTER DELETE ON Livres
FOR EACH ROW
BEGIN
    DELETE FROM Emprunts WHERE Emprunts.LivreID = OLD.LivreID;
END;
//
DELIMITER ;

Ce trigger supprime automatiquement les emprunts liés à un livre lorsque ce livre est supprimé de la base de données.

Trigger pour générer un journal d'audit des mises à jour de livres :

DELIMITER //
CREATE TRIGGER BookUpdateAudit
AFTER UPDATE ON Livres
FOR EACH ROW
BEGIN
    INSERT INTO LivresAudit (LivreID, ChampModifie, ValeurAvant, ValeurApres, DateModification)
    VALUES (OLD.LivreID, 'Prix', OLD.Prix, NEW.Prix, NOW());
    INSERT INTO LivresAudit (LivreID, ChampModifie, ValeurAvant, ValeurApres, DateModification)
    VALUES (OLD.LivreID, 'QuantiteStock', OLD.QuantiteStock, NEW.QuantiteStock, NOW());
END;
//
DELIMITER ;

Ce trigger génère un journal d'audit des mises à jour de prix et de quantité en stock des livres, en enregistrant les anciennes et nouvelles valeurs ainsi que la date de la modification.

Trigger pour marquer un emprunt comme en retard lorsque la date de retour prévue est dépassée :

DELIMITER //
CREATE TRIGGER MarkLoanAsLate
BEFORE INSERT ON Emprunts
FOR EACH ROW
BEGIN
    IF NEW.DateRetourPrevue < NOW() THEN
        SET NEW.EstEnRetard = 1;
    ELSE
        SET NEW.EstEnRetard = 0;
    END IF;
END;
//
DELIMITER ;

Ce trigger examine la date de retour prévue d'un nouvel emprunt et marque l'emprunt comme étant en retard s'il est soumis après la date de retour prévue.

Trigger pour suivre les modifications de la quantité en stock d'un livre dans un journal :

DELIMITER //
CREATE TRIGGER StockChangeJournal
AFTER UPDATE ON Livres
FOR EACH ROW
BEGIN
    IF OLD.QuantiteStock <> NEW.QuantiteStock THEN
        INSERT INTO StockChangeHistory (LivreID, AncienneQuantite, NouvelleQuantite, DateModification)
        VALUES (OLD.LivreID, OLD.QuantiteStock, NEW.QuantiteStock, NOW());
    END IF;
END;
//
DELIMITER ;

Ce trigger enregistre dans un journal toutes les modifications de la quantité en stock d'un livre, enregistrant l'ancienne et la nouvelle quantité, ainsi que la date de modification.

Trigger pour interdire la suppression d'une catégorie si des livres sont associés à cette catégorie :

DELIMITER //
CREATE TRIGGER PreventCategoryDeletion
BEFORE DELETE ON Categories
FOR EACH ROW
BEGIN
    DECLARE BookCount INT;
    SELECT COUNT(*) INTO BookCount FROM Livres WHERE CategorieID = OLD.CategorieID;
    IF BookCount > 0 THEN
        SIGNAL SQLSTATE '45000'
        SET MESSAGE_TEXT = 'La catégorie contient des livres et ne peut pas être supprimée.';
    END IF;
END;
//
DELIMITER ;

Ce trigger empêche la suppression d'une catégorie si des livres sont associés à cette catégorie en vérifiant le nombre de livres associés et en émettant une erreur si nécessaire.

pour créer un utilisateur nommé "utilisateur1" avec un mot de passe, vous pouvez exécuter la commande suivante :


 CREATE USER 'utilisateur1'@'localhost' IDENTIFIED BY 'motdepasse';

Attribution de privilèges :
Une fois que l'utilisateur est créé, vous pouvez lui accorder des privilèges sur des bases de données, des tables ou d'autres objets. Vous pouvez utiliser la commande GRANT pour cela. Voici un exemple pour accorder à l'utilisateur "utilisateur1" le privilège SELECT sur la base de données "ma_base" :

GRANT SELECT ON ma_base.* TO 'utilisateur1'@'localhost';

Révocation de privilèges :
Si vous souhaitez révoquer un privilège précédemment accordé, vous pouvez utiliser la commande REVOKE. Par exemple, pour révoquer le privilège SELECT de l'utilisateur "utilisateur1" sur la base de données "ma_base", vous pouvez exécuter la commande suivante :

REVOKE SELECT ON ma_base.* FROM 'utilisateur1'@'localhost';

Création de rôles :
Les rôles sont des groupes de privilèges que vous pouvez attribuer à un ou plusieurs utilisateurs. Pour créer un rôle, vous pouvez utiliser la commande CREATE ROLE. Voici un exemple de création d'un rôle "lecteur" :

CREATE ROLE lecteur;

Attribution de privilèges à un rôle :
Vous pouvez attribuer des privilèges à un rôle de la même manière que pour un utilisateur. Par exemple, pour attribuer le privilège SELECT à un rôle "lecteur" sur la base de données "ma_base", vous pouvez utiliser la commande GRANT :

GRANT SELECT ON ma_base.* TO lecteur;

Attribution de rôles à des utilisateurs :
Une fois que vous avez créé un rôle et attribué des privilèges à ce rôle, vous pouvez attribuer ce rôle à un utilisateur. Par exemple, pour attribuer le rôle "lecteur" à l'utilisateur "utilisateur1", vous pouvez utiliser la commande GRANT :

GRANT lecteur TO 'utilisateur1'@'localhost';

Révocation de rôles :
Pour révoquer un rôle d'un utilisateur, vous pouvez utiliser la commande REVOKE. Par exemple, pour révoquer le rôle "lecteur" de l'utilisateur "utilisateur1", vous pouvez exécuter la commande suivante :

REVOKE lecteur FROM 'utilisateur1'@'localhost';

Ces sont des exemples de gestion des droits d'accès dans MySQL en utilisant des utilisateurs, des privilèges et des rôles. Vous pouvez personnaliser davantage les droits d'accès en fonction de vos besoins spécifiques. Il est important de suivre les meilleures pratiques en matière de sécurité des bases de données pour garantir la sécurité de vos données. Création d'un utilisateur avec un rôle : Vous pouvez créer un utilisateur et lui attribuer un rôle en même temps. Par exemple, pour créer un utilisateur "utilisateur2" avec le rôle "lecteur" et un mot de passe, vous pouvez utiliser la commande suivante :

CREATE USER 'utilisateur2'@'localhost' IDENTIFIED BY 'motdepasse';
GRANT lecteur TO 'utilisateur2'@'localhost';

Attribution de privilèges spécifiques à un utilisateur : Vous pouvez également attribuer des privilèges spécifiques à un utilisateur sans utiliser de rôle. Par exemple, pour accorder à l'utilisateur "utilisateur1" le privilège SELECT sur une table "ma_table", vous pouvez exécuter la commande suivante :

GRANT SELECT ON ma_base.ma_table TO 'utilisateur1'@'localhost';

Utilisation d'un rôle pour regrouper les privilèges : L'un des avantages des rôles est de regrouper des privilèges. Vous pouvez créer un rôle "administrateur" qui regroupe tous les privilèges d'administration. Ensuite, vous attribuez le rôle "administrateur" aux utilisateurs qui doivent avoir ces privilèges. Par exemple :

CREATE ROLE administrateur;
GRANT ALL PRIVILEGES ON ma_base.* TO administrateur;
GRANT administrateur TO 'utilisateur1'@'localhost';

Révocation de tous les privilèges d'un utilisateur : Si vous souhaitez révoquer tous les privilèges d'un utilisateur, vous pouvez utiliser la commande REVOKE suivie de "ALL PRIVILEGES". Par exemple, pour révoquer tous les privilèges de l'utilisateur "utilisateur1" sur toutes les bases de données, vous pouvez exécuter :

REVOKE ALL PRIVILEGES ON *.* FROM 'utilisateur1'@'localhost';

Suppression d'un utilisateur : Si vous souhaitez supprimer un utilisateur, utilisez la commande DROP USER. Par exemple, pour supprimer l'utilisateur "utilisateur2", vous pouvez exécuter :

DROP USER 'utilisateur2'@'localhost';

Fonctions et procédures

Les triggers

la Sécurité de données

Exercices

Mysql

SELECT

DataTypes

UPDATE

DELETE

CREATE

DROP

RENAME

ALTER

Tables

Exercice