shu/OpenDBDiff
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Stefan Hutter
2021-08-26 20:59:17 +02:00
commit 3afa4c82ef
524 changed files with 52428 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareAssemblies.cs Normal file
View File

@@ -0,0 +1,58 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareAssemblies : CompareBase<Assembly>
{
protected override void DoUpdate<Root>(SchemaList<Assembly, Root> originFields, Assembly node)
{
if (!node.Compare(originFields[node.FullName]))
{
Assembly newNode = (Assembly)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
if (node.Text.Equals(originFields[node.FullName].Text))
{
if (!node.PermissionSet.Equals(originFields[node.FullName].PermissionSet))
newNode.Status += (int)ObjectStatus.PermissionSet;
if (!node.Owner.Equals(originFields[node.FullName].Owner))
newNode.Status += (int)ObjectStatus.ChangeOwner;
}
else
newNode.Status = ObjectStatus.Rebuild;
originFields[node.FullName].Files.ForEach(item =>
{
if (!newNode.Files.Contains(item.FullName))
newNode.Files.Add(new AssemblyFile(newNode, item, ObjectStatus.Drop));
else
item.Status = ObjectStatus.Alter;
});
newNode.Files.ForEach(item =>
{
if (!originFields[node.FullName].Files.Contains(item.FullName))
{
item.Status = ObjectStatus.Create;
}
});
CompareExtendedProperties(originFields[node.FullName], newNode);
originFields[node.FullName] = newNode;
}
}
protected override void DoNew<Root>(SchemaList<Assembly, Root> originFields, Assembly node)
{
bool pass = true;
Assembly newNode = (Assembly)node.Clone(originFields.Parent);
if ((((Database)newNode.RootParent).Info.Version == DatabaseInfo.SQLServerVersion.SQLServer2005)
&& (((Database)node.RootParent).Info.Version == DatabaseInfo.SQLServerVersion.SQLServer2008))
pass = node.FullName.Equals("Microsoft.SqlServer.Types");
if (pass)
{
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
}
}
}

90
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareBase.cs Normal file
View File

