Questa pagina è stata tradotta dall'API Cloud Translation.

Query Datastore

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

La query opera su entità di un determinato tipo; puoi specificare filtri sui valori delle proprietà, sulle chiavi e sugli predecessori delle entità e puoi restituire zero o più entità come risultati. Una query può anche specificare ordini di ordinamento per ordinare 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 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 ai valori, alle chiavi e agli antenati delle proprietà delle entità
Zero o più ordini di ordinamento per ordinare 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 le prestazioni, una query deve, se possibile, specificare un limite per il numero di risultati restituiti.

Ogni query calcola i risultati utilizzando uno o più indici, che contengono le chiavi delle entità in una sequenza specificata dalle proprietà dell'indice e, facoltativamente, dagli antenati 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 maggiori informazioni sulle limitazioni relative alle query in modalità Datastore, consulta Restrizioni relative alle query.

Interfaccia di query

Puoi eseguire una query in una modalità Datastore per configurare un database. L'esempio seguente mostra come recuperare tutte le attività non ancora completate con priorità maggiore o uguale a 4, ordinate in ordine decrescente per 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 la documentazione di riferimento dell'API Cloud Datastore C#.

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori 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

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 := datastore.NewQuery("Task").
	FilterField("Done", "=", false).
	FilterField("Priority", ">=", 4).
	Order("-Priority")

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

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 Node.js documentazione di riferimento.

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

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

PHP

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

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("done", "=", False))
query.add_filter(filter=datastore.query.PropertyFilter("priority", ">=", 4))
query.order = ["-priority"]

Ruby

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

GQL

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

L'esempio seguente mostra come eseguire una query:

C#

Query query = new Query("Task");
DatastoreQueryResults tasks = _db.RunQuery(query);

Go

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

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

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

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

from google.cloud import datastore

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

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

Ruby

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 a o essere 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 vengono confrontate con il valore specificato nel filtro nel modo descritto dalla procedura di confronto dell'operatore telefonico.

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. L'esempio seguente 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import datastore

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

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

Ruby

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

GQL

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

L'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 la documentazione di riferimento dell'API Java in modalità Datastore.

Per autenticarti alla modalità Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori 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

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.

Per autenticarti alla modalità Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

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

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


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

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

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

    or_query.add_filter(filter=or_filter)

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

Ruby

Snippet non disponibile.

GQL

Snippet non disponibile.

Firestore in modalità Datastore supporta la combinazione di filtri con gli operatori 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<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(CompositeFilter.or(
            PropertyFilter.eq("starred", true)),
            CompositeFilter.and(
                PropertyFilter.eq("done", false),
                PropertyFilter.eq("priority", 4)))
        .build();

Node.js

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

key := datastore.NameKey("Task", "someTask", nil)
query := datastore.NewQuery("Task").FilterField("__key__", ">", key)

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 esegue il confronto per verificare l'ineguaglianza, le chiavi vengono ordinate in base ai seguenti criteri:

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

Gli elementi del percorso dell'antenato vengono confrontati in modo simile: per tipo (stringa), poi 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 lo stesso padre e tipo usano 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 per la 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à.
Un 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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à Task in base alla data di creazione in ordine decrescente:

C#

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

Go

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

query = datastore.query("Task")
                 .order("created", :desc)

GQL

SELECT * FROM Task ORDER BY created DESC

Se una query include più ordini di ordinamento, questi vengono applicati nella sequenza specificata. Nell'esempio seguente, l'ordinamento avviene prima in base alla priorità decrescente e poi in base all'ora di creazione 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

PHP

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

$query = $datastore->query()
    ->kind('Task')
    ->order('priority', Query::ORDER_DESCENDING)
    ->order('created');

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 limitazioni:

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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à ove 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 clausole di uguaglianza (==) nella stessa proprietà con un OR logico. Una query IN restituisce le entità in cui la proprietà specificata corrisponde a uno dei valori di confronto.

C#

Non applicabile

Go

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Non applicabile

PHP

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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à ove 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à Task che hanno come antenato l'entità TaskList specificata:

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

$ancestorKey = $datastore->key('TaskList', 'default');
$query = $datastore->query()
    ->kind('Task')
    ->hasAncestor($ancestorKey);

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 senza tipo

