Tablo ve Veri Tipleri

Tablo ve Veri Tipleri

Doküman, MongoDB’de veri depolama birimidir. Döküman, veriyi depolamak için JSON stilinde bir yapı kullanır. (JavaScript Object Notation).

JSON dokümanları için basit bir örnek

site : http://gelecegiyazanlar.turkcell.com.tr

şeklinde olabilir. Genellikle nesne (object) dokümana referans verilir. Dokümanlar ilişkisel veritabanı yönetim sistemindeki (Relational Data Base System-RDBS) kayıtlara (records) karşı gelir. Aşağıdaki tablo MongoDB ile ilişkisel veritabanı tablo yapısını karşılaştırmaktadır:

İlişkisel Veri Tabanı Sistemi	MongoDB
Table (Tablo)	Collection (Koleksiyon)
Column (Sütun)	Key (Anahtar)
Value (Değer)	Value (Değer)
Records / Rows (Kayıtlar / Satırlar)	Document / Object (Döküman / Nesne)

Aşağıdaki tablo ise MongoDB’de kullanılabilecek veri tiplerini listelemektedir:

Veri Tipi	Tanım
String	UTF-8 karakter dizisi
İnteger	Tamsayı
Boolean	Mantıksal true / false değer
Null	Boş
Array	Veriler dizisi
Object	Nesne
Timestamp	Zamana referans veren 64 bitlik değer
ObjectID	Her dokümana özgü eşsiz (unique) anahtar

KOLEKSİYONLAR (Collections)

Koleksiyon çok sayıda doküman içerebilir ve bunları saklamak için kullanılır. Koleksiyonu ilişkisel veritabanı sistemindeki tabloya benzetebiliriz. Koleksiyonun içerdiği dokümanların her biri farklı bir yapıda olabilir. Çünkü MongoDB, şemadan bağımsız (schema-free) bir veritabanı sistemidir.

İlişkisel veritabanı sistemlerinde bilindiği gibi, şema, veri tabanında saklanacak verilerin genel formatını belirlemektedir. MongoDB’de ise bu tür bir yapı formatına ihtiyaç yoktur. Aşağıdaki farklı yapıda iki doküman aynı koleksiyon içinde saklanabilir:

{"kitap" : "SQL"} {"dersnotu" : 129}

ÖLÇEKLENEBİLİRLİK (SCALABILITY)

Yazılım geliştiricilerin en önemli problemlerinden biri ölçekleme problemidir. Bunun anlamı, depolanması gereken veri miktarı büyüdükçe nasıl hareket edileceğidir.

Bu konuda iki yaklaşım mevcuttur:

Yukarıya doğru genişleme (scale up): Bu yaklaşımda veri miktarı büyüdükçe daha büyük bilgisayar kullanmak söz konusudur. Önemli sakıncalar,

a) Bilgisayar gücü arttıkça maliyet çok hızlı artmaktadır.

b) Bilgisayarı büyütmek için de bir üst sınır mevcuttur.

Yatay genişleme (scale out or horizontally): Bu yaklaşımda veri miktarı arttıkça, yeni bir makul boyutta sunucu (server) alınarak mevcut kümeye (cluster) eklenir. Çok daha kolay ve esnek bir ölçekleme yöntemidir, ancak en büyük sakıncası, bilgisayar kümesinin boyutu büyümüşse (yüzlerce, binlerce) bu kümenin nasıl yönetileceğidir.

MongoDB ikinci yaklaşıma göre (yatay genişleme) tasarlanmıştır. Belgeye dayalı model yaklaşımı sayesinde, veritabanının sunucular arasında dağıtılması daha kolay olmaktadır. MongoDB, verinin dengeli dağıtılması konusuna özel önem vermekte, belgeleri bilgisayarlar arasında dengeli dağıtmakta ve belli bir dokümanı talep eden kullanıcının, doğru sunucuya yönelmesini de sağlamaktadır. Böylece yazılım geliştiriciler, ölçekleme problemi ile uğraşmak yerine, kendi esas işleri olan yazılım geliştirmeye konsantre olabilmektedirler. Bilgisayar kümesinin yeni bilgisayarlara ihtiyacı olduğunda, bunlar kümeye kolayca eklenmekte ve Mongo DB, veriyi yeniden bilgisayarlar arasında en uygun biçimde dağıtmaktadır.

MongoDB’nin Temel Özellikleri

MongoDB, genel maksatlı bir veritabanı sistemidir; veri oluşturma, okuma, güncelleme ve silme işlemlerinin dışında, ölçekleme problemini de yukarda anlatıldığı biçimde kolayca çözmektedir.

MongoDB, ikincil indekslerin (secondary indexes) oluşturulmasını desteklemektedir. Böylece çok daha hızlı sorgular düzenlenebilir. Ayrıca, unique (tek) ya da bileşik (compound), mekansal (geospatial) ve full-metin indeksleri oluşturma yeteneklerine de sahiptir. Ayrıca basit parçalardan karmaşık veri yapıları oluşturma yetenekleri de mevcuttur (aggregation). MongoDB’de ayrıca belirli bir süre için saklanan veri koleksiyonları oluşturma özelliği de mevcuttur. MongoDB, kolay kullanımlı protokollerle, büyük veri dosyalarını saklama imkanı da sağlar.

İlişkisel modelde yaygın işlemler olan birleştirme (join) ya da çoklu satır hareketleri (multirow transactions) MongoDB’de mevcut değildir. Çünkü bu özelliklerle ölçeklenebilirlik problemini kolayca çözmek olası değildir. MongoDB’nin her özelliği, büyük miktarda veri ile çalışırken yüksek performans sağlama, hızdan taviz vermeme üzerine kurulmuştur. O nedenle de ilişkisel modeldeki bazı işlemleri kolayca yapamayabilir.

MongoDB: İlk Kullanım

Bu bölümde MongoDB ile ilişkili temel kavramları vereceğiz.

BELGE (DOCUMENT)

MongoDB’de belge, temel veri birimidir. Kabaca ilişkisel modeldeki satır (row) yapısına benzetilebilir, ancak ondan çok daha zengin içeriklidir.

KOLEKSİYON (COLLECTION)

Benzer şekilde, koleksiyon da ilişkisel modelin dinamik şemasındaki bir tabloya (table) benzetilebilir.

Veri Tabanı Oluşturma - Use Komutu

VERİ TABANI OLUŞTURMA - USE KOMUTU

Sistemde mevcut olmayan bir veritabanını, ilk kez oluşturmak ya da mevcut bir veritabanını kullanmaya başlamak için, use komutu aşağıdaki biçimde kullanılmalıdır;

> use kitabevi

switched to db kitabevi

>

Daha sonra db komutunu girerseniz “kitabevi” veri tabanının adı görüntülenecektir:

> db 

kitabevi

>

MongoDB’de default veritabanının adı “test”tir; yeni bir veritabanı oluşturmadığınız takdirde, gireceğiniz bilgiler (döküman, koleksiyon vb) “test” adlı veritabanına eklenecektir.

AKTİF VERİTABANINA DÖKÜMAN EKLEME

Yukarıda oluşturulan “kitabevi” adlı veritabanı içi boş olan bir veritabanıdır. İçine bir döküman eklemek için insert metodunu kullanmak gerekir:

a) Önce kitabevi veritabanına ait bir kayıt bir döküman olarak tanımlanır. Aşağıda bu döküman kayıt adı ile saklanmıştır:

> kayit={"kod":"2343","ad":"malina","yazar":"ingeborg bachmann","yayinevi":"ekin","fiyat":35,"miktar":400}

{

"kod" : "2343",

"ad" : "malina",

"yazar" : "ingeborg bachmann",

"yayinevi" : "ekin",

"fiyat" : 35,

"miktar" : 400

}

kayıt adlı dökümanı kitabevi adlı veritabanına eklemek için aşağıdaki insert komutunu girmeliyiz:

>db.kitap.insert(kayit)

WriteResult({ "nInserted" : 1 })

Böylece döküman başarı ile veritabanına eklenmiştir.

AKTİF DİZİNDE BULUNAN VERİTABANLARININ İSİMLERİNİ LİSTELEMEK

Aktif dizinde bulunan veri tabanlarının isimlerini listelemek için show dbs komutu kullanılır:

> show dbs

admin     (empty)

kitabevi  0.078GB

local     0.078GB

test      0.078GB

> 

AKTİF VERİ TABANINI SİLMEK

Aktif veritabanını silmek için dropDatabase() metodu kullanılır. Şimdi pers adlı bir veritabanı oluşturalım:

> use pers

switched to db pers

>

Veri tabanına aşağıdaki kayıtı ekleyelim:

> kay = {

        "sicil": 2345,

        "ad": "ayse okan",

        "maas": 3000

    }

    {

        "sicil": 2345,

        "ad": "ayse okan",

        "maas": 3000

    }

kay adlı kaydı insert metodu ile pers adlı veritabanına ekleyebiliriz:

> db.person.insert(kay)

WriteResult({ "nInserted" : 1 })

Kay adlı döküman başarı ile  pers adlı veritabanına eklenmiştir. Burada person, pers adlı veritabanı içindeki koleksiyonun adıdır ve döküman bu koleksiyon içine yerleşmektedir.

Find() metodu ile veritabanının içeriğini görüntüleyebiliyoruz:

> db.person.find()

{ "_id" : ObjectId("5404b92cf13cf7fb97cab6f6"),

 "sicil" : 2345,

 "ad" : "ayse okan",

 "maas" : 3000 }

> 

Şu anda aktif dizinimizdeki veritabanları:

> show dbs

admin     (empty)

kitabevi  0.078GB

local     0.078GB

pers      0.078GB

test      0.078GB

> 

Aktif olan veritabanı ise:

> use pers

switched to db pers

pers adlı veritabanı aktif haldedir. Şimdi aşağıdaki komutu girelim:

> db.dropDatabase()

