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