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