public async Task TestGetFuncFromContextAsync()
{
var candles = await ImportIOhlcvDatasAsync();
FuncRegistry.Register("msma", "var sma = ctx.Get<SimpleMovingAverage>(10); return sma[i].Tick;");
FuncRegistry.Register("msma2", (c, i, p, ctx) => ctx.Get <SimpleMovingAverage>(p[0])[i].Tick);
var result = candles.Func("msma")[candles.Count() - 1];
var result2 = candles.Func("msma2", 10)[candles.Count() - 1];
var actual = candles.Sma(10)[candles.Count() - 1];
Assert.AreEqual(result.Tick, actual.Tick);
Assert.AreEqual(result2.Tick, actual.Tick);
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
var type = m.Member.DeclaringType;
if (type.IsNullable())
{
return(Visit(m.Expression));
//return m;
}
var member = /*type.IsNullable() ? (m.Expression as MemberExpression).Member :*/ m.Member;
var memberName = member.Name;
var key = member.Name;
IFunctionView fn;
if (FuncRegistry.TryGetFunction(key, out fn))
{
fn.Render(this, m.Expression);
return(m);
}
throw new NotSupportedException(string.Format("The member access '{0}' is not supported", m.Member));
}
protected override Expression VisitMethodCall(MethodCallExpression m)
{
var methodName = m.Method.Name;
var declaringType = m.Method.DeclaringType;
if (declaringType == typeof(SqlFunctions) && methodName == "Between")
{
var between = new BetweenExpression(m.Arguments[0], m.Arguments[1], m.Arguments[2]);
return(VisitBetween(between));
}
var key = methodName;
IFunctionView fn;
if (FuncRegistry.TryGetFunction(key, out fn))
{
if (key == "Concat")
{
fn.Render(this, (m.Arguments[0] as NewArrayExpression).Expressions.ToArray());
}
else
{
if (m.Method.IsStatic)
{
fn.Render(this, m.Arguments.ToArray());
}
else
{
var args = new List <Expression>();
args.Add(m.Object);
args.AddRange(m.Arguments);
fn.Render(this, args.ToArray());
}
}
return(m);
}
if (methodName == "CompareString" &&
declaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators")
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return(m);
}
if (methodName == "Compare" && m.Arguments.Count > 1 &&
m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return(m);
}
if (methodName == "CompareTo" && m.Arguments.Count == 1 &&
m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Object, m.Arguments[0]);
return(m);
}
if (methodName == "Equals")
{
var a = m.Arguments[0];
var b = m.Method.IsStatic ? m.Arguments[1] : m.Object;
a = a.NodeType == ExpressionType.Convert ? (a as UnaryExpression).Operand : a;
b = b.NodeType == ExpressionType.Convert ? (b as UnaryExpression).Operand : b;
if (a.NodeType == ExpressionType.Constant)
{
FunctionView.Equal.Render(this, b, a);
}
else
{
FunctionView.Equal.Render(this, a, b);
}
return(m);
}
if (methodName == "ToString" && !m.Method.IsStatic && m.Arguments.Count == 0)
{
ConvertTo(m.Object, Types.String);
return(m);
}
if (methodName == "Convert" && declaringType == typeof(SqlFunctions))
{
if (m.Method.IsGenericMethod)
{
ConvertTo(m.Arguments[0], m.Type);
}
else
{
ConvertTo(m.Arguments[0], (m.Arguments[1] as ConstantExpression).Value as Type);
}
return(m);
}
if (declaringType == Types.Decimal)
{
switch (methodName)
{
case "Add":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("+");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Subtract":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("-");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Multiply":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("*");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Divide":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("/");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Remainder":
FuncRegistry.SqlFunctions["Decimal." + methodName].Render(this, m.Arguments.ToArray());
return(m);
case "Negate":
sb.Append("-");
Visit(m.Arguments[0]);
return(m);
}
}
if (declaringType == Types.DateTime)
{
switch (methodName)
{
case "Add":
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0]);
return(m);
case "Subtract":
if (m.Arguments[0].Type == Types.TimeSpan)
{
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0], Expression.Constant(false));
return(m);
}
break;
}
}
throw new NotSupportedException(string.Format("The method '{0}' is not supported", m));
}
