public AlterationVM(Alteration alteration, Area area, Version version)
{
_alteration = alteration;
_area = area;
_version = version;
if (_alteration.PriorRecord.HasValue)
_priorRecord = _area.GetRecord(_alteration.PriorRecord.Value);
if (_alteration.NewRecord.HasValue)
_newRecord = _area.GetRecord(_alteration.NewRecord.Value);
DiffWithPreviousCommand = new DelegateCommand(DiffWithPrevious, CanDiffWithPrevious);
DiffWithCurrentCommand = new DelegateCommand(DiffWithCurrent, CanDiffWithCurrent);
LogCommand = new DelegateCommand(Log);
SaveVersionAsCommand = new DelegateCommand(SaveVersionAs, CanSaveVersionAs);
}
private long? RelinkMissingDelete(Dictionary<long, Record> records, Alteration x)
{
// Attempt to repair a possible disaster
var rec = Get<Objects.Record>(x.PriorRecord.Value);
long? result = null;
foreach (var z in records)
{
if (z.Value.CanonicalNameId == rec.CanonicalNameId && z.Value.UniqueIdentifier == rec.UniqueIdentifier)
{
result = z.Key;
break;
}
}
if (!result.HasValue)
{
foreach (var z in records)
{
if (z.Value.CanonicalNameId == rec.CanonicalNameId)
{
if (z.Value.DataIdentifier == rec.DataIdentifier)
{
result = z.Key;
break;
}
}
}
}
if (result.HasValue)
{
records.Remove(result.Value);
x.PriorRecord = result.Value;
Update(x);
}
else if (x.NewRecord.HasValue && records.ContainsKey(x.NewRecord.Value))
{
Delete(x);
return x.NewRecord;
}
return result;
}
private static FusedAlteration CreateFusedAlteration(SharedNetworkInfo sharedInfo, Alteration y)
{
FusedAlteration alteration = new FusedAlteration();
alteration.Alteration = y.Type;
alteration.NewRecord = y.NewRecord.HasValue ? sharedInfo.Workspace.GetRecord(y.NewRecord.Value) : null;
alteration.PriorRecord = y.PriorRecord.HasValue ? sharedInfo.Workspace.GetRecord(y.PriorRecord.Value) : null;
return alteration;
}
private WorkspaceDB(string path, SQLite.SQLiteOpenFlags flags, LocalDB localDB) : base(path, flags)
{
Printer.PrintDiagnostics("Metadata DB Open.");
EnableWAL = true;
LocalDatabase = localDB;
CreateTable<Objects.FormatInfo>();
if (flags.HasFlag(SQLite.SQLiteOpenFlags.Create))
{
ExecuteDirect("PRAGMA main.page_size = 4096;");
ExecuteDirect("PRAGMA main.cache_size = 10240;");
ExecuteDirect("PRAGMA temp_store = MEMORY;");
EnableWAL = true;
PrepareTables();
return;
}
if (!ValidForUpgrade)
return;
if (Format.InternalFormat < InternalDBVersion)
{
try
{
var fmt = Format;
int priorFormat = fmt.InternalFormat;
if (priorFormat < 17)
{
ExecuteDirect("PRAGMA main.page_size = 4096;");
ExecuteDirect("PRAGMA main.cache_size = 10240;");
ExecuteDirect("PRAGMA temp_store = MEMORY;");
EnableWAL = false;
ExecuteDirect("VACUUM");
EnableWAL = true;
}
BeginExclusive(true);
if (priorFormat <= 12)
{
var info = GetTableInfo("ObjectName");
if (info.Where(x => x.Name == "NameId").Count() == 0)
{
var objNames = Query<ObjectNameOld>("SELECT * FROM ObjectName").ToList();
Dictionary<long, long> nameMapping = new Dictionary<long, long>();
Dictionary<string, long> nameIndexes = new Dictionary<string, long>();
DropTable<ObjectName>();
Commit();
BeginExclusive();
CreateTable<ObjectName>();
foreach (var x in objNames)
{
if (nameIndexes.ContainsKey(x.CanonicalName))
{
nameMapping[x.Id] = nameIndexes[x.CanonicalName];
}
else
{
ObjectName oname = new ObjectName() { CanonicalName = x.CanonicalName };
Insert(oname);
nameMapping[x.Id] = oname.NameId;
nameIndexes[x.CanonicalName] = oname.NameId;
}
}
foreach (var x in Table<Record>().ToList())
{
x.CanonicalNameId = nameMapping[x.CanonicalNameId];
Update(x);
}
Commit();
}
}
PrepareTables();
Printer.PrintMessage("Updating workspace database version from v{0} to v{1}", Format.InternalFormat, InternalDBVersion);
if (priorFormat < 28)
{
var tips = Query<BranchJournal>("SELECT * FROM BranchJournal WHERE NOT EXISTS (SELECT * FROM BranchJournalLink WHERE Parent = BranchJournal.ID)").ToList();
if (tips.Count > 1)
Printer.PrintError("#e#Database update encountered an error - multiple possible tips for branch journal data found. Selecting final revision.");
if (tips.Count != 0)
BranchJournalTip = tips[tips.Count - 1].ID;
}
if (priorFormat < 14)
{
ExecuteDirect("DROP TABLE RecordIndex;");
}
if (priorFormat < 32)
{
int count = 0;
foreach (var x in Table<Objects.Version>())
{
if (x.Message != null && x.Message.StartsWith("Automatic merge of"))
{
var mergeInfos = Table<MergeInfo>().Where(y => y.DestinationVersion == x.ID).ToList();
if (mergeInfos.Count == 1)
{
mergeInfos[0].Type = MergeType.Automatic;
Update(mergeInfos[0]);
count++;
}
}
}
Printer.PrintMessage("Updated #b#{0}## merge info records.", count);
}
if (priorFormat < 31)
{
Dictionary<long, Record> recordMap = new Dictionary<long, Record>();
foreach (var x in Table<Record>().ToList())
recordMap[x.Id] = x;
foreach (var x in Table<Record>().ToList())
{
if (x.Parent.HasValue && !recordMap.ContainsKey(x.Parent.Value))
{
x.Parent = null;
Update(x);
}
}
}
if (priorFormat < 30)
{
RunConsistencyCheck();
}
if (priorFormat < 30)
{
foreach (var x in Table<Objects.Version>().ToList())
{
x.Snapshot = null;
Update(x);
var alterations = Table<Objects.Alteration>().Where(z => z.Owner == x.AlterationList);
Dictionary<long, bool> moveDeletes = new Dictionary<long, bool>();
HashSet<long> deletions = new HashSet<long>();
int counter = 0;
foreach (var s in alterations)
{
if (s.Type == AlterationType.Move)
{
if (moveDeletes.ContainsKey(s.PriorRecord.Value))
moveDeletes[s.PriorRecord.Value] = false;
else
moveDeletes[s.PriorRecord.Value] = true;
}
}
foreach (var s in alterations)
{
if (s.Type == AlterationType.Move)
{
if (moveDeletes[s.PriorRecord.Value] == false)
{
s.Type = AlterationType.Copy;
Update(s);
deletions.Add(s.PriorRecord.Value);
counter++;
}
}
}
foreach (var s in deletions)
{
Alteration alt = new Alteration() { PriorRecord = s, Type = AlterationType.Delete, Owner = x.AlterationList };
Insert(alt);
}
if (counter > 0)
Printer.PrintDiagnostics("Version {0} had {1} multiple-moves that have been fixed.", x.ShortName, counter);
}
}
if (priorFormat < 30)
{
foreach (var x in Table<Objects.Version>().ToList())
{
x.Snapshot = null;
Update(x);
var alterations = Table<Objects.Alteration>().Where(z => z.Owner == x.AlterationList);
HashSet<Tuple<AlterationType, long?, long?>> duplicateAlterations = new HashSet<Tuple<AlterationType, long?, long?>>();
int counter = 0;
foreach (var s in alterations)
{
var key = new Tuple<AlterationType, long?, long?>(s.Type, s.NewRecord, s.PriorRecord);
if (duplicateAlterations.Contains(key))
{
Delete(s);
counter++;
}
else
duplicateAlterations.Add(key);
}
if (counter > 0)
Printer.PrintDiagnostics("Version {0} had {1} duplicated alterations that have been fixed.", x.ShortName, counter);
}
}
else if (priorFormat == 7)
{
Printer.PrintMessage(" - Upgrading database - adding branch root version.");
foreach (var x in Table<Objects.Branch>().ToList())
{
var allVersions = Table<Objects.Version>().Where(y => y.Branch == x.ID);
Guid? rootVersion = null;
foreach (var y in allVersions)
{
if (y.Parent.HasValue)
{
Objects.Version parent = Get<Objects.Version>(y.Parent);
if (parent.Branch != x.ID)
{
rootVersion = parent.ID;
break;
}
}
}
x.RootVersion = rootVersion;
Update(x);
}
}
DropTable<Objects.FormatInfo>();
fmt.InternalFormat = InternalDBVersion;
CreateTable<Objects.FormatInfo>();
Insert(fmt);
Commit();
ExecuteDirect("VACUUM");
}
catch (Exception e)
{
Rollback();
Printer.PrintError("Couldn't update DB: {0}", e.ToString());
}
PrepareTables();
}
}