public void speedTest()
{
using (FileLog l = new FileLog("MdbTypeTest", new FileLogSettings()
{
DateFolderMask = "yyyy-MM-dd"
}))
{
Type t = null;
MdbTypeInfo info = new MdbTypeInfo();
l.Debug("SpeedTest 1 Start ");
int i = 0;
for (i = 0; i < 1000000; i++)
{
t = MdbTypeMap.GetType("object", typeof(string));
}
l.Debug($"SpeedTest 1 Finish {i} count result {t}");
for (i = 0; i < 1000000; i++)
{
t = MdbTypeMap.GetType("failed", typeof(string));
}
l.Debug($"SpeedTest 2 Finish {i} count result {t}");
for (i = 0; i < 1000000; i++)
{
info = MdbTypeMap.GetTypeInfo(typeof(string));
}
l.Debug($"SpeedTest 3 Finish {i} count result {info.Name}");
}
}
/// <summary>
/// ALTER TABLE only allows columns to be added that can contain nulls,
/// or have a DEFAULT definition specified,
/// or the column being added is an identity or timestamp column,
/// or alternatively if none of the previous conditions are satisfied the table must be empty
/// to allow addition of this column.
/// </summary>
public SQLStatementWriter WriteAlterColumnStatement(JMXAttribute att, bool addNew = false, JMXSchema fromSchema = null)
{
if (fromSchema == null)
{
fromSchema = _schema;
}
string action = addNew ? "add" : "alter column";
Write($"alter table [{fromSchema.DbObjectName.AreaName}].[{fromSchema.DbObjectName.ObjectName}] {action} [{att.FieldName}]\t{att.ServerDataType}");
MdbTypeInfo ti = _typeMapping.GetServerTypeMap()[att.ServerDataType];
if (att.DataType == MdbType.@decimal && !ti.FixedSize && !att.DataSize.IsEmpty())
{
Write($"({att.DataSize.Precision},{att.DataSize.Scale})");
}
else if (_typeMapping.GetVariableLenghtDataTypes().Contains(att.ServerDataType))
{
if (att.DataSize.Size == -1)
{
Write("(max)");
}
else
{
Write($"({att.DataSize.Size})");
}
}
Write($"\t{att.NullOption}\n");
return(this);
}
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}";
}
}
}
public SQLStatementWriter WriteCreateTableStatements(JMXSchema fromSchema = null)
{
if (fromSchema == null)
{
fromSchema = _schema;
}
Write($"create table {fromSchema.DbObjectName}");
Write("(\n");
int count = fromSchema.Attributes.Count;
for (int i = 0; i < count; i++)
{
var att = fromSchema.Attributes[i];
Write($"[{att.FieldName}]\t{att.ServerDataType}");
MdbTypeInfo ti = _typeMapping.GetServerTypeMap()[att.ServerDataType];
if (att.DataType == MdbType.@decimal && !ti.FixedSize && !att.DataSize.IsEmpty())
{
Write($"({att.DataSize.Precision},{att.DataSize.Scale})");
}
else if (_typeMapping.GetVariableLenghtDataTypes().Contains(att.ServerDataType))
{
if (att.DataSize.Size == -1)
{
Write("(max)");
}
else
{
Write($"({att.DataSize.Size})");
}
}
if (att.Identity.IsIdentity)
{
Write($"\tidentity({att.Identity.Seed},{att.Identity.Increment})");
}
else
{
Write($"\t{att.NullOption}");
}
if (i != count - 1)
{
Write(",\n");
}
att.ID = i + 1;
}
Write(")\n");
return(this);
}
private static bool CompareAttributes(SQLStatementWriter sb, JMXSchema schema, JMXSchema fromDbSchema)
{
bool recreate = false;
int count = schema.Attributes.Count;
List <(JMXAttribute att, JMXAttribute att2, AttribCompareDiff diff)> l =
new List <(JMXAttribute, JMXAttribute, AttribCompareDiff)>();
for (int i = 0; i < count; i++)
{
var att = schema.Attributes[i];
var att2 = fromDbSchema.Attributes.FirstOrDefault(a =>
a.FieldName.Equals(att.FieldName, StringComparison.OrdinalIgnoreCase));
bool found = (att2 != null);
AttribCompareDiff diff = AttribCompareDiff.none;
if (found)
{
if (!att.ServerDataType.Equals(att2.ServerDataType, StringComparison.OrdinalIgnoreCase))
{
diff = AttribCompareDiff.dataTtype;
}
if (att.Required != att2.Required)
{
diff |= AttribCompareDiff.nullOptions;
}
if (att.Identity.IsIdentity != att2.Identity.IsIdentity ||
att.Identity.Seed != att2.Identity.Seed ||
att.Identity.Increment != att2.Identity.Increment)
{
diff |= AttribCompareDiff.identity;
}
if (att.DataType != MdbType.@object &&
!att.AttribName.Equals(att2.FieldName, StringComparison.OrdinalIgnoreCase))
{
diff |= AttribCompareDiff.name;
}
//Server DataTypes is equals
if ((diff & AttribCompareDiff.dataTtype) != AttribCompareDiff.dataTtype)
{
MdbTypeInfo ti = SqlServerHelper.TypeInfo[att.ServerDataType];
if (!ti.FixedSize)
{
if (SqlServerHelper.TypeMapping.GetVariableLenghtDataTypes().Contains(att.ServerDataType) && att.DataSize.Size != att2.DataSize.Size)
{
diff |= AttribCompareDiff.size;
}
else if (ti.MdbType == MdbType.@decimal && (att.DataSize.Precision != att2.DataSize.Precision ||
att.DataSize.Scale != att2.DataSize.Scale))
{
diff |= AttribCompareDiff.size;
}
}
}
if (!att.CheckConstraint
.Definition
.RemoveChar("[( )]".ToCharArray())
.Equals(att2.CheckConstraint
.Definition
.RemoveChar("[( )]".ToCharArray()),
StringComparison.OrdinalIgnoreCase))
{
diff |= AttribCompareDiff.constraint;
}
else if (!att.DefaultConstraint
.Definition.RemoveChar("[( )]".ToCharArray())
.Equals(att2.DefaultConstraint
.Definition
.RemoveChar("[( )]".ToCharArray()),
StringComparison.OrdinalIgnoreCase))
{
diff |= AttribCompareDiff.constraint;
}
}
//else if (att2 != null)
// diff |= AttribCompareDiff.name;
else
{
diff = AttribCompareDiff.notFound;
}
l.Add((att, att2, diff));
}
foreach (var att2 in fromDbSchema.Attributes)
{
//var att = schema.Attributes.FirstOrDefault(a => a.ID == att2.ID);
var att = schema.Attributes.FirstOrDefault(a =>
a.FieldName.Equals(att2.FieldName, StringComparison.OrdinalIgnoreCase));
if (att == null)
{
l.Add((att, att2, AttribCompareDiff.remove));
}
}
foreach (var(att, att2, diff) in l)
{
if ((diff & AttribCompareDiff.remove) == AttribCompareDiff.remove)
{
sb.WriteDropColumnStatement(att2);
continue;
}
if ((diff & AttribCompareDiff.constraint) == AttribCompareDiff.constraint)
{
sb.WriteDropConstraintStatement(att2, fromDbSchema);
sb.WriteCreateConstraintStatement(att);
}
if ((diff & AttribCompareDiff.dataTtype) == AttribCompareDiff.dataTtype ||
(diff & AttribCompareDiff.size) == AttribCompareDiff.size ||
(diff & AttribCompareDiff.nullOptions) == AttribCompareDiff.nullOptions)
{
sb.WriteAlterColumnStatement(att);
}
else if ((diff & AttribCompareDiff.notFound) == AttribCompareDiff.notFound)
{
sb.WriteAlterColumnStatement(att, true);
}
else if ((diff & AttribCompareDiff.name) == AttribCompareDiff.name)
{
att.FieldName = att.AttribName;
sb.WriteRenameColumnStatement(att2.FieldName, att.FieldName);
}
else if ((diff & AttribCompareDiff.identity) == AttribCompareDiff.identity)
{
recreate = true;
}
}
return(recreate);
}
