Référence de l'exécution des requêtes

Concepts courants

Les concepts et termes courants suivants sont utilisés dans l'arborescence d'exécution.

Lignes et enregistrements

Les termes ligne et enregistrement sont utilisés de manière générique pour désigner un document ou une entrée d'index.

Variables

Les variables internes suivantes peuvent apparaître dans les nœuds d'exécution :

• __key__ : la clé est un identifiant interne pour un document. Il s'agit d'un identifiant absolu et unique avec le projet, la base de données et le chemin d'accès complet du document.
• __id__ : l'ID est un identifiant unique pour un document au sein de sa collection. Il est unique au sein d'une même collection.
• __$0__…__$N__ : il s'agit de variables spécifiques au contexte qui sont créées ou référencées dans l'arborescence d'exécution. Ces variables sont généralement utilisées pour faire référence au contenu d'un document ou à la valeur d'une expression évaluée lors de l'exécution d'une requête.

Prenons l'exemple d'un nœud d'extension utilisé pour extraire __id__ du document __key__ :

Extend
    |  expressions: [_id(__key__) AS __id__]
    |  records returned: 1

Contraintes et plages

Certains nœuds d'analyse utilisent les attributs constraints et ranges pour décrire la plage de valeurs analysées. Ces attributs utilisent un format d'arborescence de plage qui contient une liste de valeurs. Ces valeurs correspondent à la liste ordonnée des clés qui figurent dans la définition de l'index. Par exemple, la première plage qui apparaît dans l'arborescence, ici (1..5], correspond aux contraintes sur la première clé, ici a, dans la liste ordonnée des clés :

| index: type=CollectionGroupIndex, id=CICAgOjXh#EK, keys=[a ASC, b ASC, __key__ ASC]
| constraints: /
               |----(1..5]
                    |----[1L]

Chaque niveau d'indentation indique la contrainte qui s'applique à la clé suivante de la liste. Les crochets représentent une plage inclusive, tandis que les parenthèses représentent une plage exclusive. Dans ce cas, la contrainte se traduit par 1 < "a" <= 5 et "b" = 1.

Dans l'exemple suivant avec plusieurs branches pour a, la contrainte correspond à 1 < a <= 5 OR a = 10 :

| constraints: /
               |----(1L, 5L]
               |----[10L]

Variables clés

Dans certains nœuds d'analyse (comme SequentialScan), il existe à la fois une liste de clés dans l'attribut index et un attribut keys distinct dans le nœud Scan. L'attribut keys du nœud Scan indique le nom de variable de chaque clé dans la définition de l'index, dans l'ordre. Les variables peuvent être utilisées pour référencer les valeurs d'exécution du champ analysé plus haut dans l'arborescence d'exécution.

Dans l'exemple suivant, la valeur du champ user pour le document actuel est mappée à la variable __$6__ et la valeur de date_placed à __$7__.

index: type=CollectionGroupIndex, id=CICAgOjXh4EK, keys=[user ASC, date_placed ASC, __path__ ASC]
keys: [__$6__ ASC, __$7__ ASC, __path__ ASC]

Nœuds d'exécution

Un arbre d'exécution de requête peut contenir les nœuds suivants.

SeekingScan

Représente une analyse dynamique où les lignes renvoyées peuvent ne pas se trouver dans une seule plage séquentielle de l'index, et où plusieurs analyses distinctes doivent être effectuées pour répondre à la requête.

Par exemple, une requête où a existe et où b est égal à 1 fonctionnant sur un index de ["a" ASC, "b" ASC] devrait analyser et renvoyer une plage distincte, potentiellement non séquentielle, pour chaque valeur distincte de a. Cette méthode est plus efficace qu'un TableScan complet, mais moins efficace qu'un seul SequentialScan sur un index composite de ["b" ASC, "a" ASC].

• SeekingScan
| constraints: /
               |----(-∞..+∞)
                    |----[1L]
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, quantity ASC, __key__ ASC]
| keys: [__$1__ ASC, __$2__ ASC, __key__ ASC]
| properties: Selection { user }
| records returned: 1
| records scanned: 1

SequentialScan

Représente l'analyse d'une plage statique et séquentielle de lignes dans le stockage, qui peut être effectuée en une seule opération de lecture.

key ordering length désigne le nombre de clés qui doivent être conservées et renvoyées dans l'ordre d'origine. Pour un schéma de [k1, k2, k3], une longueur d'ordre de clé de 0 signifie que l'analyse peut renvoyer les résultats dans n'importe quel ordre, 1 signifie que l'ordre est celui de k1, mais que les lignes ayant la même valeur k1 peuvent être dans n'importe quel ordre, et 3 renvoie les documents dans un ordre trié exact.

• SequentialScan
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, date_placed ASC, __key__ ASC]
| key ordering length: 3
| keys: [__$1__ ASC, __$2__ ASC, __key__ ASC]
| limit: 10
| properties: Selection { a }
| ranges: /
| records returned: 1
| records scanned: 1

UniqueScan

