public async Task QuerySinglePartitionItemStreamTest(int perPKItemCount, int maxItemCount)
{
IList <ToDoActivity> deleteList = deleteList = await this.CreateRandomItems(pkCount : 3, perPKItemCount : perPKItemCount, randomPartitionKey : true);
ToDoActivity find = deleteList.First();
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
int iterationCount = 0;
int totalReadItem = 0;
int expectedIterationCount = perPKItemCount / maxItemCount;
string lastContinuationToken = null;
do
{
iterationCount++;
CosmosResultSetIterator setIterator = this.Container.Items
.CreateItemQueryAsStream(sql, 1, find.status,
maxItemCount: maxItemCount,
continuationToken: lastContinuationToken,
requestOptions: new CosmosQueryRequestOptions());
using (CosmosQueryResponse response = await setIterator.FetchNextSetAsync())
{
lastContinuationToken = response.ContinuationToken;
Trace.TraceInformation($"ContinuationToken: {lastContinuationToken}");
JsonSerializer serializer = new JsonSerializer();
using (StreamReader sr = new StreamReader(response.Content))
using (JsonTextReader jtr = new JsonTextReader(sr))
{
ToDoActivity[] results = serializer.Deserialize <ToDoActivity[]>(jtr);
ToDoActivity[] readTodoActivities = results.OrderBy(e => e.id)
.ToArray();
ToDoActivity[] expectedTodoActivities = deleteList
.Where(e => e.status == find.status)
.Where(e => readTodoActivities.Any(e1 => e1.id == e.id))
.OrderBy(e => e.id)
.ToArray();
totalReadItem += expectedTodoActivities.Length;
string expectedSerialized = JsonConvert.SerializeObject(expectedTodoActivities);
string readSerialized = JsonConvert.SerializeObject(readTodoActivities);
Trace.TraceInformation($"Expected: {Environment.NewLine} {expectedSerialized}");
Trace.TraceInformation($"Read: {Environment.NewLine} {readSerialized}");
int count = results.Length;
Assert.AreEqual(maxItemCount, count);
Assert.AreEqual(expectedSerialized, readSerialized);
Assert.AreEqual(maxItemCount, expectedTodoActivities.Length);
}
}
}while (lastContinuationToken != null);
Assert.AreEqual(expectedIterationCount, iterationCount);
Assert.AreEqual(perPKItemCount, totalReadItem);
}
public async Task IteratorTest()
{
string sprocBody = "function() { { var x = 42; } }";
int numberOfSprocs = 3;
string[] sprocIds = new string[numberOfSprocs];
for (int i = 0; i < numberOfSprocs; i++)
{
string sprocId = Guid.NewGuid().ToString();
sprocIds[i] = sprocId;
CosmosStoredProcedureResponse storedProcedureResponse =
await this.container.StoredProcedures.CreateStoredProceducreAsync(sprocId, sprocBody);
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
}
List <string> readSprocIds = new List <string>();
CosmosResultSetIterator <CosmosStoredProcedureSettings> iter = this.container.StoredProcedures.GetStoredProcedureIterator();
while (iter.HasMoreResults)
{
CosmosQueryResponse <CosmosStoredProcedureSettings> currentResultSet = await iter.FetchNextSetAsync();
{
foreach (CosmosStoredProcedureSettings storedProcedureSettingsEntry in currentResultSet)
{
readSprocIds.Add(storedProcedureSettingsEntry.Id);
}
}
}
CollectionAssert.AreEquivalent(sprocIds, readSprocIds);
}
private static async Task <SalesOrder> QueryItems()
{
//******************************************************************************************************************
// 1.4 - Query for items by a property other than Id
//
// NOTE: Operations like AsEnumerable(), ToList(), ToArray() will make as many trips to the database
// as required to fetch the entire result-set. Even if you set MaxItemCount to a smaller number.
// MaxItemCount just controls how many results to fetch each trip.
// If you don't want to fetch the full set of results, then use CreateItemQuery().AsItemQuery()
// For more on this please refer to the Queries project.
//
// NOTE: If you want to get the RU charge for a query you also need to use CreateItemQuery().AsItemQuery()
// and check the RequestCharge property of this IQueryable response
// Once again, refer to the Queries project for more information and examples of this
//******************************************************************************************************************
Console.WriteLine("\n1.4 - Querying for a item using its AccountNumber property");
CosmosSqlQueryDefinition query = new CosmosSqlQueryDefinition(
"select * from sales s where s.AccountNumber = @AccountInput ")
.UseParameter("@AccountInput", "Account1");
CosmosResultSetIterator <SalesOrder> resultSet = container.Items.CreateItemQuery <SalesOrder>(
query, maxConcurrency: 1,
maxItemCount: 1);
while (resultSet.HasMoreResults)
{
SalesOrder sale = (await resultSet.FetchNextSetAsync()).First();
Console.WriteLine($"Account Number: {sale.AccountNumber}; Id: {sale.Id} ");
return(sale);
}
throw new ArgumentNullException("No Sale order found by query");
}
public async Task VerifyCosmosDefaultResultSetStreamIteratorOperationType()
{
CosmosClient mockClient = MockDocumentClient.CreateMockCosmosClient();
CosmosDatabase database = new CosmosDatabase(mockClient, "database");
CosmosContainer container = new CosmosContainer(database, "container");
CosmosItems item = new CosmosItems(container);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator setIterator = item
.CreateItemQueryAsStream(sql, "pk", requestOptions: new CosmosQueryRequestOptions());
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
15, //OperationType.SqlQuery
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
mockClient.CosmosConfiguration.UseConnectionModeDirect();
CosmosResponseMessage response = await setIterator.FetchNextSetAsync();
testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
14, //OperationType.Query
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
mockClient.CosmosConfiguration.UseConnectionModeGateway();
response = await setIterator.FetchNextSetAsync();
}
private static async Task QueryItemsInPartitionAsStreams(CosmosContainer container)
{
// SQL
CosmosResultSetIterator setIterator = container.Items.CreateItemQueryAsStream("SELECT F.id, F.LastName, F.IsRegistered FROM Families F", partitionKey: "Anderson", maxItemCount: 1);
int count = 0;
while (setIterator.HasMoreResults)
{
using (CosmosResponseMessage response = await setIterator.FetchNextSetAsync())
{
response.EnsureSuccessStatusCode();
count++;
using (StreamReader sr = new StreamReader(response.Content))
using (JsonTextReader jtr = new JsonTextReader(sr))
{
JsonSerializer jsonSerializer = new JsonSerializer();
dynamic items = jsonSerializer.Deserialize <dynamic>(jtr);
Assert("Expected one family", items.Documents.Count == 1);
dynamic item = items.Documents[0];
Assert($"Expected LastName: Anderson Actual: {item.LastName}", string.Equals("Anderson", item.LastName.ToString(), StringComparison.InvariantCulture));
}
}
}
Assert("Expected 1 family", count == 1);
}
public bool MoveNext()
{
if (_underlyingEnumerator == null)
{
if (_query == null)
{
_query = _cosmosClient.CreateQuery <JObject>(_containerId, _cosmosSqlQuery);
}
if (!_query.HasMoreResults)
{
Current = default;
return(false);
}
_underlyingEnumerator = _query.FetchNextSetAsync().GetAwaiter().GetResult().GetEnumerator();
}
var hasNext = _underlyingEnumerator.MoveNext();
if (hasNext)
{
Current = (JObject)_underlyingEnumerator.Current.First.First;
return(true);
}
_underlyingEnumerator.Dispose();
_underlyingEnumerator = null;
return(MoveNext());
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (_underlyingEnumerator == null)
{
if (_query == null)
{
_query = _cosmosClient.CreateQuery <JObject>(_containerId, _cosmosSqlQuery);
}
if (!_query.HasMoreResults)
{
Current = default;
return(false);
}
_underlyingEnumerator = (await _query.FetchNextSetAsync(cancellationToken)).GetEnumerator();
}
var hasNext = _underlyingEnumerator.MoveNext();
if (hasNext)
{
Current = (JObject)_underlyingEnumerator.Current.First.First;
return(true);
}
_underlyingEnumerator.Dispose();
_underlyingEnumerator = null;
return(await MoveNext(cancellationToken));
}
public async Task ItemIterator()
{
IList <ToDoActivity> deleteList = null;
HashSet <string> itemIds = null;
try
{
deleteList = await CreateRandomItems(3, randomPartitionKey : true);
itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.GetItemIterator <ToDoActivity>();
while (setIterator.HasMoreResults)
{
foreach (ToDoActivity toDoActivity in await setIterator.FetchNextSetAsync(this.cancellationToken))
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
Assert.AreEqual(itemIds.Count, 0);
}
public async Task IteratorTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
HashSet <string> containerIds = new HashSet <string>();
CosmosResultSetIterator <CosmosContainerSettings> resultSet = this.cosmosDatabase.Containers.GetContainerIterator();
while (resultSet.HasMoreResults)
{
foreach (CosmosContainerSettings setting in await resultSet.FetchNextSetAsync())
{
if (!containerIds.Contains(setting.Id))
{
containerIds.Add(setting.Id);
}
}
}
Assert.IsTrue(containerIds.Count > 0, "The iterator did not find any containers.");
Assert.IsTrue(containerIds.Contains(containerName), "The iterator did not find the created container");
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task ValidateMaxItemCountOnItemQuery()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(6, randomPartitionKey : false);
ToDoActivity toDoActivity = deleteList.First();
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition(
"select * from toDoActivity t where t.status = @status")
.UseParameter("@status", toDoActivity.status);
// Test max size at 1
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.CreateItemQuery <ToDoActivity>(sql, toDoActivity.status, maxItemCount: 1);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <ToDoActivity> iter = await setIterator.FetchNextSetAsync();
Assert.AreEqual(1, iter.Count());
}
// Test max size at 2
CosmosResultSetIterator <ToDoActivity> setIteratorMax2 =
this.Container.Items.CreateItemQuery <ToDoActivity>(sql, toDoActivity.status, maxItemCount: 2);
while (setIteratorMax2.HasMoreResults)
{
CosmosQueryResponse <ToDoActivity> iter = await setIteratorMax2.FetchNextSetAsync();
Assert.AreEqual(2, iter.Count());
}
}
public async Task ItemMultiplePartitionQuery()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(3, randomPartitionKey : true);
ToDoActivity find = deleteList.First();
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from toDoActivity t where t.id = '" + find.id + "'");
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
MaxBufferedItemCount = 10,
ResponseContinuationTokenLimitInKb = 500
};
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.CreateItemQuery <ToDoActivity>(sql, maxConcurrency: 1, maxItemCount: 1, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <ToDoActivity> iter = await setIterator.FetchNextSetAsync();
Assert.AreEqual(1, iter.Count());
ToDoActivity response = iter.First();
Assert.AreEqual(find.id, response.id);
}
}
public async Task ItemMultiplePartitionOrderByQueryStream()
{
IList <ToDoActivity> deleteList = new List <ToDoActivity>();
try
{
deleteList = await CreateRandomItems(300, randomPartitionKey : true);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("SELECT * FROM toDoActivity t ORDER BY t.taskNum ");
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
MaxBufferedItemCount = 10,
ResponseContinuationTokenLimitInKb = 500
};
List <ToDoActivity> resultList = new List <ToDoActivity>();
double totalRequstCharge = 0;
CosmosResultSetIterator setIterator =
this.Container.Items.CreateItemQueryAsStream(sql, maxConcurrency: 5, maxItemCount: 1, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
using (CosmosQueryResponse iter = await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(iter.IsSuccess);
Assert.IsNull(iter.ErrorMessage);
Assert.IsTrue(iter.Count <= 5);
totalRequstCharge += iter.RequestCharge;
ToDoActivity response = this.jsonSerializer.FromStream <ToDoActivity[]>(iter.Content).First();
resultList.Add(response);
}
}
Assert.AreEqual(deleteList.Count, resultList.Count);
Assert.IsTrue(totalRequstCharge > 0);
List <ToDoActivity> verifiedOrderBy = deleteList.OrderBy(x => x.taskNum).ToList();
for (int i = 0; i < verifiedOrderBy.Count(); i++)
{
Assert.AreEqual(verifiedOrderBy[i].taskNum, resultList[i].taskNum);
Assert.AreEqual(verifiedOrderBy[i].id, resultList[i].id);
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
}
/// <summary>
/// The function demonstrates migrating documents that were inserted without a value for partition key, and those inserted
/// pre-migration to other logical partitions, those with a value for partition key.
/// </summary>
private static async Task MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(CosmosContainer container)
{
// Pre-create a few items in the container to demo the migration
const int ItemsToCreate = 4;
// Insert a few items with no Partition Key
for (int i = 0; i < ItemsToCreate; i++)
{
string itemid = Guid.NewGuid().ToString();
DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid);
CosmosItemResponse <DeviceInformationItem> createResponse = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
item : itemWithoutPK);
}
// Query items on the container that have no partition key value by supplying NonePartitionKeyValue
// The operation is made in batches to not lose work in case of partial execution
int resultsFetched = 0;
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator <DeviceInformationItem> setIterator = container.Items
.CreateItemQuery <DeviceInformationItem>(sql, partitionKey: CosmosContainerSettings.NonePartitionKeyValue, maxItemCount: 2);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <DeviceInformationItem> queryResponse = await setIterator.FetchNextSetAsync();
resultsFetched += queryResponse.Count();
// For the items returned with NonePartitionKeyValue
IEnumerator <DeviceInformationItem> iter = queryResponse.GetEnumerator();
while (iter.MoveNext())
{
DeviceInformationItem item = iter.Current;
if (item.DeviceId != null)
{
// Using existing deviceID for partition key
item.PartitionKey = item.DeviceId;
Console.WriteLine("Migrating item {0} to Partition {1}", item.Id, item.DeviceId);
// Re-Insert into container with a partition key
// This could result in exception if the same item was inserted in a previous run of the program on existing container
// and the program stopped before the delete.
CosmosItemResponse <DeviceInformationItem> createResponseWithPk = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : item.PartitionKey,
item : item);
// Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
CosmosItemResponse <DeviceInformationItem> deleteResponseWithoutPk = await container.Items.DeleteItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : item.Id);
}
}
}
}
public static async Task <List <T> > ToList <T>(this CosmosResultSetIterator <T> queryResultSetIterator)
{
var results = new List <T>();
while (queryResultSetIterator.HasMoreResults)
{
var currentResultSet = await queryResultSetIterator.FetchNextSetAsync();
results.AddRange(currentResultSet);
}
return(results);
}
/// <summary>
/// List the container within a database by calling the GetContainerIterator (scan) API.
/// </summary>
/// <returns></returns>
private static async Task ListContainersInDatabase()
{
Console.WriteLine("\n5. Reading all CosmosContainer resources for a database");
CosmosResultSetIterator <CosmosContainerSettings> resultSetIterator = database.Containers.GetContainerIterator();
while (resultSetIterator.HasMoreResults)
{
foreach (CosmosContainerSettings container in await resultSetIterator.FetchNextSetAsync())
{
Console.WriteLine(container.Id);
}
}
}
public async Task ValidateUserDefinedFunctionsTest()
{
// Prevent failures if previous test did not clean up correctly
await this.container.UserDefinedFunctions["calculateTax"].DeleteAsync();
ToDoActivity item = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
cost = 9001,
description = "udf_test_item",
status = "Done",
taskNum = 1
};
await this.container.Items.CreateItemAsync <ToDoActivity>(item.status, item);
CosmosUserDefinedFunction cosmosUserDefinedFunction = await this.container.UserDefinedFunctions.CreateUserDefinedFunctionAsync(
new CosmosUserDefinedFunctionSettings
{
Id = "calculateTax",
Body = @"function(amt) { return amt * 0.05; }"
});
CosmosSqlQueryDefinition sqlQuery = new CosmosSqlQueryDefinition(
"SELECT t.id, t.status, t.cost, udf.calculateTax(t.cost) as total FROM toDoActivity t where t.cost > @expensive and t.status = @status")
.UseParameter("@expensive", 9000)
.UseParameter("@status", "Done");
CosmosResultSetIterator <dynamic> setIterator = this.container.Items.CreateItemQuery <dynamic>(
sqlQueryDefinition: sqlQuery,
partitionKey: "Done");
HashSet <string> iterIds = new HashSet <string>();
while (setIterator.HasMoreResults)
{
foreach (var response in await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(response.cost > 9000);
Assert.AreEqual(response.cost * .05, response.total);
iterIds.Add(response.id.Value);
}
}
Assert.IsTrue(iterIds.Count > 0);
Assert.IsTrue(iterIds.Contains(item.id));
// Delete existing user defined functions.
await cosmosUserDefinedFunction.DeleteAsync();
}
public async Task ItemQueryStreamSerializationSetting()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(101, randomPartitionKey : true);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("SELECT * FROM toDoActivity t ORDER BY t.taskNum");
CosmosSerializationOptions options = new CosmosSerializationOptions(
ContentSerializationFormat.CosmosBinary.ToString(),
(content) => JsonNavigator.Create(content),
() => JsonWriter.Create(JsonSerializationFormat.Binary));
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
CosmosSerializationOptions = options
};
List <ToDoActivity> resultList = new List <ToDoActivity>();
double totalRequstCharge = 0;
CosmosResultSetIterator setIterator =
this.Container.Items.CreateItemQueryAsStream(sql, maxConcurrency: 5, maxItemCount: 5, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
using (CosmosQueryResponse iter = await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(iter.IsSuccess);
Assert.IsNull(iter.ErrorMessage);
Assert.IsTrue(iter.Count <= 5);
totalRequstCharge += iter.RequestCharge;
IJsonReader reader = JsonReader.Create(iter.Content);
IJsonWriter textWriter = JsonWriter.Create(JsonSerializationFormat.Text);
textWriter.WriteAll(reader);
string json = Encoding.UTF8.GetString(textWriter.GetResult());
Assert.IsNotNull(json);
ToDoActivity[] responseActivities = JsonConvert.DeserializeObject <ToDoActivity[]>(json);
resultList.AddRange(responseActivities);
}
}
Assert.AreEqual(deleteList.Count, resultList.Count);
Assert.IsTrue(totalRequstCharge > 0);
List <ToDoActivity> verifiedOrderBy = deleteList.OrderBy(x => x.taskNum).ToList();
for (int i = 0; i < verifiedOrderBy.Count(); i++)
{
Assert.AreEqual(verifiedOrderBy[i].taskNum, resultList[i].taskNum);
Assert.AreEqual(verifiedOrderBy[i].id, resultList[i].id);
}
}
/// <summary>
/// Run basic database meta data operations as a console application.
/// </summary>
/// <returns></returns>
private static async Task RunDatabaseDemo(CosmosClient client)
{
// An object containing relevant information about the response
CosmosDatabaseResponse databaseResponse = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId, 10000);
// A client side reference object that allows additional operations like ReadAsync
CosmosDatabase database = databaseResponse;
// The response from Azure Cosmos
CosmosDatabaseSettings settings = databaseResponse;
Console.WriteLine($"\n1. Create a database resource with id: {settings.Id} and last modified time stamp: {settings.LastModified}");
Console.WriteLine($"\n2. Create a database resource request charge: {databaseResponse.RequestCharge} and Activity Id: {databaseResponse.ActivityId}");
// Read the database from Azure Cosmos
CosmosDatabaseResponse readResponse = await database.ReadAsync();
Console.WriteLine($"\n3. Read a database: {readResponse.Resource.Id}");
await readResponse.Database.Containers.CreateContainerAsync("testContainer", "/pk");
// Get the current throughput for the database
int?throughput = await database.ReadProvisionedThroughputAsync();
if (throughput.HasValue)
{
Console.WriteLine($"\n4. Read a database throughput: {throughput.Value}");
// Update the current throughput for the database
await database.ReplaceProvisionedThroughputAsync(11000);
}
Console.WriteLine("\n5. Reading all databases resources for an account");
CosmosResultSetIterator <CosmosDatabaseSettings> iterator = client.Databases.GetDatabaseIterator();
do
{
foreach (CosmosDatabaseSettings db in await iterator.FetchNextSetAsync())
{
Console.WriteLine(db.Id);
}
} while (iterator.HasMoreResults);
// Delete the database from Azure Cosmos.
await database.DeleteAsync();
Console.WriteLine($"\n6. Database {database.Id} deleted.");
}
/*
* Run a query (using Azure Cosmos DB SQL syntax) against the container
*/
public async Task <List <MoviesModel> > GetAllMovies()
{
List <MoviesModel> movies = new List <MoviesModel>();
// SQL
CosmosResultSetIterator <MoviesModel> setIterator = movieContainer.Items.GetItemIterator <MoviesModel>(maxItemCount: 1);
while (setIterator.HasMoreResults)
{
foreach (MoviesModel item in await setIterator.FetchNextSetAsync())
{
movies.Add(item);
}
}
return(movies);
}
public async Task VerifyCosmosDefaultResultSetStreamIteratorOperationType()
{
CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeDirect());
CosmosContainer container = mockClient.Databases["database"].Containers["container"];
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator setIterator = container.Items.CreateItemQueryAsStream(
sqlQueryDefinition: sql,
maxConcurrency: 1,
partitionKey: "pk",
requestOptions: new CosmosQueryRequestOptions());
TestHandler testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
15, //OperationType.SqlQuery
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
CosmosQueryResponse response = await setIterator.FetchNextSetAsync();
//Test gateway mode
mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeGateway());
container = mockClient.Databases["database"].Containers["container"];
setIterator = container.Items.CreateItemQueryAsStream(
sqlQueryDefinition: sql,
maxConcurrency: 1,
partitionKey: "pk",
requestOptions: new CosmosQueryRequestOptions());
testHandler = new TestHandler((request, cancellationToken) => {
Assert.AreEqual(
14, //OperationType.Query
(int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null)
);
return(TestHandler.ReturnSuccess());
});
mockClient.RequestHandler.InnerHandler = testHandler;
response = await setIterator.FetchNextSetAsync();
}
private static async Task ItemFeed(CosmosContainer container)
{
List <Family> families = new List <Family>();
// SQL
CosmosResultSetIterator <Family> setIterator = container.Items.GetItemIterator <Family>(maxItemCount: 1);
while (setIterator.HasMoreResults)
{
int count = 0;
foreach (Family item in await setIterator.FetchNextSetAsync())
{
Assert("Should only return 1 result at a time.", count <= 1);
families.Add(item);
}
}
Assert("Expected two families", families.ToList().Count == 2);
}
private static async Task QueryWithSqlParameters(CosmosContainer container)
{
// Query using two properties within each item. WHERE Id == "" AND Address.City == ""
// notice here how we are doing an equality comparison on the string value of City
CosmosSqlQueryDefinition query = new CosmosSqlQueryDefinition("SELECT * FROM Families f WHERE f.id = @id AND f.Address.City = @city")
.UseParameter("@id", "AndersonFamily")
.UseParameter("@city", "Seattle");
List <Family> results = new List <Family>();
CosmosResultSetIterator <Family> resultSetIterator = container.Items.CreateItemQuery <Family>(query, partitionKey: "Anderson");
while (resultSetIterator.HasMoreResults)
{
results.AddRange((await resultSetIterator.FetchNextSetAsync()));
}
Assert("Expected only 1 family", results.Count == 1);
}
public async Task <IList <Ad> > GetAdsAsync()
{
List <Ad> ads = new List <Ad>();
try
{
var response = await cache.StringGetAsync("1").ConfigureAwait(false);
if (String.IsNullOrEmpty(response))
{
var sqlQueryText = "SELECT * FROM c WHERE c.MessageType = 'AD'";
var partitionKeyValue = "AD"; // Message type
CosmosSqlQueryDefinition queryDefinition = new CosmosSqlQueryDefinition(sqlQueryText);
CosmosResultSetIterator <Ad> queryResultSetIterator = container.Items.CreateItemQuery <Ad>(queryDefinition, partitionKeyValue);
while (queryResultSetIterator.HasMoreResults)
{
CosmosQueryResponse <Ad> currentResultSet = await queryResultSetIterator.FetchNextSetAsync();
ads.AddRange(currentResultSet);
}
await cache.StringSetAsync("1", JsonConvert.SerializeObject(ads.First()), TimeSpan.FromMinutes(10));
}
else
{
ads.Add(JsonConvert.DeserializeObject <Ad>(response));
}
}
catch (Exception ex) when(ex is RedisConnectionException ||
ex is RedisException ||
ex is RedisCommandException ||
ex is RedisServerException ||
ex is RedisTimeoutException ||
ex is CosmosException ||
ex is TimeoutException)
{
throw new AdRepositoryException("Repository Connection Exception", ex);
}
return(ads);
}
public async Task TriggersIteratorTest()
{
CosmosTrigger cosmosTrigger = await CreateRandomTrigger();
HashSet <string> settings = new HashSet <string>();
CosmosResultSetIterator <CosmosTriggerSettings> iter = this.container.Triggers.GetTriggerIterator();;
while (iter.HasMoreResults)
{
foreach (CosmosTriggerSettings storedProcedureSettingsEntry in await iter.FetchNextSetAsync())
{
settings.Add(storedProcedureSettingsEntry.Id);
}
}
Assert.IsTrue(settings.Contains(cosmosTrigger.Id), "The iterator did not return the user defined function definition.");
// Delete existing user defined functions.
await cosmosTrigger.DeleteAsync();
}
public async Task DatabaseIterator()
{
List <CosmosDatabase> deleteList = new List <CosmosDatabase>();
HashSet <string> databaseIds = new HashSet <string>();
try
{
for (int i = 0; i < 3; i++)
{
CosmosDatabaseResponse createResponse = await this.CreateDatabaseHelper();
deleteList.Add(createResponse.Database);
databaseIds.Add(createResponse.Resource.Id);
}
CosmosResultSetIterator <CosmosDatabaseSettings> setIterator =
this.cosmosClient.Databases.GetDatabaseIterator();
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <CosmosDatabaseSettings> iterator =
await setIterator.FetchNextSetAsync(this.cancellationToken);
foreach (CosmosDatabaseSettings databaseSettings in iterator)
{
if (databaseIds.Contains(databaseSettings.Id))
{
databaseIds.Remove(databaseSettings.Id);
}
}
}
}
finally
{
foreach (CosmosDatabase database in deleteList)
{
await database.DeleteAsync(cancellationToken : this.cancellationToken);
}
}
Assert.AreEqual(0, databaseIds.Count);
}
public async Task ValidateMaxItemCountOnItemQuery()
{
IList <ToDoActivity> deleteList = new List <ToDoActivity>();
HashSet <string> itemIds = new HashSet <string>();
try
{
deleteList = await CreateRandomItems(6, randomPartitionKey : false);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from toDoActivity t where t.taskNum = @task").UseParameter("@task", deleteList.First().taskNum);
// Test max size at 1
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.CreateItemQuery <ToDoActivity>(sql, "TBD", maxItemCount: 1);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <ToDoActivity> iter = await setIterator.FetchNextSetAsync();
Assert.AreEqual(1, iter.Count());
}
// Test max size at 2
CosmosResultSetIterator <ToDoActivity> setIteratorMax2 =
this.Container.Items.CreateItemQuery <ToDoActivity>(sql, "TBD", maxItemCount: 2);
while (setIteratorMax2.HasMoreResults)
{
CosmosQueryResponse <ToDoActivity> iter = await setIteratorMax2.FetchNextSetAsync();
Assert.AreEqual(2, iter.Count());
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
}
public async Task ItemIterator()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(3, randomPartitionKey : true);
HashSet <string> itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
CosmosResultSetIterator <ToDoActivity> setIterator =
this.Container.Items.GetItemIterator <ToDoActivity>();
while (setIterator.HasMoreResults)
{
foreach (ToDoActivity toDoActivity in await setIterator.FetchNextSetAsync(this.cancellationToken))
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
Assert.AreEqual(itemIds.Count, 0);
}
public async Task <GenresModel> GetGenre(string id)
{
var sqlQueryText = ("SELECT * FROM c WHERE c._id = {0}", id).ToString();
var partitionKeyValue = id;
CosmosSqlQueryDefinition queryDefinition = new CosmosSqlQueryDefinition(sqlQueryText);
CosmosResultSetIterator <GenresModel> queryResultSetIterator = this.genreContainer.Items.CreateItemQuery <GenresModel>(queryDefinition, partitionKeyValue);
List <GenresModel> genres = new List <GenresModel>();
while (queryResultSetIterator.HasMoreResults)
{
CosmosQueryResponse <GenresModel> currentResultSet = await queryResultSetIterator.FetchNextSetAsync();
foreach (GenresModel genre in currentResultSet)
{
genres.Add(genre);
}
}
return(genres.FirstOrDefault());
}
public async Task <MoviesModel> GetMovie(string id)
{
var sqlQueryText = "SELECT * FROM c WHERE c._id = '" + id + "'";
var partitionKeyValue = id;
CosmosSqlQueryDefinition queryDefinition = new CosmosSqlQueryDefinition(sqlQueryText);
CosmosResultSetIterator <MoviesModel> queryResultSetIterator = this.movieContainer.Items.CreateItemQuery <MoviesModel>(queryDefinition, partitionKeyValue);
List <MoviesModel> movies = new List <MoviesModel>();
while (queryResultSetIterator.HasMoreResults)
{
CosmosQueryResponse <MoviesModel> currentResultSet = await queryResultSetIterator.FetchNextSetAsync();
foreach (MoviesModel movie in currentResultSet)
{
movies.Add(movie);
}
}
return(movies.FirstOrDefault());
}
/*
* Run a query (using Azure Cosmos DB SQL syntax) against the container
*/
private async Task RunQuery()
{
var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";
var partitionKeyValue = "Andersen";
Console.WriteLine("Running query: {0}\n", sqlQueryText);
CosmosSqlQueryDefinition queryDefinition = new CosmosSqlQueryDefinition(sqlQueryText);
CosmosResultSetIterator <Family> queryResultSetIterator = this.container.Items.CreateItemQuery <Family>(queryDefinition, partitionKeyValue);
List <Family> families = new List <Family>();
while (queryResultSetIterator.HasMoreResults)
{
CosmosQueryResponse <Family> currentResultSet = await queryResultSetIterator.FetchNextSetAsync();
foreach (Family family in currentResultSet)
{
families.Add(family);
Console.WriteLine("\tRead {0}\n", family);
}
}
}
