DocumentDB - คู่มือฉบับย่อ

ในบทนี้เราจะพูดถึงแนวคิดหลัก ๆ เกี่ยวกับ NoSQL และฐานข้อมูลเอกสารโดยสังเขป นอกจากนี้เราจะมีภาพรวมโดยย่อของ DocumentDB

ฐานข้อมูลเอกสาร NoSQL

DocumentDB เป็นฐานข้อมูลเอกสาร NoSQL ใหม่ล่าสุดของ Microsoft ดังนั้นเมื่อคุณพูดว่าฐานข้อมูลเอกสาร NoSQL แล้ว NoSQL และฐานข้อมูลเอกสารหมายถึงอะไร?

  • SQL หมายถึง Structured Query Language ซึ่งเป็นภาษาแบบสอบถามแบบดั้งเดิมของฐานข้อมูลเชิงสัมพันธ์ SQL มักจะเทียบเท่ากับฐานข้อมูลเชิงสัมพันธ์

  • การคิดว่าฐานข้อมูล NoSQL เป็นฐานข้อมูลที่ไม่ใช่เชิงสัมพันธ์จะมีประโยชน์มากกว่าดังนั้น NoSQL จึงหมายถึงการไม่สัมพันธ์กันจริงๆ

มีฐานข้อมูล NoSQL ประเภทต่างๆซึ่งรวมถึงที่เก็บค่าคีย์เช่น -

  • Azure Table Storage
  • ร้านค้าตามคอลัมน์เช่น Cassandra
  • ฐานข้อมูลกราฟเช่น NEO4
  • ฐานข้อมูลเอกสารเช่น MongoDB และ Azure DocumentDB

Azure DocumentDB

ไมโครซอฟท์เปิดตัวอย่างเป็นทางการ Azure DocumentDB วันที่ 8 เมษายนTH 2015 และแน่นอนมันสามารถจะมีลักษณะเป็นฐานข้อมูลเอกสาร NoSQL ทั่วไป สามารถปรับขนาดได้มากและทำงานร่วมกับเอกสาร JSON ที่ไม่มีสคีมา

  • DocumentDB เป็นบริการฐานข้อมูลเอกสาร NoSQL ที่ไม่มีสคีมาที่แท้จริงซึ่งออกแบบมาสำหรับแอปพลิเคชันมือถือและเว็บที่ทันสมัย

  • นอกจากนี้ยังให้การอ่านและเขียนที่รวดเร็วสม่ำเสมอความยืดหยุ่นของสคีมาและความสามารถในการปรับขนาดฐานข้อมูลขึ้นและลงตามความต้องการได้อย่างง่ายดาย

  • ไม่ถือว่าหรือต้องการสคีมาใด ๆ สำหรับเอกสาร JSON ที่จัดทำดัชนี

  • DocumentDB ทำดัชนีทุกคุณสมบัติในเอกสารโดยอัตโนมัติทันทีที่เอกสารถูกเพิ่มลงในฐานข้อมูล

  • DocumentDB เปิดใช้งานการสืบค้นแบบเฉพาะกิจที่ซับซ้อนโดยใช้ภาษา SQL และทุกเอกสารจะสืบค้นได้ทันทีที่สร้างขึ้นและคุณสามารถค้นหาคุณสมบัติใดก็ได้ที่ใดก็ได้ภายในลำดับชั้นของเอกสาร

DocumentDB - ราคา

DocumentDB ถูกเรียกเก็บเงินตามจำนวนคอลเลกชันที่มีอยู่ในบัญชีฐานข้อมูล แต่ละบัญชีสามารถมีฐานข้อมูลได้ตั้งแต่หนึ่งฐานข้อมูลขึ้นไปและแต่ละฐานข้อมูลสามารถมีคอลเลกชันได้ไม่ จำกัด จำนวนแม้ว่าจะมีโควต้าเริ่มต้นเริ่มต้นที่ 100 ก็ตามโควต้านี้สามารถเพิ่มได้โดยติดต่อฝ่ายสนับสนุนของ Azure

  • คอลเลกชันไม่ได้เป็นเพียงหน่วยของขนาดเท่านั้น แต่ยังรวมถึงหน่วยของต้นทุนด้วยดังนั้นใน DocumentDB คุณจ่ายต่อคอลเลคชันซึ่งมีความจุสูงสุดถึง 10 GB

  • อย่างน้อยที่สุดคุณจะต้องมีคอลเล็กชัน S1 หนึ่งชุดเพื่อจัดเก็บเอกสารในฐานข้อมูลซึ่งจะมีค่าใช้จ่ายประมาณ $ 25 ต่อเดือนซึ่งจะถูกเรียกเก็บเงินจากการสมัครใช้งาน Azure ของคุณ

  • เนื่องจากฐานข้อมูลของคุณมีขนาดใหญ่ขึ้นและมีขนาดเกิน 10 GB คุณจะต้องซื้อคอลเล็กชันอื่นเพื่อให้มีข้อมูลเพิ่มเติม

  • คอลเลกชัน S1 แต่ละชุดจะให้หน่วยคำขอ 250 หน่วยต่อวินาทีและหากยังไม่เพียงพอคุณสามารถปรับขนาดคอลเล็กชันได้ถึง S2 และรับ 1,000 หน่วยคำขอต่อวินาทีในราคาประมาณ $ 50 ต่อเดือน

  • คุณยังสามารถเปลี่ยนเป็น S3 ได้ทั้งหมดและจ่ายประมาณ $ 100 ต่อเดือน

DocumentDB โดดเด่นด้วยความสามารถพิเศษบางอย่าง Azure DocumentDB นำเสนอความสามารถและประโยชน์ที่สำคัญดังต่อไปนี้

สคีมาฟรี

ในฐานข้อมูลเชิงสัมพันธ์ทุกตารางจะมีสคีมาที่กำหนดคอลัมน์และชนิดข้อมูลที่แต่ละแถวในตารางต้องสอดคล้องกัน

ในทางตรงกันข้ามฐานข้อมูลเอกสารไม่มีสคีมาที่กำหนดไว้และทุกเอกสารสามารถมีโครงสร้างที่แตกต่างกันได้

ไวยากรณ์ SQL

DocumentDB เปิดใช้งานการสืบค้นเฉพาะกิจที่ซับซ้อนโดยใช้ภาษา SQL และเอกสารทุกฉบับจะสืบค้นได้ทันทีที่สร้างขึ้น คุณสามารถค้นหาคุณสมบัติใดก็ได้ภายในลำดับชั้นของเอกสาร

ความสอดคล้องที่ปรับได้

มีระดับความสอดคล้องที่ละเอียดชัดเจนซึ่งช่วยให้คุณทำการแลกเปลี่ยนที่ดีระหว่างความสอดคล้องความพร้อมใช้งานและเวลาในการตอบสนอง

คุณสามารถเลือกระดับความสอดคล้องที่กำหนดไว้อย่างดีจากสี่ระดับเพื่อให้เกิดการแลกเปลี่ยนที่ดีที่สุดระหว่างความสอดคล้องและประสิทธิภาพ สำหรับการสืบค้นและการดำเนินการอ่าน DocumentDB มีระดับความสอดคล้องที่แตกต่างกันสี่ระดับ -

  • Strong
  • Bounded-staleness
  • Session
  • Eventual

เครื่องชั่งยืดหยุ่น

Scalability เป็นชื่อของเกมที่มี NoSQL และ DocumentDB มอบให้ DocumentDB ได้รับการพิสูจน์ขนาดแล้ว

  • บริการหลัก ๆ เช่น Office OneNote และ Xbox ได้รับการสนับสนุนโดย DocumentDB ด้วยฐานข้อมูลที่มีเอกสาร JSON หลายสิบเทราไบต์ผู้ใช้ที่ใช้งานอยู่กว่าล้านคนและทำงานอย่างสม่ำเสมอโดยมีความพร้อมใช้งาน 99.95%

  • คุณสามารถปรับขนาด DocumentDB ได้อย่างยืดหยุ่นพร้อมประสิทธิภาพที่คาดเดาได้โดยการสร้างหน่วยเพิ่มขึ้นเมื่อแอปพลิเคชันของคุณเติบโตขึ้น

จัดการอย่างเต็มที่

DocumentDB พร้อมใช้งานเป็นแพลตฟอร์มบนคลาวด์ที่มีการจัดการเต็มรูปแบบเป็นบริการที่ทำงานบน Azure

  • ไม่มีอะไรให้คุณติดตั้งหรือจัดการได้

  • ไม่มีเซิร์ฟเวอร์สายเคเบิลไม่มีระบบปฏิบัติการหรือการอัปเดตที่ต้องจัดการไม่มีแบบจำลองให้ตั้งค่า

  • Microsoft ดำเนินการทั้งหมดและให้บริการทำงานต่อไป

  • ภายในไม่กี่นาทีคุณสามารถเริ่มทำงานกับ DocumentDB ได้โดยใช้เพียงเบราว์เซอร์และการสมัครใช้งาน Azure

Microsoft ให้บริการ Visual Studio เวอร์ชันฟรีซึ่งมี SQL Server และสามารถดาวน์โหลดได้จาก https://www.visualstudio.com

การติดตั้ง

Step 1- เมื่อดาวน์โหลดเสร็จสิ้นให้เรียกใช้โปรแกรมติดตั้ง กล่องโต้ตอบต่อไปนี้จะปรากฏขึ้น

Step 2 - คลิกที่ปุ่มติดตั้งและจะเริ่มกระบวนการติดตั้ง

Step 3 - เมื่อขั้นตอนการติดตั้งเสร็จสมบูรณ์คุณจะเห็นกล่องโต้ตอบต่อไปนี้

Step 4 - ปิดกล่องโต้ตอบนี้และรีสตาร์ทคอมพิวเตอร์หากจำเป็น

Step 5- ตอนนี้เปิด Visual studio จากเมนูเริ่มซึ่งจะเปิดกล่องโต้ตอบด้านล่าง จะต้องใช้เวลาในการเตรียมการเป็นครั้งแรกเท่านั้น

เมื่อเสร็จแล้วคุณจะเห็นหน้าต่างหลักของ Visual Studio

Step 6 - มาสร้างโปรเจ็กต์ใหม่จากไฟล์→ใหม่→โปรเจ็กต์

Step 7 - เลือก Console Application ป้อน DocumentDBDemo ในช่อง Name แล้วคลิกปุ่ม OK

Step 8 - ในโซลูชัน Explorer ให้คลิกขวาที่โครงการของคุณ

Step 9 - เลือก Manage NuGet Packages ซึ่งจะเปิดหน้าต่างต่อไปนี้ใน Visual Studio และในช่องป้อนข้อมูล Search Online ให้ค้นหา DocumentDB Client Library

Step 10 - ติดตั้งเวอร์ชันล่าสุดโดยคลิกปุ่มติดตั้ง

Step 11- คลิก "ฉันยอมรับ" เมื่อติดตั้งเสร็จแล้วคุณจะเห็นข้อความในหน้าต่างผลลัพธ์ของคุณ

ตอนนี้คุณพร้อมที่จะเริ่มแอปพลิเคชันของคุณ

ในการใช้ Microsoft Azure DocumentDB คุณต้องสร้างบัญชี DocumentDB ในบทนี้เราจะสร้างบัญชี DocumentDB โดยใช้พอร์ทัล Azure

Step 1 - เข้าสู่ระบบออนไลน์ https://portal.azure.com หากคุณมีการสมัครใช้งาน Azure อยู่แล้วคุณต้องลงชื่อเข้าใช้ก่อน

คุณจะเห็นแดชบอร์ดหลัก สามารถปรับแต่งได้อย่างเต็มที่เพื่อให้คุณสามารถจัดเรียงไทล์เหล่านี้ได้ตามต้องการปรับขนาดเพิ่มและลบไทล์สำหรับสิ่งที่คุณใช้บ่อยหรือไม่ได้ทำอีกต่อไป

Step 2 - เลือกตัวเลือก "ใหม่" ที่ด้านซ้ายบนของหน้า

Step 3 - ตอนนี้เลือกตัวเลือก Data + Storage> Azure DocumentDB แล้วคุณจะเห็นส่วนบัญชี New DocumentDB ต่อไปนี้

เราจำเป็นต้องสร้างชื่อที่ไม่ซ้ำกันทั่วโลก (ID) ซึ่งรวมกับ. documentents.azure.com เป็นปลายทางที่สามารถระบุได้แบบสาธารณะสำหรับบัญชี DocumentDB ของเรา ฐานข้อมูลทั้งหมดที่เราสร้างภายใต้บัญชีนั้นสามารถเข้าถึงได้ทางอินเทอร์เน็ตโดยใช้อุปกรณ์ปลายทางนี้

Step 4 - ตั้งชื่อมันว่า azuredocdbdemo แล้วคลิกที่ Resource Group → new_resource

Step 5- เลือกตำแหน่งเช่นศูนย์ข้อมูล Microsoft ที่คุณต้องการให้บัญชีนี้โฮสต์ เลือกสถานที่และเลือกภูมิภาคของคุณ

Step 6 - เลือกช่องทำเครื่องหมาย Pin to dashboard แล้วคลิกปุ่ม Create

คุณจะเห็นว่าไทล์ถูกเพิ่มลงในแดชบอร์ดแล้วและจะแจ้งให้เราทราบว่ากำลังสร้างบัญชี อาจใช้เวลาสองสามนาทีในการตั้งค่าสำหรับบัญชีใหม่ในขณะที่ DocumentDB จัดสรรจุดสิ้นสุดจัดเตรียมแบบจำลองและทำงานอื่น ๆ ในเบื้องหลัง

เมื่อเสร็จแล้วคุณจะเห็นแดชบอร์ด

Step 7 - คลิกที่บัญชี DocumentDB ที่สร้างขึ้นแล้วคุณจะเห็นหน้าจอโดยละเอียดดังภาพต่อไปนี้

เมื่อคุณเริ่มเขียนโปรแกรมกับ DocumentDB ขั้นตอนแรกคือการเชื่อมต่อ ดังนั้นในการเชื่อมต่อกับบัญชี DocumentDB ของคุณคุณจะต้องมีสองสิ่ง

  • Endpoint
  • รหัสการอนุญาต

จุดสิ้นสุด

Endpoint คือ URL ไปยังบัญชี DocumentDB ของคุณและสร้างขึ้นโดยการรวมชื่อบัญชี DocumentDB ของคุณเข้ากับ. documents.azure.com ไปที่แดชบอร์ดกันเถอะ

ตอนนี้คลิกที่บัญชี DocumentDB ที่สร้างขึ้น คุณจะเห็นรายละเอียดดังที่แสดงในภาพต่อไปนี้

เมื่อคุณเลือกตัวเลือก 'คีย์' จะแสดงข้อมูลเพิ่มเติมดังที่แสดงในภาพต่อไปนี้ คุณจะเห็น URL ไปยังบัญชี DocumentDB ของคุณซึ่งคุณสามารถใช้เป็นปลายทางของคุณได้

