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