Übersicht über Abfragen mit Bereichs- und Ungleichheitsfiltern für mehrere Attribute

Firestore im Datastore-Modus unterstützt die Verwendung von Bereichs- und Ungleichheitsfiltern für mehrere Attribute in einer einzelnen Abfrage. Diese Funktion gibt Bereichs- und Ungleichheitsbedingungen für mehrere Attribute an und vereinfacht Ihrer Anwendungsentwicklung, indem Sie die Implementierung der Nachfilterung Logik an Firestore im Datastore-Modus.

Bereichs- und Ungleichheitsfilter für mehrere Attribute

In der folgenden Abfrage werden Bereichsfilter für Priorität und Tage verwendet, um alle Aufgaben zurückzugeben mit einer Priorität größer als 4 und einer Dauer von weniger als drei Tagen.

Go

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)

Hinweise zur Indexierung

Bevor Sie Abfragen ausführen, sollten Sie sich zu Abfragen.

Wenn keine ORDER BY-Klausel angegeben ist, verwendet Firestore im Datastore-Modus einen beliebigen Index, die Filterbedingung der Abfrage für die Abfrage erfüllen kann. Dieser Ansatz führt zu einem Ergebnis festgelegt, der gemäß der Indexdefinition geordnet wird.

So optimieren Sie die Leistung und Kosten von Firestore-Abfragen im Datastore-Modus: die Reihenfolge der Attribute im Index optimieren. Stellen Sie dazu sicher, dass Ihre ist von links nach rechts geordnet, sodass die Abfrage Dataset, das das Scannen überflüssiger Indexeinträge verhindert.

Angenommen, Sie möchten eine Gruppe von Mitarbeitenden durchsuchen, US-Mitarbeitende finden,deren Gehalt mehr als 100.000 US-Dollar beträgt und deren Anzahl Erfahrung in Jahren ist größer als 0. Basierend auf Ihrem Verständnis der wissen Sie, dass die Gehaltsbeschränkung selektiver ist die Einschränkung der Nutzererfahrung. Ein Index, der die Anzahl der Indexscans reduziert, ist der (salary [...], experience [...])-Index. So kann eine schnelle und kostengünstige Abfragereihenfolgen salary vor experience, wie im folgenden Beispiel gezeigt:

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 Practices für die Optimierung von Indexen

Beachten Sie beim Optimieren von Indexen die folgenden Best Practices.

Sortieren Sie Abfragen nach Gleichheit, gefolgt vom selektivesten Bereich oder Ungleichheitsfeld

Firestore im Datastore-Modus verwendet die Attribute eines zusammengesetzten Index ganz links, um die Gleichheitseinschränkungen sowie gegebenenfalls den Bereich und die Ungleichheitseinschränkung auf der ersten Feld der orderBy()-Abfrage. Diese Einschränkungen können die Anzahl der Indexeinträge, die Firestore im Datastore-Modus scannt. Firestore im Datastore-Modus verwendet die verbleibenden des Index, um andere Bereichs- und Ungleichheitseinschränkungen des Abfrage. Diese Einschränkungen verringern nicht die Anzahl der Indexeinträge, Firestore im Datastore-Modus führt Scans durch, filtert aber nicht übereinstimmende Entitäten heraus, sodass die Anzahl der an die Clients zurückgegebene Entitäten.

Weitere Informationen zum Erstellen effizienter Indexe finden Sie unter Indexstruktur und Definition und Optimierung von Indexen.

Attribute in absteigender Reihenfolge der Auswahl der Abfrageeinschränkung sortieren

Damit Firestore im Datastore-Modus den optimalen Index für Ihre Abfrage auswählt, gibt eine orderBy()-Klausel an, die Bereichs- und Ungleichheitsattribute basierend auf wie selektiv ihre Einschränkungen in Ihrer Abfrage sind, beginnend mit selektiv. Höhere Selektivität stimmt mit weniger Entitäten überein, während die Selektivität geringer ist stimmt mit mehr Entitäten überein. Tragen Sie in die Indexreihenfolge Bereich und Ungleichheit ein Eigenschaften mit höherer Selektivität vor Eigenschaften mit geringerer Selektivität.

Um die Anzahl der Entitäten zu minimieren, die Firestore im Datastore-Modus scannt und über die sie zurückgegeben wird sollten Sie die Properties immer in absteigender Reihenfolge zur Auswahl der Einschränkungsselektivität. Wenn die Ergebnismenge nicht in der erforderlichen Reihenfolge liegt und der erwartet wird, dass die Ergebnismenge klein ist, können Sie clientseitige Logik implementieren, und bestell ihn entsprechend deinen Erwartungen neu.

Wenn Sie z. B. eine Reihe von Mitarbeitenden durchsuchen möchten, US-Mitarbeitende suchen, deren Gehalt mehr als 100.000 US-Dollar beträgt, und die Ergebnisse nach Jahr der Berufserfahrung der Mitarbeitenden. Wenn Sie erwarten, dass nur wenige ein Gehalt von mehr als 100.000 US-Dollar haben,ist dies eine effiziente Möglichkeit, lautet die Abfrage:

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`

Wenn Sie der Abfrage eine experience-Reihenfolge hinzufügen, erhalten Sie den gleichen Satz. und die Neuanordnung der Ergebnisse auf den Clients umgehen, kann die Abfrage viel mehr irrelevante Indexeinträge lesen als die vorherige Abfrage. Das liegt daran, Firestore im Datastore-Modus bevorzugt immer einen Index, dessen Indexattribut-Präfix mit dem Klausel der Abfrage. Wurden der Klausel „Order by“ experience hinzugefügt, wählt Firestore im Datastore-Modus den Index (experience [...], salary [...]) aus zur Berechnung von Abfrageergebnissen. Da es keine anderen Einschränkungen experience, Firestore im Datastore-Modus liest alle Indexeinträge der employees aus, bevor Sie den Filter salary anwenden, um das endgültige Ergebnismenge. Das bedeutet, dass Indexeinträge, die die salary nicht erfüllen, Filter immer noch gelesen, wodurch sich die Latenz und die Kosten der Abfrage erhöhen.

Preise

Abfragen mit Bereichs- und Ungleichheitsfiltern für mehrere Attribute werden in Rechnung gestellt. basierend auf gelesenen Entitäten und gelesenen Indexeinträgen.

Ausführliche Informationen finden Sie auf der Preisseite.

Beschränkungen

Abgesehen von den Abfrageeinschränkungen müssen Sie folgende Einschränkungen beachten, Abfragen mit Bereichs- und Ungleichheitsfiltern für mehrere Attribute verwenden:

• Damit Abfragen nicht zu teuer für die Ausführung werden, begrenzt Firestore im Datastore-Modus die Anzahl der Bereichs- oder Ungleichheitsoperatoren auf 10.

Weitere Informationen

• Informationen zum Optimieren von Abfragen
• Weitere Informationen zum Ausführen einfacher und zusammengesetzter Abfragen
• Verwendung von Indexen in Firestore im Datastore-Modus