Diese Seite wurde von der Cloud Translation API übersetzt.

Datastore-Abfragen

Mit einer Abfrage werden von Firestore im Datastore-Modus Entitäten abgerufen, die bestimmte Bedingungen erfüllen.

Die Abfrage wird für Entitäten einer bestimmten Art ausgeführt. Sie kann Filter für die Attributwerte, Schlüssel und Ancestors der Entitäten angeben sowie null oder mehr Entitäten als Ergebnisse zurückgeben. Außerdem können mit einer Abfrage Sortierfolgen festgelegt werden, um die Ergebnisse nach ihren Attributwerten zu sortieren. Die Ergebnisse umfassen alle Entitäten mit mindestens einem Wert für jedes Attribut, das in den Filtern und Sortierfolgen angegeben wird, und deren Attributwerte alle angegebenen Filterkriterien erfüllen. Die Abfrage kann ganze Entitäten, projizierte Entitäten oder Entitätsschlüssel zurückgeben.

Eine typische Abfrage umfasst:

Eine Entitätsart, auf die die Abfrage angewendet wird
Null oder mehr Filter basierend auf den Attributwerten, Schlüsseln und Ancestors der Entitäten
Null oder mehr Sortierfolgen zur Anordnung der Ergebnisse

Bei der Ausführung ruft die Abfrage alle Entitäten der angegebenen Art ab, die alle Filter erfüllen, und sortiert sie in der angegebenen Reihenfolge. Abfragen haben nur Leseberechtigungen.

Hinweis: Um Arbeitsspeicher zu sparen und die Leistung zu verbessern, sollte eine Abfrage, wenn möglich, eine Höchstzahl zurückgegebener Ergebnisse angeben.

Bei jeder Abfrage werden die Ergebnisse anhand eines oder mehrerer Indexe berechnet, die Entitätsschlüssel in einer von den Indexattributen vorgegebenen Reihenfolge und optional auch die Ancestors der Entität enthalten. Diese Indexe werden inkrementell aktualisiert, um die von den Anwendungen durchgeführten Änderungen an den Entitäten widerzuspiegeln und so ohne weitere Berechnung exakte Ergebnisse für alle Abfragen zur Verfügung zu stellen.

Der indexbasierte Abfragemechanismus unterstützt ein breites Spektrum an Abfragen und eignet sich für die meisten Anwendungen, außer für Abfragen ohne Skalierung, wie z. B. Join-Abfragen. Für Weitere Informationen zu Einschränkungen des Datastore-Modus erhalten Sie unter Einschränkungen bei Abfragen.

Abfrageschnittstelle

Sie können eine Abfrage für einen Datastore-Modus ausführen Datenbank. Im folgenden Beispiel wird gezeigt, wie alle noch nicht erledigten Aufgaben mit einer Priorität größer als oder gleich 4 in absteigender Reihenfolge nach Priorität abgerufen werden:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Datastore zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.Equal("done", false),
        Filter.GreaterThanOrEqual("priority", 4)),
    Order = { { "priority", PropertyOrder.Types.Direction.Descending } }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie unter Cloud Datastore-Clientbibliotheken Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Datastore zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

query := datastore.NewQuery("Task").
	FilterField("Done", "=", false).
	FilterField("Priority", ">=", 4).
	Order("-Priority")

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.eq("done", false), PropertyFilter.ge("priority", 4)))
        .setOrderBy(OrderBy.desc("priority"))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('done', '=', false),
      new PropertyFilter('priority', '>=', 4),
    ])
  )
  .order('priority', {
    descending: true,
  });

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->filter('done', '=', false)
    ->filter('priority', '>=', 4)
    ->order('priority', Query::ORDER_DESCENDING);

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("done", "=", False))
query.add_filter(filter=datastore.query.PropertyFilter("priority", ">=", 4))
query.order = ["-priority"]

Ruby

query = datastore.query("Task")
                 .where("done", "=", false)
                 .where("priority", ">=", 4)
                 .order("priority", :desc)

GQL

SELECT * FROM Task
WHERE done = FALSE AND priority >= 4
ORDER BY priority DESC

Das folgende Beispiel zeigt, wie eine Abfrage ausgeführt wird:

C#

Query query = new Query("Task");
DatastoreQueryResults tasks = _db.RunQuery(query);

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

it := client.Run(ctx, query)
for {
	var task Task
	_, err := it.Next(&task)
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatalf("Error fetching next task: %v", err)
	}
	fmt.Printf("Task %q, Priority %d\n", task.Description, task.Priority)
}

Java

QueryResults<Entity> tasks = datastore.run(query);

Node.js

const [tasks] = await datastore.runQuery(query);
console.log('Tasks:');
tasks.forEach(task => console.log(task));

PHP

$result = $datastore->runQuery($query);

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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

query = client.query()
results = list(query.fetch())

Ruby

tasks = datastore.run query

GQL

Nicht zutreffend

Abfragestruktur

Für eine Abfrage können ein Entitätstyp, null oder mehr Filter sowie null oder mehr Sortierfolgen angegeben werden.

Filter

Die Filter einer Abfrage legen Einschränkungen für die Attribute, Schlüssel und Ancestors der abzurufenden Entitäten fest.

Attributfilter

In einem Attributfilter wird Folgendes angegeben:

Ein Attributname
Ein Vergleichsoperator
Ein Attributwert

Im folgenden Beispiel werden Aufgabenentitäten zurückgegeben, die als nicht erledigt markiert sind:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Filter = Filter.Equal("done", false)
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

query := datastore.NewQuery("Task").FilterField("Done", "=", false)

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.eq("done", false))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(new PropertyFilter('done', '=', false));

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('done', '=', false);

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("done", "=", False))

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .where("done", "=", false)

GQL

SELECT * FROM Task WHERE done = FALSE

Der Attributwert muss von der Anwendung angegeben werden; er kann keine anderen Attribute referenzieren oder anhand anderer Attribute berechnet werden. Eine Entität erfüllt den Filter, wenn sie ein Attribut mit dem angegebenen Namen enthält, dessen Wert dem im Filter angegebenen Wert in der vom Vergleichsoperator beschriebenen Weise entspricht. Wenn das Attribut mit dem angegebenen Namen einen Arraywert enthält, erfüllt die Entität den Filter, wenn einer der Werte dem in dem Filter angegebenen Wert in der vom Vergleichsoperator beschriebenen Weise entspricht.

Einer der folgenden Vergleichsoperatoren kann verwendet werden:

Operator	Bedeutung
`EQUAL`	Gleich
`LESS_THAN`	Weniger als
`LESS_THAN_OR_EQUAL`	Kleiner als oder gleich
`GREATER_THAN`	Größer als
`GREATER_THAN_OR_EQUAL`	Größer als oder gleich
`NOT_EQUAL`	Ungleich
`IN`	Mitglied der angegebenen Liste. Entspricht einem der Werte in einer angegebenen Liste.
`NOT_IN`	Sie sind kein Mitglied der angegebenen Liste. Entspricht keinem der Werte in einer angegebenen Liste.

Zusammengesetzte Filter

Ein zusammengesetzter Filter besteht aus mehr als einem Attributfilter. Sie können und kombinieren Sie Filter mit AND und OR. Im folgenden Beispiel werden Task-Entitäten zurückgegeben, die als nicht erledigt markiert sind und die Priorität 4 haben:

C#

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.Equal("done", false),
        Filter.Equal("priority", 4)),
};

Go

query := datastore.NewQuery("Task").
	FilterField("Done", "=", false).
	FilterField("Priority", "=", 4)

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.eq("done", false), PropertyFilter.eq("priority", 4)))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('done', '=', false),
      new PropertyFilter('priority', '=', 4),
    ])
  );

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('done', '=', false)
    ->filter('priority', '=', 4);

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("done", "=", False))
query.add_filter(filter=datastore.query.PropertyFilter("priority", "=", 4))

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Ruby API Referenzdokumentation.

query = datastore.query("Task")
                 .where("done", "=", false)
                 .where("priority", "=", 4)

GQL

SELECT * FROM Task WHERE done = FALSE AND priority = 4

Im folgenden Beispiel werden Filter mit einem logischen OR kombiniert:

C#

Snippet nicht verfügbar.