รหัสการอนุญาต

คีย์การให้สิทธิ์ประกอบด้วยข้อมูลประจำตัวของคุณและคีย์มีสองประเภท คีย์หลักช่วยให้สามารถเข้าถึงทรัพยากรทั้งหมดภายในบัญชีได้อย่างเต็มที่ในขณะที่โทเค็นทรัพยากรอนุญาตการเข้าถึงทรัพยากรที่ จำกัด

มาสเตอร์คีย์

  • ไม่มีอะไรที่คุณไม่สามารถทำได้ด้วยมาสเตอร์คีย์ คุณสามารถลบฐานข้อมูลทั้งหมดของคุณได้หากต้องการโดยใช้คีย์หลัก

  • ด้วยเหตุนี้คุณจึงไม่ต้องการแชร์คีย์หลักหรือแจกจ่ายไปยังสภาพแวดล้อมไคลเอนต์ เพื่อเป็นการเพิ่มมาตรการรักษาความปลอดภัยจึงควรเปลี่ยนบ่อยๆ

  • มีคีย์หลักสองคีย์สำหรับแต่ละบัญชีฐานข้อมูลหลักและรองตามที่ไฮไลต์ในภาพหน้าจอด้านบน

โทเค็นทรัพยากร

  • คุณยังสามารถใช้โทเค็นทรัพยากรแทนมาสเตอร์คีย์ได้อีกด้วย

  • การเชื่อมต่อตามโทเค็นทรัพยากรสามารถเข้าถึงทรัพยากรที่ระบุโดยโทเค็นเท่านั้นและไม่มีทรัพยากรอื่น ๆ

  • โทเค็นทรัพยากรจะขึ้นอยู่กับสิทธิ์ของผู้ใช้ดังนั้นก่อนอื่นคุณต้องสร้างผู้ใช้ตั้งแต่หนึ่งรายขึ้นไปและสิ่งเหล่านี้ถูกกำหนดที่ระดับฐานข้อมูล

  • คุณสร้างสิทธิ์อย่างน้อยหนึ่งรายการสำหรับผู้ใช้แต่ละรายโดยขึ้นอยู่กับทรัพยากรที่คุณต้องการอนุญาตให้ผู้ใช้แต่ละรายเข้าถึง

  • สิทธิ์แต่ละรายการจะสร้างโทเค็นทรัพยากรที่อนุญาตให้เข้าถึงทรัพยากรที่กำหนดแบบอ่านอย่างเดียวหรือแบบเต็มและอาจเป็นทรัพยากรของผู้ใช้ใดก็ได้ภายในฐานข้อมูล

ไปที่แอปพลิเคชันคอนโซลที่สร้างในบทที่ 3

Step 1 - เพิ่มการอ้างอิงต่อไปนี้ในไฟล์ Program.cs

using Microsoft.Azure.Documents; 
using Microsoft.Azure.Documents.Client; 
using Microsoft.Azure.Documents.Linq; 
using Newtonsoft.Json;

Step 2- ตอนนี้เพิ่ม Endpoint URL และรหัสการอนุญาต ในตัวอย่างนี้เราจะใช้คีย์หลักเป็นคีย์การอนุญาต

โปรดทราบว่าในกรณีของคุณทั้ง Endpoint URL และรหัสการให้สิทธิ์ควรแตกต่างกัน

private const string EndpointUrl = "https://azuredocdbdemo.documents.azure.com:443/"; 
private const string AuthorizationKey = 
   "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";

Step 3 - สร้างอินสแตนซ์ใหม่ของ DocumentClient ในงานแบบอะซิงโครนัสที่เรียกว่า CreateDocumentClient และสร้างอินสแตนซ์ DocumentClient ใหม่

Step 4 - เรียกงานแบบอะซิงโครนัสจากวิธีการหลักของคุณ

ต่อไปนี้เป็นไฟล์ 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==";
			
      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);
      }
		
   }
}

ในบทนี้เราได้เรียนรู้วิธีการเชื่อมต่อกับบัญชี DocumentDB และสร้างอินสแตนซ์ของคลาส DocumentClient

ในบทนี้เราจะเรียนรู้วิธีการสร้างฐานข้อมูล ในการใช้ Microsoft Azure DocumentDB คุณต้องมีบัญชี DocumentDB ฐานข้อมูลคอลเลกชันและเอกสาร เรามีบัญชี DocumentDB แล้วตอนนี้ในการสร้างฐานข้อมูลเรามีสองทางเลือก -

  • Microsoft Azure Portal หรือ
  • .Net SDK

สร้างฐานข้อมูลสำหรับ DocumentDB โดยใช้ Microsoft Azure Portal

ในการสร้างฐานข้อมูลโดยใช้พอร์ทัลให้ทำตามขั้นตอนต่อไปนี้

Step 1 - เข้าสู่ระบบพอร์ทัล Azure และคุณจะเห็นแดชบอร์ด

Step 2 - คลิกที่บัญชี DocumentDB ที่สร้างขึ้นและคุณจะเห็นรายละเอียดดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 3 - เลือกตัวเลือกเพิ่มฐานข้อมูลและระบุ ID สำหรับฐานข้อมูลของคุณ

Step 4 - คลิกตกลง

คุณจะเห็นว่ามีการเพิ่มฐานข้อมูล ในขณะนี้ยังไม่มีคอลเล็กชัน แต่เราสามารถเพิ่มคอลเล็กชันได้ในภายหลังซึ่งเป็นคอนเทนเนอร์ที่จะจัดเก็บเอกสาร JSON ของเรา สังเกตว่ามีทั้ง ID และ Resource ID

สร้างฐานข้อมูลสำหรับ DocumentDB โดยใช้. Net SDK

ในการสร้างฐานข้อมูลโดยใช้. Net SDK ให้ทำตามขั้นตอนต่อไปนี้

Step 1 - เปิดแอปพลิเคชันคอนโซลใน Visual Studio จากบทสุดท้าย

Step 2- สร้างฐานข้อมูลใหม่โดยสร้างวัตถุฐานข้อมูลใหม่ ในการสร้างฐานข้อมูลใหม่เราจำเป็นต้องกำหนดคุณสมบัติ Id ซึ่งเรากำลังตั้งค่าเป็น“ mynewdb” ในงาน 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- ตอนนี้ส่งฐานข้อมูลนี้ไปยัง CreateDatabaseAsync และรับผลลัพธ์กลับด้วยคุณสมบัติทรัพยากร เมธอดสร้างอ็อบเจ็กต์ทั้งหมดจะส่งคืนคุณสมบัติ Resource ที่อธิบายไอเท็มที่ถูกสร้างขึ้นซึ่งเป็นฐานข้อมูลในกรณีนี้

เราได้รับอ็อบเจ็กต์ฐานข้อมูลใหม่จากคุณสมบัติ Resource และแสดงบนคอนโซลพร้อมกับ Resource ID ที่ DocumentDB กำหนดให้

Step 4 - ตอนนี้เรียกงาน CreateDatabase จากงาน CreateDocumentClient หลังจากที่ DocumentClient ถูกสร้างอินสแตนซ์

using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) { 
   await CreateDatabase(client); 
}

ต่อไปนี้เป็นไฟล์ 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==";
			
      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 *******");
      }
		
   } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับเอาต์พุตต่อไปนี้ซึ่งมี ID ฐานข้อมูลและทรัพยากร

******** Create Database ******* 
 Database Id: mynewdb; Rid: ltpJAA== 
******** Database Created *******

จนถึงขณะนี้เราได้สร้างฐานข้อมูลสองฐานข้อมูลในบัญชี DocumentDB ของเราฐานข้อมูลแรกถูกสร้างโดยใช้พอร์ทัล Azure ในขณะที่ฐานข้อมูลที่สองถูกสร้างโดยใช้. Net SDK ในการดูฐานข้อมูลเหล่านี้คุณสามารถใช้พอร์ทัล Azure

ไปที่บัญชี DocumentDB ของคุณบนพอร์ทัล Azure และคุณจะเห็นฐานข้อมูลสองฐานข้อมูลทันที

คุณยังสามารถดูหรือแสดงรายการฐานข้อมูลจากรหัสของคุณโดยใช้. Net SDK ต่อไปนี้เป็นขั้นตอนที่เกี่ยวข้อง

Step 1 - ออกแบบสอบถามฐานข้อมูลโดยไม่มีพารามิเตอร์ที่ส่งคืนรายการทั้งหมด แต่คุณยังสามารถส่งแบบสอบถามเพื่อค้นหาฐานข้อมูลเฉพาะหรือฐานข้อมูลเฉพาะได้

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);
}

คุณจะเห็นว่ามีวิธีการ CreateQuery มากมายสำหรับการค้นหาคอลเล็กชันเอกสารผู้ใช้และทรัพยากรอื่น ๆ วิธีการเหล่านี้ไม่ได้ดำเนินการค้นหาจริงเพียงแค่กำหนดแบบสอบถามและส่งคืนวัตถุที่ทำซ้ำได้

เป็นการเรียกไปที่ ToList () ที่เรียกใช้งานแบบสอบถามจริงทำซ้ำผลลัพธ์และส่งคืนในรายการ

Step 2 - เรียกเมธอด GetDatabases จากงาน CreateDocumentClient หลังจากที่ DocumentClient ถูกสร้างอินสแตนซ์

Step 3 - คุณต้องแสดงความคิดเห็นเกี่ยวกับงาน CreateDatabase หรือเปลี่ยนรหัสฐานข้อมูลมิฉะนั้นคุณจะได้รับข้อความแสดงข้อผิดพลาดว่ามีฐานข้อมูลอยู่

using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
   //await CreateDatabase(client); 
   GetDatabases(client); 
}

ต่อไปนี้เป็นไฟล์ 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==";
			
      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);
      }
		
   } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับเอาต์พุตต่อไปนี้ซึ่งมี ID ฐานข้อมูลและทรัพยากรของทั้งสองฐานข้อมูล ในท้ายที่สุดคุณจะเห็นจำนวนฐานข้อมูลทั้งหมด

******** Get Databases List ******** 
 Database Id: myfirstdb; Rid: Ic8LAA== 
 Database Id: mynewdb; Rid: ltpJAA==  
Total databases: 2

คุณสามารถดร็อปฐานข้อมูลหรือฐานข้อมูลจากพอร์ทัลและจากโค้ดได้โดยใช้. Net SDK ในที่นี้เราจะพูดถึงวิธีการวางฐานข้อมูลใน DocumentDB อย่างเป็นขั้นตอน

Step 1- ไปที่บัญชี DocumentDB ของคุณบนพอร์ทัล Azure เพื่อจุดประสงค์ในการสาธิตฉันได้เพิ่มฐานข้อมูลอีกสองฐานตามที่เห็นในภาพหน้าจอต่อไปนี้

Step 2- ในการวางฐานข้อมูลใด ๆ คุณต้องคลิกฐานข้อมูลนั้น มาเลือก tempdb คุณจะเห็นหน้าต่อไปเลือกตัวเลือก 'ลบฐานข้อมูล'

Step 3 - จะแสดงข้อความยืนยันตอนนี้คลิกปุ่ม 'ใช่'

คุณจะเห็นว่า tempdb ไม่มีในแดชบอร์ดของคุณอีกต่อไป

คุณยังสามารถลบฐานข้อมูลจากรหัสของคุณโดยใช้. Net SDK ให้ทำตามขั้นตอนต่อไปนี้

Step 1 - มาลบฐานข้อมูลโดยระบุ ID ของฐานข้อมูลที่เราต้องการลบ แต่เราต้องการ SelfLink

Step 2 - เรากำลังเรียก CreateDatabaseQuery เหมือนก่อนหน้านี้ แต่คราวนี้เรากำลังส่งแบบสอบถามเพื่อส่งคืนฐานข้อมูลเดียวที่มี 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- คราวนี้เราสามารถเรียก AsEnumerable แทน ToList () ได้เพราะจริงๆแล้วเราไม่ต้องการวัตถุรายการ คาดหวังผลลัพธ์เท่านั้นการเรียก AsEnumerable ก็เพียงพอแล้วที่เราจะได้รับวัตถุฐานข้อมูลแรกที่ส่งคืนโดยแบบสอบถามด้วย First () นี่คือวัตถุฐานข้อมูลสำหรับ tempdb1 และมี SelfLink ที่เราสามารถใช้เพื่อเรียก DeleteDatabaseAsync ซึ่งจะลบฐานข้อมูล

Step 4 - คุณต้องเรียกใช้งาน DeleteDatabase จากงาน CreateDocumentClient หลังจาก DocumentClient ถูกสร้างอินสแตนซ์

Step 5 - หากต้องการดูรายการฐานข้อมูลหลังจากลบฐานข้อมูลที่ระบุแล้วให้เรียกเมธอด GetDatabases อีกครั้ง

using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
   //await CreateDatabase(client);
	
   GetDatabases(client);
   await DeleteDatabase(client);
   GetDatabases(client); 
}

ต่อไปนี้เป็นไฟล์ 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==";
			
      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);
      }
		
   }
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้ซึ่งมีฐานข้อมูลและรหัสทรัพยากรของฐานข้อมูลทั้งสามและจำนวนฐานข้อมูลทั้งหมด

******** Get Databases List ******** 
 Database Id: myfirstdb; Rid: Ic8LAA== 
 Database Id: mynewdb; Rid: ltpJAA== 
 Database Id: tempdb1; Rid: 06JjAA==
 
Total databases: 3  

******** Delete Database ******** 
  
******** Get Databases List ******** 
 Database Id: myfirstdb; Rid: Ic8LAA== 
 Database Id: mynewdb; Rid: ltpJAA==
 
Total databases: 2

หลังจากลบฐานข้อมูลแล้วคุณจะเห็นในตอนท้ายว่ามีเพียงสองฐานข้อมูลที่เหลืออยู่ในบัญชี DocumentDB

ในบทนี้เราจะเรียนรู้วิธีสร้างคอลเลกชัน มันคล้ายกับการสร้างฐานข้อมูล คุณสามารถสร้างคอลเล็กชันจากพอร์ทัลหรือจากโค้ดโดยใช้. Net SDK

Step 1 - ไปที่แดชบอร์ดหลักบนพอร์ทัล Azure

Step 2 - เลือก myfirstdb จากรายการฐานข้อมูล

Step 3- คลิกที่ตัวเลือก 'เพิ่มคอลเล็กชัน' และระบุ ID สำหรับการรวบรวม เลือกระดับราคาสำหรับตัวเลือกอื่น

Step 4 - มาเลือก S1 Standard แล้วคลิกปุ่ม Select → OK

ดังที่คุณเห็นว่ามีการเพิ่ม MyCollection ใน myfirstdb

