Mysql
 sql >> Base de données >  >> RDS >> Mysql

Comment utiliser les vues dans une base de données MySQL

Une vue dans MySQL est une requête nommée qui peut être déclenchée pour afficher des données stockées dans d'autres tables. En d'autres termes, les vues sont des tables virtuelles définies par l'utilisateur. Les vues peuvent être utilisées pour :

  • Améliorez la sécurité de la base de données. Si votre base de données contient des informations sensibles qui doivent être sécurisées, l'utilisation d'une vue vous aide à isoler les données. Une vue peut être créée avec un ensemble de résultats prédéfini, et vous pouvez accorder aux utilisateurs l'accès uniquement à cette vue, au lieu du tableau qui contient des informations sensibles.
  • Déplacez la logique métier complexe vers le serveur de base de données. Au lieu de coder la logique logicielle fréquemment utilisée dans différents clients, un développeur peut déplacer la logique au niveau de la base de données à l'aide d'une vue. Par exemple, une vue peut être créée pour afficher les classifications des clients en fonction de leurs ventes totales.
  • Réduire la distraction liée aux données. Une vue peut combiner les résultats de différentes tables et n'afficher que les colonnes pertinentes lorsqu'elle est invoquée.

Dans ce guide, vous apprendrez :

  • Comment est structurée la syntaxe d'une vue MySQL.
  • Comment créer une vue MySQL.
  • Comment appeler une vue MySQL.
  • Comment supprimer une vue dans MySQL.

Avant de commencer

Pour suivre ce guide, assurez-vous d'avoir les éléments suivants :

  1. Un Linode, sur lequel vous exécutez le logiciel MySQL. Vous pouvez suivre le guide Premiers pas avec Linode pour provisionner un Linode.

  2. Le logiciel serveur MySQL (ou MariaDB) installé sur votre Linode. Veuillez vous référer à la section MySQL, qui contient des guides décrivant comment installer MySQL sur plusieurs distributions Linux.

Préparation de la base de données

Avant de créer vos vues MySQL, créez un exemple de base de données, définissez quelques tables et remplissez-les d'abord avec des données :

  1. SSH à votre Linode. Ensuite, entrez cette commande pour vous connecter à MySQL en tant qu'utilisateur root :

    mysql -u root -p

    Lorsque vous y êtes invité, entrez le mot de passe root de votre serveur MySQL et appuyez sur Entrée pour continuer.

    Remarque

    Si votre mot de passe n'est pas accepté, vous devrez peut-être exécuter la commande précédente avec sudo :

    sudo mysql -u root -p

  2. Si votre mot de passe est accepté, vous devriez voir l'invite MySQL :

    
mysql >
    Remarque

    Si vous utilisez MariaDB, vous pouvez voir une invite comme celle-ci à la place :

    
MariaDB [(none)]>

  3. Ensuite, exécutez cette commande SQL pour créer un exemple de base de données nommé sample_database :

    CREATE DATABASE sample_database;

    Vous devriez voir cette sortie, qui confirme que la base de données a été créée avec succès :

    
Query OK, 1 row affected (0.02 sec)

  4. Sélectionnez la sample_database base de données :

    USE sample_database;

    Vous devriez voir cette sortie :

    
Database changed

  5. Exécutez cette commande pour créer un customers tableau :

     CREATE TABLE customers
 (
 customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
 customer_name VARCHAR(50)
 ) ENGINE = InnoDB;

    Vous devriez voir cette sortie :

    
Query OK, 0 rows affected (0.07 sec)

  6. Ensuite, remplissez les customers table avec trois enregistrements. Exécutez le INSERT ci-dessous commandes une par une :

    INSERT INTO customers (customer_name) VALUES ('Leslie');
INSERT INTO customers (customer_name) VALUES ('Andy');
INSERT INTO customers (customer_name) VALUES ('Ben');

    La sortie ci-dessous s'affiche après l'insertion de chaque enregistrement :

    
Query OK, 1 row affected (0.08 sec)
...

  7. Assurez-vous que les exemples d'enregistrements ont été insérés dans la base de données en exécutant ce SELECT commande :

    SELECT * FROM customers;

    Cette sortie apparaît, ce qui confirme que les données ont été insérées avec succès à l'étape précédente :

    