Go

Snippet nicht verfügbar.

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für den Datastore-Modus finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Datastore-Modus-Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich beim Datastore-Modus zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.cloud.datastore.Datastore;
import com.google.cloud.datastore.DatastoreOptions;
import com.google.cloud.datastore.Entity;
import com.google.cloud.datastore.Query;
import com.google.cloud.datastore.QueryResults;
import com.google.cloud.datastore.StructuredQuery.CompositeFilter;
import com.google.cloud.datastore.StructuredQuery.Filter;
import com.google.cloud.datastore.StructuredQuery.PropertyFilter;

public class OrFilterQuery {
  public static void invoke() throws Exception {

    // Instantiates a client
    Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
    String propertyName = "description";

    // Create the two filters
    Filter orFilter =
        CompositeFilter.or(
            PropertyFilter.eq(propertyName, "Feed cats"),
            PropertyFilter.eq(propertyName, "Buy milk"));

    // Build the query
    Query<Entity> query = Query.newEntityQueryBuilder().setKind("Task").setFilter(orFilter).build();

    // Get the results back from Datastore
    QueryResults<Entity> results = datastore.run(query);

    if (!results.hasNext()) {
      throw new Exception("query yielded no results");
    }

    while (results.hasNext()) {
      Entity entity = results.next();
      System.out.printf("Entity: %s%n", entity);
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für den Datastore-Modus finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Datastore-Modus-Node.js API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich im Datastore-Modus zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = "your Google Cloud project id";

// Imports the Cloud Datastore
const {Datastore, PropertyFilter, or} = require('@google-cloud/datastore');

async function queryFilterOr() {
  // Instantiate the Datastore
  const datastore = new Datastore();
  const query = datastore
    .createQuery('Task')
    .filter(
      or([
        new PropertyFilter('description', '=', 'Buy milk'),
        new PropertyFilter('description', '=', 'Feed cats'),
      ])
    );

  const [entities] = await datastore.runQuery(query);
  for (const entity of entities) {
    console.log(`Entity found: ${entity['description']}`);
  }
}

queryFilterOr();

PHP

Snippet nicht verfügbar.

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für den Datastore-Modus finden Sie hier. Weitere Informationen finden Sie in der Python API im Datastore-Modus Referenzdokumentation.

from google.cloud import datastore
from google.cloud.datastore import query


def query_filter_or(project_id: str) -> None:
    """Builds a union of two queries (OR) filter.

    Arguments:
        project_id: your Google Cloud Project ID
    """
    client = datastore.Client(project=project_id)

    or_query = client.query(kind="Task")
    or_filter = query.Or(
        [
            query.PropertyFilter("description", "=", "Buy milk"),
            query.PropertyFilter("description", "=", "Feed cats"),
        ]
    )

    or_query.add_filter(filter=or_filter)

    results = list(or_query.fetch())
    for result in results:
        print(result["description"])

Ruby

Snippet nicht verfügbar.

GQL

Snippet nicht verfügbar.

Firestore im Datastore-Modus unterstützt die Kombination von Filtern mit AND und OR . Im folgenden Beispiel werden Task-Entitäten zurückgegeben, die entweder markiert sind oder sind nicht erledigt und haben die Priorität 4:

C#

Snippet nicht verfügbar.

Go

Snippet nicht verfügbar.

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(CompositeFilter.or(
            PropertyFilter.eq("starred", true)),
            CompositeFilter.and(
                PropertyFilter.eq("done", false),
                PropertyFilter.eq("priority", 4)))
        .build();

Node.js

Snippet nicht verfügbar.

PHP

Snippet nicht verfügbar.

Python

and_or_query = client.query(kind="Task")

query_filter = query.Or(
    [
        query.PropertyFilter("starred", "=", True),
        query.And([query.PropertyFilter("done", "=", False),
                    query.PropertyFilter("priority", "=", 4,),
        ]
        )
    ]
)

and_or_query.add_filter(filter=query_filter)

results = and_or_query.fetch()
for result in results:
    print(result["description"])

Ruby

Snippet nicht verfügbar.

GQL

Snippet nicht verfügbar.

Schlüsselfilter

Zum Filtern mit dem Wert eines Entitätsschlüssels verwenden Sie das spezielle Attribut __key__.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Filter = Filter.GreaterThan("__key__", _keyFactory.CreateKey("aTask"))
};

Go

key := datastore.NameKey("Task", "someTask", nil)
query := datastore.NewQuery("Task").FilterField("__key__", ">", key)

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.gt("__key__", keyFactory.newKey("someTask")))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    new PropertyFilter('__key__', '>', datastore.key(['Task', 'someTask']))
  );

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore PHP API Referenzdokumentation.

$query = $datastore->query()
    ->kind('Task')
    ->filter('__key__', '>', $datastore->key('Task', 'someTask'));

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
first_key = client.key("Task", "first_task")
# key_filter(key, op) translates to add_filter('__key__', op, key).
query.key_filter(first_key, ">")

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .where("__key__", ">", datastore.key("Task", "someTask"))

GQL

SELECT * FROM Task WHERE __key__ > KEY(Task, 'someTask')

Bei einem Vergleich auf Ungleichheit werden die Schlüssel nach den folgenden Kriterien in folgender Reihenfolge angeordnet:

Ancestor-Pfad
Entitätsart
Kennzeichnung (Schlüsselname oder numerische ID)

Elemente des Ancestor-Pfads werden ähnlich verglichen: nach Art (String), dann nach Schlüsselname oder numerischer ID. Arten und Schlüsselnamen sind Strings und werden nach Bytewert sortiert; numerische IDs sind ganze Zahlen und werden numerisch sortiert. Wenn Entitäten mit derselben übergeordneten Entität und derselben Art eine Mischung aus Schlüsselnamen-Strings und numerischen IDs verwenden, stehen die Entitäten mit numerischen IDs vor den Entitäten mit Schlüsselnamen.

Abfragen auf Schlüssel verwenden genau wie Abfragen auf Attribute Indexe und erfordern in denselben Fällen benutzerdefinierte Indexe. Für die folgenden Ausnahmen ist kein benutzerdefinierter Index erforderlich:

Ungleichheitsfilter
Aufsteigende Sortierreihenfolge nach dem Schlüssel

Für eine absteigende Sortierung nach dem Schlüssel ist ein benutzerdefinierter Index erforderlich. Wie bei allen Abfragen erstellt der Entwicklungsserver entsprechende Einträge in der Indexkonfigurationsdatei, wenn eine Abfrage, die einen benutzerdefinierten Index erfordert, in der Entwicklungsumgebung verwendet wird.

Sortierfolgen

Eine Abfrage-Sortierfolge gibt Folgendes an:

Einen Attributnamen
Eine Sortierfolge (aufsteigend oder absteigend); standardmäßig ist die Sortierfolge aufsteigend

Dieses Beispiel sortiert Aufgabenentitäten nach Erstellungszeit in aufsteigender Reihenfolge:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Order = { { "created", PropertyOrder.Types.Direction.Ascending } }
};

Go

query := datastore.NewQuery("Task").Order("created")

Java

Query<Entity> query =
    Query.newEntityQueryBuilder().setKind("Task").setOrderBy(OrderBy.asc("created")).build();

Node.js

const query = datastore.createQuery('Task').order('created');

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->order('created');

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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

query = client.query(kind="Task")
query.order = ["created"]

Ruby

query = datastore.query("Task")
                 .order("created", :asc)

GQL

SELECT * FROM Task ORDER BY created ASC

Dieses Beispiel sortiert Aufgabenentitäten nach Erstellungszeit in absteigender Reihenfolge:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Order = { { "created", PropertyOrder.Types.Direction.Descending } }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

query := datastore.NewQuery("Task").Order("-created")

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder().setKind("Task").setOrderBy(OrderBy.desc("created")).build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Node.js API.

const query = datastore.createQuery('Task').order('created', {
  descending: true,
});

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->order('created', Query::ORDER_DESCENDING);

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.order = ["-created"]

Ruby

query = datastore.query("Task")
                 .order("created", :desc)

GQL

SELECT * FROM Task ORDER BY created DESC

