// Create one function for each expression as a closure, capturing the serial and type for that function
// Create an open or predicate function
public bool CreateFunction(string name, FuncTypes functype, int serial, SqlCommonType[] argtypes, SqlCommonType rettype)
{
Func <object[], object> func = (v) => _database.Evaluator.EvalSerialOpen(serial, functype, v);
AddWrapper(name, argtypes, rettype, func);
return(true);
}
// Callback function to evaluate an expression
public object EvaluateCommon(ExpressionEval expr, FuncTypes functype, object[] values, int haccum, int naccum)
{
var lookup = GetLookup(expr, values);
TypedValue retval = null;
switch (functype)
{
case FuncTypes.Open:
retval = expr.EvalOpen(lookup);
break;
case FuncTypes.Predicate:
retval = expr.EvalPred(lookup);
break;
case FuncTypes.Aggregate:
case FuncTypes.Ordered:
var accblk = GetAccum(haccum, naccum);
retval = expr.EvalHasFold(lookup, accblk as AccumulatorBlock);
accblk.Result = retval;
PutAccum(haccum, accblk);
break;
}
return(SqlTarget.ToObjectDict[retval.DataType.BaseType](retval));
}
// Create one function for each expression as a closure, capturing the serial and type for that function
// Create an open or predicate function
public bool CreateFunction(string name, FuncTypes functype, int serial, SqlCommonType[] args, SqlCommonType retn)
{
UserFunctionCallback func = (c, nv, v) => EvalFunctionOpen(c, nv, v, functype, serial, args, retn);
_userfuncs.Add(func);
return(CreateFunction(name, func));
}
public Cell(int X, int Y)
{
this.X = X;
this.Y = Y;
TypePosition = PosTypes.None;
TypeFunc = FuncTypes.None;
}
/// <summary>
/// помещает клетку в позицию X,Y в Environment.CellMap
/// </summary>
public Cell(int X, int Y, PosTypes tp, FuncTypes tf)
{
this.X = X;
this.Y = Y;
TypePosition = tp;
TypeFunc = tf;
Envirmnt.Inst.CellMap[X][Y] = this;
}
// Callback function to finalise an aggregation
// No value arguments, so uses the value stored in the accumulator result field
// TODO: handle default value
public object EvalSerialAggFinal(int serial, FuncTypes functype)
{
var expr = SqlTarget.ExprDict[serial];
var accblk = GetAccum(serial, 0);
FreeAccum(serial);
if (accblk.Result == null)
{
return(SqlTarget.ToObjectDict[expr.ReturnType.BaseType](expr.ReturnType.DefaultValue()));
}
return(SqlTarget.ToObjectDict[accblk.Result.DataType.BaseType](accblk.Result));
}
private static Expression ConvertTo(Expression expr, Type type)
{
if (expr.NodeType == ExpressionType.Lambda && expr.Type.IsGenericType)
{
var lambda = (LambdaExpression)expr;
Type genericType = expr.Type.GetGenericTypeDefinition();
if (FuncTypes.Contains(genericType))
{
return(Expression.Lambda(Expression.Convert(lambda.Body, type), lambda.Parameters));
}
}
return(Expression.Convert(expr, type));
}
// Callback function to evaluate an expression
// Note: use serial as accum handle
public object EvalSerialAggOpen(int serial, FuncTypes functype, object[] values, int naccum)
{
return(EvaluateCommon(SqlTarget.ExprDict[serial], functype, values, serial, naccum));
}
// Callback function to evaluate a non-aggregate expression
public object EvalSerialOpen(int serial, FuncTypes functype, object[] values)
{
return(EvaluateCommon(SqlTarget.ExprDict[serial], functype, values, _accumnul, 0));
}
// These are the callback functions called by the DBMS
// At this stage no access to Andl internals
// Callback for an open function
public static void EvalFunctionOpen(IntPtr context, int nvalues, IntPtr[] values, FuncTypes functype, int serial, SqlCommonType[] args, SqlCommonType retn)
{
var svalues = GetArgs(args, values, nvalues);
var ret = _evaluator.EvalSerialOpen(serial, functype, svalues);
SetResult(retn, context, ret);
}