{ "dropped" : "pers",

 "ok" : 1 }

Gelen mesaj pers adlı veritabanının silindiğini gösteriyor. Şu anda aktif olan dizindeki veritabanlarını listeleyelim:

> show dbs

admin     (empty)

kitabevi  0.078GB

local     0.078GB

test      0.078GB

> 

pers adlı veritabanının aktif dizinde mevcut olmadığını görürüz.

VERİTABANI İÇİNDE KOLEKSİYON OLUŞTURMAK

createCollection() METODU

createCollection() metodu ile aktif veri tabanı içinde koleksiyon oluşturmak mümkündür. Metodun yazılış biçimi,

db.createCollection(ad,opsiyonlar)

şeklindedir. Burada ad oluşturulacak koleksiyonun adıdır; opsiyonlar ise kullanımı zorunlu olmayan ve kullanılırsa koleksiyonun biçimini belirleyen bir dökümandır.

ÖRNEK:

> use kitabevi

switched to db kitabevi

kitabevi adlı  veritabanını aktif hale getirdik. Şimdi uygulayacağımız createCollection() metodu bu veritabanı üzerinde çalışacaktır:

> db.createCollection("pers")

{ "ok" : 1 }

kitabevi adlı veri tabanı içinde “pers” adlı bir koleksiyon oluşturulmuştur. Şimdi show collections komutu ile aktif veritabanı içindeki koleksiyonları listeleyebiliriz:

> show collections

kitap

pers

system.indexes

> 

Daha önceki kitap adlı koleksiyonun yanında “pers” adlı bir koleksiyon da oluşturulmuştur.

Aslında MongoDB’de koleksiyonları ayrı komutla oluşturmak gerekmez. Daha önceki örneklerde gördüğünüz gibi, veritabanına döküman eklenirken koleksiyon da otomatik olarak oluşturulur.

AKTİF VERİTABANINDAN BİR KOLEKSİYONU SİLME - DROP()  METODU

Aktif veritabanından bir koleksiyon silmek için drop metodu aşağıdaki biçimde kullanılır:

> db.pers.drop()

true

Böylece o esnada aktif olan kitabevi adlı veri tabanından “pers” adlı koleksiyon silinmiştir. Şimdi aktif veritabanında bulunan koleksiyonları listeleyiniz:

> show collections

kitap

system.indexes

> 

“pers”in artık mevcut olmadığını göreceksiniz.

VERİTABANINA DÖKÜMAN EKLEME - INSERT() VE SAVE() METOTLARI

Aktif veri tabanındaki bir koleksiyon içine bir döküman eklemek için insert() metodunun kullanıldığını daha önceki örneklerden biliyorsunuz. Bu metot,

db.koleksiyonadı.insert(dökümanadı) 

şeklinde kullanılmaktadır.

Aynı işi gerçekleştirmek için save() metodu da kullanılabilir.

ÖRNEK:

Bu örnekte save() metodunu kullanacağız. Aktif veri tabanı kitabevi olsun ve onun içindeki kitap adlı koleksiyona yeni bir kitap kayıtı eklemek isteyelim:

> kayit={"kod":"2500","ad":"dünün dünyası","yazar":"stefan zweig","yayinevi":"caner","fiyat":40,"miktar":600}

{

    "kod" : "2500",

    "ad" : "dünün dünyası",

    "yazar" : "stefan zweig",

    "yayinevi" : "caner",

    "fiyat" : 40,

    "miktar" : 600

}

Kayıt adlı dökümanı oluşturduktan sonra save() metodunu aşağıdaki biçimde kullanıyoruz:

> db.kitap.save(kayit)

WriteResult({ "nInserted" : 1 })

Şimdi  kitabevi içindeki dökümanları find() metodu ile listeleyelim:

> db.kitap.find()

{ "_id" : ObjectId("5404b03ef13cf7fb97cab6f5")

, "kod" : "2343", "ad" : "malina"

, "yazar" : "ingeborg bachmann"

, "yayinevi" : "ekin"

, "fiyat" : 35, "miktar" : 400 }

{ "_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

 "kod" : "2500",

 "ad" : "dünün dünyası",

 "yazar" : "stefan zweig",

 "yayinevi" : "caner", "fiyat" : 40, "miktar" : 600 }

> 

Böylece kitabevi veritabanındaki kitap adlı koleksiyonda iki adet dökümanın kaydedilmiş olduğunu göreceksiniz.

AYNI ANDA BİRDEN ÇOK SAYIDA DÖKÜMANI VERİTABANI KOLEKSİYONUNA EKLEMEK

Pratikte çok faydalı ve gerekli bir durum, aynı komutla birden çok dökümanı veritabanı içindeki koleksiyona ekleyebilme imkanıdır. Bunun çözümü basittir; kaydedilecek bilgi bir döküman dizisi şeklinde oluşturularak insert() ya da save() metodu uygulanır.

ÖRNEK:

Aşağıdaki kod içinde iki döküman bir dizi içine yerleştirilmiş ve yyy adı ile atanmıştır:

> yyy=[{"q":45},{"r":67}]

[ { "q" : 45 }, { "r" : 67 } ]

yyy adlı dizi insert komutu ile aktif veritabanı  içinde tt adlı bir koleksiyona kaydedilmektedir: 

db.tt.insert(yyy)

find() metodu ile tt koleksiyonunu listelerseniz aşağıdaki veriler görüntülenecektir:

db.tt.find()

{ "_id" : ObjectId("540571c7f13cf7fb97cab708"), 

"q" : 45 }

{ "_id" : ObjectId("540571c7f13cf7fb97cab709"),

 "r" : 67 }

> 

VERİTABANINI SORGULAMAK (QUERY)

Veritabanı içindeki bilgileri listelemek için find() ya da pretty() metotlarını kullanabilirsiniz. pretty() metodu ile formatlı çıktı elde etmek mümkündür.

ÖRNEK:

Kitabevi adlı veritabanındaki kitap adlı koleksiyon içindeki bilgileri listelemek istiyoruz. Önce sistemdeki veritabanlarını listeleyelim:

> show dbs

admin     (empty)

kitabevi  0.078GB

local     0.078GB

test      0.078GB

yeni      0.078GB

Sonra use komutu ile kitabevini aktif hale getirmeliyiz:

> use kitabevi

switched to db kitabevi

>

Artık find komutu ile kitabevi veritabanındaki kitap adlı koleksiyonun içeriğini listeleyebiliriz:

> db.kitap.find()

{ "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

 "kod" : "2343",

 "ad" : "malina",

 "yazar" : "ingeborg bachmann",

 "yayinevi" : "ekin",

 "fiyat" : 35, "miktar" : 400 }

{ "_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

 "kod" : "2500",

 "ad" : "dünün dünyası", 

"yazar" : "stefan zweig",

 "yayinevi" : "caner",

 "fiyat" : 40, "miktar" : 600 }

{ "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

 "kod" : "3343", "ad" : "duino ağıtları",

 "yazar" : "r.maria rilke ",

 "yayinevi" : "uz",

 "fiyat" : 25, "miktar" : 300 }

{ "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

 "kod" : "3678",

 "ad" : "buddenbruck ailesi",

 "yazar" : "Thomas mann ",

 "yayinevi" : "oka", 

"fiyat" : 55,

 "miktar" : 200 }

{ "_id" : ObjectId("5404d08af13cf7fb97cab6fa"),

 "kod" : "3343", 

"ad" : "duino ağıtları", 

"yazar" : "r.maria rilke ",

 "yayinevi" : "uz",

 "fiyat" : 25, "miktar" : 300 }

{ "_id" : ObjectId("5404d08af13cf7fb97cab6fb"),

 "kod" : "3678",

 "ad" : "buddenbruck ailesi", 

"yazar" : "Thomas mann ",

 "yayinevi" : "oka", "fiyat" : 55,

 "miktar" : 200 }

>

Dokümanlar listelenmiştir ancak pek okunabilir olduğu söylenemez. Daha iyi bir çıktı elde edebilmek için pretty() metodunu kullanabiliriz:

db.kitap.find().pretty()

Böylece aşağıda görüldüğü gibi çok daha kolay okunabilecek bir çıktı elde edebiliriz:

{

    "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

    "kod" : "2343",

    "ad" : "malina",

    "yazar" : "ingeborg bachmann",

    "yayinevi" : "ekin",

    "fiyat" : 35,

    "miktar" : 400

}

{

    "_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

    "kod" : "2500",

    "ad" : "dünün dünyası",

    "yazar" : "stefan zweig",

    "yayinevi" : "caner",

    "fiyat" : 40,

    "miktar" : 600

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

    "kod" : "3678",

    "ad" : "buddenbruck ailesi",

    "yazar" : "Thomas mann ",

    "yayinevi" : "oka",

    "fiyat" : 55,

    "miktar" : 200

}

KOŞULA BAĞLI LİSTELEME - SQL KOMUTLARINDAKİ WHERE SEÇENEĞİNİN MongoDB’DEKİ GERÇEKLEŞTİRİMİ

Bu noktada çok önemli bir konuyu inceleyeceğiz: Koşula bağlı listeleme.

Bunu bilmiyorsak veritabanını etkin kullanamayız. Her seferinde veritabanındaki tüm bilgileri listelemek yerine, (şimdiye kadar öyle yaptık) veritabanı içinden sadece belli koşulları sağlayan verileri listelemek!

Örneğin, fiyatı 50 TL’den pahalı olan kitaplar hangileridir? Ya da Thomas Mann’ın romanları hangileridir? gibi sorulara cevap vermeyi öğreneceğiz.

EŞİTLİK KONTROLÜ

Bu bölümde önce eşitlik kontrolünün nasıl yapılacağını öğreneceğiz. Örnek olarak, “fiyatı 55 TL’ye eşit olan kitapları listeleyiniz” sorusu. Bunun cevabı SQL’de,