Wenn eine Abfrage mehrere Sortierfolgen enthält, werden diese in der angegebenen Abfolge angewendet. Im folgenden Beispiel wird zuerst nach absteigender Priorität und dann nach aufsteigender Erstellungszeit sortiert:

C#

Query query = new Query("Task")
{
    Order = { { "priority", PropertyOrder.Types.Direction.Descending },
        { "created", PropertyOrder.Types.Direction.Ascending } }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

query := datastore.NewQuery("Task").Order("-priority").Order("created")

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setOrderBy(OrderBy.desc("priority"), OrderBy.asc("created"))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .order('priority', {
    descending: true,
  })
  .order('created');

PHP

$query = $datastore->query()
    ->kind('Task')
    ->order('priority', Query::ORDER_DESCENDING)
    ->order('created');

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

from google.cloud import datastore

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

query = client.query(kind="Task")
query.order = ["-priority", "created"]

Ruby

query = datastore.query("Task")
                 .order("priority", :desc)
                 .order("created", :asc)

GQL

SELECT * FROM Task ORDER BY priority DESC, created ASC

Wenn keine Sortierfolgen angegeben sind, werden die Ergebnisse in der Reihenfolge zurückgegeben, in der sie aus dem Datastore-Modus abgerufen werden.

Beschränkungen

Für Sortieraufträge gelten die folgenden Einschränkungen:

Aufgrund der Art und Weise, wie Datastore Abfragen ausführt, muss Folgendes beachtet werden: Wenn in einer Abfrage Ungleichheitsfilter für ein Attribut und Sortierreihenfolgen für andere Attribute angegeben sind, muss das Attribut, das mit Ungleichheitsfiltern verwendet wird, vor den anderen Attributen sortiert werden.
Wenn „sortieren“ angegeben ist, muss der in der distinct on-Klausel angegebene Satz von Properties in den Sortierfolgen vor allen Nicht-distinct on-Eigenschaften stehen . Weitere Informationen finden Sie unter Abfragen gruppieren.
Sortierfolgen nach Attributen mit Gleichheitsfiltern werden alle ignoriert.

Besondere Abfragetypen

Einige spezifische Abfragetypen müssen besonders erwähnt werden:

`!= Not equal`

Verwenden Sie den Ungleich-Operator (!=), um Entitäten zurückzugeben, bei denen das angegebene Attribut existiert und stimmt nicht mit dem Vergleichswert überein.

C#

Nicht zutreffend

Go

package datastore_snippets

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/datastore"
	"google.golang.org/api/iterator"
)

func queryNotEquals(w io.Writer, projectId string) error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectId)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	q := datastore.NewQuery("TaskList")
	q.FilterField("Task", "!=", []string{"notASimpleTask"})

	it := client.Run(ctx, q)
	for {
		var dst struct {
			Task string
		}
		key, err := it.Next(&dst)
		if err == iterator.Done {
			break
		}

		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Key retrieved: %v\n", key)
	}

	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.neq("category", "Work"))
        .build();

Node.js

Nicht zutreffend

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore PHP API Referenzdokumentation.

Nicht zutreffend

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

query = client.query(kind="Task")
query.add_filter("category", "!=", "work")

Ruby

Nicht zutreffend

GQL

SELECT * FROM Task WHERE category != 'work'

Diese Abfrage gibt jede Task-Entität zurück, in der das Attribut category vorhanden ist und auf einen anderen Wert als Work festgelegt ist.

Diese Abfrage gibt keine Entitäten zurück, für die die Property category nicht vorhanden ist. Abfragen vom Typ „Nicht gleich“ (!=) und NOT_IN schließen Entitäten aus, bei denen das angegebene Attribut nicht vorhanden ist oder von der Indexierung ausgeschlossen ist. Eine Property ist vorhanden, wenn sie auf einen beliebigen Wert gesetzt ist, einschließlich eines leeren Strings oder null.

Beschränkungen

Beachten Sie folgende Einschränkungen für !=-Abfragen:

Nur Entitäten, in denen die angegebene Property vorhanden ist, können mit der Abfrage übereinstimmen.
Pro Abfrage ist nur ein einziger Operator NOT_IN oder != zulässig.

`IN`

Mit dem Operator IN können Sie bis zu 30 Gleichheitsklauseln (==) für dasselbe Attribut mit einem logischen OR kombinieren. Eine IN-Abfrage gibt Entitäten zurück, bei denen die angegebene Property mit einem der Vergleichswerte übereinstimmt.

C#

Nicht zutreffend

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

package datastore_snippets

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/datastore"
	"google.golang.org/api/iterator"
)

func queryIn(w io.Writer, projectId string) error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectId)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	q := datastore.NewQuery("TaskList")
	q.FilterField("Task", "in", []string{"simpleTask", "easyTask"})

	it := client.Run(ctx, q)
	for {
		var dst struct {
			Task string
		}
		key, err := it.Next(&dst)
		if err == iterator.Done {
			break
		}

		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Key retrieved: %v\n", key)
	}

	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.in("tag", ListValue.of("learn", "study")))
        .build();

Node.js

Nicht zutreffend

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

Nicht zutreffend

Python

query = client.query(kind="Task")
query.add_filter("tag", "IN", ["learn", "study"])

Ruby

Nicht zutreffend

GQL

SELECT * FROM Task WHERE tag IN ARRAY('learn', 'study')

Diese Abfrage gibt alle Task-Entitäten zurück, bei denen die Property tag auf learn oder study festgelegt ist. Dazu gehören Task-Entitäten, deren tag-Attribut einen dieser Werte, aber nicht den anderen enthält.

`NOT_IN`

Mit dem Operator NOT_IN können Sie bis zu 10 Not-equal-Klauseln (!=) für die Dieselbe Eigenschaft mit einem logischen AND. Eine NOT_IN-Abfrage gibt Entitäten zurück, in denen das angegebene Attribut vorhanden ist und keinem der Vergleichswerte entspricht.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Nicht zutreffend

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

package datastore_snippets

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/datastore"
	"google.golang.org/api/iterator"
)

func queryNotIn(w io.Writer, projectId string) error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, projectId)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	q := datastore.NewQuery("TaskList")
	q.FilterField("Task", "not-in", []string{"notASimpleTask", "notAnEasyTask"})

	it := client.Run(ctx, q)
	for {
		var dst struct {
			Task string
		}
		key, err := it.Next(&dst)
		if err == iterator.Done {
			break
		}

		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Key retrieved: %v\n", key)
	}

	return nil
}

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.not_in("category", ListValue.of("Work", "Chores", "School")))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

Nicht zutreffend

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore PHP API Referenzdokumentation.

Nicht zutreffend

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

query = client.query(kind="Task")
query.add_filter("category", "NOT_IN", ["work", "chores", "school"])

Ruby

Nicht zutreffend

GQL

SELECT * FROM Task WHERE category NOT IN ARRAY('work', 'chores', 'school')

Diese Abfrage gibt keine Entitäten zurück in denen die Entität category nicht vorhanden ist. Ungleich (!=) und NOT_IN -Abfragen schließen Entitäten aus, bei denen die angegebene Property nicht vorhanden ist. Eine Property ist vorhanden, wenn er auf einen beliebigen Wert festgelegt ist, einschließlich eines leeren Strings oder null.

Beschränkungen

Beachten Sie folgende Einschränkungen für NOT_IN-Abfragen:

Nur Entitäten, in denen die angegebene Property vorhanden ist, können mit der Abfrage übereinstimmen.
Pro Abfrage ist nur ein einziger Operator NOT_IN oder != zulässig.

Ancestor-Abfragen

Eine Ancestor-Abfrage begrenzt ihre Ergebnisse auf die angegebene Entität und deren untergeordnete Entitäten. Dieses Beispiel gibt alle Aufgabenentitäten zurück, die die angegebene TaskList-Entität als Ancestor haben:

C#

Query query = new Query("Task")
{
    Filter = Filter.HasAncestor(_db.CreateKeyFactory("TaskList")
        .CreateKey(keyName))
};

Go

ancestor := datastore.NameKey("TaskList", "default", nil)
query := datastore.NewQuery("Task").Ancestor(ancestor)

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            PropertyFilter.hasAncestor(
                datastore.newKeyFactory().setKind("TaskList").newKey("default")))
        .build();

