/ /

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

Definição

$project: Passa os documentos com os campos solicitados para o próximo estágio do pipeline. Os campos especificados podem ser campos existentes começando nos documentos de entrada ou campos recém-calculados.

Compatibilidade

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

MongoDB Atlas: o serviço totalmente gerenciado para implantações MongoDB na nuvem

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

O estágio $project tem o seguinte formato de protótipo:

{ $project: { <specification(s)> } }

O $project usa um documento que pode especificar a inclusão de campos, a supressão do campo_id, a adição de novos campos e a redefinição dos valores de campos existentes. Alternativamente, você pode especificar a exclusão de campos.

As especificações do $project vêm nos seguintes formatos:

Formato	Descrição
`<field>: <1 or true>`	Especifica a inclusão de um campo. Números inteiros diferentes de zero também são tratados como `true`.
`_id: <0 or false>`	Especifica a supressão do campo `_id`. Para excluir um campo condicionalmente, use a variável `REMOVE`. Para obter detalhes, consulte Excluir campos condicionalmente.
`<field>: <expression>`	Adiciona um novo campo ou redefine o valor de um campo existente. Se a expressão avaliar para `$$REMOVE`, o campo será excluído na saída. Para obter detalhes, consulte Excluir campos condicionalmente.
`<field>: <0 or false>`	Especifica a exclusão de um campo. Para excluir um campo condicionalmente, use a variável `REMOVE`. Para obter detalhes, consulte Excluir campos condicionalmente. Se você especificar a exclusão de um campo diferente de `_id`,não poderá empregar nenhum outro formulário de especificação `$project`. Esta restrição não se aplica à exclusão condicional de um campo usando a variável `REMOVE`. Para excluir campos, você também pode usar o estágio `$unset`.

Comportamento

Incluir campos

O campo _id é, por padrão, incluído nos documentos de saída. Para incluir quaisquer outros campos dos documentos de entrada nos documentos de saída, você deve especificar explicitamente a inclusão no $project.
Se você especificar a inclusão de um campo que não existe no documento, $project ignorará a inclusão do campo e não o adicionará ao documento.

`_id` Campo

Por padrão, o campo _id é incluído nos documentos de saída. Para excluir o campo _id dos documentos de saída, você deve especificar explicitamente a supressão do campo _id em $project.

Exclua campos

Se você especificar a exclusão de um campo ou campos, todos os outros campos serão são retornados nos documentos de saída.

{ $project: { "<field1>": 0, "<field2>": 0, ... } } // Return all but the specified fields

Se você especificar a exclusão de um campo diferente de _id, não poderá empregar nenhum outro formulário de especificação $project: ou seja, se excluir campos, também não poderá especificar a inclusão de campos, redefinir o valor de campos existentes ou adicionar novos campos. Esta restrição não se aplica à exclusão condicional de um campo usando a variável REMOVE.

Consulte também o estágio $unset para excluir campos.

Excluir campos condicionalmente

Você pode usar a variável REMOVE em expressões de agregação para suprimir condicionalmente um campo. Para obter um exemplo, consulte Excluir campos condicionalmente.

Adicionar novos campos ou redefinir campos existentes

Observação

O MongoDB stambém fornece $addFields para adicionar novos campos aos documentos.

Para adicionar um novo campo ou redefinir o valor de um campo existente, especifique o nome do campo e defina seu valor para alguma expressão. Para mais informações sobre expressões, consulte Expressões.

Valores literais

Para definir o valor de um campo diretamente como um literal numérico ou booleano, em vez de definir o campo como uma expressão que se resolve em um literal, use o operador $literal. Caso contrário, $project trata o literal numérico ou booleano como sinalizador para incluir ou excluir o campo.

Renomear campo

Ao especificar um novo campo e definir seu valor como o caminho do campo de um campo existente, você pode renomear um campo de forma eficaz.

Novos campos de array

O estágio $project suporta o uso dos colchetes [] para criar diretamente novos campos de array. Se você especificar campos de array que não existem em um documento, a operação substituirá null como valor desse campo. Para ver um exemplo, consulte Projetar novos campos de array.

Você não pode usar um índice de array com o estágio $project.

Campos de documento incorporado

Ao projetar ou adicionar/redefinir um campo em um documento incorporado, você pode usar a notação de ponto, como em

"contact.address.country": <1 or 0 or expression>

Ou você pode aninhar os campos:

contact: { address: { country: <1 or 0 or expression> } }

