Skip to content

Latest commit

 

History

History
executable file
·
727 lines (531 loc) · 25.5 KB

5.indekslerle-calisma-optimizasyon.md

File metadata and controls

executable file
·
727 lines (531 loc) · 25.5 KB
Raw

MongoDB'de Index Kullanımı ve Sorgu Optimizasyonu (MongoDB Öğreniyoruz 5)

Standart SQL veritabanlarında olduğu gibi document DB'lerde de index yönetimi çok önemli bir konu. Bu yazımızda MongoDB'de indeksleri yakından inceleyip sorgularımızın sonucu daha hızlı alabilmek için optimizasyon tekniklerini de öğrenceğiz.

Makale serisinin diğer yazıları için alttaki linkleri kullanabilirsiniz.

Bu konu için bol miktarda dokümana ihtiyacımız olacak. Bunun için Kaggle'daki "Books with ISBN of different genres" başlıklı veriyi kullanacağız. Eğer verilere ulaşmazsanız yada ulaşsanız bide değişmesi durumunda hata alırsanız Github sayfamdaki repo'dan erişebilirsiniz.

Zip dosyasını indirdikten sonra extract yaptığınızda csv ve json dosyasını göreceksiniz. Biz csv olanı kullanacağız. Import etmek için attaki komu kullanabilirsiniz.

mongoimport "mongodb://localhost:27017/mymongodb" --collection kitaplar --type csv --file 'books.csv'  -u "root" -p "password123" --authenticationDatabase "admin" --fields=title,description,gender,num_pages,editorial,isbn,year_edition,date_edition,writer,image

Ayrıca örneklerimizde kullanabilmek için array, embedded document ve referenced document ekleyelim. Daha önce de dediğimiz gibi MongoDB Shell NodeJS ile tam uyumludur. Bu yeteneğinden faydalanarak

var degerler = [1,1,2,3,4,5,6,7,8,9]


var kategoriler = ['gezi','roman','tarih', 'felsefe','bilim','sanat','magazin','teknoloji','spor', 'sağlık']

function random(){return Math.floor(Math.random()*10)}

db.yayinevleri.insertMany( [
      { _id: 1, item: "A Yayınevi", adres: "istanbul" },
      { _id: 2, item: "B Yayınevi", adres: "izmir" },
      { _id: 3, item: "C Yayınevi", adres: "ankara" },
      { _id: 4, item: "D Yayınevi", adres: "istanbul"},
      { _id: 5, item: "E Yayınevi", adres: "samsun" },
      { _id: 6, item: "F Yayınevi", adres: "mardin"},
      { _id: 7, item: "G Yayınevi", adres: "antalya"},
      { _id: 8, item: "H Yayınevi", adres: "samsun" },
      { _id: 9, item: "I Yayınevi", adres: "mardin"}])


var deger=[]
var kategori = {}
var yayinevi=[]

var kitaplar = db.kitaplar.find()

kitaplar.forEach(
    
    function(kayit){
                    deger=[]
                    yayinevi=[]
                    kategori={}
                    for (i=0;i<3;i++){
                            kategori['kat'+ i]=kategoriler[random()]
                            deger.push(degerler[random()])
                            yayinevi.push(degerler[random()])
                        }
                    db.kitaplar.update({_id:kayit._id},{$set:{'degerler':deger,'kategoriler':kategori, 'yayinevleri':yayinevi}})
})

Document sayısına bakalım.

db.kitaplar.countDocuments()

//31285

kitaplar collection'ımızın alanlarını inceleyelim.

  • title: Kitabın adı
  • description: Özet
  • gender: Kitabın kategorisi
  • num_pages: Sayfasayısı
  • editorial: Yayınevi
  • isbn: Seri no
  • year_edition: Yayınlanma yılı
  • date_edition: Yayınlanma tarihi
  • writer: Yazar
  • image: Kapak resmi

Örnek bir doküman:

{
_id: ObjectId("62d2cc512fda470ae850d596"),
title: 'SINSONTE',
description: 'Con ecos deFahrenheit 451, Un mundo feliz oBlade Runner, Sinsonte es una de las novelas de ciencia ficción más míticas de nuestro tiempo, que se lee como una elegía a los olvidados ...',
num_pages: 360,
editorial: 'IMPEDIMENTA',
isbn: Long("9788418668371"),
year_edition: 2022,
date_edition: '04/04/2022',
writer: 'Walter Tevis',
image: 'https://imagessl1.casadellibro.com/a/l/t5/71/9788418668371.jpg',
degerler: [ 6, 2, 1 ],
kategoriler: { kat0: 'gezi', kat1: 'spor', kat2: 'roman' },
yayinevleri: [ 2, 6, 7 ]
  }

Bu arada bu veriler gerçekten var. Yani kitabı satan websitesi https://www.casadellibro.com adresinden hakikaten bu kitapları ve detaylarını görebilirsiniz. Hatta kapak resmilerinin adresleri bile çalışıyor.

Bizim eklediğimiz alanlar ise sadece test amaçlı, index eklemden önce ve sonraki durumları anlamak için kullanacağız.

Artık çalışmaya hazırız.

Single Filed Index

Amacımız sayfa sayılarına göre kitapları filtrelemek olsun. Toplamda 31285 kitap vardı. Sayfa sayısı 100 den fazla 14159 kitap varmış.

db.kitaplar.find({num_pages:{$gt:100}}).count()
//14159

Şimdi hiç index kullanmadan sayfa sayısı 100 den büyük olan dokümanların listesini alırken MongoDb'nin nasıl bir yol izlediğini, kaç adet doküman taradığını inceleyelim.

Bunu için cursor metotlarından biri olan cursor.explain() metodunu kullanıyor olacağız. Yukarıda verilerimiz ayarlarken cursor.forEach() metodunu da kullanmıştık. Bütün metotları incelemek için şu sayfayı ziyaret ediniz.

Explain metodunu sonuçlarını executionStats olarak istediğimizi belirtiyoruz. Böylece sistemin çalışm aşekli hakkında bazı bilgiler edinmiş olacağız.

Sonuçlaı inceleyeccek olursak

  • nReturned: 14159 ile 14159 satır döndüğünü,
  • executionTimeMillis: 43 ile 43 milisaniyede işin tamamlandığını,
  • totalDocsExamined: 31285 ile 31285 adet dokümanın tarandığını,
  • stage: 'COLLSCAN' ile Collectin Scan yapıldığını

alayabiliyoruz.

Diğer stage türleri de şu şekilde

  • COLLSCAN : collection taraması (collection scan)
  • IXSCAN : index taraması (index scan)
  • FETCH : Dokümanları almak için
  • SHARD_MERGE : Shard üerindne gelen verilerin merge edilmesi için
  • SHARDING_FILTER : Shard üzerindeki sahipsiz dokümanları filtrelemek için
 db.kitaplar.find({num_pages:{$gt:100}}).explain("executionStats")

//  executionStats: {
//     nReturned: 14159,
//     executionTimeMillis: 43,
//     totalKeysExamined: 0,
//     totalDocsExamined: 31285,
//     executionStages: {
//       stage: 'SINGLE_SHARD',
//       nReturned: 14159,
//       executionTimeMillis: 43,
//       totalKeysExamined: 0,
//       totalDocsExamined: 31285,
//       totalChildMillis: Long("42"),
//       shards: [
//         {
//           shardName: 'shard2',
//           executionSuccess: true,
//           nReturned: 14159,
//           executionTimeMillis: 42,
//           totalKeysExamined: 0,
//           totalDocsExamined: 31285,
//           executionStages: {
//             stage: 'COLLSCAN',
//             filter: { num_pages: { '$gt': 100 } },
//             nReturned: 14159,
//             executionTimeMillisEstimate: 4,
//             works: 31287,
//             advanced: 14159,
//             needTime: 17127,
//             needYield: 0,
//             saveState: 31,
//             restoreState: 31,
//             isEOF: 1,
//             direction: 'forward',
//             docsExamined: 31285
//           }
//         }
//       ]
//     }
//   },

Şimdi sayfa sayısı sütunu için index atıp birde arama sonucumu öyle değerlendirelim.

num_pages için yazdığımız 1 değeri indekslemenin artan (asc) olarak yapılmasını istediğimizi belirtiyor. -1 yazsaydık azalan olarak yapacaktı.

