protected override Expression VisitMemberAccess(MemberExpression m)
{
Expression source = this.Visit(m.Expression);
EntityExpression ex = GetEntityExpression(source);
if (ex != null && this.mapping.IsRelationship(ex.Entity, m.Member))
{
ProjectionExpression projection = (ProjectionExpression)this.Visit(this.mapper.GetMemberExpression(source, ex.Entity, m.Member));
if (this.currentFrom != null && this.mapping.IsSingletonRelationship(ex.Entity, m.Member))
{
// convert singleton associations directly to OUTER APPLY
// by adding join to relavent FROM clause
// and placing an OuterJoinedExpression in the projection to remember the outer-join test-for-null condition
projection = this.language.AddOuterJoinTest(projection);
Expression newFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, projection.Select, null);
this.currentFrom = newFrom;
return(projection.Projector);
}
return(projection);
}
else
{
Expression result = QueryBinder.BindMember(source, m.Member);
MemberExpression mex = result as MemberExpression;
if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression)
{
return(m);
}
return(result);
}
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
Expression source = this.Visit(m.Expression);
EntityExpression ex = source as EntityExpression;
IMemberMapping mm = null;
if (ex != null && (mm = ex.Entity.Get(m.Member)) != null && mm.IsRelationship)
{
ProjectionExpression projection = (ProjectionExpression)this.Visit(this.expressionBuilder.GetMemberExpression(source, ex.Entity, m.Member));
if (this.currentFrom != null && mm.IsManyToOne)
{
// convert singleton associations directly to OUTER APPLY
projection = this.expressionBuilder.AddOuterJoinTest(projection);
Expression newFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, projection.Select, null);
this.currentFrom = newFrom;
return(projection.Projector);
}
return(projection);
}
else
{
Expression result = QueryBinder.BindMember(source, m.Member);
MemberExpression mex = result as MemberExpression;
if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression)
{
return(m);
}
return(result);
}
}
public override Expression GetMemberExpression(Expression root, MappingEntity entity, MemberInfo member)
{
if (this.mapping.IsAssociationRelationship(entity, member))
{
MappingEntity relatedEntity = this.mapping.GetRelatedEntity(entity, member);
ProjectionExpression queryExpression = this.GetQueryExpression(relatedEntity);
List <MemberInfo> list = this.mapping.GetAssociationKeyMembers(entity, member).ToList <MemberInfo>();
List <MemberInfo> list2 = this.mapping.GetAssociationRelatedKeyMembers(entity, member).ToList <MemberInfo>();
Expression expression2 = null;
int num = 0;
int count = list2.Count;
while (num < count)
{
Expression expression3 = this.GetMemberExpression(queryExpression.Projector, relatedEntity, list2[num]).Equal(this.GetMemberExpression(root, entity, list[num]));
expression2 = (expression2 != null) ? expression2.And(expression3) : expression3;
num++;
}
TableAlias newAlias = new TableAlias();
ProjectedColumns columns = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, queryExpression.Projector, null, newAlias, new TableAlias[] { queryExpression.Select.Alias });
LambdaExpression aggregator = Aggregator.GetAggregator(King.Framework.Linq.TypeHelper.GetMemberType(member), typeof(IEnumerable <>).MakeGenericType(new Type[] { columns.Projector.Type }));
ProjectionExpression expression = new ProjectionExpression(new SelectExpression(newAlias, columns.Columns, queryExpression.Select, expression2), columns.Projector, aggregator);
return(this.translator.Police.ApplyPolicy(expression, member));
}
AliasedExpression expression6 = root as AliasedExpression;
if ((expression6 != null) && this.mapping.IsColumn(entity, member))
{
return(new ColumnExpression(King.Framework.Linq.TypeHelper.GetMemberType(member), this.GetColumnType(entity, member), expression6.Alias, this.mapping.GetColumnName(entity, member)));
}
return(QueryBinder.BindMember(root, member));
}
protected override Expression VisitMember(MemberExpression m)
{
var source = Visit(m.Expression);
IProperty property;
// **fix** 解决无法返回两级以上关联对象的问题
// var ex = source as EntityExpression
// if (ex != null &&
if ((property = PropertyUnity.GetProperty(m.Expression.Type, m.Member.Name)) != null &&
property is RelationProperty)
{
var projection = (ProjectionExpression)Visit(QueryUtility.GetMemberExpression(source, property));
if (currentFrom != null && m.Member.GetMemberType().GetEnumerableType() == null)
{
// convert singleton associations directly to OUTER APPLY
projection = projection.AddOuterJoinTest();
var newFrom = new JoinExpression(JoinType.OuterApply, currentFrom, projection.Select, null);
currentFrom = newFrom;
return(projection.Projector);
}
return(projection);
}
var result = QueryBinder.BindMember(source, m.Member);
if (result is MemberExpression mex &&
mex.Member == m.Member &&
mex.Expression == m.Expression)
{
return(m);
}
return(result);
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
Expression root = this.Visit(m.Expression);
EntityExpression expression2 = root as EntityExpression;
if ((expression2 != null) && this.mapping.IsRelationship(expression2.Entity, m.Member))
{
ProjectionExpression proj = (ProjectionExpression)this.Visit(this.mapper.GetMemberExpression(root, expression2.Entity, m.Member));
if ((this.currentFrom != null) && this.mapping.IsSingletonRelationship(expression2.Entity, m.Member))
{
proj = this.language.AddOuterJoinTest(proj);
Expression expression4 = new JoinExpression(JoinType.OuterApply, this.currentFrom, proj.Select, null);
this.currentFrom = expression4;
return(proj.Projector);
}
return(proj);
}
Expression expression5 = QueryBinder.BindMember(root, m.Member);
MemberExpression expression6 = expression5 as MemberExpression;
if (((expression6 != null) && (expression6.Member == m.Member)) && (expression6.Expression == m.Expression))
{
return(m);
}
return(expression5);
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
Expression source = Visit(m.Expression);
var ex = source as EntryExpression;
if (ex != null && mapping.IsRelationship(ex.Entry, m.Member))
{
var projection = (ProjectionExpression)Visit(mapper.GetMemberExpression(source, ex.Entry, m.Member));
if (currentFrom != null && mapping.IsSingletonRelationship(ex.Entry, m.Member))
{
// convert singleton associations directly to OUTER APPLY
projection = language.AddOuterJoinTest(projection);
Expression newFrom = new JoinExpression(JoinType.OuterApply, currentFrom, projection.Select, null);
currentFrom = newFrom;
return(projection.Projector);
}
return(projection);
}
else
{
Expression result = QueryBinder.BindMember(source, m.Member);
var mex = result as MemberExpression;
if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression)
{
return(m);
}
return(result);
}
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
protected override Expression VisitMemberAccess(MemberExpression m)
{
Expression source = this.Visit(m.Expression);
if (this.mapping.IsRelationship(m.Member))
{
ProjectionExpression projection = (ProjectionExpression)this.Visit(this.mapping.GetMemberExpression(source, m.Member));
if (this.currentFrom != null && this.mapping.IsSingletonRelationship(m.Member))
{
// convert singleton associations directly to OUTER APPLY
projection = projection.AddOuterJoinTest();
Expression newFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, projection.Source, null);
this.currentFrom = newFrom;
return(projection.Projector);
}
return(projection);
}
else
{
Expression result = QueryBinder.BindMember(source, m.Member);
MemberExpression mex = result as MemberExpression;
if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression)
{
return(m);
}
return(result);
}
}
/// <summary>
/// Get an expression for a mapped property relative to a root expression.
/// The root is either a TableExpression or an expression defining an entity instance.
/// </summary>
/// <param name="root"></param>
/// <param name="member"></param>
/// <returns></returns>
public virtual Expression GetMemberExpression(Expression root, MemberInfo member)
{
if (this.IsRelationship(member))
{
Type rowType = this.GetRelatedType(member);
ProjectionExpression projection = this.GetTableQuery(rowType);
// make where clause for joining back to 'root'
List <MemberInfo> declaredTypeMembers;
List <MemberInfo> associatedMembers;
this.GetAssociationKeys(member, out declaredTypeMembers, out associatedMembers);
Expression where = null;
for (int i = 0, n = associatedMembers.Count; i < n; i++)
{
Expression equal = Expression.Equal(
this.GetMemberExpression(projection.Projector, associatedMembers[i]),
this.GetMemberExpression(root, declaredTypeMembers[i])
);
where = (where != null) ? Expression.And(where, equal) : equal;
}
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.Language.CanBeColumn, projection.Projector, null, newAlias, projection.Source.Alias);
LambdaExpression aggregator = this.GetAggregator(TypeHelper.GetMemberType(member), typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
return(new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Source, where),
pc.Projector, aggregator
));
}
else
{
TableExpression table = root as TableExpression;
if (table != null)
{
if (this.IsColumn(member))
{
string columnName = this.GetColumnName(member);
if (!string.IsNullOrEmpty(columnName))
{
return(new ColumnExpression(TypeHelper.GetMemberType(member), table.Alias, this.GetColumnName(member)));
}
else
{
return(root);
}
}
else
{
return(this.GetTypeProjection(root, TypeHelper.GetMemberType(member)));
}
}
else
{
return(QueryBinder.BindMember(root, member));
}
}
}
internal static Expression GetMemberExpression(Expression root, IProperty property)
{
var relationProprety = property as RelationProperty;
if (relationProprety != null)
{
//所关联的实体类型
var relMetadata = EntityMetadataUnity.GetEntityMetadata(relationProprety.RelationType);
var projection = GetTableQuery(relMetadata);
Expression parentExp = null, childExp = null;
var ship = RelationshipUnity.GetRelationship(relationProprety);
if (ship.ThisType != relationProprety.EntityType)
{
parentExp = projection.Projector;
childExp = root;
}
else
{
parentExp = root;
childExp = projection.Projector;
}
Expression where = null;
for (int i = 0, n = ship.Keys.Count; i < n; i++)
{
var equal = GetMemberExpression(parentExp, ship.Keys[i].ThisProperty)
.Equal(GetMemberExpression(childExp, ship.Keys[i].OtherProperty));
where = (where != null) ? Expression.And(where, equal) : equal;
}
var newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projection.Projector, null, newAlias, projection.Select.Alias);
var aggregator = GetAggregator(property.Type, typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator
);
return(ApplyPolicy(result, property.Info.ReflectionInfo));
}
var table = root as TableExpression;
if (table != null)
{
var sqProperty = property as SubqueryProperty;
if (sqProperty != null)
{
return(new SubqueryColumnExpression(property.Type, table.Alias, property.Info.FieldName, sqProperty.Subquery));
}
else if (property is ISavedProperty)
{
return(new ColumnExpression(property.Type, table.Alias, property.Name, property.Info));
}
}
return(QueryBinder.BindMember(root, property.Info.ReflectionInfo));
}
protected Expression MakePredicate(Expression e1, Expression e2, IEnumerable <MemberInfo> members, bool negate)
{
Expression expression = (from m in members select QueryBinder.BindMember(e1, m).Equal(QueryBinder.BindMember(e2, m))).Join(ExpressionType.And);
if (negate)
{
expression = Expression.Not(expression);
}
return(expression);
}
protected Expression MakePredicate(Expression e1, Expression e2, IEnumerable <MemberInfo> members, bool negate)
{
Expression pred = members.Select(m => QueryBinder.BindMember(e1, m).Equal(QueryBinder.BindMember(e2, m))).Join(ExpressionType.And);
if (negate)
{
pred = Expression.Not(pred);
}
return(pred);
}
/// <summary>
/// Get an expression for a mapped property relative to a root expression.
/// The root is either a TableExpression or an expression defining an entity instance.
/// </summary>
/// <param name="root"></param>
/// <param name="entity"></param>
/// <param name="member"></param>
/// <returns></returns>
public override Expression GetMemberExpression(Expression root, MappingEntity entity, MemberInfo member)
{
AliasedExpression aliasedRoot = root as AliasedExpression;
if (aliasedRoot != null && this.mapping.IsColumn(entity, member))
{
return(new ColumnExpression(TypeHelper.GetMemberType(member), aliasedRoot.Alias, this.mapping.GetColumnName(entity, member)));
}
return(QueryBinder.BindMember(root, member));
}
internal static Expression GetMemberExpression(TranslateContext transContext, Expression root, IProperty property)
{
if (property is RelationProperty relationProprety)
{
//所关联的实体类型
var relMetadata = EntityMetadataUnity.GetEntityMetadata(relationProprety.RelationalType);
var projection = GetTableQuery(transContext, relMetadata, false, false);
Expression parentExp = null, childExp = null;
var ship = RelationshipUnity.GetRelationship(relationProprety);
if (ship.ThisType != relationProprety.EntityType)
{
parentExp = projection.Projector;
childExp = root;
}
else
{
parentExp = root;
childExp = projection.Projector;
}
var where = ship.Keys.Select(r =>
GetMemberExpression(transContext, parentExp, r.ThisProperty).Equal(GetMemberExpression(transContext, childExp, r.OtherProperty)))
.Aggregate(Expression.And);
var newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projection.Projector, null, newAlias, projection.Select.Alias);
var aggregator = GetAggregator(property.Type, typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator, projection.IsAsync, projection.IsNoTracking
);
return(transContext.QueryPolicy.ApplyPolicy(result, property.Info.ReflectionInfo, ex => QueryBinder.Bind(transContext, ex)));
}
if (root is TableExpression table)
{
if (property is SubqueryProperty sqProperty)
{
return(new SubqueryColumnExpression(property.Type, table.Alias, property.Info.FieldName, sqProperty.Subquery));
}
else if (property is ISavedProperty)
{
return(new ColumnExpression(property.Type, table.Alias, property.Name, property.Info));
}
}
return(QueryBinder.BindMember(root, property.Info.ReflectionInfo));
}
public virtual Expression GetMemberExpression(Expression root, IEntityMapping mapping, IMemberMapping mm)
{
var m = mm.Member;
if (mm.IsRelationship)
{
IEntityMapping relatedEntity = mm.RelatedEntity;
ProjectionExpression projection = this.GetQueryExpression(relatedEntity);
// make where clause for joining back to 'root'
var thisKeyMembers = mm.ThisKeyMembers;
var otherKeyMembers = mm.OtherKeyMembers;
Expression where = null;
for (int i = 0, n = otherKeyMembers.Length; i < n; i++)
{
Expression equal =
this.GetMemberExpression(projection.Projector, relatedEntity, otherKeyMembers[i]).Equal(
this.GetMemberExpression(root, mapping, thisKeyMembers[i])
);
where = (where != null) ? where.And(equal) : equal;
}
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(projection.Projector, null, newAlias, projection.Select.Alias);
LambdaExpression aggregator = Aggregator.GetAggregator(mm.MemberType, typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator
);
return(ApplyPolicy(result, m));
}
else
{
AliasedExpression aliasedRoot = root as AliasedExpression;
if (aliasedRoot != null && mm.IsColumn)
{
return(new ColumnExpression(mm.MemberType, mm.SqlType, aliasedRoot.Alias, mm.ColumnName));
}
return(QueryBinder.BindMember(root, m));
}
}
public override Expression GetMemberExpression(Expression root, MappingEntity entity, MemberInfo member)
{
if (this.mapping.IsAssociationRelationship(entity, member))
{
MappingEntity relatedEntity = this.mapping.GetRelatedEntity(entity, member);
ProjectionExpression projection = this.GetQueryExpression(relatedEntity);
// make where clause for joining back to 'root'
var declaredTypeMembers = this.mapping.GetAssociationKeyMembers(entity, member).ToList();
var associatedMembers = this.mapping.GetAssociationRelatedKeyMembers(entity, member).ToList();
Expression where = null;
for (int i = 0, n = associatedMembers.Count; i < n; i++)
{
Expression equal =
this.GetMemberExpression(projection.Projector, relatedEntity, associatedMembers[i]).Equal(
this.GetMemberExpression(root, entity, declaredTypeMembers[i])
);
where = (where != null) ? where.And(equal) : equal;
}
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, projection.Projector, null, newAlias, projection.Select.Alias);
LambdaExpression aggregator = Aggregator.GetAggregator(TypeHelper.GetMemberType(member), typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator
);
return(this.translator.Police.ApplyPolicy(result, member));
}
else
{
AliasedExpression aliasedRoot = root as AliasedExpression;
if (aliasedRoot != null && this.mapping.IsColumn(entity, member))
{
return(new ColumnExpression(TypeHelper.GetMemberType(member), this.GetColumnType(entity, member), aliasedRoot.Alias, this.mapping.GetColumnName(entity, member)));
}
return(QueryBinder.BindMember(root, member));
}
}
