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