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); } }