+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
|           1 | Leslie        |
|           2 | Andy          |
|           3 | Ben           |
+-------------+---------------+
3 rows in set (0.01 sec)

  8. Ensuite, créez un sales table. Exécutez cette commande :

     CREATE TABLE sales
 (
 customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
 monthly_sales DECIMAL(17,2)
 ) ENGINE = InnoDB;

    Cette sortie apparaît :

    
Query OK, 0 rows affected (0.07 sec)

  9. Ensuite, ajoutez des données aux sales table. Exécutez ces commandes une par une :

    INSERT INTO sales (customer_id, monthly_sales) VALUES ('1','500.27');
INSERT INTO sales (customer_id, monthly_sales) VALUES ('2','7600.32');
INSERT INTO sales (customer_id, monthly_sales) VALUES ('3', '25879.63');

    Après avoir inséré chaque enregistrement de vente, cette sortie apparaît :

    
Query OK, 1 row affected (0.01 sec)
...

  10. Ensuite, exécutez un SELECT requête pour vérifier que les données de ventes ont bien été insérées dans la table :

    SELECT * FROM sales;

    Cette sortie apparaît, ce qui confirme que les données de vente ont été insérées avec succès à l'étape précédente :

    


    
+-------------+---------------+
| customer_id | monthly_sales |
+-------------+---------------+
|           1 |        500.27 |
|           2 |       7600.32 |
|           3 |      25879.63 |
+-------------+---------------+
3 rows in set (0.00 sec)

Vous avez défini la base de données et les tables sur lesquelles travailler. La section suivante décrit la syntaxe d'une vue MySQL.

La syntaxe de la vue MySQL

Ceci est une version simplifiée de la syntaxe de la vue MySQL :

    CREATE
    VIEW view_name
    AS select_statement

  • view_name :Le nom de la vue MySQL doit être défini ici. Il est conseillé d'utiliser un nom descriptif afin de pouvoir mémoriser ultérieurement la fonction de la vue.

  • select_statement :Il s'agit de la requête SQL couplée à la vue définie. Lorsque la vue est invoquée, MySQL exécute cette requête pour renvoyer un jeu d'enregistrements.

Créer une vue MySQL

Cette section présente un exemple de vue MySQL. Cette vue est utilisée pour classer les clients de votre exemple de base de données, en fonction de leur nombre de ventes mensuelles.

Assurez-vous d'être connecté à votre serveur MySQL. Ensuite, exécutez la commande ci-dessous pour créer un customers_membership afficher :

CREATE
VIEW customers_membership
AS SELECT sales.customer_id,
customer_name,
(IF(sales.monthly_sales >= 5000, 'PREMIUM', 'BASIC')) as membership
FROM sales
LEFT JOIN customers
ON sales.customer_id = customers.customer_id;

Si la vue est créée avec succès, vous devriez voir le résultat ci-dessous :


Query OK, 0 rows affected (0.01 sec)

La commande MySQL ci-dessus crée une vue nommée customers_membership qui rejoint les customers et sales table avec la PRIMARY KEY customer_id . Le IF(expression, value_if_true, value_if_false) logique la logique d'instruction est utilisée pour déterminer l'appartenance du client à partir de ses ventes mensuelles :

  • Si les ventes d'un client sont égales ou supérieures à 5 000, la vue classe le client dans la catégorie PREMIUM membre.

  • Sinon (si les ventes sont inférieures à 5,000 ), le client est classé en BASIC membre.

Le customers_membership La vue est maintenant enregistrée dans la base de données. La section suivante montre comment appeler une vue MySQL et afficher un jeu d'enregistrements sans interroger directement les tables de base.

Invoquer une vue MySQL

