diff --git a/arrow/internal/flatbuf/Binary.go b/arrow/internal/flatbuf/Binary.go index fde7d8e2..4fb9bde1 100644 --- a/arrow/internal/flatbuf/Binary.go +++ b/arrow/internal/flatbuf/Binary.go @@ -24,13 +24,12 @@ import ( /// Opaque binary data type Binary struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary { +func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) (x Binary) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Binary{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -38,10 +37,9 @@ func FinishBinaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffset builder.Finish(offset) } -func GetSizePrefixedRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary { +func GetSizePrefixedRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) (x Binary) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Binary{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -50,12 +48,8 @@ func FinishSizePrefixedBinaryBuffer(builder *flatbuffers.Builder, offset flatbuf } func (rcv *Binary) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Binary) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func BinaryStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/BinaryView.go b/arrow/internal/flatbuf/BinaryView.go index 969e2d26..9b0c12f8 100644 --- a/arrow/internal/flatbuf/BinaryView.go +++ b/arrow/internal/flatbuf/BinaryView.go @@ -30,13 +30,12 @@ import ( /// Since it uses a variable number of data buffers, each Field with this type /// must have a corresponding entry in `variadicBufferCounts`. type BinaryView struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) *BinaryView { +func GetRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) (x BinaryView) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &BinaryView{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -44,10 +43,9 @@ func FinishBinaryViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOf builder.Finish(offset) } -func GetSizePrefixedRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) *BinaryView { +func GetSizePrefixedRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) (x BinaryView) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &BinaryView{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -56,12 +54,8 @@ func FinishSizePrefixedBinaryViewBuffer(builder *flatbuffers.Builder, offset fla } func (rcv *BinaryView) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *BinaryView) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func BinaryViewStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Block.go b/arrow/internal/flatbuf/Block.go index 57a697b1..8ce3e619 100644 --- a/arrow/internal/flatbuf/Block.go +++ b/arrow/internal/flatbuf/Block.go @@ -23,45 +23,41 @@ import ( ) type Block struct { - _tab flatbuffers.Struct + flatbuffers.Struct } func (rcv *Block) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Block) Table() flatbuffers.Table { - return rcv._tab.Table + rcv.Bytes = buf + rcv.Pos = i } /// Index to the start of the RecordBlock (note this is past the Message header) func (rcv *Block) Offset() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(0)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(0)) } /// Index to the start of the RecordBlock (note this is past the Message header) func (rcv *Block) MutateOffset(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(0), n) } /// Length of the metadata func (rcv *Block) MetaDataLength() int32 { - return rcv._tab.GetInt32(rcv._tab.Pos + flatbuffers.UOffsetT(8)) + return rcv.GetInt32(rcv.Pos + flatbuffers.UOffsetT(8)) } /// Length of the metadata func (rcv *Block) MutateMetaDataLength(n int32) bool { - return rcv._tab.MutateInt32(rcv._tab.Pos+flatbuffers.UOffsetT(8), n) + return rcv.MutateInt32(rcv.Pos+flatbuffers.UOffsetT(8), n) } /// Length of the data (this is aligned so there can be a gap between this and /// the metadata). func (rcv *Block) BodyLength() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(16)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(16)) } /// Length of the data (this is aligned so there can be a gap between this and /// the metadata). func (rcv *Block) MutateBodyLength(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(16), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(16), n) } func CreateBlock(builder *flatbuffers.Builder, offset int64, metaDataLength int32, bodyLength int64) flatbuffers.UOffsetT { diff --git a/arrow/internal/flatbuf/BodyCompression.go b/arrow/internal/flatbuf/BodyCompression.go index e5a231aa..8153737b 100644 --- a/arrow/internal/flatbuf/BodyCompression.go +++ b/arrow/internal/flatbuf/BodyCompression.go @@ -26,13 +26,12 @@ import ( /// bodies. Intended for use with RecordBatch but could be used for other /// message types type BodyCompression struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression { +func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) (x BodyCompression) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &BodyCompression{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishBodyCompressionBuffer(builder *flatbuffers.Builder, offset flatbuffer builder.Finish(offset) } -func GetSizePrefixedRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression { +func GetSizePrefixedRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) (x BodyCompression) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &BodyCompression{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,20 +50,16 @@ func FinishSizePrefixedBodyCompressionBuffer(builder *flatbuffers.Builder, offse } func (rcv *BodyCompression) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *BodyCompression) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Compressor library. /// For LZ4_FRAME, each compressed buffer must consist of a single frame. func (rcv *BodyCompression) Codec() CompressionType { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return CompressionType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + return CompressionType(rcv.GetInt8(o + rcv.Pos)) } return 0 } @@ -73,21 +67,21 @@ func (rcv *BodyCompression) Codec() CompressionType { /// Compressor library. /// For LZ4_FRAME, each compressed buffer must consist of a single frame. func (rcv *BodyCompression) MutateCodec(n CompressionType) bool { - return rcv._tab.MutateInt8Slot(4, int8(n)) + return rcv.MutateInt8Slot(4, int8(n)) } /// Indicates the way the record batch body was compressed func (rcv *BodyCompression) Method() BodyCompressionMethod { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return BodyCompressionMethod(rcv._tab.GetInt8(o + rcv._tab.Pos)) + return BodyCompressionMethod(rcv.GetInt8(o + rcv.Pos)) } return 0 } /// Indicates the way the record batch body was compressed func (rcv *BodyCompression) MutateMethod(n BodyCompressionMethod) bool { - return rcv._tab.MutateInt8Slot(6, int8(n)) + return rcv.MutateInt8Slot(6, int8(n)) } func BodyCompressionStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Bool.go b/arrow/internal/flatbuf/Bool.go index 6a2ca99f..90f1104a 100644 --- a/arrow/internal/flatbuf/Bool.go +++ b/arrow/internal/flatbuf/Bool.go @@ -23,13 +23,12 @@ import ( ) type Bool struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool { +func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) (x Bool) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Bool{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishBoolBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool { +func GetSizePrefixedRootAsBool(buf []byte, offset flatbuffers.UOffsetT) (x Bool) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Bool{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,12 +47,8 @@ func FinishSizePrefixedBoolBuffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *Bool) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Bool) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func BoolStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Buffer.go b/arrow/internal/flatbuf/Buffer.go index eba8d99b..99166898 100644 --- a/arrow/internal/flatbuf/Buffer.go +++ b/arrow/internal/flatbuf/Buffer.go @@ -25,27 +25,23 @@ import ( /// ---------------------------------------------------------------------- /// A Buffer represents a single contiguous memory segment type Buffer struct { - _tab flatbuffers.Struct + flatbuffers.Struct } func (rcv *Buffer) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Buffer) Table() flatbuffers.Table { - return rcv._tab.Table + rcv.Bytes = buf + rcv.Pos = i } /// The relative offset into the shared memory page where the bytes for this /// buffer starts func (rcv *Buffer) Offset() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(0)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(0)) } /// The relative offset into the shared memory page where the bytes for this /// buffer starts func (rcv *Buffer) MutateOffset(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(0), n) } /// The absolute length (in bytes) of the memory buffer. The memory is found @@ -54,7 +50,7 @@ func (rcv *Buffer) MutateOffset(n int64) bool { /// after a buffer, but such padding bytes do not need to be accounted for in /// the size here. func (rcv *Buffer) Length() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(8)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(8)) } /// The absolute length (in bytes) of the memory buffer. The memory is found /// from offset (inclusive) to offset + length (non-inclusive). When building @@ -62,7 +58,7 @@ func (rcv *Buffer) Length() int64 { /// after a buffer, but such padding bytes do not need to be accounted for in /// the size here. func (rcv *Buffer) MutateLength(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(8), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(8), n) } func CreateBuffer(builder *flatbuffers.Builder, offset int64, length int64) flatbuffers.UOffsetT { diff --git a/arrow/internal/flatbuf/Date.go b/arrow/internal/flatbuf/Date.go index ae3c1540..94483b07 100644 --- a/arrow/internal/flatbuf/Date.go +++ b/arrow/internal/flatbuf/Date.go @@ -29,13 +29,12 @@ import ( /// leap seconds), where the values are evenly divisible by 86400000 /// * Days (32 bits) since the UNIX epoch type Date struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date { +func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) (x Date) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Date{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -43,10 +42,9 @@ func FinishDateBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date { +func GetSizePrefixedRootAsDate(buf []byte, offset flatbuffers.UOffsetT) (x Date) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Date{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -55,24 +53,20 @@ func FinishSizePrefixedDateBuffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *Date) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Date) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Date) Unit() DateUnit { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return DateUnit(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return DateUnit(rcv.GetInt16(o + rcv.Pos)) } return 1 } func (rcv *Date) MutateUnit(n DateUnit) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func DateStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Decimal.go b/arrow/internal/flatbuf/Decimal.go index 8602cb3c..af6e100b 100644 --- a/arrow/internal/flatbuf/Decimal.go +++ b/arrow/internal/flatbuf/Decimal.go @@ -27,13 +27,12 @@ import ( /// 128-bit (16-byte) and 256-bit (32-byte) integers are used. /// The representation uses the endianness indicated in the Schema. type Decimal struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal { +func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) (x Decimal) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Decimal{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -41,10 +40,9 @@ func FinishDecimalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffse builder.Finish(offset) } -func GetSizePrefixedRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal { +func GetSizePrefixedRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) (x Decimal) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Decimal{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -53,48 +51,44 @@ func FinishSizePrefixedDecimalBuffer(builder *flatbuffers.Builder, offset flatbu } func (rcv *Decimal) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Decimal) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Total number of decimal digits func (rcv *Decimal) Precision() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 0 } /// Total number of decimal digits func (rcv *Decimal) MutatePrecision(n int32) bool { - return rcv._tab.MutateInt32Slot(4, n) + return rcv.MutateInt32Slot(4, n) } /// Number of digits after the decimal point "." func (rcv *Decimal) Scale() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 0 } /// Number of digits after the decimal point "." func (rcv *Decimal) MutateScale(n int32) bool { - return rcv._tab.MutateInt32Slot(6, n) + return rcv.MutateInt32Slot(6, n) } /// Number of bits per value. The accepted widths are 32, 64, 128 and 256. /// We use bitWidth for consistency with Int::bitWidth. func (rcv *Decimal) BitWidth() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 128 } @@ -102,7 +96,7 @@ func (rcv *Decimal) BitWidth() int32 { /// Number of bits per value. The accepted widths are 32, 64, 128 and 256. /// We use bitWidth for consistency with Int::bitWidth. func (rcv *Decimal) MutateBitWidth(n int32) bool { - return rcv._tab.MutateInt32Slot(8, n) + return rcv.MutateInt32Slot(8, n) } func DecimalStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/DictionaryBatch.go b/arrow/internal/flatbuf/DictionaryBatch.go index 3bcf7244..1331ec53 100644 --- a/arrow/internal/flatbuf/DictionaryBatch.go +++ b/arrow/internal/flatbuf/DictionaryBatch.go @@ -29,13 +29,12 @@ import ( /// may be spread across multiple dictionary batches by using the isDelta /// flag type DictionaryBatch struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch { +func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) (x DictionaryBatch) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &DictionaryBatch{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -43,10 +42,9 @@ func FinishDictionaryBatchBuffer(builder *flatbuffers.Builder, offset flatbuffer builder.Finish(offset) } -func GetSizePrefixedRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch { +func GetSizePrefixedRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) (x DictionaryBatch) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &DictionaryBatch{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -55,46 +53,39 @@ func FinishSizePrefixedDictionaryBatchBuffer(builder *flatbuffers.Builder, offse } func (rcv *DictionaryBatch) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *DictionaryBatch) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *DictionaryBatch) Id() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } func (rcv *DictionaryBatch) MutateId(n int64) bool { - return rcv._tab.MutateInt64Slot(4, n) + return rcv.MutateInt64Slot(4, n) } -func (rcv *DictionaryBatch) Data(obj *RecordBatch) *RecordBatch { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *DictionaryBatch) Data() (obj RecordBatch, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(RecordBatch) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// If isDelta is true the values in the dictionary are to be appended to a /// dictionary with the indicated id. If isDelta is false this dictionary /// should replace the existing dictionary. func (rcv *DictionaryBatch) IsDelta() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } @@ -103,7 +94,7 @@ func (rcv *DictionaryBatch) IsDelta() bool { /// dictionary with the indicated id. If isDelta is false this dictionary /// should replace the existing dictionary. func (rcv *DictionaryBatch) MutateIsDelta(n bool) bool { - return rcv._tab.MutateBoolSlot(8, n) + return rcv.MutateBoolSlot(8, n) } func DictionaryBatchStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/DictionaryEncoding.go b/arrow/internal/flatbuf/DictionaryEncoding.go index 69167802..bb95856b 100644 --- a/arrow/internal/flatbuf/DictionaryEncoding.go +++ b/arrow/internal/flatbuf/DictionaryEncoding.go @@ -23,13 +23,12 @@ import ( ) type DictionaryEncoding struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding { +func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) (x DictionaryEncoding) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &DictionaryEncoding{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishDictionaryEncodingBuffer(builder *flatbuffers.Builder, offset flatbuf builder.Finish(offset) } -func GetSizePrefixedRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding { +func GetSizePrefixedRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) (x DictionaryEncoding) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &DictionaryEncoding{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,21 +47,17 @@ func FinishSizePrefixedDictionaryEncodingBuffer(builder *flatbuffers.Builder, of } func (rcv *DictionaryEncoding) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *DictionaryEncoding) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// The known dictionary id in the application where this data is used. In /// the file or streaming formats, the dictionary ids are found in the /// DictionaryBatch messages func (rcv *DictionaryEncoding) Id() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } @@ -72,7 +66,7 @@ func (rcv *DictionaryEncoding) Id() int64 { /// the file or streaming formats, the dictionary ids are found in the /// DictionaryBatch messages func (rcv *DictionaryEncoding) MutateId(n int64) bool { - return rcv._tab.MutateInt64Slot(4, n) + return rcv.MutateInt64Slot(4, n) } /// The dictionary indices are constrained to be non-negative integers. If @@ -80,17 +74,14 @@ func (rcv *DictionaryEncoding) MutateId(n int64) bool { /// cross-language compatibility and performance, implementations are /// recommended to prefer signed integer types over unsigned integer types /// and to avoid uint64 indices unless they are required by an application. -func (rcv *DictionaryEncoding) IndexType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *DictionaryEncoding) IndexType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The dictionary indices are constrained to be non-negative integers. If @@ -103,9 +94,9 @@ func (rcv *DictionaryEncoding) IndexType(obj *Int) *Int { /// is used to represent ordered categorical data, and we provide a way to /// preserve that metadata here func (rcv *DictionaryEncoding) IsOrdered() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } @@ -115,19 +106,19 @@ func (rcv *DictionaryEncoding) IsOrdered() bool { /// is used to represent ordered categorical data, and we provide a way to /// preserve that metadata here func (rcv *DictionaryEncoding) MutateIsOrdered(n bool) bool { - return rcv._tab.MutateBoolSlot(8, n) + return rcv.MutateBoolSlot(8, n) } func (rcv *DictionaryEncoding) DictionaryKind() DictionaryKind { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return DictionaryKind(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return DictionaryKind(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *DictionaryEncoding) MutateDictionaryKind(n DictionaryKind) bool { - return rcv._tab.MutateInt16Slot(10, int16(n)) + return rcv.MutateInt16Slot(10, int16(n)) } func DictionaryEncodingStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Duration.go b/arrow/internal/flatbuf/Duration.go index e49f04d8..7751fbc3 100644 --- a/arrow/internal/flatbuf/Duration.go +++ b/arrow/internal/flatbuf/Duration.go @@ -23,13 +23,12 @@ import ( ) type Duration struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration { +func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) (x Duration) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Duration{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishDurationBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffs builder.Finish(offset) } -func GetSizePrefixedRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration { +func GetSizePrefixedRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) (x Duration) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Duration{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,24 +47,20 @@ func FinishSizePrefixedDurationBuffer(builder *flatbuffers.Builder, offset flatb } func (rcv *Duration) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Duration) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Duration) Unit() TimeUnit { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return TimeUnit(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return TimeUnit(rcv.GetInt16(o + rcv.Pos)) } return 1 } func (rcv *Duration) MutateUnit(n TimeUnit) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func DurationStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Field.go b/arrow/internal/flatbuf/Field.go index a955fc68..307bd25f 100644 --- a/arrow/internal/flatbuf/Field.go +++ b/arrow/internal/flatbuf/Field.go @@ -26,13 +26,12 @@ import ( /// A field represents a named column in a record / row batch or child of a /// nested type. type Field struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field { +func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) (x Field) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Field{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishFieldBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT builder.Finish(offset) } -func GetSizePrefixedRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field { +func GetSizePrefixedRootAsField(buf []byte, offset flatbuffers.UOffsetT) (x Field) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Field{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,19 +50,15 @@ func FinishSizePrefixedFieldBuffer(builder *flatbuffers.Builder, offset flatbuff } func (rcv *Field) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Field) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Name is not required (e.g., in a List) func (rcv *Field) Name() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) + return rcv.ByteVector(o + rcv.Pos) } return nil } @@ -72,35 +66,35 @@ func (rcv *Field) Name() []byte { /// Name is not required (e.g., in a List) /// Whether or not this field can contain nulls. Should be true in general. func (rcv *Field) Nullable() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } /// Whether or not this field can contain nulls. Should be true in general. func (rcv *Field) MutateNullable(n bool) bool { - return rcv._tab.MutateBoolSlot(6, n) + return rcv.MutateBoolSlot(6, n) } func (rcv *Field) TypeType() Type { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return Type(rcv._tab.GetByte(o + rcv._tab.Pos)) + return Type(rcv.GetByte(o + rcv.Pos)) } return 0 } func (rcv *Field) MutateTypeType(n Type) bool { - return rcv._tab.MutateByteSlot(8, byte(n)) + return rcv.MutateByteSlot(8, byte(n)) } /// This is the type of the decoded value if the field is dictionary encoded. func (rcv *Field) Type(obj *flatbuffers.Table) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - rcv._tab.Union(obj, o) + rcv.Union(obj, o) return true } return false @@ -108,38 +102,35 @@ func (rcv *Field) Type(obj *flatbuffers.Table) bool { /// This is the type of the decoded value if the field is dictionary encoded. /// Present only if the field is dictionary encoded. -func (rcv *Field) Dictionary(obj *DictionaryEncoding) *DictionaryEncoding { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) +func (rcv *Field) Dictionary() (obj DictionaryEncoding, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(DictionaryEncoding) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// Present only if the field is dictionary encoded. /// children apply only to nested data types like Struct, List and Union. For /// primitive types children will have length 0. -func (rcv *Field) Children(obj *Field, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) +func (rcv *Field) Children(j int) (obj Field, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(14)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Field) ChildrenLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + o := flatbuffers.UOffsetT(rcv.Offset(14)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -147,22 +138,22 @@ func (rcv *Field) ChildrenLength() int { /// children apply only to nested data types like Struct, List and Union. For /// primitive types children will have length 0. /// User-defined metadata -func (rcv *Field) CustomMetadata(obj *KeyValue, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) +func (rcv *Field) CustomMetadata(j int) (obj KeyValue, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(16)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Field) CustomMetadataLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + o := flatbuffers.UOffsetT(rcv.Offset(16)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } diff --git a/arrow/internal/flatbuf/FieldNode.go b/arrow/internal/flatbuf/FieldNode.go index 606b30bf..f1e7b09f 100644 --- a/arrow/internal/flatbuf/FieldNode.go +++ b/arrow/internal/flatbuf/FieldNode.go @@ -32,40 +32,36 @@ import ( /// would have {length: 5, null_count: 2} for its List node, and {length: 6, /// null_count: 0} for its Int16 node, as separate FieldNode structs type FieldNode struct { - _tab flatbuffers.Struct + flatbuffers.Struct } func (rcv *FieldNode) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *FieldNode) Table() flatbuffers.Table { - return rcv._tab.Table + rcv.Bytes = buf + rcv.Pos = i } /// The number of value slots in the Arrow array at this level of a nested /// tree func (rcv *FieldNode) Length() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(0)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(0)) } /// The number of value slots in the Arrow array at this level of a nested /// tree func (rcv *FieldNode) MutateLength(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(0), n) } /// The number of observed nulls. Fields with null_count == 0 may choose not /// to write their physical validity bitmap out as a materialized buffer, /// instead setting the length of the bitmap buffer to 0. func (rcv *FieldNode) NullCount() int64 { - return rcv._tab.GetInt64(rcv._tab.Pos + flatbuffers.UOffsetT(8)) + return rcv.GetInt64(rcv.Pos + flatbuffers.UOffsetT(8)) } /// The number of observed nulls. Fields with null_count == 0 may choose not /// to write their physical validity bitmap out as a materialized buffer, /// instead setting the length of the bitmap buffer to 0. func (rcv *FieldNode) MutateNullCount(n int64) bool { - return rcv._tab.MutateInt64(rcv._tab.Pos+flatbuffers.UOffsetT(8), n) + return rcv.MutateInt64(rcv.Pos+flatbuffers.UOffsetT(8), n) } func CreateFieldNode(builder *flatbuffers.Builder, length int64, nullCount int64) flatbuffers.UOffsetT { diff --git a/arrow/internal/flatbuf/FixedSizeBinary.go b/arrow/internal/flatbuf/FixedSizeBinary.go index 57d7c25e..a5e6aad8 100644 --- a/arrow/internal/flatbuf/FixedSizeBinary.go +++ b/arrow/internal/flatbuf/FixedSizeBinary.go @@ -23,13 +23,12 @@ import ( ) type FixedSizeBinary struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary { +func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) (x FixedSizeBinary) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &FixedSizeBinary{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishFixedSizeBinaryBuffer(builder *flatbuffers.Builder, offset flatbuffer builder.Finish(offset) } -func GetSizePrefixedRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary { +func GetSizePrefixedRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) (x FixedSizeBinary) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &FixedSizeBinary{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,26 +47,22 @@ func FinishSizePrefixedFixedSizeBinaryBuffer(builder *flatbuffers.Builder, offse } func (rcv *FixedSizeBinary) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *FixedSizeBinary) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Number of bytes per value func (rcv *FixedSizeBinary) ByteWidth() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 0 } /// Number of bytes per value func (rcv *FixedSizeBinary) MutateByteWidth(n int32) bool { - return rcv._tab.MutateInt32Slot(4, n) + return rcv.MutateInt32Slot(4, n) } func FixedSizeBinaryStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/FixedSizeList.go b/arrow/internal/flatbuf/FixedSizeList.go index 83e7211b..34978073 100644 --- a/arrow/internal/flatbuf/FixedSizeList.go +++ b/arrow/internal/flatbuf/FixedSizeList.go @@ -23,13 +23,12 @@ import ( ) type FixedSizeList struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList { +func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) (x FixedSizeList) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &FixedSizeList{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishFixedSizeListBuffer(builder *flatbuffers.Builder, offset flatbuffers. builder.Finish(offset) } -func GetSizePrefixedRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList { +func GetSizePrefixedRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) (x FixedSizeList) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &FixedSizeList{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,26 +47,22 @@ func FinishSizePrefixedFixedSizeListBuffer(builder *flatbuffers.Builder, offset } func (rcv *FixedSizeList) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *FixedSizeList) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Number of list items per value func (rcv *FixedSizeList) ListSize() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 0 } /// Number of list items per value func (rcv *FixedSizeList) MutateListSize(n int32) bool { - return rcv._tab.MutateInt32Slot(4, n) + return rcv.MutateInt32Slot(4, n) } func FixedSizeListStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/FloatingPoint.go b/arrow/internal/flatbuf/FloatingPoint.go index e38241f0..4897f21d 100644 --- a/arrow/internal/flatbuf/FloatingPoint.go +++ b/arrow/internal/flatbuf/FloatingPoint.go @@ -23,13 +23,12 @@ import ( ) type FloatingPoint struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint { +func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) (x FloatingPoint) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &FloatingPoint{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishFloatingPointBuffer(builder *flatbuffers.Builder, offset flatbuffers. builder.Finish(offset) } -func GetSizePrefixedRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint { +func GetSizePrefixedRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) (x FloatingPoint) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &FloatingPoint{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,24 +47,20 @@ func FinishSizePrefixedFloatingPointBuffer(builder *flatbuffers.Builder, offset } func (rcv *FloatingPoint) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *FloatingPoint) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *FloatingPoint) Precision() Precision { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return Precision(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return Precision(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *FloatingPoint) MutatePrecision(n Precision) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func FloatingPointStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Footer.go b/arrow/internal/flatbuf/Footer.go index 338bbd69..b6e5ece9 100644 --- a/arrow/internal/flatbuf/Footer.go +++ b/arrow/internal/flatbuf/Footer.go @@ -26,13 +26,12 @@ import ( /// Arrow File metadata /// type Footer struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer { +func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) (x Footer) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Footer{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishFooterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffset builder.Finish(offset) } -func GetSizePrefixedRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer { +func GetSizePrefixedRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) (x Footer) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Footer{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,94 +50,87 @@ func FinishSizePrefixedFooterBuffer(builder *flatbuffers.Builder, offset flatbuf } func (rcv *Footer) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Footer) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Footer) Version() MetadataVersion { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return MetadataVersion(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return MetadataVersion(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *Footer) MutateVersion(n MetadataVersion) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } -func (rcv *Footer) Schema(obj *Schema) *Schema { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *Footer) Schema() (obj Schema, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Schema) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } -func (rcv *Footer) Dictionaries(obj *Block, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *Footer) Dictionaries(j int) (obj Block, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 24 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Footer) DictionariesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } -func (rcv *Footer) RecordBatches(obj *Block, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) +func (rcv *Footer) RecordBatches(j int) (obj Block, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 24 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Footer) RecordBatchesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } /// User-defined metadata -func (rcv *Footer) CustomMetadata(obj *KeyValue, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) +func (rcv *Footer) CustomMetadata(j int) (obj KeyValue, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Footer) CustomMetadataLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } diff --git a/arrow/internal/flatbuf/Int.go b/arrow/internal/flatbuf/Int.go index b4ef5054..30721c53 100644 --- a/arrow/internal/flatbuf/Int.go +++ b/arrow/internal/flatbuf/Int.go @@ -23,13 +23,12 @@ import ( ) type Int struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int { +func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) (x Int) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Int{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishIntBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int { +func GetSizePrefixedRootAsInt(buf []byte, offset flatbuffers.UOffsetT) (x Int) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Int{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,36 +47,32 @@ func FinishSizePrefixedIntBuffer(builder *flatbuffers.Builder, offset flatbuffer } func (rcv *Int) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Int) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Int) BitWidth() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 0 } func (rcv *Int) MutateBitWidth(n int32) bool { - return rcv._tab.MutateInt32Slot(4, n) + return rcv.MutateInt32Slot(4, n) } func (rcv *Int) IsSigned() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } func (rcv *Int) MutateIsSigned(n bool) bool { - return rcv._tab.MutateBoolSlot(6, n) + return rcv.MutateBoolSlot(6, n) } func IntStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Interval.go b/arrow/internal/flatbuf/Interval.go index 69018c58..0f258d8e 100644 --- a/arrow/internal/flatbuf/Interval.go +++ b/arrow/internal/flatbuf/Interval.go @@ -23,13 +23,12 @@ import ( ) type Interval struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval { +func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) (x Interval) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Interval{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishIntervalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffs builder.Finish(offset) } -func GetSizePrefixedRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval { +func GetSizePrefixedRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) (x Interval) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Interval{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,24 +47,20 @@ func FinishSizePrefixedIntervalBuffer(builder *flatbuffers.Builder, offset flatb } func (rcv *Interval) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Interval) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Interval) Unit() IntervalUnit { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return IntervalUnit(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return IntervalUnit(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *Interval) MutateUnit(n IntervalUnit) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func IntervalStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/KeyValue.go b/arrow/internal/flatbuf/KeyValue.go index c9cad2f9..95e62bbb 100644 --- a/arrow/internal/flatbuf/KeyValue.go +++ b/arrow/internal/flatbuf/KeyValue.go @@ -26,13 +26,12 @@ import ( /// user defined key value pairs to add custom metadata to arrow /// key namespacing is the responsibility of the user type KeyValue struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue { +func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) (x KeyValue) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &KeyValue{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishKeyValueBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffs builder.Finish(offset) } -func GetSizePrefixedRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue { +func GetSizePrefixedRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) (x KeyValue) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &KeyValue{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,26 +50,22 @@ func FinishSizePrefixedKeyValueBuffer(builder *flatbuffers.Builder, offset flatb } func (rcv *KeyValue) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *KeyValue) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *KeyValue) Key() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) + return rcv.ByteVector(o + rcv.Pos) } return nil } func (rcv *KeyValue) Value() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) + return rcv.ByteVector(o + rcv.Pos) } return nil } diff --git a/arrow/internal/flatbuf/LargeBinary.go b/arrow/internal/flatbuf/LargeBinary.go index efb377db..c9fcfd17 100644 --- a/arrow/internal/flatbuf/LargeBinary.go +++ b/arrow/internal/flatbuf/LargeBinary.go @@ -25,13 +25,12 @@ import ( /// Same as Binary, but with 64-bit offsets, allowing to represent /// extremely large data values. type LargeBinary struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary { +func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) (x LargeBinary) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &LargeBinary{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -39,10 +38,9 @@ func FinishLargeBinaryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UO builder.Finish(offset) } -func GetSizePrefixedRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary { +func GetSizePrefixedRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) (x LargeBinary) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &LargeBinary{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -51,12 +49,8 @@ func FinishSizePrefixedLargeBinaryBuffer(builder *flatbuffers.Builder, offset fl } func (rcv *LargeBinary) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *LargeBinary) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func LargeBinaryStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/LargeList.go b/arrow/internal/flatbuf/LargeList.go index 426780ad..9a08df86 100644 --- a/arrow/internal/flatbuf/LargeList.go +++ b/arrow/internal/flatbuf/LargeList.go @@ -25,13 +25,12 @@ import ( /// Same as List, but with 64-bit offsets, allowing to represent /// extremely large data values. type LargeList struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList { +func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) (x LargeList) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &LargeList{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -39,10 +38,9 @@ func FinishLargeListBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOff builder.Finish(offset) } -func GetSizePrefixedRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList { +func GetSizePrefixedRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) (x LargeList) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &LargeList{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -51,12 +49,8 @@ func FinishSizePrefixedLargeListBuffer(builder *flatbuffers.Builder, offset flat } func (rcv *LargeList) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *LargeList) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func LargeListStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/LargeListView.go b/arrow/internal/flatbuf/LargeListView.go index b06657c3..32107d5a 100644 --- a/arrow/internal/flatbuf/LargeListView.go +++ b/arrow/internal/flatbuf/LargeListView.go @@ -25,13 +25,12 @@ import ( /// Same as ListView, but with 64-bit offsets and sizes, allowing to represent /// extremely large data values. type LargeListView struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) *LargeListView { +func GetRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) (x LargeListView) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &LargeListView{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -39,10 +38,9 @@ func FinishLargeListViewBuffer(builder *flatbuffers.Builder, offset flatbuffers. builder.Finish(offset) } -func GetSizePrefixedRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) *LargeListView { +func GetSizePrefixedRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) (x LargeListView) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &LargeListView{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -51,12 +49,8 @@ func FinishSizePrefixedLargeListViewBuffer(builder *flatbuffers.Builder, offset } func (rcv *LargeListView) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *LargeListView) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func LargeListViewStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/LargeUtf8.go b/arrow/internal/flatbuf/LargeUtf8.go index de289319..55c34467 100644 --- a/arrow/internal/flatbuf/LargeUtf8.go +++ b/arrow/internal/flatbuf/LargeUtf8.go @@ -25,13 +25,12 @@ import ( /// Same as Utf8, but with 64-bit offsets, allowing to represent /// extremely large data values. type LargeUtf8 struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8 { +func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) (x LargeUtf8) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &LargeUtf8{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -39,10 +38,9 @@ func FinishLargeUtf8Buffer(builder *flatbuffers.Builder, offset flatbuffers.UOff builder.Finish(offset) } -func GetSizePrefixedRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8 { +func GetSizePrefixedRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) (x LargeUtf8) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &LargeUtf8{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -51,12 +49,8 @@ func FinishSizePrefixedLargeUtf8Buffer(builder *flatbuffers.Builder, offset flat } func (rcv *LargeUtf8) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *LargeUtf8) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func LargeUtf8Start(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/List.go b/arrow/internal/flatbuf/List.go index eb02ae1e..c6761bd9 100644 --- a/arrow/internal/flatbuf/List.go +++ b/arrow/internal/flatbuf/List.go @@ -23,13 +23,12 @@ import ( ) type List struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List { +func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) (x List) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &List{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishListBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List { +func GetSizePrefixedRootAsList(buf []byte, offset flatbuffers.UOffsetT) (x List) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &List{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,12 +47,8 @@ func FinishSizePrefixedListBuffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *List) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *List) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func ListStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/ListView.go b/arrow/internal/flatbuf/ListView.go index 50b38cf8..1ce90d49 100644 --- a/arrow/internal/flatbuf/ListView.go +++ b/arrow/internal/flatbuf/ListView.go @@ -26,13 +26,12 @@ import ( /// sizes allowing for writes in any order and sharing of child values among /// list values. type ListView struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsListView(buf []byte, offset flatbuffers.UOffsetT) *ListView { +func GetRootAsListView(buf []byte, offset flatbuffers.UOffsetT) (x ListView) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &ListView{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishListViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffs builder.Finish(offset) } -func GetSizePrefixedRootAsListView(buf []byte, offset flatbuffers.UOffsetT) *ListView { +func GetSizePrefixedRootAsListView(buf []byte, offset flatbuffers.UOffsetT) (x ListView) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &ListView{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,12 +50,8 @@ func FinishSizePrefixedListViewBuffer(builder *flatbuffers.Builder, offset flatb } func (rcv *ListView) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *ListView) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func ListViewStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Map.go b/arrow/internal/flatbuf/Map.go index 021cfb17..a728fd52 100644 --- a/arrow/internal/flatbuf/Map.go +++ b/arrow/internal/flatbuf/Map.go @@ -48,13 +48,12 @@ import ( /// for Map can make Map an alias for List. The "layout" attribute for the Map /// field must have the same contents as a List. type Map struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map { +func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) (x Map) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Map{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -62,10 +61,9 @@ func FinishMapBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map { +func GetSizePrefixedRootAsMap(buf []byte, offset flatbuffers.UOffsetT) (x Map) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Map{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -74,26 +72,22 @@ func FinishSizePrefixedMapBuffer(builder *flatbuffers.Builder, offset flatbuffer } func (rcv *Map) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Map) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Set to true if the keys within each value are sorted func (rcv *Map) KeysSorted() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } /// Set to true if the keys within each value are sorted func (rcv *Map) MutateKeysSorted(n bool) bool { - return rcv._tab.MutateBoolSlot(4, n) + return rcv.MutateBoolSlot(4, n) } func MapStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Message.go b/arrow/internal/flatbuf/Message.go index 0975bf12..d8875164 100644 --- a/arrow/internal/flatbuf/Message.go +++ b/arrow/internal/flatbuf/Message.go @@ -23,13 +23,12 @@ import ( ) type Message struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message { +func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) (x Message) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Message{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffse builder.Finish(offset) } -func GetSizePrefixedRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message { +func GetSizePrefixedRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) (x Message) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Message{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,75 +47,71 @@ func FinishSizePrefixedMessageBuffer(builder *flatbuffers.Builder, offset flatbu } func (rcv *Message) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Message) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Message) Version() MetadataVersion { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return MetadataVersion(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return MetadataVersion(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *Message) MutateVersion(n MetadataVersion) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func (rcv *Message) HeaderType() MessageHeader { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return MessageHeader(rcv._tab.GetByte(o + rcv._tab.Pos)) + return MessageHeader(rcv.GetByte(o + rcv.Pos)) } return 0 } func (rcv *Message) MutateHeaderType(n MessageHeader) bool { - return rcv._tab.MutateByteSlot(6, byte(n)) + return rcv.MutateByteSlot(6, byte(n)) } func (rcv *Message) Header(obj *flatbuffers.Table) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - rcv._tab.Union(obj, o) + rcv.Union(obj, o) return true } return false } func (rcv *Message) BodyLength() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } func (rcv *Message) MutateBodyLength(n int64) bool { - return rcv._tab.MutateInt64Slot(10, n) + return rcv.MutateInt64Slot(10, n) } -func (rcv *Message) CustomMetadata(obj *KeyValue, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) +func (rcv *Message) CustomMetadata(j int) (obj KeyValue, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Message) CustomMetadataLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } diff --git a/arrow/internal/flatbuf/Null.go b/arrow/internal/flatbuf/Null.go index 8c831251..30acf6e9 100644 --- a/arrow/internal/flatbuf/Null.go +++ b/arrow/internal/flatbuf/Null.go @@ -24,13 +24,12 @@ import ( /// These are stored in the flatbuffer in the Type union below type Null struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null { +func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) (x Null) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Null{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -38,10 +37,9 @@ func FinishNullBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null { +func GetSizePrefixedRootAsNull(buf []byte, offset flatbuffers.UOffsetT) (x Null) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Null{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -50,12 +48,8 @@ func FinishSizePrefixedNullBuffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *Null) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Null) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func NullStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/RecordBatch.go b/arrow/internal/flatbuf/RecordBatch.go index f9a35c96..24ab18a3 100644 --- a/arrow/internal/flatbuf/RecordBatch.go +++ b/arrow/internal/flatbuf/RecordBatch.go @@ -26,13 +26,12 @@ import ( /// batch. Some systems call this a "row batch" internally and others a "record /// batch". type RecordBatch struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch { +func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) (x RecordBatch) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &RecordBatch{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishRecordBatchBuffer(builder *flatbuffers.Builder, offset flatbuffers.UO builder.Finish(offset) } -func GetSizePrefixedRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch { +func GetSizePrefixedRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) (x RecordBatch) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &RecordBatch{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,20 +50,16 @@ func FinishSizePrefixedRecordBatchBuffer(builder *flatbuffers.Builder, offset fl } func (rcv *RecordBatch) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *RecordBatch) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// number of records / rows. The arrays in the batch should all have this /// length func (rcv *RecordBatch) Length() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } @@ -73,25 +67,25 @@ func (rcv *RecordBatch) Length() int64 { /// number of records / rows. The arrays in the batch should all have this /// length func (rcv *RecordBatch) MutateLength(n int64) bool { - return rcv._tab.MutateInt64Slot(4, n) + return rcv.MutateInt64Slot(4, n) } /// Nodes correspond to the pre-ordered flattened logical schema -func (rcv *RecordBatch) Nodes(obj *FieldNode, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *RecordBatch) Nodes(j int) (obj FieldNode, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 16 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *RecordBatch) NodesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -103,21 +97,21 @@ func (rcv *RecordBatch) NodesLength() int { /// example, most primitive arrays will have 2 buffers, 1 for the validity /// bitmap and 1 for the values. For struct arrays, there will only be a /// single buffer for the validity (nulls) bitmap -func (rcv *RecordBatch) Buffers(obj *Buffer, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *RecordBatch) Buffers(j int) (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 16 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *RecordBatch) BuffersLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -129,17 +123,14 @@ func (rcv *RecordBatch) BuffersLength() int { /// bitmap and 1 for the values. For struct arrays, there will only be a /// single buffer for the validity (nulls) bitmap /// Optional compression of the message body -func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) +func (rcv *RecordBatch) Compression() (obj BodyCompression, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(BodyCompression) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// Optional compression of the message body @@ -158,18 +149,18 @@ func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression { /// This field may be omitted if and only if the schema contains no Fields with /// a variable number of buffers, such as BinaryView and Utf8View. func (rcv *RecordBatch) VariadicBufferCounts(j int) int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8)) + a := rcv.Vector(o) + return rcv.GetInt64(a + flatbuffers.UOffsetT(j*8)) } return 0 } func (rcv *RecordBatch) VariadicBufferCountsLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -189,10 +180,10 @@ func (rcv *RecordBatch) VariadicBufferCountsLength() int { /// This field may be omitted if and only if the schema contains no Fields with /// a variable number of buffers, such as BinaryView and Utf8View. func (rcv *RecordBatch) MutateVariadicBufferCounts(j int, n int64) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) + a := rcv.Vector(o) + return rcv.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) } return false } diff --git a/arrow/internal/flatbuf/RunEndEncoded.go b/arrow/internal/flatbuf/RunEndEncoded.go index 3c1d6c7b..0123c690 100644 --- a/arrow/internal/flatbuf/RunEndEncoded.go +++ b/arrow/internal/flatbuf/RunEndEncoded.go @@ -28,13 +28,12 @@ import ( /// each corresponding index in the values child array ends. /// Like list/struct types, the value array can be of any type. type RunEndEncoded struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunEndEncoded { +func GetRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) (x RunEndEncoded) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &RunEndEncoded{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -42,10 +41,9 @@ func FinishRunEndEncodedBuffer(builder *flatbuffers.Builder, offset flatbuffers. builder.Finish(offset) } -func GetSizePrefixedRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunEndEncoded { +func GetSizePrefixedRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) (x RunEndEncoded) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &RunEndEncoded{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -54,12 +52,8 @@ func FinishSizePrefixedRunEndEncodedBuffer(builder *flatbuffers.Builder, offset } func (rcv *RunEndEncoded) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *RunEndEncoded) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func RunEndEncodedStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Schema.go b/arrow/internal/flatbuf/Schema.go index fa31c22c..52a836a3 100644 --- a/arrow/internal/flatbuf/Schema.go +++ b/arrow/internal/flatbuf/Schema.go @@ -25,13 +25,12 @@ import ( /// ---------------------------------------------------------------------- /// A Schema describes the columns in a row batch type Schema struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema { +func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) (x Schema) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Schema{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -39,10 +38,9 @@ func FinishSchemaBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffset builder.Finish(offset) } -func GetSizePrefixedRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema { +func GetSizePrefixedRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) (x Schema) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Schema{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -51,21 +49,17 @@ func FinishSizePrefixedSchemaBuffer(builder *flatbuffers.Builder, offset flatbuf } func (rcv *Schema) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Schema) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// endianness of the buffer /// it is Little Endian by default /// if endianness doesn't match the underlying system then the vectors need to be converted func (rcv *Schema) Endianness() Endianness { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return Endianness(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return Endianness(rcv.GetInt16(o + rcv.Pos)) } return 0 } @@ -74,73 +68,73 @@ func (rcv *Schema) Endianness() Endianness { /// it is Little Endian by default /// if endianness doesn't match the underlying system then the vectors need to be converted func (rcv *Schema) MutateEndianness(n Endianness) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } -func (rcv *Schema) Fields(obj *Field, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *Schema) Fields(j int) (obj Field, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Schema) FieldsLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } -func (rcv *Schema) CustomMetadata(obj *KeyValue, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *Schema) CustomMetadata(j int) (obj KeyValue, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Schema) CustomMetadataLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } /// Features used in the stream/file. func (rcv *Schema) Features(j int) Feature { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - a := rcv._tab.Vector(o) - return Feature(rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8))) + a := rcv.Vector(o) + return Feature(rcv.GetInt64(a + flatbuffers.UOffsetT(j*8))) } return 0 } func (rcv *Schema) FeaturesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } /// Features used in the stream/file. func (rcv *Schema) MutateFeatures(j int, n Feature) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), int64(n)) + a := rcv.Vector(o) + return rcv.MutateInt64(a+flatbuffers.UOffsetT(j*8), int64(n)) } return false } diff --git a/arrow/internal/flatbuf/SparseMatrixIndexCSX.go b/arrow/internal/flatbuf/SparseMatrixIndexCSX.go index 07f9a00b..03d3bf72 100644 --- a/arrow/internal/flatbuf/SparseMatrixIndexCSX.go +++ b/arrow/internal/flatbuf/SparseMatrixIndexCSX.go @@ -24,13 +24,12 @@ import ( /// Compressed Sparse format, that is matrix-specific. type SparseMatrixIndexCSX struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX { +func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) (x SparseMatrixIndexCSX) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &SparseMatrixIndexCSX{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -38,10 +37,9 @@ func FinishSparseMatrixIndexCSXBuffer(builder *flatbuffers.Builder, offset flatb builder.Finish(offset) } -func GetSizePrefixedRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX { +func GetSizePrefixedRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) (x SparseMatrixIndexCSX) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &SparseMatrixIndexCSX{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -50,40 +48,33 @@ func FinishSizePrefixedSparseMatrixIndexCSXBuffer(builder *flatbuffers.Builder, } func (rcv *SparseMatrixIndexCSX) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *SparseMatrixIndexCSX) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Which axis, row or column, is compressed func (rcv *SparseMatrixIndexCSX) CompressedAxis() SparseMatrixCompressedAxis { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return SparseMatrixCompressedAxis(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return SparseMatrixCompressedAxis(rcv.GetInt16(o + rcv.Pos)) } return 0 } /// Which axis, row or column, is compressed func (rcv *SparseMatrixIndexCSX) MutateCompressedAxis(n SparseMatrixCompressedAxis) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } /// The type of values in indptrBuffer -func (rcv *SparseMatrixIndexCSX) IndptrType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *SparseMatrixIndexCSX) IndptrType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The type of values in indptrBuffer @@ -110,17 +101,14 @@ func (rcv *SparseMatrixIndexCSX) IndptrType(obj *Int) *Int { /// ```text /// indptr(X) = [0, 2, 3, 5, 5, 8, 10]. /// ``` -func (rcv *SparseMatrixIndexCSX) IndptrBuffer(obj *Buffer) *Buffer { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *SparseMatrixIndexCSX) IndptrBuffer() (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := o + rcv._tab.Pos - if obj == nil { - obj = new(Buffer) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := o + rcv.Pos + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// indptrBuffer stores the location and size of indptr array that @@ -147,17 +135,14 @@ func (rcv *SparseMatrixIndexCSX) IndptrBuffer(obj *Buffer) *Buffer { /// indptr(X) = [0, 2, 3, 5, 5, 8, 10]. /// ``` /// The type of values in indicesBuffer -func (rcv *SparseMatrixIndexCSX) IndicesType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) +func (rcv *SparseMatrixIndexCSX) IndicesType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The type of values in indicesBuffer @@ -170,17 +155,14 @@ func (rcv *SparseMatrixIndexCSX) IndicesType(obj *Int) *Int { /// indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. /// ``` /// Note that the indices are sorted in lexicographical order for each row. -func (rcv *SparseMatrixIndexCSX) IndicesBuffer(obj *Buffer) *Buffer { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) +func (rcv *SparseMatrixIndexCSX) IndicesBuffer() (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - x := o + rcv._tab.Pos - if obj == nil { - obj = new(Buffer) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := o + rcv.Pos + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// indicesBuffer stores the location and size of the array that diff --git a/arrow/internal/flatbuf/SparseTensor.go b/arrow/internal/flatbuf/SparseTensor.go index 478a91a8..7a42a1c6 100644 --- a/arrow/internal/flatbuf/SparseTensor.go +++ b/arrow/internal/flatbuf/SparseTensor.go @@ -23,13 +23,12 @@ import ( ) type SparseTensor struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor { +func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensor) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &SparseTensor{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishSparseTensorBuffer(builder *flatbuffers.Builder, offset flatbuffers.U builder.Finish(offset) } -func GetSizePrefixedRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor { +func GetSizePrefixedRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensor) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &SparseTensor{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,33 +47,29 @@ func FinishSizePrefixedSparseTensorBuffer(builder *flatbuffers.Builder, offset f } func (rcv *SparseTensor) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *SparseTensor) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *SparseTensor) TypeType() Type { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return Type(rcv._tab.GetByte(o + rcv._tab.Pos)) + return Type(rcv.GetByte(o + rcv.Pos)) } return 0 } func (rcv *SparseTensor) MutateTypeType(n Type) bool { - return rcv._tab.MutateByteSlot(4, byte(n)) + return rcv.MutateByteSlot(4, byte(n)) } /// The type of data contained in a value cell. /// Currently only fixed-width value types are supported, /// no strings or nested types. func (rcv *SparseTensor) Type(obj *flatbuffers.Table) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - rcv._tab.Union(obj, o) + rcv.Union(obj, o) return true } return false @@ -85,22 +79,22 @@ func (rcv *SparseTensor) Type(obj *flatbuffers.Table) bool { /// Currently only fixed-width value types are supported, /// no strings or nested types. /// The dimensions of the tensor, optionally named. -func (rcv *SparseTensor) Shape(obj *TensorDim, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *SparseTensor) Shape(j int) (obj TensorDim, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *SparseTensor) ShapeLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -108,35 +102,35 @@ func (rcv *SparseTensor) ShapeLength() int { /// The dimensions of the tensor, optionally named. /// The number of non-zero values in a sparse tensor. func (rcv *SparseTensor) NonZeroLength() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } /// The number of non-zero values in a sparse tensor. func (rcv *SparseTensor) MutateNonZeroLength(n int64) bool { - return rcv._tab.MutateInt64Slot(10, n) + return rcv.MutateInt64Slot(10, n) } func (rcv *SparseTensor) SparseIndexType() SparseTensorIndex { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - return SparseTensorIndex(rcv._tab.GetByte(o + rcv._tab.Pos)) + return SparseTensorIndex(rcv.GetByte(o + rcv.Pos)) } return 0 } func (rcv *SparseTensor) MutateSparseIndexType(n SparseTensorIndex) bool { - return rcv._tab.MutateByteSlot(12, byte(n)) + return rcv.MutateByteSlot(12, byte(n)) } /// Sparse tensor index func (rcv *SparseTensor) SparseIndex(obj *flatbuffers.Table) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + o := flatbuffers.UOffsetT(rcv.Offset(14)) if o != 0 { - rcv._tab.Union(obj, o) + rcv.Union(obj, o) return true } return false @@ -144,17 +138,14 @@ func (rcv *SparseTensor) SparseIndex(obj *flatbuffers.Table) bool { /// Sparse tensor index /// The location and size of the tensor's data -func (rcv *SparseTensor) Data(obj *Buffer) *Buffer { - o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) +func (rcv *SparseTensor) Data() (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(16)) if o != 0 { - x := o + rcv._tab.Pos - if obj == nil { - obj = new(Buffer) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := o + rcv.Pos + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The location and size of the tensor's data diff --git a/arrow/internal/flatbuf/SparseTensorIndexCOO.go b/arrow/internal/flatbuf/SparseTensorIndexCOO.go index 48b5667e..da832155 100644 --- a/arrow/internal/flatbuf/SparseTensorIndexCOO.go +++ b/arrow/internal/flatbuf/SparseTensorIndexCOO.go @@ -55,13 +55,12 @@ import ( /// (row-major order), and it does not have duplicated entries. Otherwise, /// the indices may not be sorted, or may have duplicated entries. type SparseTensorIndexCOO struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO { +func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensorIndexCOO) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &SparseTensorIndexCOO{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -69,10 +68,9 @@ func FinishSparseTensorIndexCOOBuffer(builder *flatbuffers.Builder, offset flatb builder.Finish(offset) } -func GetSizePrefixedRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO { +func GetSizePrefixedRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensorIndexCOO) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &SparseTensorIndexCOO{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -81,44 +79,37 @@ func FinishSizePrefixedSparseTensorIndexCOOBuffer(builder *flatbuffers.Builder, } func (rcv *SparseTensorIndexCOO) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *SparseTensorIndexCOO) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// The type of values in indicesBuffer -func (rcv *SparseTensorIndexCOO) IndicesType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) +func (rcv *SparseTensorIndexCOO) IndicesType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The type of values in indicesBuffer /// Non-negative byte offsets to advance one value cell along each dimension /// If omitted, default to row-major order (C-like). func (rcv *SparseTensorIndexCOO) IndicesStrides(j int) int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8)) + a := rcv.Vector(o) + return rcv.GetInt64(a + flatbuffers.UOffsetT(j*8)) } return 0 } func (rcv *SparseTensorIndexCOO) IndicesStridesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -126,26 +117,23 @@ func (rcv *SparseTensorIndexCOO) IndicesStridesLength() int { /// Non-negative byte offsets to advance one value cell along each dimension /// If omitted, default to row-major order (C-like). func (rcv *SparseTensorIndexCOO) MutateIndicesStrides(j int, n int64) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) + a := rcv.Vector(o) + return rcv.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) } return false } /// The location and size of the indices matrix's data -func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *SparseTensorIndexCOO) IndicesBuffer() (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := o + rcv._tab.Pos - if obj == nil { - obj = new(Buffer) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := o + rcv.Pos + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The location and size of the indices matrix's data @@ -155,9 +143,9 @@ func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer { /// but it is inverse order of SciPy's canonical coo_matrix /// (SciPy employs column-major order for its coo_matrix). func (rcv *SparseTensorIndexCOO) IsCanonical() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) + return rcv.GetBool(o + rcv.Pos) } return false } @@ -168,7 +156,7 @@ func (rcv *SparseTensorIndexCOO) IsCanonical() bool { /// but it is inverse order of SciPy's canonical coo_matrix /// (SciPy employs column-major order for its coo_matrix). func (rcv *SparseTensorIndexCOO) MutateIsCanonical(n bool) bool { - return rcv._tab.MutateBoolSlot(10, n) + return rcv.MutateBoolSlot(10, n) } func SparseTensorIndexCOOStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/SparseTensorIndexCSF.go b/arrow/internal/flatbuf/SparseTensorIndexCSF.go index 08d7e486..5b83b2e3 100644 --- a/arrow/internal/flatbuf/SparseTensorIndexCSF.go +++ b/arrow/internal/flatbuf/SparseTensorIndexCSF.go @@ -24,13 +24,12 @@ import ( /// Compressed Sparse Fiber (CSF) sparse tensor index. type SparseTensorIndexCSF struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF { +func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensorIndexCSF) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &SparseTensorIndexCSF{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -38,10 +37,9 @@ func FinishSparseTensorIndexCSFBuffer(builder *flatbuffers.Builder, offset flatb builder.Finish(offset) } -func GetSizePrefixedRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF { +func GetSizePrefixedRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) (x SparseTensorIndexCSF) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &SparseTensorIndexCSF{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -50,12 +48,8 @@ func FinishSizePrefixedSparseTensorIndexCSFBuffer(builder *flatbuffers.Builder, } func (rcv *SparseTensorIndexCSF) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *SparseTensorIndexCSF) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// CSF is a generalization of compressed sparse row (CSR) index. @@ -89,17 +83,14 @@ func (rcv *SparseTensorIndexCSF) Table() flatbuffers.Table { /// 1 2 0 2 0 0 1 2 /// ``` /// The type of values in indptrBuffers -func (rcv *SparseTensorIndexCSF) IndptrType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) +func (rcv *SparseTensorIndexCSF) IndptrType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// CSF is a generalization of compressed sparse row (CSR) index. @@ -147,21 +138,21 @@ func (rcv *SparseTensorIndexCSF) IndptrType(obj *Int) *Int { /// [0, 2, 4, 5, 8] /// ]. /// ``` -func (rcv *SparseTensorIndexCSF) IndptrBuffers(obj *Buffer, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) +func (rcv *SparseTensorIndexCSF) IndptrBuffers(j int) (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 16 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *SparseTensorIndexCSF) IndptrBuffersLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -181,17 +172,14 @@ func (rcv *SparseTensorIndexCSF) IndptrBuffersLength() int { /// ]. /// ``` /// The type of values in indicesBuffers -func (rcv *SparseTensorIndexCSF) IndicesType(obj *Int) *Int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *SparseTensorIndexCSF) IndicesType() (obj Int, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(Int) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := rcv.Indirect(o + rcv.Pos) + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The type of values in indicesBuffers @@ -206,21 +194,21 @@ func (rcv *SparseTensorIndexCSF) IndicesType(obj *Int) *Int { /// [1, 2, 0, 2, 0, 0, 1, 2] /// ]. /// ``` -func (rcv *SparseTensorIndexCSF) IndicesBuffers(obj *Buffer, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) +func (rcv *SparseTensorIndexCSF) IndicesBuffers(j int) (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 16 - obj.Init(rcv._tab.Bytes, x) - return true + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *SparseTensorIndexCSF) IndicesBuffersLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -243,18 +231,18 @@ func (rcv *SparseTensorIndexCSF) IndicesBuffersLength() int { /// axisOrder(X) = [0, 1, 2, 3]. /// ``` func (rcv *SparseTensorIndexCSF) AxisOrder(j int) int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.GetInt32(a + flatbuffers.UOffsetT(j*4)) + a := rcv.Vector(o) + return rcv.GetInt32(a + flatbuffers.UOffsetT(j*4)) } return 0 } func (rcv *SparseTensorIndexCSF) AxisOrderLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -266,10 +254,10 @@ func (rcv *SparseTensorIndexCSF) AxisOrderLength() int { /// axisOrder(X) = [0, 1, 2, 3]. /// ``` func (rcv *SparseTensorIndexCSF) MutateAxisOrder(j int, n int32) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt32(a+flatbuffers.UOffsetT(j*4), n) + a := rcv.Vector(o) + return rcv.MutateInt32(a+flatbuffers.UOffsetT(j*4), n) } return false } diff --git a/arrow/internal/flatbuf/Struct_.go b/arrow/internal/flatbuf/Struct_.go index 64571608..986cb842 100644 --- a/arrow/internal/flatbuf/Struct_.go +++ b/arrow/internal/flatbuf/Struct_.go @@ -26,13 +26,12 @@ import ( /// (according to the physical memory layout). We used Struct_ here as /// Struct is a reserved word in Flatbuffers type Struct_ struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_ { +func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) (x Struct_) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Struct_{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishStruct_Buffer(builder *flatbuffers.Builder, offset flatbuffers.UOffse builder.Finish(offset) } -func GetSizePrefixedRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_ { +func GetSizePrefixedRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) (x Struct_) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Struct_{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,12 +50,8 @@ func FinishSizePrefixedStruct_Buffer(builder *flatbuffers.Builder, offset flatbu } func (rcv *Struct_) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Struct_) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func Struct_Start(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Tensor.go b/arrow/internal/flatbuf/Tensor.go index ff3bbaa4..dbfd0056 100644 --- a/arrow/internal/flatbuf/Tensor.go +++ b/arrow/internal/flatbuf/Tensor.go @@ -23,13 +23,12 @@ import ( ) type Tensor struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor { +func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) (x Tensor) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Tensor{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -37,10 +36,9 @@ func FinishTensorBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffset builder.Finish(offset) } -func GetSizePrefixedRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor { +func GetSizePrefixedRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) (x Tensor) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Tensor{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -49,32 +47,28 @@ func FinishSizePrefixedTensorBuffer(builder *flatbuffers.Builder, offset flatbuf } func (rcv *Tensor) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Tensor) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Tensor) TypeType() Type { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return Type(rcv._tab.GetByte(o + rcv._tab.Pos)) + return Type(rcv.GetByte(o + rcv.Pos)) } return 0 } func (rcv *Tensor) MutateTypeType(n Type) bool { - return rcv._tab.MutateByteSlot(4, byte(n)) + return rcv.MutateByteSlot(4, byte(n)) } /// The type of data contained in a value cell. Currently only fixed-width /// value types are supported, no strings or nested types func (rcv *Tensor) Type(obj *flatbuffers.Table) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - rcv._tab.Union(obj, o) + rcv.Union(obj, o) return true } return false @@ -83,22 +77,22 @@ func (rcv *Tensor) Type(obj *flatbuffers.Table) bool { /// The type of data contained in a value cell. Currently only fixed-width /// value types are supported, no strings or nested types /// The dimensions of the tensor, optionally named -func (rcv *Tensor) Shape(obj *TensorDim, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) +func (rcv *Tensor) Shape(j int) (obj TensorDim, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - x := rcv._tab.Vector(o) + x := rcv.Vector(o) x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true + x = rcv.Indirect(x) + obj.Init(rcv.Bytes, x) + ok = true } - return false + return } func (rcv *Tensor) ShapeLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv.Offset(8)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -107,18 +101,18 @@ func (rcv *Tensor) ShapeLength() int { /// Non-negative byte offsets to advance one value cell along each dimension /// If omitted, default to row-major order (C-like). func (rcv *Tensor) Strides(j int) int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8)) + a := rcv.Vector(o) + return rcv.GetInt64(a + flatbuffers.UOffsetT(j*8)) } return 0 } func (rcv *Tensor) StridesLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } @@ -126,26 +120,23 @@ func (rcv *Tensor) StridesLength() int { /// Non-negative byte offsets to advance one value cell along each dimension /// If omitted, default to row-major order (C-like). func (rcv *Tensor) MutateStrides(j int, n int64) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + o := flatbuffers.UOffsetT(rcv.Offset(10)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) + a := rcv.Vector(o) + return rcv.MutateInt64(a+flatbuffers.UOffsetT(j*8), n) } return false } /// The location and size of the tensor's data -func (rcv *Tensor) Data(obj *Buffer) *Buffer { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) +func (rcv *Tensor) Data() (obj Buffer, ok bool) { + o := flatbuffers.UOffsetT(rcv.Offset(12)) if o != 0 { - x := o + rcv._tab.Pos - if obj == nil { - obj = new(Buffer) - } - obj.Init(rcv._tab.Bytes, x) - return obj + x := o + rcv.Pos + obj.Init(rcv.Bytes, x) + ok = true } - return nil + return } /// The location and size of the tensor's data diff --git a/arrow/internal/flatbuf/TensorDim.go b/arrow/internal/flatbuf/TensorDim.go index 55f2389f..3cedf8aa 100644 --- a/arrow/internal/flatbuf/TensorDim.go +++ b/arrow/internal/flatbuf/TensorDim.go @@ -26,13 +26,12 @@ import ( /// Data structures for dense tensors /// Shape data for a single axis in a tensor type TensorDim struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim { +func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) (x TensorDim) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &TensorDim{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -40,10 +39,9 @@ func FinishTensorDimBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOff builder.Finish(offset) } -func GetSizePrefixedRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim { +func GetSizePrefixedRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) (x TensorDim) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &TensorDim{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -52,33 +50,29 @@ func FinishSizePrefixedTensorDimBuffer(builder *flatbuffers.Builder, offset flat } func (rcv *TensorDim) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *TensorDim) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } /// Length of dimension func (rcv *TensorDim) Size() int64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return rcv._tab.GetInt64(o + rcv._tab.Pos) + return rcv.GetInt64(o + rcv.Pos) } return 0 } /// Length of dimension func (rcv *TensorDim) MutateSize(n int64) bool { - return rcv._tab.MutateInt64Slot(4, n) + return rcv.MutateInt64Slot(4, n) } /// Name of the dimension, optional func (rcv *TensorDim) Name() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) + return rcv.ByteVector(o + rcv.Pos) } return nil } diff --git a/arrow/internal/flatbuf/Time.go b/arrow/internal/flatbuf/Time.go index 89b8ee73..89a8aae6 100644 --- a/arrow/internal/flatbuf/Time.go +++ b/arrow/internal/flatbuf/Time.go @@ -37,13 +37,12 @@ import ( /// measurements with leap seconds will need to be corrected when ingesting /// into Arrow (for example by replacing the value 86400 with 86399). type Time struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time { +func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) (x Time) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Time{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -51,10 +50,9 @@ func FinishTimeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time { +func GetSizePrefixedRootAsTime(buf []byte, offset flatbuffers.UOffsetT) (x Time) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Time{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -63,36 +61,32 @@ func FinishSizePrefixedTimeBuffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *Time) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Time) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Time) Unit() TimeUnit { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return TimeUnit(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return TimeUnit(rcv.GetInt16(o + rcv.Pos)) } return 1 } func (rcv *Time) MutateUnit(n TimeUnit) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func (rcv *Time) BitWidth() int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.GetInt32(o + rcv._tab.Pos) + return rcv.GetInt32(o + rcv.Pos) } return 32 } func (rcv *Time) MutateBitWidth(n int32) bool { - return rcv._tab.MutateInt32Slot(6, n) + return rcv.MutateInt32Slot(6, n) } func TimeStart(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Timestamp.go b/arrow/internal/flatbuf/Timestamp.go index b580c031..02937f02 100644 --- a/arrow/internal/flatbuf/Timestamp.go +++ b/arrow/internal/flatbuf/Timestamp.go @@ -128,13 +128,12 @@ import ( /// was UTC; for example, the naive date-time "January 1st 1970, 00h00" would /// be encoded as timestamp value 0. type Timestamp struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp { +func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) (x Timestamp) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Timestamp{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -142,10 +141,9 @@ func FinishTimestampBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOff builder.Finish(offset) } -func GetSizePrefixedRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp { +func GetSizePrefixedRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) (x Timestamp) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Timestamp{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -154,24 +152,20 @@ func FinishSizePrefixedTimestampBuffer(builder *flatbuffers.Builder, offset flat } func (rcv *Timestamp) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Timestamp) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Timestamp) Unit() TimeUnit { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return TimeUnit(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return TimeUnit(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *Timestamp) MutateUnit(n TimeUnit) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } /// The timezone is an optional string indicating the name of a timezone, @@ -185,9 +179,9 @@ func (rcv *Timestamp) MutateUnit(n TimeUnit) bool { /// Whether a timezone string is present indicates different semantics about /// the data (see above). func (rcv *Timestamp) Timezone() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) + return rcv.ByteVector(o + rcv.Pos) } return nil } diff --git a/arrow/internal/flatbuf/Union.go b/arrow/internal/flatbuf/Union.go index 90a68171..1d22500d 100644 --- a/arrow/internal/flatbuf/Union.go +++ b/arrow/internal/flatbuf/Union.go @@ -27,13 +27,12 @@ import ( /// optionally typeIds provides an indirection between the child offset and the type id /// for each child `typeIds[offset]` is the id used in the type vector type Union struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union { +func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) (x Union) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Union{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -41,10 +40,9 @@ func FinishUnionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT builder.Finish(offset) } -func GetSizePrefixedRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union { +func GetSizePrefixedRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) (x Union) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Union{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -53,48 +51,44 @@ func FinishSizePrefixedUnionBuffer(builder *flatbuffers.Builder, offset flatbuff } func (rcv *Union) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Union) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func (rcv *Union) Mode() UnionMode { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + o := flatbuffers.UOffsetT(rcv.Offset(4)) if o != 0 { - return UnionMode(rcv._tab.GetInt16(o + rcv._tab.Pos)) + return UnionMode(rcv.GetInt16(o + rcv.Pos)) } return 0 } func (rcv *Union) MutateMode(n UnionMode) bool { - return rcv._tab.MutateInt16Slot(4, int16(n)) + return rcv.MutateInt16Slot(4, int16(n)) } func (rcv *Union) TypeIds(j int) int32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.GetInt32(a + flatbuffers.UOffsetT(j*4)) + a := rcv.Vector(o) + return rcv.GetInt32(a + flatbuffers.UOffsetT(j*4)) } return 0 } func (rcv *Union) TypeIdsLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - return rcv._tab.VectorLen(o) + return rcv.VectorLen(o) } return 0 } func (rcv *Union) MutateTypeIds(j int, n int32) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + o := flatbuffers.UOffsetT(rcv.Offset(6)) if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.MutateInt32(a+flatbuffers.UOffsetT(j*4), n) + a := rcv.Vector(o) + return rcv.MutateInt32(a+flatbuffers.UOffsetT(j*4), n) } return false } diff --git a/arrow/internal/flatbuf/Utf8.go b/arrow/internal/flatbuf/Utf8.go index 63a0b42c..573052b0 100644 --- a/arrow/internal/flatbuf/Utf8.go +++ b/arrow/internal/flatbuf/Utf8.go @@ -24,13 +24,12 @@ import ( /// Unicode with UTF-8 encoding type Utf8 struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8 { +func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) (x Utf8) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Utf8{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -38,10 +37,9 @@ func FinishUtf8Buffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) builder.Finish(offset) } -func GetSizePrefixedRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8 { +func GetSizePrefixedRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) (x Utf8) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Utf8{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -50,12 +48,8 @@ func FinishSizePrefixedUtf8Buffer(builder *flatbuffers.Builder, offset flatbuffe } func (rcv *Utf8) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Utf8) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func Utf8Start(builder *flatbuffers.Builder) { diff --git a/arrow/internal/flatbuf/Utf8View.go b/arrow/internal/flatbuf/Utf8View.go index 78a76f2b..c39b3ddc 100644 --- a/arrow/internal/flatbuf/Utf8View.go +++ b/arrow/internal/flatbuf/Utf8View.go @@ -30,13 +30,12 @@ import ( /// Since it uses a variable number of data buffers, each Field with this type /// must have a corresponding entry in `variadicBufferCounts`. type Utf8View struct { - _tab flatbuffers.Table + flatbuffers.Table } -func GetRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) *Utf8View { +func GetRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) (x Utf8View) { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &Utf8View{} - x.Init(buf, n+offset) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset} return x } @@ -44,10 +43,9 @@ func FinishUtf8ViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffs builder.Finish(offset) } -func GetSizePrefixedRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) *Utf8View { +func GetSizePrefixedRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) (x Utf8View) { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &Utf8View{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) + x.Table = flatbuffers.Table{Bytes: buf, Pos: n+offset+flatbuffers.SizeUint32} return x } @@ -56,12 +54,8 @@ func FinishSizePrefixedUtf8ViewBuffer(builder *flatbuffers.Builder, offset flatb } func (rcv *Utf8View) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *Utf8View) Table() flatbuffers.Table { - return rcv._tab + rcv.Bytes = buf + rcv.Pos = i } func Utf8ViewStart(builder *flatbuffers.Builder) { diff --git a/arrow/ipc/file_reader.go b/arrow/ipc/file_reader.go index d742d852..d9d9ffb6 100644 --- a/arrow/ipc/file_reader.go +++ b/arrow/ipc/file_reader.go @@ -43,7 +43,7 @@ type readerImpl interface { type footerBlock struct { offset int64 buffer *memory.Buffer - data *flatbuf.Footer + data flatbuf.Footer } type dataBlock interface { @@ -78,33 +78,31 @@ func (r *basicReaderImpl) getFooterEnd() (int64, error) { } func (r *basicReaderImpl) block(mem memory.Allocator, f *footerBlock, i int) (dataBlock, error) { - var blk flatbuf.Block - if !f.data.RecordBatches(&blk, i) { + if blk, ok := f.data.RecordBatches(i); !ok { return fileBlock{}, fmt.Errorf("arrow/ipc: could not extract file block %d", i) + } else { + return fileBlock{ + offset: blk.Offset(), + meta: blk.MetaDataLength(), + body: blk.BodyLength(), + r: r.r, + mem: mem, + }, nil } - - return fileBlock{ - offset: blk.Offset(), - meta: blk.MetaDataLength(), - body: blk.BodyLength(), - r: r.r, - mem: mem, - }, nil } func (r *basicReaderImpl) dict(mem memory.Allocator, f *footerBlock, i int) (dataBlock, error) { - var blk flatbuf.Block - if !f.data.Dictionaries(&blk, i) { + if blk, ok := f.data.Dictionaries(i); !ok { return fileBlock{}, fmt.Errorf("arrow/ipc: could not extract dictionary block %d", i) + } else { + return fileBlock{ + offset: blk.Offset(), + meta: blk.MetaDataLength(), + body: blk.BodyLength(), + r: r.r, + mem: mem, + }, nil } - - return fileBlock{ - offset: blk.Offset(), - meta: blk.MetaDataLength(), - body: blk.BodyLength(), - r: r.r, - mem: mem, - }, nil } type mappedReaderImpl struct { @@ -122,31 +120,29 @@ func (r *mappedReaderImpl) getBytes(offset, length int64) ([]byte, error) { func (r *mappedReaderImpl) getFooterEnd() (int64, error) { return int64(len(r.data)), nil } func (r *mappedReaderImpl) block(_ memory.Allocator, f *footerBlock, i int) (dataBlock, error) { - var blk flatbuf.Block - if !f.data.RecordBatches(&blk, i) { + if blk, ok := f.data.RecordBatches(i); !ok { return mappedFileBlock{}, fmt.Errorf("arrow/ipc: could not extract file block %d", i) + } else { + return mappedFileBlock{ + offset: blk.Offset(), + meta: blk.MetaDataLength(), + body: blk.BodyLength(), + data: r.data, + }, nil } - - return mappedFileBlock{ - offset: blk.Offset(), - meta: blk.MetaDataLength(), - body: blk.BodyLength(), - data: r.data, - }, nil } func (r *mappedReaderImpl) dict(_ memory.Allocator, f *footerBlock, i int) (dataBlock, error) { - var blk flatbuf.Block - if !f.data.Dictionaries(&blk, i) { + if blk, ok := f.data.Dictionaries(i); !ok { return mappedFileBlock{}, fmt.Errorf("arrow/ipc: could not extract dictionary block %d", i) + } else { + return mappedFileBlock{ + offset: blk.Offset(), + meta: blk.MetaDataLength(), + body: blk.BodyLength(), + data: r.data, + }, nil } - - return mappedFileBlock{ - offset: blk.Offset(), - meta: blk.MetaDataLength(), - body: blk.BodyLength(), - data: r.data, - }, nil } // FileReader is an Arrow file reader. @@ -242,8 +238,8 @@ func (f *FileReader) readSchema(ensureNativeEndian bool) error { kind dictutils.Kind ) - schema := f.footer.data.Schema(nil) - if schema == nil { + schema, ok := f.footer.data.Schema() + if !ok { return fmt.Errorf("arrow/ipc: could not load schema from flatbuffer data") } f.schema, err = schemaFromFB(schema, &f.memo) @@ -322,7 +318,7 @@ func (f *FileReader) Schema() *arrow.Schema { } func (f *FileReader) NumDictionaries() int { - if f.footer.data == nil { + if f.footer.data.Bytes == nil { return 0 } return f.footer.data.DictionariesLength() @@ -339,10 +335,6 @@ func (f *FileReader) Version() MetadataVersion { // Close cleans up resources used by the File. // Close does not close the underlying reader. func (f *FileReader) Close() error { - if f.footer.data != nil { - f.footer.data = nil - } - if f.footer.buffer != nil { f.footer.buffer.Release() f.footer.buffer = nil @@ -449,18 +441,18 @@ func newRecordBatch(schema *arrow.Schema, memo *dictutils.Memo, meta *memory.Buf md flatbuf.RecordBatch codec decompressor ) - initFB(&md, msg.Header) + msg.Header(&md.Table) rows := md.Length() - bodyCompress := md.Compression(nil) - if bodyCompress != nil { + bodyCompress, ok := md.Compression() + if ok { codec = getDecompressor(bodyCompress.Codec()) defer codec.Close() } ctx := &arrayLoaderContext{ src: ipcSource{ - meta: &md, + meta: md, rawBytes: body, codec: codec, mem: mem, @@ -492,15 +484,15 @@ func newRecordBatch(schema *arrow.Schema, memo *dictutils.Memo, meta *memory.Buf } type ipcSource struct { - meta *flatbuf.RecordBatch + meta flatbuf.RecordBatch rawBytes *memory.Buffer codec decompressor mem memory.Allocator } func (src *ipcSource) buffer(i int) *memory.Buffer { - var buf flatbuf.Buffer - if !src.meta.Buffers(&buf, i) { + buf, ok := src.meta.Buffers(i) + if !ok { panic("arrow/ipc: buffer index out of bound") } @@ -532,11 +524,10 @@ func (src *ipcSource) buffer(i int) *memory.Buffer { } func (src *ipcSource) fieldMetadata(i int) flatbuf.FieldNode { - var node flatbuf.FieldNode - if !src.meta.Nodes(&node, i) { - panic("arrow/ipc: field metadata out of bound") + if node, ok := src.meta.Nodes(i); ok { + return node } - return node + panic("arrow/ipc: field metadata out of bound") } func (src *ipcSource) variadicCount(i int) int64 { @@ -833,11 +824,15 @@ func readDictionary(memo *dictutils.Memo, meta *memory.Buffer, body *memory.Buff data flatbuf.RecordBatch codec decompressor ) - initFB(&md, msg.Header) + msg.Header(&md.Table) - md.Data(&data) - bodyCompress := data.Compression(nil) - if bodyCompress != nil { + data, ok := md.Data() + if !ok { + // Unreachable? + return 0, fmt.Errorf("arrow/ipc: unable to parse data") + } + bodyCompress, ok := data.Compression() + if ok { codec = getDecompressor(bodyCompress.Codec()) defer codec.Close() } @@ -852,7 +847,7 @@ func readDictionary(memo *dictutils.Memo, meta *memory.Buffer, body *memory.Buff ctx := &arrayLoaderContext{ src: ipcSource{ - meta: &data, + meta: data, codec: codec, rawBytes: body, mem: mem, diff --git a/arrow/ipc/message.go b/arrow/ipc/message.go index a2c4e370..f5edad55 100644 --- a/arrow/ipc/message.go +++ b/arrow/ipc/message.go @@ -67,7 +67,7 @@ func (m MessageType) String() string { // Message is an IPC message, including metadata and body. type Message struct { refCount atomic.Int64 - msg *flatbuf.Message + msg flatbuf.Message meta *memory.Buffer body *memory.Buffer } @@ -89,14 +89,14 @@ func NewMessage(meta, body *memory.Buffer) *Message { return m } -func newMessageFromFB(meta *flatbuf.Message, body *memory.Buffer) *Message { - if meta == nil || body == nil { +func newMessageFromFB(meta flatbuf.Message, body *memory.Buffer) *Message { + if body == nil { panic("arrow/ipc: nil buffers") } body.Retain() m := &Message{ msg: meta, - meta: memory.NewBufferBytes(meta.Table().Bytes), + meta: memory.NewBufferBytes(meta.Bytes), body: body, } m.refCount.Add(1) @@ -118,7 +118,6 @@ func (msg *Message) Release() { if msg.refCount.Add(-1) == 0 { msg.meta.Release() msg.body.Release() - msg.msg = nil msg.meta = nil msg.body = nil } diff --git a/arrow/ipc/metadata.go b/arrow/ipc/metadata.go index b83c1a84..7c8a468d 100644 --- a/arrow/ipc/metadata.go +++ b/arrow/ipc/metadata.go @@ -165,19 +165,7 @@ func unitToFB(unit arrow.TimeUnit) flatbuf.TimeUnit { } } -// initFB is a helper function to handle flatbuffers' polymorphism. -func initFB(t interface { - Table() flatbuffers.Table - Init([]byte, flatbuffers.UOffsetT) -}, f func(tbl *flatbuffers.Table) bool) { - tbl := t.Table() - if !f(&tbl) { - panic(fmt.Errorf("arrow/ipc: could not initialize %T from flatbuffer", t)) - } - t.Init(tbl.Bytes, tbl.Pos) -} - -func fieldFromFB(field *flatbuf.Field, pos dictutils.FieldPos, memo *dictutils.Memo) (arrow.Field, error) { +func fieldFromFB(field flatbuf.Field, pos dictutils.FieldPos, memo *dictutils.Memo) (arrow.Field, error) { var ( err error o arrow.Field @@ -185,7 +173,7 @@ func fieldFromFB(field *flatbuf.Field, pos dictutils.FieldPos, memo *dictutils.M o.Name = string(field.Name()) o.Nullable = field.Nullable() - o.Metadata, err = metadataFromFB(field) + o.Metadata, err = metadataFromFB(field.CustomMetadataLength(), field.CustomMetadata) if err != nil { return o, err } @@ -193,16 +181,14 @@ func fieldFromFB(field *flatbuf.Field, pos dictutils.FieldPos, memo *dictutils.M n := field.ChildrenLength() children := make([]arrow.Field, n) for i := range children { - var childFB flatbuf.Field - if !field.Children(&childFB, i) { + if childFB, ok := field.Children(i); !ok { return o, fmt.Errorf("arrow/ipc: could not load field child %d", i) - - } - child, err := fieldFromFB(&childFB, pos.Child(int32(i)), memo) - if err != nil { - return o, fmt.Errorf("arrow/ipc: could not convert field child %d: %w", i, err) + } else { + children[i], err = fieldFromFB(childFB, pos.Child(int32(i)), memo) + if err != nil { + return o, fmt.Errorf("arrow/ipc: could not convert field child %d: %w", i, err) + } } - children[i] = child } o.Type, err = typeFromFB(field, pos, children, &o.Metadata, memo) @@ -589,7 +575,7 @@ func (fv *fieldVisitor) result(field arrow.Field) flatbuffers.UOffsetT { return offset } -func typeFromFB(field *flatbuf.Field, pos dictutils.FieldPos, children []arrow.Field, md *arrow.Metadata, memo *dictutils.Memo) (arrow.DataType, error) { +func typeFromFB(field flatbuf.Field, pos dictutils.FieldPos, children []arrow.Field, md *arrow.Metadata, memo *dictutils.Memo) (arrow.DataType, error) { var data flatbuffers.Table if !field.Type(&data) { return nil, fmt.Errorf("arrow/ipc: could not load field type data") @@ -603,11 +589,13 @@ func typeFromFB(field *flatbuf.Field, pos dictutils.FieldPos, children []arrow.F var ( dictID = int64(-1) dictValueType arrow.DataType - encoding = field.Dictionary(nil) + encoding, ok = field.Dictionary() ) - if encoding != nil { - var idt flatbuf.Int - encoding.IndexType(&idt) + if ok { + idt, ok := encoding.IndexType() + if !ok { + return nil, fmt.Errorf("arrow/ipc: could not load encoding type") + } idxType, err := intFromFB(idt) if err != nil { return nil, err @@ -1026,24 +1014,19 @@ func durationFromFB(data flatbuf.Duration) (arrow.DataType, error) { return nil, fmt.Errorf("arrow/ipc: Duration type with %d unit not implemented", data.Unit()) } -type customMetadataer interface { - CustomMetadataLength() int - CustomMetadata(*flatbuf.KeyValue, int) bool -} - -func metadataFromFB(md customMetadataer) (arrow.Metadata, error) { +func metadataFromFB(len int, f func(int) (flatbuf.KeyValue, bool)) (arrow.Metadata, error) { var ( - keys = make([]string, md.CustomMetadataLength()) - vals = make([]string, md.CustomMetadataLength()) + keys = make([]string, len) + vals = make([]string, len) ) for i := range keys { - var kv flatbuf.KeyValue - if !md.CustomMetadata(&kv, i) { + if kv, ok := f(i); !ok { return arrow.Metadata{}, fmt.Errorf("arrow/ipc: could not read key-value %d from flatbuffer", i) + } else { + keys[i] = string(kv.Key()) + vals[i] = string(kv.Value()) } - keys[i] = string(kv.Key()) - vals[i] = string(kv.Value()) } return arrow.NewMetadata(keys, vals), nil @@ -1072,7 +1055,7 @@ func metadataToFB(b *flatbuffers.Builder, meta arrow.Metadata, start startVecFun return b.EndVector(n) } -func schemaFromFB(schema *flatbuf.Schema, memo *dictutils.Memo) (*arrow.Schema, error) { +func schemaFromFB(schema flatbuf.Schema, memo *dictutils.Memo) (*arrow.Schema, error) { var ( err error fields = make([]arrow.Field, schema.FieldsLength()) @@ -1080,18 +1063,17 @@ func schemaFromFB(schema *flatbuf.Schema, memo *dictutils.Memo) (*arrow.Schema, ) for i := range fields { - var field flatbuf.Field - if !schema.Fields(&field, i) { + if field, ok := schema.Fields(i); !ok { return nil, fmt.Errorf("arrow/ipc: could not read field %d from schema", i) + } else { + fields[i], err = fieldFromFB(field, pos.Child(int32(i)), memo) } - - fields[i], err = fieldFromFB(&field, pos.Child(int32(i)), memo) if err != nil { return nil, fmt.Errorf("arrow/ipc: could not convert field %d from flatbuf: %w", i, err) } } - md, err := metadataFromFB(schema) + md, err := metadataFromFB(schema.CustomMetadataLength(), schema.CustomMetadata) if err != nil { return nil, fmt.Errorf("arrow/ipc: could not convert schema metadata from flatbuf: %w", err) } diff --git a/arrow/ipc/metadata_test.go b/arrow/ipc/metadata_test.go index 64898890..8c58a93c 100644 --- a/arrow/ipc/metadata_test.go +++ b/arrow/ipc/metadata_test.go @@ -124,7 +124,11 @@ func TestRWFooter(t *testing.T) { t.Errorf("invalid metadata version: got=%[1]d %#[1]x, want=%[2]d %#[2]x", int16(got), int16(want)) } - schema, err := schemaFromFB(footer.Schema(nil), nil) + fbschema, ok := footer.Schema() + if !ok { + t.Fatalf("footer schema missing") + } + schema, err := schemaFromFB(fbschema, nil) if err != nil { t.Fatal(err) } @@ -138,14 +142,14 @@ func TestRWFooter(t *testing.T) { } for i, dict := range tc.dicts { - var blk flatbuf.Block - if !footer.Dictionaries(&blk, i) { + if blk, ok := footer.Dictionaries(i); !ok { t.Fatalf("could not get dictionary %d", i) - } - got := fileBlock{offset: blk.Offset(), meta: blk.MetaDataLength(), body: blk.BodyLength()} - want := dict - if got != want { - t.Errorf("dict[%d] differ:\ngot= %v\nwant=%v", i, got, want) + } else { + got := fileBlock{offset: blk.Offset(), meta: blk.MetaDataLength(), body: blk.BodyLength()} + want := dict + if got != want { + t.Errorf("dict[%d] differ:\ngot= %v\nwant=%v", i, got, want) + } } } @@ -154,14 +158,14 @@ func TestRWFooter(t *testing.T) { } for i, rec := range tc.recs { - var blk flatbuf.Block - if !footer.RecordBatches(&blk, i) { + if blk, ok := footer.RecordBatches(i); !ok { t.Fatalf("could not get record %d", i) - } - got := fileBlock{offset: blk.Offset(), meta: blk.MetaDataLength(), body: blk.BodyLength()} - want := rec - if got != want { - t.Errorf("record[%d] differ:\ngot= %v\nwant=%v", i, got, want) + } else { + got := fileBlock{offset: blk.Offset(), meta: blk.MetaDataLength(), body: blk.BodyLength()} + want := rec + if got != want { + t.Errorf("record[%d] differ:\ngot= %v\nwant=%v", i, got, want) + } } } }) diff --git a/arrow/ipc/reader.go b/arrow/ipc/reader.go index df9e5000..378c7a73 100644 --- a/arrow/ipc/reader.go +++ b/arrow/ipc/reader.go @@ -141,11 +141,10 @@ func (r *Reader) readSchema(schema *arrow.Schema) error { return fmt.Errorf("arrow/ipc: invalid message type (got=%v, want=%v)", msg.Type(), MessageSchema) } - // FIXME(sbinet) refactor msg-header handling. var schemaFB flatbuf.Schema - initFB(&schemaFB, msg.msg.Header) + msg.msg.Header(&schemaFB.Table) - r.schema, err = schemaFromFB(&schemaFB, &r.memo) + r.schema, err = schemaFromFB(schemaFB, &r.memo) if err != nil { return fmt.Errorf("arrow/ipc: could not decode schema from message schema: %w", err) }