internal static ProjectedColumns ProjectColumns(Func <Expression, bool> fnCanBeColumn, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
var projector = new ColumnProjector(fnCanBeColumn, expression, existingColumns, newAlias, existingAliases);
var expr = projector.Visit(expression);
return(new ProjectedColumns(expr, projector._columns.AsReadOnly()));
}
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 override Expression VisitProjection(ProjectionExpression proj)
{
var saved = currentSelect;
currentSelect = proj.Select;
try
{
if (!isTopLevel)
{
if (CanJoinOnClient(currentSelect))
{
// make a query that combines all the constraints from the outer queries into a single select
var newOuterSelect = (SelectExpression)QueryDuplicator.Duplicate(saved);
// remap any references to the outer select to the new alias;
var newInnerSelect = (SelectExpression)ColumnMapper.Map(proj.Select, newOuterSelect.Alias, saved.Alias);
// add outer-join test
var newInnerProjection = new ProjectionExpression(newInnerSelect, proj.Projector).AddOuterJoinTest();
newInnerSelect = newInnerProjection.Select;
var newProjector = newInnerProjection.Projector;
var newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(QueryUtility.CanBeColumnExpression, newProjector, newOuterSelect.Columns, newAlias, newOuterSelect.Alias, newInnerSelect.Alias);
var join = new JoinExpression(JoinType.OuterApply, newOuterSelect, newInnerSelect, null);
var joinedSelect = new SelectExpression(newAlias, pc.Columns, join, null, null, null, proj.IsSingleton, null, null, null, false);
// apply client-join treatment recursively
currentSelect = joinedSelect;
newProjector = Visit(pc.Projector);
// compute keys (this only works if join condition was a single column comparison)
var outerKeys = new List <Expression>();
var innerKeys = new List <Expression>();
if (GetEquiJoinKeyExpressions(newInnerSelect.Where, newOuterSelect.Alias, outerKeys, innerKeys))
{
// outerKey needs to refer to the outer-scope's alias
var outerKey = outerKeys.Select(k => ColumnMapper.Map(k, saved.Alias, newOuterSelect.Alias));
// innerKey needs to refer to the new alias for the select with the new join
var innerKey = innerKeys.Select(k => ColumnMapper.Map(k, joinedSelect.Alias, ((ColumnExpression)k).Alias));
var newProjection = new ProjectionExpression(joinedSelect, newProjector, proj.Aggregator);
return(new ClientJoinExpression(newProjection, outerKey, innerKey));
}
}
}
else
{
isTopLevel = false;
}
return(base.VisitProjection(proj));
}
finally
{
currentSelect = saved;
}
}
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));
}
protected override Expression VisitProjection(ProjectionExpression proj)
{
if (isTopLevel)
{
isTopLevel = false;
currentSelect = proj.Select;
var projector = Visit(proj.Projector);
if (projector != proj.Projector || currentSelect != proj.Select)
{
return(new ProjectionExpression(currentSelect, projector, proj.Aggregator, proj.IsAsync));
}
return(proj);
}
if (proj.IsSingleton && CanJoinOnServer(currentSelect))
{
var newAlias = new TableAlias();
currentSelect = currentSelect.AddRedundantSelect(newAlias);
var source = (SelectExpression)ColumnMapper.Map(proj.Select, newAlias, currentSelect.Alias);
var pex = new ProjectionExpression(source, proj.Projector, proj.IsAsync).AddOuterJoinTest();
var pc = ColumnProjector.ProjectColumns(QueryUtility.CanBeColumnExpression, pex.Projector, currentSelect.Columns, currentSelect.Alias, newAlias, proj.Select.Alias);
// **fix** 解决返回关联对象后使用Distinct的问题
var join = CreateJoinExpression(currentSelect.From, pex.Select, out bool isDistinct);
currentSelect = new SelectExpression(currentSelect.Alias, pc.Columns, join, null);
if (isDistinct)
{
var newPc = ColumnProjector.ProjectColumns(QueryUtility.CanBeColumnExpression, proj.Projector, null, currentSelect.Alias, proj.Select.Alias);
currentSelect = new SelectExpression(currentSelect.Alias, newPc.Columns, currentSelect, null, null, null, isDistinct, null, null, null, null, false);
return(Visit(newPc.Projector));
}
return(Visit(pc.Projector));
}
var saveTop = isTopLevel;
var saveSelect = currentSelect;
isTopLevel = true;
currentSelect = null;
var result = base.VisitProjection(proj);
isTopLevel = saveTop;
currentSelect = saveSelect;
return(result);
}
internal static ProjectionExpression GetTableQuery(EntityMetadata entity, bool isNoTracking)
{
var tableAlias = new TableAlias();
var selectAlias = new TableAlias();
var entityType = entity.EntityType;
var table = new TableExpression(tableAlias, entity.TableName, entityType);
var projector = GetTypeProjection(table, entity, isNoTracking);
var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projector, null, selectAlias, tableAlias);
var proj = new ProjectionExpression(
new SelectExpression(selectAlias, pc.Columns, table, null),
pc.Projector
);
return((ProjectionExpression)ApplyPolicy(proj, entityType));
}
internal static ProjectionExpression GetTableQuery(TranslateContext transContext, EntityMetadata entity, bool isNoTracking, bool isAsync)
{
var tableAlias = new TableAlias();
var selectAlias = new TableAlias();
var entityType = entity.EntityType;
var table = new TableExpression(tableAlias, entity.TableName, entityType);
var projector = GetTypeProjection(transContext, table, entity);
var pc = ColumnProjector.ProjectColumns(CanBeColumnExpression, projector, null, selectAlias, tableAlias);
var proj = new ProjectionExpression(
new SelectExpression(selectAlias, pc.Columns, table, null),
pc.Projector, isAsync, isNoTracking
);
return((ProjectionExpression)transContext.QueryPolicy.ApplyPolicy(proj, entityType, ex => QueryBinder.Bind(transContext, ex)));
}
/// <summary>
/// 访问 <see cref="JoinExpression"/>。
/// </summary>
/// <param name="join">要访问的表达式。</param>
/// <returns></returns>
protected override Expression VisitJoin(JoinExpression join)
{
join = (JoinExpression)base.VisitJoin(join);
if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
{
if (join.Right is TableExpression)
{
return(new JoinExpression(JoinType.CrossJoin, join.Left, join.Right, null));
}
else
{
var select = join.Right as SelectExpression;
// Only consider rewriting cross apply if
// 1) right side is a select
// 2) other than in the where clause in the right-side select, no left-side declared aliases are referenced
// 3) and has no behavior that would change semantics if the where clause is removed (like groups, aggregates, take, skip, etc).
// Note: it is best to attempt this after redundant subqueries have been removed.
if (select != null &&
select.Take == null &&
select.Skip == null &&
!AggregateChecker.HasAggregates(select) &&
(select.GroupBy == null || select.GroupBy.Count == 0))
{
var selectWithoutWhere = select.SetWhere(null);
var referencedAliases = ReferencedAliasGatherer.Gather(selectWithoutWhere);
var declaredAliases = DeclaredAliasGatherer.Gather(join.Left);
referencedAliases.IntersectWith(declaredAliases);
if (referencedAliases.Count == 0)
{
var where = select.Where;
select = selectWithoutWhere;
var pc = ColumnProjector.ProjectColumns(this.CanBeColumn, where, select.Columns, select.Alias, DeclaredAliasGatherer.Gather(select.From));
select = select.SetColumns(pc.Columns);
where = pc.Projector;
var jt = (where == null) ? JoinType.CrossJoin : (join.JoinType == JoinType.CrossApply ? JoinType.InnerJoin : JoinType.LeftOuter);
return(new JoinExpression(jt, join.Left, select, where));
}
}
}
}
return(join);
}
