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)); }