Una query senza tipo e senza antenato 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. I filtri principali possono essere utilizzati 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 è interessata solo a poche delle proprietà dell'entità. Le query di proiezione ti consentono di eseguire query solo per le proprietà specifiche di un'entità di cui hai effettivamente bisogno, a un costo e una latenza 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 su chiavi (un tipo di query di proiezione) restituisce solo le chiavi delle entità di risultato anziché le entità stesse, a una latenza e a 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 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 del seguente tipo:

SELECT priority, percent_complete FROM Task

Puoi utilizzare tutte le funzionalità di filtro e ordinamento disponibili per le query sulle entità standard, 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 creare questa 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 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 di disuguaglianza su più proprietà.

Valori di array

La modalità Datastore indicizza ogni valore di proprietà array univoco una volta per indice. Pertanto, per eseguire una query per verificare se un array contiene un valore, utilizza 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 in 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 i 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=datastore.query.PropertyFilter("tag", ">", "learn"))
query.add_filter(filter=datastore.query.PropertyFilter("tag", "<", "math"))

Ruby

query = datastore.query("Task")
                 .where("tag", ">", "learn")
                 .where("tag", "<", "math")

GQL

SELECT * FROM Task WHERE tag > 'learn' AND tag < 'math'

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

Più filtri di uguaglianza

È possibile utilizzare più filtri di uguaglianza per eseguire query su entità contenenti 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Query<Entity> query =
    Query.newEntityQueryBuilder()
        .setKind("Task")
        .setFilter(
            CompositeFilter.and(
                PropertyFilter.eq("tag", "fun"), PropertyFilter.eq("tag", "programming")))
        .build();

Node.js

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('tag', '=', 'fun'),
      new PropertyFilter('tag', '=', 'programming'),
    ])
  );

PHP

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

$query = $datastore->query()
    ->kind('Task')
    ->filter('tag', '=', 'fun')
    ->filter('tag', '=', 'programming');

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("tag", "=", "fun"))
query.add_filter(filter=datastore.query.PropertyFilter("tag", "=", "programming"))

Ruby

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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à 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 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 non influiscono sull'ordine di ordinamento né sul numero di valori.

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

Se in un filtro di uguaglianza viene utilizzata una proprietà a più valori, l'ordinamento in quella proprietà viene ignorato.

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

e i risultati della query sono ordinati in ordine crescente in base alla 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à con valori 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

query := datastore.NewQuery("Task").Limit(5)

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Query<Entity> query = Query.newEntityQueryBuilder().setKind("Task").setLimit(5).build();

Node.js

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

const query = datastore.createQuery('Task').limit(5);

PHP

$query = $datastore->query()
    ->kind('Task')
    ->limit(5);

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 nel database in modalità Datastore, in una cache o incorporata in una pagina web come parametro HTTP GET o POST codificato in base 64) 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 di fine per limitare l'ambito del set di risultati restituito.

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

C#

Per autenticarti a 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")
{
    Limit = pageSize,
};
if (!string.IsNullOrEmpty(pageCursor))
    query.StartCursor = ByteString.FromBase64(pageCursor);

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

Go

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

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

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

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

Java

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

Node.js

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

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

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

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

  return [entities, info];
}

PHP

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

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

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

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

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

Python

from google.cloud import datastore

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


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

    tasks = list(page)
    next_cursor = query_iter.next_page_token

    return tasks, next_cursor

Ruby

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

page_cursor = tasks.cursor

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

GQL

