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 ist für die meisten Anwendungen geeignet, mit Ausnahme von Abfragen ohne Skalierung, wie z. B. Join-Abfragen. Weitere Informationen zu den Einschränkungen bei Abfragen im Datastore-Modus finden Sie unter Einschränkungen bei Abfragen.

Abfrageschnittstelle

Sie können eine Abfrage für eine Datenbank im Datastore-Modus ausführen. Das folgende Beispiel zeigt, wie Sie alle noch nicht erledigten Aufgaben mit Prioritäten größer oder gleich 4 abrufen, in absteigender Reihenfolge nach Priorität sortiert:

C#

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 C# API.

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

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

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

PHP

$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=PropertyFilter("done", "=", False))
query.add_filter(filter=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

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

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#

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

Go

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

Java

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=PropertyFilter("done", "=", False))

Ruby

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`	Kleiner 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`	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 Filter mit AND und OR kombinieren. Im folgenden Beispiel werden Task-Entitäten zurückgegeben, die als nicht erledigt markiert sind und eine Priorität von 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

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=PropertyFilter("done", "=", False))
query.add_filter(filter=PropertyFilter("priority", "=", 4))

Ruby

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.

Einfach loslegen (Go)

Snippet nicht verfügbar.

Java

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

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.

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

/**
 * 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

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 = 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 den Operatoren AND und OR. Im folgenden Beispiel werden Task-Entitäten zurückgegeben, die entweder markiert oder nicht erledigt sind und die Priorität 4 haben:

C#

Snippet nicht verfügbar.

Einfach loslegen (Go)

Snippet nicht verfügbar.

Java

Query 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#

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

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

$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

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ätstyp
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 für Schlüssel verwenden Indexe wie Abfragen für Attribute und erfordern in denselben Fällen benutzerdefinierte Indexe. Die folgenden Ausnahmen erfordern keinen benutzerdefinierten Index:

Ungleichheitsfilter
Aufsteigende Sortierreihenfolge für den Schlüssel

Für eine absteigende Sortierfolge 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#

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

$query = $datastore->query()
    ->kind('Task')
    ->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.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#

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

Go

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

Java

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

Node.js

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

PHP

$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

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

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.

Einschränkungen

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

Aufgrund der Art und Weise, wie der Datastore-Modus Abfragen ausführt, muss das in Ungleichheitsfiltern verwendete Attribut vor den anderen Attributen sortiert werden, wenn in einer Abfrage Ungleichheitsfilter für ein Attribut und Sortierfolgen für andere Attribute angegeben sind.
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 Operator !=, um Entitäten zurückzugeben, bei denen das angegebene Attribut vorhanden ist und nicht mit dem Vergleichswert übereinstimmt.

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

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

Node.js

Nicht zutreffend

PHP

Nicht zutreffend

Python

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 und auf einen anderen Wert als Work festgelegt ist.

Diese Abfrage gibt keine Entitäten zurück, bei denen das Attribut 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 bei denen es von der Indexierung ausgeschlossen wurde. Ein Attribut ist vorhanden, wenn es auf einen beliebigen Wert festgelegt ist, einschließlich eines leeren Strings oder null.

Beschränkungen

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

Nur Entitäten, bei denen die angegebene Property vorhanden ist, können mit der Abfrage übereinstimmen.
Pro Abfrage ist nur ein 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 das angegebene Attribut mit einem der Vergleichswerte übereinstimmt.

C#

Nicht zutreffend

Go

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

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

Node.js

Nicht zutreffend

PHP

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 das Attribut tag auf learn oder study gesetzt ist. Dies gilt auch für Task-Entitäten, bei denen das Attribut tag nur einen dieser Werte enthält.

`NOT_IN`

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

C#

Nicht zutreffend

Go

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

Nicht zutreffend

PHP

Nicht zutreffend

Python

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, bei denen die Entität 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. Ein Attribut ist vorhanden, wenn es 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, bei denen die angegebene Property vorhanden ist, können mit der Abfrage übereinstimmen.
Pro Abfrage ist nur ein 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

$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 Ancestor-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#

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

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

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#

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

Go

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

Java

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

Node.js

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

PHP

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

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()
query.keys_only()

Ruby

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#

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

Go

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

Java

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

Node.js

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

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#

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

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

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 kleiner Vorgang 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#

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

Go

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

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

PHP

$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

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 angegebene Gruppe von Attributen muss in der order by-Klausel vor allen Nicht-distinct on-Properties stehen, wenn order by angegeben ist.

Aggregationsabfragen

Firestore im Datastore-Modus unterstützt die Aggregationsabfrage count(). Siehe Aggregationsabfragen.

Bereichs- und Ungleichheitsfilter für mehrere Attribute

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

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

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

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

PHP

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

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=PropertyFilter("tag", ">", "learn"))
query.add_filter(filter=PropertyFilter("tag", "<", "math"))

Ruby

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 die Abfrage von Entitäten, die eine Gruppe von Werten enthalten, können mehrere Gleichheitsfilter verwendet werden. Beispiel: Eine Entität vom Typ Task mit den Werten fun und programming für das Attribut tag erfüllt die Abfrage

C#

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

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

$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=PropertyFilter("tag", "=", "fun"))
query.add_filter(filter=PropertyFilter("tag", "=", "programming"))

Ruby

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 für dieses Attribut ausgefüllt. 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#

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

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

Node.js

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

PHP

$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

# 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#

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

Go

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

$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

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#

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

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

Go

// 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.
var tasks []Task
var task Task
it := client.Run(ctx, query)
_, err := it.Next(&task)
for err == nil {
	tasks = append(tasks, task)
	_, err = it.Next(&task)
}
if err != iterator.Done {
	log.Fatalf("Failed fetching results: %v", err)
}

// 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

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 DatastoreClient $datastore
 * @param int $pageSize
 * @param string $pageCursor
 */