คุณยังสามารถสร้างคอลเลกชันจากรหัสโดยใช้. Net SDK มาดูขั้นตอนต่อไปนี้เพื่อเพิ่มคอลเลกชันจากโค้ด

Step 1 - เปิดแอปพลิเคชันคอนโซลใน Visual Studio

Step 2 - ในการสร้างคอลเลกชันก่อนอื่นให้ดึงฐานข้อมูล myfirstdb โดยใช้ ID ในงาน 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"); 
   }
}

ต่อไปนี้คือการใช้งานสำหรับงาน 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);
}

เราสร้างอ็อบเจ็กต์ DocumentCollection ใหม่ที่กำหนดคอลเล็กชันใหม่ด้วย Id ที่ต้องการสำหรับเมธอด CreateDocumentCollectionAsync ซึ่งยอมรับพารามิเตอร์อ็อพชันที่เราใช้ที่นี่เพื่อตั้งค่าระดับประสิทธิภาพของคอลเล็กชันใหม่ซึ่งเราเรียกว่า offerType

ค่าเริ่มต้นนี้เป็น S1 และเนื่องจากเราไม่ผ่าน offerType สำหรับ MyCollection1 ดังนั้นนี่จะเป็นคอลเล็กชัน S1 และสำหรับ MyCollection2 เราได้ผ่าน S2 ซึ่งทำให้เป็น S2 ดังที่แสดงด้านบน

ต่อไปนี้คือการนำเมธอด 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);
}

ต่อไปนี้เป็นการใช้งานไฟล์ 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 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);
      }
		
   }
}

เมื่อรวบรวมและดำเนินการโค้ดด้านบนคุณจะได้รับผลลัพธ์ต่อไปนี้ซึ่งมีข้อมูลทั้งหมดที่เกี่ยวข้องกับการรวบรวม

**** Create Collection MyCollection1 in myfirstdb **** 
Created new collection
   Collection ID: MyCollection1
      Resource ID: Ic8LAPPvnAA=
         Self Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/
   Documents Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/docs/
         UDFs Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/udfs/
   StoredProcs Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/sprocs/
      Triggers Link: dbs/Ic8LAA==/colls/Ic8LAPPvnAA=/triggers/
         Timestamp: 12/10/2015 4:55:36 PM
		  
**** Create Collection MyCollection2 in myfirstdb ****
Created new collection
   Collection ID: MyCollection2
      Resource ID: Ic8LAKGHDwE=
         Self Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/
   Documents Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/docs/
         UDFs Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/udfs/
   StoredProcs Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/sprocs/
      Triggers Link: dbs/Ic8LAA==/colls/Ic8LAKGHDwE=/triggers/
         Timestamp: 12/10/2015 4:55:38 PM

ในการวางคอลเลคชันหรือคอลเลกชันคุณสามารถทำได้เช่นเดียวกันจากพอร์ทัลและจากโค้ดโดยใช้. Net SDK

Step 1- ไปที่บัญชี DocumentDB ของคุณบนพอร์ทัล Azure เพื่อจุดประสงค์ในการสาธิตฉันได้เพิ่มคอลเลกชันอีกสองชุดดังที่เห็นในภาพหน้าจอต่อไปนี้

Step 2- หากต้องการวางคอลเลกชันใด ๆ คุณต้องคลิกที่คอลเลกชันนั้น มาเลือก TempCollection1 กัน คุณจะเห็นหน้าต่อไปนี้เลือกตัวเลือก "ลบคอลเล็กชัน"

Step 3- จะแสดงข้อความยืนยัน ตอนนี้คลิกปุ่ม 'ใช่'

คุณจะเห็นว่า TempCollection1 ไม่มีในแดชบอร์ดของคุณอีกต่อไป

คุณยังสามารถลบคอลเลกชันจากรหัสของคุณโดยใช้. Net SDK โดยทำตามขั้นตอนต่อไปนี้

Step 1 - มาลบคอลเลคชันโดยระบุ ID ของคอลเล็กชันที่เราต้องการลบ

เป็นรูปแบบปกติของการสืบค้นโดย Id เพื่อรับ selfLinks ที่จำเป็นในการลบทรัพยากร

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);
}

ที่นี่เราจะเห็นวิธีที่ต้องการในการสร้างแบบสอบถามแบบกำหนดพารามิเตอร์ เราไม่ได้ฮาร์ดโค้ด collectionId ดังนั้นจึงสามารถใช้วิธีนี้เพื่อลบคอลเล็กชันใดก็ได้ เรากำลังค้นหาคอลเล็กชันเฉพาะโดย Id โดยที่พารามิเตอร์ Id ถูกกำหนดไว้ใน SqlParameterCollection นี้กำหนดให้กับคุณสมบัติของพารามิเตอร์ของ SqlQuerySpec นี้

จากนั้น SDK จะทำงานในการสร้างสตริงเคียวรีสุดท้ายสำหรับ DocumentDB โดยมี collectionId ฝังอยู่ภายใน

Step 2 - เรียกใช้แบบสอบถามจากนั้นใช้ SelfLink เพื่อลบคอลเลกชันจากงาน 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"); 
   } 
}

ต่อไปนี้คือการนำไฟล์ 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); 
      }
		
   } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Delete Collection TempCollection in myfirstdb **** 
Deleted collection TempCollection from database myfirstdb

ในบทนี้เราจะได้ทำงานกับเอกสารจริงในคอลเลคชัน คุณสามารถสร้างเอกสารโดยใช้พอร์ทัล Azure หรือ. Net SDK

การสร้างเอกสารด้วย Azure Portal

มาดูขั้นตอนต่อไปนี้เพื่อเพิ่มเอกสารลงในคอลเลกชันของคุณ

Step 1 - เพิ่มคอลเลกชั่นใหม่ตระกูลระดับราคา S1 ใน myfirstdb

Step 2 - เลือกคอลเลกชัน Families และคลิกที่ตัวเลือกสร้างเอกสารเพื่อเปิดใบมีดเอกสารใหม่

นี่เป็นเพียงโปรแกรมแก้ไขข้อความธรรมดา ๆ ที่ให้คุณพิมพ์ JSON สำหรับเอกสารใหม่

Step 3 - เนื่องจากนี่คือการป้อนข้อมูลดิบให้ป้อนเอกสารแรกของเรา

{
   "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
}

เมื่อคุณป้อนเอกสารด้านบนคุณจะเห็นหน้าจอต่อไปนี้

โปรดสังเกตว่าเราได้ระบุรหัสสำหรับเอกสาร จำเป็นต้องใช้ค่า id เสมอและต้องไม่ซ้ำกันในเอกสารอื่น ๆ ทั้งหมดในคอลเล็กชันเดียวกัน เมื่อคุณปล่อยทิ้งไว้ DocumentDB จะสร้างขึ้นมาให้คุณโดยอัตโนมัติโดยใช้ GUID หรือ Global Unique Identifier

id เป็นสตริงเสมอและต้องไม่เป็นตัวเลขวันที่บูลีนหรือวัตถุอื่นและต้องมีความยาวไม่เกิน 255 อักขระ

นอกจากนี้โปรดสังเกตโครงสร้างลำดับชั้นของเอกสารซึ่งมีคุณสมบัติระดับบนสุดบางอย่างเช่น id ที่ต้องการเช่นเดียวกับ lastName และ isRegistered แต่ยังมีคุณสมบัติที่ซ้อนกัน

ตัวอย่างเช่นคุณสมบัติ parent ถูกจัดให้เป็นอาร์เรย์ JSON ตามที่แสดงโดยวงเล็บเหลี่ยม นอกจากนี้เรายังมีอาร์เรย์อื่นสำหรับเด็กแม้ว่าจะมีลูกเดียวในอาร์เรย์ในตัวอย่างนี้

Step 4 - คลิกปุ่ม 'บันทึก' เพื่อบันทึกเอกสารและเราได้สร้างเอกสารแรกของเรา

ดังที่คุณเห็นว่าการจัดรูปแบบสวย ๆ ถูกนำไปใช้กับ JSON ของเราซึ่งจะแบ่งทุกคุณสมบัติในบรรทัดของตัวเองโดยเยื้องด้วยช่องว่างเพื่อแสดงระดับการซ้อนกันของแต่ละคุณสมบัติ

พอร์ทัลมี Document Explorer ดังนั้นให้ใช้ตอนนี้เพื่อดึงเอกสารที่เราเพิ่งสร้างขึ้น

Step 5- เลือกฐานข้อมูลและคอลเล็กชันใด ๆ ภายในฐานข้อมูลเพื่อดูเอกสารในคอลเล็กชันนั้น ขณะนี้เรามีฐานข้อมูลเพียงฐานข้อมูลชื่อ myfirstdb โดยมีหนึ่งคอลเล็กชันชื่อ Families ซึ่งทั้งสองได้รับการเลือกไว้ล่วงหน้าที่นี่ในเมนูแบบเลื่อนลง

ตามค่าเริ่มต้น Document Explorer จะแสดงรายการเอกสารที่ไม่มีการกรองภายในคอลเลกชัน แต่คุณยังสามารถค้นหาเอกสารใด ๆ โดยใช้ ID หรือเอกสารหลาย ๆ ชุดโดยใช้การค้นหาสัญลักษณ์แทนของ ID บางส่วน

เรามีเอกสารเพียงฉบับเดียวในคอลเล็กชันของเราและเราเห็น ID บนหน้าจอต่อไปนี้ AndersonFamily

Step 6 - คลิกที่ ID เพื่อดูเอกสาร

การสร้างเอกสารด้วย. NET SDK

ดังที่คุณทราบว่าเอกสารเป็นเพียงทรัพยากรอีกประเภทหนึ่งและคุณคุ้นเคยกับวิธีจัดการทรัพยากรโดยใช้ SDK แล้ว

  • ความแตกต่างที่สำคัญอย่างหนึ่งระหว่างเอกสารและทรัพยากรอื่น ๆ คือแน่นอนว่าเอกสารเหล่านี้ไม่มีสคีมา

  • จึงมีตัวเลือกมากมาย โดยปกติคุณสามารถทำงานกราฟออบเจ็กต์ JSON หรือแม้กระทั่งสตริงดิบของข้อความ JSON แต่คุณยังสามารถใช้วัตถุแบบไดนามิกที่ช่วยให้คุณเชื่อมโยงกับคุณสมบัติในรันไทม์ได้โดยไม่ต้องกำหนดคลาสในเวลาคอมไพล์

  • คุณยังสามารถทำงานกับออบเจ็กต์ C # จริงหรือเอนทิตีตามที่เรียกซึ่งอาจเป็นคลาสโดเมนธุรกิจของคุณ

มาเริ่มสร้างเอกสารโดยใช้. Net SDK ต่อไปนี้เป็นขั้นตอน

Step 1 - สร้างอินสแตนซ์ DocumentClient จากนั้นเราจะค้นหาฐานข้อมูล myfirstdb จากนั้นค้นหาคอลเล็กชัน MyCollection ซึ่งเราเก็บไว้ในคอลเล็กชันตัวแปรส่วนตัวนี้เพื่อให้สามารถเข้าถึงได้ทั่วทั้งคลาส

private static async Task CreateDocumentClient() {
   // Create a new instance of the DocumentClient
	
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) {
      database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
         'myfirstdb'").AsEnumerable().First(); 
			
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
         "SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();  
			
      await CreateDocuments(client); 
   } 
}

Step 2 - สร้างเอกสารบางอย่างในงาน CreateDocuments

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(); 
}

เอกสารแรกจะถูกสร้างขึ้นจากวัตถุไดนามิกนี้ สิ่งนี้อาจดูเหมือน JSON แต่แน่นอนว่าไม่ใช่ นี่คือรหัส C # และเรากำลังสร้างออบเจ็กต์. NET จริง แต่ไม่มีนิยามคลาส แต่คุณสมบัติจะถูกอนุมานจากวิธีเริ่มต้นวัตถุ

โปรดสังเกตว่าเราไม่ได้ให้คุณสมบัติ Id สำหรับเอกสารนี้

ตอนนี้เรามาดู CreateDocument กัน ดูเหมือนรูปแบบเดียวกับที่เราเห็นในการสร้างฐานข้อมูลและคอลเล็กชัน

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- คราวนี้เราเรียก CreateDocumentAsync ระบุ SelfLink ของคอลเล็กชันที่เราต้องการเพิ่มเอกสาร เราได้รับการตอบกลับพร้อมคุณสมบัติทรัพยากรที่ในกรณีนี้แสดงถึงเอกสารใหม่ที่มีคุณสมบัติที่ระบบสร้างขึ้น

อ็อบเจ็กต์ Document เป็นคลาสที่กำหนดไว้ใน SDK ซึ่งสืบทอดมาจากรีซอร์สดังนั้นจึงมีคุณสมบัติของรีซอร์สทั่วไปทั้งหมด แต่ยังรวมถึงคุณสมบัติไดนามิกที่กำหนดเอกสารที่ไม่มีสคีมาเอง

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();
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Create Documents ****  
Created new document: 34e9873a-94c8-4720-9146-d63fb7840fad {
   "name": "New Customer 1", 
	
   "address": { 
      "addressType": "Main Office", 
      "addressLine1": "123 Main Street", 
      "location": { 
         "city": "Brooklyn", "stateProvinceName": "New York" 
      }, 
      "postalCode": "11229", "countryRegionName": "United States"
   }, 
	
   "id": "34e9873a-94c8-4720-9146-d63fb7840fad", 
   "_rid": "Ic8LAMEUVgACAAAAAAAAAA==", 
   "_ts": 1449812756, 
   "_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgACAAAAAAAAAA==/", 
   "_etag": "\"00001000-0000-0000-0000-566a63140000\"", 
   "_attachments": "attachments/" 
} 
Created document 34e9873a-94c8-4720-9146-d63fb7840fad from dynamic object

อย่างที่คุณเห็นเรายังไม่ได้ให้ ID แต่ DocumentDB สร้างรหัสนี้ให้เราสำหรับเอกสารใหม่

ใน DocumentDB เราใช้ SQL เพื่อค้นหาเอกสารดังนั้นบทนี้จึงเกี่ยวกับการสืบค้นโดยใช้ไวยากรณ์ SQL พิเศษใน DocumentDB แม้ว่าคุณกำลังทำการพัฒนา. NET แต่ก็มีผู้ให้บริการ LINQ ที่สามารถใช้งานได้และสามารถสร้าง SQL ที่เหมาะสมจากแบบสอบถาม LINQ ได้

การสืบค้นเอกสารโดยใช้พอร์ทัล

พอร์ทัล Azure มี Query Explorer ที่ให้คุณเรียกใช้แบบสอบถาม SQL กับฐานข้อมูล DocumentDB ของคุณ

เราจะใช้ Query Explorer เพื่อแสดงให้เห็นถึงความสามารถและคุณสมบัติที่แตกต่างกันมากมายของภาษาแบบสอบถามโดยเริ่มจากการสืบค้นที่ง่ายที่สุด

