Panoramica delle query con filtri per intervallo e disuguaglianza su più proprietà

Firestore in modalità Datastore supporta l'utilizzo di filtri per intervalli e disuguaglianze su più proprietà in una singola query. Questa funzionalità fornisce condizioni di intervallo e disuguaglianza su più proprietà e semplifica dello sviluppo delle tue applicazioni delega l'implementazione dell'applicazione post-filtro a Firestore in modalità Datastore.

Filtri per intervallo e disuguaglianza su più proprietà

La seguente query utilizza filtri di intervallo per priorità e giorni per restituire tutte le attività con priorità maggiore di quattro e con meno di tre giorni per il completamento.

Vai

query := datastore.NewQuery("Task").
   FilterField("priority", ">", 4).
   FilterField("days", "<", 3).

GQL

SELECT * FROM /tasks WHERE priority > 4 AND days < 3;

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
      .setKind("Task")
      .setFilter(
        CompositeFilter.and(
            PropertyFilter.gt("priority", 4), PropertyFilter.lt("days", 3)))
    .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('priority', '>', 4),
      new PropertyFilter('days', '<', 3),
    ])
  );

Python

from google.cloud import datastore
client = datastore.Client()
query = client.query(kind="Task")
query.add_filter(filter=PropertyFilter("priority", ">", 4))
query.add_filter(filter=PropertyFilter("days", "<", 3))

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 4)
    ->filter('days', '<', 3)

C#

Query query = new Query("Task")
{
  Filter = Filter.And(Filter.GreaterThan("priority", 4),
    Filter.LessThan("days", 3))
};

Ruby

query = datastore.query("Task")
                 .where("priority", ">", 4)
                 .where("days", "<", 3)

Considerazioni sull'indicizzazione

Prima di iniziare a eseguire query, assicurati di aver letto sulle query.

Se non viene specificata una clausola ORDER BY, Firestore in modalità Datastore utilizza qualsiasi indice che soddisfare la condizione di filtro della query per gestirla. Questo approccio produce un risultato un insieme ordinato in base alla definizione dell'indice.

Per ottimizzare le prestazioni e i costi di Firestore in modalità Datastore, a ottimizzare l'ordine delle proprietà dell'indice. A questo scopo, assicurati che l'indice è ordinato da sinistra a destra in modo che la query si distilla che impedisce la scansione delle voci di indice estranee.

Ad esempio, supponiamo che tu voglia cercare in una raccolta di dipendenti per trovare dipendenti statunitensi il cui stipendio è superiore a 100.000 $e il cui numero di anni è superiore a 0. In base alla tua comprensione delle di dati, sai che il vincolo retributivo è più selettivo rispetto limitato in termini di esperienza. Un indice che riduce il numero di scansioni dell'indice è Indice (salary [...], experience [...]). Il risultato è una soluzione rapida ed economica ordini di query salary prima di experience, come mostrato nell'esempio seguente:

GQL

SELECT *
FROM /employees
WHERE salary > 100000 AND experience > 0
ORDER BY salary, experience

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(
        CompositeFilter.and(
            PropertyFilter.gt("salary", 100000), PropertyFilter.gt("experience", 0)))
    .setOrderBy(OrderBy("salary"), OrderBy("experience"))
    .build();

Node.js

const query = datastore
  .createQuery("employees")
  .filter(
    and([
      new PropertyFilter("salary", ">", 100000),
      new PropertyFilter("experience", ">", 0),
       ])
    )
  .order("salary")
  .order("experience");

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.add_filter("experience", ">", 0)
query.order = ["-salary", "-experience"]

Best practice per l'ottimizzazione degli indici

Quando ottimizzi gli indici, tieni presente le seguenti best practice.

Ordina le query in base alle uguaglianze seguite dal campo intervallo o disuguaglianza più selettivo

