use('sample_airbnb')
db.listingAndReviews.aggregate([
{
$match: {"review_scores.review_scores_raiting": {$gt: 90}}
},
{
$addFields: {
amenitiesSize: {$size: "$amenities"}
}
},
{
$group: {
_id: null,
media: {
$accumulator: {
init: function() {
return {sum: 0, count: 0};
},
accumulateArgs: ["$amenitiesSize"],
accumulate: function(state, size){
return{sum: state.sum + size, count: state.count +1};
},
merge: function(state1, state2){
return {
sum: satet1.sum + state2.sum,
count: state1.count + state2.count,
};
},
finalize: function(state) {
return state.sum / state.count
},
lang: "js"
}
}
}
}
])
Introducci贸n
Conoce el potencial de Aggregation Framework usando datos reales
Casos para usar Aggregation Framework y no queries de MongoDB o map-reduce
Preparando entorno de trabajo: configurando MongoDB Atlas y la base de datos
Preparando entorno de trabajo: Docker y Mongo Compass
Operaciones b谩sicas
Filtrando documentos con $match
Tranformando los datos con $group
Moldeamos los resultados con $project
Agregamos etapas con $count y $avg
Manipulando campos con $set
Etapas de Aggregation Framework
Trabajando con arrays y $unwind
Persistencia de datos con $out
Trabajamos y conocemos $geoNear
Consultas geoespaciales con $geoNear
Aprendemos a usar $lookup
Operaciones avanzadas
Funciones personalizadas
Evaluando expresiones con $redact
Usando funciones personalizadas con $accumulator
Agrupaciones avanzadas con $bucket y $bucketAuto
Performance y optimizaci贸n
Recomendaciones para optimizaci贸n y uso de recursos
Realizando profiling en MongoDB
Pr贸ximos pasos
Repaso de lo aprendido y recomendaciones
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Resources
What is the Accumulator operator?
The Accumulator operator is a powerful tool in MongoDB that allows you to create mini-programs within a stage of the aggregation pipeline. Unlike the Function operator, Accumulator gives you the flexibility to initialize variables, accumulate data and present a final composite result. This operator is essential when you want to perform complex calculations and keep track of information at multiple stages of the pipeline.
How is the Accumulator operator applied in a pipeline?
To apply Accumulator, you must follow a series of steps that start with data selection, controlled accumulation of values and, finally, presentation of the result. Here we guide you through a practical example using the MongoDB Aggregation Framework:
-
Select properties with Match:You start by selecting only those documents that meet certain criteria, such as properties with ratings above 90.
{ $match: { " reviewScores.rating": { $gt: 90 } }} -
Count facilities with AddFields:the number of items is stored in an Array for later analysis.
{ $addFields: { amenitiesize: { $size: "$amenities" } }} } -
Group and accumulate data with Group:Group operator is used in combination with Accumulator to accumulate and calculate the average of the amenities.
{ $group: { _id: null, avgAmenities: { $accumulator: { init: function() { return { sum: 0, count: 0 } } }, accumulate: function(state, size) { return { sum: state.sum + size, count: state.count + 1 } } }, merge: function(state1, state2) { return { sum: state1.sum + state2.sum, count: state1.count + state2.count }; }, finalize: function(state) { return (state.count === 0) ? 0 : (state.sum / state.count); }, lang: "js" } } } }} } }
What are the advantages of the Accumulator operator?
The use of Accumulator in MongoDB provides:
- Flexibility in programming: it allows inserting complex and custom logic inside aggregation pipelines.
- Computational efficiency: It is useful for operations that require multiple accumulation stages and intermediate calculations.
- Parallelism: Thanks to the merge function, it allows efficient parallel operations, thus improving the performance of complex queries.
How is the result interpreted?
The result of a pipeline using Accumulator reveals trends and can answer specific data-driven questions. For example, in our case, when comparing Airbnb properties with more or less facilities, it has been observed that:
- Properties with more facilities tend to have better ratings.
- This was concluded by observing a higher mean in facilities for those properties with high ratings.
This analysis provides a better understanding of the relationship between the characteristics of a property and its acceptance by clients, an informed decision for owners and property managers.
The Accumulator operator is an invaluable resource for those who want to delve deeper into advanced data management in MongoDB. Take advantage of this tool to optimize and customize your calculations and discover new insights into your data. What else could you explore with the power of the Accumulator? Let your imagination run wild and share your ideas!
Contributions 4
Questions 0
Sort by:
En el caso te aparezca el error:
"$accumulator not allowed in this atlas tier"
En la anterior clase coment茅 un post similar. Actualmente, las instancias sin servidor no admiten las siguientes acciones: Usar JavaScript del lado del servidor, como $where, $function, $accumulator y map-reduce. Seguramente es mi versi贸n de MongoD en el momento que hago el curso.
Puedes utilizar esta soluci贸n provisional sin "$accumulator" para esta consulta:
```js
use('sample_airbnb');
db.listingsAndReviews.aggregate([
{
$match: { "review_scores.review_scores_rating": { $gt: 90 } }
},
{
$addFields: {
amenitiesSize: { $size: "$amenities" }
}
},
{
$group: {
_id: null,
amenitiesSizes: { $push: "$amenitiesSize" }
}
},
{
$unwind: "$amenitiesSizes"
},
{
$group: {
_id: null,
total: { $sum: "$amenitiesSizes" },
count: { $sum: 1 }
}
},
{
$addFields: {
media: { $round: [{ $divide: ["$total", "$count"] }, 2] }
}
},
{
$project: {
media: 1
}
}
])
```
var db=db.getSiblingDB("sample_airbnb")
db.listingsAndReviews.aggregate([
{
$match: {
"review_scores.review_scores_rating": { $gte: 90},
}
},
{
//para guadar el acumulador en un campo
$addFields:{
amenitiesSize: {$size: "$amenities"}
}
},
{
$group: {
_id: null,
media: {
$accumulator: {
init: function(){
return {sum:0, count:0};
},
accumulateArgs:["$amenitiesSize"],
accumulate: function(state, size){
return {sum: state.sum + size, count: state.count+1};
},
// se crea una funcion para juntar documentos
merge: function(state1, state2){
return {
sum: state1.sum + state2.sum,
count: state1.count + state2.count
};
},
//finalizar
finalize: function(state){
return state.sum /state.count
},
lang:"js"
}
}
}
}
]
);
#resultado
[
{
"_id": null,
"media": 24.81186283595922
}
]
```js
// experimento para saber la media de amenities por rating desde 91% al 100%
use('sample_airbnb')
db.listingsAndReviews.aggregate([
{
$match: {"review_scores.review_scores_rating": {$gt: 90}}
},
{
$addFields: {
amenitiesSize: {$size: "$amenities"}
}
},
{
$group: {
_id: "$review_scores.review_scores_rating",
totalAmenities: {
$sum: "$amenitiesSize"
},
totalProperties: {
$sum: 1
}
}
},
{
$sort: {
_id: -1
}
},
{
$project: {
property_score: "$_id",
_id: 0,
mediaAmenities: {
$divide: ["$totalAmenities", "$totalProperties"]
}
}
}
])
```
Want to see more contributions, questions and answers from the community?