Comment créer et utiliser des vues MySQL

Qu'est-ce qu'une vue MySQL ?

Une vue MySQL est simplement un objet de base de données ordinaire qui peut faire gagner beaucoup de temps aux rédacteurs de requêtes SQL lorsqu'il est utilisé correctement. Une vue est une requête stockée qu'un utilisateur peut référencer comme une table. Souvent, les utilisateurs se retrouveront à utiliser la même requête de base encore et encore pour résoudre plusieurs problèmes. Les vues sont un moyen d'enregistrer rapidement cette requête et de la référencer ultérieurement.

Quels sont les avantages de l'utilisation des vues ?

Les vues ont plusieurs avantages. Tout d'abord, les vues apparaissent à l'utilisateur MySQL comme une table. La clause SELECT peut référencer une vue exactement comme une table. Un autre avantage est que lorsque les tables sous-jacentes référencées par une vue changent, les résultats de la vue changent également. Un troisième avantage est qu'une vue occupe très peu de place sur le serveur. Les résultats SQL de la vue sont calculés à chaque accès, ils ne sont donc pas stockés sur le serveur tant qu'ils n'y sont pas accédés.

Tableaux pour cet exercice

Pour cet article, une base de données sera créée contenant des informations sur une saison de course automobile fictive avec trois pilotes, quatre pistes et une course sur chaque piste. Dans cette base de données, il y a quatre tables.

• Chauffeurs
• Pistes
• Courses
• Finitions    

La structure des tableaux est décrite ci-dessous.

create table drivers
(
  id int auto_increment,
  name varchar(64) not null,
  car_number int not null,
  constraint drivers_pk
     primary key (id)
);
create table tracks
(
  id int auto_increment,
  name varchar(64) not null,
  location varchar(64) not null,
  constraint track_pk
     primary key (id)
);
create table races
(
  id int auto_increment,
  name varchar(64) not null,
  track int not null,
  distance int not null,
  constraint races_pk
     primary key (id)
);


create table finishes
(
  id int auto_increment,
  driver int not null,
  race int not null,
  position int not null,
  constraint finishes_pk
     primary key (id)
);

Pilotes

Maintenant, dans notre prochaine étape, nous allons insérer trois conducteurs et leurs numéros de voiture dans un tableau.

• Copain Baker 28
• Dale Earnhardt Jr. 8
• Ricky Rudd 88

insert into drivers (name,car_number) values
  ('Buddy Baker',28),
  ('Dale Earnhardt Jr.',8),
  ('Ricky Rudd',88);

Nos résultats afficheront maintenant la sortie suivante.

Hippodromes

Ensuite, nous ajoutons quatre hippodromes et leur emplacement.

• Talladega Superspeedway - Lincoln, AL
• Circuit automobile international de Daytona - Daytona Beach, Floride
• Indianapolis Motor Speedway - Speedway, IN
• Michigan International Speedway - Brooklyn, Michigan

insert into tracks (name,location) values
  ('Talladega Superspeedway','Lincoln, AL'),
  ('Daytona International Speedway','Daytona Beach, FL'),
  ('Indianapolis Motor Speedway','Speedway, IN'),
  ('Michigan International Speedway','Brooklyn, MI');

Nos résultats afficheront maintenant la sortie suivante.

Courses

Maintenant, quatre courses, ainsi que la distance pour chacune, sont inscrites.

• Daytona 500 2 500
• Talladega 500, 1 500
• Briqueterie 400,3, 400
• Michigan 400, 4, 400

insert into races (name,track,distance) values
  ('Daytona 500',2,500),
  ('Talladega 500',1,500),
  ('Brickyard 400',3,400),
  ('Michigan 400',4,'400');

Nos résultats afficheront maintenant la sortie suivante.

Résultats

Enfin, les tables de début de saison sont maintenant créées.

Lors de la première course au Daytona 500 :

• Ricky Rudd termine premier
• Dale Earnhardt Jr termine deuxième 
• Buddy Baker termine troisième.

insert into finishes (driver, race, position) values
  (1,1,3),
  (2,1,2),
  (3,1,1);

Données compilées

Première saisie de données

Maintenant, il y a des données réelles à interroger. Si nous exécutons une requête pour regarder tous les résultats des pilotes avec leurs pistes et courses correspondantes, c'est un peu compliqué car il y a plusieurs jointures.

select d.name as driver,
     r.name as race,
     t.name as track,
     t.location as location,
     f.position as position
  from finishes f
  left join races r
     on f.race = r.id
  left join tracks t
     on r.track = t.id
  left join drivers d
     on d.id = f.driver;

Nos résultats montrent maintenant la sortie suivante.

Deuxième entrée de données