@@ -0,0 +1,90 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Generates;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal abstract class CompareBase<T> where T : ISchemaBase
{
protected virtual void DoUpdate<Root>(SchemaList<T, Root> originFields, T node) where Root : ISchemaBase
{
}
protected virtual void DoNew<Root>(SchemaList<T, Root> originFields, T node) where Root : ISchemaBase
{
T newNode = node;//.Clone(originFields.Parent);
newNode.Parent = originFields.Parent;
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
protected void DoDelete(T node)
{
node.Status = ObjectStatus.Drop;
}
public void GenerateDifferences<Root>(SchemaList<T, Root> originFields, SchemaList<T, Root> destinationFields) where Root : ISchemaBase
{
bool has = true;
int destinationIndex = 0;
int originIndex = 0;
int destinationCount = destinationFields.Count;
int originCount = originFields.Count;
T node;
while (has)
{
has = false;
if (destinationCount > destinationIndex)
{
node = destinationFields[destinationIndex];
Generate.RaiseOnCompareProgress("Comparing Destination {0}: [{1}]", node.ObjectType, node.Name);
if (!originFields.Contains(node.FullName))
{
Generate.RaiseOnCompareProgress("Adding {0}: [{1}]", node.ObjectType, node.Name);
DoNew<Root>(originFields, node);
}
else
{
Generate.RaiseOnCompareProgress("Updating {0}: [{1}]", node.ObjectType, node.Name);
DoUpdate<Root>(originFields, node);
}
destinationIndex++;
has = true;
}
if (originCount > originIndex)
{
node = originFields[originIndex];
Generate.RaiseOnCompareProgress("Comparing Source {0}: [{1}]", node.ObjectType, node.Name);
if (!destinationFields.Contains(node.FullName))
{
Generate.RaiseOnCompareProgress("Deleting {0}: [{1}]", node.ObjectType, node.Name);
DoDelete(node);
}
originIndex++;
has = true;
}
}
}
protected static void CompareExtendedProperties(ISQLServerSchemaBase origin, ISQLServerSchemaBase destination)
{
List<ExtendedProperty> dropList = (from node in origin.ExtendedProperties
where !destination.ExtendedProperties.Exists(item => item.Name.Equals(node.Name, StringComparison.CurrentCultureIgnoreCase))
select node).ToList<ExtendedProperty>();
List<ExtendedProperty> addList = (from node in destination.ExtendedProperties
where !origin.ExtendedProperties.Exists(item => item.Name.Equals(node.Name, StringComparison.CurrentCultureIgnoreCase))
select node).ToList<ExtendedProperty>();
dropList.ForEach(item => { item.Status = ObjectStatus.Drop; });
addList.ForEach(item => { item.Status = ObjectStatus.Create; });
origin.ExtendedProperties.AddRange(addList);
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareCLRFunction.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareCLRFunction : CompareBase<CLRFunction>
{
protected override void DoUpdate<Root>(SchemaList<CLRFunction, Root> originFields, CLRFunction node)
{
if (!node.Compare(originFields[node.FullName]))
{
CLRFunction newNode = node; //.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareCLRStoredProcedure.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareCLRStoredProcedure : CompareBase<CLRStoredProcedure>
{
protected override void DoUpdate<Root>(SchemaList<CLRStoredProcedure, Root> originFields, CLRStoredProcedure node)
{
if (!node.Compare(originFields[node.FullName]))
{
CLRStoredProcedure newNode = node; //.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

19
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareCLRTriggers.cs Normal file
View File

@@ -0,0 +1,19 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareCLRTriggers : CompareBase<CLRTrigger>
{
protected override void DoUpdate<Root>(SchemaList<CLRTrigger, Root> originFields, CLRTrigger node)
{
if (!node.Compare(originFields[node.FullName]))
{
CLRTrigger newNode = node;
newNode.Status = ObjectStatus.Alter;
CompareExtendedProperties(newNode, originFields[node.FullName]);
originFields[node.FullName] = newNode;
}
}
}
}

91
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareColumns.cs Normal file
View File

@@ -0,0 +1,91 @@
using System;
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
public class CompareColumns
{
public void GenerateDifferences<T>(Columns<T> originFields, Columns<T> destinationFields) where T : ISchemaBase
{
int restPosition = 0;
int sumPosition = 0;
foreach (Column node in originFields)
{
if (!destinationFields.Contains(node.FullName))
{
node.Status = ObjectStatus.Drop;
restPosition++;
}
else
originFields[node.FullName].Position -= restPosition;
}
foreach (Column node in destinationFields)
{
if (!originFields.Contains(node.FullName))
{
Column newNode = node.Clone(originFields.Parent);
if ((newNode.Position == 1) || ((newNode.DefaultConstraint == null) && (!newNode.IsNullable) && (!newNode.IsComputed) && (!newNode.IsIdentity) && (!newNode.IsIdentityForReplication)))
{
newNode.Status = ObjectStatus.Create;
newNode.Parent.Status = ObjectStatus.Rebuild;
}
else
newNode.Status = ObjectStatus.Create;
sumPosition++;
originFields.Add(newNode);
}
else
{
Column originField = originFields[node.FullName];
/*ColumnConstraint oldDefault = null;
if (originField.DefaultConstraint != null)
oldDefault = originField.DefaultConstraint.Clone(originField);*/
Boolean IsColumnEqual = Column.Compare(originField, node);
if ((!IsColumnEqual) || (originField.Position != node.Position))
{
if (Column.CompareIdentity(originField, node))
{
if (node.HasToRebuildOnlyConstraint)
{
node.Status = ObjectStatus.Alter;
if ((originField.IsNullable) && (!node.IsNullable))
node.Status += (int)ObjectStatus.Update;
}
else
{
if (node.HasToRebuild(originField.Position + sumPosition, originField.Type, originField.IsFileStream))
node.Status = ObjectStatus.Rebuild;
else
{
if (!IsColumnEqual)
{
node.Status = ObjectStatus.Alter;
if ((originField.IsNullable) && (!node.IsNullable))
node.Status += (int)ObjectStatus.Update;
}
}
}
if (node.Status != ObjectStatus.Rebuild)
{
if (!Column.CompareRule(originField, node))
{
node.Status += (int)ObjectStatus.Bind;
}
}
}
else
{
node.Status = ObjectStatus.Rebuild;
}
originFields[node.FullName] = node.Clone(originFields.Parent);
}
originFields[node.FullName].DefaultConstraint = CompareColumnsConstraints.GenerateDifferences(originField, node);
}
}
}
}
}

72
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareColumnsConstraints.cs Normal file
View File

@@ -0,0 +1,72 @@
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareColumnsConstraints : CompareBase<ColumnConstraint>
{
public static ColumnConstraint GenerateDifferences(Column originFields, Column destinationFields)
{
if ((originFields.DefaultConstraint == null) && (destinationFields.DefaultConstraint != null))
{
originFields.DefaultConstraint = destinationFields.DefaultConstraint.Clone(originFields);
originFields.DefaultConstraint.Status = ObjectStatus.Create;
originFields.DefaultConstraint.Parent.Status = ObjectStatus.Original;
originFields.DefaultConstraint.Parent.Parent.Status = ObjectStatus.Alter;
}
else
{
if ((originFields.DefaultConstraint != null) && (destinationFields.DefaultConstraint != null))
{
if (!ColumnConstraint.Compare(originFields.DefaultConstraint, destinationFields.DefaultConstraint))
{
originFields.DefaultConstraint = destinationFields.DefaultConstraint.Clone(originFields);
//Indico que hay un ALTER TABLE, pero sobre la columna, no seteo ningun estado.
originFields.DefaultConstraint.Status = ObjectStatus.Alter;
originFields.DefaultConstraint.Parent.Status = ObjectStatus.Original;
originFields.DefaultConstraint.Parent.Parent.Status = ObjectStatus.Alter;
}
}
else
if ((originFields.DefaultConstraint != null) && (destinationFields.DefaultConstraint == null))
{
originFields.DefaultConstraint.Status = ObjectStatus.Drop;
originFields.DefaultConstraint.Parent.Status = ObjectStatus.Original;
originFields.DefaultConstraint.Parent.Parent.Status = ObjectStatus.Alter;
}
}
/*foreach (ColumnConstraint node in destinationFields)
{
if (!originFields.Exists(node.FullName))
{
node.Status = ObjectStatusType.CreateStatus;
originFields.Parent.Status = ObjectStatusType.OriginalStatus;
originFields.Parent.Parent.Status = ObjectStatusType.AlterStatus;
originFields.Add(node);
}
else
{
if (!ColumnConstraint.Compare(originFields[node.FullName], node))
{
ColumnConstraint newNode = node.Clone(originFields.Parent);
//Indico que hay un ALTER TABLE, pero sobre la columna, no seteo ningun estado.
newNode.Status = ObjectStatusType.AlterStatus;
newNode.Parent.Status = ObjectStatusType.OriginalStatus;
newNode.Parent.Parent.Status = ObjectStatusType.AlterStatus;
originFields[node.FullName] = newNode;
}
}
}
MarkDrop(originFields, destinationFields, node =>
{
node.Status = ObjectStatusType.DropStatus;
originFields.Parent.Status = ObjectStatusType.OriginalStatus;
originFields.Parent.Parent.Status = ObjectStatusType.AlterStatus;
}
);
*/
return originFields.DefaultConstraint;
}
}
}

40
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareConstraints.cs Normal file
View File

@@ -0,0 +1,40 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareConstraints : CompareBase<Constraint>
{
protected override void DoUpdate<Root>(SchemaList<Constraint, Root> originFields, Constraint node)
{
Constraint origin = originFields[node.FullName];
if (!Constraint.Compare(origin, node))
{
Constraint newNode = (Constraint)node.Clone(originFields.Parent);
if (node.IsDisabled == origin.IsDisabled)
{
newNode.Status = ObjectStatus.Alter;
}
else
newNode.Status = ObjectStatus.Alter + (int)ObjectStatus.Disabled;
originFields[node.FullName] = newNode;
}
else
{
if (node.IsDisabled != origin.IsDisabled)
{
Constraint newNode = (Constraint)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Disabled;
originFields[node.FullName] = newNode;
}
}
}
protected override void DoNew<Root>(SchemaList<Constraint, Root> originFields, Constraint node)
{
Constraint newNode = (Constraint)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
}
}

28
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareDDLTriggers.cs Normal file
View File

@@ -0,0 +1,28 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareDDLTriggers : CompareBase<Trigger>
{
protected override void DoUpdate<Root>(SchemaList<Trigger, Root> originFields, Trigger node)
{
if (!node.Compare(originFields[node.FullName]))
{
Trigger newNode = (Trigger)node.Clone(originFields.Parent);
if (!newNode.Text.Equals(originFields[node.FullName].Text))
newNode.Status = ObjectStatus.Alter;
if (node.IsDisabled != originFields[node.FullName].IsDisabled)
newNode.Status = newNode.Status + (int)ObjectStatus.Disabled;
originFields[node.FullName] = newNode;
}
}
protected override void DoNew<Root>(SchemaList<Trigger, Root> originFields, Trigger node)
{
Trigger newNode = (Trigger)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
}
}

54
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareDatabase.cs Normal file
View File

@@ -0,0 +1,54 @@
using OpenDBDiff.Schema.Misc;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
using System;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal static class CompareDatabase
{
/// <summary>
/// Generates the differences to migrate a schema from origin to destination
/// </summary>
/// <param name="origin">The Origin schema is the schema before our generated actions are applied.</param>
/// <param name="destination">The Destination schema is the schema after our actions are applied.</param>
/// <returns></returns>
/// <exception cref="SchemaException"></exception>
public static Database GenerateDifferences(Database origin, Database destination)
{
try
{
Database data = origin;
(new CompareTables()).GenerateDifferences<Database>(origin.Tables, destination.Tables);
(new CompareAssemblies()).GenerateDifferences<Database>(origin.Assemblies, destination.Assemblies);
(new CompareUserDataTypes()).GenerateDifferences<Database>(origin.UserTypes, destination.UserTypes);
(new CompareXMLSchemas()).GenerateDifferences<Database>(origin.XmlSchemas, destination.XmlSchemas);
(new CompareSchemas()).GenerateDifferences<Database>(origin.Schemas, destination.Schemas);
(new CompareFileGroups()).GenerateDifferences<Database>(origin.FileGroups, destination.FileGroups);
(new CompareRules()).GenerateDifferences<Database>(origin.Rules, destination.Rules);
(new CompareDDLTriggers()).GenerateDifferences<Database>(origin.DDLTriggers, destination.DDLTriggers);
(new CompareSynonyms()).GenerateDifferences<Database>(origin.Synonyms, destination.Synonyms);
(new CompareUsers()).GenerateDifferences<Database>(origin.Users, destination.Users);
(new CompareStoredProcedures()).GenerateDifferences<Database>(origin.Procedures, destination.Procedures);
(new CompareCLRStoredProcedure()).GenerateDifferences<Database>(origin.CLRProcedures, destination.CLRProcedures);
(new CompareCLRFunction()).GenerateDifferences<Database>(origin.CLRFunctions, destination.CLRFunctions);
(new CompareViews()).GenerateDifferences<Database>(origin.Views, destination.Views);
(new CompareFunctions()).GenerateDifferences<Database>(origin.Functions, destination.Functions);
(new CompareRoles()).GenerateDifferences<Database>(origin.Roles, destination.Roles);
(new ComparePartitionFunction()).GenerateDifferences<Database>(origin.PartitionFunctions, destination.PartitionFunctions);
(new ComparePartitionSchemes()).GenerateDifferences<Database>(origin.PartitionSchemes, destination.PartitionSchemes);
(new CompareTableType()).GenerateDifferences<Database>(origin.TablesTypes, destination.TablesTypes);
(new CompareFullText()).GenerateDifferences<Database>(origin.FullText, destination.FullText);
data.SourceInfo = destination.Info;
return data;
}
catch (SchemaException)
{
throw;
}
catch (Exception ex)
{
throw new SchemaException(ex.Message, ex);
}
}
}
}

44
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareFileGroups.cs Normal file
View File

@@ -0,0 +1,44 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareFileGroups : CompareBase<FileGroup>
{
protected override void DoNew<Root>(SchemaList<FileGroup, Root> originFields, FileGroup node)
{
FileGroup newNode = (FileGroup)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
/*If the Logical File Name exists in another filegroup,
* we must change the new Logical File Name.
*/
originFields.ForEach(file =>
{
if (file.Status != ObjectStatus.Drop)
{
file.Files.ForEach(group =>
{
newNode.Files.ForEach(ngroup =>
{
if (group.CompareFullNameTo(group.FullName, ngroup.FullName) == 0)
{
newNode.Files[ngroup.FullName].Name = group.Name + "_2";
}
});
});
}
});
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<FileGroup, Root> originFields, FileGroup node)
{
if (!FileGroup.Compare(node, originFields[node.FullName]))
{
FileGroup newNode = (FileGroup)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

23
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareFullText.cs Normal file
View File

@@ -0,0 +1,23 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareFullText : CompareBase<FullText>
{
protected override void DoUpdate<Root>(SchemaList<FullText, Root> originFields, FullText node)
{
if (!node.Compare(originFields[node.FullName]))
{
FullText newNode = node; //.Clone(originFields.Parent);
if (node.IsDefault != originFields[node.FullName].IsDefault)
newNode.Status += (int)ObjectStatus.Disabled;
if (!node.Owner.Equals(originFields[node.FullName].Owner))
newNode.Status += (int)ObjectStatus.ChangeOwner;
if (node.IsAccentSensity != originFields[node.FullName].IsAccentSensity)
newNode.Status += (int)ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

28
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareFullTextIndex.cs Normal file
View File

@@ -0,0 +1,28 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareFullTextIndex : CompareBase<FullTextIndex>
{
protected override void DoNew<Root>(SchemaList<FullTextIndex, Root> originFields, FullTextIndex node)
{
FullTextIndex newNode = (FullTextIndex)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<FullTextIndex, Root> originFields, FullTextIndex node)
{
if (!node.Compare(originFields[node.FullName]))
{
FullTextIndex newNode = (FullTextIndex)node.Clone(originFields.Parent);
if (node.IsDisabled != originFields[node.FullName].IsDisabled)
newNode.Status += (int)ObjectStatus.Disabled;
else
newNode.Status += (int)ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

44
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareFunctions.cs Normal file
View File

@@ -0,0 +1,44 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareFunctions : CompareBase<Function>
{
protected override void DoNew<Root>(SchemaList<Function, Root> originFields, Function node)
{
Function newNode = (Function)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
newNode.DependenciesIn.ForEach(dep =>
{
ISchemaBase item = ((Database)((ISchemaBase)originFields.Parent)).Find(dep);
if (item != null)
{
if (item.IsCodeType)
((ICode)item).DependenciesOut.Add(newNode.FullName);
}
}
);
}
protected override void DoUpdate<Root>(SchemaList<Function, Root> originFields, Function node)
{
if (!node.Compare(originFields[node.FullName]))
{
Function newNode = (Function)node.Clone(originFields.Parent);
newNode.DependenciesIn.AddRange(originFields[node.FullName].DependenciesIn);
newNode.DependenciesOut.AddRange(originFields[node.FullName].DependenciesOut);
newNode.Status = ObjectStatus.Alter;
if (newNode.IsSchemaBinding)
newNode.Status += (int)ObjectStatus.RebuildDependencies;
if (newNode.HasToRebuild)
newNode.Status += (int)ObjectStatus.Rebuild;
else
newNode.Status += (int)ObjectStatus.AlterBody;
originFields[node.FullName] = newNode;
}
}
}
}

30
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareIndexes.cs Normal file
View File

@@ -0,0 +1,30 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareIndexes : CompareBase<Index>
{
protected override void DoNew<Root>(SchemaList<Index, Root> originFields, Index node)
{
Index newNode = (Index)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<Index, Root> originFields, Index node)
{
if (!Index.Compare(node, originFields[node.FullName]))
{
Index newNode = (Index)node.Clone(originFields.Parent);
if (!Index.CompareExceptIsDisabled(node, originFields[node.FullName]))
{
newNode.Status = ObjectStatus.Alter;
}
else
newNode.Status = ObjectStatus.Disabled;
originFields[node.FullName] = newNode;
}
}
}
}

31
OpenDBDiff.Schema.SQLServer.Generates/Compare/ComparePartitionFunction.cs Normal file
View File

@@ -0,0 +1,31 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class ComparePartitionFunction : CompareBase<PartitionFunction>
{
protected override void DoUpdate<Root>(SchemaList<PartitionFunction, Root> originFields, PartitionFunction node)
{
if (!PartitionFunction.Compare(node, originFields[node.FullName]))
{
PartitionFunction newNode = node; //.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Rebuild;
originFields[node.FullName] = newNode;
}
else
{
if (!PartitionFunction.CompareValues(node, originFields[node.FullName]))
{
PartitionFunction newNode = node.Clone(originFields.Parent);
if (newNode.Values.Count == originFields[node.FullName].Values.Count)
newNode.Status = ObjectStatus.Rebuild;
else
newNode.Status = ObjectStatus.Alter;
newNode.Old = originFields[node.FullName].Clone(originFields.Parent);
originFields[node.FullName] = newNode;
}
}
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/ComparePartitionSchemes.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class ComparePartitionSchemes : CompareBase<PartitionScheme>
{
protected override void DoUpdate<Root>(SchemaList<PartitionScheme, Root> originFields, PartitionScheme node)
{
if (!PartitionScheme.Compare(node, originFields[node.FullName]))
{
PartitionScheme newNode = node; //.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Rebuild;
originFields[node.FullName] = newNode;
}
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareRoles.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareRoles : CompareBase<Role>
{
protected override void DoUpdate<Root>(SchemaList<Role, Root> originFields, Role node)
{
if (!node.Compare(originFields[node.FullName]))
{
Role newNode = node;
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

25
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareRules.cs Normal file
View File

@@ -0,0 +1,25 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareRules : CompareBase<Rule>
{
protected override void DoUpdate<Root>(SchemaList<Rule, Root> originFields, Rule node)
{
if (!node.Compare(originFields[node.FullName]))
{
Rule newNode = node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
protected override void DoNew<Root>(SchemaList<Rule, Root> originFields, Rule node)
{
Rule newNode = node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
}
}

7
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareSchemas.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareSchemas : CompareBase<Model.Schema>
{
}
}

27
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareStoredProcedures.cs Normal file
View File

@@ -0,0 +1,27 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareStoredProcedures : CompareBase<StoredProcedure>
{
protected override void DoUpdate<Root>(SchemaList<StoredProcedure, Root> originFields, StoredProcedure node)
{
if (!node.Compare(originFields[node.FullName]))
{
StoredProcedure newNode = node; //.Clone(originFields.Parent);
if (node.CompareExceptWhitespace(originFields[node.FullName]))
{
newNode.Status = ObjectStatus.AlterWhitespace;
}
else
{
newNode.Status = ObjectStatus.Alter;
}
originFields[node.FullName] = newNode;
}
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareSynonyms.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareSynonyms : CompareBase<Synonym>
{
protected override void DoUpdate<Root>(SchemaList<Synonym, Root> originFields, Synonym node)
{
if (!Synonym.Compare(node, originFields[node.FullName]))
{
Synonym newNode = node; //.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

44
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareTableType.cs Normal file
View File

@@ -0,0 +1,44 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareTableType : CompareBase<TableType>
{
protected override void DoUpdate<Root>(SchemaList<TableType, Root> originFields, TableType node)
{
if (node.Status != ObjectStatus.Drop)
{
TableType tablaOriginal = originFields[node.FullName];
(new CompareColumns()).GenerateDifferences<TableType>(tablaOriginal.Columns, node.Columns);
(new CompareConstraints()).GenerateDifferences<TableType>(tablaOriginal.Constraints, node.Constraints);
(new CompareIndexes()).GenerateDifferences<TableType>(tablaOriginal.Indexes, node.Indexes);
}
}
/*public static void GenerateDifferences(SchemaList<TableType, Database> originTables, SchemaList<TableType, Database> destinationTables)
{
MarkDrop(originTables, destinationTables);
foreach (TableType node in destinationTables)
{
if (!originTables.Exists(node.FullName))
{
node.Status = ObjectStatusType.CreateStatus;
node.Parent = originTables.Parent;
originTables.Add(node);
}
else
{
if (node.Status != ObjectStatusType.DropStatus)
{
TableType tablaOriginal = originTables[node.FullName];
CompareColumns.GenerateDifferences<TableType>(tablaOriginal.Columns, node.Columns);
CompareConstraints.GenerateDifferences<TableType>(tablaOriginal.Constraints, node.Constraints);
CompareIndexes.GenerateDifferences(tablaOriginal.Indexes, node.Indexes);
}
}
}
}*/
}
}

92
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareTables.cs Normal file
View File

@@ -0,0 +1,92 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareTables : CompareBase<Table>
{
protected override void DoUpdate<Root>(SchemaList<Table, Root> originFields, Table node)
{
if (node.Status != ObjectStatus.Drop)
{
Table tablaOriginal = originFields[node.FullName];
tablaOriginal.OriginalTable = (Table)originFields[node.FullName].Clone((Database)tablaOriginal.Parent);
(new CompareColumns()).GenerateDifferences<Table>(tablaOriginal.Columns, node.Columns);
(new CompareConstraints()).GenerateDifferences<Table>(tablaOriginal.Constraints, node.Constraints);
(new CompareIndexes()).GenerateDifferences<Table>(tablaOriginal.Indexes, node.Indexes);
(new CompareTablesOptions()).GenerateDifferences<Table>(tablaOriginal.Options, node.Options);
(new CompareTriggers()).GenerateDifferences<Table>(tablaOriginal.Triggers, node.Triggers);
(new CompareCLRTriggers()).GenerateDifferences<Table>(tablaOriginal.CLRTriggers, node.CLRTriggers);
(new CompareFullTextIndex()).GenerateDifferences<Table>(tablaOriginal.FullTextIndex, node.FullTextIndex);
if (!Table.CompareFileGroup(tablaOriginal, node))
{
tablaOriginal.FileGroup = node.FileGroup;
/*Esto solo aplica a las tablas heap, el resto hace el campo en el filegroup del indice clustered*/
if (!tablaOriginal.HasClusteredIndex)
tablaOriginal.Status = ObjectStatus.Rebuild;
}
if (!Table.CompareFileGroupText(tablaOriginal, node))
{
tablaOriginal.FileGroupText = node.FileGroupText;
tablaOriginal.Status = ObjectStatus.Rebuild;
}
if (node.HasChangeTracking != tablaOriginal.HasChangeTracking)
{
tablaOriginal.HasChangeTracking = node.HasChangeTracking;
tablaOriginal.HasChangeTrackingTrackColumn = node.HasChangeTrackingTrackColumn;
tablaOriginal.Status += (int)ObjectStatus.Disabled;
}
}
}
/// <summary>
/// Compara las colecciones de tablas de dos bases diferentes y marca el estado de los objetos
/// dependiendo si existen o si deben borrarse.
/// </summary>
/// <param name="originTables"></param>
/// Tablas originales, donde se guardaran los estados de las tablas.
/// <param name="destinationTables">
/// Tablas comparativas, que se usa para comparar con la base original.
/// </param>
/*public static void GenerateDifferences(SchemaList<Table, Database> originTables, SchemaList<Table, Database> destinationTables)
{
MarkDrop(originTables, destinationTables);
foreach (Table node in destinationTables)
{
if (!originTables.Exists(node.FullName))
{
node.Status = ObjectStatusType.CreateStatus;
node.Parent = originTables.Parent;
originTables.Add(node);
}
else
{
if (node.Status != ObjectStatusType.DropStatus)
{
Table tablaOriginal = originTables[node.FullName];
tablaOriginal.OriginalTable = (Table)originTables[node.FullName].Clone((Database)tablaOriginal.Parent);
CompareColumns.GenerateDifferences<Table>(tablaOriginal.Columns, node.Columns);
CompareConstraints.GenerateDifferences<Table>(tablaOriginal.Constraints, node.Constraints);
CompareIndexes.GenerateDifferences(tablaOriginal.Indexes, node.Indexes);
CompareTablesOptions.GenerateDifferences(tablaOriginal.Options, node.Options);
(new CompareTriggers()).GenerateDifferences<Table>(tablaOriginal.Triggers, node.Triggers);
(new CompareCLRTriggers()).GenerateDifferences<Table>(tablaOriginal.CLRTriggers, node.CLRTriggers);
if (!Table.CompareFileGroup(tablaOriginal, node))
{
tablaOriginal.FileGroup = node.FileGroup;
//Esto solo aplica a las tablas heap, el resto hace el campo en el filegroup del indice clustered
if (!tablaOriginal.HasClusteredIndex)
tablaOriginal.Status = ObjectStatusType.RebuildStatus;
}
if (!Table.CompareFileGroupText(tablaOriginal, node))
{
tablaOriginal.FileGroupText = node.FileGroupText;
tablaOriginal.Status = ObjectStatusType.RebuildStatus;
}
}
}
}
}*/
}
}

25
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareTablesOptions.cs Normal file
View File

@@ -0,0 +1,25 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareTablesOptions : CompareBase<TableOption>
{
protected override void DoNew<Root>(SchemaList<TableOption, Root> originFields, TableOption node)
{
TableOption newNode = (TableOption)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<TableOption, Root> originFields, TableOption node)
{
if (!TableOption.Compare(node, originFields[node.FullName]))
{
TableOption newNode = (TableOption)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}

28
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareTriggers.cs Normal file
View File

@@ -0,0 +1,28 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareTriggers : CompareBase<Trigger>
{
protected override void DoNew<Root>(SchemaList<Trigger, Root> originFields, Trigger node)
{
Trigger newNode = (Trigger)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<Trigger, Root> originFields, Trigger node)
{
if (!node.Compare(originFields[node.FullName]))
{
Trigger newNode = (Trigger)node.Clone(originFields.Parent);
if (!newNode.Text.Equals(originFields[node.FullName].Text))
newNode.Status = ObjectStatus.Alter;
if (node.IsDisabled != originFields[node.FullName].IsDisabled)
newNode.Status = newNode.Status + (int)ObjectStatus.Disabled;
originFields[node.FullName] = newNode;
}
}
}
}

51
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareUserDataTypes.cs Normal file
View File

@@ -0,0 +1,51 @@
using System;
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareUserDataTypes : CompareBase<UserDataType>
{
protected override void DoNew<Root>(SchemaList<UserDataType, Root> originFields, UserDataType node)
{
UserDataType newNode = (UserDataType)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
Boolean HasAssembly = originFields.Exists(item => item.AssemblyFullName.Equals(node.AssemblyFullName) && item.IsAssembly);
if (HasAssembly)
newNode.Status += (int)ObjectStatus.DropOlder;
originFields.Add(newNode);
}
protected override void DoUpdate<Root>(SchemaList<UserDataType, Root> originFields, UserDataType node)
{
if (!node.Compare(originFields[node.FullName]))
{
UserDataType newNode = (UserDataType)node.Clone(originFields.Parent);
newNode.Dependencies.AddRange(originFields[node.FullName].Dependencies);
if (!UserDataType.CompareDefault(node, originFields[node.FullName]))
{
if (!String.IsNullOrEmpty(node.Default.Name))
newNode.Default.Status = ObjectStatus.Create;
else
newNode.Default.Status = ObjectStatus.Drop;
newNode.Status = ObjectStatus.Alter;
}
else
{
if (!UserDataType.CompareRule(node, originFields[node.FullName]))
{
if (!String.IsNullOrEmpty(node.Rule.Name))
newNode.Rule.Status = ObjectStatus.Create;
else
newNode.Rule.Status = ObjectStatus.Drop;
newNode.Status = ObjectStatus.Alter;
}
else
newNode.Status = ObjectStatus.Rebuild;
}
originFields[node.FullName] = newNode;
}
}
}
}

8
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareUsers.cs Normal file
View File

@@ -0,0 +1,8 @@
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareUsers : CompareBase<User>
{
}
}

52
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareViews.cs Normal file
View File

@@ -0,0 +1,52 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareViews : CompareBase<View>
{
protected override void DoUpdate<Root>(SchemaList<View, Root> originFields, View node)
{
View original = originFields[node.FullName];
if (!node.Compare(original))
{
View newNode = (View)node.Clone(originFields.Parent);
newNode.DependenciesOut.AddRange(original.DependenciesOut);
newNode.DependenciesIn.AddRange(original.DependenciesIn);
newNode.Status = ObjectStatus.Alter;
newNode.Indexes = original.Indexes;
newNode.Triggers = original.Triggers;
if (newNode.IsSchemaBinding)
newNode.Status += (int)ObjectStatus.RebuildDependencies;
if (newNode.HasToRebuild)
newNode.Status += (int)ObjectStatus.Rebuild;
else
newNode.Status += (int)ObjectStatus.AlterBody;
originFields[node.FullName] = newNode;
original = newNode;
}
(new CompareIndexes()).GenerateDifferences<View>(original.Indexes, node.Indexes);
(new CompareTriggers()).GenerateDifferences<View>(original.Triggers, node.Triggers);
}
protected override void DoNew<Root>(SchemaList<View, Root> originFields, View node)
{
View newNode = (View)node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Create;
originFields.Add(newNode);
newNode.DependenciesIn.ForEach(dep =>
{
ISchemaBase item = ((Database)((ISchemaBase)originFields.Parent)).Find(dep);
if (item != null)
{
if (item.IsCodeType)
((ICode)item).DependenciesOut.Add(newNode.FullName);
}
}
);
}
}
}

18
OpenDBDiff.Schema.SQLServer.Generates/Compare/CompareXMLSchemas.cs Normal file
View File

@@ -0,0 +1,18 @@
using OpenDBDiff.Schema.Model;
using OpenDBDiff.Schema.SQLServer.Generates.Model;
namespace OpenDBDiff.Schema.SQLServer.Generates.Compare
{
internal class CompareXMLSchemas : CompareBase<XMLSchema>
{
protected override void DoUpdate<Root>(SchemaList<XMLSchema, Root> originFields, XMLSchema node)
{
if (!node.Compare(originFields[node.FullName]))
{
XMLSchema newNode = node.Clone(originFields.Parent);
newNode.Status = ObjectStatus.Alter;
originFields[node.FullName] = newNode;
}
}
}
}