MongoDB Rehberi: Databases, Collections, Query API ve CRUD Operations

MongoDB, verileri esnek, JSON benzeri documents içinde depolamak için kullanılan document odaklı bir NoSQL database sistemidir. MongoDB, bilgileri yalnızca tablolarda ve satırlarda düzenlemek yerine, verileri collections içinde documents olarak saklar. Bu, onu web platformları, APIs, gösterge tabloları, içerik sistemleri, e-ticaret uygulamaları, analiz araçları ve gerçek zamanlı hizmetler gibi veri yapılarının zaman içinde değişebileceği modern uygulamalar için yararlı kılar.

Bu makale, öğrenme yolunda gösterilen MongoDB konularına ayrıntılı bir giriş niteliğindedir: MongoDB Ana Sayfa, Başlarken, Query API, Create Database, Create Collection, Insert, Find, Update ve Delete. Amaç yalnızca komutları göstermek değil, aynı zamanda MongoDB’nin veriler hakkında nasıl düşündüğünü ve geliştiricilerin bunu gerçek projelerde nasıl kullanması gerektiğini de açıklamaktır.

SQL’i zaten biliyorsanız, MongoDB ilk başta farklı gelebilir. SQL databases genellikle katı bir schema, tablolar, satırlar, sütunlar, birleşimler ve ilişkisel kısıtlamalarla başlar. MongoDB, documents, collections, esnek alanlar, gömülü veriler, referanslar, indexes ve yapılandırılmış nesnelere dayalı bir sorgu dili ile başlar. Her iki yaklaşım da güçlü olabilir ancak sorunları farklı şekillerde çözerler.

MongoDB Nedir?

MongoDB, verileri documents olarak depolayan bir NoSQL database sistemidir. document, alanlardan ve değerlerden oluşan yapılandırılmış bir nesnedir. document formatı JSON'ya benzer, ancak MongoDB dahili olarak BSON adı verilen ikili formatı kullanır. BSON, ObjectId, Date, Decimal128, Binary gibi ek veri türlerini ve database depolama için yararlı olan diğer türleri destekler.

Basit bir MongoDB document şöyle görünebilir:

{
  "_id": ObjectId("665f2a1b8f2c9a0012a45c91"),
  "name": "Adnan",
  "email": "adnan@example.com",
  "role": "developer",
  "active": true,
  "skills": ["PHP", "Laravel", "MongoDB"],
  "profile": {
    "city": "Samsun",
    "country": "Turkey"
  },
  "createdAt": ISODate("2026-06-11T00:00:00Z")
}

Bu document, ad ve e-posta gibi normal alanları, beceriler adı verilen bir dizi alanını ve profil adı verilen gömülü bir nesneyi içerir. Bu, MongoDB’nin temel güçlü yönlerinden biridir: ilgili veriler genellikle birlikte okunduğunda birlikte saklanabilir.

İlişkisel bir database'da aynı bilgiler kullanıcılar, kullanıcı_becerileri ve kullanıcı_profilleri gibi birden çok tabloya bölünebilir. MongoDB'da, eğer bu yapı uygulamanın okunmasını daha kolay ve daha hızlı hale getiriyorsa, veriler bir document kullanıcısının içine yerleştirilebilir.

MongoDB Ana Sayfa: Büyük Resim

MongoDB öğrenme yolu genellikle büyük resimle başlar. Command yazmadan önce ana yapı taşlarını anlamak önemlidir.

• Veritabanı: collections için bir kapsayıcı. Örneğin bir uygulama blog, mağaza, okul veya crm adlı bir database kullanabilir.

• Koleksiyon: Bir grup documents. SQL'daki bir tabloya benzer ancak her document'nun tamamen aynı alanlara sahip olmasını gerektirmez.

• Belge: BSON nesnesi olarak depolanan tek bir kayıt. SQL'daki bir satıra benzer ancak iç içe geçmiş nesneler ve diziler içerebilir.

• Alan: document içindeki bir anahtar. SQL'daki sütun adına benzer.

• _id: Kendi benzersiz değerinizi belirtmediğiniz sürece her document'ya otomatik olarak eklenen benzersiz bir tanımlayıcı.

• Sorgu: documents’ı bulmak, filtrelemek, güncellemek veya silmek için kullanılan yapılandırılmış bir istek.

• Dizin: MongoDB’nin documents’ı daha hızlı bulmasına yardımcı olan bir veri yapısı.

Aşağıdaki karşılaştırma SQL geliştiricilerinin MongoDB terminolojisini anlamalarına yardımcı olur.

SQL Database     → MongoDB Database
SQL Table        → MongoDB Collection
SQL Row          → MongoDB Document
SQL Column       → MongoDB Field
Primary Key      → _id
WHERE condition  → Query filter
JOIN             → Embedding, references, or $lookup
INSERT           → insertOne() / insertMany()
SELECT           → find() / findOne()
UPDATE           → updateOne() / updateMany()
DELETE           → deleteOne() / deleteMany()

