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 est compatible avec un large éventail de requêtes et convient à la plupart des applications, à l'exception des requêtes non évolutives, telles que les requêtes de jointure. Pour en savoir plus sur les limites concernant les requêtes en mode Datastore, consultez la section Restrictions au niveau des requêtes.

Interface de requête

Vous pouvez émettre une requête sur une base de données en mode Datastore. L'exemple suivant montre comment récupérer toutes les tâches qui ne sont pas encore terminées et dont la priorité est supérieure ou égale à 4, puis les trier par ordre décroissant de priorité:

C#

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

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

Ruby

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

GQL

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

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=datastore.query.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`	Ne fait pas partie de la liste spécifiée. Ne correspond à aucune 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=datastore.query.PropertyFilter("done", "=", False))
query.add_filter(filter=datastore.query.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 opérateur logique OR:

C#

Extrait non disponible.

Go

Extrait non disponible.

Java

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

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

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

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 les opérateurs AND et OR. L'exemple suivant renvoie les entités Task marquées d'une étoile ou non terminées, et ayant 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 portant sur des clés utilisent des index, tout comme celles portant sur des propriétés. 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 manière dont le mode Datastore exécute les requêtes, si une requête spécifie 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 un ordre est spécifié, l'ensemble de propriétés spécifié dans la clause distinct on doit apparaître avant toute propriété autre que distinct on dans les ordres de tri . Pour en savoir plus, consultez la section Regrouper des requêtes.
Les ordres de tri sur les propriétés dotées de 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 "not equal" (!=) pour renvoyer des entités dont la propriété donnée existe et ne correspond pas à la valeur de comparaison.

C#

Non applicable

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

PHP

Non applicable

Python

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

Ruby

Non applicable

GQL

SELECT * FROM Task WHERE category != 'work'

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

Cette requête ne renvoie pas d'entités où la propriété category n'existe pas. Les requêtes Not-equal (!=) et NOT_IN excluent les entités pour lesquelles la propriété donnée n'existe pas ou pour lesquelles 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 dont la propriété donnée existe peuvent correspondre à la requête.
Un seul NOT_IN ou != est autorisé par requête.

`IN`

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

C#

Non applicable

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

PHP

Non applicable

Python

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

Ruby

Non applicable

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 dont la propriété tag inclut l'une de ces valeurs, mais pas l'autre.

`NOT_IN`

Utilisez l'opérateur NOT_IN pour combiner jusqu'à 10 clauses non différentes (!=) sur la même propriété avec un opérateur AND logique. Une requête NOT_IN renvoie des entités où la propriété donnée existe et ne correspond à aucune des valeurs de comparaison.

C#

Non applicable

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

PHP

Non applicable

Python

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

Ruby

Non applicable

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. Les requêtes Not-equal (!=) et NOT_IN excluent les entités pour 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 dont la propriété donnée existe peuvent correspondre à la requête.
Un seul 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 des 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, comptabilisée 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é autre que 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 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 Requête 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=datastore.query.PropertyFilter("tag", ">", "learn"))
query.add_filter(filter=datastore.query.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

Il est possible d'utiliser plusieurs filtres d'égalité pour rechercher des entités contenant un ensemble de valeurs. Par exemple, une entité de type Task avec les valeurs fun et programming pour la propriété tag satifiera 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=datastore.query.PropertyFilter("tag", "=", "fun"))
query.add_filter(filter=datastore.query.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 ;
l'ordre de tri n'est pas affecté par les autres valeurs, ni par leur nombre.

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 employée dans une inégalité ou un filtre 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é dotée de valeurs de tableau ne remplira pas toutes les valeurs de cette propriété. À 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 Une exception est faite 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. Comme la logique de déduplication de ces propriétés à valeurs multiples ne persiste pas entre les récupérations, le même résultat peut être renvoyé 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 cette requête, il n'est pas renvoyé lors de la récupération des résultats situés après le curseur. De la même façon, si une entité ne constitue plus un résultat pour une requête alors qu'elle apparaissait avant le curseur, les résultats situés 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 concernant ce qu'une requête est capable de 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. De plus, les restrictions suivantes 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. Sinon, l'entité est omise des index servant à exécuter la requête et, par conséquent, elle n'est 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 des filtres d'inégalité

Pour éviter que les requêtes ne deviennent trop coûteuses à exécuter, 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 Requête 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 non plus ajouter de clause 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 ont été 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 l'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 permettant d'éviter un traitement inutile pour les propriétés à une seule valeur. Étant donné que tous les résultats auront la même valeur pour la propriété, aucun tri supplémentaire ne sera donc 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 d'un ordre de tri est coûteuse et nécessite des index supplémentaires, le planificateur de requêtes du mode Datastore ignore cet ordre de tri, même en 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

Go

Non applicable

Java

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

Node.js

Non applicable

PHP

Non applicable

Python

Non applicable

Ruby

Non applicable

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 qui incluent un filtre IN. Utilisez l'opérateur IN pour combiner jusqu'à 10 clauses d'égalité (==) sur la même propriété avec un opérateur OR logique. Si vous ajoutez un ordre de tri pour cette propriété, il s'applique au jeu de résultats.

C#

Non applicable

Go

Non applicable

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

PHP

Non applicable

Python

Non applicable

Ruby

Non applicable

GQL

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

Pour l'ordre croissant, la valeur la plus faible satisfaisant au filtre est utilisée pour le tri.
Pour l'ordre décroissant, le tri est effectué en fonction de la valeur la plus élevée satisfaisant au filtre.
L'ordre de tri n'est pas affecté par les autres valeurs, ni par leur nombre.

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 poursuit l'analyse jusqu'à ce qu'elle rencontre une ligne qui ne correspond pas. 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=datastore.query.PropertyFilter("priority", ">", 3))
query.order = ["priority", "created"]

Ruby

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

GQL

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

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=datastore.query.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=datastore.query.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 par une propriété donnée, elle ne peut renvoyer que les entités dans lesquelles la propriété de tri existe.

Par exemple, la requête suivante ne renverrait aucune entité pour laquelle la propriété priority n'est pas définie, même si elles répondent aux filtres de la requête.

Java

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

Un effet similaire s'applique aux inégalités. Une requête avec un filtre d'inégalité sur une propriété implique également un tri par cette propriété. La requête suivante ne renvoie pas d'entités sans propriété priority, même si starred = true est présent dans cette entité. Pour contourner ce problème, vous pouvez exécuter des requêtes distinctes pour chaque tri ou attribuer une valeur à toutes les propriétés que vous triez.

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 un ordre implicite sur l'inégalité, comme suit : 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 (projetées ou filtrées) doivent exister dans le même indice. Par conséquent, select tag from Task where priority = 1 nécessite un indice composite sur la priorité, puis la balise.

La projection n'est pas acceptée pour les chaînes de plus de 1 500 octets, les tableaux d'octets comportant plus de 1 500 éléments et d'autres propriétés explicitement marquées comme non indexées.
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 la base de données en mode Datastore.

La requête renvoie des résultats qui ne sont que partiellement renseignés. Par conséquent, 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.