private bool ValidateModel(SchemaDesignerInfo schemaDesignerInfo, out string message)
{
message = "";
if (schemaDesignerInfo == null)
{
message = "Argument can't be null";
return false;
}
TableDesignerInfo table = schemaDesignerInfo.TableDesignerInfo;
if (table == null)
{
message = "No table information";
return false;
}
if (string.IsNullOrEmpty(table.Name))
{
message = "Table Name can't be empty";
return false;
}
#region Columns
List<TableColumnDesingerInfo> columns = schemaDesignerInfo.TableColumnDesingerInfos;
List<string> columnNames = new List<string>();
foreach (TableColumnDesingerInfo column in columns)
{
if (string.IsNullOrEmpty(column.Name))
{
message = "Column Name can't be empty";
return false;
}
else if (string.IsNullOrEmpty(column.DataType))
{
string computeExpression = column.ExtraPropertyInfo?.Expression;
if (string.IsNullOrEmpty(computeExpression) || this.dbInterpreter.DatabaseType == DatabaseType.MySql)
{
message = "Data Type can't be empty";
return false;
}
}
else if (columnNames.Contains(column.Name))
{
message = $"Column Name \"{column.Name}\" is duplicated";
return false;
}
else if (!ColumnManager.ValidateDataType(this.dbInterpreter.DatabaseType, column, out message))
{
return false;
}
columnNames.Add(column.Name);
}
#endregion
#region Indexes
if (!schemaDesignerInfo.IgnoreTableIndex)
{
List<TableIndexDesignerInfo> indexes = schemaDesignerInfo.TableIndexDesingerInfos;
List<string> indexNames = new List<string>();
int clursteredCount = 0;
foreach (TableIndexDesignerInfo index in indexes)
{
if (string.IsNullOrEmpty(index.Name))
{
message = "Index Name can't be empty";
return false;
}
else if (indexNames.Contains(index.Name))
{
message = $"Index Name \"{index.Name}\" is duplicated";
return false;
}
else if (index.Columns == null || index.Columns.Count == 0)
{
message = $"Index \"{index.Name}\" has no any column";
return false;
}
if (index.ExtraPropertyInfo != null)
{
if (index.ExtraPropertyInfo.Clustered)
{
clursteredCount++;
}
}
}
if (clursteredCount > 1)
{
message = "The clurstered index count can't be more than one";
return false;
}
}
#endregion
#region Foreign Keys
if (!schemaDesignerInfo.IgnoreTableForeignKey)
{
List<TableForeignKeyDesignerInfo> foreignKeys = schemaDesignerInfo.TableForeignKeyDesignerInfos;
List<string> keyNames = new List<string>();
foreach (TableForeignKeyDesignerInfo key in foreignKeys)
{
if (string.IsNullOrEmpty(key.Name))
{
message = "Foreign Key Name can't be empty";
return false;
}
else if (keyNames.Contains(key.Name))
{
message = $"Foreign Key Name \"{key.Name}\" is duplicated";
return false;
}
else if (key.Columns == null || key.Columns.Count == 0)
{
message = $"The \"{key.Name}\" has no any column";
return false;
}
}
}
#endregion
#region Constraints
if (!schemaDesignerInfo.IgnoreTableConstraint)
{
List<TableConstraintDesignerInfo> constraints = schemaDesignerInfo.TableConstraintDesignerInfos;
List<string> constraintNames = new List<string>();
foreach (TableConstraintDesignerInfo constraint in constraints)
{
if (string.IsNullOrEmpty(constraint.Name))
{
message = "Constraint Name can't be empty";
return false;
}
else if (constraintNames.Contains(constraint.Name))
{
message = $"Constraint Name \"{constraint.Name}\" is duplicated";
return false;
}
else if (string.IsNullOrEmpty(constraint.Definition))
{
message = "Constraint Expressioni can't be empty";
return false;
}
}
}
#endregion
return true;
}
public SchemaInfo GetSchemaInfo(SchemaDesignerInfo schemaDesignerInfo)
{
SchemaInfo schemaInfo = new SchemaInfo();
Table table = new Table();
ObjectHelper.CopyProperties(schemaDesignerInfo.TableDesignerInfo, table);
schemaInfo.Tables.Add(table);
#region Columns
TablePrimaryKey primaryKey = null;
foreach (TableColumnDesingerInfo column in schemaDesignerInfo.TableColumnDesingerInfos)
{
TableColumn tableColumn = new TableColumn();
ObjectHelper.CopyProperties(column, tableColumn);
if (!tableColumn.IsUserDefined)
{
ColumnManager.SetColumnLength(this.dbInterpreter.DatabaseType, tableColumn, column.Length);
}
if (column.IsPrimary)
{
if (primaryKey == null)
{
primaryKey = new TablePrimaryKey() { Owner = table.Owner, TableName = table.Name, Name = IndexManager.GetPrimaryKeyDefaultName(table) };
}
IndexColumn indexColumn = new IndexColumn() { ColumnName = column.Name, IsDesc = false, Order = primaryKey.Columns.Count + 1 };
if (!schemaDesignerInfo.IgnoreTableIndex)
{
TableIndexDesignerInfo indexDesignerInfo = schemaDesignerInfo.TableIndexDesingerInfos
.FirstOrDefault(item => item.Type == IndexType.Primary.ToString() && item.Columns.Any(t => t.ColumnName == column.Name));
if (indexDesignerInfo != null)
{
primaryKey.Name = indexDesignerInfo.Name;
primaryKey.Comment = indexDesignerInfo.Comment;
IndexColumn columnInfo = indexDesignerInfo.Columns.FirstOrDefault(item => item.ColumnName == column.Name);
if (columnInfo != null)
{
indexColumn.IsDesc = columnInfo.IsDesc;
}
if (indexDesignerInfo.ExtraPropertyInfo != null)
{
primaryKey.Clustered = indexDesignerInfo.ExtraPropertyInfo.Clustered;
}
}
}
primaryKey.Columns.Add(indexColumn);
}
TableColumnExtraPropertyInfo extralProperty = column.ExtraPropertyInfo;
if (column.IsIdentity)
{
if (extralProperty != null)
{
table.IdentitySeed = extralProperty.Seed;
table.IdentityIncrement = extralProperty.Increment;
}
else
{
table.IdentitySeed = 1;
table.IdentityIncrement = 1;
}
}
if (extralProperty?.Expression != null)
{
tableColumn.ComputeExp = extralProperty.Expression;
}
schemaInfo.TableColumns.Add(tableColumn);
}
if (primaryKey != null)
{
schemaInfo.TablePrimaryKeys.Add(primaryKey);
}
#endregion
#region Indexes
if (!schemaDesignerInfo.IgnoreTableIndex)
{
foreach (TableIndexDesignerInfo indexDesignerInfo in schemaDesignerInfo.TableIndexDesingerInfos)
{
if (!indexDesignerInfo.IsPrimary)
{
TableIndex index = new TableIndex() { Owner = indexDesignerInfo.Owner, TableName = indexDesignerInfo.TableName };
index.Name = indexDesignerInfo.Name;
index.IsUnique = indexDesignerInfo.Type == IndexType.Unique.ToString();
index.Clustered = indexDesignerInfo.Clustered;
index.Comment = indexDesignerInfo.Comment;
index.Columns.AddRange(indexDesignerInfo.Columns);
int order = 1;
index.Columns.ForEach(item => { item.Order = order++; });
schemaInfo.TableIndexes.Add(index);
}
}
}
#endregion
#region Foreign Keys
if (!schemaDesignerInfo.IgnoreTableForeignKey)
{
foreach (TableForeignKeyDesignerInfo keyDesignerInfo in schemaDesignerInfo.TableForeignKeyDesignerInfos)
{
TableForeignKey foreignKey = new TableForeignKey() { Owner = keyDesignerInfo.Owner, TableName = keyDesignerInfo.TableName };
foreignKey.Name = keyDesignerInfo.Name;
foreignKey.ReferencedTableName = keyDesignerInfo.ReferencedTableName;
foreignKey.UpdateCascade = keyDesignerInfo.UpdateCascade;
foreignKey.DeleteCascade = keyDesignerInfo.DeleteCascade;
foreignKey.Comment = keyDesignerInfo.Comment;
foreignKey.Columns.AddRange(keyDesignerInfo.Columns);
int order = 1;
foreignKey.Columns.ForEach(item => { item.Order = order++; });
schemaInfo.TableForeignKeys.Add(foreignKey);
}
}
#endregion
#region Constraint
if (!schemaDesignerInfo.IgnoreTableConstraint)
{
foreach (TableConstraintDesignerInfo constraintDesignerInfo in schemaDesignerInfo.TableConstraintDesignerInfos)
{
TableConstraint constraint = new TableConstraint() { Owner = constraintDesignerInfo.Owner, TableName = constraintDesignerInfo.TableName };
constraint.Name = constraintDesignerInfo.Name;
constraint.Definition = constraintDesignerInfo.Definition;
constraint.Comment = constraintDesignerInfo.Comment;
schemaInfo.TableConstraints.Add(constraint);
}
}
#endregion
return schemaInfo;
}
