// </AddItemsToContainerAsync> // <QueryItemsAsync> /// <summary> /// Run a query (using Azure Cosmos DB SQL syntax) against the container /// </summary> private async Task QueryDatabasesAsync() { var sqlQueryText = "SELECT * FROM d"; QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); Console.WriteLine("Running queries: {0}\n", sqlQueryText); Console.WriteLine($"{DateTime.Now:o}: cosmosClient.GetDatabaseQueryStreamIterator-QueryDefinition"); await ExecAndIterateQueryAsync(() => cosmosClient.GetDatabaseQueryStreamIterator(queryDefinition)); Console.WriteLine($"{DateTime.Now:o}: cosmosClient.GetDatabaseQueryStreamIterator-string"); await ExecAndIterateQueryAsync(() => cosmosClient.GetDatabaseQueryStreamIterator(sqlQueryText)); Console.WriteLine($"{DateTime.Now:o}: cosmosClient.GetDatabaseQueryIterator-QueryDefinition"); await ExecAndIterateQueryAsync(() => cosmosClient.GetDatabaseQueryIterator <DatabaseProperties>(queryDefinition)); Console.WriteLine($"{DateTime.Now:o}: cosmosClient.GetDatabaseQueryIterator-string"); await ExecAndIterateQueryAsync(() => cosmosClient.GetDatabaseQueryIterator <DatabaseProperties>(sqlQueryText)); }
/// <summary> /// See https://docs.microsoft.com/en-us/azure/cosmos-db/sql-api-dotnet-v3sdk-samples /// </summary> /// <param name="client"></param> private static void RunDatabaseDemo(CosmosClient client) { // An object containing relevant information about the response DatabaseResponse databaseResponse = client.CreateDatabaseIfNotExistsAsync(databaseId, 400).Result; // A client side reference object that allows additional operations like ReadAsync Database database = databaseResponse; _database = database; // The response from Azure Cosmos DatabaseProperties properties = databaseResponse; Console.WriteLine($"\n1. Create a database resource with id: " + $"{properties.Id} and last modified time stamp: {properties.LastModified}"); Console.WriteLine($"\n2. Create a database resource request charge: " + $"{databaseResponse.RequestCharge} and Activity Id: {databaseResponse.ActivityId}"); // Read the database from Azure Cosmos DatabaseResponse readResponse = database.ReadAsync().Result; Console.WriteLine($"\n3. Read a database: {readResponse.Resource.Id}"); _container = readResponse.Database.CreateContainerAsync("testContainer", "/city").Result; // Get the current throughput for the database int?throughputResponse = database.ReadThroughputAsync().Result; if (throughputResponse.HasValue) { Console.WriteLine($"\n4. Read a database throughput: {throughputResponse}"); // Update the current throughput for the database database.ReplaceThroughputAsync(11000).Wait(); } Console.WriteLine("\n5. Reading all databases resources for an account"); using (FeedIterator <DatabaseProperties> iterator = client.GetDatabaseQueryIterator <DatabaseProperties>()) { while (iterator.HasMoreResults) { foreach (DatabaseProperties db in iterator.ReadNextAsync().Result) { Console.WriteLine(db.Id); } } } // Delete the database from Azure Cosmos. //database.DeleteAsync().Wait(); //Console.WriteLine($"\n6. Database {database.Id} deleted."); }
// </ValidateAllPermissionsForItem> // <ValidateReadPermissions> private static async Task ValidateReadPermissions( string endpoint, string databaseName, Container container, User user) { // Read Permission on container for the user PermissionProperties readPermission = new PermissionProperties( id: "Read", permissionMode: PermissionMode.Read, container: container); PermissionProperties readContainerPermission = await user.CreatePermissionAsync(readPermission); // Create a new client with the generated token using (CosmosClient readClient = new CosmosClient(endpoint, readContainerPermission.Token)) { Container readContainer = readClient.GetContainer(databaseName, container.Id); //try read items should succeed because user1 was granted Read permission on container1 using (FeedIterator <SalesOrder> feedIterator = readContainer.GetItemQueryIterator <SalesOrder>()) { while (feedIterator.HasMoreResults) { FeedResponse <SalesOrder> salesOrders = await feedIterator.ReadNextAsync(); foreach (SalesOrder salesOrder in salesOrders) { Console.WriteLine(JsonConvert.SerializeObject(salesOrder)); } } } //try iterate databases should fail because the user has no Admin rights //but only read access to a single container and therefore //cannot access anything outside of that container. try { using (FeedIterator <DatabaseProperties> databaseIterator = readClient.GetDatabaseQueryIterator <DatabaseProperties>("select T.* from T")) { while (databaseIterator.HasMoreResults) { await databaseIterator.ReadNextAsync(); throw new ApplicationException("Should never get here"); } } } catch (CosmosException ce) when(ce.StatusCode == System.Net.HttpStatusCode.Forbidden) { Console.WriteLine("Database query failed because user has no admin rights"); } } }
private static async Task CleanUp(CosmosClient client) { FeedIterator <DatabaseProperties> allDatabases = client.GetDatabaseQueryIterator <DatabaseProperties>(); while (allDatabases.HasMoreResults) { foreach (DatabaseProperties db in await allDatabases.ReadNextAsync()) { await client.GetDatabase(db.Id).DeleteAsync(); } } }
async Task <IEnumerable <IDatabaseFacade> > ICosmosAccountFacade.GetDatabasesAsync() { var iterator = _client.GetDatabaseQueryIterator <string>("SELECT VALUE d.id FROM d"); var ids = await QueryHelper.GetAllResultsAsync(iterator); var gateways = ids .Content .Select(id => new DatabaseFacade(_client.GetDatabase(id), this, _logger)) .ToArray <IDatabaseFacade>(); return(gateways); }
public async Task Capture_Span_When_List_Databases() { await _agent.Tracer.CaptureTransaction("List CosmosDb Databases", ApiConstants.TypeDb, async () => { var iterator = _client.GetDatabaseQueryIterator<DatabaseProperties>(); while(iterator.HasMoreResults) { foreach (var db in await iterator.ReadNextAsync()) { } } }); AssertSpan("List databases"); }
// Get databases public async Task <IEnumerable <string> > GetDatabasesAsync() { List <string> result = new List <string>(); var iterator = _cosmosClient.GetDatabaseQueryIterator <DatabaseProperties>(); var databases = await iterator.ReadNextAsync(); foreach (var db in databases) { Console.WriteLine($"Database Id: {db.Id}; Modified: {db.LastModified}"); result.Add($"Database Id: {db.Id}; Modified: {db.LastModified}"); } return(result); }
public async Task GetAllDatabases() { string message = "Get all databases"; var queryText = "Select * from c"; using (FeedIterator <DatabaseProperties> feedIterator = _cosmosClient.GetDatabaseQueryIterator <DatabaseProperties>(queryText)) { FeedResponse <DatabaseProperties> response = await feedIterator.ReadNextAsync(); Printer.PrintLine(message: message); foreach (var item in response) { WriteLine($"Database details, Id: {item.Id}, ETag: {item.ETag}, \n\tSelfLink: {item.SelfLink}"); } Printer.PrintLine(noOfTimes: (100 + message.Length)); } }
protected async Task <ContainerProperties?> PruneDatabases(CosmosClient client) { FeedIterator <DatabaseProperties> containerQueryIterator = client.GetDatabaseQueryIterator <DatabaseProperties>("SELECT * FROM c"); while (containerQueryIterator.HasMoreResults) { foreach (DatabaseProperties database in await containerQueryIterator.ReadNextAsync()) { if (database.Id.EndsWith(AcceptanceTestsDatabaseSuffix)) { _logger.LogInformation("Deleting database {DatabaseName}", database.Id); await client.GetDatabase(database.Id).DeleteAsync(); } } } return(null); }
private static async Task ViewDatabases(CosmosClient client) { Console.WriteLine(); Console.WriteLine(">>> View Databases <<<"); var iterator = client.GetDatabaseQueryIterator <DatabaseProperties>(); var databases = await iterator.ReadNextAsync(); var count = 0; foreach (var database in databases) { Console.WriteLine($"Database Id: {database.Id}; Modified: {database.LastModified}"); count++; } Console.WriteLine(); Console.WriteLine($"Total databases: {count}"); }
public static async Task <bool> DeleteDatabaseIfExistsAsync(this CosmosClient client, string databaseName, ILogger logger) { FeedIterator <DatabaseProperties> containerQueryIterator = client.GetDatabaseQueryIterator <DatabaseProperties>("SELECT * FROM c"); while (containerQueryIterator.HasMoreResults) { foreach (DatabaseProperties database in await containerQueryIterator.ReadNextAsync()) { if (database.Id != databaseName) { continue; } logger.LogInformation("Deleting database {DatabaseName}", database.Id); await client.GetDatabase(database.Id).DeleteAsync(); return(true); } } return(false); }
public void VerifySynchronizationContextDoesNotLock() { string databaseId = Guid.NewGuid().ToString(); SynchronizationContext prevContext = SynchronizationContext.Current; try { TestSynchronizationContext syncContext = new TestSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(syncContext); syncContext.Post(_ => { using (CosmosClient client = TestCommon.CreateCosmosClient()) { Cosmos.Database database = client.CreateDatabaseAsync(databaseId).GetAwaiter().GetResult(); database = client.CreateDatabaseIfNotExistsAsync(databaseId).GetAwaiter().GetResult(); database.ReadStreamAsync().ConfigureAwait(false).GetAwaiter().GetResult(); database.ReadAsync().ConfigureAwait(false).GetAwaiter().GetResult(); QueryDefinition databaseQuery = new QueryDefinition("select * from T where T.id = @id").WithParameter("@id", databaseId); FeedIterator <DatabaseProperties> databaseIterator = client.GetDatabaseQueryIterator <DatabaseProperties>(databaseQuery); while (databaseIterator.HasMoreResults) { databaseIterator.ReadNextAsync().GetAwaiter().GetResult(); } Container container = database.CreateContainerAsync(Guid.NewGuid().ToString(), "/pk").GetAwaiter().GetResult(); container = database.CreateContainerIfNotExistsAsync(container.Id, "/pk").GetAwaiter().GetResult(); ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity(); ItemResponse <ToDoActivity> response = container.CreateItemAsync <ToDoActivity>(item: testItem).ConfigureAwait(false).GetAwaiter().GetResult(); Assert.IsNotNull(response); string diagnostics = response.Diagnostics.ToString(); Assert.IsTrue(diagnostics.Contains("SynchronizationContext")); using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); try { ToDoActivity tempItem = ToDoActivity.CreateRandomToDoActivity(); CancellationToken cancellationToken = cancellationTokenSource.Token; cancellationTokenSource.Cancel(); container.CreateItemAsync <ToDoActivity>(item: tempItem, cancellationToken: cancellationToken).ConfigureAwait(false).GetAwaiter().GetResult(); Assert.Fail("Should have thrown a cancellation token"); }catch (CosmosOperationCanceledException oe) { string exception = oe.ToString(); Assert.IsTrue(exception.Contains("SynchronizationContext")); } // Test read feed container.GetItemLinqQueryable <ToDoActivity>( allowSynchronousQueryExecution: true, requestOptions: new QueryRequestOptions() { }).ToList(); FeedIterator feedIterator = container.GetItemLinqQueryable <ToDoActivity>() .ToStreamIterator(); while (feedIterator.HasMoreResults) { feedIterator.ReadNextAsync().GetAwaiter().GetResult(); } FeedIterator <ToDoActivity> feedIteratorTyped = container.GetItemLinqQueryable <ToDoActivity>() .ToFeedIterator <ToDoActivity>(); while (feedIteratorTyped.HasMoreResults) { feedIteratorTyped.ReadNextAsync().GetAwaiter().GetResult(); } // Test query container.GetItemLinqQueryable <ToDoActivity>( allowSynchronousQueryExecution: true, requestOptions: new QueryRequestOptions() { }).Where(item => item.id != "").ToList(); FeedIterator queryIterator = container.GetItemLinqQueryable <ToDoActivity>() .Where(item => item.id != "").ToStreamIterator(); while (queryIterator.HasMoreResults) { queryIterator.ReadNextAsync().GetAwaiter().GetResult(); } FeedIterator <ToDoActivity> queryIteratorTyped = container.GetItemLinqQueryable <ToDoActivity>() .Where(item => item.id != "").ToFeedIterator <ToDoActivity>(); while (queryIteratorTyped.HasMoreResults) { queryIteratorTyped.ReadNextAsync().GetAwaiter().GetResult(); } double costAsync = container.GetItemLinqQueryable <ToDoActivity>() .Select(x => x.cost).SumAsync().GetAwaiter().GetResult(); double cost = container.GetItemLinqQueryable <ToDoActivity>( allowSynchronousQueryExecution: true).Select(x => x.cost).Sum(); ItemResponse <ToDoActivity> deleteResponse = container.DeleteItemAsync <ToDoActivity>(partitionKey: new Cosmos.PartitionKey(testItem.pk), id: testItem.id).ConfigureAwait(false).GetAwaiter().GetResult(); Assert.IsNotNull(deleteResponse); } }, state: null); } finally { SynchronizationContext.SetSynchronizationContext(prevContext); using (CosmosClient client = TestCommon.CreateCosmosClient()) { client.GetDatabase(databaseId).DeleteAsync().GetAwaiter().GetResult(); } } }
public async Task TestQueryWithCustomJsonSerializer() { int toStreamCount = 0; int fromStreamCount = 0; CosmosSerializer serializer = new CosmosSerializerHelper(new Newtonsoft.Json.JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore }, (item) => fromStreamCount++, (item) => toStreamCount++); CosmosClient client = TestCommon.CreateCosmosClient(builder => builder.WithCustomSerializer(serializer)); Database database = await client.CreateDatabaseAsync(Guid.NewGuid().ToString()); try { Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(), "/id"); Assert.AreEqual(0, toStreamCount); Assert.AreEqual(0, fromStreamCount); double cost = 9001.42; for (int i = 0; i < 5; i++) { ToDoActivity toDoActivity = new ToDoActivity() { id = "TestId" + i, cost = cost }; await container.CreateItemAsync <ToDoActivity>(toDoActivity, new PartitionKey(toDoActivity.id)); } Assert.AreEqual(5, toStreamCount); Assert.AreEqual(5, fromStreamCount); toStreamCount = 0; fromStreamCount = 0; QueryDefinition query = new QueryDefinition("select * from T where T.id != @id"). WithParameter("@id", Guid.NewGuid()); FeedIterator <DatabaseProperties> feedIterator = client.GetDatabaseQueryIterator <DatabaseProperties>( query); List <DatabaseProperties> databases = new List <DatabaseProperties>(); while (feedIterator.HasMoreResults) { databases.AddRange(await feedIterator.ReadNextAsync()); } Assert.AreEqual(1, toStreamCount, "parameter should use custom serializer"); Assert.AreEqual(0, fromStreamCount); toStreamCount = 0; fromStreamCount = 0; FeedIterator <ToDoActivity> itemIterator = container.GetItemQueryIterator <ToDoActivity>( query); List <ToDoActivity> items = new List <ToDoActivity>(); while (itemIterator.HasMoreResults) { items.AddRange(await itemIterator.ReadNextAsync()); } Assert.AreEqual(2, toStreamCount); Assert.AreEqual(1, fromStreamCount); toStreamCount = 0; fromStreamCount = 0; // Verify that the custom serializer is actually being used via stream FeedIterator itemStreamIterator = container.GetItemQueryStreamIterator( query); while (itemStreamIterator.HasMoreResults) { ResponseMessage response = await itemStreamIterator.ReadNextAsync(); using (StreamReader reader = new StreamReader(response.Content)) { string content = await reader.ReadToEndAsync(); Assert.IsTrue(content.Contains("9001.42")); Assert.IsFalse(content.Contains("description"), "Description should be ignored and not in the JSON"); } } Assert.AreEqual(2, toStreamCount); Assert.AreEqual(0, fromStreamCount); } finally { if (database != null) { using (await database.DeleteStreamAsync()) { } } } }