From 1944a0883ef9cc05dd80d2db104b04d01f87b66a Mon Sep 17 00:00:00 2001 From: Aaron Craelius Date: Mon, 7 Feb 2022 12:58:55 -0500 Subject: [PATCH] feat(orm)!: ordered variable length encoding for uint32 and uint64 types (#11090) ## Description `uint64` values are used in the ORM as auto-incrementing primary keys. Always using 8 bytes for these values is a bit of a waste of space. Unfortunately, varint encoding does not support ordered prefix iteration. This PR introduces a compact, well-ordered variable length encoding for `uint32` and `uint64` types. `fixed32` and `fixed64` integers are still encoded as 4 and 8 byte fixed-length big-endian arrays. With this, users have a choice of encoding based on what type of data they are storing. An auto-incrementing primary key should prefer the variable length `uint64` whereas a fixed precision decimal might want to use `fixed64`. See the golden test updates to see how this reduces key lengths. This encoding works by using the first two bits to encode the buffer length (4 possible lengths). I'm not sure if my choice of 2,4,6 and 9 bytes is the right choice of 4 lenths for `uint64` - there are many alternate choices. I could have also chosen 3 bits and allowed for 8 possible lengths, but way waste an extra bit? Input on the right design parameters would be appreciated. --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/master/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/master/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- orm/encoding/ormfield/codec.go | 12 +- orm/encoding/ormfield/codec_test.go | 94 +++ orm/encoding/ormfield/uint32.go | 159 +++- orm/encoding/ormfield/uint64.go | 171 ++++- .../ormtable/testdata/test_auto_inc.golden | 26 +- .../ormtable/testdata/test_scenario.golden | 682 +++++++++--------- proto/cosmos/orm/v1alpha1/orm.proto | 13 +- 7 files changed, 780 insertions(+), 377 deletions(-) diff --git a/orm/encoding/ormfield/codec.go b/orm/encoding/ormfield/codec.go index 7100737e5cb2..fa0acaed1f3f 100644 --- a/orm/encoding/ormfield/codec.go +++ b/orm/encoding/ormfield/codec.go @@ -78,10 +78,14 @@ func GetCodec(field protoreflect.FieldDescriptor, nonTerminal bool) (Codec, erro } else { return StringCodec{}, nil } - case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: - return Uint32Codec{}, nil - case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: - return Uint64Codec{}, nil + case protoreflect.Uint32Kind: + return CompactUint32Codec{}, nil + case protoreflect.Fixed32Kind: + return FixedUint32Codec{}, nil + case protoreflect.Uint64Kind: + return CompactUint64Codec{}, nil + case protoreflect.Fixed64Kind: + return FixedUint64Codec{}, nil case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return Int32Codec{}, nil case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: diff --git a/orm/encoding/ormfield/codec_test.go b/orm/encoding/ormfield/codec_test.go index a2e447d4ceb7..94da353dc469 100644 --- a/orm/encoding/ormfield/codec_test.go +++ b/orm/encoding/ormfield/codec_test.go @@ -85,3 +85,97 @@ func TestNTBytesTooLong(t *testing.T) { _, err = cdc.ComputeBufferSize(bz) assert.ErrorContains(t, err, ormerrors.BytesFieldTooLong.Error()) } + +func TestCompactUInt32(t *testing.T) { + var lastBz []byte + testEncodeDecode := func(x uint32, expectedLen int) { + bz := ormfield.EncodeCompactUint32(x) + assert.Equal(t, expectedLen, len(bz)) + y, err := ormfield.DecodeCompactUint32(bytes.NewReader(bz)) + assert.NilError(t, err) + assert.Equal(t, x, y) + assert.Assert(t, bytes.Compare(lastBz, bz) < 0) + lastBz = bz + } + + testEncodeDecode(64, 2) + testEncodeDecode(16383, 2) + testEncodeDecode(16384, 3) + testEncodeDecode(4194303, 3) + testEncodeDecode(4194304, 4) + testEncodeDecode(1073741823, 4) + testEncodeDecode(1073741824, 5) + + // randomized tests + rapid.Check(t, func(t *rapid.T) { + x := rapid.Uint32().Draw(t, "x").(uint32) + y := rapid.Uint32().Draw(t, "y").(uint32) + + bx := ormfield.EncodeCompactUint32(x) + by := ormfield.EncodeCompactUint32(y) + + cmp := bytes.Compare(bx, by) + if x < y { + assert.Equal(t, -1, cmp) + } else if x == y { + assert.Equal(t, 0, cmp) + } else { + assert.Equal(t, 1, cmp) + } + + x2, err := ormfield.DecodeCompactUint32(bytes.NewReader(bx)) + assert.NilError(t, err) + assert.Equal(t, x, x2) + y2, err := ormfield.DecodeCompactUint32(bytes.NewReader(by)) + assert.NilError(t, err) + assert.Equal(t, y, y2) + }) +} + +func TestCompactUInt64(t *testing.T) { + var lastBz []byte + testEncodeDecode := func(x uint64, expectedLen int) { + bz := ormfield.EncodeCompactUint64(x) + assert.Equal(t, expectedLen, len(bz)) + y, err := ormfield.DecodeCompactUint64(bytes.NewReader(bz)) + assert.NilError(t, err) + assert.Equal(t, x, y) + assert.Assert(t, bytes.Compare(lastBz, bz) < 0) + lastBz = bz + } + + testEncodeDecode(64, 2) + testEncodeDecode(16383, 2) + testEncodeDecode(16384, 4) + testEncodeDecode(4194303, 4) + testEncodeDecode(4194304, 4) + testEncodeDecode(1073741823, 4) + testEncodeDecode(1073741824, 6) + testEncodeDecode(70368744177663, 6) + testEncodeDecode(70368744177664, 9) + + // randomized tests + rapid.Check(t, func(t *rapid.T) { + x := rapid.Uint64().Draw(t, "x").(uint64) + y := rapid.Uint64().Draw(t, "y").(uint64) + + bx := ormfield.EncodeCompactUint64(x) + by := ormfield.EncodeCompactUint64(y) + + cmp := bytes.Compare(bx, by) + if x < y { + assert.Equal(t, -1, cmp) + } else if x == y { + assert.Equal(t, 0, cmp) + } else { + assert.Equal(t, 1, cmp) + } + + x2, err := ormfield.DecodeCompactUint64(bytes.NewReader(bx)) + assert.NilError(t, err) + assert.Equal(t, x, x2) + y2, err := ormfield.DecodeCompactUint64(bytes.NewReader(by)) + assert.NilError(t, err) + assert.Equal(t, y, y2) + }) +} diff --git a/orm/encoding/ormfield/uint32.go b/orm/encoding/ormfield/uint32.go index fbb15e1b909f..748808f01414 100644 --- a/orm/encoding/ormfield/uint32.go +++ b/orm/encoding/ormfield/uint32.go @@ -2,36 +2,179 @@ package ormfield import ( "encoding/binary" + "fmt" "io" "google.golang.org/protobuf/reflect/protoreflect" ) -// Uint32Codec encodes uint32 values as 4-byte big-endian integers. -type Uint32Codec struct{} +// FixedUint32Codec encodes uint32 values as 4-byte big-endian integers. +type FixedUint32Codec struct{} -func (u Uint32Codec) FixedBufferSize() int { +func (u FixedUint32Codec) FixedBufferSize() int { return 4 } -func (u Uint32Codec) ComputeBufferSize(protoreflect.Value) (int, error) { +func (u FixedUint32Codec) ComputeBufferSize(protoreflect.Value) (int, error) { return u.FixedBufferSize(), nil } -func (u Uint32Codec) IsOrdered() bool { +func (u FixedUint32Codec) IsOrdered() bool { return true } -func (u Uint32Codec) Compare(v1, v2 protoreflect.Value) int { +func (u FixedUint32Codec) Compare(v1, v2 protoreflect.Value) int { return compareUint(v1, v2) } -func (u Uint32Codec) Decode(r Reader) (protoreflect.Value, error) { +func (u FixedUint32Codec) Decode(r Reader) (protoreflect.Value, error) { var x uint32 err := binary.Read(r, binary.BigEndian, &x) return protoreflect.ValueOfUint32(x), err } -func (u Uint32Codec) Encode(value protoreflect.Value, w io.Writer) error { +func (u FixedUint32Codec) Encode(value protoreflect.Value, w io.Writer) error { return binary.Write(w, binary.BigEndian, uint32(value.Uint())) } + +// CompactUint32Codec encodes uint32 values using EncodeCompactUint32. +type CompactUint32Codec struct{} + +func (c CompactUint32Codec) Decode(r Reader) (protoreflect.Value, error) { + x, err := DecodeCompactUint32(r) + return protoreflect.ValueOfUint32(x), err +} + +func (c CompactUint32Codec) Encode(value protoreflect.Value, w io.Writer) error { + _, err := w.Write(EncodeCompactUint32(uint32(value.Uint()))) + return err +} + +func (c CompactUint32Codec) Compare(v1, v2 protoreflect.Value) int { + return compareUint(v1, v2) +} + +func (c CompactUint32Codec) IsOrdered() bool { + return true +} + +func (c CompactUint32Codec) FixedBufferSize() int { + return 5 +} + +func (c CompactUint32Codec) ComputeBufferSize(protoreflect.Value) (int, error) { + return c.FixedBufferSize(), nil +} + +// EncodeCompactUint32 encodes uint32 values in 2,3,4 or 5 bytes. +// Unlike regular varints, this encoding is +// suitable for ordered prefix scans. The length of the output + 2 is encoded +// in the first 2 bits of the first byte and the remaining bits encoded with +// big-endian ordering. +// Values less than 2^14 fill fit in 2 bytes, values less than 2^22 will +// fit in 3, and values less than 2^30 will fit in 4. +func EncodeCompactUint32(x uint32) []byte { + switch { + case x < 16384: // 2^14 + buf := make([]byte, 2) + buf[0] = byte(x >> 8) + buf[1] = byte(x) + return buf + case x < 4194304: // 2^22 + buf := make([]byte, 3) + buf[0] = 0x40 + buf[0] |= byte(x >> 16) + buf[1] = byte(x >> 8) + buf[2] = byte(x) + return buf + case x < 1073741824: // 2^30 + buf := make([]byte, 4) + buf[0] = 0x80 + buf[0] |= byte(x >> 24) + buf[1] = byte(x >> 16) + buf[2] = byte(x >> 8) + buf[3] = byte(x) + return buf + default: + buf := make([]byte, 5) + buf[0] = 0xC0 + buf[0] |= byte(x >> 26) + buf[1] = byte(x >> 18) + buf[2] = byte(x >> 10) + buf[3] = byte(x >> 2) + buf[4] = byte(x) & 0x3 + return buf + } +} + +// DecodeCompactUint32 decodes a uint32 encoded with EncodeCompactU32. +func DecodeCompactUint32(reader io.Reader) (uint32, error) { + var buf [5]byte + + n, err := reader.Read(buf[:1]) + if err != nil { + return 0, err + } + if n < 1 { + return 0, io.ErrUnexpectedEOF + } + + switch buf[0] >> 6 { + case 0: + n, err := reader.Read(buf[1:2]) + if err != nil { + return 0, err + } + if n < 1 { + return 0, io.ErrUnexpectedEOF + } + + x := uint32(buf[0]) << 8 + x |= uint32(buf[1]) + return x, nil + case 1: + n, err := reader.Read(buf[1:3]) + if err != nil { + return 0, err + } + if n < 2 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint32(buf[0]) & 0x3F) << 16 + x |= uint32(buf[1]) << 8 + x |= uint32(buf[2]) + return x, nil + case 2: + n, err := reader.Read(buf[1:4]) + if err != nil { + return 0, err + } + if n < 3 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint32(buf[0]) & 0x3F) << 24 + x |= uint32(buf[1]) << 16 + x |= uint32(buf[2]) << 8 + x |= uint32(buf[3]) + return x, nil + case 3: + n, err := reader.Read(buf[1:5]) + if err != nil { + return 0, err + } + if n < 4 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint32(buf[0]) & 0x3F) << 26 + x |= uint32(buf[1]) << 18 + x |= uint32(buf[2]) << 10 + x |= uint32(buf[3]) << 2 + x |= uint32(buf[4]) + return x, nil + default: + return 0, fmt.Errorf("unexpected case") + } +} diff --git a/orm/encoding/ormfield/uint64.go b/orm/encoding/ormfield/uint64.go index 6cc5c463725b..57bf324c247b 100644 --- a/orm/encoding/ormfield/uint64.go +++ b/orm/encoding/ormfield/uint64.go @@ -2,37 +2,38 @@ package ormfield import ( "encoding/binary" + "fmt" "io" "google.golang.org/protobuf/reflect/protoreflect" ) -// Uint64Codec encodes uint64 values as 8-byte big-endian integers. -type Uint64Codec struct{} +// FixedUint64Codec encodes uint64 values as 8-byte big-endian integers. +type FixedUint64Codec struct{} -func (u Uint64Codec) FixedBufferSize() int { +func (u FixedUint64Codec) FixedBufferSize() int { return 8 } -func (u Uint64Codec) ComputeBufferSize(protoreflect.Value) (int, error) { +func (u FixedUint64Codec) ComputeBufferSize(protoreflect.Value) (int, error) { return u.FixedBufferSize(), nil } -func (u Uint64Codec) IsOrdered() bool { +func (u FixedUint64Codec) IsOrdered() bool { return true } -func (u Uint64Codec) Compare(v1, v2 protoreflect.Value) int { +func (u FixedUint64Codec) Compare(v1, v2 protoreflect.Value) int { return compareUint(v1, v2) } -func (u Uint64Codec) Decode(r Reader) (protoreflect.Value, error) { +func (u FixedUint64Codec) Decode(r Reader) (protoreflect.Value, error) { var x uint64 err := binary.Read(r, binary.BigEndian, &x) return protoreflect.ValueOfUint64(x), err } -func (u Uint64Codec) Encode(value protoreflect.Value, w io.Writer) error { +func (u FixedUint64Codec) Encode(value protoreflect.Value, w io.Writer) error { return binary.Write(w, binary.BigEndian, value.Uint()) } @@ -47,3 +48,157 @@ func compareUint(v1, v2 protoreflect.Value) int { return 1 } } + +// CompactUint64Codec encodes uint64 values using EncodeCompactUint64. +type CompactUint64Codec struct{} + +func (c CompactUint64Codec) Decode(r Reader) (protoreflect.Value, error) { + x, err := DecodeCompactUint64(r) + return protoreflect.ValueOfUint64(x), err +} + +func (c CompactUint64Codec) Encode(value protoreflect.Value, w io.Writer) error { + _, err := w.Write(EncodeCompactUint64(value.Uint())) + return err +} + +func (c CompactUint64Codec) Compare(v1, v2 protoreflect.Value) int { + return compareUint(v1, v2) +} + +func (c CompactUint64Codec) IsOrdered() bool { + return true +} + +func (c CompactUint64Codec) FixedBufferSize() int { + return 9 +} + +func (c CompactUint64Codec) ComputeBufferSize(protoreflect.Value) (int, error) { + return c.FixedBufferSize(), nil +} + +// EncodeCompactUint64 encodes uint64 values in 2,4,6 or 9 bytes. +// Unlike regular varints, this encoding is +// suitable for ordered prefix scans. The first two bits of the first byte +// indicate the length of the buffer - 00 for 2, 01 for 4, 10 for 6 and +// 11 for 9. The remaining bits are encoded with big-endian ordering. +// Values less than 2^14 fill fit in 2 bytes, values less than 2^30 will +// fit in 4, and values less than 2^46 will fit in 6. +func EncodeCompactUint64(x uint64) []byte { + switch { + case x < 16384: // 2^14 + buf := make([]byte, 2) + buf[0] = byte(x >> 8) + buf[1] = byte(x) + return buf + case x < 1073741824: // 2^30 + buf := make([]byte, 4) + buf[0] = 0x40 + buf[0] |= byte(x >> 24) + buf[1] = byte(x >> 16) + buf[2] = byte(x >> 8) + buf[3] = byte(x) + return buf + case x < 70368744177664: // 2^46 + buf := make([]byte, 6) + buf[0] = 0x80 + buf[0] |= byte(x >> 40) + buf[1] = byte(x >> 32) + buf[2] = byte(x >> 24) + buf[3] = byte(x >> 16) + buf[4] = byte(x >> 8) + buf[5] = byte(x) + return buf + default: + buf := make([]byte, 9) + buf[0] = 0xC0 + buf[0] |= byte(x >> 58) + buf[1] = byte(x >> 50) + buf[2] = byte(x >> 42) + buf[3] = byte(x >> 34) + buf[4] = byte(x >> 26) + buf[5] = byte(x >> 18) + buf[6] = byte(x >> 10) + buf[7] = byte(x >> 2) + buf[8] = byte(x) & 0x3 + return buf + } +} + +func DecodeCompactUint64(reader io.Reader) (uint64, error) { + var buf [9]byte + n, err := reader.Read(buf[:1]) + if err != nil { + return 0, err + } + if n < 1 { + return 0, io.ErrUnexpectedEOF + } + + switch buf[0] >> 6 { + case 0: + n, err := reader.Read(buf[1:2]) + if err != nil { + return 0, err + } + if n < 1 { + return 0, io.ErrUnexpectedEOF + } + + x := uint64(buf[0]) << 8 + x |= uint64(buf[1]) + return x, nil + case 1: + n, err := reader.Read(buf[1:4]) + if err != nil { + return 0, err + } + if n < 3 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint64(buf[0]) & 0x3F) << 24 + x |= uint64(buf[1]) << 16 + x |= uint64(buf[2]) << 8 + x |= uint64(buf[3]) + return x, nil + case 2: + n, err := reader.Read(buf[1:6]) + if err != nil { + return 0, err + } + if n < 5 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint64(buf[0]) & 0x3F) << 40 + x |= uint64(buf[1]) << 32 + x |= uint64(buf[2]) << 24 + x |= uint64(buf[3]) << 16 + x |= uint64(buf[4]) << 8 + x |= uint64(buf[5]) + return x, nil + case 3: + n, err := reader.Read(buf[1:9]) + if err != nil { + return 0, err + } + if n < 8 { + return 0, io.ErrUnexpectedEOF + } + + x := (uint64(buf[0]) & 0x3F) << 58 + x |= uint64(buf[1]) << 50 + x |= uint64(buf[2]) << 42 + x |= uint64(buf[3]) << 34 + x |= uint64(buf[4]) << 26 + x |= uint64(buf[5]) << 18 + x |= uint64(buf[6]) << 10 + x |= uint64(buf[7]) << 2 + x |= uint64(buf[8]) + return x, nil + default: + return 0, fmt.Errorf("unexpected case") + } +} diff --git a/orm/model/ormtable/testdata/test_auto_inc.golden b/orm/model/ormtable/testdata/test_auto_inc.golden index 48b05fe3082b..1b77680a0ee5 100644 --- a/orm/model/ormtable/testdata/test_auto_inc.golden +++ b/orm/model/ormtable/testdata/test_auto_inc.golden @@ -1,54 +1,54 @@ -GET 03000000000000000005 +GET 03000005 PK testpb.ExampleAutoIncrementTable 5 -> {"id":5} GET 03808002 SEQ testpb.ExampleAutoIncrementTable 0 -GET 03000000000000000001 +GET 03000001 PK testpb.ExampleAutoIncrementTable 1 -> {"id":1} ORM INSERT testpb.ExampleAutoIncrementTable {"id":1,"x":"foo","y":5} HAS 0301666f6f ERR:EOF -SET 03000000000000000001 1203666f6f1805 +SET 03000001 1203666f6f1805 PK testpb.ExampleAutoIncrementTable 1 -> {"id":1,"x":"foo","y":5} SET 03808002 01 SEQ testpb.ExampleAutoIncrementTable 1 -SET 0301666f6f 0000000000000001 +SET 0301666f6f 0001 UNIQ testpb.ExampleAutoIncrementTable x : foo -> 1 GET 03808002 01 SEQ testpb.ExampleAutoIncrementTable 1 -GET 03000000000000000002 +GET 03000002 PK testpb.ExampleAutoIncrementTable 2 -> {"id":2} ORM INSERT testpb.ExampleAutoIncrementTable {"id":2,"x":"bar","y":10} HAS 0301626172 ERR:EOF -SET 03000000000000000002 1203626172180a +SET 03000002 1203626172180a PK testpb.ExampleAutoIncrementTable 2 -> {"id":2,"x":"bar","y":10} SET 03808002 02 SEQ testpb.ExampleAutoIncrementTable 2 -SET 0301626172 0000000000000002 +SET 0301626172 0002 UNIQ testpb.ExampleAutoIncrementTable x : bar -> 2 GET 03808002 02 SEQ testpb.ExampleAutoIncrementTable 2 ITERATOR 0300 -> 0301 VALID true - KEY 03000000000000000001 1203666f6f1805 + KEY 03000001 1203666f6f1805 PK testpb.ExampleAutoIncrementTable 1 -> {"id":1,"x":"foo","y":5} NEXT VALID true - KEY 03000000000000000002 1203626172180a + KEY 03000002 1203626172180a PK testpb.ExampleAutoIncrementTable 2 -> {"id":2,"x":"bar","y":10} NEXT VALID false ITERATOR 0300 -> 0301 VALID true - KEY 03000000000000000001 1203666f6f1805 + KEY 03000001 1203666f6f1805 PK testpb.ExampleAutoIncrementTable 1 -> {"id":1,"x":"foo","y":5} - KEY 03000000000000000001 1203666f6f1805 + KEY 03000001 1203666f6f1805 PK testpb.ExampleAutoIncrementTable 1 -> {"id":1,"x":"foo","y":5} NEXT VALID true - KEY 03000000000000000002 1203626172180a + KEY 03000002 1203626172180a PK testpb.ExampleAutoIncrementTable 2 -> {"id":2,"x":"bar","y":10} - KEY 03000000000000000002 1203626172180a + KEY 03000002 1203626172180a PK testpb.ExampleAutoIncrementTable 2 -> {"id":2,"x":"bar","y":10} NEXT VALID false diff --git a/orm/model/ormtable/testdata/test_scenario.golden b/orm/model/ormtable/testdata/test_scenario.golden index 57010bfea466..3f55342eeeec 100644 --- a/orm/model/ormtable/testdata/test_scenario.golden +++ b/orm/model/ormtable/testdata/test_scenario.golden @@ -1,336 +1,336 @@ -GET 0100000000047ffffffffffffffe616263 +GET 010000047ffffffffffffffe616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"str":"abc","i64":-2} ORM INSERT testpb.ExampleTable {"u32":4,"u64":7,"str":"abc","i64":-2} -HAS 01010000000000000007616263 +HAS 01010007616263 ERR:EOF -SET 0100000000047ffffffffffffffe616263 1007 +SET 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} -SET 01010000000000000007616263 000000047ffffffffffffffe +SET 01010007616263 00047ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 7/abc -> 4/-2/abc -SET 010261626300000000047ffffffffffffffe +SET 01026162630000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abc/4/-2 -> 4/-2/abc -SET 01030061626300000000047ffffffffffffffe +SET 0103006162630000047ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/4/-2 -> 4/-2/abc ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 1007 + KEY 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID false -GET 0100000000047ffffffffffffffe616264 +GET 010000047ffffffffffffffe616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"str":"abd","i64":-2} ORM INSERT testpb.ExampleTable {"u32":4,"u64":7,"str":"abd","i64":-2} -HAS 01010000000000000007616264 +HAS 01010007616264 ERR:EOF -SET 0100000000047ffffffffffffffe616264 1007 +SET 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} -SET 01010000000000000007616264 000000047ffffffffffffffe +SET 01010007616264 00047ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 7/abd -> 4/-2/abd -SET 010261626400000000047ffffffffffffffe +SET 01026162640000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/4/-2 -> 4/-2/abd -SET 01030061626400000000047ffffffffffffffe +SET 0103006162640000047ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/4/-2 -> 4/-2/abd ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 1007 + KEY 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 1007 + KEY 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} NEXT VALID false -GET 0100000000047fffffffffffffff616263 +GET 010000047fffffffffffffff616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"str":"abc","i64":-1} ORM INSERT testpb.ExampleTable {"u32":4,"u64":8,"str":"abc","i64":-1} -HAS 01010000000000000008616263 +HAS 01010008616263 ERR:EOF -SET 0100000000047fffffffffffffff616263 1008 +SET 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} -SET 01010000000000000008616263 000000047fffffffffffffff +SET 01010008616263 00047fffffffffffffff UNIQ testpb.ExampleTable u64/str : 8/abc -> 4/-1/abc -SET 010261626300000000047fffffffffffffff +SET 01026162630000047fffffffffffffff IDX testpb.ExampleTable str/u32/i64 : abc/4/-1 -> 4/-1/abc -SET 01030061626300000000047fffffffffffffff +SET 0103006162630000047fffffffffffffff IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/4/-1 -> 4/-1/abc -GET 0100000000057ffffffffffffffe616264 +GET 010000057ffffffffffffffe616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"str":"abd","i64":-2} ORM INSERT testpb.ExampleTable {"u32":5,"u64":8,"str":"abd","i64":-2} -HAS 01010000000000000008616264 +HAS 01010008616264 ERR:EOF -SET 0100000000057ffffffffffffffe616264 1008 +SET 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} -SET 01010000000000000008616264 000000057ffffffffffffffe +SET 01010008616264 00057ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 8/abd -> 5/-2/abd -SET 010261626400000000057ffffffffffffffe +SET 01026162640000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/5/-2 -> 5/-2/abd -SET 01030061626400000000057ffffffffffffffe +SET 0103006162640000057ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/5/-2 -> 5/-2/abd -GET 0100000000057ffffffffffffffe616265 +GET 010000057ffffffffffffffe616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"str":"abe","i64":-2} ORM INSERT testpb.ExampleTable {"u32":5,"u64":9,"str":"abe","i64":-2} -HAS 01010000000000000009616265 +HAS 01010009616265 ERR:EOF -SET 0100000000057ffffffffffffffe616265 1009 +SET 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} -SET 01010000000000000009616265 000000057ffffffffffffffe +SET 01010009616265 00057ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 9/abe -> 5/-2/abe -SET 010261626500000000057ffffffffffffffe +SET 01026162650000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abe/5/-2 -> 5/-2/abe -SET 01030061626500000000057ffffffffffffffe +SET 0103006162650000057ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : []/abe/5/-2 -> 5/-2/abe -GET 0100000000077ffffffffffffffe616265 +GET 010000077ffffffffffffffe616265 PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"str":"abe","i64":-2} ORM INSERT testpb.ExampleTable {"u32":7,"u64":10,"str":"abe","i64":-2} -HAS 0101000000000000000a616265 +HAS 0101000a616265 ERR:EOF -SET 0100000000077ffffffffffffffe616265 100a +SET 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} -SET 0101000000000000000a616265 000000077ffffffffffffffe +SET 0101000a616265 00077ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 10/abe -> 7/-2/abe -SET 010261626500000000077ffffffffffffffe +SET 01026162650000077ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abe/7/-2 -> 7/-2/abe -SET 01030061626500000000077ffffffffffffffe +SET 0103006162650000077ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : []/abe/7/-2 -> 7/-2/abe -GET 0100000000077fffffffffffffff616265 +GET 010000077fffffffffffffff616265 PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"str":"abe","i64":-1} ORM INSERT testpb.ExampleTable {"u32":7,"u64":11,"str":"abe","i64":-1} -HAS 0101000000000000000b616265 +HAS 0101000b616265 ERR:EOF -SET 0100000000077fffffffffffffff616265 100b +SET 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} -SET 0101000000000000000b616265 000000077fffffffffffffff +SET 0101000b616265 00077fffffffffffffff UNIQ testpb.ExampleTable u64/str : 11/abe -> 7/-1/abe -SET 010261626500000000077fffffffffffffff +SET 01026162650000077fffffffffffffff IDX testpb.ExampleTable str/u32/i64 : abe/7/-1 -> 7/-1/abe -SET 01030061626500000000077fffffffffffffff +SET 0103006162650000077fffffffffffffff IDX testpb.ExampleTable bz/str/u32/i64 : []/abe/7/-1 -> 7/-1/abe -GET 0100000000087ffffffffffffffc616263 +GET 010000087ffffffffffffffc616263 PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"str":"abc","i64":-4} ORM INSERT testpb.ExampleTable {"u32":8,"u64":11,"str":"abc","i64":-4} -HAS 0101000000000000000b616263 +HAS 0101000b616263 ERR:EOF -SET 0100000000087ffffffffffffffc616263 100b +SET 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} -SET 0101000000000000000b616263 000000087ffffffffffffffc +SET 0101000b616263 00087ffffffffffffffc UNIQ testpb.ExampleTable u64/str : 11/abc -> 8/-4/abc -SET 010261626300000000087ffffffffffffffc +SET 01026162630000087ffffffffffffffc IDX testpb.ExampleTable str/u32/i64 : abc/8/-4 -> 8/-4/abc -SET 01030061626300000000087ffffffffffffffc +SET 0103006162630000087ffffffffffffffc IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/8/-4 -> 8/-4/abc -GET 0100000000088000000000000001616263 +GET 010000088000000000000001616263 PK testpb.ExampleTable 8/1/abc -> {"u32":8,"str":"abc","i64":1} ORM INSERT testpb.ExampleTable {"u32":8,"u64":12,"str":"abc","i64":1} -HAS 0101000000000000000c616263 +HAS 0101000c616263 ERR:EOF -SET 0100000000088000000000000001616263 100c +SET 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} -SET 0101000000000000000c616263 000000088000000000000001 +SET 0101000c616263 00088000000000000001 UNIQ testpb.ExampleTable u64/str : 12/abc -> 8/1/abc -SET 010261626300000000088000000000000001 +SET 01026162630000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abc/8/1 -> 8/1/abc -SET 01030061626300000000088000000000000001 +SET 0103006162630000088000000000000001 IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/8/1 -> 8/1/abc -GET 0100000000088000000000000001616264 +GET 010000088000000000000001616264 PK testpb.ExampleTable 8/1/abd -> {"u32":8,"str":"abd","i64":1} ORM INSERT testpb.ExampleTable {"u32":8,"u64":10,"str":"abd","i64":1} -HAS 0101000000000000000a616264 +HAS 0101000a616264 ERR:EOF -SET 0100000000088000000000000001616264 100a +SET 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} -SET 0101000000000000000a616264 000000088000000000000001 +SET 0101000a616264 00088000000000000001 UNIQ testpb.ExampleTable u64/str : 10/abd -> 8/1/abd -SET 010261626400000000088000000000000001 +SET 01026162640000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abd/8/1 -> 8/1/abd -SET 01030061626400000000088000000000000001 +SET 0103006162640000088000000000000001 IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/8/1 -> 8/1/abd -ITERATOR 010000000008 -> 010000000009 +ITERATOR 01000008 -> 01000009 VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false -ITERATOR 010000000004 <- 010000000005 +ITERATOR 01000004 <- 01000005 VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 1007 + KEY 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616263 1007 + KEY 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID false -ITERATOR 0100000000047fffffffffffffff -> 010000000008 +ITERATOR 010000047fffffffffffffff -> 01000008 VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID false -ITERATOR 0100000000057ffffffffffffffd -> 010000000008800000000000000161626300 +ITERATOR 010000057ffffffffffffffd -> 01000008800000000000000161626300 VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID false ITERATOR 010261626300 <- 010261626401 VALID true - KEY 010261626400000000088000000000000001 + KEY 01026162640000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abd/8/1 -> 8/1/abd -GET 0100000000088000000000000001616264 100a +GET 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 010261626400000000057ffffffffffffffe + KEY 01026162640000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/5/-2 -> 5/-2/abd -GET 0100000000057ffffffffffffffe616264 1008 +GET 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 010261626400000000047ffffffffffffffe + KEY 01026162640000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/4/-2 -> 4/-2/abd -GET 0100000000047ffffffffffffffe616264 1007 +GET 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} NEXT VALID true - KEY 010261626300000000088000000000000001 + KEY 01026162630000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abc/8/1 -> 8/1/abc -GET 0100000000088000000000000001616263 100c +GET 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 010261626300000000087ffffffffffffffc + KEY 01026162630000087ffffffffffffffc IDX testpb.ExampleTable str/u32/i64 : abc/8/-4 -> 8/-4/abc -GET 0100000000087ffffffffffffffc616263 100b +GET 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 010261626300000000047fffffffffffffff + KEY 01026162630000047fffffffffffffff IDX testpb.ExampleTable str/u32/i64 : abc/4/-1 -> 4/-1/abc -GET 0100000000047fffffffffffffff616263 1008 +GET 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 010261626300000000047ffffffffffffffe + KEY 01026162630000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abc/4/-2 -> 4/-2/abc -GET 0100000000047ffffffffffffffe616263 1007 +GET 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID false -ITERATOR 01026162650000000007 -> 01026162650000000008 +ITERATOR 0102616265000007 -> 0102616265000008 VALID true - KEY 010261626500000000077ffffffffffffffe + KEY 01026162650000077ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abe/7/-2 -> 7/-2/abe -GET 0100000000077ffffffffffffffe616265 100a +GET 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 010261626500000000077fffffffffffffff + KEY 01026162650000077fffffffffffffff IDX testpb.ExampleTable str/u32/i64 : abe/7/-1 -> 7/-1/abe -GET 0100000000077fffffffffffffff616265 100b +GET 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID false -ITERATOR 01026162630000000004 <- 01026162630000000005 +ITERATOR 0102616263000004 <- 0102616263000005 VALID true - KEY 010261626300000000047fffffffffffffff + KEY 01026162630000047fffffffffffffff IDX testpb.ExampleTable str/u32/i64 : abc/4/-1 -> 4/-1/abc -GET 0100000000047fffffffffffffff616263 1008 +GET 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 010261626300000000047ffffffffffffffe + KEY 01026162630000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abc/4/-2 -> 4/-2/abc -GET 0100000000047ffffffffffffffe616263 1007 +GET 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID false ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 1007 + KEY 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 1007 + KEY 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false @@ -338,65 +338,65 @@ ITERATOR 0100 -> 0101 VALID true NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 1007 + KEY 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} -ITERATOR 0100000000047ffffffffffffffe61626400 -> 0101 +ITERATOR 010000047ffffffffffffffe61626400 -> 0101 VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false -HAS 0101000000000000000c616263 +HAS 0101000c616263 ERR:EOF -GET 0101000000000000000c616263 000000088000000000000001 +GET 0101000c616263 00088000000000000001 UNIQ testpb.ExampleTable u64/str : 12/abc -> 8/1/abc -GET 0100000000088000000000000001616263 100c +GET 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 1007 + KEY 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 1007 + KEY 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true @@ -412,45 +412,45 @@ ITERATOR 0100 -> 0101 VALID true NEXT VALID false -ITERATOR 0100000000057ffffffffffffffe61626400 -> 0101 +ITERATOR 010000057ffffffffffffffe61626400 -> 0101 VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true -ITERATOR 0100000000087ffffffffffffffc61626300 -> 0101 +ITERATOR 010000087ffffffffffffffc61626300 -> 0101 VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false ITERATOR 0100 <- 0101 VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true @@ -470,33 +470,33 @@ ITERATOR 0100 <- 0101 VALID true NEXT VALID false -ITERATOR 0100 <- 0100000000088000000000000001616263 +ITERATOR 0100 <- 010000088000000000000001616263 VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true -ITERATOR 0100000000047fffffffffffffff616263 -> 0100000000077ffffffffffffffe61626500 +ITERATOR 010000047fffffffffffffff616263 -> 010000077ffffffffffffffe61626500 VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID false @@ -508,13 +508,13 @@ ITERATOR 0100 -> 0101 VALID true NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true @@ -540,17 +540,17 @@ ITERATOR 0100 <- 0101 VALID true NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 1009 + KEY 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 1008 + KEY 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} - KEY 0100000000047fffffffffffffff616263 1008 + KEY 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} NEXT VALID true @@ -580,546 +580,546 @@ ITERATOR 0100 -> 0101 VALID true NEXT VALID false -GET 0100000000047ffffffffffffffe616263 1007 +GET 010000047ffffffffffffffe616263 1007 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":7,"str":"abc","i64":-2} ORM UPDATE testpb.ExampleTable {"u32":4,"u64":7,"str":"abc","i64":-2} -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} -HAS 0101000000000000000e616263 +HAS 0101000e616263 ERR:EOF -SET 0100000000047ffffffffffffffe616263 100e2203616263 +SET 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} -DEL 01010000000000000007616263 +DEL 01010007616263 DEL ERR:EOF -SET 0101000000000000000e616263 000000047ffffffffffffffe +SET 0101000e616263 00047ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 14/abc -> 4/-2/abc -DEL 01030061626300000000047ffffffffffffffe +DEL 0103006162630000047ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/4/-2 -> 4/-2/abc -SET 01030361626361626300000000047ffffffffffffffe +SET 0103036162636162630000047ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 99]/abc/4/-2 -> 4/-2/abc -GET 0100000000047ffffffffffffffe616264 1007 +GET 010000047ffffffffffffffe616264 1007 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":7,"str":"abd","i64":-2} ORM UPDATE testpb.ExampleTable {"u32":4,"u64":7,"str":"abd","i64":-2} -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} -HAS 0101000000000000000e616264 +HAS 0101000e616264 ERR:EOF -SET 0100000000047ffffffffffffffe616264 100e2203616264 +SET 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} -DEL 01010000000000000007616264 +DEL 01010007616264 DEL ERR:EOF -SET 0101000000000000000e616264 000000047ffffffffffffffe +SET 0101000e616264 00047ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 14/abd -> 4/-2/abd -DEL 01030061626400000000047ffffffffffffffe +DEL 0103006162640000047ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/4/-2 -> 4/-2/abd -SET 01030361626461626400000000047ffffffffffffffe +SET 0103036162646162640000047ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 100]/abd/4/-2 -> 4/-2/abd -GET 0100000000047fffffffffffffff616263 1008 +GET 010000047fffffffffffffff616263 1008 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":8,"str":"abc","i64":-1} ORM UPDATE testpb.ExampleTable {"u32":4,"u64":8,"str":"abc","i64":-1} -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} -HAS 01010000000000000010616263 +HAS 01010010616263 ERR:EOF -SET 0100000000047fffffffffffffff616263 10102203616263 +SET 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} -DEL 01010000000000000008616263 +DEL 01010008616263 DEL ERR:EOF -SET 01010000000000000010616263 000000047fffffffffffffff +SET 01010010616263 00047fffffffffffffff UNIQ testpb.ExampleTable u64/str : 16/abc -> 4/-1/abc -DEL 01030061626300000000047fffffffffffffff +DEL 0103006162630000047fffffffffffffff DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/4/-1 -> 4/-1/abc -SET 01030361626361626300000000047fffffffffffffff +SET 0103036162636162630000047fffffffffffffff IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 99]/abc/4/-1 -> 4/-1/abc -GET 0100000000057ffffffffffffffe616264 1008 +GET 010000057ffffffffffffffe616264 1008 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":8,"str":"abd","i64":-2} ORM UPDATE testpb.ExampleTable {"u32":5,"u64":8,"str":"abd","i64":-2} -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} -HAS 01010000000000000010616264 +HAS 01010010616264 ERR:EOF -SET 0100000000057ffffffffffffffe616264 10102203616264 +SET 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} -DEL 01010000000000000008616264 +DEL 01010008616264 DEL ERR:EOF -SET 01010000000000000010616264 000000057ffffffffffffffe +SET 01010010616264 00057ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 16/abd -> 5/-2/abd -DEL 01030061626400000000057ffffffffffffffe +DEL 0103006162640000057ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/5/-2 -> 5/-2/abd -SET 01030361626461626400000000057ffffffffffffffe +SET 0103036162646162640000057ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 100]/abd/5/-2 -> 5/-2/abd -GET 0100000000057ffffffffffffffe616265 1009 +GET 010000057ffffffffffffffe616265 1009 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":9,"str":"abe","i64":-2} ORM UPDATE testpb.ExampleTable {"u32":5,"u64":9,"str":"abe","i64":-2} -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} -HAS 01010000000000000012616265 +HAS 01010012616265 ERR:EOF -SET 0100000000057ffffffffffffffe616265 10122203616265 +SET 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} -DEL 01010000000000000009616265 +DEL 01010009616265 DEL ERR:EOF -SET 01010000000000000012616265 000000057ffffffffffffffe +SET 01010012616265 00057ffffffffffffffe UNIQ testpb.ExampleTable u64/str : 18/abe -> 5/-2/abe -DEL 01030061626500000000057ffffffffffffffe +DEL 0103006162650000057ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abe/5/-2 -> 5/-2/abe -SET 01030361626561626500000000057ffffffffffffffe +SET 0103036162656162650000057ffffffffffffffe IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 101]/abe/5/-2 -> 5/-2/abe ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false -GET 0100000000098000000000000000 +GET 010000098000000000000000 PK testpb.ExampleTable 9/0/ -> {"u32":9} ORM INSERT testpb.ExampleTable {"u32":9} -HAS 01010000000000000000 +HAS 01010000 ERR:EOF -SET 0100000000098000000000000000 +SET 010000098000000000000000 PK testpb.ExampleTable 9/0/ -> {"u32":9} -SET 01010000000000000000 000000098000000000000000 +SET 01010000 00098000000000000000 UNIQ testpb.ExampleTable u64/str : 0/ -> 9/0/ -SET 010200000000098000000000000000 +SET 01020000098000000000000000 IDX testpb.ExampleTable str/u32/i64 : /9/0 -> 9/0/ -SET 01030000000000098000000000000000 +SET 0103000000098000000000000000 IDX testpb.ExampleTable bz/str/u32/i64 : []//9/0 -> 9/0/ -GET 0100000000098000000000000000 +GET 010000098000000000000000 PK testpb.ExampleTable 9/0/ -> {"u32":9} -GET 0100000000098000000000000000 +GET 010000098000000000000000 PK testpb.ExampleTable 9/0/ -> {"u32":9} ORM UPDATE testpb.ExampleTable {"u32":9} -> {"u32":9,"b":true} -SET 0100000000098000000000000000 7801 +SET 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} -GET 0100000000098000000000000000 7801 +GET 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} - KEY 0100000000077ffffffffffffffe616265 100a + KEY 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false -GET 0100000000077ffffffffffffffe616265 100a +GET 010000077ffffffffffffffe616265 100a PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"u64":10,"str":"abe","i64":-2} ORM DELETE testpb.ExampleTable {"u32":7,"u64":10,"str":"abe","i64":-2} -DEL 0100000000077ffffffffffffffe616265 +DEL 010000077ffffffffffffffe616265 DEL PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"str":"abe","i64":-2} -DEL 0101000000000000000a616265 +DEL 0101000a616265 DEL ERR:EOF -DEL 010261626500000000077ffffffffffffffe +DEL 01026162650000077ffffffffffffffe DEL IDX testpb.ExampleTable str/u32/i64 : abe/7/-2 -> 7/-2/abe -DEL 01030061626500000000077ffffffffffffffe +DEL 0103006162650000077ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abe/7/-2 -> 7/-2/abe -HAS 0100000000077ffffffffffffffe616265 +HAS 010000077ffffffffffffffe616265 PK testpb.ExampleTable 7/-2/abe -> {"u32":7,"str":"abe","i64":-2} ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047ffffffffffffffe616264 100e2203616264 + KEY 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616264 10102203616264 + KEY 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000088000000000000001616264 100a + KEY 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false ITERATOR 010261626400 -> 010261626401 VALID true - KEY 010261626400000000047ffffffffffffffe + KEY 01026162640000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/4/-2 -> 4/-2/abd -GET 0100000000047ffffffffffffffe616264 100e2203616264 +GET 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 010261626400000000057ffffffffffffffe + KEY 01026162640000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/5/-2 -> 5/-2/abd -GET 0100000000057ffffffffffffffe616264 10102203616264 +GET 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 010261626400000000088000000000000001 + KEY 01026162640000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abd/8/1 -> 8/1/abd -GET 0100000000088000000000000001616264 100a +GET 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false ITERATOR 010261626400 -> 010261626401 VALID true - KEY 010261626400000000047ffffffffffffffe + KEY 01026162640000047ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/4/-2 -> 4/-2/abd -GET 0100000000047ffffffffffffffe616264 100e2203616264 +GET 010000047ffffffffffffffe616264 100e2203616264 PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} ORM DELETE testpb.ExampleTable {"u32":4,"u64":14,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 010261626400000000057ffffffffffffffe + KEY 01026162640000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abd/5/-2 -> 5/-2/abd -GET 0100000000057ffffffffffffffe616264 10102203616264 +GET 010000057ffffffffffffffe616264 10102203616264 PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} ORM DELETE testpb.ExampleTable {"u32":5,"u64":16,"str":"abd","bz":"abd","i64":-2} NEXT VALID true - KEY 010261626400000000088000000000000001 + KEY 01026162640000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abd/8/1 -> 8/1/abd -GET 0100000000088000000000000001616264 100a +GET 010000088000000000000001616264 100a PK testpb.ExampleTable 8/1/abd -> {"u32":8,"u64":10,"str":"abd","i64":1} ORM DELETE testpb.ExampleTable {"u32":8,"u64":10,"str":"abd","i64":1} NEXT VALID false CLOSE -DEL 0100000000047ffffffffffffffe616264 +DEL 010000047ffffffffffffffe616264 DEL PK testpb.ExampleTable 4/-2/abd -> {"u32":4,"str":"abd","i64":-2} -DEL 0100000000057ffffffffffffffe616264 +DEL 010000057ffffffffffffffe616264 DEL PK testpb.ExampleTable 5/-2/abd -> {"u32":5,"str":"abd","i64":-2} -DEL 0100000000088000000000000001616264 +DEL 010000088000000000000001616264 DEL PK testpb.ExampleTable 8/1/abd -> {"u32":8,"str":"abd","i64":1} -DEL 0101000000000000000e616264 +DEL 0101000e616264 DEL ERR:EOF -DEL 010261626400000000047ffffffffffffffe +DEL 01026162640000047ffffffffffffffe DEL IDX testpb.ExampleTable str/u32/i64 : abd/4/-2 -> 4/-2/abd -DEL 01030361626461626400000000047ffffffffffffffe +DEL 0103036162646162640000047ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 100]/abd/4/-2 -> 4/-2/abd -DEL 01010000000000000010616264 +DEL 01010010616264 DEL ERR:EOF -DEL 010261626400000000057ffffffffffffffe +DEL 01026162640000057ffffffffffffffe DEL IDX testpb.ExampleTable str/u32/i64 : abd/5/-2 -> 5/-2/abd -DEL 01030361626461626400000000057ffffffffffffffe +DEL 0103036162646162640000057ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 100]/abd/5/-2 -> 5/-2/abd -DEL 0101000000000000000a616264 +DEL 0101000a616264 DEL ERR:EOF -DEL 010261626400000000088000000000000001 +DEL 01026162640000088000000000000001 DEL IDX testpb.ExampleTable str/u32/i64 : abd/8/1 -> 8/1/abd -DEL 01030061626400000000088000000000000001 +DEL 0103006162640000088000000000000001 DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abd/8/1 -> 8/1/abd ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000057ffffffffffffffe616265 10122203616265 + KEY 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000087ffffffffffffffc616263 100b + KEY 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 0100000000088000000000000001616263 100c + KEY 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false -ITERATOR 01026162630000000008 -> 01026162650000000006 +ITERATOR 0102616263000008 -> 0102616265000006 VALID true - KEY 010261626300000000087ffffffffffffffc + KEY 01026162630000087ffffffffffffffc IDX testpb.ExampleTable str/u32/i64 : abc/8/-4 -> 8/-4/abc -GET 0100000000087ffffffffffffffc616263 100b +GET 010000087ffffffffffffffc616263 100b PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"u64":11,"str":"abc","i64":-4} ORM DELETE testpb.ExampleTable {"u32":8,"u64":11,"str":"abc","i64":-4} NEXT VALID true - KEY 010261626300000000088000000000000001 + KEY 01026162630000088000000000000001 IDX testpb.ExampleTable str/u32/i64 : abc/8/1 -> 8/1/abc -GET 0100000000088000000000000001616263 100c +GET 010000088000000000000001616263 100c PK testpb.ExampleTable 8/1/abc -> {"u32":8,"u64":12,"str":"abc","i64":1} ORM DELETE testpb.ExampleTable {"u32":8,"u64":12,"str":"abc","i64":1} NEXT VALID true - KEY 010261626500000000057ffffffffffffffe + KEY 01026162650000057ffffffffffffffe IDX testpb.ExampleTable str/u32/i64 : abe/5/-2 -> 5/-2/abe -GET 0100000000057ffffffffffffffe616265 10122203616265 +GET 010000057ffffffffffffffe616265 10122203616265 PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} ORM DELETE testpb.ExampleTable {"u32":5,"u64":18,"str":"abe","bz":"abe","i64":-2} NEXT VALID false CLOSE -DEL 0100000000087ffffffffffffffc616263 +DEL 010000087ffffffffffffffc616263 DEL PK testpb.ExampleTable 8/-4/abc -> {"u32":8,"str":"abc","i64":-4} -DEL 0100000000088000000000000001616263 +DEL 010000088000000000000001616263 DEL PK testpb.ExampleTable 8/1/abc -> {"u32":8,"str":"abc","i64":1} -DEL 0100000000057ffffffffffffffe616265 +DEL 010000057ffffffffffffffe616265 DEL PK testpb.ExampleTable 5/-2/abe -> {"u32":5,"str":"abe","i64":-2} -DEL 0101000000000000000b616263 +DEL 0101000b616263 DEL ERR:EOF -DEL 010261626300000000087ffffffffffffffc +DEL 01026162630000087ffffffffffffffc DEL IDX testpb.ExampleTable str/u32/i64 : abc/8/-4 -> 8/-4/abc -DEL 01030061626300000000087ffffffffffffffc +DEL 0103006162630000087ffffffffffffffc DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/8/-4 -> 8/-4/abc -DEL 0101000000000000000c616263 +DEL 0101000c616263 DEL ERR:EOF -DEL 010261626300000000088000000000000001 +DEL 01026162630000088000000000000001 DEL IDX testpb.ExampleTable str/u32/i64 : abc/8/1 -> 8/1/abc -DEL 01030061626300000000088000000000000001 +DEL 0103006162630000088000000000000001 DEL IDX testpb.ExampleTable bz/str/u32/i64 : []/abc/8/1 -> 8/1/abc -DEL 01010000000000000012616265 +DEL 01010012616265 DEL ERR:EOF -DEL 010261626500000000057ffffffffffffffe +DEL 01026162650000057ffffffffffffffe DEL IDX testpb.ExampleTable str/u32/i64 : abe/5/-2 -> 5/-2/abe -DEL 01030361626561626500000000057ffffffffffffffe +DEL 0103036162656162650000057ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 101]/abe/5/-2 -> 5/-2/abe ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047ffffffffffffffe616263 100e2203616263 + KEY 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} NEXT VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false -GET 0100000000047ffffffffffffffe616263 100e2203616263 +GET 010000047ffffffffffffffe616263 100e2203616263 PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} ORM DELETE testpb.ExampleTable {"u32":4,"u64":14,"str":"abc","bz":"abc","i64":-2} -DEL 0100000000047ffffffffffffffe616263 +DEL 010000047ffffffffffffffe616263 DEL PK testpb.ExampleTable 4/-2/abc -> {"u32":4,"str":"abc","i64":-2} -DEL 0101000000000000000e616263 +DEL 0101000e616263 DEL ERR:EOF -DEL 010261626300000000047ffffffffffffffe +DEL 01026162630000047ffffffffffffffe DEL IDX testpb.ExampleTable str/u32/i64 : abc/4/-2 -> 4/-2/abc -DEL 01030361626361626300000000047ffffffffffffffe +DEL 0103036162636162630000047ffffffffffffffe DEL IDX testpb.ExampleTable bz/str/u32/i64 : [97 98 99]/abc/4/-2 -> 4/-2/abc ITERATOR 0100 -> 0101 VALID true - KEY 0100000000047fffffffffffffff616263 10102203616263 + KEY 010000047fffffffffffffff616263 10102203616263 PK testpb.ExampleTable 4/-1/abc -> {"u32":4,"u64":16,"str":"abc","bz":"abc","i64":-1} NEXT VALID true - KEY 0100000000077fffffffffffffff616265 100b + KEY 010000077fffffffffffffff616265 100b PK testpb.ExampleTable 7/-1/abe -> {"u32":7,"u64":11,"str":"abe","i64":-1} NEXT VALID true - KEY 0100000000098000000000000000 7801 + KEY 010000098000000000000000 7801 PK testpb.ExampleTable 9/0/ -> {"u32":9,"b":true} NEXT VALID false diff --git a/proto/cosmos/orm/v1alpha1/orm.proto b/proto/cosmos/orm/v1alpha1/orm.proto index 317521904bd0..88a947d6369d 100644 --- a/proto/cosmos/orm/v1alpha1/orm.proto +++ b/proto/cosmos/orm/v1alpha1/orm.proto @@ -36,8 +36,15 @@ message PrimaryKeyDescriptor { // fields is a comma-separated list of fields in the primary key. Spaces are // not allowed. Supported field types, their encodings, and any applicable constraints // are described below. - // - uint32, uint64 are encoded as big-endian fixed width bytes and support - // sorted iteration. + // - uint32 are encoded as 2,3,4 or 5 bytes using a compact encoding that + // is suitable for sorted iteration (not varint encoding). This type is + // well-suited for small integers. + // - uint64 are encoded as 2,4,6 or 9 bytes using a compact encoding that + // is suitable for sorted iteration (not varint encoding). This type is + // well-suited for small integers such as auto-incrementing sequences. + // - fixed32, fixed64 are encoded as big-endian fixed width bytes and support + // sorted iteration. These types are well-suited for encoding fixed with + // decimals as integers. // - string's are encoded as raw bytes in terminal key segments and null-terminated // in non-terminal segments. Null characters are thus forbidden in strings. // string fields support sorted iteration. @@ -46,7 +53,7 @@ message PrimaryKeyDescriptor { // longer than 255 bytes are unsupported and bytes fields should not // be assumed to be lexically sorted. If you have a byte array longer than // 255 bytes that you'd like to index, you should consider hashing it first. - // - int32, sint32, int64, sint64 are encoding as fixed width bytes with + // - int32, sint32, int64, sint64, sfixed32, sfixed64 are encoded as fixed width bytes with // an encoding that enables sorted iteration. // - google.protobuf.Timestamp and google.protobuf.Duration are encoded // as 12 bytes using an encoding that enables sorted iteration.