private map CreateMapNode(DirectedReference reference, key keyNode, string cascade, collectionFetchMode colFetchMode, string lazyString, bool inverse)
{
var lazy = (collectionLazy)Enum.Parse(typeof(collectionLazy), lazyString.ToString().Replace("_", ""), true);
map mapNode = new map();
mapNode.name = reference.FromName;
mapNode.key = keyNode;
mapNode.cascade = cascade == "none" ? null : cascade;
mapNode.inverse = inverse;
mapNode.fetchSpecified = colFetchMode != collectionFetchMode.select;
mapNode.fetch = colFetchMode;
mapNode.lazySpecified = lazy != collectionLazy.@true;
mapNode.lazy = (collectionLazy)Enum.Parse(typeof(collectionLazy), lazy.ToString().Replace("_", ""), true);
var sqlWhereClause = NHCollections.GetSqlWhereClause(reference);
if (string.IsNullOrEmpty(sqlWhereClause) == false)
{
mapNode.where = sqlWhereClause;
}
return(mapNode);
}
public void It_Creates_The_Right_Relationship()
{
var entity1 = mappingSet.EntitySet.GetEntity("BasicClass1");
var entity2 = mappingSet.EntitySet.GetEntity("BasicClass2");
Assert.That(entity1.References, Has.Count(1));
Assert.That(entity2.References, Has.Count(1));
Assert.That(entity1.References[0], Is.SameAs(entity2.References[0]));
DirectedReference reference = entity1.DirectedReferences.First();
Assert.That(reference.FromName, Is.EqualTo("Class2s"));
Assert.That(reference.ToName, Is.EqualTo("Property1"));
Assert.That(reference.FromEndCardinality, Is.EqualTo(Cardinality.Many));
Assert.That(reference.ToEndCardinality, Is.EqualTo(Cardinality.One));
Assert.That(reference.FromEndEnabled, Is.True);
Assert.That(reference.ToEndEnabled, Is.True);
var indexColumnName = NHCollections.GetIndexColumnName(reference);
Assert.That(indexColumnName, Is.EqualTo("BasicClass2_Index"));
}
public IValidationResult Run(MappingSet set)
{
IValidationResult result = new ValidationResult(this);
foreach (var reference in set.EntitySet.Entities.SelectMany(e => e.References).Distinct())
{
var mappedTable = reference.MappedTable();
if (reference.Cardinality1 == ArchAngel.Interfaces.Cardinality.Many &&
reference.Cardinality2 == ArchAngel.Interfaces.Cardinality.Many)
{
if (mappedTable == null)
{
result.Issues.Add(new ValidationIssue(string.Format("Reference [{0} to {1}] with many-to-many collection type is missing an Association Table.", reference.Entity1.Name, reference.Entity2.Name), reference, ValidationErrorLevel.Error));
}
else
{
// Check that columns exist and match for the mapped table.
var primaryTable1 = ArchAngel.NHibernateHelper.MappingFiles.Version_2_2.EntityMapper.GetPrimaryTable(reference.Entity1);
var primaryTable2 = ArchAngel.NHibernateHelper.MappingFiles.Version_2_2.EntityMapper.GetPrimaryTable(reference.Entity2);
if (mappedTable.Relationships.Where(t => t.PrimaryTable == primaryTable1).Count() == 0)
{
result.Issues.Add(new ValidationIssue(string.Format("Reference [{0} to {1}] with many-to-many collection type is missing an Association Table.", reference.Entity1.Name, reference.Entity2.Name), reference, ValidationErrorLevel.Error));
}
if (mappedTable.Relationships.Where(t => t.PrimaryTable == primaryTable2).Count() == 0)
{
result.Issues.Add(new ValidationIssue(string.Format("Reference [{0} to {1}] with many-to-many collection type is missing an Association Table.", reference.Entity1.Name, reference.Entity2.Name), reference, ValidationErrorLevel.Error));
}
}
}
else if (reference.MappedRelationship() == null && mappedTable == null)
{
result.Issues.Add(new ValidationIssue(string.Format("Reference [{0} to {1}] is missing a Mapped Relationship or Association Table.", reference.Entity1.Name, reference.Entity2.Name), reference, ValidationErrorLevel.Error));
}
}
foreach (var directedReference in set.EntitySet.Entities.SelectMany(e => e.DirectedReferences).Distinct())
{
var collectionType = (ArchAngel.Interfaces.Scripting.NHibernate.Model.CollectionTypes)Enum.Parse(typeof(ArchAngel.Interfaces.Scripting.NHibernate.Model.CollectionTypes), NHCollections.GetAssociationType(directedReference).ToString(), true);
if (collectionType == ArchAngel.Interfaces.Scripting.NHibernate.Model.CollectionTypes.Map ||
collectionType == ArchAngel.Interfaces.Scripting.NHibernate.Model.CollectionTypes.IDBag ||
collectionType == ArchAngel.Interfaces.Scripting.NHibernate.Model.CollectionTypes.List)
{
var indexColumn = NHCollections.GetIndexColumn(directedReference, ArchAngel.NHibernateHelper.MappingFiles.Version_2_2.EntityMapper.GetPrimaryTable(directedReference.ToEntity));
if (indexColumn == null)
{
result.Issues.Add(new ValidationIssue(string.Format("'{0}' collection [{1} to {2}] has an invalid index column specified.",
collectionType.ToString(),
directedReference.FromEntity.Name,
directedReference.ToEntity.Name), directedReference.Reference, ValidationErrorLevel.Error));
}
//newReference.CollectionIndexColumn = columnLookups[NHCollections.GetIndexColumn(directedReference, ArchAngel.NHibernateHelper.MappingFiles.Version_2_2.EntityMapper.GetPrimaryTable(directedReference.FromEntity))];
}
//else if (collectionType == Interfaces.Scripting.NHibernate.Model.CollectionTypes.None &&
// directedReference.FromEndCardinality == ArchAngel.Interfaces.Cardinality.Many)
//{
// result.Issues.Add(new ValidationIssue(string.Format("No collection type has been set for the reference between {1} and {2}.",
// collectionType.ToString(),
// directedReference.FromEntity.Name,
// directedReference.ToEntity.Name), directedReference.Reference, ValidationErrorLevel.Error));
//}
}
return(result);
}
private void ProcessManyToOneReference(
Entity entity,
DirectedReference directedReference,
Action <object> addItem,
string cascade,
string collectionCascade,
string lazy,
string orderByClause,
bool inverse)
{
if (directedReference.FromEndEnabled == false)
{
return;
}
ITable referenceMappedTable = directedReference.Reference.MappedTable();
DirectedRelationship directedRelationship = null;
if (referenceMappedTable == null)
{
directedRelationship = GetDirectedMappedRelationship(entity, directedReference.Reference);
}
if (directedReference.FromEndCardinality == Cardinality.One)
{
fetchMode fetchMode;
bool insert;
bool update;
if (directedReference.Entity1IsFromEnd)
{
fetchMode = (fetchMode)Enum.Parse(typeof(fetchMode), directedReference.Reference.GetReferenceEnd1FetchMode().ToString(), true);
insert = directedReference.Reference.GetReferenceEnd1Insert();
update = directedReference.Reference.GetReferenceEnd1Update();
}
else
{
fetchMode = (fetchMode)Enum.Parse(typeof(fetchMode), directedReference.Reference.GetReferenceEnd2FetchMode().ToString(), true);
insert = directedReference.Reference.GetReferenceEnd2Insert();
update = directedReference.Reference.GetReferenceEnd2Update();
}
manytoone manyToOneNode;
if (referenceMappedTable == null)
{
manyToOneNode = CreateManyToOneNode(directedReference, directedRelationship, cascade);
}
else
{
manyToOneNode = CreateManyToOneNode(directedReference, referenceMappedTable);
}
manyToOneNode.fetch = fetchMode;
manyToOneNode.fetchSpecified = true;
manyToOneNode.insert = insert;
manyToOneNode.update = update;
addItem(manyToOneNode);
}
else
{
key keyNode = new key();
if (referenceMappedTable == null &&
directedRelationship.ToKey.Columns.Count > 1)
{
foreach (var columnNode in GetColumnNodes(directedRelationship.ToKey.Columns))
{
keyNode.AddColumn(columnNode);
}
}
else if (referenceMappedTable != null)
{
ITable toPrimaryMappedTable = EntityMapper.GetPrimaryTable(directedReference.ToEntity);
var toColumnsInPrimaryKey = referenceMappedTable.Relationships.First(t => t.PrimaryTable == toPrimaryMappedTable || t.ForeignTable == toPrimaryMappedTable).ForeignKey.Columns;
foreach (var columnNode in GetColumnNodes(toColumnsInPrimaryKey))
{
keyNode.AddColumn(columnNode);
}
}
else
{
keyNode.column1 = directedRelationship.ToKey.Columns[0].Name.BackTick();
}
onetomany oneToManyNode = new onetomany();
oneToManyNode.@class = directedReference.ToEntity.Name;
collectionFetchMode collFetchMode;
if (directedReference.Entity1IsFromEnd)
{
collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd1CollectionFetchMode().ToString(), true);
}
else
{
collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd2CollectionFetchMode().ToString(), true);
}
AssociationType type = NHCollections.GetAssociationType(directedReference);
switch (type)
{
case AssociationType.None:
Log.WarnFormat("No association type was set on reference {0} for the end {1}. This is usually an error.", directedReference.Reference.Name, directedReference.Entity1IsFromEnd ? "1" : "2");
return;
case AssociationType.Set:
var set = CreateSetNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
set.Item = oneToManyNode;
if (orderByClause.Length > 0)
{
set.orderby = orderByClause;
}
addItem(set);
break;
case AssociationType.Map:
var mapNode = CreateMapNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
mapNode.Item = new index
{
column1 = NHCollections.GetIndexColumnName(directedReference),
type = NHCollections.GetIndexColumnTypeName(directedReference, EntityMapper.GetPrimaryTable(directedReference.ToEntity))
};
mapNode.Item1 = oneToManyNode;
if (orderByClause.Length > 0)
{
mapNode.orderby = orderByClause;
}
addItem(mapNode);
break;
case AssociationType.Bag:
var bag = CreateBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
bag.Item = oneToManyNode;
if (orderByClause.Length > 0)
{
bag.orderby = orderByClause;
}
addItem(bag);
break;
case AssociationType.List:
list listNode = CreateListNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
listNode.Item = new index {
column1 = NHCollections.GetIndexColumnName(directedReference)
};
listNode.Item1 = oneToManyNode;
if (orderByClause.Length > 0)
{
listNode.orderby = orderByClause;
}
addItem(listNode);
break;
case AssociationType.IDBag:
idbag idbagNode = CreateIdBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
idbagNode.collectionid = new collectionid
{
column1 = NHCollections.GetIndexColumnName(directedReference),
generator = new generator {
@class = "sequence"
},
type = NHCollections.GetIndexColumnTypeName(directedReference, EntityMapper.GetPrimaryTable(directedReference.ToEntity))
};
addItem(idbagNode);
break;
default:
throw new ArgumentOutOfRangeException("AssociationType not handled yet: " + type.ToString());
}
}
}
private void ProcessManyToManyReference(
Entity entity,
DirectedReference directedReference,
Action <object> addItem,
Dictionary <ITable, int> manyToManySameTableProcessingCounts,
string collectionCascade,
string lazy,
string orderByClause,
bool inverse)
{
if (directedReference.FromEndEnabled == false)
{
return;
}
ITable referenceMappedTable = directedReference.Reference.MappedTable();
ITable fromPrimaryMappedTable = EntityMapper.GetPrimaryTable(entity);
ITable toPrimaryMappedTable = EntityMapper.GetPrimaryTable(directedReference.ToEntity);
Cardinality cardinalityPrimary;
Cardinality cardinalityForeign;
IKey mainKey;
IKey associationKey;
ITable associationTable = entity.GetAssociationTable(directedReference.ToEntity, out cardinalityPrimary, out cardinalityForeign, out mainKey, out associationKey);
key keyNode = new key();
List <IColumn> fromInPrimaryKey = new List <IColumn>();
List <IColumn> toInPrimaryKey = new List <IColumn>();
if (fromPrimaryMappedTable == toPrimaryMappedTable)
{
// This many-to-many relationship is to the same table
if (manyToManySameTableProcessingCounts.ContainsKey(toPrimaryMappedTable))
{
int index = manyToManySameTableProcessingCounts[toPrimaryMappedTable];
index++;
fromInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).ElementAt(index).PrimaryKey.Columns);
toInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).ElementAt(index).ForeignKey.Columns);
manyToManySameTableProcessingCounts[toPrimaryMappedTable] = index;
}
else
{
fromInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).ElementAt(0).PrimaryKey.Columns);
toInPrimaryKey.AddRange(referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).ElementAt(0).ForeignKey.Columns);
manyToManySameTableProcessingCounts.Add(toPrimaryMappedTable, 0);
}
}
else
{
foreach (var coll in referenceMappedTable.Relationships.Where(t => t.PrimaryTable == fromPrimaryMappedTable).Select(r => r.ForeignKey.Columns))
{
foreach (var c in coll)
{
fromInPrimaryKey.Add(c);
}
}
foreach (var coll in referenceMappedTable.Relationships.Where(t => t.PrimaryTable == toPrimaryMappedTable).Select(r => r.ForeignKey.Columns))
{
foreach (var c in coll)
{
toInPrimaryKey.Add(c);
}
}
}
if (fromInPrimaryKey.Count() == 1)
{
keyNode.column1 = fromInPrimaryKey.First().Name.BackTick();
}
else
{
foreach (var columnNode in GetColumnNodes(fromInPrimaryKey))
{
keyNode.AddColumn(columnNode);
}
}
manytomany manyToManyNode = new manytomany();
manyToManyNode.@class = directedReference.ToEntity.Name;
if (toInPrimaryKey.Count() == 1)
{
manyToManyNode.column = toInPrimaryKey.First().Name.BackTick();
}
else
{
foreach (var columnNode in GetColumnNodes(toInPrimaryKey))
{
keyNode.AddColumn(columnNode);
}
}
collectionFetchMode collFetchMode;
if (directedReference.Entity1IsFromEnd)
{
collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd1CollectionFetchMode().ToString(), true);
}
else
{
collFetchMode = (collectionFetchMode)Enum.Parse(typeof(collectionFetchMode), directedReference.Reference.GetReferenceEnd2CollectionFetchMode().ToString(), true);
}
AssociationType type = NHCollections.GetAssociationType(directedReference);
switch (type)
{
case AssociationType.None:
Log.WarnFormat("No association type was set on reference {0} for the end {1}. This is usually an error.", directedReference.Reference.Name, directedReference.Entity1IsFromEnd ? "One" : "Two");
return;
case AssociationType.Set:
set setNode = CreateSetNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
setNode.table = referenceMappedTable.Name.BackTick();
setNode.Item = manyToManyNode;
if (orderByClause.Length > 0)
{
setNode.orderby = orderByClause;
}
addItem(setNode);
break;
case AssociationType.Bag:
bag bagNode = CreateBagNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
bagNode.table = referenceMappedTable.Name.BackTick();
bagNode.Item = manyToManyNode;
if (orderByClause.Length > 0)
{
bagNode.orderby = orderByClause;
}
addItem(bagNode);
break;
case AssociationType.Map:
map mapNode = CreateMapNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
mapNode.table = referenceMappedTable.Name.BackTick();
mapNode.Item = new index
{
column1 = NHCollections.GetIndexColumnName(directedReference),
type = NHCollections.GetIndexColumnTypeName(directedReference, toPrimaryMappedTable /*fromPrimaryMappedTable*/)
};
mapNode.Item1 = manyToManyNode;
if (orderByClause.Length > 0)
{
mapNode.orderby = orderByClause;
}
addItem(mapNode);
break;
case AssociationType.List:
list listNode = CreateListNode(directedReference, keyNode, collectionCascade, collFetchMode, lazy, inverse);
listNode.table = referenceMappedTable.Name.BackTick();
listNode.Item = new index
{
column1 = NHCollections.GetIndexColumnName(directedReference),
};
listNode.Item1 = manyToManyNode;
if (orderByClause.Length > 0)
{
listNode.orderby = orderByClause;
}
addItem(listNode);
break;
// case AssociationType.IDBag:
// throw new NotImplementedException(
// string.Format("Have not implemented {0} association type for Many To Many relationships", type));
default:
throw new NotImplementedException("AssociationType not handled yet: " + type.ToString());
}
}
