Query Datastore

Una query recupera entità da Firestore in modalità Datastore che soddisfano un insieme specificato di condizioni.

La query opera su entità di un determinato kind; può specificare filtri su valori, chiavi e predecessori delle proprietà delle entità e può restituire zero o più entità come risultati. Una query può anche specificare ordini di ordinamento per mettere in sequenza i risultati in base ai valori delle proprietà. I risultati includono tutte le entità che hanno almeno un valore per ogni proprietà denominata nei filtri e negli ordini di ordinamento e i cui valori delle proprietà soddisfano tutti i criteri di filtro specificati. La query può restituire intere entità, entità previste o solo chiavi di entità.

Una query tipica include quanto segue:

Un tipo di entità a cui si applica la query
Zero o più filtri in base a valori, chiavi e predecessori delle proprietà delle entità
Zero o più ordini di ordinamento per mettere in sequenza i risultati

Quando viene eseguita, la query recupera tutte le entità del tipo specificato che soddisfano tutti i filtri indicati, ordinate nell'ordine specificato. Le query vengono eseguite in sola lettura.

Nota: per risparmiare memoria e migliorare le prestazioni, per una query deve, quando possibile, specificare un limite per il numero di risultati restituiti.

Ogni query calcola i risultati utilizzando uno o più indici, che contengono chiavi di entità in una sequenza specificata dalle proprietà dell'indice e, facoltativamente, dai predecessori dell'entità. Gli indici vengono aggiornati in modo incrementale per riflettere eventuali modifiche apportate dall'applicazione alle sue entità, in modo che siano disponibili i risultati corretti di tutte le query senza bisogno di ulteriori calcoli.

Il meccanismo di query basato su indice supporta un'ampia gamma di query ed è adatto alla maggior parte delle applicazioni. Tuttavia, non supporta alcuni tipi di query comuni in altre tecnologie di database: in particolare, i join e le query aggregate non sono supportati all'interno del motore di query in modalità Datastore. Per le limitazioni relative alle query in modalità Datastore, consulta Restrizioni per le query.

Interfaccia query

Ecco un esempio di base dell'invio di una query su un database in modalità Datastore. Recupera tutte le attività non ancora completate con priorità maggiori o uguali a 4, ordinate in ordine decrescente in base alla priorità:

C#

Per scoprire come installare e utilizzare la libreria client per Cloud Datastore, consulta librerie client di Cloud Datastore. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Datastore C#.

Per eseguire l'autenticazione in Cloud Datastore, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Ecco come eseguire una query:

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 applicabile

Struttura della query

Una query può specificare un tipo di entità, zero o più filtri e zero o più ordini di ordinamento.

Filtri

I filtri di una query impostano vincoli per le proprietà, le chiavi e i predecessori delle entità da recuperare.

Filtri proprietà

Un filtro proprietà specifica

Il nome di una proprietà
Un operatore di confronto
Un valore proprietà

Questo esempio restituisce le entità Attività contrassegnate come non completate:

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

Il valore della proprietà deve essere fornito dall'applicazione; non può fare riferimento ad altre proprietà né può essere calcolato. Un'entità soddisfa il filtro se ha una proprietà del nome specificato il cui valore viene confrontato con quello specificato nel filtro nel modo descritto dall'operatore di confronto. Se la proprietà del nome specificato ha un valore di array, l'entità soddisfa il filtro se uno dei valori viene confrontato con il valore specificato nel filtro nel modo descritto dall'operatore di confronto.

L'operatore di confronto può essere:

Operatore	Significato
`EQUAL`	Uguale a
`LESS_THAN`	Minore di
`LESS_THAN_OR_EQUAL`	Minore o uguale a
`GREATER_THAN`	Maggiore di
`GREATER_THAN_OR_EQUAL`	Maggiore o uguale a
`NOT_EQUAL`	Diverso da
`IN`	Membro dell'elenco specificato. Uguale a uno qualsiasi dei valori in un elenco specificato.
`NOT_IN`	Non è membro dell'elenco specificato. Non uguale a nessuno dei valori presenti in un elenco specificato.

