DocumentDB-はじめに

この章では、NoSQLおよびドキュメントデータベースに関する主要な概念について簡単に説明します。 DocumentDBの概要も簡単に説明します。

NoSQLドキュメントデータベース

DocumentDBはMicrosoftの最新のNoSQLドキュメントデータベースです。したがって、NoSQLドキュメントデータベースと言うと、NoSQLとドキュメントデータベースとは正確に何を意味するのでしょうか。

SQLは、リレーショナルデータベースの従来のクエリ言語である構造化クエリ言語を意味します。 SQLは、多くの場合、リレーショナルデータベースと同一視されます。
NoSQLデータベースを非リレーショナルデータベースと考えると、非常に便利です。したがって、NoSQLは本当に非リレーショナルを意味します。

次のようなキー値ストアを含むさまざまな種類のNoSQLデータベースがあります-

Azureテーブルストレージ。
Cassandraのような列ベースのストア。
NEO4のようなグラフデータベース。
MongoDBやAzure DocumentDBなどのドキュメントデータベース。

Azure DocumentDB

Microsoftは2015年4月8日に正式にAzure DocumentDBを開始しました。これは確かに典型的なNoSQLドキュメントデータベースとして特徴付けられます。非常にスケーラブルであり、スキーマフリーのJSONドキュメントで動作します。

DocumentDBは、現代のモバイルおよびWebアプリケーション向けに設計された真のスキーマフリーのNoSQLドキュメントデータベースサービスです。
また、一貫して高速な読み取りと書き込み、スキーマの柔軟性、およびデータベースを必要に応じて簡単にスケールアップおよびスケールダウンする機能も提供します。
インデックスを作成するJSONドキュメントのスキーマを想定または要求しません。
DocumentDBは、ドキュメントがデータベースに追加されるとすぐに、ドキュメント内のすべてのプロパティに自動的にインデックスを付けます。
DocumentDBは、SQL言語を使用した複雑なアドホッククエリを可能にし、すべてのドキュメントは作成された瞬間にすぐにクエリ可能であり、ドキュメント階層内の任意のプロパティを検索できます。

DocumentDB –価格

DocumentDBは、データベースアカウントに含まれるコレクションの数に基づいて請求されます。各アカウントは1つ以上のデータベースを持つことができ、各データベースはコレクションの仮想的に無制限の数を持つことができますが、100の初期デフォルトクォータがあります。このクォータは、Azureサポートに連絡することで解除できます。

コレクションはスケールの単位であるだけでなく、コストの単位でもあるため、DocumentDBではコレクションごとに支払います。これには最大10 GBのストレージ容量があります。
月に約25ドルかかるデータベースにドキュメントを保存するには、少なくとも1つのS1コレクションが必要です。これは、Azureサブスクリプションに対して請求されます。
データベースのサイズが大きくなり、10 GBを超えると、追加のデータを含めるために別のコレクションを購入する必要があります。
各S1コレクションは1秒あたり250リクエストユニットを提供しますが、それで十分でない場合は、コレクションをS2に拡大し、1か月あたり約50ドルで1000リクエストユニットを取得できます。
また、S3まですべての方法で有効にして、月額約100ドルを支払うこともできます。

DocumentDB-利点

DocumentDBは、非常にユニークな機能を備えています。 Azure DocumentDBは、次の主要な機能と利点を提供します。

スキーマフリー

リレーショナルデータベースでは、すべてのテーブルに、テーブル内の各行が準拠する必要がある列とデータ型を定義するスキーマがあります。

対照的に、ドキュメントデータベースにはスキーマが定義されておらず、すべてのドキュメントを異なる構造にすることができます。

SQL構文

DocumentDBは、SQL言語を使用した複雑なアドホッククエリを可能にし、すべてのドキュメントは作成された瞬間に即座にクエリ可能です。ドキュメント階層内の任意の場所で任意のプロパティを検索できます。

調整可能な一貫性

細かく、明確に定義された一貫性レベルを提供します。これにより、一貫性、可用性、待機時間の間で適切なトレードオフを行うことができます。

4つの明確に定義された一貫性レベルから選択して、一貫性とパフォーマンスの最適なトレードオフを実現できます。クエリと読み取り操作について、DocumentDBは4つの異なる一貫性レベルを提供します-

強い
限定された陳腐化
セッション
最終的に

弾性スケール

スケーラビリティはNoSQLを使用したゲームの名前であり、DocumentDBが提供します。 DocumentDBはすでにその規模が証明されています。

Office OneNoteやXboxなどの主要なサービスは、数十テラバイトのJSONドキュメント、100万人を超えるアクティブユーザーを含み、99.95％の可用性で一貫して動作するデータベースを備えたDocumentDBによって既にサポートされています。
アプリケーションの成長に応じてより多くのユニットを作成することにより、予測可能なパフォーマンスでDocumentDBを柔軟に拡張できます。

完全管理

DocumentDBは、Azure上で実行されるサービスとして、完全に管理されたクラウドベースのプラットフォームとして利用できます。

インストールまたは管理するものは何もありません。
サーバー、ケーブル、オペレーティングシステムまたは更新プログラム、セットアップするレプリカはありません。
マイクロソフトはすべての作業を行い、サービスを実行し続けます。
文字通り数分以内に、ブラウザーとAzureサブスクリプションだけを使用してDocumentDBの使用を開始できます。

DocumentDB-環境設定

Microsoftは、SQL Serverを含むVisual Studioの無料バージョンを提供しており、https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx [[[1]] .visualstudio.com]

インストール

ステップ1 *-ダウンロードが完了したら、インストーラーを実行します。次のダイアログが表示されます。

インストーラー

ステップ2 *-[インストール]ボタンをクリックすると、インストールプロセスが開始されます。

インストールプロセス

ステップ3 *-インストールプロセスが正常に完了すると、次のダイアログが表示されます。

今すぐ再起動

ステップ4 *-このダイアログを閉じて、必要に応じてコンピューターを再起動します。

ステップ5 *-次のダイアログを開く[スタート]メニューからVisual Studioを開きます。準備のためだけに初めて時間がかかります。

open visual studio

すべてが完了すると、Visual Studioのメインウィンドウが表示されます。

メインウィンドウ

ステップ6 *-ファイル→新規→プロジェクトから新しいプロジェクトを作成しましょう。

新規プロジェクトの作成

ステップ7 *-コンソールアプリケーションを選択し、[名前]フィールドにDocumentDBDemoと入力して[OK]ボタンをクリックします。

ステップ8 *-ソリューションエクスプローラーで、プロジェクトを右クリックします。

プロジェクトを右クリック

ステップ9 *-[NuGetパッケージの管理]を選択すると、Visual Studioで次のウィンドウが開き、[オンライン検索]入力ボックスでDocumentDB Client Libraryが検索されます。

NuGetパッケージの管理

ステップ10 *-インストールボタンをクリックして最新バージョンをインストールします。

ライセンス受理

ステップ11 *-[同意する]をクリックします。インストールが完了すると、出力ウィンドウにメッセージが表示されます。

アプリケーションの開始

これで、アプリケーションを開始する準備ができました。

DocumentDB-アカウントの作成

