Mettre à jour le champ MongoDB en utilisant la valeur d'un autre champ

Dans MongoDB, est-il possible de mettre à jour la valeur d'un champ en utilisant la valeur d'un autre champ? Le SQL équivalent serait quelque chose comme:

UPDATE Person SET Name = FirstName + ' ' + LastName

Et le pseudo-code MongoDB serait:

db.person.update( {}, { $set : { name : firstName + ' ' + lastName } );

La meilleure façon de le faire est en version 4.2+ qui permet l' utilisation d' un pipeline d'agrégation dans le document de mise à jour et updateOne, updateManyou la updateméthode de collecte. Notez que ce dernier est obsolète dans la plupart des pilotes de langues, sinon dans toutes.

MongoDB 4.2+

La version 4.2 a également introduit l' $setopérateur d'étape de pipeline qui est un alias pour $addFields. Je vais l'utiliser $setici car il correspond à ce que nous essayons de réaliser.

db.collection.<update method>(
    {},
    [
        {"$set": {"name": { "$concat": ["$firstName", " ", "$lastName"]}}}
    ]
)

MongoDB 3.4+

Dans la version 3.4+, vous pouvez utiliser $addFieldsles $outopérateurs de pipeline d'agrégation.

db.collection.aggregate(
    [
        { "$addFields": { 
            "name": { "$concat": [ "$firstName", " ", "$lastName" ] } 
        }},
        { "$out": "collection" }
    ]
)

Notez que cela ne met pas à jour votre collection mais remplace plutôt la collection existante ou en crée une nouvelle. De plus, pour les opérations de mise à jour qui nécessitent une «conversion de type», vous aurez besoin d'un traitement côté client et, selon l'opération, vous devrez peut-être utiliser la find()méthode au lieu de la .aggreate()méthode.

MongoDB 3.2 et 3.0

Pour ce faire, nous utilisons $projectnos documents et utilisons l' $concatopérateur d'agrégation de chaînes pour renvoyer la chaîne concaténée. À partir de là, vous itérez ensuite le curseur et utilisez l' $setopérateur de mise à jour pour ajouter le nouveau champ à vos documents à l'aide d' opérations en bloc pour une efficacité maximale.

Requête d'agrégation:

var cursor = db.collection.aggregate([ 
    { "$project":  { 
        "name": { "$concat": [ "$firstName", " ", "$lastName" ] } 
    }}
])

MongoDB 3.2 ou plus récent

à partir de cela, vous devez utiliser la bulkWriteméthode.

var requests = [];
cursor.forEach(document => { 
    requests.push( { 
        'updateOne': {
            'filter': { '_id': document._id },
            'update': { '$set': { 'name': document.name } }
        }
    });
    if (requests.length === 500) {
        //Execute per 500 operations and re-init
        db.collection.bulkWrite(requests);
        requests = [];
    }
});

if(requests.length > 0) {
     db.collection.bulkWrite(requests);
}

MongoDB 2.6 et 3.0

À partir de cette version, vous devez utiliser l' BulkAPI désormais obsolète et ses méthodes associées .

var bulk = db.collection.initializeUnorderedBulkOp();
var count = 0;

cursor.snapshot().forEach(function(document) { 
    bulk.find({ '_id': document._id }).updateOne( {
        '$set': { 'name': document.name }
    });
    count++;
    if(count%500 === 0) {
        // Excecute per 500 operations and re-init
        bulk.execute();
        bulk = db.collection.initializeUnorderedBulkOp();
    }
})

// clean up queues
if(count > 0) {
    bulk.execute();
}

MongoDB 2.4

cursor["result"].forEach(function(document) {
    db.collection.update(
        { "_id": document._id }, 
        { "$set": { "name": document.name } }
    );
})

Vous devriez parcourir. Pour votre cas spécifique:

db.person.find().snapshot().forEach(
    function (elem) {
        db.person.update(
            {
                _id: elem._id
            },
            {
                $set: {
                    name: elem.firstname + ' ' + elem.lastname
                }
            }
        );
    }
);

Apparemment, il existe un moyen de le faire efficacement depuis MongoDB 3.4, voir la réponse de styvane .

Réponse obsolète ci-dessous

Vous ne pouvez pas (encore) faire référence au document lui-même dans une mise à jour. Vous devrez parcourir les documents et mettre à jour chaque document à l'aide d'une fonction. Voir cette réponse pour un exemple, ou celle-ci pour le côté serveur eval().

Pour une base de données avec une activité élevée, vous pouvez rencontrer des problèmes où vos mises à jour affectent activement les enregistrements changeants et pour cette raison, je recommande d'utiliser snapshot ()

db.person.find().snapshot().forEach( function (hombre) {
    hombre.name = hombre.firstName + ' ' + hombre.lastName; 
    db.person.save(hombre); 
});

http://docs.mongodb.org/manual/reference/method/cursor.snapshot/

Concernant cette réponse , la fonction snapshot est déconseillée dans la version 3.6, selon cette mise à jour . Ainsi, sur la version 3.6 et supérieure, il est possible d'effectuer l'opération de cette façon:

db.person.find().forEach(
    function (elem) {
        db.person.update(
            {
                _id: elem._id
            },
            {
                $set: {
                    name: elem.firstname + ' ' + elem.lastname
                }
            }
        );
    }
);

Au départ Mongo 4.2, db.collection.update()peut accepter un pipeline d'agrégation, permettant enfin la mise à jour / création d'un champ basé sur un autre champ:

// { firstName: "Hello", lastName: "World" }
db.collection.update(
  {},
  [{ $set: { name: { $concat: [ "$firstName", " ", "$lastName" ] } } }],
  { multi: true }
)
// { "firstName" : "Hello", "lastName" : "World", "name" : "Hello World" }

• La première partie {}est la requête de correspondance, filtrant les documents à mettre à jour (dans notre cas tous les documents).

• La deuxième partie [{ $set: { name: { ... } }]est le pipeline d'agrégation de mise à jour (notez les crochets au carré signifiant l'utilisation d'un pipeline d'agrégation). $setest un nouvel opérateur d'agrégation et un alias de $addFields.

• N'oubliez pas { multi: true }, sinon seul le premier document correspondant sera mis à jour.

J'ai essayé la solution ci-dessus mais je l'ai trouvée inappropriée pour de grandes quantités de données. J'ai ensuite découvert la fonctionnalité de flux:

MongoClient.connect("...", function(err, db){
    var c = db.collection('yourCollection');
    var s = c.find({/* your query */}).stream();
    s.on('data', function(doc){
        c.update({_id: doc._id}, {$set: {name : doc.firstName + ' ' + doc.lastName}}, function(err, result) { /* result == true? */} }
    });
    s.on('end', function(){
        // stream can end before all your updates do if you have a lot
    })
})

Voici ce que nous avons trouvé pour copier un champ dans un autre pour ~ 150_000 enregistrements. Cela a pris environ 6 minutes, mais est toujours beaucoup moins gourmand en ressources qu'il ne l'aurait été pour instancier et itérer sur le même nombre d'objets rubis.

js_query = %({
  $or : [
    {
      'settings.mobile_notifications' : { $exists : false },
      'settings.mobile_admin_notifications' : { $exists : false }
    }
  ]
})

js_for_each = %(function(user) {
  if (!user.settings.hasOwnProperty('mobile_notifications')) {
    user.settings.mobile_notifications = user.settings.email_notifications;
  }
  if (!user.settings.hasOwnProperty('mobile_admin_notifications')) {
    user.settings.mobile_admin_notifications = user.settings.email_admin_notifications;
  }
  db.users.save(user);
})

js = "db.users.find(#{js_query}).forEach(#{js_for_each});"
Mongoid::Sessions.default.command('$eval' => js)

Avec MongoDB version 4.2+ , les mises à jour sont plus flexibles car elles permettent d'utiliser le pipeline d'agrégation dans ses update, updateOneet updateMany. Vous pouvez maintenant transformer vos documents en utilisant les opérateurs d'agrégation puis les mettre à jour sans avoir besoin d'expliciter la $setcommande (à la place nous utilisons $replaceRoot: {newRoot: "$$ROOT"})

Ici, nous utilisons la requête agrégée pour extraire l'horodatage du champ ObjectID "_id" de MongoDB et mettre à jour les documents (je ne suis pas un expert en SQL, mais je pense que SQL ne fournit aucun ObjectID généré automatiquement avec horodatage, vous devez créer automatiquement cette date)

var collection = "person"

agg_query = [
    {
        "$addFields" : {
            "_last_updated" : {
                "$toDate" : "$_id"
            }
        }
    },
    {
        $replaceRoot: {
            newRoot: "$$ROOT"
        } 
    }
]

db.getCollection(collection).updateMany({}, agg_query, {upsert: true})