SQL

Les vues

En SQL, une vue est une requête pré-enregistrée qui peut être utilisée comme une table virtuelle dans une base de données. Elle est créée en sélectionnant certaines colonnes et lignes spécifiques à partir d'une ou plusieurs tables existantes. Une vue peut être considérée comme une "vue" personnalisée des données existantes dans une base de données.

D'une manière générale, les vues permettent de simplifier l'accès aux données en fournissant une représentation simplifiée et structurée des informations stockées dans la base de données. Elles peuvent également être utilisées pour restreindre l'accès aux données en masquant certaines colonnes ou lignes sensibles.

Voici un exemple simple pour mieux comprendre. Supposons que vous ayez deux tables dans votre base de données : " Clients" et "Commandes". La table "Clients" contient des informations sur les clients, tels que leurs noms, adresses, etc. La table "Commandes" contient des informations sur les commandes passées par les clients, telles que les numéros de commande, les dates, etc.

Maintenant, vous souhaitez créer une vue qui affiche les noms des clients ainsi que les détails de leurs dernières commandes. Vous pouvez le faire en utilisant une requête SQL comme ceci :

CREATE VIEW VueDernieresCommandes AS
SELECT c.Nom, c.Adresse, cmd.NumeroCommande, cmd.DateCommande
FROM Clients c
JOIN Commandes cmd ON c.IDClient = cmd.IDClient
ORDER BY cmd.DateCommande DESC

Maintenant, vous pouvez utiliser la vue "VueDernieresCommandes" comme une table normale dans vos requêtes. Par exemple, vous pouvez exécuter une requête pour obtenir les noms des clients et leurs dernières commandes :

SELECT Nom, NumeroCommande, DateCommande
FROM VueDernieresCommandes

Les vues offrent une certaine flexibilité, car si les données sous-jacentes (dans ce cas, les tables Clients et Commandes) sont mises à jour, la vue sera automatiquement mise à jour pour refléter ces changements. Cela signifie que vous n'avez pas à modifier votre requête chaque fois que les données changent.

Les procédures stockées

En revanche, une procédure stockée est un ensemble d'instructions SQL pré-compilées qui est enregistré dans la base de données et peut être appelé et exécuté ultérieurement. Les procédures stockées sont généralement utilisées pour regrouper des tâches répétitives ou complexes en un seul bloc de code réutilisable.

Voici un exemple simple de procédure stockée. Supposons que vous souhaitiez créer une procédure stockée pour insérer un nouveau client dans la table "Clients" :

CREATE PROCEDURE AjouterClient
@Nom VARCHAR(50),
@Adresse VARCHAR(100)
AS
BEGIN
INSERT INTO Clients (Nom, Adresse)
VALUES (@Nom, @Adresse)
END

Une fois la procédure stockée créée, vous pouvez l'appeler pour insérer un nouveau client en fournissant les valeurs des paramètres :

EXEC AjouterClient 'John Doe', '123 Rue du Paradis'

Les procédures stockées offrent la possibilité de regrouper des opérations complexes et peuvent être réutilisées à plusieurs endroits dans votre code.

Voici une structure complète de procédure stockée :

 
CREATE PROCEDURE ExempleProcedureStockee
    @parametreEntree INT,
    @parametreSortie INT OUTPUT
