private async Task executeTestAsync()
{
using (FileLog l = new FileLog("MdbContextTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
MdbContextOptions.GetOptions().CommandTimeout = 120;
using (var ctx = new MdbContext(_cn))
{
l.Debug("Test 1 Start ");
int i = 0;
string sql = @"Create Table TestTable(
ID uniqueidentifier not null primary key,
Name varchar(128) not null,
DateOper datetime not null,
Notes varchar(256) null,
Handle int not null)" ;
i = await ctx.ExecuteAsync(sql);
l.Debug($"Test 1 Finish rows result {i}");
l.Debug("Test 2 Start ");
sql = @"Insert Into TestTable (ID, Name, DateOper, Handle)
Values(@ID, @Name, @DateOper, @Handle)" ;
i = 0;
for (; i < 1000; i++)
{
await ctx.ExecuteAsync(sql,
new MdbParameter("@ID", Guid.NewGuid()),
new MdbParameter("@Name", "Тестовая строка № " + i.ToString()),
new MdbParameter("@DateOper", vbo.Date().AddDays(i - 1000)),
new MdbParameter("@Handle", i) { NullIfEmpty = false });;
}
l.Debug($"Test 2 Finish rows result {i}");
l.Debug("Test 3 Start ");
i = 0;
using (var dr = await ctx.GetReaderAsync("Select * From TestTable Order By Handle"))
{
for (; dr.Read(); i++)
{
l.Debug(dr.GetRowJSON());
}
}
l.Debug($"Test 3 Finish rows result {i}");
l.Debug("Test 4 Start ");
sql = "Drop Table TestTable";
i = await ctx.ExecuteAsync(sql);
l.Debug($"Test 4 Finish rows result {i}");
}
}
}
private static async Task RecreateSchemaAsync(MdbContext mdb, SQLStatementWriter sb, JMXSchema schema, JMXSchema fromDbSchema)
{
int recCount = await mdb.ExecuteAsync <int>($"select count(*) from {fromDbSchema.DbObjectName}");
foreach (var fk in fromDbSchema.ParentRelations)
{
sb.WriteDropParentRelationStatement(fk);
}
foreach (var fk in fromDbSchema.ForeignKeys)
{
sb.WriteDropFKStatement(fk, fromDbSchema);
}
string tmpTableName = fromDbSchema.DbObjectName.ObjectName + "_" + DateTime.Now.Subtract(vbo.Date()).Seconds.ToString();
if (recCount > 0)
{
sb.WriteRenameTableStatement(tmpTableName, fromDbSchema);
}
else
{
sb.WriteDropTableStatement(null, fromDbSchema);
}
sb.WriteCreateTableStatements(schema);
if (recCount > 0)
{
sb.WriteInsertRowsStatement(tmpTableName, schema);
sb.WriteDropTableStatement(tmpTableName, fromDbSchema);
}
sb.WriteCreatePKStatement(schema);
foreach (var att in schema.Attributes)
{
sb.WriteCreateConstraintStatement(att, schema);
}
foreach (var index in schema.Indexes)
{
sb.WriteCreateIndexStatement(index, schema);
}
foreach (var fk in schema.ForeignKeys)
{
sb.WriteCreateFKStatement(fk, schema);
}
/// Need test
foreach (var fk in fromDbSchema.ParentRelations)
{
sb.WriteCreateParentRelationStatement(fk);
}
}
private async Task SaveSchemaTestAsyncNew()
{
using (MdbContext mdb = new MdbContext(_ci))
{
JMXFactory f = JMXFactory.Create(_services, mdb);
var stor = f.CreateJMXRepo();
foreach (var s in GetTestSchemas())
{
await stor.SaveSchemaAsync(s);
}
}
}
private async Task SyncSchemaTestAsyncNew()
{
using (MdbContext mdb = new MdbContext(_cn))
{
JMXFactory f = JMXFactory.Create(_services, mdb);
var stor = f.CreateJMXBalance();
foreach (string s in GetTestNames())
{
await stor.SyncObjectSchemaAsync(s);
}
}
}
public async Task <DataPackage> InvokeAsync(ActionInfo ai, DataPackage dp)
{
DateTime date = (DateTime)dp["@Date"];
string branchID = (string)dp["@BranchID"];
string dealType = (string)dp["@DealType"];
int reCalc = (int)dp["@ReCalc"];
var ctx = ai.GetContext();
var cs = ctx.Services
.GetRequiredService <IConfiguration>()
.GetSection($"connectionStrings:{ctx.ConnectionName}").Get <ConnectInfo>();
string[] filials = GetParamListData(ai, "@BranchID", branchID, "0");
string[] dealTypes = GetParamListData(ai, "@DealType", dealType, "Все");
var pipe = ctx.Services
.GetRequiredService <PipeQueue>();
StringBuilder sb = new StringBuilder();
foreach (var filial in filials)
{
foreach (var dtype in dealTypes)
{
using (MdbContext mdb = new MdbContext(cs))
{
try
{
await mdb.ExecuteAsync($@"
exec workdb..mib_msfo_dv_calc
@Date = '{date:yyyyMMdd}'
,@BranchID = {filial}
,@DealType = '{dtype}'
,@ReCalc = {reCalc}" );
string result = $"Success mib_msfo_dv_calc {date} filial={filial} deal type={dtype}";
pipe.Write(ctx, result);
sb.AppendLine(result);
}
catch (Exception ex)
{
string message = $"{LogLevels.Error} {ex.Message}\n{ex.StackTrace}";
pipe.Write(ctx, message);
sb.AppendLine(message);
}
}
}
}
return(ai.GetOutputParamTable()
.AddNew()
.SetValue("@Result", sb.ToString())
.Update());
}
public MdbContextTest()
{
_configuration = new ConfigurationBuilder()
.AddJsonFile("config.json", optional: false, reloadOnChange: true)
.Build();
FileLogSettings.Default.Filter = (s, i) => i >= LogLevels.Debug;
var cs = _configuration.GetSection($"connectionStrings:{connection_name}");
_providerName = (string)cs.GetValue <string>("providerName");
_cn = MdbContext.CreateConnectionString(_providerName,
(string)cs.GetValue <string>("connectionString"));
}
public async Task <JMXSchema> SyncSchemaAsync(string objectName)
{
JMXObjectName name = objectName;
using (var mdb = await MdbContext.CreateMdbContextAsync(_cn).ConfigureAwait(false))
{
var schema = await _syncronizer.SyncSchemaAsync(mdb, name.AreaName, name.ObjectName).ConfigureAwait(false);
lock (objLock)
_schemaCache[schema.ObjectName] = schema;
return(schema);
}
}
private static async Task NormalizeDetailsAsync(MdbContext mdb, JMXSchema schema)
{
foreach (var att in schema.Attributes.Where(a => a.DataType == MdbType.@object))
{
if (att.ObjectSchema == null)
{
//For an object type attribute, you must specify a schema
throw new InvalidOperationException(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_2);
}
att.ObjectSchema = await NormalizeSchemaAsync(mdb, att.ObjectSchema);
att.ServerDataType = "varchar";
att.DataSize = new JMXDataSize(1);
att.FieldName = $"{JMXFactory.DETAIL_FIELD_PREFIX}{att.ObjectSchema.DbObjectName.AreaName}_{att.ObjectSchema.DbObjectName.ObjectName}";
//check indexes fo FK
if (!att.ObjectSchema.ForeignKeys.Any(fk => fk.RefDbObjectName.AreaName == schema.DbObjectName.AreaName &&
fk.RefDbObjectName.ObjectName == schema.DbObjectName.ObjectName))
{
var fk = new JMXForeignKey($"FK_{att.ObjectSchema.DbObjectName.AreaName}_{att.ObjectSchema.DbObjectName.ObjectName}_{schema.DbObjectName.ObjectName}")
{
RefDbObjectName = schema.DbObjectName.ToString(),
RefObjectName = schema.ObjectName.ToString()
};
foreach (var m in schema.PrimaryKey.KeyMembers)
{
string fieldName = $"{schema.ObjectName}{m.FieldName}";
if (!att.ObjectSchema.Attributes.Any(a => a.FieldName == fieldName))
{
var refAtt = schema.Attributes.FirstOrDefault(a => a.FieldName == m.FieldName);
var newAtt = new JMXAttribute(fieldName)
{
DataType = refAtt.DataType,
ServerDataType = refAtt.ServerDataType,
Required = true,
FieldName = fieldName,
IsFK = true,
DataSize = refAtt.DataSize
};
att.ObjectSchema.Attributes.Add(newAtt);
}
}
//check for exists attribute $"{schema.ObjectName}{m.FieldName}" in att.ObjectSchema
fk.AddKeyMember(schema.PrimaryKey.KeyMembers.Select(m => $"{schema.ObjectName}{m.FieldName}").ToArray());
fk.AddRefKeyMember(schema.PrimaryKey.KeyMembers.Select(m => m.FieldName).ToArray());
att.ObjectSchema.ForeignKeys.Add(fk);
}
}
}
private static void SelectTestTable(MdbContext ctx, FileLog l)
{
l.Debug("Select Test Table Start");
int i = 0;
using (var dr = ctx.GetReader("Select * From TestTable Order By Handle"))
{
for (; dr.Read(); i++)
{
l.Debug(dr.GetRowJSON());
}
}
l.Debug($"Select Test Table Finish rows result {i}");
}
static async Task selectTestTableAsync(MdbContext ctx, FileLogger l)
{
l.Debug("Select Test Table Start");
int i = 0;
using (var dr = await ctx.GetReaderAsync("Select * From TestTable Order By Handle"))
{
for (; dr.Read(); i++)
{
l.Debug(dr.GetRowJSON());
}
}
l.Debug($"Select Test Table Finish rows result {i}");
}
/// <summary>
/// !!! Add to GetTableSchema detail references as attributes for cascade delete FK
/// </summary>
/// <param name="sb"></param>
/// <param name="schema"></param>
/// <param name="fromDbSchema"></param>
/// <returns></returns>
private async Task CompareSchemasStatementsAsync(SQLStatementWriter sb, JMXSchema schema, JMXSchema fromDbSchema)
{
MdbContext mdb = Factory.GetMdbContext();
bool recreate = false;
foreach (var att in fromDbSchema.Attributes.Where(a => a.FieldName.StartsWith(JMXFactory.DETAIL_FIELD_PREFIX)))
{
if (!schema.Attributes.Any(a => a.FieldName == att.FieldName))
{
string[] names = att.FieldName.Split('_');
var schemaFromDb = await GetObjectSchemaAsync(new JMXObjectName(names[1], names[2]).ToString());
if (schemaFromDb != null)
{
await WriteDropStatementsAsync(sb, schemaFromDb);
}
}
}
recreate = CompareAttributes(sb, schema, fromDbSchema);
if (!recreate)
{
recreate = ComparePK(sb, schema, fromDbSchema);
}
if (!recreate)
{
CompareIndexes(sb, schema, fromDbSchema);
CompareFK(sb, schema, fromDbSchema);
}
else
{
await RecreateSchemaAsync(mdb, sb, schema, fromDbSchema);
}
foreach (var att in schema.Attributes.Where(a => a.DataType == MdbType.@object))
{
var schemaFromDb = await GetObjectSchemaAsync(att.ObjectSchema.DbObjectName.ToString());
if (schemaFromDb != null)
{
await CompareSchemasStatementsAsync(sb, att.ObjectSchema, schemaFromDb);
}
else
{
sb.WriteCreateNewTableStatements(att.ObjectSchema);
}
}
}
static void createTestTable(MdbContext ctx, FileLogger l)
{
l.Debug("Create Test Table Start");
int i = 0;
string sql = @"Create Table TestTable(
ID uniqueidentifier not null primary key,
Name varchar(128) not null,
DateOper datetime not null,
Notes varchar(256) null,
Handle int not null)" ;
ctx.BeginTransaction();
i = ctx.Execute(sql);
ctx.Commit();
}
public static JMXFactory Create(IServiceProvider services, MdbContext workMdbContext)
{
if (_schemaFactory == null)
{
var mdbFactory = services.GetRequiredService <IMdbContextFactory>();
var sysCatMdb = mdbFactory.GetContext(Strings.SysCatConnection);
var schemaFactory = CreateFactoryFromMdbContext(services, sysCatMdb);
if (_schemaFactory == null)
{
lock (obj4Lock)
_schemaFactory = schemaFactory;
}
}
return(CreateFactoryFromMdbContext(services, workMdbContext));
}
private async Task WriteDropStatementsAsync(SQLStatementWriter sb, JMXSchema fromDbSchema)
{
MdbContext mdb = Factory.GetMdbContext();
foreach (var att in fromDbSchema.Attributes.Where(a => a.FieldName.StartsWith(JMXFactory.DETAIL_FIELD_PREFIX)))
{
string[] names = att.FieldName.Split('_');
var schemaFromDb = await GetObjectSchemaAsync(new JMXObjectName(names[1], names[2]).ToString());
if (schemaFromDb != null)
{
await WriteDropStatementsAsync(sb, schemaFromDb);
}
}
sb.WriteDropStatements(fromDbSchema);
}
private static async Task CreateTestTableAsync(MdbContext ctx, FileLog l)
{
l.Debug("Create Test Table Start");
int i = 0;
string sql = @"Create Table TestTable(
ID uniqueidentifier not null primary key,
Name varchar(128) not null,
DateOper datetime not null,
Notes varchar(256) null,
Handle int not null)" ;
await ctx.BeginTransactionAsync();
i = await ctx.ExecuteAsync(sql);
await ctx.CommitAsync();
}
private void CreateFactorySpeedGTest()
{
var _configuration = Program.GetServices().GetRequiredService <IConfiguration>();
var workConnectInfo = _configuration.GetSection($"connectionStrings:Test").Get <ConnectInfo>();
_logger.LogDebug("Start speed test for ApplicationContext.CreateJMXFactory");
for (int i = 0; i < 10000; i++)
{
using (MdbContext workDb = new MdbContext(workConnectInfo))
{
_ = JMXFactory.Create(_services, workDb);
}
}
_logger.LogDebug("End speed test for ApplicationContext.CreateJMXFactory");
}
public User GetUser(string userId)
{
var context = new MdbContext();
var user = context.Users.Find(u => u.UserId == userId).FirstOrDefault();
if (user == null)
{
throw new Exception("User is not registered.");
}
return(new User
{
Name = user.Name,
Email = user.Email,
UserId = user.UserId,
IsAuthenticated = true
});
}
private static async Task CreateDbSchemaAsync(MdbContext mdb, ILogger log)
{
try
{
await mdb.BeginTransactionAsync();
var scripts = SQLite.CreateSchemaObjects_12.Split(new string[] { "--go", "--GO" },
StringSplitOptions.RemoveEmptyEntries);
foreach (string statement in scripts)
{
await mdb.ExecuteAsync(statement);
}
log.LogDebug($"Schema SysCat was created in database {mdb.DbName}");
log.LogDebug("Schema tables SysCat.SysAreas and SysCat.SysSchemas was created in SysCat Schema");
string owner = await GetDefaultDbSchemaAsync(mdb);
long id = await mdb.ExecuteAsync <long>(SQLite.AddSysAreas,
new MdbParameter("@SchemaName", owner),
new MdbParameter("@SchemaOwner", owner),
new MdbParameter("@SchemaVersion", schema_version),
new MdbParameter("@SchemaConfig", "") { NullIfEmpty = true },
new MdbParameter("@IsDefault", 1),
new MdbParameter("@UpdateTime", DateTime.Now),
new MdbParameter("@DateBegin", DateTime.Now.Date),
new MdbParameter("@DateEnd", DateTime.MinValue) { NullIfEmpty = true });
id = await mdb.ExecuteAsync <long>(SQLite.AddSysAreas,
new MdbParameter("@SchemaName", "SysCat"),
new MdbParameter("@SchemaOwner", owner),
new MdbParameter("@SchemaVersion", schema_version),
new MdbParameter("@SchemaConfig", "") { NullIfEmpty = true },
new MdbParameter("@IsDefault", 1),
new MdbParameter("@UpdateTime", DateTime.Now),
new MdbParameter("@DateBegin", DateTime.Now.Date),
new MdbParameter("@DateEnd", DateTime.MinValue) { NullIfEmpty = true });
await mdb.CommitAsync();
}
catch (Exception e)
{
mdb.RollBack();
log.LogError($"CreateSchema error: {e.Message}");
throw;
}
}
public static async Task <string> GetSqlVersion(MdbContext mdb)
{
if (_sqlVersion.IsEmpty())
{
_sqlVersion = await mdb.ExecuteAsync <string>(SQLite.SQLVersion);
if (_sqlVersion.IsEmpty())
{
_sqlVersion = "3";
}
else
{
_sqlVersion = _sqlVersion.GetToken(0, ".");
}
}
return(_sqlVersion);
}
public void GetFactoryTest()
{
using (FileLog l = new FileLog("DBProviderFactoryTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
l.Debug("SpeedTest 1 Start ");
DbProviderFactory f = null;
int i = 0;
for (i = 0; i < 1000000; i++)
{
//f = ObjectFactories.GetFactory<DbProviderFactory>("System.Data.SqlClient");
f = MdbContext.GetFactory("System.Data.SqlClient");
}
l.Debug($"SpeedTest 1 Finish {i} count result {f}");
l.Debug("SpeedTest 2 Start ");
f = null;
for (i = 0; i < 1000000; i++)
{
f = MdbContext.GetFactory("System.Data.SQLite");
}
l.Debug($"SpeedTest 2 Finish {i} count result {f}");
//ApplicationContext.Services.AddFromAssembly<DbProviderFactory>(ServiceLifetime.Singleton,
// (s, t) => t.CreateInstance2<DbProviderFactory>());
//l.Debug("GetFactoryProviderNames:");
//foreach (string s in ObjectFactories.GetFactoryNames<DbProviderFactory>())
//{
// l.Debug(s);
//}
//Retrieve the installed providers and factories.
DataTable table = System.Data.Common.DbProviderFactories.GetFactoryClasses();
// Display each row and column value.
foreach (DataRow row in table.Rows)
{
foreach (DataColumn column in table.Columns)
{
l.Debug(row[column]);
}
}
}
}
public void GetSysCatReadersTest()
{
using (FileLog l = new FileLog("MdbContextTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
MdbContextOptions.GetOptions().CommandTimeout = 120;
using (var ctx = new MdbContext(_syscat))
{
l.Debug("Test 1 Start ");
int i = 0;
var drs = ctx.GetReaders(@"
select u.ID
,u.StructuralUnitID
,u.AccessLevelID
,u.UserName
,COALESCE(u.DomainName, '') as DomainName
,COALESCE(u.PersonID, 0) as PersonID
,COALESCE(u.Name, '') as Name
,COALESCE(u.JData, '') as JData
from Users u
where u.UserName LIKE '{0}';
select
Upper(r.RoleName) as RoleName
from Users u
inner join Users2Roles ur on u.ID = ur.UserID
inner join Roles r on r.ID = ur.RoleID
where u.UserName LIKE '{0}'" .ToFormat(@"DESKTOP-14MM2MF\sergey")
);
foreach (var dr in drs)
{
using (dr)
{
for (; dr.Read(); i++)
{
l.Debug(dr.GetRowJSON());
}
}
}
l.Debug($"Test 1 Finish rows result {i}");
}
}
}
public async Task <DataPackage> InvokeAsync(ActionInfo ai, DataPackage dp)
{
string objectName = (string)dp["@ObjectName"];
long[] ids = ((string)dp["@IDs"])
.Split(new char[] { ',', ';' })
.Select(s => s.ToLongOrDefault())
.ToArray();
var ctx = ai.GetContext();
var cs = ctx.Services
.GetRequiredService <IConfiguration>()
.GetSection($"connectionStrings:{ctx.ConnectionName}").Get <ConnectInfo>();
var pipe = ctx.Services
.GetRequiredService <PipeQueue>();
StringBuilder sb = new StringBuilder();
foreach (long i in ids)
{
using (MdbContext mdb = new MdbContext(cs))
{
try
{
string result = await mdb.ExecuteAsync <string>($@"
select 'Session ID = ' + cast(@@SPID as varchar(10))
+ ' User Name = ' + '{ctx.UserName}'
+ ' Connection Name = ' + '{ctx.ConnectionName}'
+ ' Param Value = ' + '{i}'" );
pipe.Write(ctx, result);
sb.AppendLine(result);
}
catch (Exception ex)
{
string message = $"{LogLevels.Error} {ex.Message}\n{ex.StackTrace}";
}
}
}
return(ai.GetOutputParamTable()
.AddNew()
.SetValue("@Result", sb.ToString())
.Update());
}
public void createContextTest()
{
using (FileLogger l = new FileLogger("MdbContextTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
Type t = null;
l.Debug("SpeedTest 1 Start ");
int i = 0;
for (i = 0; i < 1000000; i++)
{
using (var ctx = new MdbContext(_cn))
{
}
}
l.Debug($"SpeedTest 1 Finish {i} count result {t}");
}
}
public void GetReaderSpeedTest()
{
using (FileLogger l = new FileLogger("MdbContextTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
DateTime t = DateTime.MinValue;
//Caching pool
int i = 0;
for (i = 0; i < 100; i++)
{
using (var ctx = new MdbContext(_cn))
{
}
}
using (var ctx = new MdbContext(_cn))
{
l.Debug("SpeedTest 1 Start ");
MdbContextOptions.GetOptions().CommandTimeout = 120;
for (i = 0; i < 1000; i++)
{
using (var dr = ctx.GetReader("Select * From PayDocs Where Handle = @handle",
new MdbParameter("@handle", 3999758)))
{
dr.Read();
}
}
l.Debug($"SpeedTest 1 Finish {i} count result {i}");
l.Debug("SpeedTest 2 Start ");
for (i = 0; i < 1000; i++)
{
using (var dr = ctx.GetReader("Select * From PayDocs Where Handle = @handle",
"@handle", 3999758))
{
dr.Read();
}
}
l.Debug($"SpeedTest 2 Finish {i} count result {i}");
}
}
}
private static async Task <string> GetSqlVersion(MdbContext mdb)
{
int mdbHash = mdb.MdbHash();
if (!_versions.TryGetValue(mdbHash, out string sqlVersion))
{
sqlVersion = await mdb.ExecuteAsync <string>(SqlServer.SQLVersion);
if (sqlVersion.IsEmpty())
{
sqlVersion = "10";
}
else
{
sqlVersion = sqlVersion.GetToken(0, ".");
}
_versions.Add(mdbHash, sqlVersion);
}
return(sqlVersion);
}
private async Task CreateDbSchemaAsync()
{
MdbContext mdb = Factory.GetMdbContext();
try
{
await mdb.BeginTransactionAsync();
var scripts = (await SqlServerHelper.IsSql17(mdb)) ?
SqlServer.CreateSchemaObjects.Split(new string[] { "--go", "--GO" },
StringSplitOptions.RemoveEmptyEntries) :
SqlServer.CreateSchemaObjects_12.Split(new string[] { "--go", "--GO" },
StringSplitOptions.RemoveEmptyEntries);
foreach (string statement in scripts)
{
await mdb.ExecuteAsync(statement);
}
Logger.LogDebug($"Schema SysCat was created in database {mdb.DbName}");
Logger.LogDebug("Schema tables SysCat.SysAreas and SysCat.SysSchemas was created in SysCat Schema");
string owner = await GetDefaultDbSchemaAsync();
int id = await mdb.ExecuteAsync <int>(SqlServer.AddSysAreas,
new MdbParameter("@SchemaName", owner),
new MdbParameter("@SchemaOwner", owner),
new MdbParameter("@SchemaVersion", schema_version));
id = await mdb.ExecuteAsync <int>(SqlServer.AddSysAreas,
new MdbParameter("@SchemaName", "SysCat"),
new MdbParameter("@SchemaOwner", owner),
new MdbParameter("@SchemaVersion", schema_version));
await mdb.CommitAsync();
}
catch (Exception e)
{
mdb.RollBack();
Logger.LogError($"CreateSchema error: {e.Message}");
throw;
}
}
static async Task insertTestTableAsync(MdbContext ctx, FileLogger l)
{
l.Debug("Insert Test Table Start");
string sql = @"Insert Into TestTable (ID, Name, DateOper, Handle)
Values(@ID, @Name, @DateOper, @Handle)" ;
await ctx.BeginTransactionAsync();
int i = 0;
for (; i < 100; i++)
{
await ctx.ExecuteAsync(sql,
new MdbParameter("@ID", Guid.NewGuid()),
new MdbParameter("@Name", "Тестовая строка № " + i.ToString()),
new MdbParameter("@DateOper", vbo.Date().AddDays(i - 1000)),
new MdbParameter("@Handle", i) { NullIfEmpty = false });;
}
await ctx.CommitAsync();
l.Debug($"Insert Test Table Finish rows result {i}");
}
public async Task <JMXSchema> GetSchemaAsync(string objectName)
{
JMXObjectName name = objectName;
if (_schemaCache.TryGetValue(name, out JMXSchema schema))
{
schema.SchemaProvider = this;
return(schema);
}
using (var mdb = await MdbContext.CreateMdbContextAsync(_cn).ConfigureAwait(false))
{
schema = await _syncronizer.GetSchemaAsync(mdb, name.AreaName, name.ObjectName).ConfigureAwait(false);
lock (objLock)
{
if (!_schemaCache.ContainsKey(name))
{
_schemaCache.Add(name, schema);
}
}
}
return(schema);
}
private static async Task DropDbSchemaAsync(MdbContext mdb, ILogger log)
{
var test = await mdb.ExecuteAsync <string>(SQLite.TestSchema);
if (!test.IsEmpty())
{
try
{
await mdb.ExecuteAsync(SQLite.DropSchema);
log.LogDebug($"Schema SysCat was deleted from database {mdb.DbName}");
}
catch (Exception e)
{
log.LogError($"Delete Schema error: {e.Message}");
throw;
}
}
else
{
log.LogDebug($"Schema SysCat not exists in database {mdb.DbName}");
}
}
private async Task DropSchemaAsync(string objectName)
{
MdbContext mdb = Factory.GetMdbContext();
var schema = await _schemaRepo.GetSchemaAsync(objectName);
var schemaFromDb = await GetObjectSchemaAsync(schema.DbObjectName.ToString());
string[] sqlList;
if (schemaFromDb == null)
{
sqlList = Array.Empty <string>();
}
else
{
sqlList = await DropSchemaStatementsAsync(schemaFromDb);
}
if (sqlList.Length > 0)
{
await mdb.BeginTransactionAsync();
try
{
foreach (var sql in sqlList)
{
Logger.LogDebug(sql);
await mdb.ExecuteAsync(sql);
}
await mdb.CommitAsync();
}
catch
{
mdb.RollBack();
throw;
}
}
}
public ManageController()
{
db = new MdbContext();
manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
}
