POWERQUERY :: Template de requêtes - Explications sur le segment LET ... IN

[oguruma]

Ce post est à intérêt pédagogique et permet d'expliquer le fonctionnement du segment LET où on effectue les traitements et le segment IN où on les restitue.
Le modèles fournis pourront être repris pour construire vos propres requêtes selon leur complexité.

Requête avec un appel de fonction simple

(
    pParam1              as any,
    optional pParam2     as text,
    optional pParam3     as text,
    optional pParam4     as text
) =>

let
    Traitement1   = pParam1,
    Traitement2   = pParam2,
    Traitement3   = pParam3,
    Traitement4   = pParam4,
    Return        = Traitement1

in
    Return

Appel :

let
    Source = fnTemplateLevel1("Param1", "Param2", "Param3", "Param4")
in
    Source

Requête de fonction avec un LET imbriqué

let fnFunction =
    (
        pParam1              as any,
        optional pParam2     as text,
        optional pParam3     as text,
        optional pParam4     as text
    ) =>

    let
        Traitement1   = pParam1,
        Traitement2   = pParam2,
        Traitement3   = pParam3,
        Traitement4   = pParam4,
        Return        = Traitement1
    in
        Return
in
    fnFunction

Appel

let
    Source = fnTemplateLevel2("Param1", "Param2", "Param3", "Param4")
in
    Source

Requête fonction plus avancée - 1

let fnFunction =
    (
        pParam1              as any,
        optional pParam2     as text,
        optional pParam3     as text,
        optional pParam4     as text
    ) =>
   
    //-----------------------------------------------------------------------
    // Phase 2
    // Bloc LET appelé à l'issue de la phase 1
    //-----------------------------------------------------------------------
    let
        //--- Variables locales de la fonction
        Traitement1   = "(5) SEGMENT LET Phase 2 :: pParam1 = " & pParam1,
        Traitement2   = pParam2,
        Traitement3   = pParam3,
        Traitement4   = pParam4,
        Return        = Var3 & "(6) Valeur de Return : " & Traitement1
    in
        Return,
   
    //--- Variables locales d'appel accessibles par la fonction
    //-----------------------------------------------------------------------
    // Phase 1 : Ces traitements sont lancé en premier
    //-----------------------------------------------------------------------
    Traitement1="(1) Phase 1 - Traitement1 "  ,
    Var1 = " (2) Var1 ",
    Var2 = " (3) Var2 ",
    Var3 = Var1 & Var2 & " (4) Var3 " & Traitement1
    //---------------------------------------------------------------------------
    // Phase 1.1 : Puis à l'issue c'est le bloc LET qui prend le relai Phase 2
    //---------------------------------------------------------------------------
   
in
    //--- fnFunction récupère la valeur de Return
    //--- A la fin de traitements de la phase 2
    fnFunction

Appel

let
    Source = fnTemplateLevel3("Param1", "Param2", "Param3", "Param4")
in
    Source

Résultat

Requête fonction plus avancée - 2

let MainFunc = () as any =>

        //-----------------------------------------------------------------------
        // Liste des fonctions
        // A déclarer en tête de la requête afin qu'elles soient reconnues
        // Ces fonctions peuvent être considérées comme des sous-programmes
        // ou des fonctions au sens VBA
        //-----------------------------------------------------------------------
       
        let
            FuncA=() as text =>  
                let
                    //--- Variables locales de la fonction
                    Traitement1   = " (5) Appel de FuncA :: ",
                    Return        = Traitement1
                in
                    Return,

            FuncB = (msg as text) as any =>  
                let
                    //--- Variables locales de la fonction
                    Traitement1   = " (6) Appel de FuncB :: avec son message " & msg,
                    Return        = Traitement1
                in
                    Return,

            //--------------------------------------------------------------
            // Phase 2 : Traitements BLOC1
            //--------------------------------------------------------------
            Traitement1="(1) Traitement 1",
            Var1 = " (2) Var1 ",
            Var2 = " (3) Var2 ",
            Var3 = Var1 & Var2 & FuncA() & " (4) Var3 ",
            Var4 = FuncB("Message de FuncB") & " " & Var3 & VarMainFunc
        in  
            Var4 & " (7) Fin pour Var4 ",
       
        //---------------------------------------------------------------------------
        // Phase 1 : Au lancement de la fonction MainFunc()
        // Cette variable est volorisée
        // Puis appel des traitements BLOC1
        //---------------------------------------------------------------------------
        VarMainFunc=" (8) FIN pour MainFunc "
in
    //-------------------------------------------------------------------------
    // En fin de traitement MainFunc est valorisé par le contenu de Var4
    //------------------------------------------------------------------------
    MainFunc

Résultat

Requête avancée - 3

let
    FuncA=() as text =>  
        let
            //--- Variables locales de la fonction
            Traitement1   = "(5) FuncA :: Traitement1 :: ",
            Return        = Traitement1
        in
            Return,
    FuncB = (msg as text) as any =>  
        let
            //--- Variables locales de la fonction
            Traitement1   = msg & " (6) FuncB :: Traitement1 :: ",
            Return        = Traitement1
        in
            Return,
   
    //--- Variables locales d'appel accessibles par la fonction
    Traitement="(1) traitement ",
    Var1 = " (2) Var1 ",
    Var2 = " (3) Var2 ",
    Var3 = Var1 & Var2 & FuncA() & " (4) Var3 ",
    Var4 = Traitement & Var3 & FuncB("Message de FuncB")
in  
    Var4 & " :: Fin VAR4 dans le IN :: "

Résultat

 

[oguruma]

Une V2 avec d'autres exemples