DQL group by : regrouper avec summarize et by:{}, l’équivalent du GROUP BY SQL

DQL group by avec summarize et by:{} : traduire un GROUP BY SQL, nommer les colonnes, gérer le groupe null, plusieurs clés, tranches bin() et HAVING.
DQL group by : regrouper avec summarize et by:{}, l'équivalent du GROUP BY SQL

Le DQL group by n’existe pas sous ce nom : dans Dynatrace Query Language, le regroupement se fait avec la commande summarize et son paramètre by:{}. Si vous venez de SQL, vous cherchez le réflexe SELECT … GROUP BY … ; en DQL, vous écrivez une agrégation, puis la liste des clés de regroupement, dans une seule commande placée dans le pipeline.

Ce guide montre la traduction pas à pas : une clé, plusieurs clés, les alias, le groupe null qui apparaît quand un champ manque, le regroupement par tranche de temps ou de valeur avec bin(), et l’équivalent du HAVING. Chaque syntaxe vient de la documentation DQL officielle, consultée en octobre 2026.

Le contenu vaut pour Dynatrace SaaS (plateforme Grail). Dynatrace Managed n’a ni Grail ni DQL : on y regroupe avec les métriques et le Data Explorer. Pour une vue d’ensemble des commandes, voir les commandes DQL commentées ; pour des requêtes prêtes à copier, voir nos requêtes DQL d’exploitation.

DQL group by : la correspondance avec SQL

La syntaxe documentée de la commande est la suivante :

summarize [field =] aggregation, ... [, by: {[field =] expression, ...}]

Trois différences avec SQL comptent au quotidien :

  • Pas de SELECT séparé : le résultat contient uniquement les clés du by et les agrégats. Les autres champs disparaissent.
  • L’ordre est celui du pipeline : le filter placé avant summarize joue le rôle du WHERE, celui placé après joue le rôle du HAVING.
  • Les accolades sont facultatives pour une seule clé : la page de comparaison DQL/SQL de la documentation écrit summarize count(), by:event.type.

La même page donne cet exemple d’agrégation :

fetch events
| filter event.type == "travel.funnel.booking-payment"
| summarize sum = sum(amount), by:travelAgency

En SQL, on écrirait SELECT sum(amount) AS sum FROM events WHERE … GROUP BY travelAgency.

Étape par étape : regrouper avec summarize

Étape 1 — Une clé et un agrégat

Compter les logs par niveau de sévérité :

fetch logs
| summarize nb = count(), by:{loglevel}

Chaque ligne du résultat correspond à une valeur distincte de loglevel. Les fonctions d’agrégation documentées incluent notamment count, countIf, countDistinct, sum, avg, min, max, percentile et takeFirst.

Étape 2 — Nommer les colonnes avec des alias

Un alias se place devant l’agrégat et devant la clé. Sans alias, la colonne porte le texte de l’expression, par exemple sum(value), peu pratique pour la suite du pipeline.

Exemple de la documentation DQL : summarize sum = sum(value), by: category = cat (entre accolades) sur cinq enregistrements, résultat category a = 9 et b = 11
Source : docs.dynatrace.com

Dans cet exemple tiré de la documentation, l’agrégat devient sum et la clé cat devient category. Les alias rendent les tris et les filtres suivants lisibles : | sort sum desc plutôt que de répéter l’expression.

Étape 3 — Regrouper sur plusieurs clés

Listez les clés entre accolades, séparées par des virgules. La documentation compte ainsi les niveaux de log par hôte et par groupe de processus :

fetch logs
| summarize {
      errors = countIf(loglevel == "ERROR"),
      warnings = countIf(loglevel == "WARN")
    },
    by: {
      dt.entity.host,
      dt.entity.process_group
    }

Notez les accolades autour des agrégats : elles regroupent plusieurs agrégations nommées. countIf remplace le classique SUM(CASE WHEN … THEN 1 ELSE 0 END) de SQL et produit plusieurs compteurs en une seule passe.

Étape 4 — Comprendre le groupe null

Si le champ de regroupement n’existe pas sur tous les enregistrements, summarize ajoute un groupe null au résultat. C’est le piège le plus fréquent : un total qui semble juste, mais une ligne null qui concentre une partie des données.

Exemple de la documentation DQL : summarize sum(value), by: category (entre accolades) sur des enregistrements dont deux n'ont pas de champ category, résultat a = 7, b = 10 et null = 3
Source : docs.dynatrace.com

Deux réponses possibles, selon le besoin :

// exclure les enregistrements sans clé
fetch logs
| filter isNotNull(k8s.namespace.name)
| summarize nb = count(), by:{k8s.namespace.name}

// ou garder la ligne null et l'investiguer
fetch logs
| summarize nb = count(), by:{k8s.namespace.name}
| sort nb desc

