//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
foreach (var part in _voidParts)
{
part.Check(tabl);
}
}
//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
if (tabl.Fields.ContainsKey(_var.Name))
{
AddError("Имя переменной не должно совпадать с именем поля таблицы");
}
_var.DataType = _var.DataType.Add(_nodeMean.Check(tabl));
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
if (_var == null)
{
return(DataType.Error);
}
return(_var.DataType);
}
//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
if (_condition.Check(tabl) != DataType.Boolean)
{
AddError("Недопустимый тип данных условия");
}
_prog.Check(tabl);
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
if (_condition.Check(tabl) != DataType.Boolean)
{
AddError("Недопустимый тип данных условия");
return(DataType.Error);
}
return(_prog.Check(tabl).Add(_elseProg.Check(tabl)));
}
//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
if (_conditions.Any(c => c.Check(tabl) != DataType.Boolean))
{
AddError("Недопустимый тип данных условия");
}
foreach (var expr in _variants)
{
expr.Check(tabl);
}
}
private DataType CheckField(GenKeeper keeper, ITablStruct tstruct, string formula)
{
keeper.Errors.Clear();
var parsing = new FieldsParsing(keeper, "поле", formula);
if (parsing.ResultTree == null)
{
return(DataType.Error);
}
return(((IExprNode)parsing.ResultTree).Check(tstruct));
}
private ITablStruct CheckSubRule(GenKeeper keeper, TablsList tabls, ITablStruct tstruct, string formula)
{
keeper.Errors.Clear();
var parsing = new SubRuleParsing(keeper, "поле", formula);
if (parsing.ResultTree == null)
{
return(null);
}
return(((INodeRTabl)parsing.ResultTree).Check(tabls, tstruct));
}
//Проверка выражения
public ITablStruct Check(TablsList dataTabls, ITablStruct parentStruct)
{
if (parentStruct.Child == null)
{
AddError("Подтаблица отстутствует");
return(null);
}
if (Condition != null && Condition.Check(parentStruct.Child) != DataType.Boolean)
{
AddError("Недопустимый тип данных условия");
}
return(ChildNode == null ? parentStruct.Child : ChildNode.Check(dataTabls, parentStruct.Child));
}
//Выбрать ряды по условию генерации подтаблицы
private SubRows[] SelectSubRowsS(GenKeeper keeper, TablsList tabls, ITablStruct tstruct, SubRows rows, string formula)
{
keeper.Errors.Clear();
var parsing = new SubRuleParsing(keeper, "поле", formula);
if (parsing.ResultTree == null)
{
return(null);
}
var node = (SubNodeR)parsing.ResultTree;
node.Check(tabls, tstruct);
return(node.SelectRows(tabls, rows).ToArray());
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
if (tabl == null)
{
AddError("Попытка получения значения поля при не заданной таблице");
return(DataType.Error);
}
if (!tabl.Fields.ContainsKey(_field))
{
AddError("Поле не найдено в исходной таблице");
return(DataType.Error);
}
return(tabl.Fields[_field]);
}
//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
if (tabl is RowGroupStruct)
{
AddError("Переход к надтаблице недопустим для сгруппированных строк");
}
else if (tabl.Parent == null)
{
AddError("Недопустимый переход к надтаблице");
}
else
{
_prog.Check(tabl.Parent);
}
}
//Проверка корректности выражений генерации
public void Check(ITablStruct tabl)
{
if (tabl.Child == null)
{
AddError("Недопустимый переход к подтаблице");
}
else if (_condition != null && _condition.Check(tabl.Child) != DataType.Boolean)
{
AddError("Недопустимый тип данных условия");
}
else
{
_prog.Check(tabl.Child);
}
}
//Проверка выражения
public ITablStruct Check(TablsList dataTabls, ITablStruct parentStruct)
{
if (!dataTabls.Structs.ContainsKey(_tablName))
{
AddError("Не найдена таблица");
return(null);
}
var tstruct = dataTabls.Structs[_tablName].Tabls[0];
if (_condition != null && _condition.Check(tstruct) != DataType.Boolean)
{
AddError("Недопустимый тип данных условия");
}
return(ChildNode == null ? tstruct : ChildNode.Check(dataTabls, tstruct));
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
if (_conditions.Any(c => c.Check(tabl) != DataType.Boolean))
{
AddError("Недопустимый тип данных условия");
return(DataType.Error);
}
var dt = DataType.Value;
foreach (var expr in _variants)
{
dt = dt.Add(expr.Check(tabl));
}
return(dt);
}
public GenSubRow(ModuleGenerator generator, //Ссылка на генератор
TablsList dataTabls, //Исходные таблицы для генерации
ITablStruct dataTabl, //Таблица - шаблон генерации
GenTemplateTable table, //Поля таблицы - шаблона генерации
DaoRec rec) //Рекордсет таблицы результатов
: base(generator, table, rec)
{
var subTabl = Rule == null ? dataTabl : ((INodeRTabl)Rule).Check(dataTabls, dataTabl);
foreach (var key in Fields.Keys)
{
Keeper.SetFieldName(key);
Fields[key].Check(subTabl);
}
rec.Put(table.ErrField, Keeper.ErrMess);
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
if (tabl is RowGroupStruct)
{
AddError("Переход к надтаблице недопустим для сгруппированных строк");
}
else if (tabl.Parent == null)
{
AddError("Недопустимый переход к надтаблице");
}
else
{
return(_expr.Check(tabl.Parent));
}
return(DataType.Error);
}
//Проверка выражения
public ITablStruct Check(TablsList dataTabls, ITablStruct tablParent)
{
var gstruct = new RowGroupStruct((TablStruct)tablParent, _fields);
foreach (var field in _fieldsNodes)
{
var s = ((ConstNode)field).Mean.String;
if (!tablParent.Fields.ContainsKey(s))
{
Keeper.AddError("Поле для группировки не найдено в таблице", field);
}
else
{
gstruct.Fields.Add(s, tablParent.Fields[s]);
}
}
return(gstruct);
}
//Проверка формулы
public DataType Check(ITablStruct tabl)
{
var dtype = DataType.Value;
foreach (var child in Nodes)
{
if (child is IExprNode)
{
var res = ((IExprNode)child).Check(tabl);
dtype = dtype == DataType.Value ? res : DataType.String;
}
else if (child is IVoidNode)
{
((IVoidNode)child).Check(tabl);
}
}
return(dtype);
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
var generator = Keeper.Generator;
var funs = generator.FunsChecker.Funs;
if (!funs.ContainsKey(Token.Text))
{
AddError("Неизвестная функция");
}
else
{
var fs = funs[Token.Text].DefineOverload(_args.Select(a => a.Check(tabl)).ToArray());
if (fs == null)
{
AddError("Недопустимые типы данных параметров функции");
return(DataType.Error);
}
_fun = (IGenFun)generator.Functions.Funs[fs.Overload.Code];
return(_resultType = fs.DataType);
}
return(DataType.Error);
}
//Проверка корректности выражений генерации
public DataType Check(ITablStruct tabl)
{
var child = tabl.Child;
if (child == null)
{
AddError("Недопустимый переход к подтаблице");
return(DataType.Error);
}
if (_pars.Length > 1 && _pars[0].Check(child) == DataType.Boolean)
{
_condition = _pars[0];
_expr = _pars[1];
if (_pars.Length == 3)
{
_separator = _pars[2];
}
}
else
{
_expr = _pars[0];
if (_pars.Length == 2)
{
_separator = _pars[1];
}
if (_pars.Length == 3)
{
AddError("Недопустимый тип данных условия");
}
}
_expr.Check(child);
if (_separator != null)
{
_separator.Check(child);
}
return(DataType.String);
}
private IEnumerable <SubRows> SelectRowsStruct(GenKeeper keeper, TablsList tabls, string formula, out ITablStruct tstruct)
{
tstruct = null;
keeper.Errors.Clear();
var parsing = new RuleParsing(keeper, "поле", formula);
if (parsing.ResultTree == null)
{
return(null);
}
var node = (NodeRTabl)parsing.ResultTree;
tstruct = node.Check(tabls, null);
return(node.SelectRows(tabls, null));
}
//Проверка корректности выражений генерации, определение типа данных выражения
public DataType Check(ITablStruct tabl)
{
_voidProg.Check(tabl);
return(_expr.Check(tabl));
}
//Получение типа данных
public DataType Check(ITablStruct tabl)
{
return(DataType);
}
private TablRow[] SelectSubRows(GenKeeper keeper, TablsList tabls, ITablStruct tstruct, SubRows rows, string formula)
{
return(SelectSubRowsS(keeper, tabls, tstruct, rows, formula).Cast <TablRow>().ToArray());
}
