Créer des requêtes à l’aide de quelque chose en plus d’une table (Visual Database Tools)

s’applique à : SQL Server

Chaque fois que vous écrivez une requête de récupération, vous articulez les colonnes souhaitées, les lignes souhaitées et l’emplacement où le processeur de requêtes doit trouver les données d’origine. En règle générale, ces données d’origine se composent d’une table ou de plusieurs tables jointes. Toutefois, les données d’origine peuvent provenir de sources autres que des tables. En fait, il peut provenir de vues, de requêtes, de synonymes ou de fonctions définies par l’utilisateur qui retournent une table.

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

Vous pouvez sélectionner des lignes dans une vue. Par exemple, supposons que la base de données inclut une vue appelée « ExpensiveBooks », dans laquelle chaque ligne décrit un titre dont le prix dépasse 19,99. La définition d’affichage peut ressembler à ceci :

SELECT *  
FROM titles  
WHERE price > 19.99  

Vous pouvez sélectionner les livres de psychologie coûteux simplement en sélectionnant les livres de psychologie à partir de la vue ExpensiveBooks. Le code SQL résultant peut ressembler à ceci :

SELECT *  
FROM ExpensiveBooks  
WHERE type = 'psychology'  

De même, une vue peut participer à une opération JOIN. Par exemple, vous pouvez trouver les ventes de livres coûteux simplement en joignant la table des ventes à la vue ExpensiveBooks. Le code SQL résultant peut ressembler à ceci :

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 Ajouter des tables à des requêtes (Visual Database Tools).

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

Vous pouvez sélectionner des lignes à partir d’une requête. Par exemple, supposons que vous avez déjà écrit une requête récupérant des titres et des identificateurs des livres co-écrits , les livres avec plusieurs auteurs. Le code SQL peut ressembler à ceci :

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 ensuite écrire une autre requête qui s’appuie sur ce résultat. Par exemple, vous pouvez écrire une requête qui récupère les livres de psychologie coécrits. Pour écrire cette nouvelle requête, vous pouvez utiliser la requête existante comme source des données de la nouvelle requête. Le code SQL résultant peut ressembler à ceci :

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 mis en évidence montre la requête existante utilisée comme source des données de la nouvelle requête. Notez que la nouvelle requête utilise un alias (« co_authored_books ») pour la requête existante. Pour plus d’informations sur les alias, consultez Créer des alias de table (Visual Database Tools) et créer des alias de colonne (Visual Database Tools).

De même, une requête peut participer à une opération JOIN. Par exemple, vous pouvez trouver les ventes de livres coûteux co-écrits simplement en associant la vue ExpensiveBooks à la requête qui récupère les livres co-écrits. Le code SQL résultant peut ressembler à ceci :

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 Ajouter des tables à des requêtes (Visual Database Tools).

Utilisation d’une fonction User-Defined à la place d’une table

Dans SQL Server 2000 ou version ultérieure, vous pouvez créer une fonction définie par l’utilisateur qui retourne une table. Ces fonctions sont utiles pour effectuer une logique complexe ou procédurale.

Par exemple, supposons que la table employé contient une colonne supplémentaire, employee.manager_emp_id, et qu’une clé étrangère existe de manager_emp_id à employee.emp_id. Dans chaque ligne de la table des employés, la colonne manager_emp_id indique le supérieur hiérarchique de l’employé. Plus précisément, il indique le emp_id du patron de l’employé. Vous pouvez créer une fonction définie par l’utilisateur qui retourne une table contenant une ligne pour chaque employé travaillant dans la hiérarchie organisationnelle d’un responsable général particulier. Vous pouvez appeler la fonction fn_GetWholeTeam et la concevoir pour prendre une variable d’entrée , l’emp_id du responsable dont vous souhaitez récupérer l’équipe.

Vous pouvez écrire une requête qui utilise la fonction fn_GetWholeTeam comme source de données. Le code SQL résultant peut ressembler à ceci :

SELECT *   
FROM   
     fn_GetWholeTeam ('VPA30890F')  

« VPA30890F » est la emp_id du responsable dont vous souhaitez récupérer l’organisation. Pour plus d’informations sur l’ajout d’une fonction définie par l’utilisateur à une requête, consultez Ajouter des tables à des requêtes (Visual Database Tools). Pour obtenir une description complète des fonctions définies par l’utilisateur, consultez User-Defined Functions.