public override Expression GetUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression @else)
{
TableAlias alias = new TableAlias();
TableExpression root = new TableExpression(alias, entity, this.mapping.GetTableName(entity));
Expression expression2 = this.GetIdentityCheck(root, entity, instance);
if (updateCheck != null)
{
Expression entityExpression = this.GetEntityExpression(root, entity);
Expression expression4 = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], entityExpression);
expression2 = expression2.And(expression4);
}
IEnumerable <ColumnAssignment> assignments = this.GetColumnAssignments(root, instance, entity, (e, m) => this.mapping.IsUpdatable(e, m));
Expression command = new UpdateCommand(root, expression2, assignments);
if (selector != null)
{
return(new BlockCommand(new Expression[] { command, new IFCommand(this.translator.Linguist.Language.GetRowsAffectedExpression(command).GreaterThan(Expression.Constant(0)), this.GetUpdateResult(entity, instance, selector), @else) }));
}
if (@else != null)
{
return(new BlockCommand(new Expression[] { command, new IFCommand(this.translator.Linguist.Language.GetRowsAffectedExpression(command).LessThanOrEqual(Expression.Constant(0)), @else, null) }));
}
return(command);
}
protected override Expression VisitClientJoin(ClientJoinExpression join)
{
Expression expression = this.MakeJoinKey(join.InnerKey as IList <Expression>);
Expression exp = this.MakeJoinKey(join.OuterKey as IList <Expression>);
Expression projector = Expression.New(typeof(KeyValuePair <,>).MakeGenericType(new Type[] { expression.Type, join.Projection.Projector.Type }).GetConstructor(new Type[] { expression.Type, join.Projection.Projector.Type }), new Expression[] { expression, join.Projection.Projector });
ProjectionExpression projection = new ProjectionExpression(join.Projection.Select, projector);
int num = ++this.nLookup;
Expression expression5 = this.ExecuteProjection(projection, false);
ParameterExpression expression6 = Expression.Parameter(projector.Type, "kvp");
if (join.Projection.Projector.NodeType == ((ExpressionType)0x3f9))
{
LambdaExpression expression7 = Expression.Lambda(Expression.PropertyOrField(expression6, "Value").NotEqual(King.Framework.Linq.TypeHelper.GetNullConstant(join.Projection.Projector.Type)), new ParameterExpression[] { expression6 });
expression5 = Expression.Call(typeof(Enumerable), "Where", new Type[] { expression6.Type }, new Expression[] { expression5, expression7 });
}
LambdaExpression expression8 = Expression.Lambda(Expression.PropertyOrField(expression6, "Key"), new ParameterExpression[] { expression6 });
LambdaExpression expression9 = Expression.Lambda(Expression.PropertyOrField(expression6, "Value"), new ParameterExpression[] { expression6 });
Expression item = Expression.Call(typeof(Enumerable), "ToLookup", new Type[] { expression6.Type, exp.Type, join.Projection.Projector.Type }, new Expression[] { expression5, expression8, expression9 });
ParameterExpression instance = Expression.Parameter(item.Type, "lookup" + num);
Expression replaceWith = Expression.Call(instance, instance.Type.GetProperty("Item").GetGetMethod(), new Expression[] { this.Visit(exp) });
if (join.Projection.Aggregator != null)
{
replaceWith = DbExpressionReplacer.Replace(join.Projection.Aggregator.Body, join.Projection.Aggregator.Parameters[0], replaceWith);
}
this.variables.Add(instance);
this.initializers.Add(item);
return(replaceWith);
}
protected virtual Expression GetInsertResult(MappingEntity entity, Expression instance, LambdaExpression selector, Dictionary <MemberInfo, Expression> map)
{
Expression expression2;
Func <MemberInfo, bool> func = null;
Func <MemberInfo, int, Expression> func2 = null;
TableAlias alias = new TableAlias();
TableExpression tex = new TableExpression(alias, entity, this.mapping.GetTableName(entity));
LambdaExpression aggregator = Aggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(new Type[] { selector.Body.Type }));
DeclarationCommand command = null;
List <MemberInfo> source = (from m in this.mapping.GetMappedMembers(entity)
where this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)
select m).ToList <MemberInfo>();
if (source.Count > 0)
{
if (map != null)
{
}
if (!((func == null) && source.Any <MemberInfo>((func = m => map.ContainsKey(m)))))
{
Dictionary <MemberInfo, Expression> dictionary = new Dictionary <MemberInfo, Expression>();
command = this.GetGeneratedIdCommand(entity, source.ToList <MemberInfo>(), dictionary);
map = dictionary;
}
MemberExpression body = selector.Body as MemberExpression;
if (((body != null) && this.mapping.IsPrimaryKey(entity, body.Member)) && this.mapping.IsGenerated(entity, body.Member))
{
if (command != null)
{
return(new ProjectionExpression(command.Source, new ColumnExpression(body.Type, command.Variables[0].QueryType, command.Source.Alias, command.Source.Columns[0].Name), aggregator));
}
TableAlias alias2 = new TableAlias();
QueryType columnType = this.GetColumnType(entity, body.Member);
return(new ProjectionExpression(new SelectExpression(alias2, new ColumnDeclaration[] { new ColumnDeclaration("", map[body.Member], columnType) }, null, null), new ColumnExpression(King.Framework.Linq.TypeHelper.GetMemberType(body.Member), columnType, alias2, ""), aggregator));
}
if (func2 == null)
{
func2 = (m, i) => this.GetMemberExpression(tex, entity, m).Equal(map[m]);
}
expression2 = source.Select <MemberInfo, Expression>(func2).Aggregate <Expression>((x, y) => x.And(y));
}
else
{
expression2 = this.GetIdentityCheck(tex, entity, instance);
}
Expression entityExpression = this.GetEntityExpression(tex, entity);
Expression expression = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], entityExpression);
TableAlias newAlias = new TableAlias();
ProjectedColumns columns = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, expression, null, newAlias, new TableAlias[] { alias });
ProjectionExpression expression6 = new ProjectionExpression(new SelectExpression(newAlias, columns.Columns, tex, expression2), columns.Projector, aggregator);
if (command != null)
{
return(new BlockCommand(new Expression[] { command, expression6 }));
}
return(expression6);
}
protected virtual Expression GetEntityStateTest(MappingEntity entity, Expression instance, LambdaExpression updateCheck)
{
ProjectionExpression queryExpression = this.GetQueryExpression(entity);
Expression expression2 = this.GetIdentityCheck(queryExpression.Select, entity, instance);
Expression expression3 = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], queryExpression.Projector);
expression2 = expression2.And(expression3);
return(new ExistsExpression(new SelectExpression(new TableAlias(), null, queryExpression.Select, expression2)));
}
protected virtual Expression GetUpdateResult(MappingEntity entity, Expression instance, LambdaExpression selector)
{
ProjectionExpression queryExpression = this.GetQueryExpression(entity);
Expression where = this.GetIdentityCheck(queryExpression.Select, entity, instance);
Expression expression = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], queryExpression.Projector);
TableAlias newAlias = new TableAlias();
ProjectedColumns columns = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, expression, null, newAlias, new TableAlias[] { queryExpression.Select.Alias });
return(new ProjectionExpression(new SelectExpression(newAlias, columns.Columns, queryExpression.Select, where), columns.Projector, Aggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(new Type[] { selector.Body.Type }))));
}
public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
{
TableExpression root = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(entity));
Expression expression2 = null;
if (instance != null)
{
expression2 = this.GetIdentityCheck(root, entity, instance);
}
if (deleteCheck != null)
{
Expression entityExpression = this.GetEntityExpression(root, entity);
Expression expression4 = DbExpressionReplacer.Replace(deleteCheck.Body, deleteCheck.Parameters[0], entityExpression);
expression2 = (expression2 != null) ? expression2.And(expression4) : expression4;
}
return(new DeleteCommand(root, expression2));
}
private Expression ExecuteProjection(ProjectionExpression projection, bool okayToDefer, QueryCommand command, Expression[] values)
{
okayToDefer &= (this.receivingMember != null) && this.policy.IsDeferLoaded(this.receivingMember);
Scope scope = this.scope;
ParameterExpression fieldReader = Expression.Parameter(typeof(FieldReader), "r" + this.nReaders++);
this.scope = new Scope(this.scope, fieldReader, projection.Select.Alias, projection.Select.Columns);
LambdaExpression expression2 = Expression.Lambda(this.Visit(projection.Projector), new ParameterExpression[] { fieldReader });
this.scope = scope;
MappingEntity entity = EntityFinder.Find(projection.Projector);
string methodName = okayToDefer ? "ExecuteDeferred" : "Execute";
Expression replaceWith = Expression.Call(this.executor, methodName, new Type[] { expression2.Body.Type }, new Expression[] { Expression.Constant(command), expression2, Expression.Constant(entity, typeof(MappingEntity)), Expression.NewArrayInit(typeof(object), values) });
if (projection.Aggregator != null)
{
replaceWith = DbExpressionReplacer.Replace(projection.Aggregator.Body, projection.Aggregator.Parameters[0], replaceWith);
}
return(replaceWith);
}