Filtri compositi

Un filtro composto è costituito da più di un filtro di proprietà. Puoi combinare i filtri con AND e OR. Questo esempio restituisce Task entità contrassegnate come non completate e che hanno una priorità di 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

Questo esempio combina filtri con un OR logico:

C#

Snippet non disponibile.

Go

Snippet non disponibile.

Java

Per scoprire come installare e utilizzare la libreria client per la modalità Datastore, consulta Librerie client in modalità Datastore. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java per la modalità Datastore.

Per eseguire l'autenticazione in modalità Datastore, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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);
  entities.sort();
  for (const entity of entities) {
    console.log(`Entity found: ${entity['description']}`);
  }
}

queryFilterOr();

PHP

Snippet non disponibile.

Python

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

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

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

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

    or_query.add_filter(filter=or_filter)

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

Ruby

Snippet non disponibile.

GQL

Snippet non disponibile.

Firestore in modalità Datastore supporta la combinazione di filtri con gli operatori AND e OR. Questo esempio restituisce le entità Task contrassegnate come speciali o contrassegnate come non completate e che hanno una priorità di 4:

C#

Snippet non disponibile.

Go

Snippet non disponibile.

Java

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

Node.js

Snippet non disponibile.

PHP

Snippet non disponibile.

Python

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

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

and_or_query.add_filter(filter=query_filter)

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

Ruby

Snippet non disponibile.

GQL

Snippet non disponibile.

Filtri principali

Per filtrare in base al valore della chiave di un'entità, utilizza la proprietà speciale __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')

Quando si confronta la disuguaglianza, le chiavi vengono ordinate in base ai seguenti criteri:

Percorso predecessore
Tipo di entità
Identificatore (nome chiave o ID numerico)

Gli elementi del percorso predecessore vengono confrontati in modo simile: per tipo (stringa), poi per nome chiave o ID numerico. I tipi e i nomi delle chiavi sono stringhe e sono ordinati per valore byte; gli ID numerici sono numeri interi in ordine numerico. Se le entità con lo stesso tipo e l'elemento principale utilizzano una combinazione di stringhe di nomi chiave e ID numerici, quelle con ID numerici le antepongono ai nomi delle chiavi.

Le query sulle chiavi utilizzano gli indici proprio come le query sulle proprietà e, negli stessi casi, richiedono indici personalizzati, con un paio di eccezioni: i filtri di disuguaglianza o un ordinamento crescente nella chiave non richiedono un indice personalizzato, ma un ordinamento decrescente nella chiave sì. Come per tutte le query, il server di sviluppo crea voci appropriate nel file di configurazione degli indici quando nell'ambiente di sviluppo viene utilizzata una query che richiede un indice personalizzato.

Ordinare gli ordini

Un ordinamento delle query specifica

Il nome di una proprietà.
Una direzione di ordinamento (ordine crescente o decrescente). Per impostazione predefinita, l'ordinamento è crescente.

Questo esempio ordina le entità dell'attività in base all'ora di creazione in ordine crescente:

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

Questo esempio ordina le entità Tasks in base all'ora di creazione in ordine decrescente:

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

Se una query include più ordini, questi vengono applicati nella sequenza specificata. L'esempio seguente ordina prima in base alla priorità decrescente e poi in base all'ora di creazione in ordine crescente:

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

Se non vengono specificati ordini di ordinamento, i risultati vengono restituiti nell'ordine in cui sono stati recuperati dalla modalità Datastore.

Limitazioni

Tieni presente le seguenti restrizioni per gli ordini di ordinamento:

