Comment : créer des requêtes qui utilisent autre chose qu'une table

Article
08/10/2011

Pour écrire une requête de récupération, il faut toujours formuler quelles sont les colonnes et les lignes à obtenir ainsi que le lieu où le processeur de requêtes trouve les données d'origine. En général, une table ou plusieurs tables jointes constituent les données d'origine. Mais la source des données ne se trouve pas forcément dans une table. Les données d'origine peuvent venir de vues, de requêtes, de synonymes ou de fonctions définies par l'utilisateur et retournant une table.

Utilisation d'une vue à la place d'une table

Il est possible de sélectionner des lignes d'une vue. Par exemple, une base de données contient une vue « ExpensiveBooks » dont tous les titres ont un prix supérieur à 19.99 (19,99 dollars). L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT *
FROM titles
WHERE price > 19.99

Pour sélectionner les livres de luxe traitant de psychologie, sélectionnez cette catégorie dans la vue ExpensiveBooks. L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT *
FROM ExpensiveBooks
WHERE type = 'psychology'

De façon similaire, une vue peut participer à une opération JOIN. Par exemple, il est possible de rechercher les ventes de livres de luxe par une simple jointure entre la table Sales et la vue ExpensiveBooks. L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT *
FROM sales 
         INNER JOIN 
         ExpensiveBooks 
         ON sales.title_id 
         =  ExpensiveBooks.title_id

Pour plus d'informations sur l'ajout d'une vue à une requête, consultez Comment : ajouter des tables à des requêtes.

Utilisation d'une requête à la place d'une table

Il est possible de sélectionner des lignes d'une requête. Par exemple, vous avez déjà une requête qui récupère les titres et les identificateurs des livres signés par plusieurs auteurs. L'instruction SQL peut se présenter de la manière suivante :

SELECT 
     titles.title_id, title, type
FROM 
     titleauthor 
         INNER JOIN
         titles 
         ON titleauthor.title_id 
         =  titles.title_id 
GROUP BY 
     titles.title_id, title, type
HAVING COUNT(*) > 1

Vous pouvez alors écrire une autre requête qui tire parti de ce résultat. Cette requête peut demander par exemple une récupération des livres signés par plusieurs auteurs et traitant de psychologie. Utilisez la requête existante pour écrire la nouvelle. Elle constituera la source des données de la nouvelle requête. L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT 
    title
FROM 
    (
    SELECT 
        titles.title_id, 
        title, 
        type
    FROM 
        titleauthor 
            INNER JOIN
            titles 
            ON titleauthor.title_id 
            =  titles.title_id 
    GROUP BY 
        titles.title_id, 
        title, 
        type
    HAVING COUNT(*) > 1
    ) 
    co_authored_books
WHERE     type = 'psychology'

Le texte en gras montre la requête existante utilisée comme source de données de la nouvelle requête. Remarquez que la nouvelle requête utilise un alias, « co_authored_books », pour indiquer la requête existante. Pour plus d'informations sur les alias, consultez Comment : créer des alias de tables et Comment : créer des alias de colonnes.

De façon similaire, une requête peut participer à une opération JOIN. Par exemple, il est possible de rechercher les ventes de livres de luxe signés par plusieurs auteurs en créant une jointure entre la vue ExpensiveBooks et la requête de récupération des livres signés par plusieurs auteurs. L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT 
    ExpensiveBooks.title
FROM 
    ExpensiveBooks 
        INNER JOIN
        (
        SELECT 
            titles.title_id, 
            title, 
            type
        FROM 
            titleauthor 
                INNER JOIN
                titles 
                ON titleauthor.title_id 
                =  titles.title_id 
        GROUP BY 
            titles.title_id, 
            title, 
            type
        HAVING COUNT(*) > 1
        )

Pour plus d'informations sur l'ajout d'une requête à une requête, consultez Comment : ajouter des tables à des requêtes.

Utilisation d'une fonction définie par l'utilisateur à la place d'une table

Dans SQL Server 2000 ou une version ultérieure, vous pouvez créer une fonction définie par l'utilisateur et retournant une table. Ce type de fonction permet d'utiliser une logique complexe ou procédurale.

par exemple, supposez que la table des employés contient une colonne supplémentaire, employee.manager_emp_id, et qu'une clé étrangère de manager_emp_id à employee.emp_id existe. Dans chaque ligne de la table d'employés, la colonne manager_emp_id indique le patron de l'employé. Plus précisément, elle indique l'ID d'employé du responsable hiérarchique. Vous pouvez créer une fonction définie par l'utilisateur qui retourne une table qui contient une ligne pour chaque employé qui travaille dans la hiérarchie d'organisation d'un directeur de niveau supérieur particulier. Appelons cette fonction fn_GetWholeTeam et prévoyons dans son design l'utilisation d'une variable d'entrée — l'ID d'employé du responsable de l'équipe à récupérer.

Il est possible d'écrire une requête utilisant la fonction fn_GetWholeTeam comme source de données. L'instruction SQL obtenue peut se présenter de la manière suivante :

SELECT * 
FROM 
     fn_GetWholeTeam ('VPA30890F')

« VPA30890F » est l'ID d'employé du responsable de l'équipe à récupérer. Pour plus d'informations sur l'ajout dans une requête d'une fonction définie par l'utilisateur, consultez Comment : inclure des fonctions définies par l'utilisateur dans des requêtes et Comment : ajouter des tables à des requêtes. Pour obtenir une description complète des fonctions définies par l'utilisateur, consultez la documentation SQL Server.

Voir aussi

Autres ressources

Utilisation de procédures stockées et de fonctions définies par l'utilisateur

Partager via