db.kitaplar.createIndex( { num_pages: 1 } )

Bir de şimdi bakalım executionStats değerlerine. Benim kullandığım MongoDB sharded cluster olduğu için sizinkinden farklı sonuçlar içeriyor olabilir ancak inceleyeceğimiz kısımlar ortak olacak.

  • totalDocsExamined: 14159: artık bütün dokümanları taramadığını görebiliyoruz.
  • executionTimeMillis: 37 : süre de kısalmış 37 milisaniye
  • inputStage altındaki stage: 'IXSCAN': Artık index scan yapıldığını gösteriyor.
 db.kitaplar.find({num_pages:{$gt:100}}).explain("executionStats")

//  executionStats: {
//     nReturned: 14159,
//     executionTimeMillis: 37,
//     totalKeysExamined: 14159,
//     totalDocsExamined: 14159,
//     executionStages: {
//       stage: 'SINGLE_SHARD',
//       nReturned: 14159,
//       executionTimeMillis: 37,
//       totalKeysExamined: 14159,
//       totalDocsExamined: 14159,
//       totalChildMillis: Long("32"),
//       shards: [
//         {
//           shardName: 'shard2',
//           executionSuccess: true,
//           nReturned: 14159,
//           executionTimeMillis: 32,
//           totalKeysExamined: 14159,
//           totalDocsExamined: 14159,
//           executionStages: {
//             stage: 'FETCH',
//             nReturned: 14159,
//             executionTimeMillisEstimate: 5,
//             works: 14160,
//             advanced: 14159,
//             needTime: 0,
//             needYield: 0,
//             saveState: 14,
//             restoreState: 14,
//             isEOF: 1,
//             docsExamined: 14159,
//             alreadyHasObj: 0,
//             inputStage: {
//               stage: 'IXSCAN',
//               nReturned: 14159,
//               executionTimeMillisEstimate: 0,
//               works: 14160,
//               advanced: 14159,
//               needTime: 0,
//               needYield: 0,
//               saveState: 14,
//               restoreState: 14,
//               isEOF: 1,
//               keyPattern: { num_pages: 1 },
//               indexName: 'num_pages_1',
//               isMultiKey: false,
//               multiKeyPaths: { num_pages: [] },
//               isUnique: false,
//               isSparse: false,
//               isPartial: false,
//               indexVersion: 2,
//               direction: 'forward',
//               indexBounds: { num_pages: [ '(100, inf.0]' ] },
//               keysExamined: 14159,
//               seeks: 1,
//               dupsTested: 0,
//               dupsDropped: 0
//             }
//           }
//         }
//       ]
//     }
//   },

Kitaplar collection'ınında sayfa sayısı 0 olan kayıtların sayısına bakalım.

db.kitaplar.find({num_pages:0}).count()
//16414

Yani sayfa sayısı -1'den daha büyük kayıtları getir dersek bütün kayıtların gelmesi lazım. Şimdi bu tarz bi sorguyu index varken yapıp istatistikleri inceleyelim.

db.kitaplar.find({num_pages:{$gt:-1}}).explain("executionStats")

// nReturned: 31284,
// executionTimeMillis: 95,
// totalKeysExamined: 31284,
// totalDocsExamined: 31284,

Executiontime 95 milisaniye ve bütün dokümanlar taranmış.

şimdi indeksi silip birde öyle deneyelim.

db.kitaplar.getIndexes()
// [
//   { v: 2, key: { _id: 1 }, name: '_id_' },
//   {
//     v: 2,
//     key: { num_pages: 1 }, ----------------------> bunu sileceğiz
//     name: 'num_pages_1',
//     background: false
//   }
// ]

db.kitaplar.dropIndex( { "num_pages": 1 } )

db.kitaplar.find({num_pages:{$gt:-1}}).explain("executionStats")

// nReturned: 31284,
// executionTimeMillis: 53,
// totalKeysExamined: 0,
// totalDocsExamined: 31285,

Dikkat ederseniz indeks olmayan bir collection'da bütün dokümanları gezmeniz gereken bir sorgu veya ona yakın bir sorgu çalıştırdığımızda indeks oluşturulmuş collection'dan daha hızlı sonuç dönmektedir.

