Menu Docs
Página inicial do Docs
/
Manual do banco de dados
/ / /

$replaceWith (agregação)

$replaceWith

Substitui o documento de entrada pelo documento especificado. A operação substitui todos os campos existentes no documento de entrada, incluindo o campo _id. Com $replaceWith, você pode promover um documento incorporado para o nível superior. Você também pode especificar um novo documento como substituto.

O estágio $replaceWith executa a mesma ação que o $replaceRoot estágio, mas os estágios têm formas diferentes.

O estágio $replaceWith tem a seguinte forma:

{ $replaceWith: <replacementDocument> }

O documento de substituição pode ser qualquer expressão válida que se resolva a um documento. Para obter mais informações sobre expressões, consulte Operadores de expressão.

Se o <replacementDocument> não for um documento, $replaceWith apresenta erros e falha.

Se o <replacementDocument> resultar em um documento ausente (ou seja, o documento não existe), $replaceWith apresentará erro e falhará. Por exemplo, crie uma coleção com os seguintes documentos:

db.collection.insertMany([
{ "_id": 1, "name" : { "first" : "John", "last" : "Backus" } },
{ "_id": 2, "name" : { "first" : "John", "last" : "McCarthy" } },
{ "_id": 3, "name": { "first" : "Grace", "last" : "Hopper" } },
{ "_id": 4, "firstname": "Ole-Johan", "lastname" : "Dahl" },
])

Em seguida, a operação $replaceWith a seguir falha porque um dos documentos não tem o campo name:

db.collection.aggregate([
{ $replaceWith: "$name" }
])

Para evitar o erro, você pode usar $mergeObjects para mesclar o documento name com algum documento padrão. Por exemplo:

db.collection.aggregate([
{ $replaceWith: { $mergeObjects: [ { _id: "$_id", first: "", last: "" }, "$name" ] } }
])

Opcionalmente, você pode ignorar os documentos que não têm o campo name incluindo um estágio $match para verificar a existência do campo do documento antes de passar os documentos para o estágio $replaceWith:

db.collection.aggregate([
{ $match: { name : { $exists: true, $not: { $type: "array" }, $type: "object" } } },
{ $replaceWith: "$name" }
])

Ou você pode usar a expressão $ifNull para especificar algum outro documento como root. Por exemplo:

db.collection.aggregate([
{ $replaceWith: { $ifNull: [ "$name", { _id: "$_id", missingName: true} ] } }
])

Crie uma coleção denominada people com os seguintes documentos:

db.people.insertMany([
{ "_id" : 1, "name" : "Arlene", "age" : 34, "pets" : { "dogs" : 2, "cats" : 1 } },
{ "_id" : 2, "name" : "Sam", "age" : 41, "pets" : { "cats" : 1, "fish" : 3 } },
{ "_id" : 3, "name" : "Maria", "age" : 25 }
])

A seguinte operação utiliza o estágio $replaceWith para substituir cada documento de entrada pelo resultado de uma operação $mergeObjects. A expressão $mergeObjects mescla o documento padrão especificado com o documento pets.

db.people.aggregate( [
{ $replaceWith: { $mergeObjects: [ { dogs: 0, cats: 0, birds: 0, fish: 0 }, "$pets" ] } }
] )

A operação retorna os seguintes resultados:

{ "dogs" : 2, "cats" : 1, "birds" : 0, "fish" : 0 }
{ "dogs" : 0, "cats" : 1, "birds" : 0, "fish" : 3 }
{ "dogs" : 0, "cats" : 0, "birds" : 0, "fish" : 0 }

Uma coleção chamada students contém os seguintes documentos:

