private static QuerySourceScope <TEntity> CreateEntity <TEntity>(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader,
int readerOffset,
IEntityType entityType)
{
var relationalQueryContext = (RelationalQueryContext)queryContext;
var valueReader
= relationalQueryContext.ValueReaderFactory
.Create(dataReader);
if (readerOffset > 0)
{
valueReader = new OffsetValueReaderDecorator(valueReader, readerOffset);
}
return(new QuerySourceScope <TEntity>(
querySource,
(TEntity)queryContext.QueryBuffer
.GetEntity(entityType, valueReader),
parentQuerySourceScope));
}
private static QuerySourceScope <TEntity> CreateEntity <TEntity>(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
ValueBuffer valueBuffer,
int valueBufferOffset,
IEntityType entityType,
bool queryStateManager,
EntityKeyFactory entityKeyFactory,
IReadOnlyList <IProperty> keyProperties,
Func <ValueBuffer, object> materializer)
where TEntity : class
{
valueBuffer = valueBuffer.UpdateOffset(valueBufferOffset);
var entityKey
= entityKeyFactory.Create(entityType, keyProperties, valueBuffer);
return(new QuerySourceScope <TEntity>(
querySource,
(TEntity)queryContext.QueryBuffer
.GetEntity(
entityType,
entityKey,
new EntityLoadInfo(
valueBuffer,
materializer),
queryStateManager),
parentQuerySourceScope));
}
private static QuerySourceScope <TEntity> CreateEntity <TEntity>(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader,
int readerOffset)
{
var relationalQueryContext = (RelationalQueryContext)queryContext;
var valueReader
= relationalQueryContext.ValueReaderFactory.Create(dataReader);
if (readerOffset > 0)
{
valueReader = new OffsetValueReaderDecorator(valueReader, readerOffset);
}
return(new QuerySourceScope <TEntity>(
querySource,
// ReSharper disable once AssignNullToNotNullAttribute
(TEntity)queryContext.StateManager
.GetOrMaterializeEntry(
queryContext.Model.GetEntityType(typeof(TEntity)),
valueReader).Entity,
parentQuerySourceScope));
}
protected override Expression VisitMethodCallExpression(MethodCallExpression expression)
{
var newArguments = VisitAndConvert(expression.Arguments, "VisitMethodCallExpression");
if ((expression.Method.MethodIsClosedFormOf(RelationalQueryModelVisitor.CreateEntityMethodInfo) ||
expression.Method.MethodIsClosedFormOf(RelationalQueryModelVisitor.CreateValueReaderMethodInfo)) &&
((ConstantExpression)expression.Arguments[0]).Value == _outerQuerySource)
{
return
(Expression.Call(
_getValueMethodInfo,
expression.Arguments[0],
expression.Arguments[2],
expression.Arguments[3]));
}
if (expression.Method.MethodIsClosedFormOf(
QuerySourceScope.GetResultMethodInfo) &&
((ConstantExpression)expression.Arguments[0]).Value == _outerQuerySource)
{
return
(QuerySourceScope.GetResult(
expression.Object,
_outerQuerySource,
typeof(bool)));
}
if (newArguments != expression.Arguments)
{
if (expression.Method.MethodIsClosedFormOf(
_relationalQueryCompilationContext.QueryMethodProvider.QueryMethod))
{
return(Expression.Call(
_relationalQueryCompilationContext.QueryMethodProvider.QueryMethod
.MakeGenericMethod(typeof(QuerySourceScope <bool>)),
newArguments));
}
if (expression.Method.MethodIsClosedFormOf(
_relationalQueryCompilationContext.LinqOperatorProvider.Select))
{
return
(Expression.Call(
_relationalQueryCompilationContext.LinqOperatorProvider.First
.MakeGenericMethod(typeof(bool)),
Expression.Call(
_relationalQueryCompilationContext.LinqOperatorProvider.Select
.MakeGenericMethod(
typeof(QuerySourceScope),
typeof(bool)),
newArguments)));
}
return(Expression.Call(expression.Method, newArguments));
}
return(expression);
}
private static QuerySourceScope <TResult> GetValue(
IQuerySource querySource,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader)
{
return(new QuerySourceScope <TResult>(
querySource,
dataReader.GetFieldValue <TResult>(0),
parentQuerySourceScope));
}
private static QuerySourceScope <bool> GetValue(
IQuerySource querySource,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader)
{
return(new QuerySourceScope <bool>(
querySource,
dataReader.GetBoolean(0),
parentQuerySourceScope));
}
private static QuerySourceScope <IValueReader> CreateValueReader(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader)
{
return(new QuerySourceScope <IValueReader>(
querySource,
((RelationalQueryContext)queryContext).ValueReaderFactory.Create(dataReader),
parentQuerySourceScope));
}
private static QuerySourceScope <ValueBuffer> CreateValueBuffer(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
ValueBuffer valueBuffer,
int valueBufferOffset)
{
return(new QuerySourceScope <ValueBuffer>(
querySource,
valueBuffer.UpdateOffset(valueBufferOffset),
parentQuerySourceScope));
}
public override Expression VisitExpression(Expression expression)
{
if (expression != null &&
!(expression is QuerySourceReferenceExpression))
{
var sqlExpression
= _sqlTranslatingExpressionTreeVisitor.VisitExpression(expression);
if (sqlExpression == null)
{
_requiresClientEval = true;
}
else
{
var selectExpression
= QueryModelVisitor.TryGetQuery(_querySource);
Debug.Assert(selectExpression != null);
if (!(expression is NewExpression))
{
var columnExpression = sqlExpression as ColumnExpression;
if (columnExpression != null)
{
selectExpression.AddToProjection(columnExpression);
return(expression);
}
var index = selectExpression.AddToProjection(sqlExpression);
return
(QueryModelVisitor.BindReadValueMethod(
expression.Type,
QuerySourceScope.GetResult(
EntityQueryModelVisitor.QuerySourceScopeParameter,
_querySource,
typeof(IValueReader)),
index));
}
}
}
return(base.VisitExpression(expression));
}
private static QuerySourceScope <TEntity> _IncludeReference <TEntity>(
QueryContext queryContext,
QuerySourceScope <TEntity> querySourceScope,
INavigation navigation,
DbDataReader dataReader,
int readerOffset)
{
var valueReader
= ((RelationalQueryContext)queryContext).ValueReaderFactory
.Create(dataReader);
queryContext.QueryBuffer
.Include(
querySourceScope._result,
navigation,
(_, __) => new[] { new OffsetValueReaderDecorator(valueReader, readerOffset) });
return(querySourceScope);
}
private static QuerySourceScope <TEntity> CreateEntity <TEntity>(
IQuerySource querySource,
QueryContext queryContext,
QuerySourceScope parentQuerySourceScope,
DbDataReader dataReader,
int readerOffset,
IEntityType entityType,
bool queryStateManager,
EntityKeyFactory entityKeyFactory,
IReadOnlyList <IProperty> keyProperties,
Func <IValueReader, object> materializer)
where TEntity : class
{
var valueReader
= ((RelationalQueryContext)queryContext).ValueReaderFactory
.Create(dataReader);
if (readerOffset > 0)
{
valueReader = new OffsetValueReaderDecorator(valueReader, readerOffset);
}
var entityKey
= entityKeyFactory.Create(entityType, keyProperties, valueReader);
return(new QuerySourceScope <TEntity>(
querySource,
(TEntity)queryContext.QueryBuffer
.GetEntity(
entityType,
entityKey,
new EntityLoadInfo(
valueReader,
materializer),
queryStateManager),
parentQuerySourceScope));
}
protected override Expression VisitMethodCallExpression(MethodCallExpression methodCallExpression)
{
var newObject = VisitExpression(methodCallExpression.Object);
if (newObject != methodCallExpression.Object)
{
return(newObject);
}
var newArguments = VisitAndConvert(methodCallExpression.Arguments, "VisitMethodCallExpression");
if ((methodCallExpression.Method.MethodIsClosedFormOf(RelationalQueryModelVisitor.CreateEntityMethodInfo) ||
ReferenceEquals(methodCallExpression.Method, RelationalQueryModelVisitor.CreateValueReaderMethodInfo)) &&
((ConstantExpression)methodCallExpression.Arguments[0]).Value == _outerQuerySource)
{
return
(Expression.Call(
_getValueMethodInfo,
methodCallExpression.Arguments[0],
methodCallExpression.Arguments[2],
methodCallExpression.Arguments[3]));
}
if (methodCallExpression.Method.MethodIsClosedFormOf(
QuerySourceScope.GetResultMethodInfo) &&
((ConstantExpression)methodCallExpression.Arguments[0]).Value == _outerQuerySource)
{
return
(QuerySourceScope.GetResult(
methodCallExpression.Object,
_outerQuerySource,
typeof(TResult)));
}
if (newArguments != methodCallExpression.Arguments)
{
if (methodCallExpression.Method.MethodIsClosedFormOf(
_relationalQueryCompilationContext.QueryMethodProvider.QueryMethod))
{
return(Expression.Call(
_relationalQueryCompilationContext.QueryMethodProvider.QueryMethod
.MakeGenericMethod(typeof(QuerySourceScope <TResult>)),
newArguments));
}
if (methodCallExpression.Method.MethodIsClosedFormOf(
_relationalQueryCompilationContext.LinqOperatorProvider.Select))
{
return
(ResultOperatorHandler.CallWithPossibleCancellationToken(
_relationalQueryCompilationContext.LinqOperatorProvider._First
.MakeGenericMethod(typeof(TResult)),
Expression.Call(
_relationalQueryCompilationContext.LinqOperatorProvider.Select
.MakeGenericMethod(
typeof(QuerySourceScope),
typeof(TResult)),
newArguments)));
}
return(Expression.Call(methodCallExpression.Method, newArguments));
}
return(methodCallExpression);
}
