Ottimizzazione degli indici

Questa pagina descrive i concetti da considerare quando selezioni gli indici di Firestore in modalità Datastore per la tua app.

Firestore in modalità Datastore offre prestazioni elevate delle query utilizzando gli indici per tutte le query. Le prestazioni della maggior parte delle query dipendono dalle dimensioni del set di risultati e non dalle dimensioni totali del database.

Firestore in modalità Datastore definisce gli indici integrati per ogni proprietà di un'entità. Questi indici a singola proprietà supportano molte query semplici. Firestore in modalità Datastore supporta una funzionalità di unione degli indici che consente al database di unire gli indici integrati per supportare query aggiuntive. Per le query più complesse, devi definire in anticipo gli indici composti.

Questa pagina si concentra sulla funzionalità di unione degli indici, perché influisce su due importanti opportunità di ottimizzazione degli indici:

  • Velocizzazione delle query
  • Riduzione del numero di indici composti

L'esempio seguente mostra la funzionalità di unione degli indici.

Filtro delle entità Photo

Prendi in considerazione un database in modalità Datastore con entità di tipo Photo:

Foto
Proprietà Tipo di valore Descrizione
owner_id Stringa ID utente
tag Array di stringhe Parole chiave tokenizzate
size Numero intero Enumerazione:
  • 1 icon
  • 2 medium
  • 3 large
coloration Numero intero Enumerazione:
  • 1 black & white
  • 2 color

Immagina di aver bisogno di una funzionalità dell'app che consenta agli utenti di eseguire query sulle entità Photo in base a un AND logico di quanto segue:

  • Fino a tre filtri basati sulle proprietà:

    • owner_id
    • size
    • coloration

  • Una stringa di ricerca tag. L'app suddivide la stringa di ricerca in tag e aggiunge un filtro per ogni tag.

    Ad esempio, l'app trasforma la stringa di ricerca outside, family nei filtri della query tag=outside e tag=family.

Utilizzando gli indici integrati e la funzionalità di unione degli indici di Firestore in modalità Datastore, puoi soddisfare i requisiti di indice di questa funzionalità di filtro Photo senza aggiungere indici compositi aggiuntivi.

Gli indici incorporati per le entità Photo supportano query con un singolo filtro come:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_owner_id = client.query(kind="Photo", filters=[("owner_id", "=", "user1234")])

query_size = client.query(kind="Photo", filters=[("size", "=", 2)])

query_coloration = client.query(kind="Photo", filters=[("coloration", "=", 2)])

La funzionalità di filtro Photo richiede anche query che combinano più filtri di uguaglianza con un operatore logico AND:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_all_properties = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
    ],
)

Firestore in modalità Datastore può supportare queste query unendo gli indici integrati.

Unione degli indici

Firestore in modalità Datastore può utilizzare l'unione degli indici quando la query e gli indici soddisfano tutti i seguenti vincoli:

  • La query utilizza solo filtri di uguaglianza (=)
  • Non esiste alcun indice composito che corrisponda perfettamente ai filtri e all'ordinamento della query
  • Ogni filtro di uguaglianza corrisponde ad almeno un indice esistente con lo stesso ordinamento della query

In questa situazione, Firestore in modalità Datastore può utilizzare gli indici esistenti per supportare la query anziché richiedere la configurazione di un indice composto aggiuntivo.

Quando due o più indici vengono ordinati in base agli stessi criteri, Firestore in modalità Datastore può unire i risultati di più scansioni dell'indice per trovare i risultati comuni a tutti questi indici. Firestore in modalità Datastore può unire gli indici incorporati perché ordinano tutti i valori in base alla chiave dell'entità.

Unendo gli indici integrati, Firestore in modalità Datastore supporta le query con filtri di uguaglianza su più proprietà:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_all_properties = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
    ],
)

Firestore in modalità Datastore può anche unire i risultati dell'indice di più sezioni dello stesso indice. Unendo diverse sezioni dell'indice integrato per la proprietà tag, Firestore in modalità Datastore supporta le query che combinano più filtri tag in un'espressione logica AND:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_tag = client.query(
    kind="Photo",
    filters=[
        ("tag", "=", "family"),
        ("tag", "=", "outside"),
        ("tag", "=", "camping"),
    ],
)

