// </ItemOperationsWithValidPartitionKeyValue>
/// <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>
// <MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue>
private static async Task MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(Container 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);
ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>(
partitionKey : PartitionKey.None,
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;
QueryDefinition sql = new QueryDefinition("select * from r");
using (FeedIterator <DeviceInformationItem> setIterator = container.GetItemQueryIterator <DeviceInformationItem>(
sql,
requestOptions: new QueryRequestOptions()
{
PartitionKey = PartitionKey.None,
MaxItemCount = 2
}))
{
while (setIterator.HasMoreResults)
{
FeedResponse <DeviceInformationItem> queryResponse = await setIterator.ReadNextAsync();
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.
ItemResponse <DeviceInformationItem> createResponseWithPk = await container.CreateItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(item.PartitionKey),
item : item);
// Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
ItemResponse <DeviceInformationItem> deleteResponseWithoutPk = await container.DeleteItemAsync <DeviceInformationItem>(
partitionKey : PartitionKey.None,
id : item.Id);
}
}
}
}
}
/// <summary>
/// Tries to the move to the next page in the document producer.
/// </summary>
/// <param name="token">The cancellation token.</param>
/// <returns>Whether the operation was successful.</returns>
private async Task <bool> MoveNextPage(CancellationToken token)
{
token.ThrowIfCancellationRequested();
if (this.bufferedPages.Count == 0)
{
return(false);
}
if (this.itemsLeftInCurrentPage != 0)
{
throw new InvalidOperationException("Tried to move onto the next page before finishing the first page.");
}
FeedResponse <CosmosElement> feedResponse = await this.bufferedPages.TakeAsync(token);
this.previousContinuationToken = this.currentContinuationToken;
this.currentContinuationToken = feedResponse.ResponseContinuation;
this.currentPage = feedResponse.GetEnumerator();
this.itemsLeftInCurrentPage = feedResponse.Count;
if (this.MoveNextDocumentWithinCurrentPage())
{
this.isAtBeginningOfPage = true;
return(true);
}
else
{
return(false);
}
}
private void UpdateStates(FeedResponse <T> feedResponse)
{
this.PreviousResponseContinuation = this.ResponseContinuation;
this.ResponseContinuation = feedResponse.ResponseContinuation;
this.ItemsTillNextContinuationBoundary = feedResponse.Count;
this.IsAtContinuationBoundary = true;
this.CurrentEnumerator = feedResponse.GetEnumerator();
this.RequestStatistics = feedResponse.RequestStatistics;
this.TotalResponseLengthBytes += feedResponse.ResponseLengthBytes;
this.MoveNextInternal();
}
//-MANAGEMENT-----------------------------------------------------------------------------------------------------------------
private async Task <dynamic> Assert_Send_MessageToIotAndCheckIfTheMessageWasSavedInCosmos(string idToSeek, DocumentClient documentClient, Uri collectionToCosmosLink)
{
FeedResponse <dynamic> docs = await documentClient.ReadDocumentFeedAsync(collectionToCosmosLink, new FeedOptions { MaxItemCount = 10 });
IEnumerator <dynamic> docEnumerator = docs.GetEnumerator();
while (!docEnumerator.MoveNext())
{
if (docEnumerator.Current["id"] == idToSeek)
{
break;
}
}
return(JsonConvert.DeserializeObject(docEnumerator.Current.ToString()));
}
private async Task <bool> ExecuteCollectionChangeFeedQueryNextResultAsync(CancellationToken cancelToken)
{
if ((_collectionChangeFeedQuery != null) && _collectionChangeFeedQuery.HasMoreResults && !cancelToken.IsCancellationRequested)
{
FeedResponse <T> collectionChangeFeedResponse = await _collectionChangeFeedQuery.ExecuteNextAsync <T>(cancelToken);
_collectionPartitionKeyRangesCheckpoints[_collectionPartitionKeyRanges[_collectionPartitionKeyRangeIndex].Id] = collectionChangeFeedResponse.ResponseContinuation;
_collectionChangeFeedEnumerator = collectionChangeFeedResponse.GetEnumerator();
return(true);
}
return(false);
}
private async Task <List <T> > FetchResults <T>(QueryDefinition queryDefinition)
{
List <T> itemList = new List <T>();
FeedIterator <T> feedIterator = this.Container.GetItemQueryIterator <T>(queryDefinition);
while (feedIterator.HasMoreResults)
{
FeedResponse <T> queryResponse = await feedIterator.ReadNextAsync();
IEnumerator <T> iter = queryResponse.GetEnumerator();
while (iter.MoveNext())
{
itemList.Add(iter.Current);
}
}
return(itemList);
}
public async Task Execute(Experiment experiment, DocumentClient client, DocumentCollection collection, Uri documentCollectionUri, int taskId, ConfigurationOptions options)
{
try
{
IDocumentQuery <dynamic> query = client.CreateDocumentQuery(documentCollectionUri, options.QueryString,
new FeedOptions
{
PopulateQueryMetrics = true,
MaxItemCount = -1,
MaxDegreeOfParallelism = -1,
EnableCrossPartitionQuery = true,
EnableScanInQuery = true
}).AsDocumentQuery();
while (query.HasMoreResults)
{
FeedResponse <dynamic> response = await query.ExecuteNextAsync <dynamic>();
experiment.UpdateRequestUnits(taskId, response.RequestCharge);
if (options.Record)
{
var enumerator = response.GetEnumerator();
while (enumerator.MoveNext())
{
var current = enumerator.Current;
Console.WriteLine("Order {0}", current.ToString());
}
}
}
experiment.IncrementOperationCount();
}
catch (Exception e)
{
Console.WriteLine("Failed to read {0}. Exception was {1}", collection.SelfLink, e);
if (e is DocumentClientException)
{
DocumentClientException de = (DocumentClientException)e;
if (de.StatusCode == HttpStatusCode.Forbidden)
{
experiment.IncrementOperationCount();
}
}
}
}
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 static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
ILogger log,
ExecutionContext context)
{
try
{
EnsureClient(context);
string productCode = req.Query["productCode"];
SqlQuerySpec querySpec = null;
if (!String.IsNullOrWhiteSpace(productCode))
{
querySpec = new SqlQuerySpec(
String.Concat(
"SELECT VALUE COUNT(1) FROM Items i WHERE i.productCode IN ('",
productCode,
"')"));
}
else
{
querySpec = new SqlQuerySpec("SELECT VALUE COUNT(1)FROM Items i");
}
IDocumentQuery <dynamic> query = cosmosDbClient.CreateDocumentQuery(
collectionUri,
querySpec,
new FeedOptions()
{
EnableCrossPartitionQuery = true,
PartitionKey = null,
PopulateQueryMetrics = true,
MaxItemCount = 50,
MaxDegreeOfParallelism = 0,
MaxBufferedItemCount = 100
}).AsDocumentQuery();
double totalRUs = 0;
long count = 0;
while (query.HasMoreResults)
{
FeedResponse <dynamic> feedResponse = await query.ExecuteNextAsync();
Console.WriteLine(feedResponse.RequestCharge);
totalRUs += feedResponse.RequestCharge;
IReadOnlyDictionary <string, QueryMetrics> partitionIdToQueryMetrics = feedResponse.QueryMetrics;
foreach (KeyValuePair <string, QueryMetrics> kvp in partitionIdToQueryMetrics)
{
string partitionId = kvp.Key;
QueryMetrics queryMetrics = kvp.Value;
Console.WriteLine("{0}: {1}", partitionId, queryMetrics);
}
IEnumerator <dynamic> docEnumerator = feedResponse.GetEnumerator();
while (docEnumerator.MoveNext())
{
count += (long)docEnumerator.Current;
}
}
var responsePayload = new ResponseContract
{
Count = count,
TotalRUs = totalRUs,
};
log.LogInformation("Count: {0}, Total RUs: {1}", count, totalRUs);
return(new OkObjectResult(JsonConvert.SerializeObject(responsePayload)));
}
catch (Exception error)
{
return(new ObjectResult(error.ToString())
{
StatusCode = 500
});
}
}