Bunun nedeni ise MongoDB için bu tarz bir sorguda indeksi ekstra step olarak kullanması. Yani normalde bütün dokümanları dolaşmak için MongoDB doğrudan memory üzerinden sorguyu yapabilecekken indeks üzerinde gittiğinde verileri tekrar çekip indeks verileri üzerinde filtreleme yapmaya çalışıyor olmasından dolayı bu tarz sorgularda index daha yavaş çalışıyor.

Compound Indeks vs Sıralama (Sorting)

Örnek verimiz:

{
_id: ObjectId("62d2cc512fda470ae850d596"),
title: 'SINSONTE',
description: 'Con ecos deFahrenheit 451, Un mundo feliz oBlade Runner, Sinsonte es una de las novelas de ciencia ficción más míticas de nuestro tiempo, que se lee como una elegía a los olvidados ...',
num_pages: 360,
editorial: 'IMPEDIMENTA',
isbn: Long("9788418668371"),
year_edition: 2022,
date_edition: '04/04/2022',
writer: 'Walter Tevis',
image: 'https://imagessl1.casadellibro.com/a/l/t5/71/9788418668371.jpg',
degerler: [ 6, 2, 1 ],
kategoriler: { kat0: 'gezi', kat1: 'spor', kat2: 'roman' },
yayinevleri: [ 2, 6, 7 ]
  }

Sayfa sayısı ve yıl için bir indeks oluşturalım. Ancak oluşturmadan önce bir sorgu çekelim.

db.kitaplar.find({year_edition:{$gt:2000}, num_pages:{$gt:200}}).explain("executionStats")

// nReturned: 9130,
// executionTimeMillis: 31,
// totalKeysExamined: 0,
// totalDocsExamined: 31285,

Bütün dokümanlar gezilmiş ve 40 milisaniye sürmüş.

db.kitaplar.createIndex( { "year_edition": 1, "num_pages": 1 })

// nReturned: 9130,
// executionTimeMillis: 24,
// totalKeysExamined: 9154,
// totalDocsExamined: 9130,

Compound Index'lerde dikkaet edilmesi gereken konulardan biri index oluşturulurken sırasıyla verilen alanlardan ilk (bizde year_edition) alan da tek başına indekslenmiştir.

Yani tek başına year_edition alanı için sorgu çektiğimizde de index scan yapıldığını görebiliriz. Ancak num_pages için sorgu çalıştırdığımızda collection scan yapılacaktır.

Indekslerin bir güzel tarafı da sıralamada kullanılabilmesidir. Sıralama performansını ciddi ölçüde arttırır.

db.kitaplar.find().sort({year_edition:1, num_pages:1}).explain("executionStats")
// bunun sonucunda index scan yapılır çünkü indexe uygun sıralama yaptık.


db.kitaplar.find().sort({year_edition:1, num_pages:-1}).explain("executionStats")
// bunun sonucu collection scan olacaktır çünkü num_pages alanını tersten sıraladık.

Multikey Index

Array alanlar üzerinde oluşturduğumuz indeksler birer multikey indekstir. Örneğin kitaplar collection'ımıza eklediğimiz degerler alanı için index oluşturduğumuzda array'in bütün değerleri için indeks oluşturulur.

Bounds kavramı ise oluşturulan indeksin sınırlarını belirler. Örneğin [ [ 3, Infinity ] ] ve [ [ -Infinity, 6 ] ] için alt sınır 3 ve üst sınır 6'dır.

// doküman
{ _id: 1, item: "ABC", ratings: [ 2, 9 ] }
{ _id: 2, item: "XYZ", ratings: [ 4, 3 ] }

// multikey index
db.survey.createIndex( { ratings: 1 } )

// sorgu
db.survey.find( { ratings : { $elemMatch: { $gte: 3, $lte: 6 } } } )

Sorgu ($elemMatch) şu şekilde çalışır 3 ve 6 değerlerinin aynı anda sağlayan dokümanları döndürür.

Ancak soru alttaki gibi değişirse şartlardan her hangi birini sağlayan doküman alınır. Yani rating değerinde 3'e eşit veya daha büyük değer olan dokümanlarla, 6'ya eşit veya daha küçük değere sahip olan dok-manlar alınır.

db.survey.find( { ratings : { $gte: 3, $lte: 6 } }  )

