public void CombinedTest() { const string parameterName = "TestParameter"; var parameter = new Parameter <int>(parameterName); Assert.AreEqual(parameterName, parameter.Name); Assert.Throws <NotSupportedException>(() => _ = parameter.Value); var firstContext = new ParameterContext(); firstContext.SetValue(parameter, 10); Assert.AreEqual(10, firstContext.GetValue(parameter)); firstContext.SetValue(parameter, 15); Assert.AreEqual(15, firstContext.GetValue(parameter)); var secondContext = new ParameterContext(firstContext); Assert.AreEqual(15, secondContext.GetValue(parameter)); secondContext.SetValue(parameter, 20); Assert.AreEqual(20, secondContext.GetValue(parameter)); Assert.AreEqual(15, firstContext.GetValue(parameter)); firstContext.SetValue(parameter, 25); Assert.AreEqual(25, firstContext.GetValue(parameter)); Assert.AreEqual(20, secondContext.GetValue(parameter)); }
private ParameterizedQuery GetScalarQuery <TResult>( Func <QueryEndpoint, TResult> query, bool executeAsSideEffect, out TResult result) { AllocateParameterAndReplacer(); var parameterContext = new ParameterContext(outerContext); parameterContext.SetValue(queryParameter, queryTarget); var scope = new CompiledQueryProcessingScope( queryParameter, queryParameterReplacer, parameterContext, executeAsSideEffect); using (scope.Enter()) { result = query.Invoke(endpoint); } var parameterizedQuery = (ParameterizedQuery)scope.ParameterizedQuery; if (parameterizedQuery == null && queryTarget != null) { throw new NotSupportedException(Strings.ExNonLinqCallsAreNotSupportedWithinQueryExecuteDelayed); } PutCachedQuery(parameterizedQuery); return(parameterizedQuery); }
// 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 = query; var outerParameterContext = context.ParameterContext; var parameterContext = new ParameterContext(outerParameterContext); // Gather Parameter<Tuple> values from current ParameterScope for future use. outerParameterContext.SetValue(parameter, tuple); foreach (var tupleParameter in currentTranslatedQuery.TupleParameters) { var value = outerParameterContext.GetValue(tupleParameter); tupleParameterBindings[tupleParameter] = value; parameterContext.SetValue(tupleParameter, value); } this.projectionExpression = new ProjectionExpression( projectionExpression.Type, projectionExpression.ItemProjector, tupleParameterBindings, projectionExpression.ResultAccessMethod); var translatedQuery = new TranslatedQuery( query.DataSource, query.Materializer, query.ResultAccessMethod, tupleParameterBindings, EnumerableUtils <Parameter <Tuple> > .Empty); delayedQuery = new DelayedQuery <TElement>(context.Session, translatedQuery, parameterContext); context.Session.RegisterUserDefinedDelayedQuery(delayedQuery.Task); context.MaterializationContext.MaterializationQueue.Enqueue(MaterializeSelf); }
private bool Contains(Key key, Entity item) { // state check var foundInCache = State.Contains(key); if (foundInCache) { return(true); } var ownerState = Owner.PersistenceState; var itemState = item == null ? PersistenceState.Synchronized : item.PersistenceState; if (PersistenceState.New.In(ownerState, itemState) || State.IsFullyLoaded) { return(false); } // association check if (item != null) { var association = Field.GetAssociation(item.TypeInfo); if (association.IsPaired && association.Multiplicity.In(Multiplicity.ManyToOne, Multiplicity.OneToMany)) { var candidate = (IEntity)item.GetFieldValue(association.Reversed.OwnerField); return(candidate == Owner); } } // load from storage EnsureIsLoaded(WellKnown.EntitySetPreloadCount); foundInCache = State.Contains(key); if (foundInCache) { return(true); } if (State.IsFullyLoaded) { return(false); } bool foundInDatabase; var entitySetTypeState = GetEntitySetTypeState(); var parameterContext = new ParameterContext(); parameterContext.SetValue(keyParameter, entitySetTypeState.SeekTransform .Apply(TupleTransformType.TransformedTuple, Owner.Key.Value, key.Value)); using (var recordSetReader = entitySetTypeState.SeekProvider.GetRecordSetReader(Session, parameterContext)) { foundInDatabase = recordSetReader.MoveNext(); } if (foundInDatabase) { State.Register(key); } return(foundInDatabase); }
private ParameterContext CreateParameterContext(ParameterizedQuery query) { var parameterContext = new ParameterContext(outerContext); if (query.QueryParameter != null) { parameterContext.SetValue(query.QueryParameter, queryTarget); } return(parameterContext); }
/// <summary> /// Executes the query in specified parameter context. /// </summary> /// <param name="session">The session.</param> /// <param name="parameterContext">The parameter context.</param> /// <returns>Query execution result.</returns> public QueryResult <T> ExecuteSequence <T>(Session session, ParameterContext parameterContext) { var newParameterContext = new ParameterContext(parameterContext); foreach (var(parameter, tuple) in TupleParameterBindings) { newParameterContext.SetValue(parameter, tuple); } var recordSetReader = DataSource.GetRecordSetReader(session, newParameterContext); return(Materializer.Invoke <T>(recordSetReader, session, newParameterContext)); }
public void ConfusingParameterTest() { var parameter = new Parameter <Tuple>("ConfusingParameter"); var parameterContext = new ParameterContext(); parameterContext.SetValue(parameter, Tuple.Create(false)); TestQuery( () => from o in Session.Demand().Query.All <MyEntity>() where o.HasStupidName == parameterContext.GetValue(parameter).GetValueOrDefault <bool>(0) select o ); }
private QueryTask CreateQueryTask() { var parameterContext = new ParameterContext(); parameterContext.SetValue(ownerParameter, ownerKey.Value); if (ItemCountLimit != null) { parameterContext.SetValue(itemCountLimitParameter, ItemCountLimit.Value); } object key = new Pair <object, CacheKey>(itemsQueryCachingRegion, cacheKey); Func <object, object> generator = CreateRecordSetLoadingItems; var session = manager.Owner.Session; var scope = new CompiledQueryProcessingScope(null, null, parameterContext, false); QueryProvider = (CompilableProvider)session.StorageNode.InternalQueryCache.GetOrAdd(key, generator); ExecutableProvider executableProvider; using (scope.Enter()) { executableProvider = session.Compile(QueryProvider); } return(new QueryTask(executableProvider, session.GetLifetimeToken(), parameterContext)); }
private QueryTask CreateQueryTask(List <Tuple> currentKeySet) { var parameterContext = new ParameterContext(); parameterContext.SetValue(includeParameter, 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)); }
/// <summary> /// Asynchronously executes the query in specified parameter context. /// </summary> /// <remarks> Multiple active operations are not supported. Use <see langword="await"/> /// to ensure that all asynchronous operations have completed.</remarks> /// <param name="session">The session.</param> /// <param name="parameterContext">The parameter context.</param> /// <param name="token">The token to cancel this operation</param> /// <returns><see cref="Task{TResult}"/> performing this operation.</returns> public async Task <QueryResult <T> > ExecuteSequenceAsync <T>( Session session, ParameterContext parameterContext, CancellationToken token) { var newParameterContext = new ParameterContext(parameterContext); foreach (var(parameter, tuple) in TupleParameterBindings) { newParameterContext.SetValue(parameter, tuple); } var recordSetReader = await DataSource.GetRecordSetReaderAsync(session, newParameterContext, token).ConfigureAwait(false); return(Materializer.Invoke <T>(recordSetReader, session, newParameterContext)); }
private void EnsureCountIsLoaded() { if (State.TotalItemCount != null) { return; } var parameterContext = new ParameterContext(); parameterContext.SetValue(ownerParameter, owner); var cachedState = GetEntitySetTypeState(); State.TotalItemCount = Session.Query.Execute(cachedState, cachedState.ItemCountQuery, parameterContext); }
// Constructors /// <summary> /// Initializes a new instance of this class. /// </summary> /// <param name="session"></param> /// <param name="translatedQuery">The translated query.</param> /// <param name="outerParameterContext">The parameter context.</param> internal DelayedQuery(Session session, TranslatedQuery translatedQuery, ParameterContext outerParameterContext) { ArgumentValidator.EnsureArgumentNotNull(session, nameof(session)); ArgumentValidator.EnsureArgumentNotNull(translatedQuery, nameof(translatedQuery)); ArgumentValidator.EnsureArgumentNotNull(outerParameterContext, nameof(outerParameterContext)); Session = session; LifetimeToken = session.GetLifetimeToken(); materializer = translatedQuery.Materializer; parameterContext = new ParameterContext(outerParameterContext); foreach (var(parameter, tuple) in translatedQuery.TupleParameterBindings) { parameterContext.SetValue(parameter, tuple); } Task = new QueryTask(translatedQuery.DataSource, LifetimeToken, parameterContext); }
/// <inheritdoc/> public void Lock(LockMode lockMode, LockBehavior lockBehavior) { var parameterContext = new ParameterContext(); parameterContext.SetValue(keyParameter, Key.Value); object key = new Triplet <TypeInfo, LockMode, LockBehavior>(TypeInfo, lockMode, lockBehavior); Func <object, object> generator = tripletObj => { var triplet = (Triplet <TypeInfo, LockMode, LockBehavior>)tripletObj; var index = triplet.First.Indexes.PrimaryIndex; var query = index.GetQuery() .Seek(context => context.GetValue(keyParameter)) .Lock(() => triplet.Second, () => triplet.Third) .Select(); return(Session.Compile(query)); }; var source = (ExecutableProvider)Session.StorageNode.InternalQueryCache.GetOrAdd(key, generator); using var recordSetReader = source.GetRecordSetReader(Session, parameterContext); recordSetReader.MoveNext(); }
/// <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(); parameterContext.SetValue(parameter, target.Key.Value); ExecutableProvider executableProvider = Session.Compile(recordSet); var queryTask = new QueryTask(executableProvider, Session.GetLifetimeToken(), parameterContext); Session.RegisterInternalDelayedQuery(queryTask); return(GetReferencesToInternal(association, target, recordSet.Header, queryTask)); }
private void CachedRseQueryTest(int count) { using (var session = Domain.OpenSession()) using (session.Activate()) using (var ts = session.OpenTransaction()) { TestHelper.CollectGarbage(); var pKey = new Parameter <Tuple>("pKey"); var rs = Domain.Model.Types[typeof(Simplest)].Indexes.PrimaryIndex.GetQuery().Seek(context => context.GetValue(pKey)); var parameterContext = new ParameterContext(); using (warmup ? null : new Measurement("Cached RSE query", count)) { for (int i = 0; i < count; i++) { parameterContext.SetValue(pKey, Tuple.Create((long)(i % instanceCount))); var es = rs.GetRecordSetReader(session, parameterContext).ToEntities <Simplest>(0); foreach (var o in es) { // Doing nothing, just enumerate } } } ts.Complete(); } }