Step 1 - ในเบลดฐานข้อมูลคลิกเพื่อเปิดเบลด Query Explorer

โปรดจำไว้ว่าการสืบค้นจะทำงานภายในขอบเขตของคอลเล็กชันดังนั้น Query Explorer จึงให้คุณเลือกคอลเล็กชันในเมนูแบบเลื่อนลงนี้

Step 2 - เลือกคอลเล็กชัน Families ซึ่งสร้างขึ้นก่อนหน้านี้โดยใช้พอร์ทัล

Query Explorer จะเปิดขึ้นพร้อมกับการสืบค้นง่ายๆนี้ SELECT * FROM c ซึ่งจะดึงเอกสารทั้งหมดจากคอลเล็กชัน

Step 3- ดำเนินการค้นหานี้โดยคลิกปุ่ม "เรียกใช้การสืบค้น" จากนั้นคุณจะเห็นว่าเอกสารฉบับสมบูรณ์ถูกดึงมาในใบมีดผลลัพธ์

การสืบค้นเอกสารโดยใช้. Net SDK

ต่อไปนี้เป็นขั้นตอนในการรันคิวรีเอกสารโดยใช้. Net SDK

ในตัวอย่างนี้เราต้องการค้นหาเอกสารที่สร้างขึ้นใหม่ที่เราเพิ่งเพิ่มเข้าไป

Step 1 - เรียก CreateDocumentQuery ส่งผ่านคอลเลกชันเพื่อเรียกใช้แบบสอบถามโดย SelfLink และข้อความค้นหา

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(); 
}

แบบสอบถามนี้ส่งคืนเอกสารทั้งหมดในคอลเลกชันทั้งหมด แต่เราไม่ได้เรียก. ToList บน CreateDocumentQuery เหมือนเดิมซึ่งจะส่งคำขอให้มากที่สุดเท่าที่จำเป็นเพื่อดึงผลลัพธ์ทั้งหมดลงในโค้ดบรรทัดเดียว

Step 2 - ให้เรียก AsDocumentQuery แทนและวิธีนี้จะส่งคืนวัตถุแบบสอบถามที่มีคุณสมบัติ HasMoreResults

Step 3 - ถ้า HasMoreResults เป็นจริงให้เรียก ExecuteNextAsync เพื่อรับชิ้นส่วนถัดไปจากนั้นถ่ายโอนเนื้อหาทั้งหมดของกลุ่มนั้น

Step 4- คุณยังสามารถสอบถามโดยใช้ LINQ แทน SQL ได้หากต้องการ ที่นี่เราได้กำหนดแบบสอบถาม LINQ ใน q แต่จะไม่ดำเนินการจนกว่าเราจะเรียกใช้. ToList

private static void QueryDocumentsWithLinq(DocumentClient client) {
   Console.WriteLine(); 
   Console.WriteLine("**** Query Documents (LINQ) ****"); 
   Console.WriteLine();  
   Console.WriteLine("Quering for US customers (LINQ)");
	
   var q = 
      from d in client.CreateDocumentQuery<Customer>(collection.DocumentsLink) 
      where d.Address.CountryRegionName == " United States" 
      select new {
         Id = d.Id, 
         Name = d.Name, 
         City = d.Address.Location.City 
      };  
		
   var documents = q.ToList();  
   Console.WriteLine("Found {0} UK customers", documents.Count);
	
   foreach (var document in documents) {
      var d = document as dynamic; 
      Console.WriteLine(" Id: {0}; Name: {1}; City: {2}", d.Id, d.Name, d.City); 
   } 
	
   Console.WriteLine(); 
}

SDK จะแปลงแบบสอบถาม LINQ ของเราเป็นไวยากรณ์ SQL สำหรับ DocumentDB สร้างส่วนคำสั่ง SELECT และ WHERE ตามไวยากรณ์ LINQ ของเรา

Step 5 - ตอนนี้เรียกใช้แบบสอบถามข้างต้นจากงาน 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); 
   } 
	
}

เมื่อดำเนินการโค้ดด้านบนคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Query Documents (paged results) ****  
Quering for all documents 
 Id: 7e9ad4fa-c432-4d1a-b120-58fd7113609f; Name: New Customer 1; 
 Id: 34e9873a-94c8-4720-9146-d63fb7840fad; Name: New Customer 1;  
 
**** Query Documents (LINQ) **** 
Quering for US customers (LINQ) 
Found 2 UK customers 
 Id: 7e9ad4fa-c432-4d1a-b120-58fd7113609f; Name: New Customer 1; City: Brooklyn 
 Id: 34e9873a-94c8-4720-9146-d63fb7840fad; Name: New Customer 1; City: Brooklyn

ในบทนี้เราจะเรียนรู้วิธีการปรับปรุงเอกสาร ด้วยการใช้พอร์ทัล Azure คุณสามารถอัปเดตเอกสารได้อย่างง่ายดายโดยเปิดเอกสารใน Document explorer และอัปเดตในโปรแกรมแก้ไขเช่นไฟล์ข้อความ

คลิกปุ่ม 'บันทึก' ตอนนี้เมื่อคุณต้องการเปลี่ยนเอกสารโดยใช้. Net SDK คุณก็สามารถแทนที่ได้ คุณไม่จำเป็นต้องลบและสร้างมันขึ้นมาใหม่ซึ่งนอกจากจะน่าเบื่อแล้วยังเปลี่ยนรหัสทรัพยากรซึ่งคุณไม่ต้องการทำเมื่อคุณเพิ่งแก้ไขเอกสาร ขั้นตอนต่อไปนี้เพื่ออัปเดตเอกสารโดยใช้. Net SDK

ลองดูที่งาน ReplaceDocuments ต่อไปนี้ที่เราจะค้นหาเอกสารที่คุณสมบัติ isNew เป็นจริง แต่เราจะไม่ได้รับเลยเพราะไม่มีเลย เรามาแก้ไขเอกสารที่เราเพิ่มไว้ก่อนหน้าซึ่งมีชื่อขึ้นต้นด้วยลูกค้าใหม่

Step 1 - เพิ่มคุณสมบัติ isNew ให้กับเอกสารเหล่านี้และตั้งค่าเป็น 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 - รับเอกสารที่จะอัปเดตโดยใช้แบบสอบถาม STARTSWITH เดียวกันและให้เอกสารแก่เราซึ่งเราจะกลับมาที่นี่ในฐานะวัตถุแบบไดนามิก

Step 3 - แนบคุณสมบัติ isNew และตั้งค่าเป็น true สำหรับแต่ละเอกสาร

Step 4 - เรียก ReplaceDocumentAsync ส่งผ่าน SelfLink ของเอกสารพร้อมกับเอกสารที่อัปเดต

ตอนนี้เพื่อพิสูจน์ว่าสิ่งนี้ใช้ได้ผลให้ค้นหาเอกสารที่ isNew เท่ากับจริง เรียกแบบสอบถามข้างต้นจากงาน 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); 
   }
	
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Replace Documents ****  
Quering for documents with 'isNew' flag 
Documents with 'isNew' flag: 0 
Quering for documents to be updated 
Found 2 documents to be updated 
Updated document ‘isNew’ flag: True 
Updated document ‘isNew’ flag: True 
Quering for documents with 'isNew' flag 
Documents with 'isNew' flag: 2

ในบทนี้เราจะเรียนรู้วิธีการลบเอกสารจากบัญชี DocumentDB ของคุณ ด้วยการใช้ Azure Portal คุณสามารถลบเอกสารใด ๆ ได้อย่างง่ายดายโดยเปิดเอกสารใน Document Explorer แล้วคลิกตัวเลือก 'ลบ'

มันจะแสดงข้อความยืนยัน ตอนนี้กดปุ่มใช่และคุณจะเห็นว่าเอกสารไม่มีอยู่ในบัญชี DocumentDB ของคุณอีกต่อไป

ตอนนี้เมื่อคุณต้องการลบเอกสารโดยใช้. Net SDK

Step 1- เป็นรูปแบบเดียวกับที่เราเคยเห็นมาก่อนซึ่งเราจะสอบถามก่อนเพื่อรับ SelfLinks ของเอกสารใหม่แต่ละฉบับ เราไม่ได้ใช้ SELECT * ที่นี่ซึ่งจะส่งคืนเอกสารทั้งหมดซึ่งเราไม่ต้องการ

Step 2 - แต่เราแค่เลือก SelfLinks ลงในรายการจากนั้นเราก็เรียก DeleteDocumentAsync สำหรับ SelfLink แต่ละรายการทีละรายการเพื่อลบเอกสารออกจากคอลเล็กชัน

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 - ตอนนี้ขอเรียก DeleteDocuments ด้านบนจากงาน 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); 
   } 
}

เมื่อดำเนินการโค้ดด้านบนคุณจะได้รับผลลัพธ์ต่อไปนี้

***** Delete Documents *****  
Quering for documents to be deleted 
Found 2 documents to be deleted 
Deleted 2 new customer documents

แม้ว่าฐานข้อมูลที่ไม่มีสคีมาเช่น DocumentDB จะทำให้การเปลี่ยนแปลงโมเดลข้อมูลของคุณเป็นเรื่องง่ายมาก แต่คุณควรใช้เวลาคิดเกี่ยวกับข้อมูลของคุณ

  • คุณมีตัวเลือกมากมาย โดยปกติคุณสามารถทำงานกราฟออบเจ็กต์ JSON หรือแม้กระทั่งสตริงดิบของข้อความ JSON แต่คุณยังสามารถใช้วัตถุแบบไดนามิกที่ช่วยให้คุณเชื่อมโยงกับคุณสมบัติในรันไทม์ได้โดยไม่ต้องกำหนดคลาสในเวลาคอมไพล์

  • คุณยังสามารถทำงานกับออบเจ็กต์ C # จริงหรือเอนทิตีตามที่เรียกซึ่งอาจเป็นคลาสโดเมนธุรกิจของคุณ

ความสัมพันธ์

มาดูโครงสร้างลำดับชั้นของเอกสารกัน มีคุณสมบัติระดับบนสุดสองสามอย่างเช่นรหัสที่ต้องการเช่นเดียวกับ lastName และ isRegistered แต่ก็มีคุณสมบัติที่ซ้อนกัน

{ 
   "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 
}
  • ตัวอย่างเช่นคุณสมบัติ parent ถูกจัดให้เป็นอาร์เรย์ JSON ตามที่แสดงโดยวงเล็บเหลี่ยม

  • นอกจากนี้เรายังมีอาร์เรย์อื่นสำหรับเด็กแม้ว่าจะมีลูกเดียวในอาร์เรย์ในตัวอย่างนี้ นี่คือวิธีที่คุณสร้างโมเดลให้เทียบเท่ากับความสัมพันธ์แบบหนึ่งต่อกลุ่มภายในเอกสาร

  • คุณเพียงแค่ใช้อาร์เรย์โดยที่แต่ละองค์ประกอบในอาร์เรย์อาจเป็นค่าธรรมดาหรือวัตถุที่ซับซ้อนอื่นแม้แต่อาร์เรย์อื่น

  • ดังนั้นครอบครัวหนึ่งสามารถมีพ่อแม่หลายคนและมีลูกได้หลายคนและหากคุณมองไปที่วัตถุของเด็กพวกเขาจะมีทรัพย์สินของสัตว์เลี้ยงซึ่งเป็นอาร์เรย์ที่ซ้อนกันสำหรับความสัมพันธ์ระหว่างเด็กและสัตว์เลี้ยง

  • สำหรับคุณสมบัติตำแหน่งเรากำลังรวมคุณสมบัติที่เกี่ยวข้องสามอย่างรัฐเขตและเมืองไว้ในวัตถุ

  • การฝังวัตถุด้วยวิธีนี้แทนที่จะฝังอาร์เรย์ของวัตถุคล้ายกับการมีความสัมพันธ์แบบหนึ่งต่อหนึ่งระหว่างสองแถวในตารางแยกกันในฐานข้อมูลเชิงสัมพันธ์

การฝังข้อมูล

เมื่อคุณเริ่มสร้างโมเดลข้อมูลในที่เก็บเอกสารเช่น DocumentDB ให้พยายามปฏิบัติต่อเอนทิตีของคุณเป็นเอกสารในตัวที่แสดงใน JSON เมื่อทำงานกับฐานข้อมูลเชิงสัมพันธ์เราจะทำให้ข้อมูลเป็นมาตรฐานเสมอ

  • โดยทั่วไปการทำให้ข้อมูลของคุณเป็นปกติจะเกี่ยวข้องกับการพิจารณาเอนทิตีเช่นลูกค้าและแยกย่อยออกเป็นส่วนข้อมูลที่รอบคอบเช่นรายละเอียดการติดต่อและที่อยู่

  • ในการอ่านลูกค้าพร้อมรายละเอียดการติดต่อและที่อยู่ทั้งหมดคุณต้องใช้ JOINS เพื่อรวบรวมข้อมูลของคุณอย่างมีประสิทธิภาพในขณะดำเนินการ

ตอนนี้เรามาดูวิธีที่เราจะสร้างแบบจำลองข้อมูลเดียวกันกับเอนทิตีที่มีอยู่ในตัวเองในฐานข้อมูลเอกสาร

{
   "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} 
   ]
}

ดังที่คุณเห็นว่าเราได้ทำให้บันทึกของลูกค้าผิดปกติโดยที่ข้อมูลทั้งหมดของลูกค้าถูกฝังอยู่ในเอกสาร JSON เดียว

ใน NoSQL เรามีสคีมาฟรีดังนั้นคุณสามารถเพิ่มรายละเอียดการติดต่อและที่อยู่ในรูปแบบต่างๆได้เช่นกัน ใน NoSQL คุณสามารถดึงข้อมูลลูกค้าจากฐานข้อมูลได้ในการดำเนินการอ่านครั้งเดียว ในทำนองเดียวกันการอัปเดตเรกคอร์ดยังเป็นการดำเนินการเขียนเพียงครั้งเดียว

ต่อไปนี้เป็นขั้นตอนในการสร้างเอกสารโดยใช้. Net SDK

Step 1- สร้างอินสแตนซ์ DocumentClient จากนั้นเราจะค้นหาฐานข้อมูล myfirstdb และค้นหาคอลเล็กชัน MyCollection ซึ่งเราเก็บไว้ในคอลเล็กชันตัวแปรส่วนตัวนี้เพื่อให้สามารถเข้าถึงได้ทั่วทั้งชั้นเรียน

private static async Task CreateDocumentClient() { 
   // Create a new instance of the DocumentClient
	
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) { 
      database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id =
         'myfirstdb'").AsEnumerable().First(); 
			
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
         "SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();  
			
      await CreateDocuments(client); 
   }

}

Step 2 - สร้างเอกสารบางอย่างในงาน CreateDocuments

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(); 
}

