MongoDB findAndModify() Fonksiyonu: Atomik Güncelleme ve Kullanım Örnekleri

MongoDB findAndModify() Fonksiyonu: Atomik Güncelleme ve Kullanım Örnekleri

MongoDB, modern uygulamaların dinamik ve ölçeklenebilir veri ihtiyaçlarını karşılamak üzere tasarlanmış, belge tabanlı (document-oriented) bir NoSQL veritabanıdır. Geliştiricilere esneklik sunarken, veri tutarlılığı ve eşzamanlılık yönetimi gibi kritik konularda da güçlü araçlar sağlar. Bu araçlardan biri de findAndModify() fonksiyonudur. Bu makalede, findAndModify() fonksiyonunun ne olduğunu, neden bu kadar önemli olduğunu, temel parametrelerini ve çeşitli gerçek dünya senaryolarında nasıl kullanılabileceğini detaylı örneklerle inceleyeceğiz.

Giriş: findAndModify() Neden Önemli?

Veritabanı işlemlerinde atomisite (atomicity), bir işlemin ya tamamen gerçekleşmesi ya da hiç gerçekleşmemesi prensibidir. Özellikle eşzamanlı (concurrent) erişimin yoğun olduğu sistemlerde, birden fazla istemcinin aynı anda aynı veri üzerinde işlem yapmaya çalıştığı durumlarda veri tutarlılığını sağlamak hayati önem taşır. Geleneksel yaklaşımlar genellikle “oku, değiştir, yaz” (read, modify, write) döngüsünü içerir. Ancak bu döngü, birden fazla istemcinin aynı anda okuma yapıp ardından yazmaya çalıştığı bir “yarış koşulu” (race condition) yaratabilir. Örneğin, bir web sitesinin ziyaretçi sayacını artırırken, iki kullanıcı aynı anda sayacı okuyup bir artırırsa, sayaç beklenenden bir eksik değer alabilir.

İşte tam bu noktada findAndModify() fonksiyonu devreye girer. MongoDB’nin findAndModify() fonksiyonu, bir belgeyi bulma, güncelleme ve güncellenen (veya güncellenmeden önceki) belgeyi tek ve atomik bir işlem olarak döndürme yeteneği sunar. Bu, “oku, değiştir, yaz” döngüsünü tek bir veritabanı komutu altında birleştirerek yarış koşullarını ortadan kaldırır ve veri tutarlılığını garanti altına alır. Özellikle dağıtık sistemlerde kuyruk yönetimi, sayaç güncellemeleri, benzersiz kimlik atamaları ve durum geçişleri gibi senaryolarda vazgeçilmez bir araçtır.

Temel Kavramlar

findAndModify() fonksiyonunun derinlemesine anlaşılması için bazı temel veritabanı kavramlarını gözden geçirmek faydalı olacaktır.

Atomisite (Atomicity)

Atomisite, ACID (Atomicity, Consistency, Isolation, Durability) özelliklerinin “A” harfini temsil eder. Bir işlemin atomik olması, onun bölünemez ve tek bir birim olarak ele alınması anlamına gelir. Ya tüm adımları başarıyla tamamlanır ya da hiçbir adımı tamamlanmaz; kısmi bir durum söz konusu olamaz. findAndModify() fonksiyonu, tek bir belge üzerindeki işlemleri atomik olarak gerçekleştirerek, bu belgenin tutarlılığını eşzamanlı işlemler karşısında korur. Bir belge üzerinde findAndModify() işlemi yürütülürken, başka hiçbir işlem o belgeyi aynı anda değiştiremez.

Eşzamanlılık (Concurrency)

Eşzamanlılık, birden fazla işlemin aynı anda veya örtüşen zaman dilimlerinde yürütülmesidir. Modern uygulamalarda, binlerce hatta milyonlarca kullanıcının aynı anda veritabanıyla etkileşimde bulunması yaygındır. Bu durum, eşzamanlılık sorunlarına yol açabilir. findAndModify() gibi atomik işlemler, bu eşzamanlılık sorunlarını, özellikle yarış koşullarını, veritabanı seviyesinde çözerek geliştiricilerin bu karmaşık senaryoları daha güvenli bir şekilde yönetmelerine olanak tanır.

MongoDB İşlemleri (Transactions) ile Karşılaştırma

