public void AddQuery(OeParseUriContext parseUriContext, Object query, IReadOnlyDictionary <ConstantNode, OeQueryCacheDbParameterDefinition> constantNodeNames) { parseUriContext.ConstantToParameterMapper = constantNodeNames; var queryCacheItem = new QueryCacheItem(query, parseUriContext.EntryFactory); _cache.TryAdd(parseUriContext, queryCacheItem); }
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)); }
protected IQueryable CreateQuery(OeParseUriContext parseUriContext, Object dataContext, OeConstantToVariableVisitor constantToVariableVisitor) { IQueryable query = parseUriContext.EntitySetAdapter.GetEntitySet(dataContext); Expression expression = parseUriContext.CreateExpression(query, constantToVariableVisitor); return(query.Provider.CreateQuery(expression)); }
public override TResult ExecuteScalar <TResult>(OeParseUriContext parseUriContext, object dataContext) { IQueryable query = parseUriContext.EntitySetAdapter.GetEntitySet(dataContext); Expression expression = parseUriContext.CreateExpression(query, new OeConstantToVariableVisitor()); return(query.Provider.Execute <TResult>(expression)); }
public static async Task SerializeAsync(Uri baseUri, OeParseUriContext parseUriContext, Db.OeEntityAsyncEnumerator asyncEnumerator, Stream stream) { IEdmModel edmModel = parseUriContext.EdmModel; OeEntryFactory entryFactory = parseUriContext.EntryFactory; String contentType = parseUriContext.Headers.ContentType; var settings = new ODataMessageWriterSettings() { BaseUri = baseUri, EnableMessageStreamDisposal = false, ODataUri = parseUriContext.ODataUri, Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames, Version = ODataVersion.V4 }; IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType); using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, edmModel)) { ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet); ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType); var getWriter = new GetWriter(baseUri, parseUriContext.Headers.MetadataLevel, writer); await getWriter.SerializeAsync(entryFactory, asyncEnumerator, stream); } }
public QueryCacheItem GetQuery(OeParseUriContext parseUriContext) { QueryCacheItem cacheItem; _cache.TryGetValue(parseUriContext, out cacheItem); return(cacheItem); }
public async Task ExecuteAsync(ODataUri odataUri, OeRequestHeaders headers, Stream stream, CancellationToken cancellationToken) { OeParseUriContext parseUriContext = ParseUri(odataUri); parseUriContext.Headers = headers; parseUriContext.EntitySetAdapter = _dataAdapter.GetEntitySetAdapter(parseUriContext.EntitySet.Name); Object dataContext = null; try { dataContext = _dataAdapter.CreateDataContext(); if (parseUriContext.IsCountSegment) { int count = _dataAdapter.ExecuteScalar <int>(dataContext, parseUriContext); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(count.ToString()); stream.Write(buffer, 0, buffer.Length); } else { using (Db.OeEntityAsyncEnumerator asyncEnumerator = _dataAdapter.ExecuteEnumerator(dataContext, parseUriContext, cancellationToken)) await Writers.OeGetWriter.SerializeAsync(BaseUri, parseUriContext, asyncEnumerator, stream).ConfigureAwait(false); } } finally { if (dataContext != null) { _dataAdapter.CloseDataContext(dataContext); } } }
public bool Compare(OeParseUriContext parseUriContext1, OeParseUriContext parseUriContext2) { if (parseUriContext1.EntitySet != parseUriContext2.EntitySet) { return(false); } ODataUri uri1 = parseUriContext1.ODataUri; ODataUri uri2 = parseUriContext2.ODataUri; if (!ODataPathComparer.Compare(uri1.Path, uri2.Path)) { return(false); } if (!CompareParseNavigationSegments(parseUriContext1.ParseNavigationSegments, parseUriContext2.ParseNavigationSegments)) { return(false); } if (!CompareApply(uri1.Apply, uri2.Apply)) { return(false); } if (!CompareFilter(uri1.Filter, uri2.Filter)) { return(false); } if (!CompareSelectAndExpand(uri1.SelectAndExpand, uri2.SelectAndExpand, uri1.Path)) { return(false); } if (!CompareOrderBy(uri1.OrderBy, uri2.OrderBy)) { return(false); } if (!CompareSkip(uri1.Skip, uri2.Skip, uri1.Path)) { return(false); } if (!CompareTop(uri1.Top, uri2.Top, uri1.Path)) { return(false); } if (!CompareHeaders(parseUriContext1.Headers, parseUriContext2.Headers)) { return(false); } return(true); }
public override OeEntityAsyncEnumerator ExecuteEnumerator(OeParseUriContext parseUriContext, Object dataContext, CancellationToken cancellationToken) { IQueryable entitySet = parseUriContext.EntitySetAdapter.GetEntitySet(dataContext); Expression expression = parseUriContext.CreateExpression(entitySet, new OeConstantToVariableVisitor()); expression = new ParameterVisitor().Visit(expression); var query = (IQueryable <Object>)entitySet.Provider.CreateQuery(expression); return(new OeLinq2DbEntityAsyncEnumerator(query.GetEnumerator(), cancellationToken)); }
public override Db.OeEntityAsyncEnumerator ExecuteEnumerator(OeParseUriContext parseUriContext, Object dataContext, CancellationToken cancellationToken) { IQueryable query = parseUriContext.EntitySetAdapter.GetEntitySet(dataContext); Expression expression = parseUriContext.CreateExpression(query, new OeConstantToVariableVisitor()); expression = new EnumerableToQuerableVisitor().Visit(expression); var queryAsync = (IDbAsyncEnumerable)query.Provider.CreateQuery(expression); return(new OeEf6EntityAsyncEnumerator(queryAsync.GetAsyncEnumerator(), cancellationToken)); }
public override TResult ExecuteScalar <TResult>(Object dataContext, OeParseUriContext parseUriContext) { if (base.QueryCache.AllowCache) { return(GetFromCache <TResult>(parseUriContext, (T)dataContext, base.QueryCache).Single()); } IQueryable query = parseUriContext.EntitySetAdapter.GetEntitySet(dataContext); Expression expression = parseUriContext.CreateExpression(query, new OeConstantToVariableVisitor()); return(query.Provider.Execute <TResult>(expression)); }
public override Db.OeEntityAsyncEnumerator ExecuteEnumerator(OeParseUriContext parseUriContext, Object dataContext, CancellationToken cancellationToken) { IEnumerable <Object> enumerable; if (base.QueryCache.AllowCache) { enumerable = GetFromCache <Object>(parseUriContext, (T)dataContext, base.QueryCache); } else { enumerable = ((IQueryable <Object>)base.CreateQuery(parseUriContext, dataContext, new OeConstantToVariableVisitor())); } return(new OeEfCoreEntityAsyncEnumeratorAdapter(enumerable, cancellationToken)); }
public async Task ExecuteAsync(Uri requestUri, OeRequestHeaders headers, Stream stream, CancellationToken cancellationToken) { OeParseUriContext parseUriContext = ParseUri(requestUri); parseUriContext.Headers = headers; parseUriContext.EntitySetAdapter = _dataAdapter.GetEntitySetAdapter(parseUriContext.EntitySet.Name); Object dataContext = null; try { dataContext = _dataAdapter.CreateDataContext(); if (parseUriContext.IsCountSegment) { int count = _dataAdapter.ExecuteScalar <int>(parseUriContext, dataContext); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(count.ToString()); stream.Write(buffer, 0, buffer.Length); } else { long?count = null; if (parseUriContext.ODataUri.QueryCount.GetValueOrDefault()) { var countParseUriContext = new OeParseUriContext(parseUriContext.EdmModel , parseUriContext.ODataUri , parseUriContext.EntitySet , parseUriContext.ParseNavigationSegments , true); countParseUriContext.Headers = parseUriContext.Headers; countParseUriContext.EntitySetAdapter = parseUriContext.EntitySetAdapter; count = _dataAdapter.ExecuteScalar <int>(countParseUriContext, dataContext); } using (Db.OeEntityAsyncEnumerator asyncEnumerator = _dataAdapter.ExecuteEnumerator(parseUriContext, dataContext, cancellationToken)) await Writers.OeGetWriter.SerializeAsync(BaseUri, parseUriContext, asyncEnumerator, stream, count).ConfigureAwait(false); } } finally { if (dataContext != null) { _dataAdapter.CloseDataContext(dataContext); } } }
public void Test() { SelectTestDefinition[] requestMethodNames = TestHelper.GetSelectTestDefinitions(); requestMethodNames = requestMethodNames.Where(t => t.MethodName == "FilterEnum" || t.MethodName == "FilterEnumNull").ToArray(); var fixture = new DbFixtureInitDb(); var baseUri = new Uri("http://dummy/"); var parser = new OeGetParser(baseUri, fixture.OeDataAdapter, fixture.EdmModel); for (int i = 0; i < requestMethodNames.Length; i++) { OeParseUriContext parseUriContext1 = parser.ParseUri(fixture.ParseUri(requestMethodNames[i].Request)); OeParseUriContext parseUriContext2 = parser.ParseUri(fixture.ParseUri(requestMethodNames[i].Request)); var constantToParameterMapper = new FakeReadOnlyDictionary <ConstantNode, Db.OeQueryCacheDbParameterDefinition>(); if (parseUriContext1.ODataUri.Skip != null) { var constantNode = OeODataUriComparerParameterValues.CreateSkipConstantNode((int)parseUriContext1.ODataUri.Skip.Value, parseUriContext1.ODataUri.Path); constantToParameterMapper.Add(constantNode, new Db.OeQueryCacheDbParameterDefinition("p_0", typeof(int))); } if (parseUriContext1.ODataUri.Top != null) { var constantNode = OeODataUriComparerParameterValues.CreateTopConstantNode((int)parseUriContext1.ODataUri.Top.Value, parseUriContext1.ODataUri.Path); constantToParameterMapper.Add(constantNode, new Db.OeQueryCacheDbParameterDefinition($"p_{constantToParameterMapper.Count}", typeof(int))); } bool result = new OeODataUriComparer(constantToParameterMapper).Compare(parseUriContext1, parseUriContext2); Assert.True(result); for (int j = i + 1; j < requestMethodNames.Length; j++) { parseUriContext2 = parser.ParseUri(fixture.ParseUri(requestMethodNames[j].Request)); constantToParameterMapper = new FakeReadOnlyDictionary <ConstantNode, Db.OeQueryCacheDbParameterDefinition>(); result = new OeODataUriComparer(constantToParameterMapper).Compare(parseUriContext1, parseUriContext2); Assert.False(result); } } }
//[Fact] public void CacheCode() { var hashes = new Dictionary <int, List <String> >(); SelectTestDefinition[] requestMethodNames = TestHelper.GetSelectTestDefinitions(); var fixture = new DbFixtureInitDb(); var parser = new OeGetParser(new Uri("http://dummy/"), fixture.OeDataAdapter, fixture.EdmModel); for (int i = 0; i < requestMethodNames.Length; i++) { OeParseUriContext parseUriContext = parser.ParseUri(new Uri(parser.BaseUri + requestMethodNames[i].Request)); int hash = OeODataUriComparer.GetCacheCode(parseUriContext); List <String> value; if (!hashes.TryGetValue(hash, out value)) { value = new List <String>(); hashes.Add(hash, value); } value.Add(requestMethodNames[i].MethodName); } var duplicate = hashes.Where(p => p.Value.Count > 1).Select(p => p.Value).ToArray(); }
public abstract TResult ExecuteScalar <TResult>(Object dataContext, OeParseUriContext parseUriContext);
public abstract OeEntityAsyncEnumerator ExecuteEnumerator(Object dataContext, OeParseUriContext parseUriContext, CancellationToken cancellationToken);
public static int GetCacheCode(OeParseUriContext parseUriContext) { var hashVistitor = new OeQueryNodeHashVisitor(); ODataUri uri = parseUriContext.ODataUri; int hash = uri.Path.FirstSegment.Identifier.GetHashCode(); hash = CombineHashCodes(hash, uri.Path.LastSegment.Identifier.GetHashCode()); if (parseUriContext.ParseNavigationSegments != null) { for (int i = 0; i < parseUriContext.ParseNavigationSegments.Count; i++) { OeParseNavigationSegment parseNavigationSegment = parseUriContext.ParseNavigationSegments[i]; if (parseNavigationSegment.Filter != null) { int h = hashVistitor.TranslateNode(parseUriContext.ParseNavigationSegments[i].Filter.Expression); hash = CombineHashCodes(hash, h); } } } if (uri.Filter != null) { hash = CombineHashCodes(hash, hashVistitor.TranslateNode(uri.Filter.Expression)); } if (uri.Apply != null) { foreach (TransformationNode transformationNode in uri.Apply.Transformations) { if (transformationNode is FilterTransformationNode) { FilterClause filter = (transformationNode as FilterTransformationNode).FilterClause; hash = CombineHashCodes(hash, hashVistitor.TranslateNode(filter.Expression)); } else if (transformationNode is AggregateTransformationNode) { foreach (AggregateExpression aggregate in (transformationNode as AggregateTransformationNode).Expressions) { hash = CombineHashCodes(hash, (int)aggregate.Method); } } else if (transformationNode is GroupByTransformationNode) { foreach (GroupByPropertyNode group in (transformationNode as GroupByTransformationNode).GroupingProperties) { hash = CombineHashCodes(hash, group.Name.GetHashCode()); } } else { throw new InvalidProgramException("unknown TransformationNode " + transformationNode.GetType().ToString()); } } } if (uri.SelectAndExpand != null) { hash = GetCacheCode(hash, uri.SelectAndExpand); } if (uri.OrderBy != null) { hash = CombineHashCodes(hash, (int)uri.OrderBy.Direction); hash = CombineHashCodes(hash, hashVistitor.TranslateNode(uri.OrderBy.Expression)); } return(hash); }