Query ottimizzate con campi frammentati

Questa pagina descrive come visualizzare e controllare l'utilizzo dei campi suddivisi in Firestore. Questa opzione è disponibile nella versione Enterprise di Firestore.

Quando vengono scritti i documenti, Firestore può determinare che campi specifici devono essere archiviati in un formato frammentato. I campi frammentati ottimizzano le prestazioni delle query leggendo solo i campi richiesti anziché l'intero documento.

Query che traggono vantaggio dai campi suddivisi

Le letture sui campi frammentati vengono applicate alle seguenti forme di query, se applicabile:

  • Query di aggregazione: query che devono accedere solo a un sottoinsieme di campi per le operazioni di aggregazione. Ad esempio:

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

    o con il raggruppamento:

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

  • Query di proiezione: query che restituiscono solo un sottoinsieme specifico di campi. Ad esempio:

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

  • Query di filtro: query in cui il motore di query Firestore determina che l'utilizzo di campi suddivisi per il filtraggio dei documenti è vantaggioso. Ad esempio:

    db.pipeline()
  .collection("/customers")
  .where(equal("given_name", "alice"))

Visualizzare l'utilizzo dei campi eliminati

Puoi utilizzare Spiega query per verificare se una query utilizza campi frammentati. Il nodo TableScan nel piano di query include una sezione Storage con le seguenti metriche:

  • Forma della scansione:
    • shredded_fields_only: La query legge solo i campi frammentati.
    • shredded_fields_backjoin: La query legge i campi frammentati e si unisce al documento originale per altri campi.
  • Campi frammentati utilizzati: un elenco di nomi di campi letti come campi frammentati.
  • Conteggio dei ricontrolli: una mappa dei contatori per i ricontrolli. Un controllo significa tornare alla lettura del documento completo originale durante la scansione dei campi frammentati. Ciò può accadere se il valore del campo in un documento supera 8 KiB, che è troppo grande per l'archiviazione dei campi frammentati.

Output di esempio

...
└── • 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]

Controllare l'utilizzo dei campi frammentati

Per impostazione predefinita, Firestore utilizza i campi frammentati quando disponibili. Puoi controllare questo comportamento utilizzando l'opzione di query table_scan_method.

Valori supportati per l'opzione table_scan_method:

  • shredded_fields_enabled (impostazione predefinita): utilizza i campi frammentati, se disponibili.
  • shredded_fields_disabled: non utilizzare campi frammentati.
  • force_shredded_fields: la query non va a buon fine se non è possibile eseguire una scansione della tabella scansionando i campi frammentati.

Esempio

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();

Avvisi sul rendimento delle query

Firestore potrebbe generare avvisi relativi al rendimento nel risultato di spiegazione della query quando viene rilevato un utilizzo inefficiente dei campi frammentati. Ad esempio:

  • Query a bassa selettività: si verifica quando una query esegue la scansione dei campi frammentati per il filtraggio, ma filtra un numero troppo basso di documenti, rendendo la scansione inefficiente.

  • Query con molti controlli: si verifica quando la query esegue spesso il fallback alla lettura completa del documento, il che può influire sulle prestazioni. Puoi utilizzare funzioni come storage_size per identificare valori elevati che attivano i controlli.

In questi casi, valuta la possibilità di disattivare le letture dei campi frammentati utilizzando le opzioni di query.

Limitazioni

Firestore elimina solo i campi di primo livello. Inoltre, limita il numero di campi che possono essere eliminati per gruppo di raccolte.