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