Microsoft Azure DocumentDBを使用するには、DocumentDBアカウントを作成する必要があります。この章では、Azureポータルを使用してDocumentDBアカウントを作成します。

ステップ1 *-Azureサブスクリプションを既にお持ちの場合は、オンラインhttps://portal.azure.comにログインします。それ以外の場合は、最初にサインインする必要があります。

メインのダッシュボードが表示されます。完全にカスタマイズできるので、これらのタイルを好きなように配置したり、サイズを変更したり、頻繁に使用する、または使用しなくなったタイルを追加および削除したりできます。

ダッシュボード

ステップ2 *-ページの左上にある[新規]オプションを選択します。

新しいオプションを選択

ステップ3 *-データ＆plus;を選択します。 [ストレージ]> [Azure DocumentDB]オプションを選択すると、次の[新しいDocumentDBアカウント]セクションが表示されます。

Azure DocumentDB

グローバルに一意の名前（ID）を作成する必要があります。これは.documents.azure.comと組み合わせて、DocumentDBアカウントへのパブリックにアドレス可能なエンドポイントです。このアカウントの下に作成するすべてのデータベースには、このエンドポイントを使用してインターネット経由でアクセスできます。

ステップ4 *-azuredocdbdemoという名前を付けて、[リソースグループ]→[new_resource]をクリックします。

リソースグループ

ステップ5 *-場所、つまり、このアカウントをホストするMicrosoftデータセンターを選択します。場所を選択し、地域を選択します。

場所の選択

ステップ6 *-[ダッシュボードに固定]チェックボックスをオンにし、[作成]ボタンをクリックします。

ボタンの作成

タイルが既にダッシュボードに追加されており、アカウントが作成されていることがわかります。 DocumentDBがエンドポイントを割り当て、レプリカをプロビジョニングし、バックグラウンドで他の作業を実行している間、実際には新しいアカウントの設定に数分かかる場合があります。

完了すると、ダッシュボードが表示されます。

アカウントダッシュボード

ステップ7 *-作成されたDocumentDBアカウントをクリックすると、次の画像のような詳細画面が表示されます。

作成されたDocumentdb

DocumentDB-アカウントの接続

DocumentDBに対するプログラミングを開始するとき、最初のステップは接続です。したがって、DocumentDBアカウントに接続するには、2つのことが必要です。

終点
認証キー

終点

エンドポイントはDocumentDBアカウントのURLであり、DocumentDBアカウント名と.documents.azure.comを組み合わせて作成されます。ダッシュボードに行きましょう。

エンドポイント

次に、作成したDocumentDBアカウントをクリックします。次の図に示すように、詳細が表示されます。

作成されたDocumentDBをクリック

[キー]オプションを選択すると、次の画像に示すように追加情報が表示されます。また、エンドポイントとして使用できるDocumentDBアカウントのURLも表示されます。

キーオプションを選択

認証キー

認証キーには資格情報が含まれ、2種類のキーがあります。マスターキーはアカウント内のすべてのリソースへのフルアクセスを許可し、リソーストークンは特定のリソースへの制限付きアクセスを許可します。

マスターキー

マスターキーでできないことは何もありません。マスターキーを使用して、必要に応じてデータベース全体を削除できます。
このため、マスターキーを共有したり、クライアント環境に配布したりすることは絶対に望まないでしょう。追加のセキュリティ対策として、頻繁に変更することをお勧めします。
上記のスクリーンショットで強調表示されているように、実際には各データベースアカウントにプライマリキーとセカンダリキーの2つのマスターキーがあります。

リソーストークン

マスターキーの代わりにリソーストークンを使用することもできます。
リソーストークンに基づく接続は、トークンで指定されたリソースにのみアクセスでき、他のリソースにはアクセスできません。
リソーストークンはユーザー権限に基づいているため、最初に1人以上のユーザーを作成します。これらのユーザーはデータベースレベルで定義されます。
各ユーザーにアクセスを許可するリソースに基づいて、各ユーザーに1つ以上のアクセス許可を作成します。
各アクセス許可は、特定のリソースへの読み取り専用アクセスまたはフルアクセスのいずれかを許可し、データベース内の任意のユーザーリソースにできるリソーストークンを生成します。

第3章で作成したコンソールアプリケーションに行きましょう。

ステップ1 *-Program.csファイルに次の参照を追加します。

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

ステップ2 *-エンドポイントURLと認証キーを追加します。この例では、主キーを認証キーとして使用します。

あなたの場合、エンドポイントURLと認証キーの両方が異なる必要があることに注意してください。

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

ステップ3 *-CreateDocumentClientと呼ばれる非同期タスクでDocumentClientの新しいインスタンスを作成し、新しいDocumentClientをインスタンス化します。

ステップ4 *-Mainメソッドから非同期タスクを呼び出します。

以下は、これまでの完全な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クラスのインスタンスを作成する方法を学びました。

DocumentDB-データベースの作成

この章では、データベースの作成方法を学びます。 Microsoft Azure DocumentDBを使用するには、DocumentDBアカウント、データベース、コレクション、およびドキュメントが必要です。私たちはすでにDocumentDBアカウントを持っています、今データベースを作成するために2つのオプションがあります-

Microsoft Azure Portalまたは
.Net SDK

Microsoft Azureポータルを使用してDocumentDBのデータベースを作成する

ポータルを使用してデータベースを作成するには、次の手順に従います。

ステップ1 *-Azureポータルにログインすると、ダッシュボードが表示されます。

ポータルにログイン

ステップ2 *-作成されたDocumentDBアカウントをクリックすると、次のスクリーンショットに示すように詳細が表示されます。

作成されたDocumentDBをクリック

ステップ3 *-[データベースの追加]オプションを選択し、データベースのIDを指定します。

データベースの追加を選択

ステップ4 *-[OK]をクリックします。

データベースが追加されました

データベースが追加されていることがわかります。現時点ではコレクションはありませんが、後でJSONドキュメントを格納するコンテナであるコレクションを追加できます。 IDとリソースIDの両方があることに注意してください。

.Net SDKを使用してDocumentDB用のデータベースを作成する

Net SDKを使用してデータベースを作成するには、次の手順に従います。.

ステップ1 *-前の章のVisual Studioでコンソールアプリケーションを開きます。

ステップ2 *-新しいデータベースオブジェクトを作成して、新しいデータベースを作成します。新しいデータベースを作成するには、CreateDatabaseタスクで「mynewdb」に設定しているIdプロパティを割り当てるだけです。

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

ステップ3 *-このdatabaseDefinitionをCreateDatabaseAsyncに渡し、Resourceプロパティで結果を取得します。すべてのオブジェクト作成メソッドは、作成されたアイテム（この場合はデータベース）を説明するResourceプロパティを返します。

Resourceプロパティから新しいデータベースオブジェクトを取得し、DocumentDBが割り当てたリソースIDとともにコンソールに表示されます。

ステップ4 *-DocumentClientがインスタンス化された後、CreateDocumentClientタスクからCreateDatabaseタスクを呼び出します。

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-データベースのリスト

