private void SpeedGetHashCodeTest() { using (MdbContext mdb = new MdbContext(_ci)) { //string s1 = mdb.Execute<string>("SysCat.Get_TableSchema_xml", // new MdbParameter("@table_name", "dbo.OrderDetails")); //_logger.Debug(s1); //_logger.Debug(JMXSchema.ParseXml(s1).ToString()); //s1 = mdb.Execute<string>("SysCat.Get_TableSchema", // new MdbParameter("@table_name", "dbo.Orders")); //_logger.Debug(s1); //_logger.Debug("Start speed test for SysCat.Get_TableSchema_xml"); //for (int i = 0; i < 100; i++) //{ // s1 = mdb.Execute<string>("SysCat.Get_TableSchema_xml", // new MdbParameter("@table_name", "dbo.OrderDetails")); // var schema = JMXSchema.ParseXml(s1); //} //_logger.Debug("End speed test for SysCat.Get_TableSchema_xml"); _logger.LogDebug("Start speed test for SysCat.Get_TableSchema"); for (int i = 0; i < 100; i++) { var s1 = mdb.Execute <string>("SysCat.Get_TableSchema", new MdbParameter("@table_name", "dbo.OrderDetails")); var schema = JMXSchema.Parse(s1); } _logger.LogDebug("End speed test for SysCat.Get_TableSchema"); } }
public async Task <DataPackage> InvokeAsync(ActionInfo ai, DataPackage dp) { GetParameters(ai, dp); var ctx = ai.GetContext(); JMXFactory f = ctx.CreateJMXFactory(_connectionName); IJMXRepo repo = f.SchemaFactory.CreateJMXRepo(); using (SQLStatementWriter writer = f.CreateSQLStatementWriter()) { JMXSchema schema = await repo.GetSchemaAsync(_viewName); string body = writer.WriteSelectStatement( schema, _conditions.ToArray()) .ToString(); if (schema.DbObjectType == DbObjectTypes.Action) { ActionManager am = ctx.Services.GetRequiredService <ActionManager>(); return(await am.ExecuteAsync(am.GetActionInfo(body), dp)); } else { return(await f .GetMdbContext() .GetReaderAsync(body, CreateParameters(schema))); } } }
private static async Task NormalizeFKAsync(MdbContext mdb, JMXSchema schema) { //check indexes for FK!!!! foreach (var fk in schema.ForeignKeys) { if (fk.KeyName.IsEmpty()) { fk.KeyName = $"FK_{schema.DbObjectName.AreaName}_{schema.DbObjectName.ObjectName}_{fk.RefDbObjectName.ObjectName}"; } if (fk.RefObjectName.IsEmpty()) { JMXSchema refSchema = await GetSchemaAsync(mdb, fk.RefDbObjectName.AreaName, fk.RefDbObjectName.ObjectName); if (refSchema == null) { throw new ArgumentNullException("Property RefObjectName can't be empty"); } // set value, not ref fk.RefObjectName = refSchema.ObjectName.ToString(); } foreach (var member in fk.KeyMembers) { var att = schema.Attributes.FirstOrDefault(a => a.FieldName == member.FieldName); if (att == null) { //The FieldName specified in the foreign key is not in the attribute list throw new InvalidOperationException( string.Format(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_3, $"foreign key '{fk.KeyName}'")); } } } }
public async Task <JMXSchema> SaveSchemaAsync(JMXSchema schema) { using (var mdb = await MdbContext.CreateMdbContextAsync(_cn).ConfigureAwait(false)) { await _syncronizer.SaveSchemaAsync(mdb, schema).ConfigureAwait(false); } lock (objLock) _schemaCache[schema.ObjectName] = schema; foreach (var fk in schema.ForeignKeys) { if (fk.RefObjectName.IsEmpty()) { throw new ArgumentNullException("Property RefObjectName can't be empty"); } lock (objLock) { if (_parentRelations.ContainsKey(fk.RefObjectName)) { _parentRelations[fk.RefObjectName].Add(schema.ObjectName); } else { _parentRelations.Add(fk.RefObjectName, new List <string>() { schema.ObjectName }); } } } return(schema); }
private static bool ComparePK(SQLStatementWriter sb, JMXSchema schema, JMXSchema fromDbSchema) { ///Add PK compare ///writeDropPKStatement ///writeCreatePKStatement ///The constraint 'XPK1Requests' is being referenced by table 'PaymentStateHists', ///foreign key constraint 'FK_PAYMENTSTATEHISTS_REQUESTS'. ///Could not drop constraint. See previous errors. if (schema.PrimaryKey == null && fromDbSchema.PrimaryKey != null) { //writeDropPKStatement(sb, fromDbSchema); return(true); } else if (schema.PrimaryKey != null && fromDbSchema.PrimaryKey == null) { sb.WriteCreatePKStatement(); } else if (schema.PrimaryKey != null && schema.PrimaryKey.KeyName != fromDbSchema.PrimaryKey.KeyName || schema.PrimaryKey.KeyMembers == fromDbSchema.PrimaryKey.KeyMembers) { //writeDropPKStatement(sb, fromDbSchema); //writeCreatePKStatement(sb, schema); return(true); } return(false); }
private static void NormalizeIndexes(JMXSchema schema) { int i = 0; foreach (var index in schema.Indexes) { if (index.IndexName.IsEmpty() && index.IsUnique) { index.IndexName = $"AK{++i}_{schema.DbObjectName.AreaName}_{schema.DbObjectName.ObjectName}"; } else if (index.IndexName.IsEmpty()) { index.IndexName = $"IE{++i}_{schema.DbObjectName.AreaName}_{schema.DbObjectName.ObjectName}"; } foreach (var member in index.KeyMembers) { var att = schema.Attributes.FirstOrDefault(a => a.FieldName == member.FieldName); if (att == null) { //The FieldName specified in the index is not in the attribute list throw new InvalidOperationException( string.Format(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_3, member.FieldName, $"index '{index.IndexName}'")); } else if (index.IsUnique) { att.Required = true; } } } }
private JMXSchema CreateTestSchema() { JMXSchema s = new JMXSchema("SysSchema") { DbObjectName = new JMXObjectName("dbo", "SysSchemas") }; s.Attributes.Add(new JMXAttribute("ID") { DataType = MdbType.@int, Caption = "Identifier" }); s.Attributes.Add(new JMXAttribute("AreaID") { DataType = MdbType.@int, Caption = "Identifier of SysArea" }); s.Attributes.Add(new JMXAttribute("Name") { DataType = MdbType.@string, Caption = "Name of SysSchema" }); s.PrimaryKey = new JMXPrimaryKey("PK_SysSchemas", "ID"); s.Indexes.Add(new JMXIndex("IE1_SysSchemas", "Name")); var fk = new JMXForeignKey("FK1") { RefObjectName = "SysCat.SysArea", RefDbObjectName = new JMXObjectName("SysCat", "SysAreas") }; fk.AddKeyMember("AreaID"); fk.AddRefKeyMember("ID"); s.ForeignKeys.Add(fk); return(s); }
private static async Task <JMXSchema> GetSchemaInternalAsync(MdbContext mdb, string areaName, string objectName, int syncState) { string sortDirrect = syncState == 0 ? "" : "desc"; string sql = $@" select ID ,ObjectSchema ,SyncState from V_SysSchemas where SchemaName = '{areaName}' and (ObjectName = '{objectName}' or DbObjectName = '{objectName}') and SyncState >= {syncState} order by SyncState {sortDirrect} limit 1" ; using (var dr = await mdb.GetReaderAsync(sql)) { if (!dr.Read()) { //object schema not found in database throw new InvalidOperationException(string.Format(Properties.Strings.S031_MetaStack_Core_SysCat_SysCatManager_getSchema_2, $"{areaName}.{objectName}", syncState)); } var schema = JMXSchema.Parse((string)dr["ObjectSchema"]); schema.ID = Convert.ToInt32(dr["ID"]); schema.SyncState = (int)dr["SyncState"]; return(schema); } }
public override JMXSchema GetSchema(string objectName) { JMXSchema schema = ClientGate.GetObjectSchema(objectName); schema.SchemaRepo = this; return(schema); }
private void LoadRelated() { ToolStripMenuItem menuRun = (ToolStripMenuItem)(GetControl <MenuStrip>("MenuBar").Items["File"] as ToolStripMenuItem) .DropDownItems["FileOpenRelated"]; ToolStripDropDownButton tsbRun = (ToolStripDropDownButton)GetControl <ToolStrip>("Toolbar").Items["OpenRelated"]; List <ToolStripMenuItem> items = new List <ToolStripMenuItem>(); List <ToolStripMenuItem> buttons = new List <ToolStripMenuItem>(); JMXSchema schema = _grid.Schema; foreach (var att in schema.Attributes) { if (att.DataType == MdbType.@object) { JMXSchema rs = ClientGate.GetObjectSchema(att.ObjectName); if (rs.DbObjectType == DbObjectTypes.View) { items.Add(new ToolStripMenuItem(att.Name, null, MenuRel_Click) { Name = att.ObjectName, ToolTipText = att.Description }); buttons.Add(new ToolStripMenuItem(att.Name, null, MenuRel_Click) { Name = att.ObjectName, ToolTipText = att.Description }); } } } if (items.Count > 0) { menuRun.DropDownItems.AddRange(items.ToArray()); menuRun.DropDownItems.Add(new ToolStripSeparator()); tsbRun.DropDown.Items.AddRange(buttons.ToArray()); } }
public virtual JMXSchema SaveSchema(JMXSchema schema) { lock (objLock) _schemaCache[schema.ObjectName] = schema; foreach (var fk in schema.ForeignKeys) { if (fk.RefObjectName.IsEmpty()) { throw new ArgumentNullException("Property RefObjectName can't be empty"); } lock (objLock) { if (_parentRelations.ContainsKey(fk.RefObjectName)) { _parentRelations[fk.RefObjectName].Add(schema.ObjectName); } else { _parentRelations.Add(fk.RefObjectName, new List <string>() { schema.ObjectName }); } } } return(schema); }
private static void NormalizePK(JMXSchema schema) { if (schema.PrimaryKey != null) { var pk = schema.PrimaryKey; if (pk.KeyName.IsEmpty()) { pk.KeyName = $"PK_{schema.DbObjectName.AreaName}_{schema.DbObjectName.ObjectName}"; } foreach (var member in pk.KeyMembers) { var att = schema.Attributes.FirstOrDefault(a => a.FieldName == member.FieldName); if (att != null) { att.IsPK = true; att.IsNullable = false; } else { //The FieldName specified in the primary key is not in the attribute list throw new InvalidOperationException( string.Format(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_3, member.FieldName, "primary key")); } } } else if (schema.Attributes.Any(a => a.DataType == MdbType.@object)) { //Requires PK for table with object attributes var pk = new JMXPrimaryKey(keyName: $"PK_{schema.DbObjectName.AreaName}_{schema.DbObjectName.ObjectName}"); var att = schema.Attributes.FirstOrDefault(a => a.Identity.IsIdentity); if (att == null) { att = schema.Attributes.FirstOrDefault(a => a.AttribName == "ID" || a.FieldName == "ID"); } if (att == null) { att = schema.Attributes.FirstOrDefault(a => a.DefaultConstraint != null && a.DefaultConstraint.Definition.IndexOf("next value for", StringComparison.OrdinalIgnoreCase) > -1); } if (att != null) { if (att.FieldName.IsEmpty()) { att.FieldName = att.AttribName; } pk.AddKeyMember(att.FieldName); schema.PrimaryKey = pk; } else { //A primary key is required for a table that includes columns of type 'object' throw new InvalidOperationException( string.Format(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_5, schema.ObjectName)); } } }
private static void NormalizeAttributes(JMXSchema schema) { if (schema.Attributes.Count == 0) { //One or more attribute is required in the schema throw new InvalidOperationException(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_1); } int i = 0; foreach (var att in schema.Attributes) { att.Position = ++i; att.IsPK = false; if (att.FieldName.IsEmpty()) { att.FieldName = att.AttribName; } if (att.Identity.IsIdentity) { att.IsNullable = false; } if (att.DataType == MdbType.@null) { //For an object type attribute, you must specify a schema throw new InvalidOperationException(string.Format(Properties.Strings.S031_MetaStack_Core_ORM_JMXSchemaProviderDB_normalize_4, att.FieldName)); } string typeMap = TypeMap[att.DataType]; if (att.ServerDataType.IsEmpty() || !typeMap.Contains(att.ServerDataType, StringComparison.OrdinalIgnoreCase)) { att.ServerDataType = typeMap.GetToken(0, ";"); } if (att.DataSize.IsEmpty()) { MdbTypeInfo ti2 = TypeInfo[att.ServerDataType]; if (!ti2.FixedSize) { att.DataSize = new JMXDataSize(ti2.Size, ti2.Scale, ti2.Precision); } } var cc = att.CheckConstraint; if (!cc.IsEmpty() && cc.ConstraintName.IsEmpty()) { cc.ConstraintName = $"CKC_{ att.FieldName}_{ schema.DbObjectName.ObjectName}"; } var dc = att.DefaultConstraint; if (!dc.IsEmpty() && dc.ConstraintName.IsEmpty()) { dc.ConstraintName = $"DF_{ att.FieldName}_{ schema.DbObjectName.ObjectName}"; } } }
private static async Task <JMXSchema> NormalizeSchemaAsync(MdbContext mdb, JMXSchema schema) { NormalizeAttributes(schema); NormalizePK(schema); NormalizeIndexes(schema); await NormalizeFKAsync(mdb, schema); await NormalizeDetailsAsync(mdb, schema); return(schema); }
private static string[] CreateNewStatements(JMXSchema schema) { List <string> sql = new List <string>(); using (SQLStatementWriter sb = new SQLStatementWriter(SqlServerHelper.TypeMapping, schema)) { sb.WriteCreateNewTableStatements(); sql.Add(sb.ToString()); } return(sql.ToArray()); }
private void GetParameters(ActionInfo ai, DataPackage dp) { _connectionName = ai.GetContext() .Services .GetRequiredService <IConfiguration>()["appSettings:SysCatConnection"]; if (dp.Read()) { _schemaSource = JMXSchema.Parse((string)dp["ObjectName"]); } }
public MultiEdit(string objectName) { this.Width = 500; this.Height = (int)(this.Width / vbo.GoldenRatio); _schema = JMXFactory .Create() .CreateJMXRepo() .GetSchema(objectName); this.Add <Panel>(WinFormConfig.SinglePageForm); this.LoadDataComplete += (c, e) => AddSTDButtons(); }
static JMXSchema[] GetTestSchemas() { List <JMXSchema> l = new List <JMXSchema>(); var rm = Resources.TestSchemas.ResourceManager; foreach (JMXObjectName item in getTestNames()) { l.Add(JMXSchema.Parse(rm.GetObject(item.ObjectName) as string)); } return(l.ToArray()); }
private async Task <string[]> DropSchemaStatementsAsync(JMXSchema fromDbSchema) { List <string> sql = new List <string>(); using (SQLStatementWriter sb = new SQLStatementWriter(SqlServerHelper.TypeMapping, fromDbSchema)) { await WriteDropStatementsAsync(sb, fromDbSchema); sql.Add(sb.ToString()); } return(sql.ToArray()); }
private static JMXSchema[] GetTestSchemas() { List <JMXSchema> l = new List <JMXSchema>(); var rm = Resources.TestSchemas.ResourceManager; foreach (JMXObjectName item in GetTestNames()) { var path = $@"..\..\..\orm\Resources\TestSchemas\{item.ObjectName}.json"; l.Add(JMXSchema.Parse(File.ReadAllText(path))); } return(l.ToArray()); }
public override async Task <JMXSchema> GetObjectSchemaAsync(string objectName) { var mdb = Factory.GetMdbContext(); string s = await mdb.ExecuteAsync <string>( (await SqlServerHelper.IsSql17(mdb))?SqlServer.GetTableSchema : SqlServer.GetTableSchema_12, new MdbParameter("@table_name", objectName)); if (s != null) { return(JMXSchema.Parse(s)); } return(null); }
public override async Task <JMXSchema> GetObjectSchemaAsync(string objectName) { ///!!! костыль с именем таблицы JMXSchema schema = new JMXSchema(objectName.Left(objectName.Length - 1)) { DbObjectType = DbObjectTypes.Table, DbObjectName = objectName, SchemaRepo = _schemaRepo }; var drs = await Factory .GetMdbContext() .GetReadersAsync(SQLite.GetTableSchema, new MdbParameter("@table_name", objectName)); var dr = drs[0]; string sql = string.Empty; if (dr.Read()) { sql = (string)dr["sql"]; } else { return(null); } var s = sql.Split(new string[] { "CONSTRAINT ", " PRIMARY KEY" }, StringSplitOptions.RemoveEmptyEntries) .First(str => !str.Contains(' ')); if (!s.IsEmpty()) { schema.PrimaryKey = new JMXPrimaryKey(s); } dr = drs[1]; for (; dr.Read();) { JMXAttribute att = new JMXAttribute((string)dr["name"]); att.FieldName = att.AttribName; att.IsFK = dr["pk"].Equals(1); att.Required = dr["notnull"].Equals(1); if (att.IsFK) { schema.PrimaryKey.AddKeyMember(att.FieldName); } SetAttrType(att, (string)dr["type"]); schema.Attributes.Add(att); } //Костыль!!! доделать return(null); }
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 async Task WriteDropStatementsAsync(SQLStatementWriter sb, JMXSchema fromDbSchema) { 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); }
/// <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); } } }
private async Task <string[]> CompareSchemasAsync(JMXSchema schema, JMXSchema fromDbSchema) { List <string> sql = new List <string>(); using (SQLStatementWriter sb = new SQLStatementWriter(SqlServerHelper.TypeMapping, schema)) { await CompareSchemasStatementsAsync(sb, schema, fromDbSchema); string stmt = sb.ToString(); if (stmt.Length > 1) { sql.Add(sb.ToString()); } } return(sql.ToArray()); }
private void SaveTestData() { //foreach (var s in GetTestSchemas()) // System.IO.File.WriteAllText($"d:\\testData\\{s.ObjectName}.json", s.ToString()); //foreach (var f in new DirectoryInfo("d:\\testData").GetFiles("*.json", SearchOption.AllDirectories)) //{ // string s = File.ReadAllText(f.FullName); // File.WriteAllText(f.FullName, s, Encoding.UTF8); //} var s = CreateTestSchema(); _logger.LogDebug(s.ToString()); var s1 = JMXSchema.Parse(s.ToString()); Assert.Equal(s.ToString(), s1.ToString()); _logger.LogDebug(s1.ToString()); }
public override async Task <JMXSchema> SaveSchemaAsync(JMXSchema schema) { var mdb = Factory.GetMdbContext(); schema = await NormalizeSchemaAsync(mdb, schema); long id = await mdb.ExecuteAsync <long>(SQLite.AddSysSchemas, new MdbParameter("@uid", schema.UID), new MdbParameter("@SysAreaID", await mdb.ExecuteAsync <long>($"Select ID From SysAreas Where SchemaName = '{schema.ObjectName.AreaName}'")), new MdbParameter("@ObjectType", (int)schema.DbObjectType), new MdbParameter("@ObjectName", schema.ObjectName.ObjectName), new MdbParameter("@DbObjectName", schema.DbObjectName.ObjectName), new MdbParameter("@ObjectSchema", schema.ToString()), new MdbParameter("@Version", schema_version), new MdbParameter("@UpdateTime", DateTime.Now), new MdbParameter("@DateBegin", DateTime.Now.Date), new MdbParameter("@DateEnd", DateTime.MinValue) { NullIfEmpty = true }, new MdbParameter("@PreviosID", 0) { NullIfEmpty = true }); schema.ID = Convert.ToInt32(id); lock (objLock) _schemaCache[schema.ObjectName] = schema; foreach (var fk in schema.ForeignKeys) { if (fk.RefObjectName.IsEmpty()) { throw new ArgumentNullException("Property RefObjectName can't be empty"); } lock (objLock) { if (_parentRelations.ContainsKey(fk.RefObjectName)) { _parentRelations[fk.RefObjectName].Add(schema.ObjectName); } else { _parentRelations.Add(fk.RefObjectName, new List <string>() { schema.ObjectName }); } } } return(schema); }
private void SerializeTest() { using (FileLog _logger = new FileLog("ORMSchemaTest", new FileLogSettings() { DateFolderMask = "yyyy-MM-dd" })) { var str = _sourceJsonString; _logger.Debug($"Start perfomance parse string test"); int i; DateTime t = DateTime.Now; JsonObject j = null; for (i = 0; i < 1_000; i++) { j = (JsonObject) new S031.MetaStack.Json.JsonReader(str).Read(); } _logger.Debug($"Finish perfomance parse string test. Time={(DateTime.Now - t).Milliseconds} ms, loop count={i}"); _logger.Debug($"Start perfomance parse string schema test"); t = DateTime.Now; for (i = 0; i < 1_000; i++) { var schema = JMXSchema.Parse(str); } _logger.Debug($"Finish perfomance parse string schema test. Time={(DateTime.Now - t).Milliseconds} ms, loop count={i}"); //str = JSONExtensions.SerializeObject(JMXSchema.Parse(str)); //_logger.Debug($"Start perfomance parse string schema MessagePack test"); //t = DateTime.Now; //for (i = 0; i < 1_000; i++) //{ // var schema = JSONExtensions.DeserializeObject<JMXSchema>(str); //} //_logger.Debug($"Finish perfomance parse string schema MessagePack test. Time={(DateTime.Now - t).Milliseconds} ms, loop count={i}"); var s = JMXSchema.Parse(str); str = s.ToString(); var str2 = JMXSchema.Parse(str).ToString(); Assert.Equal(str, str2); _logger.Debug(JMXSchema.Parse(str)); _logger.Debug(JMXSchema.Parse(str2)); } }
public SchemaManager(JMXSchema schema) { _schema = schema; if (_schema.PrimaryKey.KeyMembers.Count == 1) { var key = _schema.PrimaryKey.KeyMembers[0].FieldName; var att = _schema.Attributes.FirstOrDefault(a => a.FieldName == key); if (att == null) { ///!!! To Resources throw new InvalidOperationException($"Attribute with FieldName that equals {key} not found"); } else if (att.DataType == MdbType.@int || att.DataType == MdbType.@long) { _identityAttribute = att; } } if (_identityAttribute == null) { _identityAttribute = schema.Attributes.FirstOrDefault(a => a.Identity.IsIdentity); } if (_identityAttribute == null) { foreach (var ak in schema.Indexes.Where(idx => idx.IsUnique && idx.KeyMembers.Count == 1)) { var key = ak.KeyMembers[0].FieldName; var att = _schema.Attributes.FirstOrDefault(a => a.FieldName == key); if (att == null) { ///!!! To Resources throw new InvalidOperationException($"Attribute with FieldName that equals {key} not found"); } else if (att.DataType == MdbType.@int || att.DataType == MdbType.@long) { _identityAttribute = att; } } } }