Bizde değerler alanına göre index oluşturalım. Ama önce indeks olmadan bir filtre çalıştıralım.

db.kitaplar.find({degerler:{$gt:2,$lt:6}}).explain("executionStats")

// nReturned: 28425,
// executionTimeMillis: 80,
// totalKeysExamined: 0,
// totalDocsExamined: 31285,
// executionStages: {
//     stage: 'COLLSCAN',

Şİmdi indeks oluşturup tekrar deneyelim.

db.kitaplar.createIndex( { degerler: 1 } )

db.kitaplar.find({degerler:{$gt:2,$lt:6}}).explain("executionStats")

// nReturned: 28425,
// executionTimeMillis: 77,
// totalKeysExamined: 59343,
// totalDocsExamined: 30449,
// inputStage: {
//     stage: 'IXSCAN',

Multikey index'i embedded dokümanlara da uygulamak mümkün.

{
_id: ObjectId("62d2cc512fda470ae850d596"),
title: 'SINSONTE',
description: 'Con ecos deFahrenheit 451, Un mundo feliz oBlade Runner, Sinsonte es una de las novelas de ciencia ficción más míticas de nuestro tiempo, que se lee como una elegía a los olvidados ...',
num_pages: 360,
editorial: 'IMPEDIMENTA',
isbn: Long("9788418668371"),
year_edition: 2022,
date_edition: '04/04/2022',
writer: 'Walter Tevis',
image: 'https://imagessl1.casadellibro.com/a/l/t5/71/9788418668371.jpg',
degerler: [ 6, 2, 1 ],
kategoriler: { kat0: 'gezi', kat1: 'spor', kat2: 'roman' },
yayinevleri: [ 2, 6, 7 ]
  }

Mesela kategoriler üzerinde uygulayabiliriz.

db.kitaplar.find({'kategoriler.kat0':'spor'}).explain("executionStats")

// nReturned: 3077,
// executionTimeMillis: 56,
// totalKeysExamined: 0,
// totalDocsExamined: 31285,
//         executionStages: {
//         stage: 'COLLSCAN',
//         executionTimeMillisEstimate: 7,


db.kitaplar.createIndex( { "kategoriler.kat0": 1 } )

// nReturned: 3077,
// executionTimeMillis: 10,
// totalKeysExamined: 3077,
// totalDocsExamined: 3077,
// executionTimeMillisEstimate: 3,

Text Index ve Text Search

Index tiplerinde biri de text. Eğer özellikle bir text alanı için indeks oluştururken index tipini text olarak belirtmezsek aramalarda ilgili text'i full vermemiz veya regular expression gibi test içinde arama yapabilen fonksiyonlar kullanmamız gerekir.

Ayrıca text index bir metindeki bütün kelimeleri tek tek indeksler. Eğer arama kısmına iki kelime yazarsak bunları ayrı ayrı OR kullnarak arar. YAzdığımız kelimeleri olduğu gibi aramasını istiyorsak kelimenin başına ve sonuna tırnakların içine " bölünü eklemliyiz. Alttaki örnekte açıklmada var.

//regex arama
db.kitaplar.find({description:{$regex : "que"}}).explain("executionStats")

// nReturned: 12986,
// executionTimeMillis: 45,
// totalKeysExamined: 0,
// totalDocsExamined: 31285,
// executionTimeMillisEstimate: 8,

// eğer iki kelimeyi olduğu gibi aramasını isteseydik alttaki gibi yazmalıydık. buna phrase arama deniliyor
//db.kitaplar.find({description:{$regex : "\"que se\""}}).explain("executionStats")

//text index ve arama

db.kitaplar.createIndex({ description: "text" })


db.kitaplar.find({$text:{$search : "que"}}).explain("executionStats")

// nReturned: 10749,
// executionTimeMillis: 32,
// totalKeysExamined: 10749,
// totalDocsExamined: 10749,
// executionStages: {
// stage: 'TEXT_MATCH',
// executionTimeMillisEstimate: 7,

Birden fazla alan eklense bile buradaki kelimler merge edilerek tek olarak arama yapılır. Ancak birden fazla alan eklendiğinde alanlara ağırlık vermek mümkün.

