static object solverAliasImpl(CallExpr ce, Generator.Ctx ctx)
{
var alias = OPs.TryAsName(ce.args[0], ctx);
if (alias == null)
{
throw new SolverException(string.Format(ce.funcName + "(alias ...): alias must be constant or name instead of [{0}]", ce.args[0]));
}
var target = (ce.args.Count > 1) ? OPs.TryAsName(ce.args[1], ctx) : string.Empty;
if (target == null)
{
throw new SolverException(string.Format(ce.funcName + "(..., target ...): target must be constant or name instead of [{0}]", ce.args[0]));
}
int priority = (ce.args.Count > 2) ? Convert.ToInt32(ctx.GetConstant(ce.args[2])) : 255;
int i = ctx.GetOrCreateIndexOf(optionSolverAliases);
var aliases = ctx[i] as SolverAliases;
if (aliases == null)
{
aliases = new SolverAliases();
ctx[i] = aliases;
}
switch (ce.funcName)
{
case nameof(solverAlias):
return(aliases.Set(alias, target, priority));
case nameof(solverAliasPush):
return(aliases.Push(alias, target));
case nameof(solverAliasPop):
return(aliases.Pop(alias));
default:
throw new NotImplementedException(ce.funcName);
}
}
private Metadata(IEnumerable <NE> exprsHdr, IEnumerable <NE> exprsRow, IEnumerable <NE> exprsRes, Generator.Ctx parentCtx)
{
var sb = new StringBuilder();
FixSheetExpr = Expr.RecursiveModifier(FixSheetImpl);
FixRowExpr = Expr.RecursiveModifier(FixRowImpl);
#region generate header code
ctxHdr = new Generator.Ctx(parentCtx);
ctxHdr.CreateValue(HdrCellsRef.name, Generator.LazyDummy);
ctxHdr.CreateValue(PrevValsRef.name, Generator.LazyDummy);
foreach (var p in exprsHdr)
{
FCurrName = p.name;
var expr = FixSheetExpr(p.expr);
var val = Generator.Generate(expr, ctxHdr);
ctxHdr.CreateValue(p.name, val);
if (OPs.KindOf(val) == ValueKind.Const)
{
expr = new ConstExpr(val);
}
sb.AppendLine($"{p.name} = {expr}");
}
sb.AppendLine();
RequiredInHdr(sSourceKey);
RequiredInHdr(sSourceName);
RequiredInHdr(sCondition);
RequiredInHdr(sFirstDataRowNum);
{
if (ctxHdr.name2ndx.TryGetValue(sFileContentKind, out int i))
{
FileContentKind = Convert.ToString(ctxHdr.GetConstant(sFileContentKind));
}
else
{
FileContentKind = "XLSX";
}
}
{
if (ctxHdr.name2ndx.TryGetValue(sFileNameExtension, out int i))
{
var val = ctxHdr.GetConstant(sFileNameExtension);
FileNameExtension = Utils.AsIList(val).Cast <object>().Select(Convert.ToString).ToArray();
}
else
{
FileNameExtension = new string[] { "xls", "xlsx", "xlsm" }
};
}
#endregion
#region generate row code
ctxRow = new Generator.Ctx(ctxHdr);
ctxRow.CreateValue(sDataKey, Generator.LazyDummy); // [0] - iKey
ctxRow.CreateValue(sDataSubkey, Generator.LazyDummy); // [1] - iSubkey
ctxRow.CreateValue(CellValsRef.name, Generator.LazyDummy); // [2] - iRowVals
foreach (var p in exprsRow)
{
string name;
if (p.name.StartsWith("~"))
{
// calculated name
name = OPs.TryAsString(Parser.ParseToExpr(p.name.Substring(1)), ctxHdr) ?? p.name;
}
else
{
name = p.name;
}
FCurrName = name;
int i = ctxRow.GetOrCreateIndexOf(name);
var expr = FixRowExpr(p.expr);
var val = Generator.Generate(expr, ctxRow);
ctxRow.values[i] = val;
if (OPs.KindOf(val) == ValueKind.Const)
{
expr = new ConstExpr(val);
}
sb.AppendLine($"{name} = {expr}");
}
RequiredInRow(sDataKey);
RequiredInRow(sDataSubkey);
ctxRow.values[iRowVals] = null;
ctxRow.CheckUndefinedValues();
#endregion
#region generate res code
if (exprsRes != null)
{
// copy all code from row to res
ctxRes = new Generator.Ctx(ctxHdr);
foreach (var p in ctxRow.name2ndx.OrderBy(p => p.Value))
{
ctxRes.values[ctxRes.CreateValue(p.Key)] = ctxRow.values[p.Value];
}
foreach (var p in exprsRes)
{
string name;
if (p.name.StartsWith("~"))
{
// calculated name
name = OPs.TryAsString(Parser.ParseToExpr(p.name.Substring(1)), ctxHdr) ?? p.name;
}
else
{
name = p.name;
}
FCurrName = name;
int i = ctxRes.GetOrCreateIndexOf(name);
var expr = FixRowExpr(p.expr);
var val = Generator.Generate(expr, ctxRes);
ctxRes.values[i] = val;
if (OPs.KindOf(val) == ValueKind.Const)
{
expr = new ConstExpr(val);
}
}
ctxRes.values[iRowVals] = null;
ctxRes.CheckUndefinedValues();
}
#endregion
ctxHdr[HdrCellsRef.name] = null;
ctxHdr[PrevValsRef.name] = null;
ctxHdr.CheckUndefinedValues();
FCodeText = sb.ToString();
if (iHdrMinUsedRow > iHdrMaxUsedRow)
{
iHdrMinUsedRow = iHdrMaxUsedRow;
}
}
public static object Filtering(Generator.Ctx ctx, string inputParam, string sourceData, IList <Expr> filterConditions, string[] outputParams)
{
var aliasOf = FuncDefs_Solver.GetAliases(ctx);
// количество стадий = количество условий фильтрации + 1 стадия подготовки выходных данных
int nStages = filterConditions.Count + 1;
// для каждой стадии перечень параметров, необходимых для её обработки
var stage = new StageInfo[nStages];
// перечень всех параметров всех стадий
var usedParamsDict = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
#region Определяем используемые на стадиях обработки данных показатели (стадии фильтрации + стадия подготовки выходных данных)
// проход по стадиям фильтрации с формированием перечней используемых параметров
for (int i = 0; i < nStages - 1; i++)
{
var prmsDict = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
foreach (var paramName in filterConditions[i].EnumerateReferences().Where(ValueInfo.IsDescriptor))
{
prmsDict[aliasOf.GetRealName(paramName)] = true;
}
var ownParams = prmsDict.Keys.ToArray <string>();
stage[i].ownParams = ownParams;
stage[i].Cond = filterConditions[i];
foreach (var s in ownParams)
{
usedParamsDict[aliasOf.GetRealName(s)] = true;
}
}
string[] outputParamsRealNames = outputParams.Select(s => aliasOf.GetRealName(s)).ToArray();
// стадия выходных данных
stage[nStages - 1].ownParams = outputParamsRealNames;
foreach (var s in outputParamsRealNames)
{
usedParamsDict[s] = true;
}
#endregion
// справочник "параметр -> оценка сложности"
var funcComplexity = new Dictionary <string, int>();
//// справочник "параметр -> влияющие на него параметры"
//IDictionary<string, string[]> dependencies;
// справочник "параметр -> имя вычисляющей его функции"
IDictionary <string, string> param2func;
// справочник "функция -> входы / выходы"
var funcInpsOuts = new Dictionary <string, Tuple <string[], List <string> > >();
#region Определяем зависимости и "сложность" параметров
{
var localCtx = new Generator.Ctx(ctx);
localCtx.GetOrCreateIndexOf(FuncDefs_Solver.optionSolverDependencies);
var res = Generator.Generate(
// вызываем функцию поиска решения,
// которая при наличии optionSolverDependencies возвращает также справочник зависимостей
new CallExpr(FuncDefs_Solver.FindSolutionExpr
// перечень дополнительных входных параметров (которые в месте этого вызова не определены)
, new ArrayExpr(new ConstExpr(inputParam))
// перечень выходных параметров, решение для которых (последовательность вызовов известных функций) надо найти
, new ArrayExpr(usedParamsDict.Keys.Select(s => new ConstExpr(s)).ToArray())
)
// контекст кодогенератора для поиска решения (содержит перечень имён известных значений и описаний функций)
, localCtx
);
var deps = (IDictionary <string, object>)localCtx.values[localCtx.IndexOf(FuncDefs_Solver.optionSolverDependencies)];
//dependencies = deps.ToDictionary(p => p.Key, p => (p.Value == null) ? new string[0] : ((IList)p.Value).Cast<string>().Where(s => !s.StartsWith("#")).ToArray());
param2func = deps.ToDictionary(
p => p.Key,
p => (p.Value == null) ? string.Empty
: ((IList)p.Value).Cast <string>().Where(s => s.StartsWith(FuncDefs_Solver.sDepsFuncNamePrefix)).First()
,
StringComparer.OrdinalIgnoreCase
);
foreach (var d in deps)
{
var prm = d.Key;
var arguments = (IList)d.Value;
if (arguments == null)
{
arguments = new string[] { string.Empty }
}
;
Tuple <string[], List <string> > fInpsOuts;
var sFunc = arguments[0].ToString();
if (!funcInpsOuts.TryGetValue(sFunc, out fInpsOuts))
{
var inpFuncs = arguments.Cast <string>()
.Skip(1) // first arg is function name
.Select(s => param2func[s]) // get function name by her output parameter name
.Where(f => f != null)
.Distinct().ToArray();
fInpsOuts = new Tuple <string[], List <string> >(inpFuncs, new List <string>());
funcInpsOuts[sFunc] = fInpsOuts;
}
fInpsOuts.Item2.Add(prm);
}
var lstAllFuncs = funcInpsOuts.Keys.ToList();
bool someToDo = true;
while (someToDo)
{
someToDo = false;
for (int i = lstAllFuncs.Count - 1; i >= 0; --i)
{
var func = lstAllFuncs[i];
int cmpl = 0;
foreach (var s in funcInpsOuts[func].Item1)
{
int c;
if (!funcComplexity.TryGetValue(s, out c))
{
cmpl = -1; break;
}
else
{
cmpl += c;
}
}
if (cmpl >= 0)
{
funcComplexity.Add(func, cmpl + 1);
lstAllFuncs.RemoveAt(i);
someToDo = true;
}
}
}
System.Diagnostics.Trace.Assert(lstAllFuncs.Count == 0, "Filtering: lstAllFuncs.Count == 0");
}
#endregion
{ // сортировка стадий по возрастанию "сложности" параметров
int[] reorder = Enumerable.Range(0, nStages - 1)
.OrderBy(i => (stage[i].ownParams.Length == 0)
? 0
: stage[i].ownParams.Select(s => param2func[s]).Distinct().Select(f => funcComplexity[f]).Sum())
.Concat(new int[] { nStages - 1 })
.ToArray();
Array.Sort(reorder, stage);
}
#region Проход по стадиям
{
#if SAFE_PARALLELIZATION
bool inParallel = ctx.IndexOf(FuncDefs_Core.stateParallelizationAlreadyInvolved) < 0;
#else
const bool inParallel = true;
#endif
if (ctx.IndexOf(FuncDefs_Core.optionMinPartSize) < 0)
{
ctx.CreateValue(FuncDefs_Core.optionMinPartSize, defaultMinPartSize);
}
if (ctx.IndexOf(FuncDefs_Core.optionMaxPartSize) < 0)
{
ctx.CreateValue(FuncDefs_Core.optionMaxPartSize, defaultMaxPartSize);
}
var readyFuncs = new Dictionary <string, bool>();
readyFuncs.Add(string.Empty, true);
var prevDataName = sourceData;
var interstageParams = new string[] { inputParam };
var lstStages = new List <StageInfo>(stage);
var readyStages = new List <StageInfo>();
var mergedStagesCode = new List <string>();
int iMergedStage = 0;
while (lstStages.Count > 0 || readyStages.Count > 0)
{
for (int i = lstStages.Count - 1; i >= 0; i--)
{
if (lstStages[i].ownParams.All(prm => readyFuncs.ContainsKey(param2func[prm])))
{
readyStages.Add(lstStages[i]);
lstStages.RemoveAt(i);
}
}
if (readyStages.Count > 0)
{
var conds = readyStages.Select(stg => stg.Cond)
.Where(cond => cond != null)
.OrderBy(cond => cond.Traverse(e => (e is CallExpr || e is ReferenceExpr) ? 1 : 0).Sum())
.ToArray();
bool lastStage = conds.Length == 0;
Dictionary <string, bool> flowOfParams = readyStages.Concat(lstStages).SelectMany(si => si.ownParams).Distinct()
.ToDictionary(s => s, s => true, StringComparer.OrdinalIgnoreCase);
var ownParamsFuncs = readyStages
.SelectMany(stg => stg.ownParams.Select(prm => param2func[prm])
.Where(func => !readyFuncs.ContainsKey(func)))
.Distinct().ToArray();
var paramsToGetEnum =
// все выходные параметры готовых функций (источников данных)
readyFuncs.Keys.SelectMany(f => funcInpsOuts[f].Item2).Distinct()
// оставляем только те, что нужны на этой и последующих стадиях, а также ID
.Where(s => s.EndsWith("_ID") || s.Contains("_ID_") || flowOfParams.ContainsKey(s))
//// показатели оставляем в той форме, которая запрошена (например, в списке есть LIQUID_WATERCUT_OISP и его алиас LIQUID_WATERCUT, а запрошен именно LIQUID_WATERCUT)
//.Select(s => aliasOf.AsIn(flowOfParams, s))
;
//if (lastStage)
paramsToGetEnum = paramsToGetEnum.Distinct();
//else
// paramsToGetEnum = paramsToGetEnum.Distinct(aliasOf);
var paramsToGet = paramsToGetEnum.ToArray();
var condExpr = lastStage ? null : (conds.Length == 1) ? conds[0] : new CallExpr("AND", conds);
var code = GetConditionStageText(prevDataName,
lastStage ? interstageParams : interstageParams.Distinct(),
paramsToGet, condExpr, (iMergedStage == 0), inParallel);
prevDataName = "stgRows_" + iMergedStage.ToString();
code = string.Format("{0}\r\n..let({1}),", code, prevDataName);
if (lastStage)
{
code += string.Format("\r\nPROGRESS('FilteringItemsList',{0}),\r\n", prevDataName);
}
mergedStagesCode.Add(code);
iMergedStage++;
interstageParams = paramsToGet.Distinct().ToArray();
readyStages.Clear();
}
else
{
var stg = lstStages[0];
lstStages.RemoveAt(0);
readyStages.Add(stg);
AllSrcFuncs(
stg.ownParams.Select(prm => param2func[prm]).Where(func => !readyFuncs.ContainsKey(func)).Distinct()
, funcInpsOuts, readyFuncs);
}
}
var sbCode = new StringBuilder();
sbCode.AppendLine("(");
sbCode.AppendFormat("PROGRESS('FilteringStagesCount',{0}),", mergedStagesCode.Count);
sbCode.AppendLine();
foreach (var code in mergedStagesCode)
{
sbCode.AppendLine(code);
}
sbCode.AppendFormat("PROGRESS('FilteringComplete',{0}.COLUMNS()),", prevDataName);
sbCode.AppendLine();
sbCode.AppendLine(prevDataName);
sbCode.AppendLine(")");
var sCode = sbCode.ToString();
return(Parser.ParseToExpr(sCode));
}
#endregion
}