Firestore in modalità Datastore utilizza le proprietà più a sinistra di un indice composto per soddisfare i vincoli di uguaglianza e i vincoli di intervallo e disuguaglianza, se presenti, primo campo della query orderBy(). Questi vincoli possono ridurre il numero voci di indice analizzate da Firestore in modalità Datastore. Firestore in modalità Datastore utilizza le risorse proprietà dell'indice per soddisfare altri vincoli di intervallo e disuguaglianza query. Questi vincoli non riducono il numero di voci di indice che Firestore in modalità Datastore esegue le analisi, ma filtrano le entità senza corrispondenza in modo che il numero le entità restituite ai clienti sono ridotte.

Per saperne di più sulla creazione di indici efficienti, consulta Struttura degli indici e definizione e ottimizzare gli indici.

Proprietà dell'ordine in ordine decrescente di selettività del vincolo di query

Per assicurarti che Firestore in modalità Datastore selezioni l'indice ottimale per la query, specificare una clausola orderBy() che stabilisce che gli ordini variano e le proprietà di disuguaglianza su quanto sono selettivi i loro vincoli nella query, a partire dal selettivo. Una selettività più alta corrisponde a meno entità, mentre una selettività più bassa corrisponde ad altre entità. Nell'ordine dell'indice, metti intervallo e disuguaglianza con una maggiore selettività, prima di quelle con un livello di selettività più basso.

Per ridurre al minimo il numero di entità che Firestore in modalità Datastore analizza e restituisce rete, dovresti sempre ordinare le proprietà nell'ordine decrescente di query selettività del vincolo. Se i risultati non sono nell'ordine richiesto e i valori di risultati previsti è ridotto, puoi implementare la logica lato client e riordinalo come previsto.

Ad esempio, se vuoi cercare in una raccolta di dipendenti per trovare dipendenti statunitensi il cui stipendio è superiore a $100.000 e ordinare i risultati in base anno di esperienza del dipendente. Se prevedi che solo un numero limitato i dipendenti avranno uno stipendio superiore a 100.000 dollari, quindi un modo efficiente scrivere la query è il seguente:

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(PropertyFilter.gt("salary", 100000))
    .setOrderBy(OrderBy("salary"))
    .build();
QueryResults<Entity> results = datastore.run(query);
// Order results by `experience`

Node.js

const query = datastore
  .createQuery("employees")
  .filter(new PropertyFilter("salary", ">", 100000))
  .order("salary");
const [entities] = await datastore.runQuery(query);
// Order results by `experience`

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.order = ["salary"]
results = query.fetch()
// Order results by `experience`

L'aggiunta di un ordinamento su experience alla query produrrà lo stesso set di entità ed evitare il riordinamento dei risultati sui client, la query e leggere molte altre voci di indice estranee rispetto alla query precedente. Questo perché Firestore in modalità Datastore preferisce sempre un indice il cui prefisso delle proprietà indice corrisponde in ordine decrescente della query. Se experience venisse aggiunto alla clausola Ordina per, Firestore in modalità Datastore selezionerà l'indice (experience [...], salary [...]) per il calcolo dei risultati delle query. Poiché non ci sono altri vincoli experience, Firestore in modalità Datastore leggerà tutte le voci di indice del Raccolta employees prima di applicare il filtro salary per trovare quella finale insieme di risultati. Ciò significa che le voci di indice che non soddisfano il salary vengono ancora letti, aumentando così la latenza e il costo della query.

Prezzi

Le query con filtri per intervallo e disuguaglianze su più proprietà vengono fatturate in base alle entità lette e alle voci di indice lette.

Per informazioni dettagliate, consulta la pagina Prezzi.

Limitazioni

Oltre alle limitazioni per le query, tieni presente le seguenti limitazioni prima di utilizzando query con filtri per intervallo e disuguaglianze su più proprietà:

  • Per evitare che le query diventino troppo costose da eseguire, Firestore in modalità Datastore limita il numero di operatori di intervalli o disuguaglianze a 10.

Passaggi successivi