Cette page a été traduite par l'API Cloud Translation.

Requêtes Datastore

Une requête permet de récupérer des entités qui répondent à un ensemble déterminé de conditions, depuis Firestore en mode Datastore.

La requête s'exécute sur des entités d'un genre donné. Elle peut spécifier des filtres sur les valeurs de propriété, les clés et les ancêtres des entités, et peut renvoyer zéro, une ou plusieurs entités en tant que résultats. Une requête peut également spécifier des ordres de tri pour séquencer les résultats en fonction de leurs valeurs de propriété. Les résultats incluent toutes les entités qui ont au moins une valeur pour chaque propriété nommée dans les filtres et les ordres de tri, et dont les valeurs de propriété répondent à tous les critères de filtre spécifiés. La requête peut renvoyer des entités entières, des entités projetées ou simplement des clés d'entité.

Une requête type comprend les éléments suivants :

Un genre d'entité auquel s'applique la requête.
Zéro, un ou plusieurs filtres basés sur les valeurs de propriété, les clés et les ancêtres des entités.
Zéro, un ou plusieurs ordres de tri, pour séquencer les résultats.

Lorsque la requête est exécutée, elle récupère toutes les entités d'un genre donné qui satisfont à tous les filtres définis, en les triant dans l'ordre spécifié. Les requêtes s'exécutent en lecture seule.

Remarque : Pour économiser de la mémoire et améliorer les performances, une requête doit, dans la mesure du possible, spécifier une limite concernant le nombre de résultats renvoyés.

Chaque requête calcule ses résultats au moyen d'un ou de plusieurs index qui contiennent des clés d'entité dans une séquence spécifiée par leurs propriétés et, éventuellement, par les ancêtres de l'entité. Les index sont mis à jour de manière incrémentielle pour refléter les modifications apportées par l'application à ses entités, afin que les résultats corrects de toutes les requêtes soient disponibles sans qu'aucun calcul supplémentaire soit nécessaire.

Le mécanisme de requête basé sur les index permet l'exécution d'un large éventail de requêtes et convient pour la plupart des applications, à l'exception des requêtes sans scaling, telles que les requêtes de jointure. Pour En savoir plus sur les limites du mode Datastore consultez la section Restrictions au niveau des requêtes.

Interface de requête

Vous pouvez émettre une requête sur un mode Datastore base de données. L'exemple suivant montre comment récupérer toutes les tâches qui ne sont pas encore terminées avec des priorités supérieures ou égales à 4, triées par ordre décroissant de priorité:

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Cloud Datastore, consultez Bibliothèques clientes Cloud Datastore. Pour en savoir plus, consultez les API C# Cloud Datastore documentation de référence.

Pour vous authentifier auprès de Cloud Datastore, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

L'exemple suivant montre comment exécuter une requête:

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

Non applicable

Structure d'une requête

Une requête peut spécifier un genre d'entité ainsi que zéro, un ou plusieurs filtres et ordres de tri.

Filtres

Les filtres d'une requête définissent des contraintes sur les propriétés, les clés et les ancêtres des entités à récupérer.

Filtres de propriété

Un filtre de propriété spécifie les éléments suivants:

Un nom de propriété
Un opérateur de comparaison
Une valeur de propriété

L'exemple suivant renvoie les entités de tâche marquées comme non terminées:

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

La valeur de propriété doit être fournie par l'application. Elle ne peut pas faire référence à d'autres propriétés ni être calculée en fonction de celles-ci. Une entité satisfait au filtre si elle possède une propriété du nom donné, dont la valeur est comparable à celle spécifiée dans le filtre, de la manière décrite par l'opérateur de comparaison. Si la propriété du nom donné est une valeur de tableau, l'entité satisfait au filtre si l'une des valeurs est comparable à celle spécifiée dans le filtre, de la manière décrite par l'opérateur de comparaison.

L'opérateur de comparaison peut être l'un des suivants :

