public async Task QueryOperationDiagnostic()
{
int totalItems = 3;
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(
this.Container,
pkCount : totalItems,
perPKItemCount : 1,
randomPartitionKey : true);
//Checking query metrics on typed query
long totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity",
expectedItemCount : totalItems);
Assert.AreEqual(totalItems, totalOutputDocumentCount);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity t ORDER BY t.cost",
expectedItemCount : totalItems);
Assert.AreEqual(totalItems, totalOutputDocumentCount);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select DISTINCT t.cost from ToDoActivity t",
expectedItemCount : 1);
Assert.IsTrue(totalOutputDocumentCount >= 1);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity OFFSET 1 LIMIT 1",
expectedItemCount : 1);
Assert.IsTrue(totalOutputDocumentCount >= 1);
}
public async Task ItemLINQWithCamelCaseSerializerOptions(bool isGatewayMode)
{
Action <CosmosClientBuilder> builder = action =>
{
action.WithSerializerOptions(new CosmosSerializationOptions()
{
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase
});
if (isGatewayMode)
{
action.WithConnectionModeGateway();
}
};
CosmosClient camelCaseCosmosClient = TestCommon.CreateCosmosClient(builder, false);
Cosmos.Database database = camelCaseCosmosClient.GetDatabase(this.database.Id);
Container containerFromCamelCaseClient = database.GetContainer(this.Container.Id);
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : containerFromCamelCaseClient, pkCount : 2, perPKItemCount : 1, randomPartitionKey : true);
//Testing query without camelCase CosmosSerializationOptions using this.Container, should not return any result
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(true);
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => item.CamelCase == "camelCase");
string queryText = queriable.ToQueryDefinition().QueryText;
Assert.AreEqual(queriable.Count(), 0);
//Testing query with camelCase CosmosSerializationOptions using containerFromCamelCaseClient, should return all the items
linqQueryable = containerFromCamelCaseClient.GetItemLinqQueryable <ToDoActivity>(true);
queriable = linqQueryable.Where(item => item.CamelCase == "camelCase");
queryText = queriable.ToQueryDefinition().QueryText;
Assert.AreEqual(queriable.Count(), 2);
}
public async Task QueryOperationMutiplePageCrossPartitionTest(ConnectionMode mode)
{
Environment.SetEnvironmentVariable(ClientTelemetryOptions.EnvPropsClientTelemetrySchedulingInSeconds, "20");
ContainerInternal itemsCore = (ContainerInternal)await this.CreateClientAndContainer(
mode : mode,
isLargeContainer : true);
// Verify container has multiple partitions
int pkRangesCount = (await itemsCore.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(itemsCore.LinkUri)).Count;
Assert.IsTrue(pkRangesCount > 1, "Should have created a multi partition container.");
Container container = (Container)itemsCore;
await ToDoActivity.CreateRandomItems(
container : container,
pkCount : 2,
perPKItemCount : 5);
string sqlQueryText = "SELECT * FROM c";
List <object> families = new List <object>();
QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
using (FeedIterator <object> queryResultSetIterator = container.GetItemQueryIterator <object>(
queryDefinition: queryDefinition,
requestOptions: new QueryRequestOptions()
{
MaxItemCount = 1
}))
{
while (queryResultSetIterator.HasMoreResults)
{
FeedResponse <object> currentResultSet = await queryResultSetIterator.ReadNextAsync();
foreach (object family in currentResultSet)
{
families.Add(family);
}
}
}
Assert.AreEqual(10, families.Count);
IDictionary <string, long> expectedRecordCountInOperation = new Dictionary <string, long>
{
{ Documents.OperationType.Query.ToString(), pkRangesCount + 10 }, // 10 is number of items
{ Documents.OperationType.Create.ToString(), 10 }
};
await this.WaitAndAssert(
expectedOperationCount : 4,
expectedOperationRecordCountMap : expectedRecordCountInOperation);
}
public async Task ItemLINQQueryWithContinuationTokenTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
QueryRequestOptions queryRequestOptions = new QueryRequestOptions();
queryRequestOptions.MaxConcurrency = 1;
queryRequestOptions.MaxItemCount = 5;
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(requestOptions: queryRequestOptions);
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => (item.taskNum < 100));
FeedIterator <ToDoActivity> feedIterator = queriable.ToFeedIterator();
int firstItemSet = 0;
string continuationToken = null;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
firstItemSet = feedResponse.Count();
continuationToken = feedResponse.ContinuationToken;
if (firstItemSet > 0)
{
break;
}
}
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(continuationToken: continuationToken, requestOptions: queryRequestOptions);
queriable = linqQueryable.Where(item => (item.taskNum < 100));
feedIterator = queriable.ToFeedIterator();
//Test continuationToken with LINQ query generation and asynchronous feedIterator execution.
int secondItemSet = 0;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
secondItemSet += feedResponse.Count();
}
Assert.AreEqual(10 - firstItemSet, secondItemSet);
//Test continuationToken with blocking LINQ execution
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(allowSynchronousQueryExecution: true, continuationToken: continuationToken, requestOptions: queryRequestOptions);
int linqExecutionItemCount = linqQueryable.Where(item => (item.taskNum < 100)).Count();
Assert.AreEqual(10 - firstItemSet, linqExecutionItemCount);
}
public async Task GatewayQueryPlanDiagnostic()
{
int totalItems = 3;
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(
this.Container,
pkCount : totalItems,
perPKItemCount : 1,
randomPartitionKey : true);
ContainerInternal containerCore = (ContainerInlineCore)this.Container;
MockCosmosQueryClient gatewayQueryPlanClient = new MockCosmosQueryClient(
clientContext: containerCore.ClientContext,
cosmosContainerCore: containerCore,
forceQueryPlanGatewayElseServiceInterop: true);
Container gatewayQueryPlanContainer = new ContainerInlineCore(
containerCore.ClientContext,
(DatabaseInternal)containerCore.Database,
containerCore.Id,
gatewayQueryPlanClient);
QueryRequestOptions queryRequestOptions = new QueryRequestOptions()
{
MaxItemCount = 1,
MaxBufferedItemCount = 0
};
FeedIterator <ToDoActivity> feedIterator = gatewayQueryPlanContainer.GetItemQueryIterator <ToDoActivity>(
"select * from ToDoActivity t ORDER BY t.cost",
requestOptions: queryRequestOptions);
List <ToDoActivity> results = new List <ToDoActivity>();
bool isFirstPage = true;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> response = await feedIterator.ReadNextAsync();
results.AddRange(response);
CosmosDiagnosticsContext diagnosticsContext = (response.Diagnostics as CosmosDiagnosticsCore).Context;
DiagnosticValidator.ValidateQueryGatewayPlanDiagnostics(diagnosticsContext, isFirstPage);
isFirstPage = false;
}
}
public async Task LinqCaseInsensitiveStringTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 2, perPKItemCount : 100, randomPartitionKey : true);
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>();
async Task TestSearch(Expression <Func <ToDoActivity, bool> > expression, string expectedMethod, bool caseInsensitive, int expectedResults)
{
string expectedQueryText = $"SELECT VALUE root FROM root WHERE {expectedMethod}(root[\"description\"], @param1{(caseInsensitive ? ", true" : "")})";
IArgumentProvider arguments = (IArgumentProvider)expression.Body;
string searchString = (arguments.GetArgument(0) as ConstantExpression).Value as string;
IQueryable <ToDoActivity> queryable = linqQueryable.Where(expression);
Dictionary <object, string> parameters = new Dictionary <object, string>();
parameters.Add(searchString, "@param1");
QueryDefinition queryDefinition = queryable.ToQueryDefinition(parameters);
string queryText = queryDefinition.ToSqlQuerySpec().QueryText;
Assert.AreEqual(expectedQueryText, queryText);
Assert.AreEqual(expectedResults, await queryable.CountAsync());
}
await TestSearch(x => x.description.StartsWith("create"), "STARTSWITH", false, 0);
await TestSearch(x => x.description.StartsWith("cReAtE", StringComparison.OrdinalIgnoreCase), "STARTSWITH", true, 200);
await TestSearch(x => x.description.EndsWith("activity"), "ENDSWITH", false, 0);
await TestSearch(x => x.description.EndsWith("AcTiViTy", StringComparison.OrdinalIgnoreCase), "ENDSWITH", true, 200);
await TestSearch(x => x.description.Equals("createrandomtodoactivity", StringComparison.OrdinalIgnoreCase), "STRINGEQUALS", true, 200);
await TestSearch(x => x.description.Contains("todo"), "CONTAINS", false, 0);
await TestSearch(x => x.description.Contains("tOdO", StringComparison.OrdinalIgnoreCase), "CONTAINS", true, 200);
}
public async Task ItemLinqReadFeedTest(bool useStatelessIterator)
{
IList <ToDoActivity> deleteList = await ToDoActivity.CreateRandomItems(this.Container, pkCount : 3, randomPartitionKey : true);
HashSet <string> itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
QueryRequestOptions requestOptions = new QueryRequestOptions()
{
MaxItemCount = 1
};
List <ToDoActivity> itemsViaReadFeed = this.Container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
requestOptions: requestOptions).ToList();
Assert.IsTrue(itemsViaReadFeed.Count >= 3);
CollectionAssert.AreEqual(deleteList.ToList(), itemsViaReadFeed);
string lastContinuationToken = null;
FeedIterator <ToDoActivity> feedIterator = this.Container.GetItemLinqQueryable <ToDoActivity>(
requestOptions: requestOptions).ToFeedIterator();
while (feedIterator.HasMoreResults)
{
if (useStatelessIterator)
{
feedIterator = this.Container.GetItemLinqQueryable <ToDoActivity>(
continuationToken: lastContinuationToken,
requestOptions: requestOptions).ToFeedIterator();
}
FeedResponse <ToDoActivity> responseMessage = await feedIterator.ReadNextAsync(this.cancellationToken);
lastContinuationToken = responseMessage.ContinuationToken;
foreach (ToDoActivity toDoActivity in responseMessage)
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
Assert.IsNull(lastContinuationToken);
Assert.AreEqual(itemIds.Count, 0);
itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
FeedIterator streamIterator = this.Container.GetItemLinqQueryable <ToDoActivity>(
requestOptions: requestOptions).ToStreamIterator();
while (streamIterator.HasMoreResults)
{
if (useStatelessIterator)
{
streamIterator = this.Container.GetItemLinqQueryable <ToDoActivity>(
continuationToken: lastContinuationToken,
requestOptions: requestOptions).ToStreamIterator();
}
using (ResponseMessage responseMessage = await streamIterator.ReadNextAsync(this.cancellationToken))
{
lastContinuationToken = responseMessage.Headers.ContinuationToken;
Collection <ToDoActivity> items = TestCommon.SerializerCore.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data;
foreach (ToDoActivity toDoActivity in items)
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
}
Assert.IsNull(lastContinuationToken);
Assert.AreEqual(itemIds.Count, 0);
}
public async Task QueryableExtentionFunctionsTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
QueryRequestOptions queryRequestOptions = new QueryRequestOptions();
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(
requestOptions: queryRequestOptions);
int count = await linqQueryable.CountAsync();
Assert.AreEqual(10, count);
Response <int> intSum = await linqQueryable.Select(item => item.taskNum).SumAsync();
this.VerifyResponse(intSum, 420, queryRequestOptions);
Response <int?> intNullableSum = await linqQueryable.Select(item => (int?)item.taskNum).SumAsync();
this.VerifyResponse(intNullableSum, 420, queryRequestOptions);
Response <float> floatSum = await linqQueryable.Select(item => (float)item.taskNum).SumAsync();
this.VerifyResponse(floatSum, 420, queryRequestOptions);
Response <float?> floatNullableSum = await linqQueryable.Select(item => (float?)item.taskNum).SumAsync();
this.VerifyResponse(floatNullableSum, 420, queryRequestOptions);
Response <double> doubleSum = await linqQueryable.Select(item => (double)item.taskNum).SumAsync();
this.VerifyResponse(doubleSum, 420, queryRequestOptions);
Response <double?> doubleNullableSum = await linqQueryable.Select(item => (double?)item.taskNum).SumAsync();
this.VerifyResponse(doubleNullableSum, 420, queryRequestOptions);
Response <long> longSum = await linqQueryable.Select(item => (long)item.taskNum).SumAsync();
this.VerifyResponse(longSum, 420, queryRequestOptions);
Response <long?> longNullableSum = await linqQueryable.Select(item => (long?)item.taskNum).SumAsync();
this.VerifyResponse(longNullableSum, 420, queryRequestOptions);
Response <decimal> decimalSum = await linqQueryable.Select(item => (decimal)item.taskNum).SumAsync();
this.VerifyResponse(decimalSum, 420, queryRequestOptions);
Response <decimal?> decimalNullableSum = await linqQueryable.Select(item => (decimal?)item.taskNum).SumAsync();
this.VerifyResponse(decimalNullableSum, 420, queryRequestOptions);
Response <double> intToDoubleAvg = await linqQueryable.Select(item => item.taskNum).AverageAsync();
this.VerifyResponse(intToDoubleAvg, 42, queryRequestOptions);
Response <double?> intToDoubleNulableAvg = await linqQueryable.Select(item => (double?)item.taskNum).AverageAsync();
this.VerifyResponse(intToDoubleNulableAvg, 42, queryRequestOptions);
Response <float> floatAvg = await linqQueryable.Select(item => (float)item.taskNum).AverageAsync();
this.VerifyResponse(floatAvg, 42, queryRequestOptions);
Response <float?> floatNullableAvg = await linqQueryable.Select(item => (float?)item.taskNum).AverageAsync();
this.VerifyResponse(floatNullableAvg, 42, queryRequestOptions);
Response <double> doubleAvg = await linqQueryable.Select(item => (double)item.taskNum).AverageAsync();
this.VerifyResponse(doubleAvg, 42, queryRequestOptions);
Response <double?> doubleNullableAvg = await linqQueryable.Select(item => (double?)item.taskNum).AverageAsync();
this.VerifyResponse(doubleNullableAvg, 42, queryRequestOptions);
Response <double> longToDoubleAvg = await linqQueryable.Select(item => (long)item.taskNum).AverageAsync();
this.VerifyResponse(longToDoubleAvg, 42, queryRequestOptions);
Response <double?> longToNullableDoubleAvg = await linqQueryable.Select(item => (long?)item.taskNum).AverageAsync();
this.VerifyResponse(longToNullableDoubleAvg, 42, queryRequestOptions);
Response <decimal> decimalAvg = await linqQueryable.Select(item => (decimal)item.taskNum).AverageAsync();
this.VerifyResponse(decimalAvg, 42, queryRequestOptions);
Response <decimal?> decimalNullableAvg = await linqQueryable.Select(item => (decimal?)item.taskNum).AverageAsync();
this.VerifyResponse(decimalNullableAvg, 42, queryRequestOptions);
//Adding more items to test min and max function
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
toDoActivity.taskNum = 20;
toDoActivity.id = "minTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.pk));
toDoActivity.taskNum = 100;
toDoActivity.id = "maxTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.pk));
Response <int> minTaskNum = await linqQueryable.Select(item => item.taskNum).MinAsync();
Assert.AreEqual(20, minTaskNum);
Response <int> maxTaskNum = await linqQueryable.Select(item => item.taskNum).MaxAsync();
Assert.AreEqual(100, maxTaskNum);
}
public async Task ItemLINQQueryWithContinuationTokenTest()
{
// Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(
container : this.Container,
pkCount : 10,
perPKItemCount : 1,
randomPartitionKey : true);
IList <ToDoActivity> filteredList = itemList.Where(item => item.taskNum < 100).ToList();
int filteredDocumentCount = filteredList.Count();
Console.WriteLine($"Filtered List: {JsonConvert.SerializeObject(filteredList)}.");
QueryRequestOptions queryRequestOptions = new QueryRequestOptions();
queryRequestOptions.MaxConcurrency = 1;
queryRequestOptions.MaxItemCount = 5;
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(requestOptions: queryRequestOptions);
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => item.taskNum < 100);
FeedIterator <ToDoActivity> feedIterator = queriable.ToFeedIterator();
int firstItemSet = 0;
string continuationToken = null;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
firstItemSet = feedResponse.Count();
continuationToken = feedResponse.ContinuationToken;
Console.WriteLine($"First page: {JsonConvert.SerializeObject(feedResponse.Resource)}.");
if (firstItemSet > 0)
{
break;
}
}
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(
continuationToken: continuationToken,
requestOptions: queryRequestOptions);
queriable = linqQueryable.Where(item => item.taskNum < 100);
feedIterator = queriable.ToFeedIterator();
// Test continuationToken with LINQ query generation and asynchronous feedIterator execution.
int secondItemSet = 0;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
secondItemSet += feedResponse.Count();
Console.WriteLine($"Second Async page: {JsonConvert.SerializeObject(feedResponse.Resource)}.");
}
Assert.AreEqual(
filteredDocumentCount - firstItemSet,
secondItemSet,
"Failed to resume execution for async iterator.");
// Test continuationToken with blocking LINQ execution
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
continuationToken: continuationToken,
requestOptions: queryRequestOptions);
List <ToDoActivity> secondSyncPage = linqQueryable.Where(item => item.taskNum < 100).ToList();
Console.WriteLine($"Second Sync page: {JsonConvert.SerializeObject(secondSyncPage)}.");
int linqExecutionItemCount = secondSyncPage.Count();
Assert.AreEqual(
filteredDocumentCount - firstItemSet,
linqExecutionItemCount,
"Failed to resume execution for sync iterator");
}
public async Task ItemLINQQueryTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 2, perPKItemCount : 1, randomPartitionKey : true);
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>();
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => item.taskNum < 100);
//V3 Asynchronous query execution with LINQ query generation sql text.
FeedIterator <ToDoActivity> setIterator = this.Container.GetItemQueryIterator <ToDoActivity>(
queriable.ToQueryDefinition(),
requestOptions: new QueryRequestOptions()
{
MaxConcurrency = 2
});
int resultsFetched = 0;
while (setIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> queryResponse = await setIterator.ReadNextAsync();
resultsFetched += queryResponse.Count();
// For the items returned with NonePartitionKeyValue
IEnumerator <ToDoActivity> iter = queryResponse.GetEnumerator();
while (iter.MoveNext())
{
ToDoActivity activity = iter.Current;
Assert.AreEqual(42, activity.taskNum);
}
Assert.AreEqual(2, resultsFetched);
}
//LINQ query execution without partition key.
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(allowSynchronousQueryExecution: true);
queriable = linqQueryable.Where(item => item.taskNum < 100);
Assert.AreEqual(2, queriable.Count());
Assert.AreEqual(itemList[0].id, queriable.ToList()[0].id);
Assert.AreEqual(itemList[1].id, queriable.ToList()[1].id);
//LINQ query execution with wrong partition key.
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
requestOptions: new QueryRequestOptions()
{
PartitionKey = new Cosmos.PartitionKey("test")
});
queriable = linqQueryable.Where(item => item.taskNum < 100);
Assert.AreEqual(0, queriable.Count());
//LINQ query execution with correct partition key.
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(
allowSynchronousQueryExecution: true,
requestOptions: new QueryRequestOptions {
ConsistencyLevel = Cosmos.ConsistencyLevel.Eventual, PartitionKey = new Cosmos.PartitionKey(itemList[1].pk)
});
queriable = linqQueryable.Where(item => item.taskNum < 100);
Assert.AreEqual(1, queriable.Count());
Assert.AreEqual(itemList[1].id, queriable.ToList()[0].id);
}
public async Task LinqParameterisedTest2()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(true);
//Test same values in two where clause
string camelCase = "wrongValue";
IQueryable <ToDoActivity> queriable = linqQueryable
.Where(item => item.CamelCase == camelCase)
.Where(item => item.description != camelCase);
Dictionary <object, string> parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
QueryDefinition queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(1, queryDefinition.ToSqlQuerySpec().Parameters.Count);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
camelCase = "camelCase";
queryDefinition.WithParameter("@param1", camelCase);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
string queryText = "SELECT VALUE root FROM root WHERE (root[\"children\"] = [@param1, @param2])";
//Test array in query, array items will be parametrized
ToDoActivity child1 = new ToDoActivity {
id = "child1", taskNum = 30
};
ToDoActivity child2 = new ToDoActivity {
id = "child2", taskNum = 40
};
ToDoActivity[] children = new ToDoActivity[]
{ child1,
child2 };
queriable = linqQueryable
.Where(item => item.children == children);
parameters = new Dictionary <object, string>();
parameters.Add(child1, "@param1");
parameters.Add(child2, "@param2");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
//updating child to wrong value, result in query returning 0 results
child1.taskNum = 50;
queryDefinition.WithParameter("@param1", child1);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
//Test orderby, skip, take, distinct, these will not get parameterized.
queryText = "SELECT VALUE root FROM root WHERE (root[\"CamelCase\"] = @param1) ORDER BY" +
" root[\"taskNum\"] ASC OFFSET @param2 LIMIT @param3";
queriable = linqQueryable
.Where(item => item.CamelCase == camelCase)
.OrderBy(item => item.taskNum)
.Skip(5)
.Take(4);
parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
parameters.Add(5, "@param2");
parameters.Add(4, "@param3");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(4, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
queryDefinition.WithParameter("@param2", 10);
queryDefinition.WithParameter("@param3", 0);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
queryText = "SELECT VALUE root FROM root WHERE (root[\"CamelCase\"] != @param1)";
camelCase = "\b\n";
queriable = linqQueryable
.Where(item => item.CamelCase != camelCase);
parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual("\b\n", queryDefinition.ToSqlQuerySpec().Parameters[0].Value);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
}
public async Task LinqParameterisedTest1()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
string queryText = "SELECT VALUE item0 FROM root JOIN item0 IN root[\"children\"] WHERE (((((root[\"CamelCase\"] = @param1)" +
" AND (root[\"description\"] = @param2)) AND (root[\"taskNum\"] < @param3))" +
" AND (root[\"valid\"] = @param4)) AND (item0 = @param5))";
ToDoActivity child1 = new ToDoActivity {
id = "child1", taskNum = 30
};
string description = "CreateRandomToDoActivity";
string camelCase = "camelCase";
int taskNum = 100;
bool valid = true;
// Passing incorrect boolean value, generating queryDefinition, updating parameter and verifying new result
valid = false;
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(true);
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => item.CamelCase == camelCase)
.Where(item => item.description == description)
.Where(item => item.taskNum < taskNum)
.Where(item => item.valid == valid)
.SelectMany(item => item.children)
.Where(child => child == child1);
Dictionary <object, string> parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
parameters.Add(description, "@param2");
parameters.Add(taskNum, "@param3");
parameters.Add(valid, "@param4");
parameters.Add(child1, "@param5");
QueryDefinition queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(5, queryDefinition.ToSqlQuerySpec().Parameters.Count);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
string paramNameForUpdate = parameters[valid];
valid = true;
queryDefinition.WithParameter(paramNameForUpdate, valid);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
// Passing incorrect string value, generating queryDefinition, updating parameter and verifying new result
description = "wrongDescription";
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(true);
queriable = linqQueryable.Where(item => item.CamelCase == "camelCase")
.Where(item => item.description == description)
.Where(item => item.taskNum < 100)
.Where(item => item.valid == true)
.SelectMany(item => item.children)
.Where(child => child == child1);
parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
parameters.Add(description, "@param2");
parameters.Add(taskNum, "@param3");
parameters.Add(valid, "@param4");
parameters.Add(child1, "@param5");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(5, queryDefinition.ToSqlQuerySpec().Parameters.Count);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
paramNameForUpdate = parameters[description];
description = "CreateRandomToDoActivity";
queryDefinition.WithParameter(paramNameForUpdate, description);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
// Passing incorrect number value, generating queryDefinition, updating parameter and verifying new result
taskNum = 10;
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(true);
queriable = linqQueryable.Where(item => item.CamelCase == "camelCase")
.Where(item => item.description == "CreateRandomToDoActivity")
.Where(item => item.taskNum < taskNum)
.Where(item => item.valid == true)
.SelectMany(item => item.children)
.Where(child => child == child1);
parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
parameters.Add(description, "@param2");
parameters.Add(taskNum, "@param3");
parameters.Add(valid, "@param4");
parameters.Add(child1, "@param5");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(5, queryDefinition.ToSqlQuerySpec().Parameters.Count);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
paramNameForUpdate = parameters[taskNum];
taskNum = 100;
queryDefinition.WithParameter(paramNameForUpdate, taskNum);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
// Passing incorrect object value, generating queryDefinition, updating parameter and verifying new result
child1.taskNum = 40;
queriable = linqQueryable.Where(item => item.CamelCase == "camelCase")
.Where(item => item.description == "CreateRandomToDoActivity")
.Where(item => item.taskNum < taskNum)
.Where(item => item.valid == true)
.SelectMany(item => item.children)
.Where(child => child == child1);
parameters = new Dictionary <object, string>();
parameters.Add(camelCase, "@param1");
parameters.Add(description, "@param2");
parameters.Add(taskNum, "@param3");
parameters.Add(valid, "@param4");
parameters.Add(child1, "@param5");
queryDefinition = queriable.ToQueryDefinition(parameters);
Assert.AreEqual(5, queryDefinition.ToSqlQuerySpec().Parameters.Count);
Assert.AreEqual(queryText, queryDefinition.ToSqlQuerySpec().QueryText);
Assert.AreEqual(0, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
paramNameForUpdate = parameters[child1];
child1.taskNum = 30;
queryDefinition.WithParameter(paramNameForUpdate, child1);
Assert.AreEqual(10, (await this.FetchResults <ToDoActivity>(queryDefinition)).Count);
}
public async Task QueryableExtentionFunctionsTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>();
int count = await linqQueryable.CountAsync();
Assert.AreEqual(10, count);
Response <int> intSum = await linqQueryable.Select(item => item.taskNum).SumAsync();
Assert.AreEqual(420, intSum.Resource);
Assert.IsTrue(intSum.RequestCharge > 0);
string diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <int?> intNullableSum = await linqQueryable.Select(item => (int?)item.taskNum).SumAsync();
Assert.AreEqual <int?>(420, intNullableSum);
Assert.IsTrue(intNullableSum.RequestCharge > 0);
diagnostics = intNullableSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <float> floatSum = await linqQueryable.Select(item => (float)item.taskNum).SumAsync();
Assert.AreEqual(420, intSum);
Assert.IsTrue(floatSum.RequestCharge > 0);
diagnostics = floatSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <float?> floatNullableSum = await linqQueryable.Select(item => (float?)item.taskNum).SumAsync();
Assert.AreEqual <float?>(420, intNullableSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double> doubleSum = await linqQueryable.Select(item => (double)item.taskNum).SumAsync();
Assert.AreEqual(420.0, doubleSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double?> doubleNullableSum = await linqQueryable.Select(item => (double?)item.taskNum).SumAsync();
Assert.AreEqual <double?>(420.0, doubleNullableSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <long> longSum = await linqQueryable.Select(item => (long)item.taskNum).SumAsync();
Assert.AreEqual <long>(420, longSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <long?> longNullableSum = await linqQueryable.Select(item => (long?)item.taskNum).SumAsync();
Assert.AreEqual <long?>(420, longNullableSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <decimal> decimalSum = await linqQueryable.Select(item => (decimal)item.taskNum).SumAsync();
Assert.AreEqual <decimal>(420, decimalSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <decimal?> decimalNullableSum = await linqQueryable.Select(item => (decimal?)item.taskNum).SumAsync();
Assert.AreEqual <decimal?>(420, decimalNullableSum);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double> intToDoubleAvg = await linqQueryable.Select(item => item.taskNum).AverageAsync();
Assert.AreEqual <double>(42, intToDoubleAvg);
Assert.IsTrue(intSum.RequestCharge > 0);
diagnostics = intSum.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double?> intToDoubleNulableAvg = await linqQueryable.Select(item => (double?)item.taskNum).AverageAsync();
Assert.AreEqual <double?>(42, intToDoubleNulableAvg);
Assert.IsTrue(intToDoubleNulableAvg.RequestCharge > 0);
diagnostics = intToDoubleNulableAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <float> floatAvg = await linqQueryable.Select(item => (float)item.taskNum).AverageAsync();
Assert.AreEqual <float>(42, floatAvg);
Assert.IsTrue(floatAvg.RequestCharge > 0);
diagnostics = floatAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <float?> floatNullableAvg = await linqQueryable.Select(item => (float?)item.taskNum).AverageAsync();
Assert.AreEqual <float?>(42, floatNullableAvg);
Assert.IsTrue(floatNullableAvg.RequestCharge > 0);
diagnostics = floatNullableAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double> doubleAvg = await linqQueryable.Select(item => (double)item.taskNum).AverageAsync();
Assert.AreEqual <double>(42, doubleAvg);
Assert.IsTrue(doubleAvg.RequestCharge > 0);
diagnostics = doubleAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double?> doubleNullableAvg = await linqQueryable.Select(item => (double?)item.taskNum).AverageAsync();
Assert.AreEqual <double?>(42, doubleNullableAvg);
Assert.IsTrue(doubleNullableAvg.RequestCharge > 0);
diagnostics = doubleNullableAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double> longToDoubleAvg = await linqQueryable.Select(item => (long)item.taskNum).AverageAsync();
Assert.AreEqual <double>(42, longToDoubleAvg);
Assert.IsTrue(longToDoubleAvg.RequestCharge > 0);
diagnostics = longToDoubleAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <double?> longToNullableDoubleAvg = await linqQueryable.Select(item => (long?)item.taskNum).AverageAsync();
Assert.AreEqual <double?>(42, longToNullableDoubleAvg);
Assert.IsTrue(longToNullableDoubleAvg.RequestCharge > 0);
diagnostics = longToNullableDoubleAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <decimal> decimalAvg = await linqQueryable.Select(item => (decimal)item.taskNum).AverageAsync();
Assert.AreEqual <decimal>(42, decimalAvg);
Assert.IsTrue(decimalAvg.RequestCharge > 0);
diagnostics = decimalAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
Response <decimal?> decimalNullableAvg = await linqQueryable.Select(item => (decimal?)item.taskNum).AverageAsync();
Assert.AreEqual <decimal?>(42, decimalNullableAvg);
Assert.IsTrue(decimalNullableAvg.RequestCharge > 0);
diagnostics = decimalNullableAvg.Diagnostics.ToString();
Assert.IsTrue(diagnostics.Contains("queryMetrics"));
//Adding more items to test min and max function
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
toDoActivity.taskNum = 20;
toDoActivity.id = "minTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.status));
toDoActivity.taskNum = 100;
toDoActivity.id = "maxTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.status));
Response <int> minTaskNum = await linqQueryable.Select(item => item.taskNum).MinAsync();
Assert.AreEqual(20, minTaskNum);
Response <int> maxTaskNum = await linqQueryable.Select(item => item.taskNum).MaxAsync();
Assert.AreEqual(100, maxTaskNum);
}
public async Task QueryOperationDiagnostic()
{
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(this.Container, 3, randomPartitionKey : true);
//Checking query metrics on typed query
ToDoActivity find = itemList.First();
QueryDefinition sql = new QueryDefinition("select * from ToDoActivity");
QueryRequestOptions requestOptions = new QueryRequestOptions()
{
MaxItemCount = 1,
MaxConcurrency = 1,
};
FeedIterator <ToDoActivity> feedIterator = this.Container.GetItemQueryIterator <ToDoActivity>(
sql,
requestOptions: requestOptions);
if (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> iter = await feedIterator.ReadNextAsync();
Assert.IsTrue(((QueryOperationStatistics)iter.Diagnostics).queryMetrics.Values.First().OutputDocumentCount > 0);
}
sql = new QueryDefinition("select * from ToDoActivity t ORDER BY t.cost");
feedIterator = this.Container.GetItemQueryIterator <ToDoActivity>(
sql,
requestOptions: requestOptions);
if (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> iter = await feedIterator.ReadNextAsync();
Assert.IsTrue(((QueryOperationStatistics)iter.Diagnostics).queryMetrics.Values.First().OutputDocumentCount > 0);
}
sql = new QueryDefinition("select DISTINCT t.cost from ToDoActivity t");
feedIterator = this.Container.GetItemQueryIterator <ToDoActivity>(
sql,
requestOptions: requestOptions);
if (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> iter = await feedIterator.ReadNextAsync();
Assert.IsNotNull((QueryOperationStatistics)iter.Diagnostics);
Assert.AreEqual(1, ((QueryOperationStatistics)iter.Diagnostics).queryMetrics.Values.First().OutputDocumentCount);
}
sql = new QueryDefinition("select * from ToDoActivity OFFSET 1 LIMIT 1");
feedIterator = this.Container.GetItemQueryIterator <ToDoActivity>(
sql,
requestOptions: requestOptions);
if (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> iter = await feedIterator.ReadNextAsync();
Assert.IsTrue(((QueryOperationStatistics)iter.Diagnostics).queryMetrics.Values.First().OutputDocumentCount > 0);
}
//Checking query metrics on stream query
sql = new QueryDefinition("select * from ToDoActivity");
FeedIterator iterator = this.Container.GetItemQueryStreamIterator(
sql,
requestOptions: requestOptions);
if (iterator.HasMoreResults)
{
ResponseMessage responseMessage = await iterator.ReadNextAsync();
Assert.IsTrue(((QueryOperationStatistics)responseMessage.Diagnostics).queryMetrics.Values.First().OutputDocumentCount > 0);
}
}
public async Task QueryableExtentionFunctionsTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>();
int count = await linqQueryable.CountAsync();
Assert.AreEqual(10, count);
int intSum = await linqQueryable.Select(item => item.taskNum).SumAsync();
Assert.AreEqual(420, intSum);
int?intNullableSum = await linqQueryable.Select(item => item.taskNum).SumAsync();
Assert.AreEqual(420, intNullableSum);
float floatSum = await linqQueryable.Select(item => (float)item.taskNum).SumAsync();
Assert.AreEqual(420, intSum);
float?floatNullableSum = await linqQueryable.Select(item => (float?)item.taskNum).SumAsync();
Assert.AreEqual(420, intNullableSum);
double doubleSum = await linqQueryable.Select(item => (double)item.taskNum).SumAsync();
Assert.AreEqual(420, doubleSum);
double?doubleNullableSum = await linqQueryable.Select(item => (double?)item.taskNum).SumAsync();
Assert.AreEqual(420, doubleNullableSum);
long longSum = await linqQueryable.Select(item => (long)item.taskNum).SumAsync();
Assert.AreEqual(420, longSum);
long?longNullableSum = await linqQueryable.Select(item => (long?)item.taskNum).SumAsync();
Assert.AreEqual(420, longNullableSum);
decimal decimalSum = await linqQueryable.Select(item => (decimal)item.taskNum).SumAsync();
Assert.AreEqual(420, decimalSum);
decimal?decimalNullableSum = await linqQueryable.Select(item => (decimal?)item.taskNum).SumAsync();
Assert.AreEqual(420, decimalNullableSum);
double intToDoubleAvg = await linqQueryable.Select(item => item.taskNum).AverageAsync();
Assert.AreEqual(42, intToDoubleAvg);
double?intToDoubleNulableAvg = await linqQueryable.Select(item => item.taskNum).AverageAsync();
Assert.AreEqual(42, intToDoubleNulableAvg);
float floatAvg = await linqQueryable.Select(item => (float)item.taskNum).AverageAsync();
Assert.AreEqual(42, floatAvg);
float?floatNullableAvg = await linqQueryable.Select(item => (float?)item.taskNum).AverageAsync();
Assert.AreEqual(42, floatNullableAvg);
double doubleAvg = await linqQueryable.Select(item => (double)item.taskNum).AverageAsync();
Assert.AreEqual(42, doubleAvg);
double?doubleNullableAvg = await linqQueryable.Select(item => (double?)item.taskNum).AverageAsync();
Assert.AreEqual(42, doubleNullableAvg);
double longToDoubleAvg = await linqQueryable.Select(item => (long)item.taskNum).AverageAsync();
Assert.AreEqual(42, longToDoubleAvg);
double?longToNullableDoubleAvg = await linqQueryable.Select(item => (long?)item.taskNum).AverageAsync();
Assert.AreEqual(42, longToNullableDoubleAvg);
decimal decimalAvg = await linqQueryable.Select(item => (decimal)item.taskNum).AverageAsync();
Assert.AreEqual(42, decimalAvg);
decimal?decimalNullableAvg = await linqQueryable.Select(item => (decimal?)item.taskNum).AverageAsync();
Assert.AreEqual(42, decimalNullableAvg);
//Adding more items to test min and max function
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
toDoActivity.taskNum = 20;
toDoActivity.id = "minTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.status));
toDoActivity.taskNum = 100;
toDoActivity.id = "maxTaskNum";
await this.Container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.status));
int minTaskNum = await linqQueryable.Select(item => item.taskNum).MinAsync();
Assert.AreEqual(20, minTaskNum);
int maxTaskNum = await linqQueryable.Select(item => item.taskNum).MaxAsync();
Assert.AreEqual(100, maxTaskNum);
}