Node.js

const ancestorKey = datastore.key(['TaskList', 'default']);

const query = datastore.createQuery('Task').hasAncestor(ancestorKey);

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$ancestorKey = $datastore->key('TaskList', 'default');
$query = $datastore->query()
    ->kind('Task')
    ->hasAncestor($ancestorKey);

Python

from google.cloud import datastore

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

# Query filters are omitted in this example as any ancestor queries with a
# non-key filter require a composite index.
ancestor = client.key("TaskList", "default")
query = client.query(kind="Task", ancestor=ancestor)

Ruby

# task_list_name = "default"
ancestor_key = datastore.key "TaskList", task_list_name

query = datastore.query("Task")
                 .ancestor(ancestor_key)

GQL

SELECT * FROM Task WHERE __key__ HAS ANCESTOR KEY(TaskList, 'default')

Einschränkungen bei Ancestor-Abfragen

Beachten Sie folgende Einschränkungen für Ancestor-Abfragen:

Alle ausgewerteten Disjunktionen müssen denselben übergeordneten Filter haben.

Typlose Abfragen

Eine Abfrage ohne Typ und ohne Ancestor ruft alle Entitäten einer Anwendung aus dem Datastore-Modus ab. Derartige typlose Abfragen können keine Filter oder Sortierfolgen für Attributwerte enthalten. Sie können jedoch mit Entitätsschlüsseln filtern und Ancestor-Filter verwenden. Sie können Schlüsselfilter verwenden, indem Sie __key__ als Attributnamen angeben:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query()
{
    Filter = Filter.GreaterThan("__key__",
        _keyFactory.CreateKey("aTask"))
};

Go

query := datastore.NewQuery("").FilterField("__key__", ">", lastSeenKey)

Java

Query<Entity> query =
    Query.newEntityQueryBuilder().setFilter(PropertyFilter.gt("__key__", lastSeenKey)).build();

Node.js

const query = datastore
  .createQuery()
  .filter(new PropertyFilter('__key__', '>', lastSeenKey))
  .limit(1);

PHP

$query = $datastore->query()
    ->filter('__key__', '>', $lastSeenKey);

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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

last_seen_key = client.key("Task", "a")
query = client.query()
query.key_filter(last_seen_key, ">")

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Ruby API Referenzdokumentation.

query = Google::Cloud::Datastore::Query.new
query.where "__key__", ">", last_seen_key

GQL

SELECT * WHERE __key__ > KEY(Task, 'someTask')

Projektionsabfragen

Die meisten Abfragen geben ganze Entitäten als Ergebnisse zurück. Häufig benötigt eine Anwendung jedoch nur einige wenige Attribute einer Entität. Mit Projektionsabfragen können Sie nur genau die Attribute einer Entität abfragen, die Sie wirklich benötigen, und zwar mit einer geringeren Latenz und niedrigeren Kosten als beim Abrufen der gesamten Entität.

Bei Projektionsabfragen müssen die angegebenen Attribute indexiert sein.

Ausschließlich schlüsselbasierte Abfragen

Eine ausschließlich schlüsselbasierte Abfrage (ein Typ der Projektionsabfrage) gibt nur die Schlüssel der Ergebnisentitäten anstelle der Entitäten selbst zurück, mit einer niedrigeren Latenz und niedrigeren Kosten als beim Abruf ganzer Entitäten.

Häufig ist es wirtschaftlicher, zuerst eine ausschließlich schlüsselbasierte Abfrage durchzuführen und dann einen Teil der Entitäten aus den Ergebnissen abzurufen als eine allgemeine Abfrage auszuführen, die unter Umständen mehr Entitäten abruft, als tatsächlich benötigt werden.

So erstellen Sie eine ausschließlich schlüsselbasierte Abfrage:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Projection = { "__key__" }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

query := datastore.NewQuery("Task").KeysOnly()

Java

Query<Key> query = Query.newKeyQueryBuilder().setKind("Task").build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

const query = datastore.createQuery().select('__key__').limit(1);

PHP

$query = $datastore->query()
    ->keysOnly();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

from google.cloud import datastore

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

query = client.query()
query.keys_only()

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .select("__key__")

GQL

SELECT __key__ FROM Task

Eine ausschließlich schlüsselbasierte Abfrage ist ein kleiner Vorgang und zählt nur als ein einzelner Entitätslesevorgang für die Abfrage selbst.

Projektionen

Projektionsabfragen ähneln SQL-Abfragen der folgenden Form:

SELECT priority, percent_complete FROM Task

Sie können alle Filter- und Sortierfunktionen für Standardabfragen verwenden. Beachten Sie jedoch diese Einschränkungen.

Die Beispiel-SQL-Abfrage gibt gekürzte Ergebnisse zurück, wobei nur die angegebenen Attribute priority und percent_complete mit Werten gefüllt sind. Alle anderen Attribute enthalten keine Daten. So erstellen Sie die Abfrage als Projektionsabfrage:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Projection = { "priority", "percent_complete" }
};

Go

query := datastore.NewQuery("Task").Project("Priority", "PercentComplete")

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<ProjectionEntity> query =
    Query.newProjectionEntityQueryBuilder()
        .setKind("Task")
        .setProjection("priority", "percent_complete")
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

const query = datastore
  .createQuery('Task')
  .select(['priority', 'percent_complete']);

PHP

$query = $datastore->query()
    ->kind('Task')
    ->projection(['priority', 'percent_complete']);

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.projection = ["priority", "percent_complete"]

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Ruby API Referenzdokumentation.

query = datastore.query("Task")
                 .select("priority", "percent_complete")

GQL

SELECT priority, percent_complete FROM Task

Hier wird dargestellt, wie die Projektionsabfrage ausgeführt wird:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Projection = { "priority", "percent_complete" }
};
List<long> priorities = new List<long>();
List<double> percentCompletes = new List<double>();
foreach (var entity in _db.RunQuery(query).Entities)
{
    priorities.Add((long)entity["priority"]);
    percentCompletes.Add((double)entity["percent_complete"]);
}

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