Opérateur	Signification
`EQUAL`	Égal à
`LESS_THAN`	Inférieur à
`LESS_THAN_OR_EQUAL`	Inférieur ou égal à
`GREATER_THAN`	Supérieur à
`GREATER_THAN_OR_EQUAL`	Supérieur ou égal à
`NOT_EQUAL`	Différent de
`IN`	Membre de la liste spécifiée. Égal à l'une des valeurs d'une liste spécifiée.
`NOT_IN`	N'appartient pas à la liste spécifiée. N'est pas égal à l'une des valeurs d'une liste spécifiée.

Filtres composites

Un filtre composite est constitué de plusieurs filtres de propriété. Vous pouvez combiner des filtres avec AND et OR ; L'exemple suivant Renvoie les entités Task marquées comme non terminées et ayant une priorité de 4:

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

L'exemple suivant combine des filtres avec un OR logique:

C#

Extrait non disponible.

Go

Extrait non disponible.

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour le mode Datastore, consultez Bibliothèques clientes en mode Datastore. Pour en savoir plus, consultez les API Java du mode Datastore documentation de référence.

Pour vous authentifier auprès du mode Datastore, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour le mode Datastore, consultez Bibliothèques clientes en mode Datastore. Pour en savoir plus, consultez les API Node.js du mode Datastore documentation de référence.

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

Extrait non disponible.

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour le mode Datastore, consultez Bibliothèques clientes en mode Datastore. Pour en savoir plus, consultez les API Python du mode Datastore documentation de référence.

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

Extrait non disponible.

GQL

Extrait non disponible.

Firestore en mode Datastore accepte la combinaison de filtres avec AND et OR. les opérateurs. L'exemple suivant renvoie les entités Task qui sont ajoutées aux favoris ou qui qui sont marqués comme non terminés et qui ont une priorité de 4:

C#

Extrait non disponible.

Go

Extrait non disponible.

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

Extrait non disponible.

PHP

Extrait non disponible.

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

Extrait non disponible.

GQL

Extrait non disponible.

Filtres de clé

Pour filtrer sur la valeur d'une clé d'entité, faites appel à la propriété spéciale __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')

En cas de comparaison d'inégalité, les clés sont triées selon les critères suivants, dans cet ordre :

Chemin d'ancêtre
Genre d'entité
Identifiant (nom de clé ou ID numérique)

Les éléments du chemin d'ancêtre sont comparés de la même manière : par genre (chaîne), puis par nom de clé ou ID numérique. Les genres et les noms de clé sont des chaînes, et sont triés par valeur d'octet. Les ID numériques sont des entiers et sont triés par ordre numérique. Si des entités ayant le même parent et le même genre emploient une combinaison de chaînes de nom de clé et d'ID numériques, celles avec des ID numériques précèdent celles portant des noms de clé.

Les requêtes sur des clés utilisent des index de la même manière que les requêtes sur des propriétés et nécessitent des index personnalisés dans les mêmes cas. Les exceptions suivantes ne nécessitent pas d'index personnalisé:

Filtres d'inégalité
Ordre de tri croissant sur la clé

Un ordre de tri décroissant sur la clé nécessite un index personnalisé. Comme pour toutes les requêtes, le serveur de développement crée les entrées appropriées dans le fichier de configuration d'index lorsqu'une requête nécessitant un index personnalisé est employée dans l'environnement de développement.

Ordres de tri

L'ordre de tri d'une requête spécifie les éléments suivants:

Un nom de propriété.
Un sens de tri (croissant ou décroissant). Par défaut, l'ordre de tri est croissant.

Cet exemple trie les entités "Task" par ordre croissant d'heure de création :

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

Cet exemple trie les entités "Task" par ordre décroissant d'heure de création :

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

Si une requête comprend plusieurs ordres de tri, ils sont appliqués selon la séquence spécifiée. L'exemple suivant effectue un tri d'abord par ordre décroissant de priorité, puis par ordre croissant d'heure de création :

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