SELECT  *  FROM kitap WHERE   fiyat=55;

şeklindedir. MongoDB’de ise eşdeğer komut,

db.kitap.find({"fiyat":55})

şeklindedir. Bu komut ile aşağıdaki çıktı elde edilir:

> db.kitap.find({"fiyat":55})

{ "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"), "kod" : "3678", "ad" : "buddenbruck ailesi", "yazar" : "Thomas mann ", "yayinevi" : "oka", "fiyat" : 55, "miktar" : 200 }

Aynı komutu pretty() metodu ile uygularsak formatlı ve daha okunabilir bir çıktı elde edeceğiz:

> db.kitap.find({"fiyat":55}).pretty()

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

    "kod" : "3678",

    "ad" : "buddenbruck ailesi",

    "yazar" : "Thomas mann ",

    "yayinevi" : "oka",

    "fiyat" : 55,

    "miktar" : 200

}

DİĞER KOŞULLARI UYGULAMA: >, <, >=, <=, !=

Doğal olarak eşitlik dışında da mukayese durumları mevcuttur. Aşağıdaki tabloda bunların bir listesi verilmiştir:

AÇIKLAMA	SQL	MongoDB
Anahtar değerden küçük mü?	anahtar<değer	<anahtar>:{$lt:<değer>}}
Anahtar değerden büyük mü?	anahtar>değer	{<anahtar>:{$gt:<değer>}}
Anahtar değerden küçük ya da eşit  mi?	anahtar<=değer	{<anahtar>:{$lte:<değer>}}
Anahtar değerden büyük ya da eşit  mi?	anahtar>=değer	{<anahtar>:{$gte:<değer>}}
Anahtar değere eşit değil mi?	anahtar!=değer	{<anahtar>:{$ne:<değer>}}

ÖRNEKLER:

SORU:

Kitap adlı tablodan fiyatı 40 TL ve daha az olan kitapları listeleyiniz.

ÇÖZÜM:

AÇIKLAMA

SQL

MongoDB

Anahtar değerden küçük mü?

anahtar<değer

<anahtar>:{$lt:<değer>}}

Anahtar değerden büyük mü?

anahtar>değer

{<anahtar>:{$gt:<değer>}}

Anahtar değerden küçük ya da eşit  mi?

anahtar<=değer

{<anahtar>:{$lte:<değer>}}

Anahtar değerden büyük ya da eşit  mi?

anahtar>=değer

{<anahtar>:{$gte:<değer>}}

Anahtar değere eşit değil mi?

anahtar!=değer

{<anahtar>:{$ne:<değer>}}

ÖRNEKLER:

SORU:

Kitap adlı tablodan fiyatı 40 TL ve daha az olan kitapları listeleyiniz.

ÇÖZÜM:

> db.kitap.find({"fiyat":{$lte:40}}).pretty()

{

    "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

    "kod" : "2343",

    "ad" : "malina",

    "yazar" : "ingeborg bachmann",

    "yayinevi" : "ekin",

    "fiyat" : 35,

    "miktar" : 400

}

{

    "_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

    "kod" : "2500",

    "ad" : "dünün dünyası",

    "yazar" : "stefan zweig",

    "yayinevi" : "caner",

    "fiyat" : 40,

    "miktar" : 600

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

SORU:

Kitap adlı koleksiyondan fiyatı 50 TL ve daha fazla olan kitapları listeleyiniz.

> db.kitap.find({"fiyat":{$lte:40}}).pretty()

{

    "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

    "kod" : "2343",

    "ad" : "malina",

    "yazar" : "ingeborg bachmann",

    "yayinevi" : "ekin",

    "fiyat" : 35,

    "miktar" : 400

}

{

    "_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

    "kod" : "2500",

    "ad" : "dünün dünyası",

    "yazar" : "stefan zweig",

    "yayinevi" : "caner",

    "fiyat" : 40,

    "miktar" : 600

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

SORU:

Kitap adlı koleksiyondan fiyatı 50 TL ve daha fazla olan kitapları listeleyiniz.

ÇÖZÜM:

> db.kitap.find({"fiyat":{$gte:50}}).pretty()

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

    "kod" : "3678",

    "ad" : "buddenbruck ailesi",

    "yazar" : "Thomas mann ",

    "yayinevi" : "oka",

    "fiyat" : 55,

    "miktar" : 200

}

SORU:

Kitap adlı koleksiyondan yazarı “Stefan Zweig” olmayan kitapları listeleyiniz. 

ÇÖZÜM:

> db.kitap.find({"yazar":{$ne:"stefan zweig"}}).pretty()

{

    "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

    "kod" : "2343",

    "ad" : "malina",

    "yazar" : "ingeborg bachmann",

    "yayinevi" : "ekin",

    "fiyat" : 35,

    "miktar" : 400

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

    "kod" : "3678",

    "ad" : "buddenbruck ailesi",

    "yazar" : "Thomas mann ",

    "yayinevi" : "oka",

    "fiyat" : 55,

    "miktar" : 200

}

BİLEŞİK KOŞULLAR :  AND VE OR AND OPERATÖRÜ

{$and:[koşul1,koşul2,….koşuln ]}

şeklinde kullanılır. AND’in işlevini aşağıdaki tablo ile hatırlatalım:

Koşul1	Koşul2	Koşul1 AND koşul2
True(doğru)	True(doğru)	True(doğru)
True(doğru)	False(yanlış)	False(yanlış)
False(Yanlış)	True(doğru)	False(yanlış)
False(Yanlış)	False(yanlış)	False(yanlış)

ÖRNEK:

Fiyatı 30 TL’den fazla ve 55 TL’den az olan kitapları listeleyiniz.

ÇÖZÜM:

Bu sorunun cevabını aşağıdaki gibi bir ifade ile alabiliriz:

{$and:[{"fiyat":{$lt:55}}

,{"fiyat":{$gt:30}}]}

Aşağıda gerekli komut ve çıktısı görülmektedir:

> db.kitap.find({$and:[{"fiyat":{$lt:55}},

{"fiyat":{$gt:30}}]}).pretty()

{

"_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

"kod" : "2343",

"ad" : "malina",

"yazar" : "ingeborg bachmann",

"yayinevi" : "ekin",

"fiyat" : 35,

"miktar" : 400

}

{

"_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

"kod" : "2500",

"ad" : "dünün dünyası",

"yazar" : "stefan zweig",

"yayinevi" : "caner",

"fiyat" : 40,

"miktar" : 600

}

> 

OR   OPERATÖRÜ

OR operatörü iki koşulu bağlarken, sadece biri doğru ise sonuç doğru sadece her iki koşul da yanlış ise sonuç yanlıştır. Aşağıdaki tabloda olası durumlar verilmiştir:

Koşul1	Koşul2	Koşul1 OR koşul2
True(doğru)	True(doğru)	True(doğru)
True(doğru)	False(yanlış)	True(doğru)
False(Yanlış)	True(doğru)	True(doğru)
False(Yanlış)	False(yanlış)	False(yanlış)

ÖRNEK:

Fiyatı 30 TL’den fazla veya yazarı “Stefan Zweig” olan kitapları listeleyiniz.

ÇÖZÜM:

> db.kitap.find({$or:[{"yazar":"stefan zweig"},{"fiyat":{$gt:30}}]}).pretty()

{

"_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

"kod" : "2343",

"ad" : "malina",

"yazar" : "ingeborg bachmann",

"yayinevi" : "ekin",

"fiyat" : 35,

"miktar" : 400

}

{

"_id" : ObjectId("5404cc69f13cf7fb97cab6f7"),

"kod" : "2500",

"ad" : "dünün dünyası",

"yazar" : "stefan zweig",

"yayinevi" : "caner",

"fiyat" : 40,

"miktar" : 600

}

{

"_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

"kod" : "3678",

"ad" : "buddenbruck ailesi",

"yazar" : "Thomas mann ",

"yayinevi" : "oka",

"fiyat" : 55,

"miktar" : 200

}

GÜNCELLEME İŞLEMİ - UPDATE() METODU

update() metodu ile veritabanı içinde güncelleme işlemleri gerçekleştirilebilir. update() metodunun kullanılış biçimi aşağıdaki gibidir:

update(Seçim kriteri ya da koşul, Güncel veri)

ÖRNEK:

“kitap” adlı koleksiyon içindeki kitaplardan “Ingeborg Bachmann”ın kitaplarının fiyatlarını 65 TL olarak değiştiren bir MongoDB komutu yazınız.

ÇÖZÜM:

> db.kitap.update({"yazar":"ingeborg bachmann"}

,{$set:{'fiyat':65}})

WriteResult({ "nMatched" : 1,

 "nUpserted" : 0,

 "nModified" : 1 })

Sonucu kontrol edersek,

db.kitap.find()

{ "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

 "kod" : "2343", 

"ad" : "malina",

 "yazar" : "ingeborg bachmann",

 "yayinevi" : "ekin",

 "fiyat" : 65,

 "miktar" : 400 }

Ingeborg Bachmann’ın kitaplarının (burada tek kitap) fiyatının 65 TL olarak değiştirildiğini görürüz.

GÜNCELLEME İŞLEMİ - SAVE() METODU

save() metodu, eski dökümanı güncellenmiş yenisi ile değiştirir. Kullanılış biçimi,

db.KoleksiyonAdı(-id:ObjectID(),YENİ_VERİ)

şeklindedir.

ÖRNEK:

Aşağıdaki koleksiyonu tablo adı ile urun adlı veritabanı içinde oluşturmak istiyoruz:

id	ur	miktar
110	conta	200
120	civata	300
150	Vida	Vida

Aşağıdaki komutları sıra ile giriniz:

> use urun

switched to db urun

> db.tablo.save({_id:110,ur:"conta"

,miktar:200})

WriteResult({ "nMatched" : 1,

 "nUpserted" : 0,

 "nModified" : 1 })

> db.tablo.save({_id:120,ur:"civata",

miktar:300})

WriteResult({ "nMatched" : 0,

 "nUpserted" : 1,

 "nModified" : 0,

 "_id" : 120 })

> db.tablo.save({_id:150,ur:"vida",

miktar:500})

WriteResult({ "nMatched" : 0, 

"nUpserted" : 1,

 "nModified" : 0,

 "_id" : 150 })

• db.tablo.find().pretty()

Böylece tablo adlı koleksiyon istediğimiz gibi oluşturulmuştur:

{ "_id" : 110, 

"ur" : "conta",

 "miktar" : 200 }

{ "_id" : 120,

 "ur" : "civata",

 "miktar" : 300 }

{ "_id" : 150, 

"ur" : "vida",

 "miktar" : 500 }

Şimdi _id’si 150 olan ürünün miktarını 458 olarak değiştirmek (güncellemek) istiyoruz. Aşağıdaki save() metodunu kullanabiliriz:

> db.tablo.save({_id:150,ur:"vida"

,miktar:458})

WriteResult({ "nMatched" : 1,

 "nUpserted" : 0,

 "nModified" : 1 

})

Şimdi tablonun son durumunu listeleyelim:

db.tablo.find().pretty()

{ "_id" : 110,

 "ur" : "conta",

 "miktar" : 200 }

{ "_id" : 120,

 "ur" : "civata",

 "miktar" : 300 }

{ "_id" : 150, 

"ur" : "vida", 

"miktar" : 458 }

> 

Çıktı listesinde gördüğünüz gibi güncelleme başarı ile gerçekleştirilmiştir.

VERİTABANINDAN DÖKÜMAN SİLME - DELETE() KOMUTU

remove() metodu aktif koleksiyon içinden döküman silmek için kullanılır. remove() metodunun iki parametresi vardır:

I. Silme kriteri:Veri tabanına hangi tür kayıtların silinmek istendiğini anlatan koşul ifadeleridir.

II. İkinci parametrenin kullanımı isteğe bağlıdır. Değeri true ya da 1 ise sadece 1 tane kayıt silinir.

ÖRNEK:

Kitap adlı koleksiyon içinden fiyatı 50 TL’den fazla olan kitapları siliniz!

ÇÖZÜM:

> use kitabevi

switched to db kitabevi

kitabevi veritabanını aktif hale getirdik. Şimdi kitap adlı koleksiyonda o anda bulunan kitapları listeleyelim:

> db.kitap.find().pretty()

{

    "_id" : ObjectId("5404b03ef13cf7fb97cab6f5"),

    "kod" : "2343",

    "ad" : "malina",

    "yazar" : "ingeborg bachmann",

    "yayinevi" : "ekin",

    "fiyat" : 65,

    "miktar" : 400

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f9"),

    "kod" : "3678",

    "ad" : "buddenbruck ailesi",

    "yazar" : "Thomas mann ",

    "yayinevi" : "oka",

    "fiyat" : 55,

    "miktar" : 200

}

Böylece 3 tane kitap listelenmiştir. Şimdi 50 TL’den pahalı olan kitapları silmek için aşağıdaki komutu girmeliyiz:

> db.kitap.remove({"fiyat":{$gt:50}})

WriteResult({ "nRemoved" : 4 })

Şimdi kitap adlı koleksiyonun son içeriğini görebilmek için kitapları listeleyelim:

> db.kitap.find().pretty()

{

    "_id" : ObjectId("5404cfe5f13cf7fb97cab6f8"),

    "kod" : "3343",

    "ad" : "duino ağıtları",

    "yazar" : "r.maria rilke ",

    "yayinevi" : "uz",

    "fiyat" : 25,

    "miktar" : 300

}

Kolayca görüldüğü gibi, fiyatı 50 TL’den fazla olan kitaplar kitap adlı koleksiyondan silinmiş ve koleksiyonda sadece 1 kitap kalmıştır.

Yukardaki remove() komutunu aşağıdaki gibi girseydik kitap adlı koleksiyondan, koşulu sağlayan sadece bir kitap silinecekti:

db.kitap.remove({"fiyat":{$gt:50}},1)

KOLEKSİYONDAKİ TÜM DÖKÜMANLARI SİLMEK

remove() komutu koşulsuz olarak kullanılırsa aktif koleksiyon içindeki tüm dökümanlar silinecektir.

ÖRNEK:

urun adlı veritabanından tablo adlı koleksiyonu siliniz.

ÇÖZÜM:

urun aktif hale getirilmelidir:

> use urun

switched to db urun

urun içindeki koleksiyonları listeliyoruz:

show collections

system.indexes

tablo

İki adet koleksiyon içinden tabloyu sileceğiz. Önce tablonun içeriğini listeliyoruz:

> db.tablo.find().pretty()

{ "_id" : 110, "ur" : "conta", "miktar" : 200 }

{ "_id" : 120, "ur" : "civata", "miktar" : 300 }

{ "_id" : 150, "ur" : "vida", "miktar" : 458 }

Şimdi remove() komutunu koşulsuz kullanıyoruz. Ayrıca ikinci parametreyi 0 yapıyoruz:

> db.tablo.remove("",0)

WriteResult({ "nRemoved" : 3 })

System 3 kayıtın silindiğini söylüyor. tablo’nun içeriğini gene listeleyelim:

> db.tablo.find().pretty()

>

Böylece tablo’nun boş olduğunu yani bütün kayıtların silinmiş olduğunu görürüz. 

PROJEKSİYON İŞLEMİ

Projeksiyon işlemi deyince şunu anlıyoruz: koleksiyonun tüm anahtar/değer ikililerini listelemek yerine sadece ilgi duyulan ya da o anda gerekli  olanları listelemek!

Bu işlemi find() metodunu özel bir biçimde kullanarak gerçekleştirebiliriz.

ÖRNEK:

Aşağıdaki adımlar ile urun adlı bir veri tabanı ve içinde tx adlı bir koleksiyon oluşturalım:

> use urun

switched to db urun

> db.tx.insert({"a":300,"b":67,"c":456,"d":800,"e":89})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":30,"b":65,"c":416,"d":807,"e":189})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":230,"b":765,"c":4316,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.find()

{ "_id" : ObjectId("5406280df13cf7fb97cab70d"), "a" : 300, "b" : 67, "c" : 456, "d" : 800, "e" : 89 }

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "b" : 65, "c" : 416, "d" : 807, "e" : 189 }

