Champs fragmentés

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

Lors de la rédaction de documents, Cloud Firestore peut déterminer que certains champs 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 s'appliquent 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 Cloud 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 supprimés

Vous pouvez utiliser l'explication de 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 la zone de détection :
  • 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 vérifications : carte des compteurs de vérifications. Une nouvelle vérification signifie un retour à la lecture du document complet d'origine lors de l'analyse des champs fragmentés. Cela peut se produire si la valeur d'un 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, Cloud Firestore utilise les 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 acceptées pour l'option table_scan_method :

• shredded_fields_enabled (par défaut) : utiliser les champs fragmentés lorsqu'ils sont disponibles.
• shredded_fields_disabled : n'utilisez pas de champs fragmentés.
• force_shredded_fields : échec de la requête si une analyse de table ne peut pas être effectuée en analysant les 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

Cloud Firestore peut émettre des avertissements de 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 produisent 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 avec un nombre élevé de vérifications : se produisent lorsque la requête revient fréquemment à la lecture complète du document, ce qui peut avoir un impact sur les performances. Vous pouvez utiliser des fonctions telles que storage_size pour identifier les valeurs élevées qui déclenchent des réexamens.

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

Limites

Cloud Firestore ne supprime que les champs de premier niveau. Il limite également le nombre de champs pouvant être supprimés par groupe de collecte.