public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
var invoke = new Invoke(routine.ObjectInfo.FullName, args);
var executeContext = new InvokeContext(invoke, routine, resolver, group, request);
return routine.Execute(executeContext);
}
public InvokeResult Execute(IRequest query, IVariableResolver resolver, IGroupResolver group)
{
var routine = ResolveRoutine(query);
var executeContext = new InvokeContext(this, routine, resolver, group, query);
return(routine.Execute(executeContext));
}
//public override SqlExpression VisitConstant(SqlConstantExpression constant) {
// var value = constant.Value;
// if (value.IsNull)
// return constant;
// var obj = value.Value;
// if (obj is SqlQueryObject) {
// return EvaluateQueryPlan((SqlQueryObject) obj);
// }
// return base.VisitConstant(constant);
//}
//private SqlConstantExpression EvaluateQueryPlan(SqlQueryObject obj) {
// if (context.QueryContext == null)
// throw new ExpressionEvaluateException("A query context is required to evaluate a query.");
// try {
// var plan = obj.QueryPlan;
// var result = plan.Evaluate(context.QueryContext);
// return SqlExpression.Constant(new DataObject(new TabularType(), SqlTabular.From(result)));
// } catch (ExpressionEvaluateException) {
// throw;
// } catch (Exception ex) {
// throw new ExpressionEvaluateException("Could not evaluate a query.", ex);
// }
//}
public override SqlExpression VisitFunctionCall(SqlFunctionCallExpression expression)
{
try {
var invoke = new Invoke(expression.FunctioName, expression.Arguments);
IRequest request = null;
IVariableResolver variableResolver = null;
IGroupResolver groupResolver = null;
if (context != null)
{
request = context.Request;
variableResolver = context.VariableResolver;
groupResolver = context.GroupResolver;
}
// TODO: if we don't have a return value (PROCEDURES) what should w return?
var result = invoke.Execute(request, variableResolver, groupResolver);
if (!result.HasReturnValue)
{
return(SqlExpression.Constant(DataObject.Null()));
}
return(SqlExpression.Constant(result.ReturnValue));
} catch (ExpressionEvaluateException) {
throw;
} catch (Exception ex) {
throw new ExpressionEvaluateException(String.Format("Could not evaluate function expression '{0}' because of an error.", expression), ex);
}
}
/// <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="query"></param>
/// <returns></returns>
public static DataObject Execute(this IFunction function, Invoke request, IGroupResolver group,
IVariableResolver resolver,
IRequest query)
{
var execContext = new InvokeContext(request, function, resolver, group, query);
var result = function.Execute(execContext);
return result.ReturnValue;
}
/// <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="query"></param>
/// <returns></returns>
public static DataObject Execute(this IFunction function, Invoke request, IGroupResolver group,
IVariableResolver resolver,
IRequest query)
{
var execContext = new InvokeContext(request, function, resolver, group, query);
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 DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
/*
* TODO:
* if (ob2.DataType is QueryType) {
* // The sub-query plan
* IQueryPlanNode plan = (IQueryPlanNode) ob2.Value;
* // Discover the correlated variables for this plan.
* IList<CorrelatedVariable> list = plan.DiscoverCorrelatedVariables(1, new List<CorrelatedVariable>());
*
* if (list.Count > 0) {
* // Set the correlated variables from the IVariableResolver
* foreach (CorrelatedVariable variable in list) {
* variable.SetFromResolver(resolver);
* }
* // Clear the cache in the context
* context.ClearCache();
* }
*
* // Evaluate the plan,
* Table t = plan.Evaluate(context);
*
* // The ANY operation
* Operator revPlainOp = GetSubQueryForm(OperatorSubType.None).Reverse();
* return t.ColumnMatchesValue(0, revPlainOp, ob1);
* }
* if (ob2.DataType is ArrayType) {
* Operator plain_op = GetSubQueryForm(OperatorSubType.None);
* Expression[] expList = (Expression[])ob2.Object;
* // Assume there are no matches
* DataObject retVal = DataObject.BooleanFalse;
* foreach (Expression exp in expList) {
* DataObject exp_item = exp.Evaluate(group, resolver, context);
* // If null value, return null if there isn't otherwise a match found.
* if (exp_item.IsNull) {
* retVal = DataObject.BooleanNull;
* } else if (IsTrue(plain_op.Evaluate(ob1, exp_item, null, null, null))) {
* // If there is a match, the ANY set test is true
* return DataObject.BooleanTrue;
* }
* }
* // No matches, so return either false or NULL. If there are no matches
* // and no nulls, return false. If there are no matches and there are
* // nulls present, return null.
* return retVal;
* }
*
* throw new ApplicationException("Unknown RHS of ANY.");
*/
throw new NotImplementedException();
}
internal ExecuteContext(Invoke invoke, IRoutine routine, IVariableResolver resolver, IGroupResolver group, IQueryContext queryContext)
{
if (invoke == null)
throw new ArgumentNullException("invoke");
if (routine == null)
throw new ArgumentNullException("routine");
QueryContext = queryContext;
GroupResolver = group;
VariableResolver = resolver;
Invoke = invoke;
Routine = routine;
}
internal InvokeContext(Invoke invoke, IRoutine routine, IVariableResolver resolver, IGroupResolver group, IRequest request)
{
if (invoke == null)
throw new ArgumentNullException("invoke");
if (routine == null)
throw new ArgumentNullException("routine");
Request = request;
GroupResolver = group;
VariableResolver = resolver;
Invoke = invoke;
Routine = routine;
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
/*
* TODO:
* if (ob2.TType is TQueryPlanType) {
* // The sub-query plan
* IQueryPlanNode plan = (IQueryPlanNode)ob2.Object;
* // Discover the correlated variables for this plan.
* IList<CorrelatedVariable> list = plan.DiscoverCorrelatedVariables(1, new List<CorrelatedVariable>());
*
* if (list.Count > 0) {
* // Set the correlated variables from the IVariableResolver
* foreach (CorrelatedVariable variable in list) {
* variable.SetFromResolver(resolver);
* }
* // Clear the cache in the context
* context.ClearCache();
* }
*
* // Evaluate the plan,
* Table t = plan.Evaluate(context);
*
* Operator revPlainOp = GetSubQueryForm(OperatorSubType.None).Reverse();
* return t.AllColumnMatchesValue(0, revPlainOp, ob1);
* }
* if (ob2.TType is TArrayType) {
* Operator plainOp = GetSubQueryForm(OperatorSubType.None);
* Expression[] expList = (Expression[])ob2.Object;
* // Assume true unless otherwise found to be false or NULL.
* DataObject retVal = DataObject.BooleanTrue;
* foreach (Expression exp in expList) {
* DataObject expItem = exp.Evaluate(group, resolver, context);
* // If there is a null item, we return null if not otherwise found to
* // be false.
* if (expItem.IsNull) {
* retVal = DataObject.BooleanNull;
* } else if (!IsTrue(plainOp.Evaluate(ob1, expItem, null, null, null))) {
* // If it doesn't match return false
* return DataObject.BooleanFalse;
* }
* }
* // Otherwise return true or null. If all match and no NULLs return
* // true. If all match and there are NULLs then return NULL.
* return retVal;
* }
*
* throw new ApplicationException("Unknown RHS of ALL.");
*/
throw new NotImplementedException();
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
if (ob1.IsNull)
{
return(ob1);
}
if (ob2.IsNull)
{
return(ob2);
}
String val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
String pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
return(DataObject.Boolean(PatternSearch.FullPatternMatch(pattern, val, '\\')));
}
internal InvokeContext(Invoke invoke, IRoutine routine, IVariableResolver resolver, IGroupResolver group, IRequest request)
{
if (invoke == null)
{
throw new ArgumentNullException("invoke");
}
if (routine == null)
{
throw new ArgumentNullException("routine");
}
Request = request;
GroupResolver = group;
VariableResolver = resolver;
Invoke = invoke;
Routine = routine;
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
bool?b1 = ob1.ToBoolean();
bool?b2 = ob2.ToBoolean();
// If either ob1 or ob2 are null
if (!b1.HasValue)
{
return(b2.HasValue && b2.Equals(false) ? DataObject.BooleanFalse : DataObject.BooleanNull);
}
if (!b2.HasValue)
{
return(b1.Equals(false) ? DataObject.BooleanFalse : DataObject.BooleanNull);
}
// If both true.
return(DataObject.Boolean(b1.Equals(true) && b2.Equals(true)));
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
if (ob1.IsNull)
{
return(ob1);
}
if (ob2.IsNull)
{
return(ob2);
}
string val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
string pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
// TODO: return DataObject.Boolean(PatternSearch.RegexMatch(context.Context, pattern, val));
throw new NotImplementedException();
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
Request = request;
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
if (ob1.IsNull) {
return ob1;
}
if (ob2.IsNull) {
return ob2;
}
String val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
String pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
return DataObject.Boolean(PatternSearch.FullPatternMatch(pattern, val, '\\'));
}
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);
}
private async Task <SqlObject> IterateValues(MethodContext context, SqlExpression input, IGroupResolver groupResolver)
{
SqlObject result = null;
for (long i = 0; i < groupResolver.Size; i++)
{
SqlObject value;
var resolver = groupResolver.GetResolver(i);
using (var reduce = context.Create("reduce", scope => scope.AddReferenceResolver(resolver))) {
var reduced = await input.ReduceAsync(reduce);
if (reduced.ExpressionType != SqlExpressionType.Constant)
{
throw new InvalidOperationException();
}
value = ((SqlConstantExpression)reduced).Value;
}
using (var accumulate = new IterateContext(context, i, result, value)) {
await IterateAsync(accumulate);
if (accumulate.Result == null)
{
throw new MethodAccessException("No result value was provided by the iteration");
}
result = accumulate.Result;
if (!accumulate.Iterate)
{
break;
}
}
}
return(result);
}
public static InvokeResult Execute(this IRoutine routine, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
return Execute(routine, new InvokeArgument[0], request, resolver, group);
}
public static IQuery CreateQuery(this IContext context, IGroupResolver groupResolver, IReferenceResolver resolver)
{
return(new QueryImpl(context, groupResolver, resolver));
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
/*
TODO:
if (ob2.DataType is QueryType) {
// The sub-query plan
IQueryPlanNode plan = (IQueryPlanNode) ob2.Value;
// Discover the correlated variables for this plan.
IList<CorrelatedVariable> list = plan.DiscoverCorrelatedVariables(1, new List<CorrelatedVariable>());
if (list.Count > 0) {
// Set the correlated variables from the IVariableResolver
foreach (CorrelatedVariable variable in list) {
variable.SetFromResolver(resolver);
}
// Clear the cache in the context
context.ClearCache();
}
// Evaluate the plan,
Table t = plan.Evaluate(context);
// The ANY operation
Operator revPlainOp = GetSubQueryForm(OperatorSubType.None).Reverse();
return t.ColumnMatchesValue(0, revPlainOp, ob1);
}
if (ob2.DataType is ArrayType) {
Operator plain_op = GetSubQueryForm(OperatorSubType.None);
Expression[] expList = (Expression[])ob2.Object;
// Assume there are no matches
DataObject retVal = DataObject.BooleanFalse;
foreach (Expression exp in expList) {
DataObject exp_item = exp.Evaluate(group, resolver, context);
// If null value, return null if there isn't otherwise a match found.
if (exp_item.IsNull) {
retVal = DataObject.BooleanNull;
} else if (IsTrue(plain_op.Evaluate(ob1, exp_item, null, null, null))) {
// If there is a match, the ANY set test is true
return DataObject.BooleanTrue;
}
}
// No matches, so return either false or NULL. If there are no matches
// and no nulls, return false. If there are no matches and there are
// nulls present, return null.
return retVal;
}
throw new ApplicationException("Unknown RHS of ANY.");
*/
throw new NotImplementedException();
}
protected abstract DataObject Evaluate(DataObject value1, DataObject value2, IRequest query, IGroupResolver group);
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
/*
TODO:
if (ob2.TType is TQueryPlanType) {
// The sub-query plan
IQueryPlanNode plan = (IQueryPlanNode)ob2.Object;
// Discover the correlated variables for this plan.
IList<CorrelatedVariable> list = plan.DiscoverCorrelatedVariables(1, new List<CorrelatedVariable>());
if (list.Count > 0) {
// Set the correlated variables from the IVariableResolver
foreach (CorrelatedVariable variable in list) {
variable.SetFromResolver(resolver);
}
// Clear the cache in the context
context.ClearCache();
}
// Evaluate the plan,
Table t = plan.Evaluate(context);
Operator revPlainOp = GetSubQueryForm(OperatorSubType.None).Reverse();
return t.AllColumnMatchesValue(0, revPlainOp, ob1);
}
if (ob2.TType is TArrayType) {
Operator plainOp = GetSubQueryForm(OperatorSubType.None);
Expression[] expList = (Expression[])ob2.Object;
// Assume true unless otherwise found to be false or NULL.
DataObject retVal = DataObject.BooleanTrue;
foreach (Expression exp in expList) {
DataObject expItem = exp.Evaluate(group, resolver, context);
// If there is a null item, we return null if not otherwise found to
// be false.
if (expItem.IsNull) {
retVal = DataObject.BooleanNull;
} else if (!IsTrue(plainOp.Evaluate(ob1, expItem, null, null, null))) {
// If it doesn't match return false
return DataObject.BooleanFalse;
}
}
// Otherwise return true or null. If all match and no NULLs return
// true. If all match and there are NULLs then return NULL.
return retVal;
}
throw new ApplicationException("Unknown RHS of ALL.");
*/
throw new NotImplementedException();
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
bool? b1 = ob1.ToBoolean();
bool? b2 = ob2.ToBoolean();
// If either ob1 or ob2 are null
if (!b1.HasValue)
return b2.HasValue && b2.Equals(false) ? DataObject.BooleanFalse : DataObject.BooleanNull;
if (!b2.HasValue)
return b1.Equals(false) ? DataObject.BooleanFalse : DataObject.BooleanNull;
// If both true.
return DataObject.Boolean(b1.Equals(true) && b2.Equals(true));
}
public abstract DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context);
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
throw new ApplicationException("SimpleOperator should never be evaluated!");
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
if (ob1.IsNull)
return ob1;
if (ob2.IsNull)
return ob2;
string val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
string pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
// TODO: return DataObject.Boolean(PatternSearch.RegexMatch(context.Context, pattern, val));
throw new NotImplementedException();
}
public abstract DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context);
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
return ob1.Multiply(ob2);
}
public static InvokeResult Execute(this IRoutine routine, IQuery query, IVariableResolver resolver, IGroupResolver group)
{
return(Execute(routine, new SqlExpression[0], query, resolver, group));
}
public SqlExpression Evaluate(IRequest context, IVariableResolver variables, IGroupResolver group)
{
return(Evaluate(new EvaluateContext(context, variables, group)));
}
public Evaluator(IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
Context = new EvaluateContext(group, resolver, context);
}
public static InvokeResult Execute(this IRoutine routine, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
return(Execute(routine, new InvokeArgument[0], request, resolver, group));
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
return(ob1.Is(ob2));
}
public static InvokeResult Execute(this IRoutine routine, InvokeArgument[] args, IRequest request, IVariableResolver resolver, IGroupResolver group)
{
var invoke = new Invoke(routine.ObjectInfo.FullName, args);
var executeContext = new InvokeContext(invoke, routine, resolver, group, request);
return(routine.Execute(executeContext));
}
public QueryImpl(IContext parent, IGroupResolver groupResolver, IReferenceResolver resolver)
: base(parent, KnownScopes.Query)
{
GroupResolver = groupResolver;
Resolver = resolver;
}
public EvaluateContext(IGroupResolver groupResolver, IVariableResolver variableResolver, IQueryContext queryContext)
{
QueryContext = queryContext;
VariableResolver = variableResolver;
GroupResolver = groupResolver;
}
public InvokeResult Execute(IRequest query, IVariableResolver resolver, IGroupResolver group)
{
var routine = ResolveRoutine(query);
var executeContext = new InvokeContext(this, routine, resolver, group, query);
return routine.Execute(executeContext);
}
protected virtual DataObject PostEvaluate(DataObject result, IRequest query, IGroupResolver group)
{
// By default, do nothing....
return(result);
}
private async Task <SqlObject> IterateReference(MethodContext context, ObjectName refName, IGroupResolver groupResolver)
{
SqlObject result = null;
for (long i = 0; i < groupResolver.Size; i++)
{
var rowValue = await groupResolver.ResolveReferenceAsync(refName, i);
var current = rowValue;
using (var accumulate = new IterateContext(context, i, result, current)) {
await IterateAsync(accumulate);
if (accumulate.Result == null)
{
throw new MethodAccessException("No result value was provided by the iteration");
}
result = accumulate.Result;
if (!accumulate.Iterate)
{
break;
}
}
}
return(result);
}
public EvaluateContext(IRequest request, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
Request = request;
}
protected abstract DataObject Evaluate(DataObject value1, DataObject value2, IRequest query, IGroupResolver group);
public static InvokeResult Execute(this IRoutine routine, IQuery query, IVariableResolver resolver, IGroupResolver group)
{
return Execute(routine, new SqlExpression[0], query, resolver, group);
}
public Evaluator(IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
Context = new EvaluateContext(group, resolver, context);
}
public EvaluateContext(IGroupResolver groupResolver, IVariableResolver variableResolver, IQueryContext queryContext)
{
QueryContext = queryContext;
VariableResolver = variableResolver;
GroupResolver = groupResolver;
}
public static ExecuteResult Execute(this IRoutine routine, IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
return Execute(routine, new SqlExpression[0], context, resolver, group);
}
public SqlExpression Evaluate(IQueryContext context, IVariableResolver variables, IGroupResolver group)
{
return Evaluate(new EvaluateContext(context, variables, group));
}
public override DataObject Evaluate(DataObject ob1, DataObject ob2,
IGroupResolver group, IVariableResolver resolver,
IQueryContext context)
{
throw new ApplicationException("SimpleOperator should never be evaluated!");
}
protected abstract DataObject Evaluate(DataObject value1, DataObject value2, IQueryContext context, IGroupResolver group);
public static InvokeResult Execute(this IRoutine routine, SqlExpression[] args, IQuery query, IVariableResolver resolver, IGroupResolver group)
{
var request = new Invoke(routine.FullName, args);
if (query != null &&
!query.UserCanExecuteFunction(request))
{
throw new InvalidOperationException();
}
var executeContext = new InvokeContext(request, routine, resolver, group, query);
return(routine.Execute(executeContext));
}
protected virtual DataObject PostEvaluate(DataObject result, IQueryContext context, IGroupResolver group)
{
// By default, do nothing....
return result;
}
protected virtual DataObject PostEvaluate(DataObject result, IRequest query, IGroupResolver group)
{
// By default, do nothing....
return result;
}
public DataObject Evaluate(IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
var evaluator = new Evaluator(group, resolver, context);
return(evaluator.Evaluate(this));
}
public EvaluateContext(IQueryContext queryContext, IVariableResolver variableResolver, IGroupResolver groupResolver)
{
GroupResolver = groupResolver;
VariableResolver = variableResolver;
QueryContext = queryContext;
}
public DataObject Evaluate(IGroupResolver group, IVariableResolver resolver, IQueryContext context)
{
var evaluator = new Evaluator(group, resolver, context);
return evaluator.Evaluate(this);
}
