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