Si aucun ordre de tri n'est spécifié, les résultats sont renvoyés dans l'ordre dans lequel ils sont récupérés depuis le mode Datastore.

Restrictions

Les ordres de tri sont soumis aux restrictions suivantes:

En raison de la façon dont le mode Datastore s'exécute Requêtes, si celles-ci spécifient des filtres d'inégalité sur une propriété et des ordres de tri sur d'autres propriétés, la propriété utilisée dans les filtres d'inégalité doit être triée avant les autres propriétés.
Si le tri est spécifié, l'ensemble de propriétés spécifié dans la clause distinct on doit apparaître avant toute propriété non-distinct on dans les ordres de tri . Pour en savoir plus, consultez la section Regrouper des requêtes.
Les ordres de tri des propriétés avec des filtres d'égalité sont tous ignorés.

Types spéciaux de requêtes

Certains types spécifiques de requêtes méritent une attention particulière :

`!= Not equal`

Utilisez l'opérateur "différent de" (!=) pour renvoyer les entités dans lesquelles la propriété donnée est existe et ne correspond pas à la valeur de comparaison.

C#

Non applicable

</ph>

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

Non applicable

</ph>

PHP

Non applicable

</ph>

Python

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

Ruby

Non applicable

</ph>

GQL


SELECT * FROM Task WHERE category != 'work'

Cette requête renvoie chaque entité Task où la propriété category existe. et est défini sur une valeur autre que Work.

Cette requête ne renvoie pas d'entités où la propriété category n'existe pas. Différent de (!=) et NOT_IN les requêtes excluent les entités dans lesquelles la propriété donnée n'existe pas ou où la propriété est exclue de l'indexation. Une propriété existe lorsqu'elle est définie sur n'importe quelle valeur, y compris une chaîne vide ou null.

Limites

Veuillez noter les limites suivantes pour les requêtes != :

Seules les entités où la propriété donnée existe peuvent correspondre à la requête.
Un seul élément NOT_IN ou != est autorisé par requête.

`IN`

Utilisez l'opérateur IN pour combiner jusqu'à 30 égalités (==) sur la même propriété avec un opérateur logique OR. IN La requête renvoie les entités où la propriété donnée correspond à l'un des critères de comparaison. valeurs.

C#

Non applicable

</ph>

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

Non applicable

</ph>

PHP

Non applicable

</ph>

Python

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

Ruby

Non applicable

</ph>

GQL


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

Cette requête renvoie chaque entité Task où la propriété tag est définie sur learn. ou study. Cela inclut les entités Task où la propriété tag inclut l'un des éléments suivants : ces valeurs mais pas les autres.

`NOT_IN`

Utilisez l'opérateur NOT_IN pour combiner jusqu'à 10 clauses "différent de" (!=) sur le la même propriété avec une valeur logique AND. Une requête NOT_IN renvoie les entités dans lesquelles le la propriété donnée existe et ne correspond à aucune des valeurs de comparaison.

C#

Non applicable

</ph>

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

Non applicable

</ph>

PHP

Non applicable

</ph>

Python

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

Ruby

Non applicable

</ph>

GQL


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

Cette requête ne renvoie pas d'entités où l'entité category n'existe pas. Différent de (!=) et NOT_IN Les requêtes excluent les entités dans lesquelles la propriété donnée n'existe pas. Une propriété existe lorsqu'elle est définie sur n'importe quelle valeur, y compris une chaîne vide ou null.

Limites

Veuillez noter les limites suivantes pour les requêtes NOT_IN :

Seules les entités où la propriété donnée existe peuvent correspondre à la requête.
Un seul élément NOT_IN ou != est autorisé par requête.

Requêtes ascendantes

Une requête ascendante limite ses résultats à l'entité spécifiée et à ses descendants. Cet exemple renvoie toutes les entités "Task" ayant pour ancêtre l'entité "TaskList" spécifiée :

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')

Limites applicables aux requêtes ascendantes

Veuillez noter les limites suivantes pour les requêtes Ancestor :

