private Expression ExecuteProjection(ProjectionExpression projection, bool okayToDefer, QueryCommand command, Expression[] values, bool isTopLevel)
{
okayToDefer &= (this.receivingMember != null && this.policy.IsDeferLoaded(this.receivingMember));
var saveScope = this.scope;
this.scope = new Scope(this.scope, projection.Select.Alias, projection.Select.Columns);
this.scope = saveScope;
var entity = EntityFinder.Find(projection.Projector);
string methExecute = okayToDefer
? nameof(QueryExecutor.ExecuteDeferred)
: nameof(QueryExecutor.Execute);
// call low-level execute directly on supplied DbQueryProvider
Expression result = Expression.Call(this.executor, methExecute, new Type[] { projection.Projector.Type },
Expression.Constant(command),
Expression.NewArrayInit(typeof(object), values)
);
if (projection.Aggregator != null)
{
// apply aggregator
result = DbExpressionReplacer.Replace(projection.Aggregator.Body, projection.Aggregator.Parameters[0], result);
}
return(result);
}
protected virtual Expression GetEntityStateTest(MappingEntity entity, Expression instance, LambdaExpression updateCheck)
{
ProjectionExpression tq = this.GetQueryExpression(entity);
Expression where = this.GetIdentityCheck(tq.Select, entity, instance);
Expression check = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], tq.Projector);
where = where.And(check);
return(new ExistsExpression(new SelectExpression(new TableAlias(), null, tq.Select, where)));
}
protected virtual Expression GetUpdateResult(MappingEntity entity, Expression instance, LambdaExpression selector)
{
var tq = this.GetQueryExpression(entity);
Expression where = this.GetIdentityCheck(tq.Select, entity, instance);
Expression selection = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], tq.Projector);
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, selection, null, newAlias, tq.Select.Alias);
return(new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, tq.Select, where),
pc.Projector,
Aggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(selector.Body.Type))
));
}
protected override Expression VisitClientJoin(ClientJoinExpression join)
{
// convert client join into a up-front lookup table builder & replace client-join in tree with lookup accessor
// 1) lookup = query.Select(e => new KVP(key: inner, value: e)).ToLookup(kvp => kvp.Key, kvp => kvp.Value)
Expression innerKey = MakeJoinKey(join.InnerKey);
Expression outerKey = MakeJoinKey(join.OuterKey);
ConstructorInfo kvpConstructor = typeof(KeyValuePair <,>).MakeGenericType(innerKey.Type, join.Projection.Projector.Type).GetConstructor(new Type[] { innerKey.Type, join.Projection.Projector.Type });
Expression constructKVPair = Expression.New(kvpConstructor, innerKey, join.Projection.Projector);
ProjectionExpression newProjection = new ProjectionExpression(join.Projection.Select, constructKVPair);
int iLookup = ++nLookup;
Expression execution = this.ExecuteProjection(newProjection, okayToDefer: false, isTopLevel: false);
ParameterExpression kvp = Expression.Parameter(constructKVPair.Type, "kvp");
// filter out nulls
if (join.Projection.Projector.NodeType == (ExpressionType)DbExpressionType.OuterJoined)
{
LambdaExpression pred = Expression.Lambda(
Expression.PropertyOrField(kvp, "Value").NotEqual(TypeHelper.GetNullConstant(join.Projection.Projector.Type)),
kvp
);
execution = Expression.Call(typeof(Enumerable), nameof(Enumerable.Where), new Type[] { kvp.Type }, execution, pred);
}
// make lookup
LambdaExpression keySelector = Expression.Lambda(Expression.PropertyOrField(kvp, "Key"), kvp);
LambdaExpression elementSelector = Expression.Lambda(Expression.PropertyOrField(kvp, "Value"), kvp);
Expression toLookup = Expression.Call(typeof(Enumerable), nameof(Enumerable.ToLookup), new Type[] { kvp.Type, outerKey.Type, join.Projection.Projector.Type }, execution, keySelector, elementSelector);
// 2) agg(lookup[outer])
ParameterExpression lookup = Expression.Parameter(toLookup.Type, "lookup" + iLookup);
PropertyInfo property = lookup.Type.GetProperty("Item");
Expression access = Expression.Call(lookup, property.GetGetMethod(), this.Visit(outerKey));
if (join.Projection.Aggregator != null)
{
// apply aggregator
access = DbExpressionReplacer.Replace(join.Projection.Aggregator.Body, join.Projection.Aggregator.Parameters[0], access);
}
this.variables.Add(lookup);
this.initializers.Add(toLookup);
return(access);
}
public override Expression GetPartialUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression @else)
{
var tableAlias = new TableAlias();
var table = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var where = this.GetIdentityCheck(table, entity, instance);
if (updateCheck != null)
{
Expression typeProjector = this.GetEntityExpression(table, entity);
Expression pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector);
where = where.And(pred);
}
var assignments = this.GetColumnAssignments(table, instance, entity, (e, m) => this.mapping.IsUpdatable(e, m));
Expression update = new PartialUpdateCommand(table, where, assignments);
if (selector != null)
{
return(new BlockCommand(
update,
new IFCommand(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).GreaterThan(Expression.Constant(0)),
this.GetUpdateResult(entity, instance, selector),
@else
)
));
}
else if (@else != null)
{
return(new BlockCommand(
update,
new IFCommand(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).LessThanOrEqual(Expression.Constant(0)),
@else,
null
)
));
}
else
{
return(update);
}
}
public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
{
TableExpression table = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(entity));
Expression where = null;
if (instance != null)
{
where = this.GetIdentityCheck(table, entity, instance);
}
if (deleteCheck != null)
{
Expression row = this.GetEntityExpression(table, entity);
Expression pred = DbExpressionReplacer.Replace(deleteCheck.Body, deleteCheck.Parameters[0], row);
where = (where != null) ? where.And(pred) : pred;
}
return(new DeleteCommand(table, where));
}
protected virtual Expression GetInsertResult(MappingEntity entity, Expression instance, LambdaExpression selector, Dictionary <MemberInfo, Expression> map)
{
var tableAlias = new TableAlias();
var tex = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var aggregator = Aggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(selector.Body.Type));
Expression where;
DeclarationCommand genIdCommand = null;
var generatedIds = this.mapping.GetMappedMembers(entity).Where(m => this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)).ToList();
if (generatedIds.Count > 0)
{
if (map == null || !generatedIds.Any(m => map.ContainsKey(m)))
{
var localMap = new Dictionary <MemberInfo, Expression>();
genIdCommand = this.GetGeneratedIdCommand(entity, generatedIds.ToList(), localMap);
map = localMap;
}
// is this just a retrieval of one generated id member?
var mex = selector.Body as MemberExpression;
if (mex != null && this.mapping.IsPrimaryKey(entity, mex.Member) && this.mapping.IsGenerated(entity, mex.Member))
{
if (genIdCommand != null)
{
// just use the select from the genIdCommand
return(new ProjectionExpression(
genIdCommand.Source,
new ColumnExpression(mex.Type, genIdCommand.Variables[0].QueryType, genIdCommand.Source.Alias, genIdCommand.Source.Columns[0].Name, null),
aggregator
));
}
else
{
TableAlias alias = new TableAlias();
var colType = this.GetColumnType(entity, mex.Member);
return(new ProjectionExpression(
new SelectExpression(alias, new[] { new ColumnDeclaration("", null, map[mex.Member], colType) }, null, null),
new ColumnExpression(TypeHelper.GetMemberType(mex.Member), colType, alias, "", null),
aggregator
));
}
}
where = generatedIds.Select((m, i) =>
this.GetMemberExpression(tex, entity, m).Equal(map[m])
).Aggregate((x, y) => x.And(y));
}
else
{
where = this.GetIdentityCheck(tex, entity, instance);
}
Expression typeProjector = this.GetEntityExpression(tex, entity);
Expression selection = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], typeProjector);
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, selection, null, newAlias, tableAlias);
var pe = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, tex, where),
pc.Projector,
aggregator
);
if (genIdCommand != null)
{
return(new BlockCommand(genIdCommand, pe));
}
return(pe);
}