예제 #1
0
        private static IEnumerable <TResult> GetFromCache <TResult>(OeParseUriContext parseUriContext, T dbContext, Db.OeQueryCache queryCache)
        {
            Db.QueryCacheItem queryCacheItem = queryCache.GetQuery(parseUriContext);

            Func <QueryContext, IEnumerable <TResult> > queryExecutor;

            if (queryCacheItem == null)
            {
                IQueryable query            = parseUriContext.EntitySetAdapter.GetEntitySet(dbContext);
                var        parameterVisitor = new OeConstantToParameterVisitor();
                Expression expression       = parseUriContext.CreateExpression(query, parameterVisitor);
                queryExecutor = dbContext.CreateQueryExecutor <TResult>(expression);

                queryCache.AddQuery(parseUriContext, queryExecutor, parameterVisitor.ConstantToParameterMapper);
                parseUriContext.ParameterValues = parameterVisitor.ParameterValues;
            }
            else
            {
                queryExecutor = (Func <QueryContext, IEnumerable <TResult> >)queryCacheItem.Query;
                parseUriContext.EntryFactory = queryCacheItem.EntryFactory;
            }

            var queryContextFactory = dbContext.GetService <IQueryContextFactory>();
            var queryContext        = queryContextFactory.Create();

            foreach (Db.OeQueryCacheDbParameterValue parameterValue in parseUriContext.ParameterValues)
            {
                queryContext.AddParameter(parameterValue.ParameterName, parameterValue.ParameterValue);
            }

            return(queryExecutor(queryContext));
        }
예제 #2
0
        private static IAsyncEnumerable <TResult> GetFromCache <TResult>(OeQueryContext queryContext, T dbContext, Db.OeQueryCache queryCache)
        {
            OeCacheContext cacheContext = queryContext.CreateCacheContext();

            Db.QueryCacheItem queryCacheItem = queryCache.GetQuery(cacheContext);

            Func <QueryContext, IAsyncEnumerable <TResult> > queryExecutor;
            Expression countExpression;
            IReadOnlyList <Db.OeQueryCacheDbParameterValue> parameterValues;

            if (queryCacheItem == null)
            {
                IQueryable query            = queryContext.EntitySetAdapter.GetEntitySet(dbContext);
                var        parameterVisitor = new OeConstantToParameterVisitor(false);

                Expression expression = queryContext.CreateExpression(query, parameterVisitor);
                queryExecutor   = dbContext.CreateAsyncQueryExecutor <TResult>(expression);
                countExpression = queryContext.CreateCountExpression(query, expression);
                queryCache.AddQuery(queryContext.CreateCacheContext(parameterVisitor.ConstantToParameterMapper), queryExecutor, countExpression,
                                    queryContext.EntryFactory, queryContext.SkipTokenParser?.Accessors);
                parameterValues = parameterVisitor.ParameterValues;
            }
            else
            {
                queryExecutor             = (Func <QueryContext, IAsyncEnumerable <TResult> >)queryCacheItem.Query;
                queryContext.EntryFactory = queryCacheItem.EntryFactory;
                if (queryContext.SkipTokenParser != null)
                {
                    queryContext.SkipTokenParser.Accessors = queryCacheItem.SkipTokenAccessors;
                }
                countExpression = queryCacheItem.CountExpression;
                parameterValues = cacheContext.ParameterValues;
            }

            var          queryContextFactory = dbContext.GetService <IQueryContextFactory>();
            QueryContext efQueryContext      = queryContextFactory.Create();

            foreach (Db.OeQueryCacheDbParameterValue parameterValue in parameterValues)
            {
                efQueryContext.AddParameter(parameterValue.ParameterName, parameterValue.ParameterValue);
            }

            if (queryContext.ODataUri.QueryCount.GetValueOrDefault())
            {
                queryContext.CountExpression = new OeParameterToVariableVisitor().Translate(countExpression, parameterValues);
            }

            return(queryExecutor(efQueryContext));
        }