これまで、DocumentDBアカウントに2つのデータベースを作成しました。1つ目はAzureポータルを使用して作成され、2つ目は.Net SDKを使用して作成されます。これらのデータベースを表示するには、Azureポータルを使用できます。

AzureポータルでDocumentDBアカウントに移動すると、2つのデータベースが表示されます。

2つのデータベース

Net SDKを使用して、コードからデータベースを表示またはリストすることもできます。以下は関連する手順です。.

ステップ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（）の呼び出しです。

ステップ2 *-DocumentClientがインスタンス化された後、CreateDocumentClientタスクからGetDatabasesメソッドを呼び出します。

ステップ3 *-CreateDatabaseタスクにコメントするか、データベースIDを変更する必要もあります。そうしないと、データベースが存在するというエラーメッセージが表示されます。

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とリソースIDを含む次の出力が表示されます。最後に、データベースの合計数も表示されます。

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

DocumentDB-データベースの削除

Net SDKを使用して、ポータルおよびコードからデータベースを削除できます。ここでは、DocumentDBにデータベースをドロップする方法を段階的に説明します。.

ステップ1 *-AzureポータルでDocumentDBアカウントに移動します。デモの目的で、次のスクリーンショットに示すように、さらに2つのデータベースを追加しました。

ドロップデータベース

ステップ2 *-データベースを削除するには、そのデータベースをクリックする必要があります。 tempdbを選択して、次のページが表示されたら、[データベースの削除]オプションを選択します。

データベースの削除

ステップ3 *-確認メッセージが表示されたら、[はい]ボタンをクリックします。

確認メッセージ

tempdbがダッシュボードで使用できなくなっていることがわかります。

TempDBが削除されました

Net SDKを使用して、コードからデータベースを削除することもできます。以下が手順です。.

ステップ1 *-削除するデータベースのIDを指定してデータベースを削除しますが、SelfLinkが必要です。

ステップ2 *-以前と同様にCreateDatabaseQueryを呼び出していますが、今回はID tempdb1を持つ1つのデータベースのみを返すクエリを実際に提供しています。

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

ステップ3 *-今回は、実際にはリストオブジェクトが必要ないため、ToList（）の代わりにAsEnumerableを呼び出すことができます。結果のみを期待し、AsEnumerableを呼び出すだけで、First（）を使用してクエリによって返される最初のデータベースオブジェクトを取得できます。これはtempdb1のデータベースオブジェクトであり、データベースを削除するDeleteDatabaseAsyncを呼び出すために使用できるSelfLinkがあります。

ステップ4 *-DocumentClientがインスタンス化された後、CreateDocumentClientタスクからDeleteDatabaseタスクを呼び出す必要もあります。

ステップ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);
      }

   }
}

上記のコードがコンパイルおよび実行されると、3つのデータベースのデータベースIDとリソースID、およびデータベースの総数を含む次の出力を受け取ります。

******* *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アカウントに2つのデータベースのみが残っていることもわかります。

DocumentDB-コレクションの作成

この章では、コレクションを作成する方法を学びます。データベースの作成に似ています。 .Net SDKを使用して、ポータルまたはコードからコレクションを作成できます。

ステップ1 *-Azureポータルのメインダッシュボードに移動します。

コレクションの作成

ステップ2 *-データベースリストからmyfirstdbを選択します。

myfirstdb

ステップ3 *-[コレクションの追加]オプションをクリックして、コレクションのIDを指定します。別のオプションの価格帯を選択します。

コレクションの追加

ステップ4 *-S1 Standardを選択して、選択→OKボタンをクリックします。

S1標準を選択

ご覧のとおり、MyCollectionがmyfirstdbに追加されています。

Net SDKを使用して、コードからコレクションを作成することもできます。コードからコレクションを追加する次の手順を見てみましょう。.

ステップ1 *-Visual Studioでコンソールアプリケーションを開きます。

ステップ2 *-コレクションを作成するには、まずCreateDocumentClientタスクでそのIDによって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();

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

CreateDocumentCollectionAsyncメソッドの目的のIDを使用して新しいコレクションを定義する新しいDocumentCollectionオブジェクトを作成します。このメソッドは、ここで使用するoptionsパラメーターも受け入れ、offerTypeを呼び出す新しいコレクションのパフォーマンス層を設定します。

これはデフォルトでS1になり、MyCollection1に対してofferTypeを渡さなかったため、これは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

DocumentDB-コレクションの削除

1つまたは複数のコレクションをドロップするには、.Net SDKを使用して、ポータルおよびコードから同じことを実行できます。

ステップ1 *-AzureポータルでDocumentDBアカウントに移動します。デモの目的で、次のスクリーンショットに示すように、さらに2つのコレクションを追加しました。

コレクションの削除

ステップ2 *-コレクションを削除するには、そのコレクションをクリックする必要があります。 TempCollection1を選択しましょう。次のページが表示されます。[コレクションを削除]オプションを選択します。

コレクションの選択

ステップ3 *-確認メッセージが表示されます。 [はい]ボタンをクリックします。

コレクションメッセージの削除

TempCollection1がダッシュボードで使用できなくなっていることがわかります。

コレクションが削除されました

Net SDKを使用して、コードからコレクションを削除することもできます。それを行うには、次の手順に従います。.

ステップ1 *-削除するコレクションのIDを指定して、コレクションを削除しましょう。

リソースを削除するために必要なselfLinksを取得するための、Idによるクエリの通常のパターンです。

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をハードコーディングしていないため、このメソッドを使用してコレクションを削除できます。このSqlQuerySpecのパラメーターのプロパティに割り当てられたこのSqlParameterCollectionでIdパラメーターが定義されている場合、Idによって特定のコレクションを照会しています。

次に、SDKは、その内部にcollectionIdが埋め込まれたDocumentDBの最終クエリ文字列を構築する作業を行います。

ステップ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

DocumentDB-文書の挿入

この章では、コレクション内の実際のドキュメントを操作します。 Azureポータルまたは.Net SDKを使用してドキュメントを作成できます。

Azure Portalでドキュメントを作成する

コレクションにドキュメントを追加するには、次の手順を見てみましょう。

ステップ1 *-myfirstdbに新しいコレクションファミリーのS1価格設定層を追加します。

ドキュメントの挿入

ステップ2 *-ファミリコレクションを選択し、[ドキュメントの作成]オプションをクリックして、[新しいドキュメント]ブレードを開きます。

家族コレクション

これは、新しいドキュメントのJSONを入力できるシンプルなテキストエディターです。

シンプルなテキストエディター

ステップ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を指定したことに注意してください。 id値は常に必須であり、同じコレクション内の他のすべてのドキュメントで一意である必要があります。省略すると、GUIDまたはグローバル一意識別子を使用してDocumentDBが自動的に生成します。

idは常に文字列であり、数値、日付、ブール値、または別のオブジェクトにすることはできません。また、255文字を超えることはできません。

また、必要なidのようないくつかのトップレベルプロパティ、lastName、isRegisteredがありますが、ネストされたプロパティもあるドキュメントの階層構造に注目してください。

たとえば、parentsプロパティは、角括弧で示されるJSON配列として提供されます。この例では、配列に子が1つしかない場合でも、子用の別の配列もあります。

