public void ErrorsOnInvalidSchemaWithSingleVariableIndex()
{
using (var tx = Env.WriteTransaction())
{
var expectedSchema = new TableSchema();
var def = new TableSchema.SchemaIndexDef
{
Count = 3,
StartIndex = 2,
};
Slice.From(tx.Allocator, "Test Name", ByteStringType.Immutable, out def.Name);
expectedSchema.DefineIndex(def);
var actualSchema = new TableSchema();
def = new TableSchema.SchemaIndexDef
{
StartIndex = 4,
};
Slice.From(tx.Allocator, "Bad Test Name", ByteStringType.Immutable, out def.Name);
actualSchema.DefineIndex(def);
Assert.Throws <ArgumentNullException>(delegate { expectedSchema.Validate(null); });
Assert.Throws <ArgumentException>(delegate { expectedSchema.Validate(actualSchema); });
}
}
private static Tree GetNewErrorTimestampsTreeFromErrorsTable(UpdateStep step, Slice errorTimestampsSlice)
{
var newTableSchema = new TableSchema();
var indexDef = new TableSchema.SchemaIndexDef
{
StartIndex = 0,
IsGlobal = false,
Name = errorTimestampsSlice
};
newTableSchema.DefineIndex(indexDef);
newTableSchema.Create(step.WriteTx, "Errors", 16);
var newErrorsTable = step.WriteTx.OpenTable(newTableSchema, "Errors");
var newErrorsTableTableTree = step.WriteTx.ReadTree("Errors", RootObjectType.Table);
byte *ptr;
using (var indexTree = Tree.Create(step.WriteTx.LowLevelTransaction, step.WriteTx, indexDef.Name, isIndexTree: true))
{
using (newErrorsTableTableTree.DirectAdd(indexDef.Name, sizeof(TreeRootHeader), out ptr))
{
indexTree.State.CopyTo((TreeRootHeader *)ptr);
}
}
var newErrorTimestampsIndexTree = newErrorsTable.GetTree(newTableSchema.Indexes[errorTimestampsSlice]);
return(newErrorTimestampsIndexTree);
}
public void Update_same_value_to_index_doesnt_throw()
{
using (var tx = Env.WriteTransaction())
{
Slice.From(tx.Allocator, "EtagIndexName", out var etagIndexName);
var index = new TableSchema.SchemaIndexDef
{
Name = etagIndexName,
StartIndex = 0,
Count = 1
};
var tableSchema = new TableSchema()
.DefineIndex(index)
.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 0,
Count = 1,
});
tableSchema.Create(tx, "Items", 16);
var itemsTable = tx.OpenTable(tableSchema, "Items");
const long number1 = 1L;
const long number2 = 2L;
const long number3 = 3L;
using (itemsTable.Allocate(out TableValueBuilder builder))
using (Slice.From(tx.Allocator, "val1", out var key))
{
builder.Add(key);
builder.Add(Bits.SwapBytes(number1));
itemsTable.Set(builder);
}
using (itemsTable.Allocate(out TableValueBuilder builder))
using (Slice.From(tx.Allocator, "val2", out var key))
{
builder.Add(key);
builder.Add(Bits.SwapBytes(number2));
itemsTable.Set(builder);
}
using (itemsTable.Allocate(out TableValueBuilder builder))
using (Slice.From(tx.Allocator, "val1", out var key))
{
builder.Add(key);
builder.Add(Bits.SwapBytes(number3));
itemsTable.Set(builder);
}
using (itemsTable.Allocate(out TableValueBuilder builder))
using (Slice.From(tx.Allocator, "val2", out var key))
{
builder.Add(key);
builder.Add(Bits.SwapBytes(number3));
itemsTable.Set(builder);
}
}
}
public void CanSerializeMultiIndexSchema()
{
using (var tx = Env.WriteTransaction())
{
var def1 = new TableSchema.SchemaIndexDef
{
StartIndex = 2,
Count = 1,
};
Slice.From(tx.Allocator, "Test Name 1", ByteStringType.Immutable, out def1.Name);
var def2 = new TableSchema.SchemaIndexDef
{
StartIndex = 1,
Count = 1,
};
Slice.From(tx.Allocator, "Test Name 2", ByteStringType.Immutable, out def2.Name);
var def3 = new TableSchema.FixedSizeSchemaIndexDef()
{
StartIndex = 2,
IsGlobal = true,
};
Slice.From(tx.Allocator, "Test Name 3", ByteStringType.Immutable, out def3.Name);
var tableSchema = new TableSchema()
.DefineIndex(def1)
.DefineIndex(def2)
.DefineFixedSizeIndex(def3)
.DefineKey(new TableSchema.SchemaIndexDef
{
StartIndex = 3,
Count = 1,
});
byte[] serialized = tableSchema.SerializeSchema();
fixed(byte *ptr = serialized)
{
var actualTableSchema = TableSchema.ReadFrom(tx.Allocator, ptr, serialized.Length);
// This checks that reserializing is the same
Assert.Equal(serialized, actualTableSchema.SerializeSchema());
// This checks that what was deserialized is correct
SchemaDefEqual(tableSchema, actualTableSchema);
tableSchema.Validate(actualTableSchema);
}
}
}
private void DeleteFromTable(DocumentsOperationContext context, Table table, TableSchema.SchemaIndexDef pk, Func <Table.TableValueHolder, bool> shouldSkip = null)
{
Table.TableValueHolder tableValueHolder = null;
var tree = table.GetTree(pk);
var last = Slices.BeforeAllKeys;
while (true)
{
using (var it = tree.Iterate(true))
{
it.SetRequiredPrefix(last);
if (it.Seek(it.RequiredPrefix) == false)
{
return;
}
while (true)
{
long id = it.CreateReaderForCurrent().ReadLittleEndianInt64();
if (shouldSkip != null)
{
var ptr = table.DirectRead(id, out int size);
if (tableValueHolder == null)
{
tableValueHolder = new Table.TableValueHolder();
}
tableValueHolder.Reader = new TableValueReader(id, ptr, size);
if (shouldSkip.Invoke(tableValueHolder))
{
last = it.CurrentKey.Clone(context.Allocator);
if (it.MoveNext() == false)
{
return;
}
continue;
}
}
table.Delete(id);
break;
}
}
}
}
private void SchemaIndexDefEqual(TableSchema.SchemaIndexDef expectedIndex,
TableSchema.SchemaIndexDef actualIndex)
{
if (expectedIndex == null)
{
Assert.Equal(null, actualIndex);
}
else
{
Assert.Equal(expectedIndex.IsGlobal, actualIndex.IsGlobal);
Assert.Equal(expectedIndex.Count, actualIndex.Count);
Assert.True(SliceComparer.Equals(expectedIndex.Name, actualIndex.Name));
Assert.Equal(expectedIndex.StartIndex, actualIndex.StartIndex);
Assert.Equal(expectedIndex.Type, actualIndex.Type);
}
}
public GraphStorage(StorageEnvironment env, bool ownsStorageEnvironment)
{
_env = env;
this._ownsStorageEnvironment = ownsStorageEnvironment;
_byteStringContext = new ByteStringContext();
var fromToIndexByteString = _byteStringContext.From(nameof(FromToIndex));
FromToIndex = new TableSchema.SchemaIndexDef
{
Name = nameof(FromToIndex),
NameAsSlice = new Slice(fromToIndexByteString),
StartIndex = (int)EdgeTableFields.FromKey,
Count = 2,
IsGlobal = true
};
CreateSchema();
}
public void ErrorsOnInvalidVariableSizeDef()
{
using (var tx = Env.WriteTransaction())
{
var expectedIndex = new TableSchema.SchemaIndexDef
{
StartIndex = 2,
Count = 1,
};
Slice.From(tx.Allocator, "Test Name", ByteStringType.Immutable, out expectedIndex.Name);
var actualIndex = new TableSchema.SchemaIndexDef
{
StartIndex = 1,
Count = 1,
};
Slice.From(tx.Allocator, "Bad Test Name", ByteStringType.Immutable, out actualIndex.Name);
Assert.Throws <ArgumentNullException>(delegate { expectedIndex.Validate(null); });
Assert.Throws <ArgumentException>(delegate { expectedIndex.Validate(actualIndex); });
}
}
public void CanSerializeNormalIndex()
{
using (var tx = Env.WriteTransaction())
{
var expectedIndex = new TableSchema.SchemaIndexDef
{
StartIndex = 2,
Count = 1,
};
Slice.From(tx.Allocator, "Test Name", ByteStringType.Immutable, out expectedIndex.Name);
byte[] serialized = expectedIndex.Serialize();
fixed(byte *serializedPtr = serialized)
{
var actualIndex = TableSchema.SchemaIndexDef.ReadFrom(tx.Allocator, serializedPtr, serialized.Length);
Assert.Equal(serialized, actualIndex.Serialize());
SchemaIndexDefEqual(expectedIndex, actualIndex);
expectedIndex.Validate(actualIndex);
}
}
}
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);
}
}
}
