Consultas de Datastore

Go Java PHP Python

Una consulta de Datastore recupera entidades de Datastore que cumplen con un conjunto específico de condiciones.

Una consulta típica incluye lo siguiente:

• Una categoría de entidad a la que se aplica la consulta
• Filtros opcionales basados en los valores de las propiedades, las claves y los principales de las entidades
• Órdenes de clasificación opcionales para secuenciar los resultados

Cuando se ejecuta, la consulta recupera todas las entidades de ese tipo que satisfacen todos los filtros indicados, en el orden que se especificó. Las consultas se ejecutan en modo de solo lectura.

En esta página, se describe la estructura y las categorías de consultas usadas dentro de App Engine para recuperar datos de Cloud Datastore.

Filtros

El conjunto de filtros de una consulta limita las propiedades, las claves y los principales de las entidades que se recuperarán.

Filtros de propiedades

Un filtro de propiedad especifica lo siguiente:

• El nombre de una propiedad
• Un operador de comparación
• El valor de una propiedad

Por ejemplo:

Filter propertyFilter =
    new FilterPredicate("height", FilterOperator.GREATER_THAN_OR_EQUAL, minHeight);
Query q = new Query("Person").setFilter(propertyFilter);

La aplicación debe proporcionar el valor de la propiedad. No se le puede hacer referencia ni se puede calcular en términos de otras propiedades. Una entidad satisface el filtro si tiene una propiedad con el nombre dado, cuyo valor se compara con el valor especificado en el filtro, de acuerdo con la descripción del operador de comparación.

El operador de comparación puede ser cualquiera de las siguientes opciones (definidas como constantes enumeradas en la clase anidada Query.FilterOperator):

Operador	Significado
EQUAL	Igual a
LESS_THAN	Inferior a
LESS_THAN_OR_EQUAL	Menor que o igual que
GREATER_THAN	Mayor que
GREATER_THAN_OR_EQUAL	Mayor que o igual que
NOT_EQUAL	No igual que
IN	Miembro de (igual a cualquier valor en una lista especificada)

El operador NOT_EQUAL lleva a cabo dos consultas: una en la que todos los demás filtros permanecen sin cambios y el filtro NOT_EQUAL se reemplaza por un filtro LESS_THAN, y otra en la que se reemplaza por un filtro GREATER_THAN. Luego, los resultados se combinan en orden. Una consulta no puede tener más de un filtro NOT_EQUAL y, si una consulta tiene uno, no puede tener otros filtros de desigualdad.

El operador IN también realiza varias consultas: una para cada elemento en la lista especificada, con todos los demás filtros que permanecen sin cambios y el filtro IN que se reemplaza por un filtro EQUAL. Los resultados se combinan en el orden de los elementos en la lista. Si una consulta tiene más de un filtro IN, se realiza como consultas múltiples, una por cada combinación posible de los valores en las listas IN.

Una única consulta que contiene los operadores NOT_EQUAL o IN se limita a un máximo de 30 subconsultas.

Para obtener más información sobre cómo las consultas NOT_EQUAL y IN se traducen en varias consultas en un framework de JDO/JPA, consulta el artículo Queries with != and IN filters (Consultas con filtros N y !=).

Filtros de clave

Para filtrar el valor de la clave de una entidad, usa la propiedad especial Entity.KEY_RESERVED_PROPERTY:

Filter keyFilter =
    new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, lastSeenKey);
Query q = new Query("Person").setFilter(keyFilter);

También se admite el orden ascendente en Entity.KEY_RESERVED_PROPERTY.

Cuando se usa un comparador de desigualdad, se aplican los siguientes criterios para clasificar las claves, en orden:

1. Ruta del principal
2. Tipo de entidad
3. Identificador (nombre de clave o ID numérico)

Los elementos de la ruta principal se comparan de manera similar: por tipo (string) y, luego, por nombre de clave o ID numérico. Los tipos y los nombres de clave son strings y se ordenan por valor de byte. Los ID numéricos son números enteros ordenados de forma numérica. Si varias entidades que tienen el mismo principal y tipo usan una combinación de ID numéricos y strings con nombre de clave, las entidades que tienen ID numéricos anteceden a las que tienen nombres de clave.

Las consultas sobre claves usan índices, al igual que las consultas sobre propiedades, y requieren índices personalizados en los mismos casos, salvo algunas excepciones: cuando se usan filtros de desigualdad o un orden de clasificación ascendente en la clave, no se necesita un índice personalizado; cuando se usa un orden de clasificación descendente en la clave, sí se necesita. Al igual que con todas las consultas, el servidor de desarrollo crea entradas adecuadas en el archivo de configuración de índices cuando se prueba una consulta que requiere un índice personalizado.

Filtros principales

Puedes filtrar tus consultas de Datastore según un principal específico para que los resultados incluyan solo las entidades que descienden de él.

Query q = new Query("Person").setAncestor(ancestorKey);