db.students.insertMany([
{
"_id" : 1,
"grades" : [
{ "test": 1, "grade" : 80, "mean" : 75, "std" : 6 },
{ "test": 2, "grade" : 85, "mean" : 90, "std" : 4 },
{ "test": 3, "grade" : 95, "mean" : 85, "std" : 6 }
]
},
{
"_id" : 2,
"grades" : [
{ "test": 1, "grade" : 90, "mean" : 75, "std" : 6 },
{ "test": 2, "grade" : 87, "mean" : 90, "std" : 3 },
{ "test": 3, "grade" : 91, "mean" : 85, "std" : 4 }
]
}
])

A operação a seguir promove o(s) documento(s) incorporado(s) com o campo grade maior ou igual a 90 ao nível superior:

db.students.aggregate( [
{ $unwind: "$grades" },
{ $match: { "grades.grade" : { $gte: 90 } } },
{ $replaceWith: "$grades" }
] )

A operação retorna os seguintes resultados:

{ "test" : 3, "grade" : 95, "mean" : 85, "std" : 6 }
{ "test" : 1, "grade" : 90, "mean" : 75, "std" : 6 }
{ "test" : 3, "grade" : 91, "mean" : 85, "std" : 4 }

Uma collection de exemplo sales é preenchida com os seguintes documentos:

db.sales.insertMany([
{ "_id" : 1, "item" : "butter", "price" : 10, "quantity": 2, date: ISODate("2019-03-01T08:00:00Z"), status: "C" },
{ "_id" : 2, "item" : "cream", "price" : 20, "quantity": 1, date: ISODate("2019-03-01T09:00:00Z"), status: "A" },
{ "_id" : 3, "item" : "jam", "price" : 5, "quantity": 10, date: ISODate("2019-03-15T09:00:00Z"), status: "C" },
{ "_id" : 4, "item" : "muffins", "price" : 5, "quantity": 10, date: ISODate("2019-03-15T09:00:00Z"), status: "C" }
])

Suponha que, para fins de relatório, você queira calcular, para cada venda concluída, o valor total a partir do tempo de execução do relatório atual. A operação a seguir encontra todas as vendas com status C e cria novos documentos usando o estágio $replaceWith. O $replaceWith calcula o valor total, como também utiliza a variável NOW para obter o tempo atual.

db.sales.aggregate([
{ $match: { status: "C" } },
{ $replaceWith: { _id: "$_id", item: "$item", amount: { $multiply: [ "$price", "$quantity"]}, status: "Complete", asofDate: "$$NOW" } }
])

A operação retorna os seguintes documentos:

{ "_id" : 1, "item" : "butter", "amount" : 20, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }
{ "_id" : 3, "item" : "jam", "amount" : 50, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }
{ "_id" : 4, "item" : "muffins", "amount" : 50, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }

Uma collection de exemplo reportedsales é preenchida com as informações de vendas relatadas por trimestre e regiões:

db.reportedsales.insertMany( [
{ _id: 1, quarter: "2019Q1", region: "A", qty: 400 },
{ _id: 2, quarter: "2019Q1", region: "B", qty: 550 },
{ _id: 3, quarter: "2019Q1", region: "C", qty: 1000 },
{ _id: 4, quarter: "2019Q2", region: "A", qty: 660 },
{ _id: 5, quarter: "2019Q2", region: "B", qty: 500 },
{ _id: 6, quarter: "2019Q2", region: "C", qty: 1200 }
] )

Suponha que, para fins de relatório, você queira visualizar os dados de vendas relatados por trimestre. Por exemplo

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }

Para visualizar os dados agrupados por trimestre, você pode usar o seguinte aggregation pipeline:

db.reportedsales.aggregate( [
{ $addFields: { obj: { k: "$region", v: "$qty" } } },
{ $group: { _id: "$quarter", items: { $push: "$obj" } } },
{ $project: { items2: { $concatArrays: [ [ { "k": "_id", "v": "$_id" } ], "$items" ] } } },
{ $replaceWith: { $arrayToObject: "$items2" } }
] )
Primeiro estágio:

O estágio $addFields adiciona um novo campo de documento obj que define a chave k como o valor da região e o valor v como a quantidade dessa região. Por exemplo:

{ "_id" : 1, "quarter" : "2019Q1", "region" : "A", "qty" : 400, "obj" : { "k" : "A", "v" : 400 } }
Segundo estágio:

O estágio $group agrupa por trimestre e usa $push para acumular os campos obj em um novo campo de array items. Por exemplo:

{ "_id" : "2019Q1", "items" : [ { "k" : "A", "v" : 400 }, { "k" : "B", "v" : 550 }, { "k" : "C", "v" : 1000 } ] }
Terceiro estágio:

O estágio $project usa $concatArrays para criar uma nova array items2 que inclui as informações _id e os elementos da array items:

{ "_id" : "2019Q1", "items2" : [ { "k" : "_id", "v" : "2019Q1" }, { "k" : "A", "v" : 400 }, { "k" : "B", "v" : 550 }, { "k" : "C", "v" : 1000 } ] }
Quarto estágio:

$replaceWith usa $arrayToObject para converter items2 em um documento, usando os pares de chave k e valor v especificados, e envia esse documento para o próximo estágio. Por exemplo:

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }

A aggregation retorna o seguinte documento:

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }
{ "_id" : "2019Q2", "A" : 660, "B" : 500, "C" : 1200 }

Crie uma coleção denominada contacts com os seguintes documentos:

db.contacts.insertMany( [
{ "_id" : 1, name: "Fred", email: "fred@example.net" },
{ "_id" : 2, name: "Frank N. Stine", cell: "012-345-9999" },
{ "_id" : 3, name: "Gren Dell", cell: "987-654-3210", email: "beo@example.net" }
] )

A operação a seguir usa $replaceWith com $mergeObjects para emitir os documentos atuais com valores padrão para os campos ausentes:

db.contacts.aggregate( [
{ $replaceWith:
{ $mergeObjects:
[
{ _id: "", name: "", email: "", cell: "", home: "" },
"$$ROOT"
]
}
}
] )

A aggregation retorna os seguintes documentos:

{
_id: 1,
name: 'Fred',
email: 'fred@example.net',
cell: '',
home: ''
},
{
_id: 2,
name: 'Frank N. Stine',
email: '',
cell: '012-345-9999',
home: ''
},
{
_id: 3,
name: 'Gren Dell',
email: 'beo@example.net',
cell: '',
home: '987-654-3210'
}

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#.

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

public class Movie
{
public ObjectId Id { get; set; }
public int Runtime { get; set; }
public string Title { get; set; }
public string Rated { get; set; }
public List<string> Genres { get; set; }
public string Plot { get; set; }
public ImdbData Imdb { get; set; }
public int Year { get; set; }
public int Index { get; set; }
public string[] Comments { get; set; }
[BsonElement("lastupdated")]
public DateTime LastUpdated { get; set; }
}

Observação

Pacote de Convenções para Caso Pascal

As classes C# nesta página usam maiúsculas e minúsculas Pascal para seus nomes de propriedade , mas os nomes de campo na coleção MongoDB usam camel case. Para contabilizar esta diferença, você pode utilizar o seguinte código para registrar um ConventionPack quando seu aplicação iniciar:

var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

A seguinte classe modela documentos ImdbData:

public class ImdbData
{
public string Id { get; set; }
public int Votes { get; set; }
public float Rating { get; set; }
}

Para usar o driver MongoDB .NET/C# para adicionar um estágio $replaceWith a um pipeline de agregação, chame o método ReplaceWith() em um objeto PipelineDefinition.

O exemplo abaixo cria um estágio de pipeline que substitui cada documento de entrada Movie pelo documento ImdbData armazenado em sua propriedade Imdb :

var pipeline = new EmptyPipelineDefinition<Movie>()
.ReplaceWith(m => m.ImdbData);

Voltar

$replaceRoot

Nesta página