Visão geral de consultas com filtros de intervalo e desigualdade em várias propriedades

O Firestore no modo Datastore oferece suporte ao uso de filtros de intervalo e desigualdade em várias propriedades em uma única consulta. Esse recurso oferece condições de intervalo e desigualdade em várias propriedades e simplifica o desenvolvimento de aplicativos delegando a implementação da lógica pós-filtragem ao Firestore no modo Datastore.

Filtros de intervalo e desigualdade em várias propriedades

A consulta a seguir usa filtros de intervalo de prioridade e dias para retornar todas as tarefas com prioridade maior que quatro e com menos de três dias para conclusão.

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)

Considerações sobre indexação

Antes de começar a executar consultas, leia sobre consultas.

Se uma cláusula ORDER BY não for especificada, o Firestore no modo Datastore vai usar qualquer índice que possa atender à condição de filtro da consulta para exibir a consulta. Essa abordagem produz um conjunto de resultados ordenado de acordo com a definição do índice.

Para otimizar o desempenho e o custo do Firestore nas consultas do modo Datastore, otimizar a ordem das propriedades no índice. Para fazer isso, verifique se do índice é ordenado da esquerda para a direita, de modo que a consulta seja refinada em um que impede a verificação de entradas de índice irrelevantes.

Por exemplo, suponha que você queira pesquisar um conjunto de funcionários para encontrar funcionários dos Estados Unidos com salário superior a US$ 100.000 e número de anos de experiência maior do que zero. Com base em sua compreensão do conjunto de dados, você sabe que a restrição salarial é mais seletiva do que a restrição de experiência. Um índice que reduz o número de verificações de índice é o (salary [...], experience [...]). Como resultado, uma implantação rápida e econômica os pedidos da consulta salary antes de experience, conforme mostrado no exemplo a seguir:

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áticas recomendadas para otimizar índices

Ao otimizar os índices, observe as seguintes práticas recomendadas.

Ordenar consultas por igualdades seguidas pelo intervalo mais seletivo ou campo de desigualdade

O Firestore no modo Datastore usa as propriedades mais à esquerda de um índice composto para atender as restrições de igualdade e a restrição de intervalo e desigualdade, se houver, primeiro campo da consulta orderBy(). Essas restrições podem reduzir o número de entradas de índice verificadas pelo Firestore no modo Datastore. O Firestore no modo Datastore usa propriedades do índice para satisfazer outras restrições de intervalo e desigualdade do consulta. Essas restrições não reduzem o número de entradas de índice que O Firestore no modo Datastore faz verificações, mas filtra entidades sem correspondência para que o número de entidades retornadas aos clientes são reduzidas.

Para obter mais informações sobre como criar índices eficientes, consulte Estrutura do índice e definição e otimização de índices.

Ordenar propriedades em ordem decrescente de seletividade de restrição da consulta

Para garantir que o Firestore no modo Datastore selecione o índice ideal para sua consulta, especificar uma cláusula orderBy() que ordena propriedades de intervalo e desigualdade com base sobre o nível de seleção das restrições na consulta, começando pela seletivos. Uma seletividade maior corresponde a menos entidades, enquanto uma seletividade menor corresponde a mais entidades. Na ordenação de índice, coloque o intervalo e a desigualdade propriedades com maior seletividade antes das propriedades com menor seletividade.

Para minimizar o número de entidades que o Firestore no modo Datastore verifica e retorna você deve sempre ordenar as propriedades na ordem decrescente da consulta e seletividade de restrição. Se o conjunto de resultados não estiver na ordem exigida e o resultado for pequeno, você pode implementar a lógica do lado do cliente para reordená-lo de acordo com sua expectativa de ordem.

Por exemplo, se você deseja pesquisar em um conjunto de funcionários para encontre funcionários dos Estados Unidos com salário superior a US $100.000 e ordene os resultados pelo ano de experiência do funcionário. Se você espera que apenas um pequeno número de funcionários terão salários superiores a US $100.000, então uma forma eficiente de gravar a consulta é o seguinte:

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`

Adicionar uma ordem em experience à consulta vai gerar o mesmo conjunto de entidades e remover a reordenação dos resultados nos clientes, a consulta pode muito mais entradas de índice irrelevantes do que a consulta anterior. Isso acontece porque o Firestore no modo Datastore sempre prefere um índice cujo prefixo de propriedades de índice corresponda à ordem por cláusula da consulta. Se experience fossem adicionados ao pedido por cláusula, o Firestore no modo Datastore selecionará o índice (experience [...], salary [...]) para calcular os resultados da consulta. Como não há outras restrições em experience, o Firestore no modo Datastore vai ler todas as entradas de índice da coleção employees antes de aplicar o filtro salary para encontrar o resultado final de conjunto de resultados. Isso significa que as entradas de índice que não atendem aos critérios salary são lidos, aumentando assim a latência e o custo da consulta.

Preços

Consultas com filtros de intervalo e desigualdade em várias propriedades são faturadas com base nas leituras de entidades e entradas de índice.

Para informações detalhadas, consulte a página Preços.

Limitações

Além das limitações de consulta, observe as seguintes limitações antes de usar consultas com filtros de intervalo e desigualdade em várias propriedades:

  • Para evitar que as consultas se tornem muito caras para serem executadas, o Firestore no modo Datastore limita a 10 o número de operadores de intervalo ou desigualdade.

A seguir