เอกสารแรกจะถูกสร้างขึ้นจากวัตถุไดนามิกนี้ สิ่งนี้อาจดูเหมือน JSON แต่แน่นอนว่าไม่ใช่ นี่คือรหัส C # และเรากำลังสร้างออบเจ็กต์. NET จริง แต่ไม่มีนิยามคลาส แต่คุณสมบัติจะถูกอนุมานจากวิธีเริ่มต้นวัตถุ คุณสามารถสังเกตได้ว่าเราไม่ได้ให้คุณสมบัติ Id สำหรับเอกสารนี้

Step 3 - ตอนนี้เรามาดู CreateDocument และดูเหมือนว่าจะเป็นรูปแบบเดียวกับที่เราเห็นในการสร้างฐานข้อมูลและคอลเล็กชัน

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- คราวนี้เราเรียก CreateDocumentAsync ระบุ SelfLink ของคอลเล็กชันที่เราต้องการเพิ่มเอกสาร เราได้รับการตอบกลับพร้อมคุณสมบัติทรัพยากรที่ในกรณีนี้แสดงถึงเอกสารใหม่ที่มีคุณสมบัติที่ระบบสร้างขึ้น

ในงาน CreateDocuments ต่อไปนี้เราได้สร้างเอกสารสามชุด

  • ในเอกสารแรกอ็อบเจ็กต์ Document เป็นคลาสที่กำหนดไว้ใน SDK ซึ่งสืบทอดมาจากรีซอร์สดังนั้นจึงมีคุณสมบัติรีซอร์สทั่วไปทั้งหมด แต่ยังรวมคุณสมบัติไดนามิกที่กำหนดเอกสารที่ไม่มีสคีมาด้วย

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(); 
}
  • เอกสารที่สองนี้ใช้ได้กับสตริง JSON ดิบ ตอนนี้เราก้าวเข้าสู่การโอเวอร์โหลดสำหรับ CreateDocument ที่ใช้ JavaScriptSerializer เพื่อยกเลิกการต่ออนุกรมสตริงลงในอ็อบเจ็กต์ซึ่งจะส่งต่อไปยังเมธอด CreateDocument เดียวกับที่เราใช้ในการสร้างเอกสารแรก

  • ในเอกสารฉบับที่สามเราได้ใช้วัตถุ C # ลูกค้าซึ่งกำหนดไว้ในใบสมัครของเรา

ลองมาดูที่ลูกค้ารายนี้มีคุณสมบัติ Id และ address โดยที่อยู่เป็นอ็อบเจ็กต์ที่ซ้อนกันซึ่งมีคุณสมบัติของตัวเองรวมถึงตำแหน่งซึ่งเป็นอีกอ็อบเจกต์ที่ซ้อนกัน

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; } 
   } 
}

นอกจากนี้เรายังมีแอตทริบิวต์คุณสมบัติ JSON เนื่องจากเราต้องการคงรูปแบบที่เหมาะสมไว้ทั้งสองด้านของรั้ว

ดังนั้นฉันจึงสร้างอ็อบเจ็กต์ New Customer ของฉันพร้อมกับอ็อบเจ็กต์ลูกที่ซ้อนกันและโทรเข้า CreateDocument อีกครั้ง แม้ว่าออบเจ็กต์ลูกค้าของเราจะมีคุณสมบัติ Id แต่เราก็ไม่ได้ให้ค่าสำหรับมันดังนั้น DocumentDB จึงสร้างขึ้นตาม GUID เช่นเดียวกับที่ทำกับเอกสารสองชุดก่อนหน้า

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Create Documents ****  
Created new document: 575882f0-236c-4c3d-81b9-d27780206b2c 
{ 
  "name": "New Customer 1", 
  "address": { 
    "addressType": "Main Office", 
    "addressLine1": "123 Main Street", 
    "location": { 
      "city": "Brooklyn", 
      "stateProvinceName": "New York" 
    }, 
    "postalCode": "11229", 
    "countryRegionName": "United States" 
  }, 
  "id": "575882f0-236c-4c3d-81b9-d27780206b2c", 
  "_rid": "kV5oANVXnwDGPgAAAAAAAA==", 
  "_ts": 1450037545, 
  "_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDGPgAAAAAAAA==/", 
  "_etag": "\"00006fce-0000-0000-0000-566dd1290000\"", 
  "_attachments": "attachments/" 
} 
Created document 575882f0-236c-4c3d-81b9-d27780206b2c from dynamic object  
Created new document: 8d7ad239-2148-4fab-901b-17a85d331056 
{ 
  "name": "New Customer 2", 
  "address": {
    "addressType": "Main Office", 
    "addressLine1": "123 Main Street", 
    "location": { 
      "city": "Brooklyn", 
      "stateProvinceName": "New York" 
    }, 
    "postalCode": "11229", 
    "countryRegionName": "United States" 
  }, 
  "id": "8d7ad239-2148-4fab-901b-17a85d331056", 
  "_rid": "kV5oANVXnwDHPgAAAAAAAA==", 
  "_ts": 1450037545, 
  "_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDHPgAAAAAAAA==/", 
  "_etag": "\"000070ce-0000-0000-0000-566dd1290000\"", 
  "_attachments": "attachments/" 
} 
Created document 8d7ad239-2148-4fab-901b-17a85d331056 from JSON string  
Created new document: 49f399a8-80c9-4844-ac28-cd1dee689968 
{ 
  "id": "49f399a8-80c9-4844-ac28-cd1dee689968", 
  "name": "New Customer 3", 
  "address": { 
    "addressType": "Main Office", 
    "addressLine1": "123 Main Street", 
    "location": { 
      "city": "Brooklyn", 
      "stateProvinceName": "New York" 
    }, 
    "postalCode": "11229", 
    "countryRegionName": "United States" 
  }, 
  "_rid": "kV5oANVXnwDIPgAAAAAAAA==", 
  "_ts": 1450037546, 
  "_self": "dbs/kV5oAA==/colls/kV5oANVXnwA=/docs/kV5oANVXnwDIPgAAAAAAAA==/", 
  "_etag": "\"000071ce-0000-0000-0000-566dd12a0000\"", 
  "_attachments": "attachments/" 
}
Created document 49f399a8-80c9-4844-ac28-cd1dee689968 from typed object

JSON หรือ JavaScript Object Notation เป็นมาตรฐานแบบเปิดแบบข้อความที่มีน้ำหนักเบาซึ่งออกแบบมาสำหรับการแลกเปลี่ยนข้อมูลที่มนุษย์อ่านได้และยังง่ายสำหรับเครื่องในการแยกวิเคราะห์และสร้าง JSON เป็นหัวใจสำคัญของ DocumentDB เราส่ง JSON ผ่านสายไฟเราจัดเก็บ JSON เป็น JSON และเราจัดทำดัชนีโครงสร้าง JSON เพื่อให้สามารถค้นหาในเอกสาร JSON แบบเต็มได้

รูปแบบ JSON รองรับประเภทข้อมูลต่อไปนี้ -

ส. ประเภทและคำอธิบาย
1

Number

รูปแบบทศนิยมที่มีความแม่นยำสองเท่าใน JavaScript

2

String

Unicode ที่ยกมาสองครั้งพร้อมแบ็กสแลช Escape

3

Boolean

จริงหรือเท็จ

4

Array

ลำดับของค่า

5

Value

อาจเป็นสตริงตัวเลขจริงหรือเท็จโมฆะเป็นต้น

6

Object

คอลเลกชันที่ไม่เรียงลำดับของคู่คีย์: ค่า

7

Whitespace

สามารถใช้ระหว่างโทเค็นคู่ใดก็ได้

8

Null

ว่างเปล่า

ลองมาดูตัวอย่างประเภท DateTime ง่ายๆ เพิ่มวันเกิดในชั้นเรียนของลูกค้า

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; } 
}

เราสามารถจัดเก็บเรียกค้นและสืบค้นโดยใช้ DateTime ดังที่แสดงในโค้ดต่อไปนี้

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(); 
}

เมื่อรวบรวมและดำเนินการโค้ดด้านบนและเอกสารถูกสร้างขึ้นคุณจะเห็นว่ามีการเพิ่มวันเกิดในขณะนี้

**** Create Documents ****  
Created new document: 1001 
{ 
   "id": "1001", 
   "name": "Luke Andrew", 
   "address": { 
      "addressType": "Main Office", 
      "addressLine1": "123 Main Street", 
      "location": { 
         "city": "Brooklyn", 
         "stateProvinceName": "New York" 
      }, 
      "postalCode": "11229", 
      "countryRegionName": "United States" 
   }, 
   "birthDate": "2015-12-14T00:00:00", 
   "_rid": "Ic8LAMEUVgAKAAAAAAAAAA==", 
   "_ts": 1450113676, 
   "_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgAKAAAAAAAAAA==/", 
   "_etag": "\"00002d00-0000-0000-0000-566efa8c0000\"", 
   "_attachments": "attachments/" 
} 
Created document 1001 from typed object

เมื่อเร็ว ๆ นี้ Microsoft ได้เพิ่มการปรับปรุงจำนวนมากเกี่ยวกับวิธีที่คุณสามารถสอบถาม Azure DocumentDB เช่นคีย์เวิร์ด TOP สำหรับไวยากรณ์ SQL ซึ่งทำให้คิวรีทำงานได้เร็วขึ้นและใช้ทรัพยากรน้อยลงเพิ่มขีด จำกัด สำหรับตัวดำเนินการคิวรีและเพิ่มการสนับสนุนสำหรับตัวดำเนินการ LINQ เพิ่มเติมใน . NET SDK

ลองมาดูตัวอย่างง่ายๆที่เราจะดึงเฉพาะสองระเบียนแรก หากคุณมีระเบียนจำนวนมากและต้องการดึงข้อมูลเพียงบางส่วนคุณสามารถใช้คำหลักยอดนิยมได้ ในตัวอย่างนี้เรามีบันทึกการเกิดแผ่นดินไหวจำนวนมาก

ตอนนี้เราต้องการแสดงสองระเบียนแรกเท่านั้น

Step 1 - ไปที่ตัวสำรวจแบบสอบถามและเรียกใช้แบบสอบถามนี้

SELECT * FROM c 
WHERE c.magnitude > 2.5

คุณจะเห็นว่ามีการดึงข้อมูลสี่รายการเนื่องจากเรายังไม่ได้ระบุคำหลักที่เป็น TOP

Step 2- ตอนนี้ใช้คำหลัก TOP กับแบบสอบถามเดียวกัน ที่นี่เราได้ระบุคำหลัก TOP และ '2' หมายความว่าเราต้องการบันทึกสองรายการเท่านั้น

SELECT TOP 2 * FROM c 
WHERE c.magnitude > 2.5

Step 3 - ตอนนี้เรียกใช้แบบสอบถามนี้และคุณจะเห็นว่ามีการเรียกข้อมูลเพียงสองระเบียน

ในทำนองเดียวกันคุณสามารถใช้คำหลัก TOP ในโค้ดโดยใช้. Net SDK ต่อไปนี้คือการนำไปใช้

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(); 
}

ต่อไปนี้เป็นงาน CreateDocumentClient ซึ่งสร้างอินสแตนซ์ฐานข้อมูล DocumentClient และแผ่นดินไหว

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); 
   } 
}

เมื่อรวบรวมและดำเนินการโค้ดด้านบนคุณจะเห็นว่ามีการเรียกข้อมูลเพียงสามรายการเท่านั้น

**** 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 รองรับการสืบค้นเอกสารโดยใช้ SQL ผ่านเอกสาร JSON คุณสามารถจัดเรียงเอกสารในคอลเลกชันด้วยตัวเลขและสตริงโดยใช้คำสั่ง ORDER BY ในแบบสอบถามของคุณ อนุประโยคสามารถรวมอาร์กิวเมนต์ ASC / DESC ที่เป็นทางเลือกเพื่อระบุลำดับที่จะต้องดึงผลลัพธ์

ลองดูตัวอย่างต่อไปนี้ที่เรามีเอกสาร 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
      }
   ]
	
}

ต่อไปนี้เป็นแบบสอบถาม SQL เพื่อเรียงลำดับผลลัพธ์จากมากไปหาน้อย

SELECT f.description, f.foodGroup,  
   f.servings[2].description AS servingDescription,  
   f.servings[2].weightInGrams AS servingWeight  
	
FROM f  
ORDER BY f.servings[2].weightInGrams DESC

เมื่อดำเนินการค้นหาข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้

[
   {
      "description": "Grapes, red or green (European type, such as Thompson
         seedless), raw",
      "foodGroup": "Fruits and Fruit Juices",
      "servingDescription": "NLEA serving",
      "servingWeight": 126
   }
]

ตามค่าเริ่มต้น DocumentDB จะทำดัชนีทุกคุณสมบัติในเอกสารโดยอัตโนมัติทันทีที่เอกสารถูกเพิ่มลงในฐานข้อมูล อย่างไรก็ตามคุณสามารถควบคุมและปรับแต่งนโยบายการจัดทำดัชนีของคุณเองเพื่อลดค่าใช้จ่ายในการจัดเก็บและการประมวลผลเมื่อมีเอกสารและ / หรือคุณสมบัติเฉพาะที่ไม่จำเป็นต้องจัดทำดัชนี

นโยบายการจัดทำดัชนีเริ่มต้นที่บอกให้ DocumentDB ทำดัชนีทุกคุณสมบัติโดยอัตโนมัติเหมาะสำหรับสถานการณ์ทั่วไปจำนวนมาก แต่คุณยังสามารถใช้นโยบายแบบกำหนดเองที่ควบคุมสิ่งที่ถูกจัดทำดัชนีและสิ่งที่ไม่ได้และฟังก์ชันอื่น ๆ ที่เกี่ยวข้องกับการจัดทำดัชนี

DocumentDB รองรับการสร้างดัชนีประเภทต่อไปนี้ -

  • Hash
  • Range

กัญชา

ดัชนีแฮชช่วยให้สามารถค้นหาความเท่าเทียมกันได้อย่างมีประสิทธิภาพกล่าวคือในขณะที่ค้นหาเอกสารที่คุณสมบัติที่กำหนดเท่ากับค่าที่แน่นอนแทนที่จะจับคู่กับช่วงของค่าเช่นน้อยกว่ามากกว่าหรือระหว่าง

คุณสามารถดำเนินการสืบค้นช่วงด้วยดัชนีแฮชได้ แต่ DocumentDB จะไม่สามารถใช้ดัชนีแฮชเพื่อค้นหาเอกสารที่ตรงกันได้และจะต้องสแกนเอกสารแต่ละฉบับตามลำดับเพื่อพิจารณาว่าควรจะเลือกโดยการสืบค้นช่วง

คุณจะไม่สามารถจัดเรียงเอกสารของคุณด้วยคำสั่ง ORDER BY ในคุณสมบัติที่มีเพียงดัชนีแฮช

พิสัย

