internal static bool IsNullable(this ColumnObjectModel column)
{
if (!column.AllowNulls)
{
return(false);
}
switch (column.SqlDataType)
{
case SqlDbType.Binary:
case SqlDbType.Char:
case SqlDbType.NChar:
case SqlDbType.NText:
case SqlDbType.NVarChar:
case SqlDbType.Text:
case SqlDbType.VarBinary:
case SqlDbType.VarChar:
case SqlDbType.Timestamp:
case SqlDbType.Xml:
return(false);
default:
return(true);
}
}
public static void RemoveColumnMapping(ColumnObjectModel column, string ownerTable)
{
ownerTable = ownerTable.ToLower();
string columnNameKey = column.ColumnName.ToLower();
int previousCount = Integrity.globalColumnsCount.ContainsKey(column.ColumnName) ?
Integrity.globalColumnsCount[column.ColumnName] : 0;
previousCount--;
Integrity.globalColumnsCount.Remove(column.ColumnName);
if (previousCount > 0)
{
Integrity.globalColumnsCount.Add(column.ColumnName, previousCount);
}
if (column.IsForeignkey && !Integrity.foreignKeyConstraintNames.Any(fk => fk.ToLower() == column.ForeignConstraintName.ToLower()))
{
Integrity.foreignKeyConstraintNames.Remove(column.ForeignConstraintName);
}
if (column.InPrimaryKey && !column.IsForeignkey && !Integrity.primaryColumns.ContainsKey(columnNameKey))
{
Integrity.primaryColumns.Remove(columnNameKey);
}
if (!Integrity.tableColumns[ownerTable].Any(cn => cn.ToLower() == columnNameKey))
{
Integrity.tableColumns[ownerTable].Remove(column.ColumnName);
}
}
//private static string GetModelFieldString(ColumnObjectModel column)
//{
//}
private static string GetModelPropertyString(ColumnObjectModel column)
{
string sqlDataType = EntityModelScript.IsNullable(column) ?
$"{EntityModelScript.GetSqlDataMap(column.SqlDataType.Value)}{(column.InPrimaryKey ? string.Empty : "?")}" :
EntityModelScript.GetSqlDataMap(column.SqlDataType.Value);
string inPrimaryKey = column.InPrimaryKey ? "(Primary Key) " : string.Empty;
string isForeignKey = column.IsForeignkey ? $"(Foreign Key from: {column.ForeignKeyTable}) " : string.Empty;
string description = $"{inPrimaryKey}{isForeignKey}{column.Description}";
if (column.SqlDataType.Value == SqlDbType.Timestamp)
{
string resultSting = EntityModelScript.Setup.ModelPropertyString
.Replace("{0}", description)
.Replace("{1}", sqlDataType)
.Replace("{2}", EntityModelScript.GetColumnName(column));
int insertIndex = resultSting.IndexOf("</summary>") + 10;
resultSting = resultSting.Insert(insertIndex, $"{Environment.NewLine} [Timestamp]");
return(resultSting.ToString());
}
// NOTE: We need to do a replace due to the brackets in the text here
return(EntityModelScript.Setup.ModelPropertyString
.Replace("{0}", description)
.Replace("{1}", sqlDataType)
.Replace("{2}", EntityModelScript.GetColumnName(column)));
}
private void ShowAddColumn()
{
try
{
ColumnObjectModel column = new ColumnObjectModel {
Column_Id = int.MaxValue
};
ColumnsEdit columnEdit = new ColumnsEdit(column, this.Table.TableName);
bool?result = columnEdit.ShowDialog();
if (result == null || !result.Value)
{
return;
}
column.HasModelChanged = false; // This is to clear the model changes values. Especialy for new column creation
this.Table.Columns = this.Table.Columns.Add(columnEdit.Column);
Integrity.MapColumn(column, this.Table.TableName);
if (column.IsForeignkey)
{
this.ForeignKeyColumnAdded?.Invoke(this, column);
}
this.TableColumnChanged?.Invoke(this, column);
}
catch (Exception err)
{
MessageBox.Show(err.GetFullExceptionMessage());
}
}
private bool TableObject_ForeignKeyAdded(object sender, ColumnObjectModel column)
{
try
{
TableObject table = (TableObject)sender;
List <string> exixtingRelations = table.ColumnRelationModel.Keys.ToList();
table.InitializeColumnRemations();
foreach (KeyValuePair <string, DatabaseRelation> relationPair in table.ColumnRelationModel)
{
if (this.columnRelationModel.ContainsKey(relationPair.Key))
{
continue;
}
this.columnRelationModel.Add(relationPair.Key, relationPair.Value);
}
UIElement[] tableControls = this.FindVisualControls(typeof(TableObject));
string dictionaryKey = table.ColumnRelationModel.Keys.FirstOrDefault(ex => !exixtingRelations.Contains(ex));
this.DrawRelation(table, tableControls, new KeyValuePair <string, DatabaseRelation>(dictionaryKey, table.ColumnRelationModel[dictionaryKey]));
return(true);
}
catch
{
return(false);
}
}
private void CheckConceptualValues(TableModel[] tablesArray)
{
if (!General.ProjectModel.KeepColumnsUnique)
{
return;
}
List <string> checkedList = new List <string>();
foreach (TableModel table in tablesArray)
{
foreach (ColumnObjectModel column in table.Columns)
{
string lowerColumnName = column.ColumnName;
if (checkedList.Contains(lowerColumnName))
{
continue;
}
checkedList.Add(lowerColumnName);
List <TableModel> referencedTables = tablesArray
.Where(t => t.TableName != table.TableName &&
t.Columns.Any(c => c.ColumnName == lowerColumnName))
.ToList();
if (referencedTables.Count == 0)
{
continue;
}
string columnDataType = column.DataType.Replace(" IDENTITY", string.Empty);
foreach (TableModel otherTable in referencedTables)
{
ColumnObjectModel otherColumn = otherTable.Columns.First(f => f.ColumnName == lowerColumnName);
if (otherColumn.DataType.Replace(" IDENTITY", string.Empty) != columnDataType)
{
string exceptionMessage = "The conceptual data values for Table {0}, Column {1} differs for the same column in Table {2}.{5}{5}" +
"The data type in Table {0} is {3} and in Table {2} is {4}.";
object[] messageParameters = new object[]
{
table.TableName,
column.ColumnName,
otherTable.TableName,
columnDataType,
otherColumn.DataType,
Environment.NewLine
};
throw new ApplicationException(String.Format(exceptionMessage, messageParameters));
}
}
}
}
}
public static string[] GetColumnDotNetDescriptor(ColumnObjectModel column)
{
return(new string[]
{
EntityModelScript.GetSqlDataMap(column.SqlDataType.Value),
EntityModelScript.GetColumnName(column)
});
}
public static void MapColumn(ColumnObjectModel column, string ownerTable)
{
string ownerTableKey = ownerTable;
string columnNameKey = column.ColumnName;
string objectModelKey = $"{ownerTableKey}||{columnNameKey}";
if (!Integrity.columnObjectModels.ContainsKey(objectModelKey))
{
Integrity.columnObjectModels.Add(objectModelKey, column);
}
if (!Integrity.tableColumns[ownerTableKey].Any(cn => cn == columnNameKey))
{
Integrity.tableColumns[ownerTableKey].Add(column.ColumnName);
}
if (column.InPrimaryKey && !column.IsForeignkey && !Integrity.primaryColumns.ContainsKey(columnNameKey))
{
Integrity.primaryColumns.Add(columnNameKey, ownerTable);
}
if (column.IsForeignkey && !Integrity.foreignKeyConstraintNames.Any(fk => fk == column.ForeignConstraintName))
{
Integrity.foreignKeyConstraintNames.Add(column.ForeignConstraintName);
}
lock (globalColumnsCountLock)
{
if (!Integrity.globalColumnsCount.Any(gl => gl.Key == columnNameKey))
{
Integrity.globalColumnsCount.Add(columnNameKey, 1);
if (column.SqlDataType.HasValue)
{
if (Integrity.globalColumnsDataType.ContainsKey(column.ColumnName))
{
Integrity.globalColumnsDataType.Remove(column.ColumnName);
}
Integrity.globalColumnsDataType.Add(column.ColumnName, column.SqlDataType.Value);
}
}
else
{
int previousCount = Integrity.globalColumnsCount[columnNameKey];
previousCount++;
Integrity.globalColumnsCount.Remove(columnNameKey);
Integrity.globalColumnsCount.Add(columnNameKey, previousCount);
}
}
}
public List <ColumnObjectModel> GetTableColumns(string schema, string tableName)
{
EventParser.ParseMessage(this, this.dispatcher, "Reading Table ", tableName);
List <ColumnObjectModel> result = new List <ColumnObjectModel>();
DataAccess dataAccess = new DataAccess(Connections.Instance.DatabaseModel);
XDocument columnsXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseTableColumnsQuery(schema, tableName));
foreach (XElement item in columnsXml.Root.Elements())
{
string columnName = item.Element("COLUMNNAME").Value;
EventParser.ParseMessage(this, this.dispatcher, "Reading Column ", columnName);
if (result.Any(col => col.ColumnName == columnName))
{
continue;
}
string originalPosistion = Connections.Instance.IsDefaultConnection ? item.Element("ORDINAL_POSITION").Value : string.Empty;
XDocument primaryKey = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseColumnKeysQuery(tableName, columnName));
ColumnObjectModel column = new ColumnObjectModel
{
ColumnName = columnName,
IsIdentity = item.Element("IS_IDENTITY").Value.ToBool(),
AllowNulls = item.Element("IS_NULLABLE").Value.ToBool(),
MaxLength = item.Element("MAX_LENGTH").Value.ToInt32(),
Precision = item.Element("PRECISION").Value.ToInt32(),
Scale = item.Element("SCALE").Value.ToInt32(),
IsForeignkey = !item.Element("PRIMARY_TABLE").Value.IsNullEmptyOrWhiteSpace(),
ForeignKeyTable = item.Element("PRIMARY_TABLE").Value,
ForeignKeyColumn = item.Element("PRIMARY_COLUMNNAME").Value,
ForeignConstraintName = item.Element("FK_CONSTRAINT_NAME").Value,
SqlDataType = this.ParseSqlDbType(item.Element("DATA_TYPE").Value),
InPrimaryKey = primaryKey.Descendants().Any(d => d.Value == "PRIMARY KEY"),
Column_Id = item.Element("COLUMN_ID").Value.ToInt32(),
OriginalPosition = originalPosistion.IsNullEmptyOrWhiteSpace() ? 0 : originalPosistion.ToInt32()
};
column.HasModelChanged = false;
result.Add(column);
}
return(result);
}
internal static string GetStringDataType(ColumnObjectModel column, LanguageOptionEnum languageOption)
{
switch (languageOption)
{
case LanguageOptionEnum.CSharp:
default:
if (column.IsNullable())
{
return($"{MsSqlDataMap.GetMsSqlDataMap(column.SqlDataType.Value)}?");
}
return(MsSqlDataMap.GetMsSqlDataMap(column.SqlDataType.Value));
}
}
public ColumnsEdit(ColumnObjectModel column, string tableName)
{
this.InitializeComponent();
this.TableName = tableName;
this.Column = column;
this.Column.PropertyChanged += this.ColumnProperty_Changed;
this.uxColumnViewer.Items.Add(this.Column);
if (this.Column.InPrimaryKey)
{
this.uxColumnViewer["Column Name"].IsEnabled = false;
this.uxColumnViewer["In Primary Key"].IsEnabled = false;
this.uxColumnViewer["Allow Nulls"].IsEnabled = false;
}
}
public static string GetDescription(string columnName)
{
string columnNameKey = columnName.ToLower();
string objectModelKey = $"||{columnNameKey}";
List <ColumnObjectModel> machList = Integrity.columnObjectModels.Where(tk => tk.Key.EndsWith(objectModelKey)).Select(v => v.Value).ToList();
if (machList.Count == 0)
{
return(string.Empty);
}
// First try the option where the column is a primary key
ColumnObjectModel keyColumn = machList.FirstOrDefault(pk => pk.InPrimaryKey && !pk.IsForeignkey);
if (keyColumn != null)
{
return(keyColumn.Description);
}
return(machList[0].Description);
}
public static void RemoveForeighKey(DatabaseRelation relation)
{
foreach (ColumnRelationMapModel mappedColumn in relation.Columns)
{
string columnKey = $"{mappedColumn.ChildTable.ToLower()}||{mappedColumn.ChildColumn.ToLower()}";
ColumnObjectModel column = Integrity.columnObjectModels[columnKey];
string constraintKey = $"{mappedColumn.ChildTable}||{column.ForeignConstraintName}";
if (!Integrity.DropRelations.Contains(constraintKey))
{
Integrity.DropRelations.Add(constraintKey);
}
column.ForeignConstraintName = string.Empty;
column.ForeignKeyColumn = string.Empty;
column.ForeignKeyTable = string.Empty;
column.IsForeignkey = false;
}
}
private void CheckColumns()
{
string[] databaseTableNames = this.databaseTables.Select(tn => tn.TableName).ToArray();
string[] erdTableNames = this.canvasTables.Select(tn => tn.TableName).ToArray();
Dictionary <string, List <ColumnObjectModel> > fromDatabaseList = this.reverse.GetInTableColumns(databaseTableNames);
Dictionary <string, List <ColumnObjectModel> > fromErdList = this.reverse.GetInTableColumns(erdTableNames);
foreach (TableModel fromDatabase in this.databaseTables)
{
EventParser.ParseMessage(this, dispatcher, "Getting Columns", fromDatabase.TableName);
fromDatabase.Columns = fromDatabaseList[fromDatabase.TableName].ToArray();
//this.reverse.GetTableColumns(fromDatabase.TableName).ToArray();
TableModel fromCanvas = this.canvasTables.FirstOrDefault(tn => tn.TableName.ToUpper() == fromDatabase.TableName.ToUpper());
if (fromCanvas == null ||
fromCanvas.ErdSegmentModelName.IsNullEmptyOrWhiteSpace())
{
// This was catched in this.CheckTables()
continue;
}
if (fromCanvas.ErdSegmentModelName.IsNullEmptyOrWhiteSpace())
{
// The table is not on A Canvas, but was read on startup
// We need the columns though
fromCanvas.Columns = fromErdList[fromDatabase.TableName].ToArray();
//this.reverse.GetTableColumns(fromDatabase.TableName).ToArray();
}
#region COMPARE DATABASE COLUMNS TO MODEL
foreach (ColumnObjectModel databaseColumn in fromDatabase.Columns)
{
ColumnObjectModel canvasColummn = fromCanvas.Columns.FirstOrDefault(dc => dc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColummn == null)
{
this.result.Add(new CompareResultModel
{
TableObject = fromDatabase,
ObjectName = databaseColumn.ColumnName,
Message = "Column Exist in Database but not on ERD Model.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.DropFromDatabase
});
}
else if (databaseColumn.DataType != canvasColummn.DataType)
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = canvasColummn.ColumnName,
Message = $"Data Type differs; Database Data Type {databaseColumn.DataType}; ERD Model Data Type{canvasColummn.DataType}.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.AlterDatabase
});
}
}
#endregion
#region COMPARE DATABASE COLUMNS TO MODEL
foreach (ColumnObjectModel canvasColumn in fromCanvas.Columns)
{
ColumnObjectModel databaseColummn = fromDatabase.Columns.FirstOrDefault(dc => dc.ColumnName.ToUpper() == canvasColumn.ColumnName.ToUpper());
if (databaseColummn == null)
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = canvasColumn.ColumnName,
Message = "Column Exist on ERD Model Database but not in Database.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.CreateInDatabase
});
}
}
#endregion
}
}
private void CheckRelations()
{
foreach (TableModel fromDatabase in this.databaseTables.Where(fk => fk.Columns.Any(col => col.IsForeignkey)))
{
EventParser.ParseMessage(this, dispatcher, fromDatabase.TableName, $"Compare Table {fromDatabase.TableName} Foreign Constraints");
Dictionary <string, List <ColumnObjectModel> > databaseForeignkeyStructure = fromDatabase.Columns
.Where(dk => dk.IsForeignkey &&
!dk.IsVertualRelation)
.GroupBy(dg => dg.ForeignKeyTable.ToUpper())
.ToDictionary(dd => dd.Key, dd => dd.ToList());
foreach (KeyValuePair <string, List <ColumnObjectModel> > keyPair in databaseForeignkeyStructure)
{
TableModel canvasKeyTable = this.canvasTables
.FirstOrDefault(ck => ck.TableName.ToUpper() == fromDatabase.TableName.ToUpper());
if (canvasKeyTable == null)
{ // This was handled in the Table Comparison
continue;
}
foreach (ColumnObjectModel databaseColumn in keyPair.Value)
{
ColumnObjectModel canvasColumn = canvasKeyTable.Columns.FirstOrDefault(cc => cc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColumn == null)
{ // This was handled in the Column Comparison
continue;
}
if (databaseColumn.ForeignKeyColumn.ToUpper() != canvasColumn.ForeignKeyColumn.ToUpper())
{
this.result.Add(new CompareResultModel
{
TableObject = fromDatabase,
ObjectName = databaseColumn.ForeignConstraintName,
Message = $"Foreign Key Constraint Exist in Database Model but not on ERD Model. ({databaseColumn.ColumnName})",
ObjectType = ObjectTypeEnum.ForeignKeyConstraint,
ObjectAction = ObjectActionEnum.DropFromDatabase
});
}
}
}
}
foreach (TableModel fromCanvas in this.canvasTables.Where(fk => fk.Columns.Any(col => col.IsForeignkey && !col.IsVertualRelation)))
{
EventParser.ParseMessage(this, dispatcher, fromCanvas.TableName, $"Compare Table {fromCanvas.TableName} Foreign Constraints");
Dictionary <string, List <ColumnObjectModel> > canvasForeignkeyStructure = fromCanvas.Columns
.Where(dk => dk.IsForeignkey &&
!dk.IsVertualRelation)
.GroupBy(dg => dg.ForeignKeyTable.ToUpper())
.ToDictionary(dd => dd.Key, dd => dd.ToList());
foreach (KeyValuePair <string, List <ColumnObjectModel> > keyPair in canvasForeignkeyStructure)
{
TableModel canvasKeyTable = this.databaseTables
.FirstOrDefault(ck => ck.TableName.ToUpper() == fromCanvas.TableName.ToUpper());
if (canvasKeyTable == null)
{ // This was handled in the Table Comparison
continue;
}
foreach (ColumnObjectModel databaseColumn in keyPair.Value)
{
ColumnObjectModel canvasColumn = canvasKeyTable.Columns.FirstOrDefault(cc => cc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColumn == null)
{ // This was handled in the Column Comparison
continue;
}
if (databaseColumn.ForeignKeyColumn.ToUpper() != canvasColumn.ForeignKeyColumn.ToUpper())
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = databaseColumn.ForeignConstraintName,
Message = $"Foreign Key Constraint Exist on ERD Model but not in Database. ({databaseColumn.ColumnName})",
ObjectType = ObjectTypeEnum.ForeignKeyConstraint,
ObjectAction = ObjectActionEnum.CreateInDatabase
});
}
}
}
}
}
public static string GetColumnName(ColumnObjectModel column)
{
return(EntityModelScript.Setup.UseFriendlyNames && !column.FriendlyName.IsNullEmptyOrWhiteSpace() ?
column.FriendlyName.Replace(' ', '_').MakeAlphaNumeric() : column.ColumnName.Replace(' ', '_').MakeAlphaNumeric());
}
public static string ScriptServerModelMapping(TableModel table)
{
StringBuilder result = new StringBuilder();
result.AppendLine(Setup.MappingClassUsing);
result.AppendLine();
result.AppendLine($"namespace {Setup.MappingClassNamespace}");
result.AppendLine("{");
result.AppendLine($" public class {EntityModelScript.GetClassName(table)}Mapping : EntityTypeConfiguration<{EntityModelScript.GetClassName(table)}>");
result.AppendLine(" {");
result.AppendLine($" public {EntityModelScript.GetClassName(table)}Mapping()");
result.AppendLine(" {");
result.AppendLine($" ToTable(\"{table.TableName}\");");
result.AppendLine();
ColumnObjectModel[] pkColumns = table.Columns.Where(pk => pk.InPrimaryKey).ToArray();
if (pkColumns.HasElements() && pkColumns.Length == 1)
{
result.AppendLine($" HasKey(k => k.{EntityModelScript.GetColumnName(pkColumns[0])});");
}
else if (pkColumns.HasElements())
{
result.Append(" HasKey(k => new { ");
for (int x = 0; x < pkColumns.Length; ++x)
{
if (x == (pkColumns.Length - 1))
{
result.Append($"k.{EntityModelScript.GetColumnName(pkColumns[x])} ");
}
else
{
result.Append($"k.{EntityModelScript.GetColumnName(pkColumns[x])}, ");
}
}
result.AppendLine(" });");
}
result.AppendLine();
for (int x = 0; x < table.Columns.Length; x++)
{
ColumnObjectModel column = table.Columns[x];
string lambda = $"col{x}";
result.AppendLine($" Property({lambda} => {lambda}.{EntityModelScript.GetColumnName(column)}).HasColumnName(\"{column.ColumnName}\");");
}
result.AppendLine(" }");
result.AppendLine(" }");
result.Append("}");
return(result.ToString());
}
public static string BuildeColumnCreate(string schemaName, string tableName, ColumnObjectModel column)
{
IScripting scriptor = Scripting.CreateClass();
return(scriptor.BuildeColumnCreate(schemaName, tableName, column));
}
public static string BuildColumnAlter(string tableName, ColumnObjectModel column)
{
IScripting scriptor = Scripting.CreateClass();
return(scripting.BuildColumnAlter(tableName, column));
}
public static string DatabaseDataType(ColumnObjectModel column)
{
IScripting scriptor = Scripting.CreateClass();
return(scriptor.DatabaseDataType(column));
}
public static string DatafieldLength(ColumnObjectModel column)
{
IScripting scriptor = Scripting.CreateClass();
return(scriptor.DatafieldLength(column));
}
public Dictionary <string, List <ColumnObjectModel> > GetInTableColumns(string[] tableNamesArray)
{
EventParser.ParseMessage(this, this.dispatcher, "Reading Tables", "");
Dictionary <string, List <ColumnObjectModel> > result = new Dictionary <string, List <ColumnObjectModel> >();
DataAccess dataAccess = new DataAccess(Connections.Instance.DatabaseModel);
XDocument columnsXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseInTableColumnsQuery(tableNamesArray));
Dictionary <string, List <XElement> > groupedTables = new Dictionary <string, List <XElement> >();
foreach (XElement column in columnsXml.Root.Elements())
{
string tableName = column.Element("TABLENAME").Value;
if (!groupedTables.ContainsKey(tableName))
{
groupedTables.Add(tableName, new List <XElement>());
}
groupedTables[tableName].Add(column);
}
foreach (KeyValuePair <string, List <XElement> > tableColumns in groupedTables)
{
result.Add(tableColumns.Key, new List <ColumnObjectModel>());
EventParser.ParseMessage(this, this.dispatcher, "Reading Columns for ", tableColumns.Key);
string[] columnNamesArray = tableColumns.Value.Select(c => c.Element("COLUMNNAME").Value).ToArray();
XDocument primaryKeys = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseInColumnKeysQuery(tableColumns.Key, columnNamesArray));
foreach (XElement item in tableColumns.Value)
{
string columnName = item.Element("COLUMNNAME").Value;
if (result[tableColumns.Key].Any(col => col.ColumnName == columnName))
{
continue;
}
string originalPosistion = item.Element("ORDINAL_POSITION").Value;
XElement primaryKey = primaryKeys.Root.Elements()
.FirstOrDefault(el => el.Element("COLUMN_NAME").Value == columnName &&
el.Element("CONSTRAINT_TYPE").Value == "PRIMARY KEY");
ColumnObjectModel column = new ColumnObjectModel
{
ColumnName = columnName,
IsIdentity = item.Element("IS_IDENTITY").Value.ToBool(),
AllowNulls = item.Element("IS_NULLABLE").Value.ToBool(),
MaxLength = item.Element("MAX_LENGTH").Value.ToInt32(),
Precision = item.Element("PRECISION").Value.ToInt32(),
Scale = item.Element("SCALE").Value.ToInt32(),
IsForeignkey = !item.Element("PRIMARY_TABLE").Value.IsNullEmptyOrWhiteSpace(),
ForeignKeyTable = item.Element("PRIMARY_TABLE").Value,
ForeignKeyColumn = item.Element("PRIMARY_COLUMNNAME").Value,
ForeignConstraintName = item.Element("FK_CONSTRAINT_NAME").Value,
SqlDataType = this.ParseSqlDbType(item.Element("DATA_TYPE").Value),
InPrimaryKey = primaryKey == null ? false : primaryKey.Descendants().Any(d => d.Value == "PRIMARY KEY"),
Column_Id = item.Element("COLUMN_ID").Value.ToInt32(),
OriginalPosition = originalPosistion.IsNullEmptyOrWhiteSpace() ? 0 : originalPosistion.ToInt32()
};
column.HasModelChanged = false;
result[tableColumns.Key].Add(column);
}
}
return(result);
}
private void TableColumn_Changed(object sender, ColumnObjectModel column)
{
this.CanvasChanged?.Invoke(this, column);
}