{ "_id" : ObjectId("5406285bf13cf7fb97cab70f"), "a" : 230, "b" : 765, "c" : 4316, "d" : 807, "e" : 789 }

> db.tx.find().pretty()

{

    "_id" : ObjectId("5406280df13cf7fb97cab70d"),

    "a" : 300,

    "b" : 67,

    "c" : 456,

    "d" : 800,

    "e" : 89

}

{

    "_id" : ObjectId("54062834f13cf7fb97cab70e"),

    "a" : 30,

    "b" : 65,

    "c" : 416,

    "d" : 807,

    "e" : 189

}

{

    "_id" : ObjectId("5406285bf13cf7fb97cab70f"),

    "a" : 230,

    "b" : 765,

    "c" : 4316,

    "d" : 807,

    "e" : 789

}

Şimdi tx koleksiyonundan sadece “a” ve “e” anahtarları ile ilişkili verileri listelemek isteyelim. Aşağıdaki komutu girmeliyiz:

db.tx.find({},{"a":1,"e":1}).pretty()

{ "_id" : ObjectId("5406280df13cf7fb97cab70d"), "a" : 300, "e" : 89 }

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "e" : 189 }

{ "_id" : ObjectId("5406285bf13cf7fb97cab70f"), "a" : 230, "e" : 789 }

> 

LİSTELENECEK DÖKÜMAN SAYISINI SINIRLAMAK - LIMIT() METODU

Aktif veritabanındaki tablodan listelenecek dökümanların sayısını bazı durumlarda sınırlamak gerekli olabilir. Bu amaçla find() metodu ile birlikte limit() metodu kullanılabilir.

db.tx.find().limit(2)

{ "_id" : ObjectId("5406280df13cf7fb97cab70d"), "a" : 300, "b" : 67, "c" : 456, "d" : 800, "e" : 89 }

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "b" : 65, "c" : 416, "d" : 807, "e" : 189 }

> 

Burada tx koleksiyonunda 3 döküman olmasına rağmen limit metodu ile listelenecek döküman sayısı 2 olarak sınırlanmaktadır.

SKIP() METODU

skip() metodu ile dökümanların belirli bir miktarının atlanması da sağlanabilir. Aşağıdaki komutta, 10 döküman atlanarak daha sonraki 2 döküman listelenmektedir:

db.tx.find().limit(2).skip(10)

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "b" : 65, "c" : 416, "d" : 807, "e" : 189 }

{ "_id" : ObjectId("5406285bf13cf7fb97cab70f"), "a" : 230, "b" : 765, "c" : 4316, "d" : 807, "e" : 789 }

> 

Bu sayede veritabanındaki dokümanlar üzerinde sayfalama (paging) işlemi gerçekleştirebiliriz.

Veritabanındaki Dökümanların Sıralanması

VERİTABANINDAKİ DÖKÜMANLARIN SIRALANMASI - SORT() METODU

Sıralama işlemi bilgisayar ortamlarında belki de en çok kullanılan işlemdir. Sıralama (sorting) denilince verilerin belli alanlara göre küçükten büyüğe ya da a’dan z’ye (Artan Sıralama - Ascending) ya da büyükten küçüğe veya z’den a’ya (Azalan sıralama - Descending) düzene sokulmasını anlıyoruz.

MongoDB’de sort() metodu her iki türde sıralamayı da gerçekleştirebilir. sort() metodunun yazılış biçimi,

sort({Anahtar:SıralamaTürü})

şeklindedir. Sıralama türü parametresi,

    1 ise Artan (ascending)

    -1 ise Azalan (descending)

