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.