public void CombinedTest() { var parameter = new Parameter <int>(); Assert.AreEqual(null, parameter.ExpectedValue); Assert.IsFalse(parameter.IsExpectedValueSet); parameter = new Parameter <int>(1); Assert.AreEqual(1, parameter.ExpectedValue); AssertEx.Throws <Exception>(delegate { parameter.Value = 5; }); var firstContext = new ParameterContext(); using (firstContext.Activate()) { AssertEx.Throws <InvalidOperationException>(delegate { int i = parameter.Value; }); parameter.Value = 10; Assert.AreEqual(10, parameter.Value); using (ParameterContext.ExpectedValues.Activate()) { Assert.AreEqual(1, parameter.Value); AssertEx.ThrowsInvalidOperationException(() => parameter.Value = 1); } Assert.AreEqual(10, parameter.Value); parameter.Value = 15; Assert.AreEqual(15, parameter.Value); using (new ParameterContext().Activate()) { Assert.AreEqual(15, parameter.Value); parameter.Value = 20; Assert.AreEqual(20, parameter.Value); // Reactivating first context using (firstContext.Activate()) { Assert.AreEqual(15, parameter.Value); parameter.Value = 25; } Assert.AreEqual(20, parameter.Value); } Assert.AreEqual(25, parameter.Value); } AssertEx.Throws <Exception>(delegate { int i = parameter.Value; }); }
private static IEnumerable <TResult> SubqueryMaterialize <TResult>(IEnumerable <TResult> materializedSequence, ParameterContext parameterContext) { ParameterScope scope = null; var batchSequence = materializedSequence .Batch(BatchFastFirstCount, BatchMinSize, BatchMaxSize) .ApplyBeforeAndAfter( () => scope = parameterContext.Activate(), () => scope.DisposeSafely()); return(batchSequence.SelectMany(batch => batch)); }
private ParameterContext CreateParameterContext <TResult>(ParameterizedQuery <TResult> query) { var parameterContext = new ParameterContext(); if (query.QueryParameter != null) { using (parameterContext.Activate()) query.QueryParameter.Value = queryTarget; } return(parameterContext); }
private QueryTask CreateQueryTask(List <Tuple> currentKeySet) { var parameterContext = new ParameterContext(); using (parameterContext.Activate()) { includeParameter.Value = currentKeySet; object key = new Pair <object, CacheKey>(recordSetCachingRegion, cacheKey); Func <object, object> generator = CreateRecordSet; var session = manager.Owner.Session; Provider = (CompilableProvider)session.StorageNode.InternalQueryCache.GetOrAdd(key, generator); var executableProvider = session.Compile(Provider); return(new QueryTask(executableProvider, session.GetLifetimeToken(), parameterContext)); } }
private QueryTask CreateQueryTask() { var parameterContext = new ParameterContext(); using (parameterContext.Activate()) { ownerParameter.Value = ownerKey.Value; if (ItemCountLimit != null) { itemCountLimitParameter.Value = ItemCountLimit.Value; } object key = new Pair <object, CacheKey>(itemsQueryCachingRegion, cacheKey); Func <object, object> generator = CreateRecordSetLoadingItems; var session = manager.Owner.Session; QueryProvider = (CompilableProvider)session.StorageNode.InternalQueryCache.GetOrAdd(key, generator); var executableProvider = session.Compile(QueryProvider); return(new QueryTask(executableProvider, session.GetLifetimeToken(), parameterContext)); } }
/// <summary> /// Materializes the specified data source. /// </summary> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="dataSource">The data source.</param> /// <param name="context">The context.</param> /// <param name="parameterContext">The parameter context.</param> /// <param name="itemMaterializer">The item materializer.</param> /// <param name="tupleParameterBindings">The tuple parameter bindings.</param> public static IEnumerable <TResult> Materialize <TResult>(IEnumerable <Tuple> dataSource, MaterializationContext context, ParameterContext parameterContext, Func <Tuple, ItemMaterializationContext, TResult> itemMaterializer, Dictionary <Parameter <Tuple>, Tuple> tupleParameterBindings) { using (parameterContext.Activate()) foreach (var tupleParameterBinding in tupleParameterBindings) { tupleParameterBinding.Key.Value = tupleParameterBinding.Value; } var session = context.Session; var recordSet = dataSource as RecordSet; if (recordSet != null) { var enumerationContext = (EnumerationContext)recordSet.Context; enumerationContext.MaterializationContext = context; } var materializedSequence = dataSource .Select(tuple => itemMaterializer.Invoke(tuple, new ItemMaterializationContext(context, session))); return(context.MaterializationQueue == null ? BatchMaterialize(materializedSequence, context, parameterContext) : SubqueryMaterialize(materializedSequence, parameterContext)); }
// Constructors // ReSharper disable MemberCanBeProtected.Global public SubQuery(ProjectionExpression projectionExpression, TranslatedQuery query, Parameter <Tuple> parameter, Tuple tuple, ItemMaterializationContext context) // ReSharper restore MemberCanBeProtected.Global { this.provider = context.Session.Query.Provider; var tupleParameterBindings = new Dictionary <Parameter <Tuple>, Tuple>(projectionExpression.TupleParameterBindings); var currentTranslatedQuery = ((TranslatedQuery <IEnumerable <TElement> >)query); // Gather Parameter<Tuple> values from current ParameterScope for future use. parameter.Value = tuple; foreach (var tupleParameter in currentTranslatedQuery.TupleParameters) { var value = tupleParameter.Value; tupleParameterBindings[tupleParameter] = value; } var parameterContext = new ParameterContext(); using (parameterContext.Activate()) foreach (var tupleParameter in currentTranslatedQuery.TupleParameters) { tupleParameter.Value = tupleParameter.Value; } this.projectionExpression = new ProjectionExpression( projectionExpression.Type, projectionExpression.ItemProjector, tupleParameterBindings, projectionExpression.ResultType); var translatedQuery = new TranslatedQuery <IEnumerable <TElement> >( query.DataSource, (Func <IEnumerable <Tuple>, Session, Dictionary <Parameter <Tuple>, Tuple>, ParameterContext, IEnumerable <TElement> >)query.UntypedMaterializer, tupleParameterBindings, EnumerableUtils <Parameter <Tuple> > .Empty); delayedSequence = new DelayedSequence <TElement>(context.Session, translatedQuery, parameterContext); context.Session.RegisterUserDefinedDelayedQuery(delayedSequence.Task); context.MaterializationContext.MaterializationQueue.Enqueue(MaterializeSelf); }
/// <summary> /// Gets the references to specified entity. /// </summary> /// <param name="target">The target.</param> /// <param name="association">The association.</param> /// <returns>References.</returns> public virtual IEnumerable <ReferenceInfo> GetReferencesTo(Entity target, AssociationInfo association) { if (association.IsPaired) { return(FindReferences(target, association, true)); } object key = new Pair <object, AssociationInfo>(CachingRegion, association); Func <object, object> generator = p => BuildReferencingQuery(((Pair <object, AssociationInfo>)p).Second); var pair = (Pair <CompilableProvider, Parameter <Tuple> >)Session.StorageNode.InternalQueryCache.GetOrAdd(key, generator); var recordSet = pair.First; var parameter = pair.Second; var parameterContext = new ParameterContext(); ExecutableProvider executableProvider; using (parameterContext.Activate()) { parameter.Value = target.Key.Value; executableProvider = Session.Compile(recordSet); } var queryTask = new QueryTask(executableProvider, Session.GetLifetimeToken(), parameterContext); Session.RegisterInternalDelayedQuery(queryTask); return(GetReferencesToInternal(association, target, recordSet.Header, queryTask)); }
public void Activate() { scope = parameterContext.Activate(); }
/// <summary> /// Activates specified <see cref="ParameterContext"/> if it is not null; /// otherwise does nothing. /// </summary> /// <param name="context">The context to activate.</param> /// <returns><see cref="ParameterScope"/> if <paramref name="context"/> is not <see langword="null"/>; /// otherwise <see langword="null"/>.</returns> public static ParameterScope ActivateSafely(this ParameterContext context) { return(context != null?context.Activate() : null); }