public override ExecuteResult Execute(ExecuteContext context)
{
if (Body == null)
throw new InvalidOperationException();
throw new NotImplementedException();
}
protected override void Dispose(bool disposing)
{
parentContext = null;
executeContext = null;
base.Dispose(disposing);
}
public override DataType ReturnType(ExecuteContext context)
{
if (method == null)
method = DiscoverMethod();
return base.ReturnType(context);
}
public FunctionQueryContext(IQueryContext parentContext, ExecuteContext executeContext)
{
if (parentContext == null)
throw new ArgumentNullException("parentContext");
if (executeContext == null)
throw new ArgumentNullException("executeContext");
this.parentContext = parentContext;
this.executeContext = executeContext;
}
/// <summary>
/// Executes the function given the cintext provided.
/// </summary>
/// <param name="function">The function to execute.</param>
/// <param name="request">The invocation information that was used to resolve
/// the function.</param>
/// <param name="group"></param>
/// <param name="resolver"></param>
/// <param name="context"></param>
/// <returns></returns>
public static DataObject Execute(this IFunction function,
Invoke request,
IGroupResolver group,
IVariableResolver resolver,
IQueryContext context)
{
var execContext = new ExecuteContext(request, function, resolver, group, context);
var result = function.Execute(execContext);
return result.ReturnValue;
}
public static ExecuteResult Execute(this IRoutine routine, SqlExpression[] args, IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
var request = new Invoke(routine.FullName, args);
if (context != null &&
!context.UserCanExecuteFunction(request))
throw new InvalidOperationException();
var executeContext = new ExecuteContext(request, routine, resolver, group, context);
return routine.Execute(executeContext);
}
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;
}
}
internal ExecuteResult(ExecuteContext context, DataObject returnValue)
: this(context, returnValue, true)
{
}
/// <summary> /// Executes the function and provides a result. /// </summary> /// <param name="context">The context of the execution.</param> /// <returns> /// Returns a <see cref="ExecuteResult"/> instance that encapsulates /// the returned value of the function. /// </returns> /// <seealso cref="ExecuteResult.ReturnValue"/> public abstract ExecuteResult Execute(ExecuteContext context);
public override ExecuteResult Execute(ExecuteContext context)
{
throw new NotImplementedException();
}
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);
}
public static DataType ReturnType(this IFunction function, Invoke request, IQueryContext context, IVariableResolver resolver)
{
var execContext = new ExecuteContext(request, function, resolver, null, context);
return function.ReturnType(execContext);
}
private ExecuteResult(ExecuteContext context, DataObject returnValue, bool hasReturn)
{
Context = context;
ReturnValue = returnValue;
HasReturnValue = hasReturn;
}
public ExecuteResult Execute(IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
var routine = ResolveRoutine(context);
var executeContext = new ExecuteContext(this, routine, resolver, group, context);
return routine.Execute(executeContext);
}
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 SqlType ReturnType(ExecuteContext context)
{
var typeArg = context.EvaluatedArguments[1];
var typeString = typeArg.AsVarChar().Value.ToString();
return SqlType.Parse(context.QueryContext, typeString);
}
public static ExecuteResult Execute(ExecuteContext context)
{
throw new NotImplementedException();
}
private static ExecuteResult Simple(ExecuteContext context, Func<DataObject[], DataObject> func)
{
var args = context.EvaluatedArguments;
var funcResult = func(args);
return context.Result(funcResult);
}
public override ExecuteResult Execute(ExecuteContext context)
{
return functionBody(context);
}
/// <summary>
/// Resolves the function return type against the given context.
/// </summary>
/// <param name="context">The execution context used to resolve
/// the function return type.</param>
/// <returns>
/// Returns an instance of <see cref="SqlType"/> that defines
/// the type of the returned value resolved against the given
/// execution context..
/// </returns>
public virtual SqlType ReturnType(ExecuteContext context)
{
return FunctionInfo.ReturnType;
}
public override SqlType ReturnType(ExecuteContext context)
{
if (returnType == null)
return FunctionInfo.ReturnType;
return returnType(context);
}
internal ExecuteResult Execute(ExecuteContext context)
{
throw new NotImplementedException();
}
internal ExecuteResult(ExecuteContext context)
: this(context, DataObject.Null(), false)
{
}