MongoDB her durumda SQL'dan daha iyi değildir ve SQL her durumda MongoDB'dan daha iyi değildir. Doğru seçim, veri modeline, tutarlılık gereksinimlerine, raporlama gereksinimlerine, ölçeklenebilirlik gereksinimlerine ve uygulamanın verileri nasıl okuyup yazdığına bağlıdır.

MongoDB Başlayın

MongoDB kullanmaya başlamak için geliştiricilerin genellikle üç şeye ihtiyacı vardır: bir MongoDB sunucusu, sunucuya bağlanmanın bir yolu ve komutları çalıştırmak için bir araç veya sürücü.

MongoDB’yi farklı şekillerde kullanabilirsiniz:

• MongoDB Atlas: Yönetilen bir bulut database hizmeti. database sunucusunu kendiniz yönetmek istemediğinizde kullanışlıdır.

• Yerel MongoDB Sunucusu: Geliştirme ve test amacıyla doğrudan bilgisayarınıza veya sunucunuza yüklenir.

• Docker: MongoDB bir konteynerin içinde çalışabildiği için yerel geliştirme için kullanışlıdır.

• MongoDB Pusula: databases, collections, documents ve indexes’i görüntülemek için grafiksel bir arayüz.

• mongosh: Terminalden database komutlarını çalıştırmak için kullanılan MongoDB Kabuğu.

• Uygulama Sürücüleri: Node.js, PHP, Python, Java, C#, Go ve diğer dillerin MongoDB ile iletişim kurmasına olanak tanıyan resmi kitaplıklar.

Yerel bir MongoDB sunucusu Docker ile şu şekilde başlatılabilir:

docker run --name mongodb-demo -p 27017:27017 -d mongo

Daha sonra mongosh kullanarak bağlanabilirsiniz:

mongosh "mongodb://localhost:27017"

Mongosh'un içinde mevcut database'yu aşağıdakilerle kontrol edebilirsiniz:

db

Mevcut databases'yu aşağıdakilerle listeleyebilirsiniz:

show dbs

Başlangıçta, MongoDB, veri gerçekten eklenene kadar bir database göstermeyebilir. Bu normaldir çünkü MongoDB, databases ve collections'yu tembelce oluşturur. Uygulamada bu, bir database veya collection’ın veri aldığında veya açıkça oluşturulduğunda gerçek hale geldiği anlamına gelir.

MongoDB Bağlantı Dizesi

Uygulamalar genellikle bir bağlantı dizesi kullanarak MongoDB'ya bağlanır. Temel bir yerel bağlantı dizesi şuna benzer:

mongodb://localhost:27017

Kimlik doğrulamalı bir bağlantı dizesi şöyle görünebilir:

mongodb://username:password@localhost:27017/app_db

Gerçek projelerde bağlantı dizeleri uygulama dosyalarının içine sabit olarak kodlanmamalıdır. Ortam değişkenlerinde, örneğin bir.env dosyasında veya sunucu yapılandırmasında saklanmaları gerekir.

MONGODB_URI=mongodb://localhost:27017
MONGODB_DATABASE=app_db

Bu, kimlik bilgilerini daha güvenli tutar ve yerel geliştirme, test, hazırlama ve üretim için farklı databases'nun kullanılmasını kolaylaştırır.

MongoDB Query API

MongoDB Query API, geliştiricilerin MongoDB'da veri okuma ve yazma yöntemidir. SQL'nun aksine, MongoDB sorguları genellikle yapılandırılmış nesneler olarak yazılır. Bu nesneler filtreleri, güncelleme işlemlerini, projeksiyonları, sıralama kurallarını, aggregation aşamalarını ve diğer database işlemlerini açıklar.

Örneğin, bir SQL sorgusu şöyle görünebilir:

SELECT name, email
FROM users
WHERE active = true
ORDER BY created_at DESC
LIMIT 10;

MongoDB sürümü şu şekilde görünebilir:

db.users.find(
  { active: true },
  { name: 1, email: 1 }
).sort({ createdAt: -1 }).limit(10)

İlk nesne filtredir:

{ active: true }

İkinci nesne projeksiyondur:

{ name: 1, email: 1 }

Sıralama kuralı, azalan düzen için -1'i ve artan düzen için 1'i kullanır:

{ createdAt: -1 }

Query API farklı işlem türlerini içerir:

• Okuma işlemleri: filtreleri, projeksiyonları, sıralamayı, sınırları ve sayfalandırmayı kullanarak documents’ı bulun.

• Yazma işlemleri: documents ekleme, güncelleme, değiştirme ve silme.

• Toplama işlemleri: pipelines kullanarak verileri dönüştürün, gruplandırın, birleştirin, hesaplayın ve yeniden şekillendirin.

• Dizin işlemleri: performans için indexes oluşturun ve yönetin.

• Veritabanı ve collection işlemleri: collections oluşturun, collections'yu listeleyin, collections'yu bırakın ve validation kurallarını yönetin.

Query API anlamlıdır çünkü filtreler operators içerebilmektedir. Ortak query operators şunları içerir:

• $eq: bir değere eşittir.

• $ne: eşit değil.

• $gt: büyüktür.

• $gte: büyük veya eşittir.

• $lt: daha az.

• $lte: küçük veya eşit.