AS
BEGIN
    IF NOT EXISTS (SELECT 1 FROM Clients WHERE Nom = @Nom AND Adresse = @Adresse)
    BEGIN
        INSERT INTO Clients (Nom, Adresse)
        VALUES (@Nom, @Adresse)
    END
    ELSE
    BEGIN
        -- Le client existe déjà, vous pouvez effectuer un traitement supplémentaire si nécessaire.
        -- Par exemple, renvoyer un message d'erreur ou mettre à jour les informations existantes.
        -- ...
    END
 
    -- Déclaration de variables
    DECLARE @variable1 INT
    DECLARE @variable2 INT
    DECLARE @somme INT
 
    -- Instructions SQL
    SET @variable1 = 5
    SET @variable2 = @parametreEntree + 10
    SET @somme = @variable1 + @variable2
 
    -- Structure de contrôle IF...ELSE
    IF @somme > 20
    BEGIN
        -- Bloc TRY...CATCH
        BEGIN TRY
            -- Transactions
            BEGIN TRANSACTION
 
            -- Instruction SELECT
            SELECT @somme AS Resultat
 
            -- Appel à une autre procédure stockée
            EXEC AutreProcedureStockee @somme
 
            -- Instruction INSERT
            INSERT INTO MaTable (Colonne) VALUES (@somme)
 
            -- Commit de la transaction
            COMMIT TRANSACTION
        END TRY
        BEGIN CATCH
            -- Rollback de la transaction en cas d'erreur
            ROLLBACK TRANSACTION
 
            -- Gestion de l'erreur avec RAISERROR
            DECLARE @messageErreur NVARCHAR(200)
            SET @messageErreur = 'Une erreur s''est produite : ' + ERROR_MESSAGE()
            RAISERROR(@messageErreur, 16, 1)
        END CATCH
    END
    ELSE
    BEGIN
        -- Curseur
        DECLARE @id INT
        DECLARE cur CURSOR FOR SELECT ID FROM AutreTable
 
        OPEN cur
 
        FETCH NEXT FROM cur INTO @id
 
        WHILE @@FETCH_STATUS = 0
        BEGIN
            -- Instructions SQL dans la boucle WHILE
            -- ...
 
            FETCH NEXT FROM cur INTO @id
        END
 
        CLOSE cur
        DEALLOCATE cur
    END
 
    -- Paramètre de sortie
    SET @parametreSortie = @somme * 2
END

Les triggers

En SQL, un déclencheur (trigger en anglais) est un type d'objet de base de données qui est associé à une table et qui est automatiquement exécuté en réponse à certaines opérations effectuées sur cette table (par exemple, l'insertion, la mise à jour ou la suppression de lignes).

Un déclencheur est défini avec une condition (ou un événement) qui détermine quand il doit être déclenché, et un ensemble d'instructions SQL à exécuter lorsque la condition est satisfaite. Les déclencheurs sont souvent utilisés pour appliquer des règles métier, effectuer des actions supplémentaires ou maintenir l'intégrité des données dans la base de données.

Voici un exemple simple pour mieux comprendre. Supposons que vous ayez une table "Commandes" avec les colonnes " IDCommande", "Montant" et "Statut". Vous souhaitez mettre à jour automatiquement la colonne "Statut" en fonction du montant de la commande. Si le montant dépasse 1000, le statut doit être défini sur "En cours de traitement", sinon il doit être défini sur "En attente".

Pour cela, vous pouvez créer un déclencheur sur la table "Commandes" qui s'exécute après chaque mise à jour de la colonne "Montant" :

CREATE TRIGGER MajStatutCommande
AFTER UPDATE ON Commandes
FOR EACH ROW
BEGIN
    IF NEW.Montant > 1000 THEN
        UPDATE Commandes SET Statut = 'En cours de traitement' WHERE IDCommande = inserted.IDCommande;
    ELSE
        UPDATE Commandes SET Statut = 'En attente' WHERE IDCommande = inserted.IDCommande;
    END IF;
END;

Dans cet exemple, le déclencheur vérifie si le nouveau montant (NEW.Montant) de la commande dépasse 1000. Si c'est le cas, il met à jour le statut de la commande en "En cours de traitement". Sinon, il met à jour le statut en "En attente". Le déclencheur est exécuté automatiquement chaque fois qu'une mise à jour est effectuée sur la table "Commandes".

Dans le monde professionnel, les déclencheurs sont couramment utilisés pour des tâches telles que :

Audit des modifications : Un déclencheur peut être utilisé pour enregistrer les modifications apportées à une table dans une table d'audit, permettant ainsi de suivre les changements effectués par les utilisateurs.

Validation des données : Un déclencheur peut être utilisé pour vérifier la validité des données avant leur insertion ou mise à jour. Par exemple, il peut être utilisé pour s'assurer qu'une date de début est antérieure à une date de fin dans une table.

Réplication de données : Les déclencheurs peuvent être utilisés pour mettre à jour automatiquement des tables de réplication lorsqu'une table source est modifiée.

Application de règles métier : Les déclencheurs peuvent être utilisés pour appliquer des règles métier spécifiques. Par exemple, un déclencheur peut vérifier si une commande est expédiée à temps et envoyer une notification si ce n'est pas le cas.

En résumé, les déclencheurs sont des objets de base de données qui sont automatiquement exécutés en réponse à des opérations spécifiques sur une table. Ils permettent de prendre des actions supplémentaires, d'appliquer des règles métier et de maintenir l'intégrité des données dans la base de données.