ステップ4 *-[保存]ボタンをクリックしてドキュメントを保存すると、最初のドキュメントが作成されました。

かなりの書式設定がJSONに適用されていることがわかります。これにより、各プロパティのネストレベルを伝えるために空白でインデントされた独自の行のすべてのプロパティが分割されます。

ドキュメントの保存

ポータルにはドキュメントエクスプローラーが含まれているため、ここで作成したドキュメントを取得するために使用します。

ドキュメントの取得

ステップ5 *-データベースとデータベース内のコレクションを選択して、そのコレクション内のドキュメントを表示します。現在、Familysという1つのコレクションを持つmyfirstdbという名前のデータベースが1つだけあり、両方のドロップダウンリストで事前に選択されています。

データベースを選択

デフォルトでは、ドキュメントエクスプローラにはコレクション内のドキュメントのフィルタリングされていないリストが表示されますが、特定のドキュメントをIDで検索したり、部分的なIDのワイルドカード検索に基づいて複数のドキュメントを検索したりすることもできます。

これまでのコレクションにはドキュメントが1つしかなく、そのIDは次の画面AndersonFamilyに表示されます。

ステップ6 *-IDをクリックしてドキュメントを表示します。

IDをクリック

.NET SDKを使用したドキュメントの作成

ドキュメントは別の種類のリソースであり、SDKを使用してリソースを処理する方法に既に慣れていることはご存じでしょう。

ドキュメントと他のリソースの大きな違いの1つは、もちろん、スキーマが無料であることです。
したがって、多くのオプションがあります。当然、JSONオブジェクトグラフまたはJSONテキストの生の文字列だけで作業できますが、コンパイル時にクラスを定義せずに実行時にプロパティにバインドできる動的オブジェクトを使用することもできます。
また、実際のC＃オブジェクト、またはそれらが呼び出されたエンティティ（ビジネスドメインクラス）を操作することもできます。

Net SDKを使用してドキュメントの作成を始めましょう。手順は次のとおりです。.

ステップ1 *-DocumentClientをインスタンス化し、myfirstdbデータベースを照会してから、MyCollectionコレクションを照会します。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);
   }
}

ステップ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;
}

ステップ3 *-今回は、ドキュメントを追加するコレクションのSelfLinkを指定してCreateDocumentAsyncを呼び出します。この場合、システムによって生成されたプロパティを持つ新しいドキュメントを表すリソースプロパティを持つ応答が返されます。

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が新しいドキュメント用にこのIDを生成しました。

DocumentDB-クエリドキュメント

DocumentDBでは、実際にSQLを使用してドキュメントを照会するため、この章では、DocumentDBの特別なSQL構文を使用した照会について説明します。 .NET開発を行っている場合は、使用でき、LINQクエリから適切なSQLを生成できるLINQプロバイダーもあります。

ポータルを使用したドキュメントのクエリ

Azureポータルには、DocumentDBデータベースに対してSQLクエリを実行できるクエリエクスプローラーがあります。

クエリエクスプローラーを使用して、可能な限り単純なクエリから始めて、クエリ言語のさまざまな機能を紹介します。

ステップ1 *-データベースブレードで、クリックしてQuery Explorerブレードを開きます。

クエリエクスプローラーブレード

クエリはコレクションのスコープ内で実行されるため、クエリエクスプローラーでは、このドロップダウンでコレクションを選択できます。

クエリの実行

ステップ2 *-ポータルを使用して以前に作成されたファミリコレクションを選択します。

クエリエクスプローラーは、コレクションからすべてのドキュメントを取得するだけの簡単なクエリSELECT * FROM cで開きます。

ステップ3 *-[クエリの実行]ボタンをクリックして、このクエリを実行します。次に、[結果]ブレードで完全なドキュメントが取得されることがわかります。

結果ブレードのドキュメント

.Net SDKを使用したドキュメントのクエリ

以下は、.Net SDKを使用していくつかのドキュメントクエリを実行する手順です。

この例では、追加したばかりの新しく作成されたドキュメントを照会します。

ステップ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();
}

このクエリはコレクション全体のすべてのドキュメントも返しますが、以前のようにCreateDocumentQueryで.ToListを呼び出していません。これにより、1行のコードですべての結果を取得するために必要な数のリクエストが発行されます。

ステップ2 *-代わりに、AsDocumentQueryを呼び出すと、このメソッドはHasMoreResultsプロパティを持つクエリオブジェクトを返します。

ステップ3 *-HasMoreResultsがtrueの場合、ExecuteNextAsyncを呼び出して次のチャンクを取得し、そのチャンクのすべての内容をダンプします。

ステップ4 *-必要に応じて、SQLの代わりにLINQを使用してクエリすることもできます。ここでは、qでLINQクエリを定義しましたが、.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クエリをDocumentDBのSQL構文に変換し、LINQ構文に基づいてSELECT句とWHERE句を生成します

ステップ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

DocumentDB-ドキュメントの更新

この章では、ドキュメントを更新する方法を学びます。 Azureポータルを使用すると、ドキュメントエクスプローラーでドキュメントを開き、エディターでテキストファイルのように更新することで、ドキュメントを簡単に更新できます。

ドキュメントの更新

[保存]ボタンをクリックします。これで、.Net SDKを使用してドキュメントを変更する必要がある場合、それを置き換えることができます。削除して再作成する必要はありません。面倒なことに加えて、リソースIDも変更します。これは、ドキュメントを変更するだけでは不要です。 .Net SDKを使用してドキュメントを更新するための次の手順を示します。

次のReplaceDocumentsタスクを見てみましょう。isNewプロパティがtrueであるドキュメントを照会しますが、何もないので何も取得しません。それでは、先ほど追加したドキュメントで、名前がNew Customerで始まるドキュメントを変更しましょう。

ステップ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();
}

ステップ2 *-同じSTARTSWITHクエリを使用して更新するドキュメントを取得します。これにより、動的オブジェクトとしてここに戻ってきたドキュメントが得られます。

ステップ3 *-isNewプロパティを添付し、各ドキュメントに対してtrueに設定します。

ステップ4 *-ReplaceDocumentAsyncを呼び出して、更新されたドキュメントとともにドキュメントのSelfLinkを渡します。

これが機能することを証明するために、isNewがtrueに等しいドキュメントを照会します。 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-ドキュメントの削除

この章では、DocumentDBアカウントからドキュメントを削除する方法を学びます。 Azure Portalを使用すると、ドキュメントエクスプローラーでドキュメントを開き、[削除]オプションをクリックして、ドキュメントを簡単に削除できます。

ドキュメントの削除

ドキュメントの削除ダイアログ

確認メッセージが表示されます。 [はい]ボタンを押すと、DocumentDBアカウントでドキュメントが使用できなくなっていることがわかります。

Net SDKを使用してドキュメントを削除する場合。.

ステップ1 *-これは、新しいドキュメントごとにSelfLinksを取得するために最初にクエリを行う場所で見たパターンと同じです。ここではSELECT *を使用しません。これはドキュメント全体を返すため、必要ありません。

ステップ2 *-代わりに、SelfLinksをリストに選択し、SelfLinkごとにDeleteDocumentAsyncを一度に1つずつ呼び出して、コレクションからドキュメントを削除します。

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