• $in: değer bir listenin içinde bulunur.

• $nin: değer bir listenin içinde mevcut değil.

• $and: hepsinin doğru olması gereken birden fazla koşulu birleştirir.

• $veya: En az birinin doğru olması gereken birden fazla koşulu birleştirin.

• $exists: Bir alanın var olup olmadığını kontrol edin.

• $regex: metni normal bir ifade kullanarak eşleştirir.

Örneğin, bu sorgu en az 18 yaşında olan aktif kullanıcıları bulur:

db.users.find({
  active: true,
  age: { $gte: 18 }
})

Bu sorgu, rolü yönetici veya editör olan kullanıcıları bulur:

db.users.find({
  role: { $in: ["admin", "editor"] }
})

Bu sorgu etkin veya doğrulanmış kullanıcıları bulur:

db.users.find({
  $or: [
    { active: true },
    { verified: true }
  ]
})

Query API, MongoDB geliştirmenin temelidir. Ekleme, bulma, güncelleme ve silme işlemlerinin tümü, filtrelerin ve document yapılarının nasıl çalıştığının anlaşılmasına bağlıdır.

MongoDB Veritabanı Oluştur

MongoDB'da bir database oluşturmak, birçok SQL sisteminde bir database oluşturmaktan farklıdır. MongoDB'da henüz mevcut olmasa bile database'ya geçiş yapabilirsiniz. database aslında ona veri eklediğinizde veya açıkça bir collection oluşturduğunuzda oluşturulur.

blog_db adlı database'ya geçmek için şunu kullanın:

use blog_db

Artık kabuk blog_db'yi işaret ediyor, ancak database veri içerene kadar show dbs'de görünmeyebilir.

database'yu otomatik olarak oluşturmak için bir document ekleyin:

db.posts.insertOne({
  title: "Learning MongoDB",
  slug: "learning-mongodb",
  status: "published",
  createdAt: new Date()
})

Artık çalıştırabilirsiniz:

show dbs

Artık bir collection ve bir document içerdiğinden database görünmelidir.

Bu tembel oluşturma davranışı geliştirme için uygundur, ancak üretimde geliştiriciler yine de database adlarını, collection adlarını, indexes, validation kurallarını, kullanıcıları, izinleri ve yedekleme politikalarını dikkatli bir şekilde planlamalıdır.

Veritabanı Adlandırmayla İlgili En İyi Uygulamalar

Veritabanı adları açık ve kararlı olmalıdır. İyi bir database adı, verilere sahip olan uygulamayı veya hizmeti tanımlar.

• blog_db, shop_db, crm_db veya analyze_db gibi anlaşılır adlar kullanın.

• database'nun amacını açıklamayan rastgele adlardan kaçının.

• İlgisiz uygulamalar için aynı database'yu kullanmaktan kaçının.

• Geliştirme, test etme, hazırlama ve üretim için ayrı databases veya ortamları kullanın.

• Üretim kimlik bilgilerini doğrudan kod dosyalarının içinde saklamayın.

Tipik bir proje, her ortam için farklı database adlarını kullanabilir:

app_local
app_testing
app_staging
app_production

Bu ayırma, kazara yapılan test işlemlerinin üretim verilerine zarar vermesini önlemeye yardımcı olur.

MongoDB Koleksiyonu

collection, MongoDB documents'nun bir grubudur. SQL'daki tabloya benzer ancak daha esnektir. Aynı collection içindeki belgeler farklı alanlara sahip olabilir; ancak profesyonel uygulamalarda tutarlı bir yapıyı korumak yine de daha iyidir.

Örneğin, collection kullanıcısı şu şekilde documents içerebilir:

{
  "_id": ObjectId("665f2a1b8f2c9a0012a45c91"),
  "name": "Adnan",
  "email": "adnan@example.com",
  "role": "admin",
  "active": true
}

Aynı collection içindeki başka bir document da ek alanlar içerebilir:

{
  "_id": ObjectId("665f2a1b8f2c9a0012a45c92"),
  "name": "Sara",
  "email": "sara@example.com",
  "role": "editor",
  "active": true,
  "profile": {
    "city": "Istanbul",
    "country": "Turkey"
  },
  "skills": ["Writing", "SEO", "Content Management"]
}

MongoDB bu esnekliğe izin verir ancak esneklik kaos anlamına gelmez. Gerçek uygulamalarda documents’ı dikkatli bir şekilde tasarlamalısınız. Bir collection’ın net bir amacı olmalı ve içindeki documents genellikle öngörülebilir bir yapı izlemelidir.

Açıkça bir collection oluşturabilirsiniz:

db.createCollection("users")

Ayrıca ilk document'yu ekleyerek otomatik olarak bir collection oluşturabilirsiniz:

db.products.insertOne({
  name: "Wireless Mouse",
  price: 25,
  stock: 100
})

Bu document'yu ekledikten sonra MongoDB, halihazırda mevcut değilse collection ürünlerini oluşturur.

Koleksiyon Adlandırmayla İlgili En İyi Uygulamalar

