protected bool GetStreamsDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IList<string> streams1List = db1.ExecuteStringQuery("SELECT `Name` FROM `_Streams`");
IList<string> streams2List = db2.ExecuteStringQuery("SELECT `Name` FROM `_Streams`");
string[] streams1 = new string[streams1List.Count];
string[] streams2 = new string[streams2List.Count];
streams1List.CopyTo(streams1, 0);
streams2List.CopyTo(streams2, 0);
IComparer caseInsComp = CaseInsensitiveComparer.Default;
Array.Sort(streams1, caseInsComp);
Array.Sort(streams2, caseInsComp);
for (int i1 = 0, i2 = 0; i1 < streams1.Length || i2 < streams2.Length; )
{
int comp;
if (i1 == streams1.Length)
{
comp = 1;
}
else if (i2 == streams2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(streams1[i1], streams2[i2]);
}
if(comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, streams1[i1]);
i1++;
difference = true;
}
else if(comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, streams2[i2]);
i2++;
difference = true;
}
else
{
if(streams1[i1] != ("" + ((char)5) + "SummaryInformation"))
{
string tempFile1 = Path.GetTempFileName();
string tempFile2 = Path.GetTempFileName();
using (View view = db1.OpenView(String.Format("SELECT `Data` FROM `_Streams` WHERE `Name` = '{0}'", streams1[i1])))
{
view.Execute();
using (Record rec = view.Fetch())
{
rec.GetStream(1, tempFile1);
}
}
using (View view = db2.OpenView(String.Format("SELECT `Data` FROM `_Streams` WHERE `Name` = '{0}'", streams2[i2])))
{
view.Execute();
using (Record rec = view.Fetch())
{
rec.GetStream(1, tempFile2);
}
}
IDiffEngine diffEngine = diffFactory.GetDiffEngine(tempFile1, tempFile2, options);
StringWriter sw = new StringWriter();
if(diffEngine.GetDiff(tempFile1, tempFile2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, streams1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
File.Delete(tempFile1);
File.Delete(tempFile2);
}
i1++;
i2++;
}
}
return difference;
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
try
{
bool difference = false;
ProcessStartInfo psi = new ProcessStartInfo("diff.exe");
psi.Arguments = String.Format("\"{0}\" \"{1}\"", diffInput1, diffInput2);
psi.WorkingDirectory = null;
psi.UseShellExecute = false;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.RedirectStandardOutput = true;
Process proc = Process.Start(psi);
string line;
while((line = proc.StandardOutput.ReadLine()) != null)
{
diffOutput.WriteLine("{0}{1}", linePrefix, line);
difference = true;
}
proc.WaitForExit();
return difference;
}
catch(System.ComponentModel.Win32Exception) // If diff.exe is not found, just compare the bytes
{
return new FileDiffEngine().GetDiff(diffInput1, diffInput2, options, diffOutput, linePrefix, diffFactory);
}
}
protected bool GetSummaryInfoDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
SummaryInfo summInfo1 = db1.SummaryInfo;
SummaryInfo summInfo2 = db2.SummaryInfo;
if(summInfo1.Title != summInfo2.Title ) { diffOutput.WriteLine("{0}SummaryInformation.Title {{{1}}}->{{{2}}}", linePrefix, summInfo1.Title, summInfo2.Title); difference = true; }
if(summInfo1.Subject != summInfo2.Subject ) { diffOutput.WriteLine("{0}SummaryInformation.Subject {{{1}}}->{{{2}}}", linePrefix, summInfo1.Subject, summInfo2.Subject); difference = true; }
if(summInfo1.Author != summInfo2.Author ) { diffOutput.WriteLine("{0}SummaryInformation.Author {{{1}}}->{{{2}}}", linePrefix, summInfo1.Author, summInfo2.Author); difference = true; }
if(summInfo1.Keywords != summInfo2.Keywords ) { diffOutput.WriteLine("{0}SummaryInformation.Keywords {{{1}}}->{{{2}}}", linePrefix, summInfo1.Keywords, summInfo2.Keywords); difference = true; }
if(summInfo1.Comments != summInfo2.Comments ) { diffOutput.WriteLine("{0}SummaryInformation.Comments {{{1}}}->{{{2}}}", linePrefix, summInfo1.Comments, summInfo2.Comments); difference = true; }
if(summInfo1.Template != summInfo2.Template ) { diffOutput.WriteLine("{0}SummaryInformation.Template {{{1}}}->{{{2}}}", linePrefix, summInfo1.Template, summInfo2.Template); difference = true; }
if(summInfo1.LastSavedBy != summInfo2.LastSavedBy ) { diffOutput.WriteLine("{0}SummaryInformation.LastSavedBy {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastSavedBy, summInfo2.LastSavedBy); difference = true; }
if(summInfo1.RevisionNumber != summInfo2.RevisionNumber) { diffOutput.WriteLine("{0}SummaryInformation.RevisionNumber {{{1}}}->{{{2}}}", linePrefix, summInfo1.RevisionNumber, summInfo2.RevisionNumber); difference = true; }
if(summInfo1.CreatingApp != summInfo2.CreatingApp ) { diffOutput.WriteLine("{0}SummaryInformation.CreatingApp {{{1}}}->{{{2}}}", linePrefix, summInfo1.CreatingApp, summInfo2.CreatingApp); difference = true; }
if(summInfo1.LastPrintTime != summInfo2.LastPrintTime ) { diffOutput.WriteLine("{0}SummaryInformation.LastPrintTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastPrintTime, summInfo2.LastPrintTime); difference = true; }
if(summInfo1.CreateTime != summInfo2.CreateTime ) { diffOutput.WriteLine("{0}SummaryInformation.CreateTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.CreateTime, summInfo2.CreateTime); difference = true; }
if(summInfo1.LastSaveTime != summInfo2.LastSaveTime ) { diffOutput.WriteLine("{0}SummaryInformation.LastSaveTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastSaveTime, summInfo2.LastSaveTime); difference = true; }
if(summInfo1.CodePage != summInfo2.CodePage ) { diffOutput.WriteLine("{0}SummaryInformation.Codepage {{{1}}}->{{{2}}}", linePrefix, summInfo1.CodePage, summInfo2.CodePage); difference = true; }
if(summInfo1.PageCount != summInfo2.PageCount ) { diffOutput.WriteLine("{0}SummaryInformation.PageCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.PageCount, summInfo2.PageCount); difference = true; }
if(summInfo1.WordCount != summInfo2.WordCount ) { diffOutput.WriteLine("{0}SummaryInformation.WordCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.WordCount, summInfo2.WordCount); difference = true; }
if(summInfo1.CharacterCount != summInfo2.CharacterCount) { diffOutput.WriteLine("{0}SummaryInformation.CharacterCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.CharacterCount, summInfo2.CharacterCount); difference = true; }
if(summInfo1.Security != summInfo2.Security ) { diffOutput.WriteLine("{0}SummaryInformation.Security {{{1}}}->{{{2}}}", linePrefix, summInfo1.Security, summInfo2.Security); difference = true; }
summInfo1.Close();
summInfo2.Close();
return difference;
}
public virtual float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2))
{
return .10f;
}
else
{
return 0;
}
}
public float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsVersionedFile(diffInput1) || IsVersionedFile(diffInput2)))
{
return .20f;
}
else
{
return 0;
}
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
string ver1 = Installer.GetFileVersion(diffInput1);
string ver2 = Installer.GetFileVersion(diffInput2);
if(ver1 != ver2)
{
diffOutput.WriteLine("{0}File version: {1} -> {2}", linePrefix, ver1, ver2);
difference = true;
}
else
{
FileStream stream1 = new FileStream(diffInput1, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream stream2 = new FileStream(diffInput2, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buf1 = new byte[512];
byte[] buf2 = new byte[512];
while(!difference)
{
int count1 = stream1.Read(buf1, 0, buf1.Length);
int count2 = stream2.Read(buf2, 0, buf2.Length);
for(int i = 0; i < count1; i++)
{
if(i == count2 || buf1[i] != buf2[i])
{
difference = true;
break;
}
}
if(count1 < buf1.Length) // EOF
{
break;
}
}
stream1.Close();
stream2.Close();
if(difference)
{
diffOutput.WriteLine("{0}File versions match but bits differ.", linePrefix);
}
}
return difference;
}
public virtual bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
Database db1 = new Database(diffInput1, DatabaseOpenMode.ReadOnly);
Database db2 = new Database(diffInput2, DatabaseOpenMode.ReadOnly);
if(GetSummaryInfoDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
if(GetDatabaseDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
if(GetStreamsDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
db1.Close();
db2.Close();
return difference;
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
FileInfo file1 = new FileInfo(diffInput1);
FileInfo file2 = new FileInfo(diffInput2);
if(file1.Length != file2.Length)
{
diffOutput.WriteLine("{0}File size: {1} -> {2}", linePrefix, file1.Length, file2.Length);
difference = true;
}
else
{
FileStream stream1 = file1.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream stream2 = file2.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buf1 = new byte[512];
byte[] buf2 = new byte[512];
while(!difference)
{
int count1 = stream1.Read(buf1, 0, buf1.Length);
int count2 = stream2.Read(buf2, 0, buf2.Length);
for(int i = 0; i < count1; i++)
{
if(i == count2 || buf1[i] != buf2[i])
{
difference = true;
break;
}
}
if(count1 < buf1.Length) // EOF
{
break;
}
}
stream1.Close();
stream2.Close();
if(difference)
{
diffOutput.WriteLine("{0}Files differ.", linePrefix);
}
}
return difference;
}
protected bool GetDatabaseDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
string tempFile = Path.GetTempFileName();
if(db2.GenerateTransform(db1, tempFile))
{
difference = true;
Database db = db1;
db.ViewTransform(tempFile);
string row, column, change;
using (View view = db.OpenView("SELECT `Table`, `Column`, `Row`, `Data`, `Current` " +
"FROM `_TransformView` ORDER BY `Table`, `Row`"))
{
view.Execute();
foreach (Record rec in view) using (rec)
{
column = String.Format("{0} {1}", rec[1], rec[2]);
change = "";
if (rec.IsNull(3))
{
row = "<DDL>";
if (!rec.IsNull(4))
{
change = "[" + rec[5] + "]: " + DecodeColDef(rec.GetInteger(4));
}
}
else
{
row = "[" + String.Join(",", rec.GetString(3).Split('\t')) + "]";
if (rec.GetString(2) != "INSERT" && rec.GetString(2) != "DELETE")
{
column = String.Format("{0}.{1}", rec[1], rec[2]);
change = "{" + rec[5] + "}->{" + rec[4] + "}";
}
}
diffOutput.WriteLine("{0}{1,-25} {2} {3}", linePrefix, column, row, change);
}
}
}
File.Delete(tempFile);
return difference;
}
public virtual float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsMsiDatabase(diffInput1) || IsMsiDatabase(diffInput2)))
{
return .70f;
}
else if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsMspPatch(diffInput1) || IsMspPatch(diffInput2)))
{
return .60f;
}
else
{
return 0;
}
}
public override float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
GetPatchTargetOption(options) != null &&
(IsMspPatch(diffInput1) && IsMspPatch(diffInput2)))
{
return .80f;
}
else if(diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
GetPatchTargetOption(options) == null &&
(IsMspPatch(diffInput1) && IsMsiDatabase(diffInput2)) ||
(IsMsiDatabase(diffInput1) && IsMspPatch(diffInput2)))
{
return .75f;
}
else
{
return 0;
}
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
try
{
bool difference = false;
ProcessStartInfo psi = new ProcessStartInfo("diff.exe");
psi.Arguments = String.Format("\"{0}\" \"{1}\"", diffInput1, diffInput2);
psi.WorkingDirectory = null;
psi.UseShellExecute = false;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.RedirectStandardOutput = true;
Process proc = Process.Start(psi);
string line;
while ((line = proc.StandardOutput.ReadLine()) != null)
{
diffOutput.WriteLine("{0}{1}", linePrefix, line);
difference = true;
}
proc.WaitForExit();
return(difference);
}
catch (System.ComponentModel.Win32Exception) // If diff.exe is not found, just compare the bytes
{
return(new FileDiffEngine().GetDiff(diffInput1, diffInput2, options, diffOutput, linePrefix, diffFactory));
}
}
public float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if (diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsTextFile(diffInput1) && IsTextFile(diffInput2)))
{
return(.70f);
}
else
{
return(0);
}
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IComparer caseInsComp = CaseInsensitiveComparer.Default;
string[] files1 = Directory.GetFiles(diffInput1);
string[] files2 = Directory.GetFiles(diffInput2);
for(int i1 = 0; i1 < files1.Length; i1++)
{
files1[i1] = Path.GetFileName(files1[i1]);
}
for(int i2 = 0; i2 < files2.Length; i2++)
{
files2[i2] = Path.GetFileName(files2[i2]);
}
Array.Sort(files1, caseInsComp);
Array.Sort(files2, caseInsComp);
for(int i1 = 0, i2 = 0; i1 < files1.Length || i2 < files2.Length; )
{
int comp;
if(i1 == files1.Length)
{
comp = 1;
}
else if(i2 == files2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(files1[i1], files2[i2]);
}
if(comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, files1[i1]);
i1++;
difference = true;
}
else if(comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, files2[i2]);
i2++;
difference = true;
}
else
{
string file1 = Path.Combine(diffInput1, files1[i1]);
string file2 = Path.Combine(diffInput2, files2[i2]);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(file1, file2, options);
StringWriter sw = new StringWriter();
if(diffEngine.GetDiff(file1, file2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, files1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
i1++;
i2++;
}
}
string[] dirs1 = Directory.GetDirectories(diffInput1);
string[] dirs2 = Directory.GetDirectories(diffInput2);
for(int i1 = 0; i1 < dirs1.Length; i1++)
{
dirs1[i1] = Path.GetFileName(dirs1[i1]);
}
for(int i2 = 0; i2 < dirs2.Length; i2++)
{
dirs2[i2] = Path.GetFileName(dirs2[i2]);
}
Array.Sort(dirs1, caseInsComp);
Array.Sort(dirs2, caseInsComp);
for(int i1 = 0, i2 = 0; i1 < dirs1.Length || i2 < dirs2.Length; )
{
int comp;
if(i1 == dirs1.Length)
{
comp = 1;
}
else if(i2 == dirs2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(dirs1[i1], dirs2[i2]);
}
if(comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, dirs1[i1]);
i1++;
difference = true;
}
else if(comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, dirs2[i2]);
i2++;
difference = true;
}
else
{
string dir1 = Path.Combine(diffInput1, dirs1[i1]);
string dir2 = Path.Combine(diffInput2, dirs2[i2]);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(dir1, dir2, options);
StringWriter sw = new StringWriter();
if(diffEngine.GetDiff(dir1, dir2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}\\", linePrefix, dirs1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
i1++;
i2++;
}
}
return difference;
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
FileInfo file1 = new FileInfo(diffInput1);
FileInfo file2 = new FileInfo(diffInput2);
if (file1.Length != file2.Length)
{
diffOutput.WriteLine("{0}File size: {1} -> {2}", linePrefix, file1.Length, file2.Length);
difference = true;
}
else
{
FileStream stream1 = file1.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream stream2 = file2.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buf1 = new byte[512];
byte[] buf2 = new byte[512];
while (!difference)
{
int count1 = stream1.Read(buf1, 0, buf1.Length);
int count2 = stream2.Read(buf2, 0, buf2.Length);
for (int i = 0; i < count1; i++)
{
if (i == count2 || buf1[i] != buf2[i])
{
difference = true;
break;
}
}
if (count1 < buf1.Length) // EOF
{
break;
}
}
stream1.Close();
stream2.Close();
if (difference)
{
diffOutput.WriteLine("{0}Files differ.", linePrefix);
}
}
return(difference);
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IComparer caseInsComp = CaseInsensitiveComparer.Default;
string[] files1 = Directory.GetFiles(diffInput1);
string[] files2 = Directory.GetFiles(diffInput2);
for (int i1 = 0; i1 < files1.Length; i1++)
{
files1[i1] = Path.GetFileName(files1[i1]);
}
for (int i2 = 0; i2 < files2.Length; i2++)
{
files2[i2] = Path.GetFileName(files2[i2]);
}
Array.Sort(files1, caseInsComp);
Array.Sort(files2, caseInsComp);
for (int i1 = 0, i2 = 0; i1 < files1.Length || i2 < files2.Length;)
{
int comp;
if (i1 == files1.Length)
{
comp = 1;
}
else if (i2 == files2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(files1[i1], files2[i2]);
}
if (comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, files1[i1]);
i1++;
difference = true;
}
else if (comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, files2[i2]);
i2++;
difference = true;
}
else
{
string file1 = Path.Combine(diffInput1, files1[i1]);
string file2 = Path.Combine(diffInput2, files2[i2]);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(file1, file2, options);
StringWriter sw = new StringWriter();
if (diffEngine.GetDiff(file1, file2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, files1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
i1++;
i2++;
}
}
string[] dirs1 = Directory.GetDirectories(diffInput1);
string[] dirs2 = Directory.GetDirectories(diffInput2);
for (int i1 = 0; i1 < dirs1.Length; i1++)
{
dirs1[i1] = Path.GetFileName(dirs1[i1]);
}
for (int i2 = 0; i2 < dirs2.Length; i2++)
{
dirs2[i2] = Path.GetFileName(dirs2[i2]);
}
Array.Sort(dirs1, caseInsComp);
Array.Sort(dirs2, caseInsComp);
for (int i1 = 0, i2 = 0; i1 < dirs1.Length || i2 < dirs2.Length;)
{
int comp;
if (i1 == dirs1.Length)
{
comp = 1;
}
else if (i2 == dirs2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(dirs1[i1], dirs2[i2]);
}
if (comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, dirs1[i1]);
i1++;
difference = true;
}
else if (comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, dirs2[i2]);
i2++;
difference = true;
}
else
{
string dir1 = Path.Combine(diffInput1, dirs1[i1]);
string dir2 = Path.Combine(diffInput2, dirs2[i2]);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(dir1, dir2, options);
StringWriter sw = new StringWriter();
if (diffEngine.GetDiff(dir1, dir2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}\\", linePrefix, dirs1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
i1++;
i2++;
}
}
return(difference);
}
public virtual float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if (diffInput1 != null && Directory.Exists(diffInput1) &&
diffInput2 != null && Directory.Exists(diffInput2))
{
return(.70f);
}
else
{
return(0);
}
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
string ver1 = Installer.GetFileVersion(diffInput1);
string ver2 = Installer.GetFileVersion(diffInput2);
if (ver1 != ver2)
{
diffOutput.WriteLine("{0}File version: {1} -> {2}", linePrefix, ver1, ver2);
difference = true;
}
else
{
FileStream stream1 = new FileStream(diffInput1, FileMode.Open, FileAccess.Read, FileShare.Read);
FileStream stream2 = new FileStream(diffInput2, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buf1 = new byte[512];
byte[] buf2 = new byte[512];
while (!difference)
{
int count1 = stream1.Read(buf1, 0, buf1.Length);
int count2 = stream2.Read(buf2, 0, buf2.Length);
for (int i = 0; i < count1; i++)
{
if (i == count2 || buf1[i] != buf2[i])
{
difference = true;
break;
}
}
if (count1 < buf1.Length) // EOF
{
break;
}
}
stream1.Close();
stream2.Close();
if (difference)
{
diffOutput.WriteLine("{0}File versions match but bits differ.", linePrefix);
}
}
return(difference);
}
protected bool GetStreamsDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IList <string> streams1List = db1.ExecuteStringQuery("SELECT `Name` FROM `_Streams`");
IList <string> streams2List = db2.ExecuteStringQuery("SELECT `Name` FROM `_Streams`");
string[] streams1 = new string[streams1List.Count];
string[] streams2 = new string[streams2List.Count];
streams1List.CopyTo(streams1, 0);
streams2List.CopyTo(streams2, 0);
IComparer caseInsComp = CaseInsensitiveComparer.Default;
Array.Sort(streams1, caseInsComp);
Array.Sort(streams2, caseInsComp);
for (int i1 = 0, i2 = 0; i1 < streams1.Length || i2 < streams2.Length;)
{
int comp;
if (i1 == streams1.Length)
{
comp = 1;
}
else if (i2 == streams2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(streams1[i1], streams2[i2]);
}
if (comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, streams1[i1]);
i1++;
difference = true;
}
else if (comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, streams2[i2]);
i2++;
difference = true;
}
else
{
if (streams1[i1] != ("" + ((char)5) + "SummaryInformation"))
{
string tempFile1 = Path.GetTempFileName();
string tempFile2 = Path.GetTempFileName();
using (View view = db1.OpenView(String.Format("SELECT `Data` FROM `_Streams` WHERE `Name` = '{0}'", streams1[i1])))
{
view.Execute();
using (Record rec = view.Fetch())
{
rec.GetStream(1, tempFile1);
}
}
using (View view = db2.OpenView(String.Format("SELECT `Data` FROM `_Streams` WHERE `Name` = '{0}'", streams2[i2])))
{
view.Execute();
using (Record rec = view.Fetch())
{
rec.GetStream(1, tempFile2);
}
}
IDiffEngine diffEngine = diffFactory.GetDiffEngine(tempFile1, tempFile2, options);
StringWriter sw = new StringWriter();
if (diffEngine.GetDiff(tempFile1, tempFile2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, streams1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
File.Delete(tempFile1);
File.Delete(tempFile2);
}
i1++;
i2++;
}
}
return(difference);
}
protected bool GetDatabaseDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
string tempFile = Path.GetTempFileName();
if (db2.GenerateTransform(db1, tempFile))
{
difference = true;
Database db = db1;
db.ViewTransform(tempFile);
string row, column, change;
using (View view = db.OpenView("SELECT `Table`, `Column`, `Row`, `Data`, `Current` " +
"FROM `_TransformView` ORDER BY `Table`, `Row`"))
{
view.Execute();
foreach (Record rec in view)
{
using (rec)
{
column = String.Format("{0} {1}", rec[1], rec[2]);
change = "";
if (rec.IsNull(3))
{
row = "<DDL>";
if (!rec.IsNull(4))
{
change = "[" + rec[5] + "]: " + DecodeColDef(rec.GetInteger(4));
}
}
else
{
row = "[" + String.Join(",", rec.GetString(3).Split('\t')) + "]";
if (rec.GetString(2) != "INSERT" && rec.GetString(2) != "DELETE")
{
column = String.Format("{0}.{1}", rec[1], rec[2]);
change = "{" + rec[5] + "}->{" + rec[4] + "}";
}
}
diffOutput.WriteLine("{0}{1,-25} {2} {3}", linePrefix, column, row, change);
}
}
}
}
File.Delete(tempFile);
return(difference);
}
public override float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if (diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
GetPatchTargetOption(options) != null &&
(IsMspPatch(diffInput1) && IsMspPatch(diffInput2)))
{
return(.80f);
}
else if (diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
GetPatchTargetOption(options) == null &&
(IsMspPatch(diffInput1) && IsMsiDatabase(diffInput2)) ||
(IsMsiDatabase(diffInput1) && IsMspPatch(diffInput2)))
{
return(.75f);
}
else
{
return(0);
}
}
public virtual bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
Database db1 = new Database(diffInput1, DatabaseOpenMode.ReadOnly);
Database db2 = new Database(diffInput2, DatabaseOpenMode.ReadOnly);
if (GetSummaryInfoDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
if (GetDatabaseDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
if (GetStreamsDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
db1.Close();
db2.Close();
return(difference);
}
public virtual float GetDiffQuality(string diffInput1, string diffInput2, string[] options, IDiffEngineFactory diffFactory)
{
if (diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsMsiDatabase(diffInput1) || IsMsiDatabase(diffInput2)))
{
return(.70f);
}
else if (diffInput1 != null && File.Exists(diffInput1) &&
diffInput2 != null && File.Exists(diffInput2) &&
(IsMspPatch(diffInput1) || IsMspPatch(diffInput2)))
{
return(.60f);
}
else
{
return(0);
}
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IComparer caseInsComp = CaseInsensitiveComparer.Default;
// TODO: Make this faster by extracting the whole cab at once.
// TODO: Optimize for the match case by first comparing the whole cab files.
CabInfo cab1 = new CabInfo(diffInput1);
CabInfo cab2 = new CabInfo(diffInput2);
IList <CabFileInfo> cabFilesList1 = cab1.GetFiles();
IList <CabFileInfo> cabFilesList2 = cab2.GetFiles();
CabFileInfo[] cabFiles1 = new CabFileInfo[cabFilesList1.Count];
CabFileInfo[] cabFiles2 = new CabFileInfo[cabFilesList2.Count];
cabFilesList1.CopyTo(cabFiles1, 0);
cabFilesList2.CopyTo(cabFiles2, 0);
string[] files1 = new string[cabFiles1.Length];
string[] files2 = new string[cabFiles2.Length];
for (int i1 = 0; i1 < cabFiles1.Length; i1++)
{
files1[i1] = cabFiles1[i1].Name;
}
for (int i2 = 0; i2 < cabFiles2.Length; i2++)
{
files2[i2] = cabFiles2[i2].Name;
}
Array.Sort(files1, cabFiles1, caseInsComp);
Array.Sort(files2, cabFiles2, caseInsComp);
for (int i1 = 0, i2 = 0; i1 < files1.Length || i2 < files2.Length;)
{
int comp;
if (i1 == files1.Length)
{
comp = 1;
}
else if (i2 == files2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(files1[i1], files2[i2]);
}
if (comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, files1[i1]);
i1++;
difference = true;
}
else if (comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, files2[i2]);
i2++;
difference = true;
}
else
{
string tempFile1 = Path.GetTempFileName();
string tempFile2 = Path.GetTempFileName();
cabFiles1[i1].CopyTo(tempFile1, true);
cabFiles2[i2].CopyTo(tempFile2, true);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(tempFile1, tempFile2, options);
StringWriter sw = new StringWriter();
if (diffEngine.GetDiff(tempFile1, tempFile2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, files1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
File.SetAttributes(tempFile1, File.GetAttributes(tempFile1) & ~FileAttributes.ReadOnly);
File.SetAttributes(tempFile2, File.GetAttributes(tempFile2) & ~FileAttributes.ReadOnly);
try
{
File.Delete(tempFile1);
File.Delete(tempFile2);
}
catch (IOException)
{
#if DEBUG
Console.WriteLine("Could not delete temporary files {0} and {1}", tempFile1, tempFile2);
#endif
}
i1++;
i2++;
}
}
return(difference);
}
public override bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
InstallPackage db1, db2;
if(IsMspPatch(diffInput1))
{
string patchTargetDbFile = GetPatchTargetOption(options);
if(patchTargetDbFile == null) patchTargetDbFile = diffInput2;
string tempPatchedDbFile = Path.GetTempFileName();
File.Copy(patchTargetDbFile, tempPatchedDbFile, true);
File.SetAttributes(tempPatchedDbFile, File.GetAttributes(tempPatchedDbFile) & ~System.IO.FileAttributes.ReadOnly);
db1 = new InstallPackage(tempPatchedDbFile, DatabaseOpenMode.Direct);
db1.ApplyPatch(new PatchPackage(diffInput1), null);
db1.Commit();
}
else
{
db1 = new InstallPackage(diffInput1, DatabaseOpenMode.ReadOnly);
}
if(IsMspPatch(diffInput2))
{
string patchTargetDbFile = GetPatchTargetOption(options);
if(patchTargetDbFile == null) patchTargetDbFile = diffInput1;
string tempPatchedDbFile = Path.GetTempFileName();
File.Copy(patchTargetDbFile, tempPatchedDbFile, true);
File.SetAttributes(tempPatchedDbFile, File.GetAttributes(tempPatchedDbFile) & ~System.IO.FileAttributes.ReadOnly);
db2 = new InstallPackage(tempPatchedDbFile, DatabaseOpenMode.Direct);
db2.ApplyPatch(new PatchPackage(diffInput2), null);
db2.Commit();
}
else
{
db2 = new InstallPackage(diffInput2, DatabaseOpenMode.ReadOnly);
}
if(GetSummaryInfoDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
if(GetDatabaseDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
if(GetStreamsDiff(db1, db2, options, diffOutput, linePrefix, diffFactory)) difference = true;
db1.Close();
db2.Close();
try
{
if(IsMspPatch(diffInput1)) File.Delete(db1.FilePath);
if(IsMspPatch(diffInput1)) File.Delete(db2.FilePath);
}
catch(IOException)
{
#if DEBUG
Console.WriteLine("Could not delete temporary files {0} and {1}", db1.FilePath, db2.FilePath);
#endif
}
if(IsMspPatch(diffInput1) && IsMspPatch(diffInput2))
{
Database dbp1 = new Database(diffInput1, DatabaseOpenMode.ReadOnly);
Database dbp2 = new Database(diffInput2, DatabaseOpenMode.ReadOnly);
if(GetStreamsDiff(dbp1, dbp2, options, diffOutput, linePrefix, diffFactory)) difference = true;
dbp1.Close();
dbp2.Close();
}
return difference;
}
public override bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
InstallPackage db1, db2;
if (IsMspPatch(diffInput1))
{
string patchTargetDbFile = GetPatchTargetOption(options);
if (patchTargetDbFile == null)
{
patchTargetDbFile = diffInput2;
}
string tempPatchedDbFile = Path.GetTempFileName();
File.Copy(patchTargetDbFile, tempPatchedDbFile, true);
File.SetAttributes(tempPatchedDbFile, File.GetAttributes(tempPatchedDbFile) & ~System.IO.FileAttributes.ReadOnly);
db1 = new InstallPackage(tempPatchedDbFile, DatabaseOpenMode.Direct);
db1.ApplyPatch(new PatchPackage(diffInput1), null);
db1.Commit();
}
else
{
db1 = new InstallPackage(diffInput1, DatabaseOpenMode.ReadOnly);
}
if (IsMspPatch(diffInput2))
{
string patchTargetDbFile = GetPatchTargetOption(options);
if (patchTargetDbFile == null)
{
patchTargetDbFile = diffInput1;
}
string tempPatchedDbFile = Path.GetTempFileName();
File.Copy(patchTargetDbFile, tempPatchedDbFile, true);
File.SetAttributes(tempPatchedDbFile, File.GetAttributes(tempPatchedDbFile) & ~System.IO.FileAttributes.ReadOnly);
db2 = new InstallPackage(tempPatchedDbFile, DatabaseOpenMode.Direct);
db2.ApplyPatch(new PatchPackage(diffInput2), null);
db2.Commit();
}
else
{
db2 = new InstallPackage(diffInput2, DatabaseOpenMode.ReadOnly);
}
if (GetSummaryInfoDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
if (GetDatabaseDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
if (GetStreamsDiff(db1, db2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
db1.Close();
db2.Close();
try
{
if (IsMspPatch(diffInput1))
{
File.Delete(db1.FilePath);
}
if (IsMspPatch(diffInput1))
{
File.Delete(db2.FilePath);
}
}
catch (IOException)
{
#if DEBUG
Console.WriteLine("Could not delete temporary files {0} and {1}", db1.FilePath, db2.FilePath);
#endif
}
if (IsMspPatch(diffInput1) && IsMspPatch(diffInput2))
{
Database dbp1 = new Database(diffInput1, DatabaseOpenMode.ReadOnly);
Database dbp2 = new Database(diffInput2, DatabaseOpenMode.ReadOnly);
if (GetStreamsDiff(dbp1, dbp2, options, diffOutput, linePrefix, diffFactory))
{
difference = true;
}
dbp1.Close();
dbp2.Close();
}
return(difference);
}
public bool GetDiff(string diffInput1, string diffInput2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
IComparer caseInsComp = CaseInsensitiveComparer.Default;
// TODO: Make this faster by extracting the whole cab at once.
// TODO: Optimize for the match case by first comparing the whole cab files.
CabInfo cab1 = new CabInfo(diffInput1);
CabInfo cab2 = new CabInfo(diffInput2);
IList<CabFileInfo> cabFilesList1 = cab1.GetFiles();
IList<CabFileInfo> cabFilesList2 = cab2.GetFiles();
CabFileInfo[] cabFiles1 = new CabFileInfo[cabFilesList1.Count];
CabFileInfo[] cabFiles2 = new CabFileInfo[cabFilesList2.Count];
cabFilesList1.CopyTo(cabFiles1, 0);
cabFilesList2.CopyTo(cabFiles2, 0);
string[] files1 = new string[cabFiles1.Length];
string[] files2 = new string[cabFiles2.Length];
for(int i1 = 0; i1 < cabFiles1.Length; i1++) files1[i1] = cabFiles1[i1].Name;
for(int i2 = 0; i2 < cabFiles2.Length; i2++) files2[i2] = cabFiles2[i2].Name;
Array.Sort(files1, cabFiles1, caseInsComp);
Array.Sort(files2, cabFiles2, caseInsComp);
for(int i1 = 0, i2 = 0; i1 < files1.Length || i2 < files2.Length; )
{
int comp;
if(i1 == files1.Length)
{
comp = 1;
}
else if(i2 == files2.Length)
{
comp = -1;
}
else
{
comp = caseInsComp.Compare(files1[i1], files2[i2]);
}
if(comp < 0)
{
diffOutput.WriteLine("{0}< {1}", linePrefix, files1[i1]);
i1++;
difference = true;
}
else if(comp > 0)
{
diffOutput.WriteLine("{0}> {1}", linePrefix, files2[i2]);
i2++;
difference = true;
}
else
{
string tempFile1 = Path.GetTempFileName();
string tempFile2 = Path.GetTempFileName();
cabFiles1[i1].CopyTo(tempFile1, true);
cabFiles2[i2].CopyTo(tempFile2, true);
IDiffEngine diffEngine = diffFactory.GetDiffEngine(tempFile1, tempFile2, options);
StringWriter sw = new StringWriter();
if(diffEngine.GetDiff(tempFile1, tempFile2, options, sw, linePrefix + " ", diffFactory))
{
diffOutput.WriteLine("{0}{1}", linePrefix, files1[i1]);
diffOutput.Write(sw.ToString());
difference = true;
}
File.SetAttributes(tempFile1, File.GetAttributes(tempFile1) & ~FileAttributes.ReadOnly);
File.SetAttributes(tempFile2, File.GetAttributes(tempFile2) & ~FileAttributes.ReadOnly);
try
{
File.Delete(tempFile1);
File.Delete(tempFile2);
}
catch(IOException)
{
#if DEBUG
Console.WriteLine("Could not delete temporary files {0} and {1}", tempFile1, tempFile2);
#endif
}
i1++;
i2++;
}
}
return difference;
}
protected bool GetSummaryInfoDiff(Database db1, Database db2, string[] options, TextWriter diffOutput, string linePrefix, IDiffEngineFactory diffFactory)
{
bool difference = false;
SummaryInfo summInfo1 = db1.SummaryInfo;
SummaryInfo summInfo2 = db2.SummaryInfo;
if (summInfo1.Title != summInfo2.Title)
{
diffOutput.WriteLine("{0}SummaryInformation.Title {{{1}}}->{{{2}}}", linePrefix, summInfo1.Title, summInfo2.Title); difference = true;
}
if (summInfo1.Subject != summInfo2.Subject)
{
diffOutput.WriteLine("{0}SummaryInformation.Subject {{{1}}}->{{{2}}}", linePrefix, summInfo1.Subject, summInfo2.Subject); difference = true;
}
if (summInfo1.Author != summInfo2.Author)
{
diffOutput.WriteLine("{0}SummaryInformation.Author {{{1}}}->{{{2}}}", linePrefix, summInfo1.Author, summInfo2.Author); difference = true;
}
if (summInfo1.Keywords != summInfo2.Keywords)
{
diffOutput.WriteLine("{0}SummaryInformation.Keywords {{{1}}}->{{{2}}}", linePrefix, summInfo1.Keywords, summInfo2.Keywords); difference = true;
}
if (summInfo1.Comments != summInfo2.Comments)
{
diffOutput.WriteLine("{0}SummaryInformation.Comments {{{1}}}->{{{2}}}", linePrefix, summInfo1.Comments, summInfo2.Comments); difference = true;
}
if (summInfo1.Template != summInfo2.Template)
{
diffOutput.WriteLine("{0}SummaryInformation.Template {{{1}}}->{{{2}}}", linePrefix, summInfo1.Template, summInfo2.Template); difference = true;
}
if (summInfo1.LastSavedBy != summInfo2.LastSavedBy)
{
diffOutput.WriteLine("{0}SummaryInformation.LastSavedBy {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastSavedBy, summInfo2.LastSavedBy); difference = true;
}
if (summInfo1.RevisionNumber != summInfo2.RevisionNumber)
{
diffOutput.WriteLine("{0}SummaryInformation.RevisionNumber {{{1}}}->{{{2}}}", linePrefix, summInfo1.RevisionNumber, summInfo2.RevisionNumber); difference = true;
}
if (summInfo1.CreatingApp != summInfo2.CreatingApp)
{
diffOutput.WriteLine("{0}SummaryInformation.CreatingApp {{{1}}}->{{{2}}}", linePrefix, summInfo1.CreatingApp, summInfo2.CreatingApp); difference = true;
}
if (summInfo1.LastPrintTime != summInfo2.LastPrintTime)
{
diffOutput.WriteLine("{0}SummaryInformation.LastPrintTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastPrintTime, summInfo2.LastPrintTime); difference = true;
}
if (summInfo1.CreateTime != summInfo2.CreateTime)
{
diffOutput.WriteLine("{0}SummaryInformation.CreateTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.CreateTime, summInfo2.CreateTime); difference = true;
}
if (summInfo1.LastSaveTime != summInfo2.LastSaveTime)
{
diffOutput.WriteLine("{0}SummaryInformation.LastSaveTime {{{1}}}->{{{2}}}", linePrefix, summInfo1.LastSaveTime, summInfo2.LastSaveTime); difference = true;
}
if (summInfo1.CodePage != summInfo2.CodePage)
{
diffOutput.WriteLine("{0}SummaryInformation.Codepage {{{1}}}->{{{2}}}", linePrefix, summInfo1.CodePage, summInfo2.CodePage); difference = true;
}
if (summInfo1.PageCount != summInfo2.PageCount)
{
diffOutput.WriteLine("{0}SummaryInformation.PageCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.PageCount, summInfo2.PageCount); difference = true;
}
if (summInfo1.WordCount != summInfo2.WordCount)
{
diffOutput.WriteLine("{0}SummaryInformation.WordCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.WordCount, summInfo2.WordCount); difference = true;
}
if (summInfo1.CharacterCount != summInfo2.CharacterCount)
{
diffOutput.WriteLine("{0}SummaryInformation.CharacterCount {{{1}}}->{{{2}}}", linePrefix, summInfo1.CharacterCount, summInfo2.CharacterCount); difference = true;
}
if (summInfo1.Security != summInfo2.Security)
{
diffOutput.WriteLine("{0}SummaryInformation.Security {{{1}}}->{{{2}}}", linePrefix, summInfo1.Security, summInfo2.Security); difference = true;
}
summInfo1.Close();
summInfo2.Close();
return(difference);
}
