public void TestLoadClassDefs()
{
IClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList =
loader.LoadClassDefs(
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" );
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
public void TestLoadClassDefs_WithParameterLessConstructor_ShouldLoadTwoClasses()
{
const string classDefsXml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
IClassDefsLoader loader = new XmlClassDefsLoader(classDefsXml, new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefList =
loader.LoadClassDefs();
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
public void Test_Valid_Relationship_1_M_Relationships_PrimaryAndForeignKeyDoesNotMatchRelationshipCardinality()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""multiple"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"),
"Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"),
"Class 'TestRelatedClass' should have been loaded.");
Assert.Fail("wRITE TEST THSI should throw validation error");
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
}
public void Test_Force_PrimaryKey_IsObjectID_False_AsCompulsoryWriteOnce_WithReadWriteRule_ReadWrite()
{
//-------------Setup Test Pack ------------------
const string xml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""string"" readWriteRule=""ReadWrite""/>
<primaryKey isObjectID=""false"">
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//-------------Execute test ---------------------
ClassDefCol classDefs = loader.LoadClassDefs(xml);
//---------------Test Result -----------------------
Assert.AreEqual(1, classDefs.Count);
Assert.IsTrue(classDefs.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
IClassDef classDef = classDefs["Habanero.Test.BO.Loaders", "TestClass"];
Assert.AreEqual(1, classDef.PrimaryKeyDef.Count);
IPropDef keyPropDef = classDef.PrimaryKeyDef[0];
Assert.IsFalse(keyPropDef.Compulsory);
Assert.AreEqual(PropReadWriteRule.ReadWrite, keyPropDef.ReadWriteRule);
}
///<summary>
/// Returns the <see cref="ClassDef"/> for the super class defined in the specified <see cref="SuperClassDef"/>.
///</summary>
///<param name="superClassDef">The <see cref="SuperClassDef"/> for which to find its Super class <see cref="ClassDef"/>.</param>
///<param name="classDefCol">The <see cref="ClassDefCol"/> to use to search for the super class <see cref="ClassDef"/>.</param>
///<returns>Returns the <see cref="ClassDef"/> for the super class defined in the specified <see cref="SuperClassDef"/>.</returns>
///<exception cref="InvalidXmlDefinitionException"></exception>
public static ClassDef GetSuperClassClassDef(ISuperClassDef superClassDef, ClassDefCol classDefCol)
{
ClassDef superClassClassDef = null;
string assemblyName = superClassDef.AssemblyName;
string className = superClassDef.ClassName;
if (assemblyName != null && className != null)
{
if (!string.IsNullOrEmpty(superClassDef.TypeParameter))
{
className = className + "_" + superClassDef.TypeParameter;
}
if (classDefCol.Contains(assemblyName, className))
{
superClassClassDef = (ClassDef)classDefCol[assemblyName, className];
}
if (superClassClassDef == null)
{
throw new InvalidXmlDefinitionException(String.Format(
"The class definition for the super class with the type " +
"'{0}' was not found. Check that the class definition " +
"exists or that spelling and capitalisation are correct. " +
"There are {1} class definitions currently loaded."
, assemblyName + "." + className, classDefCol.Count));
}
}
return(superClassClassDef);
}
public void TestLoadClassDefs_InheritedClassWithNoPrimaryKey_WithRelationship()
{
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList =
loader.LoadClassDefs(
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClass2"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClass2ID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClass2ID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
<property name=""RelatedTestClassID"" type=""Guid"" />
<relationship name=""TestRelationship"" type=""single""
relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""RelatedTestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" );
Assert.AreEqual(3, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass2"), "Class 'TestClass2' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClassInherited"), "Class 'TestClassInherited' should have been loaded.");
IClassDef classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
IClassDef classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
Assert.IsNotNull(classDefTestClass);
Assert.IsNotNull(classDefInherited.SuperClassDef);
Assert.IsNull(classDefInherited.PrimaryKeyDef);
IRelationshipDefCol relDefCol = classDefInherited.RelationshipDefCol;
Assert.AreEqual(1, relDefCol.Count, "There should be one relationship def from the given xml definition");
Assert.IsNotNull(relDefCol["TestRelationship"], "'TestRelationship' should be the name of the relationship created");
}
public void Test_Valid_Relationship_1_1_NoReverse_RelatatedProp_IsPartOfCompositePrimaryKey()
{
//----------------------Test Setup ----------------------
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey isObjectID=""false"">
<prop name=""TestRelatedClassID""/>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef relationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
}
public void Test_Valid_Relationship_Loads_Where_RelatedClass_IsLoaded_After_InitialLoad_NoReverseRelationshipSetup()
{
//----------------------Test Setup ----------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefCol = new ClassDefCol();
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
classDefCol.Add(loader.LoadClassDefs(classDefsString));
//--------------------Execute Test-------------------------
const string secondClassDefStringToLoad = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
classDefCol.Add(loader.LoadClassDefs(secondClassDefStringToLoad));
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
public void Test_Valid_Relationship()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator defValidator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert Preconditions-----------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"),
"Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"),
"Class 'TestRelatedClass' should have been loaded.");
//--------------------Execute Test-------------------------
defValidator.ValidateClassDefs(classDefList);
//--------------------Assert Results ----------------------
}
private static void MergeClassDefs(IClassDef classDef)
{
if (classDef.SuperClassDef != null)
{
//You always want the classDef that has been
// Mapped via its subClass
var superClassClassDef = classDef.SuperClassDef.SuperClassClassDef;
MergeClassDefs(superClassClassDef);
}
if (!ClassDefCol.Contains(classDef.ClassType))
{
ClassDefCol.Add(classDef);
}
}
public void TestLoadClassDefs_InheritedClassWithNoPrimaryKey()
{
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList =
loader.LoadClassDefs(
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClass2"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClass2ID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClass2ID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
</class>
</classes>
" );
Assert.AreEqual(3, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass2"), "Class 'TestClass2' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClassInherited"), "Class 'TestClassInherited' should have been loaded.");
IClassDef classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
IClassDef classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
Assert.IsNotNull(classDefTestClass);
Assert.IsNotNull(classDefInherited.SuperClassDef);
//This is expecting a null PrimaryKeyDef because the global ClassDef.Classdefs col is not loaded yet.
Assert.IsNull(classDefInherited.PrimaryKeyDef);
}
public void Test_Valid_Relationship_Loads_Where_RelatedClass_IsLoaded_After_InitialLoad_NoReverseRelationshipSetup()
{
//----------------------Test Setup ----------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefCol = new ClassDefCol();
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
";
classDefCol.Add(loader.LoadClassDefs(classDefsString));
//--------------------Execute Test-------------------------
const string secondClassDefStringToLoad = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
";
classDefCol.Add(loader.LoadClassDefs(secondClassDefStringToLoad));
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
private static bool ContainsRelatedClass(IRelationshipDef relationship, ClassDefCol classDefCol)
{
return classDefCol.Contains(relationship.RelatedObjectAssemblyName, relationship.RelatedObjectClassName);
}
private void CreateRelationships(ClassDefCol classDefCol, ClassDef classDef)
{
//ALTER TABLE `invoice`
// ADD CONSTRAINT `Invoice_InvoiceStatus_FK` FOREIGN KEY `Invoice_InvoiceStatus_FK` (`InvoiceStatusID`)
// REFERENCES `invoicestatus` (`InvoiceStatusID`)
// ON DELETE RESTRICT
// ON UPDATE RESTRICT;
if (classDef.SuperClassDef != null && classDef.SuperClassDef.ORMapping == ORMapping.SingleTableInheritance)
{
return;
}
string sqlStatement;
sqlStatement = "ALTER TABLE ";
sqlStatement += _databaseConnection.SqlFormatter.DelimitTable(classDef.TableName);
List<string> constraints = new List<string>();
foreach (RelationshipDef relationshipDef in classDef.RelationshipDefCol)
{
if (relationshipDef is SingleRelationshipDef)
{
if (!classDefCol.Contains(relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassName))
{
throw new Exception("Related class not found:" + relationshipDef.RelatedObjectAssemblyName + "." + relationshipDef.RelatedObjectClassName);
}
IClassDef relatedClassDef = classDefCol[relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassName];
string constraintName = _databaseConnection.SqlFormatter.DelimitField(
classDef.TableName + "_" + relationshipDef.RelationshipName + "_FK");
string constraintSql = " ADD CONSTRAINT " + constraintName;
constraintSql += " FOREIGN KEY " + constraintName;
List<string> props = new List<string>();
List<string> relProps = new List<string>();
foreach (RelPropDef relPropDef in relationshipDef.RelKeyDef)
{
string propName = relPropDef.OwnerPropertyName;
string relPropName = relPropDef.RelatedClassPropName;
IPropDef ownerPropDef = classDef.GetPropDef(propName);
if (ownerPropDef != null)
{
propName = ownerPropDef.DatabaseFieldName;
}
IPropDef relatedPropDef = relatedClassDef.GetPropDef(relPropName);
if (relatedPropDef != null)
{
relPropName = relatedPropDef.DatabaseFieldName;
}
props.Add(_databaseConnection.SqlFormatter.DelimitField(propName));
relProps.Add(_databaseConnection.SqlFormatter.DelimitField(relPropName));
}
constraintSql += " (" + String.Join(",", props.ToArray()) + ")";
constraintSql += " REFERENCES ";
IClassDef relatedBaseClassDef = relatedClassDef;
while (relatedBaseClassDef.SuperClassDef != null && relatedBaseClassDef.SuperClassDef.ORMapping == ORMapping.SingleTableInheritance)
{
relatedBaseClassDef = (ClassDef)relatedBaseClassDef.SuperClassDef.SuperClassClassDef;
}
string relatedTableName = relatedBaseClassDef.TableName;
constraintSql += _databaseConnection.SqlFormatter.DelimitTable(relatedTableName);
constraintSql += " (" + String.Join(",", relProps.ToArray()) + ")";
constraintSql += " ON DELETE RESTRICT ";
constraintSql += " ON UPDATE RESTRICT";
constraints.Add(constraintSql);
}
}
sqlStatement += String.Join(", ", constraints.ToArray());
sqlStatement += ";";
if (constraints.Count > 0)
{
_statements.Add(sqlStatement);
}
}
private void CreateRelationships(ClassDefCol classDefCol, ClassDef classDef)
{
//ALTER TABLE `invoice`
// ADD CONSTRAINT `Invoice_InvoiceStatus_FK` FOREIGN KEY `Invoice_InvoiceStatus_FK` (`InvoiceStatusID`)
// REFERENCES `invoicestatus` (`InvoiceStatusID`)
// ON DELETE RESTRICT
// ON UPDATE RESTRICT;
if (classDef.SuperClassDef != null && classDef.SuperClassDef.ORMapping == ORMapping.SingleTableInheritance)
{
return;
}
string sqlStatement;
sqlStatement = "ALTER TABLE ";
sqlStatement += _databaseConnection.SqlFormatter.DelimitTable(classDef.TableName);
List <string> constraints = new List <string>();
foreach (RelationshipDef relationshipDef in classDef.RelationshipDefCol)
{
if (relationshipDef is SingleRelationshipDef)
{
if (!classDefCol.Contains(relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassName))
{
throw new Exception("Related class not found:" + relationshipDef.RelatedObjectAssemblyName + "." + relationshipDef.RelatedObjectClassName);
}
IClassDef relatedClassDef = classDefCol[relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassName];
string constraintName = _databaseConnection.SqlFormatter.DelimitField(
classDef.TableName + "_" + relationshipDef.RelationshipName + "_FK");
string constraintSql = " ADD CONSTRAINT " + constraintName;
constraintSql += " FOREIGN KEY " + constraintName;
List <string> props = new List <string>();
List <string> relProps = new List <string>();
foreach (RelPropDef relPropDef in relationshipDef.RelKeyDef)
{
string propName = relPropDef.OwnerPropertyName;
string relPropName = relPropDef.RelatedClassPropName;
IPropDef ownerPropDef = classDef.GetPropDef(propName);
if (ownerPropDef != null)
{
propName = ownerPropDef.DatabaseFieldName;
}
IPropDef relatedPropDef = relatedClassDef.GetPropDef(relPropName);
if (relatedPropDef != null)
{
relPropName = relatedPropDef.DatabaseFieldName;
}
props.Add(_databaseConnection.SqlFormatter.DelimitField(propName));
relProps.Add(_databaseConnection.SqlFormatter.DelimitField(relPropName));
}
constraintSql += " (" + String.Join(",", props.ToArray()) + ")";
constraintSql += " REFERENCES ";
IClassDef relatedBaseClassDef = relatedClassDef;
while (relatedBaseClassDef.SuperClassDef != null && relatedBaseClassDef.SuperClassDef.ORMapping == ORMapping.SingleTableInheritance)
{
relatedBaseClassDef = (ClassDef)relatedBaseClassDef.SuperClassDef.SuperClassClassDef;
}
string relatedTableName = relatedBaseClassDef.TableName;
constraintSql += _databaseConnection.SqlFormatter.DelimitTable(relatedTableName);
constraintSql += " (" + String.Join(",", relProps.ToArray()) + ")";
constraintSql += " ON DELETE RESTRICT ";
constraintSql += " ON UPDATE RESTRICT";
constraints.Add(constraintSql);
}
}
sqlStatement += String.Join(", ", constraints.ToArray());
sqlStatement += ";";
if (constraints.Count > 0)
{
_statements.Add(sqlStatement);
}
}
private static bool ContainsRelatedClass(IRelationshipDef relationship, ClassDefCol classDefCol)
{
return(classDefCol.Contains(relationship.RelatedObjectAssemblyName, relationship.RelatedObjectClassName));
}
///<summary>
/// Returns the <see cref="ClassDef"/> for the super class defined in the specified <see cref="SuperClassDef"/>.
///</summary>
///<param name="superClassDef">The <see cref="SuperClassDef"/> for which to find its Super class <see cref="ClassDef"/>.</param>
///<param name="classDefCol">The <see cref="ClassDefCol"/> to use to search for the super class <see cref="ClassDef"/>.</param>
///<returns>Returns the <see cref="ClassDef"/> for the super class defined in the specified <see cref="SuperClassDef"/>.</returns>
///<exception cref="InvalidXmlDefinitionException"></exception>
public static ClassDef GetSuperClassClassDef(ISuperClassDef superClassDef, ClassDefCol classDefCol)
{
ClassDef superClassClassDef = null;
string assemblyName = superClassDef.AssemblyName;
string className = superClassDef.ClassName;
if (assemblyName != null && className != null)
{
if (!string.IsNullOrEmpty(superClassDef.TypeParameter)) className = className + "_" + superClassDef.TypeParameter;
if (classDefCol.Contains(assemblyName, className))
{
superClassClassDef = (ClassDef) classDefCol[assemblyName, className];
}
if (superClassClassDef == null)
{
throw new InvalidXmlDefinitionException(String.Format(
"The class definition for the super class with the type " +
"'{0}' was not found. Check that the class definition " +
"exists or that spelling and capitalisation are correct. " +
"There are {1} class definitions currently loaded."
, assemblyName + "." + className, classDefCol.Count));
}
}
return superClassClassDef;
}