Koleksiyon adları basit, okunabilir ve tutarlı olmalıdır. collection birçok documents içerdiğinden birçok takım çoğul ad kullanır.

• Kullanıcılar, gönderiler, siparişler, ürünler, yorumlar ve kategoriler gibi adları kullanın.

• Adlandırma stilini proje genelinde tutarlı tutun.

• Alanı gerçekten tanımlamıyorlarsa veri, öğe veya kayıt gibi belirsiz adlardan kaçının.

• MongoDB esnek olduğu için ilgisiz document türlerini aynı collection içinde karıştırmayın.

• Uygulamanın collection'yu nasıl sorguladığına bağlı olarak indexes oluşturun.

Örneğin, bir blog uygulaması aşağıdaki gibi collections'ya sahip olabilir:

users
posts
categories
tags
comments
media
settings

Bir e-ticaret uygulaması şunları içerebilir:

customers
products
orders
payments
shipments
reviews
coupons

MongoDB'da Şema Tasarımı

MongoDB, pratik anlamda schema'suz değil, schema esnektir. database, her document'nun varsayılan olarak tamamen aynı görünmesine zorlamaz ancak uygulamanın yine de net bir veri modelini izlemesi gerekir.

MongoDB'daki en önemli schema tasarım sorusu, ilgili verilerin bir document içine mi yerleştirilmesi gerektiği yoksa başka bir collection'dan mı referans alınması gerektiğidir.

Verileri Yerleştirme

Gömme, ilgili verileri aynı document içinde depolamak anlamına gelir. Bu, gömülü veriler document üst öğesine güçlü bir şekilde ait olduğunda ve genellikle onunla birlikte okunduğunda kullanışlıdır.

{
  "title": "MongoDB Basics",
  "slug": "mongodb-basics",
  "author": {
    "name": "Adnan",
    "email": "adnan@example.com"
  },
  "tags": ["mongodb", "database", "nosql"]
}

Veriler zaten document'nun içinde olduğundan, yerleştirme ekstra sorgu ihtiyacını azaltabilir.

Verilere Referans Verme

Referans verme, SQL'daki yabancı anahtar fikrine benzer şekilde başka bir document'ya işaret eden bir tanımlayıcının depolanması anlamına gelir; ancak MongoDB, varsayılan olarak tam olarak ilişkisel databases gibi davranmaz.

{
  "title": "MongoDB Basics",
  "slug": "mongodb-basics",
  "authorId": ObjectId("665f2a1b8f2c9a0012a45c91"),
  "tags": ["mongodb", "database", "nosql"]
}

İlgili veriler büyük olduğunda, birçok yerde yeniden kullanıldığında, sık sık güncellendiğinde veya iş nedeniyle ayrı kalması gerektiğinde referans verme faydalıdır.

Basit bir kural şudur: ebeveyne ait olan verileri gömün ve birlikte okuyun; Paylaşılan, büyük, bağımsız veya ayrı olarak güncellenen referans verileri.

MongoDB Ekle

Ekleme işlemleri, bir collection'ya yeni documents ekler. MongoDB farklı ekleme yöntemleri sağlar, ancak en yaygın olanları insertOne() ve insertMany()'dir.

insertOne()

insertOne() yöntemi tek bir document ekler.

db.users.insertOne({
  name: "Adnan",
  email: "adnan@example.com",
  role: "admin",
  active: true,
  createdAt: new Date()
})

Bir _id alanı sağlamazsanız MongoDB otomatik olarak bir tane oluşturur. Varsayılan değer genellikle bir ObjectId'dir.

Sonuç genellikle onaylanan bir durumu ve eklenen kimliği içerir:

{
  acknowledged: true,
  insertedId: ObjectId("665f2a1b8f2c9a0012a45c91")
}

insertMany()

insertMany() yöntemi aynı anda birden fazla documents ekler.

db.users.insertMany([
  {
    name: "Sara",
    email: "sara@example.com",
    role: "editor",
    active: true,
    createdAt: new Date()
  },
  {
    name: "Omar",
    email: "omar@example.com",
    role: "user",
    active: false,
    createdAt: new Date()
  }
])

Toplu eklemeler, çekirdek verilerini, günlükleri, ürünleri, mesajları, analiz kayıtlarını veya geçiş verilerini içe aktarırken kullanışlıdır.

Önemli Ekleme Kuralları

documents’ı eklerken şu kuralları aklınızda bulundurun:

• Her document'nun benzersiz bir _id'si olmalıdır.

• _id sağlanmazsa MongoDB bunu otomatik olarak oluşturur.

• Aynı collection içindeki belgeler farklı alanlara sahip olabilir ancak tutarlı yapı, sürdürülebilirlik açısından daha iyidir.

• Özellikle tarihler, sayılar, boolean'lar ve tanımlayıcılar için baştan itibaren doğru veri türlerini kullanın.

• Şifreleri düz metin olarak saklamayın. Şifreleri saklamadan önce daima uygulamada karma yapın.

• Çok büyük sınırsız dizileri tek bir document içinde depolamaktan kaçının çünkü documents'nun boyut sınırları vardır ve verimsiz hale gelebilir.

İyi bir document kullanıcısı gereksiz belirsizliklerden kaçınmalıdır:

db.users.insertOne({
  name: "Adnan",
  email: "adnan@example.com",
  role: "admin",
  active: true,
  loginCount: 0,
  createdAt: new Date(),
  updatedAt: new Date()
})

Bu document durum için boole değerlerini, sayaçlar için sayısal değerleri ve zaman damgaları için Tarih değerlerini kullanır. Bu, gelecekteki sorguları ve güncellemeleri kolaylaştırır.

MongoDB Bul

collection'dan documents okunan işlemleri bulun. En yaygın iki yöntem find() ve findOne()'dur.

bul()

Find() yöntemi, eşleşen tüm documents’ı döndürür.

db.users.find()

Bu komut, collection kullanıcılarından documents değerini döndürür. Gerçek uygulamalarda her şeyi okumak yerine genellikle filtreleri, projeksiyonları, sıralamayı ve limitleri kullanmalısınız.

Aktif kullanıcıları bulun:

db.users.find({
  active: true
})

Yönetici rolüne sahip kullanıcıları bulun:

db.users.find({
  role: "admin"
})

18 yaşından büyük veya 18'e eşit kullanıcıları bulun:

db.users.find({
  age: { $gte: 18 }
})

findOne()

FindOne() yöntemi eşleşen bir document döndürür.

db.users.findOne({
  email: "adnan@example.com"
})

Bu, e-posta, kullanıcı adı, bilgi veya _id gibi benzersiz bir alana göre arama yaparken kullanışlıdır.

Projeksiyonla Bul

Projeksiyon hangi alanların döndürüldüğünü kontrol eder. Bu, bir document birçok alan içerdiğinde ancak uygulamanın yalnızca bazılarına ihtiyaç duyduğunda kullanışlıdır.

db.users.find(
  { active: true },
  { name: 1, email: 1, role: 1 }
)

Bu, varsayılan olarak yalnızca adı, e-postayı, rolü ve _id değerini döndürür. _id istemiyorsanız 0 olarak ayarlayın:

db.users.find(
  { active: true },
  { _id: 0, name: 1, email: 1, role: 1 }
)

Projeksiyon netliği artırır ve documents büyük olduğunda ağ aktarımını azaltabilir.

Sırala, Sınırla ve Atla ile Bul

Sıralama, döndürülen documents'nun sırasını kontrol eder.

db.users.find().sort({ createdAt: -1 })

Limit, kaç documents'nun döndürüldüğünü kontrol eder.

db.users.find().limit(10)

Atla, basit sayfalandırma için kullanılabilir:

db.users.find()
  .sort({ createdAt: -1 })
  .skip(20)
  .limit(10)

Bu, sayfa benzeri sonuçlar verir, ancak büyük atlama değerleri verimsiz hale gelebilir. Büyük veri kümeleri için, _id veya createdAt gibi indekslenmiş alanları kullanan imleç tabanlı sayfalandırma genellikle daha iyidir.

Mantıksal Operatörlerle Bul

$and operator tüm koşulların doğru olmasını gerektirir.

db.users.find({
  $and: [
    { active: true },
    { role: "editor" }
  ]
})

Çoğu durumda MongoDB daha kısa bir forma izin verir:

db.users.find({
  active: true,
  role: "editor"
})

$veya operator en az bir koşulun doğru olmasını gerektirir.

db.users.find({
  $or: [
    { role: "admin" },
    { role: "editor" }
  ]
})

$in operator, bir alanı birden fazla değere göre kontrol ederken genellikle daha temizdir:

db.users.find({
  role: { $in: ["admin", "editor"] }
})

Dizilerde ve İç İçe Yerleştirilmiş Belgelerde Bul

MongoDB dizi alanlarını doğrudan sorgulayabilir. Örneğin, becerilerinde MongoDB olan kullanıcıları bulun:

db.users.find({
  skills: "MongoDB"
})

MongoDB ayrıca nokta gösterimini kullanarak iç içe geçmiş alanları sorgulayabilir:

db.users.find({
  "profile.city": "Samsun"
})

MongoDB’nin document tabanlı veri modelleri için yararlı olmasının nedenlerinden biri de budur. İç içe geçmiş veriler, her şeyi manuel olarak birçok tabloya bölmeden sorgulanabilir.

MongoDB Güncellemesi

Güncelleme işlemleri mevcut documents’ı değiştirir. MongoDB, updateOne(), updateMany() ve replacementOne() dahil olmak üzere çeşitli güncelleme yöntemleri sağlar.

En önemli kural şudur: çoğu durumda $set, $inc, $push, $addToSet ve $unset gibi update operators kullanın. Yalnızca bir alanı değiştirmek istediğinizde document'nun tamamını yanlışlıkla değiştirmeyin.

updateOne()

updateOne() yöntemi, filtreyle eşleşen ilk document'yu günceller.

db.users.updateOne(
  { email: "adnan@example.com" },
  {
    $set: {
      role: "admin",
      updatedAt: new Date()
    }
  }
)

İlk nesne filtredir. İkinci nesne güncelleme işlemini açıklar. Burada $set yalnızca rolü ve güncellendiAt alanlarını değiştirir.

