Questa pagina è stata tradotta dall'API Cloud Translation.

Query Datastore

Una query recupera entities da Firestore in modalità Datastore che soddisfano una richiesta insieme di condizioni.

La query opera su entità di un determinato tipo; può specificare i filtri delle entità valori delle proprietà, chiavi e può restituire zero o più entità come risultati. Una query può anche specificare gli ordinamenti per sequenziare i risultati in base alla loro proprietà e i relativi valori. I risultati includono tutte le entità con almeno un valore per ogni menzionata nei filtri e nell'ordinamento e i cui valori delle proprietà soddisfano tutti i criteri di filtro specificati. La query può restituire intere entità, entità previste o solo le 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 alle entità i valori delle proprietà, chiavi e predecessori
Zero o più ordinamenti per sequenziare i risultati

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

Nota: per risparmiare memoria e migliorare una query, quando possibile, deve specificare un limite al numero vengono restituiti i risultati.

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

Il meccanismo di query basato su indice supporta un'ampia gamma di query ed è adatto per la maggior parte delle applicazioni, ad eccezione delle query non di scalabilità, come le query di join. Per Ulteriori informazioni sulle limitazioni della modalità Datastore consulta la sezione Restrizioni relative alle query.

Interfaccia query

Puoi eseguire una query in una modalità Datastore per configurare un database. L'esempio seguente mostra come recuperare tutte le attività non ancora eseguite con priorità maggiori o uguali a 4; ordinati in ordine decrescente in base alla priorità:

C#

Per informazioni su come installare e utilizzare la libreria client per Cloud Datastore, consulta Librerie client di Cloud Datastore. Per ulteriori informazioni, consulta API Cloud Datastore C# documentazione di riferimento.

Per eseguire l'autenticazione in Cloud Datastore, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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

L'esempio seguente mostra 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 delle query

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

Filtri

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

Filtri proprietà

Un filtro proprietà specifica quanto segue:

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

L'esempio seguente restituisce le entità delle 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. a cui non può fare riferimento calcolato in termini di altre proprietà. Un'entità soddisfa il filtro se ha una proprietà del nome specificato il cui valore è confrontato con quello specificato il filtro nel modo descritto dall'operatore di confronto. Se la proprietà di se il nome è un valore array, l'entità soddisfa il filtro se uno qualsiasi dei valori confrontalo con il valore specificato nel filtro nel modo descritto dalla procedura di confronto operatore.

L'operatore di confronto può essere uno dei seguenti:

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 è un membro dell'elenco specificato. Non uguale a nessuno dei valori in un elenco specificato.

Filtri compositi

Un filtro composito è costituito da più di un filtro di proprietà. Puoi combinare i filtri con AND e OR. Nell'esempio che segue restituisce Task entità contrassegnate come non completate e con una priorità pari a 4:

C#

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

Go

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

Java

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

Node.js

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

PHP

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

Python

from google.cloud import datastore

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

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

Ruby

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

GQL


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

L'esempio seguente combina i filtri con un OR logico:

C#

Snippet non disponibile.

Vai

Snippet non disponibile.

Java

Per informazioni su come installare e utilizzare la libreria client per la modalità Datastore, consulta Librerie client in modalità Datastore. Per ulteriori informazioni, consulta API Java della modalità Datastore documentazione di riferimento.

Per eseguire l'autenticazione in modalità Datastore, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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

Per informazioni su come installare e utilizzare la libreria client per la modalità Datastore, consulta Librerie client in modalità Datastore. Per ulteriori informazioni, consulta API Node.js della modalità Datastore documentazione di riferimento.

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

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

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

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

queryFilterOr();

PHP

Snippet non disponibile.

Python

Per informazioni su come installare e utilizzare la libreria client per la modalità Datastore, consulta Librerie client in modalità Datastore. Per ulteriori informazioni, consulta API Python della modalità Datastore documentazione di riferimento.

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 AND e OR . L'esempio seguente restituisce Task entità aggiunte a Speciali o che sono contrassegnate come non completate e hanno una priorità pari a 4:

C#

Snippet non disponibile.

Vai

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 confronti la disuguaglianza, le chiavi vengono ordinate in base ai seguenti criteri, in ordine:

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

Gli elementi del percorso predecessore vengono confrontati in modo simile: per tipo (stringa), quindi per nome della chiave o ID numerico. Tipi e nomi di chiavi sono stringhe e sono ordinati per valore byte; Gli ID numerici sono numeri interi e sono ordinati numericamente. Se le entità con gli stessi valori padre e tipo utilizzano una combinazione di stringhe di nomi chiave e ID numerici, quelli con ID numerici precedono quelli con i nomi delle chiavi.

