static TimeSeriesStats()
{
using (StorageEnvironment.GetStaticContext(out ByteStringContext ctx))
{
Slice.From(ctx, RawTimeSeriesPolicy.PolicyString, SpecialChars.RecordSeparator, ByteStringType.Immutable, out RawPolicySlice);
Slice.From(ctx, nameof(TimeSeriesStatsKey), ByteStringType.Immutable, out TimeSeriesStatsKey);
Slice.From(ctx, nameof(PolicyIndex), ByteStringType.Immutable, out PolicyIndex);
Slice.From(ctx, nameof(StartTimeIndex), ByteStringType.Immutable, out StartTimeIndex);
}
TimeSeriesStatsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)StatsColumns.Key,
Count = 1,
Name = TimeSeriesStatsKey,
IsGlobal = true
});
TimeSeriesStatsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)StatsColumns.PolicyName,
Name = PolicyIndex
});
TimeSeriesStatsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
// policy, separator, start
StartIndex = (int)StatsColumns.PolicyName,
Count = 2,
Name = StartTimeIndex
});
}
static From40011()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, "Items", out Items);
Slice.From(ctx, "CertificatesSlice", out CertificatesSlice);
Slice.From(ctx, "CertificatesHashSlice", out CertificatesHashSlice);
}
ItemsSchema = new TableSchema();
ItemsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1
});
CertificatesSchema = new TableSchema();
CertificatesSchema.DefineKey(new TableSchema.SchemaIndexDef()
{
StartIndex = (int)CertificatesTable.Key,
Count = 1,
IsGlobal = false,
Name = CertificatesSlice
});
CertificatesSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)CertificatesTable.Hash,
Count = 1,
IsGlobal = false,
Name = CertificatesHashSlice
});
}
static ConflictsStorage()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, "ChangeVector", ByteStringType.Immutable, out ChangeVectorSlice);
Slice.From(ctx, "ConflictsId", ByteStringType.Immutable, out ConflictsIdSlice);
Slice.From(ctx, "IdAndChangeVector", ByteStringType.Immutable, out IdAndChangeVectorSlice);
Slice.From(ctx, "AllConflictedDocsEtags", ByteStringType.Immutable, out AllConflictedDocsEtagsSlice);
Slice.From(ctx, "ConflictedCollection", ByteStringType.Immutable, out ConflictedCollectionSlice);
Slice.From(ctx, "Conflicts", ByteStringType.Immutable, out ConflictsSlice);
}
/*
* The structure of conflicts table starts with the following fields:
* [ Conflicted Doc Id | Separator | Change Vector | ... the rest of fields ... ]
* PK of the conflicts table will be 'Change Vector' field, because when dealing with conflicts,
* the change vectors will always be different, hence the uniqueness of the ID. (inserts/updates will not overwrite)
*
* Additional index is set to have composite ID of 'Conflicted Doc Id' and 'Change Vector' so we will be able to iterate
* on conflicts by conflicted doc id (using 'starts with')
*
* We need a separator in order to delete all conflicts all "users/1" without deleting "users/11" conflicts.
*/
ConflictsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)ConflictsTable.ChangeVector,
Count = 1,
IsGlobal = false,
Name = ChangeVectorSlice
});
// required to get conflicts by ID
ConflictsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)ConflictsTable.LowerId,
Count = 3,
IsGlobal = false,
Name = IdAndChangeVectorSlice
});
ConflictsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)ConflictsTable.LowerId,
Count = 1,
IsGlobal = true,
Name = ConflictsIdSlice
});
ConflictsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)ConflictsTable.Etag,
IsGlobal = true,
Name = AllConflictedDocsEtagsSlice
});
ConflictsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)ConflictsTable.Collection,
Count = 1,
IsGlobal = true,
Name = ConflictedCollectionSlice
});
}
static RachisLogHistory()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, "LogHistory", out LogHistorySlice);
Slice.From(ctx, "LogHistoryIndex", out LogHistoryIndexSlice);
Slice.From(ctx, "LogHistoryDateTime", out LogHistoryDateTimeSlice);
}
LogHistoryTable = new TableSchema();
LogHistoryTable.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)LogHistoryColumn.Guid,
});
LogHistoryTable.DefineIndex(new TableSchema.SchemaIndexDef
{
Name = LogHistoryIndexSlice,
StartIndex = (int)LogHistoryColumn.Index,
Count = 1
});
LogHistoryTable.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
Name = LogHistoryDateTimeSlice,
StartIndex = (int)LogHistoryColumn.Ticks
});
}
static CountersStorage()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, "AllCountersEtags", ByteStringType.Immutable, out AllCountersEtagSlice);
Slice.From(ctx, "CollectionCountersEtags", ByteStringType.Immutable, out CollectionCountersEtagsSlice);
Slice.From(ctx, "CounterKeys", ByteStringType.Immutable, out CounterKeysSlice);
Slice.From(ctx, CountersTombstones, ByteStringType.Immutable, out CountersTombstonesSlice);
}
CountersSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)CountersTable.CounterKey,
Count = 1,
Name = CounterKeysSlice,
IsGlobal = true,
});
CountersSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)CountersTable.Etag,
Name = AllCountersEtagSlice,
IsGlobal = true
});
CountersSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)CountersTable.Etag,
Name = CollectionCountersEtagsSlice
});
}
static RevisionsStorage()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, "RevisionsChangeVector", ByteStringType.Immutable, out var changeVectorSlice);
Slice.From(ctx, "RevisionsIdAndEtag", ByteStringType.Immutable, out IdAndEtagSlice);
Slice.From(ctx, "DeleteRevisionEtag", ByteStringType.Immutable, out DeleteRevisionEtagSlice);
Slice.From(ctx, "AllRevisionsEtags", ByteStringType.Immutable, out AllRevisionsEtagsSlice);
Slice.From(ctx, "CollectionRevisionsEtags", ByteStringType.Immutable, out CollectionRevisionsEtagsSlice);
Slice.From(ctx, "RevisionsCount", ByteStringType.Immutable, out RevisionsCountSlice);
Slice.From(ctx, nameof(ResolvedFlagByEtagSlice), ByteStringType.Immutable, out ResolvedFlagByEtagSlice);
Slice.From(ctx, RevisionsTombstones, ByteStringType.Immutable, out RevisionsTombstonesSlice);
Slice.From(ctx, CollectionName.GetTablePrefix(CollectionTableType.Revisions), ByteStringType.Immutable, out RevisionsPrefix);
RevisionsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)RevisionsTable.ChangeVector,
Count = 1,
Name = changeVectorSlice,
IsGlobal = true
});
RevisionsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)RevisionsTable.LowerId,
Count = 3,
Name = IdAndEtagSlice,
IsGlobal = true
});
RevisionsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)RevisionsTable.Etag,
Name = AllRevisionsEtagsSlice,
IsGlobal = true
});
RevisionsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)RevisionsTable.Etag,
Name = CollectionRevisionsEtagsSlice
});
RevisionsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)RevisionsTable.DeletedEtag,
Count = 1,
Name = DeleteRevisionEtagSlice,
IsGlobal = true
});
RevisionsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)RevisionsTable.Resolved,
Count = 2,
Name = ResolvedFlagByEtagSlice,
IsGlobal = true
});
}
}
static RevisionsStorage()
{
Slice.From(StorageEnvironment.LabelsContext, "RevisionsChangeVector", ByteStringType.Immutable, out var changeVectorSlice);
Slice.From(StorageEnvironment.LabelsContext, "RevisionsIdAndEtag", ByteStringType.Immutable, out IdAndEtagSlice);
Slice.From(StorageEnvironment.LabelsContext, "RevisionsFlagsAndEtag", ByteStringType.Immutable, out FlagsAndEtagSlice);
Slice.From(StorageEnvironment.LabelsContext, "AllRevisionsEtags", ByteStringType.Immutable, out AllRevisionsEtagsSlice);
Slice.From(StorageEnvironment.LabelsContext, "CollectionRevisionsEtags", ByteStringType.Immutable, out CollectionRevisionsEtagsSlice);
Slice.From(StorageEnvironment.LabelsContext, "RevisionsCount", ByteStringType.Immutable, out RevisionsCountSlice);
Slice.From(StorageEnvironment.LabelsContext, RevisionsTombstones, ByteStringType.Immutable, out RevisionsTombstonesSlice);
var deleteRevision = DocumentFlags.DeleteRevision;
Slice.From(StorageEnvironment.LabelsContext, (byte *)&deleteRevision, sizeof(DocumentFlags), ByteStringType.Immutable, out DeleteRevisionSlice);
DocsSchema = new TableSchema()
{
TableType = (byte)TableType.Revisions
};
DocsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)Columns.ChangeVector,
Count = 1,
Name = changeVectorSlice,
IsGlobal = true
});
DocsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)Columns.LowerId,
Count = 3,
Name = IdAndEtagSlice,
IsGlobal = true
});
DocsSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)Columns.Flags,
Count = 2,
Name = FlagsAndEtagSlice,
IsGlobal = true
});
DocsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)Columns.Etag,
Name = AllRevisionsEtagsSlice,
IsGlobal = true
});
DocsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)Columns.Etag,
Name = CollectionRevisionsEtagsSlice
});
}
static IndexesEtagsStorage()
{
Slice.From(StorageEnvironment.LabelsContext, "EtagIndexName", out EtagIndexName);
Slice.From(StorageEnvironment.LabelsContext, "NameAndEtagIndexName", out NameAndEtagIndexName);
// Table schema is:
// - index id - int (-1 if tombstone)
// - etag - long
// - name - string, lowercase
// - type - enum (index / transformer)
// - change vector
// - is conflicted - boolean
//(is conflicted --> a flag, so we will not have to read another table in voron just to check if the index/transformer is conlficted)
IndexesTableSchema = new TableSchema();
IndexesTableSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)MetadataFields.Name,
Count = 1
});
IndexesTableSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
StartIndex = (int)MetadataFields.Etag,
Name = EtagIndexName
});
//Table schema is:
// - name -> string, lowercase
// - etag -> long
// - type -> enum (index / transformer)
// - change vector
// - definition of conflicted index/transformer (blittable json)
ConflictsTableSchema = new TableSchema();
ConflictsTableSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 1
});
ConflictsTableSchema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = (int)ConflictFields.Name,
Count = 2,
Name = NameAndEtagIndexName
});
}
public SubscriptionStorage(DocumentDatabase db)
{
var options = db.Configuration.Core.RunInMemory
? StorageEnvironmentOptions.CreateMemoryOnly(Path.Combine(db.Configuration.Core.DataDirectory, "Subscriptions"))
: StorageEnvironmentOptions.ForPath(Path.Combine(db.Configuration.Core.DataDirectory, "Subscriptions"));
options.SchemaVersion = 1;
options.TransactionsMode = TransactionsMode.Lazy;
_environment = new StorageEnvironment(options);
var databaseName = db.Name;
_unmanagedBuffersPool = new UnmanagedBuffersPoolWithLowMemoryHandling("Subscriptions", databaseName);
_logger = LoggingSource.Instance.GetLogger <SubscriptionStorage>(databaseName);
_subscriptionsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1
});
}
static ServerStore()
{
Slice.From(StorageEnvironment.LabelsContext, "EtagIndexName", out EtagIndexName);
_itemsSchema = new TableSchema();
// We use the follow format for the items data
// { lowered key, key, data, etag }
_itemsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 0
});
_itemsSchema.DefineFixedSizeIndex(new TableSchema.FixedSizeSchemaIndexDef
{
Name = EtagIndexName,
IsGlobal = true,
StartIndex = 3
});
}
static TimeSeriesRollups()
{
using (StorageEnvironment.GetStaticContext(out var ctx))
{
Slice.From(ctx, nameof(TimeSeriesRollupTable), ByteStringType.Immutable, out TimeSeriesRollupTable);
Slice.From(ctx, nameof(RollupKey), ByteStringType.Immutable, out RollupKey);
Slice.From(ctx, nameof(NextRollupIndex), ByteStringType.Immutable, out NextRollupIndex);
}
RollupSchema = new TableSchema();
RollupSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = (int)RollupColumns.Key,
Count = 1,
Name = RollupKey
});
RollupSchema.DefineIndex(new TableSchema.SchemaIndexDef // this isn't fixed-size since we expect to have duplicates
{
StartIndex = (int)RollupColumns.NextRollup,
Count = 1,
Name = NextRollupIndex
});
}
public unsafe void CanDeleteTableWithLargeValues()
{
TableSchema schema = new TableSchema();
schema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
Name = Etag,
IsGlobal = true
});
schema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
Name = Local,
IsGlobal = false
});
using (Transaction tx = Env.WriteTransaction())
{
schema.Create(tx, "first", 256);
schema.Create(tx, "second", 256);
Table fst = tx.OpenTable(schema, "first");
Table snd = tx.OpenTable(schema, "second");
for (var i = 0; i < 1000;)
{
var bytes = new byte[2 * RawDataSection.MaxItemSize + 100];
new Random(i).NextBytes(bytes);
TableValueBuilder tvb1 = new TableValueBuilder();
TableValueBuilder tvb2 = new TableValueBuilder();
tvb1.Add(i++);
tvb2.Add(i++);
fixed(byte *ptr = bytes)
{
tvb1.Add(ptr, bytes.Length);
tvb2.Add(ptr, bytes.Length);
fst.Insert(tvb1);
snd.Insert(tvb2);
}
}
tx.Commit();
}
using (var tx = Env.WriteTransaction())
{
tx.DeleteTable("first");
tx.DeleteTable("second");
tx.Commit();
}
using (var tx = Env.WriteTransaction())
{
Assert.Null(tx.LowLevelTransaction.RootObjects.Read("first"));
Assert.Null(tx.LowLevelTransaction.RootObjects.Read("second"));
}
}
public unsafe void CanDeleteTableWithLargeValues()
{
TableSchema schema = new TableSchema();
schema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
Name = Etag,
IsGlobal = true
});
schema.DefineIndex(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
Name = Local,
IsGlobal = false
});
using (Transaction tx = Env.WriteTransaction())
{
schema.Create(tx, "first", 256);
schema.Create(tx, "second", 256);
Table fst = tx.OpenTable(schema, "first");
Table snd = tx.OpenTable(schema, "second");
for (var i = 0; i < 1000;)
{
var bytes = new byte[2 * RawDataSection.MaxItemSize + 100];
new Random(i).NextBytes(bytes);
TableValueBuilder tvb1 = new TableValueBuilder();
TableValueBuilder tvb2 = new TableValueBuilder();
tvb1.Add(i++);
tvb2.Add(i++);
fixed(byte *ptr = bytes)
{
tvb1.Add(ptr, bytes.Length);
tvb2.Add(ptr, bytes.Length);
fst.Insert(tvb1);
snd.Insert(tvb2);
}
}
tx.Commit();
}
using (var tx = Env.WriteTransaction())
{
var firstTable = tx.OpenTable(schema, "first");
firstTable.DeleteByPrimaryKey(Slices.BeforeAllKeys, x =>
{
if (schema.Key.IsGlobal)
{
return(firstTable.IsOwned(x.Reader.Id));
}
return(true);
});
var secondTable = tx.OpenTable(schema, "first");
secondTable.DeleteByPrimaryKey(Slices.BeforeAllKeys, x =>
{
if (schema.Key.IsGlobal)
{
return(secondTable.IsOwned(x.Reader.Id));
}
return(true);
});
tx.Commit();
}
}
public unsafe void CanBeSafelyModifiedOnEither()
{
using (var tx = Env.WriteTransaction())
{
Slice.From(tx.Allocator, "RevisionsChangeVector", ByteStringType.Immutable, out var changeVectorSlice);
Slice.From(tx.Allocator, "Etag", ByteStringType.Immutable, out var etag);
var revisionsSchema = new TableSchema();
revisionsSchema.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
Name = changeVectorSlice,
IsGlobal = false
});
var indexDef = new TableSchema.SchemaIndexDef
{
StartIndex = 1,
Name = etag,
IsGlobal = true
};
revisionsSchema.DefineIndex(indexDef);
revisionsSchema.Create(tx, "users", 32);
revisionsSchema.Create(tx, "people", 32);
var usersTbl = tx.OpenTable(revisionsSchema, "users");
var peopleTbl = tx.OpenTable(revisionsSchema, "people");
using (usersTbl.Allocate(out var builder))
using (Slice.From(tx.Allocator, Guid.NewGuid().ToString(), out var key))
{
builder.Add(key);
builder.Add(0L);
usersTbl.Insert(builder);
}
for (int i = 0; i < 127; i++)
{
using (peopleTbl.Allocate(out var builder))
using (Slice.From(tx.Allocator, Guid.NewGuid().ToString(), out var key))
{
builder.Add(key);
builder.Add(0L);
peopleTbl.Insert(builder);
}
}
using (peopleTbl.Allocate(out var builder))
using (Slice.From(tx.Allocator, Guid.NewGuid().ToString(), out var key))
{
builder.Add(key);
builder.Add(0L);
peopleTbl.Insert(builder);
}
using (Slice.From(tx.Allocator, new byte[8], out var empty))
{
var userIndex = usersTbl.GetFixedSizeTree(usersTbl.GetTree(indexDef), empty, 0, true);
var peopleIndex = peopleTbl.GetFixedSizeTree(usersTbl.GetTree(indexDef), empty, 0, true);
Assert.Equal(userIndex.NumberOfEntries, peopleIndex.NumberOfEntries);
Assert.Equal(userIndex.Type, peopleIndex.Type);
}
}
}
