// </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()) { }
}
}
}
