DocumentDB - Hızlı Kılavuz
Bu bölümde, NoSQL ile ilgili temel kavramları kısaca tartışacağız ve veri tabanlarını belgeleyeceğiz. Ayrıca DocumentDB'ye hızlı bir bakış sunacağız.
NoSQL Belge Veritabanı
DocumentDB, Microsoft'un en yeni NoSQL belge veritabanıdır, bu nedenle NoSQL belge veritabanı dediğinizde, NoSQL ve belge veritabanı ile tam olarak neyi kastediyoruz?
SQL, ilişkisel veritabanlarının geleneksel sorgu dili olan Yapılandırılmış Sorgu Dili anlamına gelir. SQL genellikle ilişkisel veritabanları ile eşitlenir.
Bir NoSQL veritabanını ilişkisel olmayan bir veritabanı olarak düşünmek gerçekten daha yararlıdır, bu nedenle NoSQL gerçekten ilişkisel olmayan anlamına gelir.
Aşağıdakiler gibi anahtar değer depolarını içeren farklı NoSQL veritabanı türleri vardır:
- Azure Tablo Depolama.
- Cassandra gibi sütun tabanlı mağazalar.
- NEO4 gibi grafik veritabanları.
- MongoDB ve Azure DocumentDB gibi belge veritabanları.
Azure DocumentDB
Microsoft, resmi olarak 8 Nisan tarihinde Azure DocumentDB başlattı th 2015 ve kesinlikle tipik bir NoSQL belge veritabanı olarak karakterize edilebilir. Büyük ölçüde ölçeklenebilir ve şemasız JSON belgeleriyle çalışır.
DocumentDB, modern mobil ve web uygulamaları için tasarlanmış gerçek bir şema içermeyen NoSQL belge veritabanı hizmetidir.
Ayrıca, tutarlı bir şekilde hızlı okuma ve yazma, şema esnekliği ve bir veritabanını isteğe bağlı olarak kolayca yukarı ve aşağı ölçekleme yeteneği sağlar.
İndekslediği JSON belgeleri için herhangi bir şema varsaymaz veya gerektirmez.
DocumentDB, belge veritabanına eklenir eklenmez belgedeki her özelliği otomatik olarak dizine ekler.
DocumentDB, bir SQL dili kullanarak karmaşık geçici sorgulara olanak tanır ve her belge oluşturulduğu anda anında sorgulanabilir ve belge hiyerarşisinin herhangi bir yerinde herhangi bir özellik üzerinde arama yapabilirsiniz.
DocumentDB - Fiyatlandırma
DocumentDB, bir veritabanı hesabında bulunan koleksiyon sayısına göre faturalandırılır. Her hesabın bir veya daha fazla veritabanı olabilir ve her veritabanı neredeyse sınırsız sayıda koleksiyona sahip olabilir, ancak başlangıçta varsayılan kota 100'dür. Bu kota, Azure desteğiyle iletişime geçilerek kaldırılabilir.
Bir koleksiyon yalnızca bir ölçek birimi değil, aynı zamanda bir maliyet birimidir, bu nedenle DocumentDB'de 10 GB'a kadar depolama kapasitesine sahip koleksiyon başına ödeme yaparsınız.
En azından, belgeleri Azure aboneliğinize göre faturalandırılan aylık yaklaşık 25 ABD dolarına mal olacak bir veritabanında depolamak için bir S1 koleksiyonuna ihtiyacınız olacaktır.
Veritabanınızın boyutu büyüdükçe ve 10 GB'ı aştıkça, ek verileri içerecek başka bir koleksiyon satın almanız gerekecektir.
Her S1 koleksiyonu size saniyede 250 istek birimi verir ve bu yeterli değilse, koleksiyonu bir S2'ye kadar ölçeklendirebilir ve ayda yaklaşık 50 ABD doları karşılığında saniyede 1000 istek birimi alabilirsiniz.
Ayrıca bunu bir S3'e kadar çevirebilir ve ayda yaklaşık 100 ABD doları ödeyebilirsiniz.
DocumentDB bazı çok benzersiz yeteneklerle öne çıkıyor. Azure DocumentDB, aşağıdaki temel özellikleri ve avantajları sunar.
Şema Ücretsiz
İlişkisel bir veritabanında, her tablonun, tablodaki her satırın uyması gereken sütunları ve veri türlerini tanımlayan bir şeması vardır.
Aksine, bir belge veritabanının tanımlanmış bir şeması yoktur ve her belge farklı şekilde yapılandırılabilir.
SQL Sözdizimi
DocumentDB, SQL dilini kullanarak karmaşık geçici sorgulara olanak tanır ve her belge oluşturulduğu anda anında sorgulanabilir. Belge hiyerarşisinin herhangi bir yerindeki herhangi bir özellik üzerinde arama yapabilirsiniz.
Ayarlanabilir Tutarlılık
Tutarlılık, kullanılabilirlik ve gecikme arasında sağlam ödünleşimler yapmanıza olanak tanıyan bazı ayrıntılı, iyi tanımlanmış tutarlılık seviyeleri sağlar.
Tutarlılık ve performans arasında en iyi dengeyi elde etmek için iyi tanımlanmış dört tutarlılık düzeyinden birini seçebilirsiniz. Sorgular ve okuma işlemleri için DocumentDB dört farklı tutarlılık düzeyi sunar -
- Strong
- Bounded-staleness
- Session
- Eventual
Elastik Ölçek
Ölçeklenebilirlik, NoSQL içeren oyunun adıdır ve DocumentDB bunu sunar. DocumentDB ölçeğini zaten kanıtladı.
Office OneNote ve Xbox gibi büyük hizmetler, onlarca terabayt JSON belgesi içeren veritabanları, bir milyondan fazla aktif kullanıcı ve% 99,95 kullanılabilirlik ile tutarlı bir şekilde çalışan DocumentDB tarafından zaten destekleniyor.
Uygulamanız büyüdükçe daha fazla birim oluşturarak DocumentDB'yi tahmin edilebilir performansla esnek bir şekilde ölçekleyebilirsiniz.
Tamamen Yönetilen
DocumentDB, Azure üzerinde çalışan bir hizmet olarak tam olarak yönetilen bulut tabanlı bir platform olarak mevcuttur.
Sizin kurmanız veya yönetmeniz gereken hiçbir şey yok.
Hiçbir sunucu, kablo, işletim sistemi ya da güncelleme yok, kurulacak replikalar yok.
Microsoft tüm bunları yapar ve hizmetin çalışmaya devam etmesini sağlar.
Kelimenin tam anlamıyla dakikalar içinde, yalnızca bir tarayıcı ve bir Azure aboneliği kullanarak DocumentDB ile çalışmaya başlayabilirsiniz.
Microsoft, SQL Server'ı da içeren ücretsiz bir Visual Studio sürümü sağlar ve şu adresten indirilebilir: https://www.visualstudio.com
Kurulum
Step 1- İndirme tamamlandığında, yükleyiciyi çalıştırın. Aşağıdaki iletişim kutusu görüntülenecektir.
Step 2 - Kur düğmesine tıklayın ve kurulum sürecini başlatacaktır.
Step 3 - Kurulum işlemi başarıyla tamamlandığında aşağıdaki iletişim kutusunu göreceksiniz.
Step 4 - Bu iletişim kutusunu kapatın ve gerekirse bilgisayarınızı yeniden başlatın.
Step 5- Şimdi, aşağıdaki iletişim kutusunu açacak olan Başlat Menüsünden Visual Studio'yu açın. İlk kez sadece hazırlık için biraz zaman alacaktır.
Her şey bittiğinde, Visual Studio'nun ana penceresini göreceksiniz.
Step 6 - Dosya → Yeni → Proje'den yeni bir proje oluşturalım.
Step 7 - Konsol Uygulaması'nı seçin, Ad alanına DocumentDBDemo yazın ve Tamam düğmesine tıklayın.
Step 8 - Çözüm Gezgini'nde projenize sağ tıklayın.
Step 9 - Aşağıdaki pencereyi Visual Studio'da açacak olan NuGet Paketlerini Yönet'i seçin ve Çevrimiçi Ara giriş kutusunda DocumentDB İstemci Kitaplığı'nı arayın.
Step 10 - Kur düğmesine tıklayarak en son sürümü yükleyin.
Step 11- "Kabul Ediyorum" u tıklayın. Kurulum tamamlandığında, mesajı çıktı pencerenizde göreceksiniz.
Artık başvurunuzu başlatmaya hazırsınız.
Microsoft Azure DocumentDB'yi kullanmak için bir DocumentDB hesabı oluşturmanız gerekir. Bu bölümde, Azure portalını kullanarak bir DocumentDB hesabı oluşturacağız.
Step 1 - Çevrimiçi oturum açın https://portal.azure.com Zaten bir Azure aboneliğiniz varsa, aksi takdirde önce oturum açmanız gerekir.
Ana Kontrol Panelini göreceksiniz. Tamamen özelleştirilebilir, böylece bu döşemeleri istediğiniz şekilde düzenleyebilir, yeniden boyutlandırabilir, sık kullandığınız veya artık yapmadığınız şeyler için döşeme ekleyip kaldırabilirsiniz.
Step 2 - Sayfanın sol üst tarafındaki 'Yeni' seçeneğini seçin.
Step 3 - Şimdi Veri + Depolama> Azure DocumentDB seçeneğini seçin ve aşağıdaki Yeni DocumentDB hesabı bölümünü göreceksiniz.
.Documents.azure.com ile birlikte DocumentDB hesabımız için herkese açık olarak adreslenebilir uç nokta olan, küresel olarak benzersiz bir ad (ID) bulmamız gerekiyor. Bu hesabın altında oluşturduğumuz tüm veritabanlarına bu uç nokta kullanılarak internet üzerinden erişilebilir.
Step 4 - Onu azuredocdbdemo olarak adlandıralım ve Kaynak Grubu → new_resource seçeneğine tıklayalım.
Step 5- Konumu, yani bu hesabın barındırılmasını istediğiniz Microsoft veri merkezini seçin. Konumu seçin ve bölgenizi seçin.
Step 6 - Gösterge tablosuna sabitle onay kutusunu işaretleyin ve devam edin ve Oluştur düğmesini tıklayın.
Kutucuğun Gösterge Tablosuna zaten eklendiğini ve hesabın oluşturulmakta olduğunu bize bildirdiğini görebilirsiniz. DocumentDB uç noktayı tahsis ederken, kopyaları hazırlarken ve arka planda diğer işleri gerçekleştirirken, yeni bir hesap için işleri ayarlamak aslında birkaç dakika sürebilir.
Tamamlandığında, kontrol panelini göreceksiniz.
Step 7 - Şimdi oluşturulan DocumentDB hesabına tıklayın ve aşağıdaki görüntü gibi detaylı bir ekran göreceksiniz.
DocumentDB'ye karşı programlamaya başladığınızda, ilk adım bağlanmaktır. Yani DocumentDB hesabınıza bağlanmak için iki şeye ihtiyacınız olacak;
- Endpoint
- Yetkilendirme Anahtarı
Uç nokta
Uç nokta, DocumentDB hesabınızın URL'sidir ve DocumentDB hesap adınız .documents.azure.com ile birleştirilerek oluşturulur. Dashboard'a gidelim.
Şimdi, oluşturulan DocumentDB hesabına tıklayın. Ayrıntıları aşağıdaki resimde gösterildiği gibi göreceksiniz.
'Tuşlar' seçeneğini seçtiğinizde, aşağıdaki resimde gösterildiği gibi ek bilgiler gösterecektir. Ayrıca, uç noktanız olarak kullanabileceğiniz DocumentDB hesabınızın URL'sini de göreceksiniz.
Yetkilendirme Anahtarı
Yetkilendirme anahtarı, kimlik bilgilerinizi içerir ve iki tür anahtar vardır. Ana anahtar, hesap içindeki tüm kaynaklara tam erişim sağlarken, kaynak belirteçleri belirli kaynaklara sınırlı erişime izin verir.
Ana Anahtarlar
Ana anahtarla yapamayacağın hiçbir şey yok. Ana anahtarı kullanarak, isterseniz tüm veritabanınızı uçurabilirsiniz.
Bu nedenle, ana anahtarı kesinlikle paylaşmak veya istemci ortamlarına dağıtmak istemezsiniz. Ek bir güvenlik önlemi olarak, sık sık değiştirmek iyi bir fikirdir.
Aslında her veritabanı hesabı için iki ana anahtar vardır; yukarıdaki ekran görüntüsünde vurgulandığı gibi birincil ve ikincil.
Kaynak Jetonları
Ana anahtar yerine kaynak belirteçlerini de kullanabilirsiniz.
Kaynak belirteçlerine dayalı bağlantılar yalnızca belirteçler tarafından belirtilen kaynaklara erişebilir, diğer kaynaklara erişemez.
Kaynak belirteçleri kullanıcı izinlerine dayalıdır, bu nedenle önce bir veya daha fazla kullanıcı oluşturursunuz ve bunlar veritabanı düzeyinde tanımlanır.
Her kullanıcının erişmesine izin vermek istediğiniz kaynaklara bağlı olarak, her kullanıcı için bir veya daha fazla izin oluşturursunuz.
Her izin, belirli bir kaynağa salt okunur veya tam erişime izin veren ve veritabanı içindeki herhangi bir kullanıcı kaynağı olabilen bir kaynak belirteci oluşturur.
Bölüm 3'te oluşturulan konsol uygulamasına geçelim.
Step 1 - Program.cs dosyasına aşağıdaki referansları ekleyin.
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
Step 2- Şimdi Uç Nokta URL'si ve Yetkilendirme anahtarı ekleyin. Bu örnekte, Yetkilendirme anahtarı olarak birincil anahtarı kullanacağız.
Sizin durumunuzda hem Uç Nokta URL'si hem de yetkilendirme anahtarının farklı olması gerektiğini unutmayın.
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey =
"BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
Step 3 - CreateDocumentClient adlı eşzamansız görevde DocumentClient'in yeni bir örneğini oluşturun ve yeni DocumentClient örneğini oluşturun.
Step 4 - Asenkron görevinizi Ana yönteminizden çağırın.
Şimdiye kadarki tam Program.cs dosyası aşağıdadır.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);
}
}
}
Bu bölümde, bir DocumentDB hesabına nasıl bağlanılacağını ve DocumentClient sınıfının bir örneğini nasıl oluşturacağımızı öğrendik.
Bu bölümde, nasıl veritabanı oluşturulacağını öğreneceğiz. Microsoft Azure DocumentDB'yi kullanmak için bir DocumentDB hesabına, veritabanına, koleksiyona ve belgelere sahip olmanız gerekir. Zaten bir DocumentDB hesabımız var, şimdi veritabanı oluşturmak için iki seçeneğimiz var -
- Microsoft Azure Portal veya
- .Net SDK
Microsoft Azure Portal'ı kullanarak DocumentDB için bir Veritabanı oluşturun
Portalı kullanarak bir veritabanı oluşturmak için aşağıdaki adımlar verilmiştir.
Step 1 - Azure portalına giriş yapın ve panoyu göreceksiniz.
Step 2 - Şimdi oluşturulan DocumentDB hesabına tıklayın ve aşağıdaki ekran görüntüsünde gösterildiği gibi ayrıntıları göreceksiniz.
Step 3 - Veritabanı Ekle seçeneğini seçin ve veritabanınız için kimlik girin.
Step 4 - Tamam'ı tıklayın.
Veritabanının eklendiğini görebilirsiniz. Şu anda koleksiyonu yok, ancak daha sonra JSON belgelerimizi depolayacak konteynerler olan koleksiyonları ekleyebiliriz. Hem bir kimliği hem de bir Kaynak Kimliği olduğuna dikkat edin.
.Net SDK Kullanarak DocumentDB için Veritabanı Oluşturma
.Net SDK kullanarak bir veritabanı oluşturmak için aşağıdaki adımlar verilmiştir.
Step 1 - Son bölümden Visual Studio'da Konsol Uygulamasını açın.
Step 2- Yeni bir veritabanı nesnesi oluşturarak yeni veritabanını oluşturun. Yeni bir veritabanı oluşturmak için, yalnızca CreateDatabase görevinde "mynewdb" olarak ayarladığımız Id özelliğini atamamız gerekir.
private async static Task CreateDatabase(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("******** Create Database *******");
var databaseDefinition = new Database { Id = "mynewdb" };
var result = await client.CreateDatabaseAsync(databaseDefinition);
var database = result.Resource;
Console.WriteLine(" Database Id: {0}; Rid: {1}", database.Id, database.ResourceId);
Console.WriteLine("******** Database Created *******");
}
Step 3- Şimdi bu databaseDefinition'ı CreateDatabaseAsync'e iletin ve Resource özelliğine sahip bir sonucu geri alın. Tüm nesne oluşturma yöntemleri, bu durumda bir veritabanı olan, oluşturulan öğeyi açıklayan bir Kaynak özelliği döndürür.
Yeni veritabanı nesnesini Resource özelliğinden alırız ve DocumentDB'nin kendisine atadığı Kaynak Kimliği ile birlikte Konsolda görüntülenir.
Step 4 - Şimdi DocumentClient başlatıldıktan sonra CreateDocumentClient görevinden CreateDatabase görevini çağırın.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await CreateDatabase(client);
}
Şimdiye kadarki tam Program.cs dosyası aşağıdadır.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await CreateDatabase(client);
}
}
private async static Task CreateDatabase(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("******** Create Database *******");
var databaseDefinition = new Database { Id = "mynewdb" };
var result = await client.CreateDatabaseAsync(databaseDefinition);
var database = result.Resource;
Console.WriteLine(" Database Id: {0}; Rid: {1}", database.Id, database.ResourceId);
Console.WriteLine("******** Database Created *******");
}
}
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, Veritabanı ve Kaynak Kimliklerini içeren aşağıdaki çıktıyı alırsınız.
******** Create Database *******
Database Id: mynewdb; Rid: ltpJAA==
******** Database Created *******
Şimdiye kadar DocumentDB hesabımızda iki veri tabanı oluşturduk, birincisi Azure portalı, ikinci veri tabanı .Net SDK kullanılarak oluşturuldu. Şimdi bu veritabanlarını görüntülemek için Azure portalını kullanabilirsiniz.
Azure portalında DocumentDB hesabınıza gidin ve şimdi iki veritabanı göreceksiniz.
Ayrıca .Net SDK kullanarak kodunuzdaki veritabanlarını görüntüleyebilir veya listeleyebilirsiniz. İlgili adımlar aşağıdadır.
Step 1 - Tam bir liste döndüren parametresiz bir veritabanı Sorgusu yayınlayın, ancak belirli bir veritabanını veya belirli veritabanlarını aramak için bir sorgu da iletebilirsiniz.
private static void GetDatabases(DocumentClient client) {
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("******** Get Databases List ********");
var databases = client.CreateDatabaseQuery().ToList();
foreach (var database in databases) {
Console.WriteLine(" Database Id: {0}; Rid: {1}", database.Id, database.ResourceId);
}
Console.WriteLine();
Console.WriteLine("Total databases: {0}", databases.Count);
}
Koleksiyonları, belgeleri, kullanıcıları ve diğer kaynakları bulmak için bu CreateQuery yöntemlerinden birkaçı olduğunu göreceksiniz. Bu yöntemler aslında sorguyu yürütmez, sadece sorguyu tanımlar ve yinelenebilir bir nesne döndürür.
Sorguyu gerçekten yürüten, sonuçları yineleyen ve bunları bir listede döndüren ToList () çağrısıdır.
Step 2 - DocumentClient başlatıldıktan sonra CreateDocumentClient görevinden GetDatabases yöntemini çağırın.
Step 3 - Ayrıca CreateDatabase görevine yorum yapmanız veya veritabanı kimliğini değiştirmeniz gerekir, aksi takdirde veritabanının var olduğuna dair bir hata mesajı alırsınız.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
//await CreateDatabase(client);
GetDatabases(client);
}
Şimdiye kadarki tam Program.cs dosyası aşağıdadır.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await CreateDatabase(client);
GetDatabases(client);
}
}
private async static Task CreateDatabase(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("******** Create Database *******");
var databaseDefinition = new Database { Id = "mynewdb" };
var result = await client.CreateDatabaseAsync(databaseDefinition);
var database = result.Resource;
Console.WriteLine(" Database Id: {0}; Rid: {1}", database.Id, database.ResourceId);
Console.WriteLine("******** Database Created *******");
}
private static void GetDatabases(DocumentClient client) {
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("******** Get Databases List ********");
var databases = client.CreateDatabaseQuery().ToList();
foreach (var database in databases) {
Console.WriteLine(" Database Id: {0}; Rid: {1}",
database.Id, database.ResourceId);
}
Console.WriteLine();
Console.WriteLine("Total databases: {0}", databases.Count);
}
}
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, her iki veritabanının Veritabanı ve Kaynak Kimliklerini içeren aşağıdaki çıktıyı alırsınız. Sonunda toplam veritabanı sayısını da göreceksiniz.
******** Get Databases List ********
Database Id: myfirstdb; Rid: Ic8LAA==
Database Id: mynewdb; Rid: ltpJAA==
Total databases: 2
Net SDK kullanarak portaldan ve koddan bir veritabanı veya veritabanları bırakabilirsiniz. Burada, bir veritabanının DocumentDB'ye nasıl bırakılacağını adım adım tartışacağız.
Step 1- Azure portalında DocumentDB hesabınıza gidin. Demo amacıyla, aşağıdaki ekran görüntüsünde görüldüğü gibi iki veritabanı daha ekledim.
Step 2- Herhangi bir veritabanını bırakmak için o veritabanına tıklamanız gerekir. Tempdb'yi seçelim, sonraki sayfada göreceksiniz, 'Veritabanını Sil' seçeneğini seçin.
Step 3 - Onay mesajını gösterecek, şimdi 'Evet' düğmesine tıklayın.
Tempdb'nin artık gösterge tablonuzda bulunmadığını göreceksiniz.
Ayrıca .Net SDK kullanarak veritabanlarını kodunuzdan silebilirsiniz. Aşağıdakiler yapmak için adımlar.
Step 1 - Silmek istediğimiz veritabanının ID'sini belirterek veritabanını silelim, ancak SelfLink'e ihtiyacımız var.
Step 2 - CreateDatabaseQuery'yi daha önce olduğu gibi çağırıyoruz, ancak bu sefer aslında tempdb1 kimliğine sahip tek bir veritabanını döndürmek için bir sorgu sağlıyoruz.
private async static Task DeleteDatabase(DocumentClient client) {
Console.WriteLine("******** Delete Database ********");
Database database = client
.CreateDatabaseQuery("SELECT * FROM c WHERE c.id = 'tempdb1'")
.AsEnumerable()
.First();
await client.DeleteDatabaseAsync(database.SelfLink);
}
Step 3- Bu sefer ToList () yerine AsEnumerable'ı çağırabiliriz çünkü aslında bir liste nesnesine ihtiyacımız yok. Yalnızca sonuç beklenirken, First () ile sorgu tarafından döndürülen ilk veritabanı nesnesini alabilmemiz için AsEnumerable'ı çağırmak yeterlidir. Bu tempdb1 için veritabanı nesnesidir ve veritabanını silen DeleteDatabaseAsync'i çağırmak için kullanabileceğimiz bir SelfLink'e sahiptir.
Step 4 - DocumentClient başlatıldıktan sonra CreateDocumentClient görevinden DeleteDatabase görevini de çağırmanız gerekir.
Step 5 - Belirtilen veritabanını sildikten sonra veritabanları listesini görüntülemek için GetDatabases yöntemini tekrar çağıralım.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
//await CreateDatabase(client);
GetDatabases(client);
await DeleteDatabase(client);
GetDatabases(client);
}
Şimdiye kadarki tam Program.cs dosyası aşağıdadır.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
//await CreateDatabase(client);
GetDatabases(client);
await DeleteDatabase(client);
GetDatabases(client);
}
}
private async static Task CreateDatabase(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("******** Create Database *******");
var databaseDefinition = new Database { Id = "mynewdb" };
var result = await client.CreateDatabaseAsync(databaseDefinition);
var database = result.Resource;
Console.WriteLine(" Database Id: {0}; Rid: {1}",
database.Id, database.ResourceId);
Console.WriteLine("******** Database Created *******");
}
private static void GetDatabases(DocumentClient client) {
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("******** Get Databases List ********");
var databases = client.CreateDatabaseQuery().ToList();
foreach (var database in databases) {
Console.WriteLine(" Database Id: {0}; Rid: {1}", database.Id,
database.ResourceId);
}
Console.WriteLine();
Console.WriteLine("Total databases: {0}", databases.Count);
}
private async static Task DeleteDatabase(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("******** Delete Database ********");
Database database = client
.CreateDatabaseQuery("SELECT * FROM c WHERE c.id = 'tempdb1'")
.AsEnumerable()
.First();
await client.DeleteDatabaseAsync(database.SelfLink);
}
}
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, üç veritabanının Veritabanı ve Kaynak Kimliklerini ve toplam veritabanı sayısını içeren aşağıdaki çıktıyı alırsınız.
******** Get Databases List ********
Database Id: myfirstdb; Rid: Ic8LAA==
Database Id: mynewdb; Rid: ltpJAA==
Database Id: tempdb1; Rid: 06JjAA==
Total databases: 3
******** Delete Database ********
******** Get Databases List ********
Database Id: myfirstdb; Rid: Ic8LAA==
Database Id: mynewdb; Rid: ltpJAA==
Total databases: 2
Veritabanını sildikten sonra, sonunda DocumentDB hesabında sadece iki veritabanının kaldığını göreceksiniz.
Bu bölümde, nasıl koleksiyon oluşturacağımızı öğreneceğiz. Veritabanı oluşturmaya benzer. Portaldan veya .Net SDK kullanarak koddan bir koleksiyon oluşturabilirsiniz.
Step 1 - Azure portalında ana panele gidin.
Step 2 - Veritabanları listesinden myfirstdb'yi seçin.
Step 3- 'Koleksiyon Ekle' seçeneğini tıklayın ve koleksiyon için kimliği belirtin. Farklı seçenek için Fiyatlandırma Katmanını seçin.
Step 4 - S1 Standard'ı seçelim ve Seç → Tamam butonuna tıklayalım.
Gördüğünüz gibi, MyCollection, myfirstdb'ye eklendi.
Net SDK kullanarak koddan da koleksiyon oluşturabilirsiniz. Koddan koleksiyon eklemek için aşağıdaki adımlara bir göz atalım.
Step 1 - Visual Studio'da Konsol uygulamasını açın.
Step 2 - Bir koleksiyon oluşturmak için, önce Myfirstdb veritabanını CreateDocumentClient görevindeki kimliğine göre alın.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
await CreateCollection(client, "MyCollection1");
await CreateCollection(client, "MyCollection2", "S2");
}
}
Aşağıdaki, CreateCollection görevinin uygulamasıdır.
private async static Task CreateCollection(DocumentClient client, string collectionId,
string offerType = "S1") {
Console.WriteLine();
Console.WriteLine("**** Create Collection {0} in {1} ****", collectionId, database.Id);
var collectionDefinition = new DocumentCollection { Id = collectionId };
var options = new RequestOptions { OfferType = offerType };
var result = await client.CreateDocumentCollectionAsync(database.SelfLink,
collectionDefinition, options);
var collection = result.Resource;
Console.WriteLine("Created new collection");
ViewCollection(collection);
}
Yeni koleksiyonu, CreateDocumentCollectionAsync yöntemi için istenen Id ile tanımlayan yeni bir DocumentCollection nesnesi oluşturuyoruz; bu aynı zamanda yeni koleksiyonun performans katmanını ayarlamak için burada kullandığımız bir options parametresini de kabul eder, bu da offerType.
Bu varsayılan S1'dir ve bir offerType'ı, MyCollection1 için geçmediğimizden, bu bir S1 koleksiyonu olacak ve MyCollection2 için, bunu yukarıda gösterildiği gibi bir S2 yapan S2'yi geçtik.
ViewCollection yönteminin uygulaması aşağıdadır.
private static void ViewCollection(DocumentCollection collection) {
Console.WriteLine("Collection ID: {0} ", collection.Id);
Console.WriteLine("Resource ID: {0} ", collection.ResourceId);
Console.WriteLine("Self Link: {0} ", collection.SelfLink);
Console.WriteLine("Documents Link: {0} ", collection.DocumentsLink);
Console.WriteLine("UDFs Link: {0} ", collection.UserDefinedFunctionsLink);
Console.WriteLine(" StoredProcs Link: {0} ", collection.StoredProceduresLink);
Console.WriteLine("Triggers Link: {0} ", collection.TriggersLink);
Console.WriteLine("Timestamp: {0} ", collection.Timestamp);
}
Aşağıda, koleksiyonlar için program.cs dosyasının tam uygulaması verilmiştir.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
private static Database database;
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
await CreateCollection(client, "MyCollection1");
await CreateCollection(client, "MyCollection2", "S2");
//await CreateDatabase(client);
//GetDatabases(client);
//await DeleteDatabase(client);
//GetDatabases(client);
}
}
private async static Task CreateCollection(DocumentClient client,
string collectionId, string offerType = "S1") {
Console.WriteLine();
Console.WriteLine("**** Create Collection {0} in {1} ****", collectionId,
database.Id);
var collectionDefinition = new DocumentCollection { Id = collectionId };
var options = new RequestOptions { OfferType = offerType };
var result = await
client.CreateDocumentCollectionAsync(database.SelfLink,
collectionDefinition, options);
var collection = result.Resource;
Console.WriteLine("Created new collection");
ViewCollection(collection);
}
private static void ViewCollection(DocumentCollection collection) {
Console.WriteLine("Collection ID: {0} ", collection.Id);
Console.WriteLine("Resource ID: {0} ", collection.ResourceId);
Console.WriteLine("Self Link: {0} ", collection.SelfLink);
Console.WriteLine("Documents Link: {0} ", collection.DocumentsLink);
Console.WriteLine("UDFs Link: {0} ", collection.UserDefinedFunctionsLink);
Console.WriteLine("StoredProcs Link: {0} ", collection.StoredProceduresLink);
Console.WriteLine("Triggers Link: {0} ", collection.TriggersLink);
Console.WriteLine("Timestamp: {0} ", collection.Timestamp);
}
}
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, koleksiyonla ilgili tüm bilgileri içeren aşağıdaki çıktıyı alacaksınız.
**** Create Collection MyCollection1 in myfirstdb ****
Created new collection
Collection ID: MyCollection1
Resource ID: Ic8LAPPvnAA=
Self Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/
Documents Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/docs/
UDFs Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/udfs/
StoredProcs Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/sprocs/
Triggers Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/triggers/
Timestamp: 12/10/2015 4:55:36 PM
**** Create Collection MyCollection2 in myfirstdb ****
Created new collection
Collection ID: MyCollection2
Resource ID: Ic8LAKGHDwE=
Self Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/
Documents Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/docs/
UDFs Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/udfs/
StoredProcs Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/sprocs/
Triggers Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/triggers/
Timestamp: 12/10/2015 4:55:38 PM
Koleksiyonu veya koleksiyonları bırakmak için aynısını .Net SDK kullanarak hem portaldan hem de koddan yapabilirsiniz.
Step 1- Azure portalında DocumentDB hesabınıza gidin. Demo amacıyla, aşağıdaki ekran görüntüsünde görüldüğü gibi iki koleksiyon daha ekledim.
Step 2- Herhangi bir koleksiyonu bırakmak için o koleksiyona tıklamanız gerekir. TempCollection1'i seçelim. Aşağıdaki sayfayı göreceksiniz, 'Koleksiyonu Sil' seçeneğini seçin.
Step 3- Onay mesajını gösterecektir. Şimdi 'Evet' düğmesine tıklayın.
TempCollection1'in artık gösterge tablonuzda bulunmadığını göreceksiniz.
Ayrıca .Net SDK kullanarak koleksiyonlarınızı kodunuzdan silebilirsiniz. Bunu yapmak için aşağıdaki adımlar şunlardır.
Step 1 - Silmek istediğimiz koleksiyonun ID'sini belirterek koleksiyonu silelim.
Bu, bir kaynağı silmek için gereken selflink'leri elde etmek için Id ile sorgulamanın olağan modelidir.
private async static Task DeleteCollection(DocumentClient client, string collectionId) {
Console.WriteLine();
Console.WriteLine("**** Delete Collection {0} in {1} ****", collectionId, database.Id);
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection {
new SqlParameter {
Name = "@id", Value = collectionId
}
}
};
DocumentCollection collection = client.CreateDocumentCollectionQuery(database.SelfLink,
query).AsEnumerable().First();
await client.DeleteDocumentCollectionAsync(collection.SelfLink);
Console.WriteLine("Deleted collection {0} from database {1}", collectionId,
database.Id);
}
Burada parametreleştirilmiş bir sorgu oluşturmanın tercih edilen yolunu görüyoruz. CollectionId'yi kodlamıyoruz, bu nedenle bu yöntem herhangi bir koleksiyonu silmek için kullanılabilir. Id parametresinin bu SqlQuerySpec parametresinin özelliğine atanan bu SqlParameterCollection içinde tanımlandığı Id'ye göre belirli bir koleksiyon için sorguluyoruz.
Daha sonra SDK, içine gömülü collectionId ile DocumentDB için son sorgu dizesini oluşturma işini yapar.
Step 2 - Sorguyu çalıştırın ve ardından koleksiyonu CreateDocumentClient görevinden silmek için SelfLink'i kullanın.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
await DeleteCollection(client, "TempCollection");
}
}
Aşağıda Program.cs dosyasının tam uygulaması verilmiştir.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;
namespace DocumentDBDemo {
class Program {
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey = "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/
StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
private static Database database;
static void Main(string[] args) {
try {
CreateDocumentClient().Wait();
} catch (Exception e) {
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
Console.ReadKey();
}
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
await DeleteCollection(client, "TempCollection");
//await CreateCollection(client, "MyCollection1");
//await CreateCollection(client, "MyCollection2", "S2");
////await CreateDatabase(client);
//GetDatabases(client);
//await DeleteDatabase(client);
//GetDatabases(client);
}
}
private async static Task CreateCollection(DocumentClient client,
string collectionId, string offerType = "S1") {
Console.WriteLine();
Console.WriteLine("**** Create Collection {0} in {1} ****", collectionId,
database.Id);
var collectionDefinition = new DocumentCollection { Id = collectionId };
var options = new RequestOptions { OfferType = offerType };
var result = await client.CreateDocumentCollectionAsync(database.SelfLink,
collectionDefinition, options);
var collection = result.Resource;
Console.WriteLine("Created new collection");
ViewCollection(collection);
}
private static void ViewCollection(DocumentCollection collection) {
Console.WriteLine("Collection ID: {0} ", collection.Id);
Console.WriteLine("Resource ID: {0} ", collection.ResourceId);
Console.WriteLine("Self Link: {0} ", collection.SelfLink);
Console.WriteLine("Documents Link: {0} ", collection.DocumentsLink);
Console.WriteLine("UDFs Link: {0} ", collection.UserDefinedFunctionsLink);
Console.WriteLine("StoredProcs Link: {0} ", collection.StoredProceduresLink);
Console.WriteLine("Triggers Link: {0} ", collection.TriggersLink);
Console.WriteLine("Timestamp: {0} ", collection.Timestamp);
}
private async static Task DeleteCollection(DocumentClient client,
string collectionId) {
Console.WriteLine();
Console.WriteLine("**** Delete Collection {0} in {1} ****", collectionId,
database.Id);
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id", Parameters = new
SqlParameterCollection {
new SqlParameter {
Name = "@id", Value = collectionId
}
}
};
DocumentCollection collection = client.CreateDocumentCollectionQuery
(database.SelfLink, query).AsEnumerable().First();
await client.DeleteDocumentCollectionAsync(collection.SelfLink);
Console.WriteLine("Deleted collection {0} from database {1}", collectionId,
database.Id);
}
}
}
Yukarıdaki kod derlenip çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Delete Collection TempCollection in myfirstdb ****
Deleted collection TempCollection from database myfirstdb
Bu bölümde, bir koleksiyondaki gerçek belgelerle çalışacağız. Azure portalı veya .Net SDK kullanarak belgeler oluşturabilirsiniz.
Azure Portal ile Belge Oluşturma
Koleksiyonunuza belge eklemek için aşağıdaki adımlara bir göz atalım.
Step 1 - Myfirstdb'ye yeni koleksiyon Aileleri S1 fiyatlandırma katmanını ekleyin.
Step 2 - Aile koleksiyonunu seçin ve Yeni Belge dikey penceresini açmak için Belge Oluştur seçeneğine tıklayın.
Bu, yeni bir belge için herhangi bir JSON yazmanıza izin veren basit bir metin düzenleyicidir.
Step 3 - Bu ham veri girişi olduğu için ilk belgemize girelim.
{
"id": "AndersenFamily",
"lastName": "Andersen",
"parents": [
{ "firstName": "Thomas", "relationship": "father" },
{ "firstName": "Mary Kay", "relationship": "mother" }
],
"children": [
{
"firstName": "Henriette Thaulow",
"gender": "female",
"grade": 5,
"pets": [ { "givenName": "Fluffy", "type": "Rabbit" } ]
}
],
"location": { "state": "WA", "county": "King", "city": "Seattle"},
"isRegistered": true
}
Yukarıdaki belgeye girdiğinizde karşınıza aşağıdaki ekran çıkacaktır.
Belge için bir kimlik sağladığımıza dikkat edin. İd değeri her zaman gereklidir ve aynı koleksiyondaki diğer tüm belgelerde benzersiz olmalıdır. Bunu dışarıda bıraktığınızda, DocumentDB bir GUID veya Küresel Olarak Benzersiz Tanımlayıcı kullanarak sizin için otomatik olarak bir tane oluşturur.
Kimlik her zaman bir dizedir ve sayı, tarih, Boole veya başka bir nesne olamaz ve 255 karakterden uzun olamaz.
Ayrıca, gerekli id, lastName ve isRegistered gibi birkaç üst düzey özelliğe sahip, ancak aynı zamanda yuvalanmış özelliklere sahip olan belgenin hiyerarşik yapısına da dikkat edin.
Örneğin, parent özelliği, köşeli parantezlerle belirtildiği gibi bir JSON dizisi olarak sağlanır. Bu örnekteki dizide yalnızca bir çocuk olmasına rağmen, çocuklar için de başka bir dizimiz var.
Step 4 - Belgeyi kaydetmek için 'Kaydet' düğmesine tıklayın ve ilk belgemizi oluşturduk.
Gördüğünüz gibi, her mülkün iç içe geçme düzeyini iletmek için her mülkü kendi satırında beyaz boşlukla girintili olarak bölen JSON'umuza güzel biçimlendirme uygulandı.
Portal bir Belge Gezgini içerir, bu yüzden şimdi bunu az önce oluşturduğumuz belgeyi almak için kullanalım.
Step 5- Bir veritabanını ve bu koleksiyondaki belgeleri görüntülemek için veritabanındaki herhangi bir koleksiyonu seçin. Şu anda, her ikisi de açılır menülerde önceden seçilmiş olan, Families adlı bir koleksiyona sahip, myfirstdb adında tek bir veritabanımız var.
Varsayılan olarak, Belge Gezgini, koleksiyon içindeki belgelerin filtrelenmemiş bir listesini görüntüler, ancak herhangi bir belgeyi kimliğe göre veya kısmi bir kimliğin joker karakter aramasına göre birden çok belgeyi de arayabilirsiniz.
Koleksiyonumuzda şu ana kadar tek bir belgemiz var ve kimliğini aşağıdaki ekranda AndersonFamily'de görüyoruz.
Step 6 - Belgeyi görüntülemek için ID'ye tıklayın.
.NET SDK ile Belgeler Oluşturma
Belgelerin sadece başka bir kaynak türü olduğunu bildiğiniz ve SDK'yı kullanarak kaynakları nasıl ele alacağınızı zaten bildiğiniz gibi.
Belgeler ile diğer kaynaklar arasındaki en büyük fark, elbette şemasız olmalarıdır.
Bu nedenle birçok seçenek var. Doğal olarak, yalnızca JSON nesne grafikleri veya hatta JSON metninin ham dizeleri üzerinde çalışabilirsiniz, ancak derleme zamanında bir sınıf tanımlamadan çalışma zamanında özelliklere bağlanmanıza izin veren dinamik nesneleri de kullanabilirsiniz.
Ayrıca gerçek C # nesneleriyle veya çağrıldıkları şekliyle Varlıklar ile çalışabilirsiniz, bunlar iş etki alanı sınıflarınız olabilir.
Net SDK kullanarak döküman oluşturmaya başlayalım. Adımlar aşağıdadır.
Step 1 - DocumentClient'i somutlaştırın, ardından myfirstdb veritabanını ve ardından sınıf boyunca erişilebilir olması için bu özel değişken koleksiyonunda sakladığımız MyCollection koleksiyonunu sorgulayacağız.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
await CreateDocuments(client);
}
}
Step 2 - CreateDocuments görevinde bazı belgeler oluşturun.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
dynamic document1Definition = new {
name = "New Customer 1", address = new {
addressType = "Main Office",
addressLine1 = "123 Main Street",
location = new {
city = "Brooklyn", stateProvinceName = "New York"
}, postalCode = "11229", countryRegionName = "United States"
},
};
Document document1 = await CreateDocument(client, document1Definition);
Console.WriteLine("Created document {0} from dynamic object", document1.Id);
Console.WriteLine();
}
İlk belge bu dinamik nesneden oluşturulacaktır. Bu JSON'a benzeyebilir, ama elbette değil. Bu C # kodu ve gerçek bir .NET nesnesi oluşturuyoruz, ancak sınıf tanımı yok. Bunun yerine, özellikler, nesnenin başlatılma biçiminden çıkarılır.
Bu belge için bir Kimlik özelliği sağlamadığımıza dikkat edin.
Şimdi CreateDocument'e bir göz atalım. Veritabanları ve koleksiyonlar oluşturmak için gördüğümüz modelle aynı görünüyor.
private async static Task<Document> CreateDocument(DocumentClient client,
object documentObject) {
var result = await client.CreateDocumentAsync(collection.SelfLink, documentObject);
var document = result.Resource;
Console.WriteLine("Created new document: {0}\r\n{1}", document.Id, document);
return result;
}
Step 3- Bu sefer CreateDocumentAsync'i çağırarak belgeyi eklemek istediğimiz koleksiyonun SelfLink'ini belirledik. Bu durumda, sistem tarafından oluşturulan özellikleriyle yeni belgeyi temsil eden bir kaynak özelliğine sahip bir yanıtı geri alıyoruz.
Belge nesnesi, SDK'da kaynaktan miras alan tanımlanmış bir sınıftır ve bu nedenle tüm ortak kaynak özelliklerine sahiptir, ancak aynı zamanda şemadan bağımsız belgenin kendisini tanımlayan dinamik özellikleri de içerir.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
dynamic document1Definition = new {
name = "New Customer 1", address = new {
addressType = "Main Office",
addressLine1 = "123 Main Street",
location = new {
city = "Brooklyn", stateProvinceName = "New York"
}, postalCode = "11229", countryRegionName = "United States"
},
};
Document document1 = await CreateDocument(client, document1Definition);
Console.WriteLine("Created document {0} from dynamic object", document1.Id);
Console.WriteLine();
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde aşağıdaki çıktıyı alacaksınız.
**** Create Documents ****
Created new document: 34e9873a-94c8-4720-9146-d63fb7840fad {
"name": "New Customer 1",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn", "stateProvinceName": "New York"
},
"postalCode": "11229", "countryRegionName": "United States"
},
"id": "34e9873a-94c8-4720-9146-d63fb7840fad",
"_rid": "Ic8LAMEUVgACAAAAAAAAAA==",
"_ts": 1449812756,
"_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgACAAAAAAAAAA==/",
"_etag": "\"00001000-0000-0000-0000-566a63140000\"",
"_attachments": "attachments/"
}
Created document 34e9873a-94c8-4720-9146-d63fb7840fad from dynamic object
Gördüğünüz gibi, bir kimlik sağlamadık, ancak DocumentDB bunu bizim için yeni belge için oluşturdu.
DocumentDB'de, belgeleri sorgulamak için aslında SQL kullanıyoruz, bu nedenle bu bölüm tamamen DocumentDB'deki özel SQL sözdizimini kullanarak sorgulama ile ilgili. .NET geliştirme yapıyor olsanız da, kullanılabilecek ve bir LINQ sorgusundan uygun SQL oluşturabilen bir LINQ sağlayıcısı da vardır.
Portalı Kullanarak Belgeyi Sorgulama
Azure portalında, DocumentDB veritabanınızda herhangi bir SQL sorgusu çalıştırmanıza olanak tanıyan bir Sorgu Gezgini bulunur.
Mümkün olan en basit sorgudan başlayarak sorgu dilinin birçok farklı özelliğini ve özelliğini göstermek için Sorgu Gezgini'ni kullanacağız.
Step 1 - Veritabanı dikey penceresinde, Sorgu Gezgini dikey penceresini açmak için tıklayın.
Sorguların bir koleksiyon kapsamında çalıştığını ve bu nedenle Sorgu Gezgini'nin bu açılır menüden koleksiyonu seçmenize izin verdiğini unutmayın.
Step 2 - Portalı kullanarak daha önce oluşturulan Aileler koleksiyonunu seçin.
Sorgu Gezgini, koleksiyondaki tüm belgeleri basitçe alan bu basit SELECT * FROM c sorgusuyla açılır.
Step 3- 'Sorguyu çalıştır' düğmesini tıklayarak bu sorguyu yürütün. Ardından, tüm belgenin Sonuçlar satırında alındığını göreceksiniz.
Net SDK kullanarak Belgeyi Sorgulama
Aşağıda, .Net SDK kullanarak bazı belge sorgularını çalıştırma adımları verilmiştir.
Bu örnekte, yeni eklediğimiz yeni oluşturulmuş belgeleri sorgulamak istiyoruz.
Step 1 - Sorguyu SelfLink ve sorgu metni ile çalıştırmak için koleksiyona geçirerek CreateDocumentQuery'yi çağırın.
private async static Task QueryDocumentsWithPaging(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Query Documents (paged results) ****");
Console.WriteLine();
Console.WriteLine("Quering for all documents");
var sql = "SELECT * FROM c";
var query = client.CreateDocumentQuery(collection.SelfLink, sql).AsDocumentQuery();
while (query.HasMoreResults) {
var documents = await query.ExecuteNextAsync();
foreach (var document in documents) {
Console.WriteLine(" Id: {0}; Name: {1};", document.id, document.name);
}
}
Console.WriteLine();
}
Bu sorgu aynı zamanda tüm koleksiyondaki tüm belgeleri de döndürüyor, ancak daha önce olduğu gibi CreateDocumentQuery'de .ToList'i çağırmıyoruz, bu da tüm sonuçları tek bir kod satırında aşağı çekmek için gereken sayıda istek gönderecektir.
Step 2 - Bunun yerine, AsDocumentQuery'yi çağırın ve bu yöntem HasMoreResults özelliğine sahip bir sorgu nesnesi döndürür.
Step 3 - HasMoreResults true ise, sonraki parçayı almak için ExecuteNextAsync'i çağırın ve ardından bu yığının tüm içeriğini dökümünü alın.
Step 4- Dilerseniz SQL yerine LINQ kullanarak da sorgulama yapabilirsiniz. Burada q'da bir LINQ sorgusu tanımladık, ancak biz üzerinde .ToList çalıştırana kadar çalışmayacaktır.
private static void QueryDocumentsWithLinq(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Query Documents (LINQ) ****");
Console.WriteLine();
Console.WriteLine("Quering for US customers (LINQ)");
var q =
from d in client.CreateDocumentQuery<Customer>(collection.DocumentsLink)
where d.Address.CountryRegionName == " United States"
select new {
Id = d.Id,
Name = d.Name,
City = d.Address.Location.City
};
var documents = q.ToList();
Console.WriteLine("Found {0} UK customers", documents.Count);
foreach (var document in documents) {
var d = document as dynamic;
Console.WriteLine(" Id: {0}; Name: {1}; City: {2}", d.Id, d.Name, d.City);
}
Console.WriteLine();
}
SDK, LINQ sorgumuzu DocumentDB için SQL sözdizimine dönüştürecek ve LINQ sözdizimimize göre bir SELECT ve WHERE yan tümcesi oluşturacaktır.
Step 5 - Şimdi yukarıdaki sorguları CreateDocumentClient görevinden çağırın.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
//await CreateDocuments(client);
await QueryDocumentsWithPaging(client);
QueryDocumentsWithLinq(client);
}
}
Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Query Documents (paged results) ****
Quering for all documents
Id: 7e9ad4fa-c432-4d1a-b120-58fd7113609f; Name: New Customer 1;
Id: 34e9873a-94c8-4720-9146-d63fb7840fad; Name: New Customer 1;
**** Query Documents (LINQ) ****
Quering for US customers (LINQ)
Found 2 UK customers
Id: 7e9ad4fa-c432-4d1a-b120-58fd7113609f; Name: New Customer 1; City: Brooklyn
Id: 34e9873a-94c8-4720-9146-d63fb7840fad; Name: New Customer 1; City: Brooklyn
Bu bölümde belgeleri nasıl güncelleyeceğimizi öğreneceğiz. Azure portalını kullanarak, belgeyi Belge Gezgini'nde açıp bir metin dosyası gibi düzenleyicide güncelleyerek belgeyi kolayca güncelleyebilirsiniz.
"Kaydet" düğmesini tıklayın. Artık .Net SDK kullanarak bir belgeyi değiştirmeniz gerektiğinde, onu değiştirebilirsiniz. Silmenize ve yeniden oluşturmanıza gerek yoktur, bu sıkıcı olmasının yanı sıra, yalnızca bir belgeyi değiştirirken yapmak istemeyeceğiniz kaynak kimliğini de değiştirir. Belgeyi .Net SDK kullanarak güncellemek için aşağıdaki adımlar.
İsNew özelliğinin doğru olduğu belgeleri sorgulayacağımız aşağıdaki ReplaceDocuments görevine bir göz atalım, ancak hiçbiri olmadığı için hiçbiri almayacağız. Öyleyse daha önce eklediğimiz belgeleri, adı Yeni Müşteri ile başlayan belgeleri değiştirelim.
Step 1 - isNew özelliğini bu belgelere ekleyin ve değerini true olarak ayarlayın.
private async static Task ReplaceDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine(">>> Replace Documents <<<");
Console.WriteLine();
Console.WriteLine("Quering for documents with 'isNew' flag");
var sql = "SELECT * FROM c WHERE c.isNew = true";
var documents = client.CreateDocumentQuery(collection.SelfLink, sql).ToList();
Console.WriteLine("Documents with 'isNew' flag: {0} ", documents.Count);
Console.WriteLine();
Console.WriteLine("Quering for documents to be updated");
sql = "SELECT * FROM c WHERE STARTSWITH(c.name, 'New Customer') = true";
documents = client.CreateDocumentQuery(collection.SelfLink, sql).ToList();
Console.WriteLine("Found {0} documents to be updated", documents.Count);
foreach (var document in documents) {
document.isNew = true;
var result = await client.ReplaceDocumentAsync(document._self, document);
var updatedDocument = result.Resource;
Console.WriteLine("Updated document 'isNew' flag: {0}", updatedDocument.isNew);
}
Console.WriteLine();
Console.WriteLine("Quering for documents with 'isNew' flag");
sql = "SELECT * FROM c WHERE c.isNew = true";
documents = client.CreateDocumentQuery(collection.SelfLink, sql).ToList();
Console.WriteLine("Documents with 'isNew' flag: {0}: ", documents.Count);
Console.WriteLine();
}
Step 2 - Aynı STARTSWITH sorgusunu kullanarak güncellenecek belgeleri alın ve bu bize burada dinamik nesneler olarak geri aldığımız belgeleri verir.
Step 3 - isNew özelliğini ekleyin ve her belge için true olarak ayarlayın.
Step 4 - Belgenin SelfLink'ini güncellenmiş belgeyle birlikte ileterek ReplaceDocumentAsync'i çağırın.
Şimdi sadece bunun işe yaradığını kanıtlamak için, isNew'in true olduğu belgeleri sorgulayın. Yukarıdaki sorguları CreateDocumentClient görevinden çağıralım.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
//await CreateDocuments(client);
//QueryDocumentsWithSql(client);
//await QueryDocumentsWithPaging(client);
//QueryDocumentsWithLinq(client);
await ReplaceDocuments(client);
}
}
Yukarıdaki kod derlenip çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Replace Documents ****
Quering for documents with 'isNew' flag
Documents with 'isNew' flag: 0
Quering for documents to be updated
Found 2 documents to be updated
Updated document ‘isNew’ flag: True
Updated document ‘isNew’ flag: True
Quering for documents with 'isNew' flag
Documents with 'isNew' flag: 2
Bu bölümde, DocumentDB hesabınızdan bir belgeyi nasıl sileceğinizi öğreneceğiz. Azure Portal kullanarak, belgeyi Belge Gezgini'nde açıp 'Sil' seçeneğine tıklayarak herhangi bir belgeyi kolayca silebilirsiniz.
Onay mesajını gösterecektir. Şimdi Evet düğmesine basın ve belgenin artık DocumentDB hesabınızda bulunmadığını göreceksiniz.
Şimdi .Net SDK kullanarak bir belgeyi silmek istediğinizde.
Step 1- Her yeni belgenin SelfLink'lerini almak için ilk önce sorgulayacağımız yerde daha önce gördüğümüz modelin aynısı. İhtiyacımız olmayan belgeleri bir bütün olarak döndüren SELECT * 'i burada kullanmıyoruz.
Step 2 - Bunun yerine, bir listeden yalnızca SelfLink'leri seçiyoruz ve ardından koleksiyondaki belgeleri silmek için her bir SelfLink için DeleteDocumentAsync'i birer birer çağırıyoruz.
private async static Task DeleteDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine(">>> Delete Documents <<<");
Console.WriteLine();
Console.WriteLine("Quering for documents to be deleted");
var sql =
"SELECT VALUE c._self FROM c WHERE STARTSWITH(c.name, 'New Customer') = true";
var documentLinks =
client.CreateDocumentQuery<string>(collection.SelfLink, sql).ToList();
Console.WriteLine("Found {0} documents to be deleted", documentLinks.Count);
foreach (var documentLink in documentLinks) {
await client.DeleteDocumentAsync(documentLink);
}
Console.WriteLine("Deleted {0} new customer documents", documentLinks.Count);
Console.WriteLine();
}
Step 3 - Şimdi yukarıdaki DeleteDocuments'ı CreateDocumentClient görevinden çağıralım.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
await DeleteDocuments(client);
}
}
Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
***** Delete Documents *****
Quering for documents to be deleted
Found 2 documents to be deleted
Deleted 2 new customer documents
DocumentDB gibi şemasız veritabanları, veri modelinizdeki değişiklikleri benimsemeyi çok kolaylaştırırken, yine de verileriniz hakkında düşünmek için biraz zaman harcamalısınız.
Çok seçeneğiniz var. Doğal olarak, yalnızca JSON nesne grafikleri veya hatta JSON metninin ham dizeleri üzerinde çalışabilirsiniz, ancak derleme zamanında bir sınıf tanımlamadan çalışma zamanında özelliklere bağlanmanıza izin veren dinamik nesneleri de kullanabilirsiniz.
Ayrıca gerçek C # nesneleriyle veya çağrıldıkları şekliyle Varlıklar ile çalışabilirsiniz, bunlar iş etki alanı sınıflarınız olabilir.
İlişkiler
Belgenin hiyerarşik yapısına bir göz atalım. LastName ve isRegistered gibi gerekli id gibi birkaç üst düzey özelliğe sahiptir, ancak aynı zamanda yuvalanmış özelliklere de sahiptir.
{
"id": "AndersenFamily",
"lastName": "Andersen",
"parents": [
{ "firstName": "Thomas", "relationship": "father" },
{ "firstName": "Mary Kay", "relationship": "mother" }
],
"children": [
{
"firstName": "Henriette Thaulow",
"gender": "female",
"grade": 5,
"pets": [ { "givenName": "Fluffy", "type": "Rabbit" } ]
}
],
"location": { "state": "WA", "county": "King", "city": "Seattle"},
"isRegistered": true
}
Örneğin, parent özelliği, köşeli parantezlerle belirtildiği gibi bir JSON dizisi olarak sağlanır.
Bu örnekteki dizide yalnızca bir çocuk olmasına rağmen, çocuklar için de başka bir dizimiz var. Yani, bir belgede bire çok ilişkinin eşdeğerini böyle modelliyorsunuz.
Dizideki her öğenin basit bir değer veya başka bir karmaşık nesne, hatta başka bir dizi olabileceği dizileri kullanırsınız.
Yani bir ailenin birden çok ebeveyni ve birden çok çocuğu olabilir ve çocuk nesnelere bakarsanız, çocuklarla evcil hayvanlar arasındaki bire çok ilişki için iç içe geçmiş bir dizi olan bir evcil hayvan özelliğine sahiptir.
Konum özelliği için, ilgili üç özelliği, eyalet, ilçe ve şehri bir nesnede birleştiriyoruz.
Bir nesneyi bu şekilde gömmek, bir dizi nesneyi gömmek yerine, ilişkisel bir veritabanındaki ayrı tablolardaki iki satır arasında bire bir ilişkiye sahip olmaya benzer.
Veri Gömme
DocumentDB gibi bir belge deposundaki verileri modellemeye başladığınızda, varlıklarınızı JSON'da temsil edilen bağımsız belgeler olarak ele almaya çalışın. İlişkisel veritabanlarıyla çalışırken, verileri her zaman normalleştiririz.
Verilerinizi normalleştirmek, tipik olarak müşteri gibi bir varlığı alıp, iletişim bilgileri ve adresler gibi gizli veri parçalarına ayırmayı içerir.
Bir müşteriyi tüm iletişim bilgileri ve adresleriyle birlikte okumak için, verilerinizi çalışma zamanında etkili bir şekilde toplamak için JOINS'i kullanmanız gerekir.
Şimdi bir belge veritabanındaki bağımsız bir varlık olarak aynı verileri nasıl modelleyeceğimize bakalım.
{
"id": "1",
"firstName": "Mark",
"lastName": "Upston",
"addresses": [
{
"line1": "232 Main Street",
"line2": "Unit 1",
"city": "Brooklyn",
"state": "NY",
"zip": 11229
}
],
"contactDetails": [
{"email": "[email protected]"},
{"phone": "+1 356 545-86455", "extension": 5555}
]
}
Gördüğünüz gibi, müşterinin tüm bilgilerinin tek bir JSON belgesine gömülü olduğu müşteri kaydını normalleştirdik.
NoSQL'de ücretsiz bir şemaya sahibiz, böylece farklı formatlarda iletişim bilgilerini ve adresleri de ekleyebilirsiniz. NoSQL'de, tek bir okuma işleminde veritabanından bir müşteri kaydını alabilirsiniz. Benzer şekilde, bir kaydın güncellenmesi de tek bir yazma işlemidir.
Net SDK kullanarak belge oluşturma adımları aşağıdadır.
Step 1- DocumentClient örneğini oluşturun. Daha sonra, myfirstdb veritabanını ve ayrıca bu özel değişken koleksiyonunda sakladığımız MyCollection koleksiyonunu sorgulayacağız, böylece sınıf boyunca erişilebilir olmasını sağlayacağız.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
await CreateDocuments(client);
}
}
Step 2 - CreateDocuments görevinde bazı belgeler oluşturun.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
dynamic document1Definition = new {
name = "New Customer 1", address = new {
addressType = "Main Office",
addressLine1 = "123 Main Street",
location = new {
city = "Brooklyn", stateProvinceName = "New York"
},
postalCode = "11229", countryRegionName = "United States"
},
};
Document document1 = await CreateDocument(client, document1Definition);
Console.WriteLine("Created document {0} from dynamic object", document1.Id);
Console.WriteLine();
}
İlk belge bu dinamik nesneden oluşturulacaktır. Bu JSON'a benzeyebilir, ama elbette değil. Bu C # kodu ve gerçek bir .NET nesnesi oluşturuyoruz, ancak sınıf tanımı yok. Bunun yerine özellikler, nesnenin başlatılma biçiminden çıkarılır. Bu belge için bir Id özelliği sağlamadığımızı da fark edebilirsiniz.
Step 3 - Şimdi CreateDocument'e bir göz atalım ve veritabanları ve koleksiyonlar oluşturmak için gördüğümüz aynı modele benziyor.
private async static Task<Document> CreateDocument(DocumentClient client,
object documentObject) {
var result = await client.CreateDocumentAsync(collection.SelfLink, documentObject);
var document = result.Resource;
Console.WriteLine("Created new document: {0}\r\n{1}", document.Id, document);
return result;
}
Step 4- Bu sefer CreateDocumentAsync'i çağırarak belgeyi eklemek istediğimiz koleksiyonun SelfLink'ini belirledik. Bu durumda, sistem tarafından oluşturulan özellikleriyle yeni belgeyi temsil eden bir kaynak özelliğine sahip bir yanıtı geri alıyoruz.
Aşağıdaki CreateDocuments görevinde üç belge oluşturduk.
İlk belgede, Belge nesnesi, SDK'da kaynaktan miras alan tanımlanmış bir sınıftır ve bu nedenle tüm ortak kaynak özelliklerine sahiptir, ancak aynı zamanda şemadan bağımsız belgenin kendisini tanımlayan dinamik özellikleri de içerir.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
dynamic document1Definition = new {
name = "New Customer 1", address = new {
addressType = "Main Office",
addressLine1 = "123 Main Street",
location = new {
city = "Brooklyn", stateProvinceName = "New York"
},
postalCode = "11229",
countryRegionName = "United States"
},
};
Document document1 = await CreateDocument(client, document1Definition);
Console.WriteLine("Created document {0} from dynamic object", document1.Id);
Console.WriteLine();
var document2Definition = @" {
""name"": ""New Customer 2"",
""address"": {
""addressType"": ""Main Office"",
""addressLine1"": ""123 Main Street"",
""location"": {
""city"": ""Brooklyn"", ""stateProvinceName"": ""New York""
},
""postalCode"": ""11229"",
""countryRegionName"": ""United States""
}
}";
Document document2 = await CreateDocument(client, document2Definition);
Console.WriteLine("Created document {0} from JSON string", document2.Id);
Console.WriteLine();
var document3Definition = new Customer {
Name = "New Customer 3",
Address = new Address {
AddressType = "Main Office",
AddressLine1 = "123 Main Street",
Location = new Location {
City = "Brooklyn", StateProvinceName = "New York"
},
PostalCode = "11229",
CountryRegionName = "United States"
},
};
Document document3 = await CreateDocument(client, document3Definition);
Console.WriteLine("Created document {0} from typed object", document3.Id);
Console.WriteLine();
}
Bu ikinci belge yalnızca ham bir JSON dizesiyle çalışır. Şimdi, dizeyi bir nesneye dönüştürmek için JavaScriptSerializer'ı kullanan CreateDocument için bir aşırı yüklemeye adım atıyoruz ve daha sonra bu, ilk belgeyi oluşturmak için kullandığımız aynı CreateDocument yöntemine aktarılıyor.
Üçüncü belgede, uygulamamızda tanımlanan C # Müşteri nesnesini kullandık.
Bu müşteriye bir göz atalım, bir Id ve address özelliğine sahiptir, burada adres, lokasyon dahil olmak üzere kendi özellikleri ile iç içe geçmiş bir nesne olup, yine başka bir iç içe nesnedir.
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DocumentDBDemo {
public class Customer {
[JsonProperty(PropertyName = "id")]
public string Id { get; set; }
// Must be nullable, unless generating unique values for new customers on client
[JsonProperty(PropertyName = "name")]
public string Name { get; set; }
[JsonProperty(PropertyName = "address")]
public Address Address { get; set; }
}
public class Address {
[JsonProperty(PropertyName = "addressType")]
public string AddressType { get; set; }
[JsonProperty(PropertyName = "addressLine1")]
public string AddressLine1 { get; set; }
[JsonProperty(PropertyName = "location")]
public Location Location { get; set; }
[JsonProperty(PropertyName = "postalCode")]
public string PostalCode { get; set; }
[JsonProperty(PropertyName = "countryRegionName")]
public string CountryRegionName { get; set; }
}
public class Location {
[JsonProperty(PropertyName = "city")]
public string City { get; set; }
[JsonProperty(PropertyName = "stateProvinceName")]
public string StateProvinceName { get; set; }
}
}
Ayrıca, çitin her iki tarafında da uygun kuralları sürdürmek istediğimiz için JSON özellik özniteliklerine sahibiz.
Bu yüzden, iç içe geçmiş alt nesnelerle birlikte Yeni Müşteri nesnemi oluşturuyorum ve bir kez daha CreateDocument'ı çağırıyorum. Müşteri nesnemiz bir Id özelliğine sahip olmasına rağmen, bunun için bir değer sağlamadık ve bu nedenle DocumentDB, önceki iki belgede olduğu gibi GUID'e dayalı bir tane oluşturdu.
Yukarıdaki kod derlendiğinde ve yürütüldüğünde aşağıdaki çıktıyı alacaksınız.
**** Create Documents ****
Created new document: 575882f0-236c-4c3d-81b9-d27780206b2c
{
"name": "New Customer 1",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
"id": "575882f0-236c-4c3d-81b9-d27780206b2c",
"_rid": "kV5oANVXnwDGPgAAAAAAAA==",
"_ts": 1450037545,
"_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDGPgAAAAAAAA==/",
"_etag": "\"00006fce-0000-0000-0000-566dd1290000\"",
"_attachments": "attachments/"
}
Created document 575882f0-236c-4c3d-81b9-d27780206b2c from dynamic object
Created new document: 8d7ad239-2148-4fab-901b-17a85d331056
{
"name": "New Customer 2",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
"id": "8d7ad239-2148-4fab-901b-17a85d331056",
"_rid": "kV5oANVXnwDHPgAAAAAAAA==",
"_ts": 1450037545,
"_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDHPgAAAAAAAA==/",
"_etag": "\"000070ce-0000-0000-0000-566dd1290000\"",
"_attachments": "attachments/"
}
Created document 8d7ad239-2148-4fab-901b-17a85d331056 from JSON string
Created new document: 49f399a8-80c9-4844-ac28-cd1dee689968
{
"id": "49f399a8-80c9-4844-ac28-cd1dee689968",
"name": "New Customer 3",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
"_rid": "kV5oANVXnwDIPgAAAAAAAA==",
"_ts": 1450037546,
"_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDIPgAAAAAAAA==/",
"_etag": "\"000071ce-0000-0000-0000-566dd12a0000\"",
"_attachments": "attachments/"
}
Created document 49f399a8-80c9-4844-ac28-cd1dee689968 from typed object
JSON veya JavaScript Object Notation, insan tarafından okunabilir veri alışverişi için tasarlanmış hafif bir metin tabanlı açık standarttır ve ayrıca makinelerin ayrıştırması ve üretmesi kolaydır. JSON, DocumentDB'nin kalbindedir. JSON'u kablo üzerinden iletiyoruz, JSON'u JSON olarak saklıyoruz ve JSON ağacını indeksleyerek tam JSON belgesi üzerinde sorgulara izin veriyoruz.
JSON biçimi aşağıdaki veri türlerini destekler -
S.No. | Tip ve Açıklama |
---|---|
1 | Number JavaScript'te çift duyarlıklı kayan nokta biçimi |
2 | String Ters eğik çizgiden kaçan çift tırnaklı Unicode |
3 | Boolean Doğru ya da yanlış |
4 | Array Sıralı bir değerler dizisi |
5 | Value Bir dize, sayı, doğru veya yanlış, boş vb. Olabilir. |
6 | Object Sıralanmamış bir anahtar koleksiyonu: değer çiftleri |
7 | Whitespace Herhangi bir token çifti arasında kullanılabilir |
8 | Null Boş |
Basit bir örnek DateTime türüne bakalım. Müşteri sınıfına doğum tarihi ekleyin.
public class Customer {
[JsonProperty(PropertyName = "id")]
public string Id { get; set; }
// Must be nullable, unless generating unique values for new customers on client
[JsonProperty(PropertyName = "name")]
public string Name { get; set; }
[JsonProperty(PropertyName = "address")]
public Address Address { get; set; }
[JsonProperty(PropertyName = "birthDate")]
public DateTime BirthDate { get; set; }
}
Aşağıdaki kodda gösterildiği gibi DateTime kullanarak depolayabilir, alabilir ve sorgulayabiliriz.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
var document3Definition = new Customer {
Id = "1001",
Name = "Luke Andrew",
Address = new Address {
AddressType = "Main Office",
AddressLine1 = "123 Main Street",
Location = new Location {
City = "Brooklyn",
StateProvinceName = "New York"
},
PostalCode = "11229",
CountryRegionName = "United States"
},
BirthDate = DateTime.Parse(DateTime.Today.ToString()),
};
Document document3 = await CreateDocument(client, document3Definition);
Console.WriteLine("Created document {0} from typed object", document3.Id);
Console.WriteLine();
}
Yukarıdaki kod derlenip yürütüldüğünde ve belge oluşturulduğunda, şimdi doğum tarihinin eklendiğini göreceksiniz.
**** Create Documents ****
Created new document: 1001
{
"id": "1001",
"name": "Luke Andrew",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
"birthDate": "2015-12-14T00:00:00",
"_rid": "Ic8LAMEUVgAKAAAAAAAAAA==",
"_ts": 1450113676,
"_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgAKAAAAAAAAAA==/",
"_etag": "\"00002d00-0000-0000-0000-566efa8c0000\"",
"_attachments": "attachments/"
}
Created document 1001 from typed object
Microsoft kısa süre önce Azure DocumentDB'yi nasıl sorgulayabileceğiniz konusunda, sorguların daha hızlı çalışmasını ve daha az kaynak tüketmesini sağlayan, sorgu işleçleri için sınırları artıran ve ek LINQ işleçleri için destek ekleyen SQL dilbilgisine TOP anahtar sözcüğü gibi bir dizi iyileştirme ekledi. .NET SDK.
Sadece ilk iki kaydı alacağımız basit bir örneğe bakalım. Çok sayıda kaydınız varsa ve bunlardan yalnızca bazılarını almak istiyorsanız, o zaman Top anahtar sözcüğünü kullanabilirsiniz. Bu örnekte, çok sayıda deprem kaydımız var.
Şimdi sadece ilk iki kaydı göstermek istiyoruz
Step 1 - Sorgu gezginine gidin ve bu sorguyu çalıştırın.
SELECT * FROM c
WHERE c.magnitude > 2.5
Henüz TOP anahtar kelimesini belirtmediğimiz için dört kaydı aldığını göreceksiniz.
Step 2- Şimdi aynı sorgu ile TOP anahtar kelimesini kullanın. Burada TOP anahtar kelimesini belirledik ve '2' sadece iki kayıt istediğimiz anlamına gelir.
SELECT TOP 2 * FROM c
WHERE c.magnitude > 2.5
Step 3 - Şimdi bu sorguyu çalıştırın ve sadece iki kaydın alındığını göreceksiniz.
Benzer şekilde, .Net SDK kullanarak kodda TOP anahtar kelimesini kullanabilirsiniz. Uygulama aşağıdadır.
private async static Task QueryDocumentsWithPaging(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Query Documents (paged results) ****");
Console.WriteLine();
Console.WriteLine("Quering for all documents");
var sql = "SELECT TOP 3 * FROM c";
var query = client
.CreateDocumentQuery(collection.SelfLink, sql)
.AsDocumentQuery();
while (query.HasMoreResults) {
var documents = await query.ExecuteNextAsync();
foreach (var document in documents) {
Console.WriteLine(" PublicId: {0}; Magnitude: {1};", document.publicid,
document.magnitude);
}
}
Console.WriteLine();
}
Aşağıda, DocumentClient ve deprem veritabanının somutlaştırıldığı CreateDocumentClient görevi verilmiştir.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'earthquake'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'earthquakedata'").AsEnumerable().First();
await QueryDocumentsWithPaging(client);
}
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, yalnızca üç kaydın alındığını göreceksiniz.
**** Query Documents (paged results) ****
Quering for all documents
PublicId: 2015p947400; Magnitude: 2.515176918;
PublicId: 2015p947373; Magnitude: 1.506774108;
PublicId: 2015p947329; Magnitude: 1.593394461;
Microsoft Azure DocumentDB, JSON belgeleri üzerinden SQL kullanarak belgelerin sorgulanmasını destekler. Koleksiyondaki belgeleri, sorgunuzda ORDER BY yan tümcesi kullanarak sayılara ve dizelere göre sıralayabilirsiniz. Yantümce, sonuçların alınması gereken sırayı belirtmek için isteğe bağlı bir ASC / DESC bağımsız değişkeni içerebilir.
JSON belgemiz olan aşağıdaki örneğe bir göz atalım.
{
"id": "Food Menu",
"description": "Grapes, red or green (European type, such as Thompson seedless), raw",
"tags": [
{
"name": "grapes"
},
{
"name": "red or green (european type"
},
{
"name": "such as thompson seedless)"
},
{
"name": "raw"
}
],
"foodGroup": "Fruits and Fruit Juices",
"servings": [
{
"amount": 1,
"description": "cup",
"weightInGrams": 151
},
{
"amount": 10,
"description": "grapes",
"weightInGrams": 49
},
{
"amount": 1,
"description": "NLEA serving",
"weightInGrams": 126
}
]
}
Aşağıda, sonucu azalan bir sırada sıralamak için SQL sorgusu verilmiştir.
SELECT f.description, f.foodGroup,
f.servings[2].description AS servingDescription,
f.servings[2].weightInGrams AS servingWeight
FROM f
ORDER BY f.servings[2].weightInGrams DESC
Yukarıdaki sorgu yürütüldüğünde, aşağıdaki çıktıyı alacaksınız.
[
{
"description": "Grapes, red or green (European type, such as Thompson
seedless), raw",
"foodGroup": "Fruits and Fruit Juices",
"servingDescription": "NLEA serving",
"servingWeight": 126
}
]
Varsayılan olarak DocumentDB, belge veritabanına eklenir eklenmez belgedeki her özelliği otomatik olarak dizine ekler. Ancak, hiçbir zaman dizine eklenmesi gerekmeyen belirli belgeler ve / veya özellikler olduğunda depolama ve işleme ek yüklerini azaltan kendi dizinleme ilkenizi kontrol edebilir ve ince ayar yapabilirsiniz.
DocumentDB'ye her özelliği otomatik olarak indekslemesini söyleyen varsayılan indeksleme politikası, birçok yaygın senaryo için uygundur. Ancak, neyin indekslenip neyin indekslenmediğini ve indeksleme ile ilgili diğer işlevselliği tam olarak kontrol eden özel bir politika da uygulayabilirsiniz.
DocumentDB aşağıdaki dizinleme türlerini destekler -
- Hash
- Range
Hash
Karma indeksi, eşitlik için verimli sorgulama sağlar, yani belirli bir özelliğin tam bir değere eşit olduğu belgeleri ararken, küçüktür, büyüktür veya arasında gibi bir değer aralığında eşleştirme yerine.
Karma dizini ile aralık sorguları gerçekleştirebilirsiniz, ancak DocumentDB eşleşen belgeleri bulmak için karma dizini kullanamayacak ve bunun yerine aralık sorgusu tarafından seçilip seçilmeyeceğini belirlemek için her belgeyi sıralı olarak taraması gerekecektir.
Yalnızca karma dizini olan bir mülkte ORDER BY yan tümcesine sahip belgelerinizi sıralayamazsınız.
Aralık
Özellik için tanımlanan aralık dizini olan DocumentDB, belgeler için bir dizi değere göre verimli bir şekilde sorgulama yapılmasına izin verir. Ayrıca ORDER BY kullanarak bu özellikteki sorgu sonuçlarını sıralamanıza olanak tanır.
DocumentDB, herhangi bir veya tüm özelliklerde hem bir karma hem de bir aralık dizini tanımlamanıza olanak tanır, bu da verimli eşitlik ve aralık sorgularının yanı sıra ORDER BY sağlar.
Endeksleme Politikası
Her koleksiyonun, her belgenin her özelliğindeki sayılar ve dizeler için hangi tür dizinlerin kullanılacağını belirleyen bir dizin oluşturma ilkesi vardır.
Ayrıca, koleksiyona eklendiklerinde belgelerin otomatik olarak dizine eklenip eklenmeyeceğini kontrol edebilirsiniz.
Otomatik indeksleme varsayılan olarak etkindir, ancak bir belge eklerken bu davranışı geçersiz kılabilirsiniz ve DocumentDB'ye söz konusu belgeyi indekslememesini söyleyebilirsiniz.
Otomatik indekslemeyi devre dışı bırakabilirsiniz, böylece varsayılan olarak, koleksiyona eklendiğinde dokümanlar indekslenmez. Benzer şekilde, bunu belge düzeyinde geçersiz kılabilir ve DocumentDB'ye belirli bir belgeyi koleksiyona eklerken dizine eklemesini söyleyebilirsiniz. Bu, manuel indeksleme olarak bilinir.
İndekslemeyi Dahil Et / Hariç Tut
Bir indeksleme politikası, hangi yol veya yolların indekse dahil edileceğini veya hariç tutulacağını da tanımlayabilir. Bu, bir belgenin asla sorgulamadığınız belirli kısımları ve yaptığınız belirli kısımları olduğunu biliyorsanız kullanışlıdır.
Bu durumlarda, DocumentDB'ye koleksiyona eklenen her belgenin yalnızca belirli bölümlerini dizine eklemesini söyleyerek dizinleme ek yükünü azaltabilirsiniz.
Otomatik İndeksleme
Otomatik indekslemenin basit bir örneğine bakalım.
Step 1 - İlk olarak otomatik indeksleme adında bir koleksiyon oluşturuyoruz ve açıkça bir politika sağlamadan, bu koleksiyon varsayılan indeksleme politikasını kullanıyor, bu da bu koleksiyonda otomatik indekslemenin etkinleştirildiği anlamına geliyor.
Burada veritabanı kendi kendine bağlantısı için kimlik tabanlı yönlendirme kullanıyoruz, bu nedenle koleksiyonu oluşturmadan önce kaynak kimliğini veya sorgusunu bilmemize gerek yok. Mydb olan veritabanı kimliğini kullanabiliriz.
Step 2 - Şimdi her ikisi de Upston soyadıyla iki belge oluşturalım.
private async static Task AutomaticIndexing(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Override Automatic Indexing ****");
// Create collection with automatic indexing
var collectionDefinition = new DocumentCollection {
Id = "autoindexing"
};
var collection = await client.CreateDocumentCollectionAsync("dbs/mydb",
collectionDefinition);
// Add a document (indexed)
dynamic indexedDocumentDefinition = new {
id = "MARK",
firstName = "Mark",
lastName = "Upston",
addressLine = "123 Main Street",
city = "Brooklyn",
state = "New York",
zip = "11229",
};
Document indexedDocument = await client
.CreateDocumentAsync("dbs/mydb/colls/autoindexing", indexedDocumentDefinition);
// Add another document (request no indexing)
dynamic unindexedDocumentDefinition = new {
id = "JANE",
firstName = "Jane",
lastName = "Upston",
addressLine = "123 Main Street",
city = "Brooklyn",
state = "New York",
zip = "11229",
};
Document unindexedDocument = await client
.CreateDocumentAsync("dbs/mydb/colls/autoindexing", unindexedDocumentDefinition,
new RequestOptions { IndexingDirective = IndexingDirective.Exclude });
//Unindexed document won't get returned when querying on non-ID (or selflink) property
var doeDocs = client.CreateDocumentQuery("dbs/mydb/colls/autoindexing", "SELECT *
FROM c WHERE c.lastName = 'Doe'").ToList();
Console.WriteLine("Documents WHERE lastName = 'Doe': {0}", doeDocs.Count);
// Unindexed document will get returned when using no WHERE clause
var allDocs = client.CreateDocumentQuery("dbs/mydb/colls/autoindexing",
"SELECT * FROM c").ToList();
Console.WriteLine("All documents: {0}", allDocs.Count);
// Unindexed document will get returned when querying by ID (or self-link) property
Document janeDoc = client.CreateDocumentQuery("dbs/mydb/colls/autoindexing",
"SELECT * FROM c WHERE c.id = 'JANE'").AsEnumerable().FirstOrDefault();
Console.WriteLine("Unindexed document self-link: {0}", janeDoc.SelfLink);
// Delete the collection
await client.DeleteDocumentCollectionAsync("dbs/mydb/colls/autoindexing");
}
Bu, Mark Upston için koleksiyona eklenir ve ardından varsayılan indeksleme politikasına göre hemen otomatik olarak indekslenir.
Ancak Mark Upston için ikinci belge eklendiğinde, koleksiyonun indeksleme politikasına rağmen DocumentDB'ye bu belgeyi indekslememesini açıkça bildiren IndexingDirective.Exclude ile istek seçeneklerini geçtik.
Sonunda her iki belge için de farklı türde sorgularımız var.
Step 3 - CreateDocumentClient'ten AutomaticIndexing görevini çağıralım.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await AutomaticIndexing(client);
}
}
Yukarıdaki kod derlenip çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Override Automatic Indexing ****
Documents WHERE lastName = 'Upston': 1
All documents: 2
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oAOEkfQA=/docs/kV5oAOEkfQACA
AAAAAAAAA==/
Gördüğünüz gibi bu tür iki belgemiz var, ancak sorgu yalnızca Mark için olanı döndürüyor çünkü Mark için olanı dizine eklenmemiş. Koleksiyondaki tüm belgeleri almak için bir WHERE cümlesi olmadan tekrar sorgulama yaparsak, her iki belgeyle birlikte bir sonuç kümesi elde ederiz ve bunun nedeni, indekslenmemiş belgelerin her zaman WHERE yan tümcesi olmayan sorgular tarafından döndürülmesidir.
Ayrıca indekslenmemiş belgeleri kimlikleri veya kendi kendine bağlantılarıyla da alabiliriz. Bu yüzden Mark'ın belgesini MARK kimliğine göre sorguladığımızda DocumentDB'nin koleksiyonda indekslenmemiş olmasına rağmen dokümanı döndürdüğünü görüyoruz.
Manuel Dizin Oluşturma
Otomatik indekslemeyi geçersiz kılarak basit bir manuel indeksleme örneğine bakalım.
Step 1- Öncelikle manuel indeksleme adlı bir koleksiyon oluşturacağız ve otomatik indekslemeyi açıkça devre dışı bırakarak varsayılan politikayı geçersiz kılacağız. Bu, aksi talep edilmedikçe, bu koleksiyona eklenen yeni belgelerin dizine eklenmeyeceği anlamına gelir.
private async static Task ManualIndexing(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Manual Indexing ****");
// Create collection with manual indexing
var collectionDefinition = new DocumentCollection {
Id = "manualindexing",
IndexingPolicy = new IndexingPolicy {
Automatic = false,
},
};
var collection = await client.CreateDocumentCollectionAsync("dbs/mydb",
collectionDefinition);
// Add a document (unindexed)
dynamic unindexedDocumentDefinition = new {
id = "MARK",
firstName = "Mark",
lastName = "Doe",
addressLine = "123 Main Street",
city = "Brooklyn",
state = "New York",
zip = "11229",
};
Document unindexedDocument = await client
.CreateDocumentAsync("dbs/mydb/colls/manualindexing", unindexedDocumentDefinition);
// Add another document (request indexing)
dynamic indexedDocumentDefinition = new {
id = "JANE",
firstName = "Jane",
lastName = "Doe",
addressLine = "123 Main Street",
city = "Brooklyn",
state = "New York",
zip = "11229",
};
Document indexedDocument = await client.CreateDocumentAsync
("dbs/mydb/colls/manualindexing", indexedDocumentDefinition, new RequestOptions {
IndexingDirective = IndexingDirective.Include });
//Unindexed document won't get returned when querying on non-ID (or selflink) property
var doeDocs = client.CreateDocumentQuery("dbs/mydb/colls/manualindexing",
"SELECT * FROM c WHERE c.lastName = 'Doe'").ToList();
Console.WriteLine("Documents WHERE lastName = 'Doe': {0}", doeDocs.Count);
// Unindexed document will get returned when using no WHERE clause
var allDocs = client.CreateDocumentQuery("dbs/mydb/colls/manualindexing",
"SELECT * FROM c").ToList();
Console.WriteLine("All documents: {0}", allDocs.Count);
// Unindexed document will get returned when querying by ID (or self-link) property
Document markDoc = client
.CreateDocumentQuery("dbs/mydb/colls/manualindexing",
"SELECT * FROM c WHERE c.id = 'MARK'")
.AsEnumerable().FirstOrDefault();
Console.WriteLine("Unindexed document self-link: {0}", markDoc.SelfLink);
await client.DeleteDocumentCollectionAsync("dbs/mydb/colls/manualindexing");
}
Step 2- Şimdi yine eskisi gibi aynı iki belgeyi oluşturacağız. Koleksiyonun indeksleme politikası nedeniyle bu sefer Mark'ın dokümanı için herhangi bir özel istek seçeneği sunmayacağız, bu doküman indekslenmeyecek.
Step 3 - Şimdi Mark için ikinci dokümanı eklediğimizde, IndexingDirective ile RequestOptions kullanıyoruz. DocumentDB'ye bu dokümanı indekslemesi gerektiğini söylemek için dahil ediyoruz, bu da koleksiyonun indeksleme politikasını geçersiz kılmaması gerektiğini söylüyor.
Sonunda her iki belge için de farklı türde sorgularımız var.
Step 4 - CreateDocumentClient'ten ManualIndexing görevini çağıralım.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await ManualIndexing(client);
}
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde aşağıdaki çıktıyı alacaksınız.
**** Manual Indexing ****
Documents WHERE lastName = 'Upston': 1
All documents: 2
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oANHJPgE=/docs/kV5oANHJPgEBA
AAAAAAAAA==/
Yine, sorgu iki belgeden yalnızca birini döndürür, ancak bu sefer, dizine eklenmesini açıkça istediğimiz Jane Doe'yi döndürür. Ancak yine daha önce olduğu gibi, bir WHERE yan tümcesi olmadan sorgulama, Mark için dizine eklenmemiş belge de dahil olmak üzere koleksiyondaki tüm belgeleri alır. Dizinlenmemiş belgeyi kimliğine göre de sorgulayabiliriz, bu da DocumentDB'nin dizine eklenmemiş olmasına rağmen döndürür.
Microsoft eklendi geospatial support, konum verilerini belgelerinizde saklamanıza ve noktalar ile çokgenler arasındaki mesafe ve kesişimler için uzamsal hesaplamalar yapmanızı sağlar.
Uzamsal veriler, uzaydaki nesnelerin konumunu ve şeklini tanımlar.
Tipik olarak, bir kişinin konumunu, ilgilenilen bir yeri veya bir şehrin veya gölün sınırını temsil etmek için kullanılabilir.
Yaygın kullanım örnekleri genellikle yakınlık sorgularını içerir. Örneğin, "bulunduğum yere yakın tüm üniversiteleri bul".
Bir Pointbelirli bir üniversitenin sokak adresi gibi tam konumu temsil eden uzaydaki tek bir konumu belirtir. DocumentDB'de bir nokta koordinat çifti (boylam ve enlem) kullanılarak temsil edilir. Aşağıda bir JSON noktası örneği verilmiştir.
{
"type":"Point",
"coordinates":[ 28.3, -10.7 ]
}
Bir üniversitenin yerini içeren basit bir örneğe bakalım.
{
"id":"case-university",
"name":"CASE: Center For Advanced Studies In Engineering",
"city":"Islamabad",
"location": {
"type":"Point",
"coordinates":[ 33.7194136, -73.0964862 ]
}
}
Konuma göre üniversite adını almak için aşağıdaki sorguyu kullanabilirsiniz.
SELECT c.name FROM c
WHERE c.id = "case-university" AND ST_ISVALID({
"type":"Point",
"coordinates":[ 33.7194136, -73.0964862 ]})
Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı alacaksınız.
[
{
"name": "CASE: Center For Advanced Studies In Engineering"
}
]
.NET'te Jeo-uzamsal Verilerle Belge Oluşturun
Jeo-uzamsal verilerle bir belge oluşturabilirsiniz, bir üniversite belgesinin oluşturulduğu basit bir örneğe bakalım.
private async static Task CreateDocuments(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents ****");
Console.WriteLine();
var uniDocument = new UniversityProfile {
Id = "nust",
Name = "National University of Sciences and Technology",
City = "Islamabad",
Loc = new Point(33.6455715, 72.9903447)
};
Document document = await CreateDocument(client, uniDocument);
Console.WriteLine("Created document {0} from typed object", document.Id);
Console.WriteLine();
}
Aşağıda UniversityProfile sınıfı için uygulama yer almaktadır.
public class UniversityProfile {
[JsonProperty(PropertyName = "id")]
public string Id { get; set; }
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("city")]
public string City { get; set; }
[JsonProperty("location")]
public Point Loc { get; set; }
}
Yukarıdaki kod derlenip çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Create Documents ****
Created new document: nust
{
"id": "nust",
"name": "National University of Sciences and Technology",
"city": "Islamabad",
"location": {
"type": "Point",
"coordinates": [
33.6455715,
72.9903447
]
},
"_rid": "Ic8LAMEUVgANAAAAAAAAAA==",
"_ts": 1450200910,
"_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgANAAAAAAAAAA==/",
"_etag": "\"00004100-0000-0000-0000-56704f4e0000\"",
"_attachments": "attachments/"
}
Created document nust from typed object
Veritabanınız 10 GB'ın üzerinde büyümeye başladığında, yalnızca yeni koleksiyonlar oluşturarak ve ardından verilerinizi giderek daha fazla koleksiyona dağıtarak veya bölümlere ayırarak ölçeği genişletebilirsiniz.
Er ya da geç 10GB kapasiteye sahip tek bir koleksiyon, veritabanınızı tutmaya yetmeyecektir. Şimdi 10 GB çok büyük bir sayı gibi görünmeyebilir, ancak yalnızca düz metin olan JSON belgelerini sakladığımızı ve dizinler için depolama ek yükünü düşünseniz bile 10 GB'a çok sayıda düz metin belgesini sığdırabileceğinizi unutmayın.
Ölçeklenebilirlik söz konusu olduğunda tek sorun depolama değildir. Bir koleksiyonda kullanılabilen maksimum aktarım hızı, bir S3 koleksiyonuyla elde ettiğiniz saniyede iki buçuk bin istek birimidir. Bu nedenle, daha yüksek işleme hızına ihtiyacınız varsa, birden fazla koleksiyonla bölümlere ayırarak ölçeklendirmeniz de gerekecektir. Ölçeklendirilmiş bölümleme de denirhorizontal partitioning.
Azure DocumentDB ile verileri bölümlemek için kullanılabilecek birçok yaklaşım vardır. En yaygın stratejiler şunlardır -
- Yayılma Bölümleme
- Aralık Bölümleme
- Arama Bölümleme
- Hash Bölümleme
Yayılma Bölümleme
Yayılma bölümleme en basit stratejidir çünkü bölüm anahtarı yoktur. Pek çok şeyden emin olmadığınızda başlamak için genellikle iyi bir seçimdir. Tek bir koleksiyonun ötesine geçmeniz gerekip gerekmediğini veya kaç koleksiyon eklemeniz gerekebileceğini veya bunları ne kadar hızlı eklemeniz gerekeceğini bile bilemeyebilirsiniz.
Yayılma bölümleme, tek bir koleksiyonla başlar ve bölüm anahtarı yoktur.
Koleksiyon büyümeye başlar ve sonra biraz daha büyür, sonra 10 GB sınırına yaklaşana kadar biraz daha büyür.
Yüzde 90 kapasiteye ulaştığınızda, yeni bir koleksiyona geçersiniz ve onu yeni belgeler için kullanmaya başlarsınız.
Veritabanınız daha fazla sayıda koleksiyona ölçeklendiğinde, muhtemelen bölüm anahtarına dayalı bir stratejiye geçmek isteyeceksiniz.
Bunu yaptığınızda, geçiş yaptığınız stratejiye bağlı olarak belgeleri farklı koleksiyonlara taşıyarak verilerinizi yeniden dengelemeniz gerekir.
Aralık Bölümleme
En yaygın stratejilerden biri aralık bölümlemedir. Bu yaklaşımla, bir belgenin bölüm anahtarının düşebileceği değer aralığını belirler ve belgeyi bu aralığa karşılık gelen bir koleksiyona yönlendirirsiniz.
Tarihler, tanımlanmış tarih aralığına giren belgeleri tutmak için bir koleksiyon oluşturduğunuz bu strateji ile çok tipik olarak kullanılır. Yeterince küçük aralıklar tanımladığınızda, hiçbir koleksiyonun 10 GB sınırını asla aşmayacağından emin olursunuz. Örneğin, tek bir koleksiyonun tüm bir ay boyunca belgeleri makul bir şekilde işleyebileceği bir senaryo olabilir.
Çoğu kullanıcının bu ay veya belki de geçen aya ait veriler olan mevcut verileri sorgulaması da söz konusu olabilir, ancak kullanıcılar nadiren çok daha eski verileri arıyor. Böylece, satın alabileceğiniz en pahalı koleksiyon olan ve elde edebileceğiniz en iyi verimi sunan bir S3 koleksiyonuyla Haziran ayında başlarsınız.
Temmuz ayında, Temmuz verilerini depolamak için başka bir S3 koleksiyonu satın alırsınız ve ayrıca Haziran verilerini daha ucuz bir S2 koleksiyonuna indirirsiniz. Ardından Ağustos'ta, başka bir S3 koleksiyonu elde edersiniz ve Temmuz'u S2'ye ve Haziran'ı S1'e indirirsiniz. Her ay geçerli verileri yüksek verim için her zaman hazır tuttuğunuz ve eski verilerin daha düşük üretim hızlarında tutulduğu yer.
Sorgu bir bölüm anahtarı sağladığı sürece, yalnızca sorgulanması gereken koleksiyon sorgulanacak ve yayılma bölümlemede olduğu gibi veritabanındaki tüm koleksiyonlar sorgulanmayacaktır.
Arama Bölümleme
Arama bölümleme ile, belgeleri bölüm anahtarına göre belirli koleksiyonlara yönlendiren bir bölüm haritası tanımlayabilirsiniz. Örneğin, bölgeye göre bölümleyebilirsiniz.
Tüm ABD belgelerini tek bir koleksiyonda, tüm Avrupa belgelerini başka bir koleksiyonda ve başka herhangi bir bölgeden tüm belgeleri üçüncü bir koleksiyonda saklayın.
Bu bölüm haritasını kullanın ve arama bölümü çözümleyici, her belgede bulunan bölge özelliği olan bölüm anahtarına göre hangi koleksiyonda belge oluşturulacağını ve hangi koleksiyonların sorgulanacağını belirleyebilir.
Hash Bölümleme
Karma bölümlemede bölümler, bir karma işlevin değerine göre atanır ve bu da istekleri ve verileri bir dizi bölüme eşit olarak dağıtmanıza olanak tanır.
Bu, genellikle çok sayıda farklı istemciden üretilen veya tüketilen verileri bölümlemek için kullanılır ve kullanıcı profillerini, katalog öğelerini vb. Depolamak için kullanışlıdır.
.NET SDK tarafından sağlanan RangePartitionResolver'ı kullanarak aralık bölümlemesinin basit bir örneğine bakalım.
Step 1- Yeni bir DocumentClient oluşturun ve CreateCollections görevinde iki koleksiyon oluşturalım. Biri, A ile M ile başlayan kullanıcı kimliklerine sahip kullanıcılar için ve diğeri N ile Z arası kullanıcı kimlikleri için dokümanları içerecektir.
private static async Task CreateCollections(DocumentClient client) {
await client.CreateDocumentCollectionAsync(“dbs/myfirstdb”, new DocumentCollection {
Id = “CollectionAM” });
await client.CreateDocumentCollectionAsync(“dbs/myfirstdb”, new DocumentCollection {
Id = “CollectionNZ” });
}
Step 2 - Veritabanı için aralık çözümleyiciyi kaydedin.
Step 3- Bölüm anahtarımızın veri türü olan yeni bir RangePartitionResolver <string> oluşturun. Yapıcı iki parametre alır; bölüm anahtarının özellik adı ve parça eşlemesi veya bölüm eşlemesi olan bir sözlük, bu sadece çözümleyici için önceden tanımladığımız aralıkların ve karşılık gelen koleksiyonların bir listesi.
private static void RegisterRangeResolver(DocumentClient client) {
//Note: \uffff is the largest UTF8 value, so M\ufff includes all strings that start with M.
var resolver = new RangePartitionResolver<string>(
"userId", new Dictionary<Range<string>, string>() {
{ new Range<string>("A", "M\uffff"), "dbs/myfirstdb/colls/CollectionAM" },
{ new Range<string>("N", "Z\uffff"), "dbs/myfirstdb/colls/CollectionNZ" },
});
client.PartitionResolvers["dbs/myfirstdb"] = resolver;
}
Burada mümkün olan en büyük UTF-8 değerini kodlamak gerekir. Ya da ilk aralık, tek bir M dışında herhangi bir Ms ile eşleşmez ve aynı şekilde ikinci aralıktaki Z için de aynı şekilde. Bu nedenle, buradaki kodlanmış değeri, bölüm anahtarında eşleştirme için bir joker karakter olarak düşünebilirsiniz.
Step 4- Çözümleyiciyi oluşturduktan sonra, mevcut DocumentClient ile veritabanına kaydedin. Bunu yapmak için sadece PartitionResolver'ın sözlük özelliğine atayın.
Normalde yaptığınız gibi bir koleksiyon değil, veritabanına göre belgeler oluşturacak ve sorgulayacağız; çözümleyici, istekleri uygun koleksiyonlara yönlendirmek için bu haritayı kullanacaktır.
Şimdi bazı belgeler oluşturalım. Önce userId Kirk için bir tane ve sonra Spock için bir tane oluşturacağız.
private static async Task CreateDocumentsAcrossPartitions(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create Documents Across Partitions ****");
var kirkDocument = await client.CreateDocumentAsync("dbs/myfirstdb", new { userId =
"Kirk", title = "Captain" });
Console.WriteLine("Document 1: {0}", kirkDocument.Resource.SelfLink);
var spockDocument = await client.CreateDocumentAsync("dbs/myfirstdb", new { userId =
"Spock", title = "Science Officer" });
Console.WriteLine("Document 2: {0}", spockDocument.Resource.SelfLink);
}
Buradaki ilk parametre, belirli bir koleksiyon değil, veritabanına kendi kendine bağlantıdır. Bu, bir bölüm çözücü olmadan mümkün değildir, ancak bir tanesiyle sorunsuz bir şekilde çalışır.
Her iki belge de myfirstdb veritabanına kaydedildi, ancak RangePartitionResolver'ımız düzgün çalışıyorsa Kirk'ün A'dan M'ye kadar koleksiyonda saklandığını ve Spock'ın N'den Z'ye koleksiyonda depolandığını biliyoruz.
Bunları aşağıdaki kodda gösterildiği gibi CreateDocumentClient görevinden çağıralım.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await CreateCollections(client);
RegisterRangeResolver(client);
await CreateDocumentsAcrossPartitions(client);
}
}
Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı alacaksınız.
**** Create Documents Across Partitions ****
Document 1: dbs/Ic8LAA==/colls/Ic8LAO2DxAA=/docs/Ic8LAO2DxAABAAAAAAAAAA==/
Document 2: dbs/Ic8LAA==/colls/Ic8LAP12QAE=/docs/Ic8LAP12QAEBAAAAAAAAAA==/
Görüldüğü gibi, iki belgenin kendi kendine bağlantıları, iki ayrı koleksiyonda mevcut oldukları için farklı kaynak kimliklerine sahiptir.
DocumentDB Veri Taşıma aracıyla, verileri kolayca DocumentDB'ye taşıyabilirsiniz. DocumentDB Veri Taşıma Aracı, Microsoft Yükleme Merkezi'nden indirebileceğiniz ücretsiz ve açık kaynaklı bir yardımcı programdır.https://www.microsoft.com/
Taşıma Aracı birçok veri kaynağını destekler, bunlardan bazıları aşağıda listelenmiştir -
- SQL Server
- JSON dosyaları
- Virgülle Ayrılmış Değerler (CSV) içeren düz dosyalar
- MongoDB
- Azure Tablo Depolama
- Amazon DynamoDB
- HBase ve hatta diğer DocumentDB veritabanları
DocumentDB Veri Taşıma aracını indirdikten sonra, zip dosyasını çıkartın.
Aşağıdaki ekran görüntüsünde gösterildiği gibi bu klasörde iki yürütülebilir dosya görebilirsiniz.
Öncelikle komut satırı arayüzüne sahip konsol versiyonu olan dt.exe, ardından grafik kullanıcı arayüzüne sahip masaüstü versiyonu olan dtui.exe vardır.
GUI sürümünü başlatalım.
Hoş Geldiniz sayfasını görebilirsiniz. Kaynak Bilgileri sayfası için 'İleri'yi tıklayın.
Veri kaynağınızı burada yapılandırırsınız ve açılır menüden desteklenen birçok seçeneği görebilirsiniz.
Bir seçim yaptığınızda, Kaynak Bilgi sayfasının geri kalanı buna göre değişir.
DocumentDB Veri Taşıma Aracını kullanarak DocumentDB'ye veri aktarmak çok kolaydır. Yukarıdaki örnekleri kullanmanızı ve diğer veri dosyalarını da kullanmanızı tavsiye ederiz.
DocumentDB, DocumentDB kaynaklarına erişimi kontrol etmek için kavramlar sağlar. DocumentDB kaynaklarına erişim, bir ana anahtar belirteci veya bir kaynak belirteci tarafından yönetilir. Kaynak belirteçlerine dayalı bağlantılar yalnızca belirteçler tarafından belirtilen kaynaklara erişebilir, diğer kaynaklara erişemez. Kaynak belirteçleri, kullanıcı izinlerine dayanır.
Önce bir veya daha fazla kullanıcı oluşturursunuz ve bunlar veritabanı düzeyinde tanımlanır.
Ardından, her kullanıcının erişmesine izin vermek istediğiniz kaynaklara bağlı olarak her kullanıcı için bir veya daha fazla izin oluşturursunuz.
Her izin, belirli bir kaynağa salt okunur veya tam erişime izin veren ve veritabanı içindeki herhangi bir kullanıcı kaynağı olabilen bir kaynak belirteci oluşturur.
Kullanıcılar veritabanı düzeyinde tanımlanır ve her kullanıcı için izinler tanımlanır.
Kullanıcılar ve izinler, veritabanındaki tüm koleksiyonlar için geçerlidir.
DocumentDB'de granüler güvenlik elde etmek için kullanıcıları ve izinleri nasıl tanımlayacağımızı öğreneceğimiz basit bir örneğe bakalım.
Yeni bir DocumentClient ile başlayacağız ve myfirstdb veritabanını sorgulayacağız.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
var alice = await CreateUser(client, "Alice");
var tom = await CreateUser(client, "Tom");
}
}
Aşağıda, CreateUser için uygulama yer almaktadır.
private async static Task<User> CreateUser(DocumentClient client, string userId) {
Console.WriteLine();
Console.WriteLine("**** Create User {0} in {1} ****", userId, database.Id);
var userDefinition = new User { Id = userId };
var result = await client.CreateUserAsync(database.SelfLink, userDefinition);
var user = result.Resource;
Console.WriteLine("Created new user");
ViewUser(user);
return user;
}
Step 1- Alice ve Tom olmak üzere iki kullanıcı oluşturun, yarattığımız her kaynak gibi, istenen Id ile bir tanım nesnesi oluşturuyoruz ve create yöntemini çağırıyoruz ve bu durumda, veritabanının SelfLink ve userDefinition ile CreateUserAsync çağırıyoruz. Yeni oluşturulan kullanıcı nesnesini kaynak özelliğinden elde ettiğimiz sonucu geri alıyoruz.
Şimdi bu iki yeni kullanıcıyı veritabanında görelim.
private static void ViewUsers(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** View Users in {0} ****", database.Id);
var users = client.CreateUserQuery(database.UsersLink).ToList();
var i = 0;
foreach (var user in users) {
i++;
Console.WriteLine();
Console.WriteLine("User #{0}", i);
ViewUser(user);
}
Console.WriteLine();
Console.WriteLine("Total users in database {0}: {1}", database.Id, users.Count);
}
private static void ViewUser(User user) {
Console.WriteLine("User ID: {0} ", user.Id);
Console.WriteLine("Resource ID: {0} ", user.ResourceId);
Console.WriteLine("Self Link: {0} ", user.SelfLink);
Console.WriteLine("Permissions Link: {0} ", user.PermissionsLink);
Console.WriteLine("Timestamp: {0} ", user.Timestamp);
}
Step 2- Tüm kullanıcıların bir listesini almak için veritabanının UsersLink'ine karşı CreateUserQuery'yi çağırın. Ardından bunların arasında döngü yapın ve özelliklerini görüntüleyin.
Şimdi önce onları yaratmalıyız. Diyelim ki Alice'in MyCollection koleksiyonuna okuma / yazma izinlerine izin vermek istedik, ancak Tom yalnızca koleksiyondaki belgeleri okuyabilir.
await CreatePermission(client, alice, "Alice Collection Access", PermissionMode.All,
collection);
await CreatePermission(client, tom, "Tom Collection Access", PermissionMode.Read,
collection);
Step 3- MyCollection koleksiyonu olan bir kaynak üzerinde bir izin oluşturun, böylece bu kaynağı bir SelfLink almamız gerekir.
Step 4 - Sonra bir İzin oluşturun. Tüm bu koleksiyonda Alice için ve bir İzin. Tom için bu koleksiyonu okuyun.
Aşağıda, CreatePermission için uygulama yer almaktadır.
private async static Task CreatePermission(DocumentClient client, User user,
string permId, PermissionMode permissionMode, string resourceLink) {
Console.WriteLine();
Console.WriteLine("**** Create Permission {0} for {1} ****", permId, user.Id);
var permDefinition = new Permission {
Id = permId,
PermissionMode = permissionMode,
ResourceLink = resourceLink
};
var result = await client.CreatePermissionAsync(user.SelfLink, permDefinition);
var perm = result.Resource;
Console.WriteLine("Created new permission");
ViewPermission(perm);
}
Şimdiye kadar beklemeniz gerektiği gibi, bunu yeni izin için bir Id ve bir permission.All veya Permission.Read ve güvenliği sağlanan kaynağın SelfLink'i olan bir allowMode içeren bir tanım nesnesi oluşturarak yapıyoruz. izinle.
Step 5 - CreatePermissionAsync'i çağırın ve sonuçta kaynak özelliğinden oluşturulan izni alın.
Oluşturulan izni görüntülemek için, ViewPermissions uygulamasının uygulanması aşağıdadır.
private static void ViewPermissions(DocumentClient client, User user) {
Console.WriteLine();
Console.WriteLine("**** View Permissions for {0} ****", user.Id);
var perms = client.CreatePermissionQuery(user.PermissionsLink).ToList();
var i = 0;
foreach (var perm in perms) {
i++;
Console.WriteLine();
Console.WriteLine("Permission #{0}", i);
ViewPermission(perm);
}
Console.WriteLine();
Console.WriteLine("Total permissions for {0}: {1}", user.Id, perms.Count);
}
private static void ViewPermission(Permission perm) {
Console.WriteLine("Permission ID: {0} ", perm.Id);
Console.WriteLine("Resource ID: {0} ", perm.ResourceId);
Console.WriteLine("Permission Mode: {0} ", perm.PermissionMode);
Console.WriteLine("Token: {0} ", perm.Token);
Console.WriteLine("Timestamp: {0} ", perm.Timestamp);
}
Bu sefer, kullanıcının izinler bağlantısına karşı bir izin sorgusu ve biz sadece kullanıcı için döndürülen her izni listeliyoruz.
Alice'in ve Tom'un izinlerini silelim.
await DeletePermission(client, alice, "Alice Collection Access");
await DeletePermission(client, tom, "Tom Collection Access");
DeletePermission için uygulama aşağıdadır.
private async static Task DeletePermission(DocumentClient client, User user,
string permId) {
Console.WriteLine();
Console.WriteLine("**** Delete Permission {0} from {1} ****", permId, user.Id);
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection {
new SqlParameter { Name = "@id", Value = permId }
}
};
Permission perm = client.CreatePermissionQuery(user.PermissionsLink, query)
.AsEnumerable().First();
await client.DeletePermissionAsync(perm.SelfLink);
Console.WriteLine("Deleted permission {0} from user {1}", permId, user.Id);
}
Step 6 - İzinleri silmek için, SelfLink'i almak için izin kimliğine göre sorgulayın ve ardından izni silmek için SelfLink'i kullanın.
Ardından, kullanıcıların kendilerini silelim. Her iki kullanıcıyı da silelim.
await DeleteUser(client, "Alice");
await DeleteUser(client, "Tom");
DeleteUser için uygulama aşağıdadır.
private async static Task DeleteUser(DocumentClient client, string userId) {
Console.WriteLine();
Console.WriteLine("**** Delete User {0} in {1} ****", userId, database.Id);
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection {
new SqlParameter { Name = "@id", Value = userId }
}
};
User user = client.CreateUserQuery(database.SelfLink, query).AsEnumerable().First();
await client.DeleteUserAsync(user.SelfLink);
Console.WriteLine("Deleted user {0} from database {1}", userId, database.Id);
}
Step 7 - Önce SelfLink'i almak için sorgu ve ardından kullanıcı nesnesini silmek için DeleteUserAsync'i çağırın.
Aşağıda, yukarıdaki tüm görevleri çağırdığımız CreateDocumentClient görevinin uygulanması yer almaktadır.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
'myfirstdb'").AsEnumerable().First();
collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
"SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();
ViewUsers(client);
var alice = await CreateUser(client, "Alice");
var tom = await CreateUser(client, "Tom");
ViewUsers(client);
ViewPermissions(client, alice);
ViewPermissions(client, tom);
string collectionLink = client.CreateDocumentCollectionQuery(database.SelfLink,
"SELECT VALUE c._self FROM c WHERE c.id = 'MyCollection'")
.AsEnumerable().First().Value;
await CreatePermission(client, alice, "Alice Collection Access", PermissionMode.All,
collectionLink);
await CreatePermission(client, tom, "Tom Collection Access", PermissionMode.Read,
collectionLink);
ViewPermissions(client, alice);
ViewPermissions(client, tom);
await DeletePermission(client, alice, "Alice Collection Access");
await DeletePermission(client, tom, "Tom Collection Access");
await DeleteUser(client, "Alice");
await DeleteUser(client, "Tom");
}
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde aşağıdaki çıktıyı alacaksınız.
**** View Users in myfirstdb ****
Total users in database myfirstdb: 0
**** Create User Alice in myfirstdb ****
Created new user
User ID: Alice
Resource ID: kV5oAC56NwA=
Self Link: dbs/kV5oAA==/users/kV5oAC56NwA=/
Permissions Link: dbs/kV5oAA==/users/kV5oAC56NwA=/permissions/
Timestamp: 12/17/2015 5:44:19 PM
**** Create User Tom in myfirstdb ****
Created new user
User ID: Tom
Resource ID: kV5oAALxKgA=
Self Link: dbs/kV5oAA==/users/kV5oAALxKgA=/
Permissions Link: dbs/kV5oAA==/users/kV5oAALxKgA=/permissions/
Timestamp: 12/17/2015 5:44:21 PM
**** View Users in myfirstdb ****
User #1
User ID: Tom
Resource ID: kV5oAALxKgA=
Self Link: dbs/kV5oAA==/users/kV5oAALxKgA=/
Permissions Link: dbs/kV5oAA==/users/kV5oAALxKgA=/permissions/
Timestamp: 12/17/2015 5:44:21 PM
User #2
User ID: Alice
Resource ID: kV5oAC56NwA=
Self Link: dbs/kV5oAA==/users/kV5oAC56NwA=/
Permissions Link: dbs/kV5oAA==/users/kV5oAC56NwA=/permissions/
Timestamp: 12/17/2015 5:44:19 PM
Total users in database myfirstdb: 2
**** View Permissions for Alice ****
Total permissions for Alice: 0
**** View Permissions for Tom ****
Total permissions for Tom: 0
**** Create Permission Alice Collection Access for Alice ****
Created new permission
Permission ID: Alice Collection Access
Resource ID: kV5oAC56NwDON1RduEoCAA==
Permission Mode: All
Token: type=resource&ver=1&sig=zB6hfvvleC0oGGbq5cc67w==;Zt3Lx
Ol14h8pd6/tyF1h62zbZKk9VwEIATIldw4ZyipQGW951kirueAKdeb3MxzQ7eCvDfvp7Y/ZxFpnip/D G
JYcPyim5cf+dgLvos6fUuiKSFSul7uEKqp5JmJqUCyAvD7w+qt1Qr1PmrJDyAIgbZDBFWGe2VT9FaBH o
PYwrLjRlnH0AxfbrR+T/UpWMSSHtLB8JvNFZNSH8hRjmQupuTSxCTYEC89bZ/pS6fNmNg8=;
Timestamp: 12/17/2015 5:44:28 PM
**** Create Permission Tom Collection Access for Tom ****
Created new permission
Permission ID: Tom Collection Access
Resource ID: kV5oAALxKgCMai3JKWdfAA==
Permission Mode: Read
Token: type=resource&ver=1&sig=ieBHKeyi6EY9ZOovDpe76w==;92gwq
V4AxKaCJ2dLS02VnJiig/5AEbPcfo1xvOjR10uK3a3FUMFULgsaK8nzxdz6hLVCIKUj6hvMOTOSN8Lt 7
i30mVqzpzCfe7JO3TYSJEI9D0/5HbMIEgaNJiCu0JPPwsjVecTytiLN56FHPguoQZ7WmUAhVTA0IMP6 p
jQpLDgJ43ZaG4Zv3qWJiO689balD+egwiU2b7RICH4j6R66UVye+GPxq/gjzqbHwx79t54=;
Timestamp: 12/17/2015 5:44:30 PM
**** View Permissions for Alice ****
Permission #1
Permission ID: Alice Collection Access
Resource ID: kV5oAC56NwDON1RduEoCAA==
Permission Mode: All
Token: type=resource&ver=1&sig=BSzz/VNe9j4IPJ9M31Mf4Q==;Tcq/B
X50njB1vmANZ/4aHj/3xNkghaqh1OfV95JMi6j4v7fkU+gyWe3mJasO3MJcoop9ixmVnB+RKOhFaSxE l
P37SaGuIIik7GAWS+dcEBWglMefc95L2YkeNuZsjmmW5b+a8ELCUg7N45MKbpzkp5BrmmGVJ7h4Z4pf D
rdmehYLuxSPLkr9ndbOOrD8E3bux6TgXCsgYQscpIlJHSKCKHUHfXWBP2Y1LV2zpJmRjis=;
Timestamp: 12/17/2015 5:44:28 PM
Total permissions for Alice: 1
**** View Permissions for Tom ****
Permission #1
Permission ID: Tom Collection Access
Resource ID: kV5oAALxKgCMai3JKWdfAA==
Permission Mode: Read
Token: type=resource&ver=1&sig=NPkWNJp1mAkCASE8KdR6PA==;ur/G2
V+fDamBmzECux000VnF5i28f8WRbPwEPxD1DMpFPqYcu45wlDyzT5A5gBr3/R3qqYkEVn8bU+een6Gl j
L6vXzIwsZfL12u/1hW4mJT2as2PWH3eadry6Q/zRXHAxV8m+YuxSzlZPjBFyJ4Oi30mrTXbBAEafZhA 5
yvbHkpLmQkLCERy40FbIFOzG87ypljREpwWTKC/z8RSrsjITjAlfD/hVDoOyNJwX3HRaz4=;
Timestamp: 12/17/2015 5:44:30 PM
Total permissions for Tom: 1
**** Delete Permission Alice Collection Access from Alice ****
Deleted permission Alice Collection Access from user Alice
**** Delete Permission Tom Collection Access from Tom ****
Deleted permission Tom Collection Access from user Tom
**** Delete User Alice in myfirstdb ****
Deleted user Alice from database myfirstdb
**** Delete User Tom in myfirstdb ****
Deleted user Tom from database myfirstdb
Bu bölümde, DocumentDB'de depolanan verilerin nasıl görselleştirileceğini öğreneceğiz. Microsoft, verilerinizi zengin görsellere dönüştüren Power BI Masaüstü aracı sağladı. Ayrıca çeşitli veri kaynaklarından veri almanıza, verileri birleştirmenize ve dönüştürmenize, güçlü raporlar ve görselleştirmeler oluşturmanıza ve raporları Power BI'da yayımlamanıza olanak tanır.
Power BI Desktop'ın en son sürümünde Microsoft, DocumentDB için de destek ekledi ve artık DocumentDB hesabınıza bağlanabilirsiniz. Bu aracı linkten indirebilirsiniz,https://powerbi.microsoft.com
Son bölümde içe aktarılan deprem verilerini görselleştireceğimiz bir örneğe bakalım.
Step 1 - Araç indirildikten sonra Power BI masaüstünü başlatın.
Step 2 - Dış Veri grubu altındaki Ana Sayfa sekmesinde bulunan 'Veri Al' seçeneğine tıklayın ve Veri Al sayfasını görüntüleyecektir.
Step 3 - Microsoft Azure DocumentDB (Beta) seçeneğini seçin ve 'Bağlan' düğmesini tıklayın.
Step 4 - Verileri görselleştirmek istediğiniz Azure DocumentDB hesabınızın, Veritabanınızın ve Koleksiyonunuzun URL'sini girin ve Tamam'a basın.
Bu uç noktaya ilk kez bağlanıyorsanız, hesap anahtarını girmeniz istenecektir.
Step 5 - Azure portalında bulunan her DocumentDB hesabı için benzersiz olan hesap anahtarını (birincil anahtar) girin ve ardından Bağlan'a tıklayın.
Hesap başarıyla bağlandığında, verileri belirtilen veri tabanından alır. Önizleme bölmesi Kayıt öğelerinin bir listesini gösterir; bir Belge, Power BI'da Kayıt türü olarak temsil edilir.
Step 6 - Sorgu Düzenleyicisini başlatacak olan 'Düzenle' düğmesini tıklayın.
Step 7 - Power BI Sorgu Düzenleyicisi'nde, orta bölmede bir Belge sütunu görmeli, Belge sütun başlığının sağ tarafındaki genişleticiye tıklamalı ve görüntülenmesini istediğiniz sütunları seçmelisiniz.
Gördüğünüz gibi ayrı bir sütun olarak enlem ve boylamımız var ama verileri enlem, boylam koordinatları biçiminde görselleştiriyoruz.
Step 8 - Bunu yapmak için 'Sütun Ekle' sekmesini tıklayın.
Step 9 - Aşağıdaki sayfayı görüntüleyecek Özel Sütun Ekle'yi seçin.
Step 10- Yeni sütun adını belirtin, LatLong diyelim ve ayrıca enlem ve boylamı virgülle ayrılmış bir sütunda birleştirecek formülü belirtin. Formül aşağıdadır.
Text.From([latitude])&", "&Text.From([longitude])
Step 11 - Devam etmek için Tamam'ı tıklayın ve yeni sütunun eklendiğini göreceksiniz.
Step 12 - Ana Sayfa sekmesine gidin ve 'Kapat ve Uygula' seçeneğini tıklayın.
Step 13- Alanları Rapor tuvaline sürükleyip bırakarak raporlar oluşturabilirsiniz. Sağda görebilirsiniz, iki bölme vardır - biri Görselleştirmeler bölmesi ve diğeri Alanlar bölmesidir.
Her depremin yerini gösteren bir harita görünümü oluşturalım.
Step 14 - Harita görsel türünü Görselleştirmeler bölmesinden sürükleyin.
Step 15- Şimdi, LatLong alanını Alanlar bölmesinden Görselleştirmeler bölmesindeki Konum özelliğine sürükleyip bırakın. Ardından, büyüklük alanını Values özelliğine sürükleyip bırakın.
Step 16 - Derinlik alanını Renk doygunluğu özelliğine sürükleyip bırakın.
Şimdi her depremin konumunu gösteren bir dizi baloncuk gösteren Harita görselini göreceksiniz.