MongoDB 4.0 ve sonraki sürümler, çok belgeli (multi-document) ve çok koleksiyonlu (multi-collection) işlemler (transactions) desteği sunmuştur. Bu özellik, birden fazla belgeyi veya koleksiyonu etkileyen karmaşık iş süreçlerinin atomik olarak yönetilmesini sağlar. Peki, findAndModify() varken neden işlemlere ihtiyaç duyalım veya tam tersi?

* findAndModify(): Tek bir belge üzerindeki atomik güncellemeler için tasarlanmıştır. Belgeyi bulur, günceller ve döndürür. Performans açısından çok verimlidir ve tek belge atomisitesi gerektiğinde ideal çözümdür.
* MongoDB İşlemleri: Birden fazla belgeyi ve/veya koleksiyonu içeren işlemlerin atomik olarak yürütülmesi gerektiğinde kullanılır. Örneğin, bir banka uygulamasında bir hesaptan para çekip başka bir hesaba yatırma işlemi iki ayrı belgeyi (iki hesap) etkiler ve bu işlem atomik olmalıdır. Bu tür senaryolarda findAndModify() yetersiz kalır.

Özetle, findAndModify() tek belge atomisitesi için hızlı ve optimize bir çözümdür, MongoDB işlemleri ise daha geniş kapsamlı, çok belgeli atomiklik gerektiren durumlarda kullanılır.

findAndModify() Fonksiyonunun Yapısı ve Parametreleri

findAndModify() fonksiyonu, MongoDB shell’inde db.collection.findAndModify() şeklinde çağrılır ve bir dizi parametre alır. Bu parametreler, işlemin davranışını detaylı bir şekilde kontrol etmenizi sağlar.

db.collection.findAndModify({
   query: ,
   sort: ,
   update: ,
   new: ,
   upsert: ,
   fields: ,
   bypassDocumentValidation: ,
   writeConcern: ,
   maxTimeMS: 
});

Şimdi bu parametreleri tek tek inceleyelim:

* query (Gerekli): Bir belgeyi bulmak için kullanılan sorgu kriterlerini belirtir. findOne() metodunda kullanılan sorgulara benzer. findAndModify() bu sorguyla eşleşen ilk belgeyi bulur.
* sort (Opsiyonel): Eğer query birden fazla belgeyle eşleşiyorsa, hangi belgenin seçileceğini belirlemek için sıralama kriterlerini belirtir. sort parametresi verilmezse, MongoDB rastgele bir belge seçebilir.
* update (Gerekli): Bulunan belgede yapılacak değişiklikleri belirten güncelleme operatörlerini (örn. $set, $inc, $push, $pull) içeren bir belgedir. Sadece update parametresi kullanılırsa, findAndModify() sadece güncellemeyi gerçekleştirir ve varsayılan olarak güncellenmeden önceki belgeyi döndürür.
* new (Opsiyonel, varsayılan: false): Bir boolean değerdir.
* true ise, findAndModify() işlemi sonucunda güncellenmiş belgeyi döndürür.
* false ise, (varsayılan davranış) findAndModify() işlemi sonucunda güncellenmeden önceki belgeyi döndürür.
* upsert (Opsiyonel, varsayılan: false): Bir boolean değerdir.
* true ise ve query ile eşleşen hiçbir belge bulunamazsa, update parametresi kullanılarak yeni bir belge oluşturulur ve eklenir. Bu durumda, query ve update parametrelerindeki alanlar birleştirilerek yeni belge oluşturulur.
* false ise, belge bulunamazsa hiçbir işlem yapılmaz ve null döndürülür.
* fields (Opsiyonel): Döndürülecek belgedeki alanları kısıtlar (projeksiyon). Döndürülen belgenin boyutunu azaltmak ve ağ trafiğini optimize etmek için kullanılabilir.
* bypassDocumentValidation (Opsiyonel, varsayılan: false): Bir boolean değerdir. true olarak ayarlanırsa, koleksiyon için tanımlanmış belge doğrulama kurallarını atlar.
* writeConcern (Opsiyonel): Yazma onayı seviyesini belirtir. Veritabanının yazma işlemini ne kadar güvenilir bir şekilde kaydettiğini ve istemciye ne zaman onay döneceğini belirler.
* maxTimeMS (Opsiyonel): İşlemin milisaniye cinsinden maksimum yürütme süresini belirtir. Bu süreyi aşan işlemler sonlandırılır.

