/// <summary>
/// Creates an IDistinctMap based on the type.
/// </summary>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <param name="distinctMapContinuationToken">The continuation token to resume from.</param>
/// <returns>The appropriate IDistinctMap.</returns>
public static TryCatch <DistinctMap> TryCreate(
DistinctQueryType distinctQueryType,
CosmosElement distinctMapContinuationToken)
{
TryCatch <DistinctMap> tryCreateDistinctMap;
switch (distinctQueryType)
{
case DistinctQueryType.None:
throw new ArgumentException("distinctQueryType can not be None. This part of code is not supposed to be reachable. Please contact support to resolve this issue.");
case DistinctQueryType.Unordered:
tryCreateDistinctMap = UnorderdDistinctMap.TryCreate(distinctMapContinuationToken);
break;
case DistinctQueryType.Ordered:
tryCreateDistinctMap = OrderedDistinctMap.TryCreate(distinctMapContinuationToken);
break;
default:
throw new ArgumentException($"Unrecognized DistinctQueryType: {distinctQueryType}.");
}
return(tryCreateDistinctMap);
}
/// <summary>
/// Creates an DistinctDocumentQueryExecutionComponent
/// </summary>
/// <param name="executionEnvironment">The environment to execute on.</param>
/// <param name="queryClient">The query client</param>
/// <param name="requestContinuation">The continuation token.</param>
/// <param name="createSourceCallback">The callback to create the source to drain from.</param>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <returns>A task to await on and in return </returns>
public static async Task <IDocumentQueryExecutionComponent> CreateAsync(
ExecutionEnvironment executionEnvironment,
CosmosQueryClient queryClient,
string requestContinuation,
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback,
DistinctQueryType distinctQueryType)
{
IDocumentQueryExecutionComponent distinctDocumentQueryExecutionComponent;
switch (executionEnvironment)
{
case ExecutionEnvironment.Client:
distinctDocumentQueryExecutionComponent = await ClientDistinctDocumentQueryExecutionComponent.CreateAsync(
queryClient,
requestContinuation,
createSourceCallback,
distinctQueryType);
break;
case ExecutionEnvironment.Compute:
distinctDocumentQueryExecutionComponent = await ComputeDistinctDocumentQueryExecutionComponent.CreateAsync(
queryClient,
requestContinuation,
createSourceCallback,
distinctQueryType);
break;
default:
throw new ArgumentException($"Unknown {nameof(ExecutionEnvironment)}: {executionEnvironment}.");
}
return(distinctDocumentQueryExecutionComponent);
}
private ComputeDistinctDocumentQueryExecutionComponent(
DistinctQueryType distinctQueryType,
DistinctMap distinctMap,
IDocumentQueryExecutionComponent source)
: base(distinctMap, source)
{
}
/// <summary>
/// Creates an DistinctDocumentQueryExecutionComponent
/// </summary>
/// <param name="queryClient">The query client</param>
/// <param name="requestContinuation">The continuation token.</param>
/// <param name="createSourceCallback">The callback to create the source to drain from.</param>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <returns>A task to await on and in return </returns>
public static async Task <DistinctDocumentQueryExecutionComponent> CreateAsync(
CosmosQueryClient queryClient,
string requestContinuation,
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback,
DistinctQueryType distinctQueryType)
{
DistinctContinuationToken distinctContinuationToken;
if (requestContinuation != null)
{
if (!DistinctContinuationToken.TryParse(requestContinuation, out distinctContinuationToken))
{
throw queryClient.CreateBadRequestException($"Invalid {nameof(DistinctContinuationToken)}: {requestContinuation}");
}
}
else
{
distinctContinuationToken = new DistinctContinuationToken(sourceToken: null, distinctMapToken: null);
}
DistinctMap distinctMap = DistinctMap.Create(distinctQueryType, distinctContinuationToken.DistinctMapToken);
IDocumentQueryExecutionComponent source = await createSourceCallback(distinctContinuationToken.SourceToken);
return(new ComputeDistinctDocumentQueryExecutionComponent(
distinctQueryType,
distinctMap,
source));
}
public static TryCatch <IQueryPipelineStage> MonadicCreate(
ExecutionEnvironment executionEnvironment,
CosmosElement requestContinuation,
CancellationToken cancellationToken,
MonadicCreatePipelineStage monadicCreatePipelineStage,
DistinctQueryType distinctQueryType) => executionEnvironment switch
{
private ClientDistinctDocumentQueryExecutionComponent(
DistinctQueryType distinctQueryType,
DistinctMap distinctMap,
IDocumentQueryExecutionComponent source)
: base(distinctMap, source)
{
if ((distinctQueryType != DistinctQueryType.Unordered) && (distinctQueryType != DistinctQueryType.Ordered))
{
throw new ArgumentException($"Unknown {nameof(DistinctQueryType)}: {distinctQueryType}.");
}
this.distinctQueryType = distinctQueryType;
}
private static async Task <List <CosmosElement> > CreateAndDrainAsync(
IReadOnlyList <IReadOnlyList <CosmosElement> > pages,
ExecutionEnvironment executionEnvironment,
CosmosElement continuationToken,
DistinctQueryType distinctQueryType)
{
IQueryPipelineStage source = new MockQueryPipelineStage(pages);
TryCatch <IQueryPipelineStage> tryCreateDistinctQueryPipelineStage = DistinctQueryPipelineStage.MonadicCreate(
executionEnvironment: executionEnvironment,
requestContinuation: continuationToken,
distinctQueryType: distinctQueryType,
cancellationToken: default,
private ClientDistinctQueryPipelineStage(
DistinctQueryType distinctQueryType,
DistinctMap distinctMap,
IQueryPipelineStage source,
CancellationToken cancellationToken)
: base(distinctMap, source, cancellationToken)
{
if ((distinctQueryType != DistinctQueryType.Unordered) && (distinctQueryType != DistinctQueryType.Ordered))
{
throw new ArgumentException($"Unknown {nameof(DistinctQueryType)}: {distinctQueryType}.");
}
this.distinctQueryType = distinctQueryType;
}
/// <summary>
/// Initializes a new instance of the DistinctDocumentQueryExecutionComponent class.
/// </summary>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <param name="previousHash">The previous that distinct map saw.</param>
/// <param name="source">The source to drain from.</param>
private DistinctDocumentQueryExecutionComponent(
DistinctQueryType distinctQueryType,
UInt192?previousHash,
IDocumentQueryExecutionComponent source)
: base(source)
{
if (distinctQueryType == DistinctQueryType.None)
{
throw new ArgumentException("It doesn't make sense to create a distinct component of type None.");
}
this.distinctQueryType = distinctQueryType;
this.distinctMap = DistinctMap.Create(distinctQueryType, previousHash);
}
/// <summary>
/// Creates an IDistinctMap based on the type.
/// </summary>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <param name="previousHash">The hash of the previous value successfully inserted into this DistinctMap</param>
/// <returns>The appropriate IDistinctMap.</returns>
public static DistinctMap Create(DistinctQueryType distinctQueryType, UInt192? previousHash)
{
switch (distinctQueryType)
{
case DistinctQueryType.None:
throw new ArgumentException("distinctQueryType can not be None. This part of code is not supposed to be reachable. Please contact support to resolve this issue.");
case DistinctQueryType.Unordered:
return new UnorderdDistinctMap();
case DistinctQueryType.Ordered:
return new OrderedDistinctMap(previousHash.GetValueOrDefault());
default:
throw new ArgumentException($"Unrecognized DistinctQueryType: {distinctQueryType}.");
}
}
public static TryCatch <IQueryPipelineStage> MonadicCreate(
CosmosElement requestContinuation,
CancellationToken cancellationToken,
MonadicCreatePipelineStage monadicCreatePipelineStage,
DistinctQueryType distinctQueryType)
{
if (monadicCreatePipelineStage == null)
{
throw new ArgumentNullException(nameof(monadicCreatePipelineStage));
}
DistinctContinuationToken distinctContinuationToken;
if (requestContinuation != null)
{
if (!DistinctContinuationToken.TryParse(requestContinuation, out distinctContinuationToken))
{
return(TryCatch <IQueryPipelineStage> .FromException(
new MalformedContinuationTokenException(
$"Invalid {nameof(DistinctContinuationToken)}: {requestContinuation}")));
}
}
else
{
distinctContinuationToken = new DistinctContinuationToken(sourceToken: null, distinctMapToken: null);
}
TryCatch <DistinctMap> tryCreateDistinctMap = DistinctMap.TryCreate(
distinctQueryType,
distinctContinuationToken.DistinctMapToken);
if (!tryCreateDistinctMap.Succeeded)
{
return(TryCatch <IQueryPipelineStage> .FromException(tryCreateDistinctMap.Exception));
}
TryCatch <IQueryPipelineStage> tryCreateSource = monadicCreatePipelineStage(distinctContinuationToken.SourceToken, cancellationToken);
if (!tryCreateSource.Succeeded)
{
return(TryCatch <IQueryPipelineStage> .FromException(tryCreateSource.Exception));
}
return(TryCatch <IQueryPipelineStage> .FromResult(
new ComputeDistinctQueryPipelineStage(
tryCreateDistinctMap.Result,
tryCreateSource.Result,
cancellationToken)));
}
public static async Task <TryCatch <IDocumentQueryExecutionComponent> > TryCreateAsync(
CosmosElement requestContinuation,
Func <CosmosElement, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync,
DistinctQueryType distinctQueryType)
{
if (tryCreateSourceAsync == null)
{
throw new ArgumentNullException(nameof(tryCreateSourceAsync));
}
DistinctContinuationToken distinctContinuationToken;
if (requestContinuation != null)
{
if (!DistinctContinuationToken.TryParse(requestContinuation, out distinctContinuationToken))
{
return(TryCatch <IDocumentQueryExecutionComponent> .FromException(
new MalformedContinuationTokenException($"Invalid {nameof(DistinctContinuationToken)}: {requestContinuation}")));
}
}
else
{
distinctContinuationToken = new DistinctContinuationToken(sourceToken: null, distinctMapToken: null);
}
TryCatch <DistinctMap> tryCreateDistinctMap = DistinctMap.TryCreate(
distinctQueryType,
distinctContinuationToken.DistinctMapToken);
if (!tryCreateDistinctMap.Succeeded)
{
return(TryCatch <IDocumentQueryExecutionComponent> .FromException(tryCreateDistinctMap.Exception));
}
TryCatch <IDocumentQueryExecutionComponent> tryCreateSource = await tryCreateSourceAsync(
distinctContinuationToken.SourceToken);
if (!tryCreateSource.Succeeded)
{
return(TryCatch <IDocumentQueryExecutionComponent> .FromException(tryCreateSource.Exception));
}
return(TryCatch <IDocumentQueryExecutionComponent> .FromResult(
new ComputeDistinctDocumentQueryExecutionComponent(
distinctQueryType,
tryCreateDistinctMap.Result,
tryCreateSource.Result)));
}
/// <summary>
/// Creates an IDistinctMap based on the type.
/// </summary>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <param name="distinctMapContinuationToken">The continuation token to resume from.</param>
/// <returns>The appropriate IDistinctMap.</returns>
public static DistinctMap Create(
DistinctQueryType distinctQueryType,
string distinctMapContinuationToken)
{
switch (distinctQueryType)
{
case DistinctQueryType.None:
throw new ArgumentException("distinctQueryType can not be None. This part of code is not supposed to be reachable. Please contact support to resolve this issue.");
case DistinctQueryType.Unordered:
return(UnorderdDistinctMap.Create(distinctMapContinuationToken));
case DistinctQueryType.Ordered:
return(OrderedDistinctMap.Create(distinctMapContinuationToken));
default:
throw new ArgumentException($"Unrecognized DistinctQueryType: {distinctQueryType}.");
}
}
/// <summary>
/// Creates an DistinctDocumentQueryExecutionComponent
/// </summary>
/// <param name="requestContinuation">The continuation token.</param>
/// <param name="createSourceCallback">The callback to create the source to drain from.</param>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <returns>A task to await on and in return </returns>
public static async Task <IDocumentQueryExecutionComponent> CreateAsync(
string requestContinuation,
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback,
DistinctQueryType distinctQueryType)
{
DistinctContinuationToken distinctContinuationToken = new DistinctContinuationToken(null, null);
if (requestContinuation != null)
{
distinctContinuationToken = DistinctContinuationToken.Parse(requestContinuation);
if (distinctQueryType != DistinctQueryType.Ordered && distinctContinuationToken.LastHash != null)
{
throw new BadRequestException($"DistinctContinuationToken is malformed: {distinctContinuationToken}. DistinctContinuationToken can not have a 'lastHash', when the query type is not ordered (ex SELECT DISTINCT VALUE c.blah FROM c ORDER BY c.blah).");
}
}
return(new DistinctDocumentQueryExecutionComponent(
distinctQueryType,
distinctContinuationToken.LastHash,
await createSourceCallback(distinctContinuationToken.SourceToken)));
}
public static async Task <TryCatch <IDocumentQueryExecutionComponent> > TryCreateAsync(
ExecutionEnvironment executionEnvironment,
CosmosElement requestContinuation,
Func <CosmosElement, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync,
DistinctQueryType distinctQueryType)
{
if (tryCreateSourceAsync == null)
{
throw new ArgumentNullException(nameof(tryCreateSourceAsync));
}
TryCatch <IDocumentQueryExecutionComponent> tryCreateDistinctDocumentQueryExecutionComponent;
switch (executionEnvironment)
{
case ExecutionEnvironment.Client:
tryCreateDistinctDocumentQueryExecutionComponent = await ClientDistinctDocumentQueryExecutionComponent.TryCreateAsync(
requestContinuation,
tryCreateSourceAsync,
distinctQueryType);
break;
case ExecutionEnvironment.Compute:
tryCreateDistinctDocumentQueryExecutionComponent = await ComputeDistinctDocumentQueryExecutionComponent.TryCreateAsync(
requestContinuation,
tryCreateSourceAsync,
distinctQueryType);
break;
default:
throw new ArgumentException($"Unknown {nameof(ExecutionEnvironment)}: {executionEnvironment}.");
}
return(tryCreateDistinctDocumentQueryExecutionComponent);
}
public static TryCatch <IQueryPipelineStage> MonadicCreate(
CosmosElement requestContinuation,
CancellationToken cancellationToken,
MonadicCreatePipelineStage monadicCreatePipelineStage,
DistinctQueryType distinctQueryType)
{
if (monadicCreatePipelineStage == null)
{
throw new ArgumentNullException(nameof(monadicCreatePipelineStage));
}
DistinctContinuationToken distinctContinuationToken;
if (requestContinuation != null)
{
if (!DistinctContinuationToken.TryParse(requestContinuation, out distinctContinuationToken))
{
return(TryCatch <IQueryPipelineStage> .FromException(
new MalformedContinuationTokenException(
$"Invalid {nameof(DistinctContinuationToken)}: {requestContinuation}")));
}
}
else
{
distinctContinuationToken = new DistinctContinuationToken(
sourceToken: null,
distinctMapToken: null);
}
CosmosElement distinctMapToken = distinctContinuationToken.DistinctMapToken != null
? CosmosString.Create(distinctContinuationToken.DistinctMapToken)
: null;
TryCatch <DistinctMap> tryCreateDistinctMap = DistinctMap.TryCreate(
distinctQueryType,
distinctMapToken);
if (!tryCreateDistinctMap.Succeeded)
{
return(TryCatch <IQueryPipelineStage> .FromException(tryCreateDistinctMap.Exception));
}
CosmosElement sourceToken;
if (distinctContinuationToken.SourceToken != null)
{
TryCatch <CosmosElement> tryParse = CosmosElement.Monadic.Parse(distinctContinuationToken.SourceToken);
if (tryParse.Failed)
{
return(TryCatch <IQueryPipelineStage> .FromException(
new MalformedContinuationTokenException(
message : $"Invalid Source Token: {distinctContinuationToken.SourceToken}",
innerException : tryParse.Exception)));
}
sourceToken = tryParse.Result;
}
else
{
sourceToken = null;
}
TryCatch <IQueryPipelineStage> tryCreateSource = monadicCreatePipelineStage(sourceToken, cancellationToken);
if (!tryCreateSource.Succeeded)
{
return(TryCatch <IQueryPipelineStage> .FromException(tryCreateSource.Exception));
}
return(TryCatch <IQueryPipelineStage> .FromResult(
new ClientDistinctQueryPipelineStage(
distinctQueryType,
tryCreateDistinctMap.Result,
tryCreateSource.Result,
cancellationToken)));
}
/// <summary>
/// Creates an IDistinctMap based on the type.
/// </summary>
/// <param name="distinctQueryType">The type of distinct query.</param>
/// <param name="distinctMapContinuationToken">The continuation token to resume from.</param>
/// <returns>The appropriate IDistinctMap.</returns>
public static TryCatch <DistinctMap> TryCreate(
DistinctQueryType distinctQueryType,
CosmosElement distinctMapContinuationToken) => distinctQueryType switch
{