Beispiel #1
0
        /// <summary>
        /// DeletingRule: typeof(UniquenessConstraintIncludesColumn)
        /// If a uniqueness constraint column is being removed, then remove the corresponding column
        /// in any reference constraints that target the columns in the uniqueness constraint.
        /// </summary>
        private static void UniquenessConstraintColumnDeleting(ElementDeletingEventArgs e)
        {
            UniquenessConstraintIncludesColumn link   = (UniquenessConstraintIncludesColumn)e.ModelElement;
            UniquenessConstraint uniquenessConstraint = link.UniquenessConstraint;

            if (!uniquenessConstraint.IsDeleting)
            {
                bool haveIndex = false;
                int  index     = -1;
                foreach (ReferenceConstraint referenceConstraint in uniquenessConstraint.ReferenceConstraintCollection)
                {
                    if (!haveIndex)
                    {
                        haveIndex = true;
                        index     = UniquenessConstraintIncludesColumn.GetLinksToColumnCollection(uniquenessConstraint).IndexOf(link);
                    }
                    LinkedElementCollection <ColumnReference> columnRefs = referenceConstraint.ColumnReferenceCollection;
                    if (index < columnRefs.Count && columnRefs[index].TargetColumn == link.Column)                     // Sanity check
                    {
                        columnRefs.RemoveAt(index);
                    }
                    else
                    {
                        // Something is off, delay validate this later
                        ReferenceConstraintTargetsTable tableLink = ReferenceConstraintTargetsTable.GetLinkToTargetTable(referenceConstraint);
                        if (tableLink != null)
                        {
                            FrameworkDomainModel.DelayValidateElement(tableLink, DelayValidateTargetUniquenessConstraint);
                        }
                    }
                }
            }
        }
Beispiel #2
0
 /// <summary>
 /// AddRule: typeof(UniquenessConstraintIncludesColumn)
 /// Verify any related <see cref="ReferenceConstraint"/> when a new
 /// column is added to a uniqueness constraint. The reference constraint
 /// needs to be deleted if the calling code has not made a matching modification
 /// by the end of the transaction.
 /// </summary>
 private static void UniquenessConstraintColumnAdded(ElementAddedEventArgs e)
 {
     foreach (ReferenceConstraint referenceConstraint in ReferenceConstraintTargetsUniquenessConstraint.GetReferenceConstraintCollection(((UniquenessConstraintIncludesColumn)e.ModelElement).UniquenessConstraint))
     {
         ReferenceConstraintTargetsTable tableLink = ReferenceConstraintTargetsTable.GetLinkToTargetTable(referenceConstraint);
         if (tableLink != null)
         {
             FrameworkDomainModel.DelayValidateElement(tableLink, DelayValidateTargetUniquenessConstraint);
         }
     }
 }
        /// <summary>
        /// AddRule: typeof(ORMSolutions.ORMArchitect.RelationalModels.ConceptualDatabase.ReferenceConstraintTargetsTable), FireTime=TopLevelCommit, Priority=DiagramFixupConstants.AddConnectionRulePriority;
        /// Add a <see cref="ForeignKeyConnector"/> to the diagram
        /// </summary>
        private static void ReferenceConstraintAddedRule(ElementAddedEventArgs e)
        {
            ReferenceConstraintTargetsTable link = (ReferenceConstraintTargetsTable)e.ModelElement;
            Table   sourceTable;
            Schema  schema;
            Catalog catalog;

            if (null != (sourceTable = link.ReferenceConstraint.SourceTable) &&
                null != (schema = sourceTable.Schema) &&
                null != (catalog = schema.Catalog))
            {
                FixUpDiagram(catalog, link);
            }
        }
        /// <summary>
        /// Correctly connect a <see cref="ForeignKeyConnector"/>
        /// </summary>
        protected override void OnChildConfiguring(ShapeElement child, bool createdDuringViewFixup)
        {
            ForeignKeyConnector foreignKeyConnector;

            if (null != (foreignKeyConnector = child as ForeignKeyConnector))
            {
                ReferenceConstraintTargetsTable link = (ReferenceConstraintTargetsTable)child.ModelElement;
                TableShape sourceShape = null;
                Table      sourceTable;
                if (null != (sourceTable = link.ReferenceConstraint.SourceTable))
                {
                    foreach (PresentationElement pel in PresentationViewsSubject.GetPresentation(sourceTable))
                    {
                        TableShape testShape = pel as TableShape;
                        if (testShape != null && testShape.Diagram == this)
                        {
                            sourceShape = testShape;
                            break;
                        }
                    }
                }
                if (null != sourceShape)
                {
                    foreach (PresentationElement pel in PresentationViewsSubject.GetPresentation(link.TargetTable))
                    {
                        TableShape targetShape = pel as TableShape;
                        if (targetShape != null && targetShape.Diagram == this)
                        {
                            foreignKeyConnector.Connect(sourceShape, targetShape);
                            return;
                        }
                    }
                }
            }
            base.OnChildConfiguring(child, createdDuringViewFixup);
        }