ดัชนีช่วงที่กำหนดสำหรับคุณสมบัติ DocumentDB ช่วยให้สามารถสืบค้นเอกสารเทียบกับช่วงของค่าได้อย่างมีประสิทธิภาพ นอกจากนี้ยังช่วยให้คุณสามารถจัดเรียงผลลัพธ์การค้นหาในคุณสมบัตินั้นโดยใช้ ORDER BY

DocumentDB ช่วยให้คุณสามารถกำหนดทั้งแฮชและดัชนีช่วงในคุณสมบัติใด ๆ หรือทั้งหมดซึ่งช่วยให้มีความเท่าเทียมกันและการสืบค้นช่วงที่มีประสิทธิภาพรวมทั้ง ORDER BY

นโยบายการจัดทำดัชนี

ทุกคอลเลกชันมีนโยบายการจัดทำดัชนีที่กำหนดประเภทของดัชนีที่ใช้สำหรับตัวเลขและสตริงในทุกคุณสมบัติของทุกเอกสาร

  • คุณยังสามารถควบคุมได้ว่าจะจัดทำดัชนีเอกสารโดยอัตโนมัติหรือไม่เมื่อมีการเพิ่มลงในคอลเลกชัน

  • การจัดทำดัชนีอัตโนมัติจะเปิดใช้งานตามค่าเริ่มต้น แต่คุณสามารถแทนที่ลักษณะการทำงานนั้นได้เมื่อเพิ่มเอกสารโดยบอก DocumentDB ว่าอย่าทำดัชนีเอกสารนั้น

  • คุณสามารถปิดใช้งานการจัดทำดัชนีอัตโนมัติเพื่อให้โดยค่าเริ่มต้นเอกสารจะไม่ถูกจัดทำดัชนีเมื่อเพิ่มลงในคอลเล็กชัน ในทำนองเดียวกันคุณสามารถแทนที่สิ่งนี้ในระดับเอกสารและสั่งให้ DocumentDB ทำดัชนีเอกสารเฉพาะเมื่อเพิ่มลงในคอลเล็กชัน สิ่งนี้เรียกว่าการจัดทำดัชนีด้วยตนเอง

รวม / ไม่รวมการจัดทำดัชนี

นโยบายการจัดทำดัชนียังสามารถกำหนดเส้นทางหรือเส้นทางที่ควรรวมหรือแยกออกจากดัชนี สิ่งนี้มีประโยชน์หากคุณทราบว่ามีบางส่วนของเอกสารที่คุณไม่เคยสอบถามและบางส่วนที่คุณทำ

ในกรณีเหล่านี้คุณสามารถลดค่าใช้จ่ายในการจัดทำดัชนีได้โดยบอกให้ DocumentDB จัดทำดัชนีเฉพาะบางส่วนของเอกสารแต่ละฉบับที่เพิ่มลงในคอลเล็กชัน

การจัดทำดัชนีอัตโนมัติ

มาดูตัวอย่างง่ายๆของการจัดทำดัชนีอัตโนมัติ

Step 1 - ก่อนอื่นเราสร้างคอลเล็กชันที่เรียกว่าการทำดัชนีอัตโนมัติและไม่มีการระบุนโยบายอย่างชัดเจนคอลเล็กชันนี้จะใช้นโยบายการจัดทำดัชนีเริ่มต้นซึ่งหมายความว่าการจัดทำดัชนีอัตโนมัติถูกเปิดใช้งานในคอลเล็กชันนี้

ที่นี่เราใช้การกำหนดเส้นทางตาม ID สำหรับการเชื่อมโยงฐานข้อมูลด้วยตนเองดังนั้นเราจึงไม่จำเป็นต้องรู้ ID ทรัพยากรหรือแบบสอบถามก่อนสร้างคอลเล็กชัน เราสามารถใช้ ID ฐานข้อมูลซึ่งก็คือ mydb

Step 2 - ตอนนี้เรามาสร้างเอกสารสองชุดทั้งที่มีนามสกุลของ 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");
}

อันแรกนี้สำหรับ Mark Upston จะถูกเพิ่มลงในคอลเลกชันและจากนั้นจะถูกจัดทำดัชนีโดยอัตโนมัติตามนโยบายการจัดทำดัชนีเริ่มต้น

แต่เมื่อมีการเพิ่มเอกสารที่สองสำหรับ Mark Upston เราได้ส่งผ่านตัวเลือกการร้องขอด้วย IndexingDirective.Exclude ซึ่งสั่งให้ DocumentDB อย่างชัดเจนไม่ให้ทำดัชนีเอกสารนี้แม้ว่าจะมีนโยบายการจัดทำดัชนีของคอลเล็กชันก็ตาม

เรามีแบบสอบถามประเภทต่างๆสำหรับทั้งสองเอกสารในตอนท้าย

Step 3 - เรียกงาน AutomaticIndexing จาก 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); 
   } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Override Automatic Indexing **** 
Documents WHERE lastName = 'Upston': 1 
All documents: 2 
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oAOEkfQA=/docs/kV5oAOEkfQACA 
AAAAAAAAA==/

ดังที่คุณเห็นว่าเรามีเอกสารดังกล่าวสองฉบับ แต่แบบสอบถามจะส่งคืนเพียงเอกสารสำหรับ Mark เนื่องจากเอกสารสำหรับ Mark ไม่ได้รับการจัดทำดัชนี หากเราสอบถามอีกครั้งโดยไม่มีคำสั่ง WHERE เพื่อดึงเอกสารทั้งหมดในคอลเล็กชันเราจะได้รับชุดผลลัพธ์พร้อมเอกสารทั้งสองชุดและนี่เป็นเพราะเอกสารที่ไม่ได้จัดทำดัชนีจะถูกส่งกลับโดยการสืบค้นที่ไม่มี WHERE clause เสมอ

นอกจากนี้เรายังสามารถดึงเอกสารที่ไม่ได้จัดทำดัชนีด้วย ID หรือ self-link ดังนั้นเมื่อเราค้นหาเอกสารของ Mark โดยใช้ ID ของเขา MARK เราจะเห็นว่า DocumentDB ส่งคืนเอกสารแม้ว่าจะไม่ได้จัดทำดัชนีในคอลเล็กชันก็ตาม

การจัดทำดัชนีด้วยตนเอง

ลองดูตัวอย่างง่ายๆของการจัดทำดัชนีด้วยตนเองโดยการลบล้างการจัดทำดัชนีอัตโนมัติ

Step 1- ก่อนอื่นเราจะสร้างคอลเล็กชันที่เรียกว่าการจัดทำดัชนีด้วยตนเองและแทนที่นโยบายเริ่มต้นโดยการปิดใช้งานการจัดทำดัชนีอัตโนมัติอย่างชัดเจน ซึ่งหมายความว่าเว้นแต่เราจะร้องขอเป็นอย่างอื่นเอกสารใหม่ที่เพิ่มลงในคอลเล็กชันนี้จะไม่ถูกจัดทำดัชนี

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- ตอนนี้เราจะสร้างเอกสารสองชุดเหมือนเดิมอีกครั้ง เราจะไม่จัดหาตัวเลือกคำขอพิเศษสำหรับเอกสารของ Mark ในครั้งนี้เนื่องจากนโยบายการจัดทำดัชนีของคอลเลคชันเอกสารนี้จะไม่ได้รับการจัดทำดัชนี

Step 3 - ตอนนี้เมื่อเราเพิ่มเอกสารที่สองสำหรับ Mark เราใช้ RequestOptions กับ IndexingDirective รวมเพื่อบอก DocumentDB ว่าควรทำดัชนีเอกสารนี้ซึ่งจะแทนที่นโยบายการจัดทำดัชนีของคอลเล็กชันที่ระบุว่าไม่ควร

เรามีแบบสอบถามประเภทต่างๆสำหรับทั้งสองเอกสารในตอนท้าย

Step 4 - เรียกงาน ManualIndexing จาก 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); 
   } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Manual Indexing **** 
Documents WHERE lastName = 'Upston': 1 
All documents: 2 
Unindexed document self-link: dbs/kV5oAA==/colls/kV5oANHJPgE=/docs/kV5oANHJPgEBA 
AAAAAAAAA==/

อีกครั้งการสืบค้นส่งคืนเอกสารเพียงหนึ่งในสองเอกสาร แต่คราวนี้ส่งคืน Jane Doe ซึ่งเราขอให้จัดทำดัชนีอย่างชัดเจน แต่เหมือนเดิมการสืบค้นโดยไม่มีคำสั่ง WHERE จะดึงเอกสารทั้งหมดในคอลเล็กชันรวมถึงเอกสารที่ไม่ได้จัดทำดัชนีสำหรับ Mark นอกจากนี้เรายังสามารถค้นหาเอกสารที่ไม่ได้จัดทำดัชนีด้วย ID ซึ่ง DocumentDB จะส่งคืนแม้ว่าจะไม่ได้จัดทำดัชนีก็ตาม

Microsoft เพิ่ม geospatial supportซึ่งช่วยให้คุณจัดเก็บข้อมูลตำแหน่งในเอกสารของคุณและทำการคำนวณเชิงพื้นที่สำหรับระยะทางและจุดตัดระหว่างจุดและรูปหลายเหลี่ยม

  • ข้อมูลเชิงพื้นที่อธิบายตำแหน่งและรูปร่างของวัตถุในอวกาศ

  • โดยทั่วไปแล้วสามารถใช้เพื่อแสดงตำแหน่งของบุคคลสถานที่ที่น่าสนใจหรือขอบเขตของเมืองหรือทะเลสาบ

  • กรณีการใช้งานทั่วไปมักจะเกี่ยวข้องกับการสอบถาม เช่น "ค้นหามหาวิทยาลัยทั้งหมดที่อยู่ใกล้ตำแหน่งปัจจุบันของฉัน"

Pointหมายถึงตำแหน่งเดียวในอวกาศซึ่งแสดงถึงตำแหน่งที่แน่นอนเช่นที่อยู่ของมหาวิทยาลัยนั้น ๆ จุดถูกแสดงใน DocumentDB โดยใช้คู่พิกัด (ลองจิจูดและละติจูด) ต่อไปนี้เป็นตัวอย่างของจุด JSON

{ 
   "type":"Point", 
   "coordinates":[ 28.3, -10.7 ] 
}

ลองมาดูตัวอย่างง่ายๆที่มีที่ตั้งของมหาวิทยาลัย

{ 
   "id":"case-university", 
   "name":"CASE: Center For Advanced Studies In Engineering", 
   "city":"Islamabad", 
	
   "location": { 
      "type":"Point", 
      "coordinates":[ 33.7194136, -73.0964862 ] 
   } 
}

ในการเรียกชื่อมหาวิทยาลัยตามสถานที่ตั้งคุณสามารถใช้แบบสอบถามต่อไปนี้

SELECT c.name FROM c 

WHERE c.id = "case-university" AND ST_ISVALID({ 
      "type":"Point", 
      "coordinates":[ 33.7194136, -73.0964862 ]})

เมื่อดำเนินการค้นหาข้างต้นคุณจะได้รับผลลัพธ์ต่อไปนี้

[ 
   { 
      "name": "CASE: Center For Advanced Studies In Engineering" 
   } 
]

สร้างเอกสารด้วยข้อมูลภูมิสารสนเทศใน. NET

คุณสามารถสร้างเอกสารที่มีข้อมูลภูมิสารสนเทศได้มาดูตัวอย่างง่ายๆในการสร้างเอกสารของมหาวิทยาลัย

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(); 
}

ต่อไปนี้คือการนำไปใช้สำหรับคลาส 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; } 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Create Documents ****  
Created new document: nust 
{ 
   "id": "nust", 
   "name": "National University of Sciences and Technology", 
   "city": "Islamabad", 
   "location": { 
      "type": "Point", 
      "coordinates": [ 
         33.6455715, 
         72.9903447 
      ] 
   }, 
   "_rid": "Ic8LAMEUVgANAAAAAAAAAA==", 
   "_ts": 1450200910, 
   "_self": "dbs/Ic8LAA==/colls/Ic8LAMEUVgA=/docs/Ic8LAMEUVgANAAAAAAAAAA==/", 
   "_etag": "\"00004100-0000-0000-0000-56704f4e0000\"", 
   "_attachments": "attachments/" 
} 
Created document nust from typed object

เมื่อฐานข้อมูลของคุณเริ่มเติบโตเกิน 10GB คุณสามารถขยายขนาดได้ง่ายๆโดยการสร้างคอลเลกชันใหม่จากนั้นกระจายหรือแบ่งพาร์ติชันข้อมูลของคุณในคอลเลกชันที่มากขึ้น

ไม่ช้าก็เร็วคอลเลกชั่นเดียวซึ่งมีความจุ 10GB จะไม่เพียงพอที่จะบรรจุฐานข้อมูลของคุณ ตอนนี้ 10GB อาจฟังดูไม่เหมือนตัวเลขที่มากนัก แต่โปรดจำไว้ว่าเรากำลังจัดเก็บเอกสาร JSON ซึ่งเป็นเพียงข้อความธรรมดาและคุณสามารถใส่เอกสารข้อความธรรมดาจำนวนมากได้ใน 10GB แม้ว่าคุณจะพิจารณาค่าใช้จ่ายในการจัดเก็บข้อมูลสำหรับดัชนีก็ตาม

พื้นที่จัดเก็บไม่ใช่สิ่งเดียวที่ต้องกังวลในเรื่องความสามารถในการขยายขนาด ปริมาณงานสูงสุดที่มีอยู่ในคอลเลกชันคือสองและครึ่งพันหน่วยคำขอต่อวินาทีที่คุณได้รับจากคอลเล็กชัน S3 ดังนั้นหากคุณต้องการปริมาณงานที่สูงขึ้นคุณจะต้องขยายขนาดโดยแบ่งพาร์ติชันกับหลายคอลเลกชัน เรียกอีกอย่างว่าการแบ่งพาร์ติชันแบบปรับขนาดออกhorizontal partitioning.

มีหลายวิธีที่สามารถใช้สำหรับการแบ่งข้อมูลกับ Azure DocumentDB ต่อไปนี้เป็นกลยุทธ์ที่พบบ่อยที่สุด -

  • การแบ่งพาร์ติชัน Spillover
  • การแบ่งช่วง
  • ค้นหาการแบ่งพาร์ติชัน
  • การแบ่งพาร์ติชันแฮช

การแบ่งพาร์ติชัน Spillover

