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; }