MongoDB
 sql >> Base de données >  >> NoSQL >> MongoDB

Mise à jour en masse des documents dans MongoDB

1. Présentation

Dans ce didacticiel, nous verrons comment effectuer des mises à jour groupées et des opérations d'insertion dans MongoDB. De plus, MongoDB fournit des appels API qui permettent d'insérer ou de récupérer plusieurs documents en une seule opération. MongoDB utilise le tableau ou Lot interfaces qui améliorent considérablement les performances de la base de données en réduisant le nombre d'appels entre le client et la base de données.

Dans ce didacticiel, nous examinerons à la fois les solutions utilisant MongoDB Shell et le code du pilote Java.

Plongeons-nous dans l'implémentation de la mise à jour en masse des documents dans MongoDB.

2. Initialisation de la base de données

Tout d'abord, nous devons nous connecter au shell mongo :

mongo --host localhost --port 27017

Maintenant, configurez une base de données baeldung et une collection d'échantillons de populations :

use baeldung;
db.createCollection(populations);

Ajoutons quelques exemples de données dans la collection populations en utilisant insertMany méthode :

db.populations.insertMany([
{
    "cityId":1124,
    "cityName":"New York",
    "countryName":"United States",
    "continentName":"North America",
    "population":22
},
{
    "cityId":1125,
    "cityName":"Mexico City",
    "countryName":"Mexico",
    "continentName":"North America",
    "population":25
},
{
    "cityId":1126,
    "cityName":"New Delhi",
    "countryName":"India",
    "continentName":"Asia",
    "population":45
},
{
    "cityId":1134,
    "cityName":"London",
    "countryName":"England",
    "continentName":"Europe",
    "population":32
}]);

Le insertMany ci-dessus la requête renverra le document suivant :

{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("623575049d55d4e137e477f6"),
        ObjectId("623575049d55d4e137e477f7"),
        ObjectId("623575049d55d4e137e477f8"),
        ObjectId("623575049d55d4e137e477f9")
    ]
}

Ici, nous avons inséré quatre documents dans la requête ci-dessus pour effectuer tous les types d'opérations d'écriture en masse dans MongoDB.

La base de données baeldung a été créé avec succès, et toutes les données requises sont également insérées dans la collection populations , nous sommes donc prêts à effectuer la mise à jour groupée.

3. Utilisation de la requête Shell MongoDB

Le générateur d'opérations en bloc de MongoDB est utilisé pour construire une liste d'opérations d'écriture en bloc pour une seule collection. Nous pouvons initialiser les opérations en masse de 2 manières différentes. La méthode initializeOrderedBulkOp est utilisé pour effectuer des opérations en bloc dans la liste ordonnée des opérations d'écriture. L'un des inconvénients de initializeOrderedBulkOp est que si une erreur se produit lors du traitement des opérations d'écriture, MongoDB reviendra sans traiter les opérations d'écriture restantes dans la liste.

Nous pouvons utiliser les méthodes d'insertion, de mise à jour, de remplacement et de suppression pour effectuer différents types d'opérations dans un seul appel de base de données. À titre d'illustration, examinons la requête d'opération d'écriture en bloc à l'aide du shell MongoDB :

db.populations.bulkWrite([
    { 
        insertOne :
            { 
                "document" :
                    {
                        "cityId":1128,
                        "cityName":"Kathmandu",
                        "countryName":"Nepal",
                        "continentName":"Asia",
                        "population":12
                    }
            }
    },
    { 
        insertOne :
            { 
                "document" :
                    {
                        "cityId":1130,
                        "cityName":"Mumbai",
                        "countryName":"India",
                        "continentName":"Asia",
                        "population":55
                    }
            }
    },
    { 
        updateOne :
            { 
                "filter" : 
                     { 
                         "cityName": "New Delhi"
                     },
                 "update" : 
                     { 
                         $set : 
                         { 
                             "status" : "High Population"
                         } 
                     }
            }
    },
    { 
        updateMany :
            { 
                "filter" : 
                     { 
                         "cityName": "London"
                     },
                 "update" : 
                     { 
                         $set : 
                         { 
                             "status" : "Low Population"
                         } 
                     }
            }
    },
    { 
        deleteOne :
            { 
                "filter" : 
                    { 
                        "cityName":"Mexico City"
                    } 
            }
    },
    { 
        replaceOne :
            {
                "filter" : 
                    { 
                        "cityName":"New York"
                    },
                 "replacement" : 
                    {
                        "cityId":1124,
                        "cityName":"New York",
                        "countryName":"United States",
                        "continentName":"North America",
                        "population":28
                    }
             }
    }
]);