Kullanım Senaryoları ve Örnekleri

Şimdi findAndModify() fonksiyonunun gücünü ve esnekliğini göstermek için çeşitli gerçek dünya senaryolarını ve kod örneklerini inceleyelim.

1. Sayaç Güncelleme (Counter Increment)

En klasik findAndModify() kullanım senaryolarından biri, bir sayacı atomik olarak artırmaktır. Bu, web sitelerinin ziyaretçi sayıları, ürün stok miktarları veya herhangi bir sayısal değeri eşzamanlı olarak güncellerken veri tutarlılığını sağlamak için kritik öneme sahiptir.

Senaryo: Bir blog yazısının görüntülenme sayısını her ziyaret edildiğinde atomik olarak artırmak.

// Örnek bir blog yazısı belgesi oluşturalım
db.posts.insertOne({
   _id: 1,
   title: "MongoDB findAndModify Rehberi",
   views: 0
});

// Blog yazısının görüntülenme sayısını atomik olarak artırma
const updatedPost = db.posts.findAndModify({
   query: { _id: 1 },
   update: { $inc: { views: 1 } },
   new: true // Güncellenmiş belgeyi döndür
});

print("Güncellenmiş Post:", JSON.stringify(updatedPost, null, 2));

// Çıktı örneği (her çalıştırmada views değeri artacaktır):
/*
Güncellenmiş Post: {
  "_id": 1,
  "title": "MongoDB findAndModify Rehberi",
  "views": 1
}
*/

Açıklama: Bu örnekte, query: { _id: 1 } ile belirli bir blog yazısı bulunur. update: { $inc: { views: 1 } } ile views alanı bir artırılır. new: true sayesinde, işlem tamamlandıktan sonra güncellenmiş belge döndürülür. Birden fazla istemci aynı anda bu kodu çalıştırsa bile, MongoDB her zaman views değerini doğru bir şekilde artırır, çünkü findAndModify() atomik bir işlemdir.

2. Kuyruk İşleme / Dağıtık Kilit (Queue Processing / Distributed Lock)

Dağıtık sistemlerde, görevlerin bir kuyruktan alınıp işlenmesi yaygın bir modeldir. Bir görevin birden fazla işçi (worker) tarafından aynı anda işlenmesini önlemek için bir “dağıtık kilit” mekanizması gereklidir. findAndModify() bu senaryoda mükemmel bir çözümdür.

Senaryo: Bir görev kuyruğundan ‘pending’ durumundaki bir görevi alıp ‘processing’ durumuna getirerek başka bir işçinin aynı görevi almasını engellemek.

// Örnek görevler ekleyelim
db.tasks.insertMany([
   { _id: 1, description: "E-posta gönder", status: "pending", assignedTo: null },
   { _id: 2, description: "Veri yedekle", status: "pending", assignedTo: null },
   { _id: 3, description: "Rapor oluştur", status: "completed", assignedTo: "workerA" }
]);

// 'pending' durumundaki bir görevi al ve 'processing' olarak işaretle
const taskToProcess = db.tasks.findAndModify({
   query: { status: "pending" },
   sort: { _id: 1 }, // En eski görevi al (isteğe bağlı)
   update: { $set: { status: "processing", assignedTo: "workerB", startTime: new Date() } },
   new: true // Güncellenmiş belgeyi döndür
});

if (taskToProcess) {
   print("İşlenecek Görev:", JSON.stringify(taskToProcess, null, 2));
   // Burada görevin işlenmesi simüle edilir
   // ...
   // Görev tamamlandıktan sonra durumu 'completed' olarak güncellenebilir
   db.tasks.updateOne(
      { _id: taskToProcess._id },
      { $set: { status: "completed", endTime: new Date() } }
   );
   print("Görev tamamlandı:", JSON.stringify(db.tasks.findOne({ _id: taskToProcess._id }), null, 2));
} else {
   print("İşlenecek görev bulunamadı.");
}

// Çıktı örneği:
/*
İşlenecek Görev: {
  "_id": 1,
  "description": "E-posta gönder",
  "status": "processing",
  "assignedTo": "workerB",
  "startTime": ISODate("2023-10-27T10:00:00.000Z")
}
Görev tamamlandı: {
  "_id": 1,
  "description": "E-posta gönder",
  "status": "completed",
  "assignedTo": "workerB",
  "startTime": ISODate("2023-10-27T10:00:00.000Z"),
  "endTime": ISODate("2023-10-27T10:00:05.000Z")
}
*/

