public override void Visit(DiscriminatorMapping discriminatorMapping) { var writer = serviceLocator.GetWriter <DiscriminatorMapping>(); var discriminatorXml = writer.Write(discriminatorMapping); document.ImportAndAppendChild(discriminatorXml); }
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <Member> mappedMembers) { var discriminatorSet = HasDiscriminator(mapping); var isDiscriminated = cfg.IsDiscriminated(classType) || discriminatorSet; var mappingTypesWithLogicalParents = GetMappingTypesWithLogicalParents(); foreach (var inheritedClass in mappingTypesWithLogicalParents .Where(x => x.Value != null && x.Value.Type == classType) .Select(x => x.Key)) { var tempMapping = mapping as ClassMapping; var tempIsNull = tempMapping == null; if (isDiscriminated && !discriminatorSet && !tempIsNull) { var discriminatorColumn = cfg.GetDiscriminatorColumn(classType); var discriminator = new DiscriminatorMapping { ContainingEntityType = classType, }; discriminator.Set(x => x.Type, Layer.Defaults, new TypeReference(typeof(string))); var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, discriminatorColumn); discriminator.AddColumn(Layer.Defaults, columnMapping); tempMapping.Set(x => x.Discriminator, Layer.Defaults, discriminator); discriminatorSet = true; } SubclassMapping subclassMapping; var tempSubClassMap = mapping as SubclassMapping; if (!tempIsNull && tempMapping.IsUnionSubclass || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.UnionSubclass) { subclassMapping = new SubclassMapping(SubclassType.UnionSubclass); subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type); } else if (isDiscriminated || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.Subclass) { subclassMapping = new SubclassMapping(SubclassType.Subclass); subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type); } else { subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass); subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type); subclassMapping.Set(x => x.Key, Layer.Defaults, new KeyMapping()); var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, mapping.Type.Name + "_id"); subclassMapping.Key.AddColumn(Layer.Defaults, columnMapping); } // track separate set of properties for each sub-tree within inheritance hierarchy var subclassMembers = new List <Member>(mappedMembers); MapSubclass(subclassMembers, subclassMapping, inheritedClass); mapping.AddSubclass(subclassMapping); MergeMap(inheritedClass.Type, subclassMapping, subclassMembers); } }
public void ShouldWriteColumns() { var mapping = new DiscriminatorMapping(); mapping.AddColumn(Layer.Defaults, new ColumnMapping("Column1")); writer.VerifyXml(mapping) .Element("column").Exists(); }
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <string> mappedProperties) { var discriminatorSet = false; var isDiscriminated = expressions.IsDiscriminated(classType); foreach (var inheritedClass in mappingTypes.Where(q => q.Type.BaseType == classType && !expressions.IsConcreteBaseType(q.Type.BaseType))) { if (isDiscriminated && !discriminatorSet && mapping is ClassMapping) { var discriminatorColumn = expressions.DiscriminatorColumn(classType); var discriminator = new DiscriminatorMapping { ContainingEntityType = classType, Type = new TypeReference(typeof(string)) }; discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn }); ((ClassMapping)mapping).Discriminator = discriminator; discriminatorSet = true; } ISubclassMapping subclassMapping; var subclassStrategy = expressions.SubclassStrategy(classType); if (subclassStrategy == SubclassStrategy.JoinedSubclass) { // TODO: This id name should be removed. Ideally it needs to be set by a // default and be overridable by a convention (preferably the ForeignKey convention // that already exists) var subclass = new JoinedSubclassMapping { Type = inheritedClass.Type }; subclass.Key = new KeyMapping(); subclass.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" }); subclassMapping = subclass; } else { subclassMapping = new SubclassMapping(); } MapSubclass(mappedProperties, subclassMapping, inheritedClass); mapping.AddSubclass(subclassMapping); MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties); } }
public void ShouldWriteColumns() { var mapping = new DiscriminatorMapping(); mapping.AddColumn(new ColumnMapping { Name = "Column1" }); writer.VerifyXml(mapping) .Element("column").Exists(); }
DiscriminatorMapping IDiscriminatorMappingProvider.GetDiscriminatorMapping() { var mapping = new DiscriminatorMapping(attributes.CloneInner()) { ContainingEntityType = entity, }; mapping.SetDefaultValue("Type", discriminatorValueType); mapping.AddColumn(new ColumnMapping(columnAttributes.CloneInner()) { Name = columnName }); return(mapping); }
DiscriminatorMapping IDiscriminatorMappingProvider.GetDiscriminatorMapping() { var mapping = new DiscriminatorMapping(attributes.Clone()) { ContainingEntityType = entity, }; mapping.Set(x => x.Type, Layer.Defaults, discriminatorValueType); var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, columnName); mapping.AddColumn(Layer.Defaults, columnMapping); return(mapping); }
public void CreateDsl() { mapping = new DiscriminatorMapping(); inspector = new DiscriminatorInspector(mapping); }
public override void Visit(DiscriminatorMapping discriminatorMapping) { discriminatorMapping.AcceptVisitor(this); }
public virtual void ProcessDiscriminator(DiscriminatorMapping discriminatorMapping) { }
public virtual void Visit(DiscriminatorMapping discriminatorMapping) { }
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <Member> mappedMembers) { var discriminatorSet = HasDiscriminator(mapping); var isDiscriminated = cfg.IsDiscriminated(classType) || discriminatorSet; var mappingTypesWithLogicalParents = GetMappingTypesWithLogicalParents(); foreach (var inheritedClass in mappingTypesWithLogicalParents .Where(x => x.Value != null && x.Value.Type == classType) .Select(x => x.Key)) { if (isDiscriminated && !discriminatorSet && mapping is ClassMapping) { var discriminatorColumn = cfg.GetDiscriminatorColumn(classType); var discriminator = new DiscriminatorMapping { ContainingEntityType = classType, Type = new TypeReference(typeof(string)) }; discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn }); ((ClassMapping)mapping).Discriminator = discriminator; discriminatorSet = true; } SubclassMapping subclassMapping; if (!isDiscriminated) { subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass) { Type = inheritedClass.Type }; subclassMapping.Key = new KeyMapping(); subclassMapping.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" }); } else { subclassMapping = new SubclassMapping(SubclassType.Subclass) { Type = inheritedClass.Type } }; // track separate set of properties for each sub-tree within inheritance hierarchy var subclassMembers = new List <Member>(mappedMembers); MapSubclass(subclassMembers, subclassMapping, inheritedClass); mapping.AddSubclass(subclassMapping); MergeMap(inheritedClass.Type, subclassMapping, subclassMembers); } } bool HasDiscriminator(ClassMappingBase mapping) { if (mapping is ClassMapping && ((ClassMapping)mapping).Discriminator != null) { return(true); } return(false); } Dictionary <AutoMapType, AutoMapType> GetMappingTypesWithLogicalParents() { var excludedTypes = mappingTypes .Where(x => cfg.IsConcreteBaseType(x.Type.BaseType)) .ToArray(); var availableTypes = mappingTypes.Except(excludedTypes); var mappingTypesWithLogicalParents = new Dictionary <AutoMapType, AutoMapType>(); foreach (var type in availableTypes) { mappingTypesWithLogicalParents.Add(type, GetLogicalParent(type.Type, availableTypes)); } return(mappingTypesWithLogicalParents); } AutoMapType GetLogicalParent(Type type, IEnumerable <AutoMapType> availableTypes) { if (type.BaseType == typeof(object) || type.BaseType == null) { return(null); } var baseType = availableTypes.FirstOrDefault(x => x.Type == type.BaseType); if (baseType != null) { return(baseType); } return(GetLogicalParent(type.BaseType, availableTypes)); }
public DiscriminatorInspector(DiscriminatorMapping mapping) : base(mapping.Columns) { this.mapping = mapping; propertyMappings.Map(x => x.Nullable, "NotNull"); }