sql >> Base de Datos >  >> NoSQL >> MongoDB

Actualización masiva de documentos en MongoDB

1. Resumen

En este tutorial, veremos cómo realizar actualizaciones masivas e insertar operaciones en MongoDB. Además, MongoDB proporciona llamadas a la API que permiten insertar o recuperar varios documentos en una sola operación. MongoDB utiliza la matriz o Lote interfaces que mejoran en gran medida el rendimiento de la base de datos al reducir el número de llamadas entre el cliente y la base de datos.

En este tutorial, veremos las dos soluciones que usan MongoDB Shell y el código del controlador Java.

Profundicemos en la implementación de la actualización masiva de documentos en MongoDB.

2. Inicialización de la base de datos

En primer lugar, necesitamos conectarnos al shell de mongo:

mongo --host localhost --port 27017

Ahora, configure una base de datos baeldung y una colección de muestra poblaciones :

use baeldung;
db.createCollection(populations);

Agreguemos algunos datos de muestra a la colección poblaciones usando insertMany método:

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
}]);

El anterior insertMany query devolverá el siguiente documento:

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

Aquí, insertamos cuatro documentos en la consulta anterior para realizar todos los tipos de operaciones de escritura masiva en MongoDB.

La base de datos baeldung se ha creado correctamente y todos los datos necesarios también se han insertado en la colección poblaciones , por lo que estamos listos para realizar la actualización masiva.

3. Usando MongoDB Shell Consulta

El generador de operaciones masivas de MongoDB se usa para construir una lista de operaciones de escritura masivas para una sola colección. Podemos inicializar operaciones masivas de 2 maneras diferentes. El método initializeOrderedBulkOp se utiliza para realizar operaciones masivas en la lista ordenada de operaciones de escritura. Uno de los inconvenientes de initializeOrderedBulkOp es que si ocurre un error al procesar cualquier operación de escritura, MongoDB regresará sin procesar las operaciones de escritura restantes en la lista.

Podemos usar métodos de inserción, actualización, reemplazo y eliminación para realizar diferentes tipos de operaciones en una sola llamada a la base de datos. Como ilustración, echemos un vistazo a la consulta de operación de escritura masiva utilizando el shell de 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
                    }
             }
    }
]);

El anterior bulkWrite query devolverá el siguiente documento:

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

Aquí, en la consulta anterior, realizamos todos los tipos de operaciones de escritura, es decir, insertOne , actualizar uno , eliminarUno , reemplazar uno .

Primero, usamos insertOne para insertar un nuevo documento en la colección. En segundo lugar, usamos updateOne para actualizar el documento de cityName "Nueva Delhi". Más tarde, usamos el deleteOne método para eliminar un documento de la colección según el filtro. Finalmente, usamos replaceOne  para reemplazar un documento completo con el filtro cityName “Nueva York”.

4. Uso del controlador Java

Hemos discutido la consulta de shell de MongoDB para realizar las operaciones de escritura masiva. Antes de crear la operación de escritura masiva, primero creemos un MongoClient conexión con la colección poblaciones de la base de datos baeldung :

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

Aquí, creamos la conexión con el servidor MongoDB, ejecutándose en el puerto predeterminado 27017. Ahora implementemos las mismas operaciones masivas usando el código 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);

Aquí, primero creamos una lista de writeModel para agregar todos los diferentes tipos de operaciones de escritura en una sola lista de actualización. Además, usamos InsertOneModel , Actualizar un modelo , ActualizarMuchosModelos , Eliminar un modelo y Reemplazar un modelo en nuestra consulta. Finalmente, el bulkWrite El método ejecutó todas las operaciones a la vez.