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
- Obtén información para optimizar tus consultas.
- Obtén más información para realizar consultas simples y compuestas.
- Obtén información sobre cómo Firestore en modo Datastore usa índices.