ステップ3 *-次に、CreateDocumentClientタスクから上記のDeleteDocumentsを呼び出します。

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-データモデリング

DocumentDBのようなスキーマフリーデータベースを使用すると、データモデルへの変更を非常に簡単に取り入れることができますが、データについて考えるのにしばらく時間をかける必要があります。

あなたにはたくさんの選択肢があります。当然、JSONオブジェクトグラフまたはJSONテキストの生の文字列だけで作業できますが、コンパイル時にクラスを定義せずに実行時にプロパティにバインドできる動的オブジェクトを使用することもできます。
また、実際のC＃オブジェクト、またはそれらが呼び出されたエンティティ（ビジネスドメインクラス）を操作することもできます。

関係

ドキュメントの階層構造を見てみましょう。必要なid、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
}

たとえば、parentsプロパティは、角括弧で示されるJSON配列として提供されます。
この例では、配列に子が1つしかない場合でも、子用の別の配列もあります。これが、ドキュメント内の1対多の関係に相当するものをモデル化する方法です。
単純に配列を使用します。配列内の各要素は、単純な値または別の複雑なオブジェクト、さらに別の配列になります。
したがって、1つの家族は複数の親と複数の子を持つことができ、子オブジェクトを見ると、それ自体が子とペットの1対多の関係のネストされた配列であるペットのプロパティを持っています。
locationプロパティについては、3つの関連するプロパティ、州、郡、市をオブジェクトに結合しています。
オブジェクトの配列を埋め込むのではなく、この方法でオブジェクトを埋め込むことは、リレーショナルデータベースの別々のテーブルにある2つの行の間に1対1の関係を持たせることに似ています。

データを埋め込む

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": "mark.upston@xyz.com"},
      {"phone": "+1 356 545-86455", "extension": 5555}
   ]
}

ご覧のとおり、顧客のすべての情報が単一のJSONドキュメントに埋め込まれている顧客レコードを非正規化しています。

NoSQLには無料のスキーマがあるため、連絡先の詳細と住所を異なる形式で追加することもできます。 NoSQLでは、1回の読み取り操作でデータベースから顧客レコードを取得できます。同様に、レコードの更新も単一の書き込み操作です。

以下は、.Net SDKを使用してドキュメントを作成する手順です。

ステップ1 *-DocumentClientをインスタンス化します。次に、myfirstdbデータベースを照会し、MyCollectionコレクションを照会します。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);
   }

}

ステップ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プロパティが提供されていないことにも気づくでしょう。

ステップ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;
}

ステップ4 *-今回は、ドキュメントを追加するコレクションのSelfLinkを指定してCreateDocumentAsyncを呼び出します。この場合、システムによって生成されたプロパティを持つ新しいドキュメントを表すリソースプロパティを持つ応答が返されます。

次のCreateDocumentsタスクでは、3つのドキュメントを作成しました。

最初のドキュメントでは、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();
}

この2番目のドキュメントは、生のJSON文字列でのみ機能します。ここで、JavaScriptSerializerを使用して文字列をオブジェクトに逆シリアル化するCreateDocumentのオーバーロードにステップインし、最初のドキュメントの作成に使用したのと同じCreateDocumentメソッドに渡します。
3番目のドキュメントでは、アプリケーションで定義されているC＃オブジェクトCustomerを使用しました。

この顧客を見てみましょう。IDとアドレスのプロパティがあります。アドレスは、さらに別のネストされたオブジェクトである場所を含む独自のプロパティを持つネストされたオブジェクトです。

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は前の2つのドキュメントの場合と同様に、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

DocumentDB-データ型

JSONまたはJavaScript Object Notationは、人間が読めるデータ交換用に設計された軽量のテキストベースのオープンスタンダードであり、マシンが解析および生成するのも簡単です。 JSONはDocumentDBの中心です。 JSONをネットワーク経由で送信し、JSONをJSONとして保存し、JSONツリーにインデックスを付けて、完全なJSONドキュメントでクエリを実行できるようにします。

JSON形式は次のデータ型をサポートしています-

S.No.	Type & Description
1	Number JavaScriptの倍精度浮動小数点形式
2	String バックスラッシュをエスケープする二重引用符付きUnicode
3	Boolean 正しいか間違っているか
4	Array 値の順序付けられたシーケンス
5	Value 文字列、数値、trueまたはfalse、nullなどを指定できます。
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

DocumentDB-レコードの制限

Microsoftは最近、SQL文法のTOPキーワードなど、Azure DocumentDBのクエリ方法にいくつかの改善を追加しました。これにより、クエリの実行が速くなり、リソースの消費が少なくなり、クエリ演算子の制限が増加し、追加のLINQ演算子のサポートが追加されました.NET SDK。

最初の2つのレコードのみを取得する簡単な例を見てみましょう。多数のレコードがあり、それらの一部のみを取得する場合は、Topキーワードを使用できます。この例では、地震の記録がたくさんあります。

レコードの制限

ここで、最初の2つのレコードのみを表示します

ステップ1 *-クエリエクスプローラーに移動して、このクエリを実行します。

SELECT * FROM c
WHERE c.magnitude > 2.5

TOPキーワードをまだ指定していないため、4つのレコードが取得されていることがわかります。

取得したレコード

ステップ2 *-同じクエリでTOPキーワードを使用します。ここでは、TOPキーワードを指定しました。「2」は、2つのレコードのみが必要であることを意味します。

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

ステップ3 *-このクエリを実行すると、2つのレコードのみが取得されることがわかります。

2つのレコードを取得

同様に、.Net SDKを使用してコードでTOPキーワードを使用できます。以下は実装です。

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

以下は、DocumentClientおよび地震データベースをインスタンス化する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 =
         'earthquake'").AsEnumerable().First();

      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink,
         "SELECT * FROM c WHERE c.id = 'earthquakedata'").AsEnumerable().First();

      await QueryDocumentsWithPaging(client);
   }
}

上記のコードをコンパイルして実行すると、3つのレコードのみが取得されることがわかります。

*** *Query Documents (paged results)* ***

Quering for all documents
PublicId: 2015p947400; Magnitude: 2.515176918;
PublicId: 2015p947373; Magnitude: 1.506774108;
PublicId: 2015p947329; Magnitude: 1.593394461;

DocumentDB-レコードの並べ替え

Microsoft Azure DocumentDBは、SQL over 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に指示するデフォルトのインデックスポリシーは、多くの一般的なシナリオに適しています。ただし、インデックスを作成するものとしないものを正確に制御するカスタムポリシーや、インデックス作成に関するその他の機能を実装することもできます。

DocumentDBは、次の種類のインデックス作成をサポートしています-

Hash
範囲

Hash

ハッシュインデックスを使用すると、等しいかどうかの効率的なクエリが可能になります。つまり、特定のプロパティがより小さい、より大きい、または間の値の範囲で一致するのではなく、正確な値に等しいドキュメントを検索します。

ハッシュインデックスを使用して範囲クエリを実行できますが、DocumentDBは一致するドキュメントを見つけるためにハッシュインデックスを使用できず、代わりに各ドキュメントを順次スキャンして範囲クエリで選択する必要があるかどうかを判断する必要があります。

