FlatBuffers test

flatbuf_test.go

package chunk

import (
	"testing"
	
	flatbuffers "github.com/google/flatbuffers/go"
	"github.com/pingcap/tidb/util/types"
	"github.com/pingcap/tidb/util/codec"
)

func BenchmarkEncode(b *testing.B) {
	b.ReportAllocs()
	builder := flatbuffers.NewBuilder(1024)
	for i := 0; i < b.N; i++ {
		EncodeRow(builder)
	}
}

func BenchmarkEncodeOld(b *testing.B) {
	buf := make([]byte, 1024)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		EncodeRowOld(buf)
	}
}

func BenchmarkEncodeDatum(b *testing.B) {
	builder := flatbuffers.NewBuilder(1024)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		EncodeDatum(builder)
	}
}

var abcd = []byte("abcd")

func EncodeRow(builder *flatbuffers.Builder) []byte {
	builder.Reset()
	DatumStart(builder)
	DatumAddInt64(builder, 1)
	intCol := DatumEnd(builder)

	DatumStart(builder)
	DatumAddFloat64(builder, 1.1)
	floatCol := DatumEnd(builder)

	bin := builder.CreateByteVector(abcd)
	DatumStart(builder)
	DatumAddBytes(builder, bin)
	strCol := DatumEnd(builder)
	RowStartValuesVector(builder, 3)
	builder.PrependUOffsetT(strCol)
	builder.PrependUOffsetT(floatCol)
	builder.PrependUOffsetT(intCol)
	valuesOff := builder.EndVector(3)
	RowStart(builder)
	RowAddValues(builder, valuesOff)
	root := RowEnd(builder)
	builder.Finish(root)
	return builder.FinishedBytes()
}

func EncodeDatum(builder *flatbuffers.Builder) {
	builder.Reset()
	DatumStart(builder)
	DatumAddInt64(builder, 0)
	DatumAddFloat64(builder, 0)
	DatumEnd(builder)
}

var datums = []types.Datum{types.NewIntDatum(1), types.NewFloat64Datum(1.1), types.NewBytesDatum(abcd)}

func EncodeRowOld(buf []byte) []byte {
	buf = buf[:0]
	buf, _ = codec.EncodeValue(buf, datums...)
	return buf
}


/* Copied from generated files. */

type Datum struct {
	_tab flatbuffers.Table
}

func GetRootAsDatum(buf []byte, offset flatbuffers.UOffsetT) *Datum {
	n := flatbuffers.GetUOffsetT(buf[offset:])
	x := &Datum{}
	x.Init(buf, n+offset)
	return x
}

func (rcv *Datum) Init(buf []byte, i flatbuffers.UOffsetT) {
	rcv._tab.Bytes = buf
	rcv._tab.Pos = i
}

func (rcv *Datum) Table() flatbuffers.Table {
	return rcv._tab
}

func (rcv *Datum) Tp() byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		return rcv._tab.GetByte(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *Datum) MutateTp(n byte) bool {
	return rcv._tab.MutateByteSlot(4, n)
}

func (rcv *Datum) Int64() int64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
	if o != 0 {
		return rcv._tab.GetInt64(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *Datum) MutateInt64(n int64) bool {
	return rcv._tab.MutateInt64Slot(6, n)
}

func (rcv *Datum) Uint64() uint64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
	if o != 0 {
		return rcv._tab.GetUint64(o + rcv._tab.Pos)
	}
	return 0
}

func (rcv *Datum) MutateUint64(n uint64) bool {
	return rcv._tab.MutateUint64Slot(8, n)
}

func (rcv *Datum) Float32() float32 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
	if o != 0 {
		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
	}
	return 0.0
}

func (rcv *Datum) MutateFloat32(n float32) bool {
	return rcv._tab.MutateFloat32Slot(10, n)
}

func (rcv *Datum) Float64() float64 {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
	if o != 0 {
		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
	}
	return 0.0
}

func (rcv *Datum) MutateFloat64(n float64) bool {
	return rcv._tab.MutateFloat64Slot(12, n)
}

func (rcv *Datum) Bytes(j int) byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
	if o != 0 {
		a := rcv._tab.Vector(o)
		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
	}
	return 0
}

func (rcv *Datum) BytesLength() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

func (rcv *Datum) BytesBytes() []byte {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
	if o != 0 {
		return rcv._tab.ByteVector(o + rcv._tab.Pos)
	}
	return nil
}

func DatumStart(builder *flatbuffers.Builder) {
	builder.StartObject(6)
}
func DatumAddTp(builder *flatbuffers.Builder, tp byte) {
	builder.PrependByteSlot(0, tp, 0)
}
func DatumAddInt64(builder *flatbuffers.Builder, int64 int64) {
	builder.PrependInt64Slot(1, int64, 0)
}
func DatumAddUint64(builder *flatbuffers.Builder, uint64 uint64) {
	builder.PrependUint64Slot(2, uint64, 0)
}
func DatumAddFloat32(builder *flatbuffers.Builder, float32 float32) {
	builder.PrependFloat32Slot(3, float32, 0.0)
}
func DatumAddFloat64(builder *flatbuffers.Builder, float64 float64) {
	builder.PrependFloat64Slot(4, float64, 0.0)
}
func DatumAddBytes(builder *flatbuffers.Builder, bytes flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(bytes), 0)
}
func DatumStartBytesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(1, numElems, 1)
}
func DatumEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	return builder.EndObject()
}

type Row struct {
	_tab flatbuffers.Table
}

func GetRootAsRow(buf []byte, offset flatbuffers.UOffsetT) *Row {
	n := flatbuffers.GetUOffsetT(buf[offset:])
	x := &Row{}
	x.Init(buf, n+offset)
	return x
}

func (rcv *Row) Init(buf []byte, i flatbuffers.UOffsetT) {
	rcv._tab.Bytes = buf
	rcv._tab.Pos = i
}

func (rcv *Row) Table() flatbuffers.Table {
	return rcv._tab
}

func (rcv *Row) Values(obj *Datum, j int) bool {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		x := rcv._tab.Vector(o)
		x += flatbuffers.UOffsetT(j) * 4
		x = rcv._tab.Indirect(x)
		obj.Init(rcv._tab.Bytes, x)
		return true
	}
	return false
}

func (rcv *Row) ValuesLength() int {
	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
	if o != 0 {
		return rcv._tab.VectorLen(o)
	}
	return 0
}

func RowStart(builder *flatbuffers.Builder) {
	builder.StartObject(1)
}
func RowAddValues(builder *flatbuffers.Builder, values flatbuffers.UOffsetT) {
	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(values), 0)
}
func RowStartValuesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
	return builder.StartVector(4, numElems, 4)
}
func RowEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
	return builder.EndObject()
}