Toutes les disjonctions évaluées doivent avoir le même filtre d'ancêtre.

Requêtes sans genre

Une requête sans genre ni ancêtre récupère toutes les entités d'une application à partir du mode Datastore. Ces requêtes sans genre ne peuvent pas inclure de filtres ni d'ordres de tri sur les valeurs de propriété. Toutefois, elles peuvent filtrer sur des clés d'entité et utiliser des filtres d'ancêtres. Pour employer des filtres de clé, spécifiez __key__ comme nom de propriété :

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')

Requêtes de projection

La plupart des requêtes renvoient des entités entières en tant que résultats, mais, bien souvent, une application ne s'intéresse en réalité qu'à quelques-unes des propriétés d'une entité. Les requêtes de projection vous permettent de n'exécuter des requêtes que sur les propriétés spécifiques d'une entité dont vous avez réellement besoin, ce qui entraîne une latence et un coût inférieurs à ceux induits par la récupération de l'entité entière.

Les requêtes de projection nécessitent l'indexation des propriétés spécifiées.

Requêtes ne contenant que des clés

Une requête ne contenant que des clés (qui est un type de requête de projection) renvoie seulement les clés des entités de résultat, et non les entités elles-mêmes, ce qui entraîne une latence et un coût inférieurs à ceux induits par la récupération d'entités entières.

Il est souvent plus économique de commencer par ce type de requête, puis d'extraire un sous-ensemble d'entités parmi les résultats, plutôt que d'exécuter une requête générale pouvant extraire plus d'entités que nécessaire.

Voici comment créer une requête ne contenant que des clés :

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

Une requête ne contenant que des clés est une petite opération qui est comptabilisée comme une seule lecture d'entité pour la requête elle-même.

Projections

Les requêtes de projection sont semblables aux requêtes SQL de ce type :

SELECT priority, percent_complete FROM Task

Vous pouvez employer toutes les fonctionnalités de filtrage et de tri disponibles pour les requêtes d'entité standards, par contre veillez à tenir compte de ces limites.

L'exemple de requête SQL renvoie des résultats partiels, seules les valeurs des propriétés spécifiées (priority et percent_complete) étant indiquées. Toutes les autres propriétés ne sont pas renseignées. Voici comment créer une requête de projection :

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

Et voici comment exécuter la requête de projection :

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

Non applicable

Une requête de projection qui n'utilise pas la clause distinct on est une petite opération et compte comme une seule lecture d'entité pour la requête elle-même.

Regroupement

Les requêtes de projection peuvent employer la clause distinct on pour garantir que seul le premier résultat de chaque combinaison distincte de valeurs pour les propriétés spécifiées est renvoyé. Cette clause renvoie seulement le premier résultat pour les entités dont les valeurs des propriétés en cours de projection sont identiques.

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

L'ensemble de propriétés spécifié dans la clause distinct on doit apparaître avant toute propriété non-distinct on dans la clause order by si order by est spécifié.

Requêtes d'agrégation

Firestore en mode Datastore est compatible avec la requête d'agrégation count(). Consultez la page Requêtes d'agrégation.

Filtres de plage et d'inégalité sur plusieurs propriétés

Firestore en mode Datastore accepte plusieurs filtres d'inégalité dans une requête composée. Consultez la section Exécuter une requête en utilisant des filtres de plage et d'inégalité sur plusieurs propriétés.

Valeurs de tableau

Le mode Datastore indexe chaque valeur unique de propriété de tableau une fois par index. Ainsi, pour vérifier si un tableau contient une valeur, utilisez un filtre d'égalité.

Lorsque la requête inclut des propriétés avec des valeurs de tableau, tenez compte des points ci-après.

Filtres d'inégalité

En raison de la manière dont elles sont indexées, les entités possédant plusieurs valeurs pour la même propriété peuvent parfois interagir avec les filtres et les ordres de tri de la requête de manière inattendue et surprenante.