query_owner_size_color_tags = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
        ("tag", "=", "outside"),
        ("tag", "=", "camping"),
    ],
)

Le query supportate dagli indici incorporati uniti completano il set di query richiesto dalla funzionalità di filtro Photo. Tieni presente che il supporto della funzionalità di filtro Photo non ha richiesto indici compositi aggiuntivi.

Quando selezioni gli indici ottimali per la tua app, è importante comprendere la funzionalità di unione degli indici. L'unione degli indici offre a Firestore in modalità Datastore una maggiore flessibilità delle query, ma con un possibile compromesso in termini di prestazioni. La sezione successiva descrive il rendimento dell'unione degli indici e come migliorarlo aggiungendo indici compositi.

Trovare l'indice perfetto

L'indice viene ordinato prima in base all'antenato e poi in base ai valori delle proprietà, nell'ordine specificato nella definizione dell'indice. L'indice composto perfetto per una query, che consente di eseguirla nel modo più efficiente, è definito sulle seguenti proprietà, in ordine:

  1. Proprietà utilizzate nei filtri di uguaglianza
  2. Proprietà utilizzate negli ordinamenti
  3. Proprietà utilizzate nel filtro distinctOn
  4. Proprietà utilizzate nei filtri di intervallo e disuguaglianza (non già incluse negli ordinamenti)
  5. Proprietà utilizzate in aggregazioni e proiezioni (non già incluse negli ordinamenti e nei filtri di intervallo e disuguaglianza)

In questo modo, vengono presi in considerazione tutti i risultati per ogni possibile esecuzione della query. I database Firestore in modalità Datastore eseguono una query utilizzando un indice perfetto seguendo questi passaggi:

  1. Identifica l'indice corrispondente al tipo, alle proprietà di filtro, agli operatori di filtro e agli ordini di ordinamento della query
  2. Esegue la scansione dall'inizio dell'indice alla prima entità che soddisfa tutte o un sottoinsieme delle condizioni di filtro della query
  3. Continua a scansionare l'indice, restituendo ogni entità che soddisfa tutte le condizioni del filtro, finché non
    • trova un'entità che non soddisfa le condizioni del filtro oppure
    • raggiunge la fine dell'indice oppure
    • ha raccolto il numero massimo di risultati richiesti dalla query

Ad esempio, considera la seguente query:

SELECT * FROM Task
WHERE category = 'Personal'
  AND priority < 3
ORDER BY priority DESC

L'indice composto perfetto per questa query è un indice delle chiavi per le entità di tipo Task, con colonne per i valori delle proprietà category e priority. L'indice viene ordinato prima in ordine crescente in base a category e poi in ordine decrescente in base a priority:

indexes:
- kind: Task
  properties:
  - name: category
    direction: asc
  - name: priority
    direction: desc

Due query dello stesso modulo, ma con valori di filtro diversi, utilizzano lo stesso indice. Ad esempio, la seguente query utilizza lo stesso indice della query precedente:

SELECT * FROM Task
WHERE category = 'Work'
  AND priority < 5
ORDER BY priority DESC

Per questo indice

indexes:
- kind: Task
  properties:
  - name: category
    direction: asc
  - name: priority
    direction: asc
  - name: created
    direction: asc

L'indice precedente può soddisfare entrambe le seguenti query:

SELECT * FROM Task
WHERE category = 'Personal'
  AND priority = 5
ORDER BY created ASC

e

SELECT * FROM Task
WHERE category = 'Work'
ORDER BY priority ASC, created ASC

Ottimizzazione della selezione degli indici

Questa sezione descrive le caratteristiche di rendimento dell'unione degli indici e due opportunità di ottimizzazione correlate all'unione degli indici:

  • Aggiungi indici composti per velocizzare le query che si basano su indici uniti
  • Riduci il numero di indici composti sfruttando gli indici uniti

Rendimento dell'unione degli indici