การแบ่งพาร์ติชัน Spillover เป็นกลยุทธ์ที่ง่ายที่สุดเนื่องจากไม่มีคีย์พาร์ติชัน มักจะเป็นทางเลือกที่ดีในการเริ่มต้นเมื่อคุณไม่แน่ใจเกี่ยวกับสิ่งต่างๆมากมาย คุณอาจไม่ทราบว่าคุณจะต้องปรับขนาดให้มากกว่าคอลเลกชั่นเดียวหรือไม่หรือต้องเพิ่มจำนวนคอลเลกชันหรือเร็วแค่ไหนในการเพิ่ม

  • การแบ่งพาร์ติชัน Spillover เริ่มต้นด้วยคอลเล็กชันเดียวและไม่มีคีย์พาร์ติชัน

  • คอลเลกชันเริ่มเติบโตและเพิ่มขึ้นเรื่อย ๆ และเพิ่มขึ้นเรื่อย ๆ จนกว่าคุณจะเริ่มเข้าใกล้ขีด จำกัด 10GB

  • เมื่อคุณมีความจุถึง 90 เปอร์เซ็นต์คุณจะล้นไปยังคอลเล็กชันใหม่และเริ่มใช้งานสำหรับเอกสารใหม่

  • เมื่อฐานข้อมูลของคุณขยายเป็นจำนวนคอลเลกชันที่มากขึ้นคุณอาจต้องการเปลี่ยนไปใช้กลยุทธ์ที่ใช้พาร์ติชันคีย์

  • เมื่อคุณทำเช่นนั้นคุณจะต้องปรับสมดุลข้อมูลของคุณใหม่โดยการย้ายเอกสารไปยังคอลเลคชันต่างๆตามกลยุทธ์ที่คุณจะย้ายไป

การแบ่งช่วง

หนึ่งในกลยุทธ์ที่พบบ่อยที่สุดคือการแบ่งช่วง ด้วยวิธีนี้คุณจะกำหนดช่วงของค่าที่คีย์พาร์ติชันของเอกสารอาจอยู่ในและกำหนดทิศทางเอกสารไปยังคอลเล็กชันที่ตรงกับช่วงนั้น

  • โดยทั่วไปแล้ววันที่จะใช้กับกลยุทธ์นี้ซึ่งคุณสร้างคอลเลกชันเพื่อเก็บเอกสารที่อยู่ในช่วงวันที่ที่กำหนด เมื่อคุณกำหนดช่วงที่มีขนาดเล็กพอคุณมั่นใจได้ว่าจะไม่มีคอลเลกชันใดเกินขีด จำกัด 10GB ตัวอย่างเช่นอาจมีสถานการณ์สมมติที่คอลเลกชันเดียวสามารถจัดการเอกสารได้อย่างสมเหตุสมผลตลอดทั้งเดือน

  • นอกจากนี้ยังอาจเป็นกรณีที่ผู้ใช้ส่วนใหญ่กำลังค้นหาข้อมูลปัจจุบันซึ่งอาจเป็นข้อมูลของเดือนนี้หรือเดือนที่แล้ว แต่ผู้ใช้มักไม่ค่อยค้นหาข้อมูลที่เก่ากว่ามากนัก ดังนั้นคุณจึงเริ่มต้นในเดือนมิถุนายนด้วยคอลเลกชัน S3 ซึ่งเป็นคอลเลกชั่นที่แพงที่สุดที่คุณสามารถซื้อและให้ปริมาณงานที่ดีที่สุดที่คุณจะได้รับ

  • ในเดือนกรกฎาคมคุณซื้อคอลเลกชัน S3 อีกชุดเพื่อจัดเก็บข้อมูลเดือนกรกฎาคมและคุณยังปรับขนาดข้อมูลเดือนมิถุนายนให้เป็นคอลเลคชัน S2 ที่ราคาไม่แพง จากนั้นในเดือนสิงหาคมคุณจะได้รับคอลเลกชั่น S3 อีกชุดและปรับขนาดกรกฎาคมลงเป็น S2 และมิถุนายนไปจนถึง S1 เป็นไปทุกเดือนโดยที่คุณจะเก็บรักษาข้อมูลปัจจุบันไว้เสมอสำหรับปริมาณงานที่สูงและข้อมูลเก่าจะยังคงมีอยู่ในปริมาณงานที่ต่ำลง

  • ตราบใดที่แบบสอบถามมีคีย์พาร์ติชันเฉพาะคอลเลกชันที่จำเป็นต้องสืบค้นเท่านั้นที่จะได้รับการสืบค้นและไม่ใช่คอลเลกชันทั้งหมดในฐานข้อมูลเช่นเดียวกับที่เกิดขึ้นกับการแบ่งพาร์ติชันที่รั่วไหล

ค้นหาการแบ่งพาร์ติชัน

ด้วยการแบ่งพาร์ติชันการค้นหาคุณสามารถกำหนดพาร์ติชันแม็พที่กำหนดเส้นทางเอกสารไปยังคอลเลกชันเฉพาะตามคีย์พาร์ติชัน ตัวอย่างเช่นคุณแบ่งพาร์ติชันตามภูมิภาคได้

  • จัดเก็บเอกสารของสหรัฐอเมริกาทั้งหมดในคอลเลกชั่นเดียวเอกสารยุโรปทั้งหมดในคอลเลกชันอื่นและเอกสารทั้งหมดจากภูมิภาคอื่น ๆ ในคอลเล็กชันที่สาม

  • ใช้การแม็พพาร์ติชันนี้และตัวแก้ไขพาร์ติชันการค้นหาสามารถระบุได้ว่าคอลเล็กชันใดที่จะสร้างเอกสารและคอลเล็กชันใดที่จะเคียวรีโดยยึดตามพาร์ติชันคีย์ซึ่งเป็นคุณสมบัติของพื้นที่ที่มีอยู่ในแต่ละเอกสาร

การแบ่งพาร์ติชันแฮช

ในการแบ่งแฮชพาร์ติชันจะถูกกำหนดตามค่าของฟังก์ชันแฮชซึ่งช่วยให้คุณสามารถแจกจ่ายคำขอและข้อมูลในพาร์ติชันต่างๆได้อย่างเท่าเทียมกัน

โดยทั่วไปจะใช้เพื่อแบ่งพาร์ติชันข้อมูลที่ผลิตหรือใช้จากไคลเอนต์ที่แตกต่างกันจำนวนมากและมีประโยชน์สำหรับการจัดเก็บโปรไฟล์ผู้ใช้รายการแค็ตตาล็อก ฯลฯ

มาดูตัวอย่างง่ายๆของการแบ่งช่วงโดยใช้ RangePartitionResolver ที่จัดทำโดย. NET SDK

Step 1- สร้าง DocumentClient ใหม่และเราจะสร้างสองคอลเลกชันในงาน CreateCollections เอกสารหนึ่งจะมีเอกสารสำหรับผู้ใช้ที่มี ID ผู้ใช้ที่ขึ้นต้นด้วย A ถึง M และอีกฉบับสำหรับ ID ผู้ใช้ N ถึง 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 - ลงทะเบียนตัวแก้ไขช่วงสำหรับฐานข้อมูล

Step 3- สร้าง RangePartitionResolver <string> ใหม่ซึ่งเป็นประเภทข้อมูลของคีย์พาร์ติชันของเรา ตัวสร้างใช้พารามิเตอร์สองตัวชื่อคุณสมบัติของพาร์ติชันคีย์และพจนานุกรมที่เป็นแผนที่ชาร์ดหรือแผนผังพาร์ติชันซึ่งเป็นเพียงรายการของช่วงและคอลเล็กชันที่เกี่ยวข้องซึ่งเรากำหนดไว้ล่วงหน้าสำหรับตัวแก้ไข

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;
 }

จำเป็นต้องเข้ารหัสค่า UTF-8 ที่ใหญ่ที่สุดที่เป็นไปได้ที่นี่ หรือมิฉะนั้นช่วงแรกจะไม่ตรงกับ Ms ใด ๆ ยกเว้น M ตัวเดียวและในทำนองเดียวกันสำหรับ Z ในช่วงที่สอง ดังนั้นคุณสามารถคิดว่าค่าที่เข้ารหัสที่นี่เป็นสัญลักษณ์แทนสำหรับการจับคู่คีย์พาร์ติชัน

Step 4- หลังจากสร้างตัวแก้ไขแล้วให้ลงทะเบียนสำหรับฐานข้อมูลด้วย DocumentClient ปัจจุบัน ในการทำเช่นนั้นให้กำหนดให้กับคุณสมบัติพจนานุกรมของ PartitionResolver

เราจะสร้างและสอบถามเอกสารกับฐานข้อมูลไม่ใช่คอลเลกชันอย่างที่คุณทำตามปกติตัวแก้ไขจะใช้แผนที่นี้เพื่อกำหนดเส้นทางคำขอไปยังคอลเล็กชันที่เหมาะสม

ตอนนี้มาสร้างเอกสารกัน ก่อนอื่นเราจะสร้างหนึ่งสำหรับ userId Kirk จากนั้นหนึ่งสำหรับ 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); 
}

พารามิเตอร์แรกในที่นี้คือลิงก์ไปยังฐานข้อมูลในตัวเองไม่ใช่คอลเล็กชันเฉพาะ สิ่งนี้เป็นไปไม่ได้หากไม่มีตัวแก้ไขพาร์ติชัน แต่ด้วยตัวนี้มันก็ทำงานได้อย่างราบรื่น

เอกสารทั้งสองถูกบันทึกลงในฐานข้อมูล myfirstdb แต่เรารู้ว่า Kirk ถูกเก็บไว้ในคอลเลกชันสำหรับ A ถึง M และ Spock จะถูกเก็บไว้ในคอลเลกชันสำหรับ N ถึง Z หาก RangePartitionResolver ของเราทำงานอย่างถูกต้อง

เรียกสิ่งเหล่านี้จากงาน CreateDocumentClient ดังแสดงในโค้ดต่อไปนี้

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); 
   } 
}

เมื่อดำเนินการโค้ดด้านบนคุณจะได้รับผลลัพธ์ต่อไปนี้

**** Create Documents Across Partitions **** 
Document 1: dbs/Ic8LAA==/colls/Ic8LAO2DxAA=/docs/Ic8LAO2DxAABAAAAAAAAAA==/ 
Document 2: dbs/Ic8LAA==/colls/Ic8LAP12QAE=/docs/Ic8LAP12QAEBAAAAAAAAAA==/

ดังที่เห็นการเชื่อมโยงด้วยตนเองของเอกสารทั้งสองมี ID ทรัพยากรที่แตกต่างกันเนื่องจากมีอยู่ในคอลเล็กชันสองชุดแยกกัน

ด้วยเครื่องมือ DocumentDB Data Migration คุณสามารถย้ายข้อมูลไปยัง DocumentDB ได้อย่างง่ายดาย DocumentDB Data Migration Tool เป็นยูทิลิตี้โอเพนซอร์สฟรีที่คุณสามารถดาวน์โหลดได้จาก Microsoft Download Centerhttps://www.microsoft.com/

เครื่องมือการย้ายข้อมูลรองรับแหล่งข้อมูลหลายแหล่งข้อมูลบางส่วนมีการระบุไว้ด้านล่าง -

  • เซิร์ฟเวอร์ SQL
  • ไฟล์ JSON
  • ไฟล์แบบแบนของค่าที่คั่นด้วยจุลภาค (CSV)
  • MongoDB
  • Azure Table Storage
  • Amazon DynamoDB
  • HBase และแม้แต่ฐานข้อมูล DocumentDB อื่น ๆ

หลังจากดาวน์โหลดเครื่องมือ DocumentDB Data Migration แล้วให้แตกไฟล์ zip

คุณสามารถเห็นไฟล์ปฏิบัติการสองไฟล์ในโฟลเดอร์นี้ดังที่แสดงในภาพหน้าจอต่อไปนี้

ประการแรกมี dt.exe ซึ่งเป็นเวอร์ชันคอนโซลที่มีอินเทอร์เฟซบรรทัดคำสั่งจากนั้นมี dtui.exe ซึ่งเป็นเวอร์ชันเดสก์ท็อปที่มีอินเทอร์เฟซผู้ใช้แบบกราฟิก

มาเปิดเวอร์ชัน GUI

คุณสามารถดูหน้ายินดีต้อนรับ คลิก 'ถัดไป' สำหรับหน้าข้อมูลแหล่งที่มา

ที่นี่คุณกำหนดค่าแหล่งข้อมูลของคุณและคุณสามารถดูตัวเลือกที่รองรับมากมายจากเมนูแบบเลื่อนลง

เมื่อคุณทำการเลือกส่วนที่เหลือของหน้าข้อมูลแหล่งที่มาจะเปลี่ยนไปตามนั้น

การนำเข้าข้อมูลไปยัง DocumentDB โดยใช้ DocumentDB Data Migration Tool นั้นง่ายมาก เราขอแนะนำให้คุณใช้ตัวอย่างข้างต้นและใช้ไฟล์ข้อมูลอื่นด้วย

DocumentDB ให้แนวคิดในการควบคุมการเข้าถึงทรัพยากร DocumentDB การเข้าถึงทรัพยากร DocumentDB ถูกควบคุมโดยโทเค็นคีย์หลักหรือโทเค็นทรัพยากร การเชื่อมต่อตามโทเค็นทรัพยากรสามารถเข้าถึงทรัพยากรที่ระบุโดยโทเค็นเท่านั้นและไม่มีทรัพยากรอื่น ๆ โทเค็นทรัพยากรขึ้นอยู่กับสิทธิ์ของผู้ใช้

  • ก่อนอื่นคุณต้องสร้างผู้ใช้ตั้งแต่หนึ่งรายขึ้นไปและกำหนดไว้ที่ระดับฐานข้อมูล

  • จากนั้นคุณจะสร้างการอนุญาตอย่างน้อยหนึ่งรายการสำหรับผู้ใช้แต่ละคนตามทรัพยากรที่คุณต้องการอนุญาตให้ผู้ใช้แต่ละรายเข้าถึง

  • สิทธิ์แต่ละรายการจะสร้างโทเค็นทรัพยากรที่อนุญาตให้เข้าถึงทรัพยากรที่กำหนดแบบอ่านอย่างเดียวหรือแบบเต็มและอาจเป็นทรัพยากรของผู้ใช้ใดก็ได้ภายในฐานข้อมูล

  • ผู้ใช้ถูกกำหนดที่ระดับฐานข้อมูลและมีการกำหนดสิทธิ์สำหรับผู้ใช้แต่ละคน

  • ผู้ใช้และสิทธิ์ใช้กับคอลเลกชันทั้งหมดในฐานข้อมูล

มาดูตัวอย่างง่ายๆที่เราจะเรียนรู้วิธีกำหนดผู้ใช้และสิทธิ์เพื่อให้ได้ความปลอดภัยอย่างละเอียดใน DocumentDB

เราจะเริ่มต้นด้วย DocumentClient ใหม่และค้นหาฐานข้อมูล 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");
   }
}

ต่อไปนี้คือการใช้งานสำหรับ 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- สร้างผู้ใช้สองคน Alice และ Tom เหมือนทรัพยากรใด ๆ ที่เราสร้างเราสร้างวัตถุนิยามด้วย Id ที่ต้องการและเรียกใช้วิธีการสร้างและในกรณีนี้เราจะเรียก CreateUserAsync ด้วย SelfLink ของฐานข้อมูลและ UserDefinition เราได้รับผลลัพธ์กลับมาจากทรัพยากรของทรัพยากรที่เราได้รับวัตถุผู้ใช้ที่สร้างขึ้นใหม่

