//Генерация расчетных параметров для одного модуля
public void GenerateParams(string moduleDir) //Каталог модуля
{
using (StartLog("Генерация параметров", moduleDir))
{
try
{
var dir = moduleDir.EndDir();
var table = new GenTemplateTable("GenParams", "GenRule", "ErrMess", "CalcOn", "ParamId");
var subTable = new GenTemplateTable("GenSubParams", table, "GenRule", "ErrMess", "CalcOn", "SubParamId", "ParamId");
var dataTabls = new TablsList();
AddEvent("Загрузка структуры исходных таблиц", dir + "Tables.accdb");
using (var db = new DaoDb(dir + "Tables.accdb"))
{
dataTabls.AddDbStructs(db);
AddEvent("Загрузка значений из исходных таблиц");
dataTabls.LoadValues(db, true);
}
AddEvent("Загрузка и проверка генерирующих параметров");
var generator = new ModuleGenerator(Logger, dataTabls, dir + "CalcParams.accdb", table, subTable);
generator.Generate(dir + "Compiled.accdb", "GeneratedParams", "GeneratedSubParams");
AddEvent("Генерация завершена", generator.GenErrorsCount + " ошибок");
if (generator.GenErrorsCount != 0)
{
SetLogResults(generator.GenErrorsCount + " ошибок");
AddCollectResult("Шаблон генерации содержит " + generator.GenErrorsCount + " ошибок");
}
}
catch (Exception ex)
{
AddError("Ошибка при генерации параметров", ex);
}
}
}
//Загрузка структур таблиц
private void LoadTabls()
{
AddEvent("Загрузка структур таблиц");
Tabls = new TablsList();
using (var db = new DaoDb(Dir + "Tables.accdb"))
Tabls.AddDbStructs(db);
}
public void TablsList()
{
var tdir = Different.GetTestInfoTaskDir() + @"CommonTypes\Tabls\TablsList\";
var tdb = new DaoDb(tdir + "Project1GenData.accdb");
{
var tlist = new TablsList(tdb);
Assert.IsNotNull(tlist.Tabls);
Assert.IsTrue(tlist.Tabls.ContainsKey("T1"));
var t = tlist.Tabls["T1"];
Assert.AreEqual("T1", t.Code);
Assert.AreEqual(1, t.MaxLevel);
Assert.AreEqual(2, t.Fields.Count);
Assert.AreEqual(2, t.Fields[0].Count);
Assert.AreEqual(2, t.FieldsNums[0].Count);
Assert.IsTrue(new TablField("StringField", 0, DataType.String).IsEquals(t.FieldsNums[0][0]));
Assert.IsTrue(new TablField("IntField", 1, DataType.Integer).IsEquals(t.FieldsNums[0][1]));
Assert.AreEqual(2, t.Fields[1].Count);
Assert.AreEqual(2, t.FieldsNums[1].Count);
Assert.IsTrue(new TablField("StringSub", 0, DataType.String).IsEquals(t.FieldsNums[1][0]));
Assert.IsTrue(new TablField("IntSub", 1, DataType.Integer).IsEquals(t.FieldsNums[1][1]));
Assert.IsTrue(tlist.Tabls.ContainsKey("T2"));
t = tlist.Tabls["T2"];
Assert.AreEqual("T2", t.Code);
Assert.AreEqual(0, t.MaxLevel);
Assert.AreEqual(1, t.Fields.Count);
Assert.AreEqual(1, t.Fields[0].Count);
}
}
//Выбрать ряды для генерации
public IEnumerable <SubRows> SelectRows(TablsList dataTabls, SubRows parentRow)
{
IEnumerable <SubRows> rows = dataTabls.Tabls[_tablName].SubList;
rows = _condition == null ? rows : rows.Where(row => _condition.Generate(row).Boolean);
return(ChildNode == null ? rows : ChildNode.SelectRows(rows));
}
public GenRow(ModuleGenerator generator, //Ссылка на генератор
TablsList dataTabls, //Исходные таблицы для генерации
GenTemplateTable table, DaoRec rec, //Рекортсет и поля таблицы
GenTemplateTable subTable, DaoRec subRec) //Рекордсет и и поля подтаблицы
: base(generator, table, rec)
{
Id = rec.GetInt(table.IdField);
var dataTabl = Rule == null ? null : ((NodeRTabl)Rule).Check(dataTabls, null);
foreach (var key in Fields.Keys)
{
Keeper.SetFieldName(key);
Fields[key].Check(dataTabl);
}
if (subRec != null && !subRec.EOF)
{
Keeper.SetFieldName("");
bool subErr = false;
while (subRec.GetInt(subTable.ParentIdField) == Id)
{
var row = new GenSubRow(generator, dataTabls, dataTabl, subTable, subRec);
if (row.Keeper.Errors.Count != 0 && !subErr)
{
Keeper.AddError("Ошибки в рядах подтаблицы", (IToken)null);
subErr = true;
}
SubRows.Add(row);
if (!subRec.MoveNext())
{
break;
}
}
}
rec.Put(table.ErrField, Keeper.ErrMess);
}
//Сгенерировать таблицу по данному ряду
public void Generate(TablsList dataTabls, //Список таблиц с данными для генерации
DaoRec rec, //Рекордсет генерируемой таблицы
DaoRec subrec) //Рекордсет генерируемой подтаблицы
{
if (!Keeper.ErrMess.IsEmpty())
{
return;
}
IEnumerable <SubRows> rows = Rule == null ? new SubRows[] { null } : ((NodeRTabl)Rule).SelectRows(dataTabls, null);
foreach (var row in rows)
{
rec.AddNew();
int id = rec.GetInt(Table.IdField);
GenerateFields(row, rec);
rec.Update();
if (subrec != null)
{
foreach (var subRowGen in SubRows)
{
IEnumerable <SubRows> subRows = subRowGen.RuleString.IsEmpty() ? new [] { row } : (((INodeRTabl)subRowGen.Rule).SelectRows(dataTabls, row));
foreach (var subRow in subRows)
{
subrec.AddNew();
subrec.Put(subRowGen.Table.ParentIdField, id);
subRowGen.GenerateFields(subRow, subrec);
subrec.Update();
}
}
}
}
}
//Генерация по всему условию
public void GenerateParams(TablsList tabls, //список всех таблиц для генерации
RecDao rec, //рекордсет параметров
RecDao recs) //рекордсет подпараметров
{
_paramsRec = rec;
SubParamsRec = recs;
_condition.Generate(this, tabls);
}
//Выбрать ряды для генерации, главный узел выражения подтаблицы
public IEnumerable <SubRows> SelectRows(TablsList dataTabls, SubRows parentRow)
{
IEnumerable <SubRows> rows = Condition == null
? parentRow.SubList
: parentRow.SubList.Where(row => Condition.Generate(row).Boolean);
return(ChildNode == null ? rows : ChildNode.SelectRows(rows));
}
//Загрузка таблиц
private void LoadTables()
{
AddEvent("Загрузка данных исходных таблиц");
using (var db = new DaoDb(_tablsFile))
{
db.ConnectDao();
TablsList = new TablsList(db);
TablsList.LoadValues();
}
}
public void LoadValues()
{
var tdir = Different.GetTestInfoTaskDir() + @"CommonTypes\Tabls\LoadValues\";
var tdb = new DaoDb(tdir + "Project2GenData.accdb");
{
var tlist = new TablsList(tdb);
tlist.LoadValues();
var t = tlist.Tabls["T1"];
var rnums = t.TablValues.SubNums;
var rcodes = t.TablValues.SubCodes;
Assert.IsTrue(rnums.ContainsKey(1));
Assert.AreEqual("aa", rnums[1].Code);
Assert.AreEqual("sssa", rnums[1]["stringfield"].String);
Assert.AreEqual(10, rnums[1]["intfield"].Integer);
Assert.AreEqual(2, rnums[1].SubCodes.Count);
Assert.AreEqual(2, rnums[1].SubNums.Count);
Assert.AreEqual("a1", rnums[1].SubNums[1].Code);
Assert.AreEqual(2, rnums[1].SubCodes["a2"].Num);
Assert.AreEqual("sa1", rnums[1].SubNums[1]["StringSub"].String);
Assert.AreEqual("sa2", rnums[1].SubNums[2]["StringSub"].String);
Assert.AreEqual("sa1", rnums[1].SubNums[1][0].String);
Assert.AreEqual("sa2", rnums[1].SubNums[2][0].String);
Assert.AreEqual(11, rnums[1].SubNums[1][1].Integer);
Assert.AreEqual(12, rnums[1].SubNums[2][1].Integer);
Assert.IsTrue(rcodes.ContainsKey("aa"));
Assert.AreEqual(1, rcodes["aa"].Num);
Assert.AreEqual("sssa", rcodes["aa"]["stringfield"].String);
Assert.AreEqual("sa2", rcodes["aa"].SubNums[2]["StringSub"].String);
Assert.IsTrue(rnums.ContainsKey(2));
Assert.AreEqual("bb", rnums[2].Code);
Assert.AreEqual("Sssb", rnums[2]["StringField"].String);
Assert.AreEqual(20, rnums[2]["IntField"].Integer);
Assert.AreEqual(1, rnums[2].SubCodes.Count);
Assert.AreEqual(1, rnums[2].SubNums.Count);
Assert.AreEqual("b1", rnums[2].SubNums[1].Code);
Assert.AreEqual("sb1", rnums[2].SubNums[1]["StringSub"].String);
Assert.IsTrue(rnums.ContainsKey(3));
Assert.AreEqual("cc", rnums[3].Code);
Assert.AreEqual("SSSC", rnums[3]["StringField"].String);
Assert.AreEqual(30, rnums[3]["IntField"].Integer);
Assert.AreEqual(3, rnums[3].SubCodes.Count);
Assert.AreEqual(3, rnums[3].SubNums.Count);
Assert.AreEqual("c2", rnums[3].SubNums[2].Code);
Assert.AreEqual("sc3", rnums[3].SubNums[3]["StringSub"].String);
Assert.AreEqual(33, rnums[3].SubNums[3]["IntSub"].Integer);
t = tlist.Tabls["T2"];
Assert.AreEqual(0, t.TablValues.SubNums.Count);
Assert.AreEqual(0, t.TablValues.SubCodes.Count);
}
}
//Генерация для надтаблицы
internal override void Generate(GenParamBase par, TablsList tabls)
{
if (!tabls.Tabls.ContainsKey(_tablName))
{
par.ErrMess += "Не найдена таблица " + _tablName + " (GenConditions); ";
}
else
{
par.Generate(tabls.Tabls[_tablName].TablValues);
}
}
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));
}
//Загрузка таблиц
private TablsList Load(string prefix)
{
var tabls = new TablsList();
using (var db = new DaoDb(TestLib.CopyFile("Generator", "GenData.accdb", "Check" + prefix + ".accdb")))
{
tabls.AddStruct(db, "Tabl", "SubTabl", "SubSubTabl");
tabls.AddDbStructs(db);
}
return(tabls);
}
//Проверка выражения
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());
}
//Выбрать ряды по условию генерации таблицы, возвращает ряды и, возможно, также структуру
private SubRows[] SelectRowsS(GenKeeper keeper, TablsList tabls, string formula)
{
keeper.Errors.Clear();
var parsing = new RuleParsing(keeper, "поле", formula);
if (parsing.ResultTree == null)
{
return(null);
}
var node = (NodeRTabl)parsing.ResultTree;
node.Check(tabls, null);
return(node.SelectRows(tabls, null).ToArray());
}
//Проверка выражения
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));
}
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 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 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);
}
private void LoadTabls()
{
AddEvent("Загрузка графиков");
using (var db = new DaoDb(Dir + "Grafics.accdb"))
{
using (var rec = new DaoRec(db, "GraficsList"))
while (rec.Read())
{
}
}
AddEvent("Загрузка таблиц");
using (var db = new DaoDb(Dir + "Tables.accdb"))
{
TablsList.AddDbStructs(db);
TablsList.LoadValues(db, false);
}
}
private void Generate(string tablName, string subTablName = null, bool copyRes = true)
{
var tabls = new TablsList();
using (var db = new DaoDb(TestLib.CopyFile("Generator", "GenData.accdb", "Gen" + tablName + "Data.accdb")))
{
tabls.AddStruct(db, "Tabl", "SubTabl", "SubSubTabl");
tabls.AddDbStructs(db);
tabls.LoadValues(db, true);
}
TestLib.CopyFile("Generator", "GenTemplate.accdb", "Gen" + tablName + "Template.accdb");
if (copyRes)
{
TestLib.CopyFile("Generator", "GenRes.accdb", "Gen" + tablName + "Res.accdb");
}
TestLib.CopyFile("Generator", "CorrectGen" + tablName + ".accdb", "Gen" + tablName + "Correct.accdb");
var templatesFile = TestLib.TestRunDir + @"Generator\Gen" + tablName + "Template.accdb";
var table = new GenTemplateTable(tablName, "GenRule", "ErrMess", "CalcOn", "Id");
var subTable = subTablName == null ? null : new GenTemplateTable(subTablName, table, "GenRule", "ErrMess", "CalcOn", "Id", "ParentId");
var logger = new Logger(new AppIndicator());
logger.History = new TestHistory(logger);
var generator = new ModuleGenerator(logger, tabls, templatesFile, table, subTable);
var s = TestLib.TestRunDir + @"Generator\Gen" + tablName;
if (copyRes)
{
generator.Generate(s + "Res.accdb", tablName, subTablName);
}
using (var db1 = new DaoDb(s + (copyRes ? "Res" : "Template") + ".accdb"))
using (var db2 = new DaoDb(s + "Correct" + ".accdb"))
{
TestLib.CompareTables(db1, db2, tablName, "Id");
if (subTablName != null)
{
TestLib.CompareTables(db1, db2, subTablName, "Id");
}
}
}
public ModuleGenerator(Logger logger, //Логгер
TablsList dataTabls, //Таблицы с данными для генерации
string templateFile, //Файл шаблона генерации
GenTemplateTable table, //Главная таблица шаблона генерации
GenTemplateTable subTable = null) //Подчиненная таблица шаблона генерации
: base(logger)
{
GenErrorsCount = 0;
AddEvent("Загрузка списка функций");
FunsChecker = new FunsChecker(FunsCheckType.Gen);
Functions = new GenFunctions();
DataTabls = dataTabls;
try
{
AddEvent("Загрузка таблиц шаблона генерации", templateFile + ", " + table.Name);
bool hasSub = subTable != null;
using (var rec = new DaoRec(templateFile, table.QueryString))
using (var subRec = !hasSub ? null : new DaoRec(rec.DaoDb, subTable.QueryString))
{
if (hasSub && !subRec.EOF)
{
subRec.MoveFirst();
}
while (rec.Read())
{
var row = new GenRow(this, dataTabls, table, rec, subTable, subRec);
GenErrorsCount += row.Keeper.Errors.Count;
_rowsGen.Add(row.Id, row);
}
}
}
catch (Exception ex)
{
AddError("Ошибка при загрузке шаблона генерации", ex, templateFile);
}
}
//Перечисление строк таблицы
internal override void Generate(GenParamBase par, TablsList tabls)
{
if (!tabls.Tabls.ContainsKey(_tablName))
{
par.ErrMess += "Не найдена таблица " + _tablName + " (GenConditions); ";
}
else
{
foreach (TablRow row in tabls.Tabls[_tablName].TablValues.Subs)
{
if (Cond == null || Cond.CalculateBool(row))
{
if (Children == null)
{
par.Generate(row);
}
else
{
Children.Generate(par, row);
}
}
}
}
}
private TablRow[] SelectSubRows(GenKeeper keeper, TablsList tabls, ITablStruct tstruct, SubRows rows, string formula)
{
return(SelectSubRowsS(keeper, tabls, tstruct, rows, formula).Cast <TablRow>().ToArray());
}
//Перечисление строк таблицы internal abstract void Generate(GenParamBase par, TablsList tabls);
//Генерация по строке таблицы
internal override void Generate(GenParamBase par, TablsList tabls)
{
par.Generate(null);
}
public void TablValues()
{
using (var db = CopyDb("Values"))
{
var tlist = new TablsList();
Assert.AreEqual(0, tlist.Tabls.Count);
tlist.AddStruct(db, "Tabl", "SubTabl", "SubSubTabl");
Assert.AreEqual(1, tlist.Structs.Count);
tlist.LoadValues(db, false);
Assert.AreEqual(1, tlist.Tabls.Count);
var tabl = tlist.Tabls["Tabl"];
Assert.AreEqual(3, tabl.Rows[0].Count);
Assert.AreEqual(4, tabl.Rows[1].Count);
Assert.AreEqual(0, tabl.Rows[2].Count);
Assert.AreEqual(3, tabl.SubCodes.Count);
Assert.AreEqual(2, tabl.SubNums.Count);
Assert.AreEqual(3, tabl.SubList.Count);
Assert.IsTrue(tabl.SubCodes.ContainsKey("s1"));
Assert.IsTrue(tabl.SubCodes.ContainsKey("s2"));
Assert.IsTrue(tabl.SubCodes.ContainsKey("s3"));
Assert.IsTrue(tabl.SubNums.ContainsKey(11));
Assert.IsTrue(tabl.SubNums.ContainsKey(12));
var row = tabl.SubCodes["s1"];
Assert.AreEqual(3, row.SubCodes.Count);
Assert.AreEqual(3, row.SubNums.Count);
Assert.AreEqual(3, row.SubList.Count);
Assert.AreEqual(1, row.Id);
Assert.AreEqual(11, row.Num);
Assert.AreEqual("s1", row.Code);
Assert.AreEqual(DataType.Integer, row["Num"].DataType);
Assert.AreEqual(11, row["Num"].Integer);
Assert.IsNull(row["Num"].Error);
Assert.AreEqual(DataType.String, row["StringField"].DataType);
Assert.AreEqual("SSS", row["StringField"].String);
Assert.AreEqual(DataType.Boolean, row["BoolField"].DataType);
Assert.AreEqual(true, row["StringField"].Boolean);
Assert.AreEqual(DataType.Time, row["TimeField"].DataType);
Assert.AreEqual(new DateTime(2016, 9, 26), row["TimeField"].Date);
row = row.SubNums[1];
Assert.AreEqual(2, row.SubCodes.Count);
Assert.AreEqual(2, row.SubNums.Count);
Assert.AreEqual(2, row.SubList.Count);
Assert.AreEqual(1, row.Id);
Assert.AreEqual(1, row.ParentId);
Assert.AreEqual(1, row.Num);
Assert.AreEqual("a", row.Code);
Assert.AreEqual(DataType.Integer, row["Num"].DataType);
Assert.AreEqual(1, row["Num"].Integer);
Assert.AreEqual(DataType.String, row["Code"].DataType);
Assert.AreEqual("a", row["Code"].String);
Assert.AreEqual(DataType.String, row["StringSub"].DataType);
Assert.AreEqual("", row["StringSub"].String);
Assert.AreEqual(DataType.Boolean, row["BoolSub"].DataType);
Assert.AreEqual(true, row["StringSub"].Boolean);
Assert.AreEqual(DataType.Real, row["RealSub"].DataType);
Assert.AreEqual(1, row["RealSub"].Real);
row = row.SubNums[2000];
Assert.AreEqual(0, row.SubCodes.Count);
Assert.AreEqual(0, row.SubNums.Count);
Assert.AreEqual(0, row.SubList.Count);
Assert.AreEqual(2, row.Id);
Assert.AreEqual(1, row.ParentId);
Assert.AreEqual(2000, row.Num);
Assert.AreEqual("ppp", row.Code);
Assert.AreEqual(DataType.String, row["Code"].DataType);
Assert.AreEqual("ppp", row["Code"].String);
Assert.AreEqual(DataType.String, row["StringString"].DataType);
Assert.AreEqual("ppp", row["StringString"].String);
Assert.AreEqual(DataType.Boolean, row["BoolBool"].DataType);
Assert.AreEqual(true, row["BoolBool"].Boolean);
row = tabl.SubNums[12];
Assert.AreEqual(1, row.SubCodes.Count);
Assert.AreEqual(1, row.SubNums.Count);
Assert.AreEqual(1, row.SubList.Count);
Assert.AreEqual(2, row.Id);
Assert.AreEqual(12, row.Num);
Assert.AreEqual("s2", row.Code);
Assert.AreEqual(DataType.Integer, row["Num"].DataType);
Assert.AreEqual(12, row["Num"].Integer);
Assert.AreEqual(DataType.String, row["StringField"].DataType);
Assert.AreEqual("SSS", row["StringField"].String);
Assert.AreEqual(DataType.Boolean, row["BoolField"].DataType);
Assert.AreEqual(true, row["StringField"].Boolean);
Assert.AreEqual(DataType.Real, row["RealField"].DataType);
Assert.AreEqual(123.5, row["RealField"].Real);
tlist.AddDbStructs(db);
tlist.LoadValues(db, true);
Assert.AreEqual(2, tlist.Tabls.Count);
Assert.AreEqual(2, tlist.Structs.Count);
tabl = tlist.Tabls["VTZTZ"];
Assert.AreEqual(6, tabl.SubCodes.Count);
Assert.AreEqual(1, tabl.SubNums.Count);
Assert.AreEqual(6, tabl.SubList.Count);
row = tabl.SubCodes["ВТЗЗ00120101002"];
Assert.AreEqual(1, row.SubCodes.Count);
Assert.AreEqual(1, row.SubNums.Count);
Assert.AreEqual(1, row.SubList.Count);
Assert.AreEqual(386, row.Id);
Assert.AreEqual(0, row.Num);
Assert.AreEqual("ВТЗЗ00120101002", row.Code);
Assert.AreEqual(DataType.String, row["Code"].DataType);
Assert.AreEqual("ВТЗЗ00120101002", row["Code"].String);
Assert.AreEqual(DataType.String, row["NameVTZ"].DataType);
Assert.AreEqual("Выходные цепи отключения ДВ-А", row["NameVTZ"].String);
Assert.AreEqual(DataType.Integer, row["SysNumVTZ"].DataType);
Assert.AreEqual(43000, row["SysNumVTZ"].Integer);
Assert.AreEqual(DataType.Integer, row["PriorVTZ"].DataType);
Assert.AreEqual(1, row["PriorVTZ"].Integer);
row = row.SubCodes["ТЗ_З00120101004"];
Assert.IsNotNull(row.Parent);
Assert.AreEqual(0, row.SubCodes.Count);
Assert.AreEqual(0, row.SubNums.Count);
Assert.AreEqual(0, row.SubList.Count);
Assert.AreEqual(1, row.Id);
Assert.AreEqual(386, row.ParentId);
Assert.AreEqual(0, row.Num);
Assert.AreEqual("ТЗ_З00120101004", row.Code);
Assert.AreEqual(DataType.String, row["Code"].DataType);
Assert.AreEqual("ТЗ_З00120101004", row["Code"].String);
Assert.AreEqual(DataType.String, row["NameTZ"].DataType);
Assert.AreEqual("Понижение Pм на смазку ДВ-А", row["NameTZ"].String);
Assert.AreEqual(DataType.Integer, row["SysNumTZ"].DataType);
Assert.AreEqual(41000, row["SysNumTZ"].Integer);
Assert.AreEqual(DataType.Integer, row["IdUnitTZ"].DataType);
Assert.AreEqual(10299, row["IdUnitTZ"].Integer);
}
}
public void TablStruct()
{
using (var db = CopyDb("Struct"))
{
var tlist = new TablsList();
Assert.AreEqual(0, tlist.Structs.Count);
Assert.AreEqual(0, tlist.Tabls.Count);
var gr = tlist.AddStruct(db, "Tabl", "SubTabl", "SubSubTabl");
Assert.AreEqual(1, tlist.Structs.Count);
Assert.AreEqual("Tabl", gr.Code);
Assert.AreEqual(File("Struct"), gr.DbFile);
Assert.AreEqual(4, gr.Tabls.Count);
var tstruct = gr.Tabls[-1];
Assert.AreEqual(-1, tstruct.Level);
Assert.IsNull(tstruct.Parent);
Assert.IsNotNull(tstruct.Child);
Assert.AreEqual(0, tstruct.Fields.Count);
tstruct = gr.Tabls[0];
Assert.AreEqual("Tabl", tstruct.TableName);
Assert.AreEqual(0, tstruct.Level);
Assert.IsNotNull(tstruct.Parent);
Assert.IsNotNull(tstruct.Child);
Assert.AreEqual(11, tstruct.Fields.Count);
Assert.AreEqual(DataType.String, tstruct.Fields["Code"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["Num"]);
Assert.AreEqual(DataType.String, tstruct.Fields["NameField"]);
Assert.AreEqual(DataType.Boolean, tstruct.Fields["BoolField"]);
tstruct = gr.Tabls[1];
Assert.AreEqual("SubTabl", tstruct.TableName);
Assert.AreEqual(1, tstruct.Level);
Assert.IsNotNull(tstruct.Parent);
Assert.IsNotNull(tstruct.Child);
Assert.AreEqual(12, tstruct.Fields.Count);
Assert.AreEqual(DataType.String, tstruct.Fields["GenType"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["Num"]);
Assert.AreEqual(DataType.String, tstruct.Fields["StringSub"]);
Assert.AreEqual(DataType.Real, tstruct.Fields["RealSub"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["IntSub"]);
Assert.AreEqual(DataType.Time, tstruct.Fields["TimeSub"]);
tstruct = gr.Tabls[2];
Assert.AreEqual("SubSubTabl", tstruct.TableName);
Assert.AreEqual(2, tstruct.Level);
Assert.IsNotNull(tstruct.Parent);
Assert.IsNull(tstruct.Child);
Assert.AreEqual(12, tstruct.Fields.Count);
Assert.AreEqual(DataType.String, tstruct.Fields["Code"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["Id"]);
Assert.AreEqual(DataType.String, tstruct.Fields["StringString"]);
Assert.AreEqual(DataType.Real, tstruct.Fields["RealReal"]);
Assert.AreEqual(DataType.Boolean, tstruct.Fields["BoolBool"]);
tlist.AddDbStructs(db);
Assert.AreEqual(2, tlist.Structs.Count);
Assert.AreEqual(0, tlist.Tabls.Count);
gr = tlist.Structs["VTZTZ"];
Assert.AreEqual("VTZTZ", gr.Code);
Assert.AreEqual(File("Struct"), gr.DbFile);
Assert.AreEqual(3, gr.Tabls.Count);
tstruct = gr.Tabls[-1];
Assert.AreEqual(-1, tstruct.Level);
Assert.IsNull(tstruct.Parent);
Assert.IsNotNull(tstruct.Child);
Assert.AreEqual(0, tstruct.Fields.Count);
tstruct = gr.Tabls[0];
Assert.AreEqual("Tbl_VTZTZ_Sub0", tstruct.TableName);
Assert.AreEqual(0, tstruct.Level);
Assert.IsNotNull(tstruct.Parent);
Assert.IsNotNull(tstruct.Child);
Assert.AreEqual(9, tstruct.Fields.Count);
Assert.AreEqual(DataType.String, tstruct.Fields["Code"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["Num"]);
Assert.AreEqual(DataType.String, tstruct.Fields["NameVTZ"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["SysNumVTZ"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["IdUnitVTZ"]);
tstruct = gr.Tabls[1];
Assert.AreEqual("Tbl_VTZTZ_Sub1", tstruct.TableName);
Assert.AreEqual(1, tstruct.Level);
Assert.IsNotNull(tstruct.Parent);
Assert.IsNull(tstruct.Child);
Assert.AreEqual(9, tstruct.Fields.Count);
Assert.AreEqual(DataType.String, tstruct.Fields["Code"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["ParentId"]);
Assert.AreEqual(DataType.String, tstruct.Fields["NameTZ"]);
Assert.AreEqual(DataType.Integer, tstruct.Fields["SysNumTZ"]);
Assert.AreEqual(DataType.String, tstruct.Fields["UnitTypeTZ"]);
}
}
private TablRow[] SelectRows(GenKeeper keeper, TablsList tabls, string formula)
{
return(SelectRowsS(keeper, tabls, formula).Cast <TablRow>().ToArray());
}