Le query sulle chiavi utilizzano gli indici esattamente come le query sulle proprietà e richiedono indici personalizzati negli stessi casi. Le seguenti eccezioni non richiedono un indice personalizzato:

Filtri di disuguaglianza
Ordinamento crescente nella chiave

L'ordinamento decrescente sulla chiave richiede un indice personalizzato. Come per tutte le query, il server di sviluppo crea voci appropriate nel file di configurazione dell'indice quando una query che richiede un indice personalizzato viene utilizzata nell'ambiente di sviluppo.

Ordina

Un ordinamento di query specifica quanto segue:

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

In questo esempio le entità delle attività vengono ordinate 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à delle attività 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ù ordinamenti, questi vengono applicati nella sequenza specificato. L'esempio seguente ordina prima in base alla priorità decrescente e poi per data/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 viene specificato alcun ordinamento, i risultati vengono restituiti nell'ordine in cui recuperate dalla modalità Datastore.

Limitazioni

Gli ordini di ordinamento presentano le seguenti restrizioni:

A causa del modo in cui viene eseguita la modalità Datastore query, se una query specifica filtri di disuguaglianza su una proprietà e ordina gli ordini su altre proprietà, la proprietà utilizzata nei filtri di disuguaglianza deve essere ordinata prima delle altre proprietà.
Se viene specificato l'ordinamento, l'insieme di proprietà specificato nella clausola distinct on deve apparire prima di qualsiasi proprietà non distinct on negli ordinamenti . Per ulteriori informazioni, consulta la sezione sul raggruppamento delle query.
Gli ordini di ordinamento nelle proprietà con filtri di uguaglianza vengono ignorati.

Tipi di query speciali

Alcuni tipi specifici di query meritano una menzione speciale:

`!= Not equal`

Utilizza l'operatore non uguale (!=) per restituire le 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 è impostato su qualsiasi valore diverso da Work.

Questa query non restituisce entità in cui la proprietà category non esiste. Non uguale (!=) e NOT_IN escludono entità in cui la proprietà specificata non esiste o in cui è esclusa dall'indicizzazione. Una proprietà esiste quando è impostato 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 NOT_IN o != per query.

`IN`

Utilizza l'operatore IN per combinare fino a 30 di uguaglianze (==) sulla stessa proprietà con un OR logico. IN la query restituisce entità in cui la proprietà specificata corrisponde a uno qualsiasi dei confronti e i relativi valori.

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 degli sono questi valori, ma non l'altro.

`NOT_IN`

Utilizza l'operatore NOT_IN per combinare fino a 10 clausole non uguali (!=) nella la stessa proprietà con un AND logico. Una query NOT_IN restituisce le entità in cui la proprietà specificata esiste e non corrisponde a nessuno 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 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. Non uguale (!=) e NOT_IN escludono entità in cui la proprietà specificata non esiste. Una proprietà esiste quando è impostato 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 NOT_IN o != per query.

Query predecessore

Una query da predecessore limita i risultati all'entità specificata e ai suoi discendenti. Questo esempio restituisce tutte le entità Tasks con l'oggetto Entità TaskList 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 delle query predecessore

Tieni presente le seguenti limitazioni per le query Ancestor:

Tutte le disgiunzioni valutate devono avere lo stesso filtro predecessore.

Query gentili

Una query senza tipo e senza predecessore recupera tutte le entità di un'applicazione dalla modalità Datastore. Queste query senza tipo non possono includere filtri o ordinamento in base ai valori delle proprietà. Tuttavia, possono filtrare in base alle chiavi di entità e utilizzare filtri predecessore. Puoi utilizzare i filtri della chiave specificando __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 una un'applicazione è interessata solo ad alcune proprietà dell'entità. Le query di proiezione ti consentono di eseguire query solo per query proprietà di un'entità di cui hai effettivamente bisogno, con latenza e costi inferiori rispetto recuperando l'intera entità.

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

Query basate solo su chiavi

Una query con solo chiavi (che è un tipo di query di proiezione) restituisce solo delle entità risultato invece delle entità stesse, in posizioni inferiori latenza e costi 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 generica che potrebbe recuperare più entità di quelle di cui hanno davvero 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 con solo 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 del formato:

SELECT priority, percent_complete FROM Task

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

La query SQL di esempio restituisce risultati ridotti con solo le proprietà specificate, priority e percent_complete, compilate con valori. tutte le altre proprietà non sono compilati. Ecco come strutturarla come una proiezione query:

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 è una piccola operazione ed è conteggiata come una singola lettura entità per la query stessa.

Raggruppamento

Le query di proiezione possono utilizzare la clausola distinct on per garantire che solo il primo risultato per ogni diversa combinazione di valori per l'attributo specificato verranno restituite. Verrà restituito solo il primo risultato per le entità che hanno gli stessi valori per le proprietà oggetto della previsione.

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