Représente un scan d'une plage statique et séquentielle de lignes dans le stockage avec déduplication en mémoire des lignes.

• UniqueScan
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, date_placed ASC, __key__ ASC]
| keys: [__$1__ ASC, __$2__ ASC, __key__ ASC]
| properties: Selection { a }
| ranges: /
          |----(-∞..+∞)
| records returned: 1
| records scanned: 1

TableAccess

Effectue une jointure arrière de l'identifiant de la ligne fournie avec le contenu réel de la ligne à partir du stockage principal. TableAccess est obligatoire si un nœud parent (ou le résultat final de la requête) nécessite un sous-ensemble de champs des documents.

• TableAccess
|  order: PRESERVE_INPUT_ORDER
|  peak memory usage: 4.00 KiB (4,096 B)
|  properties: *
|  records returned: 1

TableScan

Analyse complète et non ordonnée d'une collection. Utilisé lorsqu'une requête est exécutée sans index associé.

L'ordre peut être STABLE ou UNDEFINED, STABLE désignant un ordre déterministe.

• TableScan
|  order: STABLE
|  properties: *
|  records returned: 1
|  records scanned: 1
|  source: (default)#/**/collection

HashAggregate

Implémentation basée sur le hachage des opérations d'agrégation. Nécessite de matérialiser l'intégralité du groupe en mémoire avant de renvoyer le résultat et ne doit pas dépasser la limite de mémoire des requêtes.

• HashAggregate
|  aggregations: [sum(__$0__) AS total]
|  groups: [a]
|  peak memory usage: 4.00 KiB (4,096 B)
|  records returned: 0

StreamAggregate

Nœud agrégé spécialisé qui ne conserve l'état que d'un seul groupe à la fois, ce qui réduit l'utilisation maximale de la mémoire. Utilisé lorsque le nœud enfant sous-jacent renvoie les groupes de manière séquentielle. Par exemple, lorsque vous regroupez des valeurs distinctes d'un champ tout en utilisant un index sur ce champ.

• StreamAggregate
|  keys: [foo ASC, bar ASC]
|  properties: Selection { baz }
|  aggregations: [$sum(foo) AS baz]

MajorSort

Effectue une opération de tri sur un ensemble fixe de propriétés. Matérialise tous les enregistrements en mémoire à la fois et renvoie les valeurs triées dans l'ordre. La taille de l'ensemble de tri est limitée par la limite de mémoire de la requête.

Lorsqu'une limite ultérieure est fournie, un algorithme de tri top-k est utilisé pour réduire l'utilisation de la mémoire. Il permet de trier un ensemble de données arbitrairement grand, à condition que la mémoire utilisée pour stocker les k éléments considérés ne dépasse pas la limite.

• MajorSort
|  fields: [a ASC, b DESC]
|  limit: 10
|  peak memory usage: 4.00 KiB (4,096 B)
|  records returned: 1

Concat

Concatène les résultats de plusieurs nœuds enfants et renvoie le résultat au nœud parent. Ce nœud ne déduplique pas les résultats qui apparaissent dans plusieurs enfants, et l'ordre des résultats renvoyés est non déterministe.

• Concat
├── • TableAccess
...
├── • TableAccess

Limiter

Projette un ensemble de propriétés à transmettre à son nœud parent. Réduit l'utilisation de la mémoire en empêchant la propagation des champs inutilisés dès qu'ils ne sont plus pertinents pour le reste de la requête.

• Restrict
|  expressions: [foo AS foo, bar AS bar]
|  records returned: 0

Prolonger

Ajoute un ensemble de champs à chaque ligne de l'ensemble de résultats. Utilisé lors de l'ajout de champs à un document et comme nœud intermédiaire pour prendre en charge des opérations plus complexes.

• Extend
|  expressions: ["bar" AS foo]
|  records returned: 1

Filtre

Renvoie sélectivement les lignes si et seulement si elles correspondent à l'expression fournie.

• Filter
|  expression: $eq(foo, "bar")
|  records returned: 1

Valeurs

Produit une séquence de valeurs littérales sur lesquelles travailler. Utilisé principalement lorsqu'une liste de documents est fournie comme entrée d'une requête.

• Values
| expression: [{__key__=/col/1}, {__key__=/col/2}]

ReplaceWith

Remplace les champs des lignes produites par le nœud enfant par les champs de l'expression map fournie.

• ReplaceWith
|  map: map("full_name", str_concat(first_name, " ", last_name)), current_context())
|  records returned: 1

Désimbriquer

Annule l'imbrication de la valeur générée par le nœud enfant.

• Unnest
|  expression: foo AS unnested_foo

Limite

Limite le nombre de lignes renvoyées au nœud parent.

• Limit
|  limit: 10
|  records returned: 1

Décalage (offset)

Ignore un nombre défini de lignes produites par le nœud enfant.

• Offset
|  offset: 10
|  records returned: 1

Drop

Supprime un ensemble de champs spécifié des résultats générés par le nœud enfant.

• Drop
|  fields to drop: [__key__]
|  records returned: 1