türde sıralama söz konusudur.

ÖRNEK:

Önce urun adlı veritabanımızı aktif hale getirerek, içindeki tx tablosunun içeriğini görüntüleyelim:

> use urun

switched to db urun

> db.tx.find().pretty()

{

    "_id" : ObjectId("5406280df13cf7fb97cab70d"),

    "a" : 300,

    "b" : 67,

    "c" : 456,

    "d" : 800,

    "e" : 89

}

{

    "_id" : ObjectId("54062834f13cf7fb97cab70e"),

    "a" : 30,

    "b" : 65,

    "c" : 416,

    "d" : 807,

    "e" : 189

}

{

    "_id" : ObjectId("5406285bf13cf7fb97cab70f"),

    "a" : 230,

    "b" : 765,

    "c" : 4316,

    "d" : 807,

    "e" : 789

}

Şimdi tx koleksiyonunu “a” alanine göre artan (ascending) biçimde sıralamak istiyoruz. Buna göre aşağıdaki komutu girmeliyiz:

db.tx.find().sort({"a":1}).pretty()

Bu durumda aşağıdaki çıktı elde edilecektir:

{

    "_id" : ObjectId("54062834f13cf7fb97cab70e"),

    "a" : 30,

    "b" : 65,

    "c" : 416,

    "d" : 807,

    "e" : 189

}

{

    "_id" : ObjectId("5406285bf13cf7fb97cab70f"),

    "a" : 230,

    "b" : 765,

    "c" : 4316,

    "d" : 807,

    "e" : 789

}

{

    "_id" : ObjectId("5406280df13cf7fb97cab70d"),

    "a" : 300,

    "b" : 67,

    "c" : 456,

    "d" : 800,

    "e" : 89

}

Görüldüğü gibi tx koleksiyonu içindeki dökümanlar “a” alanına göre küçükten büyüğe doğru sıralanmıştır (30, 230, 300).

Şimdi aynı koleksiyonu büyükten küçüğe doğru (azalan - descending) tarzda sıralamak isteyelim. Buna göre aşağıdaki komutu girmeliyiz:

