/ /

$match (estágio de agregação )

Definição

$match: Filtra documentos com base em um predicado de consulta especificado. Os documentos correspondentes são passados para a próxima etapa do pipeline.

Compatibilidade

Você pode utilizar o $match para implantações hospedadas nos seguintes ambientes:

MongoDB Atlas: The fully managed service for MongoDB deployments in the cloud

MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB
MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

{ $match: { <query predicate> } }

A sintaxe do predicado de query $match é idêntica à sintaxe usada no argumento de query de um comando find().

Comportamento

Otimização de pipeline

Place the $match as early in the aggregation pipeline as possible. Because $match limits the total number of documents in the aggregation pipeline, earlier $match operations minimize the amount of processing down the pipe.
If you place a $match at the very beginning of a pipeline, the query can take advantage of indexes like any other db.collection.find() or db.collection.findOne().

Expressões em predicados de query

Para incluir expressões em um predicado de query, use o operador $expr.

0, valores nulos, falsos ou ausentes

Um estágio $match filtra um documento dos resultados do pipeline se uma das seguintes condições se aplicar:

O predicado de query $match retorna um valor 0, null ou false nesse documento.
O predicado de query $match utiliza um campo ausente desse documento.

Restrições

Você não pode usar $where em um estágio $match .
Você não pode usar $near ou $nearSphere em um estágio $match. Como alternativa, você pode:
- Use the $geoNear stage instead of the $match stage.
- Use the $geoWithin query predicate operator with $center or $centerSphere in the $match stage.
To use $text in a $match stage, the $match stage has to be the first stage of the pipeline.

As visualizações não suportam $text.

Observação
$text fornece recursos de query de texto para sistemas autogerenciados (não Atlas). Para dados hospedados no MongoDB, o MongoDB também oferece uma solução de query de texto completo aprimorada, MongoDB Search.

Filtre dados no Atlas usando o MongoDB Search

For data stored in MongoDB Atlas, you can use the MongoDB Search compound Operator operator filter option to match or filter documents when running $search queries. Running $match after $search is less performant than running $search with the compound Operator operator filter option.

Para saber mais sobre a opção filter, consulte o operador composto na documentação do Atlas.

Exemplos

Os exemplos nesta página usam dados do conjunto de dados sample_mflix. Para obter detalhes sobre como carregar este conjunto de dados em sua implantação do MongoDB autogerenciado, consulte Carregar o conjunto de dados de amostra. Se você fez alguma modificação nos bancos de dados de amostra, talvez seja necessário descartar e recriar os bancos de dados para executar os exemplos nesta página.

Correspondência de qualidade

The following operation uses $match to perform an equality match on the rated field. The runtime filter limits the result to a small, representative set:

db.movies.aggregate(
    [ { $match : { rated : "TV-PG", runtime : { $gt: 1000 } } } ]
)

The $match selects the documents where the rated field equals "TV-PG" and runtime is greater than 1000.

Fazer uma contagem

The following example selects documents to process using the $match pipeline operator and then pipes the results to the $group pipeline operator to compute a count of the documents:

db.movies.aggregate( [
  { $match: { $or: [
      { runtime: { $gt: 1000 } },
      { year: { $lt: 1910 } }
  ] } },
  { $group: { _id: null, count: { $sum: 1 } } }
] )

[ { _id: null, count: 6 } ]

In the aggregation pipeline, $match selects the documents where either the runtime is greater than 1000 or the year is earlier than 1910. These documents are then sent to the $group to perform a count.

Elementos da matriz de correspondência

Para filtrar document com base em elementos em um campo de array, use o operador $elemMatch no predicado de query do estágio $match:

db.aggregate( [
   {
      $documents: [
         { student_id: 1, scores: [ 0.75, 0.65, 0.73 ] },
         { student_id: 2, scores: [ 0.9, 0.88, 0.98 ] },
         { student_id: 3, scores: [ 0.9, 0.84, 0.93 ] }
      ]
   }, {
      $match: {
         scores: { $elemMatch: { $gte: 0.9 } }
      }
   }
] )

[
  { student_id: 2, scores: [ 0.9, 0.88, 0.98 ] },
  { student_id: 3, scores: [ 0.9, 0.84, 0.93 ] }
]

A seguinte classe Movie modela os documentos na collection sample_mflix.movies:

[BsonIgnoreExtraElements]
public class Movie
{
    [BsonId]
    public ObjectId Id { get; set; }
    [BsonElement("title")]
    public string Title { get; set; } = null!;
    [BsonElement("year")]
    public int? Year { get; set; }
    [BsonElement("runtime")]
    public int? Runtime { get; set; }
    [BsonElement("rated")]
    public string? Rated { get; set; }
    [BsonElement("metacritic")]
    public int Metacritic { get; set; }
    [BsonElement("plot")]
    public string? Plot { get; set; }
    [BsonElement("type")]
    public string? Type { get; set; }
    [BsonElement("cast")]
    public string[]? Cast { get; set; }
    [BsonElement("directors")]
    public string[]? Directors { get; set; }
    [BsonElement("writers")]
    public string[]? Writers { get; set; }
    [BsonElement("imdb")]
    public ImdbData? Imdb { get; set; }
}

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Match(m => m.Title == "The Godfather");

{ "_id" : "...", "title" : "The Godfather", "metacritic" : 100, "rated" : "R", "runtime" : 175, "imdb" : "..." }

Os exemplos do Node.js nesta página utilizam o banco de dados do sample_mflix a partir dos conjuntos de dados de amostra do Atlas. Para saber como criar um cluster gratuito do MongoDB Atlas e carregar os conjuntos de dados de exemplo, consulte Introdução na documentação do driver do MongoDB Node.js

Para usar o driver Node.js do MongoDB para adicionar um estágio $match a um pipeline de agregação , use o operador $match em um objeto de pipeline.

O exemplo a seguir cria um estágio de pipeline que corresponde a todos os documentos movie em que o campo title é igual a "The Shawshank Redemption". O exemplo em seguida executa o pipeline de agregação:

const pipeline = [
  {
    $match: {
      title: "The Shawshank Redemption"
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Saiba mais

Consulte os Tutoriais do pipeline de agregação completo para obter mais informações e casos de uso sobre agregação.

Voltar

$lookup

$merge