A causa del modo in cui la modalità Datastore esegue le query, se una query specifica filtri di disuguaglianza su una proprietà e ordina gli ordini in altre proprietà, la proprietà utilizzata nei filtri di disuguaglianza deve essere ordinata prima delle altre proprietà.
L'insieme di proprietà specificato nella clausola distinct on deve apparire prima di qualsiasi proprietà non disintct on negli ordini di ordinamento, se l'ordinamento è specificato. Consulta la sezione sul raggruppamento delle query.
L'ordinamento degli ordini nelle proprietà con filtri di uguaglianza viene ignorato.

Tipi di query speciali

Alcuni tipi specifici di query meritano una menzione speciale:

`!= Not equal`

Utilizza l'operatore non uguale (!=) per restituire entità in cui la proprietà specificata esiste e non corrisponde al valore di confronto.

C#

Non applicabile

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 applicabile

PHP

Non applicabile

Python

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

Ruby

Non applicabile

GQL


SELECT * FROM Task WHERE category != 'work'

Questa query restituisce ogni entità Task in cui esiste la proprietà category ed è impostata su un valore diverso da Work.

Questa query non restituisce entità in cui la proprietà category non esiste. Le query Diverso (!=) e NOT_IN escludono le entità in cui la proprietà specificata non esiste o in cui è esclusa dall'indicizzazione. Una proprietà esiste quando è impostata su qualsiasi valore, inclusa una stringa vuota o null.

Limitazioni

Tieni presente le seguenti limitazioni per le query !=:

Solo le entità in cui esiste la proprietà specificata possono corrispondere alla query.
È consentito un solo valore NOT_IN o != per query.

`IN`

Utilizza l'operatore IN per combinare fino a 30 clausole di uguaglianza (==) nella stessa proprietà con un OR logico. Una query IN restituisce entità in cui la proprietà specificata corrisponde a uno dei valori di confronto.

C#

Non applicabile

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 applicabile

PHP

Non applicabile

Python

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

Ruby

Non applicabile

GQL


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

Questa query restituisce ogni entità Task in cui la proprietà tag è impostata su learn o study. Sono incluse le entità Task in cui la proprietà tag include uno di questi valori ma non l'altro.

`NOT_IN`

Utilizza l'operatore NOT_IN per combinare fino a 10 clausole non uguali (!=) nella stessa proprietà con un AND logico. Una query NOT_IN restituisce entità in cui la proprietà specificata esiste e non corrisponde a nessun valore di confronto.

C#

Non applicabile

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 applicabile

PHP

Non applicabile

Python

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

Ruby

Non applicabile

GQL


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

Questa query non restituisce entità in cui l'entità category non esiste. Le query Diverso (!=) e NOT_IN escludono le entità in cui la proprietà specificata non esiste. Una proprietà esiste quando è impostata su qualsiasi valore, inclusa una stringa vuota o null.

Limitazioni

Tieni presente le seguenti limitazioni per le query NOT_IN:

Solo le entità in cui esiste la proprietà specificata possono corrispondere alla query.
È consentito un solo valore NOT_IN o != per query.

Query sui predecessori

Una query da predecessore limita i risultati all'entità specificata e ai suoi discendenti. Questo esempio restituisce tutte le entità Tasks che hanno l'entità TaskList specificata come predecessore:

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

Limitazioni sulle query precedenti

Tieni presente le seguenti limitazioni per le query Ancestor:

Tutte le disgiunzioni valutate devono avere lo stesso filtro dei predecessori.

Query senza carattere

Una query senza tipo e nessun predecessore recupera tutte le entità di un'applicazione dalla modalità Datastore. Queste query gentili non possono includere filtri o ordinare ordini in base ai valori delle proprietà. Tuttavia, possono filtrare in base alle chiavi di entità e utilizzare i filtri dei predecessori. Per utilizzare i filtri chiave, specifica __key__ come nome della proprietà:

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

Query di proiezione

