public static object GetConstant(this Generator.Ctx ctx, string valueName)
{
int i = ctx.IndexOf(valueName);
var val = (i < 0) ? null : ctx[i];
if (val == null)
{
return(null);
}
var expr = val as Expr;
if (expr != null)
{
val = Generator.Generate(expr, ctx);
}
if (OPs.KindOf(val) == ValueKind.Const)
{
return(val);
}
else if (expr != null)
{
return(ctx.Error(string.Format("Constant expected as value of '{0}' // {1}", valueName, expr)));
}
else
{
return(ctx.Error(string.Format("Constant expected as value of '{0}'", valueName)));
}
}
public static object UseSqlAsFuncsFrom(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = Generator.Generate(ce.args[0], ctx);
if (OPs.KindOf(arg0) != ValueKind.Const)
{
ctx.Error("Constant value expected");
}
var arg1 = (ce.args.Count < 2) ? null : Generator.Generate(ce.args[1], ctx);
var sqlFileName = Convert.ToString(arg0);
DbFuncType forKinds;
if (arg1 == null)
{
forKinds = DbFuncType.TimeSlice | DbFuncType.TimeInterval;
}
else
{
var lst = arg1 as IList ?? new object[] { arg1 };
forKinds = DbFuncType.None;
foreach (var v in lst)
{
forKinds |= (DbFuncType)Enum.Parse(typeof(DbFuncType), Convert.ToString(v));
}
}
var dbConnName = (ce.args.Count < 3) ? DefaultDbConnName : OPs.TryAsName(ce.args[2], ctx);
if (string.IsNullOrEmpty(dbConnName))
{
ctx.Error($"Connection name must be nonempty: {ce.args[2]}");
}
var fullFileName = Path.IsPathRooted(sqlFileName)
? sqlFileName
: Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Convert.ToString(sqlFileName));
var cacheKey = $"FuncDefs:{fullFileName}:{forKinds.ToString()}";
Func <object> ldfsFunc = () =>
{
var sqlCtx = new W.Expressions.Sql.Preprocessing.PreprocessingContext()
{
sqlFileName = fullFileName,
cacheSubdomain = "DB",
dbConnValueName = dbConnName,
forKinds = forKinds,
ctx = ctx,
cachingExpiration = TimeSpan.FromMinutes(5),
defaultLocationForValueInfo = (ce.args.Count < 4) ? null : OPs.TryAsString(ce.args[3], ctx)
};
return(sqlCtx.LoadingFuncs());
};
var lfds = (IEnumerable <FuncDef>)FuncDefs_Core._Cached(cacheKey, ldfsFunc, DateTimeOffset.MaxValue, TimeSpan.FromMinutes(5));
return(lfds);
}
public static object GetConstant(this Generator.Ctx ctx, Expr expr)
{
var val = Generator.Generate(expr, ctx);
if (OPs.KindOf(val) == ValueKind.Const)
{
return(val);
}
else
{
return(ctx.Error("Constant expected as value of " + expr.ToString()));
}
}
public static string TryAsString(Expr expr, Generator.Ctx ctx)
{
var ce = expr as ConstExpr;
if (ce != null)
{
return(Convert.ToString(ce.value));
}
var val = Generator.Generate(expr, ctx);
if (OPs.KindOf(val) == ValueKind.Const && val != null)
{
return(Convert.ToString(val));
}
return(null);
}
public static object FindDependencies(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = Generator.Generate(ce.args[0], ctx);
if (OPs.KindOf(arg0) != ValueKind.Const || arg0 == null)
{
throw new SolverException("FindDependencies: list of source params must be constant and not null");
}
var arg1 = (ce.args.Count > 1) ? Generator.Generate(ce.args[1], ctx) : null;
if (OPs.KindOf(arg1) != ValueKind.Const)
{
throw new SolverException("FindDependencies: optional list of dependent params must be constant");
}
var arg2 = (ce.args.Count > 2) ? Generator.Generate(ce.args[2], ctx) : null;
if (OPs.KindOf(arg2) != ValueKind.Const)
{
throw new SolverException("FindDependencies: optional list of unusable params must be constant");
}
var srcPrms = ((IList)arg0).Cast <object>().Select(o => o.ToString()).ToArray();
var depPrms = (arg1 == null) ? null : ((IList)arg1).Cast <object>().Select(o => o.ToString()).ToArray();
var unusables = (arg2 == null)
? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
: ((IList)arg2).Cast <object>().Select(o => o.ToString()).ToDictionary(s => s, StringComparer.OrdinalIgnoreCase);
var aliasOf = GetAliases(ctx);
var funcs = Dependecies.GetFuncInfos(ctx.GetFunc(null, 0), aliasOf, fi => !fi.inputs.Any(inp => unusables.ContainsKey(inp)));
var dependencies = Dependecies.Find(funcs, aliasOf, int.MaxValue, srcPrms, depPrms);
var resDict = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
var resParams = (depPrms == null)
? dependencies.Keys.Except(srcPrms, StringComparer.OrdinalIgnoreCase)
: depPrms.Where(s => dependencies.ContainsKey(s));
var res = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
foreach (var prmName in resParams)
{
var deps = dependencies[prmName];
var srcs = srcPrms.Where(s => deps.ContainsKey(s)).ToArray();
if (srcs.Length > 0)
{
res.Add(prmName, srcs);
}
}
return(res);
}
public static object letLookupFunc(CallExpr ce, Generator.Ctx ctx)
{
var arg0 = ce.args[0];
object name;
var ref0 = arg0 as ReferenceExpr;
if (ref0 != null)
{
name = ref0.name;
}
else
{
name = Generator.Generate(arg0, ctx);
if (OPs.KindOf(name) != ValueKind.Const)
{
throw new SolverException("letLookupFunc(name, ...) : name must be constant");
}
}
var keysDescriptorObjs = Generator.Generate(ce.args[1], ctx);
var keysDescriptors = keysDescriptorObjs as IList;
if (OPs.KindOf(keysDescriptorObjs) != ValueKind.Const || keysDescriptors == null)
{
throw new SolverException("letLookupFunc(...,keysDescrs ...) : keysDescrs must be list of constants");
}
var valsDescriptorObjs = Generator.Generate(ce.args[2], ctx);
var valsDescriptors = valsDescriptorObjs as IList;
if (OPs.KindOf(valsDescriptorObjs) != ValueKind.Const || valsDescriptors == null)
{
throw new SolverException("letLookupFunc(...,...,valuesDescrs ...) : valuesDescrs must be list of constants");
}
var body = ce.args[3];
var func = (Macro)((expr, gctx) =>
Generator.Generate(body, gctx)
);
var keys = keysDescriptors.Cast <object>().Select(Convert.ToString);
var vals = valsDescriptors.Cast <object>().Select(Convert.ToString);
var fd = GetLookupFuncDef(Convert.ToString(name), keys, vals, func);
return(Generator.Generate(CallExpr.let(ce.args[0], new ConstExpr(fd)), ctx));
}
