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)); }