public override ExecuteResult Execute(ExecuteContext context)
{
if (context == null)
throw new ArgumentNullException("context");
var group = context.GroupResolver;
if (group == null)
throw new Exception(String.Format("'{0}' can only be used as an aggregate function.", FunctionName));
DataObject result = null;
// All aggregates functions return 'null' if group size is 0
int size = group.Count;
if (size == 0) {
// Return a NULL of the return type
return context.Result(DataObject.Null(ReturnType(context)));
}
DataObject val;
ObjectName v = context.Arguments[0].AsReferenceName();
// If the aggregate parameter is a simple variable, then use optimal
// routine,
if (v != null) {
for (int i = 0; i < size; ++i) {
val = group.Resolve(v, i);
result = Evaluate(result, val, context.QueryContext, group);
}
} 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) {
val = exp.EvaluateToConstant(context.QueryContext, group.GetVariableResolver(i));
result = Evaluate(result, val, context.QueryContext, group);
}
}
// Post method.
result = PostEvaluate(result, context.QueryContext, group);
return context.Result(result);
}
public override ExecuteResult Execute(ExecuteContext context)
{
if (method == null)
method = DiscoverMethod();
if (method == null)
throw new InvalidOperationException();
var args = context.EvaluatedArguments;
try {
var methodArgs = ConvertArguments(method, args);
var result = method.Invoke(null, methodArgs);
return context.Result(ConvertValue(result, ReturnType()));
} catch (Exception ex) {
throw;
}
}
private static ExecuteResult Simple(ExecuteContext context, Func<DataObject[], DataObject> func)
{
var args = context.EvaluatedArguments;
var funcResult = func(args);
return context.Result(funcResult);
}
public static ExecuteResult Execute(ExecuteContext context)
{
var value = context.EvaluatedArguments[0];
var typeArg = context.EvaluatedArguments[1];
var typeString = typeArg.AsVarChar().Value.ToString();
var type = SqlType.Parse(context.QueryContext, typeString);
return context.Result(SystemFunctions.Cast(value, type));
}
public static ExecuteResult Execute(ExecuteContext context)
{
if (context.GroupResolver == null)
throw new Exception("'count' can only be used as an aggregate function.");
int size = context.GroupResolver.Count;
DataObject result;
// if, count(*)
if (size == 0 || context.Invoke.IsGlobArgument) {
result = DataObject.Integer(size);
} else {
// Otherwise we need to count the number of non-null entries in the
// columns list(s).
int totalCount = size;
var exp = context.Arguments[0];
for (int i = 0; i < size; ++i) {
var val = exp.EvaluateToConstant(context.QueryContext, context.GroupResolver.GetVariableResolver(i));
if (val.IsNull) {
--totalCount;
}
}
result = DataObject.Integer(totalCount);
}
return context.Result(result);
}
private ExecuteResult Simple(ExecuteContext context, Func<DataObject[], DataObject> func)
{
var evaluated = context.EvaluatedArguments;
var value = func(evaluated);
return context.Result(value);
}
private ExecuteResult Binary(ExecuteContext context, Func<DataObject, DataObject, DataObject> func)
{
var evaluated = context.EvaluatedArguments;
var value = func(evaluated[0], evaluated[1]);
return context.Result(value);
}