public override SqlExpression VisitReference(SqlReferenceExpression reference)
{
var refName = reference.ReferenceName;
foreach (var column in selectColumns)
{
if (refName.Equals(column.ResolvedName))
{
return(SqlExpression.Reference(column.InternalName));
}
}
return(base.VisitReference(reference));
}
public override SqlExpression VisitReference(SqlReferenceExpression reference)
{
var exp = reference;
var colName = exp.ReferenceName.Name;
var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
foreach (var columnInfo in tableInfo)
{
if (String.Equals(colName, columnInfo.ColumnName, comparison))
{
exp = SqlExpression.Reference(new ObjectName(tableInfo.TableName, columnInfo.ColumnName));
}
}
return(exp);
}
public override SqlExpression VisitReference(SqlReferenceExpression reference)
{
var refName = reference.ReferenceName;
var origColumn = refName.Name;
var resolvedColumn = checker.ResolveColumnName(origColumn);
if (resolvedColumn == null)
{
throw new InvalidOperationException($"Column '{origColumn} not found in table.");
}
if (!origColumn.Equals(resolvedColumn))
{
refName = new ObjectName(refName.Parent, resolvedColumn);
}
return(SqlExpression.Reference(refName));
}
public override SqlExpression VisitReference(SqlReferenceExpression reference)
{
columnNames.Add(reference.ReferenceName);
return(base.VisitReference(reference));
}
public override InvokeResult Execute(InvokeContext context)
{
if (FunctionInfo.FunctionType != FunctionType.Aggregate)
{
return(functionBody(context));
}
if (context.GroupResolver == null)
{
throw new Exception(String.Format("Function '{0}' can only be used as an aggregate.", FunctionInfo.RoutineName));
}
Field result = null;
// All aggregates functions return 'null' if group size is 0
int size = context.GroupResolver.Count;
if (size == 0)
{
// Return a NULL of the return type
return(context.Result(Field.Null(ReturnType(context))));
}
Field val;
SqlReferenceExpression v = context.Arguments[0].Value as SqlReferenceExpression;
// If the aggregate parameter is a simple variable, then use optimal
// routine,
if (v != null)
{
for (int i = 0; i < size; ++i)
{
var variable = context.GroupResolver.Resolve(v.ReferenceName, i);
val = variable.Evaluate(context.Request);
var invokeResult = functionBody(context.New(new SqlExpression[] {
SqlExpression.Constant(result),
SqlExpression.Constant(val)
}));
result = invokeResult.ReturnValue;
}
}
else
{
// Otherwise we must resolve the expression for each entry in group,
// This allows for expressions such as 'sum(quantity * price)' to
// work for a group.
var exp = context.Arguments[0];
for (int i = 0; i < size; ++i)
{
var evaluated = exp.Value.Evaluate(context.Request, context.GroupResolver.GetVariableResolver(i));
if (evaluated.ExpressionType != SqlExpressionType.Constant)
{
throw new InvalidOperationException(
String.Format("The evaluation of the group {0} in aggregate function '{1}' is not constant", i,
FunctionInfo.RoutineName));
}
val = ((SqlConstantExpression)evaluated).Value;
var invokeResult = functionBody(context.New(new SqlExpression[] {
SqlExpression.Constant(result),
SqlExpression.Constant(val)
}));
result = invokeResult.ReturnValue;
}
}
// Post method.
if (afterAggregate != null)
{
result = afterAggregate(context, result);
}
return(context.Result(result));
}
