protected virtual ReadOnlyCollection <ColumnDeclaration> VisitColumnDeclarations(ReadOnlyCollection <ColumnDeclaration> columns) { List <ColumnDeclaration> list = null; int count = 0; int num2 = columns.Count; while (count < num2) { ColumnDeclaration declaration = columns[count]; Expression expression = this.Visit(declaration.Expression); if ((list == null) && (expression != declaration.Expression)) { list = columns.Take <ColumnDeclaration>(count).ToList <ColumnDeclaration>(); } if (list != null) { list.Add(new ColumnDeclaration(declaration.Name, expression, declaration.QueryType)); } count++; } if (list != null) { return(list.AsReadOnly()); } return(columns); }
public static SelectExpression RemoveColumn(this SelectExpression select, ColumnDeclaration column) { List <ColumnDeclaration> columns = new List <ColumnDeclaration>(select.Columns); columns.Remove(column); return(select.SetColumns(columns)); }
protected virtual void WriteColumns(ReadOnlyCollection <ColumnDeclaration> columns) { if (columns.Count > 0) { int num = 0; int count = columns.Count; while (num < count) { ColumnDeclaration declaration = columns[num]; if (num > 0) { this.Write(", "); } ColumnExpression expression = this.VisitValue(declaration.Expression) as ColumnExpression; if (!(string.IsNullOrEmpty(declaration.Name) || ((expression != null) && !(expression.Name != declaration.Name)))) { this.Write(" "); this.WriteAsColumnName(declaration.Name); } num++; } } else { this.Write("NULL "); if (this.isNested) { this.WriteAsColumnName("tmp"); this.Write(" "); } } }
protected override Expression VisitSelect(SelectExpression select) { ReadOnlyCollection <ColumnDeclaration> columns = select.Columns; bool retainAllColumns = this.retainAllColumns; this.retainAllColumns = false; List <ColumnDeclaration> list = null; int num = 0; int count = select.Columns.Count; while (num < count) { ColumnDeclaration item = select.Columns[num]; if ((retainAllColumns || select.IsDistinct) || this.IsColumnUsed(select.Alias, item.Name)) { Expression expression = this.Visit(item.Expression); if (expression != item.Expression) { item = new ColumnDeclaration(item.Name, expression, item.QueryType); } } else { item = null; } if ((item != select.Columns[num]) && (list == null)) { list = new List <ColumnDeclaration>(); for (int i = 0; i < num; i++) { list.Add(select.Columns[i]); } } if ((item != null) && (list != null)) { list.Add(item); } num++; } if (list != null) { columns = list.AsReadOnly(); } Expression take = this.Visit(select.Take); Expression skip = this.Visit(select.Skip); ReadOnlyCollection <Expression> groupBy = this.VisitExpressionList(select.GroupBy); ReadOnlyCollection <OrderExpression> orderBy = this.VisitOrderBy(select.OrderBy); Expression where = this.Visit(select.Where); Expression from = this.Visit(select.From); this.ClearColumnsUsed(select.Alias); if (((((columns != select.Columns) || (take != select.Take)) || ((skip != select.Skip) || (orderBy != select.OrderBy))) || ((groupBy != select.GroupBy) || (where != select.Where))) || (from != select.From)) { select = new SelectExpression(select.Alias, columns, from, where, orderBy, groupBy, select.IsDistinct, skip, take, select.IsReverse); } this.retainAllColumns = retainAllColumns; return(select); }
public static SelectExpression AddColumn(this SelectExpression select, ColumnDeclaration column) { List <ColumnDeclaration> columns = new List <ColumnDeclaration>(select.Columns) { column }; return(select.SetColumns(columns)); }
protected override Expression VisitSelect(SelectExpression selectExpression) { selectExpression = (SelectExpression)base.VisitSelect(selectExpression); List <ColumnDeclaration> list = (from c in selectExpression.Columns orderby c.Name select c).ToList <ColumnDeclaration>(); BitArray array = new BitArray(selectExpression.Columns.Count); bool flag = false; int index = 0; int count = list.Count; while (index < (count - 1)) { ColumnDeclaration declaration = list[index]; ColumnExpression expression = declaration.Expression as ColumnExpression; QueryType queryType = (expression != null) ? expression.QueryType : declaration.QueryType; ColumnExpression expression2 = new ColumnExpression(declaration.Expression.Type, queryType, selectExpression.Alias, declaration.Name); for (int i = index + 1; i < count; i++) { if (!array.Get(i)) { ColumnDeclaration declaration2 = list[i]; if (this.SameExpression(declaration.Expression, declaration2.Expression)) { ColumnExpression key = new ColumnExpression(declaration2.Expression.Type, queryType, selectExpression.Alias, declaration2.Name); this.map.Add(key, expression2); array.Set(i, true); flag = true; } } } index++; } if (flag) { List <ColumnDeclaration> columns = new List <ColumnDeclaration>(); index = 0; count = list.Count; while (index < count) { if (!array.Get(index)) { columns.Add(list[index]); } index++; } selectExpression = selectExpression.SetColumns(columns); } return(selectExpression); }
private static bool IsColumnProjection(SelectExpression select) { int num = 0; int count = select.Columns.Count; while (num < count) { ColumnDeclaration declaration = select.Columns[num]; if ((declaration.Expression.NodeType != ((ExpressionType)0x3ea)) && (declaration.Expression.NodeType != ExpressionType.Constant)) { return(false); } num++; } return(true); }
protected override Expression VisitSelect(SelectExpression select) { select = (SelectExpression)base.VisitSelect(select); if (this.lookup.Contains(select.Alias)) { List <ColumnDeclaration> columns = new List <ColumnDeclaration>(select.Columns); foreach (AggregateSubqueryExpression expression in this.lookup[select.Alias]) { string name = "agg" + columns.Count; QueryType columnType = this.language.TypeSystem.GetColumnType(expression.Type); ColumnDeclaration item = new ColumnDeclaration(name, expression.AggregateInGroupSelect, columnType); this.map.Add(expression, new ColumnExpression(expression.Type, columnType, expression.GroupByAlias, name)); columns.Add(item); } return(new SelectExpression(select.Alias, columns, select.From, select.Where, select.OrderBy, select.GroupBy, select.IsDistinct, select.Skip, select.Take, select.IsReverse)); } return(select); }
private Expression MakeSubquery(Expression expression) { TableAlias alias = new TableAlias(); HashSet <TableAlias> set = DeclaredAliasGatherer.Gather(expression); List <ColumnDeclaration> columns = new List <ColumnDeclaration>(); foreach (TableAlias alias2 in set) { foreach (ColumnExpression expression2 in this.columns[alias2]) { ColumnDeclaration item = new ColumnDeclaration(columns.GetAvailableColumnName(expression2.Name), expression2, expression2.QueryType); columns.Add(item); ColumnExpression expression3 = new ColumnExpression(expression2.Type, expression2.QueryType, alias, expression2.Name); this.map.Add(expression2, expression3); } } return(new SelectExpression(alias, columns, expression, null)); }
private void GetColumns(MappingEntity entity, Dictionary <string, TableAlias> aliases, List <ColumnDeclaration> columns) { foreach (MemberInfo info in this.mapping.GetMappedMembers(entity)) { if (!this.mapping.IsAssociationRelationship(entity, info)) { if (this.mapping.IsNestedEntity(entity, info)) { this.GetColumns(this.mapping.GetRelatedEntity(entity, info), aliases, columns); } else if (this.mapping.IsColumn(entity, info)) { TableAlias alias; string columnName = this.mapping.GetColumnName(entity, info); string key = this.mapping.GetAlias(entity, info); aliases.TryGetValue(key, out alias); QueryType columnType = this.GetColumnType(entity, info); ColumnExpression expression = new ColumnExpression(King.Framework.Linq.TypeHelper.GetMemberType(info), columnType, alias, columnName); ColumnDeclaration item = new ColumnDeclaration(columnName, expression, columnType); columns.Add(item); } } } }
protected virtual bool CompareColumnDeclaration(ColumnDeclaration a, ColumnDeclaration b) { return((a.Name == b.Name) && this.Compare(a.Expression, b.Expression)); }