Query di aggregazione

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

Filtri per intervallo e disuguaglianza su più proprietà

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

Valori array

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

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

Filtri di disuguaglianza

A causa della modalità di indicizzazione, le entità con più valori per la stessa proprietà a volte possono interagire con i filtri di 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'

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

Più filtri di uguaglianza

È possibile utilizzare più filtri di uguaglianza per eseguire query per le entità che contengono un insieme di valori. Ad esempio, un'entità di tipo Task con i valori fun e programming per la proprietà tag soddisferà 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 delle proprietà a 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 una proprietà a più valori non viene utilizzata in nessun filtro:

e i risultati della query vengono ordinati in ordine crescente dalla proprietà, per l'ordinamento viene utilizzato il valore più piccolo della proprietà.
e i risultati della query vengono ordinati in ordine decrescente in base alla proprietà, dove viene utilizzato il valore più alto per l'ordinamento.
gli altri valori, così come il numero di valori, non influiscono sull'ordinamento.

Si tratta della conseguenza insolita che un'entità con i valori delle proprietà 1 e 9 precede un'entità con i valori 4, 5, 6 e 7 sia in ordine crescente che in ordine decrescente.

Se in un filtro di uguaglianza viene utilizzata una proprietà a più valori, l'ordinamento in quella 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 dalla proprietà, per l'ordinamento viene utilizzato il valore più piccolo 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 più alto 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 su quella proprietà viene ignorato, perché i filtri hanno lo stesso valore del filtro di uguaglianza

WHERE tag = 'math'

Proiezioni e proprietà di un array

La proiezione di una proprietà con valori array non completerà tutti i valori per quella proprietà proprietà. Verrà invece restituita un'entità separata per ogni combinazione di valori previsti corrispondenti alla query. Ad esempio, supponiamo che 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

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 i risultati restituiti in un unico batch. L'esempio seguente recupera al massimo cinque attività entità:

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 pratici senza dover sostenere l'overhead di un offset della query. Dopo aver eseguito un'operazione di recupero, l'applicazione può ottenere un cursore, ovvero una stringa di byte opaca che contrassegna posizione nell'indice dell'ultimo risultato recuperato. L'applicazione può salvare questa stringa (ad esempio nella modalità Datastore un database, una cache o incorporato in una pagina web come parametro HTTP GET o POST codificato in Base64), quindi potrà utilizzare il cursore come punto di partenza per un'operazione di recupero successiva al fine di ottenere il batch successivo di risultati 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 interi, dovresti evitare di utilizzarli. Utilizza invece i cursori. L'utilizzo di un offset evita solo la restituzione delle entità ignorate all'applicazione, ma queste entità vengono comunque recuperate internamente. La le entità ignorate influiscono sulla latenza e l'applicazione e fatturate per le operazioni di lettura necessarie per recuperarle. Utilizzo dei cursori di compensazioni ti consente di evitare tutti questi costi.

Limiti 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 impostare la stessa query da cui sono stati originariamente generati.
Se viene modificata una delle seguenti voci, sarà comunque possibile utilizzare un cursore per i recuperi successivi.
- cursore di avvio
- cursore finale
- compensare
- limite
Se viene modificata una delle seguenti voci, non è possibile utilizzare un cursore per i recuperi successivi.
- proiezione
- kind
- predecessore
- filtro
- distinto su
- ordinamento Un'eccezione è il caso in cui l'ordinamento finale della query originale fosse il giorno __key__. In questo caso, puoi utilizzare il cursore in una query inversa, ovvero la 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 con una query che utilizza un filtro di disuguaglianza o un ordinamento su una proprietà con più valori. La logica di deduplicazione per queste proprietà a più valori non persiste tra i recuperi, causando probabilmente la restituzione dello stesso risultato più di una volta.
Le nuove release in modalità Datastore possono modificare i dettagli di implementazione interni, invalidando i cursori che dipendono da questi. Se un'applicazione tenta di utilizzare un cursore che 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. Un cursore non è una posizione relativa nell'elenco (non è un offset). si tratta di un indicatore a cui un database in modalità Datastore può saltare quando si avvia una scansione dell'indice dei risultati. Se i risultati di una query cambiano tra l'uso di un cursore, la query rileva solo le modifiche che si verificano nei risultati dopo il cursore. Se prima della posizione del cursore per la query viene visualizzato un nuovo risultato, non verrà restituito quando i risultati vengono recuperati dopo il recupero del cursore. Analogamente, se un'entità non è più il risultato di una query, ma è stata visualizzata prima del cursore, i risultati visualizzati dopo il cursore non cambiano. Se l'ultimo risultato restituito viene rimosso dal set di risultati, il cursore sa ancora come individuare il risultato successivo.

