[Power Query] - Mesurer le temps d'exécution d'une requête

Bonsoir à tous !

Pour répondre à une sollicitation, vous trouverez ci-après un tutoriel rapide pour effectuer un test comparatif sur la vélocité de différentes requêtes.

Cette proposition est le fruit d'échanges longs et très laborieux avec une IA

Mode opératoire : Power Query de Power BI Desktop (la requête est non fonctionnelle dans Power Query Excel)

Menu Outils / Options de Diagnostic / Chargement des données : on vide les caches avant le test.

Menu Outils / Options de Diagnostic / Diagnostic

(Je ne sais plus les options par défaut.... la copie écran reflète mes choix du moment...!)

Une fois ces options mises en place, et le test peut démarrer :

Après avoir cliquer sur le bouton idoine, pointer chacune des requêtes à comparer et "Actualiser l'aperçu".

Après la dernière requête, mettre fin au diagnostic.

Cette dernière étape va générer une requête nommée Diagnostics_Aggregated_"année-mois-jour_heure-minute"

La requête que je propose ("Test comparatif") va chercher le dernier diagnostic produit et le retraiter pour retourner les informations voulues.

Elle ne s'intéresse qu'au temps cumulé. Mais il est possible, pour une requête particulière, de forer pour analyser le temps des différentes étapes.

Code de la requête :

let
    Source = #sections[Section1], 
    ConvTbl = Record.ToTable(Source), 
    Filtre_Aggregated = Table.SelectRows(
        ConvTbl, 
        each Text.StartsWith([Name], "Diagnostics_Aggregated")
    ), 
    TriDécroissant = Table.Sort(Filtre_Aggregated, {{"Name", 1}}), 
    Requete_analysée = TriDécroissant[Value]{0}, 
    Filtre = Table.SelectRows(Requete_analysée, each ([Query] <> null)), 
    GroupBy_Méthodes = Table.Group(
        Filtre, 
        {"Query"}, 
        {{"Durée", each List.Sum([Exclusive Duration]), type nullable duration}}
    ), 
    Rang = Table.AddRankColumn(GroupBy_Méthodes, "Rang", {"Durée", 0}), 
    Ecart = Table.AddColumn(
        Rang, 
        "Ecart", 
        each 
            let
                min = List.Min(Rang[Durée])
            in
                if min = [Durée] then null else ([Durée] - min) / min, 
        Percentage.Type
    )
in
    Ecart

Bonsoir à tous, à Jfl,

J'étais partit à la recherche sur Google d'une solution permettant la mesure du temps d'exécution d'une requête.

Malheureusement pour moi, ma version de PQ (ou d'Excel) ne me le permets pas, je n'ai pas accès à Diagnostics de requête, la fenêtre suivante s'arrête à la ligne relative à la version (2.61.5192.52227 64 bits)

Voici le résultat de la recherche :

En Power Query (M), il n’existe pas de fonction native qui mesure directement la vélocité (temps d’exécution) des autres requêtes.
Cependant, on peut mettre en place une requête d’analyse de performance en utilisant une approche de profilage

Dans l’éditeur Power Query :

• Onglet : Affichage → activer Profilage des colonnes et Qualité des colonnes.
• Onglet : Outils → Diagnostiquer → Démarrer le diagnostic puis Arrêter le diagnostic.
• Power Query génère alors deux tables :
  • Diagnostics_Detailed
  • Diagnostics_Summary

Ces tables contiennent :

• Nom de la requête exécutée
• Étapes internes
• Temps d’exécution (en millisecondes)
• Nombre de lignes traitées

Une fois le diagnostic arrêté, vous pouvez créer une requête qui analyse ces données.

<h5>M</h5>Copier le code<code>let
    // Charger la table de diagnostic détaillé
    Source = Diagnostics_Detailed,

    // Garder uniquement les colonnes utiles
    ColonnesUtile = Table.SelectColumns(Source, {"Query", "Step", "Duration", "Exclusive Duration"}),

    // Convertir la durée en secondes
    AjoutSec = Table.AddColumn(ColonnesUtile, "Durée (sec)", each Duration.TotalSeconds([Duration]), type number),

    // Regrouper par requête pour obtenir le temps total
    Regroupé = Table.Group(AjoutSec, {"Query"}, {
        {"Temps total (sec)", each List.Sum([Durée (sec)]), type number},
        {"Nombre d'étapes", each Table.RowCount(_), Int64.Type}
    }),

    // Trier par temps décroissant
    Trié = Table.Sort(Regroupé, {{"Temps total (sec)", Order.Descending}})
in
    Trié
</code>

Cette requête vous donnera :

• Nom de la requête
• Temps total d’exécution
• Nombre d’étapes
• Classement par lenteur décroissante

Cela reprends en partie la solution proposée par Jfl,

Le code proposé que je ne peux pas tester pour avoir le temps par étape est le suivant :

let
    // Charger la table de diagnostic détaillé
    Source = Diagnostics_Detailed,

    // Sélectionner uniquement les colonnes utiles
    ColonnesUtile = Table.SelectColumns(Source, {"Query", "Step", "Duration"}),

    // Convertir la durée en secondes
    AjoutSec = Table.AddColumn(
        ColonnesUtile,
        "Durée (sec)",
        each Duration.TotalSeconds([Duration]),
        type number
    ),

    // Regrouper par requête pour obtenir les statistiques
    Regroupé = Table.Group(
        AjoutSec,
        {"Query"},
        {
            {"Temps total (sec)", each List.Sum([Durée (sec)]), type number},
            {"Nombre d'étapes", each Table.RowCount(_), Int64.Type},
            {"Temps moyen par étape (sec)", each List.Average([Durée (sec)]), type number}
        }
    ),

    // Trier par temps total décroissant
    Trié = Table.Sort(Regroupé, {{"Temps total (sec)", Order.Descending}})
in
    Trié

Cordialement,

Merci à vous deux pour vos fils

Power Bi, je l'avais téléchargé, essayé, et il m'a mis un peu le "brin" dans mon univers "Office"...

Je vais donc ré-essayer, pour voir

Au plaisir