Non 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 di restituire le entità saltate alla tua applicazione, ma queste entità vengono comunque recuperate internamente. Le entità saltate influiscono sulla latenza della query e alla tua applicazione vengono addebitate le operazioni di lettura necessarie per recuperarle. L'utilizzo dei cursori anziché degli offset consente di 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 impostare la stessa query da cui sono stati originariamente generati.
Se uno dei seguenti elementi viene modificato, è comunque possibile utilizzare un cursore per i successivi recuperi.
- cursore di avvio
- cursore di fine
- compensare
- limite
Se uno dei seguenti elementi viene modificato, non è possibile utilizzare un cursore per i successivi recuperi.
- proiezione
- kind
- predecessore
- filtro
- distinto su
- ordinamento Un'eccezione è rappresentata dal caso in cui l'ordinamento finale della query originale fosse impostato su __key__. In questo caso, puoi utilizzare il cursore in una query inversa, ovvero la query originale con ogni ordine di 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 ordine di ordinamento in una proprietà con più valori. La logica di deduplica per queste proprietà con più valori non persiste tra i recuperi, il che potrebbe causare il ritorno dello stesso risultato più volte.
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 viene visualizzato un nuovo risultato prima della posizione del cursore per la query, non verrà restituito quando i risultati vengono recuperati dopo il recupero del 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 dal set di risultati, il cursore sa comunque come trovare 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 per le 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 avere un valore (eventualmente 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 verrà inclusa nei risultati della query.

Il filtro per le 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 ulteriori informazioni, consulta Proprietà non indicizzate.

Limiti per i filtri di disuguaglianza

Per evitare che l'esecuzione delle query diventi troppo costosa, Firestore in modalità Datastore limita a 10 il numero di proprietà di intervallo o di disuguaglianza. Per saperne di più sulle query con filtri di disuguaglianza, consulta Eseguire query utilizzando filtri per intervallo e disuguaglianza su più proprietà.

Non puoi utilizzare sia `NOT_EQUAL` che `NOT_IN`

Se utilizzi NOT_IN, non puoi aggiungere anche una 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 che i risultati della query vengano visualizzati in un determinato ordine, assicurati di specificare esplicitamente questo 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 ordine di ordinamento specificato per quella proprietà. Si tratta di un'ottimizzazione per risparmiare su un'elaborazione non necessaria per le proprietà con un solo valore. Poiché tutti i risultati hanno lo stesso valore per la proprietà, non è necessaria un'ulteriore ordinamento. Tuttavia, le proprietà con più valori possono avere valori aggiuntivi oltre a quello corrispondente al filtro di uguaglianza. Poiché questo caso d'uso è raro e l'applicazione dell'ordinamento sarebbe costosa e richiederebbe indici aggiuntivi, il pianificatore delle query in modalità Datastore ignora l'ordinamento anche nel caso di valori multipli. Ciò potrebbe causare il ritorno dei risultati della query in un ordine diverso da quello suggerito dall'ordinamento. Ad esempio, l'ordinamento viene ignorato nella seguente query:

C#

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Non applicabile

Go

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Non applicabile

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Node.js

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Non applicabile

PHP

Non applicabile

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Non applicabile

Ruby

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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 valori di uguaglianza (==) sulla stessa proprietà con un elemento logico OR. Se aggiungi un ordine di ordinamento per la proprietà, questo viene applicato al set di risultati.

C#

Non applicabile

Go

Non applicabile

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Node.js

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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'intero insieme 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 di ordinamento, il primo ordine di ordinamento 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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Java

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Python

from google.cloud import datastore

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

query = client.query(kind="Task")
query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
query.order = ["priority", "created"]

Ruby

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

GQL

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

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import datastore

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

    query = client.query(kind="Task")
    query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
    query.order = ["created"]

Ruby

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

GQL

# Invalid query!
SELECT * FROM Task WHERE priority > 3 ORDER BY created

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Python

Per autenticarti a Cloud Datastore, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import datastore

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

    query = client.query(kind="Task")
    query.add_filter(filter=datastore.query.PropertyFilter("priority", ">", 3))
    query.order = ["created", "priority"]

Ruby

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

GQL

# Invalid query!
SELECT * FROM Task WHERE priority > 3 ORDER BY created, priority

`OrderBy` ed esistenza

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

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

Java

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

Un effetto correlato si applica alle ineguaglianze. Una query con un filtro di disuguaglianza su una proprietà implica anche l'ordinamento in base a quella proprietà. Le seguenti la query non restituisce entità senza una proprietà priority nemmeno 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 alle quali effettui l'ordinamento.

Java

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

La query precedente include un criterio di ordinamento implicito per l'ineguaglianza, ad esempio quanto segue. La direzione dell'ordinamento implicito dipende dagli indici disponibili:

Java

Query<Entity> 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:

Possono essere proiettate 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 di nuovo nel database in modalità Datastore.

Poiché la query restituisce risultati compilati solo parzialmente, non devi riscriverli nel database della 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.