Durante il recupero dei risultati della query, puoi utilizzare sia un cursore di inizio che un cursore finale per restituire un gruppo continuo di risultati. Quando utilizzi un cursore di inizio e fine per recuperare i risultati, non è garantito che le dimensioni dei risultati corrispondano a quelle della generazione dei cursori. Le entità possono essere aggiunte o eliminate dal database tra il momento in cui vengono generati i cursori e il momento in cui vengono utilizzati in una query.

Restrizioni relative alle query

La natura del meccanismo di query di indicizzazione impone alcune restrizioni su eseguibili da una query. Le query in modalità Datastore non supportano le corrispondenze di sottostringhe, corrispondenze senza distinzione tra maiuscole e minuscole o ricerca a testo intero. Inoltre, quanto segue con 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 nell'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.

Il filtro in base alle proprietà non indicizzate non restituisce risultati

Una query non può trovare i valori delle proprietà che non sono indicizzati né può ordinare su tali proprietà. Per saperne di più, consulta Proprietà non indicizzate.

I filtri di disuguaglianza sono limitati a al massimo una proprietà

Per evitare di dover analizzare l'intero indice, il meccanismo di query si basa su tutti i potenziali risultati di una query adiacenti nell'indice. Per soddisfare questo vincolo, una singola query non può utilizzare i confronti di disuguaglianze (LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL, NOT_EQUAL e NOT_IN) in più di una proprietà in tutti e i suoi filtri. Ad esempio, la seguente query è valida, perché sia la disuguaglianza i filtri 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à. Pertanto, la seguente è una 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 utilizzi NOT_IN, non puoi aggiungere anche un Clausola NOT_EQUAL.

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

Quando per una query non è specificato un ordinamento, i risultati vengono restituiti nell'ordine in cui sono stati recuperati. Man mano che l'implementazione in 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 determinato ordine, assicurati di specificare esplicitamente tale ordinamento nella query.

Gli ordini di ordinamento 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 è un'ottimizzazione da salvare per le proprietà a un valore. Poiché tutti i risultati contengono lo stesso valore per la proprietà, non è necessario un ulteriore ordinamento. A più valori proprietà, tuttavia, possono avere valori aggiuntivi oltre a quello corrispondente filtro di uguaglianza. Poiché questo caso d'uso è raro e l'applicazione dell'ordinamento sarebbe costosa e richiede indici aggiuntivi, la query in modalità Datastore planner ignora l'ordinamento anche nel caso a più valori. Questo può i risultati della query vengono restituiti in un ordine diverso da quello dell'ordinamento sembra sottintendere. Ad esempio, questo 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 vale per le query che includono un filtro IN. Utilizza l'operatore IN per combinare fino a 10 valori di uguaglianza (==) sulla stessa proprietà con un elemento logico OR. Se aggiungi un ordinamento per questa 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, viene utilizzato il valore più piccolo che soddisfa il filtro.
Per l'ordine decrescente, viene utilizzato il valore massimo che soddisfa il filtro.
Altri valori, così come il numero di valori nella proprietà, non influiscono sull'ordinamento.

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 analizza l'indice per trovare la prima riga corrispondente al filtro, quindi esegue la scansione in avanti finché non trova una riga non corrispondente. Affinché le righe consecutive includano l'insieme di risultati completo, 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ù ordinamenti, il primo deve fare riferimento alla stessa proprietà denominata nei filtri di disuguaglianza. Di seguito è 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 ordina 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

Analogamente, 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` ed esistenza

Quando ordini una query in base a una determinata proprietà, la query può restituire solo delle entità in cui esiste la proprietà "order-by".

Ad esempio, la seguente query non restituirà 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 l'ordinamento in base a quella proprietà. Le seguenti query non restituisce entità senza una proprietà priority nemmeno se starred = true in questa entità. Come soluzione alternativa, puoi eseguire query separate per ogni ordine oppure puoi assegnare un valore a tutte le proprietà che 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 sulla disuguaglianza come seguire. 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 delle 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 (previste o filtri) devono nello stesso indice. Pertanto, select tag from Task where priority = 1 richiede un indice composto sulla priorità e poi su tag.

La proiezione non è supportata per le stringhe più lunghe di 1500 byte, array di byte con più di 1500 elementi e altre proprietà contrassegnati esplicitamente come non indicizzati.
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
```
sia valida (proprietà proiettata 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 che sono stati compilati solo parzialmente, non deve riscriverli 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 i valori di timestamp in valori interi in microsecondi.

Passaggi successivi

Scopri di più sulle transazioni.