var priorities []int
var percents []float64
it := client.Run(ctx, query)
for {
	var task Task
	if _, err := it.Next(&task); err == iterator.Done {
		break
	} else if err != nil {
		log.Fatal(err)
	}
	priorities = append(priorities, task.Priority)
	percents = append(percents, task.PercentComplete)
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

List<Long> priorities = new LinkedList<>();
List<Double> percentCompletes = new LinkedList<>();
QueryResults<ProjectionEntity> tasks = datastore.run(query);
while (tasks.hasNext()) {
  ProjectionEntity task = tasks.next();
  priorities.add(task.getLong("priority"));
  percentCompletes.add(task.getDouble("percent_complete"));
}

Node.js

async function runProjectionQuery() {
  const priorities = [];
  const percentCompletes = [];
  const [tasks] = await datastore.runQuery(query);
  tasks.forEach(task => {
    priorities.push(task.priority);
    percentCompletes.push(task.percent_complete);
  });

  return {
    priorities: priorities,
    percentCompletes: percentCompletes,
  };
}

PHP

$priorities = array();
$percentCompletes = array();
$result = $datastore->runQuery($query);
/* @var Entity $task */
foreach ($result as $task) {
    $priorities[] = $task['priority'];
    $percentCompletes[] = $task['percent_complete'];
}

Python

priorities = []
percent_completes = []

for task in query.fetch():
    priorities.append(task["priority"])
    percent_completes.append(task["percent_complete"])

Ruby

priorities = []
percent_completes = []
datastore.run(query).each do |task|
  priorities << task["priority"]
  percent_completes << task["percent_complete"]
end

GQL

Nicht zutreffend

Eine Projektionsabfrage ohne die Klausel distinct on ist ein und zählt nur als einzelner Entitätslesevorgang für die Abfrage selbst.

Gruppierung

Projektionsabfragen können mit der Klausel distinct on gewährleisten, dass nur das erste Ergebnis für jede einzelne Kombination von Werten für die angegebenen Attribute zurückgegeben wird. Dadurch wird für Entitäten mit denselben Werten in den projizierten Attributen nur das erste Ergebnis zurückgegeben.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Projection = { "category", "priority" },
    DistinctOn = { "category" },
    Order = {
        { "category", PropertyOrder.Types.Direction.Ascending},
        {"priority", PropertyOrder.Types.Direction.Ascending }
    }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

query := datastore.NewQuery("Task").
	Project("Priority", "Category").
	DistinctOn("Category").
	Order("Category").Order("Priority")

Java

Query<ProjectionEntity> query =
    Query.newProjectionEntityQueryBuilder()
        .setKind("Task")
        .setProjection("category", "priority")
        .setDistinctOn("category")
        .setOrderBy(OrderBy.asc("category"), OrderBy.asc("priority"))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Node.js API.

const query = datastore
  .createQuery('Task')
  .groupBy('category')
  .order('category')
  .order('priority');

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->order('category')
    ->order('priority')
    ->projection(['category', 'priority'])
    ->distinctOn('category');

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.distinct_on = ["category"]
query.order = ["category", "priority"]

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .select("category", "priority")
                 .distinct_on("category")
                 .order("category")
                 .order("priority")

GQL

SELECT DISTINCT ON (category) category, priority FROM Task
ORDER BY category, priority

Die in der distinct on-Klausel angegebenen Attribute müssen vor allen anderen Attributen in der order by-Klausel erscheinen, wenn order by angegeben ist.

Aggregationsabfragen

Firestore im Datastore-Modus unterstützt die Aggregationsabfrage count(). Weitere Informationen finden Sie unter Aggregationsabfragen.

Bereichs- und Ungleichheitsfilter für mehrere Properties

Firestore im Datastore-Modus unterstützt mehrere Ungleich-Filter in einer zusammengesetzten Abfrage. Weitere Informationen finden Sie unter Abfragen mit Bereichs- und Ungleichheitsfiltern für mehrere Properties.

Arraywerte

Im Datastore-Modus wird jeder eindeutige Array-Attributwert einmal pro Index indexiert. Verwenden Sie daher einen Gleichheitsfilter, wenn Sie abfragen möchten, ob ein Array einen bestimmten Wert enthält.

Beachten Sie Folgendes, wenn die Abfrage Attribute mit Arraywerten enthält.

Ungleichheitsfilter

Aufgrund der Art der Indexierung können Entitäten mit mehreren Werten für dasselbe Attribut gelegentlich auf unerwartete und überraschende Weise mit Abfragefiltern und Sortierfolgen interagieren.

Wenn eine Abfrage mehrere Ungleichheitsfilter für ein bestimmtes Attribut enthält, stimmt eine Entität nur dann mit der Abfrage überein, wenn mindestens einer der individuellen Werte des Attributs alle Filter erfüllt. Wenn beispielsweise eine Entität vom Typ Task die Werte fun und programming für das Attribut tag hat, stimmt sie nicht mit der Abfrage überein:

C#

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.GreaterThan("tag", "learn"),
        Filter.LessThan("tag", "math"))
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

query := datastore.NewQuery("Task").
	FilterField("Tag", ">", "learn").
	FilterField("Tag", "<", "math")

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.gt("tag", "learn"), PropertyFilter.lt("tag", "math")))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('tag', '>', 'learn'),
      new PropertyFilter('tag', '<', 'math'),
    ])
  );

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->filter('tag', '>', 'learn')
    ->filter('tag', '<', 'math');

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("tag", ">", "learn"))
query.add_filter(filter=datastore.query.PropertyFilter("tag", "<", "math"))

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Ruby API Referenzdokumentation.

query = datastore.query("Task")
                 .where("tag", ">", "learn")
                 .where("tag", "<", "math")

GQL

SELECT * FROM Task WHERE tag > 'learn' AND tag < 'math'

Jeder tag-Wert der Entität erfüllt einen der Filter, aber keiner der Einzelwerte erfüllt beide Filter.

Mehrere Gleichheitsfilter

Für Abfragen können mehrere Gleichheitsfilter verwendet werden. für Entitäten, die eine Gruppe von Werten enthalten. Beispiel: Eine Entität vom Typ Task mit den Werten fun und programming für das Attribut tag erfüllt die Abfrage

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.Equal("tag", "fun"),
        Filter.Equal("tag", "programming"))
};

Go

query := datastore.NewQuery("Task").
	FilterField("Tag", "=", "fun").
	FilterField("Tag", "=", "programming")

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.eq("tag", "fun"), PropertyFilter.eq("tag", "programming")))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('tag', '=', 'fun'),
      new PropertyFilter('tag', '=', 'programming'),
    ])
  );

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->filter('tag', '=', 'fun')
    ->filter('tag', '=', 'programming');

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("tag", "=", "fun"))
query.add_filter(filter=datastore.query.PropertyFilter("tag", "=", "programming"))

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Ruby API Referenzdokumentation.

query = datastore.query("Task")
                 .where("tag", "=", "fun")
                 .where("tag", "=", "programming")

GQL

SELECT * FROM Task WHERE tag = 'fun' AND tag = 'programming'

Dabei erfüllt keiner der individuellen tag-Werte der Entität beide Filterbedingungen.

Sortierfolge

Genauso ist die Sortierfolge für mehrwertige Attribute ungewöhnlich. Weil derartige Attribute im Index jeweils einmal für jeden eindeutigen Wert auftreten, bestimmt der erste Wert im Index die Sortierfolge der Entität.

Wenn kein mehrwertiges Attribut in einem Filter verwendet wird:

und die Abfrageergebnisse in aufsteigender Reihenfolge nach dem Attribut sortiert werden, wird der kleinste Wert des Attributs für die Sortierung verwendet.
und die Abfrageergebnisse in absteigender Reihenfolge nach dem Attribut sortiert werden, wird der größte Wert des Attributs für die Sortierung verwendet.
haben weder andere Werte noch die Anzahl der Werte Einfluss auf die Sortierreihenfolge.

Dies hat die ungewöhnliche Folge, dass eine Entität mit den Attributwerten 1 und 9 in aufsteigender und absteigender Reihenfolge vor einer Entität mit den Werten 4, 5, 6 und 7 steht.

Wenn ein mehrwertiges Attribut in einem Gleichheitsfilter verwendet wird, wird jede Sortierfolge für dieses Attribut ignoriert.

Wenn ein mehrwertiges Attribut in einer Ungleichheit oder einem NOT_IN-Filter verwendet wird:

und die Ergebnisse in aufsteigender Reihenfolge nach dem Attribut sortiert werden, wird der kleinste Wert, der alle Ungleichheitsfilter der Abfrage erfüllt, für die Sortierung verwendet.
und die Ergebnisse in absteigender Reihenfolge nach dem Attribut sortiert werden, wird der größte Wert, der alle Ungleichheitsfilter der Abfrage erfüllt, für die Sortierung verwendet.

Hinweis: Wenn sich ein Satz Ungleichheitsfilter für ein Attribut in einen Gleichheitsfilter übersetzen lässt, z. B.:

WHERE tag >= 'math' AND tag <= 'math'

dann wird jede Sortierfolge für dieses Attribut ignoriert, weil die Filter wie der entsprechende Gleichheitsfilter ausgewertet werden:

WHERE tag = 'math'

Projektionen und arraywertige Attribute

Bei der Projektion eines Attributs mit Arraywerten werden nicht alle Werte dafür ausgefüllt. Property. Stattdessen wird für jede eindeutige Kombination von projizierten Werten, die mit der Abfrage übereinstimmt, eine separate Entität zurückgegeben. Angenommen, Sie haben eine Entität der Art Task mit den beiden mehrwertigen Attributen tag und collaborators:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Entity task = new Entity()
{
    Key = _db.CreateKeyFactory("Task").CreateKey("sampleTask"),
    ["collaborators"] = new ArrayValue() { Values = { "alice", "bob" } },
    ["tags"] = new ArrayValue() { Values = { "fun", "programming" } }
};

Go