Si une requête comporte plusieurs filtres d'inégalité sur une propriété donnée, une entité ne correspond à la requête que si au moins l'une de ses valeurs individuelles pour la propriété satisfait tous les filtres. Par exemple, si une entité du genre Task comporte les valeurs fun et programming pour la propriété tag, elle ne correspond pas à la requête suivante :

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'

Chacune des valeurs tag de l'entité satisfait à l'un des filtres, mais aucune valeur unique ne satisfait aux deux filtres.

Filtres d'égalité multiples

Plusieurs filtres d'égalité peuvent être utilisés pour interroger pour les entités contenant un ensemble de valeurs. Par exemple, une entité de genre Task avec les valeurs fun et programming pour la propriété tag satisfera la requête

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'

Et ce, même si aucune des valeurs tag individuelles de l'entité ne remplit les deux conditions de filtre.

Ordre de tri

De même, l'ordre de tri des propriétés à valeurs multiples est inhabituel. Étant donné que ces propriétés apparaissent une fois dans l'index pour chaque valeur unique, la première valeur affichée dans l'index détermine l'ordre de tri d'une entité.

Si une propriété à valeurs multiples n'est employée dans aucun filtre :

et que les résultats de la requête sont triés par ordre croissant de propriété, le tri est effectué en fonction de la valeur la plus faible ;
et que les résultats de la requête sont triés par ordre décroissant de propriété, le tri est effectué en fonction de la valeur la plus élevée ;
les autres valeurs n'affectent pas l'ordre de tri, pas plus que le nombre de valeurs.

Cela a pour conséquence inhabituelle qu'une entité dotée des valeurs de propriété 1 et 9 précède une entité possédant les valeurs 4, 5, 6 et 7 dans un tri par ordre croissant et dans un tri par ordre décroissant.

Si une propriété à valeurs multiples est employée dans un filtre d'égalité, tout ordre de tri basé sur cette propriété est ignoré.

Si une propriété à valeurs multiples est utilisée dans un filtre d'inégalité ou NOT_IN:

et que les résultats de la requête sont triés par ordre croissant de propriété, le tri est effectué en fonction de la plus petite valeur satisfaisant à tous les filtres d'inégalité de la requête ;
et que les résultats de la requête sont triés par ordre décroissant de propriété, le tri est effectué en fonction de la valeur la plus élevée satisfaisant à tous les filtres d'inégalité de la requête.

Sachez que si un ensemble de filtres d'inégalité d'une propriété se traduit par un filtre d'égalité, tel que :

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

tout ordre de tri basé sur cette propriété est ignoré, car les filtres renvoient le même résultat que le filtre d'égalité suivant :

WHERE tag = 'math'

Projections et propriétés dotées de valeurs de tableau

La projection d'une propriété avec des valeurs de tableau ne remplira pas toutes les valeurs correspondantes . À la place, une entité distincte sera renvoyée pour chaque combinaison unique de valeurs projetées correspondant à la requête. Par exemple, supposons que vous ayez une entité de genre Task dotée de deux propriétés ayant plusieurs valeurs, tag et 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

Non applicable

La requête de projection suivante :

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

renvoie quatre entités avec les combinaisons de valeurs suivantes :

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

Curseurs, limites et décalages

Vous pouvez spécifier une limite pour la requête afin de contrôler le nombre maximal de résultats renvoyés dans un lot. L'exemple suivant extrait au maximum cinq entités "Task" :

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