La maggior parte delle query restituisce intere entità come risultati, ma spesso un'applicazione è in realtà interessata solo ad alcune delle proprietà dell'entità. Le query di proiezione ti consentono di eseguire query solo per quelle proprietà specifiche di un'entità di cui hai effettivamente bisogno, con latenza e costi inferiori rispetto al recupero dell'intera entità.

Le query di proiezione richiedono l'indicizzazione delle proprietà specificate.

Query basate solo su chiavi

Una query basata solo sulle chiavi (che è un tipo di query di proiezione) restituisce solo le chiavi delle entità risultati anziché le entità stesse, con una latenza e un costo inferiori rispetto al recupero di intere entità.

Spesso è più economico eseguire prima una query basata solo su chiavi e poi recuperare un sottoinsieme di entità dai risultati, anziché eseguire una query generale che potrebbe recuperare più entità di quelle di cui hai effettivamente bisogno.

Ecco come creare una query basata solo su chiavi:

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

Una query basata solo su chiavi è un'operazione di piccole dimensioni e viene conteggiata come una singola lettura di entità per la query stessa.

Proiezioni

Le query di proiezione sono simili alle query SQL nel formato:

SELECT priority, percent_complete FROM Task

Puoi utilizzare tutte le funzionalità di filtro e ordinamento disponibili per le query di entità standard, ma tieni presente queste limitazioni.

La query SQL di esempio restituisce risultati ridotti con solo le proprietà specificate, priority e percent_complete, completate con i valori; tutte le altre proprietà non vengono compilate. Ecco come crearlo come query di proiezione:

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

Ecco come eseguire la query di proiezione:

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 applicabile

Una query di proiezione che non utilizza la clausola distinct on è un'operazione piccola e viene conteggiata come una singola lettura di entità per la query stessa.

Raggruppamento

Le query di proiezione possono utilizzare la clausola distinct on per garantire che venga restituito solo il primo risultato per ogni combinazione distinta di valori per le proprietà specificate. Verrà restituito solo il primo risultato per le entità che hanno gli stessi valori per le proprietà previste.

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'insieme di proprietà specificato nella clausola distinct on deve apparire prima di qualsiasi proprietà non disintct on nella clausola order by se order by è specificato.

Query di aggregazione

Firestore in modalità Datastore supporta la query di aggregazione count(). Consulta Query di aggregazione.

Filtri di intervallo e disuguaglianza su più proprietà

Firestore in modalità Datastore supporta più filtri di disuguaglianza in una query composta. Consulta Eseguire query utilizzando filtri di intervallo e disuguaglianza su più proprietà.

Valori array

La modalità Datastore indicizza ogni valore di proprietà array univoco una volta per indice. Per eseguire una query se un array contiene un valore, usa un filtro di uguaglianza.

Considera quanto segue quando la query include proprietà con valori array.

Filtri di disuguaglianza

A causa del modo in cui vengono indicizzati, le entità con più valori per la stessa proprietà a volte possono interagire con i filtri delle query e ordinare gli ordini in modi inaspettati e sorprendenti.

Se una query ha più filtri di disuguaglianza su una determinata proprietà, un'entità corrisponderà alla query solo se almeno uno dei suoi singoli valori per la proprietà soddisfa tutti i filtri. Ad esempio, se un'entità di tipo Task ha valori fun e programming per la proprietà tag, non corrisponderà alla query:

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'

Ciascun valore tag dell'entità soddisfa uno dei filtri, ma nessuno dei due valori soddisfa entrambi.

Più filtri di uguaglianza

Si possono usare più filtri di uguaglianza per cercare entità che contengono un insieme di valori. Ad esempio, un'entità di tipo Task con valori fun e programming per la proprietà tag soddisfa la query

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'

anche se nessuno dei singoli valori tag dell'entità soddisfa entrambe le condizioni di filtro.

Ordinamento

