protected BaseFunctions()
{
var factory = new MomErrFactory(ErrSourceCode, MomErrType.Calc);
factory.AddGoodDescr(0);
ErrPool = new MomErrPool(factory);
using (var rec = new AdoReader(ItStatic.InfoTaskDir() + @"General\General.accdb",
"SELECT FunctionsOverloads.*, Functions.Name, Functions.Synonym, Functions.Code, Functions.CalcType FROM Functions INNER JOIN FunctionsOverloads ON Functions.Id = FunctionsOverloads.FunctionId " +
"WHERE " + FunsWhereCondition + " ORDER BY FunctionsOverloads.FunctionId, FunctionsOverloads.RunNumber"))
while (rec.Read())
{
string name = rec.GetString("Name");
string synonym = rec.GetString("Synonym");
if (!synonym.IsEmpty())
{
name += " (" + synonym + ")";
}
string code = (rec.GetString("Code") ?? (synonym ?? name)) + "_";
for (int i = 1; i <= 9 && rec.GetString("Operand" + i) != null; i++)
{
code += rec.GetString("Operand" + i).ToDataType().ToLetter();
}
for (int i = 1; i <= 2 && rec.GetString("More" + i) != null; i++)
{
code += rec.GetString("More" + i).ToDataType().ToLetter();
}
var errNum = rec.GetInt("IdOverload") * 10;
var ftype = rec.GetString("CalcType");
Funs.Add(code, CreateFun(code, ftype, errNum));
factory.AddDescr(errNum, "Недопустимые параметры функции " + name);
}
}
public void TestAddUser()
{
Location newloc = new Location();
AdoReader newreader = new AdoReader();
Assert.IsFalse(newreader.AddUser("Jacob", "dickbutt") == true);
}
//Получение времени архива ПТК
protected override TimeInterval GetTimeProvider()
{
using (var rec = new AdoReader(Connection, "Exec RT_ARCHDATE"))
{
var beg = rec.GetTime(0);
var en = rec.GetTime(1);
return(beg.ToString() != "0:00:00"
? new TimeInterval(beg, en)
: TimeInterval.CreateDefault());
}
}
public void RecAccess()
{
var db = CopyDb("");
var file = File("");
var rec = new AdoReader(db, "SELECT * FROM Tabl");
Assert.IsNotNull(rec.DaoDb);
Assert.IsNotNull(rec.Reader);
Assert.AreEqual(DatabaseType.Access, rec.DatabaseType);
Assert.AreEqual(file, rec.DaoDb.File);
Assert.IsTrue(rec.HasRows);
Assert.AreEqual(5, rec.RecordCount("SELECT Count(*) FROM Tabl"));
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.Read());
Assert.IsTrue(rec.EOF);
rec.Dispose();
rec = new AdoReader(db, "SELECT * FROM EmptyTabl");
Assert.AreEqual(DatabaseType.Access, rec.DatabaseType);
Assert.AreEqual(file, rec.DaoDb.File);
Assert.IsFalse(rec.HasRows);
Assert.AreEqual(0, rec.RecordCount("SELECT Count(*) FROM EmptyTabl"));
Assert.IsTrue(rec.EOF);
Assert.IsFalse(rec.Read());
Assert.IsTrue(rec.EOF);
rec.Dispose();
rec = new AdoReader(db, "SELECT Tabl.IntField, Tabl.RealField, SubTabl.StringSubField FROM Tabl INNER JOIN SubTabl ON Tabl.Id = SubTabl.ParentId");
Assert.IsNotNull(rec.DaoDb);
Assert.IsNotNull(rec.Reader);
Assert.AreEqual(file, rec.DaoDb.File);
Assert.AreEqual(DatabaseType.Access, rec.DatabaseType);
Assert.IsTrue(rec.HasRows);
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.Read());
Assert.IsTrue(rec.EOF);
rec.Dispose();
}
public FunsChecker(FunsCheckType listType)
{
try
{
bool isGenerate = listType == FunsCheckType.Gen;
using (var db = new DaoDb(ItStatic.InfoTaskDir() + @"General\General.accdb"))
{
var funsId = new DicI <FunCompile>();
var where = " WHERE (Functions.IsCompile = True)" + (isGenerate ? "AND (Functions.IsGen = True) " : " ");
using (var rec = new AdoReader(db, "SELECT * FROM Functions" + where))
while (rec.Read())
{
var f = new FunCompile(rec);
funsId.Add(f.Id, f);
_funs.Add(f.Name, f);
if (!f.Synonym.IsEmpty())
{
_funs.Add(f.Synonym, f);
}
}
using (var rec = new AdoReader(db, "SELECT FunctionsOverloads.* FROM Functions INNER JOIN FunctionsOverloads ON Functions.Id = FunctionsOverloads.FunctionId "
+ where + "ORDER BY FunctionsOverloads.FunctionId, FunctionsOverloads.RunNumber"))
{
rec.Read();
while (!rec.EOF)
{
var id = rec.GetInt("FunctionId");
var fun = funsId[id];
while (rec.GetInt("FunctionId") == id)
{
fun.Overloads.Add(new FunOverload(fun, rec));
if (!rec.Read())
{
break;
}
}
}
}
using (var rec = new AdoReader(db, "SELECT * FROM ParamProps"))
while (rec.Read())
{
var dt = rec.GetString("DataType").ToDataType();
ParamProps.Add(rec.GetString("EnglishCode"), dt);
ParamProps.Add(rec.GetString("RussianCode"), dt);
}
}
}
catch (Exception ex)
{
ex.MessageError("Системная ошибка компилятора. Ошибка загрузки функций");
}
}
public void TestDatabaseGetInventory()
{
Location newloc = new Location();
AdoReader newreader = new AdoReader();
List <Pizza> newpizzalist = new List <Pizza>();
newpizzalist = newreader.GetInventory();
foreach (var item in newpizzalist)
{
newloc.AddInventory(item.GetName(), item.Getnumberof());
}
Assert.IsTrue(newloc.GetInventory().Count > 0);
}
public void DaoDbStatic()
{
var db = CopyDb("Static");
string file = File("Static");
string fileWrong = File("Static2");
string fileCopy = File("Copy");
string fileTmp = TestLib.TestRunDir + @"Libraries\TmpDaoStatic.accdb";
db.Dispose();
Assert.IsNull(db.Database);
Assert.IsNull(db.Connection);
Assert.IsTrue(DaoDb.Check(file, "DaoTest"));
Assert.IsTrue(DaoDb.Check(file, "DaoTest", new[] { "Tabl", "SubTabl", "EmptyTabl", "SysTabl", "SysSubTabl" }));
Assert.IsTrue(DaoDb.Check(file, new[] { "Tabl", "SubTabl", "EmptyTabl" }));
Assert.IsFalse(DaoDb.Check(fileWrong, "Fignia"));
Assert.IsFalse(DaoDb.Check(null, "Fignia"));
Assert.IsFalse(DaoDb.Check(fileWrong, "Fignia"));
Assert.IsFalse(DaoDb.Check(fileWrong, new[] { "Tabl" }));
Assert.IsFalse(DaoDb.Check(file, new[] { "Tabl", "SubTabl", "EmptyTabl1" }));
DaoDb.Compress(file, 10000000);
DaoDb.Compress(file, 10000);
Assert.IsTrue(new FileInfo(fileTmp).Exists);
Assert.IsTrue(DaoDb.FromTemplate(file, fileCopy, ReplaceByTemplate.Always));
Assert.IsFalse(DaoDb.FromTemplate(file, fileCopy, ReplaceByTemplate.IfNotExists));
Assert.IsFalse(DaoDb.FromTemplate(file, fileCopy, ReplaceByTemplate.IfNewVersion));
new FileInfo(fileCopy).Delete();
Assert.IsTrue(DaoDb.FromTemplate(file, fileCopy, ReplaceByTemplate.IfNotExists));
new FileInfo(fileCopy).Delete();
Assert.IsTrue(DaoDb.FromTemplate(file, fileCopy, ReplaceByTemplate.IfNewVersion));
Assert.IsTrue(new FileInfo(fileCopy).Exists);
DaoDb.Execute(file, "DELETE * FROM Tabl");
DaoDb.ExecuteAdo(file, "DELETE * FROM SysTabl");
using (var rec = new AdoReader(file, "SELECT * FROM Tabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new AdoReader(file, "SELECT * FROM SubTabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new DaoRec(file, "SysTabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new DaoRec(file, "SysSubTabl"))
Assert.IsFalse(rec.HasRows);
}
//Подготовка провайдера, чтение значений IDCHANNEL
protected override void PrepareProvider()
{
OutsId.Clear();
using (var rec = new AdoReader(SqlProps, "SELECT OBJECTS.NAME_OBJECT, DEVICES.NAME_DEVICE, LIB_CHANNELS.NAME_TYPE, LIB_CHANNELS.UNIT, CHANNELS.IDCHANNEL, LIB_CHANNELS.TABLE_NAME " +
"FROM CHANNELS INNER JOIN DEVICES ON CHANNELS.IDDEVICE = DEVICES.IDDEVICE INNER JOIN " +
"LIB_CHANNELS ON dbo.CHANNELS.IDTYPE_CHANNEL = dbo.LIB_CHANNELS.IDTYPE_CHANNEL INNER JOIN " +
"POINT_DEVICES ON dbo.DEVICES.IDDEVICE = dbo.POINT_DEVICES.IDDEVICE INNER JOIN " +
"POINT_CONNECTIONS ON dbo.POINT_DEVICES.IDPOINT_CONNECTION = dbo.POINT_CONNECTIONS.IDPOINT_CONNECTION INNER JOIN " +
"POINT_OBJ ON dbo.POINT_CONNECTIONS.IDPOINT_CONNECTION = dbo.POINT_OBJ.IDPOINT_CONNECTION INNER JOIN " +
"OBJECTS ON dbo.POINT_OBJ.IDOBJECT = dbo.OBJECTS.IDOBJECT"))
while (rec.Read())
{
string ocode = rec.GetString("NAME_OBJECT") + "." + rec.GetString("NAME_DEVICE") + "." + rec.GetString("NAME_TYPE");
var id = rec.GetInt("IDCHANNEL");
if (Outs.ContainsKey(ocode))
{
var ob = Outs[ocode];
ob.IdChannel = id;
OutsId.Add(id, ob);
}
}
}
//Запрос значений из Historian по списку выходов и интервалу
protected override IRecordRead QueryValues(IList <ListSourceOut> part, DateTime beg, DateTime en, bool isCut)
{
var sb = new StringBuilder("select ID, TIMESTAMP, TIME_NSEC, F_VALUE, RAW_VALUE, STS from PT_HF_HIST " + "where (");
bool isFirst = true;
foreach (OvationOut ob in part)
{
if (!isFirst)
{
sb.Append(" or ");
}
sb.Append("(ID=").Append(ob.Id).Append(")");
isFirst = false;
}
sb.Append(") and").Append(TimeCondition(beg, en));
var rec = new AdoReader(Connection, sb.ToString());
if (en.Subtract(beg).TotalMinutes > 59 && !rec.HasRows)
{
AddWarning("Значения из источника не получены", null, beg + " - " + en + "; " + part.First().Context + " и др.");
}
return(rec);
}
//Получение диапазона архива по блокам истории
protected override TimeInterval GetTimeProvider()
{
DateTime mind = Static.MaxDate, maxd = Static.MinDate;
using (var rec = new AdoReader(SqlProps, "SELECT FromDate, ToDate FROM v_HistoryBlock ORDER BY FromDate, ToDate DESC"))
while (rec.Read())
{
var fromd = rec.GetTime("FromDate");
var tod = rec.GetTime("ToDate");
if (fromd < mind)
{
mind = fromd;
}
if (maxd < tod)
{
maxd = tod;
}
}
if (mind == Static.MaxDate && maxd == Static.MinDate)
{
return(TimeInterval.CreateDefault());
}
return(new TimeInterval(mind, maxd));
}
public void DaoDbTest()
{
try { new DaoDb("hhh").ConnectDao(); }
catch (Exception ex) { Assert.AreEqual("Файл базы данных не найден", ex.Message); }
try { new DaoDb("hhh").ConnectAdo(); }
catch (Exception ex) { Assert.AreEqual("Файл базы данных не найден", ex.Message); }
var db = CopyDb("Common");
string file = File("Common");
db.ConnectDao();
Assert.AreEqual(file, db.File);
Assert.IsNull(db.Connection);
Assert.IsNotNull(db.Database);
Assert.AreEqual(file, db.Database.Name);
db.ConnectAdo();
Assert.IsNotNull(db.Connection);
Assert.IsNotNull(db.Database);
Assert.AreEqual(ConnectionState.Open, db.Connection.State);
db.Execute("DELETE * FROM Tabl");
Thread.Sleep(800);
db.ExecuteAdo("DELETE * FROM SysTabl");
using (var rec = new AdoReader(db, "SELECT * FROM Tabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new AdoReader(db, "SELECT * FROM SubTabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new DaoRec(db, "SysTabl"))
Assert.IsFalse(rec.HasRows);
using (var rec = new DaoRec(db, "SysSubTabl"))
Assert.IsFalse(rec.HasRows);
Assert.IsTrue(db.TableExists("SubTabl"));
Assert.IsFalse(db.TableExists("SubTabl2"));
Assert.IsTrue(db.ColumnExists("Tabl", "IntField"));
Assert.IsFalse(db.ColumnExists("SubTabl", "RealField"));
Assert.IsTrue(db.ColumnExists("SubTabl", "StringSubField"));
db.SetColumnBool("SubTabl", "BoolField");
Assert.IsTrue(db.ColumnExists("SubTabl", "BoolField"));
db.SetColumnBool("SubTabl", "BoolField");
Assert.IsTrue(db.ColumnExists("SubTabl", "BoolField"));
db.SetColumnLong("SubTabl", "IntSubField");
Assert.IsTrue(db.ColumnExists("SubTabl", "IntSubField"));
db.SetColumnLong("SubTabl", "IntSubField");
Assert.IsTrue(db.ColumnExists("SubTabl", "IntSubField"));
db.SetColumnDouble("SubTabl", "RealField", IndexModes.WithoutChange, 0);
Assert.IsTrue(db.ColumnExists("SubTabl", "RealField"));
db.SetColumnDouble("SubTabl", "RealField", IndexModes.WithoutChange, 0);
Assert.IsTrue(db.ColumnExists("SubTabl", "RealField"));
db.SetColumnString("SubTabl", "StringSubField", 30, IndexModes.EmptyIndex, "aaa", false, false);
Assert.IsTrue(db.ColumnExists("SubTabl", "StringSubField"));
db.SetColumnString("SubTabl", "StringSubField", 50, IndexModes.EmptyIndex, "aaa", false, false);
Assert.IsTrue(db.ColumnExists("SubTabl", "StringSubField"));
db.SetColumnMemo("SubTabl", "MemoField", "bbb");
Assert.IsTrue(db.ColumnExists("SubTabl", "MemoField"));
db.SetColumnMemo("SubTabl", "MemoField", "bbb");
Assert.IsTrue(db.ColumnExists("SubTabl", "MemoField"));
db.SetColumnDateTime("SubTabl", "TimeField");
Assert.IsTrue(db.ColumnExists("SubTabl", "TimeField"));
db.SetColumnDateTime("SubTabl", "TimeField");
Assert.IsTrue(db.ColumnExists("SubTabl", "TimeField"));
db.DeleteColumn("SubTabl", "TimeField");
db.DeleteColumn("SubTabl", "IntSubField");
db.Dispose();
Assert.IsFalse(db.ColumnExists("SubTabl", "TimeField"));
Assert.IsFalse(db.ColumnExists("SubTabl", "IntSubField"));
db.RenameTable("EmptyTabl", "SmallTabl");
Assert.IsTrue(db.TableExists("SmallTabl"));
db.AddTable("BigTabl", "SmallTabl");
db.Dispose();
Assert.IsTrue(db.TableExists("BigTabl"));
db.DeleteTable("SmallTabl");
db.DeleteTable("BigTabl");
Assert.IsFalse(db.TableExists("BigTabl"));
Assert.IsFalse(db.TableExists("SmallTabl"));
db.SetColumnIndex("Tabl", "StringField1", IndexModes.UniqueIndex);
db.SetColumnIndex("Tabl", "StringField2", IndexModes.CommonIndex);
db.SetColumnIndex("Tabl", "IntField", "RealField", false, IndexModes.UniqueIndex);
db.Dispose();
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
// connections
foreach (var connection in _process.Connections.Where(c => c.Provider.In(_ado)))
{
// Connection Factory
builder.Register <IConnectionFactory>(ctx => {
switch (connection.Provider)
{
case "sqlserver":
return(new SqlServerConnectionFactory(connection));
case "mysql":
return(new MySqlConnectionFactory(connection));
case "postgresql":
return(new PostgreSqlConnectionFactory(connection));
case "sqlite":
return(new SqLiteConnectionFactory(connection));
default:
return(new NullConnectionFactory());
}
}).Named <IConnectionFactory>(connection.Key).InstancePerLifetimeScope();
// Schema Reader
builder.Register <ISchemaReader>(ctx => {
var factory = ctx.ResolveNamed <IConnectionFactory>(connection.Key);
return(new AdoSchemaReader(ctx.ResolveNamed <IConnectionContext>(connection.Key), factory));
}).Named <ISchemaReader>(connection.Key);
}
//ISchemaReader
//IOutputController
//IRead (Process for Calculated Columns)
//IWrite (Process for Calculated Columns)
//IInitializer (Process)
// Per Entity
// IInputVersionDetector
// IRead (Input, per Entity)
// IOutputController
// -- ITakeAndReturnRows (for matching)
// -- IWriteMasterUpdateQuery (for updating)
// IUpdate
// IWrite
// IEntityDeleteHandler
// entitiy input
foreach (var entity in _process.Entities.Where(e => _process.Connections.First(c => c.Name == e.Connection).Provider.In(_ado)))
{
// INPUT READER
builder.Register <IRead>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", input.RowCapacity));
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputReader(
input,
input.InputFields,
ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key),
rowFactory
));
default:
return(new NullReader(input, false));
}
}).Named <IRead>(entity.Key);
// INPUT VERSION DETECTOR
builder.Register <IInputVersionDetector>(ctx => {
var input = ctx.ResolveNamed <InputContext>(entity.Key);
switch (input.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoInputVersionDetector(input, ctx.ResolveNamed <IConnectionFactory>(input.Connection.Key)));
default:
return(new NullVersionDetector());
}
}).Named <IInputVersionDetector>(entity.Key);
}
// entity output
if (_process.Output().Provider.In(_ado))
{
var calc = _process.ToCalculatedFieldsProcess();
// PROCESS OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.Resolve <OutputContext>();
if (_process.Mode != "init")
{
return(new NullOutputController());
}
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
return(new AdoStarController(output, new AdoStarViewCreator(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))));
default:
return(new NullOutputController());
}
}).As <IOutputController>();
// PROCESS CALCULATED READER
builder.Register <IRead>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext, new Incrementer(calcContext));
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
var capacity = outputContext.Entity.Fields.Count + outputContext.Entity.CalculatedFields.Count;
var rowFactory = new RowFactory(capacity, false, false);
return(new AdoStarParametersReader(outputContext, _process, cf, rowFactory));
}).As <IRead>();
// PROCESS CALCULATED FIELD WRITER
builder.Register <IWrite>(ctx => {
var calcContext = new PipelineContext(ctx.Resolve <IPipelineLogger>(), calc, calc.Entities.First());
var outputContext = new OutputContext(calcContext, new Incrementer(calcContext));
var cf = ctx.ResolveNamed <IConnectionFactory>(outputContext.Connection.Key);
return(new AdoCalculatedFieldUpdater(outputContext, _process, cf));
}).As <IWrite>();
// PROCESS INITIALIZER
builder.Register <IInitializer>(ctx => {
var output = ctx.Resolve <OutputContext>();
return(new AdoInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
}).As <IInitializer>();
// ENTITIES
foreach (var entity in _process.Entities)
{
// ENTITY OUTPUT CONTROLLER
builder.Register <IOutputController>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var initializer = _process.Mode == "init" ? (IAction) new AdoEntityInitializer(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)) : new NullInitializer();
return(new AdoOutputController(
output,
initializer,
ctx.ResolveNamed <IInputVersionDetector>(entity.Key),
new AdoOutputVersionDetector(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)),
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)
));
default:
return(new NullOutputController());
}
}).Named <IOutputController>(entity.Key);
// OUTPUT ROW MATCHER
builder.Register(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var rowFactory = ctx.ResolveNamed <IRowFactory>(entity.Key, new NamedParameter("capacity", output.GetAllEntityFields().Count()));
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "sqlite":
return(new TypedEntityMatchingKeysReader(new AdoEntityMatchingKeysReader(output, cf, rowFactory), output));
default:
return((ITakeAndReturnRows) new AdoEntityMatchingKeysReader(output, cf, rowFactory));
}
}).Named <ITakeAndReturnRows>(entity.Key);
// MASTER UPDATE QUERY
builder.Register <IWriteMasterUpdateQuery>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
var factory = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
switch (output.Connection.Provider)
{
case "mysql":
return(new MySqlUpdateMasterKeysQueryWriter(output, factory));
case "postgresql":
return(new PostgreSqlUpdateMasterKeysQueryWriter(output, factory));
default:
return(new SqlServerUpdateMasterKeysQueryWriter(output, factory));
}
}).Named <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys");
// UPDATER
builder.Register <IUpdate>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlserver":
return(new AdoMasterUpdater(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <IWriteMasterUpdateQuery>(entity.Key + "MasterKeys")
));
case "sqlite":
return(new AdoTwoPartMasterUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key)));
default:
return(new NullMasterUpdater());
}
}).Named <IUpdate>(entity.Key);
// WRITER
builder.Register <IWrite>(ctx => {
var output = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (output.Connection.Provider)
{
case "sqlserver":
return(new SqlServerWriter(
output,
ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key),
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityUpdater(output, ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key))
));
case "mysql":
case "postgresql":
case "sqlite":
var cf = ctx.ResolveNamed <IConnectionFactory>(output.Connection.Key);
return(new AdoEntityWriter(
output,
ctx.ResolveNamed <ITakeAndReturnRows>(entity.Key),
new AdoEntityInserter(output, cf),
new AdoEntityUpdater(output, cf)
));
default:
return(new NullWriter(output));
}
}).Named <IWrite>(entity.Key);
// DELETE HANDLER
if (entity.Delete)
{
builder.Register <IEntityDeleteHandler>(ctx => {
var context = ctx.ResolveNamed <IContext>(entity.Key);
var inputContext = ctx.ResolveNamed <InputContext>(entity.Key);
var rowCapacity = inputContext.Entity.GetPrimaryKey().Count();
var rowFactory = new RowFactory(rowCapacity, false, true);
IRead input = new NullReader(context);
var primaryKey = entity.GetPrimaryKey();
switch (inputContext.Connection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
input = new AdoReader(
inputContext,
primaryKey,
ctx.ResolveNamed <IConnectionFactory>(inputContext.Connection.Key),
rowFactory,
ReadFrom.Input
);
break;
}
IRead output = new NullReader(context);
IDelete deleter = new NullDeleter(context);
var outputConnection = _process.Output();
var outputContext = ctx.ResolveNamed <OutputContext>(entity.Key);
switch (outputConnection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
var ocf = ctx.ResolveNamed <IConnectionFactory>(outputConnection.Key);
output = new AdoReader(context, entity.GetPrimaryKey(), ocf, rowFactory, ReadFrom.Output);
deleter = new AdoDeleter(outputContext, ocf);
break;
}
var handler = new DefaultDeleteHandler(context, input, output, deleter);
// since the primary keys from the input may have been transformed into the output, you have to transform before comparing
// feels a lot like entity pipeline on just the primary keys... may look at consolidating
handler.Register(new DefaultTransform(context, entity.GetPrimaryKey().ToArray()));
handler.Register(TransformFactory.GetTransforms(ctx, _process, entity, primaryKey));
handler.Register(new StringTruncateTransfom(context, primaryKey));
return(new ParallelDeleteHandler(handler));
}).Named <IEntityDeleteHandler>(entity.Key);
}
}
}
}
public void RecAccessRead()
{
using (var rec = new AdoReader(CopyDb("Read"), "SELECT * FROM Tabl"))
{
Assert.IsTrue(rec.GetBool("BoolField"));
Assert.AreEqual(true, rec.GetBoolNull("BoolField"));
Assert.AreEqual(1, rec.GetInt("Id"));
Assert.AreEqual(1, rec.GetIntNull("Id"));
Assert.AreEqual(10, rec.GetInt("IntField"));
Assert.AreEqual(10, rec.GetIntNull("IntField"));
Assert.AreEqual(1.5, rec.GetDouble("RealField"));
Assert.AreEqual(1.5, rec.GetDoubleNull("RealField"));
Assert.AreEqual("Большой текст 1", rec.GetString("StringField1"));
Assert.AreEqual("Text", rec.GetString("StringField2"));
Assert.AreEqual(new DateTime(2016, 7, 1), rec.GetTime("TimeField"));
Assert.AreEqual(new DateTime(2016, 7, 1), rec.GetTimeNull("TimeField"));
Assert.AreEqual(1, rec.GetInt(0));
Assert.AreEqual(1, rec.GetIntNull(0));
Assert.AreEqual(10, rec.GetInt(1));
Assert.AreEqual(10, rec.GetIntNull(1));
Assert.AreEqual(1.5, rec.GetDouble(2));
Assert.AreEqual(1.5, rec.GetDoubleNull(2));
Assert.AreEqual("Большой текст 1", rec.GetString(3));
Assert.AreEqual("Text", rec.GetString(4));
Assert.AreEqual(true, rec.GetBool(5));
Assert.AreEqual(new DateTime(2016, 7, 1), rec.GetTime(6));
Assert.AreEqual(new DateTime(2016, 7, 1), rec.GetTimeNull(6));
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsFalse(rec.GetBool("BoolField"));
Assert.AreEqual(false, rec.GetBoolNull("BoolField"));
Assert.AreEqual(2, rec.GetInt("Id"));
Assert.AreEqual(2, rec.GetIntNull("Id"));
Assert.AreEqual(20, rec.GetInt("IntField"));
Assert.AreEqual(20, rec.GetIntNull("IntField"));
Assert.AreEqual(0, rec.GetDouble("RealField"));
Assert.AreEqual(null, rec.GetDoubleNull("RealField"));
Assert.AreEqual("Большой текст 2", rec.GetString("StringField1"));
Assert.AreEqual("null", rec.GetString("StringField2", "null"));
Assert.AreEqual(new DateTime(2016, 7, 2, 2, 3, 4), rec.GetTime("TimeField"));
Assert.AreEqual(new DateTime(2016, 7, 2, 2, 3, 4), rec.GetTimeNull("TimeField"));
Assert.AreEqual(2, rec.GetInt(0));
Assert.AreEqual(2, rec.GetIntNull(0));
Assert.AreEqual(20, rec.GetInt(1));
Assert.AreEqual(20, rec.GetIntNull(1));
Assert.AreEqual(0, rec.GetDouble(2));
Assert.AreEqual(null, rec.GetDoubleNull(2));
Assert.AreEqual("Большой текст 2", rec.GetString(3));
Assert.AreEqual("null", rec.GetString(4, "null"));
Assert.IsFalse(rec.GetBool(5));
Assert.AreEqual(false, rec.GetBoolNull(5));
Assert.AreEqual(new DateTime(2016, 7, 2, 2, 3, 4), rec.GetTime(6));
Assert.AreEqual(new DateTime(2016, 7, 2, 2, 3, 4), rec.GetTimeNull(6));
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.GetBool("BoolField"));
Assert.AreEqual(true, rec.GetBoolNull("BoolField"));
Assert.AreEqual(3, rec.GetInt("Id"));
Assert.AreEqual(3, rec.GetIntNull("Id"));
Assert.AreEqual(0, rec.GetInt("IntField"));
Assert.AreEqual(null, rec.GetIntNull("IntField"));
Assert.IsTrue(rec.IsNull("IntField"));
Assert.AreEqual(3.5, rec.GetDouble("RealField", 300));
Assert.AreEqual(3.5, rec.GetDoubleNull("RealField"));
Assert.IsFalse(rec.IsNull("RealField"));
Assert.AreEqual("Большой текст 3", rec.GetString("StringField1"));
Assert.AreEqual("Text3", rec.GetString("StringField2", "null"));
Assert.AreEqual(Static.MinDate, rec.GetTime("TimeField"));
Assert.AreEqual(null, rec.GetTimeNull("TimeField"));
Assert.AreEqual(3, rec.GetInt(0));
Assert.AreEqual(3, rec.GetIntNull(0));
Assert.AreEqual(0, rec.GetInt(1));
Assert.AreEqual(null, rec.GetIntNull(1));
Assert.IsTrue(rec.IsNull(1));
Assert.AreEqual(3.5, rec.GetDouble(2, 300));
Assert.AreEqual(3.5, rec.GetDoubleNull(2));
Assert.IsFalse(rec.IsNull(2));
Assert.AreEqual("Большой текст 3", rec.GetString(3));
Assert.AreEqual("Text3", rec.GetString(4, "null"));
Assert.IsTrue(rec.GetBool(5));
Assert.AreEqual(true, rec.GetBoolNull(5));
Assert.AreEqual(Static.MinDate, rec.GetTime(6));
Assert.AreEqual(null, rec.GetTimeNull(6));
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.GetBool("BoolField"));
Assert.AreEqual(true, rec.GetBoolNull("BoolField"));
Assert.AreEqual(5, rec.GetInt("Id"));
Assert.AreEqual(5, rec.GetIntNull("Id"));
Assert.AreEqual(50, rec.GetInt("IntField", 400));
Assert.AreEqual(50, rec.GetIntNull("IntField"));
Assert.AreEqual(5.5, rec.GetDouble("RealField"));
Assert.AreEqual(5.5, rec.GetDoubleNull("RealField"));
Assert.AreEqual("Большой текст 5", rec.GetString("StringField1"));
Assert.AreEqual(null, rec.GetString("StringField2"));
Assert.AreEqual(new DateTime(2016, 7, 5), rec.GetTime("TimeField"));
Assert.AreEqual(new DateTime(2016, 7, 5), rec.GetTimeNull("TimeField"));
Assert.IsNotNull(rec.Reader);
Assert.AreEqual(5, (int)rec.Reader["Id"]);
Assert.AreEqual(5.5, (double)rec.Reader["RealField"]);
Assert.AreEqual("Большой текст 5", (string)rec.Reader["StringField1"]);
Assert.IsFalse(rec.Read());
Exception exception = null;
try { Assert.IsTrue(rec.GetBool("BoolField")); }
catch (Exception ex) { exception = ex; }
Assert.IsNotNull(exception);
}
using (var rec = new AdoReader(new DaoDb(File("Read")),
"SELECT Tabl.Id, Tabl.IntField AS IntF, Tabl.RealField, SubTabl.StringSubField AS StringF " +
"FROM Tabl LEFT JOIN SubTabl ON Tabl.Id = SubTabl.ParentId ORDER BY Tabl.Id, SubTabl.StringSubField;"))
{
Assert.IsTrue(rec.Read());
Assert.AreEqual(1, rec.GetInt("Id"));
Assert.AreEqual(10, rec.GetInt("IntF"));
Assert.AreEqual(2, rec.GetInt("RealField"));
Assert.AreEqual(1.5, rec.GetDouble("RealField"));
Assert.AreEqual("1", rec.GetString("StringF"));
Assert.AreEqual(1, rec.GetInt(0));
Assert.AreEqual(10, rec.GetInt(1));
Assert.AreEqual(1.5, rec.GetDouble(2));
Assert.AreEqual("1", rec.GetString(3));
Assert.AreEqual(1, rec.GetIntNull(0));
Assert.AreEqual(10, rec.GetIntNull(1));
Assert.AreEqual(1.5, rec.GetDoubleNull(2));
Assert.IsTrue(rec.Read());
Assert.AreEqual(2, rec.GetInt("Id"));
Assert.AreEqual(20, rec.GetInt("IntF"));
Assert.AreEqual(0, rec.GetInt("RealField"));
Assert.AreEqual(0, rec.GetDouble("RealField"));
Assert.AreEqual("22", rec.GetString("StringF"));
Assert.IsTrue(rec.Read());
Assert.AreEqual(2, rec.GetInt("Id"));
Assert.AreEqual("2", rec.GetString("Id"));
Assert.AreEqual(20, rec.GetInt("IntF"));
Assert.AreEqual(0, rec.GetInt("RealField"));
Assert.AreEqual(null, rec.GetIntNull("RealField"));
Assert.AreEqual(0, rec.GetDouble("RealField"));
Assert.AreEqual(null, rec.GetDoubleNull("RealField"));
Assert.AreEqual("222", rec.GetString("StringF"));
Assert.IsTrue(rec.Read());
Assert.AreEqual(3, rec.GetInt("Id"));
Assert.AreEqual(0, rec.GetInt("IntF"));
Assert.AreEqual(4, rec.GetInt("RealField"));
Assert.AreEqual(3.5, rec.GetDouble("RealField"));
Assert.AreEqual("333", rec.GetString("StringF"));
Assert.IsFalse(rec.EOF);
Assert.IsTrue(rec.Read());
Assert.IsTrue(rec.Read());
Assert.AreEqual(40, rec.GetInt("IntF"));
Assert.AreEqual(null, rec.GetString("StringF"));
}
}
public void TestVerify()
{
AdoReader newreader = new AdoReader();
Assert.IsTrue(newreader.VerifyUserAccount("Jacob", "dickbutt"));
}
public void TestAddSale()
{
AdoReader newreader = new AdoReader();
Assert.IsTrue(newreader.AddSale(newreader.GetLocationID("Pizza Jacob, Fake Road"), newreader.GetInventoryID("PepperoniSmallPan"), 10, 100.00f, newreader.GetCustomerID("Jacob")));
}