Açıklama: Birden fazla worker aynı anda bu findAndModify() komutunu çalıştırsa bile, yalnızca biri status: "pending" olan bir görevi başarıyla status: "processing" olarak değiştirebilir. Diğer worker‘lar ya başka bir ‘pending’ görev bulur (eğer varsa) ya da null değeri alırlar. sort: { _id: 1 } ile en eski görevin öncelikli olarak alınması sağlanır. Bu, dağıtık kilit mekanizmasının temelini oluşturur.

3. Belge Ekleme veya Güncelleme (Upserting a Document)

Bazı durumlarda, bir belgenin mevcut olup olmadığına bakılmaksızın işlem yapmak isteyebiliriz: eğer belge varsa güncelle, yoksa yeni bir belge olarak ekle. upsert: true parametresi bu senaryoyu atomik olarak gerçekleştirir.

Senaryo: Bir kullanıcının profil bilgilerini güncellemek. Eğer kullanıcı mevcut değilse, yeni bir kullanıcı profili oluşturmak.

// Kullanıcı profilini güncelle veya oluştur
const userProfile = db.users.findAndModify({
   query: { username: "alice" },
   update: { $set: { email: "alice@example.com", lastLogin: new Date() }, $setOnInsert: { registrationDate: new Date() } },
   upsert: true, // Belge yoksa oluştur
   new: true // Güncellenmiş/oluşturulmuş belgeyi döndür
});

print("Kullanıcı Profili:", JSON.stringify(userProfile, null, 2));

// İlk çalıştırmada çıktı örneği:
/*
Kullanıcı Profili: {
  "_id": ObjectId("..."),
  "username": "alice",
  "email": "alice@example.com",
  "lastLogin": ISODate("2023-10-27T10:05:00.000Z"),
  "registrationDate": ISODate("2023-10-27T10:05:00.000Z")
}
*/

// İkinci çalıştırmada çıktı örneği (sadece lastLogin güncellenir):
/*
Kullanıcı Profili: {
  "_id": ObjectId("..."),
  "username": "alice",
  "email": "alice@example.com",
  "lastLogin": ISODate("2023-10-27T10:05:30.000Z"), // lastLogin değişti
  "registrationDate": ISODate("2023-10-27T10:05:00.000Z")
}
*/

Açıklama: query: { username: "alice" } ile ‘alice’ kullanıcı adını ararız. Eğer bulunamazsa, upsert: true sayesinde update ve query alanlarını birleştirerek yeni bir belge oluşturulur. $setOnInsert operatörü, yalnızca yeni bir belge oluşturulduğunda belirli alanları ayarlamak için kullanılır. Bu sayede registrationDate sadece ilk oluşturmada eklenir, sonraki güncellemelerde değişmez.

4. Belge Durumu Değiştirme (Document State Transition)

Bir belgenin belirli bir durumdan başka bir duruma geçişini atomik olarak yönetmek, iş akışlarında yaygın bir gereksinimdir (örn. siparişin durumu, bir görevin ilerlemesi).

Senaryo: Bir siparişin durumunu ‘pending’ durumundan ‘shipped’ durumuna geçirmek, ancak yalnızca sipariş ‘pending’ durumundaysa.

// Örnek sipariş belgesi
db.orders.insertOne({
   _id: 101,
   customer: "Ayşe Yılmaz",
   item: "Laptop",
   status: "pending",
   orderDate: new Date()
});

// Sipariş durumunu 'pending' ise 'shipped' olarak güncelle
const shippedOrder = db.orders.findAndModify({
   query: { _id: 101, status: "pending" }, // Sadece pending durumundaysa
   update: { $set: { status: "shipped", shipDate: new Date() } },
   new: true // Güncellenmiş belgeyi döndür
});

if (shippedOrder) {
   print("Sipariş Durumu Güncellendi:", JSON.stringify(shippedOrder, null, 2));
} else {
   print("Sipariş güncellenemedi (belki zaten 'pending' değildi veya bulunamadı).");
}

// Çıktı örneği:
/*
Sipariş Durumu Güncellendi: {
  "_id": 101,
  "customer": "Ayşe Yılmaz",
  "item": "Laptop",
  "status": "shipped",
  "orderDate": ISODate("2023-10-27T10:10:00.000Z"),
  "shipDate": ISODate("2023-10-27T10:10:05.000Z")
}
*/