Beispiel #5
0
        private static void ValidateTargetUniquenessConstraint(ReferenceConstraintTargetsTable tableReference, INotifyElementAdded notifyAdded)
        {
            if (tableReference.IsDeleted)
            {
                return;
            }
            Table targetTable = tableReference.TargetTable;
            ReferenceConstraint referenceConstraint = tableReference.ReferenceConstraint;
            LinkedElementCollection <ColumnReference> columnRefs = referenceConstraint.ColumnReferenceCollection;
            int columnRefCount = columnRefs.Count;
            ReferenceConstraintTargetsUniquenessConstraint targetUniquenessLink = ReferenceConstraintTargetsUniquenessConstraint.GetLinkToTargetUniquenessConstraint(referenceConstraint);

            if (targetUniquenessLink != null)
            {
                // Verify the target uniqueness
                UniquenessConstraint targetUniqueness = targetUniquenessLink.TargetUniquenessConstraint;
                bool existingIsValid = targetUniqueness.Table == targetTable;
                if (existingIsValid)
                {
                    LinkedElementCollection <Column> uniquenessColumns = targetUniqueness.ColumnCollection;
                    existingIsValid = uniquenessColumns.Count == columnRefCount;
                    if (existingIsValid)
                    {
                        for (int i = 0; i < columnRefCount; ++i)
                        {
                            if (uniquenessColumns[i] != columnRefs[i].TargetColumn)
                            {
                                existingIsValid = false;
                                break;
                            }
                        }
                    }
                }
                if (!existingIsValid)
                {
                    // Delete the link without deleting the reference constraint we're processing
                    targetUniquenessLink.Delete(ReferenceConstraintTargetsUniquenessConstraint.ReferenceConstraintDomainRoleId);
                    targetUniquenessLink = null;
                }
            }
            if (targetUniquenessLink == null)
            {
                foreach (UniquenessConstraint testUniqueness in targetTable.UniquenessConstraintCollection)
                {
                    LinkedElementCollection <Column> uniquenessColumns = testUniqueness.ColumnCollection;
                    if (uniquenessColumns.Count == columnRefCount)
                    {
                        int i = 0;
                        for (; i < columnRefCount; ++i)
                        {
                            if (uniquenessColumns[i] != columnRefs[i].TargetColumn)
                            {
                                break;
                            }
                        }
                        if (i == columnRefCount)
                        {
                            // We have a match
                            targetUniquenessLink = new ReferenceConstraintTargetsUniquenessConstraint(referenceConstraint, testUniqueness);
                            if (notifyAdded != null)
                            {
                                notifyAdded.ElementAdded(targetUniquenessLink, false);
                            }
                            break;
                        }
                    }
                }
                if (targetUniquenessLink == null)
                {
                    referenceConstraint.Delete();
                }
            }
        }