Öncelikle öncekli indeksi silelim.

db.kitaplar.getIndexes()

//{
//  v: 2,
//  key: { _fts: 'text', _ftsx: 1 },
//  name: 'description_text',
//  weights: { description: 1 },
//  default_language: 'english',
//  language_override: 'language',
//  textIndexVersion: 3
//}

// key alanını kullanarak silme yapılabilir

db.kitaplar.dropIndex({ _fts: 'text', _ftsx: 1 })

Yeni indeksi oluşturalım.

db.kitaplar.createIndex(
   {
     title: "text",
     description: "text"
   },
   {
     weights: {
       title: 10,
       description: 5
     },
     name: "TextIndex"
   }
 )

Text search yaparken biz belirtmediğimiz sürece aramalar izgilizce dili yapısına göre yapılır. Ancak gördüğümüz üzere bizim kitaplar collection'ınımın dili İspanyolca. Text tipinde index oluştururken dil de belirtilebilir. Örnek olarak aşağıdaki gibi index detaylarına dili de ekliyoruz.

db.quotes.createIndex(
   { content : "text" },
   { default_language: "spanish" }
)

Index Özellikleri

  • Unique Index: Oluşturulacak index unique olacaksa bu özellik kullanılır. Yani index oluşturduğumuz değer tüm dokümanlarda tekilse (unique) bu kullanılır.

Örneğin,

db.members.createIndex( { "user_id": 1 }, { unique: true } )
  • Partial Index: Dokümanların bazılarını indekslemek istediğimizde kullnabiliriz.

Örneğin, rating alanın değeri 5'den büyük olan dokümanlarını indekslemesini sağlamak için alttaki gibi bir index oluşturlmalıdır.

db.restaurants.createIndex(
   { cuisine: 1, name: 1 },
   { partialFilterExpression: { rating: { $gt: 5 } } }
)

Case Sensitive Index

Collation özelliğini kullanarak büyük küçük harf duyarlı index oluşturulabilir.

  • locale: Dil ayarlanır. Detayları için şu sayfayı ziyaret ediniz.
  • strength :
    • 1 = Büyük küçük harfı yok sayar.
    • 2 = Temel karakterlerin (birincil farklılıklar) ve aksanların (ikincil farklılıklar) karşılaştırmalarını gerçekleştirir. Temel karakterler arasındaki farklar, ikincil farklılıklara göre önceliklidir.
    • diğerleri için şu sayfayı ziyaret ediniz.
db.collection.createIndex( { "key" : 1 },
                           { collation: {
                               locale : <locale>,
                               strength : <strength>
                             }
                           } )

Indeksleri Yönetmek

  • Herhangi bir veritabanındaki bütün indeksleri listelemek için
db.getCollectionNames().forEach(function(collection) {
   indexes = db[collection].getIndexes();
   print("Indexes for " + collection + ":");
   printjson(indexes);
});
  • Herhangi bir indeksi silmek için

Index listesinden alacağımız index key'ini fonksiyona veriyoruz.

db.accounts.dropIndex( { "tax-id": 1 } )
  • Bütün indeksleri silmek için
db.accounts.dropIndexes()

Indeksi Zorunlu Kılmak

Oluşturduğumuz indeksi sorguda zorunlu tutmak için.

db.people.find(
   { name: "John Doe", zipcode: { $gt: "63000" } }
).hint( { zipcode: 1 } ).explain("executionStats")

Son olarak Index'lerin ram'e sığıyor olması çok öenmli böylece indekslerin diskten okunmasına gerek kalmaz. Bunun için alttaki komutla oluşturduğunuz indeksin byte olarak boyutunu kontrol ediniz.

db.collection.totalIndexSize()
//4617080000

Ayrıca alttaki komutla sonuçlarda ilgili collection'ın kaç adet inkse sahip olduğunu ve ram'de nekadar yer turruğunu görebilirsiniz.

  • totalIndexSize
  • nindexes
db.collection.stats()

Son olarak MongoDB schema design üzerine kurulu "Learn MongoDB The Hard Way" sayfasını ziyaret etmenizi tavsiye ederim.

Umarım faydalı olmuştur.

Makale serisinin diğer yazıları için alttaki linkleri kullanabilirsiniz.

Kaynaklar