// Tekrar çalıştırma (artık 'pending' olmadığı için güncelleme yapmaz):
/*
Sipariş güncellenemedi (belki zaten 'pending' değildi veya bulunamadı).
*/

Açıklama: query: { _id: 101, status: "pending" } ifadesi, yalnızca _id‘si 101 olan ve status‘ü ‘pending’ olan bir belgeyi bulur. Bu atomik sorgu sayesinde, başka bir işlem aynı anda siparişin durumunu değiştirse bile, bu findAndModify() çağrısı yalnızca doğru koşullar altında çalışır ve veri tutarlılığı sağlanır.

5. Dizi Elemanı Ekleme/Çıkarma (Array Element Push/Pull)

MongoDB’nin belge modeli, dizileri doğrudan belgelerin içine gömmeye olanak tanır. Bir dizideki elemanları atomik olarak eklemek veya çıkarmak, findAndModify() ile kolayca yapılabilir.

Senaryo: Bir kullanıcının favori ürünler listesine ürün eklemek veya çıkarmak.

// Örnek kullanıcı belgesi
db.users.insertOne({
   _id: "userA",
   name: "Can",
   favoriteProducts: ["product1", "product2"]
});

// Favori ürün ekleme
const userWithNewFavorite = db.users.findAndModify({
   query: { _id: "userA" },
   update: { $addToSet: { favoriteProducts: "product3" } }, // Sadece yoksa ekler
   new: true
});
print("Yeni Favori Eklendi:", JSON.stringify(userWithNewFavorite, null, 2));

// Favori ürün çıkarma
const userWithRemovedFavorite = db.users.findAndModify({
   query: { _id: "userA" },
   update: { $pull: { favoriteProducts: "product2" } },
   new: true
});
print("Favori Çıkarıldı:", JSON.stringify(userWithRemovedFavorite, null, 2));

// Çıktı örneği:
/*
Yeni Favori Eklendi: {
  "_id": "userA",
  "name": "Can",
  "favoriteProducts": [
    "product1",
    "product2",
    "product3"
  ]
}
Favori Çıkarıldı: {
  "_id": "userA",
  "name": "Can",
  "favoriteProducts": [
    "product1",
    "product3"
  ]
}
*/

Açıklama: $addToSet operatörü, belirtilen elemanı yalnızca dizide mevcut değilse ekler, böylece benzersiz elemanlardan oluşan bir dizi sağlar. $pull operatörü ise belirtilen elemanı diziden kaldırır. Bu işlemler, findAndModify() sayesinde atomik olarak gerçekleştirilir, bu da eşzamanlı güncellemelerde dizi tutarlılığını garanti eder.

6. Benzersiz Kimlik Atama (Unique ID Assignment)

Bazı uygulamalarda, belirli bir dizi içinde benzersiz ve sıralı kimlikler atamak gerekebilir (örn. fatura numaraları, sıra numaraları). findAndModify() bu tür bir “sequence generator” (sıra üreteci) oluşturmak için kullanılabilir.

Senaryo: Yeni bir fatura için benzersiz ve ardışık bir fatura numarası oluşturmak.

// Bir sequence (sıra) belgesi oluşturalım
db.sequences.insertOne({
   _id: "invoiceId",
   value: 0
});

// Yeni bir fatura numarası almak
function getNextSequenceValue(sequenceName) {
   const sequenceDoc = db.sequences.findAndModify({
      query: { _id: sequenceName },
      update: { $inc: { value: 1 } },
      new: true
   });
   return sequenceDoc ? sequenceDoc.value : null;
}

const invoiceNumber1 = getNextSequenceValue("invoiceId");
print("Yeni Fatura Numarası 1:", invoiceNumber1);

const invoiceNumber2 = getNextSequenceValue("invoiceId");
print("Yeni Fatura Numarası 2:", invoiceNumber2);

// Çıktı örneği:
/*
Yeni Fatura Numarası 1: 1
Yeni Fatura Numarası 2: 2
*/

Açıklama: Bu örnekte, sequences koleksiyonunda _id‘si “invoiceId” olan bir belge, bir sayaç görevi görür. getNextSequenceValue fonksiyonu, bu belgedeki value alanını atomik olarak bir artırır ve güncellenmiş değeri döndürür. Bu, birden fazla istemcinin aynı anda yeni bir fatura numarası istemesi durumunda bile her zaman benzersiz ve ardışık numaralar almasını sağlar.

