Comment combiner les résultats de plusieurs requêtes SQL en utilisant la déclaration de l'Union

Dans un article précédent, nous avons parlé des différents types de REJOINDRE Nous pouvons utiliser dans une base de données MARIADB / MYSQL. Cette fois, au lieu de cela, nous jetons un coup d'œil au SYNDICAT Déclaration: comment cela fonctionne, comment nous pouvons l'utiliser pour combiner le résultat des requêtes exécutées sur différentes tables, et quelles sont ses particularités.

Dans ce tutoriel, vous apprendrez:

• Comment utiliser l'instruction Union dans un serveur MARIADB / MySQL
• Quelles sont les propriétés de la déclaration syndicale

Exigences et conventions logicielles utilisées

La déclaration syndicale

Le SYNDICAT déclaration, combinons les résultats de deux requêtes ou plus. Lorsque vous effectuez une jointure, nous pouvons exécuter une sorte d'action ou récupérer des informations supplémentaires sur la base des relations existantes entre les tables, lorsque vous utilisez le SYNDICAT Déclaration, si certaines conditions sont remplies, les lignes résultant de requêtes lancées sur différentes tables non liées, peuvent être combinées. Dans ce didacticiel, nous verrons un exemple de base et réel de comment pouvons-nous utiliser le SYNDICAT Déclaration dans un environnement MariaDB / MySQL.

Un exemple de base

Commençons par un exemple très basique pour introduire les particularités du SYNDICAT déclaration. Supposons que nous ayons deux tables complètement indépendantes: le premier appelé "film" et le second "Color". Dans le premier, chaque ligne contient des informations sur un film: le titre, le genre et la date de sortie. Ce dernier héberge juste le nom de quelques couleurs. Voici à quoi ressemblent les tables:

+----+---------------+---------+--------------+ | ID | Titre | genre | release_date | + ---- + --------------- + --------- + -------------- + | 1 | Un nouvel espoir | fantasme | 1977-05-25 | | 2 | Le parrain | Drame | 1972-05-24 | + ---- + --------------- + --------- + -------------- + + - - + -------- + | ID | Nom | + ---- + -------- + | 1 | Bleu | | 2 | Jaune | +----+--------+ 

Et voici leur description:

+--------------+-------------+------+-----+---------+----------------+ | Champ | Type | NULL | Clé | Par défaut | Extra | + -------------- + ------------- + ------ + ----- + ------- - + ---------------- + | ID | int (2) | Non | Pri | NULL | auto_increment | | Titre | varchar (20) | Non | | NULL | | | genre | varchar (20) | Non | | NULL | | | release_date | Date | Non | | NULL | | + -------------- + ------------- + ------ + ----- + ------- - + ---------------- + + ------- + ------------- + ------ + ----- + --------- + ---------------- + | Champ | Type | NULL | Clé | Par défaut | Extra | + ------- + ------------- + ------ + ----- + --------- + ---- ------------ + | ID | int (2) | Non | Pri | NULL | auto_increment | | Nom | varchar (10) | Non | | NULL | | +-------+-------------+------+-----+---------+----------------+ 

Comme dit précédemment, ces deux tables n'ont absolument aucun lien entre elles. En utilisant le SYNDICAT Déclaration, cependant, nous pouvons combiner les résultats de deux requêtes distinctes lancées sur eux. Courons:

Select Title, Genre From Movie Union Select ID, Nom From Color;

La commande ci-dessus renvoie le résultat suivant:

+---------------+---------+ | Titre | genre | + --------------- + --------- + | Un nouvel espoir | fantasme | | Le parrain | Drame | | 1 | Bleu | | 2 | Jaune | +---------------+---------+ 

Expliquez. Nous avons effectué deux différents SÉLECTIONNER Requêtes: Dans le premier, nous avons sélectionné la valeur des colonnes «Title» et «Genre» pour chaque ligne de la table de cinéma. Dans le second, nous avons plutôt sélectionné les colonnes «ID» et «Nom» de la table «Color», encore une fois sans utiliser de filtre.

Même si les deux tables ne sont pas complètement liées, car nous avons utilisé le SYNDICAT Déclaration entre les deux requêtes, les lignes renvoyées par chacun d'elles sont combinées: le résultat est le tableau que vous pouvez voir ci-dessus.