function cursor_paging(DatastoreClient $datastore, int $pageSize, string $pageCursor = '')
{
    $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

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

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 Eine Ausnahme besteht, wenn die endgültige Sortierfolge 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 solche mehrwertigen Eigenschaften bleibt zwischen Abrufvorgängen nicht bestehen, was dazu führen kann, dass dasselbe Ergebnis mehr als einmal zurückgegeben wird.
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 vor der Position des Cursors angezeigt wird, wird es beim Abrufen der Ergebnisse nach dem Cursor 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 Indexabfragemechanismus schränkt die Funktionen einer Abfrage mit bestimmten Einschränkungen ein. Abfragen im Datastore-Modus unterstützen keine Teilstring-Übereinstimmungen, Übereinstimmungen ohne Berücksichtigung der Groß-/Kleinschreibung und keine Volltextsuche. Außerdem gelten die folgenden 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. Ist dies nicht der Fall, wird die Entität nicht in den Indexen aufgeführt, die zum Ausführen der Abfrage verwendet werden, und ist folglich nicht in den Ergebnissen der Abfrage 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.

Ungleichheitsfilter sind auf maximal ein Attribut begrenzt

Damit nicht der ganze Index gescannt werden muss, verlässt sich das Abfrageverfahren darauf, dass alle potenziellen Ergebnisse einer Abfrage in dem Index nebeneinanderstehen. Aus diesem Grund darf eine einzelne Abfrage in allen Filtern keine Ungleichheitsvergleiche (LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL, NOT_EQUAL, NOT_IN) für mehr als ein Attribut verwenden. Die folgende Abfrage ist beispielsweise gültig, da beide Ungleichheitsfilter auf dasselbe Attribut angewendet werden:

C#

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.GreaterThan("created", _startDate),
        Filter.LessThan("created", _endDate))
};

Go