type Task struct {
	Tags          []string
	Collaborators []string
}
task := &Task{
	Tags:          []string{"fun", "programming"},
	Collaborators: []string{"alice", "bob"},
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

Entity task =
    Entity.newBuilder(taskKey)
        .set("tags", "fun", "programming")
        .set("collaborators", ListValue.of("alice", "bob"))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Node.js API Referenzdokumentation.

const task = {
  tags: ['fun', 'programming'],
  collaborators: ['alice', 'bob'],
};

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore PHP API Referenzdokumentation.

$task = $datastore->entity(
    $key,
    [
        'tags' => ['fun', 'programming'],
        'collaborators' => ['alice', 'bob']
    ]
);

Python

from google.cloud import datastore

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

key = client.key("Task")
task = datastore.Entity(key)
task.update({"tags": ["fun", "programming"], "collaborators": ["alice", "bob"]})

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

# task_name = "sampleTask"
task = datastore.entity "Task", task_name do |t|
  t["tags"] = ["fun", "programming"]
  t["collaborators"] = ["alice", "bob"]
end

GQL

Nicht zutreffend

dann gibt die Projektionsabfrage

SELECT tag, collaborators FROM Task WHERE collaborators < 'charlie'

vier Entitäten mit den folgenden Wertekombinationen zurück:

tag = 'fun', collaborators = 'alice'
tag = 'fun', collaborators = 'bob'
tag = 'programming', collaborators = 'alice'
tag = 'programming', collaborators = 'bob'

Cursors, Grenzwerte und Offsets

Sie können ein Limit für die Abfrage festlegen, um die Höchstzahl von Ergebnissen zu kontrollieren, die in einem Stapel zurückgegeben werden. Im folgenden Beispiel werden maximal fünf Aufgabenentitäten zurückgegeben:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Limit = 5,
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

query := datastore.NewQuery("Task").Limit(5)

Java

Query<Entity> query = Query.newEntityQueryBuilder().setKind("Task").setLimit(5).build();

Node.js

const query = datastore.createQuery('Task').limit(5);

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->limit(5);

Python

from google.cloud import datastore

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

query = client.query()
tasks = list(query.fetch(limit=5))

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .limit(5)

GQL

SELECT * FROM Task LIMIT 5

Mit Abfrage-Cursors kann eine Anwendung die Ergebnisse einer Abfrage in bequemen Stapeln ohne den Overhead eines Abfrage-Offsets abrufen. Nach Ausführung eines Abfragevorgangs kann die Anwendung einen Cursor abrufen, bei dem es sich um einen intransparenten Bytestring handelt, der die Indexposition des letzten abgerufenen Ergebnisses markiert. Die Anwendung kann diesen String speichern (beispielsweise in der Datenbank im Datastore-Modus, einem Cache oder auf einer Webseite als base-64-codierten HTTP-GET- oder -POST-Parameter) und den Cursor dann als Ausgangspunkt für einen nachfolgenden Abrufvorgang verwenden. So wird der nächste Stapel mit Ergebnissen ab dem Punkt abgerufen, an dem der vorherige Abrufvorgang beendet wurde. Ein Abruf kann auch einen Endcursor angeben, um den Umfang der zurückgegebenen Ergebnismenge zu begrenzen.

Im folgenden Beispiel wird die Verwendung von Cursors für die Paginierung demonstriert.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Limit = pageSize,
};
if (!string.IsNullOrEmpty(pageCursor))
    query.StartCursor = ByteString.FromBase64(pageCursor);

return _db.RunQuery(query).EndCursor?.ToBase64();

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

// cursorStr is a cursor to start querying at.
cursorStr := ""

const pageSize = 5
query := datastore.NewQuery("Tasks").Limit(pageSize)
if cursorStr != "" {
	cursor, err := datastore.DecodeCursor(cursorStr)
	if err != nil {
		log.Fatalf("Bad cursor %q: %v", cursorStr, err)
	}
	query = query.Start(cursor)
}

// Read the tasks.
it := client.Run(ctx, query)
var tasks []Task
for {
	var task Task
	_, err := it.Next(&task)
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatalf("Failed fetching results: %v", err)
	}
	tasks = append(tasks, task)
}

// Get the cursor for the next page of results.
// nextCursor.String can be used as the next page's token.
nextCursor, err := it.Cursor()

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

EntityQuery.Builder queryBuilder =
    Query.newEntityQueryBuilder().setKind("Task").setLimit(pageSize);
if (pageCursor != null) {
  queryBuilder.setStartCursor(pageCursor);
}
QueryResults<Entity> tasks = datastore.run(queryBuilder.build());
while (tasks.hasNext()) {
  Entity task = tasks.next();
  // do something with the task
}
Cursor nextPageCursor = tasks.getCursorAfter();

Node.js

// By default, google-cloud-node will automatically paginate through all of
// the results that match a query. However, this sample implements manual
// pagination using limits and cursor tokens.
async function runPageQuery(pageCursor) {
  let query = datastore.createQuery('Task').limit(pageSize);

  if (pageCursor) {
    query = query.start(pageCursor);
  }
  const results = await datastore.runQuery(query);
  const entities = results[0];
  const info = results[1];

  if (info.moreResults !== Datastore.NO_MORE_RESULTS) {
    // If there are more results to retrieve, the end cursor is
    // automatically set on `info`. To get this value directly, access
    // the `endCursor` property.
    const results = await runPageQuery(info.endCursor);

    // Concatenate entities
    results[0] = entities.concat(results[0]);
    return results;
  }

  return [entities, info];
}

PHP

/**
 * Fetch a query cursor.
 *
 * @param int $pageSize
 * @param string $pageCursor
 * @param string $namespaceId
 */
function cursor_paging(int $pageSize, string $pageCursor = '', string $namespaceId = null)
{
    $datastore = new DatastoreClient(['namespaceId' => $namespaceId]);
    $query = $datastore->query()
        ->kind('Task')
        ->limit($pageSize)
        ->start($pageCursor);
    $result = $datastore->runQuery($query);
    $nextPageCursor = '';
    $entities = [];
    /* @var Entity $entity */
    foreach ($result as $entity) {
        $nextPageCursor = $entity->cursor();
        $entities[] = $entity;
    }

    printf('Found %s entities', count($entities));

    $entities = [];
    if (!empty($nextPageCursor)) {
        $query = $datastore->query()
          ->kind('Task')
          ->limit($pageSize)
          ->start($nextPageCursor);
        $result = $datastore->runQuery($query);

        foreach ($result as $entity) {
            $entities[] = $entity;
        }

        printf('Found %s entities with next page cursor', count($entities));
    }
}

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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


def get_one_page_of_tasks(cursor=None):
    query = client.query(kind="Task")
    query_iter = query.fetch(start_cursor=cursor, limit=5)
    page = next(query_iter.pages)

    tasks = list(page)
    next_cursor = query_iter.next_page_token

    return tasks, next_cursor

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

page_size = 2
query = datastore.query("Task")
                 .limit(page_size)
tasks = datastore.run query

page_cursor = tasks.cursor

query = datastore.query("Task")
                 .limit(page_size)
                 .start(page_cursor)

GQL

Nicht zutreffend

Datenbanken im Datastore-Modus unterstützen zwar ganzzahlige Offsets, aber Sie sollten diese nach Möglichkeit nicht einsetzen. Verwenden Sie stattdessen Cursors. Bei Verwendung eines Offsets wird nur vermieden, dass die übersprungenen Entitäten an die Anwendung zurückgegeben werden, diese Entitäten werden jedoch dennoch intern abgerufen. Die übersprungenen Entitäten wirken sich auf die Latenz der Abfrage aus, und Lesevorgänge, die für deren Abruf erforderlich sind, werden für Ihre Anwendung in Rechnung gestellt. Wenn Cursors anstelle von Offsets verwendet werden, können Sie diese Kosten vermeiden.

Einschränkungen von Cursors

Cursors unterliegen den folgenden Einschränkungen:

Ein Cursor kann nur von demselben Projekt, das die ursprüngliche Abfrage durchgeführt hat, und nur zur Fortsetzung derselben Abfrage verwendet werden. Ergebnisse können mit einem Cursor nur abgerufen werden, wenn dieselbe Abfrage eingerichtet wird, aus der er ursprünglich generiert wurde.
Wenn eines der folgenden Elemente geändert wird, kann ein Cursor weiter für nachfolgende Abrufvorgänge verwendet werden:
- Startcursor
- Endcursor
- Offset
- Limit
Wenn eines der folgenden Elemente geändert wird, kann ein Cursor nicht mehr für nachfolgende Abrufvorgänge verwendet werden:
- Projektion
- Typ
- Ancestor
- Filter
- "distinct on"-Klausel
- Sortierreihenfolge Dies gilt nicht, wenn die endgültige Sortierreihenfolge der ursprünglichen Abfrage nach __key__ erfolgte. In diesem Fall können Sie den Cursor in einer umgekehrten Abfrage verwenden. Dabei handelt es sich um die ursprüngliche Abfrage, bei der jede Sortierfolge umgekehrt wird. Die umgekehrte Abfrage kann Startcursor, Endcursor, Offset und Beschränkung ändern.
Cursors funktionieren häufig nicht wie erwartet bei Abfragen, die einen Ungleichheitsfilter oder eine Sortierfolge bei einem Attribut mit mehreren Werten verwenden. Die Deduplizierungslogik für derartige mehrwertige Attribute bleibt zwischen Abrufvorgängen nicht bestehen, weshalb dasselbe Ergebnis mehr als einmal zurückgegeben werden kann.
In neuen Versionen des Datastore-Modus können interne Implementierungsdetails abweichen, wodurch Cursors ungültig werden, die auf ihnen beruhen. Wenn eine Anwendung versucht, einen Cursor zu verwenden, der nicht mehr gültig ist, löst Firestore im Datastore-Modus eine Ausnahme aus.

Cursors und Datenaktualisierungen

Der Cursor stellt die Position in der Ergebnisliste nach dem letzten zurückgegebenen Ergebnis dar. Ein Cursor ist keine relative Position in der Liste (er ist kein Offset); er ist vielmehr eine Markierung, zu der eine Datenbank im Datastore-Modus springen kann, wenn ein Indexscan nach Ergebnissen gestartet wird. Wenn sich die Ergebnisse während der Verwendung eines Cursors ändern, berücksichtigt die Abfrage nur die Änderungen, die in den Ergebnissen nach der Position des Cursors auftreten. Wenn für die Abfrage ein neues Ergebnis hinzukommt, das aber vor der Position des Cursors steht, wird es beim Abrufen der Ergebnisse ab der Position des Cursors nicht zurückgegeben. Ebenso ändern sich die Ergebnisse nach dem Cursor nicht, wenn eine Entität kein Ergebnis einer Abfrage mehr ist, aber vor dem Cursor angezeigt wurde. Wenn das letzte zurückgegebene Ergebnis aus der Ergebnismenge entfernt wird, kann der Cursor trotzdem weiterhin die Position des nächsten Ergebnisses bestimmen.

Beim Abrufen von Abfrageergebnissen können Sie einen Start- und einen Endcursor einsetzen, um fortlaufende Ergebnisse zurückzugeben. Wenn Sie beim Abrufen der Ergebnisse einen Start- und einen Endcursor verwenden, haben Sie allerdings trotzdem keine Garantie dafür, dass die Größe der Ergebnisse mit der beim Generieren der Cursors vorliegenden Größe übereinstimmt. Das liegt daran, dass es passieren kann, dass Entitäten in der Datenbank zwischen dem Zeitpunkt der Generierung der Cursors und deren Verwendung in einer Abfrage hinzugefügt oder gelöscht werden.

Beschränkungen bei Abfragen

Die Art des Indexabfrageverfahrens führt zu bestimmten Beschränkungen bei den Funktionen einer Abfrage. Abfragen im Datastore-Modus unterstützen weder Teilstring-Übereinstimmungen noch Übereinstimmungen, bei denen die Groß-/Kleinschreibung nicht beachtet werden muss, und auch keine Volltextsuchvorgänge. Außerdem gilt Folgendes: Es gelten Einschränkungen:

Entitäten, bei denen ein in der Abfrage benanntes Attribut fehlt, werden ignoriert

Entitäten desselben Typs haben nicht unbedingt dieselben Attribute. Damit eine Entität als Abfrageergebnis genutzt werden kann, muss sie einen Wert (kann null sein) für jedes Attribut haben, das in den Filtern und Sortierfolgen der Abfrage benannt wird. Wenn die Entität diese Voraussetzung nicht erfüllt, wird sie nicht in die Indexe für die Ausführung der Abfrage aufgenommen. Sie ist dann auch nicht in den Ergebnissen enthalten.

Filterung nach nicht indexierten Attributen gibt keine Ergebnisse zurück

Eine Abfrage kann keine Attributwerte finden, die nicht indexiert sind, und kann nicht nach derartigen Attributen sortieren. Weitere Informationen finden Sie unter Nicht indexierte Attribute.

Einschränkungen bei Ungleichheitsfiltern

Damit Abfragen nicht zu teuer für die Ausführung werden, begrenzt Firestore im Datastore-Modus die Anzahl der Bereichs- oder Ungleichheitsattribute auf 10. Weitere Informationen zu Abfragen mit Ungleichheitsfiltern finden Sie unter Abfrage mit Bereichs- und Ungleichheitsfiltern für mehrere Attribute.

Sie können nicht sowohl `NOT_EQUAL` als auch `NOT_IN` verwenden.

Wenn Sie NOT_IN verwenden, können Sie keine NOT_EQUAL-Klausel hinzufügen.

Reihenfolge der Abfrageergebnisse ist undefiniert, wenn keine Sortierfolge angegeben wird

Wenn in einer Abfrage keine Sortierreihenfolge angegeben ist, werden die Ergebnisse in der Reihenfolge zurückgegeben, in der sie abgerufen werden. Im Laufe der Weiterentwicklung des Datastore-Modus (oder wenn sich die Indexe eines Projekts ändern) kann sich diese Reihenfolge ändern. Wenn die Abfrageergebnisse für Ihre Anwendung in einer bestimmten Reihenfolge erforderlich sind, müssen Sie diese Sortierreihenfolge daher explizit in der Abfrage angeben.

Sortierfolgen werden bei Attributen mit Gleichheitsfiltern ignoriert

Abfragen, die einen Gleichheitsfilter für ein bestimmtes Attribut enthalten, ignorieren jede für dieses Attribut angegebene Sortierfolge. Das ist eine Optimierung, die Sie eine unnötige Verarbeitung einwertiger Attribute. Da alle Ergebnisse die denselben Wert für die Eigenschaft hat, ist keine weitere Sortierung erforderlich. Mehrwertige Attribute hingegen können zusätzliche Werte neben dem Wert haben, der mit dem Gleichheitsfilter übereinstimmt. Da dieser Anwendungsfall selten ist und die Sortierreihenfolge aber teuer sein und zusätzliche Indexe erfordern, wird die Sortierreihenfolge ignoriert, auch wenn es sich um einen mehrwertigen Fall handelt. Dies kann dazu führen, dass Abfrageergebnisse in einer anderen Reihenfolge zurückgegeben werden, als die Sortierfolge scheinbar impliziert. Die Sortierreihenfolge wird beispielsweise in der folgenden Abfrage ignoriert:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Nicht zutreffend

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

Nicht zutreffend

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.eq("tag", "learn"))
        .setOrderBy(OrderBy.asc("tag"))
        .build();

Node.js

Nicht zutreffend

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

Nicht zutreffend

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Python API.

Nicht zutreffend

Ruby

Nicht zutreffend

GQL

# Sort order on an equality filter is ignored
SELECT * FROM Task WHERE tag = 'learn' ORDER BY tag ASC

Das gilt nicht für Abfragen, die einen IN-Filter enthalten. Mit dem Operator IN können Sie bis zu 10 Gleichheitsklauseln (==) für dasselbe Attribut mit einem logischen OR kombinieren. Wenn Sie eine Sortierreihenfolge für diese Property hinzufügen, wird sie auf das Ergebnissatz angewendet.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Nicht zutreffend

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Go API Referenzdokumentation.

Nicht zutreffend

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.in("tag", ListValue.of("learn", "study")))
        .setOrderBy(OrderBy.asc("tag"))
        .build();

Node.js

Nicht zutreffend

PHP

Nicht zutreffend

Python

Nicht zutreffend

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

Nicht zutreffend

GQL

SELECT * FROM Task WHERE tag IN ARRAY('learn', 'study') ORDER BY tag ASC