db.tx.find().sort({“a":-1}).pretty()

Bu komut sonucunda elde edilecek çıktı ise aşağıda verilmiştir:

{

    "_id" : ObjectId("5406280df13cf7fb97cab70d"),

    "a" : 300,

    "b" : 67,

    "c" : 456,

    "d" : 800,

    "e" : 89

}

{

    "_id" : ObjectId("5406285bf13cf7fb97cab70f"),

    "a" : 230,

    "b" : 765,

    "c" : 4316,

    "d" : 807,

    "e" : 789

}

{

    "_id" : ObjectId("54062834f13cf7fb97cab70e"),

    "a" : 30,

    "b" : 65,

    "c" : 416,

    "d" : 807,

    "e" : 189

}

> 

Kolayca görüldüğü gibi bu kez tx koleksiyonu “a” alanına göre azalan sırada (300, 230, 30) sıralanmıştır.

BİRDEN FAZLA ANAHTARA GÖRE SIRALAMA

Pratikte en çok ihtiyaç duyulan uygulamalardan biri de, dökümanların birden fazla alana göre sıralanmalarıdır. Örneğin, personel bilgisini maaşa göre sıralamak ama maaşı aynı olanları da kendi aralarında yaşa göre sıralamak!

Bu işlem de MongoDB’de sort() metodu sayesinde kolayca gerçekleştirilebilir. Şimdi urun adlı veritabanımızın tx koleksiyonuna bu bilgiyi test edebileceğimiz veriler yükleyelim:

> db.tx.insert({"a":230,"b":75,"c":436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":230,"b":5,"c":8436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":230,"b":345,"c":8436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":30,"b":34,"c":8436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":30,"b":347,"c":8436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

> db.tx.insert({"a":30,"b":7,"c":8436,"d":807,"e":789})

WriteResult({ "nInserted" : 1 })

tx koleksiyonunun son durumu aşağıdadır:

> db.tx.find()

{ "_id" : ObjectId("5406280df13cf7fb97cab70d"), "a" : 300, "b" : 67, "c" : 456, "d" : 800, "e" : 89 }

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "b" : 65, "c" : 416, "d" : 807, "e" : 189 }

{ "_id" : ObjectId("5406285bf13cf7fb97cab70f"), "a" : 230, "b" : 765, "c" : 4316, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b40af13cf7fb97cab710"), "a" : 230, "b" : 75, "c" : 436, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b41bf13cf7fb97cab711"), "a" : 230, "b" : 5, "c" : 8436, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b42ef13cf7fb97cab712"), "a" : 230, "b" : 345, "c" : 8436, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b443f13cf7fb97cab713"), "a" : 30, "b" : 34, "c" : 8436, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b452f13cf7fb97cab714"), "a" : 30, "b" : 347, "c" : 8436, "d" : 807, "e" : 789 }

{ "_id" : ObjectId("5406b45df13cf7fb97cab715"), "a" : 30, "b" : 7, "c" : 8436, "d" : 807, "e" : 789 }

Şimdi tx koleksiyonunu önce “a” anahtarına göre artan sırada, aynı “a” değerine sahip olanları da kendi aralarında “b” alanına göre sıralamak istiyoruz; bunun için aşağıdaki sort komutunu girmeliyiz:

> db.tx.find({},{"a":1,"b":1}).sort({"a":1,"b":1})> 

Sonuçta aşağıdaki çıktıyı elde edeceksiniz:

{ "_id" : ObjectId("5406b45df13cf7fb97cab715"), "a" : 30, "b" : 7 }

{ "_id" : ObjectId("5406b443f13cf7fb97cab713"), "a" : 30, "b" : 34 }

{ "_id" : ObjectId("54062834f13cf7fb97cab70e"), "a" : 30, "b" : 65 }

{ "_id" : ObjectId("5406b452f13cf7fb97cab714"), "a" : 30, "b" : 347 }

{ "_id" : ObjectId("5406b41bf13cf7fb97cab711"), "a" : 230, "b" : 5 }

{ "_id" : ObjectId("5406b40af13cf7fb97cab710"), "a" : 230, "b" : 75 }

{ "_id" : ObjectId("5406b42ef13cf7fb97cab712"), "a" : 230, "b" : 345 }

{ "_id" : ObjectId("5406285bf13cf7fb97cab70f"), "a" : 230, "b" : 765 }

{ "_id" : ObjectId("5406280df13cf7fb97cab70d"), "a" : 300, "b" : 67 }

> 

Yukardaki çıktı dikkatle izlenirse, aşağıdaki tabloda verilen türde bir sıralama yapıldığı kolayca görülür:

“a”	“b”
30	7
30	34
30	65
30	347
230	5
230	75
230	345
230	765
300	67

MongoDB -  İNDEKSLEME (INDEXING)

MongoDB’de sıralama işlemi çok faydalıdır ancak büyük miktarda veri ile çalışıldığında her seferinde veriyi bir anahtara göre düzene sokmak oldukça zaman alıcı bir işlemdir.

Bunun yerine veriyi önceden hazırlanan bir veri yapısı ile bir mekanizma ile her seferinde sıra ile dolaşmayı sağlamak daha etkin bir metottur. Veriyi belli bir alana göre sıra ile dolaşmayı sağlayan ve başlangıçta bir kere hazırlanan bu veri yapısına indeks dosyası (index file) adı verilir.

MongoDB’de bu işlem ensureIndex() metodu yardımı ile gerçekleştirilir.

Şimdi urun veri tabanında tx koleksiyonuna bu metodu uygulayalım:

> db.tx.ensureIndex({"a":1})

{ "numIndexesBefore" : 5, "note" : "all indexes already exist", "ok" : 1 }

> 

Bu işlemden sonra find ile yapılacak sorgulamalar ya da sort işlemleri çok daha hızlı hale gelecektir.

Agregasyon (Aggregation)

MongoDB - AGREGASYON (AGGREGATION)

MongoDB’de agregasyon işlemleri denilince dökümanların belli alanlara göre gruplandırılması ve bu gruplar yardımı ile bazı filtreleme ya da hesaplama işlemlerinin yapılmasını anlıyoruz. Bu işlemler SQL’de count() ve group by komutları ile gerçekleştirilir.

Şimdi bu konuyu daha iyi anlayabilmek için özel bir veri seçelim. Bu veri aşağıdaki tabloda verilmiştir:

Sicil	ad	Bölüm	Maaş
234	ali can	Satis	5000
112	okan sert	pazarlama	3000
567	ayse akıner	Satis	1800
777	mehmet özer	teknik destek	4500
222	melih sahin	pazarlama	3300
765	mehmet cenk	satis	2200
454	selin seker	teknik destek	3400
432	berna bilen	muhasebe	4500
113	deniz ikiler	muhasebe	2300

Bu tabloyu person adlı veri tabanında pers adlı koleksiyon içine yükleyelim:

> USE person

switched TO db person

> db.pers.INSERT({"sicil":234,"ad":"ali can","bolum":"satis","maas":5000 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":112,"ad":"okan sert","bolum":"pazarlama","maas":3000 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":567,"ad":"ayse akıner","bolum":"satis","maas":1800 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":777,"ad":"mehmet özer","bolum":"teknik destek","maas":4500 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":222,"ad":"melih sahin","bolum":"pazarlama","maas":3300 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":765,"ad":"mehmet cenk","bolum":"satis","maas":2200 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":454,"ad":"selin seker","bolum":"teknik destek","maas":3400 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":432,"ad":"berna bilen","bolum":"muhasebe","maas":4500 })

WriteResult({ "nInserted" : 1 })

> db.pers.INSERT({"sicil":113,"ad":"deniz ikiler","bolum":"muhasebe","maas":2300 })

WriteResult({ "nInserted" : 1 })

Click and drag to move

Yüklediğimiz koleksiyonu listeleyelim:

> db.pers.find().pretty()

{

    "_id" : ObjectId("5406dcc3f13cf7fb97cab716"),

    "sicil" : 234,

    "ad" : "ali can",

    "bolum" : "satis",

    "maas" : 5000

}

{

    "_id" : ObjectId("5406dd14f13cf7fb97cab717"),

    "sicil" : 112,

    "ad" : "okan sert",

    "bolum" : "pazarlama",

    "maas" : 3000

}

{

    "_id" : ObjectId("5406e45bf13cf7fb97cab718"),

    "sicil" : 567,

    "ad" : "ayse akıner",

    "bolum" : "satis",

    "maas" : 1800

}

{

    "_id" : ObjectId("5406e4aaf13cf7fb97cab719"),

    "sicil" : 777,

    "ad" : "mehmet özer",

    "bolum" : "teknik destek",

    "maas" : 4500

}

{

    "_id" : ObjectId("5406e52ef13cf7fb97cab71a"),

    "sicil" : 222,

    "ad" : "melih sahin",

    "bolum" : "pazarlama",

    "maas" : 3300

}

{

    "_id" : ObjectId("5406e588f13cf7fb97cab71b"),

    "sicil" : 765,

    "ad" : "mehmet cenk",

    "bolum" : "satis",

    "maas" : 2200

}

{

    "_id" : ObjectId("5406e5d8f13cf7fb97cab71c"),

    "sicil" : 454,

    "ad" : "selin seker",

    "bolum" : "teknik destek",

    "maas" : 3400

}

{

    "_id" : ObjectId("5406e625f13cf7fb97cab71d"),

    "sicil" : 432,

    "ad" : "berna bilen",

    "bolum" : "muhasebe",

    "maas" : 4500

}

{

    "_id" : ObjectId("5406e653f13cf7fb97cab71e"),

    "sicil" : 113,

    "ad" : "deniz ikiler",

    "bolum" : "muhasebe",

    "maas" : 2300

}

SORU:

Şimdi şu işlemi gerçekleştirmek istiyoruz: “Her bölümde çalışan kişi sayılarını listeleyiniz!”

ÇÖZÜM:

Bu sorunun cevabını aggregate() fonksiyonu ile aşağıdaki ifade ile bulabiliriz:

> db.pers.aggregate([{$group : {_id : "$bolum" ,personel_sayisi : {$sum : 1}}}])

Bu komut sonucunda aşağıdaki çıktı elde edilecektir:

{ "_id" : "muhasebe", "personel_sayisi" : 2 }

{ "_id" : "teknik destek", "personel_sayisi" : 2 }

{ "_id" : "pazarlama", "personel_sayisi" : 2 }

{ "_id" : "satis", "personel_sayisi" : 3 }

> 

SORU:

Her bölümdeki maas ortalamasını bulunuz!

ÇÖZÜM:

Bu sorunun çözümü avg() fonksiyonunu uygun biçimde kullanarak oluşturulur:

> db.pers.aggregate([{$group : {_id : "$bolum" ,ortalama_maas : {$avg : "$maas"}}}])

> 

Sonuçta aşağıdaki çıktı elde edilecektir:

{ "_id" : "muhasebe", "ortalama_maas" : 3400 }

{ "_id" : "teknik destek", "ortalama_maas" : 3950 }

{ "_id" : "pazarlama", "ortalama_maas" : 3150 }

{ "_id" : "satis", "ortalama_maas" : 3000 }

> 

SORU:

Her bölümdeki en yüksek maaşı bulunuz!

ÇÖZÜM:

> db.pers.aggregate([{$group : {_id : "$bolum" ,ortalama_maas : {$max: "$maas"}}}])

{ "_id" : "muhasebe", "ortalama_maas" : 4500 }

{ "_id" : "teknik destek", "ortalama_maas" : 4500 }

{ "_id" : "pazarlama", "ortalama_maas" : 3300 }

{ "_id" : "satis", "ortalama_maas" : 5000 }

> 

Sorunun cevabı olan MongoDB komutu ve çıktısı aşağıdadır:

SORU:

Her bölümdeki en düşük maaşı bulunuz!

ÇÖZÜM:

Sorunun cevabı olan MongoDB komutu ve çıktısı aşağıdadır:

> db.pers.aggregate([{$group : {_id : "$bolum" ,ortalama_maas : {$min: "$maas"}}}])

{ "_id" : "muhasebe", "ortalama_maas" : 2300 }

{ "_id" : "teknik destek", "ortalama_maas" : 3400 }

{ "_id" : "pazarlama", "ortalama_maas" : 3000 }

{ "_id" : "satis", "ortalama_maas" : 1800 }

>

İstemci Oluşturma

MongoDB İLE İSTEMCİ OLUŞTURMA

MongoDB’yi başlattığınızda, shell otomatik olarak MongoDB sunucusundaki test veritabanına bağlanır ve bu veritabanı bağlantısı db adlı global değişkende saklanır. Bu değişken, MongoDB sunucusuna shell ile erişim için birincil noktadır. Şimdi, komut satırında db girerek enter’a basınız:

> db

test

>

SHELL İLE TEMEL İŞLEMLER

Bu bölümde shell ile 4 temel işlemi gözden geçireceğiz:

I. Create (veri oluşturma)

II. Read (okuma)

III. Update (güncelleme)

IV. Delete (silme)

I.VERİ OLUŞTURMA (CREATE)

Insert fonksiyonu, bir dokümanı bir koleksiyon içine ekleme işlevini yerine getirir.

Önce bir kitap ile ilişkili bilgileri saklayacağımız bir doküman oluşturalım. Dokümanı post adı ile oluşturduk:

> post = {"kod" : 1255, "konu" : "roman", "fiyat" : 15, "miktar" : 500, "stok_gir_tar" : new Date()}

{

    "kod" : 1255,

    "konu" : "roman",

    "fiyat" : 15,

    "miktar" : 500,

    "stok_gir_tar" : ISODate("2015-02-23T17:29:16.760Z")

}

ANAHTAR(KEY)	DEĞER(VALUE)
kod	“1255”
konu	“roman”
fiyat	15
miktar	500
stok_gir_tar	“2014-09-01”

Dökümanı kitap adlı bir koleksiyonun içine eklemek için insert metodunu kullanıyoruz:

> db.kitap.insert(post)

WriteResult({ "nInserted" : 1 })

>

kitap adlı koleksiyonu listelemek içinse find() fonksiyonunu kullanabiliriz;

> db.kitap.find()

{ "_id" : ObjectId("54eb63780fb6afb327b12626"), "kod" : 1255, "konu" : "roman", "fiyat" : 15, "miktar" : 500, "stok_gir_tar" : ISODate("2015-02-23T17:29:16.760Z") }

Burada, daha önce veri içinde olmayan _id değişkeninin eklendiğine dikkatinizi çekiyoruz. Bunun nedeni ile ilişkili bilgileri daha sonra vereceğiz.

II.OKUMA (READ) İŞLEMİ

Bir koleksiyonu sorgulamak için find ya da findOne metotları kullanılabilir. Koleksiyon içinden bir tek elemanı görmek istersek findOne metodunu kullanırız:

> db.kitap.findOne();

{

    "_id" : ObjectId("54eb63780fb6afb327b12626"),

    "kod" : 1255,

    "konu" : "roman",

    "fiyat" : 15,

    "miktar" : 500,

    "stok_gir_tar" : ISODate("2015-02-23T17:29:16.760Z")

}

find ve findOne ile koşula bağlı listeleme de yapılır. Daha sonra bu konuda örnekler verilecektir.

III.GÜNCELLEME (UPDATE)

Kaydedilmiş bilgi üzerindeki değişikliklerin yansıtılması yani güncelleme işlemi bilgi işlem teknolojisinde en önemli işlerden biridir.

Şimdi kitap adlı koleksiyon içindeki dokümanımızda bir değişiklik yapmak istiyoruz ve o anda mevcut olmayan “yayinevi” bilgisini eklemek istiyoruz. Yayınevinin adı da “Turkcell” dir. Önce aşağıdaki komutu girmeliyiz:

> post.yayinevi="Turkcell"

Turkcell

Komut başarı ile çalıştı. Şimdi güncellemeyi tamamlamak için update metodunu kullanırız:

> db.kitap.update({"kod":1255},post)

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

Burada kod’u 1255 olan kitabın yayınevi “Turkcell” olarak atanmıştır. Şimdi güncel durumu görebilmek için find() metodunu kullanabiliriz:

> db.kitap.find()

{ "_id" : ObjectId("54eb63780fb6afb327b12626"), "kod" : 1255, "konu" : "roman", "fiyat" : 15, "miktar" : 500, "stok_gir_tar" : ISODate("2015-02-23T17:29:16.760Z"), "yayinevi" : "Turkcell" }

Böylece güncelleme işlemi başarı ile sonuçlanmıştır.

IV.SİLME (DELETE)

remove() metodu ile bir koleksiyon içinden dokümanları silmek mümkündür. Koşul ya da parametre belirtilmezse koleksiyon içindeki tüm dokümanlar silinecektir.

> db.kitap.remove({"kod": 1255})

WriteResult({ "nRemoved" : 1 })db.kitap.find()

Böylece koleksiyon içinde sadece 1 doküman olduğu için onu sildiğimizde koleksiyon boşalmıştır ve artık veri içermemektedir.

MongoDB’DE VERİ TÜRLERİ

Genellikle MongoDB’de dokümanları JSON benzeri veriler olarak düşünmek mümkündür. Bunlar kavramsal olarak ta JavaScript nesnelerine benzerler. JSON verinin oldukça basit bir saklama biçimidir. 6 çeşit veri tipi söz konusudur. Date türü veri yoktur.

MongoDB, JSON’un anahtar/veri ikilisi mantığını kullanırken ilave bazı veri çeşitleri de kullanmaktadır.

null

null veri tipi mevcut olmayan alanlar ya da boş veri alanını temsil etmek için kullanılır.

ÖRNEK:

> c={a:null}

{ "a" : null }

> c

{ "a" : null }

> b=c

{ "a" : null }

> b

{ "a" : null }

> 

boolean

Mantıksal veri tipidir; değeri ya doğru (true) ya da yanlış (false) tur.

ÖRNEK:

{“a”:true}

number

Sayı türü numeric değerlerle işlem yapmak için kullanılır. shell için default durum 64 bitlik kayan noktalı(floating point) sayıları kullanmaktır.

ÖRNEK:

{"e" : 2.718} 

Tamsayılar içinse NumberInt (4 byte)  ya da NumberLong (8 byte) sınıfları kullanılır.

ÖRNEK:

{"m" : NumberInt("7")}

{"n" : NumberLong("789")}

string

Karakter zinciri anlamındadır; UTF-8 karakterlerinden oluşur:

{“ad”:”ahmet cemil”}

date

Tarihler milisaniye olarak saklanır. Zaman bölgesi saklanmaz.

ÖRNEK:

{"tarih" : new Date()} 

regular expression

Düzenli ifadeler sorgular için çok faydalı ve bazen çok karmaşık olabilen ifadelerdir; MongoDB ’de düzenli ifadeler için JavaScript’in düzenli ifadeler için kullandığı yazılış biçimini kullanır.

{"aa" : /fter/jj} 

array

Diğer dillerden de bildiğiniz gibi tek bir isim altında toplanmış çok sayıda elemandan oluşur; yazılış biçimi aşağıdaki gibidir:

{"s" : ["x", "y", "z", ”k”]}

gömülü belge (embedded document)

Bir doküman başka bir doküman içine yerleştirilebilir böyle bir dokümana gömülü doküman adı verilir.

ÖRNEK:

{"rr" : {"kod" : "2345"}}

nesne belirleyicisi (object id)

Nesnelerle ilişkili hale getirilen özel anahtarlardır. Bir nesne belirleyicisi, 12 byte uzunluğundadır.

ÖRNEK:

{"asd" : ObjectId()}

ikili sistemde temsil edilen veri (binary data)

Keyfi byte dizisinden oluşur. shell içinden işlenemez. Sadece UTF-8 string’i olmayan veriyi saklamak için kullanılır.

Kod (code)

Sorgular (queries) ve dökümanlar (documents) JavaScript kodlarını da içerebilir:

ÖRNEK:

{"wer" : function() { /* ... */ }}

Tarihler (Dates)

JavaScript’te, Date sınıfı, MongoDB için tarih tipi olarak kullanılır.

Yeni bir Date nesnesi oluşturulacağı zaman daima new Date() ifadesi kullanılır.

Diziler (Arrays)

Diziler hem sıralı yapılar (liste, yığın, kuyruk) hem de sırasız yapılar (küme) için kullanılır. Aşağıdaki örnekte anahtar değeri bir diziden oluşmaktadır:

{"anahtar" : ["e", 2.718]}

GÖMÜLÜ DÖKÜMANLAR (Embedded Documents)

Dokümanlar bir anahtar için değer olarak da kullanılabilir. Bu durumda gömülü doküman kullanımı söz konusudur. Gömülü dokümanlar sayesinde veri gerçek yaşamdaki ihtiyaçlara göre organize edilebilir.

ÖRNEK:

{

        "ad" : "ali can",

        "adres" : {

            "cadde" : "cumhuriyet cd 56",

            "sehir" : "mersin",

            "posta_kod" : "54678"

} }

Yukardaki örnekte adres anahtarı aslında bir dokümandan oluşmaktadır. Bu dokümandaki anahtarlar ise, cadde, sehir ve posta_kod alanlarıdır.

_id ve ObjectId

MongoDB’de her saklanacak elemanın bir “_id” anahtarı olmalıdır. “_id” anahtarı herhangi bir veri türünde olabilir fakat default olarak ObjectID’dir. Bir koleksiyon içindeki her dokümanın bir “_id” değeri oluşturulur bu sayede bu unique kod yardımı ile birbirinden farklı dokümanlara erişilebilir. Farklı iki koleksiyonda aynı “_id” numaralı dokümanlar bulunabilir ancak tek bir koleksiyon içinde aynı “_id” numarasına sahip birden fazla doküman bulunamaz.

ObjectId

ObjectID,”_id” tipi için default değerdir. ObjectID’ler, 12 bytelık yer kaplar; her byte için 2 hexadecimal basamak hesabı ile 24 hexadecimal uzunluğunda bir anahtar söz konusudur. 

Bir Dizin (Index) Oluşturma

BİR DİZİN (INDEX) OLUŞTURMA

MongoDB’de, dizin ya da indeks yapıları sayesinde, bir koleksiyon (collection) içindeki belgelere (document) çok daha hızlı olarak erişmek mümkündür. Bu metinde dizin ve indeks sözcükleri eş anlamlı olarak kullanılacaktır. İndeks yapıları nispeten az yer kaplayan ancak etkin veri yapılarıdır. Kullanıcılar herhangi bir koleksiyon için, herhangi bir belge üzerindeki herhangi bir alan (field) için indeksler oluşturabilirler. Default olarak, MongoDB, her koleksiyon için, _id alanı üzerinde bir indeks oluşturur.

TEK BİR ALAN ÜZERİNDE İNDEKS OLUŞTURMA

Bir indeks oluşturmak için, ensureIndex() metodunu ya da sürücünüzdeki (driver) benzer bir metodu kullanmalısınız. Örneğin, aşağıdaki komut ile personel adlı koleksiyonun sicil adlı alanı üzerinde bir indeks oluşturulmaktadır:

db.personel.ensureIndex( { sicil: 1 } )

sicil alanından sonraki sayı dizin ya da indeksin biçimini belirler.

1 değeri kullanılmışsa indeks sicile göre artan (ascending) biçimde oluşturulacaktır; yani sicil değerleri küçükten büyüğe doğru sıralanacaktır.

-1 değeri kullanılırsa da indeks değerleri büyükten küçüğe yani azalan (descending) biçimde sıralanacaktır.

ensureIndex() metodu o anda mevcut olmayan indeks yapılarını ilk kez oluşturmak için kullanılır.

Aşağıdaki sorguda ile, personel kayıtları içinde sicil alanine göre oluşturulan bir indeks kullanılmaktadır:

db.personel.find( { sicil: 2 } ) db.personel.find( { sicil: { $gt: 10 } } )

Oluşturulan indeks aşağıdaki sorgu içinse geçersizdir:

db.personel.find( { pers_url: 2 } )

İndeks kullanmayan sorgular için, Mongkoleksiyon içindeki tüm belgeleri tarayacaktır; bu da doğal olarak önemli zaman kaybı demektir.

UNIQUE (TEK, BENZERSİZ) İNDEKS OLUŞTURMA

MongoDB, indeks oluşturmada unique kısıtını kullanma imkanı da verir. Bunun anlamı şudur: indekslenen alan için birden fazla aynı değerin kullanılmasını engeller. Ayrıca duplicate dropping (kopyaları yok et) olanağı ile birlikte, tekrar eden değerlerin silinmesi de sağlanabilir.

UNIQUE İNDEKS

Unique indeks oluşturmak için aşağıdaki prototip ifadeden yararlanabilirsiniz:

 db.personel.ensureIndex( { a: 1 }, { unique: true } )

Aşağıdaki örnekte vergi numarası ile ilişkili bir unique indeks oluşturulmaktadır; böylece muhasebe koleksiyonunda aynı vergi numarasından birden fazla bulunması engellenecektir:

db.muhasebe.ensureIndex( { "vergi_no": 1 }, { unique: true } )

_id  indeksi de unique bir indekstir. Bazı durumlarda başka bir alan üzerinden unique indeks oluşturmaktansa, bunun yerine _id indeksi ile işlem yapmak daha uygun olabilir.

Bir belde içinde bir alan içinde bir değer yoksa, bu alan için oluşturulan indeks yapısı içinde bu indeks alanı boş (null) olacaktır. Birçok durumda unique kısıtı ile sparse seçeneğini birlikte kullanmak isteyebilirsiniz. Sparse indeksler, herhangi bir indeks alanı boşsa (null) boş indeks alanını saklamak yerine bu alanı atlar; sparse opsiyonu olmadıkça, unique indeksler tekrar eden değerlere müsaade etmez. Bu durumda, MongoDB, indeks alanı olmayan ikinci belgeyi ve onun alt belgelerini reddeder. Aşağıdaki örneğe bakalım:

db.personel.ensureIndex( { a: 1 }, { unique: true, sparse: true } )

unique kısıtını, bileşik indekslerde de (compound indexes) kullanabilirsiniz:

db.personel.ensureIndex( { a: 1, b: 1 }, { unique: true } )

Bileşik indeksin birden fazla alanın bir araya getirilmesiyle oluşturulduğunu hatırlatalım.

Bileşik indeksler için unique kısıtı kullanılırsa, bileşik indeksin tek tek alanlarının tekrarına değil fakat alan gruplarının tekrarına bakılır ve bu tekrarlar önlenir.

Örneğin, bir bileşik indeks a ve b alanlarından meydana gelmişse, a=3, b=7ve a=3, b=9 durumları iki farklı indekstir; buna izin verilir ancak a=3, b=7  ve a=3, b=7 değerleri ise bileşik indeksin tekrarlı olması demektir ve buna müsaade edilmez.

TEKRARLARIN SİLİNMESİ (DROP DUPLICATES)

dropDups komutu yardımı ile indeks oluşturulurken, tekrar eden indeks değerlerine ait belgeler silinir. Aşağıdaki örneğe bakalım:

db.personel.ensureIndex( { a: 1 }, { unique: true, dropDups: true } )

dropDups komutunu kullanırken dikkatli olunmalıdır; bazen veritabanından arzu etmediğiniz kayıt silmeleri de yapabilirsiniz.

BACKGROUND’DA (ARKA PLANDA) İNDEKS OLUŞTURMA

Default olarak, MongoDB, indeksleri ön alanda (foreground) oluşturur. Bu tür indeksler oluşturulurken de veritabanına tüm yazma ve veritabanından okuma işlemleri engellenir.

Halbuki, background indeks oluşturma işlemi, veritabanı ile ilgili okuma-yazma işlemlerini engellemez. Background indeks oluşumu sürerken veritabanından okuma ya da veritabanına yazma işlemleri de gerçekleştirilir.

Background indeks oluşturma işlemi nispeten daha uzun sürer; bu tür indeksler foreground indekslere göre daha büyük yer kaplar ve foreground indekslere göre daha az yoğundur (compact). Zaman içinde background indekslerin biçimi ve performansı da foreground indekslere yaklaşır.

PROSEDÜR

Background’da bir indeks oluşturmak için, ensureIndex() fonksiyonunda background parametresini true yapmak gerekir:

db.personel.ensureIndex( { a: 1 }, { background: true } )

2DSPHERE Index Oluşturma

2DSPHERE İNDEKS OLUŞTURMA

GeoSON formatında geospatial (coğrafi mekansal) bir indeks oluşturmak için db.collection.ensureIndex() metodunu kullanmalısınız. Oluşturulacak indeksin 2dsphere türünde olması için bu anahtar sözcüğü komuta eklemelisiniz.

ÖRNEK:

db.collection.ensureIndex( { <İndeks Alanı> : "2dsphere" } )

Aşağıdaki prosedür, GeoJSON veri alanı içeren bir grup belge için 2dsphere indeksleri oluşturulmasını gösteriyor:

PROSEDÜR

Önce YER adlı alanda, GeoJSON Point türünde veri içeren belgeler MEKANLAR adlı bir koleksiyon oluşturuluyor; Koordinat düzeni önce boylam (longitude) sonra enlem (latitude) şeklindedir:

db.MEKANLAR.insert(

{

        YER: {

            type: "Point",

            coordinates: [-72.90, 41.77]

        },

        name: "Central Park",

        SINIF: "Parks"

    }

) 

db.MEKANLAR.insert(

{

        YER: {

            type: "Point",

            coordinates: [-73.908, 43.78]

        },

        AD: "La Guardia Airport",

        SINIF: "Airport"

    }

) 

Bu işlemden sonra da 2dsphere indeks, YER alanı için oluşturulabilir:

db.MEKANLAR.ensureIndex( { YER : "2dsphere" } )

2dSPHERE İNDEKS ALANI İLE BİLEŞİK (COMPOUND) İNDEKS OLUŞTURMA

Bir bileşik indeks alanı, 2dsphere tipi bir indeks alanı ile birlikte geospatial olmayan başka bir indeks alanı da içerebilir. Aşağıdaki örnekte 2dsphere türünde geospatial YER alanı ile birlikte geospatial olmayan SINIF ve AD alanları da bileşik indeks oluşturmakta birlikte kullanılmıştır:

db.MEKANLAR.ensureIndex( { YER : "2dsphere" , SINIF : -1, AD: 1 } )

Burada 1 değerinin artan (ascending) -1 değerinin de azalan (descending) anlamında olduğunu bir kez daha hatırlatalım.

2d türü indeksten farklı olarak bileşik bir 2dsphere indeksinde YER bilgisinin ilk alan olması gerekmez.

ÖRNEK:

db.MEKANLAR.ensureIndex( { SINIF : 1 , YER : "2dsphere" } )

BİR 2dSPHERE İNDEKSİ İLE SORGULAMA (QUERY)

Aşağıda, 2dsphere indeksleri ile desteklenen bir MongoDB içinde sorgulamaların nasıl gerçekleştirilebileceğine dair kalıplar verilmektedir:

BİR ÇOKGEN (POLYGON) İLE SINIRLANMIŞ  GeoJSON NESNELERİ

$geoWithin  operatörü sayesinde bir GeoJSON poligonu içindeki yer verileri ile ilişkili sorgulama gerçekleştirilebilir. Yer verisi, GeoJSON formatında saklanmış olmalıdır. Sorgunun yazılış biçimi, aşağıdaki gibidir:

db.<collection>.find( { <location field> :                          { $geoWithin :                            { $geometry :                              { type : "Polygon" ,                                coordinates : [ <coordinates> ]                       } } } } )

Aşağıdaki örnek, bir GeoJSON çokgeni içindeki bütün nokta ve şekilleri seçiyor:

db.places.find( { loc : { $geoWithin : { $geometry :{ type : "Polygon" ,coordinates : [ [[ 0 , 0 ] ,[ 3 , 6 ] ,[ 6 , 1 ],[ 0 , 0 ]] ]} } } } )

GeoJSON  NESNELERİNİN ARAKESİTLERİ (INTERSECTION)

$geoIntersects operatörü yardımı ile, belirli bir GeoJSON nesnesi ile arakesiti olan bölgeler sorgulanabilir:

db.<collection>.find( { <location field> :{ $geoIntersects :{ $geometry :{ type : "<GeoJSON object type>" ,coordinates : [ <coordinates> ]} } } } )

Aşağıdaki örnek ise coordinates dizisi ile belirlenmiş çokgen ile kesişen bütün nokta ve şekilleri sorgulamaktadır:

db.places.find( { loc :{ $geoIntersects :{ $geometry : { type : "Polygon" ,coordinates: [ [ [ 0 , 0 ] , [ 3 , 6 ] ,[ 6 , 1 ] ,  [ 0 , 0 ]  ] ] } } } } )

BİR GeoJSON  NOKTASINA YAKINLIK

Yakınlık (proximity) sorguları verilen bir noktaya en yakın olan noktaları bulur ve bunları uzaklıklarına göre sıralı olarak listeler.

Bir GeoJSON verisi üzerindeki uzaklık sorgusu,2dsphere türü bir indeksin oluşturulmasını gerekli kılar.

GeoJSON noktasına yakınlık sorgusu için, MongoDB, $near  operatörünü ya da geoNear komutunu kullanır.Uzaklıklar metre cinsindendir.

$near operatörü aşağıdaki yazılış biçimini kullanmaktadır:

db.<collection>.find( { <location field> :{ $near :{ $geometry : { type : "Point" , coordinates : [ <longitude> , <latitude> ] } , $maxDistance : <distance in meters> } } } )

geoNear komutu ise aşağıdaki yazılış biçiminde kullanılır:

db.runCommand( { geoNear : <collection> ,near : { type : "Point" , coordinates: [ <longitude>, <latitude> ] } ,spherical : true } )

geoNear komutunun, $near operatörüne göre daha çok seçeneği vardır ve daha çok bilgi gönderir.

BİR KÜRE ÜZERİNDEKİ BİR DAİRE İÇİNDEKİ NOKTALAR

Bir küre üzerindeki bir küresel kep (spherical cap) içindeki tüm grid koordinatlarını seçmek için $geoWithin operatörünü $centerSphere operatörü ile birlikte kullanmalısınız. Aşağıdaki bilgileri içeren bir dizi (array) oluşturunuz:

a)Dairenin merkezine ait grid koordinatları

b)Radyan cinsinden ölçülmüş dairenin yarıçapı.

Aşağıdaki yazılış biçimini kullanmalısınız:

db.<collection>.find( { <location field> :{ $geoWithin :{ $centerSphere :[ [ <x>, <y> ] , <radius> ] } } } )

KÜRESEL GEOMETRİYİ KULLANARAK UZAKLIK HESAPLAMAK

Verinizde boylam ve enlem bilgileri varsa,küresel hesaplamalar yapmak için 2dsphere indekslerini devreye sokmanız gerekir.

2d indeksleri,Öklid(Euclidean) düzleminde uzaklıkları hesaplayan sorgular gerçekleştirebilir.

Küresel geometriyi kullanarak uzaklıklar hesaplamak içinse aşağıdaki operator ve komutlar kullanılır:

$nearSphere

$centerSphere

$near

geoNear  { spherical: true } opsiyonu ile

UZAKLIĞI RADYANA DÖNÜŞTÜRME:

Radyan=Uzaklık/Yarıçap

Bağıntısı kullanılır. Uzaklık ve yarıçap aynı birimde olmalıdır. Dünya üzerinde işlem yapılıyorsa doğal olarak yarıçap dünyanın yarıçapıdır.

RADYANI UZAKLIĞA DÖNÜŞTÜRMEK

Uzaklık=Radyan*Yarıçap

Dünyanın yarıçapı yaklaşık olarak   r=3959 mil  ya da r=6731 km’dir.

Aşağıdaki örnekte merkezi -76,45.00 ve yarıçapı r=110 mil olarak tanımlanmış  daire içinde, YERLER adlı koleksiyondaki belgeler sorgulanmaktadır:

db.YERLER.find( { loc: { $geoWithin: { $centerSphere: [ [ -76, 45.00 ],110 / 3959 ] } } } )

Aşağı sorgu ile de YERLER adlı koleksiyonda, -75,45 merkezli ve 110 mil yarıçaplı bir bölgeye ait belgeler listelenmektedir:

db.runCommand( { geoNear: "places",near: [ -75, 45 },110/3959], spherical: true})

MESAFE  ÇARPANI

geoNear komutunun distanceMultiplier seçeneği kullanılırsa, MongoDB dönüştürülmüş değerleri gönderir ve uygulama içinde dönüşüme gerek kalmaz.

Aşağıdaki örnekte distanceMultiplier  kullanılmakta ve böylece geoNear komutunun radyan-mesafe dönüşümüne küresel sorgularda gerek kalmamaktadır.

db.runCommand({ geoNear: "YERLER",near: [ -75, 45 ],spherical: true,distanceMultiplier: 3959})