private StructureReader <T> LoadStruct <T>(TableOfStructures <T> table, Slice name, out ushort version) where T : struct
{
var reader = LoadStruct(table, name, writeBatch.Value, out version);
if (reader == null)
{
throw new IndexDoesNotExistsException(string.Format("There is no index with the name: '{0}'", name.ToString()));
}
return(reader);
}
protected StructureReader <T> LoadStruct <T>(TableOfStructures <T> table, Slice key, WriteBatch writeBatch, out ushort version)
{
var read = table.ReadStruct(Snapshot, key, writeBatch);
if (read == null)
{
version = 0;
return(null);
}
version = read.Version;
return(read.Reader);
}
private void Initialize()
{
Documents = new Table(Tables.Documents.TableName, bufferPool, Tables.Documents.Indices.KeyByEtag, Tables.Documents.Indices.Metadata);
Details = new Table(Tables.Details.TableName, bufferPool);
IndexingStats = new TableOfStructures<IndexingWorkStatsFields>(Tables.IndexingStats.TableName,
new StructureSchema<IndexingWorkStatsFields>()
.Add<int>(IndexingWorkStatsFields.IndexId)
.Add<int>(IndexingWorkStatsFields.IndexingAttempts)
.Add<int>(IndexingWorkStatsFields.IndexingSuccesses)
.Add<int>(IndexingWorkStatsFields.IndexingErrors)
.Add<long>(IndexingWorkStatsFields.LastIndexingTime)
.Add<long>(IndexingWorkStatsFields.CreatedTimestamp),
bufferPool);
IndexingMetadata = new Table(Tables.IndexingMetadata.TableName, bufferPool);
LastIndexedEtags = new TableOfStructures<LastIndexedStatsFields>(Tables.LastIndexedEtags.TableName,
new StructureSchema<LastIndexedStatsFields>()
.Add<int>(LastIndexedStatsFields.IndexId)
.Add<long>(LastIndexedStatsFields.LastTimestamp)
.Add<byte[]>(LastIndexedStatsFields.LastEtag),
bufferPool);
DocumentReferences = new TableOfStructures<DocumentReferencesFields>(Tables.DocumentReferences.TableName,
new StructureSchema<DocumentReferencesFields>()
.Add<int>(DocumentReferencesFields.IndexId)
.Add<string>(DocumentReferencesFields.Key)
.Add<string>(DocumentReferencesFields.Reference),
bufferPool, Tables.DocumentReferences.Indices.ByRef, Tables.DocumentReferences.Indices.ByView, Tables.DocumentReferences.Indices.ByViewAndKey, Tables.DocumentReferences.Indices.ByKey);
Queues = new Table(Tables.Queues.TableName, bufferPool, Tables.Queues.Indices.ByName, Tables.Queues.Indices.Data);
Lists = new Table(Tables.Lists.TableName, bufferPool, Tables.Lists.Indices.ByName, Tables.Lists.Indices.ByNameAndKey);
Tasks = new TableOfStructures<TaskFields>(Tables.Tasks.TableName,
new StructureSchema<TaskFields>()
.Add<int>(TaskFields.IndexId)
.Add<long>(TaskFields.AddedAt)
.Add<byte[]>(TaskFields.TaskId)
.Add<string>(TaskFields.Type)
.Add<byte[]>(TaskFields.SerializedTask),
bufferPool, Tables.Tasks.Indices.ByIndexAndType, Tables.Tasks.Indices.ByType, Tables.Tasks.Indices.ByIndex);
ScheduledReductions = new TableOfStructures<ScheduledReductionFields>(Tables.ScheduledReductions.TableName,
new StructureSchema<ScheduledReductionFields>()
.Add<int>(ScheduledReductionFields.IndexId)
.Add<int>(ScheduledReductionFields.Bucket)
.Add<int>(ScheduledReductionFields.Level)
.Add<long>(ScheduledReductionFields.Timestamp)
.Add<string>(ScheduledReductionFields.ReduceKey)
.Add<byte[]>(ScheduledReductionFields.Etag),
bufferPool, Tables.ScheduledReductions.Indices.ByView, Tables.ScheduledReductions.Indices.ByViewAndLevelAndReduceKey);
MappedResults = new TableOfStructures<MappedResultFields>(Tables.MappedResults.TableName,
new StructureSchema<MappedResultFields>()
.Add<int>(MappedResultFields.IndexId)
.Add<int>(MappedResultFields.Bucket)
.Add<long>(MappedResultFields.Timestamp)
.Add<string>(MappedResultFields.ReduceKey)
.Add<string>(MappedResultFields.DocId)
.Add<byte[]>(MappedResultFields.Etag),
bufferPool, Tables.MappedResults.Indices.ByView, Tables.MappedResults.Indices.ByViewAndDocumentId, Tables.MappedResults.Indices.ByViewAndReduceKey, Tables.MappedResults.Indices.ByViewAndReduceKeyAndSourceBucket, Tables.MappedResults.Indices.Data);
ReduceKeyCounts = new TableOfStructures<ReduceKeyCountFields>(Tables.ReduceKeyCounts.TableName,
new StructureSchema<ReduceKeyCountFields>()
.Add<int>(ReduceKeyCountFields.IndexId)
.Add<int>(ReduceKeyCountFields.MappedItemsCount)
.Add<string>(ReduceKeyCountFields.ReduceKey),
bufferPool, Tables.ReduceKeyCounts.Indices.ByView);
ReduceKeyTypes = new TableOfStructures<ReduceKeyTypeFields>(Tables.ReduceKeyTypes.TableName,
new StructureSchema<ReduceKeyTypeFields>()
.Add<int>(ReduceKeyTypeFields.IndexId)
.Add<int>(ReduceKeyTypeFields.ReduceType)
.Add<string>(ReduceKeyTypeFields.ReduceKey),
bufferPool, Tables.ReduceKeyTypes.Indices.ByView);
Attachments = new Table(Tables.Attachments.TableName, bufferPool, Tables.Attachments.Indices.ByEtag, Tables.Attachments.Indices.Metadata);
ReduceResults = new TableOfStructures<ReduceResultFields>(Tables.ReduceResults.TableName,
new StructureSchema<ReduceResultFields>()
.Add<int>(ReduceResultFields.IndexId)
.Add<int>(ReduceResultFields.Level)
.Add<int>(ReduceResultFields.SourceBucket)
.Add<int>(ReduceResultFields.Bucket)
.Add<long>(ReduceResultFields.Timestamp)
.Add<string>(ReduceResultFields.ReduceKey)
.Add<byte[]>(ReduceResultFields.Etag),
bufferPool, Tables.ReduceResults.Indices.ByView, Tables.ReduceResults.Indices.ByViewAndReduceKeyAndLevel, Tables.ReduceResults.Indices.ByViewAndReduceKeyAndLevelAndSourceBucket, Tables.ReduceResults.Indices.ByViewAndReduceKeyAndLevelAndBucket, Tables.ReduceResults.Indices.Data);
General = new Table(Tables.General.TableName, bufferPool);
ReduceStats = new TableOfStructures<ReducingWorkStatsFields>(Tables.ReduceStats.TableName,
new StructureSchema<ReducingWorkStatsFields>()
.Add<int>(ReducingWorkStatsFields.ReduceAttempts)
.Add<int>(ReducingWorkStatsFields.ReduceSuccesses)
.Add<int>(ReducingWorkStatsFields.ReduceErrors)
.Add<long>(ReducingWorkStatsFields.LastReducedTimestamp)
.Add<byte[]>(ReducingWorkStatsFields.LastReducedEtag),
bufferPool);
}
public void MigrateToStructures <T>(StorageEnvironment env, TableOfStructures <T> table, Action <string> output, Action <RavenJObject, Structure <T> > copyToStructure)
{
long entriesCount;
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
entriesCount = tx.ReadTree(table.TableName).State.EntriesCount;
}
if (entriesCount == 0)
{
output(string.Format("No records to migrate in '{0}' table.", table.TableName));
return;
}
output(string.Format("Starting to migrate '{0}' table to use structures. Records to process: {1}", table.TableName, entriesCount));
var migratedEntries = 0L;
var keyToSeek = Slice.BeforeAllKeys;
// delete Temp_TabelName if exists
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.DeleteTree(txw, "Temp_" + table.TableName);
txw.Commit();
}
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(txw, "Temp_" + table.TableName);
txw.Commit();
}
do
{
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
var destTree = txw.ReadTree("Temp_" + table.TableName);
var srcTree = txw.ReadTree(table.TableName);
var iterator = srcTree.Iterate();
if (iterator.Seek(keyToSeek) == false)
{
break;
}
var writtenStructsSize = 0;
do
{
keyToSeek = iterator.CurrentKey;
if (writtenStructsSize > 8 * 1024 * 1024) // 8 MB
{
break;
}
var readerForCurrent = iterator.CreateReaderForCurrent();
using (var stream = readerForCurrent.AsStream())
{
var currentDataSize = iterator.GetCurrentDataSize();
try
{
RavenJObject jsonValue = stream.ToJObject();
var structValue = new Structure <T>(table.Schema);
copyToStructure(jsonValue, structValue);
destTree.WriteStruct(iterator.CurrentKey, structValue);
writtenStructsSize += structValue.GetSize();
}
catch (Exception)
{
// already converted this, probably, just move as is
int used;
var readBytes = readerForCurrent.ReadBytes(currentDataSize, out used);
destTree.Add(iterator.CurrentKey, readBytes);
writtenStructsSize += currentDataSize;
}
migratedEntries++;
}
} while (iterator.MoveNext());
txw.Commit();
output(string.Format("{0} of {1} records processed.", migratedEntries, entriesCount));
}
} while (migratedEntries < entriesCount);
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.DeleteTree(txw, table.TableName);
env.RenameTree(txw, "Temp_" + table.TableName, table.TableName);
txw.Commit();
}
output(string.Format("All records of '{0}' table have been migrated to structures.", table.TableName));
}
