public void TestMergeWith()
{
//-------------Setup Test Pack ------------------
Source originalSource = new Source("FromSource", "FromSourceEntity");
Source.JoinList originalJoinList = new Source.JoinList(originalSource);
Source otherSource = new Source("FromSource", "FromSourceEntity");
Source.JoinList joinList = new Source.JoinList(otherSource);
Source childSource = new Source("ToSource", "ToSourceEntity");
Source.Join join = joinList.AddNewJoinTo(childSource, Source.JoinType.InnerJoin);
QueryField field1 = new QueryField("FromSourceProp1", "FromSourceProp1Field", otherSource);
QueryField field2 = new QueryField("ToSourceProp1", "ToSourceProp1Field", childSource);
join.JoinFields.Add(new Source.Join.JoinField(field1, field2));
//-------------Execute test ---------------------
originalJoinList.MergeWith(joinList);
//-------------Test Result ----------------------
Assert.AreEqual(1, originalJoinList.Count);
Assert.AreEqual(1, originalJoinList[0].JoinFields.Count);
Assert.AreEqual(field1, originalJoinList[0].JoinFields[0].FromField);
Assert.AreEqual(field2, originalJoinList[0].JoinFields[0].ToField);
}
public void TestCreateSQL_WithJoin_NoFields()
{
//-------------Setup Test Pack ------------------
string tableName = "MY_SOURCE";
Source source = new Source("MySource", tableName);
string joinTableName = "MY_JOINED_TABLE";
Source joinSource = new Source("JoinSource", joinTableName);
Source.Join join = new Source.Join(source, joinSource);
source.Joins.Add(join);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
Exception exception = null;
try
{
sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource));
} catch (Exception ex)
{
exception = ex;
}
//-------------Test Result ----------------------
Assert.IsNotNull(exception, "An error was expected when creating SQL with joins that have no fields");
Assert.IsInstanceOf(typeof(HabaneroDeveloperException), exception);
string expectedMessage = string.Format("SQL cannot be created for the source '{0}' because it has a join to '{1}' without join fields",
sourceDB.Name, join.ToSource.Name);
StringAssert.Contains(expectedMessage, exception.Message);
}
public void TestCreateSQL_WithInheritanceJoin_TwoLevels()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source joinSource2 = new Source("JoinSource2", "MY_JOINED_TABLE_2");
Source.Join join = CreateAndAddInheritanceJoin(source, joinSource);
Source.Join join2 = CreateAndAddInheritanceJoin(joinSource, joinSource2);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
string sql = sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource, joinSource2));
//-------------Test Result ----------------------
Source.Join.JoinField joinField = join.JoinFields[0];
Source.Join.JoinField joinField2 = join2.JoinFields[0];
string expectedSql = string.Format("(({0} a1 JOIN {1} a2 ON a1.{2} = a2.{3}) JOIN {4} a3 ON a2.{5} = a3.{6})",
sourceDB.EntityName,
joinSource.EntityName, joinField.FromField.FieldName, joinField.ToField.FieldName,
joinSource2.EntityName, joinField2.FromField.FieldName, joinField2.ToField.FieldName);
Assert.AreEqual(expectedSql, sql);
}
public void TestCreateSQL_WithJoin_TwoFields()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = CreateAndAddJoin(source, joinSource);
QueryField fromField = new QueryField("FromField2", "FROM_FIELD2", source);
QueryField toField = new QueryField("ToField2", "TO_FIELD2", joinSource);
join.JoinFields.Add(new Source.Join.JoinField(fromField, toField));
Source.Join.JoinField joinField1 = join.JoinFields[0];
Source.Join.JoinField joinField2 = join.JoinFields[1];
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
string sql = sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource));
//-------------Test Result ----------------------
string expectedSql = string.Format("({0} a1 JOIN {1} a2 ON a1.{2} = a2.{3} AND a1.{4} = a2.{5})",
source.EntityName, joinSource.EntityName,
joinField1.FromField.FieldName, joinField1.ToField.FieldName,
joinField2.FromField.FieldName, joinField2.ToField.FieldName);
Assert.AreEqual(expectedSql, sql);
}
public void TestCreateSQL_WithJoin_SecondLevel_TwoBranches()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source branch1 = new Source("JoinBranch1", "MY_BRANCH_1");
Source branch2 = new Source("JoinBranch2", "MY_BRANCH_2");
Source.Join join = CreateAndAddJoin(source, joinSource);
Source.Join branchJoin1 = CreateAndAddJoin(joinSource, branch1);
Source.Join branchJoin2 = CreateAndAddJoin(joinSource, branch2);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
string sql = sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource, branch1, branch2));
//-------------Test Result ----------------------
Source.Join.JoinField joinField = join.JoinFields[0];
Source.Join.JoinField joinFieldBranch1 = branchJoin1.JoinFields[0];
Source.Join.JoinField joinFieldBranch2 = branchJoin2.JoinFields[0];
string expectedSql = string.Format("((({0} a1 JOIN {1} a2 ON a1.{4} = a2.{5}) JOIN {2} a3 ON a2.{6} = a3.{7}) JOIN {3} a4 ON a2.{8} = a4.{9})",
sourceDB.EntityName, joinSource.EntityName, branch1.EntityName, branch2.EntityName,
joinField.FromField.FieldName, joinField.ToField.FieldName,
joinFieldBranch1.FromField.FieldName, joinFieldBranch1.ToField.FieldName,
joinFieldBranch2.FromField.FieldName, joinFieldBranch2.ToField.FieldName);
Assert.AreEqual(expectedSql, sql);
}
private static Source.Join CreateJoin(Source fromSource, Source toSource)
{
Source.Join join = new Source.Join(fromSource, toSource);
QueryField fromField = new QueryField("FromField", "FROM_FIELD", fromSource);
QueryField toField = new QueryField("ToField", "TO_FIELD", toSource);
join.JoinFields.Add(new Source.Join.JoinField(fromField, toField));
return(join);
}
public void TestPrepareSource_ExistingSource_Relationship_TwoLevels()
{
//---------------Set up test pack-------------------
IClassDef engineClassDef = Engine.LoadClassDef_IncludingCarAndOwner();
Source carSource = Source.FromString("Car.Owner");
Source source = carSource;
//---------------Execute Test ----------------------
QueryBuilder.PrepareSource(engineClassDef, ref source);
//---------------Test Result -----------------------
Assert.IsNotNull(source);
Assert.AreNotSame(carSource, source);
Assert.AreEqual("Engine", source.Name);
Assert.AreEqual("Table_Engine", source.EntityName);
Assert.AreEqual(1, source.Joins.Count);
Source.Join join = source.Joins[0];
Source childSource = join.ToSource;
Assert.IsNotNull(childSource);
Assert.AreSame(carSource, childSource);
Assert.AreEqual("Car", childSource.Name);
Assert.AreEqual("car_table", childSource.EntityName);
Assert.AreEqual(1, join.JoinFields.Count);
Source.Join.JoinField joinField = join.JoinFields[0];
QueryField fromField = joinField.FromField;
Assert.AreSame(source, fromField.Source);
Assert.AreEqual("CarID", fromField.PropertyName);
Assert.AreEqual("CAR_ID", fromField.FieldName);
QueryField toField = joinField.ToField;
Assert.AreSame(childSource, toField.Source);
Assert.AreEqual("CarID", toField.PropertyName);
Assert.AreEqual("CAR_ID", toField.FieldName);
Assert.AreEqual(1, childSource.Joins.Count);
Source.Join childJoin = childSource.Joins[0];
Source grandChildSource = childJoin.ToSource;
Assert.IsNotNull(grandChildSource);
Assert.AreSame(carSource.ChildSource, grandChildSource);
Assert.AreEqual("Owner", grandChildSource.Name);
Assert.AreEqual("contact_person", grandChildSource.EntityName);
Assert.AreEqual(1, childJoin.JoinFields.Count);
Source.Join.JoinField childJoinField = childJoin.JoinFields[0];
QueryField childFromField = childJoinField.FromField;
Assert.AreSame(carSource, childFromField.Source);
Assert.AreEqual("OwnerId", childFromField.PropertyName);
Assert.AreEqual("OWNER_ID", childFromField.FieldName);
QueryField childToField = childJoinField.ToField;
Assert.AreSame(grandChildSource, childToField.Source);
Assert.AreEqual("ContactPersonID", childToField.PropertyName);
Assert.AreEqual("ContactPersonID", childToField.FieldName);
}
public void Test_Join_Constructor()
{
//---------------Set up test pack-------------------
Source fromSource = new Source("From");
Source toSource = new Source("To");
//---------------Execute Test ----------------------
Source.Join join = new Source.Join(fromSource, toSource);
//---------------Test Result -----------------------
Assert.AreSame(fromSource, join.FromSource);
Assert.AreSame(toSource, join.ToSource);
//---------------Tear Down -------------------------
}
protected virtual Source GetCorrectPartSourceStructure()
{
Source partSource = new Source("Part", "table_class_Part");
Source entitySource = new Source("Entity", "table_Entity");
Source.Join join = partSource.InheritanceJoins.AddNewJoinTo(entitySource, Source.JoinType.InnerJoin);
QueryField partQueryField = new QueryField("PartID", "field_Part_ID", partSource);
QueryField entityQueryField = new QueryField("EntityID", "field_Entity_ID", entitySource);
Source.Join.JoinField joinField = new Source.Join.JoinField(partQueryField, entityQueryField);
join.JoinFields.Add(joinField);
return(partSource);
}
protected virtual Source GetCorrectEngineSourceStructure()
{
Source engineSource = new Source("Engine", "table_class_Engine");
Source partSource = GetCorrectPartSourceStructure();
Source.Join join = engineSource.InheritanceJoins.AddNewJoinTo(partSource, Source.JoinType.InnerJoin);
QueryField engineQueryField = new QueryField("EngineID", "field_Engine_ID", engineSource);
QueryField partQueryField = new QueryField("PartID", "field_Part_ID", partSource);
Source.Join.JoinField joinField = new Source.Join.JoinField(engineQueryField, partQueryField);
join.JoinFields.Add(joinField);
return(engineSource);
}
public void Test_Join_Constructor()
{
//---------------Set up test pack-------------------
Source fromSource = new Source("From");
Source toSource = new Source("To");
//---------------Execute Test ----------------------
Source.Join join = new Source.Join(fromSource, toSource);
//---------------Test Result -----------------------
Assert.AreSame(fromSource, join.FromSource);
Assert.AreSame(toSource, join.ToSource);
//---------------Tear Down -------------------------
}
public void TestFromString_TwoLevels_CreatesLeftJoins()
{
//---------------Set up test pack-------------------
const string sourcename = "OneSource.TwoSource";
//---------------Execute Test ----------------------
Source source = Source.FromString(sourcename);
//---------------Test Result -----------------------
Source.Join join = source.Joins[0];
Assert.AreEqual(Source.JoinType.LeftJoin, join.JoinType);
//---------------Tear Down -------------------------
}
private static void AssertJoinListsEqual(Source.JoinList expected, Source.JoinList actual, string context)
{
Assert.AreEqual(expected.Count, actual.Count, context + ".Count");
foreach (Source.Join expectedJoin in expected)
{
string joinToSourceName = expectedJoin.ToSource.Name;
Source.Join actualJoin = actual.Find(delegate(Source.Join join1)
{
return(join1.ToSource.Name == joinToSourceName);
});
Assert.IsNotNull(actualJoin, string.Format("{0}: Could not find a join from {1} to {2}", context, expected.FromSource.Name, joinToSourceName));
AssertJoinsEqual(expectedJoin, actualJoin, context + string.Format("(Join to '{0}')", joinToSourceName));
}
}
public void TestCreateSourceDB_WithJoins()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = new Source.Join(source, joinSource);
source.Joins.Add(join);
//-------------Execute test ---------------------
SourceDB sourceDB = new SourceDB(source);
//-------------Test Result ----------------------
Assert.AreEqual(source.Name, sourceDB.Name);
Assert.AreEqual(source.EntityName, sourceDB.EntityName);
Assert.AreEqual(source.Joins, sourceDB.Joins);
}
public void TestMergeWith_LeftJoin()
{
//-------------Setup Test Pack ------------------
Source fromSource = new Source("FromSource", "FromSourceEntity");
Source toSource = new Source("ToSource", "ToSourceEntity");
Source.Join join = new Source.Join(fromSource, toSource, Source.JoinType.LeftJoin);
Source.JoinList joinList = new Source.JoinList(fromSource);
joinList.Add(join);
//-------------Execute test ---------------------
fromSource.Joins.MergeWith(joinList);
//-------------Test Result ----------------------
Assert.AreEqual(1, fromSource.Joins.Count);
Assert.AreEqual(Source.JoinType.LeftJoin, fromSource.Joins[0].JoinType);
}
public void TestAddNewJoinTo()
{
//---------------Set up test pack-------------------
Source source = new Source("TestSource");
Source.JoinList joinList = new Source.JoinList(source);
Source toSource = new Source("TestToSource");
//---------------Execute Test ----------------------
Source.Join join = joinList.AddNewJoinTo(toSource, Source.JoinType.InnerJoin);
//---------------Test Result -----------------------
Assert.IsNotNull(join);
Assert.AreEqual(1, joinList.Count);
Assert.AreSame(join, joinList[0]);
}
public void Test_Clone_Join()
{
//---------------Set up test pack-------------------
Source source1 = new Source("Source1");
Source source2 = new Source("Source2");
Source.Join join = new Source.Join(source1, source2);
//---------------Execute Test ----------------------
Source.Join cloneOfJoin = join.Clone();
//---------------Test Result -----------------------
Assert.AreNotSame(join, cloneOfJoin);
Assert.AreSame(source1, cloneOfJoin.FromSource);
Assert.AreSame(source2, cloneOfJoin.ToSource);
Assert.AreEqual(join.JoinType, cloneOfJoin.JoinType);
Assert.AreEqual(join.JoinFields.Count, cloneOfJoin.JoinFields.Count);
}
public void TestCreateSQL_LeftJoin()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = CreateAndAddJoin(source, joinSource);
join.JoinType = Source.JoinType.LeftJoin;
SourceDB leftJoinSourceDB = new SourceDB(source);
//-------------Execute test ---------------------
string sql = leftJoinSourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource));
//-------------Test Result ----------------------
StringAssert.Contains("LEFT JOIN", sql);
}
public void TestCreateSourceDB_WithJoins()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = new Source.Join(source, joinSource);
source.Joins.Add(join);
//-------------Execute test ---------------------
SourceDB sourceDB = new SourceDB(source);
//-------------Test Result ----------------------
Assert.AreEqual(source.Name, sourceDB.Name);
Assert.AreEqual(source.EntityName, sourceDB.EntityName);
Assert.AreEqual(source.Joins, sourceDB.Joins);
}
public void TestFromString_TwoLevels()
{
//---------------Set up test pack-------------------
const string sourcename = "OneSource.TwoSource";
//---------------Execute Test ----------------------
Source source = Source.FromString(sourcename);
//---------------Test Result -----------------------
string[] sourceParts = sourcename.Split('.');
Assert.AreEqual(sourceParts[0], source.Name);
Assert.AreEqual(1, source.Joins.Count);
Source.Join join = source.Joins[0];
Assert.AreSame(source, join.FromSource);
Assert.AreEqual(sourceParts[1], join.ToSource.Name);
//---------------Tear Down -------------------------
}
public void TestCreateSQL_WithJoin()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = CreateAndAddJoin(source, joinSource);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
string sql = sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource));
//-------------Test Result ----------------------
Source.Join.JoinField joinField = join.JoinFields[0];
string expectedSql = string.Format("({0} a1 JOIN {1} a2 ON a1.{2} = a2.{3})", source.EntityName, joinSource.EntityName,
joinField.FromField.FieldName, joinField.ToField.FieldName);
Assert.AreEqual(expectedSql, sql);
}
public void TestCreateSQL_WithJoin_WithDelimiter()
{
//-------------Setup Test Pack ------------------
Source source = new Source("MySource", "MY_SOURCE");
Source joinSource = new Source("JoinSource", "MY_JOINED_TABLE");
Source.Join join = CreateAndAddJoin(source, joinSource);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
SqlFormatter myFormatter = new SqlFormatter("[", "]", "TOP", "");
string sql = sourceDB.CreateSQL(myFormatter, CreateAliases(source, joinSource));
//-------------Test Result ----------------------
Source.Join.JoinField joinField = join.JoinFields[0];
string expectedSql = string.Format("([{0}] a1 JOIN [{1}] a2 ON a1.[{2}] = a2.[{3}])", source.EntityName, joinSource.EntityName,
joinField.FromField.FieldName, joinField.ToField.FieldName);
Assert.AreEqual(expectedSql, sql);
}
public void TestJoinStructure()
{
//-------------Setup Test Pack ------------------
string tableName = "MY_SOURCE";
Source source = new Source("MySource", tableName);
string joinTableName = "MY_JOINED_TABLE";
Source joinSource = new Source("JoinSource", joinTableName);
Source.Join join = new Source.Join(source, joinSource);
QueryField fromField = new QueryField("FromField", "FROM_FIELD", source);
QueryField toField = new QueryField("ToField", "TO_FIELD", joinSource);
//-------------Execute test ---------------------
join.JoinFields.Add(new Source.Join.JoinField(fromField, toField));
source.Joins.Add(join);
//-------------Test Result ----------------------
Assert.AreEqual(1, source.Joins.Count);
Assert.AreSame(join, source.Joins[0]);
Assert.AreSame(fromField, join.JoinFields[0].FromField);
Assert.AreSame(toField, join.JoinFields[0].ToField);
}
public void TestJoinStructure()
{
//-------------Setup Test Pack ------------------
string tableName = "MY_SOURCE";
Source source = new Source("MySource", tableName);
string joinTableName = "MY_JOINED_TABLE";
Source joinSource = new Source("JoinSource", joinTableName);
Source.Join join = new Source.Join(source, joinSource);
QueryField fromField = new QueryField("FromField", "FROM_FIELD", source);
QueryField toField = new QueryField("ToField", "TO_FIELD", joinSource);
//-------------Execute test ---------------------
join.JoinFields.Add(new Source.Join.JoinField(fromField, toField));
source.Joins.Add(join);
//-------------Test Result ----------------------
Assert.AreEqual(1, source.Joins.Count);
Assert.AreSame(join, source.Joins[0]);
Assert.AreSame(fromField, join.JoinFields[0].FromField);
Assert.AreSame(toField, join.JoinFields[0].ToField);
}
private static void CreateInheritanceJoins(IClassDef classDef, Source rootSource)
{
IClassDef currentClassDef = classDef;
while (currentClassDef.IsUsingClassTableInheritance())
{
IClassDef superClassDef = currentClassDef.SuperClassClassDef;
Source baseSource = new Source(superClassDef.ClassNameExcludingTypeParameter, superClassDef.TableName);
Source.Join join = new Source.Join(rootSource, baseSource);
PrimaryKeyDef superClassPrimaryKeyDef = (PrimaryKeyDef)superClassDef.PrimaryKeyDef;
IPropDef basePrimaryKeyPropDef = superClassPrimaryKeyDef[0];
PrimaryKeyDef currentPrimaryKeyDef = (PrimaryKeyDef)currentClassDef.PrimaryKeyDef;
if (currentPrimaryKeyDef != null)
{
IPropDef thisPrimaryKeyPropDef = currentPrimaryKeyDef[0];
join.JoinFields.Add(new Source.Join.JoinField(
new QueryField(thisPrimaryKeyPropDef.PropertyName,
thisPrimaryKeyPropDef.DatabaseFieldName,
rootSource),
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
baseSource)));
}
else
{
join.JoinFields.Add(new Source.Join.JoinField(
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
rootSource),
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
baseSource)));
}
rootSource.InheritanceJoins.Add(join);
rootSource = baseSource;
currentClassDef = superClassDef;
}
}
/// <summary>
/// Prepares the Source based on the ClassDef.
/// </summary>
/// <param name="classDef"></param>
/// <param name="source"></param>
/// <param name="relatedClassDef"></param>
/// <exception cref="ArgumentNullException"></exception>
public static void PrepareSource(IClassDef classDef, ref Source source, out IClassDef relatedClassDef)
{
if (classDef == null)
{
throw new ArgumentNullException("classDef");
}
if (source != null && source.IsPrepared)
{
relatedClassDef = source.RelatedClassDef;
return;
}
Source rootSource = new Source(((ClassDef)classDef).GetBaseClassOfSingleTableHierarchy().ClassNameExcludingTypeParameter, classDef.GetTableName());
CreateInheritanceJoins(classDef, rootSource);
if (source == null)
{
source = rootSource;
relatedClassDef = classDef;
}
else if (source.Name == rootSource.Name)
{
//relatedClassDef = null;
relatedClassDef = classDef;
source.EntityName = rootSource.EntityName;
}
else
{
ClassDef currentClassDef = (ClassDef)classDef;
Source.Join join = new Source.Join(rootSource, source, Source.JoinType.LeftJoin);
rootSource.Joins.Add(join);
Source currentSource = rootSource;
PrepareSourceTree(currentSource, ref currentClassDef);
relatedClassDef = currentClassDef;
source = rootSource;
}
source.RelatedClassDef = relatedClassDef;
source.IsPrepared = true;
}
public void TestCreateOrderCriteria_ThroughRelationship()
{
//---------------Set up test pack-------------------
IClassDef myRelatedBoClassDef = MyRelatedBo.LoadClassDefWithDifferentTableAndFieldNames();
IClassDef myBoClassdef = MyBO.LoadClassDefWithRelationship();
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = QueryBuilder.CreateOrderCriteria(myBoClassdef, "MyRelationship.MyRelatedTestProp");
//---------------Test Result -----------------------
IOrderCriteriaField orderCriteriaField = orderCriteria.Fields[0];
Assert.AreEqual(myRelatedBoClassDef.GetPropDef("MyRelatedTestProp").DatabaseFieldName, orderCriteriaField.FieldName);
Assert.AreEqual(myBoClassdef.ClassName, orderCriteriaField.Source.Name);
Assert.AreEqual(myBoClassdef.GetTableName(), orderCriteriaField.Source.EntityName);
Assert.AreEqual(1, orderCriteriaField.Source.Joins.Count);
Source.Join relJoin = orderCriteriaField.Source.Joins[0];
Assert.AreEqual("MyRelationship", relJoin.ToSource.Name);
Assert.AreEqual(myRelatedBoClassDef.GetTableName(), relJoin.ToSource.EntityName);
Assert.AreEqual(1, relJoin.JoinFields.Count);
Assert.AreEqual("RelatedID", relJoin.JoinFields[0].FromField.PropertyName);
Assert.AreEqual("MyRelatedBoID", relJoin.JoinFields[0].ToField.PropertyName);
//---------------Tear Down -------------------------
}
public void TestMergeWith_IncludesInheritanceJoinFields()
{
//-------------Setup Test Pack ------------------
Source originalSource = new Source("FromSource", "FromSourceEntity");
Source otherSource = new Source("FromSource", "FromSourceEntity");
Source childSource = new Source("ToSource", "ToSourceEntity");
Source.Join join = new Source.Join(otherSource, childSource);
QueryField field1 = new QueryField("FromSourceProp1", "FromSourceProp1Field", otherSource);
QueryField field2 = new QueryField("ToSourceProp1", "ToSourceProp1Field", childSource);
otherSource.InheritanceJoins.Add(join);
join.JoinFields.Add(new Source.Join.JoinField(field1, field2));
//-------------Execute test ---------------------
originalSource.MergeWith(otherSource);
//-------------Test Result ----------------------
Assert.AreEqual(1, originalSource.InheritanceJoins.Count);
Assert.AreEqual(1, originalSource.InheritanceJoins[0].JoinFields.Count);
Assert.AreEqual(field1, originalSource.InheritanceJoins[0].JoinFields[0].FromField);
Assert.AreEqual(field2, originalSource.InheritanceJoins[0].JoinFields[0].ToField);
}
public void TestFromString_ThreeLevels()
{
//---------------Set up test pack-------------------
const string sourcename = "OneSource.TwoSource.ThreeSource";
//---------------Execute Test ----------------------
Source oneSource = Source.FromString(sourcename);
//---------------Test Result -----------------------
string[] sourceParts = sourcename.Split('.');
Assert.AreEqual(sourceParts[0], oneSource.Name);
Assert.AreEqual(1, oneSource.Joins.Count);
Source.Join oneJoin = oneSource.Joins[0];
Assert.AreSame(oneSource, oneJoin.FromSource);
Assert.AreEqual(sourceParts[1], oneJoin.ToSource.Name);
Source twoSource = oneJoin.ToSource;
Source.Join twoJoin = twoSource.Joins[0];
Assert.AreSame(twoSource, twoJoin.FromSource);
Assert.AreEqual(sourceParts[2], twoJoin.ToSource.Name);
//---------------Tear Down -------------------------
}
public void TestPrepareSource_ExistingSource_RelationshipName()
{
//---------------Set up test pack-------------------
IClassDef engineClassDef = Engine.LoadClassDef_IncludingCarAndOwner();
Source originalSource = new Source("Car", null);
Source source = originalSource;
//---------------Execute Test ----------------------
QueryBuilder.PrepareSource(engineClassDef, ref source);
//---------------Test Result -----------------------
Assert.IsNotNull(source);
Assert.AreNotSame(originalSource, source);
Assert.AreEqual("Engine", source.Name);
Assert.AreEqual("Table_Engine", source.EntityName);
Assert.AreEqual(1, source.Joins.Count);
Source.Join join = source.Joins[0];
Source childSource = join.ToSource;
Assert.IsNotNull(childSource);
Assert.AreSame(originalSource, childSource);
Assert.AreEqual("Car", childSource.Name);
Assert.AreEqual("car_table", childSource.EntityName);
Assert.AreEqual(1, join.JoinFields.Count);
Source.Join.JoinField field = join.JoinFields[0];
QueryField fromField = field.FromField;
Assert.AreSame(source, fromField.Source);
Assert.AreEqual("CarID", fromField.PropertyName);
Assert.AreEqual("CAR_ID", fromField.FieldName);
QueryField toField = field.ToField;
Assert.AreSame(childSource, toField.Source);
Assert.AreEqual("CarID", toField.PropertyName);
Assert.AreEqual("CAR_ID", toField.FieldName);
}
public void TestSetOrderCriteria_AddsJoinToSource()
{
//---------------Set up test pack-------------------
MyRelatedBo.LoadClassDefWithDifferentTableAndFieldNames();
IClassDef myBoClassdef = MyBO.LoadClassDefWithRelationship_DifferentTableAndFieldNames();
ISelectQuery selectQuery = QueryBuilder.CreateSelectQuery(myBoClassdef);
IOrderCriteria orderCriteria = QueryBuilder.CreateOrderCriteria(myBoClassdef, "MyRelationship.MyRelatedTestProp");
//---------------Execute Test ----------------------
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreEqual(1, selectQuery.Source.Joins.Count);
Source.Join join = selectQuery.Source.Joins[0];
Assert.AreEqual(selectQuery.Source, join.FromSource);
Assert.AreEqual("MyRelationship", join.ToSource.Name);
Assert.AreEqual(1, join.JoinFields.Count);
Assert.AreEqual("RelatedID", join.JoinFields[0].FromField.PropertyName);
Assert.AreEqual("related_id", join.JoinFields[0].FromField.FieldName);
Assert.AreEqual("MyRelatedBoID", join.JoinFields[0].ToField.PropertyName);
Assert.AreEqual("My_Related_Bo_ID", join.JoinFields[0].ToField.FieldName);
//---------------Tear Down -------------------------
}
public void TestMergeWith_LeftJoin()
{
//-------------Setup Test Pack ------------------
Source fromSource = new Source("FromSource", "FromSourceEntity");
Source toSource = new Source("ToSource", "ToSourceEntity");
Source.Join join = new Source.Join(fromSource, toSource, Source.JoinType.LeftJoin);
Source.JoinList joinList = new Source.JoinList(fromSource);
joinList.Add(join);
//-------------Execute test ---------------------
fromSource.Joins.MergeWith(joinList);
//-------------Test Result ----------------------
Assert.AreEqual(1, fromSource.Joins.Count);
Assert.AreEqual(Source.JoinType.LeftJoin, fromSource.Joins[0].JoinType);
}
private static void AssertJoinsEqual(Source.Join expectedJoin, Source.Join actualJoin, string context)
{
Assert.AreEqual(expectedJoin.FromSource, actualJoin.FromSource, context + ".FromSource");
AssertSourcesEqual(expectedJoin.ToSource, actualJoin.ToSource, context + ".ToSource");
AssertJoinFieldsListEqual(expectedJoin.JoinFields, actualJoin.JoinFields, context + ".JoinFields");
}
public void TestMergeWith_IncludesInheritanceJoinFields()
{
//-------------Setup Test Pack ------------------
Source originalSource = new Source("FromSource", "FromSourceEntity");
Source otherSource = new Source("FromSource", "FromSourceEntity");
Source childSource = new Source("ToSource", "ToSourceEntity");
Source.Join join = new Source.Join(otherSource, childSource);
QueryField field1 = new QueryField("FromSourceProp1", "FromSourceProp1Field", otherSource);
QueryField field2 = new QueryField("ToSourceProp1", "ToSourceProp1Field", childSource);
otherSource.InheritanceJoins.Add(join);
join.JoinFields.Add(new Source.Join.JoinField(field1, field2));
//-------------Execute test ---------------------
originalSource.MergeWith(otherSource);
//-------------Test Result ----------------------
Assert.AreEqual(1, originalSource.InheritanceJoins.Count);
Assert.AreEqual(1, originalSource.InheritanceJoins[0].JoinFields.Count);
Assert.AreEqual(field1, originalSource.InheritanceJoins[0].JoinFields[0].FromField);
Assert.AreEqual(field2, originalSource.InheritanceJoins[0].JoinFields[0].ToField);
}
public void Test_Clone_Join()
{
//---------------Set up test pack-------------------
Source source1 = new Source("Source1");
Source source2 = new Source("Source2");
Source.Join join = new Source.Join(source1, source2);
//---------------Execute Test ----------------------
Source.Join cloneOfJoin = join.Clone();
//---------------Test Result -----------------------
Assert.AreNotSame(join, cloneOfJoin);
Assert.AreSame(source1, cloneOfJoin.FromSource);
Assert.AreSame(source2, cloneOfJoin.ToSource);
Assert.AreEqual(join.JoinType, cloneOfJoin.JoinType);
Assert.AreEqual(join.JoinFields.Count, cloneOfJoin.JoinFields.Count);
}
public void TestCreateSQL_WithJoin_NoFields()
{
//-------------Setup Test Pack ------------------
string tableName = "MY_SOURCE";
Source source = new Source("MySource", tableName);
string joinTableName = "MY_JOINED_TABLE";
Source joinSource = new Source("JoinSource", joinTableName);
Source.Join join = new Source.Join(source, joinSource);
source.Joins.Add(join);
SourceDB sourceDB = new SourceDB(source);
//-------------Execute test ---------------------
Exception exception = null;
try
{
sourceDB.CreateSQL(GetSqlFormatter(), CreateAliases(source, joinSource));
} catch( Exception ex)
{
exception = ex;
}
//-------------Test Result ----------------------
Assert.IsNotNull(exception, "An error was expected when creating SQL with joins that have no fields");
Assert.IsInstanceOf(typeof(HabaneroDeveloperException), exception);
string expectedMessage = string.Format("SQL cannot be created for the source '{0}' because it has a join to '{1}' without join fields",
sourceDB.Name, join.ToSource.Name);
StringAssert.Contains(expectedMessage, exception.Message);
}
private static Source.Join CreateJoin(Source fromSource, Source toSource)
{
Source.Join join = new Source.Join(fromSource, toSource);
QueryField fromField = new QueryField("FromField", "FROM_FIELD", fromSource);
QueryField toField = new QueryField("ToField", "TO_FIELD", toSource);
join.JoinFields.Add(new Source.Join.JoinField(fromField, toField));
return join;
}
/// <summary>
/// Prepares the Source based on the ClassDef.
/// </summary>
/// <param name="classDef"></param>
/// <param name="source"></param>
/// <param name="relatedClassDef"></param>
/// <exception cref="ArgumentNullException"></exception>
public static void PrepareSource(IClassDef classDef, ref Source source, out IClassDef relatedClassDef)
{
if (classDef == null) throw new ArgumentNullException("classDef");
if (source != null && source.IsPrepared)
{
relatedClassDef = source.RelatedClassDef;
return;
}
Source rootSource = new Source(((ClassDef)classDef).GetBaseClassOfSingleTableHierarchy().ClassNameExcludingTypeParameter, classDef.GetTableName());
CreateInheritanceJoins(classDef, rootSource);
if (source == null)
{
source = rootSource;
relatedClassDef = classDef;
}
else if (source.Name == rootSource.Name)
{
//relatedClassDef = null;
relatedClassDef = classDef;
source.EntityName = rootSource.EntityName;
}
else
{
ClassDef currentClassDef = (ClassDef)classDef;
Source.Join join = new Source.Join(rootSource, source, Source.JoinType.LeftJoin);
rootSource.Joins.Add(join);
Source currentSource = rootSource;
PrepareSourceTree(currentSource, ref currentClassDef);
relatedClassDef = currentClassDef;
source = rootSource;
}
source.RelatedClassDef = relatedClassDef;
source.IsPrepared = true;
}
private static Source.Join CreateAndAddInheritanceJoin(Source fromSource, Source toSource)
{
Source.Join join = CreateJoin(fromSource, toSource);
fromSource.InheritanceJoins.Add(join);
return(join);
}
private static void CreateInheritanceJoins(IClassDef classDef, Source rootSource)
{
IClassDef currentClassDef = classDef;
while (currentClassDef.IsUsingClassTableInheritance())
{
IClassDef superClassDef = currentClassDef.SuperClassClassDef;
Source baseSource = new Source(superClassDef.ClassNameExcludingTypeParameter, superClassDef.TableName);
Source.Join join = new Source.Join(rootSource, baseSource);
PrimaryKeyDef superClassPrimaryKeyDef = (PrimaryKeyDef) superClassDef.PrimaryKeyDef;
IPropDef basePrimaryKeyPropDef = superClassPrimaryKeyDef[0];
PrimaryKeyDef currentPrimaryKeyDef = (PrimaryKeyDef) currentClassDef.PrimaryKeyDef;
if (currentPrimaryKeyDef != null)
{
IPropDef thisPrimaryKeyPropDef = currentPrimaryKeyDef[0];
join.JoinFields.Add(new Source.Join.JoinField(
new QueryField(thisPrimaryKeyPropDef.PropertyName,
thisPrimaryKeyPropDef.DatabaseFieldName,
rootSource),
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
baseSource)));
} else
{
join.JoinFields.Add(new Source.Join.JoinField(
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
rootSource),
new QueryField(basePrimaryKeyPropDef.PropertyName,
basePrimaryKeyPropDef.DatabaseFieldName,
baseSource)));
}
rootSource.InheritanceJoins.Add(join);
rootSource = baseSource;
currentClassDef = superClassDef;
}
}