Le bulkWrite ci-dessus la requête renverra le document suivant :

{
    "acknowledged" : true,
    "deletedCount" : 1,
    "insertedCount" : 2,
    "matchedCount" : 3,
    "upsertedCount" : 0,
    "insertedIds" : 
        {
            "0" : ObjectId("623575f89d55d4e137e477f9"),
            "1" : ObjectId("623575f89d55d4e137e477fa")
        },
    "upsertedIds" : {}
}

Ici, dans la requête ci-dessus, nous avons effectué tous les types d'opérations d'écriture, c'est-à-dire insertOne , updateOne , supprimerun , remplacerUn .

Tout d'abord, nous avons utilisé insertOne méthode pour insérer un nouveau document dans la collection. Deuxièmement, nous avons utilisé updateOne pour mettre à jour le document de cityName "New Delhi". Plus tard, nous avons utilisé le deleteOne méthode pour supprimer un document de la collection en fonction du filtre. Enfin, nous avons utilisé replaceOne  pour remplacer un document complet par le filtre cityName "New-York".

4. Utilisation du pilote Java

Nous avons discuté de la requête shell MongoDB pour effectuer les opérations d'écriture en masse. Avant de créer l'opération d'écriture en masse, créons d'abord un MongoClient lien avec la collection populations de la base de données baeldung :

MongoClient mongoClient = new MongoClient("localhost", 27017);
MongoDatabase database = mongoClient.getDatabase("baeldung");
MongoCollection<Document> collection = database.getCollection("populations");

Ici, nous avons créé la connexion avec le serveur MongoDB, s'exécutant sur le port par défaut 27017. Implémentons maintenant les mêmes opérations en masse à l'aide du code Java :

List<WriteModel<Document>> writeOperations = new ArrayList<WriteModel<Document>>();
writeOperations.add(new InsertOneModel<Document>(new Document("cityId", 1128)
  .append("cityName", "Kathmandu")
  .append("countryName", "Nepal")
  .append("continentName", "Asia")
  .append("population", 12)));
writeOperations.add(new InsertOneModel<Document>(new Document("cityId", 1130)
  .append("cityName", "Mumbai")
  .append("countryName", "India")
  .append("continentName", "Asia")
  .append("population", 55)));
writeOperations.add(new UpdateOneModel<Document>(new Document("cityName", "New Delhi"),
  new Document("$set", new Document("status", "High Population"))
));
writeOperations.add(new UpdateManyModel<Document>(new Document("cityName", "London"),
  new Document("$set", new Document("status", "Low Population"))
));
writeOperations.add(new DeleteOneModel<Document>(new Document("cityName", "Mexico City")));
writeOperations.add(new ReplaceOneModel<Document>(new Document("cityId", 1124), 
  new Document("cityName", "New York").append("cityName", "United States")
    .append("continentName", "North America")
    .append("population", 28)));
BulkWriteResult bulkWriteResult = collection.bulkWrite(writeOperations);
System.out.println("bulkWriteResult:- " + bulkWriteResult);

Ici, nous avons d'abord créé une liste de writeModel pour ajouter tous les différents types d'opérations d'écriture dans une seule liste de mise à jour. De plus, nous avons utilisé InsertOneModel , Mettre à jour un modèle , Mise à jour de nombreux modèles , SupprimerUnModèle , et ReplaceOneModel dans notre requête. Enfin, le bulkWrite la méthode a exécuté toutes les opérations à la fois.