query := datastore.NewQuery("Task").
	FilterField("Created", ">", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
	FilterField("Created", "<", time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC))

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.gt("created", startDate), PropertyFilter.lt("created", endDate)))
        .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('created', '>', new Date('1990-01-01T00:00:00z')),
      new PropertyFilter('created', '<', new Date('2000-12-31T23:59:59z')),
    ])
  );

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('created', '>', new DateTime('1990-01-01T00:00:00z'))
    ->filter('created', '<', new DateTime('2000-12-31T23:59:59z'));

Python

from google.cloud import datastore

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

start_date = datetime.datetime(1990, 1, 1)
end_date = datetime.datetime(2000, 1, 1)
query = client.query(kind="Task")
query.add_filter(filter=PropertyFilter("created", ">", start_date))
query.add_filter(filter=PropertyFilter("created", "<", end_date))

Ruby

query = datastore.query("Task")
                 .where("created", ">=", Time.utc(1990, 1, 1))
                 .where("created", "<", Time.utc(2000, 1, 1))

GQL


SELECT * FROM Task
WHERE created > DATETIME('1990-01-01T00:00:00z')
  AND created < DATETIME('2000-12-31T23:59:59z')

Diese Abfrage ist dagegen ungültig, da sie Ungleichheitsfilter für zwei verschiedene Attribute verwendet:

C#

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.GreaterThan("created", _startDate),
        Filter.GreaterThan("priority", 3))
};

Go

query := datastore.NewQuery("Task").
	FilterField("Created", ">", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
	FilterField("Priority", ">", 3)

Java

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

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('priority', '>', 3),
      new PropertyFilter('created', '>', new Date('1990-01-01T00:00:00z')),
    ])
  );

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 3)
    ->filter('created', '>', new DateTime('1990-01-01T00:00:00z'));

Python

from google.cloud import datastore

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

    start_date = datetime.datetime(1990, 1, 1)
    query = client.query(kind="Task")
    query.add_filter(filter=PropertyFilter("created", ">", start_date))
    query.add_filter(filter=PropertyFilter("priority", ">", 3))

Ruby

query = datastore.query("Task")
                 .where("created", ">=", Time.utc(1990, 1, 1))
                 .where("priority", ">", 3)

GQL


# Invalid query!
SELECT * FROM Task
WHERE created > DATETIME('1990-01-01T00:00:00z')
AND priority > 3

In einer Abfrage können Gleichheitsfilter (EQUAL) für unterschiedliche Attribute mit einem oder mehreren Ungleichheitsfiltern für ein einzelnes Attribut kombiniert werden. Daher ist die folgende Abfrage gültig:

C#

Query query = new Query("Task")
{
    Filter = Filter.And(Filter.Equal("priority", 4),
        Filter.GreaterThan("created", _startDate),
        Filter.LessThan("created", _endDate))
};

Go

query := datastore.NewQuery("Task").
	FilterField("Priority", "=", 4).
	FilterField("Done", "=", false).
	FilterField("Created", ">", time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)).
	FilterField("Created", "<", time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC))

Java

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

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('priority', '=', 4),
      new PropertyFilter('done', '=', false),
      new PropertyFilter('created', '>', new Date('1990-01-01T00:00:00z')),
      new PropertyFilter('created', '<', new Date('2000-12-31T23:59:59z')),
    ])
  );

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '=', 4)
    ->filter('done', '=', false)
    ->filter('created', '>', new DateTime('1990-01-01T00:00:00z'))
    ->filter('created', '<', new DateTime('2000-12-31T23:59:59z'));

Python

from google.cloud import datastore

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

start_date = datetime.datetime(1990, 1, 1)
end_date = datetime.datetime(2000, 12, 31, 23, 59, 59)
query = client.query(kind="Task")
query.add_filter(filter=PropertyFilter("priority", "=", 4))
query.add_filter(filter=PropertyFilter("done", "=", False))
query.add_filter(filter=PropertyFilter("created", ">", start_date))
query.add_filter(filter=PropertyFilter("created", "<", end_date))

Ruby

