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 join que nous pouvons utiliser dans une base de données MARIADB/MYSQL. Cette fois, nous examinons plutôt la déclaration Union : 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

Le résultat d'une déclaration syndicale

Exigences et conventions logicielles utilisées

La déclaration syndicale

L'instruction Union combinons les résultats de deux requêtes ou plus. Lors de l'exécution d'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 l'instruction Union , si certaines conditions sont remplies, les lignes résultant des requêtes lancées Sur différentes tables, même non liées, peuvent être combinées. Dans ce didacticiel, nous verrons un exemple de base et réel du monde comment pouvons-nous utiliser l'instruction Union dans un environnement MariaDB/MySQL.

Un exemple de base

Commençons par un exemple très basique pour introduire les particularités de la déclaration Union . 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 | title         | genre   | release_date |
+----+---------------+---------+--------------+
|  1 | A New Hope    | fantasy | 1977-05-25   |
|  2 | The Godfather | Drama   | 1972-05-24   |
+----+---------------+---------+--------------+

+----+--------+
| id | name   |
+----+--------+
|  1 | blue   |
|  2 | yellow |
+----+--------+

Et voici leur description:

+--------------+-------------+------+-----+---------+----------------+
| Field        | Type        | Null | Key | Default | Extra          |
+--------------+-------------+------+-----+---------+----------------+
| id           | int(2)      | NO   | PRI | NULL    | auto_increment |
| title        | varchar(20) | NO   |     | NULL    |                |
| genre        | varchar(20) | NO   |     | NULL    |                |
| release_date | date        | NO   |     | NULL    |                |
+--------------+-------------+------+-----+---------+----------------+

+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(2)      | NO   | PRI | NULL    | auto_increment |
| name  | varchar(10) | NO   |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+

Comme dit précédemment, ces deux tables n'ont absolument aucun lien entre elles. Cependant, en utilisant l'instruction Union , nous pouvons combiner les résultats de deux requêtes distinctes lancées sur eux. Courons:

SELECT title, genre FROM movie UNION SELECT id, name FROM color;

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

+---------------+---------+
| title         | genre   |
+---------------+---------+
| A New Hope    | fantasy |
| The Godfather | Drama   |
| 1             | blue    |
| 2             | yellow  |
+---------------+---------+

Expliquons. Nous avons effectué deux requêtes différentes : dans le premier, nous avons sélectionné la valeur des colonnes «Title» et «Genre» pour chaque ligne de la table de film. 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 sont complètement sans rapport, car nous avons utilisé l'instruction Union 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 Union 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 "Movie" sont du type de données varchar , tandis que la colonne "ID" de la table "Color" est de type < Code> 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 résultat Union , ont hérité de leurs noms de ceux sélectionnés dans la requête d'abord , celle à gauche du Union mot-clé: «titre» et «genre». Regarder l'exemple ci-dessus vous ferait probablement vous demander ce que la déclaration Union peut être utile dans le scénario réel: 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 le concours. Ceci est un extrait de celui-ci:

+----+-----------------+--------+
| id | name            | budget |
+----+-----------------+--------+
|  1 | Havana Blu      |      4 |
|  2 | Longobarda      |      4 |
|  3 | Real Siderno    |      0 |
|  4 | Earthquake Team |     66 |
|  5 | Kalapagos       |     33 |
|  6 | Cantasant       |      5 |
|  7 | F.C. Mojito     |      0 |
|  8 | Apoel Nicotina  |      1 |
|  9 | Dharma          |      0 |
| 10 | Real 1908       |     12 |
+----+-----------------+--------+

Dans le même projet, il y avait également un appel de table «Calendar», 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 | day | host | host_scores | guest | guest_scores |
+----+-----+------+-------------+-------+--------------+
|  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 une clé de substitution utilisée comme la clé primaire pour la table. Le second contient l'entier représentant le jour où le match fait partie. Le hôte , host_scores , et invité , gard_scores Les colonnes contiennent respectivement, l'ID et les scores du club qui a joué comme hôte et ceux du club qui a 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 au cours des quatre premiers jours de championnat. Si chaque ID de club était répertorié uniquement dans une colonne, dites «hôte», l'opération serait vraiment facile: nous calculions simplement la somme des scores à l'aide de la fonction agrégée SUM() et regroupant le Résultats de l'ID des clubs, les affichant par ordre décroissant:

SELECT
    host, SUM(host_scores) AS total_scores
FROM
    calendar
GROUP BY
    host
ORDER BY
    total_scores DESC

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ù l'instruction Union peut être utile: nous pouvons effectuer deux requêtes distinctes, l'une impliquant les colonnes «hôte» et «host_score», et l'autre impliquant les «invités » et «invité_score» ceux; Nous pouvons ensuite utiliser l'instruction Union 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:

SELECT
    data.team_id
    , club.name
    , SUM(scores) AS total_scores

FROM  (
    SELECT
        host as team_id
        ,host_scores AS scores
    FROM
        calendar

    UNION ALL

    SELECT
        guest
        ,guest_scores
    FROM
        calendar
) AS data

JOIN club ON club.id = data.team_id
GROUP BY
    data.team_id
ORDER BY
    total_scores DESC;

Voici le résultat de la requête:

+---------+-----------------+--------------+
| team_id | name            | total_scores |
+---------+-----------------+--------------+
|       6 | Cantasant       |          308 |
|       4 | Earthquake Team |        300.5 |
|       8 | Apoel Nicotina  |          290 |
|       2 | Longobarda      |        286.5 |
|       3 | Real Siderno    |          282 |
|       9 | Dharma          |          282 |
|       7 | F.C. Mojito     |          282 |
|       1 | Havana Blu      |        280.5 |
|       5 | Kalapagos       |          272 |
|      10 | Real 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 mot-clé tout avec Union : il était nécessaire car lorsque l'instruction Union Utilisé, par défaut, les lignes en double sont supprimées; Si Union All est utilisé, mais les lignes sont conservées.

Conclusions

Dans ce didacticiel, nous avons appris à connaître l'instruction Union 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'une instruction Union :

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 l'instruction Union est utilisée, les lignes en double dans les résultats sont supprimées: pour éviter cela, nous pouvons utiliser Union all ;