In un'unione di indici, Firestore in modalità Datastore unisce in modo efficiente gli indici utilizzando un algoritmo di unione zig-zag. Utilizzando questo algoritmo, la modalità Datastore unisce le potenziali corrispondenze di più scansioni dell'indice per produrre un insieme di risultati che corrisponde a una query. L'unione degli indici combina i componenti del filtro in fase di lettura anziché in fase di scrittura. A differenza della maggior parte delle query Firestore in modalità Datastore, in cui le prestazioni dipendono solo dalle dimensioni del set di risultati, le prestazioni delle query di unione degli indici dipendono dai filtri nella query e dal numero di potenziali corrispondenze prese in considerazione dal database.

Il rendimento migliore di un'unione di indici si verifica quando ogni potenziale corrispondenza in un indice soddisfa i filtri della query. In questo caso, il rendimento è O(R * I), dove R è la dimensione del set di risultati e I è il numero di indici scansionati.

Le prestazioni nel caso peggiore si verificano quando il database deve considerare molte corrispondenze potenziali, ma poche di queste soddisfano i filtri della query. In questo caso, il rendimento è O(S), dove S è la dimensione del più piccolo insieme di potenziali entità da una singola scansione dell'indice.

Il rendimento effettivo dipende dalla forma dei dati. Il numero medio di entità prese in considerazione per ogni risultato restituito è O(S/(R * I)). Le query hanno un rendimento peggiore quando molte entità corrispondono a ogni scansione dell'indice, ma poche entità corrispondono alla query nel suo complesso, il che significa che R è piccolo e S è grande.

Quattro fattori riducono questo rischio:

  • Il pianificatore di query non cerca un'entità finché non sa che l'entità corrisponde all'intera query.

  • L'algoritmo a zig-zag non ha bisogno di trovare tutti i risultati per restituire il risultato successivo. Se richiedi i primi 10 risultati, paghi solo la latenza per trovare questi 10 risultati.

  • L'algoritmo a zig-zag salta ampie sezioni di risultati falsi positivi. Il rendimento nel caso peggiore si verifica solo se i risultati dei falsi positivi sono perfettamente intrecciati (in ordine di ordinamento) tra le scansioni.

  • La latenza dipende dal numero di entità trovate in ogni scansione dell'indice, non dal numero di entità che corrispondono a ciascun filtro. Come mostrato nella sezione successiva, puoi aggiungere indici compositi per migliorare le prestazioni dell'unione degli indici.

Velocizzazione di una query di unione degli indici

Quando Firestore in modalità Datastore unisce gli indici, ogni scansione dell'indice spesso corrisponde a un singolo filtro nella query. Puoi migliorare le prestazioni delle query aggiungendo indici composti che corrispondono a più filtri nella query.

Considera questa query:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_owner_size_tag = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "username"),
        ("size", "=", 2),
        ("tag", "=", "family"),
    ],
)

Ogni filtro viene mappato a una scansione dell'indice nei seguenti indici incorporati:

Index(Photo, owner_id)
Index(Photo, size)
Index(Photo, tag)

Se aggiungi l'indice composito Index(Photo, owner_id, size), la query viene mappata a due scansioni dell'indice anziché tre:

#  Satisfies both 'owner_id=username' and 'size=2'
Index(Photo, owner_id, size)
Index(Photo, tag)

Prendi in considerazione uno scenario con molte immagini grandi, molte immagini in bianco e nero, ma poche immagini panoramiche di grandi dimensioni. Una query che filtra sia le immagini panoramiche che quelle in bianco e nero sarà lenta se unisce gli indici integrati:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_size_coloration = client.query(
    kind="Photo", filters=[("size", "=", 2), ("coloration", "=", 1)]
)

