///// <summary>
///// Applies project settings to .NET data type
///// </summary>
//private string NaturalizeNames_DotNetType(string dotNetTypeName)
//{
// return dotNetTypeName.Replace(DbColumn.DotNetArrayIdenticator, _patternProject.LanguageSettings.ArrayIdenticator);
//}
/// <summary>
/// Applies project settings to fields name
/// </summary>
/// <param name="table"></param>
/// <param name="fieldName"></param>
/// <param name="isAlreadyMember">is the field aready member of the table, or it is an external</param>
/// <returns></returns>
private string NaturalizeNames_FieldName(DbTable table, DbColumn column, string fieldName, bool isAlreadyMember)
{
if (string.IsNullOrEmpty(fieldName))
return fieldName;
var newName = fieldName;
var stringCompare = StringComparison.InvariantCulture;
if (_patternProject.LanguageSettings.KeywordsCaseSensitive == false)
stringCompare = StringComparison.InvariantCultureIgnoreCase;
// suppress pattern
string replacement = _patternProject.LanguageSettings.LanguageKeywordsSuppress;
// renaming options
newName = NaturalizeNames_RenamingOptions(newName, _projectDef.RenamingOptions, false, true);
// remove names
newName = NaturalizeNames_Name_RemoveInvalidChars(newName);
int initReplacePartCount = 0;
string initReplacePartStr = "";
// column name should not be same
if (newName.Equals(table.TableNameSchema, stringCompare) ||
newName.Equals(table.TableNameSchemaCS, stringCompare))
{
var renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
// no duplicate
while (table.FindColumnSchema(renamedName) != null)
{
renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
}
newName = renamedName;
}
// field name is not changed and is a member
if (newName.Equals(fieldName, stringCompare) && isAlreadyMember)
{
var sameNameColumns =
table.SchemaColumns.Where(x => x.FieldNameSchema.Equals(newName, stringCompare)).ToList();
// no more than one accurance, including itself
if (sameNameColumns.Count > 1 &&
sameNameColumns.IndexOf(column) > 0)
{
var renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
// no duplicate
while (table.FindColumnSchema(renamedName) != null)
{
renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
}
newName = renamedName;
}
}
else
{
if (table.FindColumnSchema(newName) != null)
{
var renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
// no duplicate
while (table.FindColumnSchema(renamedName) != null)
{
renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
}
newName = renamedName;
}
}
// checking keyword match if only not changed field name
if (newName.Equals(fieldName, stringCompare))
{
// ignoring keywords
foreach (var keyword in _patternProject.LanguageSettings.LanguageKeywords)
{
// keyword match
if (newName.Equals(keyword, stringCompare))
{
var renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
// no duplicate
while (table.FindColumnSchema(renamedName) != null)
{
renamedName = string.Format(replacement, newName, initReplacePartStr);
initReplacePartCount++;
initReplacePartStr = initReplacePartCount.ToString();
}
newName = renamedName;
// name is chaned and check is no longer required
break;
}
}
}
// field name is ok to be used
return newName;
}
/// <summary>
/// Column data type is nullabe
/// </summary>
private bool Determine_DataTypeNullable(DbColumn dbColumn)
{
if (dbColumn.IsArray(_patternProject.LanguageSettings.ArrayIdenticator))
return true;
var stringCompare = StringComparison.CurrentCulture;
if (!_patternProject.LanguageSettings.KeywordsCaseSensitive)
stringCompare = StringComparison.InvariantCultureIgnoreCase;
foreach (var dataType in _patternProject.LanguageSettings.NullableDataTypes)
{
var type = "." + dataType;
if (dbColumn.DataTypeDotNet.EndsWith(type, stringCompare))
{
return true;
}
if (dataType.Equals(dbColumn.DataTypeDotNet, stringCompare))
{
return true;
}
}
return false;
}
private bool Determine_ExplicitCastDataType(DbColumn dbColumn)
{
if (dbColumn.IsArray(_patternProject.LanguageSettings.ArrayIdenticator))
return true;
var stringCompare = StringComparison.CurrentCulture;
if (!_patternProject.LanguageSettings.KeywordsCaseSensitive)
stringCompare = StringComparison.InvariantCultureIgnoreCase;
// any type that has any dot (.) in it!
if (dbColumn.DataTypeDotNet.IndexOf('.') != -1)
return true;
foreach (var dataType in _patternProject.LanguageSettings.ExplicitCastDataTypes)
{
if (dataType.Equals(dbColumn.DataTypeDotNet, stringCompare))
{
return true;
}
}
return false;
}
/// <summary>
/// One table, one column or one foreignKey in table!
/// </summary>
string PatternContentAppliesTo_OneTable(string baseContent,
List<PatternContent> patternContent,
DbTable table,
DbColumn column,
DbForeignKey foreignKey)
{
string appliedContent = "";
// ---------------------------------
// Only one table is applying here!
// table can not be null here
if (table == null)
{
return baseContent;
}
foreach (var pattern in patternContent)
{
string replacementName = string.Format(ReplaceConsts.PatternContentReplacer, pattern.Name);
// is there a pattern for that
if (baseContent.IndexOf(replacementName) == -1)
continue;
switch (pattern.ConditionKeyMode)
{
case PatternConditionKeyMode.General:
// nothing!
break;
case PatternConditionKeyMode.TablesAll:
case PatternConditionKeyMode.ViewsAll:
case PatternConditionKeyMode.TablesAndViewsAll:
// for one table? Meh, we do nothing!
break;
case PatternConditionKeyMode.TableAutoIncrement:
case PatternConditionKeyMode.TableIndexConstraint:
case PatternConditionKeyMode.TablePrimaryKey:
case PatternConditionKeyMode.TableUniqueConstraint:
appliedContent = ConditionItem_AppliesToTable(pattern, table);
// base content
if (!string.IsNullOrEmpty(pattern.BaseContent))
{
appliedContent = pattern.BaseContent.Replace(ReplaceConsts.PatternContentInnerContents, appliedContent);
}
// internal pattern contents
if (pattern.ConditionContents.Count > 0)
{
// nested call
appliedContent = PatternContentAppliesTo_OneTable(appliedContent, pattern.ConditionContents, table, null, null);
}
// replace the content
baseContent = baseContent.Replace(replacementName, appliedContent);
break;
case PatternConditionKeyMode.Field:
case PatternConditionKeyMode.FieldCondensedType:
case PatternConditionKeyMode.FieldKeyReadType:
case PatternConditionKeyMode.FieldKeyType:
case PatternConditionKeyMode.FieldPrimaryKey:
case PatternConditionKeyMode.FieldReferencedKeyType:
appliedContent = "";
// no special column is specified
if (column == null)
{
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
}
else
{
// Apply the replacement to the pattern content
string columnReplace = ConditionItem_AppliesToColumn(pattern, table, column);
// The seperator
if (!string.IsNullOrEmpty(columnReplace))
{
// internal pattern contents
// FOR EACH column
if (pattern.ConditionContents.Count > 0)
{
// nested call
columnReplace = PatternContentAppliesTo_OneTable(
columnReplace,
pattern.ConditionContents,
table,
column,
null);
}
appliedContent += columnReplace + pattern.ItemsSeperator;
}
}
// Remove additional ItemsSeperator
if (!string.IsNullOrEmpty(pattern.ItemsSeperator)
&& appliedContent.EndsWith(pattern.ItemsSeperator))
appliedContent = appliedContent.Remove(appliedContent.Length - pattern.ItemsSeperator.Length, pattern.ItemsSeperator.Length);
// internal pattern contents
// FOR EACH column
if (pattern.ConditionContents.Count > 0)
{
// nested call
appliedContent = PatternContentAppliesTo_OneTable(appliedContent, pattern.ConditionContents, table, null, null);
}
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
break;
case PatternConditionKeyMode.FieldsAll:
case PatternConditionKeyMode.FieldsCondensedTypeAll:
case PatternConditionKeyMode.FieldsKeyReadTypeAll:
case PatternConditionKeyMode.FieldsKeyTypeAll:
case PatternConditionKeyMode.FieldsPrimaryKeyAll:
case PatternConditionKeyMode.FieldsReferencedKeyTypeAll:
appliedContent = "";
// fetch the columns and apply the replacement operation
foreach (var tableColumn in table.SchemaColumns)
{
// Apply the replacement to the pattern content
string columnReplace = ConditionItem_AppliesToColumn(pattern, table, tableColumn);
// The seperator
if (!string.IsNullOrEmpty(columnReplace))
{
// internal pattern contents
// FOR EACH column
if (pattern.ConditionContents.Count > 0)
{
// nested call
columnReplace = PatternContentAppliesTo_OneTable(
columnReplace,
pattern.ConditionContents,
table,
tableColumn, null);
}
appliedContent += columnReplace + pattern.ItemsSeperator;
}
}
// Remove additional ItemsSeperator
if (!string.IsNullOrEmpty(pattern.ItemsSeperator)
&& appliedContent.EndsWith(pattern.ItemsSeperator))
appliedContent = appliedContent.Remove(appliedContent.Length - pattern.ItemsSeperator.Length, pattern.ItemsSeperator.Length);
// internal pattern contents
// FOR EACH column
if (pattern.ConditionContents.Count > 0)
{
// nested call
appliedContent = PatternContentAppliesTo_OneTable(appliedContent, pattern.ConditionContents, table, null, null);
}
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
break;
case PatternConditionKeyMode.ForeignKeyDeleteAction:
case PatternConditionKeyMode.ForeignKeyUpdateAction:
case PatternConditionKeyMode.FieldForeignKey:
appliedContent = "";
if (foreignKey == null)
{
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
}
else
{
// Apply the replacement to the pattern content
string columnReplace = ConditionItem_AppliesToForeignKeyColumns(pattern, table, foreignKey);
// The seperator
if (!string.IsNullOrEmpty(columnReplace))
{
// internal pattern contents
if (pattern.ConditionContents.Count > 0)
{
// nested call
columnReplace = PatternContentAppliesTo_OneTable(
columnReplace,
pattern.ConditionContents,
table,
null,
foreignKey);
}
appliedContent += columnReplace + pattern.ItemsSeperator;
}
}
// Remove additional ItemsSeperator
if (!string.IsNullOrEmpty(pattern.ItemsSeperator)
&& appliedContent.EndsWith(pattern.ItemsSeperator))
appliedContent = appliedContent.Remove(appliedContent.Length - pattern.ItemsSeperator.Length, pattern.ItemsSeperator.Length);
// internal pattern contents
if (pattern.ConditionContents.Count > 0)
{
// nested call
appliedContent = PatternContentAppliesTo_OneTable(appliedContent, pattern.ConditionContents, table, null, null);
}
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
break;
case PatternConditionKeyMode.FieldsForeignKeyAll:
case PatternConditionKeyMode.TableForeignKey:
appliedContent = "";
// fetch the columns and apply the replacement operation
foreach (var dbForeignKey in table.ForeignKeys)
{
// Apply the replacement to the pattern content
string columnReplace = ConditionItem_AppliesToForeignKeyColumns(pattern, table, dbForeignKey);
// The seperator
if (!string.IsNullOrEmpty(columnReplace))
{
// internal pattern contents
if (pattern.ConditionContents.Count > 0)
{
// nested call
columnReplace = PatternContentAppliesTo_OneTable(
columnReplace,
pattern.ConditionContents,
table,
null,
dbForeignKey);
}
appliedContent += columnReplace + pattern.ItemsSeperator;
}
}
// Remove additional ItemsSeperator
if (!string.IsNullOrEmpty(pattern.ItemsSeperator)
&& appliedContent.EndsWith(pattern.ItemsSeperator))
appliedContent = appliedContent.Remove(appliedContent.Length - pattern.ItemsSeperator.Length, pattern.ItemsSeperator.Length);
// internal pattern contents
if (pattern.ConditionContents.Count > 0)
{
// nested call
appliedContent = PatternContentAppliesTo_OneTable(appliedContent, pattern.ConditionContents, table, null, null);
}
// replace in the main content
baseContent = Common.ReplaceEx(baseContent, replacementName, appliedContent, StringComparison.CurrentCulture);
break;
default:
break;
}
}
return baseContent;
}
/// <summary>
/// Get field type database full name
/// </summary>
private string FieldType_ColumnDataTypeSize(DbColumn column)
{
string cleanType = (column.DataTypeDotNet);
if (cleanType == "String" &&
column.DataTypeDb.ToLower().IndexOf(_patternProject.LanguageSettings.TextFieldIdenticator) == -1)
return column.DataTypeDb + "(" + column.Length + ")";
if (column.DataTypeDb.ToLower() == _patternProject.LanguageSettings.DbDecimalName.ToLower())
{
return _patternProject.LanguageSettings.DbDecimalType
.Replace(ReplaceConsts.Pattern_LanguageSettings_Precision, column.NumericPrecision.ToString())
.Replace(ReplaceConsts.Pattern_LanguageSettings_Scale, column.NumericScale.ToString());
}
else if (column.DataTypeDb.ToLower() == _patternProject.LanguageSettings.DbNumericName.ToLower())
{
return _patternProject.LanguageSettings.DbNumericType
.Replace(ReplaceConsts.Pattern_LanguageSettings_Precision, column.NumericPrecision.ToString())
.Replace(ReplaceConsts.Pattern_LanguageSettings_Scale, column.NumericScale.ToString());
}
return column.DataTypeDb;
}
/// <summary>
/// Get field size
/// </summary>
private string FieldType_ColumnDataSize(DbColumn column)
{
if (column.Length > 0)
return column.Length.ToString();
if (column.DataTypeMaxLength > 0)
return column.DataTypeMaxLength.ToString();
return "0";
}
/// <summary>
/// Partial content replacer.
/// </summary>
string ConditionItem_AppliesToColumn(PatternContent partialContent, DbTable table, DbColumn column)
{
switch (partialContent.ConditionKeyMode)
{
//case PatternConditionKeyMode.DatabaseProvider:
// ConditionItem dbReplacer = null;
// switch (this._database.Provider)
// {
// case DatabaseProvider.Oracle:
// dbReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.DatabaseProvider._Oracle);
// break;
// case DatabaseProvider.SQLServer:
// dbReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.DatabaseProvider.SQLServer);
// break;
// case DatabaseProvider.SQLite:
// dbReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.DatabaseProvider.SQLite);
// break;
// case DatabaseProvider.SqlCe4:
// dbReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.DatabaseProvider.SqlCe4);
// break;
// }
// if (dbReplacer == null)
// return "";
// // Replace the contents
// return Replacer_ConditionItem_AppliesToColumn(dbReplacer.Content, table, column);
case PatternConditionKeyMode.FieldsAll:
case PatternConditionKeyMode.Field:
var replacer = partialContent.GetFirst();
// Replace the contents
return Replacer_ConditionItem_AppliesToColumn(replacer.ContentText, table, column);
case PatternConditionKeyMode.FieldsCondensedTypeAll:
case PatternConditionKeyMode.FieldCondensedType:
ConditionItem replacerCondensedType = null;
switch (column.DataCondensedType)
{
case DbColumn.ColumnCondensedType.None:
replacerCondensedType = partialContent.GetReplacement(ConditionKeyModeConsts.FieldCondensedType.None);
break;
case DbColumn.ColumnCondensedType.String:
replacerCondensedType = partialContent.GetReplacement(ConditionKeyModeConsts.FieldCondensedType.String);
break;
case DbColumn.ColumnCondensedType.Decimal:
replacerCondensedType = partialContent.GetReplacement(ConditionKeyModeConsts.FieldCondensedType.Decimal);
break;
case DbColumn.ColumnCondensedType.Integer:
replacerCondensedType = partialContent.GetReplacement(ConditionKeyModeConsts.FieldCondensedType.Integer);
break;
}
// Replace the contents
if (replacerCondensedType != null)
return Replacer_ConditionItem_AppliesToColumn(replacerCondensedType.ContentText, table, column);
return string.Empty;
case PatternConditionKeyMode.FieldsPrimaryKeyAll:
case PatternConditionKeyMode.FieldPrimaryKey:
ConditionItem primaryReplacer;
if (column.PrimaryKey)
primaryReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldPrimaryKey.PrimaryKey);
else
primaryReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldPrimaryKey.NormalField);
// Replace the contents
return Replacer_ConditionItem_AppliesToColumn(primaryReplacer.ContentText, table, column);
case PatternConditionKeyMode.FieldReferencedKeyType:
case PatternConditionKeyMode.FieldKeyType:
case PatternConditionKeyMode.FieldsReferencedKeyTypeAll:
case PatternConditionKeyMode.FieldsKeyTypeAll:
ConditionItem keyTypeReplacer;
// this key is not reference type
if (_patternProject.SeperateReferenceColumns)
{
if (column.IsReferenceKey && partialContent.ConditionKeyMode == PatternConditionKeyMode.FieldsKeyTypeAll)
return "";
if (!column.IsReferenceKey && partialContent.ConditionKeyMode == PatternConditionKeyMode.FieldsReferencedKeyTypeAll)
return "";
}
// Key type
bool dataTypeNotNullable = !column.DataTypeNullable;
if (column.AutoIncrement && column.PrimaryKey)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.AutoInrcementPrimaryKey);
}
else if (column.AutoIncrement && column.AllowNull && !dataTypeNotNullable)
{
// AutoIncrement
// Nullable column
// Nullable object
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.AutoIncNativeNullable);
}
else if (column.AutoIncrement && column.AllowNull && dataTypeNotNullable)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.AutoIncNullableType);
}
else if (column.AutoIncrement)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.AutoInrcement);
}
else if (column.PrimaryKey)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.PrimaryKey);
}
else if (column.AllowNull && !dataTypeNotNullable)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.NativeNullable);
}
else if (column.AllowNull && dataTypeNotNullable)
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.NullableType);
}
else
{
keyTypeReplacer = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyType.NormalField);
}
// Replace the contents
return Replacer_ConditionItem_AppliesToColumn(keyTypeReplacer.ContentText, table, column);
case PatternConditionKeyMode.FieldsKeyReadTypeAll:
case PatternConditionKeyMode.FieldKeyReadType:
ConditionItem keyRead;
bool canConvert = !column.ExplicitCastDataType; // TODO
// how to read key type
if (!column.AllowNull && canConvert)
{
keyRead = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyReadType.NormalField_Convert);
}
else if (!column.AllowNull && !canConvert)
{
keyRead = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyReadType.NormalField_Cast);
}
else if (column.AllowNull && canConvert)
{
keyRead = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyReadType.Nullable_Convert);
}
else
{
keyRead = partialContent.GetReplacement(ConditionKeyModeConsts.FieldKeyReadType.Nullable_Cast);
}
// Replace the contents
return Replacer_ConditionItem_AppliesToColumn(keyRead.ContentText, table, column);
default:
// Ignored
return "";
}
}
/// <summary>
/// Applies column data to pattern content replacement
/// </summary>
string Replacer_ConditionItem_AppliesToColumn(string content, DbTable table, DbColumn column)
{
// table of the column
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.TableName, table.TableNameSchema);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.TableNameDb, table.TableName);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.TableOwnerName, table.OwnerName);
// general
content = Replacer_GeneratorGeneral(content);
// database provider class
content = Replacer_DatabaseProvider(content);
// referenced table of the column
if (column.IsReferenceKey && column.IsReferenceKeyTable != null)
{
var refTable = column.IsReferenceKeyTable;
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.TableNameRefField, refTable.TableNameSchema);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.TableNameDbRefField, refTable.TableName);
}
// column information
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldDataType, column.DataTypeDotNet);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldName, column.FieldNameSchema);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldNameDb, column.FieldNameDb);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldOrdinalValue, column.ColumnOrdinal.ToString());
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldIsPrimaryKey, column.PrimaryKey.ToString().ToLower());
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldCanBeNull, column.AllowNull.ToString().ToLower());
// column description
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldDescription, column.UserDescription);
// Database field type
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldDbType, column.DataTypeDb);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldDbTypeSize, FieldType_ColumnDataTypeSize(column));
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.FieldDbSize, FieldType_ColumnDataSize(column));
if (column.AutoIncrement)
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.AutoIncrementDataType, column.DataTypeDotNet);
else
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.AutoIncrementDataType, _patternProject.LanguageSettings.VoidDataType);
if (column.PrimaryKey)
{
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDbType, column.DataTypeDb);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDbTypeSize, FieldType_ColumnDataTypeSize(column));
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDataType, column.DataTypeDotNet);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyName, column.FieldNameSchema);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyNameDb, column.FieldNameDb);
}
else
{
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDbType, "");
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDbTypeSize, "");
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyDataType, _patternProject.LanguageSettings.VoidDataType);
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyName, "");
content = Common.ReplaceExIgnoreCase(content, ReplaceConsts.PrimaryKeyNameDb, "");
}
return content;
}