private string GetEscapedReservedName(string name, string appendValue, bool checkExtraReserved)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (appendValue == null)
{
throw new ArgumentNullException(nameof(appendValue));
}
// Use case-sensitive comparisons to reduce generated names
if (ReservedWords.Contains(name, StringComparer.Ordinal))
{
name += appendValue;
}
// If checkExtraReserved is true, we also includes some more words to escape
if (checkExtraReserved && ExtraReservedWords.Contains(name, StringComparer.Ordinal))
{
name += appendValue;
}
return(name);
}
public override string IsNameLegal(string desiredName, IIdentifier whoIsAsking)
{
if (whoIsAsking is Property && ReservedWords.Contains(desiredName, StringComparer.OrdinalIgnoreCase))
{ // ignore case in case of properties, since the property will be used with altered case in the model constructor => bad
return(desiredName);
}
return(base.IsNameLegal(desiredName, whoIsAsking));
}
/// <summary>
/// Is a word not reserved or ill-formed?
/// Throws ScriptException if not.
/// </summary>
/// <param name="name">Name to check</param>
public static void ValidateName(string name)
{
if (ReservedWords.Contains(name))
{
throw new ScriptException("Name is reserved: " + name);
}
if (!ValidNames.IsMatch(name))
{
throw new ScriptException("Names must start with a letter and contain only letters, digits, or underscores: " + name);
}
}
private static string ValidateName(NWPlayer player)
{
string error = string.Empty;
string name = player.Name.ToLower();
string[] words = name.Split(null);
foreach (var word in words)
{
if (ReservedWords.Contains(word))
{
error = "Your character has a reserved word in his or her name. Please remake your character and use a different name. Note that famous Star Wars names are not allowed to be used for your character. Offending word: " + word;
break;
}
}
return(error);
}
/// <summary>
/// Converts names the conflict with Go reserved terms by appending the passed appendValue.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="appendValue">String to append.</param>
/// <returns>The transformed reserved name</returns>
protected override string GetEscapedReservedName(string name, string appendValue)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (appendValue == null)
{
throw new ArgumentNullException(nameof(appendValue));
}
// Use case-sensitive comparisons to reduce generated names
if (ReservedWords.Contains(name, StringComparer.Ordinal))
{
name += appendValue;
}
return(name);
}
public static bool IsReservedWord(string word)
{
return(ReservedWords.Contains(word.ToUpper()));
}
protected void ValidateTable(IDbConnection connection, EntityInfo entity)
{
using (var command = new FbCommand())
{
command.Connection = connection as FbConnection;
// first make sure the table exists
//var sql = string.Format("SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{0}'", entity.EntityAttribute.NameInStore);
var sql = string.Format("SELECT COUNT(*) FROM sysobjects WHERE xtype='u' AND name='{0}'", entity.EntityAttribute.NameInStore);
command.CommandText = sql;
var count = Convert.ToInt32(command.ExecuteScalar());
if (count == 0)
{
CreateTable(connection, entity);
}
else
{
foreach (var field in entity.Fields)
{
if (ReservedWords.Contains(field.FieldName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(field.FieldName);
}
// yes, I realize hard-coded ordinals are not a good practice, but the SQL isn't changing, it's method specific
sql = string.Format("SELECT column_name, " // 0
+ "data_type, " // 1
+ "character_maximum_length, " // 2
+ "numeric_precision, " // 3
+ "numeric_scale, " // 4
+ "is_nullable "
+ "FROM information_schema.columns "
+ "WHERE (table_name = '{0}' AND column_name = '{1}')",
entity.EntityAttribute.NameInStore, field.FieldName);
command.CommandText = sql;
using (var reader = command.ExecuteReader())
{
if (!reader.Read())
{
// field doesn't exist - we must create it
var alter = new StringBuilder(string.Format("ALTER TABLE {0} ", entity.EntityAttribute.NameInStore));
alter.Append(string.Format("ADD [{0}] {1} {2}",
field.FieldName,
GetFieldDataTypeString(entity.EntityName, field),
GetFieldCreationAttributes(entity.EntityAttribute, field)));
using (var altercmd = new FbCommand(alter.ToString(), connection as FbConnection))
{
altercmd.ExecuteNonQuery();
}
}
else
{
// TODO: verify field length, etc.
}
}
}
}
}
}
protected override void CreateTable(IDbConnection connection, EntityInfo entity, Boolean forceMultiplePrimaryKeysSyntax)
{
Boolean bTableExists = false;
Boolean bMultiplePrimaryKeys = false;
if (ReservedWords.Contains(entity.EntityName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(entity.EntityName);
}
bTableExists = TableExists(connection, entity);
bMultiplePrimaryKeys = entity.Fields.KeyFields.Count > 1;
// Handles the case of tables with multiple primary keys
if (!bTableExists)
{
StringBuilder sql = new StringBuilder();
StringBuilder keys = new StringBuilder();
sql.AppendFormat("CREATE TABLE {0} ( ", entity.EntityName);
int count = entity.Fields.Count;
int keycount = entity.Fields.KeyFields.Count;
if (count > 0)
{
foreach (var field in entity.Fields)
{
sql.AppendFormat(" {0} {1} {2} ",
field.FieldName,
GetFieldDataTypeString(entity.EntityName, field),
GetFieldCreationAttributes(entity.EntityAttribute, field, true));
if (field.IsPrimaryKey)
{
keys.Append(field.FieldName);
if (--keycount > 0)
{
keys.Append(", ");
}
}
if (--count > 0)
{
sql.Append(", ");
}
}
sql.AppendFormat(", PRIMARY KEY({0}) )", keys.ToString());
}
using (var command = GetNewCommandObject())
{
command.CommandText = sql.ToString();
command.Connection = connection;
int i = command.ExecuteNonQuery();
}
bTableExists = true;
foreach (var field in entity.Fields)
{
if (field.SearchOrder != FieldOrder.None)
{
field.IndexName = VerifyIndex(entity.EntityName, field.FieldName, field.SearchOrder, connection);
}
}
}
else
{
foreach (var field in entity.Fields)
{
StringBuilder sql = new StringBuilder();
if (!FieldExists(connection, entity, field))
{
if (ReservedWords.Contains(field.FieldName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(field.FieldName);
}
sql.AppendFormat("ALTER TABLE {0} ADD ", entity.EntityName);
// ALTER TABLE {TABLENAME}
// ADD {COLUMNNAME} {TYPE} {NULL|NOT NULL}
// CONSTRAINT {CONSTRAINT_NAME} DEFAULT {DEFAULT_VALUE}
sql.AppendFormat(" {0} {1} {2} ",
field.FieldName,
GetFieldDataTypeString(entity.EntityName, field),
GetFieldCreationAttributes(entity.EntityAttribute, field, bMultiplePrimaryKeys));
using (var command = GetNewCommandObject())
{
command.CommandText = sql.ToString();
command.Connection = connection;
int i = command.ExecuteNonQuery();
}
// create indexes
if (field.SearchOrder != FieldOrder.None)
{
field.IndexName = VerifyIndex(entity.EntityName, field.FieldName, field.SearchOrder, connection);
}
}
else
{
// create indexes
if (field.SearchOrder != FieldOrder.None)
{
field.IndexName = VerifyIndex(entity.EntityName, field.FieldName, field.SearchOrder, connection);
}
}
}
}
}
public bool IsReservedWord(string word)
{
return(ReservedWords.Contains(word));
}
protected override void ValidateTable(IDbConnection connection, IEntityInfo entity)
{
// first make sure the table exists
if (!TableExists(entity.EntityAttribute.NameInStore))
{
CreateTable(connection, entity);
return;
}
using (var command = GetNewCommandObject())
{
command.Transaction = CurrentTransaction;
command.Connection = connection;
foreach (var field in entity.Fields)
{
if (ReservedWords.Contains(field.FieldName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(field.FieldName);
}
// yes, I realize hard-coded ordinals are not a good practice, but the SQL isn't changing, it's method specific
var sql = string.Format(
"SELECT COLUMN_NAME, "
+ "DATA_TYPE, "
+ "DATA_LENGTH, "
+ "DATA_PRECISION, "
+ "DATA_SCALE, "
+ "NULLABLE "
+ "FROM all_tab_cols "
+ "WHERE (UPPER(table_name) = UPPER('{0}') AND UPPER(column_name) = UPPER('{1}'))",
entity.EntityAttribute.NameInStore, field.FieldName);
command.CommandText = sql;
using (var reader = command.ExecuteReader())
{
if (!reader.Read())
{
// field doesn't exist - we must create it
var alter = new StringBuilder(string.Format("ALTER TABLE {0} ", entity.EntityAttribute.NameInStore));
alter.Append(string.Format("ADD {0} {1} {2}",
field.FieldName,
GetFieldDataTypeString(entity.EntityName, field),
GetFieldCreationAttributes(entity.EntityAttribute, field)));
using (var altercmd = GetNewCommandObject())
{
altercmd.CommandText = alter.ToString();
altercmd.Connection = connection;
var result = altercmd.ExecuteNonQuery();
altercmd.Dispose();
}
}
else
{
// TODO: verify field length, etc.
}
}
}
}
}
public void EnsueValidAndUnique(GeneratorParameters generatorParameters)
{
var addedParamNames = new List <string>();
for (int idx = 0; idx < ParameterCount; idx++)
{
var parameter = Parameters[idx];
var managedName = parameter.Name;
if (generatorParameters.ForceMeaningfulParameterNames)
{
// if the parameter name is generated, try harder
var isGenerated =
managedName.StartsWith("p") &&
managedName.Length > 1 &&
char.IsDigit(managedName[1]);
if (isGenerated)
{
// remove generics part (eg: SomeType<T>)
var type = genericTemplate.Replace(parameter.Type, string.Empty);
// get the type as the parameter name
type = type.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault() ?? "param";
// change arrays
if (type.EndsWith("[]"))
{
type = type.Replace("[]", "Array");
}
// remove invalid characters
type = alphanumericTemplate.Replace(type, string.Empty);
// make sure it is camel case
managedName = type[0].ToString().ToLower() + type.Substring(1);
}
}
// fix any bad C# parameter names
if (generatorParameters.ParameterCasing != TextCasing.Original)
{
if (generatorParameters.ParameterCasing == TextCasing.Pascal)
{
managedName = char.ToUpper(managedName[0]) + string.Concat(managedName.Skip(1));
}
else if (generatorParameters.ParameterCasing == TextCasing.Camel)
{
managedName = char.ToLower(managedName[0]) + string.Concat(managedName.Skip(1));
}
}
if (ReservedWords.Contains(managedName))
{
managedName = generatorParameters.ReservedPrefix + managedName + generatorParameters.ReservedSuffix;
}
//if (!managedName.StartsWith("@"))
//{
// managedName = "@" + managedName;
//}
// make sure the name is unique for this method
var tmpName = managedName;
int pi = 2;
while (addedParamNames.Contains(tmpName))
{
tmpName = managedName + pi++;
}
addedParamNames.Add(tmpName);
parameter.ManagedName = tmpName;
}
}
/// <summary>
/// Is a name something used internally by metastrings?
/// </summary>
public static bool IsNameReserved(string name)
{
return(ReservedWords.Contains(name.ToLower()));
}
protected override void ValidateTable(IDbConnection connection, IEntityInfo entity)
{
// first make sure the table exists
if (!TableExists(entity.EntityAttribute.NameInStore))
{
CreateTable(connection, entity);
return;
}
using (var command = GetNewCommandObject())
{
command.Transaction = CurrentTransaction;
command.Connection = connection;
foreach (var field in entity.Fields)
{
if (ReservedWords.Contains(field.FieldName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(field.FieldName);
}
// yes, I realize hard-coded ordinals are not a good practice, but the SQL isn't changing, it's method specific
var sql = string.Format("SELECT column_name, " // 0
+ "data_type, " // 1
+ "character_maximum_length, " // 2
+ "numeric_precision, " // 3
+ "numeric_scale, " // 4
+ "is_nullable "
+ "FROM information_schema.columns "
+ "WHERE (table_name = '{0}' AND column_name = '{1}')",
entity.EntityAttribute.NameInStore, field.FieldName);
command.CommandText = sql;
using (var reader = command.ExecuteReader())
{
if (!reader.Read())
{
// field doesn't exist - we must create it
var alter = new StringBuilder(string.Format("ALTER TABLE {0} ", entity.EntityAttribute.NameInStore));
alter.Append(string.Format("ADD {0} {1} {2}",
field.FieldName,
GetFieldDataTypeString(entity.EntityName, field),
GetFieldCreationAttributes(entity.EntityAttribute, field)));
using (var alterConnection = GetNewConnectionObject())
using (var altercmd = GetNewCommandObject())
{
alterConnection.Open();
altercmd.CommandText = alter.ToString();
altercmd.Connection = alterConnection;
altercmd.ExecuteNonQuery();
}
}
else
{
// TODO: verify field length, etc.
}
}
}
}
}
public bool IsReserved(string value)
{
return(ReservedWords.Contains(value));
}