güncellemeÇok()

updateMany() yöntemi, filtreyle eşleşen tüm documents’ı günceller.

db.users.updateMany(
  { active: false },
  {
    $set: {
      status: "inactive",
      updatedAt: new Date()
    }
  }
)

updateMany'i dikkatli kullanın. Büyük bir güncellemeyi çalıştırmadan önce daima filtreyi find() ile test edin.

db.users.find({ active: false })

Sonuç kümesini onayladıktan sonra güncellemeyi çalıştırın.

Ortak Güncelleme Operatörleri

MongoDB update operators hassas modifikasyonlara izin verir.

$set

Alan değerlerini ayarlayın veya değiştirin:

db.users.updateOne(
  { email: "sara@example.com" },
  { $set: { active: true } }
)

$unset

document'dan bir alanı kaldırın:

db.users.updateOne(
  { email: "sara@example.com" },
  { $unset: { temporaryToken: "" } }
)

$inc

Sayısal bir değeri artırma veya azaltma:

db.users.updateOne(
  { email: "adnan@example.com" },
  { $inc: { loginCount: 1 } }
)

$itme

Bir diziye bir değer ekleyin:

db.users.updateOne(
  { email: "adnan@example.com" },
  { $push: { skills: "Node.js" } }
)

$addToSet

Bir diziye yalnızca halihazırda mevcut değilse bir değer ekleyin:

db.users.updateOne(
  { email: "adnan@example.com" },
  { $addToSet: { skills: "MongoDB" } }
)

$Push ve $addToSet arasındaki fark önemlidir. $Push yinelenen değerler oluşturabilir, $addToSet ise aynı değer için yinelenen değerleri önler.

MongoDB'da yükseliş

Yükseltme, document mevcutsa güncelleme anlamına gelir veya mevcut değilse yeni bir document ekleyin. Bu, ayarlar, sayaçlar, senkronizasyon işleri, harici tanımlayıcılar ve bağımsız işlemler için kullanışlıdır.

db.users.updateOne(
  { email: "newuser@example.com" },
  {
    $set: {
      name: "New User",
      role: "user",
      active: true,
      updatedAt: new Date()
    },
    $setOnInsert: {
      createdAt: new Date()
    }
  },
  { upsert: true }
)

Burada, $set güncelleme veya ekleme sırasında uygulanırken $setOnInsert yalnızca yeni bir document oluşturulduğunda uygulanır.

değiştirBir()

changeOne() yöntemi, _id alanı dışında eşleşen document'nun tamamını değiştirir. Yalnızca document yapısının tamamını kasıtlı olarak değiştirmek istediğinizde kullanılmalıdır.

db.users.replaceOne(
  { email: "adnan@example.com" },
  {
    name: "Adnan Mehrat",
    email: "adnan@example.com",
    role: "admin",
    active: true,
    updatedAt: new Date()
  }
)

Dikkatli olun: document yerine dahil olmayan alanlar kaldırılabilir. Çoğu normal değişiklik için, updateOne()'un $set ile kullanılması, changeOne()'dan daha güvenlidir.

MongoDB Sil

Silme işlemleri, documents’ı bir collection'dan kaldırır. MongoDB, deleteOne() ve deleteMany() işlevlerini sağlar.

deleteOne()

deleteOne() yöntemi, filtreyle eşleşen ilk document'yu siler.

db.users.deleteOne({
  email: "omar@example.com"
})

Bu, _id veya email gibi benzersiz bir alanla silerken kullanışlıdır.

silmeBirçok()

deleteMany() yöntemi, filtreyle eşleşen tüm documents’ı siler.

db.users.deleteMany({
  active: false
})

deleteMany() işlevini kullanmadan önce, hangi documents'nun kaldırılacağını doğrulamak için daima aynı filtreyle find() komutunu çalıştırın.

db.users.find({
  active: false
})

Daha sonra yalnızca emin olduktan sonra deleteMany() komutunu çalıştırın.

Tehlikeli Silme İşlemleri

En tehlikeli silme komutu boş bir filtredir:

db.users.deleteMany({})

Bu, collection kullanıcılarındaki tüm documents’ı siler. Geliştirme veya test aşamasında faydalı olabilir ancak üretim aşamasında tehlikelidir.

Bir collection’ın tamamını düşürmek de yıkıcıdır:

db.users.drop()

database'yu düşürmek daha da tehlikelidir:

db.dropDatabase()

Üretim sistemleri, yedeklemeleri, izinleri, dikkatli komut dosyalarını, inceleme süreçlerini ve izlemeyi kullanarak yıkıcı operasyonları korumalıdır.

Kalıcı Silme Yerine Geçici Silme

Birçok uygulama önemli kayıtları hemen silmekten kaçınır. Bunun yerine geçici silme yaklaşımını kullanıyorlar. Bu, document'nun database'da kaldığı ancak silinmiş olarak işaretlendiği anlamına gelir.

db.users.updateOne(
  { email: "sara@example.com" },
  {
    $set: {
      deletedAt: new Date(),
      active: false
    }
  }
)