Analogamente, l'ordinamento per le proprietà con più valori è insolito. Poiché queste proprietà vengono visualizzate una sola volta nell'indice per ogni valore univoco, il primo valore visualizzato nell'indice determina l'ordinamento di un'entità.

Se in nessun filtro viene utilizzata una proprietà a più valori:

e i risultati della query vengono ordinati in ordine crescente in base alla proprietà, il valore più basso della proprietà viene utilizzato per l'ordinamento.
e i risultati della query vengono ordinati in ordine decrescente in base alla proprietà, per l'ordinamento viene utilizzato il valore più alto.
gli altri valori non influiscono sull'ordinamento, né sul numero di valori.

Ciò ha l'insolita conseguenza che un'entità con valori di proprietà 1 e 9 preceda un'entità con i valori 4, 5, 6 e 7 in ordine crescente e decrescente.

Se in un filtro di uguaglianza viene utilizzata una proprietà a più valori, qualsiasi ordinamento nella proprietà viene ignorato.

Se una proprietà a più valori viene utilizzata in una disuguaglianza o in un filtro NOT_IN:

e i risultati della query vengono ordinati in ordine crescente in base alla proprietà, per l'ordinamento viene utilizzato il valore più basso che soddisfa tutti i filtri di disuguaglianza della query.
e i risultati della query vengono ordinati in ordine decrescente in base alla proprietà, per l'ordinamento viene utilizzato il valore massimo che soddisfa tutti i filtri di disuguaglianza della query.

Tieni presente che se un insieme di filtri di disuguaglianza su una proprietà si traduce in un filtro di uguaglianza, come

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

qualsiasi ordinamento nella proprietà viene ignorato, poiché i filtri restituiscono lo stesso valore del filtro di uguaglianza

WHERE tag = 'math'

Proiezioni e proprietà con valore array

La proiezione di una proprietà con valori array non completerà tutti i valori per quella proprietà. Verrà invece restituita un'entità separata per ogni combinazione univoca di valori previsti corrispondenti alla query. Ad esempio, supponi di avere un'entità di tipo Task con due proprietà a più valori, tag e 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 applicabile

Quindi la query di proiezione

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

restituirà quattro entità con le seguenti combinazioni di valori:

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

Cursori, limiti e offset

Puoi specificare un limite per la query per controllare il numero massimo di risultati restituiti in un batch. L'esempio seguente recupera al massimo cinque entità attività:

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

I cursori di query consentono a un'applicazione di recuperare i risultati di una query in batch comodi senza incorrere nell'overhead di un offset di query. Dopo aver eseguito un'operazione di recupero, l'applicazione può ottenere un cursore, ovvero una stringa di byte opaca che contrassegna la posizione dell'indice dell'ultimo risultato recuperato. L'applicazione può salvare questa stringa (ad esempio nel tuo database in modalità Datastore, in una cache o incorporata in una pagina web come parametro HTTP GET o POST con codifica Base64) e può quindi utilizzare il cursore come punto di partenza per un'operazione di recupero successiva per ottenere il batch di risultati successivo dal punto in cui è terminato il recupero precedente. Un recupero può anche specificare un cursore finale per limitare l'estensione del set di risultati restituito.

L'esempio seguente mostra l'utilizzo dei cursori per l'impaginazione:

C#

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

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

Go

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

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

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

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

Java

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

Node.js

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

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

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

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

  return [entities, info];
}

PHP

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

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

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

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

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

Python

from google.cloud import datastore

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

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

    tasks = list(page)
    next_cursor = query_iter.next_page_token

    return tasks, next_cursor

Ruby

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

page_cursor = tasks.cursor

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

GQL

Non applicabile

Sebbene i database in modalità Datastore supportino gli offset di numeri interi, dovresti evitare di utilizzarli. Utilizza invece i cursori. L'uso di un offset evita solo di restituire le entità ignorate all'applicazione, ma che vengono comunque recuperate internamente. Le entità ignorate influiscono sulla latenza della query e all'applicazione vengono fatturate le operazioni di lettura necessarie per recuperarle. Se utilizzi i cursori anziché gli offset, puoi evitare tutti questi costi.

