private void MergeFlags(EntityFieldFlags loadedFlags, EntityFieldFlags toTest)
{
_flags = _flags | toTest;
if ((loadedFlags & toTest) == 0)
{
_flags = _flags ^ toTest;
}
}
/// <summary>
/// Initializes the object.
/// </summary>
/// <param name="dbType"></param>
/// <param name="isNullable"></param>
/// <param name="length"></param>
private void Initialize(DbType dbType, long length, EntityFieldFlags flags)
{
_dbType = dbType;
_length = length;
_flags = flags;
// json...
this.JsonName = this.DefaultJsonName;
}
/// <summary>
/// Returns true if the given flag is set.
/// </summary>
/// <param name="flags"></param>
/// <returns></returns>
public bool GetEntityFieldFlags(EntityFieldFlags flags)
{
if ((this.Flags & flags) == flags)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Returns true if the given flag is set.
/// </summary>
/// <param name="flags"></param>
/// <returns></returns>
private void SetEntityFieldFlags(EntityFieldFlags flags, bool value)
{
_flags = _flags | flags;
if (!(value))
{
_flags = _flags ^ flags;
}
// set...
this.OnFlagsChanged();
}
/// <summary>
/// Constructor.
/// </summary>
public EntityField(string name, string nativeName, DbType dbType, EntityFieldFlags flags, long size) : base(name, nativeName)
{
// are we allowed to have a size?
if (ConversionHelper.DoesDBTypeHaveFixedSize(dbType) == true)
{
throw new InvalidOperationException(string.Format(Cultures.Exceptions, "Cannot specify a size for '{0}'.", dbType));
}
// set...
this.Initialize(dbType, flags, size);
}
/// <summary>
/// Constructor.
/// </summary>
public EntityFieldAttribute(string nativeName, DbType dbType, EntityFieldFlags flags)
{
// set...
_nativeName = nativeName;
_dbType = dbType;
_flags = flags;
_sizeDefined = false;
// default...
_default = EntityField.GetDefaultDefault(dbType, flags);
}
internal override void Merge(System.Xml.XmlElement element, bool createIfNotFound)
{
base.Merge(element, createIfNotFound);
// load the values...
this.EnumerationTypeName = XmlHelper.GetElementString(element, "EnumerationTypeName", OnNotFound.ReturnNull);
_length = XmlHelper.GetElementInt64(element, "Length", OnNotFound.ReturnNull);
_dbType = (DbType)XmlHelper.GetElementEnumerationValue(element, "DbType", typeof(DbType), OnNotFound.ReturnNull);
// we don't merge in all field values - basically just those that we can set. (e.g. if the DB changes from Nullable to NotNullable,
// we don't want to replace that flag.)
// mbr - 13-11-2005 - added...
EntityFieldFlags loadedFlags = (EntityFieldFlags)XmlHelper.GetElementEnumerationValue(element, "Flags", typeof(EntityFieldFlags), OnNotFound.ReturnNull);
// mbr - 21-09-2007 - do we actually have modifiers?
string modifiersAsString = XmlHelper.GetElementString(element, "Modifiers", OnNotFound.ReturnNull);
if (modifiersAsString != null && modifiersAsString.Length > 0)
{
this.Modifiers = (ColumnModifiers)Enum.Parse(typeof(ColumnModifiers), modifiersAsString, true);
}
// dto...
var jsonName = element.GetElementString("JsonName", OnNotFound.ReturnNull);
if (!(string.IsNullOrEmpty(jsonName)))
{
this.JsonName = jsonName;
}
else
{
this.JsonName = DefaultJsonName;
}
var asString = element.GetElementString("GenerateDtoField", OnNotFound.ReturnNull);
if (!(string.IsNullOrEmpty(asString)))
{
this.GenerateDtoField = ConversionHelper.ToBoolean(asString);
}
else
{
if (!(this.IsLarge))
{
this.GenerateDtoField = this.Table.GenerateDto;
}
else
{
this.GenerateDtoField = false;
}
}
}
/// <summary>
/// Creates a column from the given row.
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private SqlColumn GetSchemaColumn(DataRow row)
{
if (row == null)
{
throw new ArgumentNullException("row");
}
// get...
string nativeName = (string)row["column_name"];
string isNullableAsString = (string)row["is_nullable"];
string dataTypeAsString = (string)row["data_type"];
// mbr - 2008-08-31 - MySQL implementation means this int has to be a long?
//int length = -1;
long length = -1;
if (row.IsNull("character_maximum_length") == false)
{
//length = ConversionHelper.ToInt32(row["character_maximum_length"], Cultures.System);
length = ConversionHelper.ToInt64(row["character_maximum_length"], Cultures.System);
}
// get...
if (Connection == null)
{
throw new InvalidOperationException("Connection is null.");
}
// nullable?
EntityFieldFlags flags = EntityFieldFlags.Normal;
if (string.Compare(isNullableAsString, "yes", true, System.Globalization.CultureInfo.InvariantCulture) == 0)
{
flags |= EntityFieldFlags.Nullable;
}
// large?
FieldSpecification specification = this.Connection.GetFieldSpecificationForNativeTypeName(dataTypeAsString);
if (specification == null)
{
throw new InvalidOperationException("specification is null.");
}
if (specification.IsLarge)
{
flags |= EntityFieldFlags.Large;
}
// return...
return(new SqlColumn(nativeName, specification.DbType, length, flags));
}
/// <summary>
/// Gets the columns defined as key columns.
/// </summary>
/// <returns></returns>
internal SqlColumn[] GetColumnsWithFlags(EntityFieldFlags flags)
{
// walk...
ArrayList results = new ArrayList();
foreach (SqlColumn column in this.InnerList)
{
if (column.GetEntityFieldFlags(flags))
{
results.Add(column);
}
}
return((SqlColumn[])results.ToArray(typeof(SqlColumn)));
}
/// <summary>
/// Constructor.
/// </summary>
public EntityField(string name, string nativeName, DbType dbType, EntityFieldFlags flags) : base(name, nativeName)
{
// do we need a length?
long size = 0;
if ((flags & EntityFieldFlags.Large) == 0)
{
size = ConversionHelper.GetDefaultDBTypeSize(dbType);
}
else
{
size = uint.MaxValue;
}
// init...
this.Initialize(dbType, flags, size);
}
/// <summary>
/// Initializes the field.
/// </summary>
/// <param name="dbType"></param>
/// <param name="flags"></param>
/// <param name="size"></param>
private void Initialize(DbType dbType, EntityFieldFlags flags, long size)
{
// large...
bool isLarge = ((flags & EntityFieldFlags.Large) == EntityFieldFlags.Large);
bool supportsLarge = ConversionHelper.DoesDBTypeSupportLarge(dbType);
if (isLarge == true && supportsLarge == false)
{
throw new InvalidOperationException(string.Format(Cultures.Exceptions, "Database type '{0}' does not support large values.", dbType));
}
// basics...
_dbType = dbType;
_flags = flags;
_size = size;
// default...
_default = GetDefaultDefault(dbType, flags);
}
/// <summary>
/// Returns true if the given DB type supports encryption.
/// </summary>
/// <param name="dbType"></param>
/// <returns></returns>
//private static bool IsEncryptionSupported(DbType dbType)
//{
// switch(dbType)
// {
// case DbType.String:
// case DbType.StringFixedLength:
// case DbType.AnsiString:
// case DbType.AnsiStringFixedLength:
// return true;
// default:
// return false;
// }
//}
/// <summary>
/// Gets the default default.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static CommonDefault GetDefaultDefault(DbType dbType, EntityFieldFlags flags)
{
// set the default default...
if ((flags & EntityFieldFlags.Nullable) != 0)
{
return(CommonDefault.DBNull);
}
else
{
// if we're date time or a guid use a flashy version...
if (dbType == DbType.DateTime || dbType == DbType.Date)
{
return(CommonDefault.UtcNow);
}
else if (dbType == DbType.Guid)
{
return(CommonDefault.NewGuid);
}
else
{
return(CommonDefault.ClrNullEquivalent);
}
}
}
/// <summary>
/// Gets the columns defined as key columns.
/// </summary>
/// <returns></returns>
private SqlColumn[] GetColumnsWithFlags(EntityFieldFlags flags)
{
return(this.Columns.GetColumnsWithFlags(flags));
}
/// <summary>
/// Constructor.
/// </summary>
public SqlColumn(string nativeName, DbType dbType, long length, EntityFieldFlags flags) : base(nativeName)
{
this.Initialize(dbType, length, flags);
}
/// <summary>
/// Constructor.
/// </summary>
public EntityFieldAttribute(string nativeName, DbType dbType, EntityFieldFlags flags, long size) : this(nativeName, dbType, flags)
{
// set...
_size = size;
_sizeDefined = true;
}
