protected Relation GetConcreteRelation(MemberInfo subject) { var declaredMany = subject.GetPropertyOrFieldType().DetermineCollectionElementType(); if (declaredMany == null) { return(null); } var implementorsOfMany = DomainInspector.GetBaseImplementors(declaredMany).ToArray(); if (implementorsOfMany.Length != 1) { // short return(null); } var declaredOne = subject.ReflectedType; var implementorsOfOne = DomainInspector.GetBaseImplementors(declaredOne).ToArray(); if (implementorsOfOne.Length != 1) { return(null); } return(new Relation(implementorsOfOne[0], implementorsOfMany[0])); }
public bool Match(MemberInfo subject) { var propertyType = subject.GetPropertyOrFieldType(); Type many = propertyType.DetermineCollectionElementType(); Type one = subject.DeclaringType; if (many == null) { return(false); } if (one.Equals(many)) { // Circular references return(false); } CascadeOn?applyCascade = DomainInspector.ApplyCascade(one, subject, many); if (applyCascade.HasValue && !applyCascade.Value.Has(CascadeOn.DeleteOrphans) && !applyCascade.Value.Has(CascadeOn.Remove) && !applyCascade.Value.Has(CascadeOn.All)) { return(false); } if (!DomainInspector.IsEntity(many)) { return(false); } if (DomainInspector.IsTablePerClass(many) && !DomainInspector.IsRootEntity(many)) { return(false); } return(base.Match(new Relation(one, many))); }
protected bool HasMultipleCollectionOf(Type collectionOwner, Type elementType, ref int collectionCount) { foreach (var propertyType in collectionOwner.GetProperties(PublicPropertiesOfClassHierarchy).Where(p => DomainInspector.IsPersistentProperty(p)).Select(p => p.PropertyType)) { if (!propertyType.Equals(elementType) && DomainInspector.IsComponent(propertyType)) { if (HasMultipleCollectionOf(propertyType, elementType, ref collectionCount)) { return(true); } } else { var propertyElementType = propertyType.DetermineCollectionElementOrDictionaryValueType(); if (elementType.Equals(propertyElementType)) { collectionCount++; } } if (collectionCount > 1) { return(true); } } return(false); }
public override bool Match(MemberInfo subject) { // does not match even when an explicit cascade is provided by DomainInspector var relation = GetRelation(subject); return(relation != null && !DomainInspector.ApplyCascade(relation.From, subject, relation.To).HasValue&& base.Match(relation)); }
public override bool Match(MemberInfo subject) { var relation = GetRelation(subject); if (relation == null || !DomainInspector.IsEntity(relation.To)) { return(false); } return(base.Match(subject)); }
protected virtual string GetKeyColumnName(PropertyPath subject) { // Note: in a double usage of a collection of children the user can choose to solve it // using a different 'key-column' or a specific 'where-clause'. // Is better to delegate this responsibility case-by-case to a customizer instead use a general pattern. // In case of unidirectional relation the UnidirectionalOneToManyMultipleCollectionsKeyColumnApplier is available Type propertyType = subject.LocalMember.GetPropertyOrFieldType(); Type childType = propertyType.DetermineCollectionElementType(); var entity = subject.GetContainerEntity(DomainInspector); var parentPropertyInChild = DomainInspector.GetBidirectionalMember(entity, subject.LocalMember, childType) ?? childType.GetFirstPropertyOfType(entity); var baseName = parentPropertyInChild == null ? subject.PreviousPath == null ? entity.Name : entity.Name + subject.PreviousPath : parentPropertyInChild.Name; return(GetKeyColumnName(baseName)); }
protected virtual string GetColumnNameForRelation(PropertyPath subject) { var relation = GetRelation(subject.LocalMember); var fromMany = relation.From; if (!DomainInspector.IsEntity(fromMany)) { fromMany = subject.GetContainerEntity(DomainInspector); } var toMany = relation.To; var baseColumnName = toMany.GetPoidColumnName(); return(fromMany != toMany ? baseColumnName : string.Format("{0}_{1}", subject.ToColumnName("_"), baseColumnName)); }
protected virtual string GetColumnNameForRelation(PropertyPath subject) { var relation = GetRelation(subject.LocalMember); var fromMany = relation.From; if (!DomainInspector.IsEntity(fromMany)) { fromMany = subject.GetContainerEntity(DomainInspector); } var toMany = relation.To; var baseColumnName = toMany.Name + "Id"; if (fromMany != toMany) { return(baseColumnName); } return(subject.ToColumnName() + baseColumnName); }
protected virtual string GetManyToManyTableName(PropertyPath subject) { var manyToManyRelation = GetRelation(subject.LocalMember); var fromMany = manyToManyRelation.From; var toMany = manyToManyRelation.To; bool fromIsMaster = DomainInspector.IsMasterManyToMany(fromMany, toMany); bool toIsMaster = DomainInspector.IsMasterManyToMany(toMany, fromMany); fromMany = subject.GetContainerEntity(DomainInspector); string[] names; if (fromIsMaster == toIsMaster) { names = (from t in (new[] { fromMany, toMany }) orderby t.Name select t.Name).ToArray(); } else { names = fromIsMaster ? new[] { fromMany.Name, toMany.Name } : new[] { toMany.Name, fromMany.Name }; } return(GetTableNameForRelation(names)); }
public override bool Match(MemberInfo subject) { if (!base.Match(subject)) { return(false); } var concreteRelation = GetConcreteRelation(subject); if (concreteRelation == null) { return(false); } var one = concreteRelation.From; var many = concreteRelation.To; if (one.Equals(many)) { // Circular references return(false); } Cascade?applyCascade = GetExplicitPolymorphismCascade(subject); if (applyCascade.HasValue && !applyCascade.Value.Has(Cascade.DeleteOrphans) && !applyCascade.Value.Has(Cascade.Remove) && !applyCascade.Value.Has(Cascade.All)) { return(false); } if (!DomainInspector.IsEntity(many)) { return(false); } if (DomainInspector.IsTablePerClass(many) && !DomainInspector.IsRootEntity(many)) { return(false); } return(true); }
protected virtual string GetManyToManyTableName(PropertyPath subject) { var manyToManyRelation = GetRelation(subject.LocalMember); var fromMany = manyToManyRelation.From; var toMany = manyToManyRelation.To; bool fromIsMaster = DomainInspector.IsMasterManyToMany(fromMany, toMany); bool toIsMaster = DomainInspector.IsMasterManyToMany(toMany, fromMany); fromMany = subject.GetContainerEntity(DomainInspector); var explicitBidirectionalMember = DomainInspector.GetBidirectionalMember(fromMany, subject.LocalMember, toMany); if (explicitBidirectionalMember == null) { Relation[] twoRelations = GetTwoRelation(fromMany, fromIsMaster, toMany, toIsMaster); return(GetTableNameForRelation(twoRelations[0], twoRelations[1])); } else { RelationOn[] twoRelationOn = GetTwoRelationOn(fromMany, fromIsMaster, subject, toMany, toIsMaster, explicitBidirectionalMember); return(GetTableNameForRelationOnProperty(twoRelationOn[0], twoRelationOn[1])); } }
private bool IsUnidirectionalOneToMany(Type from, Type to) { return(DomainInspector.IsOneToMany(from, to) && to.GetFirstPropertyOfType(from, p => DomainInspector.IsPersistentProperty(p)) == null); }
protected virtual bool KeyIsElement(Type memberType, MemberInfo subject) { var mapKey = memberType.DetermineDictionaryKeyType(); return(!DomainInspector.IsManyToMany(subject.ReflectedType, mapKey) && !DomainInspector.IsComponent(mapKey)); }