Ao aninhar os campos, você não pode usar a notação de ponto dentro do documento incorporado para especificar o campo, por exemplo contact: { "address.country": <1 or 0 or expression> } é inválido.

Erros de colisão de caminho em campos incorporados

Não é possível especificar um documento incorporado e um campo dentro desse documento incorporado na mesma projeção.

O estágio $project a seguir falha com um erro Path collision porque tenta projeto o documento contact incorporado e o campocontact.address.country:

{ $project: { contact: 1, "contact.address.country": 1 } }

O erro ocorre independentemente da ordem em que o documento pai e o campo incorporado são especificados. O seguinte $project falha com o mesmo erro:

{ $project: { "contact.address.country": 1, contact: 1 } }

`$project` Colocação no palco

Quando você usa um estágio $project, ele normalmente deve ser o último estágio do pipeline, usado para especificar quais campos devem ser retornados ao cliente.

É improvável que o uso de um estágio $project no início ou no meio de um pipeline para reduzir o número de campos passados para estágios subsequentes melhore o desempenho, pois o banco de dados executa essa otimização automaticamente.

Considerações

Especificação vazia

O MongoDB retorna um erro se o estágio $project for passado como um documento vazio.

Por exemplo, a execução do seguinte pipeline produz um erro:

db.myCollection.aggregate( [ {
   $project: { }
} ] )

índice da matriz

Você não pode usar um índice de array com o estágio $project.

Exemplos

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

Incluir campos específicos em documentos de saída

O seguinte estágio $project inclui apenas os campos _id, title e rated:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { title: 1, rated: 1 } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    title: 'The Great Train Robbery',
    rated: 'TV-G'
  }
]

Suprimir o campo `_id` nos documentos de saída

O MongoDB inclui o campo _id por padrão. Para excluir o campo _id do estágio $project, defina o campo _id como 0 no documento de projeção .

O seguinte estágio $project exclui o campo _id, mas inclui os campos title e rated:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project : { _id: 0, title : 1, rated : 1 } },
   { $limit: 1 }
] )

[ { title: 'The Great Train Robbery', rated: 'TV-G' } ]

Excluir campos de documentos de saída

O estágio $project a seguir exclui o campo rated da saída:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project : { "rated": 0 } },
   { $limit: 1 }
] )

Alternativamente, utilize o estágio $unset para excluir campos.

Excluir campos de documentos incorporados

O estágio $project a seguir exclui os campos imdb.id e type da saída:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { "imdb.id": 0, "type": 0 } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    plot: 'A group of bandits stage a brazen train hold-up, only to find a determined posse hot on their heels.',
    genres: [ 'Short', 'Western' ],
    runtime: 11,
    cast: [
      'A.C. Abadie',
      "Gilbert M. 'Broncho Billy' Anderson",
      'George Barnes',
      'Justus D. Barnes'
    ],
    poster: 'https://m.media-amazon.com/images/M/MV5BMTU3NjE5NzYtYTYyNS00MDVmLWIwYjgtMmYwYWIxZDYyNzU2XkEyXkFqcGdeQXVyNzQzNzQxNzI@._V1_SY1000_SX677_AL_.jpg',
    title: 'The Great Train Robbery',
    fullplot: "Among the earliest existing films in American cinema - notable as the first film that presented a narrative story to tell - it depicts a group of cowboy outlaws who hold up a train and rob the passengers. They are then pursued by a Sheriff's posse. Several scenes have color included - all hand tinted.",
    languages: [ 'English' ],
    released: ISODate('1903-12-01T00:00:00.000Z'),
    directors: [ 'Edwin S. Porter' ],
    rated: 'TV-G',
    awards: { wins: 1, nominations: 0, text: '1 win.' },
    lastupdated: '2015-08-13 00:27:59.177000000',
    year: 1903,
    imdb: { rating: 7.4, votes: 9847 },
    countries: [ 'USA' ],
    tomatoes: {
      viewer: { rating: 3.7, numReviews: 2559, meter: 75 },
      fresh: 6,
      critic: { rating: 7.6, numReviews: 6, meter: 100 },
      rotten: 0,
      lastUpdated: ISODate('2015-08-08T19:16:10.000Z')
    },
    num_mflix_comments: 0
  }
]

