/ /

$ 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 novos campos calculados.

$project pode:

Incluir campos dos documentos de entrada.
Suprima o campo_id.
Adicione novos campos ou redefina os valores dos campos existentes.
Exclua campos dos documentos de entrada.

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

$project tem o seguinte formato:

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

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á usar nenhuma outra 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

Por padrão, os documentos de saída incluem o campo_id. Para incluir outros campos dos documentos de entrada, especifique-os explicitamente em $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.

Campo _id

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 suprimir explicitamente o campo _id em $project.

Exclua campos

Se você excluir um campo}, todos os outros campos aparecerão nos documentos de saída.

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

Se você excluir um campo diferente de _id, não poderá usar outros formulários de especificação $project. Se você excluir campos, também não poderá especificar a inclusão de campos, redefinir o valor dos campos existentes ou adicionar novos campos. 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 $unset.

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 para redefinir o valor de um campo existente, especifique o nome do campo e defina seu valor para uma expressão. Para mais informações sobre expressões, consulte Expressões.

Valores literais

Para definir um campo como um literal numérico ou booleano em vez de uma expressão que se resolve em um literal, use o operador $literal. Caso contrário, $project trata o literal 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á o null como o 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

Para projeto, adicionar ou redefinir um campo em um documento incorporado, você pode usar a notação de ponto:

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

Você também pode aninhar os campos:

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

Ao aninhar 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 você especifica o campo principal e incorporado. O seguinte $project falha com o mesmo erro:

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

$ estágio do projeto

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.

Especificação vazia

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

Por exemplo, o pipeline a seguir retorna 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 seguinte estágio $project 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 seguinte estágio $project 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, com 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 adicionar um estágio $project com o driver MongoDB .NET/C#, chame o método Project() em um objeto PipelineDefinition e passe um objetoProjectionDefinitionBuilder<TDocument> . TDocument é a classe que representa os documentos da coleção.

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 . Você pode encadear chamadas Include() para incluir vários 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 . Você pode 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 incluem o campo_id. O exemplo a seguir exclui _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 ou .NET/C#, chame o método Exclude() no construtor de projeção e passe 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 seguinte classeProjectedMovie:

[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 projeto 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 classeProjectedMovie:

[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 matriz incluir campos que não existem em um documento, o pipeline substituirá null como 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# retorna um erro de tempo de compilação se você tentar usar construtores para adicionar um campo ausente a uma array. Outros drivers de linguagem MongoDB podem suportar esse recurso.Consulte a documentação do driver MongoDB para obter mais informações.

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 $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 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 campoimdb.votes, o pipeline retornará documentos semelhantes ao exemplo de saída a seguir:

{
  _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;

{
  _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;

Saída de 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 da array incluir campos que não estejam em um documento, o pipeline substituirá null como valor desse campo. Por exemplo, o seguinte exemplo projeta os campos directors, writers e um campo inexistente , makeupArtists, como elementos em um novo campo denominado crew:

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

Saída de exemplo:

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

Saiba mais

Para obter mais informações sobre tarefas de agregação comuns, consulte Tutoriais de Pipeline de Agregação Completo.

Para saber mais sobre as expressões e variáveis nesta página, consulte:

Voltar

$planCacheStats

$querySettings