Même si dans la grande majorité des cas du monde réel, les colonnes sélectionnées dans les tableaux impliqués auraient probablement les mêmes types de données, dans l'exemple idiot ci-dessus, nous pouvons clairement voir comment le SYNDICAT se produit même si les colonnes des deux tables originales contient des types de données différents: les deux colonnes sélectionnées dans la table «film» sont du Varchar Type de données, tandis que la colonne «ID» de la table «Color» est de type Int. Cela est possible car la base de données effectue automatiquement les conversions de données nécessaires.

Une autre chose très importante à remarquer est que les colonnes du SYNDICAT résultat, a hérité de leurs noms de ceux sélectionnés dans le d'abord requête, celle à gauche du SYNDICAT Mot-clé: «titre» et «genre». Regarder l'exemple ci-dessus vous ferait probablement vous demander ce que le SYNDICAT La déclaration peut être utile dans le scénario de la vie réelle: voyons un autre exemple.

L'affaire de football fantastique

Il y a quelque temps, j'ai participé à la création d'une petite application de football fantastique. Dans la base de données de l'application, il y avait un tableau appelé «Club», qui a accueilli des informations sur les clubs fantastiques impliqués dans la compétition. Ceci est un extrait de celui-ci:

+----+-----------------+--------+ | ID | Nom | Budget | + ---- + ----------------- + -------- + | 1 | Havana Blu | 4 | | 2 | Longobarda | 4 | | 3 | Vraie Siderno | 0 | | 4 | Équipe de tremblement de terre | 66 | | 5 | Kalapagos | 33 | | 6 | Cantasant | 5 | | 7 | F.C. Mojito | 0 | | 8 | Apoel nicotina | 1 | | 9 | Dharma | 0 | | 10 | Vrai 1908 | 12 | +----+-----------------+--------+ 

Dans le même projet, il y avait également un appel de table «Calendrier», dans lequel chaque ligne représentait un match entre deux des clubs énumérés ci-dessus. Depuis que nous avions 10 clubs, chaque journée de championnat a accueilli un total de 5 matchs. Par exemple, voici un extrait de tous les matchs des quatre premiers jours:

+----+-----+------+-------------+-------+--------------+ | ID | Jour | Hôte | host_scores | Invité | invité_score | + ---- + ----- + ------ + ------------- + ------- + --------- ----- + | 1 | 1 | 2 | 75.5 | 8 | 67 | | 2 | 1 | 4 | 80 | 6 | 77 | | 3 | 1 | 7 | 63 | 9 | 71.5 | | 4 | 1 | 3 | 79.5 | 5 | 68 | | 5 | 1 | 10 | 64 | 1 | 72.5 | | 6 | 2 | 5 | 66.5 | 10 | 65.5 | | 7 | 2 | 9 | 82 | 3 | 62.5 | | 8 | 2 | 6 | 83 | 7 | 69.5 | | 9 | 2 | 8 | 77 | 4 | 79.5 | | 10 | 2 | 1 | 67 | 2 | 81.5 | | 11 | 3 | 4 | 73 | 2 | 58 | | 12 | 3 | 7 | 70.5 | 8 | 75.5 | | 13 | 3 | 3 | 66.5 | 6 | 88 | | 14 | 3 | 10 | 74.5 | 9 | 60.5 | | 15 | 3 | 5 | 68.5 | 1 | 72.5 | | 16 | 4 | 9 | 68 | 5 | 69 | | 17 | 4 | 6 | 60 | 10 | 66 | | 18 | 4 | 8 | 70.5 | 3 | 73.5 | | 19 | 4 | 2 | 71.5 | 7 | 79 | | 20 | 4 | 1 | 68.5 | 4 | 68 | +----+-----+------+-------------+-------+--------------+ 

La première colonne de chaque ligne contient un Clé de substitution utilisé comme le clé primaire pour la table. Le second contient l'entier représentant le jour où le match fait partie de. Le héberger, host_score, et invité, invité_score Les colonnes contiennent, respectivement, l'ID et les scores du club qui ont joué comme hôte et ceux du club qui ont joué comme invité.