Les curseurs de requêtes permettent à une application de récupérer les résultats d'une requête sous forme de lots pratiques, sans entraîner la surcharge d'un décalage de requête. Après avoir effectué une opération de récupération, l'application peut obtenir un curseur, qui est une chaîne d'octets opaque marquant la position d'index du dernier résultat récupéré. L'application peut enregistrer cette chaîne (par exemple dans la base de données en mode Datastore, dans un cache, ou en l'intégrant dans une page Web en tant que paramètre HTTP GET ou POST encodé en base64). Elle peut ensuite utiliser le curseur comme point de départ pour une opération de récupération ultérieure, afin d'obtenir le prochain lot de résultats à partir du point où l'extraction précédente s'est terminée. Une récupération peut également spécifier un curseur de fin, afin de limiter l'étendue de l'ensemble de résultats renvoyé.

L'exemple qui suit illustre l'utilisation de curseurs pour la pagination.

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

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

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

Non applicable

Bien que les bases de données en mode Datastore acceptent les décalages d'entiers, évitez de les utiliser. Employez plutôt des curseurs. Un décalage permet seulement d'éviter de renvoyer les entités ignorées à l'application, mais ces dernières sont tout de même récupérées en interne. Les entités ignorées n'ont pas d'incidence sur la latence de la requête, et l'application est facturée pour les opérations de lecture nécessaires à leur récupération. En faisant appel à des curseurs plutôt qu'à des décalages, vous évitez tous ces coûts.

Limites relatives aux curseurs

Les curseurs sont soumis aux limites suivantes :

Un curseur ne peut être employé que par le projet qui a exécuté la requête d'origine, et seulement pour poursuivre la même requête. Il n'est pas possible de récupérer des résultats à l'aide d'un curseur sans configurer la requête à partir de laquelle il a été généré au départ.
Si l'un des éléments suivants est modifié, vous pouvez toujours employer un curseur pour les récupérations ultérieures :
- Curseur de début
- Curseur de fin
- Décalage
- Limite
Si l'un des éléments suivants est modifié, vous ne pouvez pas employer un curseur pour les récupérations ultérieures :
- Projection
- Genre
- Ancêtre
- Filtre
- Clause "distinct on"
- ordre de tri Il existe une exception : si l'ordre de tri final de la requête d'origine était défini sur __key__. Dans ce cas, vous pouvez employer le curseur dans une requête inverse, à savoir la requête d'origine avec chaque ordre de tri inversé. La requête inverse peut modifier le curseur de début, le curseur de fin, le décalage et la limite.
Les curseurs ne fonctionnent pas toujours comme prévu avec une requête qui emploie un filtre d'inégalité ou un ordre de tri basé sur une propriété à valeurs multiples. La logique de déduplication de ces propriétés à valeurs multiples ne persiste pas entre les récupérations, ce qui peut entraîner le renvoi du même résultat plusieurs fois.
Les nouvelles versions du mode Datastore peuvent modifier les détails de la mise en œuvre interne et invalider les curseurs qui en dépendent. Si une application tente d'employer un curseur qui n'est plus valide, Firestore en mode Datastore déclenche une exception.

Mises à jour des curseurs et des données

Le curseur représente l'emplacement dans la liste des résultats après le dernier résultat renvoyé. Un curseur n'est pas une position relative dans la liste (ce n'est pas un décalage). Il s'agit d'un marqueur auquel une base de données en mode Datastore peut accéder lors du lancement d'une analyse des résultats dans un index. Si les résultats d'une requête changent entre les différentes utilisations d'un curseur, la requête remarque uniquement les modifications apportées aux résultats situés après le curseur. Si un nouveau résultat apparaît avant la position du curseur pour la requête, il n'est pas renvoyé lors de l'extraction des résultats situés après le curseur. De même, si une entité ne constitue plus un résultat pour une requête, mais qu'elle apparaissait avant le curseur, les résultats qui apparaissent après le curseur ne changent pas. Si le dernier résultat renvoyé est supprimé de l'ensemble de résultats, le curseur est toujours capable de localiser le résultat suivant.

Lors de la récupération des résultats de la requête, vous pouvez utiliser un curseur de début et un curseur de fin pour renvoyer un groupe continu de résultats. Lorsque vous utilisez un curseur de début et de fin pour récupérer les résultats, vous n'êtes pas sûr d'obtenir la même taille de résultats que lorsque vous avez généré les curseurs. Des entités peuvent être ajoutées ou supprimées de la base de données entre le moment où les curseurs sont générés et celui où ils sont employés dans une requête.

Restrictions au niveau des requêtes

La nature du mécanisme de requête d'index impose certaines restrictions qu'une requête peut faire. Les requêtes en mode Datastore n'acceptent pas les correspondances de sous-chaînes. les correspondances non sensibles à la casse ou la recherche en texte intégral. En outre, les éléments suivants Des restrictions s'appliquent:

Les entités sans propriété nommée dans la requête sont ignorées

Les entités du même genre ne doivent pas nécessairement avoir les mêmes propriétés. Pour être éligible en tant que résultat de requête, une entité doit posséder une valeur (éventuellement nulle) pour chaque propriété nommée dans les filtres et les ordres de tri de la requête. Dans le cas contraire, l'entité est omise des index utilisés pour exécuter la requête et, par conséquent, ne sera pas incluse dans les résultats de la requête.

Le filtrage sur des propriétés non indexées ne renvoie aucun résultat

Une requête ne peut pas trouver les valeurs de propriétés qui ne sont pas indexées ni effectuer de tri en fonction de ces propriétés. Pour en savoir plus, consultez la section Propriétés non indexées.

Limites concernant les filtres d'inégalité

Pour éviter que l'exécution des requêtes ne devienne trop coûteuse, Firestore en mode Datastore limite le nombre de propriétés de plage ou d'inégalité à 10. Pour en savoir plus sur les requêtes avec des filtres d'inégalité, consultez la section Requête en utilisant des filtres de plage et d'inégalité sur plusieurs propriétés.

Vous ne pouvez pas utiliser à la fois `NOT_EQUAL` et `NOT_IN`.

Si vous utilisez NOT_IN, vous ne pouvez pas également ajouter un NOT_EQUAL.

Le tri des résultats de la requête n'est pas défini si aucun ordre de tri n'est spécifié

Lorsqu'une requête ne spécifie pas d'ordre de tri, les résultats sont renvoyés dans l'ordre dans lequel ils sont récupérés. Cet ordre est susceptible d'être modifié à mesure que la mise en œuvre du mode Datastore évolue, ou en cas de modification des index d'un projet. Par conséquent, si votre application requiert des résultats de requête dans un ordre particulier, veillez à spécifier explicitement cet ordre de tri dans la requête.

Les ordres de tri sont ignorés sur les propriétés dotées de filtres d'égalité

Les requêtes qui incluent un filtre d'égalité pour une propriété donnée ignorent tout ordre de tri spécifié pour cette dernière. Il s'agit d'une optimisation afin d’économiser pour les propriétés à valeur unique. Étant donné que tous les résultats présentent le paramètre valeur identique pour la propriété, aucun tri supplémentaire n'est nécessaire. En revanche, les propriétés à valeurs multiples peuvent avoir des valeurs supplémentaires en plus de celle qui correspond au filtre d'égalité. Comme ce cas d'utilisation est rare et que l'application de l'ordre de tri et qui nécessitent des index supplémentaires, la requête en mode Datastore planificateur ignore l'ordre de tri, même dans le cas de valeurs multiples. Cela peut entraîner le renvoi des résultats de la requête dans un ordre différent de celui que l'ordre de tri semble impliquer. Par exemple, l'ordre de tri est ignoré dans la requête suivante:

C#

Non applicable

</ph>

Go

Non applicable

</ph>

Java

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

Node.js

Non applicable

</ph>

PHP

Non applicable

</ph>

Python

Non applicable

</ph>

Ruby

Non applicable

</ph>

GQL


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

Cela ne s'applique pas aux requêtes incluant un filtre IN. Utilisez l'opérateur IN pour combiner jusqu'à 10 égalités. (==) sur la même propriété avec un OR logique. Si vous ajoutez un tri pour cette propriété, il est appliqué à l'ensemble de résultats.

C#

Non applicable

</ph>

Go

Non applicable

</ph>

Java

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

Node.js

Non applicable

</ph>

PHP

Non applicable

</ph>

Python

Non applicable

</ph>

Ruby

Non applicable

</ph>

GQL


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

Pour l'ordre croissant, la plus petite valeur conforme au filtre est utilisée pour le tri.
Pour l'ordre décroissant, la valeur la plus élevée conforme au filtre est utilisée pour le tri.
Les autres valeurs n'ont aucune incidence sur l'ordre de tri ni sur le nombre de valeurs dans la propriété.

Les propriétés utilisées dans les filtres d'inégalité doivent être triées en premier

Pour récupérer tous les résultats correspondant à un filtre d'inégalité, une requête recherche dans l'index la première ligne correspondant au filtre, puis analyse les résultats jusqu'à ce qu'elle rencontre une ligne non correspondante. Pour que les lignes consécutives englobent l'intégralité de l'ensemble de résultats, elles doivent être triées en fonction de la propriété utilisée dans le filtre d'inégalité avant toute autre propriété. Ainsi, si une requête spécifie un ou plusieurs filtres d'inégalité avec un ou plusieurs ordres de tri, le premier ordre de tri doit faire référence à la propriété qui est nommée dans les filtres d'inégalité. Voici une requête valide :

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

La requête suivante n'est pas valide, car elle n'effectue pas de tri en fonction de la propriété employée dans le filtre d'inégalité :

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

De même, la requête suivante n'est pas valide, car la propriété employée dans le filtre d'inégalité n'est pas la première triée :

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` et existence

Lorsque vous triez une requête en fonction d'une propriété donnée, elle ne peut renvoyer que le Entités dans lesquelles la propriété "order-by" existe.

Par exemple, la requête suivante ne renvoie aucune entité dont le La propriété priority n'est pas définie, même si elle répond aux filtres de requête.

Java

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

Un effet connexe s'applique aux inégalités. Une requête avec un filtre d'inégalité sur une propriété implique également de trier selon cette propriété. Les éléments suivants : ne renvoie pas d'entités sans propriété priority, même si starred = true dans cette entité. Pour contourner ce problème, vous pouvez exécuter des requêtes distinctes pour chaque classement ou vous pouvez attribuer une valeur à toutes les propriétés que vous commandez.

Java

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

La requête précédente inclut une clause de tri implicite sur l'inégalité, telle que la suivis. Le sens de l'ordre implicite dépend des index disponibles:

Java

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

Limites relatives aux projections

Les requêtes de projection sont soumises aux restrictions suivantes :

Seules les propriétés indexées peuvent être projetées.

Cela signifie que toutes les propriétés utilisées dans une requête (projets ou filtres) doivent dans le même index. Ainsi, select tag from Task where priority = 1 nécessite un index composite sur priorité, puis tag.

La projection n'est pas compatible avec les chaînes de plus de 1 500 octets. Tableaux d'octets comportant plus de 1 500 éléments et autres propriétés explicitement marqués comme non indexés.
Une même propriété ne peut pas être projetée plusieurs fois.
Les propriétés référencées dans un filtre d'égalité ne peuvent pas être projetées.

Par exemple,
```
SELECT tag FROM Task WHERE priority = 1
```
est une requête valide (propriété projetée non utilisée dans le filtre d'égalité), de même que :
```
SELECT tag FROM Task WHERE tag > 'fun`
```
(pas un filtre d'égalité). Par contre :
```
SELECT tag FROM Task WHERE tag = 'fun`
```
(propriété projetée utilisée dans un filtre d'égalité) n'est pas une requête valide.
Les résultats renvoyés par une requête de projection ne doivent pas être réenregistrés dans votre base de données en mode Datastore.

Étant donné que la requête renvoie des résultats qui ne sont que partiellement renseignés, vous ne devez pas les réécrire dans la base de données en mode Datastore.
Les requêtes de projection convertissent les horodatages en entiers.

Dans les résultats d'une requête de projection, le mode Datastore convertit les valeurs d'horodatage en valeurs entières exprimées en microsecondes.

Étape suivante

Apprenez-en davantage sur les transactions.