Au fur et à mesure que la deuxième course, le Talladega 500, des données sont ajoutées, la requête peut être écrite à nouveau, comme la requête précédente. Dans cette course, Dale Earnhardt arrive premier et Buddy Baker arrive deuxième.

insert into finishes (driver, race, position) values
  (1,2,2),
  (2,2,1),
  (3,2,3);

Les résultats de la requête ci-dessus ressembleraient à ceci.

Créer une vue

Maintenant qu'il y a plusieurs courses dans la base de données, il existe de nouvelles façons de regarder les résultats. Les requêtes peuvent être écrites pour "Meilleure finition ” et “Le plus de victoires .” Ces requêtes commenceraient toutes avec les mêmes données sous-jacentes de ce que les pilotes ont terminé dans la position de chaque course. Pour simplifier le processus de développement de ces requêtes, une vue peut être créée avec la clause "créer ou remplacer la vue en tant que". Cette clause est suivie du SQL à sauvegarder. Dans ce cas, il est ajouté avant la requête précédente que nous avons montrée ci-dessus.

create or replace view all_finishes as
select d.name as driver,
     r.name as race,
     t.name as track,
     t.location as location,
     f.position as position
  from finishes f
  left join races r
     on f.race = r.id
  left join tracks t
     on r.track = t.id
  left join drivers d
     on d.id = f.driver;

Le résultat est une fonctionnalité puissante de SQL. Ce résultat est maintenant quelque chose qui ressemble à une table mais qui changera lorsque de nouvelles informations seront ajoutées à une table sous-jacente. Exécutons cette requête.

select * from all_finishes;

Les résultats sont identiques à la dernière fois que nous avons exécuté cette requête :

La différence est que maintenant la vue peut être interrogée comme une table. Une requête qui affiche les gagnants de chaque course.

select * from all_finishes where position = 1;

La requête fournit ces résultats.

Une requête peut également être écrite pour afficher le leader en fonction de la finition moyenne.

select avg(position) as finish,
  driver
from all_finishes
  group by driver
     order by finish;

Ce qui montre Dale Earnhardt en tête jusqu'à présent pour la saison :

Étant donné que les vues peuvent référencer d'autres vues, des vues plus étendues peuvent être créées avec ces requêtes.

create view standings_leader as
select avg(position) as finish,
  driver
from all_finishes
  group by driver
     order by finish;

Les résultats de la requête ci-dessus ressembleraient à ceci.

Ainsi que :

create view race_winners as
select * from all_finishes where position = 1;

Ce qui nous donne les mêmes résultats.

Ajout de données

La partie la plus puissante des vues est que lorsque nous ajoutons plus de données comme ces arrivées de course où Buddy Baker remporte le Brickyard 400 et le Michigan 400, nous pouvons simplement interroger nos vues pour obtenir les mêmes résultats.

insert into finishes (driver, race, position) values
  (1,3,1),
  (2,3,3),
  (3,3,2);

insert into finishes (driver, race, position) values
  (1,4,1),
  (2,4,2),
  (3,4,3);

Nous pouvons maintenant voir toutes les finitions avec cette requête.

select * from all_finishes;\

Les résultats de la requête ci-dessus ressembleraient à ceci.

Nous pouvons également exécuter :

select * from race_winners;

Ce qui nous donne :

De plus, cela donne le champion de la série :

select * from standings_leader;

Ce qui donne :

Conclusion

Lorsque nous enregistrons une requête dans notre serveur de base de données (plus précisément dans le catalogue de la base de données) et que nous lui donnons un nom, cette requête nouvellement nommée s'appelle une vue de base de données ou, plus simplement, une vue. Les vues MySQL sont un moyen puissant d'enregistrer des requêtes vitales et réutilisables qui peuvent nous aider à accélérer la récupération d'informations importantes. Étant donné que ces vues de sauvegarde peuvent faire référence à d'autres vues, des vues plus détaillées peuvent être créées avec ces requêtes substantielles.

Évaluez-nous !

Nous sommes fiers d'être The Most Helpful Humans In Hosting™ !

Nos équipes d'assistance sont composées de techniciens Linux expérimentés et d'administrateurs système talentueux qui ont une connaissance intime de plusieurs technologies d'hébergement Web, en particulier celles abordées dans cet article.

Si vous avez des questions concernant ces informations, nous sommes toujours disponibles pour répondre à toute demande concernant des problèmes liés à cet article, 24 heures sur 24, 7 jours sur 7, 365 jours par an.

Si vous êtes un serveur VPS entièrement géré, un cloud dédié, un cloud privé VMWare, un serveur parent privé, des serveurs cloud gérés ou un propriétaire de serveur dédié et que vous n'êtes pas à l'aise avec l'une des étapes décrites, nous peut être contacté par téléphone au 800.580.4985, un chat ou un ticket d'assistance pour vous aider dans ce processus.