Firestore im Datastore-Modus unterstützt die Verwendung von Bereichs- und Ungleichheitsfiltern für mehrere Properties in einer einzigen 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 Properties
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 mit Abfragen vertraut machen.
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. Bei diesem Ansatz wird ein Ergebnissatz generiert, der gemäß der Indexdefinition sortiert ist.
Um die Leistung und Kosten von Abfragen in Firestore im Datastore-Modus zu optimieren, sollten Sie die Reihenfolge der Properties 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 in einer Sammlung von Mitarbeitern nach Mitarbeitern in den USA suchen, deren Gehalt über 100.000 $ liegt und deren Berufserfahrung mehr als 0 Jahre beträgt. Aus Ihrer Kenntnis der Datasets wissen Sie, dass die Gehaltsbeschränkung selektiver ist als die Erfahrungsbeschränkung. 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. Durch diese Einschränkungen wird nicht die Anzahl der Indexeinträge reduziert, die von Firestore im Datastore-Modus gescannt werden. Es werden jedoch nicht übereinstimmende Entitäten herausgefiltert, sodass die Anzahl der an die Clients zurückgegebenen Entitäten verringert wird.
Weitere Informationen zum Erstellen effizienter Indexe finden Sie unter Indexstruktur und ‑definition und Indexe optimieren.
Attribute in absteigender Reihenfolge der Selektivität für die 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 in Firestore im Datastore-Modus gescannt und über das Netzwerk zurückgegeben werden, sollten Sie Eigenschaften immer in absteigender Reihenfolge der Selektivität der Abfrageeinschränkung sortieren. Wenn der Ergebnissatz nicht in der erforderlichen Reihenfolge ist und voraussichtlich klein ist, können Sie clientseitige Logik implementieren, um ihn gemäß Ihren Anforderungen neu anzuordnen.
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 eine Neuanordnung der Ergebnisse auf den Clients
vermeiden müssen, kann die Abfrage
viel mehr irrelevante Indexeinträge lesen als die vorherige Abfrage. Das liegt daran, dass in Firestore im Datastore-Modus immer ein Index bevorzugt wird, dessen Indexeigenschaften mit dem Präfix der ORDER BY-Klausel der Abfrage übereinstimmen. Wenn experience der Order-by-Klausel hinzugefügt wurde, wird in Firestore im Datastore-Modus der Index (experience [...], salary [...]) zum Berechnen der Abfrageergebnisse ausgewählt. 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 den salary-Filter nicht erfüllen, trotzdem gelesen werden, was die Latenz und die Kosten der Abfrage erhöht.
Preise
Abfragen mit Bereichs- und Ungleichheitsfiltern für mehrere Properties werden basierend auf den gelesenen Entitäten und Indexeinträgen abgerechnet.
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 werden, ist die Anzahl der Intervall- oder Ungleichheitsoperatoren in Firestore im Datastore-Modus auf 10 beschränkt.
Weitere Informationen
- Weitere Informationen zum Optimieren von Abfragen
- Weitere Informationen zum Ausführen einfacher und zusammengesetzter Abfragen
- Informationen zur Verwendung von Indexen in Firestore im Datastore-Modus