ハッシュインデックスだけのプロパティでORDER BY句を使用してドキュメントを並べ替えることはできません。

範囲

プロパティに定義された範囲インデックス、DocumentDBにより、値の範囲に対してドキュメントを効率的に照会できます。また、ORDER BYを使用して、そのプロパティのクエリ結果を並べ替えることができます。

DocumentDBでは、任意またはすべてのプロパティでハッシュと範囲インデックスの両方を定義できます。これにより、効率的な等価クエリと範囲クエリ、およびORDER BYが可能になります。

インデックス作成ポリシー

すべてのコレクションには、すべてのドキュメントのすべてのプロパティの数値と文字列に使用されるインデックスのタイプを指定するインデックスポリシーがあります。

また、ドキュメントがコレクションに追加されるときに、ドキュメントのインデックスを自動的に作成するかどうかも制御できます。
自動インデックスはデフォルトで有効になっていますが、ドキュメントを追加するときにその動作をオーバーライドして、DocumentDBにその特定のドキュメントのインデックスを作成しないように指示できます。
自動インデックス作成を無効にして、デフォルトでドキュメントがコレクションに追加されたときにインデックスが作成されないようにすることができます。同様に、ドキュメントレベルでこれをオーバーライドし、特定のドキュメントをコレクションに追加するときにDocumentDBにインデックスを作成するように指示できます。これは、手動インデックス付けと呼ばれます。

インデックス作成を含める/除外する

インデックス作成ポリシーでは、インデックスに含めるパスまたは除外するパスを定義することもできます。これは、クエリを実行しないドキュメントの特定の部分と実行する特定の部分があることがわかっている場合に役立ちます。

これらの場合、コレクションに追加された各ドキュメントの特定の部分のみをインデックス付けするようにDocumentDBに指示することにより、インデックス付けのオーバーヘッドを削減できます。

自動索引付け

自動インデックス作成の簡単な例を見てみましょう。

ステップ1 *-最初に自動インデックス付けと呼ばれるコレクションを作成し、明示的にポリシーを指定せずに、このコレクションはデフォルトのインデックス付けポリシーを使用します。つまり、このコレクションで自動インデックス付けが有効になります。

ここでは、データベースのセルフリンクにIDベースのルーティングを使用しているため、コレクションを作成する前にリソースIDやクエリを知る必要はありません。 mydbというデータベースIDを使用できます。

ステップ2 *-次に、姓がUpstonの2つのドキュメントを作成しましょう。

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の2番目のドキュメントが追加されると、コレクションのインデックス付けポリシーにかかわらず、DocumentDBにこのドキュメントをインデックス付けしないように明示的に指示するIndexingDirective.Excludeを使用して要求オプションを渡しました。

最後に両方のドキュメントに対して異なるタイプのクエリがあります。

ステップ3 *-CreateDocumentClientからAutomaticIndexingタスクを呼び出しましょう。

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==/

ご覧のとおり、このようなドキュメントが2つありますが、Markのインデックスは作成されていないため、クエリはMarkのドキュメントのみを返します。コレクション内のすべてのドキュメントを取得するWHERE句なしで再度クエリを実行すると、両方のドキュメントの結果セットが取得されます。これは、インデックス付けされていないドキュメントが常にWHERE句のないクエリによって返されるためです。

IDまたはセルフリンクによって、インデックス付けされていないドキュメントを取得することもできます。したがって、MarkのIDであるMARKでドキュメントを照会すると、DocumentDBがコレクション内でインデックス付けされていなくてもドキュメントを返すことがわかります。

手動インデックス付け

自動インデックス作成を無効にして、手動インデックス作成の簡単な例を見てみましょう。

ステップ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");
}

ステップ2 *-次に、以前と同じ2つのドキュメントを再度作成します。コレクションのインデックス作成ポリシーにより、このドキュメントはインデックス化されないため、今回はMarkのドキュメントに特別なリクエストオプションを提供しません。

ステップ3 *-Markに2番目のドキュメントを追加するとき、RequestOptionsをIndexingDirective.Includeとともに使用して、DocumentDBにこのドキュメントのインデックスを作成するように指示します。

最後に両方のドキュメントに対して異なるタイプのクエリがあります。

ステップ4 *-CreateDocumentClientからManualIndexingタスクを呼び出しましょう。

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==/

繰り返しますが、クエリは2つのドキュメントのうちの1つだけを返しますが、今回はJane Doeを返します。ただし、以前と同様に、WHERE句なしでクエリを実行すると、Markのインデックス付けされていないドキュメントを含むコレクション内のすべてのドキュメントが取得されます。また、IDによってインデックスが付けられていないドキュメントを照会することもできます。このIDは、インデックス付けされていなくてもDocumentDBから返されます。

DocumentDB-地理空間データ

Microsoftは*地理空間サポート*を追加しました。これにより、ドキュメントに位置データを保存し、ポイントとポリゴン間の距離と交差点の空間計算を実行できます。

空間データは、空間内のオブジェクトの位置と形状を表します。
通常は、人の位置、関心のある場所、都市の境界、または湖を表すために使用できます。

一般的なユースケースには、近接クエリが関係することがよくあります。たとえば、「現在の場所の近くにあるすべての大学を検索する」。

*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

DocumentDB-パーティショニング

データベースが10GBを超えて大きくなり始めると、新しいコレクションを作成してから、さらに多くのコレクションにデータを分散またはパーティション分割するだけでスケールアウトできます。

遅かれ早かれ、10GBの容量を持つ単一のコレクションでは、データベースを含めるのに十分ではなくなります。 10GBはそれほど大きな数字には聞こえないかもしれませんが、JSONドキュメントを保存していることに注意してください。これは単なるテキストであり、インデックスのストレージオーバーヘッドを考慮しても、多くのプレーンテキストドキュメントを10GBに収めることができます。

スケーラビリティに関しては、ストレージだけが問題ではありません。コレクションで使用可能な最大スループットは、S3コレクションで取得できる1秒あたり2.5リクエスト単位です。したがって、より高いスループットが必要な場合は、複数のコレクションでパーティション化してスケールアウトする必要もあります。スケールアウトパーティショニングは、*水平パーティショニング*とも呼ばれます。

Azure DocumentDBでデータをパーティション分割するために使用できる多くのアプローチがあります。以下は最も一般的な戦略です-

スピルオーバーパーティショニング
範囲分割
ルックアップパーティショニング
ハッシュ分割

スピルオーバーパーティショニング

スピルオーバーパーティショニングは、パーティションキーがないため、最も単純な戦略です。多くのことについて確信が持てない場合は、多くの場合、最初から始めるのが良い選択です。単一のコレクションを超えてスケールアウトする必要があるかどうか、追加する必要があるコレクションの数、または追加する必要のある速度を知ることはできません。

スピルオーバーパーティショニングは単一のコレクションから始まり、パーティションキーはありません。
コレクションは拡大し始め、その後、10GBの制限に近づくまで、さらに拡大し、さらに拡大します。
容量が90％に達すると、新しいコレクションにあふれて、新しいドキュメントに使用し始めます。
データベースがより多くのコレクションにスケールアウトしたら、おそらくパーティションキーに基づく戦略に移行する必要があります。
その場合、移行先の戦略に基づいてドキュメントを異なるコレクションに移動することにより、データのバランスを取り直す必要があります。

