// internal static methods internal static ProjectedColumns ProjectColumns(Func<Expression, Boolean> canBeColumn, Expression expression, SourceAlias newAlias, params SourceAlias[] existingAliases) { var projector = new Projector(canBeColumn, expression, newAlias, existingAliases); Expression expr = projector.Visit(expression); return new ProjectedColumns(expr, projector._columns.AsReadOnly()); }
// constructors private Projector(Func<Expression, Boolean> canBeColumn, Expression expression, SourceAlias newAlias, params SourceAlias[] existingAliases) { _map = new Dictionary<ColumnExpression, ColumnExpression>(); _columns = new List<ColumnDeclaration>(); _columnNames = new HashSet<String>(); _newAlias = newAlias; _existingAliases = existingAliases; _candidates = Nominator.Nominate(canBeColumn, expression); }
/// <summary> /// Rebind order expressions to reference a new alias and add to column declarations if necessary /// </summary> protected virtual BindResult RebindOrderings(IEnumerable<OrderByExpression> orderings, SourceAlias alias, HashSet<SourceAlias> existingAliases, IEnumerable<ColumnDeclaration> existingColumns) { List<ColumnDeclaration> newColumns = null; var newOrderings = new List<OrderByExpression>(); foreach (OrderByExpression ordering in orderings) { Expression expr = ordering.Expression; var column = expr as ColumnExpression; if (column == null || (existingAliases != null && existingAliases.Contains(column.Alias))) { // check to see if a declared column already contains a similar expression Int32 iOrdinal = 0; if (existingColumns != null) { foreach (ColumnDeclaration decl in existingColumns) { var declColumn = decl.Expression as ColumnExpression; if (decl.Expression == ordering.Expression || (column != null && declColumn != null && column.Alias == declColumn.Alias && column.Name == declColumn.Name)) { // found it, so make a reference to this column if (column != null) expr = new ColumnExpression(column.Type, alias, decl.Name); break; } iOrdinal++; } // if not already projected, add a new column declaration for it if (expr == ordering.Expression) { if (newColumns == null) { newColumns = new List<ColumnDeclaration>(existingColumns); existingColumns = newColumns; } String colName = column != null ? column.Name : "c" + iOrdinal; newColumns.Add(new ColumnDeclaration(colName, ordering.Expression)); expr = new ColumnExpression(expr.Type, alias, colName); } } newOrderings.Add(new OrderByExpression(expr, ordering.Direction)); } } return existingColumns != null ? new BindResult(existingColumns, newOrderings) : null; }
internal SelectExpression(SourceAlias alias, IEnumerable<ColumnDeclaration> columns, Expression from, Expression where, IEnumerable<OrderByExpression> orderBy, IEnumerable<Expression> groupBy, Expression take) : base(PigExpressionType.Select, typeof(void), alias) { Columns = columns as ReadOnlyCollection<ColumnDeclaration> ?? new List<ColumnDeclaration>(columns).AsReadOnly(); OrderBy = orderBy as ReadOnlyCollection<OrderByExpression>; if (OrderBy == null && orderBy != null) { OrderBy = new List<OrderByExpression>(orderBy).AsReadOnly(); } GroupBy = groupBy as ReadOnlyCollection<Expression>; if (GroupBy == null && groupBy != null) { GroupBy = new List<Expression>(groupBy).AsReadOnly(); } Take = take; From = from; Where = where; }
protected virtual void AddAlias(SourceAlias alias) { Int32 value; if (_aliases.TryGetValue(alias, out value)) { _aliases[alias] = value + 1; } else { _aliases.Add(alias, _aliasCount); } AddAlias(); }
// constructors internal GroupByInfo(SourceAlias alias, Expression element) { Alias = alias; Element = element; }
private ProjectedColumns ProjectColumns(Expression expression, SourceAlias newAlias, params SourceAlias[] existingAliases) { return Projector.ProjectColumns(CanBeColumn, expression, newAlias, existingAliases); }
// constructors internal SourceExpression(Type sourceType, SourceAlias alias, String name) : base(PigExpressionType.Source, sourceType, alias) { Name = name; }
// constructors protected AliasedExpression(PigExpressionType nodeType, Type type, SourceAlias alias) : base(nodeType, type) { Alias = alias; }
private void ClearColumnsUsed(SourceAlias alias) { _allColumnsUsed[alias] = new HashSet<String>(); }
internal SelectExpression(SourceAlias alias, IEnumerable<ColumnDeclaration> columns, Expression from, Expression where, IEnumerable<OrderByExpression> orderBy, IEnumerable<Expression> groupBy) : this(alias, columns, from, where, orderBy, groupBy, null) { }
// constructors internal SelectExpression(SourceAlias alias, IEnumerable<ColumnDeclaration> columns, Expression from, Expression where) : this(alias, columns, from, where, null, null) { }
// private methods private void MarkColumnAsUsed(SourceAlias alias, String name) { HashSet<String> columns; if (!_allColumnsUsed.TryGetValue(alias, out columns)) { columns = new HashSet<String>(); _allColumnsUsed.Add(alias, columns); } columns.Add(name); }
private Boolean IsColumnUsed(SourceAlias alias, String name) { HashSet<String> columnsUsed; if (_allColumnsUsed.TryGetValue(alias, out columnsUsed)) { if (columnsUsed != null) { return columnsUsed.Contains(name); } } return false; }
protected virtual void AddAlias(SourceAlias alias, Int32 aliasNumber) { Int32 value; if (_aliases.TryGetValue(alias, out value)) { _aliases[alias] = aliasNumber; } else { AddAlias(alias); } }
protected virtual String GetLastAliasName(SourceAlias alias) { Int32 value; if (_aliases.TryGetValue(alias, out value)) { return "t" + value; } return "t" + (_aliasCount - 1); }
// constructors internal ColumnExpression(Type type, SourceAlias alias, String name) : base(PigExpressionType.Column, type, alias) { Name = name; }