Menu
▾
▴
SF.net SVN: orm: [1119] trunk/RelationalModel/OialDcilBridge
|
From: <mcu...@us...> - 2007-09-10 23:04:38
|
Revision: 1119
http://orm.svn.sourceforge.net/orm/?rev=1119&view=rev
Author: mcurland
Date: 2007-09-10 16:04:41 -0700 (Mon, 10 Sep 2007)
Log Message:
-----------
Modified the ColumnHasConceptTypeChild Path to allow duplicate ConceptTypeChildren, allowing us to record the full path, from the column to the ConceptType to the identifier for that ConceptType. Using the new Path restructured FindTarget to properly return the correct column. refs #328.
Modified Paths:
--------------
trunk/RelationalModel/OialDcilBridge/GeneratedCode/DomainRelationships.cs
trunk/RelationalModel/OialDcilBridge/OialDcilBridge.DeserializationFixupListeners.cs
trunk/RelationalModel/OialDcilBridge/OialDcilBridge.dsl
Modified: trunk/RelationalModel/OialDcilBridge/GeneratedCode/DomainRelationships.cs
===================================================================
--- trunk/RelationalModel/OialDcilBridge/GeneratedCode/DomainRelationships.cs 2007-09-10 23:03:11 UTC (rev 1118)
+++ trunk/RelationalModel/OialDcilBridge/GeneratedCode/DomainRelationships.cs 2007-09-10 23:04:41 UTC (rev 1119)
@@ -2463,7 +2463,7 @@
[DslDesign::DisplayNameResource("Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild.DisplayName", typeof(global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ORMAbstractionToConceptualDatabaseBridgeDomainModel), "Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.GeneratedCode.DomainModelResx")]
[DslDesign::DescriptionResource("Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild.Description", typeof(global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ORMAbstractionToConceptualDatabaseBridgeDomainModel), "Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.GeneratedCode.DomainModelResx")]
[global::System.CLSCompliant(true)]
- [DslModeling::DomainRelationship()]
+ [DslModeling::DomainRelationship(AllowsDuplicates = true)]
[DslModeling::DomainObjectId("ccbcab63-ade4-43fa-8e29-8a598b0969f5")]
public partial class ColumnHasConceptTypeChild : DslModeling::ElementLink
{
@@ -2650,24 +2650,6 @@
}
return outLinks.AsReadOnly();
}
- /// <summary>
- /// Get the one ColumnHasConceptTypeChild link between a given Columnand a ConceptTypeChild.
- /// </summary>
- [global::System.Diagnostics.DebuggerStepThrough]
- [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
- public static global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild GetLink( global::Neumont.Tools.RelationalModels.ConceptualDatabase.Column source, global::Neumont.Tools.ORMAbstraction.ConceptTypeChild target )
- {
- global::System.Collections.Generic.IList<global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild> links = DslModeling::DomainRoleInfo.GetElementLinks<global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild>(source, global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild.ColumnDomainRoleId);
- foreach ( global::Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge.ColumnHasConceptTypeChild link in links )
- {
- if ( target.Equals(link.ConceptTypeChild) )
- {
- return link;
- }
- }
- return null;
- }
-
#endregion
}
}
Modified: trunk/RelationalModel/OialDcilBridge/OialDcilBridge.DeserializationFixupListeners.cs
===================================================================
--- trunk/RelationalModel/OialDcilBridge/OialDcilBridge.DeserializationFixupListeners.cs 2007-09-10 23:03:11 UTC (rev 1118)
+++ trunk/RelationalModel/OialDcilBridge/OialDcilBridge.DeserializationFixupListeners.cs 2007-09-10 23:04:41 UTC (rev 1119)
@@ -316,7 +316,9 @@
if (TableIsPrimarilyForConceptType.GetTable(conceptType) == null && TableIsAlsoForConceptType.GetLink(table, conceptType) == null)
{
TableIsAlsoForConceptType tableIsAlsoForConceptType = new TableIsAlsoForConceptType(table, conceptType);
- tableIsAlsoForConceptType.AssimilationPath.AddRange(assimilationPath);
+ ConceptTypeAssimilatesConceptType[] assimilationPathReversed = assimilationPath.ToArray();
+ Array.Reverse(assimilationPathReversed);
+ tableIsAlsoForConceptType.AssimilationPath.AddRange(assimilationPathReversed);
}
// For all Assimilations that the ConceptType is the Parent of, if the assimilation is set to absorb,
// then recursively add the ConceptTypes it assimilates to the table as a TableIsAlsoForConceptType as well.
@@ -505,89 +507,62 @@
/// <summary>
/// Creates columns for a ConceptType for every Table that the ConceptType plays a role in, as a TableIsPrimarilyForConceptType or TableIsAlsoForConceptType relationship.
/// </summary>
-
private static void CreateColumns(ConceptType conceptType)
{
- List<ConceptTypeChild> preferredConceptTypeChildList = GetPreferredConceptTypeChildrenForConceptType(conceptType);
List<Column> columnsForConceptType = new List<Column>();
-
- foreach (ConceptTypeChild conceptTypeChild in ConceptTypeChild.GetLinksToTargetCollection(conceptType))
+ foreach (InformationType informationType in InformationType.GetLinksToInformationTypeFormatCollection(conceptType))
{
- if (!(conceptTypeChild is ConceptTypeAssimilatesConceptType))
+ columnsForConceptType.Add(GetColumnForInformationType(informationType, new Stack<ConceptTypeChild>()));
+ }
+ foreach (ConceptTypeRelatesToConceptType conceptTypeRelation in ConceptTypeRelatesToConceptType.GetLinksToRelatedConceptTypeCollection(conceptType))
+ {
+ columnsForConceptType.AddRange(GetColumnsForConceptTypeRelation(conceptTypeRelation, new Stack<ConceptTypeChild>()));
+ }
+ foreach (ConceptTypeAssimilatesConceptType assimilation in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptType))
+ {
+ switch (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation))
{
- columnsForConceptType.AddRange(GetColumnsForConceptTypeChild(conceptTypeChild, new List<ConceptTypeChild>()));
+ case AssimilationAbsorptionChoice.Absorb:
+ // Ignore this, it will be handled by this method when it is run for the absorbed concept type.
+ break;
+ case AssimilationAbsorptionChoice.Partition:
+ // Ignore this too.
+ break;
+ case AssimilationAbsorptionChoice.Separate:
+ // UNDONE: Handle separate here? If so, pull in the preferred identifier columns for the assimilated concept type if IsPreferredForParent is true.
+ break;
}
}
- foreach (ConceptTypeChild assimilatedConceptType in preferredConceptTypeChildList)
+ foreach (ConceptTypeAssimilatesConceptType assimilation in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatorConceptTypeCollection(conceptType))
{
- if (assimilatedConceptType is ConceptTypeAssimilatesConceptType)
+ switch (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation))
{
- columnsForConceptType.AddRange(GetColumnsForConceptTypeChild(assimilatedConceptType, new List<ConceptTypeChild>()));
+ case AssimilationAbsorptionChoice.Absorb:
+ // Ignore this too.
+ break;
+ case AssimilationAbsorptionChoice.Partition:
+ // Ignore this too.
+ break;
+ case AssimilationAbsorptionChoice.Separate:
+ // UNDONE: Handle separate here? If so, pull in the preferred identifier columns for the assimilator concept type if IsPreferredForTarget is true.
+ break;
}
}
- // TESTING - UNDONE#1 -- Not needed, should be contained within the first Foreach
- //foreach(ConceptTypeChild relatedConceptType in preferredConceptTypeChildList)
+
+
+ //foreach (ConceptTypeChild conceptTypeChild in ConceptTypeChild.GetLinksToTargetCollection(conceptType))
//{
- // if (relatedConceptTypeChild.GetType() == typeof(ConceptTypeRelatesToConceptType))
- // {
- // columnsForConceptType.AddRange(GetColumnsForConceptTypeChild(relatedConceptType, new List<ConceptTypeChild>()));
- // }
+ // columnsForConceptType.AddRange(GetColumnsForConceptTypeChild(conceptTypeChild, new List<ConceptTypeChild>()));
//}
- // END TESTING
+
Table conceptTypeTable = TableIsPrimarilyForConceptType.GetTable(conceptType);
if (conceptTypeTable != null)
{
- foreach (Column column in columnsForConceptType)
- {
- Column possibleDuplicateColumn = CheckForDuplicateColumn(conceptTypeTable, column);
- if (possibleDuplicateColumn != null)
- {
- if (preferredConceptTypeChildList.Contains(ColumnHasConceptTypeChild.GetConceptTypeChildPath(possibleDuplicateColumn)[0]))
- {
- // Record CTHasPrimaryIdentifierColumn(CT, "PossibleDuplicateColumn");
- }
- }
- else
- {
- if (preferredConceptTypeChildList.Contains(ColumnHasConceptTypeChild.GetConceptTypeChildPath(column)[0]))
- {
- // Record CTHasPrimaryIdentifierColumn(CT, Column);
- }
- conceptTypeTable.ColumnCollection.Add(column);
- }
- }
+ conceptTypeTable.ColumnCollection.AddRange(columnsForConceptType);
}
else
{
- //ReadOnlyCollection<Table> tablesInvolvedWithConceptType = TableIsAlsoForConceptType.GetTable(conceptType);
- //foreach (Table table in tablesInvolvedWithConceptType)
- //{
- // foreach (Column column in columnsForConceptType)
- // {
- // // UNDONE: Why do we need to clone these here, where do we use it?
- // Column clonedColumn = new Column(column.Store, new PropertyAssignment[] { new PropertyAssignment(Column.NameDomainPropertyId, column.Name) });
- // List<ConceptTypeChild> clonedConceptTypeChildPath = new List<ConceptTypeChild>(ColumnHasConceptTypeChild.GetConceptTypeChildPath(column));
-
- // AssimilationPath assimPath = new AssimilationPath(assimilationPath[table].Path);
-
- // int inumerator = 0;
-
- // foreach (ConceptTypeAssimilatesConceptType currentConceptTypeAssimilatesConceptType in assimPath.Path)
- // {
- // clonedConceptTypeChildPath.Insert(inumerator, (ConceptTypeChild)currentConceptTypeAssimilatesConceptType);
- // inumerator++;
- // }
-
- // Column possibleDuplicateColumn = CheckForDuplicateColumn(table.Table, clonedColumn);
- // if (possibleDuplicateColumn == null)
- // {
- // // if CTC is in PreferredList
- // // Record CTCHasPrimaryIdentifierColumn(CT, ClonedColumn);
- // table.Table.ColumnCollection.Add(clonedColumn);
- // }
- // }
- //}
ReadOnlyCollection<TableIsAlsoForConceptType> tableIsAlsoForConceptTypeInvolvedWithConceptType = TableIsAlsoForConceptType.GetLinksToTable(conceptType);
foreach (TableIsAlsoForConceptType tableIsAlsoForConceptType in tableIsAlsoForConceptTypeInvolvedWithConceptType)
{
@@ -600,21 +575,11 @@
{
clonedConceptTypeChildPath.Add(assimilation);
}
- foreach (ConceptTypeChild child in ColumnHasConceptTypeChild.GetConceptTypeChildPath(column))
- {
- if (!clonedConceptTypeChildPath.Contains(child))
- {
- clonedConceptTypeChildPath.Add(child);
- }
- }
- //clonedConceptTypeChildPath.AddRange(ColumnHasConceptTypeChild.GetConceptTypeChildPath(column));
+ clonedConceptTypeChildPath.AddRange(ColumnHasConceptTypeChild.GetConceptTypeChildPath(column));
Column possibleDuplicateColumn = CheckForDuplicateColumn(tableIsAlsoForConceptType.Table, clonedColumn);
if (possibleDuplicateColumn == null)
{
- // if CTC is in PreferredList
- // Record CTCHasPrimaryIdentifierColumn(CT, ClonedColumn);
-
tableIsAlsoForConceptType.Table.ColumnCollection.Add(clonedColumn);
}
else
@@ -632,6 +597,88 @@
}
}
+ private static Column GetColumnForInformationType(InformationType informationType, Stack<ConceptTypeChild> conceptTypeChildPath)
+ {
+ conceptTypeChildPath.Push(informationType);
+ Column column = new Column(informationType.Store,
+ new PropertyAssignment[]{
+ new PropertyAssignment(Column.NameDomainPropertyId, informationType.Name)});
+ ConceptTypeChild[] concpetTypeChildPathReverse = conceptTypeChildPath.ToArray();
+ Array.Reverse(concpetTypeChildPathReverse);
+ ColumnHasConceptTypeChild.GetConceptTypeChildPath(column).AddRange(concpetTypeChildPathReverse);
+ conceptTypeChildPath.Pop();
+ return column;
+ }
+ private static List<Column> GetColumnsForConceptTypeRelation(ConceptTypeRelatesToConceptType conceptTypeRelation, Stack<ConceptTypeChild> conceptTypeChildPath)
+ {
+ conceptTypeChildPath.Push(conceptTypeRelation);
+ List<Column> columns = GetPreferredIdentifierColumnsForConceptType(conceptTypeRelation.RelatedConceptType, conceptTypeChildPath);
+ conceptTypeChildPath.Pop();
+ return columns;
+ }
+
+ private static List<Column> GetPreferredIdentifierColumnsForConceptType(ConceptType conceptType, Stack<ConceptTypeChild> conceptTypeChildPath)
+ {
+ foreach (Uniqueness uniqueness in conceptType.UniquenessCollection)
+ {
+ if (uniqueness.IsPreferred)
+ {
+ LinkedElementCollection<ConceptTypeChild> uniquenessConceptTypeChildren = uniqueness.ConceptTypeChildCollection;
+ List<Column> columns = new List<Column>(uniquenessConceptTypeChildren.Count);
+
+ foreach (ConceptTypeChild conceptTypeChild in uniquenessConceptTypeChildren)
+ {
+ InformationType informationType = conceptTypeChild as InformationType;
+ if (informationType != null)
+ {
+ columns.Add(GetColumnForInformationType(informationType, conceptTypeChildPath));
+ }
+ else
+ {
+ Debug.Assert(conceptTypeChild is ConceptTypeRelatesToConceptType, "Uniquenesses can't contain ConceptTypeAssimilations.");
+ columns.AddRange(GetColumnsForConceptTypeRelation((ConceptTypeRelatesToConceptType)conceptTypeChild, conceptTypeChildPath));
+ }
+ }
+
+ return columns;
+ }
+ }
+ foreach (ConceptTypeAssimilatesConceptType assimilation in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatorConceptTypeCollection(conceptType))
+ {
+ if (assimilation.IsPreferredForTarget)
+ {
+ bool isAbsorb = (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation) == AssimilationAbsorptionChoice.Absorb);
+
+ conceptTypeChildPath.Push(assimilation);
+
+ List<Column> columns = GetPreferredIdentifierColumnsForConceptType(assimilation.AssimilatorConceptType, conceptTypeChildPath);
+
+ conceptTypeChildPath.Pop();
+
+ return columns;
+ }
+ }
+ foreach (ConceptTypeAssimilatesConceptType assimilation in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptType))
+ {
+ if (assimilation.IsPreferredForParent)
+ {
+ bool isPartition = (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation) == AssimilationAbsorptionChoice.Partition);
+
+ conceptTypeChildPath.Push(assimilation);
+
+ List<Column> columns = GetPreferredIdentifierColumnsForConceptType(assimilation.AssimilatedConceptType, conceptTypeChildPath);
+
+ conceptTypeChildPath.Pop();
+
+ return columns;
+ }
+ }
+ Debug.Fail("Couldn't find preferred identifier for concept type.");
+ throw new InvalidOperationException();
+ }
+
+
+
/// <summary>
/// GetColumnsForConceptTypeChild gets the <see cref="Column"/> coresponding to a <see cref="ConceptTypeChild"/>.
/// </summary>
@@ -649,16 +696,15 @@
List<Column> columnList = new List<Column>();
conceptTypeChildPath.Add(conceptTypeChild);
- if (conceptTypeChild.GetType() == typeof(InformationType))
+ if (conceptTypeChild is InformationType)
{
Column informationTypeColumn = new Column(conceptTypeChild.Store,
new PropertyAssignment[]{
new PropertyAssignment(Column.NameDomainPropertyId, conceptTypeChild.Name)});
- ColumnHasConceptTypeChild.GetConceptTypeChildPath(informationTypeColumn).Clear();
ColumnHasConceptTypeChild.GetConceptTypeChildPath(informationTypeColumn).AddRange(conceptTypeChildPath);
columnList.Add(informationTypeColumn);
}
- else if (conceptTypeChild.GetType() == typeof(ConceptTypeRelatesToConceptType))
+ else if (conceptTypeChild is ConceptTypeRelatesToConceptType)
{
ConceptType relatedConceptType = (ConceptType)conceptTypeChild.Target;
@@ -667,7 +713,11 @@
{
if (child == preferredList[preferredList.Count - 1])
{
+
columnList.AddRange(GetColumnsForConceptTypeChild(child, conceptTypeChildPath));
+
+ //conceptTypeChildPath.Clear();
+ //columnList.AddRange(GetColumnsForConceptTypeChild(child, conceptTypeChildPath));
}
else
{
@@ -677,7 +727,7 @@
}
return columnList;
}
- else if (conceptTypeChild.GetType() == typeof(ConceptTypeAssimilatesConceptType))
+ else if (conceptTypeChild is ConceptTypeAssimilatesConceptType)
{
ConceptType targetConceptType = (ConceptType)conceptTypeChild.Parent;
List<ConceptTypeChild> preferredList = GetPreferredConceptTypeChildrenForConceptType(targetConceptType);
@@ -744,64 +794,36 @@
/// </summary>
private static List<ConceptTypeChild> GetPreferredConceptTypeChildrenForConceptType(ConceptType conceptType)
{
- List<ConceptTypeChild> prefferedConceptTypeChildrenList = new List<ConceptTypeChild>();
foreach (Uniqueness uniqueness in conceptType.UniquenessCollection)
{
if (uniqueness.IsPreferred)
{
- foreach (ConceptTypeChild childConceptType in uniqueness.ConceptTypeChildCollection)
- {
- prefferedConceptTypeChildrenList.Add(childConceptType);
- }
- break;
+ return new List<ConceptTypeChild>(uniqueness.ConceptTypeChildCollection);
}
}
- if (prefferedConceptTypeChildrenList.Count == 0)
+ foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
+ in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatorConceptTypeCollection(conceptType))
{
- foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
- in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatorConceptTypeCollection(conceptType))
+ if (conceptTypeAssimilatesConceptType.IsPreferredForTarget)
{
- if (conceptTypeAssimilatesConceptType.IsPreferredForTarget)
- {
- prefferedConceptTypeChildrenList.AddRange(GetPreferredConceptTypeChildrenForConceptType(conceptTypeAssimilatesConceptType.AssimilatorConceptType));
- break;
- }
+ List<ConceptTypeChild> prefferedConceptTypeChildrenList = new List<ConceptTypeChild>(1);
+ prefferedConceptTypeChildrenList.Add(conceptTypeAssimilatesConceptType);
+ return prefferedConceptTypeChildrenList;
}
}
- if (prefferedConceptTypeChildrenList.Count == 0)
+ foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
+ in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptType))
{
- foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
- in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptType))
+ if (conceptTypeAssimilatesConceptType.IsPreferredForParent)
{
- if (conceptTypeAssimilatesConceptType.IsPreferredForParent)
- {
- prefferedConceptTypeChildrenList.Add(conceptTypeAssimilatesConceptType);
- break;
- }
+ List<ConceptTypeChild> prefferedConceptTypeChildrenList = new List<ConceptTypeChild>(1);
+ prefferedConceptTypeChildrenList.Add(conceptTypeAssimilatesConceptType);
+ return prefferedConceptTypeChildrenList;
}
}
- // TESTING
- if (prefferedConceptTypeChildrenList.Count == 0)
- {
- foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
- in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatorConceptTypeCollection(conceptType))
- {
- prefferedConceptTypeChildrenList.AddRange(GetPreferredConceptTypeChildrenForConceptType(conceptTypeAssimilatesConceptType.AssimilatorConceptType));
- break;
- }
- }
- if (prefferedConceptTypeChildrenList.Count == 0)
- {
- foreach (ConceptTypeAssimilatesConceptType conceptTypeAssimilatesConceptType
- in ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptType))
- {
- prefferedConceptTypeChildrenList.AddRange(GetPreferredConceptTypeChildrenForConceptType(conceptTypeAssimilatesConceptType.AssimilatedConceptType));
- break;
- }
- }
-
- return prefferedConceptTypeChildrenList;
+ Debug.Fail("Couldn't find preferred identifier.");
+ return null;
}
/// <summary>
@@ -1080,7 +1102,7 @@
bool isPartitioned = false;
foreach (ConceptTypeAssimilatesConceptType possiblePartition in childAssimilations)
{
- if (AssimilationMapping.GetAssimilationMappingFromAssimilation(possiblePartition).AbsorptionChoice == AssimilationAbsorptionChoice.Partition)
+ if (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(possiblePartition) == AssimilationAbsorptionChoice.Partition)
{
isPartitioned = true;
break;
@@ -1222,7 +1244,6 @@
// UNDONE: Problem occuring with A is partitioned to B, C; C is partitioned to D, E. Setting A-C to Partition
ReadOnlyCollection<ConceptTypeAssimilatesConceptType> childCollection = ConceptTypeAssimilatesConceptType.GetLinksToAssimilatedConceptTypeCollection(conceptTypeAssimilatesConceptType.AssimilatedConceptType);
- /**/
bool containsPartitions = false;
foreach (ConceptTypeAssimilatesConceptType act in childCollection)
{
@@ -1233,11 +1254,8 @@
break;
}
}
- /**/
- /**/
if (!containsPartitions)
{
- /**/
Table targetTable = TableIsPrimarilyForConceptType.GetTable(conceptTypeAssimilatesConceptType.AssimilatedConceptType);
foreach (Column target in targetTable.ColumnCollection)
@@ -1250,7 +1268,6 @@
}
}
}
- /**/
}
else
{
@@ -1259,7 +1276,6 @@
columns.AddRange(ConceptTypeHasPrimaryIdentifierColumns(column, act.AssimilatedConceptType));
}
}
- /**/
}
}
@@ -1374,110 +1390,121 @@
/// <summary>
/// FindTarget finds the target column for an input <see cref="ConceptType" />.
/// </summary>
- /// <param name="column">The <see cref="Column"/>.</param>
- /// <param name="conceptType">The <see cref="ConceptType"/>.</param>
+ /// <param name="sourceColumn">The <see cref="Column"/>.</param>
+ /// <param name="targetConceptType">The <see cref="ConceptType"/>.</param>
/// <returns>The target <see cref="Column"/>.</returns>
- private static Column FindTarget(Column column, ConceptType conceptType)
+ private static Column FindTarget(Column sourceColumn, ConceptType targetConceptType)
{
- bool targetFound = true;
-
- if (TableIsPrimarilyForConceptType.GetTable(conceptType) == null)
+ Table targetTable = TableIsPrimarilyForConceptType.GetTable(targetConceptType);
+ TableIsAlsoForConceptType tableIsAlsoForConceptType;
+ if (targetTable == null)
{
- LinkedElementCollection<Table> tables = TableIsAlsoForConceptType.GetTable(conceptType);
- if (tables.Count != 1)
+ ReadOnlyCollection<TableIsAlsoForConceptType> tableIsAlsoForConceptTypeLinks = TableIsAlsoForConceptType.GetLinksToTable(targetConceptType);
+ if (tableIsAlsoForConceptTypeLinks.Count != 1)
{
return null;
}
+ else
+ {
+ tableIsAlsoForConceptType = tableIsAlsoForConceptTypeLinks[0];
+ targetTable = tableIsAlsoForConceptType.Table;
+ }
}
+ else
+ {
+ tableIsAlsoForConceptType = null;
+ }
- //LinkedElementCollection<ConceptType> relating = ConceptTypeRelatesToConceptType.GetRelatingConceptTypeCollection(conceptType);
- //int relatingCount = relating.Count;
- //ConceptType[] real = new ConceptType[] { relatingCount };
- //relating.CopyTo(real, 0);
- List<Column> possibleColumns = ConceptTypeHasPrimaryIdentifierColumns(column, conceptType);
-
- foreach (Column targetColumn in possibleColumns)
+ LinkedElementCollection<ConceptTypeChild> sourceCtcPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(sourceColumn);
+ List<ConceptTypeChild> targetCtcPath = new List<ConceptTypeChild>(sourceCtcPath.Count);
+
+ // This handles removing the source concept type's assimilation path,
+ // and the relationship itself.
+ // UNDONE: Can the relationship portion of this ever have more than one CTC in it? If so, this will break badly.
+ bool finishedWithAssimilationPath = false;
+ bool copyPath = false;
+ for (int i = 0; i < sourceCtcPath.Count; i++)
{
- targetFound = true;
-
- if (targetColumn.Equals(column))
+ ConceptTypeChild currentSourcePathChild = sourceCtcPath[i];
+ if (copyPath)
{
- targetFound = false;
+ targetCtcPath.Add(currentSourcePathChild);
}
else
{
- //for (int i = 0; i < ColumnHasConceptTypeChild.GetConceptTypeChildPath(targetColumn).Count; ++i)
- //{
- LinkedElementCollection<ConceptTypeChild> leftPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(column);
- LinkedElementCollection<ConceptTypeChild> rightPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(targetColumn);
-
- int leftBuffer = 0;
- int rightBuffer = 0;
-
- if (rightPath[0].GetType() == typeof(ConceptTypeAssimilatesConceptType))
+ if (!finishedWithAssimilationPath)
{
- if (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(rightPath[0] as ConceptTypeAssimilatesConceptType) == AssimilationAbsorptionChoice.Separate)
+ ConceptTypeAssimilatesConceptType currentAssimilation = currentSourcePathChild as ConceptTypeAssimilatesConceptType;
+ if (currentAssimilation != null)
{
- rightBuffer += 1;
+ if (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(currentAssimilation) != AssimilationAbsorptionChoice.Separate)
+ {
+ continue;
+ }
}
+ finishedWithAssimilationPath = true;
}
- if (leftPath[0].GetType() == typeof(ConceptTypeAssimilatesConceptType))
+ if (currentSourcePathChild.Target == targetConceptType)
{
- if (AssimilationMapping.GetAbsorptionChoiceFromAssimilation(leftPath[0] as ConceptTypeAssimilatesConceptType) == AssimilationAbsorptionChoice.Separate)
- {
- leftBuffer += 1;
- }
+ // This is the end of the assimilations and we're now at the start of the path to the preferred identifier.
+ copyPath = true;
}
+ }
+ }
- if (leftPath.Count - leftBuffer >= rightPath.Count - rightBuffer)
- {
- for (int reverseIndex = 0; reverseIndex < rightPath.Count - rightBuffer; reverseIndex++)
- {
- if (rightPath[rightPath.Count - 1 - reverseIndex] != leftPath[leftPath.Count - 1 - reverseIndex])
- {
- targetFound = false;
- break;
- }
+ if (tableIsAlsoForConceptType != null)
+ {
+ LinkedElementCollection<ConceptTypeAssimilatesConceptType> targetAssimilationPath = TableIsAlsoForConceptTypeHasAssimilationPath.GetAssimilationPath(tableIsAlsoForConceptType);
+ InformationType informationType = (InformationType)sourceCtcPath[sourceCtcPath.Count - 1];
+ ConceptType informationTypeParent = informationType.Parent;
- }
- }
- else
+ // Remove everything at and after index, and add everything before it
+ int index;
+ for (index = 0; index < targetAssimilationPath.Count; index++)
+ {
+ if (targetAssimilationPath[index].Parent == informationTypeParent)
{
- for (int reverseIndex = 0; reverseIndex < leftPath.Count - leftBuffer; reverseIndex++)
- {
- if (leftPath[leftPath.Count - 1 - reverseIndex] != rightPath[rightPath.Count - 1 - reverseIndex])
- {
- targetFound = false;
- break;
- }
- }
+ break;
}
- //}
- // END TEST
+ }
+#if DEBUG
+ for (int i = targetAssimilationPath.Count - 1, j = 0; i >= index; i--, j++)
+ {
+ Debug.Assert(targetCtcPath[j] == targetAssimilationPath[i]);
+ }
+#endif //DEBUG
- //if ((i + 1 < leftPath.Count && i + offset < rightPath.Count &&
- // leftPath[i + 1] != rightPath[i + offset]))
- //{
- // for (int j = 0; j < leftPath.Count; ++j)
- // {
- // if (leftPath[j].GetType() == typeof(InformationType))
- // {
- // offset = j;
- // }
- // }
+ targetCtcPath.RemoveRange(0, targetAssimilationPath.Count - index);
- // if ((i + 1 < leftPath.Count && i + offset < rightPath.Count &&
- // rightPath[rightPath.Count - 1] != rightPath[offset]))
- // {
+ for (int i = index - 1; i >= 0; i--)
+ {
+ targetCtcPath.Insert(0, targetAssimilationPath[i]);
+ }
+ }
- // targetFound = false;
- // break;
- // }
- //}
+ foreach (Column possibleColumn in targetTable.ColumnCollection)
+ {
+ if (possibleColumn == sourceColumn)
+ {
+ continue;
}
- if (targetFound && targetColumn.Table != null)
+ bool isMatch = true;
+ LinkedElementCollection<ConceptTypeChild> possibleCtcPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(possibleColumn);
+
+ if (possibleCtcPath.Count == targetCtcPath.Count)
{
- return targetColumn;
+ for (int i = targetCtcPath.Count - 1; i >= 0; i--)
+ {
+ if (possibleCtcPath[i] != targetCtcPath[i])
+ {
+ isMatch = false;
+ break;
+ }
+ }
+ if (isMatch)
+ {
+ return possibleColumn;
+ }
}
}
@@ -1526,7 +1553,7 @@
foreach (TableIsAlsoForConceptType tableIsAlsoForConceptType in TableIsAlsoForConceptType.GetLinksToTable(conceptType))
{
Table table = tableIsAlsoForConceptType.Table;
- LinkedElementCollection<Column> columns = table.ColumnCollection;
+ LinkedElementCollection<Column> tableColumns = table.ColumnCollection;
LinkedElementCollection<ConceptTypeAssimilatesConceptType> assimilationPath = tableIsAlsoForConceptType.AssimilationPath;
int assimilationPathCount = assimilationPath.Count;
@@ -1535,6 +1562,7 @@
UniquenessConstraint uniquenessConstraint = new UniquenessConstraint(table.Store, new PropertyAssignment[] { new PropertyAssignment(UniquenessConstraint.NameDomainPropertyId, uniqueness.Name) });
uniquenessConstraint.Table = table;
new UniquenessConstraintIsForUniqueness(uniquenessConstraint, uniqueness);
+ LinkedElementCollection<Column> uniquenessColumns = uniquenessConstraint.ColumnCollection;
bool isPreferred = uniqueness.IsPreferred;
if (isPreferred)
@@ -1568,10 +1596,10 @@
List<Column> matchingColumns = new List<Column>(uniquenessConceptTypeChildren.Count);
- foreach (Column column in columns)
+ foreach (Column column in tableColumns)
{
LinkedElementCollection<ConceptTypeChild> ctcPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(column);
- bool pathMatches = ctcPath.Count == assimilationPathCount + 1;
+ bool pathMatches = ctcPath.Count >= assimilationPathCount + 1;
if (pathMatches)
{
for (int i = 0; i < assimilationPathCount; i++)
@@ -1589,7 +1617,7 @@
}
}
- Debug.Assert(matchingColumns.Count == uniquenessConceptTypeChildren.Count);
+ Debug.Assert(matchingColumns.Count >= uniquenessConceptTypeChildren.Count);
foreach (ConceptTypeChild conceptTypeChild in uniqueness.ConceptTypeChildCollection)
{
@@ -1598,9 +1626,8 @@
Column column = matchingColumns[i];
if (ColumnHasConceptTypeChild.GetConceptTypeChildPath(column)[assimilationPathCount] == conceptTypeChild)
{
- uniquenessConstraint.ColumnCollection.Add(column);
+ uniquenessColumns.Add(column);
matchingColumns.RemoveAt(i);
- break;
}
}
}
Modified: trunk/RelationalModel/OialDcilBridge/OialDcilBridge.dsl
===================================================================
--- trunk/RelationalModel/OialDcilBridge/OialDcilBridge.dsl 2007-09-10 23:03:11 UTC (rev 1118)
+++ trunk/RelationalModel/OialDcilBridge/OialDcilBridge.dsl 2007-09-10 23:04:41 UTC (rev 1119)
@@ -253,7 +253,7 @@
</DomainRole>
</Target>
</DomainRelationship>
- <DomainRelationship Id="CCBCAB63-ADE4-43FA-8E29-8A598B0969F5" Name="ColumnHasConceptTypeChild" Namespace="Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge">
+ <DomainRelationship Id="CCBCAB63-ADE4-43FA-8E29-8A598B0969F5" Name="ColumnHasConceptTypeChild" Namespace="Neumont.Tools.ORMAbstractionToConceptualDatabaseBridge" AllowsDuplicates="true">
<Source>
<DomainRole Id="BC7EA8A8-8772-4CA4-B914-B78B4B583338" Description="" Name="Column" PropertyName="ConceptTypeChildPath" Multiplicity="OneMany">
<RolePlayer>
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