Limitazioni dei cursori

I cursori sono soggetti alle seguenti limitazioni:

Un cursore può essere utilizzato solo dallo stesso progetto che ha eseguito la query originale e solo per continuare la stessa query. Non è possibile recuperare i risultati utilizzando un cursore senza configurare la stessa query da cui è stato inizialmente generato.
Se viene modificato uno qualsiasi dei seguenti elementi, è comunque possibile utilizzare un cursore per i recuperi successivi.
- avvia il cursore
- cursore finale
- offset
- limite
Se viene modificato uno qualsiasi dei seguenti elementi, non è possibile utilizzare un cursore per i recuperi successivi.
- projection
- kind
- ancestor
- filtro
- distinto su
- ordinamento Un'eccezione è se l'ordinamento finale della query originale era in __key__. In questo caso, puoi utilizzare il cursore in una query inversa, che corrisponde alla query originale con ogni ordinamento invertito. La query inversa può modificare il cursore iniziale, il cursore finale, l'offset e il limite.
I cursori non funzionano sempre come previsto in una query che utilizza un filtro di disuguaglianza o un ordinamento in una proprietà con più valori. La logica di deduplicazione di queste proprietà a più valori non persiste tra un recupero e l'altro, causando probabilmente la restituzione dello stesso risultato più volte.
Le nuove release in modalità Datastore possono modificare i dettagli di implementazione interni, annullando i cursori che dipendono da essi. Se un'applicazione tenta di utilizzare un cursore non più valido, Firestore in modalità Datastore genera un'eccezione.

Cursori e aggiornamenti dei dati

Il cursore rappresenta la posizione nell'elenco dei risultati dopo l'ultimo risultato restituito. Il cursore non è una posizione relativa nell'elenco (non rappresenta un offset), ma un indicatore a cui può passare un database in modalità Datastore all'avvio di una scansione dell'indice per trovare i risultati. Se i risultati di una query cambiano a seconda dell'uso del cursore, la query rileva solo le modifiche che si verificano nei risultati successivi al cursore. Se un nuovo risultato viene visualizzato prima della posizione del cursore per la query, non verrà restituito quando vengono recuperati i risultati dopo il cursore. Analogamente, se un'entità non è più un risultato per una query, ma è stata visualizzata prima del cursore, i risultati visualizzati dopo il cursore non cambiano. Se l'ultimo risultato restituito viene rimosso dall'insieme di risultati, il cursore sa comunque come individuare il risultato successivo.

Quando recuperi i risultati della query, puoi utilizzare sia un cursore di inizio sia un cursore finale per restituire un gruppo continuo di risultati. Quando utilizzi un cursore di inizio e fine per recuperare i risultati, non hai la garanzia che le dimensioni dei risultati saranno le stesse di quando hai generato i cursori. Le entità possono essere aggiunte o eliminate dal database tra il momento in cui i cursori vengono generati e il momento in cui vengono utilizzati in una query.

Limitazioni per le query

La natura del meccanismo di query sull'indice impone determinate restrizioni sulle operazioni che può essere eseguita da una query. Le query in modalità Datastore non supportano corrispondenze di sottostringhe, corrispondenze senza distinzione tra maiuscole e minuscole o la ricerca a testo intero. Inoltre, si applicano le seguenti limitazioni:

Le entità prive di una proprietà denominata nella query vengono ignorate

Le entità dello stesso tipo non devono avere le stesse proprietà. Per essere idonea come risultato di una query, un'entità deve possedere un valore (possibilmente nullo) per ogni proprietà denominata nei filtri e negli ordini di ordinamento della query. In caso contrario, l'entità viene omessa dagli indici utilizzati per eseguire la query e di conseguenza non sarà inclusa nei risultati della query.