Maintenant, disons que nous voulons générer un rang dans lequel tous les clubs sont répertoriés par ordre décroissant sur la base du total des scores qu'ils ont réalisés dans les quatre premiers jours de championnat. Si chaque ID de club n'était répertorié que dans une colonne, dites «hôte», l'opération serait vraiment facile: nous calculions simplement la somme des scores en utilisant le SOMME() la fonction agrégée et regrouper les résultats par l'ID des clubs, les affichant par ordre décroissant:

Sélectionnez l'hôte, sum (host_scores) comme total_score à partir du groupe de calendrier par commande hôte par total_scores dec

Cependant, depuis que chaque jour de championnat, un club joue alternativement en tant qu'hôte et en tant qu'invité, la requête ci-dessus ne rendrait pas les résultats que nous voulons, mais produirait les scores totaux d'une équipe comprenant uniquement les scores réalisés lorsqu'il a joué comme hôte (ou alternativement, comme invité).

C'est un cas où le SYNDICAT La déclaration peut être utile: nous pouvons effectuer deux requêtes distinctes, l'une impliquant les colonnes «hôte» et «host_score», et l'autre impliquant celles «invité» et «invité_score»; Nous pouvons alors utiliser le SYNDICAT déclaration pour ajouter la ligne résultant de la deuxième requête à celles renvoyées par la première, et enfin calculer les valeurs agrégées. De plus, nous pouvons effectuer une jointure avec la table «Club», pour faire apparaître le nom de chaque club dans le résultat. Voici la requête complète:

Sélectionner des données.Team_id, club.Nom, Sum (scores) As Total_scores de (sélectionnez l'hôte comme Team_id, host_scores en tant que scores de Calendar Union All Select Guest, invité_score dans le calendrier) en tant que données Rejoignez le club sur le club.id = données.Team_id Group by Data.Team_id Order by total_scores dec; 

Voici le résultat de la requête:

+---------+-----------------+--------------+ | Team_id | Nom | Total_scores | + --------- + ----------------- + -------------- + | 6 | Cantasant | 308 | | 4 | Équipe de tremblement de terre | 300.5 | | 8 | Apoel nicotina | 290 | | 2 | Longobarda | 286.5 | | 3 | Vraie Siderno | 282 | | 9 | Dharma | 282 | | 7 | F.C. Mojito | 282 | | 1 | Havana Blu | 280.5 | | 5 | Kalapagos | 272 | | 10 | Vrai 1908 | 270 | +---------+-----------------+--------------+ 

Comme vous pouvez le voir, à la fin de la quatrième journée de championnat, l'équipe «Cantasant» était celle avec les scores les plus élevés. Une autre chose à remarquer dans la requête ci-dessus, c'est l'utilisation du TOUS mot-clé avec SYNDICAT: c'était nécessaire parce que lorsque le SYNDICAT L'instruction est utilisée, par défaut, les lignes en double sont supprimées; si Union All est utilisé, au lieu de cela, les lignes sont conservées.

Conclusions

Dans ce tutoriel, nous avons appris à connaître le SYNDICAT Déclaration dans les bases de données MARIADB / MYSQL. Nous avons vu un exemple de base pour démontrer certaines des propriétés de la déclaration et un exemple du monde réel, tiré d'un vrai projet. Pour résumer, les caractéristiques d'un SYNDICAT déclaration:

• Dans le tableau résultant, le nom des colonnes sélectionnées dans la première requête est utilisée;
• Le nombre de colonnes doit être le même dans toutes les requêtes;
• Les types de données des colonnes peuvent être différents, la base de données effectuera la conversion;
• Par défaut, lorsque le SYNDICAT La déclaration est utilisée, les lignes en double dans les résultats sont supprimées: pour éviter cela, nous pouvons utiliser Union All ;

Prenez davantage élargir vos connaissances sur la déclaration du syndicat, vous pouvez jeter un œil à la documentation officielle.

Tutoriels Linux connexes:

• Installez MySQL sur Ubuntu 20.04 LTS Linux
• Comment installer MySQL sur Almalinux
• Ubuntu 20.04 WordPress avec installation Apache
• Choses à installer sur Ubuntu 20.04
• Introduction aux moteurs de stockage MySQL
• Ampache Raspberry Pi Installation
• Une introduction à l'automatisation Linux, des outils et des techniques
• Comment créer une pile de lampe basée sur Docker à l'aide de Docker sur…
• Comment changer le mot de passe de l'utilisateur de MariaDB
• Comment persister les données à PostgreSQL à Java