DocumentDB - Panduan Cepat
Pada bab ini, kita akan membahas secara singkat konsep-konsep utama seputar NoSQL dan database dokumen. Kami juga akan memiliki gambaran umum singkat tentang DocumentDB.
Database Dokumen NoSQL
DocumentDB adalah database dokumen NoSQL terbaru dari Microsoft, jadi ketika Anda mengatakan database dokumen NoSQL lalu, apa tepatnya yang kami maksud dengan NoSQL, dan database dokumen?
SQL berarti Bahasa Kueri Terstruktur yang merupakan bahasa kueri tradisional dari database relasional. SQL sering disamakan dengan database relasional.
Ini benar-benar lebih membantu untuk memikirkan database NoSQL sebagai database non-relasional, jadi NoSQL benar-benar berarti non-relasional.
Ada berbagai jenis database NoSQL yang mencakup penyimpanan nilai kunci seperti -
- Penyimpanan Meja Azure.
- Toko berbasis kolom seperti Cassandra.
- Database grafik seperti NEO4.
- Database dokumen seperti MongoDB dan Azure DocumentDB.
Azure DocumentDB
Microsoft secara resmi meluncurkan Azure DocumentDB pada tanggal 8 April th 2015, dan tentu saja dapat dicirikan sebagai database dokumen yang khas NoSQL. Ini sangat skalabel, dan berfungsi dengan dokumen JSON tanpa skema.
DocumentDB adalah layanan database dokumen NoSQL bebas skema yang dirancang untuk aplikasi seluler dan web modern.
Ini juga memberikan pembacaan dan penulisan yang cepat secara konsisten, fleksibilitas skema, dan kemampuan untuk dengan mudah menaikkan dan menurunkan skala database sesuai permintaan.
Itu tidak mengasumsikan atau memerlukan skema apa pun untuk dokumen JSON yang diindeksnya.
DocumentDB secara otomatis mengindeks setiap properti dalam dokumen segera setelah dokumen ditambahkan ke database.
DocumentDB memungkinkan kueri ad-hoc yang kompleks menggunakan bahasa SQL, dan setiap dokumen langsung dapat dikueri saat dibuat, dan Anda dapat mencari di properti apa pun di mana pun dalam hierarki dokumen.
DocumentDB - Harga
DocumentDB ditagih berdasarkan jumlah koleksi yang terdapat dalam akun database. Setiap akun dapat memiliki satu atau lebih database dan setiap database dapat memiliki jumlah koleksi yang hampir tidak terbatas, meskipun ada kuota default awal 100. Kuota ini dapat dicabut dengan menghubungi dukungan Azure.
Koleksi tidak hanya satuan skala, tetapi juga satuan biaya, jadi di DocumentDB Anda membayar per koleksi, yang memiliki kapasitas penyimpanan hingga 10 GB.
Minimal, Anda memerlukan satu koleksi S1 untuk menyimpan dokumen dalam database yang biayanya kira-kira $ 25 per bulan, yang akan ditagih terhadap langganan Azure Anda.
Saat database Anda bertambah besar dan melebihi 10 GB, Anda harus membeli koleksi lain untuk memuat data tambahan.
Setiap koleksi S1 akan memberi Anda 250 unit permintaan per detik, dan jika itu tidak cukup, Anda dapat menskalakan koleksi hingga S2 dan mendapatkan 1.000 unit permintaan per detik dengan harga sekitar $ 50 per bulan.
Anda juga dapat mengubahnya hingga S3 dan membayar sekitar $ 100 sebulan.
DocumentDB menonjol dengan beberapa kemampuan yang sangat unik. Azure DocumentDB menawarkan kapabilitas dan manfaat utama berikut.
Skema Gratis
Dalam database relasional, setiap tabel memiliki skema yang menentukan kolom dan tipe data yang harus dipatuhi oleh setiap baris dalam tabel.
Sebaliknya, database dokumen tidak memiliki skema yang ditentukan, dan setiap dokumen dapat disusun secara berbeda.
Sintaks SQL
DocumentDB memungkinkan kueri ad-hoc yang kompleks menggunakan bahasa SQL, dan setiap dokumen langsung dapat dikueri saat dibuat. Anda dapat mencari di properti mana saja di dalam hierarki dokumen.
Konsistensi Merdu
Ini memberikan beberapa tingkat konsistensi yang terperinci dan terdefinisi dengan baik, yang memungkinkan Anda membuat trade-off yang baik antara konsistensi, ketersediaan, dan latensi.
Anda dapat memilih dari empat tingkat konsistensi yang ditentukan dengan baik untuk mencapai trade-off yang optimal antara konsistensi dan kinerja. Untuk kueri dan operasi baca, DocumentDB menawarkan empat tingkat konsistensi yang berbeda -
- Strong
- Bounded-staleness
- Session
- Eventual
Skala Elastis
Skalabilitas adalah nama permainan dengan NoSQL, dan DocumentDB memberikannya. DocumentDB telah membuktikan skalanya.
Layanan utama seperti Office OneNote dan Xbox sudah didukung oleh DocumentDB dengan database yang berisi puluhan terabyte dokumen JSON, lebih dari satu juta pengguna aktif, dan beroperasi secara konsisten dengan ketersediaan 99,95%.
Anda dapat menskalakan DocumentDB secara elastis dengan kinerja yang dapat diprediksi dengan membuat lebih banyak unit saat aplikasi Anda berkembang.
Terkelola Sepenuhnya
DocumentDB tersedia sebagai platform berbasis cloud yang terkelola sepenuhnya sebagai layanan yang berjalan di Azure.
Tidak ada yang perlu Anda instal atau kelola.
Tidak ada server, kabel, tidak ada sistem operasi atau pembaruan yang harus ditangani, tidak ada replika yang harus disiapkan.
Microsoft melakukan semua itu dan menjaga layanan tetap berjalan.
Dalam hitungan menit, Anda dapat mulai bekerja dengan DocumentDB hanya dengan menggunakan browser dan langganan Azure.
Microsoft menyediakan versi gratis dari Visual Studio yang juga berisi SQL Server dan dapat diunduh dari https://www.visualstudio.com
Instalasi
Step 1- Setelah pengunduhan selesai, jalankan penginstal. Dialog berikut akan ditampilkan.
Step 2 - Klik pada tombol Install dan itu akan memulai proses instalasi.
Step 3 - Setelah proses instalasi selesai dengan sukses, Anda akan melihat dialog berikut.
Step 4 - Tutup dialog ini dan restart komputer Anda jika diperlukan.
Step 5- Sekarang buka Visual studio dari Start Menu yang akan membuka dialog di bawah ini. Ini akan memakan waktu untuk pertama kalinya hanya untuk persiapan.
Setelah semuanya selesai, Anda akan melihat jendela utama Visual Studio.
Step 6 - Mari buat proyek baru dari File → New → Project.
Step 7 - Pilih Aplikasi Konsol, masukkan DocumentDBDemo di bidang Nama dan klik tombol OK.
Step 8 - Di Solution Explorer, klik kanan pada proyek Anda.
Step 9 - Pilih Kelola Paket NuGet yang akan membuka jendela berikut di Visual Studio dan di kotak input Pencarian Online, cari Perpustakaan Klien DocumentDB.
Step 10 - Instal versi terbaru dengan mengklik tombol instal.
Step 11- Klik "Saya Setuju". Setelah instalasi selesai, Anda akan melihat pesan di jendela output Anda.
Anda sekarang siap untuk memulai aplikasi Anda.
Untuk menggunakan Microsoft Azure DocumentDB, Anda harus membuat akun DocumentDB. Di bab ini, kami akan membuat akun DocumentDB menggunakan portal Azure.
Step 1 - Masuk ke online https://portal.azure.com jika Anda sudah memiliki langganan Azure jika tidak, Anda harus masuk terlebih dahulu.
Anda akan melihat Dashboard utama. Ini sepenuhnya dapat disesuaikan sehingga Anda dapat mengatur ubin ini sesuka Anda, mengubah ukurannya, menambah dan menghapus ubin untuk hal-hal yang sering Anda gunakan atau tidak lagi lakukan.
Step 2 - Pilih opsi 'Baru' di sisi kiri atas halaman.
Step 3 - Sekarang pilih Data + Storage> opsi Azure DocumentDB dan Anda melihat bagian akun New DocumentDB berikut.
Kita perlu membuat nama (ID) yang unik secara global, yang dikombinasikan dengan .documents.azure.com adalah titik akhir yang dapat dialamatkan secara publik ke akun DocumentDB kita. Semua database yang kami buat di bawah akun itu dapat diakses melalui internet menggunakan titik akhir ini.
Step 4 - Beri nama azuredocdbdemo dan klik Resource Group → new_resource.
Step 5- Pilih lokasi, misalnya, pusat data Microsoft mana Anda ingin akun ini dihosting. Pilih lokasi dan pilih wilayah Anda.
Step 6 - Centang kotak Pin to dashboard dan langsung saja klik tombol Create.
Anda dapat melihat bahwa ubin telah ditambahkan ke Dasbor, dan ubin tersebut memberi tahu kami bahwa akun tersebut sedang dibuat. Sebenarnya diperlukan beberapa menit untuk mengatur berbagai hal untuk akun baru sementara DocumentDB mengalokasikan titik akhir, menyediakan replika, dan melakukan pekerjaan lain di latar belakang.
Setelah selesai, Anda akan melihat dasbor.
Step 7 - Sekarang klik pada akun DocumentDB yang dibuat dan Anda akan melihat layar detail seperti gambar berikut.
Saat Anda memulai pemrograman terhadap DocumentDB, langkah pertama adalah menghubungkan. Jadi untuk terhubung ke akun DocumentDB Anda, Anda memerlukan dua hal;
- Endpoint
- Kunci Otorisasi
Titik akhir
Endpoint adalah URL ke akun DocumentDB Anda dan dibuat dengan menggabungkan nama akun DocumentDB Anda dengan .documents.azure.com. Ayo pergi ke Dashboard.
Sekarang, klik pada akun DocumentDB yang dibuat. Anda akan melihat detailnya seperti yang ditunjukkan pada gambar berikut.
Ketika Anda memilih opsi 'Kunci', itu akan menampilkan informasi tambahan seperti yang ditunjukkan pada gambar berikut. Anda juga akan melihat URL ke akun DocumentDB Anda, yang dapat Anda gunakan sebagai titik akhir.
Kunci Otorisasi
Kunci otorisasi berisi kredensial Anda dan ada dua jenis kunci. Kunci master memungkinkan akses penuh ke semua sumber daya dalam akun, sementara token sumber daya mengizinkan akses terbatas ke sumber daya tertentu.
Kunci Master
Tidak ada yang tidak dapat Anda lakukan dengan kunci master. Anda dapat menghapus seluruh database Anda jika Anda mau, menggunakan kunci master.
Untuk alasan ini, Anda pasti tidak ingin membagikan kunci master atau mendistribusikannya ke lingkungan klien. Sebagai langkah keamanan tambahan, sebaiknya sering-seringlah mengubahnya.
Sebenarnya ada dua kunci master untuk setiap akun database, primer dan sekunder seperti yang disorot pada gambar di atas.
Token Sumber Daya
Anda juga dapat menggunakan token sumber daya sebagai ganti kunci master.
Koneksi berdasarkan token sumber daya hanya dapat mengakses sumber daya yang ditentukan oleh token dan tidak ada sumber daya lainnya.
Token sumber daya didasarkan pada izin pengguna, jadi pertama-tama Anda membuat satu atau beberapa pengguna, dan ini ditentukan di tingkat database.
Anda membuat satu atau beberapa izin untuk setiap pengguna, berdasarkan sumber daya yang ingin Anda izinkan untuk mengakses setiap pengguna.
Setiap izin menghasilkan token sumber daya yang memungkinkan akses hanya-baca atau akses penuh ke sumber daya yang diberikan dan itu bisa menjadi sumber daya pengguna apa pun dalam database.
Mari kita pergi ke aplikasi konsol yang dibuat di bab 3.
Step 1 - Tambahkan referensi berikut di file Program.cs.
using Microsoft.Azure.Documents;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents.Linq;
using Newtonsoft.Json;Step 2- Sekarang tambahkan URL Endpoint dan kunci Otorisasi. Dalam contoh ini kami akan menggunakan kunci utama sebagai kunci Otorisasi.
Perhatikan bahwa dalam kasus Anda, URL Endpoint dan kunci otorisasi harus berbeda.
private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/";
private const string AuthorizationKey =
"BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";Step 3 - Buat instance baru DocumentClient dalam tugas asinkron yang disebut CreateDocumentClient dan buat instance DocumentClient baru.
Step 4 - Panggil tugas asinkron Anda dari metode Utama Anda.
Berikut adalah file Program.cs selengkapnya sejauh ini.
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);
}
}
}Dalam bab ini, kita telah mempelajari cara menghubungkan ke akun DocumentDB dan membuat instance kelas DocumentClient.
Pada bab ini, kita akan mempelajari cara membuat database. Untuk menggunakan Microsoft Azure DocumentDB, Anda harus memiliki akun DocumentDB, database, koleksi, dan dokumen. Kami sudah memiliki akun DocumentDB, sekarang untuk membuat database kami memiliki dua opsi -
- Portal Microsoft Azure atau
- .Net SDK
Buat Database untuk DocumentDB menggunakan Portal Microsoft Azure
Untuk membuat database menggunakan portal, berikut langkah-langkahnya.
Step 1 - Masuk ke portal Azure dan Anda akan melihat dasbor.
Step 2 - Sekarang klik pada akun DocumentDB yang dibuat dan Anda akan melihat detailnya seperti yang ditunjukkan pada tangkapan layar berikut.
Step 3 - Pilih opsi Add Database dan berikan ID untuk database Anda.
Step 4 - Klik OK.
Anda dapat melihat bahwa database telah ditambahkan. Saat ini tidak memiliki koleksi, tetapi kita dapat menambahkan koleksi nanti yang merupakan wadah yang akan menyimpan dokumen JSON kita. Perhatikan bahwa ia memiliki ID dan ID Sumber Daya.
Buat Database untuk DocumentDB Menggunakan .Net SDK
Untuk membuat database menggunakan .Net SDK, berikut langkah-langkahnya.
Step 1 - Buka Aplikasi Konsol di Visual Studio dari bab terakhir.
Step 2- Buat database baru dengan membuat objek database baru. Untuk membuat database baru, kita hanya perlu menetapkan properti Id, yang kita setel ke "mynewdb" di tugas CreateDatabase.
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- Sekarang teruskan databaseDefinition ini ke CreateDatabaseAsync, dan dapatkan kembali hasilnya dengan properti Resource. Semua metode buat objek mengembalikan properti Sumber Daya yang menjelaskan item yang dibuat, yang dalam kasus ini adalah database.
Kami mendapatkan objek database baru dari properti Resource dan itu ditampilkan di Konsol bersama dengan ID Sumber Daya yang ditetapkan oleh DocumentDB padanya.
Step 4 - Sekarang panggil tugas CreateDatabase dari tugas CreateDocumentClient setelah DocumentClient dibuat.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await CreateDatabase(client);
}Berikut adalah file Program.cs selengkapnya sejauh ini.
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 *******");
}
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut yang berisi ID Database dan Sumber Daya.
******** Create Database *******
Database Id: mynewdb; Rid: ltpJAA==
******** Database Created *******Sejauh ini, kami telah membuat dua database di akun DocumentDB kami, yang pertama dibuat menggunakan portal Azure sedangkan database kedua dibuat menggunakan .Net SDK. Sekarang untuk melihat database ini, Anda dapat menggunakan portal Azure.
Buka akun DocumentDB Anda di portal Azure dan Anda akan melihat dua database sekarang.
Anda juga dapat melihat atau membuat daftar database dari kode Anda menggunakan .Net SDK. Berikut adalah langkah-langkahnya.
Step 1 - Menerbitkan Query database tanpa parameter yang mengembalikan daftar lengkap, tapi Anda juga bisa meneruskan query untuk mencari database tertentu atau database tertentu.
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);
}Anda akan melihat bahwa ada banyak metode CreateQuery ini untuk menemukan koleksi, dokumen, pengguna, dan sumber daya lainnya. Metode ini tidak benar-benar mengeksekusi kueri, mereka hanya mendefinisikan kueri dan mengembalikan objek yang dapat diulang.
Ini adalah panggilan ke ToList () yang benar-benar menjalankan kueri, mengulang hasilnya, dan mengembalikannya dalam daftar.
Step 2 - Panggil metode GetDatabases dari tugas CreateDocumentClient setelah DocumentClient dibuat.
Step 3 - Anda juga perlu memberi komentar pada tugas CreateDatabase atau mengubah id database, jika tidak, Anda akan mendapatkan pesan error bahwa database tersebut ada.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
//await CreateDatabase(client);
GetDatabases(client);
}Berikut adalah file Program.cs selengkapnya sejauh ini.
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);
}
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut yang berisi ID Database dan Sumber Daya dari kedua database. Pada akhirnya Anda juga akan melihat jumlah total database.
******** Get Databases List ********
Database Id: myfirstdb; Rid: Ic8LAA==
Database Id: mynewdb; Rid: ltpJAA==
Total databases: 2Anda dapat melepaskan database atau database dari portal serta dari kode dengan menggunakan .Net SDK. Di sini, kita akan membahas, secara bertahap, cara menjatuhkan database di DocumentDB.
Step 1- Buka akun DocumentDB Anda di portal Azure. Untuk tujuan demo, saya telah menambahkan dua database lagi seperti yang terlihat pada tangkapan layar berikut.
Step 2- Untuk menjatuhkan database apa pun, Anda perlu mengklik database itu. Mari pilih tempdb, Anda akan melihat halaman berikut, pilih opsi 'Hapus Database'.
Step 3 - Ini akan menampilkan pesan konfirmasi, sekarang klik tombol 'Ya'.
Anda akan melihat bahwa tempdb tidak lagi tersedia di dasbor Anda.
Anda juga dapat menghapus database dari kode Anda menggunakan .Net SDK. Untuk melakukan berikut ini adalah langkah-langkahnya.
Step 1 - Mari kita hapus database dengan menentukan ID dari database yang ingin kita hapus, tetapi kita membutuhkan SelfLink-nya.
Step 2 - Kami memanggil CreateDatabaseQuery seperti sebelumnya, tetapi kali ini kami sebenarnya menyediakan kueri untuk mengembalikan hanya satu database dengan ID tempdb1.
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- Kali ini, kita bisa memanggil AsEnumerable daripada ToList () karena sebenarnya kita tidak membutuhkan objek list. Hanya mengharapkan hasil, memanggil AsEnumerable sudah cukup sehingga kita bisa mendapatkan objek database pertama yang dikembalikan oleh kueri dengan First (). Ini adalah objek database untuk tempdb1 dan memiliki SelfLink yang dapat kita gunakan untuk memanggil DeleteDatabaseAsync yang menghapus database.
Step 4 - Anda juga perlu memanggil tugas DeleteDatabase dari tugas CreateDocumentClient setelah DocumentClient dibuat.
Step 5 - Untuk melihat daftar database setelah menghapus database yang ditentukan, mari kita panggil metode GetDatabases lagi.
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
//await CreateDatabase(client);
GetDatabases(client);
await DeleteDatabase(client);
GetDatabases(client);
}Berikut adalah file Program.cs selengkapnya sejauh ini.
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);
}
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut yang berisi ID Database dan Sumber Daya dari tiga database dan jumlah total database.
******** 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: 2Setelah menghapus database, Anda juga akan melihat di bagian akhir bahwa hanya dua database yang tersisa di akun DocumentDB.
Pada bab ini, kita akan belajar bagaimana membuat sebuah koleksi. Ini mirip dengan membuat database. Anda dapat membuat koleksi baik dari portal atau dari kode menggunakan .Net SDK.
Step 1 - Buka dasbor utama di portal Azure.
Step 2 - Pilih myfirstdb dari daftar database.
Step 3- Klik opsi 'Tambah Koleksi' dan tentukan ID untuk koleksi. Pilih Tingkat Harga untuk opsi yang berbeda.
Step 4 - Pilih S1 Standard dan klik tombol Select → OK.
Seperti yang Anda lihat, MyCollection ditambahkan ke myfirstdb.
Anda juga dapat membuat koleksi dari kode dengan menggunakan .Net SDK. Mari kita lihat langkah-langkah berikut untuk menambahkan koleksi dari kode.
Step 1 - Buka aplikasi Konsol di Visual Studio.
Step 2 - Untuk membuat koleksi, pertama-tama ambil database myfirstdb dengan ID-nya di tugas CreateDocumentClient.
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");
}
}Berikut adalah implementasi untuk tugas CreateCollection.
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);
}Kami membuat objek DocumentCollection baru yang mendefinisikan koleksi baru dengan Id yang diinginkan untuk metode CreateDocumentCollectionAsync yang juga menerima parameter opsi yang kami gunakan di sini untuk menyetel tingkat kinerja koleksi baru, yang kami sebut offerType.
Ini defaultnya ke S1 dan karena kita tidak mengirimkan offerType, untuk MyCollection1, jadi ini akan menjadi koleksi S1 dan untuk MyCollection2 kita telah lulus S2 yang membuat ini S2 seperti yang ditunjukkan di atas.
Berikut adalah implementasi metode ViewCollection.
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);
}Berikut implementasi lengkap file program.cs untuk koleksi.
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);
}
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut yang berisi semua informasi yang berkaitan dengan collection.
**** 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 PMUntuk menjatuhkan koleksi atau koleksi Anda dapat melakukan hal yang sama dari portal serta dari kode dengan menggunakan .Net SDK.
Step 1- Buka akun DocumentDB Anda di portal Azure. Untuk tujuan demo, saya telah menambahkan dua koleksi lagi seperti yang terlihat pada tangkapan layar berikut.
Step 2- Untuk menjatuhkan koleksi apa pun, Anda perlu mengklik koleksi itu. Mari pilih TempCollection1. Anda akan melihat halaman berikut, pilih opsi 'Hapus Koleksi'.
Step 3- Ini akan menampilkan pesan konfirmasi. Sekarang klik tombol 'Ya'.
Anda akan melihat bahwa TempCollection1 tidak lagi tersedia di dasbor Anda.
Anda juga dapat menghapus koleksi dari kode Anda menggunakan .Net SDK. Untuk melakukannya, berikut adalah langkah-langkah berikut ini.
Step 1 - Mari hapus koleksi dengan menentukan ID dari koleksi yang ingin kita hapus.
Ini adalah pola kueri yang biasa dilakukan oleh Id untuk mendapatkan tautan mandiri yang diperlukan untuk menghapus sumber daya.
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);
}Di sini kita melihat cara yang disukai untuk membuat kueri berparameter. Kami tidak melakukan hardcode collectionId sehingga metode ini dapat digunakan untuk menghapus koleksi apa pun. Kami membuat kueri untuk koleksi tertentu berdasarkan Id di mana parameter Id ditentukan dalam SqlParameterCollection yang ditetapkan ke properti parameter dari SqlQuerySpec ini.
Kemudian SDK melakukan pekerjaan membangun string kueri akhir untuk DocumentDB dengan collectionId yang disematkan di dalamnya.
Step 2 - Jalankan kueri lalu gunakan Tautan Otomatisnya untuk menghapus koleksi dari tugas CreateDocumentClient.
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");
}
}Berikut implementasi lengkap file Program.cs.
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);
}
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** Delete Collection TempCollection in myfirstdb ****
Deleted collection TempCollection from database myfirstdbDalam bab ini, kita akan mulai bekerja dengan dokumen aktual dalam sebuah koleksi. Anda dapat membuat dokumen menggunakan portal Azure atau .Net SDK.
Membuat Dokumen dengan Azure Portal
Mari kita lihat langkah-langkah berikut untuk menambahkan dokumen ke koleksi Anda.
Step 1 - Tambahkan koleksi baru Keluarga tingkat harga S1 di myfirstdb.
Step 2 - Pilih koleksi Keluarga dan klik opsi Buat Dokumen untuk membuka bilah Dokumen Baru.
Ini hanyalah editor teks sederhana yang memungkinkan Anda mengetik JSON apa pun untuk dokumen baru.
Step 3 - Karena ini adalah entri data mentah, mari kita masukkan dokumen pertama kita.
{
"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
}Saat Anda memasukkan dokumen di atas, Anda akan melihat layar berikut.
Perhatikan bahwa kami telah memberikan id untuk dokumen tersebut. Nilai id selalu diperlukan, dan harus unik di semua dokumen lain dalam koleksi yang sama. Ketika Anda membiarkannya, maka DocumentDB secara otomatis akan membuatkannya untuk Anda menggunakan GUID atau Pengenal Unik Secara Global.
Id selalu berupa string dan tidak boleh berupa angka, tanggal, Boolean, atau objek lain, dan tidak boleh lebih dari 255 karakter.
Perhatikan juga struktur hierarki dokumen yang memiliki beberapa properti tingkat atas seperti id yang diperlukan, serta lastName dan isRegistered, tetapi juga memiliki properti bertingkat.
Misalnya, properti orang tua diberikan sebagai larik JSON seperti yang dilambangkan dengan tanda kurung siku. Kami juga memiliki array lain untuk anak-anak, meskipun hanya ada satu anak dalam array dalam contoh ini.
Step 4 - Klik tombol 'Simpan' untuk menyimpan dokumen dan kami telah membuat dokumen pertama kami.
Seperti yang Anda lihat, pemformatan cantik telah diterapkan ke JSON kami, yang memecah setiap properti pada barisnya sendiri yang diberi jarak untuk menyampaikan tingkat bertingkat dari setiap properti.
Portal menyertakan Document Explorer, jadi mari gunakan itu sekarang untuk mengambil dokumen yang baru kita buat.
Step 5- Pilih database dan koleksi apa pun dalam database untuk melihat dokumen dalam koleksi itu. Saat ini kami hanya memiliki satu database bernama myfirstdb dengan satu koleksi bernama Keluarga, keduanya telah dipilih sebelumnya di sini di menu tarik-turun.
Secara default, Penjelajah Dokumen menampilkan daftar dokumen yang tidak difilter dalam koleksi, tetapi Anda juga dapat mencari dokumen tertentu berdasarkan ID atau beberapa dokumen berdasarkan pencarian karakter pengganti dari sebagian ID.
Kami hanya memiliki satu dokumen dalam koleksi kami sejauh ini, dan kami melihat ID-nya di layar berikut, AndersonFamily.
Step 6 - Klik ID untuk melihat dokumen.
Membuat Dokumen dengan .NET SDK
Seperti yang Anda ketahui bahwa dokumen hanyalah jenis sumber daya lain dan Anda sudah terbiasa dengan cara menangani sumber daya menggunakan SDK.
Satu perbedaan besar antara dokumen dan sumber daya lainnya adalah, tentu saja, mereka bebas skema.
Jadi ada banyak sekali pilihan. Biasanya, Anda hanya dapat mengerjakan grafik objek JSON atau bahkan string mentah teks JSON, tetapi Anda juga dapat menggunakan objek dinamis yang memungkinkan Anda mengikat ke properti pada waktu proses tanpa menentukan kelas pada waktu kompilasi.
Anda juga dapat bekerja dengan objek C # nyata, atau Entitas sebagaimana namanya, yang mungkin merupakan kelas domain bisnis Anda.
Mari mulai membuat dokumen menggunakan .Net SDK. Berikut langkah-langkahnya.
Step 1 - Instantiate DocumentClient kemudian kita akan melakukan kueri untuk database myfirstdb dan kemudian melakukan kueri untuk koleksi MyCollection, yang kita simpan dalam koleksi variabel pribadi ini sehingga dapat diakses di seluruh kelas.
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 - Buat beberapa dokumen dalam tugas CreateDocuments.
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();
}Dokumen pertama akan dibuat dari objek dinamis ini. Ini mungkin terlihat seperti JSON, tetapi tentu saja tidak. Ini adalah kode C # dan kami membuat objek NET nyata, tetapi tidak ada definisi kelas. Sebaliknya, properti disimpulkan dari cara objek diinisialisasi.
Perhatikan bahwa kami belum menyediakan properti Id untuk dokumen ini.
Sekarang mari kita lihat CreateDocument. Sepertinya pola yang sama yang kita lihat untuk membuat database dan koleksi.
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- Kali ini kita memanggil CreateDocumentAsync yang menetapkan Tautan Mandiri dari koleksi yang ingin kita tambahkan dokumennya. Kami mendapatkan kembali respons dengan properti sumber daya yang, dalam hal ini, mewakili dokumen baru dengan properti yang dihasilkan sistem.
Objek Dokumen adalah kelas yang ditentukan dalam SDK yang diwarisi dari sumber daya sehingga memiliki semua properti sumber daya yang sama, tetapi juga menyertakan properti dinamis yang menentukan dokumen bebas skema itu sendiri.
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();
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** 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 objectSeperti yang Anda lihat, kami belum memberikan Id, namun DocumentDB membuat ini untuk kami untuk dokumen baru.
Di DocumentDB, kami benar-benar menggunakan SQL untuk melakukan kueri dokumen, jadi bab ini adalah tentang kueri menggunakan sintaks SQL khusus di DocumentDB. Meskipun jika Anda melakukan pengembangan .NET, ada juga penyedia LINQ yang dapat digunakan dan yang dapat menghasilkan SQL yang sesuai dari kueri LINQ.
Membuat Kueri Dokumen menggunakan Portal
Portal Azure memiliki Penjelajah Kueri yang memungkinkan Anda menjalankan kueri SQL apa pun terhadap database DocumentDB Anda.
Kami akan menggunakan Penjelajah Kueri untuk mendemonstrasikan berbagai kemampuan dan fitur bahasa kueri yang dimulai dengan kueri sesederhana mungkin.
Step 1 - Dalam bilah database, klik untuk membuka bilah Penjelajah Kueri.
Ingatlah bahwa kueri berjalan dalam lingkup koleksi, sehingga Penjelajah Kueri memungkinkan Anda memilih koleksi di tarik-turun ini.
Step 2 - Pilih koleksi Keluarga yang dibuat sebelumnya menggunakan portal.
Query Explorer terbuka dengan query sederhana ini SELECT * FROM c, yang hanya mengambil semua dokumen dari koleksi.
Step 3- Jalankan kueri ini dengan mengklik tombol 'Jalankan kueri'. Kemudian Anda akan melihat bahwa dokumen lengkap diambil di bilah Hasil.
Membuat Kueri Dokumen menggunakan .Net SDK
Berikut adalah langkah-langkah untuk menjalankan beberapa query dokumen menggunakan .Net SDK.
Dalam contoh ini, kami ingin menanyakan dokumen yang baru dibuat yang baru saja kami tambahkan.
Step 1 - Panggil CreateDocumentQuery, meneruskan koleksi untuk menjalankan kueri dengan SelfLink dan teks kueri.
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();
}Kueri ini juga mengembalikan semua dokumen di seluruh koleksi, tetapi kami tidak memanggil .ToList di CreateDocumentQuery seperti sebelumnya, yang akan mengeluarkan permintaan sebanyak yang diperlukan untuk menarik semua hasil dalam satu baris kode.
Step 2 - Sebaliknya, panggil AsDocumentQuery dan metode ini mengembalikan objek kueri dengan properti HasMoreResults.
Step 3 - Jika HasMoreResults benar, panggil ExecuteNextAsync untuk mendapatkan potongan berikutnya dan kemudian buang semua konten potongan itu.
Step 4- Anda juga dapat melakukan kueri menggunakan LINQ daripada SQL jika Anda mau. Di sini kita telah mendefinisikan kueri LINQ di q, tetapi tidak akan dijalankan sampai kita menjalankan .ToList di atasnya.
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 akan mengubah kueri LINQ kami menjadi sintaks SQL untuk DocumentDB, menghasilkan klausa SELECT dan WHERE berdasarkan sintaks LINQ kami
Step 5 - Sekarang panggil kueri di atas dari tugas CreateDocumentClient.
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);
}
}Ketika kode di atas dijalankan, Anda akan menerima output berikut.
**** 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: BrooklynPada bab ini, kita akan mempelajari cara memperbarui dokumen. Menggunakan portal Azure, Anda dapat dengan mudah memperbarui dokumen dengan membuka dokumen di Penjelajah dokumen dan memperbaruinya di editor seperti file teks.
Klik tombol 'Simpan'. Sekarang ketika Anda perlu mengubah dokumen menggunakan .Net SDK Anda bisa menggantinya. Anda tidak perlu menghapus dan membuatnya kembali, yang selain membosankan, juga akan mengubah id sumber daya, yang tidak ingin Anda lakukan saat Anda hanya memodifikasi dokumen. Berikut adalah langkah-langkah berikut untuk memperbarui dokumen menggunakan .Net SDK.
Mari kita lihat tugas ReplaceDocuments berikut di mana kita akan meminta dokumen di mana properti isNew benar, tetapi kita tidak akan mendapatkan apa pun karena tidak ada. Jadi, mari kita ubah dokumen yang kita tambahkan sebelumnya, yang namanya dimulai dengan Pelanggan Baru.
Step 1 - Tambahkan properti isNew ke dokumen ini dan setel nilainya menjadi true.
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 - Dapatkan dokumen diperbarui menggunakan kueri STARTSWITH yang sama dan itu memberi kami dokumen, yang kami dapatkan kembali ke sini sebagai objek dinamis.
Step 3 - Lampirkan properti isNew dan setel ke true untuk setiap dokumen.
Step 4 - Panggil ReplaceDocumentAsync, meneruskan SelfLink dokumen, bersama dengan dokumen yang diperbarui.
Sekarang hanya untuk membuktikan bahwa ini berhasil, kueri untuk dokumen di mana isNew sama dengan true. Mari panggil kueri di atas dari tugas CreateDocumentClient.
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);
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** 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: 2Di bab ini, kita akan belajar cara menghapus dokumen dari akun DocumentDB Anda. Menggunakan Azure Portal, Anda dapat dengan mudah menghapus dokumen apa pun dengan membuka dokumen di Document Explorer dan mengklik opsi 'Hapus'.
Ini akan menampilkan pesan konfirmasi. Sekarang tekan tombol Yes dan Anda akan melihat bahwa dokumen tersebut tidak lagi tersedia di akun DocumentDB Anda.
Sekarang ketika Anda ingin menghapus dokumen menggunakan .Net SDK.
Step 1- Ini adalah pola yang sama seperti yang kita lihat sebelumnya di mana kita akan melakukan kueri terlebih dahulu untuk mendapatkan Tautan Mandiri dari setiap dokumen baru. Kami tidak menggunakan SELECT * di sini, yang akan mengembalikan dokumen secara keseluruhan, yang tidak kami butuhkan.
Step 2 - Sebagai gantinya kami hanya memilih SelfLinks ke dalam daftar dan kemudian kami hanya memanggil DeleteDocumentAsync untuk setiap SelfLink, satu per satu, untuk menghapus dokumen dari koleksi.
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 - Sekarang panggil DeleteDocuments di atas dari tugas CreateDocumentClient.
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);
}
}Ketika kode di atas dijalankan, Anda akan menerima output berikut.
***** Delete Documents *****
Quering for documents to be deleted
Found 2 documents to be deleted
Deleted 2 new customer documentsMeskipun database bebas skema, seperti DocumentDB, sangat memudahkan untuk menerima perubahan pada model data Anda, Anda tetap harus meluangkan waktu untuk memikirkan data Anda.
Anda punya banyak pilihan. Biasanya, Anda hanya dapat mengerjakan grafik objek JSON atau bahkan string mentah teks JSON, tetapi Anda juga dapat menggunakan objek dinamis yang memungkinkan Anda mengikat ke properti pada waktu proses tanpa menentukan kelas pada waktu kompilasi.
Anda juga dapat bekerja dengan objek C # nyata, atau Entitas sebagaimana namanya, yang mungkin merupakan kelas domain bisnis Anda.
Hubungan
Mari kita lihat struktur hierarki dokumen. Ini memiliki beberapa properti level teratas seperti id yang diperlukan, serta lastName dan isRegistered, tetapi juga memiliki properti bertingkat.
{
"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
}Misalnya, properti orang tua diberikan sebagai larik JSON seperti yang dilambangkan dengan tanda kurung siku.
Kami juga memiliki array lain untuk anak-anak, meskipun hanya ada satu anak dalam array dalam contoh ini. Jadi ini adalah cara Anda memodelkan persamaan hubungan satu-ke-banyak dalam dokumen.
Anda cukup menggunakan array di mana setiap elemen dalam array bisa berupa nilai sederhana atau objek kompleks lainnya, bahkan array lain.
Jadi, satu keluarga dapat memiliki banyak orang tua dan beberapa anak dan jika Anda melihat objek turunan, mereka memiliki properti hewan peliharaan yang merupakan larik bersarang untuk hubungan oneto-many antara anak-anak dan hewan peliharaan.
Untuk properti lokasi, kami menggabungkan tiga properti terkait, negara bagian, kabupaten, dan kota menjadi sebuah objek.
Menyematkan objek dengan cara ini daripada menyematkan larik objek mirip dengan memiliki hubungan satu-ke-satu antara dua baris dalam tabel terpisah dalam database relasional.
Menyematkan Data
Saat Anda mulai membuat model data di penyimpanan dokumen, seperti DocumentDB, coba perlakukan entitas Anda sebagai dokumen mandiri yang direpresentasikan dalam JSON. Saat bekerja dengan database relasional, kami selalu menormalkan data.
Normalisasi data Anda biasanya melibatkan pengambilan entitas, seperti pelanggan, dan memecahnya menjadi potongan-potongan data rahasia, seperti detail kontak dan alamat.
Untuk membaca pelanggan, dengan semua detail kontak dan alamat mereka, Anda perlu menggunakan GABUNG untuk menggabungkan data Anda secara efektif pada waktu proses.
Sekarang mari kita lihat bagaimana kita akan memodelkan data yang sama sebagai entitas mandiri dalam database dokumen.
{
"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}
]
}Seperti yang Anda lihat bahwa kami telah menormalisasi catatan pelanggan di mana semua informasi pelanggan disematkan ke dalam satu dokumen JSON.
Di NoSQL kami memiliki skema gratis, sehingga Anda dapat menambahkan detail kontak dan alamat dalam format yang berbeda juga. Di NoSQL, Anda dapat mengambil catatan pelanggan dari database dalam satu operasi baca. Demikian pula, memperbarui rekaman juga merupakan operasi tulis tunggal.
Berikut langkah-langkah membuat dokumen menggunakan .Net SDK.
Step 1- Membuat instance DocumentClient. Kemudian kita akan meminta database myfirstdb dan juga query untuk koleksi MyCollection, yang kita simpan dalam koleksi variabel pribadi ini sehingga dapat diakses di seluruh kelas.
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 - Buat beberapa dokumen dalam tugas CreateDocuments.
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();
}Dokumen pertama akan dibuat dari objek dinamis ini. Ini mungkin terlihat seperti JSON, tetapi tentu saja tidak. Ini adalah kode C # dan kami membuat objek NET nyata, tetapi tidak ada definisi kelas. Sebaliknya, properti disimpulkan dari cara objek diinisialisasi. Anda juga dapat melihat bahwa kami belum menyediakan properti Id untuk dokumen ini.
Step 3 - Sekarang mari kita lihat CreateDocument dan terlihat seperti pola yang sama yang kita lihat untuk membuat database dan koleksi.
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- Kali ini kita memanggil CreateDocumentAsync yang menetapkan Tautan Mandiri dari koleksi yang ingin kita tambahkan dokumennya. Kami mendapatkan kembali respons dengan properti sumber daya yang, dalam hal ini, mewakili dokumen baru dengan properti yang dihasilkan sistem.
Dalam tugas CreateDocuments berikut, kami telah membuat tiga dokumen.
Di dokumen pertama, objek Dokumen adalah kelas yang ditentukan dalam SDK yang diwarisi dari sumber daya sehingga memiliki semua properti sumber daya umum, tetapi juga menyertakan properti dinamis yang menentukan dokumen bebas skema itu sendiri.
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();
}Dokumen kedua ini hanya berfungsi dengan string JSON mentah. Sekarang kita melangkah ke dalam kelebihan untuk CreateDocument yang menggunakan JavaScriptSerializer untuk melakukan de-serialisasi string menjadi objek, yang kemudian diteruskan ke metode CreateDocument yang sama yang kita gunakan untuk membuat dokumen pertama.
Di dokumen ketiga, kami telah menggunakan objek C # Pelanggan yang didefinisikan dalam aplikasi kami.
Mari kita lihat pelanggan ini, ia memiliki properti Id dan alamat di mana alamatnya adalah objek bertingkat dengan propertinya sendiri termasuk lokasi, yang merupakan objek bertingkat lainnya.
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; }
}
}Kami juga memiliki atribut properti JSON karena kami ingin mempertahankan konvensi yang tepat di kedua sisi pagar.
Jadi saya hanya membuat objek Pelanggan Baru saya bersama dengan objek anak bersarangnya dan memanggil ke CreateDocument sekali lagi. Meskipun objek pelanggan kami memiliki properti Id, kami tidak memberikan nilai untuknya sehingga DocumentDB membuatnya berdasarkan GUID, seperti yang dilakukannya untuk dua dokumen sebelumnya.
Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** 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 objectJSON atau JavaScript Object Notation adalah standar terbuka berbasis teks ringan yang dirancang untuk pertukaran data yang dapat dibaca manusia dan juga mudah untuk diurai dan dibuat oleh mesin. JSON adalah jantung dari DocumentDB. Kami mengirimkan JSON melalui kabel, kami menyimpan JSON sebagai JSON, dan kami mengindeks pohon JSON yang memungkinkan kueri pada dokumen JSON lengkap.
Format JSON mendukung tipe data berikut -
| S.No. | Jenis & Deskripsi |
|---|---|
| 1 | Number Format titik-mengambang presisi ganda di JavaScript |
| 2 | String Unicode kutip ganda dengan pelolosan garis miring terbalik |
| 3 | Boolean Benar atau salah |
| 4 | Array Urutan nilai yang berurutan |
| 5 | Value Ini bisa berupa string, angka, benar atau salah, nol, dll. |
| 6 | Object Kumpulan key: value pair yang tidak berurutan |
| 7 | Whitespace Ini dapat digunakan di antara sepasang token apa pun |
| 8 | Null Kosong |
Mari kita lihat contoh sederhana tipe DateTime. Tambahkan tanggal lahir ke kelas pelanggan.
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; }
}Kita dapat menyimpan, mengambil, dan melakukan kueri menggunakan DateTime seperti yang ditunjukkan pada kode berikut.
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();
}Ketika kode di atas dikompilasi dan dijalankan, dan dokumen dibuat, Anda akan melihat bahwa tanggal lahir ditambahkan sekarang.
**** 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 objectMicrosoft baru-baru ini menambahkan sejumlah perbaikan tentang bagaimana Anda dapat melakukan kueri Azure DocumentDB, seperti kata kunci TOP ke tata bahasa SQL, yang membuat kueri berjalan lebih cepat dan mengonsumsi lebih sedikit sumber daya, meningkatkan batas untuk operator kueri, dan menambahkan dukungan untuk operator LINQ tambahan di SDK .NET.
Mari kita lihat contoh sederhana di mana kita hanya akan mengambil dua record pertama. Jika Anda memiliki sejumlah record dan Anda ingin mengambil hanya beberapa, maka Anda dapat menggunakan kata kunci Top. Dalam contoh ini, kami memiliki banyak catatan tentang gempa bumi.
Sekarang kami hanya ingin menampilkan dua rekaman pertama
Step 1 - Buka penjelajah kueri dan jalankan kueri ini.
SELECT * FROM c
WHERE c.magnitude > 2.5Anda akan melihat bahwa itu telah mengambil empat rekaman karena kami belum menentukan kata kunci TOP.
Step 2- Sekarang gunakan kata kunci TOP dengan kueri yang sama. Di sini kami telah menentukan kata kunci TOP dan '2' berarti kami hanya menginginkan dua rekaman.
SELECT TOP 2 * FROM c
WHERE c.magnitude > 2.5Step 3 - Sekarang jalankan query ini dan Anda akan melihat bahwa hanya dua record yang diambil.
Demikian pula, Anda dapat menggunakan kata kunci TOP dalam kode menggunakan .Net SDK. Berikut implementasinya.
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();
}Berikut adalah tugas CreateDocumentClient yang membuat instance dari DocumentClient dan database gempa.
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);
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan melihat bahwa hanya tiga record yang diambil.
**** 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 mendukung dokumen kueri menggunakan SQL melalui dokumen JSON. Anda dapat mengurutkan dokumen dalam koleksi pada angka dan string menggunakan klausa ORDER BY dalam kueri Anda. Klausa dapat menyertakan argumen ASC / DESC opsional untuk menentukan urutan pengambilan hasil.
Mari kita lihat contoh berikut di mana kita memiliki dokumen JSON.
{
"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
}
]
}Berikut ini adalah kueri SQL untuk mengurutkan hasil dalam urutan menurun.
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 DESCKetika query di atas dijalankan, Anda akan menerima output berikut.
[
{
"description": "Grapes, red or green (European type, such as Thompson
seedless), raw",
"foodGroup": "Fruits and Fruit Juices",
"servingDescription": "NLEA serving",
"servingWeight": 126
}
]Secara default, DocumentDB secara otomatis mengindeks setiap properti dalam dokumen segera setelah dokumen ditambahkan ke database. Namun, Anda dapat mengontrol dan menyesuaikan kebijakan pengindeksan Anda sendiri yang mengurangi penyimpanan dan overhead pemrosesan saat ada dokumen dan / atau properti tertentu yang tidak perlu diindeks.
Kebijakan pengindeksan default yang memberi tahu DocumentDB untuk mengindeks setiap properti secara otomatis cocok untuk banyak skenario umum. Namun Anda juga dapat menerapkan kebijakan khusus yang menjalankan kontrol yang baik atas apa yang sebenarnya diindeks dan apa yang tidak, serta fungsi lain yang berkaitan dengan pengindeksan.
DocumentDB mendukung jenis pengindeksan berikut -
- Hash
- Range
Hash
Indeks hash memungkinkan kueri yang efisien untuk kesetaraan, yaitu saat mencari dokumen di mana properti yang diberikan sama dengan nilai yang tepat, daripada mencocokkan pada rentang nilai seperti kurang dari, lebih besar dari atau antara.
Anda dapat melakukan kueri rentang dengan indeks hash, tetapi DocumentDB tidak akan dapat menggunakan indeks hash untuk menemukan dokumen yang cocok dan sebagai gantinya perlu memindai setiap dokumen secara berurutan untuk menentukan apakah itu harus dipilih oleh kueri rentang.
Anda tidak akan dapat mengurutkan dokumen Anda dengan klausa ORDER BY pada properti yang hanya memiliki indeks hash.
Jarak
Rentang indeks yang ditentukan untuk properti, DocumentDB memungkinkan untuk meminta dokumen secara efisien terhadap berbagai nilai. Ini juga memungkinkan Anda untuk mengurutkan hasil kueri pada properti itu, menggunakan ORDER BY.
DocumentDB memungkinkan Anda menentukan hash dan indeks rentang pada salah satu atau semua properti, yang memungkinkan persamaan dan rentang kueri yang efisien, serta ORDER BY.
Kebijakan Pengindeksan
Setiap koleksi memiliki kebijakan pengindeksan yang menentukan jenis indeks mana yang digunakan untuk angka dan string di setiap properti setiap dokumen.
Anda juga dapat mengontrol apakah dokumen diindeks secara otomatis atau tidak saat ditambahkan ke koleksi.
Pengindeksan otomatis diaktifkan secara default, tetapi Anda dapat mengganti perilaku itu saat menambahkan dokumen, memberi tahu DocumentDB agar tidak mengindeks dokumen tertentu itu.
Anda dapat menonaktifkan pengindeksan otomatis sehingga secara default, dokumen tidak diindeks saat ditambahkan ke koleksi. Demikian pula, Anda dapat mengganti ini di tingkat dokumen dan menginstruksikan DocumentDB untuk mengindeks dokumen tertentu saat menambahkannya ke koleksi. Ini dikenal sebagai pengindeksan manual.
Sertakan / Kecualikan Pengindeksan
Kebijakan pengindeksan juga dapat menentukan jalur atau jalur mana yang harus disertakan atau dikecualikan dari indeks. Ini berguna jika Anda mengetahui bahwa ada bagian tertentu dari dokumen yang tidak pernah Anda kueri dan bagian tertentu yang Anda lakukan.
Dalam kasus ini, Anda dapat mengurangi overhead pengindeksan dengan memberi tahu DocumentDB untuk mengindeks hanya bagian tertentu dari setiap dokumen yang ditambahkan ke koleksi.
Pengindeksan Otomatis
Mari kita lihat contoh sederhana pengindeksan otomatis.
Step 1 - Pertama kita membuat koleksi yang disebut autoindexing dan tanpa secara eksplisit memberikan kebijakan, koleksi ini menggunakan kebijakan pengindeksan default, yang berarti pengindeksan otomatis diaktifkan pada koleksi ini.
Di sini kami menggunakan perutean berbasis ID untuk tautan mandiri database sehingga kami tidak perlu mengetahui ID sumber dayanya atau kueri untuk itu sebelum membuat koleksi. Kita tinggal menggunakan ID database, yaitu mydb.
Step 2 - Sekarang mari kita buat dua dokumen, keduanya dengan nama belakang Upston.
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");
}Yang pertama ini, untuk Mark Upston, ditambahkan ke koleksi dan kemudian segera diindeks secara otomatis berdasarkan kebijakan pengindeksan default.
Tetapi ketika dokumen kedua untuk Mark Upston ditambahkan, kami telah meneruskan opsi permintaan dengan IndexingDirective.Exclude yang secara eksplisit menginstruksikan DocumentDB untuk tidak mengindeks dokumen ini, terlepas dari kebijakan pengindeksan koleksi.
Kami memiliki tipe kueri yang berbeda untuk kedua dokumen di bagian akhir.
Step 3 - Mari kita panggil tugas AutomaticIndexing dari CreateDocumentClient.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await AutomaticIndexing(client);
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** Override Automatic Indexing ****
Documents WHERE lastName = 'Upston': 1
All documents: 2
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oAOEkfQA=/docs/kV5oAOEkfQACA
AAAAAAAAA==/Seperti yang Anda lihat, kami memiliki dua dokumen seperti itu, tetapi kueri hanya mengembalikan satu untuk Mark karena satu untuk Mark tidak diindeks. Jika kita melakukan kueri lagi, tanpa klausa WHERE untuk mengambil semua dokumen dalam koleksi, maka kita mendapatkan hasil yang ditetapkan dengan kedua dokumen tersebut dan ini karena dokumen yang tidak terindeks selalu dikembalikan oleh kueri yang tidak memiliki klausa WHERE.
Kami juga dapat mengambil dokumen yang tidak terindeks dengan ID atau tautan mandiri mereka. Jadi ketika kita menanyakan dokumen Mark dengan ID-nya, MARK, kita melihat bahwa DocumentDB mengembalikan dokumen tersebut meskipun tidak diindeks dalam koleksi.
Pengindeksan Manual
Mari kita lihat contoh sederhana pengindeksan manual dengan mengganti pengindeksan otomatis.
Step 1- Pertama kita akan membuat koleksi yang disebut pengindeksan manual dan mengganti kebijakan default dengan menonaktifkan pengindeksan otomatis secara eksplisit. Artinya, kecuali kami meminta sebaliknya, dokumen baru yang ditambahkan ke koleksi ini tidak akan diindeks.
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- Sekarang kita akan kembali membuat dua dokumen yang sama seperti sebelumnya. Kami tidak akan menyediakan opsi permintaan khusus apa pun untuk dokumen Mark kali ini, karena kebijakan pengindeksan koleksi, dokumen ini tidak akan diindeks.
Step 3 - Sekarang ketika kami menambahkan dokumen kedua untuk Mark, kami menggunakan RequestOptions dengan IndexingDirective.Include untuk memberi tahu DocumentDB bahwa ia harus mengindeks dokumen ini, yang menggantikan kebijakan pengindeksan koleksi yang mengatakan bahwa seharusnya tidak.
Kami memiliki tipe kueri yang berbeda untuk kedua dokumen di bagian akhir.
Step 4 - Mari kita panggil tugas ManualIndexing dari CreateDocumentClient.
private static async Task CreateDocumentClient() {
// Create a new instance of the DocumentClient
using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
await ManualIndexing(client);
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** Manual Indexing ****
Documents WHERE lastName = 'Upston': 1
All documents: 2
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oANHJPgE=/docs/kV5oANHJPgEBA
AAAAAAAAA==/Sekali lagi, kueri hanya mengembalikan satu dari dua dokumen, tetapi kali ini, mengembalikan Jane Doe, yang secara eksplisit kami minta untuk diindeks. Tapi sekali lagi seperti sebelumnya, kueri tanpa klausa WHERE mengambil semua dokumen dalam koleksi, termasuk dokumen yang tidak terindeks untuk Mark. Kita juga bisa meminta dokumen yang tidak terindeks berdasarkan ID-nya, yang dikembalikan DocumentDB meskipun tidak diindeks.
Microsoft menambahkan geospatial support, yang memungkinkan Anda menyimpan data lokasi dalam dokumen Anda dan melakukan penghitungan spasial untuk jarak dan persimpangan antara titik dan poligon.
Data spasial menggambarkan posisi dan bentuk benda dalam ruang.
Biasanya, ini dapat digunakan untuk mewakili lokasi seseorang, tempat yang diminati, atau batas kota, atau danau.
Kasus penggunaan umum sering kali melibatkan kueri kedekatan. Misalnya, "temukan semua universitas di dekat lokasi saya saat ini".
SEBUAH Pointmenunjukkan posisi tunggal dalam ruang yang mewakili lokasi yang tepat, misalnya alamat jalan universitas tertentu. Sebuah titik direpresentasikan dalam DocumentDB menggunakan pasangan koordinatnya (bujur dan lintang). Berikut adalah contoh titik JSON.
{
"type":"Point",
"coordinates":[ 28.3, -10.7 ]
}Mari kita lihat contoh sederhana yang memuat lokasi sebuah universitas.
{
"id":"case-university",
"name":"CASE: Center For Advanced Studies In Engineering",
"city":"Islamabad",
"location": {
"type":"Point",
"coordinates":[ 33.7194136, -73.0964862 ]
}
}Untuk mendapatkan kembali nama universitas berdasarkan lokasi, Anda dapat menggunakan query berikut.
SELECT c.name FROM c
WHERE c.id = "case-university" AND ST_ISVALID({
"type":"Point",
"coordinates":[ 33.7194136, -73.0964862 ]})Ketika query di atas dijalankan, Anda akan menerima output berikut.
[
{
"name": "CASE: Center For Advanced Studies In Engineering"
}
]Buat Dokumen dengan Data Geospasial di .NET
Anda dapat membuat dokumen dengan data geospasial, mari kita lihat contoh sederhana di mana dokumen universitas dibuat.
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();
}Berikut adalah implementasi untuk kelas UniversityProfile.
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; }
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** 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 objectSaat database Anda mulai berkembang melebihi 10 GB, Anda dapat menskalakannya hanya dengan membuat koleksi baru, lalu menyebarkan atau mempartisi data Anda di lebih banyak koleksi.
Cepat atau lambat, satu koleksi, yang memiliki kapasitas 10 GB, tidak akan cukup untuk menampung database Anda. Sekarang 10GB mungkin tidak terdengar seperti angka yang sangat besar, tetapi ingat bahwa kami menyimpan dokumen JSON, yang hanya berupa teks biasa dan Anda dapat memasukkan banyak dokumen teks biasa dalam 10GB, bahkan ketika Anda mempertimbangkan overhead penyimpanan untuk indeks.
Penyimpanan bukanlah satu-satunya perhatian dalam hal skalabilitas. Throughput maksimum yang tersedia pada sebuah koleksi adalah dua setengah ribu unit permintaan per detik yang Anda dapatkan dengan koleksi S3. Karenanya, jika Anda membutuhkan throughput yang lebih tinggi, Anda juga perlu melakukan penskalaan dengan mempartisi dengan beberapa koleksi. Skala keluar partisi juga disebuthorizontal partitioning.
Ada banyak pendekatan yang dapat digunakan untuk mempartisi data dengan Azure DocumentDB. Berikut adalah strategi yang paling umum -
- Partisi Spillover
- Rentang Partisi
- Lookup Partitioning
- Partisi Hash
Partisi Spillover
Partisi spillover adalah strategi paling sederhana karena tidak ada kunci partisi. Ini sering kali merupakan pilihan yang baik untuk memulai ketika Anda tidak yakin tentang banyak hal. Anda mungkin tidak tahu apakah Anda bahkan perlu memperbesar lebih dari satu koleksi atau berapa banyak koleksi yang mungkin perlu Anda tambahkan atau seberapa cepat Anda mungkin perlu menambahkannya.
Partisi spillover dimulai dengan satu koleksi dan tidak ada kunci partisi.
Koleksinya mulai bertambah dan kemudian bertambah lagi, dan kemudian bertambah lagi, sampai Anda mendekati batas 10GB.
Saat Anda mencapai kapasitas 90 persen, Anda beralih ke koleksi baru dan mulai menggunakannya untuk dokumen baru.
Setelah database Anda berkembang ke lebih banyak koleksi, Anda mungkin ingin beralih ke strategi yang didasarkan pada kunci partisi.
Ketika Anda melakukannya, Anda perlu menyeimbangkan kembali data Anda dengan memindahkan dokumen ke koleksi yang berbeda berdasarkan strategi apa pun yang Anda gunakan untuk bermigrasi.
Rentang Partisi
Salah satu strategi yang paling umum adalah pembagian jarak. Dengan pendekatan ini Anda menentukan rentang nilai yang mungkin termasuk dalam kunci partisi dokumen dan mengarahkan dokumen ke koleksi yang sesuai dengan rentang tersebut.
Tanggal biasanya digunakan dengan strategi ini di mana Anda membuat koleksi untuk menyimpan dokumen yang termasuk dalam rentang tanggal yang ditentukan. Saat Anda menentukan rentang yang cukup kecil, Anda yakin bahwa tidak ada koleksi yang akan melebihi batas 10 GB-nya. Misalnya, mungkin ada skenario di mana satu koleksi dapat menangani dokumen secara wajar selama sebulan penuh.
Mungkin juga sebagian besar pengguna menanyakan data saat ini, yang akan menjadi data untuk bulan ini atau mungkin bulan lalu, tetapi pengguna jarang mencari data yang jauh lebih lama. Jadi Anda memulai pada bulan Juni dengan koleksi S3, yang merupakan koleksi termahal yang dapat Anda beli dan memberikan hasil terbaik yang dapat Anda peroleh.
Pada bulan Juli Anda membeli koleksi S3 lainnya untuk menyimpan data Juli dan Anda juga menurunkan skala data bulan Juni menjadi koleksi S2 yang lebih murah. Kemudian pada bulan Agustus, Anda mendapatkan koleksi S3 lainnya dan menurunkan skala Juli menjadi S2 dan Juni hingga S1. Ini berjalan, bulan demi bulan, di mana Anda selalu menjaga data saat ini tersedia untuk throughput tinggi dan data lama tetap tersedia pada throughput yang lebih rendah.
Selama kueri menyediakan kunci partisi, hanya koleksi yang perlu dikueri yang akan ditanyakan dan tidak semua koleksi dalam database seperti yang terjadi dengan partisi spillover.
Lookup Partitioning
Dengan pemartisian pencarian, Anda dapat menentukan peta partisi yang merutekan dokumen ke koleksi tertentu berdasarkan kunci partisi mereka. Misalnya, Anda dapat mempartisi menurut wilayah.
Simpan semua dokumen AS dalam satu koleksi, semua dokumen Eropa di koleksi lain, dan semua dokumen dari kawasan lain mana pun di koleksi ketiga.
Gunakan peta partisi ini dan resolver partisi pencarian dapat mengetahui koleksi mana untuk membuat dokumen dan koleksi mana yang akan ditanyakan, berdasarkan kunci partisi, yang merupakan properti kawasan yang terdapat dalam setiap dokumen.
Partisi Hash
Dalam partisi hash, partisi ditetapkan berdasarkan nilai fungsi hash, memungkinkan Anda mendistribusikan permintaan dan data secara merata ke sejumlah partisi.
Ini biasanya digunakan untuk mempartisi data yang dihasilkan atau dikonsumsi dari sejumlah besar klien berbeda, dan berguna untuk menyimpan profil pengguna, item katalog, dll.
Mari kita lihat contoh sederhana pemartisian jarak menggunakan RangePartitionResolver yang disediakan oleh .NET SDK.
Step 1- Buat DocumentClient baru dan kami akan membuat dua koleksi di tugas CreateCollections. Satu akan berisi dokumen untuk pengguna yang memiliki ID pengguna yang dimulai dengan A hingga M dan yang lainnya untuk ID pengguna N hingga Z.
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 - Daftarkan resolver jangkauan untuk database.
Step 3- Buat RangePartitionResolver <string> baru, yang merupakan tipe data dari kunci partisi kami. Konstruktor mengambil dua parameter, nama properti kunci partisi dan kamus yang merupakan peta pecahan atau peta partisi, yang hanya merupakan daftar rentang dan koleksi terkait yang telah kami tentukan sebelumnya untuk resolver.
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;
}Anda perlu menyandikan kemungkinan nilai UTF-8 terbesar di sini. Jika tidak, rentang pertama tidak akan cocok pada Ms mana pun kecuali satu M, dan juga untuk Z di rentang kedua. Jadi, anggap saja nilai yang dikodekan ini di sini sebagai karakter pengganti untuk pencocokan pada kunci partisi.
Step 4- Setelah membuat resolver, daftarkan ke database dengan DocumentClient saat ini. Untuk melakukan itu, tetapkan saja ke properti kamus PartitionResolver.
Kami akan membuat dan meminta dokumen terhadap database, bukan koleksi seperti yang biasa Anda lakukan, resolver akan menggunakan peta ini untuk mengarahkan permintaan ke koleksi yang sesuai.
Sekarang mari kita buat beberapa dokumen. Pertama kita akan membuat satu untuk userId Kirk, dan kemudian satu untuk Spock.
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);
}Parameter pertama di sini adalah tautan mandiri ke database, bukan koleksi khusus. Ini tidak mungkin tanpa resolver partisi, tetapi dengan resolver partisi ini berfungsi dengan mulus.
Kedua dokumen disimpan ke database myfirstdb, tetapi kita tahu bahwa Kirk disimpan dalam koleksi untuk A hingga M dan Spock disimpan dalam koleksi untuk N hingga Z, jika RangePartitionResolver kami berfungsi dengan baik.
Mari kita panggil ini dari tugas CreateDocumentClient seperti yang ditunjukkan pada kode berikut.
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);
}
}Ketika kode di atas dijalankan, Anda akan menerima output berikut.
**** Create Documents Across Partitions ****
Document 1: dbs/Ic8LAA==/colls/Ic8LAO2DxAA=/docs/Ic8LAO2DxAABAAAAAAAAAA==/
Document 2: dbs/Ic8LAA==/colls/Ic8LAP12QAE=/docs/Ic8LAP12QAEBAAAAAAAAAA==/Seperti yang terlihat, tautan mandiri dari kedua dokumen memiliki ID sumber daya yang berbeda karena keduanya ada dalam dua koleksi terpisah.
Dengan alat Migrasi Data DocumentDB, Anda dapat dengan mudah memigrasi data ke DocumentDB. Alat Migrasi Data DocumentDB adalah utilitas gratis dan sumber terbuka yang dapat Anda unduh dari Pusat Unduhan Microsofthttps://www.microsoft.com/
Alat Migrasi mendukung banyak sumber data, beberapa di antaranya tercantum di bawah -
- SQL Server
- File JSON
- File datar Nilai yang Dipisahkan Koma (CSV)
- MongoDB
- Penyimpanan Meja Azure
- Amazon DynamoDB
- HBase, dan bahkan database DocumentDB lainnya
Setelah mengunduh alat Migrasi Data DocumentDB, ekstrak file zip tersebut.
Anda dapat melihat dua file yang dapat dieksekusi di folder ini seperti yang ditunjukkan pada gambar layar berikut.
Pertama, ada dt.exe, yang merupakan versi konsol dengan antarmuka baris perintah, lalu ada dtui.exe, yang merupakan versi desktop dengan antarmuka pengguna grafis.
Mari luncurkan versi GUI.
Anda dapat melihat halaman Selamat Datang. Klik 'Next' untuk halaman Informasi Sumber.
Di sinilah Anda mengonfigurasi sumber data, dan Anda dapat melihat banyak pilihan yang didukung dari menu tarik-turun.
Saat Anda membuat pilihan, sisa halaman Informasi Sumber akan berubah sesuai.
Sangat mudah untuk mengimpor data ke DocumentDB menggunakan Alat Migrasi Data DocumentDB. Kami merekomendasikan Anda untuk menggunakan contoh di atas dan menggunakan file data lainnya juga.
DocumentDB menyediakan konsep untuk mengontrol akses ke sumber daya DocumentDB. Akses ke sumber daya DocumentDB diatur oleh token kunci master atau token sumber daya. Koneksi berdasarkan token sumber daya hanya dapat mengakses sumber daya yang ditentukan oleh token dan tidak ada sumber daya lainnya. Token sumber daya didasarkan pada izin pengguna.
Pertama Anda membuat satu atau beberapa pengguna, dan ini ditentukan di tingkat database.
Kemudian Anda membuat satu atau beberapa izin untuk setiap pengguna, berdasarkan sumber daya yang ingin Anda izinkan untuk mengakses setiap pengguna.
Setiap izin menghasilkan token sumber daya yang memungkinkan akses hanya-baca atau akses penuh ke sumber daya yang diberikan dan itu bisa menjadi sumber daya pengguna apa pun dalam database.
Pengguna ditentukan di tingkat database dan izin ditentukan untuk setiap pengguna.
Pengguna dan izin berlaku untuk semua koleksi di database.
Mari kita lihat contoh sederhana di mana kita akan belajar bagaimana mendefinisikan pengguna dan izin untuk mencapai keamanan granular di DocumentDB.
Kami akan mulai dengan DocumentClient baru dan kueri untuk database myfirstdb.
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");
}
}Berikut adalah implementasi untuk CreateUser.
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- Buat dua pengguna, Alice dan Tom seperti sumber daya apa pun yang kita buat, kita membuat objek definisi dengan Id yang diinginkan dan memanggil metode buat dan dalam hal ini kita memanggil CreateUserAsync dengan SelfLink database dan userDefinition. Kami mendapatkan kembali hasil dari properti sumber yang kami dapatkan objek pengguna yang baru dibuat.
Sekarang untuk melihat dua pengguna baru ini di database.
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- Panggil CreateUserQuery, terhadap UsersLink database untuk mengambil daftar semua pengguna. Kemudian putar melalui mereka dan lihat propertinya.
Sekarang kita harus membuatnya dulu. Jadi katakanlah kita ingin mengizinkan Alice membaca / menulis izin ke koleksi MyCollection, tetapi Tom hanya dapat membaca dokumen dalam koleksi.
await CreatePermission(client, alice, "Alice Collection Access", PermissionMode.All,
collection);
await CreatePermission(client, tom, "Tom Collection Access", PermissionMode.Read,
collection);Step 3- Buat izin pada sumber daya yang merupakan koleksi MyCollection sehingga kita perlu mendapatkan sumber daya itu SelfLink.
Step 4 - Kemudian buat Permission. Semua pada koleksi ini untuk Alice and a Permission. Baca koleksi ini untuk Tom.
Berikut adalah implementasi untuk CreatePermission.
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);
}Seperti yang Anda harapkan sekarang, kami melakukan ini dengan membuat objek definisi untuk izin baru, yang menyertakan Id dan izinMode, yang merupakan Permission.All atau Permission.Read, dan SelfLink sumber daya yang diamankan dengan izin.
Step 5 - Panggil CreatePermissionAsync dan dapatkan izin yang dibuat dari properti sumber daya di hasilnya.
Untuk melihat izin yang dibuat, berikut adalah implementasi ViewPermissions.
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);
}Kali ini, ini adalah kueri izin terhadap tautan izin pengguna dan kami hanya mencantumkan setiap izin yang dikembalikan untuk pengguna tersebut.
Mari hapus izin Alice dan Tom.
await DeletePermission(client, alice, "Alice Collection Access");
await DeletePermission(client, tom, "Tom Collection Access");Berikut adalah implementasi untuk DeletePermission.
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 - Untuk menghapus izin, kueri dengan ID izin untuk mendapatkan Tautan Otomatis, lalu gunakan Tautan Otomatis untuk menghapus izin.
Selanjutnya, mari kita hapus pengguna itu sendiri. Mari hapus kedua pengguna tersebut.
await DeleteUser(client, "Alice");
await DeleteUser(client, "Tom");Berikut adalah implementasi untuk DeleteUser.
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 - Kueri pertama untuk mendapatkan SelfLink-nya, lalu panggil DeleteUserAsync untuk menghapus objek penggunanya.
Berikut adalah implementasi tugas CreateDocumentClient di mana kita memanggil semua tugas di atas.
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");
}
}Ketika kode di atas dikompilasi dan dijalankan, Anda akan menerima output berikut.
**** 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 myfirstdbPada bab ini, kita akan belajar bagaimana memvisualisasikan data yang disimpan di DocumentDB. Microsoft menyediakan alat Power BI Desktop yang mengubah data Anda menjadi visual yang kaya. Ini juga memungkinkan Anda untuk mengambil data dari berbagai sumber data, menggabungkan dan mengubah data, membuat laporan dan visualisasi yang kuat, dan menerbitkan laporan ke Power BI.
Di versi terbaru Power BI Desktop, Microsoft telah menambahkan dukungan untuk DocumentDB juga di mana Anda sekarang dapat terhubung ke akun DocumentDB Anda. Anda dapat mengunduh alat ini dari tautan,https://powerbi.microsoft.com
Mari kita lihat contoh di mana kita akan memvisualisasikan data gempa bumi yang diimpor di bab terakhir.
Step 1 - Setelah alat diunduh, luncurkan desktop Power BI.
Step 2 - Klik opsi 'Dapatkan Data' yang ada di tab Beranda di bawah grup Data Eksternal dan itu akan menampilkan halaman Dapatkan Data.
Step 3 - Pilih opsi Microsoft Azure DocumentDB (Beta) dan klik tombol 'Hubungkan'.
Step 4 - Masukkan URL akun Azure DocumentDB Anda, Basis Data, dan Koleksi dari mana Anda ingin memvisualisasikan data dan tekan Ok.
Jika Anda terhubung ke titik akhir ini untuk pertama kalinya, Anda akan diminta memasukkan kunci akun.
Step 5 - Masukkan kunci akun (kunci utama) yang unik untuk setiap akun DocumentDB yang tersedia di portal Azure, lalu klik Hubungkan.
Ketika akun berhasil terhubung, itu akan mengambil data dari database yang ditentukan. Panel Pratinjau memperlihatkan daftar item Rekaman, Dokumen ditunjukkan sebagai tipe Rekaman di Power BI.
Step 6 - Klik tombol 'Edit' yang akan meluncurkan Editor Kueri.
Step 7 - Di Power BI Query Editor, Anda akan melihat kolom Dokumen di panel tengah, klik expander di sisi kanan header kolom Dokumen dan pilih kolom yang ingin Anda tampilkan.
Seperti yang Anda lihat bahwa kami memiliki lintang dan bujur sebagai kolom terpisah tetapi kami memvisualisasikan data dalam bentuk koordinat lintang dan bujur.
Step 8 - Untuk melakukan itu, klik tab 'Tambahkan Kolom'.
Step 9 - Pilih Tambahkan Kolom Kustom yang akan menampilkan halaman berikut.
Step 10- Tentukan nama kolom baru, misalkan LatLong dan juga rumus yang akan menggabungkan latitude dan longitude dalam satu kolom dipisahkan dengan koma. Berikut rumusnya.
Text.From([latitude])&", "&Text.From([longitude])Step 11 - Klik OK untuk melanjutkan dan Anda akan melihat bahwa kolom baru telah ditambahkan.
Step 12 - Buka tab Beranda dan klik opsi 'Tutup & Terapkan'.
Step 13- Anda dapat membuat laporan dengan menyeret dan melepaskan bidang ke kanvas Laporan. Anda dapat melihat di sebelah kanan, ada dua panel - satu panel Visualisasi dan yang lainnya adalah panel Fields.
Mari buat tampilan peta yang menunjukkan lokasi tiap gempa.
Step 14 - Seret tipe visual peta dari panel Visualisasi.
Step 15- Sekarang, seret dan lepas bidang LatLong dari panel Bidang ke properti Lokasi di panel Visualisasi. Lalu, seret dan lepas bidang besaran ke properti Nilai.
Step 16 - Seret dan lepas bidang kedalaman ke properti Saturasi warna.
Sekarang Anda akan melihat visual Peta yang menunjukkan sekumpulan gelembung yang menunjukkan lokasi setiap gempa.