Beispiel #6
0
        /// <summary>
        /// RolePlayerPositionChangeRule: typeof(UniquenessConstraintIncludesColumn)
        /// If a uniqueness constraint column is being repositioned, then reposition the corresponding column
        /// in any reference constraints that target the columns in the uniqueness constraint.
        /// </summary>
        private static void UniquenessConstraintColumnPositionChanged(RolePlayerOrderChangedEventArgs e)
        {
            if (e.CounterpartDomainRole.Id == UniquenessConstraintIncludesColumn.ColumnDomainRoleId)
            {
                UniquenessConstraint uniquenessConstraint = (UniquenessConstraint)e.SourceElement;
                int oldIndex = e.OldOrdinal;
                int newIndex = e.NewOrdinal;
                foreach (ReferenceConstraint referenceConstraint in uniquenessConstraint.ReferenceConstraintCollection)
                {
                    LinkedElementCollection <ColumnReference> columnRefs = referenceConstraint.ColumnReferenceCollection;
                    int columnRefCount = columnRefs.Count;
                    if (newIndex < columnRefCount && oldIndex < columnRefCount && columnRefs[oldIndex].TargetColumn == e.CounterpartRolePlayer)                     // Sanity check
                    {
                        Column sourceColumn = columnRefs[oldIndex].SourceColumn;
                        columnRefs.Move(oldIndex, newIndex);

                        // Any uniqueness constraint that includes all columns in the
                        // reference constraint will generate in a different order and
                        // should be updated
                        Table sourceTable;
                        if (null != (sourceTable = referenceConstraint.SourceTable))
                        {
                            foreach (UniquenessConstraint sourceUniquenessConstraint in sourceTable.UniquenessConstraintCollection)
                            {
                                LinkedElementCollection <Column> uniquenessColumns = sourceUniquenessConstraint.ColumnCollection;
                                int uniquenessColumnCount = uniquenessColumns.Count;
                                if (uniquenessColumnCount >= columnRefCount)
                                {
                                    int firstMatchColumn = int.MaxValue;
                                    for (int i = 0; i < columnRefCount; ++i)
                                    {
                                        Column matchColumn = columnRefs[i].SourceColumn;
                                        int    j           = 0;
                                        for (; j < uniquenessColumnCount; ++j)
                                        {
                                            if (uniquenessColumns[j] == matchColumn)
                                            {
                                                firstMatchColumn = Math.Min(firstMatchColumn, j);
                                                break;
                                            }
                                        }
                                        if (j == uniquenessColumnCount)
                                        {
                                            // Not included
                                            firstMatchColumn = int.MaxValue;
                                            break;
                                        }
                                    }
                                    if (firstMatchColumn != int.MaxValue)
                                    {
                                        uniquenessColumnCount -= firstMatchColumn;
                                        if (newIndex < uniquenessColumnCount &&
                                            oldIndex < uniquenessColumnCount &&
                                            uniquenessColumns[firstMatchColumn + oldIndex] == sourceColumn)                                             // Sanity check
                                        {
                                            uniquenessColumns.Move(firstMatchColumn + oldIndex, firstMatchColumn + newIndex);
                                        }
                                        // If this does not line up then something is clearly off, but
                                        // this is a non-critical error in that the model is still correctly
                                        // aligned and generates correct DDL.
                                        // However, the constraint will now have a different column order
                                        // than with a full regeneration.
                                        // UNDONE: Delay validation routine for this situation
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        // Something is off, delay validate this later
                        ReferenceConstraintTargetsTable tableLink = ReferenceConstraintTargetsTable.GetLinkToTargetTable(referenceConstraint);
                        if (tableLink != null)
                        {
                            FrameworkDomainModel.DelayValidateElement(tableLink, DelayValidateTargetUniquenessConstraint);
                        }
                    }
                }
            }
        }