protected override Expression VisitJoin(DbJoinExpression join)
{
join = base.VisitJoin(join) as DbJoinExpression;
if (join.JoinType == JoinType.CrossJoin && this.currentWhere != null)
{
var declaredLeft = DbDeclaredAliasGatherer.Gather(join.Left);
var declaredRight = DbDeclaredAliasGatherer.Gather(join.Right);
var declared = new HashSet <TableAlias>(declaredLeft.Union(declaredRight));
var exprs = this.currentWhere.Split(ExpressionType.And, ExpressionType.AndAlso);
var good = exprs.Where(e => CanBeJoinCondition(e, declaredLeft, declaredRight, declared)).ToList();
if (good.Count > 0)
{
var condition = good.Join(ExpressionType.And);
join = this.UpdateJoin(join, JoinType.InnerJoin, join.Left, join.Right, condition);
var newWhere = exprs.Where(e => !good.Contains(e)).Join(ExpressionType.And);
this.currentWhere = newWhere;
}
}
return(join);
}
protected virtual bool CompareJoin(DbJoinExpression a, DbJoinExpression b)
{
if (a.JoinType != b.JoinType || !this.Compare(a.Left, b.Left))
{
return(false);
}
if (a.JoinType == JoinType.CrossApply || a.JoinType == JoinType.OuterApply)
{
var save = this.aliasScope;
try
{
this.aliasScope = new ScopedDictionary <TableAlias, TableAlias>(this.aliasScope);
this.MapAliases(a.Left, b.Left);
return(this.Compare(a.Right, b.Right) && this.Compare(a.Condition, b.Condition));
}
finally
{
this.aliasScope = save;
}
}
else
{
return(this.Compare(a.Right, b.Right) && this.Compare(a.Condition, b.Condition));
}
}
protected override Expression VisitJoin(DbJoinExpression join)
{
if (join.JoinType == JoinType.SingletonLeftOuter)
{
var right = this.Visit(join.Right);
if (right is DbAliasedExpression ax && !this.allColumnsUsed.ContainsKey(ax.Alias))
{
return(this.Visit(join.Left));
}
var cond = this.Visit(join.Condition);
var left = this.Visit(join.Left);
right = this.Visit(join.Right);
return(this.UpdateJoin(join, join.JoinType, left, right, cond));
}
else
{
var condition = this.Visit(join.Condition);
var right = this.VisitSource(join.Right);
var left = this.VisitSource(join.Left);
return(this.UpdateJoin(join, join.JoinType, left, right, condition));
}
}
protected virtual Expression VisitJoin(DbJoinExpression join)
{
var left = this.VisitSource(join.Left);
var right = this.VisitSource(join.Right);
var condition = this.Visit(join.Condition);
return(this.UpdateJoin(join, join.JoinType, left, right, condition));
}
protected override Expression VisitJoin(DbJoinExpression join)
{
this.VisitJoinLeft(join.Left);
this.WriteLine(Indentation.Same);
switch (join.JoinType)
{
case JoinType.CrossJoin:
{
this.Write("CROSS JOIN ");
break;
}
case JoinType.InnerJoin:
{
this.Write("INNER JOIN ");
break;
}
case JoinType.CrossApply:
{
this.Write("CROSS APPLY ");
break;
}
case JoinType.OuterApply:
{
this.Write("OUTER APPLY ");
break;
}
case JoinType.LeftOuter:
case JoinType.SingletonLeftOuter:
{
this.Write("LEFT OUTER JOIN ");
break;
}
}
this.VisitJoinRight(join.Right);
if (join.Condition != null)
{
this.WriteLine(Indentation.Inner);
this.Write("ON ");
this.VisitPredicate(join.Condition);
this.Indent(Indentation.Outer);
}
return(join);
}
protected DbJoinExpression UpdateJoin(DbJoinExpression join, JoinType joinType, Expression left, Expression right, Expression condition)
{
if (joinType != join.JoinType || left != join.Left || right != join.Right || condition != join.Condition)
{
return(new DbJoinExpression(joinType, left, right, condition));
}
return(join);
}
protected override Expression VisitProjection(DbProjectionExpression proj)
{
if (isTopLevel)
{
isTopLevel = false;
this.currentSelect = proj.Select;
var projector = this.Visit(proj.Projector);
if (projector != proj.Projector || this.currentSelect != proj.Select)
{
return(new DbProjectionExpression(this.currentSelect, projector, proj.Aggregator));
}
return(proj);
}
if (proj.IsSingleton && this.CanJoinOnServer(this.currentSelect))
{
var newAlias = new TableAlias();
this.currentSelect = this.currentSelect.AddRedundantSelect(this.language, newAlias);
var source = DbColumnMapper.Map(proj.Select, newAlias, this.currentSelect.Alias) as DbSelectExpression;
var pex = this.language.AddOuterJoinTest(new DbProjectionExpression(source, proj.Projector));
var pc = DbColumnProjector.ProjectColumns(this.language, pex.Projector, this.currentSelect.Columns, this.currentSelect.Alias, newAlias, proj.Select.Alias);
var join = new DbJoinExpression(JoinType.OuterApply, this.currentSelect.From, pex.Select, null);
this.currentSelect = new DbSelectExpression(this.currentSelect.Alias, pc.Columns, join, null);
return(this.Visit(pc.Projector));
}
var saveTop = this.isTopLevel;
var saveSelect = this.currentSelect;
this.isTopLevel = true;
this.currentSelect = null;
var result = base.VisitProjection(proj);
this.isTopLevel = saveTop;
this.currentSelect = saveSelect;
return(result);
}
protected override Expression VisitJoin(DbJoinExpression join)
{
var saveLastJoin = this.lastJoin;
this.lastJoin = join.JoinType;
join = base.VisitJoin(join) as DbJoinExpression;
this.lastJoin = saveLastJoin;
if (this.lastJoin != null && (join.JoinType == JoinType.CrossJoin) != (this.lastJoin == JoinType.CrossJoin))
{
return(this.MakeSubquery(join));
}
return(join);
}
protected override Expression VisitJoin(DbJoinExpression join)
{
var left = this.VisitSource(join.Left);
var leftOrders = this.gatheredOrderings;
this.gatheredOrderings = null;
var right = this.VisitSource(join.Right);
this.PrependOrderings(leftOrders);
var condition = this.Visit(join.Condition);
if (left != join.Left || right != join.Right || condition != join.Condition)
{
return(new DbJoinExpression(join.JoinType, left, right, condition));
}
return(join);
}
protected override Expression VisitJoin(DbJoinExpression join)
{
join = base.VisitJoin(join) as DbJoinExpression;
if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
{
if (join.Right is DbTableExpression)
{
return(new DbJoinExpression(JoinType.CrossJoin, join.Left, join.Right, null));
}
if (join.Right is DbSelectExpression select && select.Take == null && select.Skip == null && !DbAggregateChecker.HasAggregates(select) && (select.GroupBy == null || select.GroupBy.Count == 0))
{
var selectWithoutWhere = select.SetWhere(null);
var referencedAliases = DbReferencedAliasGatherer.Gather(selectWithoutWhere);
var declaredAliases = DbDeclaredAliasGatherer.Gather(join.Left);
if (referencedAliases != null)
{
referencedAliases.IntersectWith(declaredAliases);
}
if (referencedAliases.Count == 0)
{
var where = select.Where;
select = selectWithoutWhere;
var pc = DbColumnProjector.ProjectColumns(this.language, where, select.Columns, select.Alias, DbDeclaredAliasGatherer.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 DbJoinExpression(jt, join.Left, select, where));
}
}
}
return(join);
}
protected override Expression VisitJoin(DbJoinExpression join)
{
var result = base.VisitJoin(join);
join = result as DbJoinExpression;
if (join != null)
{
if (join.Right is DbAliasedExpression right)
{
if (this.FindSimilarRight(join.Left as DbJoinExpression, join) is DbAliasedExpression similarRight)
{
this.map.Add(right.Alias, similarRight.Alias);
return(join.Left);
}
}
}
return(result);
}
private Expression FindSimilarRight(DbJoinExpression join, DbJoinExpression compareTo)
{
if (join == null)
{
return(null);
}
if (join.JoinType == compareTo.JoinType)
{
if (join.Right.NodeType == compareTo.Right.NodeType && DbExpressionComparer.AreEqual(join.Right, compareTo.Right))
{
if (join.Condition == compareTo.Condition)
{
return(join.Right);
}
var scope = new ScopedDictionary <TableAlias, TableAlias>(null);
if (scope != null)
{
scope.Add((join.Right as DbAliasedExpression).Alias, (compareTo.Right as DbAliasedExpression).Alias);
}
if (DbExpressionComparer.AreEqual(null, scope, join.Condition, compareTo.Condition))
{
return(join.Right);
}
}
}
var result = FindSimilarRight(join.Left as DbJoinExpression, compareTo);
if (result == null)
{
result = FindSimilarRight(join.Right as DbJoinExpression, compareTo);
}
return(result);
}
internal override DbProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count <= 1)
{
return(base.GetQueryExpression(entity));
}
var aliases = new Dictionary <string, TableAlias>();
var rootTable = tables.Single(ta => !this.mapping.IsExtensionTable(ta));
var tex = new DbTableExpression(new TableAlias(), entity, this.mapping.GetTableName(rootTable));
aliases.Add(this.mapping.GetAlias(rootTable), tex.Alias);
var source = tex as Expression;
foreach (var table in tables.Where(t => this.mapping.IsExtensionTable(t)))
{
var joinedTableAlias = new TableAlias();
var extensionAlias = this.mapping.GetAlias(table);
aliases.Add(extensionAlias, joinedTableAlias);
var keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToList();
var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToList();
var relatedAlias = this.mapping.GetExtensionRelatedAlias(table);
aliases.TryGetValue(relatedAlias, out TableAlias relatedTableAlias);
var joinedTex = new DbTableExpression(joinedTableAlias, entity, this.mapping.GetTableName(table));
var cond = null as Expression;
for (int i = 0, n = keyColumns.Count; i < n; i++)
{
var memberType = TypeHelper.GetMemberType(relatedMembers[i]);
var colType = this.GetColumnType(entity, relatedMembers[i]);
var relatedColumn = new DbColumnExpression(memberType, colType, relatedTableAlias, this.mapping.GetColumnName(entity, relatedMembers[i]));
var joinedColumn = new DbColumnExpression(memberType, colType, joinedTableAlias, keyColumns[i]);
var eq = joinedColumn.Equal(relatedColumn);
cond = (cond != null) ? cond.And(eq) : eq;
}
source = new DbJoinExpression(JoinType.SingletonLeftOuter, source, joinedTex, cond);
}
var columns = new List <DbColumnDeclaration>();
this.GetColumns(entity, aliases, columns);
var root = new DbSelectExpression(new TableAlias(), columns, source, null);
var existingAliases = aliases.Values.ToArray();
var projector = this.GetEntityExpression(root, entity) as Expression;
var selectAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns(this.Translator.Linguist.Language, projector, null, selectAlias, root.Alias);
var proj = new DbProjectionExpression
(
new DbSelectExpression(selectAlias, pc.Columns, root, null),
pc.Projector
);
return(this.Translator.Police.ApplyPolicy(proj, entity.ElementType.GetTypeInfo()) as DbProjectionExpression);
}
protected override Expression VisitProjection(DbProjectionExpression proj)
{
var save = this.currentSelect;
this.currentSelect = proj.Select;
try
{
if (this.isTopLevel == false)
{
if (this.CanJoinOnClient(this.currentSelect))
{
var newOuterSelect = DbQueryDuplicator.Duplicate(save) as DbSelectExpression;
var newInnerSelect = DbColumnMapper.Map(proj.Select, newOuterSelect.Alias, save.Alias) as DbSelectExpression;
var newInnerProjection = this.language.AddOuterJoinTest(new DbProjectionExpression(newInnerSelect, proj.Projector));
if (newInnerProjection != null)
{
newInnerSelect = newInnerProjection.Select;
}
var newProjector = newInnerProjection.Projector;
var newAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns(this.language, newProjector, null, newAlias, newOuterSelect.Alias, newInnerSelect.Alias);
var join = new DbJoinExpression(JoinType.OuterApply, newOuterSelect, newInnerSelect, null);
var joinedSelect = new DbSelectExpression(newAlias, pc.Columns, join, null, null, null, proj.IsSingleton, null, null, false);
this.currentSelect = joinedSelect;
if (pc != null)
{
newProjector = this.Visit(pc.Projector);
}
var outerKeys = new List <Expression>();
var innerKeys = new List <Expression>();
if (this.GetEquiJoinKeyExpressions(newInnerSelect.Where, newOuterSelect.Alias, outerKeys, innerKeys))
{
var outerKey = outerKeys.Select(k => DbColumnMapper.Map(k, save.Alias, newOuterSelect.Alias));
var innerKey = innerKeys.Select(k => DbColumnMapper.Map(k, joinedSelect.Alias, ((DbColumnExpression)k).Alias));
var newProjection = new DbProjectionExpression(joinedSelect, newProjector, proj.Aggregator);
return(new DbClientJoinExpression(newProjection, outerKey, innerKey));
}
}
else
{
var saveJoin = this.canJoinOnClient;
this.canJoinOnClient = false;
var result = base.VisitProjection(proj);
this.canJoinOnClient = saveJoin;
return(result);
}
}
else
{
this.isTopLevel = false;
}
return(base.VisitProjection(proj));
}
finally
{
this.currentSelect = save;
}
}