Como alternativa, você pode aninhar a especificação de exclusão em um documento:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { "imdb": { "id": 0 }, "type" : 0 } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    plot: 'A group of bandits stage a brazen train hold-up, only to find a determined posse hot on their heels.',
    genres: [ 'Short', 'Western' ],
    runtime: 11,
    cast: [
      'A.C. Abadie',
      "Gilbert M. 'Broncho Billy' Anderson",
      'George Barnes',
      'Justus D. Barnes'
    ],
    poster: 'https://m.media-amazon.com/images/M/MV5BMTU3NjE5NzYtYTYyNS00MDVmLWIwYjgtMmYwYWIxZDYyNzU2XkEyXkFqcGdeQXVyNzQzNzQxNzI@._V1_SY1000_SX677_AL_.jpg',
    title: 'The Great Train Robbery',
    fullplot: "Among the earliest existing films in American cinema - notable as the first film that presented a narrative story to tell - it depicts a group of cowboy outlaws who hold up a train and rob the passengers. They are then pursued by a Sheriff's posse. Several scenes have color included - all hand tinted.",
    languages: [ 'English' ],
    released: ISODate('1903-12-01T00:00:00.000Z'),
    directors: [ 'Edwin S. Porter' ],
    rated: 'TV-G',
    awards: { wins: 1, nominations: 0, text: '1 win.' },
    lastupdated: '2015-08-13 00:27:59.177000000',
    year: 1903,
    imdb: { rating: 7.4, votes: 9847 },
    countries: [ 'USA' ],
    tomatoes: {
      viewer: { rating: 3.7, numReviews: 2559, meter: 75 },
      fresh: 6,
      critic: { rating: 7.6, numReviews: 6, meter: 100 },
      rotten: 0,
      lastUpdated: ISODate('2015-08-08T19:16:10.000Z')
    },
    num_mflix_comments: 0
  }
]

Alternativamente, utilize o estágio $unset para excluir campos.

Excluir campos condicionalmente

Você pode usar a variável REMOVE em expressões de aggregation para suprimir condicionalmente um campo.

O estágio $project a seguir usa a variável REMOVE para excluir o campo imdb.votes se ele for igual a null ou for uma string vazia:

db.movies.aggregate( [
   { $match: { title: "This Is Spinal Tap" } },
   {
      $project: {
         title: 1,
         "imdb.rating": 1,
         "imdb.id": 1,
         "imdb.votes": {
            $cond: {
               if: { $in: [ "$imdb.votes", [ null, "" ] ] },
               then: "$$REMOVE",
               else: "$imdb.votes"
            }
         }
      }
   },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1398f29313caabce94a3'),
    title: 'This Is Spinal Tap',
    imdb: { rating: 8, id: 88258 }
  }
]

Como imdb.votes é uma string vazia para este document, o MongoDB exclui o campo da saída.

Dica

Comparação com $addFields

Você pode usar o estágio $addFields ou $project para remover campos do documento. A melhor abordagem depende do seu pipeline e de quanto do documento original você deseja manter.

Para ver um exemplo usando $$REMOVE em um estágio $addFields , consulte Remover campos.

Incluir campos específicos de documentos incorporados

Os documentos na coleção movies contêm um document imdb incorporado com os campos rating, votes e id. Para incluir somente o campo rating do document imdb, use notação de ponto:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { "imdb.rating": 1 } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    imdb: { rating: 7.4 }
  }
]

Ou aninhe a especificação de inclusão em um document:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { imdb: { rating: 1 } } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    imdb: { rating: 7.4 }
  }
]

Incluir campos calculados

O estágio $project a seguir adiciona os campos leadActor e releaseYear:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   {
      $project: {
         title: 1,
         leadActor: { $arrayElemAt: [ "$cast", 0 ] },
         releaseYear: "$year"
      }
   },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    title: 'The Great Train Robbery',
    leadActor: 'A.C. Abadie',
    releaseYear: 1903
  }
]

Projetar novos campos de array

A seguinte operação projeta os campos year e runtime como elementos em um novo campo myArray :

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { myArray: [ "$year", "$runtime" ] } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    myArray: [ 1903, 11 ]
  }
]

Se a especificação da array incluir campos que não existem em um documento, a operação substituirá null como o valor desse campo.

Por exemplo, considerando o mesmo documento acima, a operação a seguir projeta os campos year, runtime e um campo $someField inexistente como elementos em um novo campo myArray:

db.movies.aggregate( [
   { $match: { title: "The Great Train Robbery" } },
   { $project: { myArray: [ "$year", "$runtime", "$someField" ] } },
   { $limit: 1 }
] )

