protected override Expression VisitJoin(JoinExpression join)
{
if (join.Join == JoinType.SingletonLeftOuter)
{
// first visit right side w/o looking at condition
Expression right = this.Visit(join.Right);
AliasedExpression ax = right as AliasedExpression;
if (ax != null && !this.allColumnsUsed.ContainsKey(ax.Alias))
{
// if nothing references the alias on the right, then the join is redundant
return(this.Visit(join.Left));
}
// otherwise do it the right way
Expression cond = this.Visit(join.Condition);
Expression left = this.Visit(join.Left);
right = this.Visit(join.Right);
return(this.UpdateJoin(join, join.Join, left, right, cond));
}
else
{
// visit join in reverse order
Expression condition = this.Visit(join.Condition);
Expression right = this.VisitSource(join.Right);
Expression left = this.VisitSource(join.Left);
return(this.UpdateJoin(join, join.Join, left, right, condition));
}
}
public void WhereQuery_AliasedWhereFact()
{
var fromTable = new Table("dbo.from", "f");
var addressCol = new AliasedExpression <Expression>(
new Expression("CONCAT(Street, Number)"), "Address");
var zipCityCol = new AliasedExpression <Expression>(
new Expression("CONCAT(Zip, City)"), "ZipCity");
var builder = new SqlExpressionBuilderSelect();
builder
.From(fromTable)
.Select(addressCol)
.Select(zipCityCol)
.Where(
new Compare <string, string>(addressCol.Alias, "@address"));
builder.Where(
new Compare <string, IDbDataParameter>(zipCityCol.Alias, new SqlParameter {
ParameterName = "@zc"
}));
Assert.Equal(
"SELECT CONCAT(Street, Number) AS Address, CONCAT(Zip, City) AS ZipCity FROM dbo.from f " +
"WHERE Address = @address AND ZipCity = @zc", builder.ToString());
Assert.Equal(2, builder.Parameters.Count());
}
/// <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));
}
public void SimpleSelectFromFact()
{
var fromTable = new Table("from", "f");
var builder = new SqlExpressionBuilderSelect();
builder.From(fromTable);
Assert.Equal("SELECT * FROM from f", builder.ToString());
var expr = new AliasedExpression <CountExpression>(
new CountExpression(new ColumnExpression("Id", fromTable)), "Anzahl");
Assert.Equal("SELECT COUNT(f.Id) AS Anzahl FROM from f", builder.GetSingleSelectString(expr));
Assert.Equal("SELECT * FROM from f", builder.ToString());
}
/// <summary>
/// Adds the aliases.
/// </summary>
/// <param name="expr">The expr.</param>
protected virtual void AddAliases(Expression expr)
{
AliasedExpression ax = expr as AliasedExpression;
if (ax != null)
{
this.AddAlias(ax.Alias);
}
else
{
JoinExpression jx = expr as JoinExpression;
if (jx != null)
{
this.AddAliases(jx.Left);
this.AddAliases(jx.Right);
}
}
}
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));
}
}
protected override Expression VisitJoin(JoinExpression join)
{
Expression result = base.VisitJoin(join);
join = result as JoinExpression;
if (join != null)
{
AliasedExpression right = join.Right as AliasedExpression;
if (right != null)
{
AliasedExpression similarRight = (AliasedExpression)this.FindSimilarRight(join.Left as JoinExpression, join);
if (similarRight != null)
{
this.map.Add(right.Alias, similarRight.Alias);
return(join.Left);
}
}
}
return(result);
}