L'applicazione di filtri in base a proprietà non indicizzate non restituisce risultati

Una query non può trovare valori di proprietà che non sono indicizzati, né può ordinarli in base a queste proprietà. Per una discussione dettagliata sulle proprietà non indicizzate, consulta la sezione Proprietà non indicizzate.

I filtri di disuguaglianza sono limitati a una sola proprietà

Per evitare di dover analizzare l'intero indice, il meccanismo di query si basa sul fatto che tutti i potenziali risultati di una query siano adiacenti l'uno all'altro nell'indice. Per soddisfare questo vincolo, una singola query non può utilizzare confronti di disuguaglianza (LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL, NOT_EQUAL, NOT_IN) su più di una proprietà tra tutti i propri filtri. Ad esempio, la seguente query è valida, perché entrambi i filtri di disuguaglianza si applicano alla stessa proprietà:

C#

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

Go

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

Java

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

Node.js

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

PHP

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

Python

from google.cloud import datastore

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

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

Ruby

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

GQL


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

Tuttavia, questa query non è valida perché utilizza filtri di disuguaglianza su due proprietà diverse:

C#

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

Go

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

Java

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

Node.js

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

PHP

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

Python

from google.cloud import datastore

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

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

Ruby

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

GQL


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

Tieni presente che una query può combinare filtri di uguaglianza (EQUAL) per proprietà diverse, insieme a uno o più filtri di disuguaglianza su una singola proprietà. Di conseguenza, la query è valida:

C#

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

Go

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

Java

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

Node.js

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

PHP

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

Python

from google.cloud import datastore

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

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

Ruby

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

GQL


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

Non puoi utilizzare sia `NOT_EQUAL` sia `NOT_IN`

Se usi NOT_IN, non puoi anche aggiungere una clausola NOT_EQUAL.

L'ordine dei risultati delle query non è definito se non è specificato alcun ordinamento

Quando una query non specifica un ordinamento, i risultati vengono restituiti nell'ordine in cui sono stati recuperati. Man mano che l'implementazione della modalità Datastore si evolve (o se gli indici di un progetto cambiano), questo ordine potrebbe cambiare. Pertanto, se la tua applicazione richiede i risultati della query in un ordine particolare, assicurati di specificare tale ordinamento in modo esplicito nella query.

Gli ordini vengono ignorati nelle proprietà con filtri di uguaglianza

Le query che includono un filtro di uguaglianza per una determinata proprietà ignorano qualsiasi ordinamento specificato per quella proprietà. Questa ottimizzazione consente di evitare l'elaborazione necessaria per le proprietà con valore singolo. Poiché tutti i risultati hanno lo stesso valore per la proprietà, non è necessario ordinarli ulteriormente. Le proprietà con più valori, tuttavia, possono avere valori aggiuntivi oltre a quello corrispondente dal filtro di uguaglianza. Poiché questo caso d'uso è raro e l'applicazione dell'ordinamento sarebbe costosa e richiederà indici aggiuntivi, lo strumento di pianificazione delle query in modalità Datastore ignora l'ordinamento anche nel caso con più valori. Ciò potrebbe causare la restituzione dei risultati della query in un ordine diverso da quello suggerito dall'ordinamento. Ad esempio, l'ordinamento viene ignorato nella seguente query:

C#

Non applicabile

Go

Non applicabile

Java

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

Node.js

Non applicabile

PHP

Non applicabile

Python

Non applicabile

Ruby

Non applicabile

GQL


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

Questo non si applica alle query che includono un filtro IN. Utilizza l'operatore IN per combinare fino a 10 clausole di uguaglianza (==) nella stessa proprietà con un OR logico. Se aggiungi un ordinamento per quella proprietà, questo viene applicato al set di risultati.

C#

Non applicabile

Go

Non applicabile

Java

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

Node.js

Non applicabile