Bei aufsteigender Reihenfolge wird der kleinste Wert, der den Filter erfüllt, für die Sortierung verwendet.
Bei absteigender Reihenfolge wird der größte Wert für die Sortierung verwendet, der den Filter erfüllt.
Andere Werte und die Anzahl der Werte in der Eigenschaft wirken sich weder auf die Sortierreihenfolge noch auf die Anzahl der Werte in der Eigenschaft aus.

In Ungleichheitsfiltern verwendete Attribute müssen zuerst sortiert werden

Zum Abrufen aller Ergebnisse, die mit einem Ungleichheitsfilter übereinstimmen, scannt eine Abfrage den Index auf die erste Zeile, die mit dem Filter übereinstimmt, und scannt dann weiter, bis eine nicht übereinstimmende Zeile gefunden wird. Damit die aufeinanderfolgenden Zeilen die vollständige Ergebnismenge bilden, müssen sie vor allen anderen Attributen sortiert werden, und zwar nach dem Attribut, das in dem Ungleichheitsfilter verwendet wird. Wenn eine Abfrage also einen oder mehrere Ungleichheitsfilter zusammen mit einer oder mehreren Sortierfolgen angibt, muss sich die erste Sortierfolge auf dasselbe Attribut beziehen, das in den Ungleichheitsfiltern angegeben wird. Die folgende Abfrage ist eine gültige Abfrage:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore C# API.

Query query = new Query("Task")
{
    Filter = Filter.GreaterThan("priority", 3),
    Order = { { "priority", PropertyOrder.Types.Direction.Ascending},
        {"created", PropertyOrder.Types.Direction.Ascending } }
};

Go

query := datastore.NewQuery("Task").
	FilterField("Priority", ">", 3).
	Order("Priority").
	Order("Created")

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.gt("priority", 3))
        .setOrderBy(OrderBy.asc("priority"), OrderBy.asc("created"))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Node.js API.

const query = datastore
  .createQuery('Task')
  .filter(new PropertyFilter('priority', '>', 3))
  .order('priority')
  .order('created');

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 3)
    ->order('priority')
    ->order('created');

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
query.order = ["priority", "created"]

Ruby

query = datastore.query("Task")
                 .where("priority", ">", 3)
                 .order("priority")
                 .order("created")

GQL

SELECT * FROM Task WHERE priority > 3 ORDER BY priority, created

Diese Abfrage ist nicht gültig, weil sie nicht nach dem Attribut sortiert, das in dem Ungleichheitsfilter verwendet wird:

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore C# API Referenzdokumentation.

Query query = new Query("Task")
{
    Filter = Filter.GreaterThan("priority", 3),
    Order = { { "created", PropertyOrder.Types.Direction.Ascending } }
};

Go

query := datastore.NewQuery("Task").
	FilterField("Priority", ">", 3).
	Order("Created")

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Java API Referenzdokumentation.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.gt("priority", 3))
        .setOrderBy(OrderBy.asc("created"))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(new PropertyFilter('priority', '>', 3))
  .order('created');

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 3)
    ->order('created');

Python

from google.cloud import datastore

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

    query = client.query(kind="Task")
    query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
    query.order = ["created"]

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .where("priority", ">", 3)
                 .order("created")

GQL

# Invalid query!
SELECT * FROM Task WHERE priority > 3 ORDER BY created

Ebenso ist diese Abfrage nicht gültig, weil das in dem Ungleichheitsfilter verwendete Attribut nicht das erste sortierte Attribut ist:

C#

Query query = new Query("Task")
{
    Filter = Filter.GreaterThan("priority", 3),
    Order = { {"created", PropertyOrder.Types.Direction.Ascending },
        { "priority", PropertyOrder.Types.Direction.Ascending} }
};

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Go API.

query := datastore.NewQuery("Task").
	FilterField("Priority", ">", 3).
	Order("Created").
	Order("Priority")

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Java API.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(PropertyFilter.gt("priority", 3))
        .setOrderBy(OrderBy.asc("created"), OrderBy.asc("priority"))
        .build();

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Node.js API.

const query = datastore
  .createQuery('Task')
  .filter(new PropertyFilter('priority', '>', 3))
  .order('created')
  .order('priority');

PHP

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore PHP API.

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 3)
    ->order('created')
    ->order('priority');

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Cloud Datastore Python API Referenzdokumentation.

from google.cloud import datastore

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

    query = client.query(kind="Task")
    query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
    query.order = ["created", "priority"]

Ruby

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Datastore finden Sie hier. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Datastore Ruby API.

query = datastore.query("Task")
                 .where("priority", ">", 3)
                 .order("created")
                 .order("priority")

GQL

# Invalid query!
SELECT * FROM Task WHERE priority > 3 ORDER BY created, priority

`OrderBy` und Existenz

Wenn Sie eine Abfrage nach einer bestimmten Eigenschaft sortieren, kann die Abfrage nur das Folgende zurückgeben: Entitäten, bei denen das Attribut „sort-by“ vorhanden ist.

Mit der folgenden Abfrage werden beispielsweise keine Entitäten zurückgegeben, für die das Attribut priority nicht festgelegt ist, auch wenn sie ansonsten die Abfragefilter erfüllen.

Java

Query<Entity> query =
    Query.newEntityQueryBuilder().setKind("Task")
                                 .setFilter(PropertyFilter.eq("done", false))
                                 .setOrderBy(OrderBy.desc("priority"))
                                 .build();

Ein ähnlicher Effekt gilt für Ungleichheiten. Eine Abfrage mit einem Ungleichheitsfilter für eine Eigenschaft impliziert auch eine Sortierung nach dieser Eigenschaft. Mit der folgenden Abfrage werden keine Entitäten ohne priority-Attribut zurückgegeben, auch wenn starred = true in dieser Entität vorhanden ist. Als Behelfslösung können Sie separate Abfragen für jede Reihenfolge oder Sie können einen Wert für alle Eigenschaften zuweisen. nach der Sie sortieren.

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(CompositeFilter.or(
            PropertyFilter.eq("starred", true)),
            PropertyFilter.ge("priority", 4))
        .build();

Die vorherige Abfrage enthält eine implizite Sortierung nach der Ungleichung wie die folgen. Die Richtung der implizierten Sortierung hängt von den verfügbaren Indexen ab:

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(CompositeFilter.or(
            PropertyFilter.eq("starred", true)),
            PropertyFilter.ge("priority", 4)
        )
        .setOrderBy(OrderBy.asc("priority"))
        .build();

Einschränkungen bei Projektionen

Projektionsabfragen unterliegen folgenden Einschränkungen:

Nur indexierte Attribute können projiziert werden.

Das bedeutet, dass alle in einer Abfrage verwendeten Properties (projizierte Properties oder Filter) im selben Index vorhanden sein müssen. Für select tag from Task where priority = 1 ist also ein zusammengesetzter Index mit Priorität und dann Tag erforderlich.

Projektion wird für Strings, die länger als 1.500 Byte sind, nicht unterstützt. Byte-Arrays mit mehr als 1.500 Elementen und andere Eigenschaften explizit als nicht indexiert gekennzeichnet sind.
Ein Attribut kann nicht mehr als einmal projiziert werden.
Attribute, die in einem Gleichheitsfilter referenziert werden, können nicht projiziert werden.

Beispiel:
```
SELECT tag FROM Task WHERE priority = 1
```
ist gültig (projiziertes Attribut nicht im Gleichheitsfilter verwendet), wie auch
```
SELECT tag FROM Task WHERE tag > 'fun`
```
(kein Gleichheitsfilter), aber
```
SELECT tag FROM Task WHERE tag = 'fun`
```
(projizierte Property in Gleichheitsfilter verwendet) ist nicht gültig.
Von einer Projektionsabfrage zurückgegebene Ergebnisse sollten nicht wieder in der Datenbank im Datastore-Modus gespeichert werden.

Da die Abfrage Ergebnisse zurückgibt, die nur teilweise ausgefüllt sind, sie nicht in die Datenbank im Datastore-Modus zurückschreiben.
Projektionsabfragen wandeln Zeitstempel in Ganzzahlen um.

In den Ergebnissen einer Projektionsabfrage wandelt der Datastore-Modus Zeitstempelwerte in ganzzahlige Mikrosekundenwerte um.

Weitere Informationen

Mehr über Transaktionen erfahren