Daha sonra normal sorgular silinen documents’ı hariç tutar:

db.users.find({
  deletedAt: { $exists: false }
})

Geçici silme, denetim izleri, geri yükleme özellikleri, yönetici incelemesi, uyumluluk ihtiyaçları ve kazara kalıcı kayıpların önlenmesi için kullanışlıdır.

Eksiksiz Bir CRUD Örneği

Aşağıdaki örnek, ekleme, bulma, güncelleme ve silme işlemlerine yönelik database seçiminden küçük bir MongoDB iş akışını göstermektedir.

use tutorial_db

db.users.insertOne({
  name: "Adnan",
  email: "adnan@example.com",
  role: "developer",
  active: true,
  skills: ["PHP", "Laravel"],
  loginCount: 0,
  createdAt: new Date(),
  updatedAt: new Date()
})

db.users.findOne({
  email: "adnan@example.com"
})

db.users.updateOne(
  { email: "adnan@example.com" },
  {
    $set: {
      role: "admin",
      updatedAt: new Date()
    },
    $addToSet: {
      skills: "MongoDB"
    },
    $inc: {
      loginCount: 1
    }
  }
)

db.users.find(
  { active: true },
  { name: 1, email: 1, role: 1, skills: 1 }
).sort({ createdAt: -1 }).limit(10)

db.users.deleteOne({
  email: "adnan@example.com"
})

Bu örnek hemen hemen her MongoDB uygulamasında kullanılan temel akışı göstermektedir. Gerçek bir sistem kimlik doğrulama, validation, indexes, işlemler, yedeklemeler ve uygulama düzeyinde hizmetler ekleyebilir ancak CRUD işlemleri temel olarak kalır.

MongoDB ve Dizinler: Pratik Bir Not

indexes bu makalenin ana konusu olmasa da gerçek MongoDB performansı için önemlidir. indexes olmadan, MongoDB’nin eşleşen sonuçları bulmak için birçok documents taraması yapması gerekebilir. Doğru indexes ile sorgular çok daha hızlı hale gelebilir.

Örneğin, kullanıcılar sıklıkla e-posta yoluyla aranıyorsa bir index oluşturun:

db.users.createIndex({ email: 1 }, { unique: true })

Bu index, MongoDB’nin e-posta yoluyla kullanıcıları daha hızlı bulmasına yardımcı olur ve ayrıca yinelenen e-posta değerlerinin önlenmesini sağlar.

Gönderiler genellikle duruma ve oluşturulma tarihine göre listeleniyorsa index bileşiği yardımcı olabilir:

db.posts.createIndex({ status: 1, createdAt: -1 })

Dizinler gerçek sorgu modellerine dayanmalıdır. Çok az sayıda indexes okuma işlemini yavaşlatabilirken, çok sayıda indexes yazma işlemlerini daha ağır hale getirebilir ve depolama kullanımını artırabilir.

MongoDB Doğrulaması: Esnek Verileri Temiz Tutma

MongoDB, esnek documents'ya izin verir, ancak profesyonel sistemler genellikle validation'ya ihtiyaç duyar. validation Koleksiyonu gerekli alanların, alan türlerinin ve temel yapının uygulanmasına yardımcı olabilir.

Örneğin, basit validation ile bir collection kullanıcısı oluşturabilirsiniz:

db.createCollection("users_validated", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email", "role"],
      properties: {
        name: {
          bsonType: "string"
        },
        email: {
          bsonType: "string"
        },
        role: {
          enum: ["admin", "editor", "user"]
        },
        active: {
          bsonType: "bool"
        }
      }
    }
  }
})

Bu, validation uygulamasının yerini almaz ancak database düzeyinde başka bir koruma katmanı ekler. Ciddi uygulamalarda, validation hem uygulamada hem de uygun olduğu yerde database'da mevcut olmalıdır.

MongoDB Öğrenirken Yaygın Yapılan Hatalar

Yeni başlayanlar sıklıkla hata yapar çünkü MongoDB ilk bakışta basit görünür. Commandların yazılması kolaydır ancak iyi veri modelleme yine de disiplin gerektirir.

• MongoDB’yi ilişkisel bir database gibi kullanmak: Birçok SQL tarzı tablo ve birleştirmeyi yeniden oluşturmak, MongoDB’nin document modelinin avantajlarını göz ardı edebilir.

• Çok fazla veri gömme: Büyük iç içe geçmiş dizilerin veya büyük gömülü yapıların güncellenmesi zor ve verimsiz hale gelebilir.

• indexes'nun yoksayılması: Sorgular küçük verilerle çalışabilir ancak collections büyüdüğünde yavaşlayabilir.

• Tutarsız alan adları kullanma: created_at, createdAt, created_date ve dateCreated'in karıştırılması kodun bakımını zorlaştırır.

• Yanlış veri türlerinin saklanması: Sayıların dizeler halinde veya tarihlerin düz metin olarak saklanması, filtrelemeyi ve sıralamayı zorlaştırır.

• updateMany veya deleteMany'yi test etmeden çalıştırma: Filtre yanlışsa büyük yazma işlemleri verilere zarar verebilir.

