Come aumentare le prestazioni dell'operazione di aggiornamento in Mongo?

Quando si esegue l'aggiornamento nel modo in cui si è, è necessario recuperare il contenuto del documento per ispezionarlo e apportare tali modifiche. MongoDB non ha operazioni atomiche che agiscano sui valori esistenti nel modo in cui desideri, quindi è ovviamente necessaria l'iterazione.

Non c'è alcuna reale differenza nella parte "query" di come stai abbinando sull'espressione regolare tra le tue due versioni dell'istruzione. In ogni caso, il contenuto viene convertito in BSON prima di essere comunque inviato al server, quindi se utilizzi un generatore di espressioni standard o un documento BSON diretto ha poche conseguenze.

Ma passiamo ai miglioramenti delle prestazioni che possono essere apportati.

Utilizza le operazioni in blocco per aggiornare

Come affermato, le operazioni in blocco sono il modo in cui dovresti aggiornare su tale iterazione dell'elenco e "dovresti" anche utilizzare un cursore anziché convertire tutti i risultati in un elenco, poiché risparmierà memoria.

Evitando tutte le dichiarazioni di tipo specifico e rappresentando semplicemente come BsonDocument (che probabilmente ti farà risparmiare sul marshalling, ma non necessario), quindi il processo di esempio di base sarebbe:

var pattern = @"(?si)<([^\s<]*workUnit[^\s<]*)>.*?</\1>";
var filter = Builders<JobInfoRecord>.Filter.Regex(x => x.SerializedBackgroundJobInfo,
                                              new BsonRegularExpression(pattern, "i"));


var ops = new List<WriteModel<BsonDocument>>();
var writeOptions = new BulkWriteOptions() { IsOrdered = false };

using ( var cursor = await records.FindAsync<BsonDocument>(filter))
{
    while ( await cursor.MoveNextAsync())
    {
        foreach( var doc in cursor.Current )
        {
            // Replace inspected value
            var updatedJobInfo = Regex.Replace(doc.SerializedBackgroundJobInfo, pattern, "<$1></$1>");

            // Add WriteModel to list
            ops.Add(
                new UpdateOneModel<BsonDocument>(
                    Builders<BsonDocument>.Filter.Eq("JobTypeValue", doc.JobTypeValue),
                    Builders<BsonDocument>.Update.Set("SerializedBackgroundJobInfo", updatedJobInfo)
                )
            );

            // Execute once in every 1000 and clear list
            if (ops.Count == 1000)
            {
                BulkWriteResult<BsonDocument> result = await records.BulkWriteAsync(ops,writeOptions);
                ops = new List<WriteModel<BsonDocument>>();
            }
        }
    }

    // Clear any remaining
    if (ops.Count > 0 )
    {
        BulkWriteResult<BsonDocument> result = await records.BulkWriteAsync(ops,writeOptions);
    }

}

Quindi, anziché fare una richiesta al database per ogni singolo documento recuperato dalla query, crei un List di WriteModel operazioni invece.

Una volta che questo elenco è cresciuto fino a un valore ragionevole ( 1000 in questo esempio ), esegui il commit dell'operazione di scrittura sul server in un'unica richiesta e risposta per tutte le operazioni in batch. Qui utilizziamo BulkWriteAsync .

Puoi creare i lotti in una dimensione maggiore di 1000, se lo desideri, ma in genere è un numero ragionevole da gestire. L'unico vero limite è il limite BSON di 16 MB, che poiché tutte le richieste sono ancora in realtà documenti BSON, questo vale ancora. Ad ogni modo ci vogliono molte richieste per avvicinarsi a 16 MB, ma c'è anche una corrispondenza di impedenza da considerare nel modo in cui la richiesta verrà elaborata quando raggiunge effettivamente il server, come documentato: