public void CanDeleteStructsFromTrees()
{
var schema = new StructureSchema <IndexingStatsFields>()
.Add <int>(IndexingStatsFields.Attempts)
.Add <int>(IndexingStatsFields.Errors)
.Add <int>(IndexingStatsFields.Successes);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
var stats = new Structure <IndexingStatsFields>(schema);
stats.Set(IndexingStatsFields.Attempts, 5);
stats.Set(IndexingStatsFields.Errors, -1);
stats.Set(IndexingStatsFields.Successes, 4);
tree.WriteStruct("stats/1", stats);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("stats");
tree.Delete("stats/1");
var stats = tree.ReadStruct("stats/1", schema);
Assert.Null(stats);
}
}
public void Ctor_WhenUniqueIndexAccessorsIsInjected_ItExistsInListOfIndexAccessors()
{
var typeFake = new Mock <IStructureType>();
var idAccessorFake = new Mock <IIdAccessor>();
var conTokenFake = new Mock <IConcurrencyTokenAccessor>();
var timeStampFake = new Mock <ITimeStampAccessor>();
var indexAccessorFake = new Mock <IIndexAccessor>();
indexAccessorFake.Setup(x => x.Path).Returns("Plain");
indexAccessorFake.Setup(x => x.IsUnique).Returns(false);
var uniqueIndexAccessorFake = new Mock <IIndexAccessor>();
uniqueIndexAccessorFake.Setup(x => x.Path).Returns("Unique");
uniqueIndexAccessorFake.Setup(x => x.IsUnique).Returns(true);
var schema = new StructureSchema(
typeFake.Object,
idAccessorFake.Object,
conTokenFake.Object,
timeStampFake.Object,
new[] { indexAccessorFake.Object, uniqueIndexAccessorFake.Object });
Assert.IsTrue(schema.IndexAccessors.Any(iac => iac.Path == indexAccessorFake.Object.Path));
Assert.IsTrue(schema.IndexAccessors.Any(iac => iac.Path == uniqueIndexAccessorFake.Object.Path));
}
public void ShouldNotAllowToSkipVariableSizeFieldsByDefault()
{
var schema = new StructureSchema <MappedResults>()
.Add <int>(MappedResults.View)
.Add <string>(MappedResults.ReduceKey)
.Add <string>(MappedResults.DocId);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.State.Root.WriteStruct("structures/1", new Structure <MappedResults>(schema)
.Set(MappedResults.View, 1)
.Set(MappedResults.ReduceKey, "reduce")
.Set(MappedResults.DocId, "doc"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var ex = Assert.Throws <InvalidOperationException>(() => tx.State.Root.WriteStruct("structures/1", new Structure <MappedResults>(schema)
.Set(MappedResults.View, 2)));
Assert.Equal("Your structure schema defines variable size fields but you haven't set any. If you really want to skip those fields set AllowToSkipVariableSizeFields = true.", ex.Message);
Assert.DoesNotThrow(() => tx.State.Root.WriteStruct("structures/1", new Structure <MappedResults>(schema)
{
AllowToSkipVariableSizeFields = true
}.Set(MappedResults.View, 2)));
}
}
public void BasicStructureWithStringTest()
{
var schema = new StructureSchema<Enum>()
.Add<int>(MappedResults.View)
.Add<string>(MappedResults.ReduceKey);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1",
new Structure<Enum>(schema)
.Set(MappedResults.View, 3)
.Set(MappedResults.ReduceKey, "reduce_key"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree("stats");
var mappedResults = readTree.ReadStruct("items/1", schema).Reader;
Assert.Equal(3, mappedResults.ReadInt(MappedResults.View));
Assert.Equal("reduce_key", mappedResults.ReadString(MappedResults.ReduceKey));
}
}
public StructReadResult <T> ReadStruct <T>(string treeName, Slice key, StructureSchema <T> schema, WriteBatch writeBatch = null)
{
Tree tree = null;
if (writeBatch != null && writeBatch.IsEmpty == false)
{
WriteBatch.InBatchValue result;
if (writeBatch.TryGetValue(treeName, key, out result))
{
if (!result.Version.HasValue)
{
tree = GetTree(treeName);
}
switch (result.OperationType)
{
case WriteBatch.BatchOperationType.AddStruct:
return(new StructReadResult <T>(new StructureReader <T>((Structure <T>)result.Struct, schema), result.Version.HasValue ? (ushort)(result.Version.Value + 1) : tree.ReadVersion(key)));
case WriteBatch.BatchOperationType.Delete:
return(null);
}
}
}
if (tree == null)
{
tree = GetTree(treeName);
}
return(tree.ReadStruct(key, schema));
}
public void BasicStructureWithStringTest()
{
var schema = new StructureSchema <Enum>()
.Add <int>(MappedResults.View)
.Add <string>(MappedResults.ReduceKey);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1",
new Structure <Enum>(schema)
.Set(MappedResults.View, 3)
.Set(MappedResults.ReduceKey, "reduce_key"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree("stats");
var mappedResults = readTree.ReadStruct("items/1", schema).Reader;
Assert.Equal(3, mappedResults.ReadInt(MappedResults.View));
Assert.Equal("reduce_key", mappedResults.ReadString(MappedResults.ReduceKey));
}
}
public void Should_assign_empty_index_accessors_When_not_passed()
{
var structureType = new StructureType(typeof(Foo));
var schema = new StructureSchema(structureType);
schema.IndexAccessors.Should().BeEmpty();
}
public void Should_initialize_type_and_name()
{
var structureType = new StructureType(typeof(Foo));
var schema = new StructureSchema(structureType);
schema.StructureType.Type.Should().Be(typeof(Foo));
schema.Name.Should().Be(typeof(Foo).Name);
}
public void Should_assign_index_accessors_When_present()
{
var structureType = new StructureType(typeof(Foo));
var schema = new StructureSchema(structureType, new List <IIndexAccessor> {
Mock.Of <IIndexAccessor>()
});
schema.IndexAccessors.Should().HaveCount(1);
}
public void ShouldThrowWhenSettingDifferentValueTypeThanDefinedInSchema()
{
var schema = new StructureSchema <SchemaFields>()
.Add <int>(SchemaFields.Count);
var structure = new Structure <SchemaFields>(schema);
var invalidData = Assert.Throws <InvalidDataException>(() => structure.Set(SchemaFields.Count, (long)1));
Assert.Equal("Attempt to set a field value which type is different than defined in the structure schema. Expected: System.Int32, got: System.Int64", invalidData.Message);
}
public StructReadResult <T> ReadStruct <T>(Slice key, StructureSchema <T> schema)
{
var readResult = Read(key);
if (readResult == null)
{
return(null);
}
return(new StructReadResult <T>(new StructureReader <T>(readResult.Reader.Base, schema), readResult.Version));
}
public void ComplexStructureTest()
{
var now = DateTime.Now;
var etag = new byte[16]
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6
};
var schema = new StructureSchema <MappedResults>()
.Add <int>(MappedResults.View)
.Add <long>(MappedResults.Bucket)
.Add <long>(MappedResults.TimestampBinary)
.Add <string>(MappedResults.ReduceKey)
.Add <string>(MappedResults.DocId)
.Add <byte[]>(MappedResults.Etag);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1",
new Structure <MappedResults>(schema)
.Set(MappedResults.View, 3)
.Set(MappedResults.Bucket, 999L)
.Set(MappedResults.TimestampBinary, now.ToBinary())
.Set(MappedResults.ReduceKey, "reduce_key")
.Set(MappedResults.DocId, "orders/1")
.Set(MappedResults.Etag, etag));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree("stats");
var mappedResults = readTree.ReadStruct("items/1", schema).Reader;
Assert.Equal(3, mappedResults.ReadInt(MappedResults.View));
Assert.Equal("reduce_key", mappedResults.ReadString(MappedResults.ReduceKey));
Assert.Equal(999, mappedResults.ReadLong(MappedResults.Bucket));
Assert.Equal("orders/1", mappedResults.ReadString(MappedResults.DocId));
Assert.Equal(etag, mappedResults.ReadBytes(MappedResults.Etag));
Assert.Equal(now, DateTime.FromBinary(mappedResults.ReadLong(MappedResults.TimestampBinary)));
}
}
public void CanReadStructsFromTreeIterator()
{
var statsSchema = new StructureSchema <IndexingStatsFields>()
.Add <int>(IndexingStatsFields.Attempts)
.Add <string>(IndexingStatsFields.Message);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1", new Structure <IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 1)
.Set(IndexingStatsFields.Message, "1"));
tree.WriteStruct("items/2", new Structure <IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 2)
.Set(IndexingStatsFields.Message, "2"));
tree.WriteStruct("items/3", new Structure <IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 3)
.Set(IndexingStatsFields.Message, "3"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var iterator = tx.ReadTree("stats").Iterate();
iterator.Seek(Slice.BeforeAllKeys);
var count = 0;
do
{
var stats = iterator.ReadStructForCurrent(statsSchema);
count++;
Assert.Equal(count, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(count.ToString(CultureInfo.InvariantCulture), stats.ReadString(IndexingStatsFields.Message));
} while (iterator.MoveNext());
Assert.Equal(3, count);
}
}
public void ShouldThrowOnAttemptToPartialWriteOfVariableFields()
{
var schema = new StructureSchema <SchemaFields>()
.Add <string>(SchemaFields.Message)
.Add <string>(SchemaFields.Additional_Info);
var structure = new Structure <SchemaFields>(schema);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
structure.Set(SchemaFields.Message, "hello");
var invalidOperationException = Assert.Throws <InvalidOperationException>(() => tree.WriteStruct("items/1", structure));
Assert.Equal("Your structure has variable size fields. You have to set all of them to properly write a structure and avoid overlapping fields. Missing fields: Additional_Info", invalidOperationException.Message);
}
}
public void ShouldThrowWhenSettingUndefinedField()
{
var schema = new StructureSchema<SchemaFields>()
.Add<int>(SchemaFields.Count)
.Add<string>(SchemaFields.Message);
var structure = new Structure<SchemaFields>(schema);
Assert.DoesNotThrow(() => structure.Set(SchemaFields.Count, 1));
Assert.DoesNotThrow(() => structure.Set(SchemaFields.Message, "hello"));
var ae = Assert.Throws<ArgumentException>(() => structure.Set(SchemaFields.Does_Not_Exist, 1));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
ae = Assert.Throws<ArgumentException>(() => structure.Set(SchemaFields.Does_Not_Exist, "hello"));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
ae = Assert.Throws<ArgumentException>(() => structure.Increment(SchemaFields.Does_Not_Exist, 1));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
}
public void CanReadAndWriteStructsFromTrees()
{
var indexedAt = new DateTime(2015, 1, 20);
var schema = new StructureSchema <IndexingStatsFields>()
.Add <int>(IndexingStatsFields.Attempts)
.Add <int>(IndexingStatsFields.Errors)
.Add <int>(IndexingStatsFields.Successes)
.Add <byte>(IndexingStatsFields.IsValid)
.Add <long>(IndexingStatsFields.IndexedAt);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
var stats = new Structure <IndexingStatsFields>(schema);
stats.Set(IndexingStatsFields.Attempts, 5);
stats.Set(IndexingStatsFields.Errors, -1);
stats.Set(IndexingStatsFields.Successes, 4);
stats.Set(IndexingStatsFields.IsValid, (byte)1);
stats.Set(IndexingStatsFields.IndexedAt, indexedAt.ToBinary());
tree.WriteStruct("stats/1", stats);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("stats");
var stats = tree.ReadStruct("stats/1", schema).Reader;
Assert.Equal(5, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(-1, stats.ReadInt(IndexingStatsFields.Errors));
Assert.Equal(4, stats.ReadInt(IndexingStatsFields.Successes));
Assert.Equal(1, stats.ReadByte(IndexingStatsFields.IsValid));
Assert.Equal(indexedAt, DateTime.FromBinary(stats.ReadLong(IndexingStatsFields.IndexedAt)));
}
}
public void ShouldThrowWhenSettingUndefinedField()
{
var schema = new StructureSchema <SchemaFields>()
.Add <int>(SchemaFields.Count)
.Add <string>(SchemaFields.Message);
var structure = new Structure <SchemaFields>(schema);
Assert.DoesNotThrow(() => structure.Set(SchemaFields.Count, 1));
Assert.DoesNotThrow(() => structure.Set(SchemaFields.Message, "hello"));
var ae = Assert.Throws <ArgumentException>(() => structure.Set(SchemaFields.Does_Not_Exist, 1));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
ae = Assert.Throws <ArgumentException>(() => structure.Set(SchemaFields.Does_Not_Exist, "hello"));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
ae = Assert.Throws <ArgumentException>(() => structure.Increment(SchemaFields.Does_Not_Exist, 1));
Assert.Equal("No such field in schema defined. Field name: Does_Not_Exist", ae.Message);
}
public void MultipleStringFieldsShouldBeWrittenInProperOrder()
{
var schema = new StructureSchema <HelloWorld>()
.Add <string>(HelloWorld.Hello)
.Add <string>(HelloWorld.World);
var structure = new Structure <HelloWorld>(schema);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
structure.Set(HelloWorld.World, "W0rld!"); // set 2nd value first
structure.Set(HelloWorld.Hello, "Hell0"); // set 1st value in second operation
tree.WriteStruct("items/1", structure);
var structReader = tree.ReadStruct("items/1", schema).Reader;
Assert.Equal("Hell0", structReader.ReadString(HelloWorld.Hello));
Assert.Equal("W0rld!", structReader.ReadString(HelloWorld.World));
}
}
public void ComplexStructureTest()
{
var now = DateTime.Now;
var etag = new byte[16]
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6
};
var schema = new StructureSchema<MappedResults>()
.Add<int>(MappedResults.View)
.Add<long>(MappedResults.Bucket)
.Add<long>(MappedResults.TimestampBinary)
.Add<string>(MappedResults.ReduceKey)
.Add<string>(MappedResults.DocId)
.Add<byte[]>(MappedResults.Etag);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1",
new Structure<MappedResults>(schema)
.Set(MappedResults.View, 3)
.Set(MappedResults.Bucket, 999L)
.Set(MappedResults.TimestampBinary, now.ToBinary())
.Set(MappedResults.ReduceKey, "reduce_key")
.Set(MappedResults.DocId, "orders/1")
.Set(MappedResults.Etag, etag));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree("stats");
var mappedResults = readTree.ReadStruct("items/1", schema).Reader;
Assert.Equal(3, mappedResults.ReadInt(MappedResults.View));
Assert.Equal("reduce_key", mappedResults.ReadString(MappedResults.ReduceKey));
Assert.Equal(999, mappedResults.ReadLong(MappedResults.Bucket));
Assert.Equal("orders/1", mappedResults.ReadString(MappedResults.DocId));
Assert.Equal(etag, mappedResults.ReadBytes(MappedResults.Etag));
Assert.Equal(now, DateTime.FromBinary(mappedResults.ReadLong(MappedResults.TimestampBinary)));
}
}
public void MultipleStringFieldsShouldBeWrittenInProperOrder()
{
var schema = new StructureSchema<HelloWorld>()
.Add<string>(HelloWorld.Hello)
.Add<string>(HelloWorld.World);
var structure = new Structure<HelloWorld>(schema);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
structure.Set(HelloWorld.World, "W0rld!"); // set 2nd value first
structure.Set(HelloWorld.Hello, "Hell0"); // set 1st value in second operation
tree.WriteStruct("items/1", structure);
var structReader = tree.ReadStruct("items/1", schema).Reader;
Assert.Equal("Hell0", structReader.ReadString(HelloWorld.Hello));
Assert.Equal("W0rld!", structReader.ReadString(HelloWorld.World));
}
}
public void CanReadStructsFromTreeIterator()
{
var statsSchema = new StructureSchema<IndexingStatsFields>()
.Add<int>(IndexingStatsFields.Attempts)
.Add<string>(IndexingStatsFields.Message);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
tree.WriteStruct("items/1", new Structure<IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 1)
.Set(IndexingStatsFields.Message, "1"));
tree.WriteStruct("items/2", new Structure<IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 2)
.Set(IndexingStatsFields.Message, "2"));
tree.WriteStruct("items/3", new Structure<IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 3)
.Set(IndexingStatsFields.Message, "3"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var iterator = tx.ReadTree("stats").Iterate();
iterator.Seek(Slice.BeforeAllKeys);
var count = 0;
do
{
var stats = iterator.ReadStructForCurrent(statsSchema);
count++;
Assert.Equal(count, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(count.ToString(CultureInfo.InvariantCulture), stats.ReadString(IndexingStatsFields.Message));
} while (iterator.MoveNext());
Assert.Equal(3, count);
}
}
public void CanWriteStructsByUsingWriteBatchAndReadFromSnapshot()
{
var statsSchema = new StructureSchema<IndexingStatsFields>()
.Add<int>(IndexingStatsFields.Attempts)
.Add<int>(IndexingStatsFields.Errors)
.Add<int>(IndexingStatsFields.Successes)
.Add<string>(IndexingStatsFields.Message);
var operationSchema = new StructureSchema<IndexingStatsFields>()
.Add<int>(IndexingStatsFields.Attempts)
.Add<int>(IndexingStatsFields.Successes)
.Add<string>(IndexingStatsFields.Message);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(tx, "stats");
Env.CreateTree(tx, "operations");
tx.Commit();
}
var batch = new WriteBatch();
batch.AddStruct("stats/1",
new Structure<IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 5)
.Set(IndexingStatsFields.Errors, -1)
.Set(IndexingStatsFields.Successes, 4)
.Set(IndexingStatsFields.Message, "hello world"),
"stats");
batch.AddStruct("operations/1",
new Structure<IndexingStatsFields>(operationSchema)
.Set(IndexingStatsFields.Attempts, 10)
.Set(IndexingStatsFields.Successes, 10)
.Set(IndexingStatsFields.Message, "hello world"),
"operations");
using (var snapshot = Env.CreateSnapshot())
{
var stats = snapshot.ReadStruct("stats", "stats/1", statsSchema, batch).Reader;
Assert.Equal(5, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(-1, stats.ReadInt(IndexingStatsFields.Errors));
Assert.Equal(4, stats.ReadInt(IndexingStatsFields.Successes));
Assert.Equal("hello world", stats.ReadString(IndexingStatsFields.Message));
}
Env.Writer.Write(batch);
using (var snapshot = Env.CreateSnapshot())
{
var operation = snapshot.ReadStruct("operations", "operations/1", operationSchema).Reader;
Assert.Equal(10, operation.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(10, operation.ReadInt(IndexingStatsFields.Successes));
Assert.Equal("hello world", operation.ReadString(IndexingStatsFields.Message));
}
batch.Delete("stats/1", "stats");
using (var snapshot = Env.CreateSnapshot())
{
var stats = snapshot.ReadStruct("stats", "stats/1", statsSchema, batch);
Assert.Null(stats);
}
}
public void CanWriteStructsByUsingWriteBatchAndReadFromSnapshot()
{
var statsSchema = new StructureSchema <IndexingStatsFields>()
.Add <int>(IndexingStatsFields.Attempts)
.Add <int>(IndexingStatsFields.Errors)
.Add <int>(IndexingStatsFields.Successes)
.Add <string>(IndexingStatsFields.Message);
var operationSchema = new StructureSchema <IndexingStatsFields>()
.Add <int>(IndexingStatsFields.Attempts)
.Add <int>(IndexingStatsFields.Successes)
.Add <string>(IndexingStatsFields.Message);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(tx, "stats");
Env.CreateTree(tx, "operations");
tx.Commit();
}
var batch = new WriteBatch();
batch.AddStruct("stats/1",
new Structure <IndexingStatsFields>(statsSchema)
.Set(IndexingStatsFields.Attempts, 5)
.Set(IndexingStatsFields.Errors, -1)
.Set(IndexingStatsFields.Successes, 4)
.Set(IndexingStatsFields.Message, "hello world"),
"stats");
batch.AddStruct("operations/1",
new Structure <IndexingStatsFields>(operationSchema)
.Set(IndexingStatsFields.Attempts, 10)
.Set(IndexingStatsFields.Successes, 10)
.Set(IndexingStatsFields.Message, "hello world"),
"operations");
using (var snapshot = Env.CreateSnapshot())
{
var stats = snapshot.ReadStruct("stats", "stats/1", statsSchema, batch).Reader;
Assert.Equal(5, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(-1, stats.ReadInt(IndexingStatsFields.Errors));
Assert.Equal(4, stats.ReadInt(IndexingStatsFields.Successes));
Assert.Equal("hello world", stats.ReadString(IndexingStatsFields.Message));
}
Env.Writer.Write(batch);
using (var snapshot = Env.CreateSnapshot())
{
var operation = snapshot.ReadStruct("operations", "operations/1", operationSchema).Reader;
Assert.Equal(10, operation.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(10, operation.ReadInt(IndexingStatsFields.Successes));
Assert.Equal("hello world", operation.ReadString(IndexingStatsFields.Message));
}
batch.Delete("stats/1", "stats");
using (var snapshot = Env.CreateSnapshot())
{
var stats = snapshot.ReadStruct("stats", "stats/1", statsSchema, batch);
Assert.Null(stats);
}
}
public StructureReader <T> ReadStructForCurrent <T>(StructureSchema <T> schema)
{
throw new InvalidOperationException("No current page");
}
public void ShouldThrowOnAttemptToPartialWriteOfVariableFields()
{
var schema = new StructureSchema<SchemaFields>()
.Add<string>(SchemaFields.Message)
.Add<string>(SchemaFields.Additional_Info);
var structure = new Structure<SchemaFields>(schema);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
structure.Set(SchemaFields.Message, "hello");
var invalidOperationException = Assert.Throws<InvalidOperationException>(() => tree.WriteStruct("items/1", structure));
Assert.Equal("Your structure has variable size fields. You have to set all of them to properly write a structure and avoid overlapping fields. Missing fields: Additional_Info", invalidOperationException.Message);
}
}
public void CanWriteAndReadAllPrimitiveTypesAndDecimals()
{
var schema = new StructureSchema<PrimitiveFields>()
.Add<sbyte>(PrimitiveFields.@sbyte)
.Add<byte>(PrimitiveFields.@byte)
.Add<short>(PrimitiveFields.@short)
.Add<ushort>(PrimitiveFields.@ushort)
.Add<int>(PrimitiveFields.@int)
.Add<uint>(PrimitiveFields.@uint)
.Add<long>(PrimitiveFields.@long)
.Add<ulong>(PrimitiveFields.@ulong)
.Add<char>(PrimitiveFields.@char)
.Add<float>(PrimitiveFields.@float)
.Add<double>(PrimitiveFields.@double)
.Add<decimal>(PrimitiveFields.@decimal)
.Add<bool>(PrimitiveFields.@bool);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "primitives");
tree.WriteStruct("primitives/1",
new Structure<PrimitiveFields>(schema)
.Set(PrimitiveFields.@sbyte, sbyte.MaxValue)
.Set(PrimitiveFields.@byte, byte.MaxValue)
.Set(PrimitiveFields.@short, short.MaxValue)
.Set(PrimitiveFields.@ushort, ushort.MaxValue)
.Set(PrimitiveFields.@int, int.MaxValue)
.Set(PrimitiveFields.@uint, uint.MaxValue)
.Set(PrimitiveFields.@long, long.MaxValue)
.Set(PrimitiveFields.@ulong, ulong.MaxValue)
.Set(PrimitiveFields.@char, char.MaxValue)
.Set(PrimitiveFields.@float, float.MaxValue)
.Set(PrimitiveFields.@double, double.MaxValue)
.Set(PrimitiveFields.@decimal, decimal.MaxValue)
.Set(PrimitiveFields.@bool, false));
var primitives = tree.ReadStruct("primitives/1", schema).Reader;
Assert.Equal(sbyte.MaxValue, primitives.ReadSByte(PrimitiveFields.@sbyte));
Assert.Equal(byte.MaxValue, primitives.ReadByte(PrimitiveFields.@byte));
Assert.Equal(short.MaxValue, primitives.ReadShort(PrimitiveFields.@short));
Assert.Equal(ushort.MaxValue, primitives.ReadUShort(PrimitiveFields.@ushort));
Assert.Equal(int.MaxValue, primitives.ReadInt(PrimitiveFields.@int));
Assert.Equal(uint.MaxValue, primitives.ReadUInt(PrimitiveFields.@uint));
Assert.Equal(long.MaxValue, primitives.ReadLong(PrimitiveFields.@long));
Assert.Equal(ulong.MaxValue, primitives.ReadULong(PrimitiveFields.@ulong));
Assert.Equal(char.MaxValue, primitives.ReadChar(PrimitiveFields.@char));
Assert.Equal(float.MaxValue, primitives.ReadFloat(PrimitiveFields.@float));
Assert.Equal(double.MaxValue, primitives.ReadDouble(PrimitiveFields.@double));
Assert.Equal(decimal.MaxValue, primitives.ReadDecimal(PrimitiveFields.@decimal));
Assert.Equal(false, primitives.ReadBool(PrimitiveFields.@bool));
tree.WriteStruct("primitives/1",
new Structure<PrimitiveFields>(schema)
.Increment(PrimitiveFields.@sbyte, -1 * sbyte.MaxValue)
.Increment(PrimitiveFields.@short, -1 * short.MaxValue)
.Increment(PrimitiveFields.@int, -1 * int.MaxValue)
.Increment(PrimitiveFields.@long, -1 * long.MaxValue));
primitives = tree.ReadStruct("primitives/1", schema).Reader;
Assert.Equal(0, primitives.ReadSByte(PrimitiveFields.@sbyte));
Assert.Equal(0, primitives.ReadShort(PrimitiveFields.@short));
Assert.Equal(0, primitives.ReadInt(PrimitiveFields.@int));
Assert.Equal(0, primitives.ReadLong(PrimitiveFields.@long));
tree.WriteStruct("primitives/2",
new Structure<PrimitiveFields>(schema)
.Set(PrimitiveFields.@byte, (byte) 0)
.Set(PrimitiveFields.@ushort, (ushort) 0)
.Set(PrimitiveFields.@uint, (uint) 0)
.Set(PrimitiveFields.@ulong, (ulong) 0)
.Set(PrimitiveFields.@float, 0f)
.Set(PrimitiveFields.@double, 0d)
.Set(PrimitiveFields.@decimal, (decimal) 0)
.Set(PrimitiveFields.@char, 'a'));
tree.WriteStruct("primitives/2",
new Structure<PrimitiveFields>(schema)
.Increment(PrimitiveFields.@byte, 1)
.Increment(PrimitiveFields.@ushort, 2)
.Increment(PrimitiveFields.@uint, 3)
.Increment(PrimitiveFields.@ulong, 4)
.Increment(PrimitiveFields.@float, -1)
.Increment(PrimitiveFields.@double, -2)
.Increment(PrimitiveFields.@decimal, -3)
.Increment(PrimitiveFields.@char, 1));
var primitives2 = tree.ReadStruct("primitives/2", schema).Reader;
Assert.Equal(1, primitives2.ReadByte(PrimitiveFields.@byte));
Assert.Equal(2, primitives2.ReadUShort(PrimitiveFields.@ushort));
Assert.Equal((uint) 3, primitives2.ReadUInt(PrimitiveFields.@uint));
Assert.Equal((ulong) 4, primitives2.ReadULong(PrimitiveFields.@ulong));
Assert.Equal(-1, primitives2.ReadFloat(PrimitiveFields.@float));
Assert.Equal(-2, primitives2.ReadDouble(PrimitiveFields.@double));
Assert.Equal(-3, primitives2.ReadDecimal(PrimitiveFields.@decimal));
Assert.Equal('b', primitives2.ReadChar(PrimitiveFields.@char));
}
}
public StructureReader <T> ReadStructForCurrent <T>(StructureSchema <T> schema)
{
throw new NotSupportedException("Multi trees do not support reading/writing structures");
}
public void CanWriteAndReadAllPrimitiveTypesAndDecimals()
{
var schema = new StructureSchema <PrimitiveFields>()
.Add <sbyte>(PrimitiveFields.@sbyte)
.Add <byte>(PrimitiveFields.@byte)
.Add <short>(PrimitiveFields.@short)
.Add <ushort>(PrimitiveFields.@ushort)
.Add <int>(PrimitiveFields.@int)
.Add <uint>(PrimitiveFields.@uint)
.Add <long>(PrimitiveFields.@long)
.Add <ulong>(PrimitiveFields.@ulong)
.Add <char>(PrimitiveFields.@char)
.Add <float>(PrimitiveFields.@float)
.Add <double>(PrimitiveFields.@double)
.Add <decimal>(PrimitiveFields.@decimal)
.Add <bool>(PrimitiveFields.@bool);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "primitives");
tree.WriteStruct("primitives/1",
new Structure <PrimitiveFields>(schema)
.Set(PrimitiveFields.@sbyte, sbyte.MaxValue)
.Set(PrimitiveFields.@byte, byte.MaxValue)
.Set(PrimitiveFields.@short, short.MaxValue)
.Set(PrimitiveFields.@ushort, ushort.MaxValue)
.Set(PrimitiveFields.@int, int.MaxValue)
.Set(PrimitiveFields.@uint, uint.MaxValue)
.Set(PrimitiveFields.@long, long.MaxValue)
.Set(PrimitiveFields.@ulong, ulong.MaxValue)
.Set(PrimitiveFields.@char, char.MaxValue)
.Set(PrimitiveFields.@float, float.MaxValue)
.Set(PrimitiveFields.@double, double.MaxValue)
.Set(PrimitiveFields.@decimal, decimal.MaxValue)
.Set(PrimitiveFields.@bool, false));
var primitives = tree.ReadStruct("primitives/1", schema).Reader;
Assert.Equal(sbyte.MaxValue, primitives.ReadSByte(PrimitiveFields.@sbyte));
Assert.Equal(byte.MaxValue, primitives.ReadByte(PrimitiveFields.@byte));
Assert.Equal(short.MaxValue, primitives.ReadShort(PrimitiveFields.@short));
Assert.Equal(ushort.MaxValue, primitives.ReadUShort(PrimitiveFields.@ushort));
Assert.Equal(int.MaxValue, primitives.ReadInt(PrimitiveFields.@int));
Assert.Equal(uint.MaxValue, primitives.ReadUInt(PrimitiveFields.@uint));
Assert.Equal(long.MaxValue, primitives.ReadLong(PrimitiveFields.@long));
Assert.Equal(ulong.MaxValue, primitives.ReadULong(PrimitiveFields.@ulong));
Assert.Equal(char.MaxValue, primitives.ReadChar(PrimitiveFields.@char));
Assert.Equal(float.MaxValue, primitives.ReadFloat(PrimitiveFields.@float));
Assert.Equal(double.MaxValue, primitives.ReadDouble(PrimitiveFields.@double));
Assert.Equal(decimal.MaxValue, primitives.ReadDecimal(PrimitiveFields.@decimal));
Assert.Equal(false, primitives.ReadBool(PrimitiveFields.@bool));
tree.WriteStruct("primitives/1",
new Structure <PrimitiveFields>(schema)
.Increment(PrimitiveFields.@sbyte, -1 * sbyte.MaxValue)
.Increment(PrimitiveFields.@short, -1 * short.MaxValue)
.Increment(PrimitiveFields.@int, -1 * int.MaxValue)
.Increment(PrimitiveFields.@long, -1 * long.MaxValue));
primitives = tree.ReadStruct("primitives/1", schema).Reader;
Assert.Equal(0, primitives.ReadSByte(PrimitiveFields.@sbyte));
Assert.Equal(0, primitives.ReadShort(PrimitiveFields.@short));
Assert.Equal(0, primitives.ReadInt(PrimitiveFields.@int));
Assert.Equal(0, primitives.ReadLong(PrimitiveFields.@long));
tree.WriteStruct("primitives/2",
new Structure <PrimitiveFields>(schema)
.Set(PrimitiveFields.@byte, (byte)0)
.Set(PrimitiveFields.@ushort, (ushort)0)
.Set(PrimitiveFields.@uint, (uint)0)
.Set(PrimitiveFields.@ulong, (ulong)0)
.Set(PrimitiveFields.@float, 0f)
.Set(PrimitiveFields.@double, 0d)
.Set(PrimitiveFields.@decimal, (decimal)0)
.Set(PrimitiveFields.@char, 'a'));
tree.WriteStruct("primitives/2",
new Structure <PrimitiveFields>(schema)
.Increment(PrimitiveFields.@byte, 1)
.Increment(PrimitiveFields.@ushort, 2)
.Increment(PrimitiveFields.@uint, 3)
.Increment(PrimitiveFields.@ulong, 4)
.Increment(PrimitiveFields.@float, -1)
.Increment(PrimitiveFields.@double, -2)
.Increment(PrimitiveFields.@decimal, -3)
.Increment(PrimitiveFields.@char, 1));
var primitives2 = tree.ReadStruct("primitives/2", schema).Reader;
Assert.Equal(1, primitives2.ReadByte(PrimitiveFields.@byte));
Assert.Equal(2, primitives2.ReadUShort(PrimitiveFields.@ushort));
Assert.Equal((uint)3, primitives2.ReadUInt(PrimitiveFields.@uint));
Assert.Equal((ulong)4, primitives2.ReadULong(PrimitiveFields.@ulong));
Assert.Equal(-1, primitives2.ReadFloat(PrimitiveFields.@float));
Assert.Equal(-2, primitives2.ReadDouble(PrimitiveFields.@double));
Assert.Equal(-3, primitives2.ReadDecimal(PrimitiveFields.@decimal));
Assert.Equal('b', primitives2.ReadChar(PrimitiveFields.@char));
}
}
public void ShouldNotAllowToSkipVariableSizeFieldsByDefault()
{
var schema = new StructureSchema<MappedResults>()
.Add<int>(MappedResults.View)
.Add<string>(MappedResults.ReduceKey)
.Add<string>(MappedResults.DocId);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.State.Root.WriteStruct("structures/1", new Structure<MappedResults>(schema)
.Set(MappedResults.View, 1)
.Set(MappedResults.ReduceKey, "reduce")
.Set(MappedResults.DocId, "doc"));
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var ex = Assert.Throws<InvalidOperationException>(() => tx.State.Root.WriteStruct("structures/1", new Structure<MappedResults>(schema)
.Set(MappedResults.View, 2)));
Assert.Equal("Your structure schema defines variable size fields but you haven't set any. If you really want to skip those fields set AllowToSkipVariableSizeFields = true.", ex.Message);
Assert.DoesNotThrow(() => tx.State.Root.WriteStruct("structures/1", new Structure<MappedResults>(schema)
{
AllowToSkipVariableSizeFields = true
}.Set(MappedResults.View, 2)));
}
}
public void Record_debug_journal_and_replay_it()
{
var structSchema = new StructureSchema<SampleStruct>()
.Add<int>(SampleStruct.Foo)
.Add<string>(SampleStruct.Bar);
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = new DebugJournal(debugJouralName, env, true);
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "test-tree");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
var valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("{ \"title\": \"foo\",\"name\":\"bar\"}"));
writeBatch.Add("foo", valueBuffer, "test-tree");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2!"));
writeBatch.Add("bar", valueBuffer, "test-tree");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2 3!"));
writeBatch.Add("foo-bar", valueBuffer, "test-tree");
writeBatch.MultiAdd("multi-foo", "AA", "test-tree");
env.Writer.Write(writeBatch);
}
using (var writeBatch = new WriteBatch())
{
writeBatch.Increment("incr-key", 5, "test-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
Assert.Equal(5, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
using (var writeBatch = new WriteBatch())
{
writeBatch.Increment("incr-key", 5, "test-tree");
env.Writer.Write(writeBatch);
}
Assert.Equal(5, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
}
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
Assert.Equal(10, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
}
using (var writeBatch = new WriteBatch())
{
writeBatch.MultiAdd("multi-foo", "BB", "test-tree");
writeBatch.MultiAdd("multi-foo", "CC", "test-tree");
writeBatch.Delete("foo-bar", "test-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "test-tree2");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
var valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1!"));
writeBatch.Add("foo", valueBuffer, "test-tree2");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2!"));
writeBatch.Add("bar", valueBuffer, "test-tree2");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2 3!"));
writeBatch.Add("foo-bar", valueBuffer, "test-tree2");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "structures-tree");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
writeBatch.AddStruct("structs/1", new Structure<SampleStruct>(structSchema)
.Set(SampleStruct.Foo, 13)
.Set(SampleStruct.Bar, "debug journal testing"),
"structures-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "rename-me");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
writeBatch.Add("item", "renaming tree test", "rename-me");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.RenameTree(tx, "rename-me", "renamed");
tx.Commit();
}
}
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = DebugJournal.FromFile(debugJouralName, env);
env.DebugJournal.Replay();
using (var snapshot = env.CreateSnapshot())
{
Assert.Equal("{ \"title\": \"foo\",\"name\":\"bar\"}", snapshot.Read("test-tree", "foo").Reader.ToStringValue());
Assert.Equal("testing testing 1 2!", snapshot.Read("test-tree", "bar").Reader.ToStringValue());
Assert.Equal("testing testing 1!", snapshot.Read("test-tree2", "foo").Reader.ToStringValue());
Assert.Equal("testing testing 1 2!", snapshot.Read("test-tree2", "bar").Reader.ToStringValue());
Assert.Equal("testing testing 1 2 3!", snapshot.Read("test-tree2", "foo-bar").Reader.ToStringValue());
Assert.Equal(10, snapshot.Read("test-tree", "incr-key").Reader.ReadLittleEndianInt64());
Assert.Equal(0,snapshot.ReadVersion("test-tree","foo-bar"));
using (var iter = snapshot.MultiRead("test-tree","multi-foo"))
{
iter.Seek(Slice.BeforeAllKeys);
Assert.Equal("AA",iter.CurrentKey.ToString());
Assert.DoesNotThrow(() => iter.MoveNext());
Assert.Equal("BB",iter.CurrentKey.ToString());
Assert.DoesNotThrow(() => iter.MoveNext());
Assert.Equal("CC",iter.CurrentKey.ToString());
}
var structReader = snapshot.ReadStruct("structures-tree", "structs/1", structSchema).Reader;
Assert.Equal(13, structReader.ReadInt(SampleStruct.Foo));
Assert.Equal("debug journal testing", structReader.ReadString(SampleStruct.Bar));
Assert.Equal("renaming tree test", snapshot.Read("renamed", "item").Reader.ToStringValue());
}
}
}
public void ShouldThrowWhenSettingDifferentValueTypeThanDefinedInSchema()
{
var schema = new StructureSchema<SchemaFields>()
.Add<int>(SchemaFields.Count);
var structure = new Structure<SchemaFields>(schema);
var invalidData = Assert.Throws<InvalidDataException>(() => structure.Set(SchemaFields.Count, (long) 1));
Assert.Equal("Attempt to set a field value which type is different than defined in the structure schema. Expected: System.Int32, got: System.Int64", invalidData.Message);
}
public void Record_debug_journal_and_replay_it()
{
var structSchema = new StructureSchema <SampleStruct>()
.Add <int>(SampleStruct.Foo)
.Add <string>(SampleStruct.Bar);
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = new DebugJournal(debugJouralName, env, true);
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "test-tree");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
var valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("{ \"title\": \"foo\",\"name\":\"bar\"}"));
writeBatch.Add("foo", valueBuffer, "test-tree");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2!"));
writeBatch.Add("bar", valueBuffer, "test-tree");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2 3!"));
writeBatch.Add("foo-bar", valueBuffer, "test-tree");
writeBatch.MultiAdd("multi-foo", "AA", "test-tree");
env.Writer.Write(writeBatch);
}
using (var writeBatch = new WriteBatch())
{
writeBatch.Increment("incr-key", 5, "test-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
Assert.Equal(5, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
using (var writeBatch = new WriteBatch())
{
writeBatch.Increment("incr-key", 5, "test-tree");
env.Writer.Write(writeBatch);
}
Assert.Equal(5, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
}
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
Assert.Equal(10, tx.ReadTree("test-tree").Read("incr-key").Reader.ReadLittleEndianInt64());
}
using (var writeBatch = new WriteBatch())
{
writeBatch.MultiAdd("multi-foo", "BB", "test-tree");
writeBatch.MultiAdd("multi-foo", "CC", "test-tree");
writeBatch.Delete("foo-bar", "test-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "test-tree2");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
var valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1!"));
writeBatch.Add("foo", valueBuffer, "test-tree2");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2!"));
writeBatch.Add("bar", valueBuffer, "test-tree2");
valueBuffer = new MemoryStream(Encoding.UTF8.GetBytes("testing testing 1 2 3!"));
writeBatch.Add("foo-bar", valueBuffer, "test-tree2");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "structures-tree");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
writeBatch.AddStruct("structs/1", new Structure <SampleStruct>(structSchema)
.Set(SampleStruct.Foo, 13)
.Set(SampleStruct.Bar, "debug journal testing"),
"structures-tree");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.CreateTree(tx, "rename-me");
tx.Commit();
}
using (var writeBatch = new WriteBatch())
{
writeBatch.Add("item", "renaming tree test", "rename-me");
env.Writer.Write(writeBatch);
}
using (var tx = env.NewTransaction(TransactionFlags.ReadWrite))
{
env.RenameTree(tx, "rename-me", "renamed");
tx.Commit();
}
}
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = DebugJournal.FromFile(debugJouralName, env);
env.DebugJournal.Replay();
using (var snapshot = env.CreateSnapshot())
{
Assert.Equal("{ \"title\": \"foo\",\"name\":\"bar\"}", snapshot.Read("test-tree", "foo").Reader.ToStringValue());
Assert.Equal("testing testing 1 2!", snapshot.Read("test-tree", "bar").Reader.ToStringValue());
Assert.Equal("testing testing 1!", snapshot.Read("test-tree2", "foo").Reader.ToStringValue());
Assert.Equal("testing testing 1 2!", snapshot.Read("test-tree2", "bar").Reader.ToStringValue());
Assert.Equal("testing testing 1 2 3!", snapshot.Read("test-tree2", "foo-bar").Reader.ToStringValue());
Assert.Equal(10, snapshot.Read("test-tree", "incr-key").Reader.ReadLittleEndianInt64());
Assert.Equal(0, snapshot.ReadVersion("test-tree", "foo-bar"));
using (var iter = snapshot.MultiRead("test-tree", "multi-foo"))
{
iter.Seek(Slice.BeforeAllKeys);
Assert.Equal("AA", iter.CurrentKey.ToString());
Assert.DoesNotThrow(() => iter.MoveNext());
Assert.Equal("BB", iter.CurrentKey.ToString());
Assert.DoesNotThrow(() => iter.MoveNext());
Assert.Equal("CC", iter.CurrentKey.ToString());
}
var structReader = snapshot.ReadStruct("structures-tree", "structs/1", structSchema).Reader;
Assert.Equal(13, structReader.ReadInt(SampleStruct.Foo));
Assert.Equal("debug journal testing", structReader.ReadString(SampleStruct.Bar));
Assert.Equal("renaming tree test", snapshot.Read("renamed", "item").Reader.ToStringValue());
}
}
}
public StructureReader <T> ReadStructForCurrent <T>(StructureSchema <T> schema)
{
var valueReader = NodeHeader.Reader(_tx, Current);
return(new StructureReader <T>(valueReader.Base, schema));
}
public void CanReadAndWriteStructsFromTrees()
{
var indexedAt = new DateTime(2015, 1, 20);
var schema = new StructureSchema<IndexingStatsFields>()
.Add<int>(IndexingStatsFields.Attempts)
.Add<int>(IndexingStatsFields.Errors)
.Add<int>(IndexingStatsFields.Successes)
.Add<byte>(IndexingStatsFields.IsValid)
.Add<long>(IndexingStatsFields.IndexedAt);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
var stats = new Structure<IndexingStatsFields>(schema);
stats.Set(IndexingStatsFields.Attempts, 5);
stats.Set(IndexingStatsFields.Errors, -1);
stats.Set(IndexingStatsFields.Successes, 4);
stats.Set(IndexingStatsFields.IsValid, (byte) 1);
stats.Set(IndexingStatsFields.IndexedAt, indexedAt.ToBinary());
tree.WriteStruct("stats/1", stats);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("stats");
var stats = tree.ReadStruct("stats/1", schema).Reader;
Assert.Equal(5, stats.ReadInt(IndexingStatsFields.Attempts));
Assert.Equal(-1, stats.ReadInt(IndexingStatsFields.Errors));
Assert.Equal(4, stats.ReadInt(IndexingStatsFields.Successes));
Assert.Equal(1, stats.ReadByte(IndexingStatsFields.IsValid));
Assert.Equal(indexedAt, DateTime.FromBinary(stats.ReadLong(IndexingStatsFields.IndexedAt)));
}
}
public TableOfStructures(string tableName, StructureSchema <T> schema, IBufferPool bufferPool, params string[] indexNames) : base(tableName, bufferPool, indexNames)
{
Schema = schema;
}
public void CanDeleteStructsFromTrees()
{
var schema = new StructureSchema<IndexingStatsFields>()
.Add<int>(IndexingStatsFields.Attempts)
.Add<int>(IndexingStatsFields.Errors)
.Add<int>(IndexingStatsFields.Successes);
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "stats");
var stats = new Structure<IndexingStatsFields>(schema);
stats.Set(IndexingStatsFields.Attempts, 5);
stats.Set(IndexingStatsFields.Errors, -1);
stats.Set(IndexingStatsFields.Successes, 4);
tree.WriteStruct("stats/1", stats);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("stats");
tree.Delete("stats/1");
var stats = tree.ReadStruct("stats/1", schema);
Assert.Null(stats);
}
}