• Güvenliğin göz ardı edilmesi: Veritabanları kimlik doğrulamayı, ağ kısıtlamalarını, en az ayrıcalıklı kullanıcıları ve yedeklemeleri kullanmalıdır.

Bu hatalardan kaçınmanın en iyi yolu, collections'yu uygulama kullanım senaryolarına dayalı olarak tasarlamak, sorguları gerçekçi verilerle test etmek ve MongoDB'ya yalnızca esnek bir JSON depolama aracı olarak değil, ciddi bir database sistemi olarak davranmaktır.

MongoDB’yi Ne Zaman Kullanmalısınız?

MongoDB, uygulamanın esnek documents, hızlı yineleme, iç içe geçmiş veriler, yüksek yazma hacmi, ölçeklenebilir mimari ve katı ilişkisel tablolara doğal olarak uymayan veri yapılarına ihtiyaç duyduğu durumlarda güçlü bir seçimdir.

Yaygın kullanım durumları şunları içerir:

• İçerik yönetim sistemleri.

• Esnek özelliklere sahip kullanıcı profilleri.

• Farklı ürün özelliklerine sahip ürün katalogları.

• Olay günlükleri ve etkinlik akışları.

• Gerçek zamanlı kontrol panelleri.

• Mobil ve web uygulaması arka uçları.

• Analitik ve yarı yapılandırılmış veriler.

• Sohbet mesajları ve bildirim sistemleri.

Ancak MongoDB her sorun için en iyi ilk tercih olmayabilir. Yüksek düzeyde ilişkisel verilere, karmaşık joinse, sıkı işlem raporlamasına veya yoğun SQL analitiğine sahip sistemler, MySQL veya PostgreSQL gibi ilişkisel bir database tarafından veya MongoDB’nin diğer araçlarla birlikte kullanılmasıyla daha iyi sunulabilir.

Bu MongoDB Konseptleri Birlikte Nasıl Çalışır?

Bu makaledeki konular birbiriyle bağlantılıdır. MongoDB’nin document modelini anlayarak başlayın. Daha sonra bir database oluşturur veya seçersiniz. Bu database'nun içinde collections ile çalışırsınız. collections'nun içine documents’ı eklersiniz. Verileri ekledikten sonra, documents’ı filtreler, projeksiyonlar, sıralama ve sınırlamalarla bulmak için Query API'yu kullanırsınız. Veriler değiştiğinde documents’ı update operators kullanarak güncellersiniz. Verilere artık ihtiyaç duyulmadığında, dikkatlice siler veya geçici silme özelliğini kullanarak silinmiş olarak işaretlersiniz.

Profesyonel bir MongoDB iş akışı genellikle şöyle görünür:

1. Uygulama verilerini ve erişim modellerini anlayın.

2. database ve collection adlarını seçin.

3. Gömme ve referansları akıllıca kullanarak document yapısını tasarlayın.

4. Gerektiğinde collections, validation kuralları ve indexes oluşturun.

5. documents’ı doğru veri türleriyle ekleyin.

6. Filtreleri, projeksiyonları, sıralamayı ve sayfalara ayırmayı kullanarak documents’ı okuyun.

7. documents’ı güvenli update operators ile güncelleyin.

8. documents’ı dikkatlice silin veya önemli veriler için geçici silmeyi kullanın.

9. Sorgu performansını izleyin ve indexes’i gerçek kullanıma göre iyileştirin.

10. Üretim verilerini kimlik doğrulama, yedeklemeler ve sınırlı izinlerle koruyun.

Bu iş akışı, MongoDB’yi basit bir document deposundan gerçek uygulamalar için güvenilir bir database katmanına dönüştürür.

Sonuç

MongoDB, geliştiricilerin verileri esnek, JSON benzeri documents biçiminde depolamasına olanak tanıyan güçlü bir document database sistemidir. Temel kavramlarıyla başlamak kolaydır: databases, collections içerir, collections, documents içerir ve documents, alanları içerir. Ancak MongoDB’yi iyi kullanmak için geliştiricilerin Query API, document modellemeyi, ekleme işlemlerini, bulma işlemlerini, update operators, silme güvenliğini, indexes, validation'yu ve gerçek proje yapısını anlaması gerekir.

Bu makalede ele alınan konular MongoDB geliştirmenin temelini oluşturur: MongoDB Ana Sayfa, Başlarken, Query API, Veritabanı Oluşturma, Toplama, Ekleme, Bul, Güncelleştirme ve Sil. Bu konular netleştikten sonra bir sonraki adım indexing, aggregation pipelines, schema validation, ilişkiler, işlemler, performans optimizasyonu, yedekleme stratejileri ve güvenliği öğrenmek olacaktır.

MongoDB yalnızca JSON benzeri verileri depolamakla ilgili değildir. documents’ı uygulama davranışına göre tasarlamak, verileri verimli bir şekilde okumak, güvenli bir şekilde güncellemek ve kaotik hale gelmeden büyüyebilen sistemler oluşturmakla ilgilidir. Disiplinle kullanıldığında MongoDB, modern backend uygulamaları için mükemmel bir database seçimi olabilir.