Example #1
0
        private void UpdateHints()
        {
            var originalHints = Hints;

            Hints = new HintSet(CurrentModel, TargetModel);

            // Process RenameHints
            foreach (var renameHint in originalHints.OfType <RenameHint>())
            {
                if (TemporaryRenames.TryGetValue(renameHint.SourcePath, out var sourceNode))
                {
                    Hints.Add(new RenameHint(sourceNode.Path, renameHint.TargetPath));
                }
                else
                {
                    Hints.Add(renameHint);
                }
            }

            // Process CopyDataHints
            foreach (var copyDataHint in originalHints.OfType <CopyDataHint>())
            {
                var sourceTablePath = GetActualPath(copyDataHint.SourceTablePath);
                var identities      = copyDataHint.Identities.Select(pair =>
                                                                     new IdentityPair(GetActualPath(pair.Source), pair.Target, pair.IsIdentifiedByConstant))
                                      .ToList();
                var copiedColumns = copyDataHint.CopiedColumns.Select(pair =>
                                                                      new Pair <string>(GetActualPath(pair.First), pair.Second))
                                    .ToList();
                var newCopyDataHint = new CopyDataHint(sourceTablePath, identities, copiedColumns);
                Hints.Add(newCopyDataHint);
            }

            // Process DeleteDataHints
            foreach (var deleteDataHint in originalHints.OfType <DeleteDataHint>())
            {
                if (!deleteDataHint.PostCopy)
                {
                    continue; // It's not necessary to copy this hint
                }

                var sourceTablePath = GetActualPath(deleteDataHint.SourceTablePath);
                var identities      = deleteDataHint.Identities.Select(pair =>
                                                                       new IdentityPair(GetActualPath(pair.Source), pair.Target, pair.IsIdentifiedByConstant))
                                      .ToList();
                var newDeleteDataHint = new DeleteDataHint(sourceTablePath, identities, true);
                Hints.Add(newDeleteDataHint);
            }

            // Process IgnoreHints
            foreach (var ignoreHint in originalHints.OfType <IgnoreHint>())
            {
                Hints.Add(ignoreHint);
            }
        }
        public void RemoveTypeTest()
        {
            var storage = CreateSimpleStorageModel();

            TestUpdate(storage, (s1, s2, hs) => {
                var fkCRefB = s2.Resolve("Tables/C/ForeignKeys/FK_CRefB") as ForeignKeyInfo;
                var tB      = s2.Resolve("Tables/B") as TableInfo;
                fkCRefB.Remove();
                tB.Remove();

                var deleteDataHint = new DeleteDataHint(
                    "Tables/A",
                    new List <IdentityPair> {
                    new IdentityPair("Tables/A/Columns/Id", "102", true)
                });
                var updateDataHint1 = new UpdateDataHint(
                    "Tables/C",
                    new List <IdentityPair>()
                {
                    new IdentityPair("Tables/C/Columns/RefA", "Tables/B/Columns/Id", false)
                },
                    new List <Pair <string, object> > {
                    new Pair <string, object>("Tables/C/Columns/RefA", "null")
                });
                var updateDataHint2 = new UpdateDataHint(
                    "Tables/C",
                    new List <IdentityPair> {
                    new IdentityPair("Tables/C/Columns/RefB", "Tables/B/Columns/Id", false)
                },
                    new List <Pair <string, object> > {
                    new Pair <string, object>("Tables/C/Columns/RefB", "null")
                });

                hs.Add(deleteDataHint);
                hs.Add(updateDataHint1);
                hs.Add(updateDataHint2);
            },
                       (diff, actions) => { });
        }