public DatabaseNode(DocumentClient localclient, Database db) { Text = db.Id; Tag = db; _client = localclient; ImageKey = "SystemFeed"; SelectedImageKey = "SystemFeed"; Nodes.Add(new UsersNode(_client)); MenuItem myMenuItem3 = new MenuItem("Read Database"); myMenuItem3.Click += new EventHandler(myMenuItemReadDatabase_Click); _contextMenu.MenuItems.Add(myMenuItem3); MenuItem myMenuItem = new MenuItem("Delete Database"); myMenuItem.Click += new EventHandler(myMenuItemDeleteDatabase_Click); _contextMenu.MenuItems.Add(myMenuItem); _contextMenu.MenuItems.Add("-"); MenuItem myMenuItem2 = new MenuItem("Create DocumentCollection"); myMenuItem2.Click += new EventHandler(myMenuItemAddDocumentCollection_Click); _contextMenu.MenuItems.Add(myMenuItem2); MenuItem myMenuItem4 = new MenuItem("Refresh DocumentCollections Feed"); myMenuItem4.Click += new EventHandler((sender, e) => Refresh(true)); _contextMenu.MenuItems.Add(myMenuItem4); }
static DocumentCollection FindDocumentCollection(DocumentClient client, Database database, string name) { return client.CreateDocumentCollectionQuery(database.SelfLink) .Where(x => x.Id == name) .ToList() .SingleOrDefault(); }
/// <summary> /// Check to verify a database with the id=FamilyRegistry does not exist /// If the database does not exist, create a new database /// </summary> /// <returns>Database object</returns> private static async Task<Database> CreateDatabaseAsync() { Database database = client .CreateDatabaseQuery() .Where(db => db.Id == "FamilyRegistry") .AsEnumerable() .FirstOrDefault(); if (database == null) { database = await client.CreateDatabaseAsync( new Database { Id = "FamilyRegistry" }); // Write the new database's id to the console Console.WriteLine("{0} created!", database.Id); Console.WriteLine("Press any key to continue ..."); Console.ReadKey(); Console.Clear(); } return database; }
/// <summary> /// Initialize a HashPartitionResolver. /// </summary> /// <param name="partitionKeyPropertyName">The property name to be used as the partition Key.</param> /// <param name="client">The DocumentDB client instance to use.</param> /// <param name="database">The database to run the samples on.</param> /// <param name="collectionNames">The names of collections used.</param> /// <returns>The created HashPartitionResolver.</returns> public static async Task<HashPartitionResolver> InitializeHashResolver(string partitionKeyPropertyName, DocumentClient client, Database database, string[] collectionNames) { // Set local to input. string[] CollectionNames = collectionNames; int numCollectionNames = CollectionNames.Length; // Create array of DocumentCollections. DocumentCollection[] collections = new DocumentCollection[numCollectionNames]; // Create string array of Self Links to Collections. string[] selfLinks = new string[numCollectionNames]; //Create some collections to partition data. for (int i = 0; i < numCollectionNames; i++) { collections[i] = await DocumentClientHelper.GetCollectionAsync(client, database, CollectionNames[i]); selfLinks[i] = collections[i].SelfLink; } // Join Self Link Array into a comma separated string. string selfLinkString = String.Join(", ", selfLinks); //Initialize a partition resolver that users hashing, and register with DocumentClient. //Uses User Id for PartitionKeyPropertyName, could also be TenantId, or any other variable. HashPartitionResolver hashResolver = new HashPartitionResolver(partitionKeyPropertyName, new[] { selfLinkString }); client.PartitionResolvers[database.SelfLink] = hashResolver; return hashResolver; }
//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, }); } }
public static void Main(string[] args) { try { //Instantiate a new DocumentClient instance using (client = new DocumentClient(new Uri(endpointUrl), authorizationKey, connectionPolicy)) { //Get, or Create, a reference to Database database = GetOrCreateDatabaseAsync(databaseId).Result; //Do operations on Collections RunCollectionDemo().Wait(); } } catch (DocumentClientException de) { Exception baseException = de.GetBaseException(); Console.WriteLine("{0} error occurred: {1}, Message: {2}", de.StatusCode, de.Message, baseException.Message); } catch (Exception e) { Exception baseException = e.GetBaseException(); Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message); } finally { Console.WriteLine("End of demo, press any key to exit."); Console.ReadKey(); } }
private static DocumentCollection GetDocumentCollection(DocumentClient client, Database database, string collectionId) { return client.CreateDocumentCollectionQuery(database.SelfLink) .Where(c => c.Id == collectionId) .AsEnumerable() .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.. } }
private static async Task<DocumentCollection> CreateDocumentCollection(DocumentClient client, Database database, string collectionId) { var collectionSpec = new DocumentCollection { Id = collectionId }; var requestOptions = new RequestOptions { OfferType = "S1" }; return await client.CreateDocumentCollectionAsync(database.SelfLink, collectionSpec, requestOptions); }
public static async Task<HttpStatusCode> CreateCollection(DocumentClient client, Database database, string collectionName) { var result = await client.CreateDocumentCollectionAsync(database.CollectionsLink, new DocumentCollection { Id = collectionName }); return result.StatusCode; }
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(); }
// create or return a collection on a database public static async Task<DocumentCollection> GetCollection(Database database, string collName) { if (client.CreateDocumentCollectionQuery(database.SelfLink).Where(coll => coll.Id == collName).ToArray().Any()) { return client.CreateDocumentCollectionQuery(database.SelfLink).Where(coll => coll.Id == collName).ToArray().FirstOrDefault(); } return await client.CreateDocumentCollectionAsync(database.SelfLink, new DocumentCollection { Id = collName }); }
private async Task<Database> InitializeAsync(string databaseName) { if(this._database == null) { this._database = await this._dbClient.Initialize(databaseName); } return this._database; }
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(); }
public async Task<Database> Initialize() { if(this._database == null) { this._database = await this._dbClient.Initialize(this._databasename); } return this._database; }
private static DocumentCollection GetDocumentCollection(DocumentClient client, Database database) { var documentCollection = client .CreateDocumentCollectionQuery(database.CollectionsLink) .Where(c => c.Id == "Documents") .AsEnumerable() .FirstOrDefault(); return documentCollection; }
protected void Setup() { _client = CreateClient(); _database = CreateDatabase(); var collection = CreateCollection(_database.SelfLink); AddDocuments(collection.SelfLink); DbSet = new DbSet<Widget>(_client, _database.ResourceId, collection.ResourceId); }
private static async Task ReadOrCreateDatabase() { _database = Client.CreateDatabaseQuery().Where(o => o.Id == _databaseId).AsEnumerable().FirstOrDefault(); if (_database == null) { _database = await Client.CreateDatabaseAsync(new Database {Id = _databaseId}); } }
public async Task<Database> GetDatabase() { if (_database == null) { _database = await GetDatabase(_config["DocumentDatabase"]); } return _database; }
private async void ChangeCosmosRu(string databaseAccount, string primaryKey, string databasename, Collection coll, int pkr, double averageRu) { try { var endPointUrl = $"https://{databaseAccount}.documents.azure.cn:443"; var documentClient = new DocumentClient(new Uri(endPointUrl), primaryKey); Microsoft.Azure.Documents.Database database = await GetOrCreateDatabaseAsync(documentClient, databasename); DocumentCollection collection = await GetOrCreateCollectionAsync(documentClient, database.SelfLink, coll.Name); Offer offer = documentClient.CreateOfferQuery() .Where(r => r.ResourceLink == collection.SelfLink) .AsEnumerable() .SingleOrDefault(); int offerThroughput = JsonConvert.DeserializeObject <dynamic>(offer.ToString()).content.offerThroughput; //当前设置的RU var currentThroughput = pkr * averageRu; //当前实时RU var ruRate = Math.Round(currentThroughput / offerThroughput, 2); //计算实时RU和设置的RU占 if ((ruRate - coll.IncreaseRate >= coll.ThresholdRate || ruRate + coll.IncreaseRate < coll.ThresholdRate) && currentThroughput > 1000) { var newOfferThroughput = Convert.ToInt32(currentThroughput / coll.ThresholdRate); //保证RU为阈值左右 var increaseValue = Math.Abs(newOfferThroughput - currentThroughput); //计算调整RU的差值 if (increaseValue > 100) { newOfferThroughput = newOfferThroughput - newOfferThroughput % 100 + 100; if (newOfferThroughput < coll.DefaultValue) { newOfferThroughput = coll.DefaultValue; } offer = new OfferV2(offer, newOfferThroughput); Console.WriteLine(databasename + "-" + coll.Name + ",当前设置" + offerThroughput + "RU" + ",当前消耗" + currentThroughput + "RU" + ",调整设置为" + newOfferThroughput + "RU"); await documentClient.ReplaceOfferAsync(offer); } else { Console.WriteLine(databasename + "-" + coll.Name + ",当前设置" + offerThroughput + "RU" + ",当前消耗" + currentThroughput + "RU" + ",无需调整设置,调整幅度最小为100RU"); } } else { Console.WriteLine(databasename + "-" + coll.Name + ",当前设置" + offerThroughput + "RU" + ",当前消耗" + currentThroughput + "RU" + ",无需调整设置"); } } catch (Exception ex) { string sErrorMsg = ex.Message; if (ex.InnerException != null) { sErrorMsg += ex.InnerException.Message; } Console.WriteLine("ChangeCosmosRU-" + sErrorMsg); } }
//SELECT C.id AS CourseId, C.Name AS CourseName //from CourseCollection AS C //Join Session IN C.Sessions //WHERE Session.Name = "Introduction" #region Helpers private static async Task<DocumentCollection> GetDocumentCollection(DocumentClient client, Database database) { DocumentCollection documentCollection = client.CreateDocumentCollectionQuery(database.CollectionsLink).Where(c => c.Id == "CourseCollection").AsEnumerable().FirstOrDefault(); if (documentCollection == null) { documentCollection = await client.CreateDocumentCollectionAsync(database.CollectionsLink, new DocumentCollection() { Id = "CourseCollection" }); } return documentCollection; }
private async Task<DocumentCollection> CreateCollectionAsync(Microsoft.Azure.Documents.Database db) { var containerId = RandomName(); var containerResponse = await _client.CreateDocumentCollectionAsync( db.AltLink, new DocumentCollection { Id = containerId, PartitionKey = new PartitionKeyDefinition{ Paths = new Collection<string>{ "/PartitionKey" } } }); return containerResponse.Resource; }
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; }
private async Task CreateDatabaseIfNotExistsAsync(string databaseName) { _database = (await _client.ReadDatabaseFeedAsync()) .SingleOrDefault(d => d.Id == databaseName); if (_database == null) _database = await _client.CreateDatabaseAsync(new Database { Id = databaseName }); }
static void Main(string[] args) { try { _documentDbClient = new Db.Client.DocumentClient( new Uri(ConfigurationManager.AppSettings["DocumentDbUri"]), ConfigurationManager.AppSettings["DocumentDbKey"]); _documentDatabase = _documentDbClient.CreateDatabaseQuery() .Where(db => db.Id == DatabaseStore).AsEnumerable().FirstOrDefault(); //Create database and collection if not present CreateDatabaseIfNotExistsAsync().Wait(); //Create Seed Data CreateDocumentsAsync(_customerCollection.SelfLink).Wait(); //Query inserted customers QueryAllDocuments(_customerCollection.SelfLink); //Query subdocuments(orders) QueryWithSubdocuments(_customerCollection.SelfLink); //Query all customer first and last name with order number with amount greate than $300.00 QueryWithTwoJoinsAndFilter(_customerCollection.SelfLink); //Create partitions InitializeRangeResolverAsync().Wait(); //Run queries agianst different partitions and see where the documents are stored QueryPartitionAsync().Wait(); //Update and delete the document UpdateAndDeleteDocumentAsync().Wait(); } catch (Db.DocumentClientException de) { var baseException = de.GetBaseException(); Console.WriteLine("{0} error occurred: {1}, Message: {2}", de.StatusCode, de.Message, baseException.Message); } catch (Exception e) { var baseException = e.GetBaseException(); Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message); } finally { //Cleanup CleanUpAsync().Wait(); Console.WriteLine("End of demo, press any key to exit."); Console.ReadKey(); } }
/// <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 async Task InitClient() { _client = new DocumentClient(new Uri(Uri), Key); _database = await _client.GetDatabase("reportdb"); _documentCollection = await _client.GetCollection(_database, "reports"); if (HasReports() == false) { await CreateDummyReportsAsync(); } }
/// <summary> /// Initializes a new instance of the <see cref="DocumentClientHashPartitioningManager"/> class. /// </summary> /// <param name="partitionKeyExtractor">The partition key extractor function.</param> /// <param name="client">The DocumentDB client instance.</param> /// <param name="database">The database to partition.</param> /// <param name="initialPartitionCount">The number of initial partitions to create.</param> /// <param name="readMode">The mode to process requests in during data migrations.</param> public DocumentClientHashPartitioningManager( Func<object, string> partitionKeyExtractor, DocumentClient client, Database database, int initialPartitionCount, TransitionReadMode readMode = TransitionReadMode.ReadBoth) { this.Client = client; this.Database = database; this.Client.PartitionResolvers[database.SelfLink] = new ManagedHashPartitionResolver(partitionKeyExtractor, client, database, initialPartitionCount); this.ReadMode = readMode; }
public SpeakerAzureDocDbRepository(Settings settings) { _settings = settings; _client = new DocumentClient(new Uri(endpointUrl), authorizationKey); //Get, or Create, the Database _database = GetOrCreateDatabaseAsync(databaseId).Result; //Get, or Create, the Document Collection _collection = GetOrCreateCollectionAsync(_database.SelfLink, collectionId).Result; }
/// <summary> /// Initialize a RangePartitionResolver. /// </summary> /// <param name="partitionKeyPropertyName">The property name to be used as the partition Key.</param> /// <param name="client">The DocumentDB client instance to use.</param> /// <param name="database">The database to run the samples on.</param> /// <param name="collectionNames">The names of collections used.</param> /// <returns>The created HashPartitionResolver.</returns> public static async Task<RangePartitionResolver<string>> InitializeRangeResolver(string partitionKeyPropertyName, DocumentClient client, Database database, string[] collectionNames) { // Set local to input. string[] CollectionNames = collectionNames; int numCollectionNames = CollectionNames.Length; // Create array of DocumentCollections. DocumentCollection[] collections = new DocumentCollection[numCollectionNames]; // Create string array of Self Links to Collections. string[] selfLinks = new string[numCollectionNames]; //Create some collections to partition data. for (int i = 0; i < numCollectionNames; i++) { collections[i] = await DocumentClientHelper.GetCollectionAsync(client, database, CollectionNames[i]); selfLinks[i] = collections[i].SelfLink; } // Join Self Link Array into a comma separated string. string selfLinkString = String.Join(", ", selfLinks); // If each collection represents a range, it will have both a start and end point in its range, thus there are 2 rangeNames for each collection. string[] rangeNames = new string[numCollectionNames * 2]; // Keeping track of where in the rangeNames array to add a new start/end of a range. int currentRangePosition = 0; for (int y = 0; y < numCollectionNames; y++) { string[] rangeTemp = collectionNames[y].Split('-'); for (int z = 0; z < rangeTemp.Length; z++) { rangeNames[currentRangePosition] = rangeTemp[z]; currentRangePosition++; } } // Dictionary needed to input into RangePartitionResolver with corresponding range and collection self link. Dictionary<Range<string>, string> rangeCollections = new Dictionary<Range<string>, string>(); // TO DO:: Iterate through the ranges and add then to rangeCollections with the appropriate start/end point, with the corresponding collection self link. //rangeCollections.Add() RangePartitionResolver<string> rangeResolver = new RangePartitionResolver<string>( partitionKeyPropertyName, rangeCollections); client.PartitionResolvers[database.SelfLink] = rangeResolver; return rangeResolver; }
public async Task ClearDatabaseAsync() { var db = _client.CreateDatabaseQuery() .Where(d => d.Id == DBID) .AsEnumerable() .FirstOrDefault(); // If the database does not exist, create a new database if (db != null) { await _client.DeleteDatabaseAsync(DatabaseLink); _database = null; } }
public CosmosRepositoryBase(string collectionId) { this.docCollectionId = collectionId; this.cosmosClient = new DocumentClient(new Uri(EndpointUrl), PrimaryKey); this.database = new Database() { Id = databaseId }; this.database = this.cosmosClient.CreateDatabaseIfNotExistsAsync(database).Result; this.docCollection = new DocumentCollection() { Id = docCollectionId }; this.docCollection = this.cosmosClient.CreateDocumentCollectionIfNotExistsAsync("dbs/" + databaseId, docCollection).Result; }
private async Task CreateDatabase() { // Check to verify a database with the id=FamilyRegistry does not exist database = this.client.CreateDatabaseQuery().Where(db => db.Id == "Survey").AsEnumerable().FirstOrDefault(); // If the database does not exist, create a new database if (database == null) { database = await client.CreateDatabaseAsync( new Database { Id = "Survey" }); } }
private static async Task CreateDatabaseIfNotExistsAsync() { #region Db if (_documentDatabase == null) { _documentDatabase = await _documentDbClient.CreateDatabaseAsync(new Db.Database { Id = DatabaseStore }); } #endregion #region Customer Collection if (_customerCollection == null) { // dbs/MyDatabaseId/colls/MyCollectionId/docs/MyDocumentId _customerCollection = _documentDbClient.CreateDocumentCollectionQuery("dbs/" + _documentDatabase.Id) .Where(c => c.Id == CustomerCollectionName) .AsEnumerable() .FirstOrDefault(); // ReSharper disable once ConvertIfStatementToNullCoalescingExpression if (_customerCollection == null) { _customerCollection = await _documentDbClient.CreateDocumentCollectionAsync("dbs/" + _documentDatabase.Id, new Db.DocumentCollection { Id = CustomerCollectionName, IndexingPolicy = { Automatic = true, IndexingMode = Db.IndexingMode.Lazy } }, new Db.Client.RequestOptions { OfferType = "S1" }); } } #endregion }
private static async Task <Uri> RunDemoAsync(string databaseId, string collectionId, bool addSuffix) { Microsoft.Azure.Documents.Database database = await client.CreateDatabaseIfNotExistsAsync( new Microsoft.Azure.Documents.Database { Id = databaseId }); DocumentCollection collection = await GetOrCreateCollectionAsync(databaseId, collectionId); Uri collectionUri = UriFactory.CreateDocumentCollectionUri(databaseId, collectionId); // await CreateDocuments(collectionUri, addSuffix); return(collectionUri); // await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(databaseId)); }
/// <summary> ///If DB is not avaliable in Cosmos DB create DB /// </summary> private Database GetOrCreateDatabase(string databaseName) { var client = GetOrCreateClient(); lock (this) { if (_database == null) { _database = client.CreateDatabaseQuery().Where(d => d.Id == databaseName).AsEnumerable().FirstOrDefault(); if (_database == null) { client.CreateDatabaseAsync(new Microsoft.Azure.Documents.Database { Id = databaseName }, null) .ContinueWith(t => _database = t.Result);; } } return(_database); } }
private async Task ConnectAsync() { _lockMutex.WaitOne(); if (_client == null) { IsConnected = false; if (string.IsNullOrEmpty(ConnectionUrl)) { throw new ArgumentNullException(nameof(ConnectionUrl)); } if (string.IsNullOrWhiteSpace(ConnectionKey)) { throw new ArgumentNullException(nameof(ConnectionKey)); } if (string.IsNullOrWhiteSpace(DatabaseName)) { throw new ArgumentNullException(nameof(DatabaseName)); } try { _client = new DocumentClient(new Uri(ConnectionUrl), ConnectionKey); _database = await GetOrCreateDatabaseAsync(DatabaseName); IsConnected = true; } catch (DocumentClientException de) { var baseException = de.GetBaseException(); Debug.WriteLine("{0} error occurred: {1}, Message: {2}", de.StatusCode, de.Message, baseException.Message); _client = null; } catch (Exception e) { var baseException = e.GetBaseException(); Debug.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message); _client = null; } } _lockMutex.ReleaseMutex(); }
/// <summary> /// Create users the specified database. /// </summary> /// <param name="db">The database.</param> /// <param name="dbuser">Name of the user.</param> /// <param name="allowUpdate">if set to <c>true</c> [allow updates].</param> /// <returns> /// The Resource Response /// </returns> private async Task <Microsoft.Azure.Documents.User> CreateUserAsync(Microsoft.Azure.Documents.Database db, User dbuser, bool allowUpdate) { ResourceResponse <Microsoft.Azure.Documents.User> response = null; try { this.logger.Info("Checking whether {0} user exists or not", dbuser.Name); var existingUser = this.client.CreateUserQuery(db.UsersLink).Where(x => x.Id == dbuser.Name).AsEnumerable().SingleOrDefault(); if (existingUser == null) { this.logger.Info("{0} User doesn't exist. Creating it", dbuser.Name); response = await this.client.CreateUserAsync(db.SelfLink, new Microsoft.Azure.Documents.User() { Id = dbuser.Name }).ConfigureAwait(false); } else if (allowUpdate) { this.logger.Info("{0} User exists, Updating it", dbuser.Name); response = await this.client.ReplaceUserAsync(existingUser).ConfigureAwait(false); } else { this.logger.Info("{0} user exists. Skipping update", dbuser.Name); response = new ResourceResponse <Microsoft.Azure.Documents.User>(existingUser); } } catch (Exception exception) { this.logger.Error("An exception occured in {0} user creation/update with the error :{1} ", dbuser.Name, exception.StackTrace); throw; } if (response != null) { return(response.Resource); } return(null); }
private async Task EnsureDatabaseCreated(string databaseName) { var dbNameToUse = Configuration.DatabaseName.GetValueOrDefault(databaseName); // Create new database DatabaseV3 = await CosmosClient.CreateDatabaseIfNotExistsAsync(dbNameToUse); DatabaseUri = UriFactory.CreateDatabaseUri(dbNameToUse); Logger?.LogDebug($"Database URI: {DatabaseUri}"); Database = new Microsoft.Azure.Documents.Database { Id = databaseName }; Logger?.LogDebug($"Database: {Database}"); Logger.LogDebug($"Ensuring `{Database.Id}` exists..."); var result = DocumentClient.CreateDatabaseIfNotExistsAsync(Database).Result; Logger.LogDebug($"{Database.Id} Creation Results: {result.StatusCode}"); if (result.StatusCode.EqualsOne(HttpStatusCode.Created, HttpStatusCode.OK)) { Database = result.Resource; } }
private async Task<Microsoft.Azure.Documents.Database> CreateDatabaseAsync() { var db = new Microsoft.Azure.Documents.Database { Id = RandomName() }; var response = await _client.CreateDatabaseAsync(db); return response.Resource; }
public async Task <IEnumerable <string> > buildDB() { var results = new List <string>(); Microsoft.Azure.Documents.Database database = await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "graphdb" }); DocumentCollection graph = await client.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri("graphdb"), new DocumentCollection { Id = "Persons" }, new RequestOptions { OfferThroughput = 400 }); Dictionary <string, string> gremlinQueries = new Dictionary <string, string> { { "Cleanup", "g.V().drop()" }, { "AddAdam", "g.addV('person').property('id', 'Adam').property('Name', 'Adam')" }, { "AddEve", "g.addV('person').property('id', 'Eve').property('Name', 'Eve')" }, { "AddCain", "g.addV('person').property('id', 'Cain').property('Name', 'Cain')" }, { "AddAbel", "g.addV('person').property('id', 'Abel').property('Name', 'Abel')" }, { "AddSeth", "g.addV('person').property('id', 'Seth').property('Name', 'Seth')" }, { "AddEnosh", "g.addV('person').property('id', 'Enosh').property('Name', 'Enosh')" }, { "AddAdam+Eve", "g.V('Adam').addE('Married').to(g.V('Eve'))" }, { "AddCain->Abel", "g.V('Cain').addE('Brother').to(g.V('Abel'))" }, { "AddCain->Seth", "g.V('Cain').addE('Brother').to(g.V('Seth'))" }, { "AddAbel->Seth", "g.V('Abel').addE('Brother').to(g.V('Seth'))" }, { "AddEve->Abel", "g.V('Eve').addE('Mother').to(g.V('Abel'))" }, { "AddEve->Cain", "g.V('Eve').addE('Mother').to(g.V('Cain'))" }, { "AddEve->Seth", "g.V('Eve').addE('Mother').to(g.V('Seth'))" }, { "AddAdam->Abel", "g.V('Adam').addE('Father').to(g.V('Abel'))" }, { "AddAdam->Cain", "g.V('Adam').addE('Father').to(g.V('Cain'))" }, { "AddAdam->Seth", "g.V('Adam').addE('Father').to(g.V('Seth'))" }, { "AddSeth->Enosh", "g.V('Seth').addE('Father').to(g.V('Enosh'))" }, { "UpdateAbel1", "g.V('Abel').property('Profession', 'Shepherd')" }, { "UpdateCain1", "g.V('Cain').property('Profession', 'Farmer')" }, { "UpdateAdam", "g.V('Adam').property('Max Age', '930').property('Born', '4026 BCE').property('Died', '3096 BCE').property('Name Means', 'Earthling Man; Mankind; Humankind; from a root meaning \"red\"')" }, { "UpdateAdamFatherAge", "g.V('Adam').outE('Father').as('e').inV().has('Name', 'Seth').select('e').property('Age', '130')" } }; foreach (KeyValuePair <string, string> gremlinQuery in gremlinQueries) { results.Add($"Running {gremlinQuery.Key}: {gremlinQuery.Value}"); // The CreateGremlinQuery method extensions allow you to execute Gremlin queries and iterate // results asychronously IDocumentQuery <dynamic> query = client.CreateGremlinQuery <dynamic>(graph, gremlinQuery.Value); while (query.HasMoreResults) { foreach (dynamic result in await query.ExecuteNextAsync()) { results.Add($"\t {JsonConvert.SerializeObject(result)}"); } } results.Add(""); } return(results); }
/// <summary> /// Driver function for bulk import. /// </summary> /// <returns></returns> private async Task RunBulkImportAsync() { // Cleanup on start if set in config. DocumentCollection dataCollection = null; try { if (bool.Parse(ConfigurationManager.AppSettings["ShouldCleanupOnStart"])) { Microsoft.Azure.Documents.Database database = Utils.GetDatabaseIfExists(client, DatabaseName); if (database != null) { await client.DeleteDatabaseAsync(database.SelfLink); } Trace.TraceInformation("Creating database {0}", DatabaseName); database = await client.CreateDatabaseAsync(new Microsoft.Azure.Documents.Database { Id = DatabaseName }); Trace.TraceInformation(String.Format("Creating collection {0} with {1} RU/s", CollectionName, CollectionThroughput)); dataCollection = await Utils.CreatePartitionedCollectionAsync(client, DatabaseName, CollectionName, CollectionThroughput); } else { dataCollection = Utils.GetCollectionIfExists(client, DatabaseName, CollectionName); if (dataCollection == null) { throw new Exception("The data collection does not exist"); } } } catch (Exception de) { Trace.TraceError("Unable to initialize, exception message: {0}", de.Message); throw; } // Prepare for bulk import. // Creating documents with simple partition key here. string partitionKeyProperty = dataCollection.PartitionKey.Paths[0].Replace("/", ""); long numberOfDocumentsToGenerate = long.Parse(ConfigurationManager.AppSettings["NumberOfDocumentsToImport"]); int numberOfBatches = int.Parse(ConfigurationManager.AppSettings["NumberOfBatches"]); long numberOfDocumentsPerBatch = (long)Math.Floor(((double)numberOfDocumentsToGenerate) / numberOfBatches); // Set retry options high for initialization (default values). client.ConnectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = 30; client.ConnectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = 9; IBulkExecutor bulkExecutor = new BulkExecutor(client, dataCollection); await bulkExecutor.InitializeAsync(); // Set retries to 0 to pass control to bulk executor. client.ConnectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = 0; client.ConnectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = 0; BulkImportResponse bulkImportResponse = null; long totalNumberOfDocumentsInserted = 0; double totalRequestUnitsConsumed = 0; double totalTimeTakenSec = 0; var tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; for (int i = 0; i < numberOfBatches; i++) { // Generate JSON-serialized documents to import. List <string> documentsToImportInBatch = new List <string>(); long prefix = i * numberOfDocumentsPerBatch; Trace.TraceInformation(String.Format("Generating {0} documents to import for batch {1}", numberOfDocumentsPerBatch, i)); for (int j = 0; j < numberOfDocumentsPerBatch; j++) { string partitionKeyValue = (prefix + j).ToString(); string id = partitionKeyValue + Guid.NewGuid().ToString(); } // Invoke bulk import API. var tasks = new List <Task>(); tasks.Add(Task.Run(async() => { Trace.TraceInformation(String.Format("Executing bulk import for batch {0}", i)); do { try { bulkImportResponse = await bulkExecutor.BulkImportAsync( documents: documentsToImportInBatch, enableUpsert: true, disableAutomaticIdGeneration: true, maxConcurrencyPerPartitionKeyRange: null, maxInMemorySortingBatchSize: null, cancellationToken: token); } catch (DocumentClientException de) { Trace.TraceError("Document client exception: {0}", de); break; } catch (Exception e) { Trace.TraceError("Exception: {0}", e); break; } } while (bulkImportResponse.NumberOfDocumentsImported < documentsToImportInBatch.Count); Trace.WriteLine(String.Format("\nSummary for batch {0}:", i)); Trace.WriteLine("--------------------------------------------------------------------- "); Trace.WriteLine(String.Format("Inserted {0} docs @ {1} writes/s, {2} RU/s in {3} sec", bulkImportResponse.NumberOfDocumentsImported, Math.Round(bulkImportResponse.NumberOfDocumentsImported / bulkImportResponse.TotalTimeTaken.TotalSeconds), Math.Round(bulkImportResponse.TotalRequestUnitsConsumed / bulkImportResponse.TotalTimeTaken.TotalSeconds), bulkImportResponse.TotalTimeTaken.TotalSeconds)); Trace.WriteLine(String.Format("Average RU consumption per document: {0}", (bulkImportResponse.TotalRequestUnitsConsumed / bulkImportResponse.NumberOfDocumentsImported))); Trace.WriteLine("---------------------------------------------------------------------\n "); totalNumberOfDocumentsInserted += bulkImportResponse.NumberOfDocumentsImported; totalRequestUnitsConsumed += bulkImportResponse.TotalRequestUnitsConsumed; totalTimeTakenSec += bulkImportResponse.TotalTimeTaken.TotalSeconds; }, token)); /* * tasks.Add(Task.Run(() => * { * char ch = Console.ReadKey(true).KeyChar; * if (ch == 'c' || ch == 'C') * { * tokenSource.Cancel(); * Trace.WriteLine("\nTask cancellation requested."); * } * })); */ await Task.WhenAll(tasks); } Trace.WriteLine("Overall summary:"); Trace.WriteLine("--------------------------------------------------------------------- "); Trace.WriteLine(String.Format("Inserted {0} docs @ {1} writes/s, {2} RU/s in {3} sec", totalNumberOfDocumentsInserted, Math.Round(totalNumberOfDocumentsInserted / totalTimeTakenSec), Math.Round(totalRequestUnitsConsumed / totalTimeTakenSec), totalTimeTakenSec)); Trace.WriteLine(String.Format("Average RU consumption per document: {0}", (totalRequestUnitsConsumed / totalNumberOfDocumentsInserted))); Trace.WriteLine("--------------------------------------------------------------------- "); // Cleanup on finish if set in config. if (bool.Parse(ConfigurationManager.AppSettings["ShouldCleanupOnFinish"])) { Trace.TraceInformation("Deleting Database {0}", DatabaseName); await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName)); } Trace.WriteLine("\nPress any key to exit."); Console.ReadKey(); }
/// <summary> /// Creates the collection. /// </summary> /// <param name="db">The database.</param> /// <param name="collection">The collection</param> /// <param name="allowUpdate">if set to <c>true</c> [allow updates].</param> /// <returns> /// The Resource Response for collection /// </returns> /// <exception cref="InvalidOperationException">Document collection partition key cannot be changed.</exception> private async Task <DocumentCollection> CreateCollectionAsync(Microsoft.Azure.Documents.Database db, Collection collection, bool allowUpdate) { ResourceResponse <DocumentCollection> response = null; this.logger.Info("Checking whether {0} collection exists or not", collection.Name); var existingColl = this.client.CreateDocumentCollectionQuery(db.SelfLink).Where(x => x.Id == collection.Name).AsEnumerable().SingleOrDefault(); this.logger.Info("Initializing {0} collection", collection.Name); var documentCollection = new DocumentCollection { Id = collection.Name, DefaultTimeToLive = collection.Ttl }; // Setting up Partition Key if (collection.Partitioned && !string.IsNullOrEmpty(collection.PartitionKey)) { this.logger.Info("Setting up Partition Key for the {0} collection", collection.Name); documentCollection.PartitionKey = new PartitionKeyDefinition(); documentCollection.PartitionKey.Paths.Add(collection.PartitionKey); } // Excluded Paths foreach (var path in collection.ExcludedPaths) { this.logger.Info("Setting up excluded paths for the {0} collection", collection.Name); var excludedPaths = new ExcludedPath() { Path = path }; documentCollection.IndexingPolicy.ExcludedPaths.Add(excludedPaths); } // Included Paths foreach (var path in collection.IncludedPaths) { this.logger.Info("Setting up included path {0} for the {1} collection", path, collection.Name); var includedPaths = new IncludedPath() { Path = path }; documentCollection.IndexingPolicy.IncludedPaths.Add(includedPaths); } // Range Index Path foreach (var path in collection.RangeIndexIncludedPaths) { this.logger.Info("Setting up range included path {0} for the {1} collection", path, collection.Name); var includedPaths = new IncludedPath() { Path = path, Indexes = new System.Collections.ObjectModel.Collection <Index> { new RangeIndex(DataType.String) { Precision = -1 } } }; documentCollection.IndexingPolicy.IncludedPaths.Add(includedPaths); } documentCollection.IndexingPolicy.IndexingMode = this.GetIndexingMode(collection.IndexingMode); if (existingColl == null) { this.logger.Info("{0} Collection doesn't exist, Creating it", collection.Name); response = await this.client.CreateDocumentCollectionAsync(db.SelfLink, documentCollection, new RequestOptions { OfferThroughput = collection.ResourceUnits }).ConfigureAwait(false); } else if (allowUpdate) { this.logger.Info("{0} Collection exists, Updating the collection", collection.Name); var validationResult = ValidatePartitionKey(existingColl.PartitionKey, documentCollection.PartitionKey); if (validationResult) { existingColl.PartitionKey = documentCollection.PartitionKey; } else { throw new InvalidOperationException("Document collection partition key cannot be changed."); } existingColl.IndexingPolicy = documentCollection.IndexingPolicy; response = await this.client.ReplaceDocumentCollectionAsync(existingColl).ConfigureAwait(false); this.logger.Info("Updating throughput of the collection"); var offer = this.client.CreateOfferQuery().Where(t => t.ResourceLink == existingColl.SelfLink).AsEnumerable().SingleOrDefault(); if (offer != null) { offer = new OfferV2(offer, collection.ResourceUnits); await this.client.ReplaceOfferAsync(offer).ConfigureAwait(false); } } else { this.logger.Info("{0} Collection exists. Skipping update", collection.Name); response = new ResourceResponse <DocumentCollection>(existingColl); } if (response != null) { return(response.Resource); } return(null); }