static Database FindDatabase(DocumentClient client, string name)
{
return client.CreateDatabaseQuery()
.Where(x => x.Id == name)
.ToList()
.SingleOrDefault();
}
public DocumentDBDataReader()
{
var dict = new Dictionary<HighchartsHelper.DocumentTypes, IEnumerable<Document>>();
_documentClient = new DocumentClient(new Uri(ConfigurationManager.AppSettings["DocumentServiceEndpoint"]), ConfigurationManager.AppSettings["DocumentKey"]);
_database = _documentClient.CreateDatabaseQuery().Where(db => db.Id == ConfigurationManager.AppSettings["DocumentDatabase"]).AsEnumerable().FirstOrDefault();
if (_database == null)
throw new ApplicationException("Error: DocumentDB database does not exist");
// Check to verify a document collection with the id=FamilyCollection does not exist
_documentCollection = _documentClient.CreateDocumentCollectionQuery(_database.CollectionsLink).Where(c => c.Id == ConfigurationManager.AppSettings["DocumentCollection"]).AsEnumerable().FirstOrDefault();
if (_documentCollection == null)
throw new ApplicationException("Error: DocumentDB collection does not exist");
try
{
_documentClient.CreateUserDefinedFunctionAsync(_documentCollection.SelfLink, new UserDefinedFunction
{
Id = "ISDEFINED",
Body = @"function ISDEFINED(doc, prop) {
return doc[prop] !== undefined;
}"
});
}
catch (Exception)
{
//fail silently for now..
}
}
//new add
private static async Task GetStart()
{
var client = new DocumentClient(new Uri(EndpointURL), AuthorizationKey);
database = client.CreateDatabaseQuery().Where(d => d.Id == "ppweict").AsEnumerable().FirstOrDefault();
collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == "Exam_Pool").AsEnumerable().FirstOrDefault();
var EfDs = client.CreateDocumentQuery(collection.DocumentsLink, "SELECT * FROM Exam_pool f WHERE f.verify = \"true\" ");
foreach (exam_pool EfD in EfDs)
{
Console.WriteLine(EfD);
exams.Add(new exam_pool
{
id = EfD.id,
exam_catrgory = EfD.exam_catrgory,
exam_level = EfD.exam_level,
questions = EfD.questions,
answer_A = EfD.answer_A,
answer_B = EfD.answer_B,
answer_C = EfD.answer_C,
answer_D = EfD.answer_D,
answer_E = EfD.answer_E,
C_answer = EfD.C_answer,
exam_link = EfD.exam_link,
lang = EfD.lang,
verify = EfD.verify,
});
}
}
private async Task<DocumentClient> GetDocumentDbClient()
{
var client = new DocumentClient(new Uri(_endPointUrl), _authorizationKKry);
var database = client.CreateDatabaseQuery().
Where(db => db.Id == DocumentDbId).AsEnumerable().FirstOrDefault();
if (database == null)
{
database = await client.CreateDatabaseAsync(
new Database
{
Id = DocumentDbId
});
}
DocumentCollection = client.CreateDocumentCollectionQuery
("dbs/" + database.Id).Where(c => c.Id == _collectionId).AsEnumerable().FirstOrDefault();
if (DocumentCollection == null)
{
DocumentCollection = await client.CreateDocumentCollectionAsync("dbs/" + DocumentDbId,
new DocumentCollection
{
Id = _collectionId
});
}
return client;
}
public Dichotomy(string endpointUrl, string authorizationKey)
{
_client = new DocumentClient(new Uri(endpointUrl), authorizationKey);
_database =
_client.CreateDatabaseQuery().Where(db => db.SelfLink == ConfigurationManager.AppSettings["DBSelfLink"])
.AsEnumerable().FirstOrDefault();
_iDbService = new DbService();
}
private static Database GetOrCreateDatabase(DocumentClient client, string databaseName)
{
// Try to retrieve the database (Microsoft.Azure.Documents.Database) whose Id is equal to databaseName
var database = client.CreateDatabaseQuery().Where(db => db.Id == databaseName).ToArray().FirstOrDefault()
?? client.CreateDatabaseAsync(new Database { Id = databaseName }).Result;
return database;
}
public Dichotomy(string endpointUrl, string authorizationKey)
{
_client = new DocumentClient(new Uri(endpointUrl), authorizationKey);
_database =
_client.CreateDatabaseQuery().Where(db => db.Id == CloudConfigurationManager.GetSetting("Database"))
.AsEnumerable().FirstOrDefault();
_iDbService = new DbService();
}
private static Database GetDatabase(DocumentClient client)
{
var database = client
.CreateDatabaseQuery()
.Where(x => x.Id == "TestDocumentDatabase")
.AsEnumerable()
.FirstOrDefault();
return database;
}
public DocumentClient Initialise()
{
var configuration = (Configuration)ConfigurationManager.GetSection("DocumentDbProvider");
_documentClient = new DocumentClient(new Uri(configuration.Endpoint), configuration.Key);
Database = _documentClient.CreateDatabaseQuery()
.Where(d => d.Id == _databaseName).AsEnumerable().FirstOrDefault()
?? _documentClient.CreateDatabaseAsync(new Database { Id = _databaseName }).Result;
return _documentClient;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="documentClient"></param>
/// <param name="databaseId"></param>
/// <param name="createDatabaseIfNonexistent"></param>
public CollectionManager( DocumentClient documentClient ,
string databaseId ,
bool createDatabaseIfNonexistent = false ) {
DocumentClient = documentClient;
DatabaseId = databaseId;
Database =
DocumentClient.CreateDatabaseQuery().Where( item => item.Id == databaseId ).AsEnumerable().FirstOrDefault();
Initialize( createDatabaseIfNonexistent ).Wait();
}
private static Database GetDatabase(Microsoft.Azure.Documents.Client.DocumentClient client)
{
// Check to verify a database with the id=LoggingDocumentsDB does not exist
var database = client.CreateDatabaseQuery().Where(db => db.Id == "LoggingDocumentsDB").AsEnumerable().FirstOrDefault();
if (database == null)
{
database = client.CreateDatabaseAsync(new Database {
Id = "LoggingDocumentsDB"
}).Result;
}
return(database);
}
internal static Database ReadOrCreateDatabase(DocumentClient client, string databaseId)
{
var databases = client.CreateDatabaseQuery()
.Where(db => db.Id == databaseId).ToArray();
if (databases.Any())
{
return databases.First();
}
var database = new Database { Id = databaseId };
return client.CreateDatabaseAsync(database).Result;
}
static void Main(string[] args)
{
if (args.Count() < 4)
{
Console.WriteLine("You must specify the following parameters: Document DB endpoint URL, secret key, database name, and collection name.");
Console.WriteLine("Program terminated. Press any key to exit");
Console.ReadKey();
return; // exit program
}
// setup DocumentDB client using passed parameters
Uri endpoint = new Uri(args[0]);
string authKey = args[1];
string databaseId = args[2];
string collectionId = args[3];
var connectionPolicy = new ConnectionPolicy()
{
ConnectionProtocol = Protocol.Https,
ConnectionMode = ConnectionMode.Gateway
};
client = new DocumentClient(endpoint, authKey, connectionPolicy);
Database database = client.CreateDatabaseQuery().Where(db => db.Id == databaseId).ToArray().FirstOrDefault();
DocumentCollection collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == collectionId).ToArray().FirstOrDefault();
// get list of SP files
var currentDir = new DirectoryInfo(Directory.GetCurrentDirectory());
foreach (FileInfo tmpFile in currentDir.GetFiles("SP_*.js"))
{
string storedProecureId = tmpFile.Name.Substring(3, (tmpFile.Name.Length - 6));
Console.WriteLine("Found File: " + storedProecureId);
var storedProc = new StoredProcedure()
{
Id = storedProecureId,
Body = File.ReadAllText(tmpFile.FullName)
};
TryDeleteStoredProcedure(collection.SelfLink, storedProc.Id);
client.CreateStoredProcedureAsync(collection.SelfLink, storedProc, null).Wait();
}
Console.WriteLine("Stored Procedure Setup completed. Press any key to continue.");
Console.ReadKey();
}
public static Database GetOrCreateDatabase(DocumentClient client, string databaseId)
{
IQueryable<Database> dbQuery = from db in client.CreateDatabaseQuery()
where db.Id == databaseId
select db;
IEnumerable<Database> enumerable = dbQuery.AsEnumerable();
if (!enumerable.Any())
{
return client.CreateDatabaseAsync(new Database() { Id = databaseId }).Result.Resource;
}
else
{
return enumerable.First<Database>();
}
}
public async Task<bool> WriteDocument(MessageType type, String jsonString)
{
var client = new DocumentClient(new Uri(ConfigurationManager.AppSettings["DocumentServiceEndpoint"]), ConfigurationManager.AppSettings["DocumentKey"]);
var dbName = ConfigurationManager.AppSettings["DocumentDatabase"];
var database = client.CreateDatabaseQuery().Where(db => db.Id == dbName).AsEnumerable().FirstOrDefault() ??
await client.CreateDatabaseAsync(new Database{ Id = dbName});
// Check to verify a document collection with the does not exist
var docCollection = ConfigurationManager.AppSettings["DocumentCollection"];
var documentCollection = client.CreateDocumentCollectionQuery(database.CollectionsLink).Where(c => c.Id == docCollection).AsEnumerable().FirstOrDefault() ??
await client.CreateDocumentCollectionAsync(database.CollectionsLink, new DocumentCollection { Id = docCollection });
var id = Guid.NewGuid().ToString();
var response = HttpStatusCode.Unused;
switch (type)
{
case MessageType.Energy:
var energyDoc = JsonConvert.DeserializeObject<EnergyDocument>(jsonString);
energyDoc.id = id;
response = (await client.CreateDocumentAsync(documentCollection.DocumentsLink, energyDoc)).StatusCode;
break;
case MessageType.Humidity:
var humidityDoc = JsonConvert.DeserializeObject<HumidityDocument>(jsonString);
humidityDoc.id = id;
response = (await client.CreateDocumentAsync(documentCollection.DocumentsLink, humidityDoc)).StatusCode;
break;
case MessageType.Light:
var lightDoc = JsonConvert.DeserializeObject<LightDocument>(jsonString);
lightDoc.id = id;
response = (await client.CreateDocumentAsync(documentCollection.DocumentsLink, lightDoc)).StatusCode;
break;
case MessageType.Temperature:
var tempDoc = JsonConvert.DeserializeObject<TemperatureDocument>(jsonString);
tempDoc.id = id;
response = (await client.CreateDocumentAsync(documentCollection.DocumentsLink, tempDoc)).StatusCode;
break;
}
return response == HttpStatusCode.Created;
}
static void Main(string[] args)
{
ConnectionPolicy policy = new ConnectionPolicy()
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
Uri endPoint = new Uri(EndpointUrl);
using (DocumentClient client = new DocumentClient(endPoint, AuthKey, policy))
{
Database database =
client.CreateDatabaseQuery().Where(db => db.Id == DatabasebId).AsEnumerable().First();
DocumentCollection collection =
client.CreateDocumentCollectionQuery(database.SelfLink)
.Where(c => c.Id == CollectionId)
.AsEnumerable()
.First();
IEnumerable<DataClass> dataSet = GetDataObjects(100);
Task<ResourceResponse<Document>>[] documentTasks =
dataSet.Select(d => client.CreateDocumentAsync(collection.DocumentsLink, d)).ToArray();
Task.WaitAll(documentTasks);
Document[] docs = documentTasks.Select(t => t.Result.Resource).ToArray();
Document doc = docs.First();
Task<ResourceResponse<Attachment>>[] attachmentTasks =
docs.Select(d => client.CreateAttachmentAsync(doc.AttachmentsLink, GetStream(1024))).ToArray();
Task.WaitAll(attachmentTasks);
DataClass[] data =
client.CreateDocumentQuery<DataClass>(collection.DocumentsLink).Select(d => d).ToArray();
Attachment[] attachments = client.CreateAttachmentQuery(doc.AttachmentsLink).ToArray();
string sql = "SELECT c.Name FROM c Where c.ObjectKey < 30 AND c.ObjectKey > 20";
dynamic[] dataArray = client.CreateDocumentQuery(collection.DocumentsLink, sql).ToArray();
}
}
// GET /api/search/?criterias=TOTO
public List<FeedItem> Get([FromUri]string criterias = "")
{
// si criterias = LAST10 -> renvoyé les dix derniere articles
var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);
Database database = client.CreateDatabaseQuery()
.Where(db => db.Id == databaseId)
.AsEnumerable()
.FirstOrDefault();
DocumentCollection collectionPosts = client.CreateDocumentCollectionQuery(database.CollectionsLink)
.Where(doccoll => doccoll.Id == collectionIdPost)
.AsEnumerable()
.FirstOrDefault();
var posts = (
from b in client.CreateDocumentQuery<FeedItem>(collectionPosts.SelfLink)
where b.Year == 2015 && b.Month >= 1 && b.Day >= 8
select b).ToList();
return posts;
}
public static async Task SaveTestResults(PerformanceTestResult testResults)
{
// Make sure to call client.Dispose() once you've finished all DocumentDB interactions
// Create a new instance of the DocumentClient
var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);
// Check to verify a database with the id=FamilyRegistry does not exist
Database database = client.CreateDatabaseQuery().Where(db => db.Id == "DistributedWebTest").AsEnumerable().FirstOrDefault();
if (database == null)
{
// Create a database
database = await client.CreateDatabaseAsync(
new Database
{
Id = "DistributedWebTest"
});
}
// Check to verify a document collection with the id=FamilyCollection does not exist
DocumentCollection documentCollection = client.CreateDocumentCollectionQuery(database.CollectionsLink).Where(c => c.Id == "DistributedTestResults").AsEnumerable().FirstOrDefault();
if (documentCollection == null)
{
// Create a document collection using the lowest performance tier available (currently, S1)
documentCollection = await client.CreateDocumentCollectionAsync(database.CollectionsLink,
new DocumentCollection { Id = "DistributedTestResults" },
new RequestOptions { OfferType = "S1" });
}
await client.CreateDocumentAsync(documentCollection.DocumentsLink, testResults);
}
public static Database GetDatabase(DocumentClient client, string databaseName)
{
return client.CreateDatabaseQuery().Where(db => db.Id == databaseName).AsEnumerable().FirstOrDefault();
}
/// <summary>
/// Deletes the service database.
/// </summary>
public static async Task DeleteDatabase(DocumentClient client, string databaseId)
{
// Get the database
var db = client.CreateDatabaseQuery().Where(d => d.Id == databaseId).AsEnumerable().FirstOrDefault();
// Return the database or create it if not exists yet
if (db != null)
{
await client.DeleteDatabaseAsync(db.SelfLink);
}
}
/// <summary>
/// Reads or create a database.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="databaseId">The database identifier.</param>
public static async Task<Microsoft.Azure.Documents.Database> ReadOrCreateDatabase(DocumentClient client, string databaseId)
{
// Get the database
var db = client.CreateDatabaseQuery().Where(d => d.Id == databaseId).AsEnumerable().FirstOrDefault();
// Return the database or create it if not exists yet
return db ?? await client.CreateDatabaseAsync(new Microsoft.Azure.Documents.Database { Id = databaseId });
}
private DocumentConnection CreateDocumentDbConnection()
{
var client = new DocumentClient(new Uri(EndpointUri), AccountKey);
// get the database and if it doesn't exist create it
Database database = client.CreateDatabaseQuery()
.Where(db => db.Id == Database)
.AsEnumerable()
.FirstOrDefault();
if (database == null)
{
Log.LogMessage(MessageImportance.Low, "The database {0} does not exist, will create it.", Database);
var task = client.CreateDatabaseAsync(new Database { Id = Database });
database = task.Result;
}
// get the document collection and if it doesn't exist create it
DocumentCollection collection = client.CreateDocumentCollectionQuery(database.SelfLink)
.Where(c => c.Id == Collection)
.AsEnumerable()
.FirstOrDefault();
if (collection == null)
{
Log.LogMessage(MessageImportance.Low, "The collection {0} does not exist, will create it.", Collection);
var task = client.CreateDocumentCollectionAsync(database.SelfLink, new DocumentCollection { Id = Collection });
collection = task.Result;
}
Log.LogMessage(MessageImportance.Normal, "Connected to DocumentDB database {0}, collection {1}.", Database, Collection);
return new DocumentConnection(database, client, collection);
}
/// <summary>
/// Initialize the DocumentDb settings and connections
/// </summary>
public void InitializeDocumentDb()
{
this.DocumentDbEndPointUrl = ConfigurationManager.AppSettings["DocumentDbEndPointUrl"];
if (String.IsNullOrWhiteSpace(this.DocumentDbEndPointUrl))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbEndPointUrl");
}
this.DocumentDbAuthorizationKey = ConfigurationManager.AppSettings["DocumentDbAuthorizationKey"];
if (String.IsNullOrWhiteSpace(this.DocumentDbAuthorizationKey))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbAuthorizationKey");
}
this.DocumentDbDatabase = ConfigurationManager.AppSettings["DocumentDbDatabase"];
if (String.IsNullOrWhiteSpace(this.DocumentDbDatabase))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbDatabase");
}
this.DocumentDbCollection = ConfigurationManager.AppSettings["DocumentDbCollection"];
if (String.IsNullOrWhiteSpace(this.DocumentDbCollection))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbCollection");
}
// Create a new instance of the DocumentClient
documentClient = new DocumentClient(new Uri(this.DocumentDbEndPointUrl), this.DocumentDbAuthorizationKey);
// Check to verify if database already exists
Database database = documentClient.CreateDatabaseQuery().
Where(db => db.Id == this.DocumentDbDatabase).AsEnumerable().FirstOrDefault();
if (database == null)
{
Context.Logger.Info("Creating a new DocumentDb database: {0}", this.DocumentDbDatabase);
// Create a database
var task = documentClient.CreateDatabaseAsync(
new Database
{
Id = this.DocumentDbDatabase
});
task.Wait();
database = task.Result;
}
else
{
Context.Logger.Info("Found an existing DocumentDb database: {0}", database.Id);
}
// Check to verify a document collection already exists
documentCollection = documentClient.CreateDocumentCollectionQuery(database.CollectionsLink).
Where(c => c.Id == this.DocumentDbCollection).AsEnumerable().FirstOrDefault();
if (documentCollection == null)
{
Context.Logger.Info("Creating a new DocumentDb collection: {0}", this.DocumentDbCollection);
// Create a document collection
var task = documentClient.CreateDocumentCollectionAsync(database.CollectionsLink,
new DocumentCollection
{
Id = this.DocumentDbCollection,
});
task.Wait();
documentCollection = task.Result;
}
else
{
Context.Logger.Info("Found an existing DocumentDb collection: {0}", documentCollection.Id);
}
}
/// <summary>
/// Initialize the DocumentDb settings and connections
/// </summary>
public void InitializeDocumentDb()
{
this.DocumentDbEndPointUrl = ConfigurationManager.AppSettings["DocumentDbEndPointUrl"];
if (String.IsNullOrWhiteSpace(this.DocumentDbEndPointUrl))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbEndPointUrl");
}
this.DocumentDbAuthorizationKey = ConfigurationManager.AppSettings["DocumentDbAuthorizationKey"];
if (String.IsNullOrWhiteSpace(this.DocumentDbAuthorizationKey))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbAuthorizationKey");
}
this.DocumentDbDatabase = ConfigurationManager.AppSettings["DocumentDbDatabase"];
if (String.IsNullOrWhiteSpace(this.DocumentDbDatabase))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbDatabase");
}
this.DocumentDbCollection = ConfigurationManager.AppSettings["DocumentDbCollection"];
if (String.IsNullOrWhiteSpace(this.DocumentDbCollection))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbCollection");
}
this.DocumentDbLookupField = ConfigurationManager.AppSettings["DocumentDbLookupField"];
if (String.IsNullOrWhiteSpace(this.DocumentDbLookupField))
{
throw new ArgumentException("A required AppSetting cannot be null or empty", "DocumentDbLookupField");
}
// Create a new instance of the DocumentClient
documentClient = new DocumentClient(new Uri(this.DocumentDbEndPointUrl), this.DocumentDbAuthorizationKey);
// Check to verify if database already exists
Database database = documentClient.CreateDatabaseQuery().Where(db => db.Id == this.DocumentDbDatabase).AsEnumerable().FirstOrDefault();
if (database == null)
{
throw new Exception("DocumentDb database '" + this.DocumentDbDatabase + "' does not exist.");
}
// Check to verify a document collection already exists
documentCollection = documentClient.CreateDocumentCollectionQuery(database.CollectionsLink).Where(c => c.Id == this.DocumentDbCollection).AsEnumerable().FirstOrDefault();
if (documentCollection == null)
{
throw new Exception("DocumentDb database collection '" + this.DocumentDbCollection + "' does not exist.");
}
}
private static Database GetOrCreateDatabase(DocumentClient client, string databaseId)
{
var db = client.CreateDatabaseQuery()
.Where(d => d.Id == databaseId)
.AsEnumerable()
.FirstOrDefault();
if (db == null)
{
db = client.CreateDatabaseAsync(new Database { Id = databaseId }).Result;
}
return db;
}
private static async Task<Database> GetDatabase(DocumentClient client)
{
Database database = client.CreateDatabaseQuery().Where(c => c.Id == "SchoolRegistry").AsEnumerable().FirstOrDefault();
if (database == null)
{
database = await client.CreateDatabaseAsync(new Database() { Id = "SchoolRegistry" });
}
return database;
}
private static async Task GetStartedDemo()
{
// Create a new instance of the DocumentClient
var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey);
// Check to verify a database with the id=FamilyRegistry does not exist
Database database = client.CreateDatabaseQuery().Where(db => db.Id == "FamilyRegistry").AsEnumerable().FirstOrDefault();
// If the database does not exist, create a new database
if (database == null)
{
database = await client.CreateDatabaseAsync(
new Database
{
Id = "FamilyRegistry"
});
WriteMessage("Created dbs/FamilyRegistry");
}
// Check to verify a document collection with the id=FamilyCollection does not exist
DocumentCollection documentCollection = client.CreateDocumentCollectionQuery("dbs/" + database.Id).Where(c => c.Id == "FamilyCollection").AsEnumerable().FirstOrDefault();
// If the document collection does not exist, create a new collection
if (documentCollection == null)
{
documentCollection = await client.CreateDocumentCollectionAsync("dbs/" + database.Id,
new DocumentCollection
{
Id = "FamilyCollection"
});
WriteMessage("Created dbs/FamilyRegistry/colls/FamilyCollection");
}
// Check to verify a document with the id=AndersenFamily does not exist
Document document = client.CreateDocumentQuery("dbs/" + database.Id + "/colls/" + documentCollection.Id).Where(d => d.Id == "AndersenFamily").AsEnumerable().FirstOrDefault();
// If the document does not exist, create a new document
if (document == null)
{
// Create the Andersen Family document
Family andersonFamily = new Family
{
Id = "AndersenFamily",
LastName = "Andersen",
Parents = new Parent[] {
new Parent { FirstName = "Thomas" },
new Parent { FirstName = "Mary Kay"}
},
Children = new Child[] {
new Child
{
FirstName = "Henriette Thaulow",
Gender = "female",
Grade = 5,
Pets = new Pet[] {
new Pet { GivenName = "Fluffy" }
}
}
},
Address = new Address { State = "WA", County = "King", City = "Seattle" },
IsRegistered = true
};
// id based routing for the first argument, "dbs/FamilyRegistry/colls/FamilyCollection"
await client.CreateDocumentAsync("dbs/" + database.Id + "/colls/" + documentCollection.Id, andersonFamily);
WriteMessage("Created dbs/FamilyRegistry/colls/FamilyCollection/docs/AndersenFamily");
}
// Check to verify a document with the id=AndersenFamily does not exist
document = client.CreateDocumentQuery("dbs/" + database.Id + "/colls/" + documentCollection.Id).Where(d => d.Id == "WakefieldFamily").AsEnumerable().FirstOrDefault();
if (document == null)
{
// Create the WakeField document
Family wakefieldFamily = new Family
{
Id = "WakefieldFamily",
Parents = new Parent[] {
new Parent { FamilyName= "Wakefield", FirstName= "Robin" },
new Parent { FamilyName= "Miller", FirstName= "Ben" }
},
Children = new Child[] {
new Child {
FamilyName= "Merriam",
FirstName= "Jesse",
Gender= "female",
Grade= 8,
Pets= new Pet[] {
new Pet { GivenName= "Goofy" },
new Pet { GivenName= "Shadow" }
}
},
new Child {
FamilyName= "Miller",
FirstName= "Lisa",
Gender= "female",
Grade= 1
}
},
Address = new Address { State = "NY", County = "Manhattan", City = "NY" },
IsRegistered = false
};
// id based routing for the first argument, "dbs/FamilyRegistry/colls/FamilyCollection"
await client.CreateDocumentAsync("dbs/" + database.Id + "/colls/" + documentCollection.Id, wakefieldFamily);
WriteMessage("Created dbs/FamilyRegistry/colls/FamilyCollection/docs/WakefieldFamily");
}
// Query the documents using DocumentDB SQL for the Andersen family
var families = client.CreateDocumentQuery("dbs/" + database.Id + "/colls/" + documentCollection.Id,
"SELECT * " +
"FROM Families f " +
"WHERE f.id = \"AndersenFamily\"");
foreach (var family in families)
{
Console.WriteLine("\tRead {0} from SQL", family);
}
// Query the documents using LINQ for the Andersen family
families =
from f in client.CreateDocumentQuery("dbs/" + database.Id + "/colls/" + documentCollection.Id)
where f.Id == "AndersenFamily"
select f;
foreach (var family in families)
{
Console.WriteLine("Read {0} from LINQ", family);
}
// Query the documents using LINQ lambdas for the Andersen family
families = client.CreateDocumentQuery("dbs/" + database.Id + "/colls/" + documentCollection.Id)
.Where(f => f.Id == "AndersenFamily")
.Select(f => f);
foreach (var family in families)
{
Console.WriteLine("\tRead {0} from LINQ query", family);
}
// Clean up/delete the database and client
await client.DeleteDatabaseAsync("dbs/" + database.Id);
client.Dispose();
}
static int Main(string[] args)
{
Options options = new Options();
if (!CommandLine.Parser.Default.ParseArguments(args, options))
{
Console.WriteLine("Invalid arguments");
return 1;
}
using (DocumentClient client = new DocumentClient(
new Uri(options.Endpoint),
options.AuthKey,
new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }))
{
Database database = client.CreateDatabaseQuery().Where(d => d.Id == options.Database).AsEnumerable().FirstOrDefault();
if (database == null)
{
Console.WriteLine("Cannot find database " + options.Database);
return 2;
}
List<DocumentCollection> collections = client.ReadDocumentCollectionFeedAsync(database.SelfLink).Result.ToList();
int minimumRequiredCollections = Math.Max(options.NewCollections, options.CurrentCollections);
if (collections.Count < minimumRequiredCollections)
{
Console.WriteLine("At least {0} collections must be pre-created", minimumRequiredCollections);
return 3;
}
Console.WriteLine("Current distribution of documents across collections:");
LogDocumentCountsPerCollection(client, database).Wait();
Console.WriteLine();
HashPartitionResolver currentPartitionResolver = new HashPartitionResolver(options.PartitionKeyName, collections.Take(options.CurrentCollections).Select(c => c.SelfLink));
HashPartitionResolver nextPartitionResolver = new HashPartitionResolver(options.PartitionKeyName, collections.Take(options.NewCollections).Select(c => c.SelfLink));
int numberOfMovedDocuments = 0;
Parallel.ForEach(currentPartitionResolver.CollectionLinks, collectionLink =>
{
ResourceFeedReader<Document> feedReader = client.CreateDocumentFeedReader(collectionLink, new FeedOptions { MaxItemCount = -1 });
while (feedReader.HasMoreResults)
{
foreach (Document document in DocumentClientHelper.ExecuteWithRetryAsync<FeedResponse<Document>>(() => feedReader.ExecuteNextAsync()).Result)
{
object partitionKey = nextPartitionResolver.GetPartitionKey(document);
string newCollectionLink = nextPartitionResolver.ResolveForCreate(partitionKey);
if (newCollectionLink != collectionLink)
{
int count = Interlocked.Increment(ref numberOfMovedDocuments);
DocumentClientHelper.ExecuteWithRetryAsync(() => client.DeleteDocumentAsync(document.SelfLink)).Wait();
DocumentClientHelper.ExecuteWithRetryAsync(() => client.CreateDocumentAsync(newCollectionLink, document)).Wait();
if (count % 100 == 0)
{
Console.WriteLine("Moved {0} documents between partitions", numberOfMovedDocuments);
}
}
}
}
});
Console.WriteLine();
Console.WriteLine("Moved {0} documents between partitions.", numberOfMovedDocuments);
Console.WriteLine();
Console.WriteLine("Current distribution of documents across collections:");
LogDocumentCountsPerCollection(client, database).Wait();
Console.WriteLine();
}
return 0;
}
public IdeaRepo(string endpoint, string authKey)
{
_client = new DocumentClient(new Uri(endpoint), authKey);
_database = _client.CreateDatabaseQuery().Where(db => db.Id == "Idea").AsEnumerable().FirstOrDefault();
}
/// <summary>
/// Internal Member to Get or Create an Azure DocumentDB
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private async Task<Database> GetOrCreateDatabaseAsync(DocumentClient client)
{
Database database = client.CreateDatabaseQuery().Where(db => db.Id == this.Container).ToArray().FirstOrDefault();
if (database == null)
{
database = await client.CreateDatabaseAsync(new Database { Id = this.Container });
Log.Info("AzureDocDbRequestManager.GetOrCreateDatabaseAsync", "Created Document DB {0}", this.Container);
}
return database;
}
public static async Task<Database> GetDB(DocumentClient client, string name)
{
Database database = client.CreateDatabaseQuery().Where(db => db.Id == name)
.AsEnumerable().FirstOrDefault();
/*?? await client.CreateDatabaseAsync(
new Database
{
Id = "LMSRegistry"
});*/
Console.WriteLine(database.SelfLink);
return database;
}
