static AccessControlList()
{
PrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(M.AccessControl.CacheId.RoleType)
.WithRule(M.AccessControl.EffectiveUsers)
.WithRule(M.AccessControl.EffectivePermissions)
.Build();
}
static SecurityResponseBuilder()
{
AccessControlPrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(M.AccessControl.EffectiveWorkspacePermissions)
.Build();
PermissionPrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(M.Permission.ConcreteClassPointer)
.WithRule(M.Permission.OperandTypePointer)
.WithRule(M.Permission.OperationEnum)
.Build();
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params long[] objectIds)
{
var references = this.Prefetcher.GetReferencesForPrefetching(new HashSet <long>(objectIds));
if (references.Count != 0)
{
this.Flush();
var prefetcher = new Prefetch(this.Prefetcher, prefetchPolicy, references);
prefetcher.Execute();
}
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <long> objectIds)
{
var references = this.Prefetcher.GetReferencesForPrefetching(objectIds);
if (references.Count != 0)
{
this.Flush();
var prefetcher = new Prefetch(this.Prefetcher, prefetchPolicy, references);
prefetcher.Execute();
}
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params string[] objectIdStrings)
{
var objectIds = new HashSet <long>(objectIdStrings.Select(v => long.Parse(v)));
var references = this.Prefetcher.GetReferencesForPrefetching(objectIds);
if (references.Count != 0)
{
this.Flush();
var prefetcher = new Prefetch(this.Prefetcher, prefetchPolicy, references);
prefetcher.Execute();
}
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params IStrategy[] strategies)
{
var objectIds = new HashSet <long>(strategies.Select(x => x.ObjectId));
var references = this.Prefetcher.GetReferencesForPrefetching(objectIds);
if (references.Count != 0)
{
this.Flush();
var prefetcher = new Prefetch(this.Prefetcher, prefetchPolicy, references);
prefetcher.Execute();
}
}
public CrossPartitionRangePageAsyncEnumerable(
IFeedRangeProvider feedRangeProvider,
CreatePartitionRangePageAsyncEnumerator <TPage, TState> createPartitionRangeEnumerator,
IComparer <PartitionRangePageAsyncEnumerator <TPage, TState> > comparer,
int maxConcurrency,
PrefetchPolicy prefetchPolicy,
ITrace trace,
CrossFeedRangeState <TState> state = default)
{
this.feedRangeProvider = feedRangeProvider ?? throw new ArgumentNullException(nameof(comparer));
this.createPartitionRangeEnumerator = createPartitionRangeEnumerator ?? throw new ArgumentNullException(nameof(createPartitionRangeEnumerator));
this.comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
this.state = state;
this.maxConcurrency = maxConcurrency < 0 ? throw new ArgumentOutOfRangeException(nameof(maxConcurrency)) : maxConcurrency;
this.prefetchPolicy = prefetchPolicy;
this.trace = trace ?? throw new ArgumentNullException(nameof(trace));
}
public static TryCatch <IQueryPipelineStage> MonadicCreate(
IDocumentContainer documentContainer,
SqlQuerySpec sqlQuerySpec,
IReadOnlyList <FeedRangeEpk> targetRanges,
Cosmos.PartitionKey?partitionKey,
QueryPaginationOptions queryPaginationOptions,
int maxConcurrency,
PrefetchPolicy prefetchPolicy,
CosmosElement continuationToken,
CancellationToken cancellationToken)
{
if (targetRanges == null)
{
throw new ArgumentNullException(nameof(targetRanges));
}
if (targetRanges.Count == 0)
{
throw new ArgumentException($"{nameof(targetRanges)} must have some elements");
}
TryCatch <CrossFeedRangeState <QueryState> > monadicExtractState = MonadicExtractState(continuationToken, targetRanges);
if (monadicExtractState.Failed)
{
return(TryCatch <IQueryPipelineStage> .FromException(monadicExtractState.Exception));
}
CrossFeedRangeState <QueryState> state = monadicExtractState.Result;
CrossPartitionRangePageAsyncEnumerator <QueryPage, QueryState> crossPartitionPageEnumerator = new CrossPartitionRangePageAsyncEnumerator <QueryPage, QueryState>(
feedRangeProvider: documentContainer,
createPartitionRangeEnumerator: ParallelCrossPartitionQueryPipelineStage.MakeCreateFunction(documentContainer, sqlQuerySpec, queryPaginationOptions, partitionKey, cancellationToken),
comparer: Comparer.Singleton,
maxConcurrency: maxConcurrency,
prefetchPolicy: prefetchPolicy,
state: state,
cancellationToken: cancellationToken);
ParallelCrossPartitionQueryPipelineStage stage = new ParallelCrossPartitionQueryPipelineStage(crossPartitionPageEnumerator, cancellationToken);
return(TryCatch <IQueryPipelineStage> .FromResult(stage));
}
public PrefetchRule(IPropertyType propertyType, PrefetchPolicy prefetchPolicy)
{
if (propertyType == null)
{
throw new ArgumentNullException("propertyType");
}
if (prefetchPolicy != null)
{
var roleType = propertyType as IRoleType;
if (roleType != null && roleType.ObjectType.IsUnit)
{
throw new ArgumentException("prefetchPolicy");
}
}
this.propertyType = propertyType;
this.prefetchPolicy = prefetchPolicy;
}
public CrossPartitionRangePageAsyncEnumerator(
IFeedRangeProvider feedRangeProvider,
CreatePartitionRangePageAsyncEnumerator <TPage, TState> createPartitionRangeEnumerator,
IComparer <PartitionRangePageAsyncEnumerator <TPage, TState> > comparer,
int?maxConcurrency,
PrefetchPolicy prefetchPolicy,
CancellationToken cancellationToken,
CrossFeedRangeState <TState> state = default)
{
this.feedRangeProvider = feedRangeProvider ?? throw new ArgumentNullException(nameof(feedRangeProvider));
this.createPartitionRangeEnumerator = createPartitionRangeEnumerator ?? throw new ArgumentNullException(nameof(createPartitionRangeEnumerator));
this.cancellationToken = cancellationToken;
this.lazyEnumerators = new AsyncLazy <IQueue <PartitionRangePageAsyncEnumerator <TPage, TState> > >((ITrace trace, CancellationToken token) =>
InitializeEnumeratorsAsync(
feedRangeProvider,
createPartitionRangeEnumerator,
comparer,
maxConcurrency,
prefetchPolicy,
state,
trace,
token));
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <IObject> objects) => this.Prefetch(prefetchPolicy, objects.Select(x => x.Strategy.ObjectId));
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <IObject> objects)
{
// nop
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params IObject[] objects) => this.Prefetch(prefetchPolicy, objects.Select(x => x.Strategy.ObjectId));
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <long> objectIds)
{
// nop
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <IStrategy> strategies)
{
// nop
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params string[] objectIds)
{
// nop
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params IStrategy[] strategies)
{
// nop
}
static PermissionCache()
{
PrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(M.Permission.ConcreteClassPointer)
.Build();
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <IStrategy> strategies) => this.Prefetch(prefetchPolicy, strategies.Select(v => v.ObjectId));
public PrefetchPolicyBuilder WithRule(IPropertyType propertyType, PrefetchPolicy prefetch)
{
var rule = new PrefetchRule(propertyType, prefetch);
this.rules.Add(rule);
return this;
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <string> objectIdStrings) => this.Prefetch(prefetchPolicy, objectIdStrings.Select(long.Parse));
public static TryCatch <IQueryPipelineStage> MonadicCreate(
ExecutionEnvironment executionEnvironment,
IDocumentContainer documentContainer,
SqlQuerySpec sqlQuerySpec,
IReadOnlyList <FeedRangeEpk> targetRanges,
PartitionKey?partitionKey,
QueryInfo queryInfo,
QueryPaginationOptions queryPaginationOptions,
int maxConcurrency,
CosmosElement requestContinuationToken,
CancellationToken requestCancellationToken)
{
if (documentContainer == null)
{
throw new ArgumentNullException(nameof(documentContainer));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (targetRanges == null)
{
throw new ArgumentNullException(nameof(targetRanges));
}
if (targetRanges.Count == 0)
{
throw new ArgumentException($"{nameof(targetRanges)} must not be empty.");
}
if (queryInfo == null)
{
throw new ArgumentNullException(nameof(queryInfo));
}
sqlQuerySpec = !string.IsNullOrEmpty(queryInfo.RewrittenQuery) ? new SqlQuerySpec(queryInfo.RewrittenQuery, sqlQuerySpec.Parameters) : sqlQuerySpec;
PrefetchPolicy prefetchPolicy = DeterminePrefetchPolicy(queryInfo);
MonadicCreatePipelineStage monadicCreatePipelineStage;
if (queryInfo.HasOrderBy)
{
monadicCreatePipelineStage = (continuationToken, cancellationToken) => OrderByCrossPartitionQueryPipelineStage.MonadicCreate(
documentContainer: documentContainer,
sqlQuerySpec: sqlQuerySpec,
targetRanges: targetRanges,
partitionKey: partitionKey,
orderByColumns: queryInfo
.OrderByExpressions
.Zip(queryInfo.OrderBy, (expression, sortOrder) => new OrderByColumn(expression, sortOrder)).ToList(),
queryPaginationOptions: queryPaginationOptions,
maxConcurrency: maxConcurrency,
continuationToken: continuationToken,
cancellationToken: cancellationToken);
}
else
{
monadicCreatePipelineStage = (continuationToken, cancellationToken) => ParallelCrossPartitionQueryPipelineStage.MonadicCreate(
documentContainer: documentContainer,
sqlQuerySpec: sqlQuerySpec,
targetRanges: targetRanges,
queryPaginationOptions: queryPaginationOptions,
partitionKey: partitionKey,
prefetchPolicy: prefetchPolicy,
maxConcurrency: maxConcurrency,
continuationToken: continuationToken,
cancellationToken: cancellationToken);
}
if (queryInfo.HasAggregates && !queryInfo.HasGroupBy)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => AggregateQueryPipelineStage.MonadicCreate(
executionEnvironment,
queryInfo.Aggregates,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue,
continuationToken,
cancellationToken,
monadicCreateSourceStage);
}
if (queryInfo.HasDistinct)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => DistinctQueryPipelineStage.MonadicCreate(
executionEnvironment,
continuationToken,
cancellationToken,
monadicCreateSourceStage,
queryInfo.DistinctType);
}
if (queryInfo.HasGroupBy)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => GroupByQueryPipelineStage.MonadicCreate(
executionEnvironment,
continuationToken,
cancellationToken,
monadicCreateSourceStage,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue,
(queryPaginationOptions ?? QueryPaginationOptions.Default).PageSizeLimit.GetValueOrDefault(int.MaxValue));
}
if (queryInfo.HasOffset)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => SkipQueryPipelineStage.MonadicCreate(
executionEnvironment,
queryInfo.Offset.Value,
continuationToken,
cancellationToken,
monadicCreateSourceStage);
}
if (queryInfo.HasLimit)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => TakeQueryPipelineStage.MonadicCreateLimitStage(
executionEnvironment,
queryInfo.Limit.Value,
continuationToken,
cancellationToken,
monadicCreateSourceStage);
}
if (queryInfo.HasTop)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => TakeQueryPipelineStage.MonadicCreateTopStage(
executionEnvironment,
queryInfo.Top.Value,
continuationToken,
cancellationToken,
monadicCreateSourceStage);
}
if (queryInfo.HasDCount)
{
MonadicCreatePipelineStage monadicCreateSourceStage = monadicCreatePipelineStage;
monadicCreatePipelineStage = (continuationToken, cancellationToken) => DCountQueryPipelineStage.MonadicCreate(
executionEnvironment,
queryInfo.DCountInfo,
continuationToken,
cancellationToken,
monadicCreateSourceStage);
}
return(monadicCreatePipelineStage(requestContinuationToken, requestCancellationToken)
.Try <IQueryPipelineStage>(onSuccess: (stage) => new SkipEmptyPageQueryPipelineStage(stage, requestCancellationToken)));
}
public Prefetcher(Session session, PrefetchPolicy prefetchPolicy, List<Reference> references)
{
this.session = session;
this.references = references;
this.prefetchPolicy = prefetchPolicy;
}
public void Prefetch(PrefetchPolicy prefetchPolicy, long[] objectIds)
{
// nop
}
public Prefetch(Prefetcher prefetcher, PrefetchPolicy prefetchPolicy, HashSet <Reference> references)
{
this.prefetcher = prefetcher;
this.references = references;
this.prefetchPolicy = prefetchPolicy;
}
public void Prefetch(PrefetchPolicy prefetchPolicy, IEnumerable <string> objectIds)
{
}
private Prefetcher(Session session, PrefetchPolicy prefetchPolicy, IEnumerable<ObjectId> objectIds)
{
this.session = session;
this.prefetchPolicy = prefetchPolicy;
this.references = session.GetReferences(objectIds);
}
public void Prefetch(PrefetchPolicy prefetchPolicy, params IObject[] objects)
{
// nop
}
