# Résultats et graphiques

> Filtrez et copiez les résultats, profilez chaque colonne, dessinez barres, courbes, nuages de points, secteurs et cartes, exportez en CSV ou Parquet.

Source: https://ducklocal.app/docs/fr/results-and-charts

Le panneau sous l'éditeur a trois onglets : **Résultats**, **Graphique** et
**Aperçu**. À droite des onglets se trouvent la taille du résultat
(`N rows · M columns`) et les boutons **Exporter en CSV** et **Exporter en Parquet**.

L'onglet **Résultats** affiche aussi ce que produisent les boutons **Explain** et
**Profile** de l'éditeur — voir [Sortie d'Explain et de Profile](#explain-and-profile).

## La grille de résultats

La grille commence par une colonne `#` de numéros de ligne, suivie des colonnes du résultat de la requête. Les colonnes numériques sont alignées à droite. Les largeurs initiales sont calculées à partir des en-têtes et des 200 premières lignes, en comptant les caractères chinois ou japonais pour deux caractères de large. Les largeurs vont de 80 à 360 pixels à la [taille de l'interface](settings-and-data.md#interface-size) par défaut et s'adaptent proportionnellement aux autres tailles. Faites glisser les bordures de colonne pour ajuster les largeurs ; la colonne `#` ne peut pas être redimensionnée.
Lorsque les colonnes sont plus larges que le panneau, une barre de défilement
horizontale reste visible sous elles.

Cliquez sur les flèches dans l'en-tête d'une colonne pour trier les lignes
chargées selon cette colonne : ordre décroissant, puis croissant, puis retour à
l'ordre de la requête. Les colonnes de nombres se trient comme des nombres, tout
le reste comme du texte (ce qui ordonne les dates et heures ISO), `NULL` se trie
en dernier, et les lignes de même valeur conservent l'ordre de la requête. Un
[filtre](#filtering) conserve le tri, et le résultat suivant démarre sans tri. Le
tri s'effectue côté client, comme le filtre : pour trier plus de lignes que celles
chargées, utilisez `ORDER BY`.

### Affichage des cellules

| Valeur | Affichage |
| --- | --- |
| `NULL` | la chaîne littérale `NULL`, dans une couleur atténuée |
| BLOB | `<blob N bytes>` |
| GEOMETRY | `<geometry N bytes>` |
| Nombre flottant à valeur entière | `3.0` |
| Horodatage | `2026-09-17 04:21:09.5` — **en UTC, pas en heure locale** ; la partie fractionnaire a autant de chiffres que la valeur (neuf pour TIMESTAMP_NS) |
| Intervalle | notation DuckDB, par exemple `1 day 02:00:00` |
| Liste / structure / map | joliment formaté |

L'affichage en UTC mérite d'être retenu si vous examinez des horodatages à l'œil
plutôt que de les comparer en SQL.

### Filtrage {#filtering}

Le champ de filtre effectue une recherche de sous-chaîne insensible à la casse
**sur toutes les cellules** des lignes chargées. Elle s'exécute côté client : elle
n'interroge jamais la base de données et ne porte que sur les lignes chargées, pas
sur la taille réelle du résultat.

Le filtre s'applique lorsque vous appuyez sur Entrée ou videz le champ, et non à
chaque frappe. Tant qu'un filtre est appliqué, la grille indique
`visible / total rows` à côté.

## Limites de lignes {#row-limits}

Les résultats sont tronqués dès que l'une de ces limites est atteinte en premier :

- **100 000 lignes**
- **2 000 000 de cellules** — un résultat de 400 colonnes ne produit donc qu'environ 5 000
  lignes

Le budget de cellules existe parce qu'un plafond de lignes ne borne pas le travail
à lui seul : un `PIVOT` sur une colonne à forte cardinalité renvoie une colonne par
valeur distincte, et formater des dizaines de millions de cellules donnerait
l'impression d'un blocage.

La troncature est signalée par un bandeau qui indique le nombre réel de lignes
chargées. Il n'y a **ni pagination ni « charger plus »** — restreignez plutôt la
requête.

## Copier

Survoler une cellule fait apparaître un bouton de copie qui place le texte de
cette cellule dans le presse-papiers. Faites un clic droit sur une cellule pour
**Copier la cellule**, **Copier la ligne** (séparée par des tabulations) ou
**Copier la colonne** (une valeur par ligne, dans l'ordre affiché). Faites un clic
droit sur un numéro de ligne pour copier sa ligne. Les copies suivent le filtre et
le tri en cours. Les tables des tableaux de bord proposent les mêmes trois actions
de copie. Il n'y a ni sélection de plage ni « copier en SQL » ; pour plus d'une
ligne ou d'une colonne, utilisez [l'export](#export).

## Export {#export}

`Export CSV` et `Export Parquet` ouvrent une petite boîte de dialogue avec un
champ de chemin, pré-rempli avec `~/Desktop/export.csv` ou
`~/Desktop/export.parquet`.

Deux points à connaître :

- L'export **réexécute le SQL qui a produit les lignes actuelles** : le fichier
  contient donc l'ensemble du résultat de la requête — ni la vue filtrée, ni la
  grille tronquée.
- Il n'y a ni sélecteur de fichier ni demande de confirmation d'écrasement.
  Saisissez un chemin, et il est écrit.

## Graphiques {#charts}

Tant que vous n'avez pas choisi de colonnes, un graphique est dessiné à partir des
lignes déjà présentes dans la grille, dans l'ordre où la requête les a renvoyées,
sans agrégation. Les [menus **X**, **Y** et **Répartition**](#pick-columns) font
plutôt regrouper tout le résultat par DuckDB.

Le sélecteur de graphique au-dessus du graphique démarre sur **Auto**, qui choisit
d'après les colonnes du résultat :

| Le résultat contient | Auto dessine |
| --- | --- |
| Une colonne de latitude et une de longitude | Une carte |
| Une première colonne temporelle (date / horodatage) | Un graphique en aires ; x correspond à la colonne 0, une série par colonne numérique |
| Tout le reste | Un graphique en barres ; la colonne 0 est l'étiquette, la première colonne numérique est la valeur |

« Colonne numérique » inclut la première colonne : si la colonne 0 est un nombre —
une heure, une année, un identifiant — elle devient la valeur du graphique en
barres, et non son étiquette. Convertissez-la en texte (`year::VARCHAR`, ou
`format('{:02d}:00', hour(ts))`) pour qu'elle serve d'étiquette.

**Barres**, **Courbes**, **Aires** et **Nuage de points** sont accessibles en un
clic pour tout résultat ; **Secteurs** pour un résultat dont la première colonne
n'est pas une date ou une heure, et **Carte** pour un résultat avec des
coordonnées. Le choix est conservé d'une exécution à l'autre ; lorsqu'un nouveau
résultat ne permet pas de le dessiner — une carte sans coordonnées — le graphique
revient au choix d'Auto sans oublier le vôtre.

### Choisir les colonnes {#pick-columns}

Les menus **X**, **Y** et **Répartition** au-dessus du graphique déterminent ce
qu'il dessine. **Y** est le nombre de lignes, ou la somme, la moyenne, le minimum
ou le maximum d'un nombre. DuckDB regroupe alors tout le résultat plutôt que les
lignes chargées, et conserve les 200 plus grandes catégories (ou les 50 000
premières valeurs ordonnées) ainsi que les 12 plus grandes séries. Un message
indique ce qui a été écarté.

- Avec une **Répartition** choisie, **Empilé** et **Carte de chaleur** rejoignent le sélecteur de graphique, et **Secteurs** en disparaît.
- **Histogramme** est proposé lorsqu'il y a un nombre à regrouper en classes. DuckDB calcule les classes sur tout le résultat.
- **Copier en .dash** copie votre choix sous forme d'un bloc `query` et d'un bloc `plot` qui dessinent le même graphique dans un [tableau de bord](dashboards.md).

Sans choix de colonnes, le graphique d'un résultat tronqué affiche **Dessiné à
partir des N premières lignes chargées par la grille, pas du résultat complet**.
Une série temporelle tronquée est réexécutée en arrière-plan et moyennée sur
toutes les lignes.

### Types de graphiques et limites

Un **camembert** dessine la valeur de la première colonne numérique par étiquette,
de la plus grande à la plus petite. Les valeurs à zéro, négatives et manquantes ne
sont pas dessinées en parts, et un message les compte ; au-delà de 8 parts, les 7
plus grandes conservent leur part et le reste est regroupé dans « autres ».

Une **carte** est choisie d'après les noms de colonnes :

- **Latitude :** `lat`, `latitude`, ou tout nom qui les contient (`geo_lat`,
  `start_lat`) — `纬度` fonctionne aussi.
- **Longitude :** `lng`, `lon`, `long`, `longitude`, de même — `经度` fonctionne
  aussi.

Chaque ligne est un point sur une projection Web Mercator ajustée aux points,
par-dessus une grille de latitude/longitude graduée en degrés ; une colonne de
texte qui n'a que quelques valeurs distinctes les colore. Survolez un point pour
voir sa ligne.

Sous les points, une carte de base OpenStreetMap peut être dessinée : activez-la
avec **Affichage → Carte de base en ligne (OpenStreetMap)**. Elle est désactivée
par défaut, car le chargement des tuiles nécessite le réseau — les requêtes
révèlent approximativement la zone consultée, jamais vos lignes. Les tuiles sont
mises en cache pendant une semaine ; hors ligne, la carte se dessine uniquement
par-dessus la grille de latitude/longitude.

Les lignes dont les cellules de valeur ne sont pas numériques — `NULL`, par
exemple — sont écartées avant le tracé.

Limites, toutes annoncées dans une ligne de message sous le titre du graphique :

| Limite | Comportement |
| --- | --- |
| 12 séries | Les colonnes numériques supplémentaires sont écartées |
| 1 500 points | La série est regroupée en classes et **moyennée** dans chaque classe |
| 200 barres | Les barres en trop sont tronquées, pas fusionnées |
| 8 parts de camembert | Les plus petites sont regroupées dans « autres » |
| 20 000 points de carte | Les points en trop sont omis |

Le titre indique toujours combien de points ont été tracés : vérifiez-le avant de
faire confiance à la forme d'une courbe.

## Aperçu des colonnes {#overview}

L'onglet **Aperçu** décrit d'un coup chaque colonne du résultat actuel : son taux
de remplissage, le nombre de valeurs qu'elle prend, sa plage, et l'allure de ses
valeurs.

La ligne de titre affiche `Current result · N rows · M columns · took …`. Ensuite,
chaque colonne occupe une ligne :

| Élément | Ce qu'il montre |
| --- | --- |
| Nom et type | Le nom de la colonne et son type DuckDB |
| Valeurs nulles | La part de lignes `NULL`, avec une petite barre ; mise en évidence lorsqu'elle dépasse 0 % |
| Distinctes | `~N distinct` — l'estimation par DuckDB du nombre de valeurs distinctes |
| Plage | Minimum – maximum, ou la valeur unique lorsqu'elles sont égales |
| Médiane | Pour les nombres, les dates et les horodatages |
| Distribution | Un petit graphique, décrit ci-dessous |

La distribution dépend du type de la colonne :

- **Nombres, dates et horodatages** : un histogramme d'environ 12 barres de
  largeur égale. Une colonne à valeur unique affiche cette valeur à la place.
- **Textes et booléens** : leurs 5 valeurs les plus fréquentes, chacune avec sa
  part de lignes ; survolez une valeur pour son nombre exact. Au-delà d'environ
  10 000 valeurs distinctes, les valeurs sont estimées et listées sous *Valeurs
  fréquentes (estimées)*, sans parts.
- **Listes, structures, maps et unions** : aucun graphique.

Fonctionnement :

- **L'aperçu réexécute la requête**, entière, en deux passes : `SUMMARIZE` pour
  les statistiques, puis un `SELECT` pour la distribution de chaque colonne. Il
  couvre donc le résultat complet, et pas seulement les lignes que la grille a
  conservées dans ses [limites de lignes](#row-limits) — et une requête lente
  redevient lente. Une requête non déterministe (`random()`, `USING SAMPLE`) est
  décrite telle qu'elle est sortie lors de cette seconde exécution.
- Il est calculé à l'ouverture de l'onglet, puis de nouveau pour chaque nouveau
  résultat tant que l'onglet est ouvert.
- **Seule une requête qui peut tenir dans `FROM ( … )` peut être résumée** : une
  requête qui commence par `SELECT`, `WITH`, `FROM`, `VALUES`, `TABLE`, `PIVOT`
  ou `UNPIVOT` (les commentaires `--` en tête sont ignorés). Tout le reste —
  `SHOW`, `DESCRIBE`, `PRAGMA`, `CALL`, `SUMMARIZE` — donne *Only the result of a
  query (SELECT, WITH, FROM…) can be summarized: the overview runs it again.*

Pour résumer une table, une vue ou un fichier enregistré entier sans écrire de
requête, faites un clic droit dessus dans la barre latérale et choisissez **Aperçu
des colonnes**. Cela place `FROM <name>;` dans l'éditeur, l'exécute et ouvre cet
onglet. Voir [Menu contextuel](schema-and-history.md#right-click-menu).

## Sortie d'Explain et de Profile {#explain-and-profile}

Les [boutons **Explain** et **Profile**](sql-editor.md#explain-and-profile) de la
barre d'outils de l'éditeur affichent leur sortie dans l'onglet **Résultats**, en y
basculant si un autre onglet était ouvert. L'un comme l'autre remplace la grille ;
réexécutez la requête pour retrouver ses lignes.

**Explain** affiche le plan de DuckDB sous forme de texte monospace brut sous une
ligne `EXPLAIN · took …`.

**Profile** affiche le plan réellement exécuté sous forme d'arbre, une ligne par
opérateur, chacun étant indenté sous l'opérateur qu'il alimente :

- une barre pour la part de l'opérateur dans le temps passé par tous les
  opérateurs ;
- le temps propre de l'opérateur, celui de ses enfants exclu ;
- son nom, par exemple `TABLE_SCAN`, `FILTER` ou `HASH_GROUP_BY` ;
- `N rows` — les lignes qu'il a produites ;
- `est. N` — l'estimation de ces lignes par l'optimiseur, lorsque le plan en
  fournit une. Elle est mise en évidence lorsqu'elle est fausse d'un facteur
  supérieur à 10 dans un sens ou dans l'autre (survolez-la pour voir
  *Estimate off by more than 10×*) : une erreur de cette ampleur est une cause
  fréquente de jointure lente ;
- en dessous, ce avec quoi l'opérateur a travaillé : filtres, clés de jointure,
  projections.

La ligne de titre affiche `Profile · took … · operators …` : le temps réel écoulé,
puis la somme des temps propres des opérateurs. Les deux diffèrent, car les
opérateurs d'un même pipeline s'exécutent en entrelacement ; les barres
représentent des parts du second. À côté, `Hottest: NAME (time)` nomme l'opérateur
qui a coûté le plus à lui seul, et sa ligne est dessinée en rouge.