範囲分割

最も一般的な戦略の1つは、範囲分割です。このアプローチでは、ドキュメントのパーティションキーが含まれる可能性のある値の範囲を決定し、その範囲に対応するコレクションにドキュメントを向けます。

定義された日付の範囲内のドキュメントを保持するコレクションを作成するこの戦略では、通常、日付が使用されます。十分に小さい範囲を定義すると、コレクションが10GBの制限を超えることはないと確信できます。たとえば、1つのコレクションで1か月間ドキュメントを合理的に処理できるシナリオがあります。
また、ほとんどのユーザーが現在のデータ（今月またはおそらく先月のデータ）を照会している場合もありますが、はるかに古いデータを検索することはほとんどありません。そのため、6月にS3コレクションを開始します。S3コレクションは、購入できる最も高価なコレクションであり、取得できる最高のスループットを提供します。
7月に別のS3コレクションを購入して7月のデータを保存し、6月のデータをより安価なS2コレクションに縮小します。次に、8月に別のS3コレクションを取得し、7月をS2に、6月をS1に縮小します。毎月、常に最新のデータを高いスループットで使用できるようにし、古いデータは低いスループットで使用できるようにします。
クエリがパーティションキーを提供している限り、クエリが必要なコレクションのみがクエリされ、スピルオーバーパーティショニングで発生するようなデータベース内のすべてのコレクションはクエリされません。

ルックアップパーティショニング

ルックアップパーティション分割を使用すると、パーティションキーに基づいてドキュメントを特定のコレクションにルーティングするパーティションマップを定義できます。たとえば、地域ごとにパーティションを分割できます。

1つのコレクションにすべての米国のドキュメント、別のコレクションにすべてのヨーロッパのドキュメント、および3番目のコレクションにある他の地域のすべてのドキュメントを保存します。
このパーティションマップとルックアップパーティションリゾルバを使用すると、各ドキュメントに含まれるリージョンプロパティであるパーティションキーに基づいて、ドキュメントを作成するコレクションとクエリするコレクションを判別できます。

ハッシュ分割

ハッシュパーティション分割では、ハッシュ関数の値に基づいてパーティションが割り当てられるため、複数のパーティションにリクエストとデータを均等に分散できます。

これは一般に、多数の個別のクライアントから生成または消費されるデータを分割するために使用され、ユーザープロファイル、カタログアイテムなどの保存に役立ちます。

NET SDKが提供するRangePartitionResolverを使用した範囲分割の簡単な例を見てみましょう。.

ステップ1 *-新しいDocumentClientを作成し、CreateCollectionsタスクで2つのコレクションを作成します。 1つはA〜Mで始まるユーザーIDを持つユーザー用のドキュメントを含み、もう1つはユーザー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” });
}

ステップ2 *-データベースの範囲リゾルバーを登録します。

ステップ3 *-新しいRangePartitionResolver <string>を作成します。これは、パーティションキーのデータ型です。コンストラクターは、パーティションキーのプロパティ名と、シャードマップまたはパーティションマップであるディクショナリの2つのパラメーターを取ります。ディクショナリは、リゾルバー用に事前定義している範囲と対応するコレクションの単なるリストです。

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値をエンコードする必要があります。または、最初の範囲は、1つの単一のMを除くどのMでも一致せず、同様に2番目の範囲のZでも一致しません。したがって、ここでエンコードされた値は、パーティションキーで一致するためのワイルドカードと考えることができます。

ステップ4 *-リゾルバーを作成したら、現在のDocumentClientでデータベースに登録します。それを行うには、PartitionResolverの辞書プロパティに割り当てます。

通常のコレクションではなく、データベースに対してドキュメントを作成およびクエリします。リゾルバーはこのマップを使用して、リクエストを適切なコレクションにルーティングします。

それでは、いくつかのドキュメントを作成しましょう。最初に、userId Kirk用に1つ作成し、次にSpock用に1つ作成します。

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

ここでの最初のパラメーターは、特定のコレクションではなく、データベースへの自己リンクです。これはパーティションリゾルバなしでは不可能ですが、1つを使用するとシームレスに機能します。

両方のドキュメントはデータベースmyfirstdbに保存されましたが、RangePartitionResolverが正常に機能している場合、KirkはAからMのコレクションに格納され、SpockはNからZのコレクションに格納されていることがわかります。

次のコードに示すように、これらを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==/

ご覧のように、2つのドキュメントのセルフリンクは2つの別々のコレクションに存在するため、異なるリソースIDを持っています。

DocumentDB-データ移行

DocumentDBデータ移行ツールを使用すると、データをDocumentDBに簡単に移行できます。 DocumentDBデータ移行ツールは、Microsoftダウンロードセンターhttps://www.microsoft.com/enus/download/details.aspx?id=46436[[[2]] com/]

移行ツールは、多くのデータソースをサポートしています。それらの一部は以下にリストされています-

リンク：/documentdb/documentdb_sql_server [SQL Server]
リンク：/documentdb/documentdb_json_files [JSONファイル]
リンク：/documentdb/documentdb_csv [カンマ区切り値（CSV）のフラットファイル]
MongoDB
Azureテーブルストレージ
Amazon DynamoDB
HBase、さらには他のDocumentDBデータベース

DocumentDB Data Migrationツールをダウンロードした後、zipファイルを抽出します。

次のスクリーンショットに示すように、このフォルダーには2つの実行可能ファイルがあります。

実行可能ファイル

最初に、コマンドラインインターフェイスを備えたコンソールバージョンであるdt.exeがあり、次にグラフィカルユーザーインターフェイスを備えたデスクトップバージョンであるdtui.exeがあります。

GUIバージョンを起動しましょう。

GUIバージョンの起動

Welcomeページが表示されます。 [ソース情報]ページの[次へ]をクリックします。

ソース情報ページ

ここでデータソースを構成し、ドロップダウンメニューからサポートされている多くの選択肢を確認できます。

ソース情報の指定

選択すると、ソース情報ページの残りの部分がそれに応じて変わります。

DocumentDBデータ移行ツールを使用して、DocumentDBにデータをインポートするのは非常に簡単です。上記の例を実行し、他のデータファイルも使用することをお勧めします。

DocumentDB-アクセス制御

DocumentDBは、DocumentDBリソースへのアクセスを制御するための概念を提供します。 DocumentDBリソースへのアクセスは、マスターキートークンまたはリソーストークンによって管理されます。リソーストークンに基づく接続は、トークンで指定されたリソースにのみアクセスでき、他のリソースにはアクセスできません。リソーストークンは、ユーザーのアクセス許可に基づいています。

最初に1人以上のユーザーを作成します。これらのユーザーはデータベースレベルで定義されます。
次に、各ユーザーにアクセスを許可するリソースに基づいて、各ユーザーに1つ以上のアクセス許可を作成します。
各アクセス許可は、特定のリソースへの読み取り専用アクセスまたはフルアクセスのいずれかを許可し、データベース内の任意のユーザーリソースにできるリソーストークンを生成します。
ユーザーはデータベースレベルで定義され、権限はユーザーごとに定義されます。 *ユーザーと権限は、データベース内のすべてのコレクションに適用されます。

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