ตอนนี้เพื่อดูผู้ใช้ใหม่สองคนนี้ในฐานข้อมูล

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- โทร CreateUserQuery กับ UsersLink ของฐานข้อมูลเพื่อดึงรายชื่อผู้ใช้ทั้งหมด จากนั้นวนซ้ำและดูคุณสมบัติของพวกเขา

ตอนนี้เราต้องสร้างพวกเขาก่อน สมมติว่าเราต้องการอนุญาตสิทธิ์ในการอ่าน / เขียนของ Alice ในคอลเล็กชัน MyCollection แต่ Tom สามารถอ่านเอกสารในคอลเล็กชันเท่านั้น

await CreatePermission(client, alice, "Alice Collection Access", PermissionMode.All,
   collection);
	
await CreatePermission(client, tom, "Tom Collection Access", PermissionMode.Read,
   collection);

Step 3- สร้างสิทธิ์ในทรัพยากรที่เป็นคอลเลกชัน MyCollection ดังนั้นเราจำเป็นต้องรับทรัพยากรนั้นเป็น SelfLink

Step 4 - จากนั้นสร้างการอนุญาตทั้งหมดในคอลเลกชันนี้สำหรับอลิซและการอนุญาตอ่านคอลเลกชันนี้สำหรับทอม

ต่อไปนี้คือการใช้งาน 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);
}

ตามที่คุณควรจะคาดหวังในตอนนี้เราทำได้โดยการสร้างออบเจ็กต์คำจำกัดความสำหรับการอนุญาตใหม่ซึ่งรวมถึง Id และ permissionMode ซึ่งก็คือ Permission All หรือ Permission Read และ SelfLink ของทรัพยากรที่ได้รับการรักษาความปลอดภัย โดยได้รับอนุญาต

Step 5 - เรียก CreatePermissionAsync และรับสิทธิ์ที่สร้างขึ้นจากคุณสมบัติทรัพยากรในผลลัพธ์

หากต้องการดูสิทธิ์ที่สร้างขึ้นต่อไปนี้คือการใช้งาน 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); 
}

คราวนี้เป็นการสอบถามสิทธิ์กับลิงก์สิทธิ์ของผู้ใช้และเราจะแสดงรายการสิทธิ์แต่ละรายการที่ส่งคืนสำหรับผู้ใช้

มาลบสิทธิ์ของ Alice และ Tom

await DeletePermission(client, alice, "Alice Collection Access"); 
await DeletePermission(client, tom, "Tom Collection Access");

ต่อไปนี้คือการนำไปใช้สำหรับ 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 - ในการลบสิทธิ์ให้ค้นหาโดย Id ที่ได้รับอนุญาตเพื่อรับ SelfLink จากนั้นใช้ SelfLink เพื่อลบสิทธิ์

ต่อไปให้ลบผู้ใช้เอง ลองลบทั้งผู้ใช้

await DeleteUser(client, "Alice"); 
await DeleteUser(client, "Tom");

ต่อไปนี้คือการใช้งาน 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 - แบบสอบถามแรกเพื่อรับ SelfLink ของเธอจากนั้นเรียก DeleteUserAsync เพื่อลบวัตถุผู้ใช้ของเธอ

ต่อไปนี้คือการใช้งาน 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();
			
      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");
   }
}

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการคุณจะได้รับผลลัพธ์ต่อไปนี้

**** View Users in myfirstdb **** 
 
Total users in database myfirstdb: 0 
 
**** Create User Alice in myfirstdb **** 
Created new user 
          User ID: Alice 
      Resource ID: kV5oAC56NwA= 
        Self Link: dbs/kV5oAA==/users/kV5oAC56NwA=/ 
 Permissions Link: dbs/kV5oAA==/users/kV5oAC56NwA=/permissions/ 
        Timestamp: 12/17/2015 5:44:19 PM
		  
**** Create User Tom in myfirstdb **** 
Created new user 
          User ID: Tom 
      Resource ID: kV5oAALxKgA= 
        Self Link: dbs/kV5oAA==/users/kV5oAALxKgA=/ 
 Permissions Link: dbs/kV5oAA==/users/kV5oAALxKgA=/permissions/ 
        Timestamp: 12/17/2015 5:44:21 PM
		  
**** View Users in myfirstdb ****
  
User #1 
          User ID: Tom 
      Resource ID: kV5oAALxKgA= 
        Self Link: dbs/kV5oAA==/users/kV5oAALxKgA=/ 
 Permissions Link: dbs/kV5oAA==/users/kV5oAALxKgA=/permissions/ 
        Timestamp: 12/17/2015 5:44:21 PM 
		  
User #2 
          User ID: Alice 
      Resource ID: kV5oAC56NwA= 
        Self Link: dbs/kV5oAA==/users/kV5oAC56NwA=/ 
 Permissions Link: dbs/kV5oAA==/users/kV5oAC56NwA=/permissions/ 
        Timestamp: 12/17/2015 5:44:19 PM
		  
Total users in database myfirstdb: 2
  
**** View Permissions for Alice **** 
 
Total permissions for Alice: 0  

**** View Permissions for Tom **** 
 
Total permissions for Tom: 0  

**** Create Permission Alice Collection Access for Alice **** 
Created new permission 
    Permission ID: Alice Collection Access 
      Resource ID: kV5oAC56NwDON1RduEoCAA== 
  Permission Mode: All
            Token: type=resource&ver=1&sig=zB6hfvvleC0oGGbq5cc67w==;Zt3Lx 
Ol14h8pd6/tyF1h62zbZKk9VwEIATIldw4ZyipQGW951kirueAKdeb3MxzQ7eCvDfvp7Y/ZxFpnip/D G 
JYcPyim5cf+dgLvos6fUuiKSFSul7uEKqp5JmJqUCyAvD7w+qt1Qr1PmrJDyAIgbZDBFWGe2VT9FaBH o 
PYwrLjRlnH0AxfbrR+T/UpWMSSHtLB8JvNFZNSH8hRjmQupuTSxCTYEC89bZ/pS6fNmNg8=; 
        Timestamp: 12/17/2015 5:44:28 PM
		  
**** Create Permission Tom Collection Access for Tom **** 
Created new permission 
    Permission ID: Tom Collection Access 
      Resource ID: kV5oAALxKgCMai3JKWdfAA== 
  Permission Mode: Read 
            Token: type=resource&ver=1&sig=ieBHKeyi6EY9ZOovDpe76w==;92gwq 
V4AxKaCJ2dLS02VnJiig/5AEbPcfo1xvOjR10uK3a3FUMFULgsaK8nzxdz6hLVCIKUj6hvMOTOSN8Lt 7 
i30mVqzpzCfe7JO3TYSJEI9D0/5HbMIEgaNJiCu0JPPwsjVecTytiLN56FHPguoQZ7WmUAhVTA0IMP6 p 
jQpLDgJ43ZaG4Zv3qWJiO689balD+egwiU2b7RICH4j6R66UVye+GPxq/gjzqbHwx79t54=; 
        Timestamp: 12/17/2015 5:44:30 PM
		  
**** View Permissions for Alice ****
  
Permission #1 
    Permission ID: Alice Collection Access 
      Resource ID: kV5oAC56NwDON1RduEoCAA== 
  Permission Mode: All 
            Token: type=resource&ver=1&sig=BSzz/VNe9j4IPJ9M31Mf4Q==;Tcq/B 
X50njB1vmANZ/4aHj/3xNkghaqh1OfV95JMi6j4v7fkU+gyWe3mJasO3MJcoop9ixmVnB+RKOhFaSxE l 
P37SaGuIIik7GAWS+dcEBWglMefc95L2YkeNuZsjmmW5b+a8ELCUg7N45MKbpzkp5BrmmGVJ7h4Z4pf D 
rdmehYLuxSPLkr9ndbOOrD8E3bux6TgXCsgYQscpIlJHSKCKHUHfXWBP2Y1LV2zpJmRjis=; 
        Timestamp: 12/17/2015 5:44:28 PM
		  
Total permissions for Alice: 1
  
**** View Permissions for Tom ****
Permission #1 
    Permission ID: Tom Collection Access 
      Resource ID: kV5oAALxKgCMai3JKWdfAA== 
  Permission Mode: Read 
            Token: type=resource&ver=1&sig=NPkWNJp1mAkCASE8KdR6PA==;ur/G2 
V+fDamBmzECux000VnF5i28f8WRbPwEPxD1DMpFPqYcu45wlDyzT5A5gBr3/R3qqYkEVn8bU+een6Gl j 
L6vXzIwsZfL12u/1hW4mJT2as2PWH3eadry6Q/zRXHAxV8m+YuxSzlZPjBFyJ4Oi30mrTXbBAEafZhA 5 
yvbHkpLmQkLCERy40FbIFOzG87ypljREpwWTKC/z8RSrsjITjAlfD/hVDoOyNJwX3HRaz4=; 
        Timestamp: 12/17/2015 5:44:30 PM
		  
Total permissions for Tom: 1
  
**** Delete Permission Alice Collection Access from Alice **** 
Deleted permission Alice Collection Access from user Alice
  
**** Delete Permission Tom Collection Access from Tom **** 
Deleted permission Tom Collection Access from user Tom
  
**** Delete User Alice in myfirstdb **** 
Deleted user Alice from database myfirstdb
  
**** Delete User Tom in myfirstdb **** 
Deleted user Tom from database myfirstdb

ในบทนี้เราจะเรียนรู้วิธีการแสดงภาพข้อมูลที่เก็บไว้ใน DocumentDB Microsoft จัดเตรียมเครื่องมือ Power BI Desktop ซึ่งจะแปลงข้อมูลของคุณให้เป็นภาพที่สมบูรณ์ นอกจากนี้ยังช่วยให้คุณสามารถดึงข้อมูลจากแหล่งข้อมูลต่างๆผสานและแปลงข้อมูลสร้างรายงานและการแสดงภาพที่มีประสิทธิภาพและเผยแพร่รายงานไปยัง Power BI

ใน Power BI Desktop เวอร์ชันล่าสุด Microsoft ได้เพิ่มการสนับสนุน DocumentDB ด้วยซึ่งตอนนี้คุณสามารถเชื่อมต่อกับบัญชี DocumentDB ของคุณได้แล้ว คุณสามารถดาวน์โหลดเครื่องมือนี้ได้จากลิงค์https://powerbi.microsoft.com

มาดูตัวอย่างที่เราจะแสดงภาพข้อมูลแผ่นดินไหวที่นำเข้าในบทสุดท้าย

Step 1 - เมื่อดาวน์โหลดเครื่องมือแล้วให้เปิด Power BI desktop

Step 2 - คลิกตัวเลือก 'รับข้อมูล' ซึ่งอยู่ในแท็บหน้าแรกภายใต้กลุ่มข้อมูลภายนอกและจะแสดงหน้ารับข้อมูล

Step 3 - เลือกตัวเลือก Microsoft Azure DocumentDB (Beta) แล้วคลิกปุ่ม 'Connect'

Step 4 - ป้อน URL ของบัญชี Azure DocumentDB ฐานข้อมูลและคอลเล็กชันที่คุณต้องการแสดงภาพข้อมูลแล้วกดตกลง

หากคุณกำลังเชื่อมต่อกับปลายทางนี้เป็นครั้งแรกคุณจะได้รับแจ้งให้ป้อนรหัสบัญชี

Step 5 - ป้อนรหัสบัญชี (คีย์หลัก) ซึ่งไม่ซ้ำกันสำหรับแต่ละบัญชี DocumentDB ที่มีอยู่บนพอร์ทัล Azure จากนั้นคลิกเชื่อมต่อ

เมื่อเชื่อมต่อบัญชีสำเร็จจะดึงข้อมูลจากฐานข้อมูลที่ระบุ บานหน้าต่างแสดงตัวอย่างจะแสดงรายการของเรกคอร์ดเอกสารจะแสดงเป็นชนิดเรกคอร์ดใน Power BI

Step 6 - คลิกปุ่ม 'แก้ไข' ซึ่งจะเปิดตัวแก้ไขแบบสอบถาม

Step 7 - ใน Power BI Query Editor คุณควรเห็นคอลัมน์เอกสารในบานหน้าต่างตรงกลางคลิกที่ตัวขยายที่ด้านขวาของส่วนหัวคอลัมน์เอกสารแล้วเลือกคอลัมน์ที่คุณต้องการให้แสดง

ดังที่คุณเห็นว่าเรามีละติจูดและลองจิจูดเป็นคอลัมน์แยกกัน แต่เราแสดงภาพข้อมูลในรูปแบบพิกัดละติจูดลองจิจูด

Step 8 - ในการดำเนินการดังกล่าวให้คลิกแท็บ "เพิ่มคอลัมน์"

Step 9 - เลือกเพิ่มคอลัมน์แบบกำหนดเองซึ่งจะแสดงหน้าต่อไปนี้

Step 10- ระบุชื่อคอลัมน์ใหม่สมมติว่า LatLong และสูตรที่จะรวมละติจูดและลองจิจูดในคอลัมน์เดียวโดยคั่นด้วยลูกน้ำ ต่อไปนี้เป็นสูตร

Text.From([latitude])&", "&Text.From([longitude])

Step 11 - คลิกตกลงเพื่อดำเนินการต่อและคุณจะเห็นว่ามีการเพิ่มคอลัมน์ใหม่

Step 12 - ไปที่แท็บหน้าแรกแล้วคลิกตัวเลือก "ปิดและใช้"

Step 13- คุณสามารถสร้างรายงานได้โดยการลากและวางฟิลด์ลงในพื้นที่รายงาน คุณจะเห็นทางด้านขวามีสองบาน - บานหน้าต่างการแสดงภาพหนึ่งบานและอีกบานคือบานหน้าต่างเขตข้อมูล

มาสร้างมุมมองแผนที่เพื่อแสดงตำแหน่งของแผ่นดินไหวแต่ละครั้ง

Step 14 - ลากประเภทภาพแผนที่จากบานหน้าต่างการแสดงภาพ

Step 15- ตอนนี้ลากและวางเขตข้อมูล LatLong จากบานหน้าต่างเขตข้อมูลไปยังคุณสมบัติตำแหน่งในบานหน้าต่างการแสดงภาพ จากนั้นลากและวางฟิลด์ขนาดไปที่คุณสมบัติค่า

Step 16 - ลากและวางฟิลด์ความลึกไปที่คุณสมบัติความอิ่มตัวของสี

ตอนนี้คุณจะเห็นภาพแผนที่แสดงชุดฟองอากาศที่ระบุตำแหน่งของแผ่นดินไหวแต่ละครั้ง