Per migliorare le prestazioni delle query, puoi ridurre il valore di S (il più piccolo insieme di entità in una singola scansione dell'indice) in O(S/(R * I)) aggiungendo il seguente indice composito:

Index(Photo, size, coloration)

Rispetto all'utilizzo di due indici incorporati, questo indice composito produce meno risultati potenziali per gli stessi due filtri di query. Questo approccio migliora notevolmente le prestazioni a costo di un indice in più.

Riduzione del numero di indici composti con l'unione degli indici

Sebbene gli indici compositi che corrispondono esattamente ai filtri di una query offrano il rendimento migliore, non è sempre ottimale o possibile aggiungere un indice composito per ogni combinazione di filtri. Devi bilanciare gli indici composti in base a quanto segue:

  • Limiti degli indici composti:

    Limite Importo
    Numero massimo di indici composti per un database
    Somma massima delle dimensioni delle voci dell'indice composto di un'entità 2 MiB
    Somma massima dei seguenti elementi per un'entità:
    • numero di valori di proprietà indicizzati
    • numero di voci dell'indice composto
    		 20.000
  • Costi di archiviazione di ogni indice aggiuntivo.
  • Effetti sulla latenza di scrittura.

I problemi di indicizzazione si verificano spesso con i campi multivalore come la proprietà tag delle entità Photo.

Ad esempio, supponiamo che la funzionalità di filtro Photo ora debba supportare clausole di ordinamento decrescente basate su quattro proprietà aggiuntive:

Foto
Proprietà Tipo di valore Descrizione
date_added Numero intero Data/ora
rating Numero in virgola mobile Valutazione complessiva degli utenti
comment_count Numero intero Numero di commenti
download_count Numero intero Numero di download

Se non tieni conto del campo tag, è possibile selezionare indici compositi che corrispondono a ogni combinazione di filtri Photo:

Index(Photo, owner_id, -date_added)
Index(Photo, owner_id, -comments)
Index(Photo, size, -date_added)
Index(Photo, size, -comments)
...
Index(Photo, owner_id, size, -date_added)
Index(Photo, owner_id, size, -comments)
...
Index(Photo, owner_id, size, coloration, -date_added)
Index(Photo, owner_id, size, coloration, -comments)

Il numero totale di indici composti è:

2^(number of filters) * (number of different orders) = 2 ^ 3 * 4 = 32 composite indexes

Se provi a supportare fino a tre filtri tag, il numero totale di indici compositi è:

2 ^ (3 + 3 tag filters) * 4 = 256 indexes.

Gli indici che includono proprietà multivalore come tag portano anche a problemi di indice esplosivo che aumentano i costi di archiviazione e la latenza di scrittura.

Per supportare i filtri nel campo tag per questa funzionalità, puoi ridurre il numero totale di indici facendo affidamento sugli indici uniti. Il seguente insieme di indici compositi è il minimo richiesto per supportare la funzionalità di filtro Photo con ordinamento:

Index(Photo, owner_id, -date_added)
Index(Photo, owner_id, -rating)
Index(Photo, owner_id, -comments)
Index(Photo, owner_id, -downloads)
Index(Photo, size, -date_added)
Index(Photo, size, -rating)
Index(Photo, size, -comments)
Index(Photo, size, -downloads)
...
Index(Photo, tag, -date_added)
Index(Photo, tag, -rating)
Index(Photo, tag, -comments)
Index(Photo, tag, -downloads)

Il numero di indici composti definiti è:

(number of filters + 1) * (number of orders) = 7 * 4 = 28

L'unione degli indici offre anche i seguenti vantaggi:

  • Consente a un'entità Photo di supportare fino a 1000 tag senza limiti al numero di filtri tag per query.
  • Riduce il numero totale di indici, il che riduce i costi di archiviazione e la latenza di scrittura.

Selezionare gli indici per l'app

Puoi selezionare gli indici ottimali per il database in modalità Datastore utilizzando due approcci:

  • Utilizzare l'unione degli indici per supportare query aggiuntive

    • Richiede meno indici composti
    • Riduce il costo di archiviazione per entità
    • Migliora la latenza di scrittura
    • Evita indici enormi
    • Il rendimento dipende dalla forma dei dati

  • Definisci un indice composto che corrisponda a più filtri in una query

    • Migliora il rendimento delle query
    • Prestazioni delle query coerenti che non dipendono dalla forma dei dati
    • Deve rimanere al di sotto del limite di indici composti
    • Aumento del costo di archiviazione per entità
    • Aumento della latenza di scrittura

Quando determini gli indici ottimali per la tua app, la risposta può cambiare man mano che la forma dei dati cambia. Il campionamento delle prestazioni delle query ti dà una buona idea delle query comuni della tua app e delle query lente. Con queste informazioni, puoi aggiungere indici per migliorare il rendimento delle query comuni e lente.