| public static PrintError ( string v ) : void | ||
| v | string | |
| Результат | void | |
public List <Record> GetRecords(Objects.Version version, out List <Record> baseList, out List <Alteration> alterations, bool testFailure = false)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
Printer.PrintDiagnostics("Getting records for version {0}.", version.ID);
long?snapshotID = null;
bool readtrans = false;
try
{
BeginTransaction();
readtrans = true;
}
catch (InvalidOperationException)
{
// not an issue
}
List <Objects.Version> parents = new List <Objects.Version>();
Objects.Version snapshotVersion = version;
while (!snapshotID.HasValue)
{
parents.Add(snapshotVersion);
if (snapshotVersion.Snapshot.HasValue)
{
snapshotID = snapshotVersion.Snapshot;
}
else
{
if (!snapshotVersion.Parent.HasValue)
{
break;
}
snapshotVersion = Get <Objects.Version>(snapshotVersion.Parent);
}
}
if (!snapshotID.HasValue)
{
Printer.PrintDiagnostics(" - No snapshot.");
baseList = new List <Record>();
}
else
{
Printer.PrintDiagnostics(" - Last snapshot version: {0}", snapshotVersion.ID);
var sslist = Query <RecordRef>("SELECT * FROM RecordRef WHERE RecordRef.SnapshotID = ?", snapshotID.Value).Select(x => x.RecordID).ToList();
CacheRecords(sslist);
baseList = sslist.Select(x => GetCachedRecord(x)).ToList();
Printer.PrintDiagnostics(" - Snapshot {0} has {1} records.", snapshotID, baseList.Count);
}
alterations = GetAlterationsInternal(parents);
if (readtrans)
{
Commit();
}
Printer.PrintDiagnostics(" - Target has {0} alterations.", alterations.Count);
List <Record> finalList = null;
try
{
finalList = Consolidate(baseList, alterations, null);
}
catch
{
if (testFailure)
{
throw;
}
Printer.PrintError("Error during database operation. Deleting cached snapshots.");
BeginExclusive(true);
RunConsistencyCheck();
Commit();
Printer.PrintError("Please retry this operation.");
throw;
}
Printer.PrintDiagnostics("Record list resolved in {0} ticks.", sw.ElapsedTicks);
if (testFailure)
{
return(finalList);
}
if (baseList.Count < alterations.Count || (alterations.Count > 4096 && parents.Count > 128))
{
Printer.PrintDiagnostics(" - Attempting to build new snapshot ({0} records in base list, {1} alterations over {2} revisions)", baseList.Count, alterations.Count, parents.Count);
try
{
BeginTransaction();
try
{
Objects.Snapshot snapshot = new Snapshot();
this.InsertSafe(snapshot);
foreach (var z in finalList)
{
Objects.RecordRef rref = new RecordRef();
rref.RecordID = z.Id;
rref.SnapshotID = snapshot.Id;
this.InsertSafe(rref);
}
version.Snapshot = snapshot.Id;
this.UpdateSafe(version);
Commit();
}
catch
{
Rollback();
}
}
catch
{
// Already in a transaction
Objects.Snapshot snapshot = new Snapshot();
this.InsertSafe(snapshot);
foreach (var z in finalList)
{
Objects.RecordRef rref = new RecordRef();
rref.RecordID = z.Id;
rref.SnapshotID = snapshot.Id;
this.InsertSafe(rref);
}
version.Snapshot = snapshot.Id;
this.UpdateSafe(version);
}
}
return(finalList);
}
private WorkspaceDB(string path, SQLite.SQLiteOpenFlags flags, LocalDB localDB) : base(path, flags)
{
Printer.PrintDiagnostics("Metadata DB Open.");
EnableWAL = true;
LocalDatabase = localDB;
if (ExecuteScalar <string>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'FormatInfo';") != "FormatInfo")
{
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;");
ExecuteDirect("PRAGMA threads = 2;");
EnableWAL = true;
PrepareTables();
return;
}
if (!ValidForUpgrade)
{
return;
}
if (Format.InternalFormat < InternalDBVersion)
{
try
{
var fmt = Format;
int priorFormat = fmt.InternalFormat;
if (priorFormat < 42)
{
ExecuteDirect("DROP TABLE Annotation");
ExecuteDirect("DROP TABLE AnnotationJournal");
ExecuteDirect("DROP TABLE TagJournal");
ExecuteDirect("DROP TABLE Tag");
}
BeginExclusive(true);
Printer.PrintMessage("Updating workspace database version from v{0} to v{1}", Format.InternalFormat, InternalDBVersion);
PrepareTables();
if (priorFormat < 42)
{
RunConsistencyCheck();
}
if (priorFormat < 33)
{
foreach (var x in Table <Record>().ToList())
{
if (x.Parent.HasValue)
{
Record rp = Find <Record>(x.Parent.Value);
if (rp == null)
{
Printer.PrintMessage("Found missing parent for record ID {0} - parent ID: {1}, attempting to fix.", x.Id, x.Parent.Value);
Printer.PrintMessage(" - Record {0} - {1}", Find <ObjectName>(x.CanonicalNameId).CanonicalName, x.Fingerprint);
var alterations = Query <Alteration>("SELECT * from Alteration where Alteration.NewRecord = ?", x.Id);
var possibleParents = alterations.Where(z => z.PriorRecord.HasValue).Select(z => z.PriorRecord.Value).Distinct().ToList();
Printer.PrintMessage(" - Found {0} possible parents for this record.", possibleParents.Count);
if (possibleParents.Count == 1)
{
Printer.PrintMessage(" - Updating parent record to ID {0}", possibleParents[0]);
x.Parent = possibleParents[0];
}
else
{
if (possibleParents.Count > 0)
{
Printer.PrintMessage(" - Data is ambiguous, removing parent record.");
}
else
{
Printer.PrintMessage(" - No parents found, removing parent record.");
}
x.Parent = null;
}
Update(x);
}
}
}
}
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)
{
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);
}
}
}
DropTable <Objects.FormatInfo>();
fmt.InternalFormat = InternalDBVersion;
CreateTable <Objects.FormatInfo>();
Insert(fmt);
Commit();
Vacuum();
}
catch (Exception e)
{
Rollback();
Printer.PrintError("Couldn't update DB: {0}", e.ToString());
}
PrepareTables();
}
}