[
  {
    _id: ObjectId('573a1390f29313caabcd42e8'),
    myArray: [ 1903, 11, null ]
  }
]

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

Para utilizar o driver MongoDB .NET/C# para adicionar uma etapa $project a um pipeline de agregação, chame o método Project() em um objeto PipelineDefinition e forneça um objeto ProjectionDefinitionBuilder<TDocument>. TDocument é a classe que representa os documentos na sua coleção.

As seções a seguir mostram as diferentes maneiras de personalizar os documentos de saída do estágio $project.

Incluir campos específicos em documentos de saída

Para incluir campos específicos ao usar o driver .NET/C#, chame o método Include() no construtor de projeção. É possível encadear chamadas Include() para incluir múltiplos campos.

O exemplo de código a seguir produz um documento que inclui apenas os campos _id, plot e title:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>.Projection
            .Include(m => m.Title)
            .Include(m => m.Plot)
    );

{ "_id" : "...", "plot" : "...", "title" : "!Women Art Revolution" }

Excluir campos de documentos de saída

Para excluir um campo dos documentos de resultado ao usar o driver .NET/C#, chame o método Exclude() no construtor de projeção. É possível encadear chamadas Exclude() para excluir vários campos.

O exemplo de código a seguir produz um documento que exclui o campo Type:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>.Projection
            .Exclude(m => m.Type)
    );

{ "_id" : "...", "title" : "!Women Art Revolution", "..." : "..." }

Por padrão, os documentos de resultado sempre incluem o campo _id. O exemplo de código a seguir produz um documento que exclui o campo _id, mas inclui os campos plot e title:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>.Projection
            .Exclude(m => m.Id)
            .Include(m => m.Title)
            .Include(m => m.Plot)
    );

{ "plot" : "...", "title" : "!Women Art Revolution" }

Excluir campos de documentos incorporados

Para excluir um campo em um documento incorporado ao usar o driver .NET/C#, chame o método Exclude() no construtor de projeção e forneça o caminho para a propriedade de classe correspondente. Você pode encadear chamadas Exclude() para excluir vários campos.

O exemplo de código a seguir produz um documento que exclui os campos imdb.id e type:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>.Projection
            .Exclude("Imdb.id")
            .Exclude(m => m.Type)
    );

{ "_id" : "...", "title" : "!Women Art Revolution", "..." : "..." }

Observação

Use strings para campos de ID incorporados

Para projetar um campo ID em um documento incorporado, especifique o nome do campo como string, não como expressão lambda.

Excluir campos condicionalmente

Você pode usar a variável REMOVE em expressões de agregação para suprimir condicionalmente um campo:

var stage = new BsonDocument
{
    { "title", 1 },
    { "imdb.id", 1 },
    { "imdb.rating", 1 },
    {
        "imdb.votes", new BsonDocument("$cond", new BsonDocument
        {
            { "if", new BsonDocument("$eq", new BsonArray { "", "$imdb.votes" }) },
            { "then", "$$REMOVE" },
            { "else", "$imdb.votes" }
        })
    }
};
var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(stage);

{ "_id" : "...", "title" : "!Women Art Revolution", "imdb" : { "id" : "...", "rating" : "...", "votes" : "..." } }

Observação

Nenhum construtor para exclusão condicional

O exemplo anterior usa objetos BsonDocument porque o driver .NET/C# não fornece um construtor para excluir campos condicionalmente. Outros drivers de linguagem MongoDB podem suportar esse recurso. Consulte a documentação do driver MongoDB para obter mais informações.

Incluir campos calculados

Para incluir campos calculados nos documentos de resultado ao usar o driver .NET/C#, chame o método Expression() no construtor de projeção e passe uma expressão que inclua os campos calculados. Para maior segurança de tipo, você pode definir uma classe de modelo para os documentos de resultado, como a classe ProjectedMovie a seguir:

[BsonIgnoreExtraElements]
public class ProjectedMovie
{
    [BsonId]
    public ObjectId Id { get; set; }
    public string Title { get; set; } = null!;
    public string? LeadActor { get; set; }
    public List<string>? Crew { get; set; }
}

O exemplo de código a seguir produz um documento que inclui vários campos computados:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>
            .Projection
            .Expression(m => new ProjectedMovie
            {
                Id = m.Id,
                Title = m.Title,
                LeadActor = m.Cast![0],
            })
    );