findAndModify() Kullanımında Dikkat Edilmesi Gerekenler

findAndModify() güçlü bir araç olsa da, onu etkin ve güvenli bir şekilde kullanmak için bazı önemli noktaları göz önünde bulundurmak gerekir.

Performans

findAndModify() tek bir belge üzerinde atomik bir işlem gerçekleştirir. Bu, genellikle çok hızlıdır. Ancak, çok yoğun eşzamanlı yazma yükü altında ve aynı belge üzerinde sürekli findAndModify() çağrıları yapıldığında, bu işlemler belgenin kilitlenmesine ve diğer işlemlerin kısa süreli beklemesine neden olabilir. Çoğu durumda bu performans etkisi ihmal edilebilir düzeyde olsa da, ultra yüksek performans gerektiren sistemlerde bu durumun farkında olmak önemlidir. query ve sort parametrelerinin indekslenmesi, arama süresini optimize ederek genel performansı artırabilir.

Hata Yönetimi ve Döndürülen Değer

findAndModify() işlemi, sorguyla eşleşen bir belge bulamazsa veya upsert: false ise, null döndürür. Bu durumu uygulamanızda doğru bir şekilde ele almanız gerekir.

const nonExistentDoc = db.collection.findAndModify({
   query: { _id: "nonExistent" },
   update: { $set: { value: 1 } },
   new: true
});

if (nonExistentDoc === null) {
   print("Belge bulunamadı veya oluşturulamadı.");
}

Ayrıca, new: true ve new: false arasındaki farkı anlamak önemlidir. new: true güncellenmiş belgeyi döndürürken, new: false (varsayılan) güncellenmeden önceki belgeyi döndürür. Uygulamanızın hangi belgeye ihtiyacı olduğuna karar vererek doğru parametreyi kullanmalısınız.

MongoDB İşlemleri (Transactions) ile Karşılaştırma

Daha önce de belirtildiği gibi, findAndModify() tek belge atomisitesi için idealdir. Ancak, bir işlemin birden fazla belgeyi veya birden fazla koleksiyonu atomik olarak etkilemesi gerekiyorsa, MongoDB 4.0 ve sonraki sürümlerde sunulan çok belgeli işlemler (multi-document transactions) kullanılmalıdır. Örneğin, bir kullanıcının bakiyesini bir hesaptan diğerine aktarırken hem gönderici hem de alıcı hesap belgelerinin atomik olarak güncellenmesi gerekir. Bu, findAndModify() ile tek bir adımda yapılamaz ve bir işlem gerektirir.

Özetle:
* Tek belge atomisitesi: findAndModify()
* Çok belge/koleksiyon atomisitesi: MongoDB İşlemleri

Bu ayrımı doğru yapmak, hem veri tutarlılığını sağlamak hem de gereksiz yere daha karmaşık ve potansiyel olarak daha yavaş olan işlemleri kullanmaktan kaçınmak için kritik öneme sahiptir.

Sonuç

MongoDB’nin findAndModify() fonksiyonu, eşzamanlılık ve veri tutarlılığı sorunlarını tek bir belge seviyesinde atomik olarak çözmek için güçlü ve esnek bir araçtır. Sayaç güncellemeleri, kuyruk işleme, dağıtık kilitler, durum geçişleri, upsert işlemleri ve benzersiz kimlik atamaları gibi birçok yaygın uygulama senaryosunda vazgeçilmez bir rol oynar.

Bu makalede, findAndModify()‘nin temel kavramlarını, parametrelerini ve çeşitli pratik örneklerini ele aldık. Geliştiricilerin bu fonksiyonun atomik yapısını anlayarak ve parametrelerini doğru kullanarak, karmaşık eşzamanlılık sorunlarını güvenli ve verimli bir şekilde çözebilecekleri açıktır. Ancak, çok belgeli atomisite gerektiren durumlarda MongoDB işlemlerine yönelmek gerektiğini de unutmamak gerekir. findAndModify(), modern, ölçeklenebilir ve hataya dayanıklı MongoDB uygulamaları geliştiren her geliştiricinin araç kutusunda bulunması gereken temel bir fonksiyondur.