Descripción general de las consultas con filtros de rango y desigualdad en varias propiedades

Firestore en modo Datastore admite el uso de filtros de rango y desigualdad en varias propiedades en una sola consulta. Esta función te proporciona condiciones de rango y desigualdad en varias propiedades y simplifica el desarrollo de tu aplicación delegando la implementación del filtrado posterior lógica para Firestore en modo Datastore.

Filtros de rango y desigualdad en varias propiedades

La siguiente consulta usa filtros de rango por prioridad y días para mostrar todas las tareas con prioridad superior a cuatro y menos de tres días para completarse.

Go

query := datastore.NewQuery("Task").
   FilterField("priority", ">", 4).
   FilterField("days", "<", 3).

GQL

SELECT * FROM /tasks WHERE priority > 4 AND days < 3;

Java

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

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('priority', '>', 4),
      new PropertyFilter('days', '<', 3),
    ])
  );

Python

from google.cloud import datastore
client = datastore.Client()
query = client.query(kind="Task")
query.add_filter(filter=PropertyFilter("priority", ">", 4))
query.add_filter(filter=PropertyFilter("days", "<", 3))

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 4)
    ->filter('days', '<', 3)

C#

Query query = new Query("Task")
{
  Filter = Filter.And(Filter.GreaterThan("priority", 4),
    Filter.LessThan("days", 3))
};

Ruby

query = datastore.query("Task")
                 .where("priority", ">", 4)
                 .where("days", "<", 3)

Consideraciones sobre la indexación

Antes de comenzar a ejecutar consultas, asegúrate de leer sobre las consultas.

Si no se especifica una cláusula ORDER BY, Firestore en modo Datastore usa cualquier índice que cumplas con la condición del filtro de la consulta para entregarla. Este enfoque produce un resultado que se ordena de acuerdo con la definición del índice.

Para optimizar el rendimiento y el costo de las consultas de Firestore en modo Datastore, sigue estos pasos: optimizar el orden de las propiedades en el índice. Para ello, asegúrate de que tus índice se ordena de izquierda a derecha para que la consulta se extraiga en que evita el análisis de entradas de índices irrelevantes.

Por ejemplo, supongamos que deseas buscar en una colección de empleados para encontrar empleados de Estados Unidos cuyo salario sea superior a $100.000 y cuyo número de años de experiencia es mayor que 0. Según tu comprensión del conjunto de datos, sabes que la restricción salarial es más selectiva que limitación de experiencia. Un índice que reduce la cantidad de análisis de índices es (salary [...], experience [...]). Como resultado, una solución rápida y pedidos de consulta salary antes de experience, como se muestra en el siguiente ejemplo:

GQL

SELECT *
FROM /employees
WHERE salary > 100000 AND experience > 0
ORDER BY salary, experience

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(
        CompositeFilter.and(
            PropertyFilter.gt("salary", 100000), PropertyFilter.gt("experience", 0)))
    .setOrderBy(OrderBy("salary"), OrderBy("experience"))
    .build();

Node.js

const query = datastore
  .createQuery("employees")
  .filter(
    and([
      new PropertyFilter("salary", ">", 100000),
      new PropertyFilter("experience", ">", 0),
       ])
    )
  .order("salary")
  .order("experience");

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.add_filter("experience", ">", 0)
query.order = ["-salary", "-experience"]

Prácticas recomendadas para optimizar índices

Cuando optimices índices, ten en cuenta las siguientes prácticas recomendadas.

Ordena las consultas por igualdades seguidas por rango más selectivo o campo de desigualdad

Firestore en modo Datastore usa las propiedades del extremo izquierdo de un índice compuesto para satisfacer las restricciones de igualdad y la restricción de rango y desigualdad, si corresponde, en la primer campo de la consulta orderBy(). Estas restricciones pueden reducir la cantidad de entradas de índice que analiza Firestore en modo Datastore. Firestore en modo Datastore usa el resto propiedades del índice para satisfacer otras restricciones de rango y desigualdad de la para cada búsqueda. Estas restricciones no reducen el número de entradas de índice que Firestore en modo Datastore, pero filtra las entidades no coincidentes para que la cantidad de que se devuelven a los clientes se reducen.

Para obtener más información sobre cómo crear índices eficientes, consulta Estructura de índices y definición y optimización de índices.

Ordena las propiedades en orden descendente según la selectividad de las restricciones de la consulta

A fin de asegurarte de que Firestore en modo Datastore seleccione el índice óptimo para tu consulta, haz lo siguiente: especificar una cláusula orderBy() que ordene el rango y las propiedades de desigualdad de qué tan selectivas son sus limitaciones en la consulta, empezando por la más selectivo. Una selectividad más alta coincide con menos entidades, mientras que una selectividad más baja. coincide con más entidades. En el orden de tu índice, coloca rango y desigualdad propiedades con mayor selectividad antes que las propiedades con menor selectividad.

Minimizar la cantidad de entidades que Firestore en modo Datastore analiza y muestra en la red, siempre debes ordenar las propiedades en orden descendente de consulta selectividad de las restricciones. Si el conjunto de resultados no está en el orden requerido y el conjunto de resultados esperados es pequeño, puedes implementar la lógica del cliente y volver a hacer el pedido según lo previsto.

Por ejemplo, si quieres buscar en un conjunto de empleados para buscar empleados de Estados Unidos cuyo salario sea superior a 100.000 USD y ordenar los resultados según año de experiencia del empleado. Si esperas que solo un pequeño número los empleados tendrán un salario superior a USD 100,000, por lo tanto, es una forma eficiente escribir la consulta es como se muestra a continuación:

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(PropertyFilter.gt("salary", 100000))
    .setOrderBy(OrderBy("salary"))
    .build();
QueryResults<Entity> results = datastore.run(query);
// Order results by `experience`

Node.js

const query = datastore
  .createQuery("employees")
  .filter(new PropertyFilter("salary", ">", 100000))
  .order("salary");
const [entities] = await datastore.runQuery(query);
// Order results by `experience`

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.order = ["salary"]
results = query.fetch()
// Order results by `experience`

Si bien agregar un orden en experience a la consulta generará el mismo conjunto de entidades y evitar reordenar los resultados en los clientes, la consulta puede leer muchas más entradas de índice irrelevantes que la consulta anterior. Esto se debe a que Firestore en modo Datastore siempre prefiere un índice cuyo prefijo de propiedades de índice coincida con orden por cláusula de la consulta. Si se agregaran experience a la cláusula order by, Luego, Firestore en modo Datastore seleccionará el índice (experience [...], salary [...]). para procesar los resultados de la consulta. Como no hay otras limitaciones en experience, Firestore en modo Datastore leerá todas las entradas de índice de la employees antes de aplicar el filtro salary para encontrar la colección final conjunto de resultados. Esto significa que las entradas de índice que no satisfacen el filtro salary aún se leen, lo que aumenta la latencia y el costo de la consulta.

Precios

Se facturan las consultas con filtros de rango y desigualdad en varias propiedades. basadas en entidades leídas y entradas de índice leídas.

Para obtener más detalles, consulta la página de precios.

Limitaciones

Además de las limitaciones de las consultas, ten en cuenta las siguientes limitaciones antes de usando consultas con filtros de rango y desigualdad en múltiples propiedades:

  • Para evitar que la ejecución de las consultas sea demasiado costosa, Firestore en modo Datastore limita la cantidad de operadores de rango o desigualdad a 10.

Qué sigue