{ "_id" : "...", "Title" : "!Women Art Revolution", "LeadActor" : "Lynn Hershman-Leeson", "Crew" : null }

Projetar novos campos de array

Para projetar novos campos de array nos documentos de resultado ao usar o driver .NET/C#, chame o método Expression() no construtor de projeção e passe uma expressão que inclua os novos campos de array. Para maior segurança de tipo, você pode definir uma classe de modelo para os documentos de resultado, como a seguinte classe ProjectedMovie:

[BsonIgnoreExtraElements]
public class ProjectedMovie
{
    [BsonId]
    public ObjectId Id { get; set; }
    public string Title { get; set; } = null!;
    public string? LeadActor { get; set; }
    public List<string>? Crew { get; set; }
}

O exemplo de código a seguir gera documentos que incluem um novo campo de array, crew, que contém valores dos campos directors e writers:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(
        Builders<Movie>
            .Projection
            .Expression(m => new ProjectedMovie
            {
                Id = m.Id,
                Title = m.Title,
                LeadActor = m.Cast![0],
                Crew = m.Directors!.Concat(m.Writers!).ToList()
            })
    );

{ "_id" : "...", "Title" : "$", "LeadActor" : "Warren Beatty", "Crew" : ["..."] }

Se a especificação da array incluir campos que não existem em um documento, o pipeline substituirá null como o valor desse campo. Por exemplo, o exemplo de código a seguir projeta os campos directors, writers e um campo inexistente, makeupArtists, como elementos em um novo campo chamado crew:

var stage = new BsonDocument
{
    { "crew", new BsonArray { "$directors", "$writers", "$makeupArtists" } }
};
var pipeline = new EmptyPipelineDefinition<Movie>()
    .Project(stage);

{ "_id" : "...", "crew" : [["..."], null, null] }

Observação

Classe de construtores impede campos ausentes

O exemplo anterior usa objetos BsonDocument porque o driver .NET/C# gera um erro durante a compilação caso você tente usar construtores para adicionar um campo ausente a um array. Outros drivers de linguagem do MongoDB podem ter suporte a esse recurso. Consulte a Documentação de drivers do MongoDB para mais informações.

Os exemplos do Node.js nesta página usam o banco de dados sample_mflix 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 $project a um pipeline de agregação , use o operador $project em um objeto de pipeline.

As seções a seguir mostram como personalizar os documentos de saída do estágio $project.

Incluir campos específicos em documentos de saída

Para incluir campos específicos, defina o valor do campo como 1 na etapa $project.

O exemplo a seguir retorna documentos que incluem apenas os campos _id, plot e title:

const pipeline = [
  {
    $project: {
      title: 1, 
      plot: 1
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  _id: new ObjectId('573a1390f29313caabcd42e8'),
  plot: 'A group of bandits stage a brazen train hold-up, only to find a
            determined posse hot on their heels.',
  title: 'The Great Train Robbery'
}

Excluir campos de documentos de saída

Para excluir campos específicos, defina o valor do campo como 0 na etapa $project.

O exemplo a seguir retorna documentos que excluem o campo type:

const pipeline = [
  {
    $project: {
      type: 0
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Por padrão, os documentos de resultado sempre incluem o campo _id. O exemplo a seguir retorna documentos que excluem o campo _id, mas incluem os campos plot e title:

const pipeline = [
  {
    $project: {
      _id: 0, 
      title: 1,
      plot: 1 
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  plot: 'A group of bandits stage a brazen train hold-up, only to find a
            determined posse hot on their heels.',
  title: 'The Great Train Robbery'
}

Excluir campos de documentos incorporados

Para excluir um campo em um documento incorporado, defina o valor do caminho do campo como 0 na etapa $project.

Observação

Use strings para campos incorporados

Para projetar um campo em um documento incorporado, especifique o caminho do campo como uma string.

O exemplo a seguir retorna documentos que excluem os campos imdb.id e type:

const pipeline = [
  {
    $project: {
      "imdb.id": 0, 
      type: 0
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  plot: 'A group of bandits stage a brazen train hold-up, only to find a
            determined posse hot on their heels.',
  title: 'The Great Train Robbery',
  imdb: { rating: 7.4000000000000004, votes: 9847 }
}

Excluir campos condicionalmente

Para excluir um campo de forma condicional, atribua uma lógica condicional que inclua a variável REMOVE ao nome do campo.

const pipeline = [
  {
    $project: {
      title: 1,
      "imdb.id": 1, 
      "imdb.rating": 1,
      "imdb.votes": {
        $cond: {
          if: { $eq: ["$imdb.votes", ""] },
          then: "$REMOVE",
          else: "$imdb.votes"
        }
      }
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Se um documento contiver o campo imdb.votes, o pipeline retornará documentos que se assemelham ao seguinte exemplo de saída:

{
  _id: new ObjectId('573a1390f29313caabcd42e8'),
  title: 'The Great Train Robbery',
  imdb: { rating : 7.4000000000000004, id: 439, votes: 9847 }
}

Se um documento não contiver o campo imdb.votes, o pipeline retorna documentos que se assemelham à seguinte saída de exemplo:

{
  _id: new ObjectId('573a1390f29313caabcd42e8'),
  title: 'This Is Spinal Tap',
  imdb: { rating: 8.0, id: 88258 }
}

Incluir campos calculados

Para incluir campos calculados nos documentos de resultado, atribua uma expressão ao campo que armazena os resultados.

O projeto a seguir projeta os campos _id e title em novos campos com o mesmo nome e calcula o novo campo leadActor. O exemplo então retorna documentos que incluem estes campos:

const pipeline = [
  {
    $project: {
      _id: "$_id",
      title: "$title",
      leadActor: { $arrayElemAt: ["$cast", 0] }
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  _id: new ObjectId('573a1390f29313caabcd42e8'),
  title: 'The Great Train Robbery',
  leadActor: 'A.C. Abadie'
}

Projetar novos campos de array

Para projetar novos campos de array nos documentos de resultado, atribua ao campo que armazena o array uma expressão que calcule o novo campo de array.

O exemplo a seguir retorna documentos que incluem um novo campo de array, crew, que combina valores dos campos directors e writers:

const pipeline = [
  {
    $project: {
      _id: "$_id",
      title: "$title",
      leadActor: { $arrayElemAt: ["$cast", 0] },
      crew: { $concatArrays: ["$directors", "$writers"] }
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  _id: new ObjectId('573a1395f29313caabce2297'),
  title: 'The Chalk Garden',
  leadActor: 'Deborah Kerr',
  crew: ['Ronald Neame', 'John Michael Hayes (screenplay)', 'Enid Bagnold (from the play by)']
}

Se a especificação do array incluir campos que não estão presentes em um documento, o pipeline substituirá null pelo valor desse campo. Por exemplo, o seguinte exemplo projeta os campos directors, writers e um campo inexistente, makeupArtists, como elementos em um novo campo chamado crew:

const pipeline = [
  {
    $project: {
      crew: ["$directors", "$writers", "$makeupArtists"]
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Os documentos de saída se assemelham ao seguinte exemplo:

{
  _id: new ObjectId('573a1399f29313caabced0d9'),
  crew: [['Bill Kroyer'], ['Jim Cox (screenplay)', 'Diana Young (original stories)'], null]
}

Saiba mais

Para obter mais informações e explicações detalhadas sobre tarefas comuns de agregação, consulte os Tutoriais completos do pipeline de agregação.

Para saber mais sobre os métodos nesta página, consulte os seguintes guias:

Voltar

$planCacheStats

$querySettings

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

Definição

Compatibilidade

Sintaxe

Comportamento

Incluir campos

_id Campo

Exclua campos

Excluir campos condicionalmente

Adicionar novos campos ou redefinir campos existentes

Valores literais

Renomear campo

Novos campos de array

Campos de documento incorporado

Erros de colisão de caminho em campos incorporados

$project Colocação no palco

Considerações

Especificação vazia

índice da matriz

Exemplos

Incluir campos específicos em documentos de saída

Suprimir o campo _id nos documentos de saída

Excluir campos de documentos de saída

Excluir campos de documentos incorporados

Excluir campos condicionalmente

Incluir campos específicos de documentos incorporados

Incluir campos calculados

Projetar novos campos de array

Incluir campos específicos em documentos de saída

Excluir campos de documentos de saída

Excluir campos de documentos incorporados

Excluir campos condicionalmente

Incluir campos calculados

Projetar novos campos de array

Incluir campos específicos em documentos de saída

Excluir campos de documentos de saída

Excluir campos de documentos incorporados

Excluir campos condicionalmente

Incluir campos calculados

Projetar novos campos de array

Saiba mais

`_id` Campo

`$project` Colocação no palco

Suprimir o campo `_id` nos documentos de saída