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);
}
