/// <summary>
/// Cache the location of any table shape associated with the provided <see cref="ObjectType"/> and <see cref="Table"/>
/// </summary>
private static void RememberTableShapeLocations(ObjectType objectType, Table table)
{
foreach (PresentationElement pel in PresentationViewsSubject.GetPresentation(table))
{
TableShape shape = pel as TableShape;
if (pel != null)
{
Dictionary<object, object> context = objectType.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo;
object tablePositionsObject;
Dictionary<Guid, PointD> tablePositions;
if (!context.TryGetValue(TablePositionDictionaryKey, out tablePositionsObject) ||
(tablePositions = tablePositionsObject as Dictionary<Guid, PointD>) == null)
{
context[TablePositionDictionaryKey] = tablePositions = new Dictionary<Guid, PointD>();
}
tablePositions[objectType.Id] = shape.Location;
}
}
}
/// <summary>
/// Constructor
/// Creates a SchemaContainsTable link in the same Partition as the given Schema
/// </summary>
/// <param name="source">Schema to use as the source of the relationship.</param>
/// <param name="target">Table to use as the target of the relationship.</param>
public SchemaContainsTable(Schema source, Table target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(SchemaContainsTable.SchemaDomainRoleId, source), new DslModeling::RoleAssignment(SchemaContainsTable.TableDomainRoleId, target)}, null)
{
}
public static void SetTargetTable(ReferenceConstraint element, Table newTargetTable)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, ReferenceConstraintDomainRoleId, newTargetTable);
}
public static DslModeling::LinkedElementCollection<ReferenceConstraint> GetReferenceConstraints(Table element)
{
return new DslModeling::LinkedElementCollection<ReferenceConstraint>(element, TargetTableDomainRoleId);
}
/// <summary>
/// Constructor
/// Creates a ReferenceConstraintTargetsTable link in the same Partition as the given ReferenceConstraint
/// </summary>
/// <param name="source">ReferenceConstraint to use as the source of the relationship.</param>
/// <param name="target">Table to use as the target of the relationship.</param>
public ReferenceConstraintTargetsTable(ReferenceConstraint source, Table target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(ReferenceConstraintTargetsTable.ReferenceConstraintDomainRoleId, source), new DslModeling::RoleAssignment(ReferenceConstraintTargetsTable.TargetTableDomainRoleId, target)}, null)
{
}
public static DslModeling::LinkedElementCollection<CheckConstraint> GetCheckConstraintCollection(Table element)
{
return new DslModeling::LinkedElementCollection<CheckConstraint>(element, TableDomainRoleId);
}
string IDatabaseNameGenerator.GenerateTableName(Table table, int phase)
{
return GenerateTableName(table, phase);
}
public static void SetTable(Column element, Table newTable)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, ColumnDomainRoleId, newTable);
}
public static DslModeling::LinkedElementCollection<Column> GetColumnCollection(Table element)
{
return new DslModeling::LinkedElementCollection<Column>(element, TableDomainRoleId);
}
private static void ValidateTableNameChanged(Table table)
{
if (null != table)
{
FrameworkDomainModel.DelayValidateElement(table, DelayValidateTableNameChanged);
}
}
/// <summary>
/// Constructor
/// Creates a TableContainsColumn link in the same Partition as the given Table
/// </summary>
/// <param name="source">Table to use as the source of the relationship.</param>
/// <param name="target">Column to use as the target of the relationship.</param>
public TableContainsColumn(Table source, Column target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(TableContainsColumn.TableDomainRoleId, source), new DslModeling::RoleAssignment(TableContainsColumn.ColumnDomainRoleId, target)}, null)
{
}
public static DslModeling::LinkedElementCollection<UniquenessConstraint> GetUniquenessConstraintCollection(Table element)
{
return GetRoleCollection<DslModeling::LinkedElementCollection<UniquenessConstraint>, UniquenessConstraint>(element, TableDomainRoleId);
}
public static DslModeling::ReadOnlyLinkedElementCollection<Constraint> GetConstraintCollection(Table element)
{
return GetRoleCollection<DslModeling::ReadOnlyLinkedElementCollection<Constraint>, Constraint>(element, TableDomainRoleId);
}
private string GenerateTableName(Table table, int phase)
{
if (phase != 0)
{
return null;
}
NamePart singleName = default(NamePart);
List<NamePart> nameCollection = null;
NameGenerator nameGenerator = TableNameGenerator;
ReferenceModeNaming.SeparateObjectTypeParts(
ConceptTypeIsForObjectType.GetObjectType(TableIsPrimarilyForConceptType.GetConceptType(table)),
nameGenerator,
delegate(NamePart newPart, int? insertIndex)
{
AddToNameCollection(ref singleName, ref nameCollection, newPart, insertIndex.HasValue ? insertIndex.Value : -1, true);
});
string finalName = GetFinalName(singleName, nameCollection, nameGenerator);
return string.IsNullOrEmpty(finalName) ? "TABLE" : finalName;
}
public static Schema GetSchema(Table element)
{
return DslModeling::DomainRoleInfo.GetLinkedElement(element, TableDomainRoleId) as Schema;
}
/// <summary>
/// Constructor
/// Creates a TableContainsCheckConstraint link in the same Partition as the given Table
/// </summary>
/// <param name="source">Table to use as the source of the relationship.</param>
/// <param name="target">CheckConstraint to use as the target of the relationship.</param>
public TableContainsCheckConstraint(Table source, CheckConstraint target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(TableContainsCheckConstraint.TableDomainRoleId, source), new DslModeling::RoleAssignment(TableContainsCheckConstraint.CheckConstraintDomainRoleId, target)}, null)
{
}
public static void SetSchema(Table element, Schema newSchema)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, TableDomainRoleId, newSchema);
}
public static void SetTable(CheckConstraint element, Table newTable)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, CheckConstraintDomainRoleId, newTable);
}
private static void UpdateTablePresentationSize(Table table)
{
if (table != null)
{
foreach (PresentationElement pel in PresentationViewsSubject.GetPresentation(table))
{
TableShape shape;
ColumnElementListCompartment compartment;
if (null != (shape = pel as TableShape) &&
null != (compartment = shape.FindCompartment("ColumnsCompartment") as ColumnElementListCompartment))
{
compartment.InvalidateOrUpdateSize();
}
}
}
}
private LinkedNode<ColumnPathStep> GetColumnPath(Column column)
{
Table table = column.Table;
if (myColumnStepTable == table)
{
return myColumnSteps[column];
}
Dictionary<Column, LinkedNode<ColumnPathStep>> columnSteps = myColumnSteps;
if (myColumnStepTable == null)
{
myColumnSteps = columnSteps = new Dictionary<Column, LinkedNode<ColumnPathStep>>();
}
else
{
columnSteps.Clear();
}
myColumnStepTable = table;
#if DEBUGCOLUMNPATH
Debug.WriteLine("Table: " + table.Name);
Debug.Indent();
Debug.Indent();
#endif // DEBUGCOLUMNPATH
// Seed the cross-cutting dictionary and seed it with the main represented
// ObjectTypes to force decorations on columns that loop back into this table.
Dictionary<ObjectType, LinkedNode<LinkedNode<ColumnPathStep>>> objectTypeToSteps = new Dictionary<ObjectType, LinkedNode<LinkedNode<ColumnPathStep>>>();
ConceptType primaryConceptType = TableIsPrimarilyForConceptType.GetConceptType(table);
if (primaryConceptType != null)
{
ObjectType targetObjectType = ConceptTypeIsForObjectType.GetObjectType(primaryConceptType);
objectTypeToSteps[targetObjectType] = new LinkedNode<LinkedNode<ColumnPathStep>>(new LinkedNode<ColumnPathStep>(new ColumnPathStep(null, targetObjectType, null, ColumnPathStepFlags.None)));
}
foreach (ConceptType secondaryConceptType in TableIsAlsoForConceptType.GetConceptType(table))
{
ObjectType targetObjectType = ConceptTypeIsForObjectType.GetObjectType(secondaryConceptType);
objectTypeToSteps[targetObjectType] = new LinkedNode<LinkedNode<ColumnPathStep>>(new LinkedNode<ColumnPathStep>(new ColumnPathStep(null, targetObjectType, null, ColumnPathStepFlags.None)));
}
LinkedElementCollection<Column> columns = table.ColumnCollection;
int columnCount = columns.Count;
for (int iColumn = 0; iColumn < columnCount; ++iColumn)
{
Column currentColumn = columns[iColumn];
#if DEBUGCOLUMNPATH
Debug.Unindent();
Debug.WriteLine("Column: " + currentColumn.Name);
Debug.Indent();
#endif // DEBUGCOLUMNPATH
LinkedElementCollection<ConceptTypeChild> childPath = ColumnHasConceptTypeChild.GetConceptTypeChildPath(currentColumn);
int childPathCount = childPath.Count;
LinkedNode<ColumnPathStep> headNode = null;
LinkedNode<ColumnPathStep> tailNode = null;
bool passedIdentifier = false;
bool processTailDelayed = false;
ConceptType nextComingFromConceptType = primaryConceptType;
Objectification assimilationObjectification = null;
for (int iChild = 0; iChild < childPathCount; ++iChild)
{
ConceptType comingFromConceptType = nextComingFromConceptType;
ConceptTypeChild child = childPath[iChild];
ConceptTypeAssimilatesConceptType assimilation = child as ConceptTypeAssimilatesConceptType;
bool reverseAssimilation = false;
bool forwardToReverseTransition = false;
bool towardsSubtype = false;
if (assimilation != null)
{
if (comingFromConceptType == assimilation.Parent)
{
nextComingFromConceptType = assimilation.ReferencedConceptType;
}
else
{
towardsSubtype = true;
nextComingFromConceptType = assimilation.Parent;
}
#if DEBUGCOLUMNPATH
Debug.WriteLine("From: " + comingFromConceptType.Name + " To: " + nextComingFromConceptType.Name + "(" + (assimilation.RefersToSubtype && assimilation.IsPreferredForTarget).ToString() + ")");
#endif // DEBUGCOLUMNPATH
if (tailNode != null)
{
// If we're already moving down an assimilation path in a specific direction then keep
// going that direction
ColumnPathStep pathStep = tailNode.Value;
ColumnPathStepFlags stepFlags = pathStep.Flags;
if (0 != (stepFlags & ColumnPathStepFlags.ForwardAssimilation))
{
// Keep going forward
if (0 != (stepFlags & ColumnPathStepFlags.AssimilationIsSubtype) &&
AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation) != AssimilationAbsorptionChoice.Absorb &&
comingFromConceptType == (0 == (stepFlags & ColumnPathStepFlags.AssimilationTowardsSubtype) ? assimilation.AssimilatedConceptType : assimilation.AssimilatorConceptType))
{
forwardToReverseTransition = true;
}
}
else if (0 != (stepFlags & ColumnPathStepFlags.ReverseAssimilation))
{
// Keep going backward
reverseAssimilation = true;
}
else
{
// Figure it out from this step
reverseAssimilation = AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation) != AssimilationAbsorptionChoice.Absorb;
}
}
else
{
reverseAssimilation = AssimilationMapping.GetAbsorptionChoiceFromAssimilation(assimilation) != AssimilationAbsorptionChoice.Absorb;
}
}
else
{
nextComingFromConceptType = child.Target as ConceptType;
#if DEBUGCOLUMNPATH
Debug.WriteLine("From: " + comingFromConceptType.Name + " To: " + ((nextComingFromConceptType != null) ? nextComingFromConceptType.Name : ((InformationTypeFormat)child.Target).Name));
#endif // DEBUGCOLUMNPATH
}
LinkedElementCollection<FactType> factTypes = ConceptTypeChildHasPathFactType.GetPathFactTypeCollection(child);
int factTypeCount = factTypes.Count;
for (int iFactType = 0; iFactType < factTypeCount; ++iFactType)
{
FactType factType = factTypes[iFactType];
Role targetRole = FactTypeMapsTowardsRole.GetTowardsRole(factType).Role;
ColumnPathStepFlags flags = passedIdentifier ? ColumnPathStepFlags.PassedIdentifier : 0;
ColumnPathStep pathStep = default(ColumnPathStep);
bool processPreviousTail = false;
Objectification previousAssimilationObjectification = assimilationObjectification;
assimilationObjectification = null;
bool processAsFactType = true;
if (assimilation != null)
{
Role nonAssimilationTargetRole = targetRole;
if (!towardsSubtype)
{
targetRole = targetRole.OppositeRoleAlwaysResolveProxy.Role;
}
processAsFactType = false;
Objectification objectification;
bool assimilationIsSubtype = assimilation.RefersToSubtype;
bool secondarySubtype = assimilationIsSubtype && !assimilation.IsPreferredForTarget;
if (!assimilationIsSubtype &&
null != (objectification = factType.ImpliedByObjectification) &&
objectification.NestingType == targetRole.RolePlayer)
{
assimilationObjectification = objectification;
}
if (tailNode != null)
{
pathStep = tailNode.Value;
ColumnPathStepFlags tailFlags = pathStep.Flags;
if (0 != (tailFlags & (ColumnPathStepFlags.ForwardAssimilation | ColumnPathStepFlags.ReverseAssimilation)))
{
bool tailIsSubtype = 0 != (tailFlags & ColumnPathStepFlags.AssimilationIsSubtype);
if (tailIsSubtype && assimilationIsSubtype)
{
if (forwardToReverseTransition)
{
flags |= ColumnPathStepFlags.DeclinedAssimilation;
targetRole = towardsSubtype ? targetRole.OppositeRoleAlwaysResolveProxy.Role : nonAssimilationTargetRole;
processAsFactType = true;
}
else
{
if (secondarySubtype && 0 == (tailFlags & ColumnPathStepFlags.NonPreferredSubtype))
{
tailNode.Value = new ColumnPathStep(pathStep.FromRole, pathStep.ObjectType, pathStep.AlternateObjectType, tailFlags | ColumnPathStepFlags.NonPreferredSubtype);
}
// If this is a subtype chain, then keep going, using the first
// subtype in the chain as a node used in the final name.
continue;
}
}
else if (assimilationObjectification != null)
{
// The type of assimilation has changed, but we have an objectifying object type,
// so we treat it like a separate link in the chain, or the previous element was
// also not a subtype.
tailNode.Value = new ColumnPathStep(pathStep.FromRole, pathStep.ObjectType, nonAssimilationTargetRole.RolePlayer, pathStep.Flags);
processPreviousTail = processTailDelayed;
}
else
{
flags |= ColumnPathStepFlags.DeclinedAssimilation;
targetRole = towardsSubtype ? targetRole.OppositeRoleAlwaysResolveProxy.Role : nonAssimilationTargetRole;
processAsFactType = true;
}
}
}
else if (!assimilationIsSubtype && assimilationObjectification == null)
{
flags |= ColumnPathStepFlags.DeclinedAssimilation;
targetRole = towardsSubtype ? targetRole.OppositeRoleAlwaysResolveProxy.Role : nonAssimilationTargetRole;
processAsFactType = true;
}
if (!processAsFactType)
{
if (reverseAssimilation)
{
flags |= ColumnPathStepFlags.ReverseAssimilation;
}
else
{
flags |= ColumnPathStepFlags.ForwardAssimilation;
}
if (assimilationIsSubtype)
{
flags |= ColumnPathStepFlags.AssimilationIsSubtype;
if (secondarySubtype)
{
flags |= ColumnPathStepFlags.NonPreferredSubtype;
}
if (towardsSubtype)
{
flags |= ColumnPathStepFlags.AssimilationTowardsSubtype;
}
}
pathStep = new ColumnPathStep(
null,
towardsSubtype ? ConceptTypeIsForObjectType.GetObjectType(comingFromConceptType) : targetRole.RolePlayer,
towardsSubtype ? targetRole.RolePlayer : null,
flags);
processTailDelayed = true;
}
}
if (processAsFactType)
{
bool haveStep = false;
if (tailNode != null)
{
pathStep = tailNode.Value;
ColumnPathStepFlags tailFlags = pathStep.Flags;
if (0 != (tailFlags & (ColumnPathStepFlags.ForwardAssimilation | ColumnPathStepFlags.ReverseAssimilation)))
{
RoleProxy oppositeProxy;
Role objectifiedResolvedProxyRole;
Role objectifiedOppositeRole;
if (previousAssimilationObjectification != null &&
factType.ImpliedByObjectification == previousAssimilationObjectification &&
null != (oppositeProxy = targetRole.OppositeRole as RoleProxy) &&
null != (objectifiedOppositeRole = (objectifiedResolvedProxyRole = oppositeProxy.Role).OppositeRole as Role))
{
flags |= ColumnPathStepFlags.ObjectifiedFactType;
// Replace both factTypes with the original unobjectified FactType
ObjectType fromObjectType = objectifiedOppositeRole.RolePlayer;
if (pathStep.ObjectType == previousAssimilationObjectification.NestingType)
{
// Trivial path leading in, remove the subtype completely
processTailDelayed = false;
tailNode.Value = new ColumnPathStep(objectifiedOppositeRole, objectifiedResolvedProxyRole.RolePlayer, null, flags);
ProcessTailNode(tailNode, objectTypeToSteps);
continue;
}
tailNode.Value = new ColumnPathStep(pathStep.FromRole, pathStep.ObjectType, fromObjectType, pathStep.Flags);
pathStep = new ColumnPathStep(objectifiedOppositeRole, objectifiedResolvedProxyRole.RolePlayer, null, flags);
haveStep = true;
}
else
{
// Add a resolved supertype to the forward subtype to
// allow later steps to be compared to this one.
tailNode.Value = new ColumnPathStep(pathStep.FromRole, pathStep.ObjectType, targetRole.RolePlayer, pathStep.Flags);
}
}
else if (!processTailDelayed && 0 != (tailFlags & ColumnPathStepFlags.DeclinedAssimilation))
{
// Add a resolved supertype to the previous step
tailNode.Value = new ColumnPathStep(pathStep.FromRole, pathStep.ObjectType, targetRole.RolePlayer, pathStep.Flags);
}
}
if (!haveStep)
{
Role oppositeRole = targetRole.OppositeRoleAlwaysResolveProxy.Role;
ORMUniquenessConstraint pid = targetRole.RolePlayer.PreferredIdentifier;
if (pid != null && pid.RoleCollection.Contains(oppositeRole))
{
flags |= ColumnPathStepFlags.IsIdentifier;
passedIdentifier = true;
}
pathStep = new ColumnPathStep(targetRole, oppositeRole.RolePlayer, null, flags);
}
processPreviousTail = processTailDelayed;
processTailDelayed = false;
}
if (processPreviousTail && tailNode != null)
{
ProcessTailNode(tailNode, objectTypeToSteps);
}
LinkedNode<ColumnPathStep> newNode = new LinkedNode<ColumnPathStep>(pathStep);
if (tailNode == null)
{
headNode = tailNode = newNode;
}
else
{
tailNode.SetNext(newNode, ref headNode);
tailNode = newNode;
}
if (!processTailDelayed)
{
ProcessTailNode(tailNode, objectTypeToSteps);
}
}
}
if (processTailDelayed)
{
ProcessTailNode(tailNode, objectTypeToSteps);
}
columnSteps.Add(currentColumn, headNode);
}
Debug.Unindent();
Debug.Unindent();
return columnSteps[column];
}