Cette section montre comment invoquer la vue MySQL que vous avez créée ci-dessus et confirmer qu'elle fonctionne comme prévu. Une fois qu'une vue est créée, elle est visible en tant qu'objet de base de données et peut être appelée à l'aide de SELECT déclaration.

  1. Pour invoquer le customers_membership afficher, exécuter :

    SELECT * FROM customers_membership;

    Si la vue fonctionne comme prévu, vous devriez maintenant voir une liste de clients avec leur membership généré valeurs basées sur leurs ventes. Depuis Leslie les ventes de étaient inférieures à 5 000 (500,27), la vue affiche l'adhésion du client en tant que BASIC . Andy et Ben les ventes de s'élevaient respectivement à 7 600,32 et 25 879,63, ce qui les rend PREMIUM membres :

    
+-------------+---------------+------------+
| customer_id | customer_name | membership |
+-------------+---------------+------------+
|           1 | Leslie        | BASIC      |
|           2 | Andy          | PREMIUM    |
|           3 | Ben           | PREMIUM    |
+-------------+---------------+------------+
3 rows in set (0.00 sec)

  2. Une fois que les données d'une table de base sont mises à jour et que vous appelez à nouveau une vue MySQL, vous devriez voir les dernières informations. Les vues extraient des informations de leurs tables de base et ne stockent pas les données. Pour montrer comment une vue extrait les informations mises à jour des tables de base, ajoutez un autre client nommé Rajie aux customers tableau :

    INSERT INTO customers (customer_name) VALUES ('Rajie');

    Cette sortie apparaît :

    
Query OK, 1 row affected (0.01 sec)

  3. Ajoutez ensuite les informations sur les ventes mensuelles du client au tableau des ventes :

    INSERT INTO sales (customer_id, monthly_sales) VALUES ('4', '147.41');

    Cette sortie apparaît :

    
Query OK, 1 row affected (0.01 sec)

  4. Ensuite, invoquez le customers_membership revoir :

    SELECT * FROM customers_membership;

    La sortie ci-dessous s'affiche, ce qui confirme que la vue est capable de prendre en compte les modifications et d'extraire les informations des nouveaux clients comme prévu :

    
+-------------+---------------+------------+
| customer_id | customer_name | membership |
+-------------+---------------+------------+
|           1 | Leslie        | BASIC      |
|           2 | Andy          | PREMIUM    |
|           3 | Ben           | PREMIUM    |
|           4 | Rajie         | BASIC      |
+-------------+---------------+------------+
4 rows in set (0.00 sec)

    Comme vous pouvez le voir dans le jeu d'enregistrements ci-dessus, vous avez maintenant un nouveau client nommé Rajie avec un BASIC adhésion.

Supprimer une vue MySQL

Tout comme les autres objets de base de données, vous pouvez supprimer des vues si vous n'en avez plus besoin. Voici la syntaxe de base pour supprimer une vue MySQL :

    DROP VIEW IF EXISTS view_name;

  1. Avant de déposer une vue MySQL, identifiez d'abord son nom en exécutant la commande ci-dessous :

    SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';

    Une liste de toutes les vues de la base de données actuellement sélectionnée s'affiche :

    
+---------------------------+------------+
| Tables_in_sample_database | Table_type |
+---------------------------+------------+
| customers_membership      | VIEW       |
+---------------------------+------------+
1 row in set (0.01 sec)

  2. Dans ce cas, le nom de la vue que vous souhaitez supprimer est customers_membership . Donc, pour le supprimer, exécutez :

    DROP VIEW IF EXISTS customers_membership;

    Assurez-vous que la sortie ci-dessous s'affiche après la suppression de la vue de la base de données :

    
Query OK, 0 rows affected (0.01 sec)
    Remarque Veuillez noter que si vous essayez de supprimer une vue MySQL qui n'existe pas sans utiliser le IF EXISTS mot-clé, MySQL renvoie une erreur.

  3. Lorsque la commande de l'étape 1 est réexécutée, il ne devrait plus y avoir de résultat :

    SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';

    
Empty set (0.000 sec)

Plus d'informations

Vous pouvez consulter les ressources suivantes pour plus d'informations sur ce sujet. Bien que ceux-ci soient fournis dans l'espoir qu'ils seront utiles, veuillez noter que nous ne pouvons pas garantir l'exactitude ou l'actualité des documents hébergés en externe.

  • MySQL – Utilisation des vues