POWERQUERY :: Application étendue du fnCaseOf -- Simulation du SELECT CASE en VBA

[oguruma]

Bonjour,
Ce post est une application concrète du post https://excel-downloads.com/threads...te-du-caseof-et-application-etendue.20083595/

Pour cela nous allons faire évoluer la fonction fnColumnsToSameTypeV2
présentée dans ce post https://excel-downloads.com/threads...t-ou-partie-des-colonnes-dune-table.20083500/ pour en arriver à une version simplifiée appliquant les principes du SELECT CASE en VBA.

fnColumnsToSameTypeV3

let fnColumnsToSameTypeV2 = (
                    pTable as any,
                    optional pColumnType as text,
                    optional pStartPosition as number,
                    optional pEndPosition as number,
                    optional pFunction as text) =>
        let

            
            Source = if pTable is text
                     then Excel.CurrentWorkbook(){[Name=pTable]}[Content]
                     else pTable,

            StartPosition=if pStartPosition is null then 0 else pStartPosition,
            EndPosition=if pEndPosition is null then 0 else pEndPosition,
            ColumnType=if pColumnType is null then "text" else pColumnType,
            Function=if pFunction is null then "R" else Text.Upper(pFunction),  // "F:L:R:N"

            StrType=  ColumnType,
            EvalColumnType=Expression.Evaluate(StrType,[Currency.Type=Currency.Type, Int64.Type=Int64.Type, Percentage.Type=Percentage.Type]),

            FunctionR = () =>
                    let
                        R= Table.TransformColumnTypes(
                                Source,
                                List.Transform(
                                    List.RemoveLastN(List.RemoveFirstN(Table.ColumnNames(Source),StartPosition),EndPosition),
                                    each {_, EvalColumnType}
                                    )
                            )
                    in
                        R,

            FunctionF = () =>
                    let
                        R= Table.TransformColumnTypes(
                                        Source,
                                        List.Transform(                                           
                                            List.FirstN(Table.ColumnNames(Source),StartPosition),
                                            each {_, EvalColumnType}
                                            )
                                    )
                    in
                        R,

            FunctionL = () =>
                    let
                        R= Table.TransformColumnTypes(
                                            Source,
                                            List.Transform(
                                                List.LastN(Table.ColumnNames(Source),StartPosition),
                                                each {_, EvalColumnType}
                                                )
                                        )
                    in
                        R,

            FunctionN = () =>
                    let
                        R=  Table.TransformColumnTypes(
                                                Source,
                                                List.Transform(
                                                    {Table.ColumnNames(Source){StartPosition - 1}},
                                                    each {_, EvalColumnType}
                                                    )
                                            )
                    in
                        R,

            ListCaseOf={
                        {"R", FunctionR()},
                        {"F", FunctionF()},
                        {"L", FunctionL()},
                        {"N", FunctionN()}
                    },

            TypeModified = fnCaseOf(ListCaseOf, Function)



        in
            TypeModified
in
    fnColumnsToSameTypeV2

La série de if...then...else imrbiqués a été tout simplement remplacée par

            ListCaseOf={

                        {"R", FunctionR()},

                        {"F", FunctionF()},

                        {"L", FunctionL()},

                        {"N", FunctionN()}

                    },

            TypeModified = fnCaseOf(ListCaseOf, Function)

Les fonctions appelées sont décrites en début de code juste après l'analyse des paramètres et l'initialisation de certaines valeurs. En effet les fonctions appelées doivent avoir accès à variables d'où la nécessité d'une déclaration préalable

Tous les détails se trouvent dans le fichier joint. Je vous laisse explorer ces requêtes qui appliquent cette nouvelle fonction