En exploitation, la ligne null révèle souvent un défaut d’enrichissement : des logs qui arrivent sans métadonnées Kubernetes, par exemple. L’exclure sans regarder masque le problème.

Étape 5 — Regrouper par tranche avec bin()

La fonction bin(expression, interval) arrondit une valeur vers le bas au multiple de l’intervalle. La documentation précise qu’elle est souvent utilisée avec summarize et by. Elle accepte un nombre, une durée ou un horodatage :

fetch logs
| summarize nb = count(), by:{minute = bin(timestamp, 1m), loglevel}
| sort minute asc

Pour une valeur numérique, bin(x, 10) range 27 dans la tranche 20 ; le paramètre optionnel at: décale les tranches (bin(x, 10, at:5) range 27 dans la tranche 25). C’est l’équivalent DQL d’un histogramme GROUP BY FLOOR(x / 10) * 10.

Pour des séries temporelles destinées à un graphique, la commande makeTimeseries, avec son propre paramètre by, produit des séries homogènes avec des intervalles réguliers. summarize avec bin() reste plus simple pour un tableau.

Étape 6 — L’équivalent du HAVING

Ajoutez un filter après le summarize :

fetch logs
| filter loglevel == "ERROR"
| summarize erreurs = count(), by:{dt.entity.host}
| filter erreurs > 100
| sort erreurs desc
| limit 10

Le premier filter réduit les données lues (le WHERE), le second garde les groupes qui dépassent le seuil (le HAVING). La commande sort accepte asc ou desc pour chaque champ.

Comment vérifier que le regroupement est juste

  • Contrôlez le total : lancez la même requête sans by. La somme des groupes doit égaler le total, groupe null compris.
  • Cherchez la ligne null : | filter isNull(ma_cle) après le summarize montre immédiatement si elle existe.
  • Vérifiez le cas vide : sans by et sans enregistrement en entrée, summarize renvoie quand même une ligne (count() à 0, les autres agrégats à null). Un tableau de bord doit afficher correctement ce cas, ainsi que le tableau vide d’une requête avec by quand aucun groupe ne ressort.

Bonnes pratiques

  • Filtrez avant de regrouper : moins de données lues, requête plus rapide et moins coûteuse.
  • Nommez systématiquement agrégats et clés : la requête reste lisible six mois plus tard, pendant une astreinte.
  • Évitez de regrouper sur un champ à forte cardinalité (identifiant de requête, contenu de log complet). La documentation limite la taille combinée des clés de regroupement à 128 kB par enregistrement et conseille de tronquer, par exemple avec substring(content, 0, 100).
  • Gardez la ligne null visible dans les requêtes de diagnostic ; ne la filtrez que dans les vues destinées aux utilisateurs.
  • Pour un SLI, regroupez par service et par statut, puis calculez le ratio dans une étape fieldsAdd : voir le parcours métriques Dynatrace SaaS.

Questions fréquentes

Existe-t-il une commande group by en DQL ?

Non. Le regroupement passe par summarize … by:{}. Pour obtenir seulement les valeurs distinctes, comme un SELECT DISTINCT, la documentation montre summarize count(), by:event.type suivi de fields event.type ; la commande dedup est une autre option.

Pourquoi mon résultat contient-il une ligne null ?

Parce qu’au moins un enregistrement ne porte pas le champ de regroupement. summarize le range dans un groupe null au lieu de l’ignorer. Filtrez avec isNotNull() avant le regroupement si ces enregistrements ne vous intéressent pas.

Quelle différence avec l’article sur les requêtes DQL d’exemple ?

Ce guide se concentre sur le regroupement et ses pièges. Les requêtes DQL d’exemple couvrent des cas complets d’exploitation, et la fonction DQL in() sert à filtrer sur une liste avant de regrouper.

Conclusion

Le DQL group by se résume à une habitude : écrire l’agrégat, puis by:{}, dans le même summarize. Nommer les colonnes, surveiller le groupe null, découper avec bin() et filtrer après le regroupement pour le HAVING suffisent à couvrir l’essentiel des requêtes d’exploitation. Pour aller plus loin sur la topologie, voir DQL et Smartscape.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Les marques citées appartiennent à leurs propriétaires. La syntaxe DQL évolue : vérifiez-la dans la documentation officielle avant de l’utiliser en production.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Comparatif LLM open source : licence, taille, VRAM et débit mesuré sur vLLM et Ollama

Comparatif LLM open source : licence, taille, VRAM et débit mesuré sur vLLM et Ollama

Next Post
DQL fonction in() : filtrer sur une liste, un tableau ou une sous-requête

DQL fonction in() : filtrer sur une liste, un tableau ou une sous-requête

Related Posts