Requêtes optimisées avec des champs fragmentés

Cette page explique comment afficher et contrôler l'utilisation des champs fragmentés dans Firestore. Cette fonctionnalité est disponible dans Firestore Enterprise Edition.

Lorsque des documents sont écrits, Firestore peut déterminer que des champs spécifiques doivent être stockés dans un format fragmenté. Les champs fragmentés optimisent les performances des requêtes en ne lisant que les champs requis au lieu du document complet.

Requêtes qui bénéficient des champs fragmentés

Les lectures sur les champs fragmentés sont appliquées aux formes de requête suivantes, le cas échéant :

Requêtes d'agrégation : requêtes qui n'ont besoin d'accéder qu'à un sous-ensemble de champs pour les opérations d'agrégation. Exemple :

db.pipeline()
  .collection("/customers")
  .where(lessThan("account_balance", 0))
  .aggregate(
    countAll().as("total"),
  )

ou avec group-by :

db.pipeline()
  .collection("/customers")
  .where(lessThan("account_balance", 0))
  .aggregate({
    accumulators: [
      field('account_balance').average().as('avg_account_balance')
    ],
    groups: [field('market_segment')]
  })

Requêtes de projection : requêtes qui ne renvoient qu'un sous-ensemble spécifique de champs. Exemple :

db.pipeline()
  .collection("/customers")
  .select("family_name", "given_name")
  .limit(10)

Requêtes de filtrage : requêtes pour lesquelles le moteur de requête Firestore détermine qu'il est avantageux d'utiliser des champs fragmentés pour le filtrage des documents. Exemple :
```
db.pipeline()
  .collection("/customers")
  .where(equal("given_name", "alice"))
```

Afficher l'utilisation des champs fragmentés

Vous pouvez utiliser l'explication de la requête pour vérifier si une requête utilise des champs fragmentés. Le nœud TableScan du plan de requête inclut une section Storage avec les métriques suivantes :

Forme de l'analyse:
- shredded_fields_only : la requête ne lit que les champs fragmentés.
- shredded_fields_backjoin: la requête lit les champs fragmentés et les joint au document d'origine pour les autres champs.
Champs fragmentés utilisés : liste des noms de champs lus en tant que champs fragmentés.
Nombre de revérifications : carte des compteurs pour les revérifications. Une revérification signifie revenir à la lecture du document complet d'origine lors de l'analyse des champs fragmentés. Cela peut se produire si la valeur du champ dans un document dépasse 8 Kio, ce qui est trop volumineux pour le stockage des champs fragmentés.

Exemple de résultat :

...
└── • TableScan
        source: /customers
        order: UNDEFINED
        row range: (-∞..+∞)
        filter: ($account_balance_1 < 0L)
        output bindings: {$account_balance_1=account_balance, $market_segment_1=market_segment}
        variables: [$account_balance_1, $market_segment_1]

        Execution:
         records returned: 1,374
         latency: 26.58 ms
         post-filtered rows: 13,626
         records scanned: 15,000
         data bytes read: 23.73 MiB (24,887,141 B)

        Storage:
         scan shape: shredded_fields_only
         shredded fields used: [account_balance, market_segment]

Contrôler l'utilisation des champs fragmentés

Par défaut, Firestore utilise des champs fragmentés lorsqu'ils sont disponibles. Vous pouvez contrôler ce comportement à l'aide de l'option de requête table_scan_method.

Valeurs compatibles pour l'option table_scan_method :

shredded_fields_enabled (par défaut) : utiliser des champs fragmentés lorsqu'ils sont disponibles.
shredded_fields_disabled : ne pas utiliser de champs fragmentés.
force_shredded_fields: échouer la requête si une analyse de table ne peut pas être effectuée en analysant des champs fragmentés.

Exemple

var opts = new PipelineExecuteOptions()
    .with("table_scan_method", "shredded_fields_disabled");

var snapshot = db.pipeline()
    .collection("/customers")
    .where(equal("given_name", "alice"))
    .execute(opts)
    .get();

Avertissements concernant les performances des requêtes

Firestore peut émettre des avertissements concernant les performances dans le résultat de l'explication de la requête lorsqu'une utilisation inefficace des champs fragmentés est détectée. Exemple :

Requêtes à faible sélectivité : se produit lorsqu’une requête analyse des champs fragmentés pour le filtrage, mais filtre trop peu de documents, ce qui rend l’analyse inefficace.
Requêtes à revérification élevée : se produit lorsque la requête revient fréquemment à des lectures de documents complets, ce qui peut avoir un impact sur les performances. Vous pouvez utiliser des fonctions telles que storage_size pour identifier les valeurs volumineuses qui déclenchent des revérifications.

Dans ce cas, envisagez de désactiver les lectures de champs fragmentés à l'aide des options de requête.

Limites

Firestore ne fragmente que les champs de premier niveau. Il limite également le nombre de champs pouvant être fragmentés par groupe de collections.