public static string RecuperarChaveEstrangeira <T>(string Entidade) where T : new() { //Type tipo = RecuperarClassePorNome<T>(Entidade); Type tipoT = typeof(T); var propriedades = tipoT.GetProperties(); PropertyInfo prop = null; foreach (var i in propriedades) { if (i.PropertyType.Name == Entidade) { prop = i; } } string chave = null; var campos = prop.GetCustomAttributes(typeof(ForeignKeyAttribute), true); foreach (var i in campos) { ForeignKeyAttribute att = (ForeignKeyAttribute)i; chave = att.Nome; } return(chave); }
/// <summary> /// Gets the ModelForeignKeyProperties for the Type. /// If it does not exist, it is created, added to the cache, and returned /// </summary> /// <param name="type"></param> /// <returns></returns> public ModelForeignKeyProperties GetOrAdd(Type type) { if (!Contains(type)) { ModelForeignKeyProperties modelFkProperties = new ModelForeignKeyProperties(type); Dictionary <string, PropertyInfo> properties = type.GetProperties().ToDictionary(x => x.Name); foreach (KeyValuePair <string, PropertyInfo> propertyElement in properties) { PropertyInfo property = propertyElement.Value; ForeignKeyAttribute attribute = (ForeignKeyAttribute)property.GetCustomAttribute(typeof(ForeignKeyAttribute)); if (attribute is null) { continue; } string attributeValue = attribute.Name; if (!properties.ContainsKey(attribute.Name)) { throw new Exception($"ForeignKey Attribute value ({attribute.Name}) on Property ({property.Name}) in Model ({type.Name}) is invalid"); } PropertyInfo fKReferenceProperty = type.GetProperty(attributeValue); modelFkProperties.Add(property, attribute, fKReferenceProperty); } Cache.TryAdd(type, modelFkProperties); } return(Cache[type]); }
public static ForeignKeyDefinition GetForeignKeyDefinition(Type modelType, PropertyInfo propertyInfo, ForeignKeyAttribute attribute, string columnName, string tableName) { var referencedTable = attribute.Type.FirstAttribute <TableNameAttribute>(); var referencedPrimaryKey = attribute.Type.FirstAttribute <PrimaryKeyAttribute>(); string referencedColumn = string.IsNullOrEmpty(attribute.Column) ? referencedPrimaryKey.Value : attribute.Column; string foreignKeyName = string.IsNullOrEmpty(attribute.Name) ? string.Format("FK_{0}_{1}_{2}", tableName, referencedTable.Value, referencedColumn) : attribute.Name; var definition = new ForeignKeyDefinition { Name = foreignKeyName, ForeignTable = tableName, PrimaryTable = referencedTable.Value, OnDelete = attribute.OnDelete, OnUpdate = attribute.OnUpdate }; definition.ForeignColumns.Add(columnName); definition.PrimaryColumns.Add(referencedColumn); return(definition); }
public void Test_With_Valid_Values() { // ARRANGE AuditIgnoreAttribute paramAuditIgnore = new AuditIgnoreAttribute(); ForeignKeyAttribute paramForeignKey = new ForeignKeyAttribute("ForeignKeyProperty"); KeyAttribute paramKey = new KeyAttribute(); NotMappedAttribute paramNotMapped = new NotMappedAttribute(); RangeAttribute paramRange = new RangeAttribute( minimum: 1D, maximum: 5D); // ACT PropertyAttributeSummary propertyAttributeSummary = new PropertyAttributeSummary( auditIgnore: paramAuditIgnore, foreignKey: paramForeignKey, key: paramKey, notMapped: paramNotMapped, range: paramRange); // ASSERT Assert.AreSame(paramAuditIgnore, propertyAttributeSummary.AuditIgnore); Assert.AreSame(paramForeignKey, propertyAttributeSummary.ForeignKey); Assert.AreSame(paramKey, propertyAttributeSummary.Key); Assert.AreSame(paramNotMapped, propertyAttributeSummary.NotMapped); Assert.AreSame(paramRange, propertyAttributeSummary.Range); }
private ColumnTypeAttribute GetDefaultColumnType(Type type) { if (IsEnum(type)) { type = typeof(Enum); } if (_defaultTypeAttributes.ContainsKey(type)) { return(_defaultTypeAttributes[type]); } var foreignKey = IsEntityBasedProperty(type); if (foreignKey == null) { throw new NotSupportedException("Unmappable type: " + type.FullName); } if (type.IsGenericType) { _defaultTypeAttributes.Add(type, new CrossTableReferenceAttribute(type.GenericTypeArguments.First())); } else { var targetDbSet = Context.EnsureTable(type); var attribute = new ForeignKeyAttribute(GetColumnType(foreignKey).ToString(), targetDbSet); var mapperType = typeof(ForeignKeyMapper <>).MakeGenericType(type); var mapper = (MapperBase)Activator.CreateInstance(mapperType, attribute, targetDbSet); _mappers.Add(new KeyValuePair <Type, ColumnTypeAttribute>(type, attribute), mapper); _defaultTypeAttributes.Add(type, attribute); } return(_defaultTypeAttributes[type]); }
public void Apply_generates_constraint_when_composite_fk() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var associationType = model.AddAssociationType( "A", entityType, RelationshipMultiplicity.ZeroOrOne, entityType, RelationshipMultiplicity.Many); var navigationProperty = entityType.AddNavigationProperty("N", associationType); var property = EdmProperty.Primitive("Fk1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); var fkProperty1 = property; var property1 = EdmProperty.Primitive("Fk2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property1); var fkProperty2 = property1; var foreignKeyAnnotation = new ForeignKeyAttribute("Fk2,Fk1"); navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation }); ((IEdmConvention <NavigationProperty>) new ForeignKeyNavigationPropertyAttributeConvention()) .Apply(navigationProperty, model); Assert.NotNull(associationType.Constraint); Assert.True(new[] { fkProperty2, fkProperty1 }.SequenceEqual(associationType.Constraint.ToProperties)); }
public static string GetForeignKey <T, TKey>(this T fonte, Func <T, TKey> entidade) where T : class where TKey : class { //Type tipo = RecuperarClassePorNome<T>(Entidade); Type tipoT = typeof(T); var propriedades = tipoT.GetProperties(); PropertyInfo prop = null; var ent = entidade.Method.ReturnParameter.ParameterType.Name; foreach (var i in propriedades) { if (i.PropertyType.Name == ent) { prop = i; } } string chave = null; var campos = prop.GetCustomAttributes(typeof(ForeignKeyAttribute), true); foreach (var i in campos) { ForeignKeyAttribute att = (ForeignKeyAttribute)i; chave = att.Nome; } return(chave); }
public IQueryBuilder GetCreationCommand(ForeignKeyAttribute fkd) { var cname = $"fk_{fkd.Column}_{fkd.RefTable}_{fkd.RefColumn}"; String creationCommand = $"ALTER TABLE {fkd.Table} ADD CONSTRAINT {cname} FOREIGN KEY ({fkd.Column}) REFERENCES {fkd.RefTable} ({fkd.RefColumn});"; return(new QbFmt(creationCommand)); }
void ConfigureNavigationProperty() { PropertyInfo[] properties = this.EntityType.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(a => a.GetSetMethod() != null && a.GetGetMethod() != null).ToArray(); foreach (PropertyInfo property in properties) { if (MappingTypeSystem.IsMappingType(property.PropertyType)) { continue; } if (this.IsSupportedCollectionType(property.PropertyType)) { this.EntityType.CollectionProperties.Add(new CollectionProperty(property)); continue; } ForeignKeyAttribute foreignKeyAttribute = property.GetCustomAttribute <ForeignKeyAttribute>(); if (foreignKeyAttribute != null) { ComplexProperty complexProperty = new ComplexProperty(property); complexProperty.ForeignKey = foreignKeyAttribute.Name; this.EntityType.ComplexProperties.Add(complexProperty); } } }
private void GetColumns(ref IList <KeyValuePair <string, PropertyInfo> > columns, Type type, bool includeForeingKeys = false) { try { PropertyInfo[] properties = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance) .Where(p => FilterColumns(p)) .ToArray(); IDictionary <string, PropertyInfo> currEntityColumns = properties .Where(p => p.GetCustomAttribute <NotMappedAttribute>() == null) .ToDictionary(p => GetColumnName(type, p), p => p); foreach (KeyValuePair <string, PropertyInfo> column in currEntityColumns) { columns.Add(column); if (includeForeingKeys) { ForeignKeyAttribute foreinKeyAttribute = column.Value.GetCustomAttribute <ForeignKeyAttribute>(); if (foreinKeyAttribute != null) { GetColumns(ref columns, column.Value.PropertyType, includeForeingKeys); } } } } catch (Exception ex) { throw new OrmException($"Error on GetColumns from Type {type}.", ex); } }
public IEnumerable <ReferenceInfo> GetReferences(Type entityType) { foreach (var property in ReflectionUtil.GetAllProperties(entityType)) { var refType = m_convention.TryGetRefEntityType(property); if (refType == null) { continue; } string leftKeyColumnName; string rightKeyColumnName; if (typeof(IEnumerable).IsAssignableFrom(property.PropertyType)) { leftKeyColumnName = LocalKeyAttribute.GetLocalKeyName( property, m_convention.GetPrimaryKeyProperty(entityType).Name); rightKeyColumnName = ForeignKeyAttribute.GetForeignKeyName( property, $"{GetTableName(entityType)}Id"); } else { leftKeyColumnName = LocalKeyAttribute.GetLocalKeyName(property, $"{property.Name}Id"); rightKeyColumnName = ForeignKeyAttribute.GetForeignKeyName( property, m_convention.GetPrimaryKeyProperty(refType).Name); } yield return (new ReferenceInfo(property.Name, entityType, leftKeyColumnName, null, refType, rightKeyColumnName)); } }
public override void Apply(PropertyConfiguration edmProperty, StructuralTypeConfiguration structuralTypeConfiguration, Attribute attribute) { if (edmProperty == null) { throw Error.ArgumentNull("edmProperty"); } if (structuralTypeConfiguration == null) { throw Error.ArgumentNull("structuralTypeConfiguration"); } EntityTypeConfiguration declaringEntityType = (EntityTypeConfiguration)structuralTypeConfiguration; ForeignKeyAttribute foreignKeyAttribute = (ForeignKeyAttribute)attribute; switch (edmProperty.Kind) { case PropertyKind.Navigation: ApplyNavigation((NavigationPropertyConfiguration)edmProperty, declaringEntityType, foreignKeyAttribute); break; case PropertyKind.Primitive: ApplyPrimitive((PrimitivePropertyConfiguration)edmProperty, declaringEntityType, foreignKeyAttribute); break; } }
public override IEnumerable <string> SqlCommands(IDbConnection connection) { foreach (var cmd in base.SqlCommands(connection)) { yield return(cmd); } DbObject obj = DbObject.FromType(_propertyInfo.DeclaringType); obj.SquareBraces = false; yield return($"EXEC sp_rename '{obj}.{_attr.OldName}', '{_propertyInfo.SqlColumnName()}', 'COLUMN'"); ForeignKeyAttribute fkAttr = _propertyInfo.GetAttribute <ForeignKeyAttribute>(); if (fkAttr != null) { yield return($"ALTER TABLE [{obj.Schema}].[{obj.Name}] DROP CONSTRAINT [FK_{obj.ConstraintName()}_{_attr.OldName}]"); if (fkAttr.CreateIndex) { yield return($"DROP INDEX [IX_{DbObject.ConstraintName(_propertyInfo.DeclaringType)}_{_attr.OldName}] ON [{obj.Schema}].[{obj.Name}]"); } CreateForeignKey fk = new CreateForeignKey(_propertyInfo); foreach (var cmd in fk.SqlCommands(connection)) { yield return(cmd); } } }
public static string GetJoiner <E, D>() { Type firstType = typeof(E); string secondName; Type secondType = typeof(D); secondName = secondType.Name; BasicList <PropertyInfo> thisList = firstType.GetPublicPropertiesWithAttribute <ForeignKeyAttribute>().ToBasicList(); BasicList <PropertyInfo> newList = thisList.Where(items => { ForeignKeyAttribute thisKey = items.GetCustomAttribute <ForeignKeyAttribute>() !; if (thisKey.ClassName == secondName) { return(true); } return(false); }).ToBasicList(); if (newList.Count == 0) { throw new CustomBasicException($"No Key Found Linking {secondName}"); } if (newList.Count > 1) { throw new CustomBasicException($"Duplicate Key Found Linking {secondName}"); } PropertyInfo thisProp = newList.Single(); ColumnAttribute thisCol = thisProp.GetCustomAttribute <ColumnAttribute>() !; if (thisCol == null) { return(thisProp.Name); } return(thisCol.ColumnName); }
/// <summary> /// Compares navigational properties of two models defined by a foreign key property. These nagivational properties must implement IHasId interface and cannot be lists and collections. TODO: improve this method so that an actual navigational property is selected, not its foreign key /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="model1"></param> /// <param name="model2"></param> /// <param name="foreignKey"></param> /// <returns></returns> public static bool CompareNagivationalProperties <TModel>(TModel model1, TModel model2, Expression <Func <TModel, int?> > foreignKey) where TModel : class { if (foreignKey == null) { throw new ArgumentNullException("foreignKey may not be null whereas it is null now"); } MemberExpression mex = (MemberExpression)foreignKey.Body; PropertyInfo fkProperty = (PropertyInfo)mex.Member; ForeignKeyAttribute attr = fkProperty.GetCustomAttribute(typeof(ForeignKeyAttribute)) as ForeignKeyAttribute; if (attr == null) { throw new ArgumentException("foreignKey property does not contain ForeignKey attribute"); } int?key1 = fkProperty.GetValue(model1) as int?; int?key2 = fkProperty.GetValue(model2) as int?; if (key1 != key2) { return(false); } else if (key1 == null && key2 == null) { PropertyInfo property = typeof(TModel).GetProperty(attr.Name); IHasId val1 = property.GetValue(model1) as IHasId; IHasId val2 = property.GetValue(model2) as IHasId; if (val1?.Id != val2?.Id) { return(false); } } return(true); }
public override IEdmModel GetEdmModel() { var basemodel = base.GetEdmModel(); foreach (EntitySetConfiguration set in EntitySets) { Dictionary <string, ExternalSource> navdictionary; // If the referenced Model Type is not listed in the targetdictionary add it, otherwise set the targetdictionary //TODO [ap] Perhaps better to change it to entity set, as types may be used in multiple locations? if (!CustomNavigationReferences.TryGetValue(set.ClrType, out navdictionary)) { navdictionary = new Dictionary <string, ExternalSource>(); CustomNavigationReferences.Add(set.ClrType, navdictionary); } Dictionary <string, PropertyInfo> foreignKeys = new Dictionary <string, PropertyInfo>(); foreach (PropertyInfo pi in set.ClrType.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { ForeignKeyAttribute fk = pi.GetCustomAttribute(typeof(ForeignKeyAttribute), true) as ForeignKeyAttribute; if (fk != null) { foreignKeys.Add(fk.Name, pi); } } string key = null; try { key = set.ClrType.GetProperties().FirstOrDefault(x => { return(x.GetCustomAttribute(typeof(KeyAttribute), true) != null); }).Name; } catch (Exception) { } // Get all expand source attributes foreach (PropertyInfo pi in set.ClrType.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { foreach (ExpandSourceAttribute a in pi.GetCustomAttributes <ExpandSourceAttribute>(true)) { var exs = new ExternalSource { EntitySet = a.SourceEntitySet, IsLocal = a.IsLocal, NavigationProperty = pi, Key = key, ForeignKey = a.ForeignKey }; PropertyInfo fk; if (foreignKeys.TryGetValue(pi.Name, out fk)) { exs.ForeignKeyProperty = fk; try { exs.ForeignKey = pi.PropertyType.GetProperties().FirstOrDefault(x => x.GetCustomAttribute(typeof(KeyAttribute), true) != null).Name; } catch (Exception ex) { throw new ArgumentException(pi.PropertyType.Name + " has no KeyAttribute defined and, thus, cannot be used as ExpandSource.", pi.PropertyType.Name, ex); } } navdictionary.Add(pi.Name, exs); } } } return(basemodel); }
public ForeignKey(EntityInfoCollection entities, IEntityInfo entityLocal, PropertyInfo prop, ForeignKeyAttribute foreignKeyAttribute) : base(entityLocal, prop, foreignKeyAttribute) { _constraintName = new Lazy <string>(ComputeConstraintName); Entities = entities; ForeignType = foreignKeyAttribute.ForeignType; }
//public static string GetReferencedId(ReferenceAttribute referenceAttribute) //{ // return referenceAttribute.RefencedPropertyName + "Id"; //} public static PropertyInfo GetReferencedPropertyId(BaseEntity baseEntity, ReferenceAttribute referenceAttribute) { PropertyInfo propertyInfo = baseEntity.GetType().GetProperty(referenceAttribute.RefencedPropertyName); ForeignKeyAttribute foreignKeyAttribute = propertyInfo.GetCustomAttribute <ForeignKeyAttribute>(); return(baseEntity.GetType().GetProperty(foreignKeyAttribute.Name)); //return referenceAttribute.RefencedPropertyName + "Id"; }
public ForeignKeyColumn(Table table, string memberPath, Type memberType, ForeignKeyAttribute columnAttribute) : base(table, memberPath, memberType, columnAttribute) { m_DeleteRule = columnAttribute.DeleteRule; m_ForeignTableName = columnAttribute.ForeignTableName; m_ForeignColumnName = columnAttribute.ForeignColumnName; }
public ForeignKeyColumn(Table table, MemberInfo member, string memberPath, ForeignKeyAttribute columnAttribute) : base(table, member, memberPath, null, columnAttribute) { m_DeleteRule = columnAttribute.DeleteRule; m_ForeignTableName = columnAttribute.ForeignTableName; m_ForeignColumnName = columnAttribute.ForeignColumnName; }
// Constructs input to check against dictionary contents when looking up an input. public Table(ForeignKeyAttribute foreignKeyAttribute, TableAttribute tableAttribute) { foreignKeyAttribute.IsNotNull(nameof(foreignKeyAttribute)); this.HasTableAttribute = tableAttribute != null; this.CatalogueName = tableAttribute?.CatalogueName; this.TableName = foreignKeyAttribute.PrimaryTableName; this.Schema = foreignKeyAttribute.Schema; }
protected void SetTemporaryForeignKeys(Dao dao, Dictionary <string, Dao> temp) { List <PropertyInfo> foreignKeyProperties = dao.GetType().GetProperties().Where(p => p.HasCustomAttributeOfType <ForeignKeyAttribute>()).ToList(); foreignKeyProperties.Each(prop => { ForeignKeyAttribute fk = prop.GetCustomAttribute <ForeignKeyAttribute>(); dao.Property(prop.Name, temp[fk.ReferencedTable].IdValue); }); }
public static bool ReferencingTableExists(this IDbConnection connection, PropertyInfo propertyInfo) { ForeignKeyAttribute fk = propertyInfo.GetForeignKeyAttribute(); if (fk != null) { return(TableExists(connection, propertyInfo.DeclaringType)); } throw new ArgumentException($"{propertyInfo.Name} is not a foreign key."); }
public override IEnumerable <string> SqlCommands(IDbConnection connection) { yield return(Syntax.ForeignKeyAddStatement(_propertyInfo)); ForeignKeyAttribute fk = _propertyInfo.GetForeignKeyAttribute(); if (fk != null && fk.CreateIndex && !Syntax.IndexExists(connection, _propertyInfo.IndexName(Syntax))) { yield return(Syntax.CreateColumnIndexStatement(_propertyInfo)); } }
private object ReadValue(DbDataReader reader, Mapping mapping) { object value = TryReadValue(reader, mapping); if (value == DBNull.Value || value == null) { return(null); } Type propertyType = ResolveType(mapping.Property.PropertyType); if (propertyType == typeof(Guid)) { return((Guid)value); } else if (propertyType.IsPrimitive()) { value = ChangeType(value, propertyType); if (Options.AutoTrimStrings && value != null && (value is string)) { value = value.ToString().Trim(); } return(value); } else if (propertyType.IsEnum) { if (Enum.IsDefined(propertyType, value)) { return(Enum.ToObject(propertyType, value)); } LogError("Cannot get an Enum of type {propertyType} from {value}.", propertyType.Name, value); throw new InvalidCastException($"Cannot get an Enum of type {propertyType.Name} from {value}."); } ColumnAttribute columnAttribute = mapping.Property.GetCustomAttribute <ColumnAttribute>(); if (columnAttribute.Serialize) { return(JsonConvert.DeserializeObject(value.ToString(), propertyType)); } ForeignKeyAttribute foreignKeyAttribute = mapping.Property.GetCustomAttribute <ForeignKeyAttribute>(); if (foreignKeyAttribute != null) { return(CreateInstance(mapping.Property.PropertyType, reader, $"{mapping.Path}{mapping.Property.Name}\\")); } LogError("Type {type} is not supported.", mapping.Property.PropertyType); throw new NotSupportedException($"Type \"{mapping.Property.PropertyType}\" is not supported."); }
public void ForeignKeyAttribute_Ctor_AsExpected() { var fk = new ForeignKeyAttribute("property", true); fk.DeleteCascade.Should().BeTrue(); fk.InversePropertyName.Should().Be("property"); var fk2 = new ForeignKeyAttribute(); fk2.DeleteCascade.Should().BeFalse(); fk2.InversePropertyName.Should().BeNullOrWhiteSpace(); }
private object GetValue(PropertyInfo property, object entity) { if (entity == null) { return(DBNull.Value); } object value = property.GetValue(entity); if (value == null) { return(DBNull.Value); } Type propertyType = ResolveType(property.PropertyType); ColumnAttribute columnAttribute = property.GetCustomAttribute <ColumnAttribute>(); if (propertyType.IsPrimitive()) { if (propertyType == typeof(DateTime)) { if (!string.IsNullOrEmpty(columnAttribute?.TypeName) && "bigint|int".Contains(columnAttribute?.TypeName)) { return((long)(((DateTime)value) - new DateTime(1970, 1, 1)).TotalSeconds); } } return(value); } else if (propertyType.IsEnum) { return((int)value); } if (columnAttribute != null && columnAttribute.Serialize) { return(JsonConvert.SerializeObject(value, Newtonsoft.Json.Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore })); } ForeignKeyAttribute foreignKeyAttribute = property.GetCustomAttribute <ForeignKeyAttribute>(); if (foreignKeyAttribute != null) { PropertyInfo outerProperty = value.GetType().GetProperty(foreignKeyAttribute.JoinPropertyName); value = GetValue(outerProperty, value); return(value); } throw new NotSupportedException($"Type \"{property.PropertyType}\" is not supported."); }
public override IEnumerable <string> SqlCommands() { ForeignKeyAttribute fk = _pi.GetForeignKeyAttribute(); string cascadeDelete = (fk.CascadeDelete) ? " ON DELETE CASCADE" : string.Empty; yield return ($"ALTER TABLE {DbObject.SqlServerName(_pi.DeclaringType)} ADD CONSTRAINT [{_pi.ForeignKeyName()}] FOREIGN KEY (\r\n" + $"\t[{_pi.SqlColumnName()}]\r\n" + $") REFERENCES {DbObject.SqlServerName(fk.PrimaryTableType)} (\r\n" + $"\t[{fk.PrimaryTableType.IdentityColumnName()}]\r\n" + ")" + cascadeDelete); }
public Column(PropertyInfo prop, CreateFlags createFlags = CreateFlags.None) { var colAttr = (ColumnAttribute)prop.GetCustomAttributes(typeof(ColumnAttribute), true).FirstOrDefault(); _prop = prop; Name = colAttr == null ? prop.Name : colAttr.Name; //If this type is Nullable<T> then Nullable.GetUnderlyingType returns the T, otherwise it returns null, so get the actual type instead ColumnType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType; Collation = Orm.Collation(prop); IsPK = Orm.IsPK(prop) || (((createFlags & CreateFlags.ImplicitPK) == CreateFlags.ImplicitPK) && string.Compare(prop.Name, Orm.ImplicitPkName, StringComparison.OrdinalIgnoreCase) == 0); IsCK = Orm.IsCK(prop); IsFK = Orm.IsFK(prop); if (IsFK) { ForeignKeyAttribute attr = prop.GetCustomAttribute <ForeignKeyAttribute>(true); TableMapping refTable = new TableMapping(attr.ReferenceTable); string refColumnName = attr.ReferenceColumn ?? this.Name; var refColumns = refTable.Columns.Select(c => c).Where(c => c.Name == refColumnName).ToArray(); if (refColumns.Length > 0) { FK = new ForeignKey(this, attr.ReferenceTable, refColumns[0]); } else { throw new Exception(string.Format("The referenced column \"{0}\" in {1} doesn't exist", refColumnName, this.Name)); } } var isAuto = Orm.IsAutoInc(prop) || (IsPK && ((createFlags & CreateFlags.AutoIncPK) == CreateFlags.AutoIncPK)); IsAutoGuid = isAuto && ColumnType == typeof(Guid); IsAutoInc = isAuto && !IsAutoGuid; Indices = Orm.GetIndices(prop); if (!Indices.Any() && !IsPK && ((createFlags & CreateFlags.ImplicitIndex) == CreateFlags.ImplicitIndex) && Name.EndsWith(Orm.ImplicitIndexSuffix, StringComparison.OrdinalIgnoreCase) ) { Indices = new IndexedAttribute[] { new IndexedAttribute() }; } IsNullable = !(IsPK || Orm.IsMarkedNotNull(prop)); MaxStringLength = Orm.MaxStringLength(prop); StoreAsText = prop.PropertyType.GetTypeInfo().GetCustomAttribute(typeof(StoreAsTextAttribute), false) != null; }
public void IrisFormBuilder() { _modelType = typeof(T); foreach (PropertyInfo p in _modelType.GetProperties()) { ForeignKeyAttribute fk = p.GetCustomAttribute <ForeignKeyAttribute>(); if (fk != null) { fk.GetForeignKeyList(); } } }
internal static IEnumerable <ForeignKeyRef> GetReferencingForeignKeys(Type modelType, IEnumerable <Type> allTypes) { return(allTypes.SelectMany(t => GetForeignKeys(t).Where(pi => { ForeignKeyAttribute fk = pi.GetForeignKeyAttribute(); return (fk.PrimaryTableType.Equals(modelType)); }).Select(pi => new ForeignKeyRef() { ConstraintName = pi.ForeignKeyName(), ReferencingTable = DbObject.FromType(pi.DeclaringType) } ))); }
private PropertyInfo GetPrimaryKeyProperty(Type recordType, ForeignKeyAttribute foreignKeyAttribute) { PropertyInfo result = recordType.GetPropertiesHelper() .First( p => Helper.GetColumnName(p, this.attributeDecorator) .Equals(foreignKeyAttribute.PrimaryKeyName, StringComparison.Ordinal)); return result; }
public AttributeDecoratorException(string cannotResolveForeignTableMessage, ForeignKeyAttribute foreignAttribute, Type foreignType) : base(string.Format(cannotResolveForeignTableMessage, foreignAttribute, foreignType)) { }
public static void Ctor_String(string name) { ForeignKeyAttribute attribute = new ForeignKeyAttribute(name); Assert.Equal(name, attribute.Name); }