ステップ1 *-2人のユーザー、AliceとTomを作成するリソースと同様に作成し、目的のIdで定義オブジェクトを作成し、createメソッドを呼び出します。この場合、データベースのSelfLinkとuserDefinitionでCreateUserAsyncを呼び出します。新しく作成されたユーザーオブジェクトを取得したリソースプロパティから結果を取得します。

次に、データベース内のこれら2人の新しいユーザーを表示します。

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

ステップ2 *-データベースのUsersLinkに対してCreateUserQueryを呼び出して、すべてのユーザーのリストを取得します。次に、それらをループし、プロパティを表示します。

まず、それらを作成する必要があります。したがって、MyCollectionコレクションに対するAliceの読み取り/書き込み権限を許可したかったが、Tomはコレクション内のドキュメントのみを読み取ることができるとしましょう。

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

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

ステップ3-MyCollectionコレクションであるリソースにアクセス許可を作成して、そのリソースをSelfLinkにする必要があります。

ステップ4 *-次に、このコレクションでAliceのPermission.Allを作成し、このコレクションでTomのPermission.Readを作成します。

以下は、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とPermission.AllまたはPermission.ReadであるpermissionMode、および保護されているリソースのSelfLinkを含む新しいアクセス許可の定義オブジェクトを作成することでこれを行います許可によって。

ステップ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);
}

今回は、ユーザーのアクセス許可リンクに対するアクセス許可クエリであり、ユーザーに対して返された各アクセス許可を単純にリストします。

アリスとトムの許可を削除しましょう。

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

ステップ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);
}

ステップ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-データの視覚化

この章では、DocumentDBに保存されているデータを視覚化する方法を学びます。マイクロソフトは、データをリッチなビジュアルに変換するPower BI Desktopツールを提供しました。また、さまざまなデータソースからデータを取得し、データを結合および変換し、強力なレポートと視覚化を作成し、レポートをPower BIに発行できます。

Power BI Desktopの最新バージョンでは、MicrosoftはDocumentDBのサポートも追加し、DocumentDBアカウントに接続できるようになりました。このツールは、https://powerbi.microsoft.com/en-us/desktop [https://powerbi.microsoft.com]リンクからダウンロードできます。

前の章でインポートした地震データを視覚化する例を見てみましょう。

ステップ1 *-ツールをダウンロードしたら、Power BIデスクトップを起動します。

Power BIの起動

ステップ2 *-[外部データ]グループの[ホーム]タブにある[データの取得]オプションをクリックすると、[データの取得]ページが表示されます。

データの取得をクリック

ステップ3 *-Microsoft Azure DocumentDB（ベータ）オプションを選択し、[接続]ボタンをクリックします。

接続をクリック

ステップ4 *-データを視覚化するAzure DocumentDBアカウント、データベース、およびコレクションのURLを入力し、[OK]を押します。

初めてこのエンドポイントに接続する場合は、アカウントキーの入力を求められます。

アカウントキー

ステップ5 *-Azureポータルで利用可能な各DocumentDBアカウントに固有のアカウントキー（プライマリキー）を入力し、[接続]をクリックします。

レコードのリスト

アカウントが正常に接続されると、指定されたデータベースからデータを取得します。プレビューペインにはレコードアイテムのリストが表示され、ドキュメントはPower BIのレコードタイプとして表されます。

ステップ6 *-[編集]ボタンをクリックして、クエリエディターを起動します。

編集ボタンをクリック

ステップ7 *-Power BIクエリエディターでは、中央のウィンドウにドキュメント列が表示され、ドキュメント列ヘッダーの右側にあるエキスパンダーをクリックして、表示する列を選択します。

エキスパンダーをクリック

ご覧のとおり、緯度と経度は別々の列になっていますが、緯度と経度の座標形式でデータを視覚化します。

ステップ8 *-それを行うには、[列の追加]タブをクリックします。

列の追加をクリック

ステップ9 *-次のページを表示するカスタム列の追加を選択します。

カスタム列の追加

ステップ10 *-新しい列名、たとえばLatLongと、コンマで区切られた1つの列の緯度と経度を結合する式を指定します。以下は式です。

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

ステップ11 *-[OK]をクリックして続行すると、新しい列が追加されたことがわかります。

新しい列が追加されました

ステップ12 *-[ホーム]タブに移動し、[閉じると適用]オプションをクリックします。

閉じるをクリックして適用

ステップ13 *-フィールドをレポートキャンバスにドラッグアンドドロップしてレポートを作成できます。右側に2つのペインがあります。1つは視覚化ペインで、もう1つはフィールドペインです。

レポート作成

各地震の場所を示すマップビューを作成しましょう。

ステップ14 *-視覚化ペインからマップの視覚タイプをドラッグします。

ステップ15 *-次に、LatLongフィールドを[フィールド]ペインから[視覚化]ペインの[場所]プロパティにドラッグアンドドロップします。次に、マグニチュードフィールドをValuesプロパティにドラッグアンドドロップします。

ステップ16 *-深度フィールドを[彩度]プロパティにドラッグアンドドロップします。

深度フィールド

これで、マップのビジュアルに各地震の場所を示す一連のバブルが表示されます。

Documentdb-quick-guide

DocumentDB-はじめに

NoSQLドキュメントデータベース

Azure DocumentDB

DocumentDB –価格

DocumentDB-利点

スキーマフリー

SQL構文

調整可能な一貫性

弾性スケール

完全管理

DocumentDB-環境設定

インストール

DocumentDB-アカウントの作成

DocumentDB-アカウントの接続

終点

認証キー

マスターキー

リソーストークン

DocumentDB-データベースの作成

Microsoft Azureポータルを使用してDocumentDBのデータベースを作成する

.Net SDKを使用してDocumentDB用のデータベースを作成する

DocumentDB-データベースのリスト

DocumentDB-データベースの削除

DocumentDB-コレクションの作成

DocumentDB-コレクションの削除

DocumentDB-文書の挿入

Azure Portalでドキュメントを作成する

.NET SDKを使用したドキュメントの作成

DocumentDB-クエリドキュメント

ポータルを使用したドキュメントのクエリ

.Net SDKを使用したドキュメントのクエリ

DocumentDB-ドキュメントの更新

DocumentDB-ドキュメントの削除

DocumentDB-データモデリング

関係

データを埋め込む

DocumentDB-データ型

DocumentDB-レコードの制限

DocumentDB-レコードの並べ替え

DocumentDB-レコードのインデックス作成

Hash

範囲

インデックス作成ポリシー

インデックス作成を含める/除外する

自動索引付け

手動インデックス付け

DocumentDB-地理空間データ

.NETで地理空間データを使用してドキュメントを作成する

DocumentDB-パーティショニング

スピルオーバーパーティショニング

範囲分割

ルックアップパーティショニング

ハッシュ分割

DocumentDB-データ移行

DocumentDB-アクセス制御

DocumentDB-データの視覚化