Precaución: Pasar null como la clave del principal no consultará las entidades raíz (aquellas sin principales). Este tipo de consulta no se admite en la actualidad y mostrará un error.

Tipos especiales de consultas

Hay algunos tipos específicos de consultas que merecen una mención especial:

Consultas sin categoría

Cuando una consulta no especifica el tipo ni el principal, se muestran todas las entidades de una aplicación del almacén de datos. Esto incluye entidades creadas y administradas por otras funciones de App Engine, como la entidades de estadísticas y entidades de metadatos de Blobstore (si las hubiera). Estas consultas sin categoría no pueden incluir filtros ni órdenes de clasificación en los valores de las propiedades. Sin embargo, pueden filtrar las claves de entidad si se especifica Entity.KEY_RESERVED_PROPERTY como el nombre de la propiedad:

Filter keyFilter =
    new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, lastSeenKey);
Query q = new Query().setFilter(keyFilter);

Consultas principales

Una consulta con un filtro de principal limita sus resultados a la entidad especificada y a sus secundarios.

DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

Entity tom = new Entity("Person", "Tom");
Key tomKey = tom.getKey();
datastore.put(tom);

Entity weddingPhoto = new Entity("Photo", tomKey);
weddingPhoto.setProperty("imageURL", "http://domain.com/some/path/to/wedding_photo.jpg");

Entity babyPhoto = new Entity("Photo", tomKey);
babyPhoto.setProperty("imageURL", "http://domain.com/some/path/to/baby_photo.jpg");

Entity dancePhoto = new Entity("Photo", tomKey);
dancePhoto.setProperty("imageURL", "http://domain.com/some/path/to/dance_photo.jpg");

Entity campingPhoto = new Entity("Photo");
campingPhoto.setProperty("imageURL", "http://domain.com/some/path/to/camping_photo.jpg");

List<Entity> photoList = Arrays.asList(weddingPhoto, babyPhoto, dancePhoto, campingPhoto);
datastore.put(photoList);

Query photoQuery = new Query("Photo").setAncestor(tomKey);

// This returns weddingPhoto, babyPhoto, and dancePhoto,
// but not campingPhoto, because tom is not an ancestor
List<Entity> results =
    datastore.prepare(photoQuery).asList(FetchOptions.Builder.withDefaults());

Nota: Configurar un filtro principal permite realizar consultas con coherencia sólida. Las consultas que no usan un filtro principal solo muestran resultados con coherencia eventual.

Consultas principales sin categoría

Una consulta sin categoría que incluye un filtro principal recuperará el principal especificado y todos sus descendientes, sin importar la categoría. Este tipo de consulta no requiere índices personalizados. Al igual que todas las consultas sin categoría, no pueden incluir filtros ni órdenes de clasificación para los valores de las propiedades, pero pueden filtrarse según la clave de la entidad.

Filter keyFilter =
    new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, lastSeenKey);
Query q = new Query().setAncestor(ancestorKey).setFilter(keyFilter);

El siguiente ejemplo muestra cómo recuperar todas las entidades descendientes de determinado principal:

DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

Entity tom = new Entity("Person", "Tom");
Key tomKey = tom.getKey();
datastore.put(tom);

Entity weddingPhoto = new Entity("Photo", tomKey);
weddingPhoto.setProperty("imageURL", "http://domain.com/some/path/to/wedding_photo.jpg");

Entity weddingVideo = new Entity("Video", tomKey);
weddingVideo.setProperty("videoURL", "http://domain.com/some/path/to/wedding_video.avi");

List<Entity> mediaList = Arrays.asList(weddingPhoto, weddingVideo);
datastore.put(mediaList);

// By default, ancestor queries include the specified ancestor itself.
// The following filter excludes the ancestor from the query results.
Filter keyFilter =
    new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, tomKey);

Query mediaQuery = new Query().setAncestor(tomKey).setFilter(keyFilter);

// Returns both weddingPhoto and weddingVideo,
// even though they are of different entity kinds
List<Entity> results =
    datastore.prepare(mediaQuery).asList(FetchOptions.Builder.withDefaults());

Consultas de solo clave

Una consulta de solo clave muestra solo las claves de las entidades resultantes, en lugar de las entidades en sí, con una latencia y un costo más bajos que recuperar entidades completas:

Query q = new Query("Person").setKeysOnly();

A menudo, es más rentable hacer primero consultas de solo claves y, luego, elegir un subconjunto de entidades de los resultados, en lugar de ejecutar una consulta general que puede arrojar más entidades de las que necesitas.

Consultas de proyección

En ocasiones, lo único que necesitas de los resultados de una consulta son los valores de unas pocas propiedades específicas. En estos casos, puedes usar una consulta de proyección a fin de recuperar solo las propiedades que en realidad te interesan, con costos y latencia menores que los de recuperar toda la entidad. Revisa la página Consultas de proyección para obtener más detalles.

Órdenes de clasificación

Un orden de clasificación de consulta especifica lo siguiente:

• El nombre de una propiedad
• Un orden de clasificación (ascendente o descendente)

Por ejemplo:

// Order alphabetically by last name:
Query q1 = new Query("Person").addSort("lastName", SortDirection.ASCENDING);

// Order by height, tallest to shortest:
Query q2 = new Query("Person").addSort("height", SortDirection.DESCENDING);

Si una consulta incluye varios órdenes de clasificación, estos se aplican en la secuencia especificada. En el siguiente ejemplo, primero se clasifica por apellido ascendente, luego, por altura descendente:

Query q =
    new Query("Person")
        .addSort("lastName", SortDirection.ASCENDING)
        .addSort("height", SortDirection.DESCENDING);

Si no se especifica ningún orden de clasificación, los resultados se muestran en el orden en que se recuperan de Datastore.

Nota: Debido a la forma en que Datastore ejecuta las consultas, si una consulta especifica filtros de desigualdad en una propiedad y órdenes de clasificación en otras propiedades, la propiedad que se use en los filtros de desigualdad deberá ordenarse antes de las demás propiedades.

Índices

Cada consulta de Datastore calcula los resultados mediante uno o más índices, que contienen claves de entidad en una secuencia especificada por las propiedades del índice y, de forma opcional, los principales de la entidad. Los índices se actualizan de forma incremental con los cambios que la aplicación les haga a sus entidades, de modo que los resultados correctos de todas las consultas estén disponibles sin necesidad de realizar cálculos adicionales.

App Engine predefine un índice simple en cada propiedad de una entidad. Una aplicación de App Engine puede definir más índices personalizados en un archivo de configuración de índice llamado datastore-indexes.xml, que se genera en el directorio /war/WEB-INF/appengine-generated de tu aplicación . El servidor de desarrollo agrega sugerencias a este archivo de forma automática cuando encuentra consultas que no pueden ejecutarse con los índices existentes. Para ajustar los índices de manera manual, edita el archivo antes de subir la aplicación.

Ejemplo de interfaz de consulta

La API de Datastore para Java de bajo nivel proporciona la clase Query para crear consultas y la interfaz PreparedQuery a fin de recuperar entidades de Datastore:

DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

Filter heightMinFilter =
    new FilterPredicate("height", FilterOperator.GREATER_THAN_OR_EQUAL, minHeight);

Filter heightMaxFilter =
    new FilterPredicate("height", FilterOperator.LESS_THAN_OR_EQUAL, maxHeight);

// Use CompositeFilter to combine multiple filters
CompositeFilter heightRangeFilter =
    CompositeFilterOperator.and(heightMinFilter, heightMaxFilter);

// Use class Query to assemble a query
Query q = new Query("Person").setFilter(heightRangeFilter);

// Use PreparedQuery interface to retrieve results
PreparedQuery pq = datastore.prepare(q);

for (Entity result : pq.asIterable()) {
  String firstName = (String) result.getProperty("firstName");
  String lastName = (String) result.getProperty("lastName");
  Long height = (Long) result.getProperty("height");

  out.println(firstName + " " + lastName + ", " + height + " inches tall");
}

Ten en cuenta el uso de FilterPredicate y CompositeFilter para construir filtros. Si configuras solo un filtro en una consulta, puedes usar FilterPredicate solo:

Filter heightMinFilter =
    new FilterPredicate("height", FilterOperator.GREATER_THAN_OR_EQUAL, minHeight);

Query q = new Query("Person").setFilter(heightMinFilter);

Sin embargo, si deseas establecer más de un filtro en una consulta, debes usar CompositeFilter, que requiere al menos dos filtros. En el ejemplo anterior, se usa el ayudante de acceso directo CompositeFilterOperator.and; en el siguiente ejemplo, se muestra una forma de construir un filtro OR compuesto:

Filter tooShortFilter = new FilterPredicate("height", FilterOperator.LESS_THAN, minHeight);

Filter tooTallFilter = new FilterPredicate("height", FilterOperator.GREATER_THAN, maxHeight);

Filter heightOutOfRangeFilter = CompositeFilterOperator.or(tooShortFilter, tooTallFilter);

Query q = new Query("Person").setFilter(heightOutOfRangeFilter);

Precaución: Ten en cuenta que, si usas un filtro OR, se ejecutarán varias consultas en el Datastore subyacente.

Nota: Las propiedades filtradas deben tener un índice predefinido correspondiente que se puede definir en el archivo de configuración del índice (datastore-indexes.xml).

Próximos pasos

• Aprende a especificar lo que muestra una consulta y cómo controlar en mayor medida los resultados de consultas.
• Conoce las restricciones comunes para las consultas en Datastore.
• Obtén información sobre los cursores de consulta, que permiten que una aplicación recupere los resultados de una consulta en lotes convenientes.
• Comprende la coherencia de los datos y cómo funciona con diferentes tipos de consultas en Datastore.