query = datastore.query("Task")
                 .where("done", "=", false)
                 .where("priority", "=", 4)
                 .where("created", ">=", Time.utc(1990, 1, 1))
                 .where("created", "<", Time.utc(2000, 1, 1))

GQL


SELECT * FROM Task
WHERE priority = 4
  AND done = FALSE
  AND created > DATETIME('1990-01-01T00:00:00z')
  AND created < DATETIME('2000-12-31T23:59:59z')

Sie können nicht gleichzeitig `NOT_EQUAL` und `NOT_IN` verwenden

Wenn Sie die NOT_IN verwenden, können Sie nicht gleichzeitig eine 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. Dies ist eine Optimierung, um eine unnötige Verarbeitung von einwertigen Attributen zu vermeiden. Da alle Ergebnisse den gleichen Wert für die Eigenschaft haben, 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, das Anwenden der Sortierreihenfolge teuer wäre und zusätzliche Indexe erfordert, ignoriert der Abfrageplaner im Datastore-Modus die Sortierfolge, auch wenn die Sortierfolge mit mehreren Werten bewertet wird. 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#

Nicht zutreffend

Go

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

Nicht zutreffend

Python

Nicht zutreffend

Ruby

Nicht zutreffend

GQL


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

Dies gilt nicht für Abfragen, die den Filter IN enthalten. Mit dem IN-Operator können Sie bis zu 10 Gleichheitsklauseln (==) für dasselbe Attribut mit einem logischen OR kombinieren. Wenn Sie für diese Eigenschaft eine Sortierreihenfolge festlegen, wird sie auf die Ergebnismenge angewendet.

C#

Nicht zutreffend

Go

Nicht zutreffend

Java

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

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

Um alle Ergebnisse abzurufen, die einem Ungleichheitsfilter entsprechen, durchsucht eine Abfrage den Index nach der ersten Zeile, die dem Filter entspricht, und scannt dann vorwärts, 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#

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

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

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 3)
    ->order('priority')
    ->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=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#

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

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=PropertyFilter("priority", ">", 3))
    query.order = ["created"]

Ruby

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

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

Java

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

Node.js

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

PHP

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

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=PropertyFilter("priority", ">", 3))
    query.order = ["created", "priority"]

Ruby

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 einem bestimmten Attribut sortieren, kann die Abfrage nur die Entitäten zurückgeben, in denen das Attribut „Sortieren nach“ vorhanden ist.

Die folgende Abfrage gibt beispielsweise keine Entitäten zurück, für die das Attribut priority nicht festgelegt ist, auch wenn sie ansonsten den Abfragefiltern entsprechen.

Java

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

Ein damit verbundener Effekt bezieht sich auf Ungleichungen. Eine Abfrage mit einem Ungleichheitsfilter für ein Attribut impliziert auch eine Sortierung nach diesem Attribut. Die folgende Abfrage gibt keine Entitäten ohne priority-Attribut zurück, auch wenn starred = true in dieser Entität enthalten ist. Als Behelfslösung können Sie separate Abfragen für jede Sortierung ausführen oder allen Attributen, nach denen Sie sortieren, einen Wert zuweisen.

Java

Query 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 folgende. Die Richtung der implizierten Sortierung hängt von den verfügbaren Indexen ab:

Java

Query 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 Attribute (prognostiziert oder Filter) im selben Index vorhanden sein müssen. Daher erfordert select tag from Task where priority = 1 einen zusammengesetzten Index nach Priorität und dann Tag.

Die Projektion wird für Strings, die länger als 1.500 Byte sind, Bytearrays mit mehr als 1.500 Elementen und andere Attribute, die explizit als nicht indexiert gekennzeichnet sind, nicht unterstützt.
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, sollten diese nicht in die Datenbank im Datastore-Modus zurückgeschrieben werden.
Projektionsabfragen wandeln Zeitstempel in Ganzzahlen um.

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

Nächste Schritte

Mehr über Transaktionen erfahren