PHP

Non applicabile

Python

Non applicabile

Ruby

Non applicabile

GQL


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

In ordine crescente, per l'ordinamento viene utilizzato il valore più basso che soddisfa il filtro.
In ordine decrescente, per l'ordinamento viene utilizzato il valore massimo che soddisfa il filtro.
Gli altri valori non influiscono sull'ordinamento né sul numero di valori nella proprietà.

Le proprietà utilizzate nei filtri di disuguaglianza devono essere ordinate per prime

Per recuperare tutti i risultati che corrispondono a un filtro di disuguaglianza, una query esegue la scansione dell'indice alla ricerca della prima riga corrispondente al filtro, quindi esegue la scansione in avanti fino a quando non rileva una riga non corrispondente. Affinché le righe consecutive comprendano l'intero set di risultati, devono essere ordinate in base alla proprietà utilizzata nel filtro di disuguaglianza prima di qualsiasi altra proprietà. Pertanto, se una query specifica uno o più filtri di disuguaglianza insieme a uno o più ordini, il primo ordinamento deve fare riferimento alla stessa proprietà indicata nei filtri di disuguaglianza. Quella che segue è una query valida:

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

Questa query non è valida perché non esegue un ordinamento in base alla proprietà utilizzata nel filtro di disuguaglianza:

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

Allo stesso modo, questa query non è valida perché la proprietà utilizzata nel filtro di disuguaglianza non è la prima ordinata:

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` e esistenza

Quando ordini una query in base a una determinata proprietà, la query può restituire solo le entità in cui esiste la proprietà ordine per.

Ad esempio, la seguente query non restituirà alcuna entità in cui la proprietà priority non è impostata, anche se soddisfa i filtri delle query.

Java

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

Un effetto correlato si applica alle disuguaglianze. Una query con un filtro di disuguaglianza su una proprietà implica anche un ordinamento in base a questa proprietà. La seguente query non restituisce entità senza una proprietà priority anche se starred = true in questa entità. Come soluzione alternativa, puoi eseguire query separate per ogni ordinamento oppure assegnare un valore a tutte le proprietà in base a cui ordini.

Java

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

La query precedente include un ordine implicito della disuguaglianza come quello riportato di seguito. La direzione dell'ordine implicito dipende dagli indici disponibili:

Java

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

Limitazioni sulle proiezioni

Le query di proiezione sono soggette alle seguenti limitazioni:

È possibile prevedere solo le proprietà indicizzate.

Ciò significa che tutte le proprietà utilizzate in una query (previsioni o filtri) devono esistere nello stesso indice. Quindi, select tag from Task where priority = 1 richiede un indice composto e poi un tag.

La proiezione non è supportata per stringhe più lunghe di 1500 byte, array di byte con più di 1500 elementi e altre proprietà esplicitamente contrassegnate come non indicizzate.
Non è possibile prevedere la stessa proprietà più di una volta.
Non è possibile prevedere le proprietà a cui viene fatto riferimento in un filtro di uguaglianza.

Ad esempio:
```
SELECT tag FROM Task WHERE priority = 1
```
è valida (proprietà prevista non utilizzata nel filtro di uguaglianza), così com'è
```
SELECT tag FROM Task WHERE tag > 'fun`
```
(non un filtro di uguaglianza), ma
```
SELECT tag FROM Task WHERE tag = 'fun`
```
(proprietà prevista utilizzata nel filtro di uguaglianza) non lo è.
I risultati restituiti da una query di proiezione non devono essere salvati nel database in modalità Datastore.

Poiché la query restituisce risultati compilati solo parzialmente, non devi riportarli nel database in modalità Datastore.
Le query di proiezione convertono i timestamp in numeri interi.

Nei risultati di una query di proiezione, la modalità Datastore converte i valori di timestamp in valori interi in microsecondi.

Passaggi successivi

Scopri di più sulle transazioni.