public override async Task<IEnumerable<string>> GetPartitionKeyRangesAsync(
IRoutingMapProvider routingMapProvider,
string containerRid,
Documents.PartitionKeyDefinition partitionKeyDefinition,
CancellationToken cancellationToken)
{
string effectivePartitionKeyString = this.PartitionKey.InternalKey.GetEffectivePartitionKeyString(partitionKeyDefinition);
Documents.PartitionKeyRange range = await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(containerRid, effectivePartitionKeyString);
return new List<string>() { range.Id };
}
public virtual async Task <bool> TryAddPartitionKeyRangeToContinuationTokenAsync(
INameValueCollection backendResponseHeaders,
IReadOnlyList <Range <string> > providedPartitionKeyRanges,
IRoutingMapProvider routingMapProvider,
string collectionRid,
ResolvedRangeInfo resolvedRangeInfo,
RntdbEnumerationDirection direction = RntdbEnumerationDirection.Forward)
{
Debug.Assert(resolvedRangeInfo.ResolvedRange != null, "ResolvedRange can't be null");
PartitionKeyRange currentRange = resolvedRangeInfo.ResolvedRange;
// IF : Split happened, or already had multiple target ranges in the continuation
if (resolvedRangeInfo.ContinuationTokens != null && resolvedRangeInfo.ContinuationTokens.Count > 1)
{
if (!string.IsNullOrEmpty(backendResponseHeaders[HttpConstants.HttpHeaders.Continuation]))
{
resolvedRangeInfo.ContinuationTokens[0].Token = backendResponseHeaders[HttpConstants.HttpHeaders.Continuation];
}
else
{
resolvedRangeInfo.ContinuationTokens.RemoveAt(0);
}
backendResponseHeaders[HttpConstants.HttpHeaders.Continuation] = JsonConvert.SerializeObject(resolvedRangeInfo.ContinuationTokens);
}
else
{
//// ELSE: Single target Range was provided, and no split happened
PartitionKeyRange rangeToUse = currentRange;
// We only need to get the next range if we have to
if (string.IsNullOrEmpty(backendResponseHeaders[HttpConstants.HttpHeaders.Continuation]))
{
if (direction == RntdbEnumerationDirection.Reverse)
{
rangeToUse = PartitionRoutingHelper.MinBefore(
(await routingMapProvider.TryGetOverlappingRangesAsync(collectionRid, providedPartitionKeyRanges.Single())).ToList(),
currentRange);
}
else
{
Range <string> nextProvidedRange = PartitionRoutingHelper.MinAfter(
providedPartitionKeyRanges,
currentRange.ToRange(),
Range <string> .MaxComparer.Instance);
if (nextProvidedRange == null)
{
return(true);
}
string max = string.CompareOrdinal(nextProvidedRange.Min, currentRange.MaxExclusive) > 0
? nextProvidedRange.Min
: currentRange.MaxExclusive;
if (string.CompareOrdinal(max, PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey) == 0)
{
return(true);
}
PartitionKeyRange nextRange = await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(collectionRid, max);
if (nextRange == null)
{
return(false);
}
rangeToUse = nextRange;
}
}
if (rangeToUse != null)
{
backendResponseHeaders[HttpConstants.HttpHeaders.Continuation] = PartitionRoutingHelper.AddPartitionKeyRangeToContinuationToken(
backendResponseHeaders[HttpConstants.HttpHeaders.Continuation],
rangeToUse);
}
}
return(true);
}
/// <summary>
/// Gets <see cref="PartitionKeyRange"/> instance which corresponds to <paramref name="rangeFromContinuationToken"/>
/// </summary>
/// <param name="providedPartitionKeyRanges"></param>
/// <param name="routingMapProvider"></param>
/// <param name="collectionRid"></param>
/// <param name="rangeFromContinuationToken"></param>
/// <param name="suppliedTokens"></param>
/// <param name="direction"></param>
/// <returns>null if collection with specified <paramref name="collectionRid"/> doesn't exist, which potentially means
/// that collection was resolved to outdated Rid by name. Also null can be returned if <paramref name="rangeFromContinuationToken"/>
/// is not found - this means it was split.
/// </returns>
public virtual async Task <ResolvedRangeInfo> TryGetTargetRangeFromContinuationTokenRangeAsync(
IReadOnlyList <Range <string> > providedPartitionKeyRanges,
IRoutingMapProvider routingMapProvider,
string collectionRid,
Range <string> rangeFromContinuationToken,
List <CompositeContinuationToken> suppliedTokens,
RntdbEnumerationDirection direction = RntdbEnumerationDirection.Forward)
{
// For queries such as "SELECT * FROM root WHERE false",
// we will have empty ranges and just forward the request to the first partition
if (providedPartitionKeyRanges.Count == 0)
{
return(new ResolvedRangeInfo(
await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(
collectionRid,
PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey),
suppliedTokens));
}
// Initially currentRange will be empty
if (rangeFromContinuationToken.IsEmpty)
{
if (direction == RntdbEnumerationDirection.Reverse)
{
PartitionKeyRange lastPartitionKeyRange = (await routingMapProvider.TryGetOverlappingRangesAsync(collectionRid, providedPartitionKeyRanges.Single())).Last();
return(new ResolvedRangeInfo(
lastPartitionKeyRange,
suppliedTokens));
}
Range <string> minimumRange = PartitionRoutingHelper.Min(
providedPartitionKeyRanges,
Range <string> .MinComparer.Instance);
return(new ResolvedRangeInfo(
await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(collectionRid, minimumRange.Min),
suppliedTokens));
}
PartitionKeyRange targetPartitionKeyRange = await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(collectionRid, rangeFromContinuationToken.Min);
if (targetPartitionKeyRange == null)
{
return(new ResolvedRangeInfo(null, suppliedTokens));
}
if (!rangeFromContinuationToken.Equals(targetPartitionKeyRange.ToRange()))
{
// Cannot find target range. Either collection was resolved incorrectly or the range was split
List <PartitionKeyRange> replacedRanges = (await routingMapProvider.TryGetOverlappingRangesAsync(collectionRid, rangeFromContinuationToken, true)).ToList();
if (replacedRanges == null || replacedRanges.Count < 1)
{
return(new ResolvedRangeInfo(null, null));
}
else
{
if (!(replacedRanges[0].MinInclusive.Equals(rangeFromContinuationToken.Min) && replacedRanges[replacedRanges.Count - 1].MaxExclusive.Equals(rangeFromContinuationToken.Max)))
{
return(new ResolvedRangeInfo(null, null));
}
}
if (direction == RntdbEnumerationDirection.Reverse)
{
replacedRanges.Reverse();
}
List <CompositeContinuationToken> continuationTokensToBePersisted = null;
if (suppliedTokens != null && suppliedTokens.Count > 0)
{
continuationTokensToBePersisted = new List <CompositeContinuationToken>(replacedRanges.Count + suppliedTokens.Count - 1);
foreach (PartitionKeyRange partitionKeyRange in replacedRanges)
{
CompositeContinuationToken token = (CompositeContinuationToken)suppliedTokens[0].ShallowCopy();
token.Range = partitionKeyRange.ToRange();
continuationTokensToBePersisted.Add(token);
}
continuationTokensToBePersisted.AddRange(suppliedTokens.Skip(1));
}
return(new ResolvedRangeInfo(replacedRanges[0], continuationTokensToBePersisted));
}
return(new ResolvedRangeInfo(targetPartitionKeyRange, suppliedTokens));
}
