public Task <TryCatch <ReadFeedPage> > MonadicReadFeedAsync(
ReadFeedState readFeedState,
FeedRangeInternal feedRange,
QueryRequestOptions queryRequestOptions,
int pageSize,
CancellationToken cancellationToken) => this.monadicDocumentContainer.MonadicReadFeedAsync(
readFeedState,
feedRange,
queryRequestOptions,
pageSize,
cancellationToken);
public static ReadFeedCrossFeedRangeState CreateFromContinuation(CosmosElement continuation, FeedRange feedRange)
{
if (!(feedRange is FeedRangeInternal feedRangeInternal))
{
throw new ArgumentException($"{nameof(feedRange)} needs to be a {nameof(FeedRangeInternal)}.");
}
return(new ReadFeedCrossFeedRangeState(
new List <FeedRangeState <ReadFeedState> >()
{
new FeedRangeState <ReadFeedState>(feedRangeInternal, ReadFeedState.Continuation(continuation))
}));
}
public Task <ReadFeedPage> ReadFeedAsync(
ReadFeedState readFeedState,
FeedRangeInternal feedRange,
QueryRequestOptions queryRequestOptions,
int pageSize,
CancellationToken cancellationToken) => TryCatch <ReadFeedPage> .UnsafeGetResultAsync(
this.MonadicReadFeedAsync(
readFeedState,
feedRange,
queryRequestOptions,
pageSize,
cancellationToken),
cancellationToken);
public async Task TargetMultipleLogicalPartitionKeys()
{
int batchSize = 25;
string pkToRead1 = "pkToRead1";
string pkToRead2 = "pkToRead2";
string otherPK = "otherPK";
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: pkToRead1));
}
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: pkToRead2));
}
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: otherPK));
}
// Create one start state for each logical partition key.
List <FeedRangeState <ReadFeedState> > feedRangeStates = new List <FeedRangeState <ReadFeedState> >();
IReadOnlyList <string> partitionKeysToTarget = new List <string>()
{
pkToRead1,
pkToRead2
};
foreach (string partitionKeyToTarget in partitionKeysToTarget)
{
feedRangeStates.Add(
new FeedRangeState <ReadFeedState>(
(FeedRangeInternal)FeedRange.FromPartitionKey(
new Cosmos.PartitionKey(partitionKeyToTarget)),
ReadFeedState.Beginning()));
}
// Use the list composition property of the constructor to merge them in to a single state.
ReadFeedCrossFeedRangeState multipleLogicalPartitionKeyState = new ReadFeedCrossFeedRangeState(feedRangeStates.ToImmutableArray());
IAsyncEnumerable <TryCatch <ReadFeedPage> > asyncEnumerable = this.Container.GetReadFeedAsyncEnumerable(multipleLogicalPartitionKeyState);
(int totalCount, ReadFeedCrossFeedRangeState? _) = await DrainAllAsync(asyncEnumerable);
Assert.AreEqual(2 * batchSize, totalCount);
}
public static ReadFeedCrossFeedRangeState CreateFromBeginning(FeedRange feedRange)
{
if (!(feedRange is FeedRangeInternal feedRangeInternal))
{
throw new ArgumentException($"{nameof(feedRange)} needs to be a {nameof(FeedRangeInternal)}.");
}
if (feedRange.Equals(FeedRangeEpk.FullRange))
{
return(FullRangeStatesSingletons.Beginning);
}
return(new ReadFeedCrossFeedRangeState(
new List <FeedRangeState <ReadFeedState> >()
{
new FeedRangeState <ReadFeedState>(feedRangeInternal, ReadFeedState.Beginning())
}));
}
public ReadFeedIteratorCore(
IDocumentContainer documentContainer,
string continuationToken,
ReadFeedPaginationOptions readFeedPaginationOptions,
QueryRequestOptions queryRequestOptions,
CancellationToken cancellationToken)
{
this.queryRequestOptions = queryRequestOptions;
readFeedPaginationOptions ??= ReadFeedPaginationOptions.Default;
if (!string.IsNullOrEmpty(continuationToken))
{
bool isNewArrayFormat = (continuationToken.Length >= 2) && (continuationToken[0] == '[') && (continuationToken[continuationToken.Length - 1] == ']');
if (!isNewArrayFormat)
{
// One of the two older formats
if (!FeedRangeContinuation.TryParse(continuationToken, out FeedRangeContinuation feedRangeContinuation))
{
// Backward compatible with old format
feedRangeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
FeedRangeEpk.FullRange,
new List <Documents.Routing.Range <string> >()
{
new Documents.Routing.Range <string>(
Documents.Routing.PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey,
Documents.Routing.PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey,
isMinInclusive: true,
isMaxInclusive: false)
},
continuationToken);
}
// need to massage it a little
List <CosmosElement> feedRangeStates = new List <CosmosElement>();
string oldContinuationFormat = feedRangeContinuation.ToString();
if (feedRangeContinuation.FeedRange is FeedRangePartitionKey feedRangePartitionKey)
{
CosmosObject cosmosObject = CosmosObject.Parse(oldContinuationFormat);
CosmosArray continuations = (CosmosArray)cosmosObject["Continuation"];
if (continuations.Count != 1)
{
throw new InvalidOperationException("Expected only one continuation for partition key queries");
}
CosmosElement continuation = continuations[0];
CosmosObject continuationObject = (CosmosObject)continuation;
CosmosElement token = continuationObject["token"];
ReadFeedState state;
if (token is CosmosNull)
{
state = ReadFeedState.Beginning();
}
else
{
CosmosString tokenAsString = (CosmosString)token;
state = ReadFeedState.Continuation(CosmosElement.Parse(tokenAsString.Value));
}
FeedRangeState <ReadFeedState> feedRangeState = new FeedRangeState <ReadFeedState>(feedRangePartitionKey, state);
feedRangeStates.Add(ReadFeedFeedRangeStateSerializer.ToCosmosElement(feedRangeState));
}
else
{
CosmosObject cosmosObject = CosmosObject.Parse(oldContinuationFormat);
CosmosArray continuations = (CosmosArray)cosmosObject["Continuation"];
foreach (CosmosElement continuation in continuations)
{
CosmosObject continuationObject = (CosmosObject)continuation;
CosmosObject rangeObject = (CosmosObject)continuationObject["range"];
string min = ((CosmosString)rangeObject["min"]).Value;
string max = ((CosmosString)rangeObject["max"]).Value;
CosmosElement token = continuationObject["token"];
FeedRangeInternal feedRange = new FeedRangeEpk(new Documents.Routing.Range <string>(min, max, isMinInclusive: true, isMaxInclusive: false));
ReadFeedState state;
if (token is CosmosNull)
{
state = ReadFeedState.Beginning();
}
else
{
CosmosString tokenAsString = (CosmosString)token;
state = ReadFeedState.Continuation(CosmosElement.Parse(tokenAsString.Value));
}
FeedRangeState <ReadFeedState> feedRangeState = new FeedRangeState <ReadFeedState>(feedRange, state);
feedRangeStates.Add(ReadFeedFeedRangeStateSerializer.ToCosmosElement(feedRangeState));
}
}
CosmosArray cosmosArrayContinuationTokens = CosmosArray.Create(feedRangeStates);
continuationToken = cosmosArrayContinuationTokens.ToString();
}
}
TryCatch <ReadFeedCrossFeedRangeState> monadicReadFeedState;
if (continuationToken == null)
{
FeedRange feedRange;
if ((this.queryRequestOptions != null) && this.queryRequestOptions.PartitionKey.HasValue)
{
feedRange = new FeedRangePartitionKey(this.queryRequestOptions.PartitionKey.Value);
}
else if ((this.queryRequestOptions != null) && (this.queryRequestOptions.FeedRange != null))
{
feedRange = this.queryRequestOptions.FeedRange;
}
else
{
feedRange = FeedRangeEpk.FullRange;
}
monadicReadFeedState = TryCatch <ReadFeedCrossFeedRangeState> .FromResult(ReadFeedCrossFeedRangeState.CreateFromBeginning(feedRange));
}
else
{
monadicReadFeedState = ReadFeedCrossFeedRangeState.Monadic.Parse(continuationToken);
}
if (monadicReadFeedState.Failed)
{
this.monadicEnumerator = TryCatch <CrossPartitionReadFeedAsyncEnumerator> .FromException(monadicReadFeedState.Exception);
}
else
{
this.monadicEnumerator = TryCatch <CrossPartitionReadFeedAsyncEnumerator> .FromResult(
CrossPartitionReadFeedAsyncEnumerator.Create(
documentContainer,
new CrossFeedRangeState <ReadFeedState>(monadicReadFeedState.Result.FeedRangeStates),
readFeedPaginationOptions,
cancellationToken));
}
this.hasMoreResults = true;
}
public override async Task <ResponseMessage> ReadNextAsync(
ITrace trace,
CancellationToken cancellationToken = default)
{
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
cancellationToken.ThrowIfCancellationRequested();
if (!this.hasMoreResults)
{
throw new InvalidOperationException("Should not be calling FeedIterator that does not have any more results");
}
if (this.monadicEnumerator.Failed)
{
this.hasMoreResults = false;
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(this.monadicEnumerator.Exception);
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.BadRequest,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossPartitionReadFeedAsyncEnumerator enumerator = this.monadicEnumerator.Result;
TryCatch <CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> > monadicPage;
try
{
if (!await enumerator.MoveNextAsync(trace))
{
throw new InvalidOperationException("Should not be calling enumerator that does not have any more results");
}
monadicPage = enumerator.Current;
}
catch (Exception ex)
{
monadicPage = TryCatch <CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> > .FromException(ex);
}
if (monadicPage.Failed)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(monadicPage.Exception);
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
statusCode: cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
trace: trace));
}
CrossFeedRangePage <Pagination.ReadFeedPage, ReadFeedState> crossFeedRangePage = monadicPage.Result;
if (crossFeedRangePage.State == default)
{
this.hasMoreResults = false;
}
// Make the continuation token match the older format:
string continuationToken;
if (crossFeedRangePage.State != null)
{
List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>();
CrossFeedRangeState <ReadFeedState> crossFeedRangeState = crossFeedRangePage.State;
for (int i = 0; i < crossFeedRangeState.Value.Length; i++)
{
FeedRangeState <ReadFeedState> feedRangeState = crossFeedRangeState.Value.Span[i];
FeedRangeEpk feedRange;
if (feedRangeState.FeedRange is FeedRangeEpk feedRangeEpk)
{
feedRange = feedRangeEpk;
}
else
{
feedRange = FeedRangeEpk.FullRange;
}
ReadFeedState readFeedState = feedRangeState.State;
CompositeContinuationToken compositeContinuationToken = new CompositeContinuationToken()
{
Range = feedRange.Range,
Token = readFeedState is ReadFeedBeginningState ? null : ((ReadFeedContinuationState)readFeedState).ContinuationToken.ToString(),
};
compositeContinuationTokens.Add(compositeContinuationToken);
}
FeedRangeInternal outerFeedRange;
if ((this.queryRequestOptions != null) && this.queryRequestOptions.PartitionKey.HasValue)
{
outerFeedRange = new FeedRangePartitionKey(this.queryRequestOptions.PartitionKey.Value);
}
else if ((this.queryRequestOptions != null) && (this.queryRequestOptions.FeedRange != null))
{
outerFeedRange = (FeedRangeInternal)this.queryRequestOptions.FeedRange;
}
else
{
outerFeedRange = FeedRangeEpk.FullRange;
}
FeedRangeCompositeContinuation feedRangeCompositeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
feedRange: outerFeedRange,
compositeContinuationTokens);
continuationToken = feedRangeCompositeContinuation.ToString();
}
else
{
continuationToken = null;
}
Pagination.ReadFeedPage page = crossFeedRangePage.Page;
Headers headers = new Headers()
{
RequestCharge = page.RequestCharge,
ActivityId = page.ActivityId,
ContinuationToken = continuationToken,
};
foreach (KeyValuePair <string, string> kvp in page.AdditionalHeaders)
{
headers[kvp.Key] = kvp.Value;
}
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.OK,
requestMessage: default,
/// <summary>
/// Get the next set of results from the cosmos service
/// </summary>
/// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A query response from cosmos service</returns>
public override async Task <ResponseMessage> ReadNextAsync(CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (!this.hasMoreResults)
{
throw new InvalidOperationException("Should not be calling FeedIterator that does not have any more results");
}
if (this.monadicEnumerator.Failed)
{
this.hasMoreResults = false;
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(this.monadicEnumerator.Exception);
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.BadRequest,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: cosmosException.DiagnosticsContext));
}
CrossPartitionReadFeedAsyncEnumerator enumerator = this.monadicEnumerator.Result;
TryCatch <ReadFeedPage> monadicPage;
try
{
if (!await enumerator.MoveNextAsync())
{
throw new InvalidOperationException("Should not be calling enumerator that does not have any more results");
}
monadicPage = enumerator.Current;
}
catch (Exception ex)
{
monadicPage = TryCatch <ReadFeedPage> .FromException(ex);
}
if (monadicPage.Failed)
{
CosmosException cosmosException = ExceptionToCosmosException.CreateFromException(monadicPage.Exception);
if (!IsRetriableException(cosmosException))
{
this.hasMoreResults = false;
}
return(new ResponseMessage(
statusCode: cosmosException.StatusCode,
requestMessage: null,
headers: cosmosException.Headers,
cosmosException: cosmosException,
diagnostics: cosmosException.DiagnosticsContext));
}
ReadFeedPage readFeedPage = monadicPage.Result;
if (readFeedPage.State == default)
{
this.hasMoreResults = false;
}
// Make the continuation token match the older format:
string continuationToken;
if (readFeedPage.State != null)
{
List <CompositeContinuationToken> compositeContinuationTokens = new List <CompositeContinuationToken>();
CosmosArray compositeContinuationTokensCosmosArray = (CosmosArray)readFeedPage.State.ContinuationToken;
foreach (CosmosElement arrayItem in compositeContinuationTokensCosmosArray)
{
ReadFeedContinuationToken readFeedContinuationToken = ReadFeedContinuationToken.MonadicConvertFromCosmosElement(arrayItem).Result;
FeedRangeEpk feedRangeEpk = (FeedRangeEpk)readFeedContinuationToken.Range;
ReadFeedState readFeedState = readFeedContinuationToken.State;
CompositeContinuationToken compositeContinuationToken = new CompositeContinuationToken()
{
Range = feedRangeEpk.Range,
Token = readFeedState.ContinuationToken.ToString(),
};
compositeContinuationTokens.Add(compositeContinuationToken);
}
FeedRangeCompositeContinuation feedRangeCompositeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
feedRange: FeedRangeEpk.FullRange,
compositeContinuationTokens);
continuationToken = feedRangeCompositeContinuation.ToString();
}
else
{
continuationToken = null;
}
return(new ResponseMessage(
statusCode: System.Net.HttpStatusCode.OK,
requestMessage: default,
public ReadFeedIteratorCore(
IDocumentContainer documentContainer,
QueryRequestOptions queryRequestOptions,
string continuationToken,
int pageSize,
CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(continuationToken))
{
bool isNewArrayFormat = (continuationToken.Length >= 2) && (continuationToken[0] == '[') && (continuationToken[continuationToken.Length - 1] == ']');
if (!isNewArrayFormat)
{
// One of the two older formats
if (!FeedRangeContinuation.TryParse(continuationToken, out FeedRangeContinuation feedRangeContinuation))
{
// Backward compatible with old format
feedRangeContinuation = new FeedRangeCompositeContinuation(
containerRid: string.Empty,
FeedRangeEpk.FullRange,
new List <Documents.Routing.Range <string> >()
{
new Documents.Routing.Range <string>(
Documents.Routing.PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey,
Documents.Routing.PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey,
isMinInclusive: true,
isMaxInclusive: false)
},
continuationToken);
}
// need to massage it a little
string oldContinuationFormat = feedRangeContinuation.ToString();
CosmosObject cosmosObject = CosmosObject.Parse(oldContinuationFormat);
CosmosArray continuations = (CosmosArray)cosmosObject["Continuation"];
List <CosmosElement> readFeedContinuationTokens = new List <CosmosElement>();
foreach (CosmosElement continuation in continuations)
{
CosmosObject continuationObject = (CosmosObject)continuation;
CosmosObject rangeObject = (CosmosObject)continuationObject["range"];
string min = ((CosmosString)rangeObject["min"]).Value;
string max = ((CosmosString)rangeObject["max"]).Value;
CosmosElement token = CosmosElement.Parse(((CosmosString)continuationObject["token"]).Value);
FeedRangeInternal feedRange = new FeedRangeEpk(new Documents.Routing.Range <string>(min, max, isMinInclusive: true, isMaxInclusive: false));
ReadFeedState state = new ReadFeedState(token);
ReadFeedContinuationToken readFeedContinuationToken = new ReadFeedContinuationToken(feedRange, state);
readFeedContinuationTokens.Add(ReadFeedContinuationToken.ToCosmosElement(readFeedContinuationToken));
}
CosmosArray cosmosArrayContinuationTokens = CosmosArray.Create(readFeedContinuationTokens);
continuationToken = cosmosArrayContinuationTokens.ToString();
}
}
this.monadicEnumerator = CrossPartitionReadFeedAsyncEnumerator.MonadicCreate(
documentContainer,
queryRequestOptions,
continuationToken: continuationToken,
pageSize,
cancellationToken);
this.hasMoreResults = true;
}