This is an automated email from the ASF dual-hosted git repository.
zeroshade pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-go.git
The following commit(s) were added to refs/heads/main by this push:
new fac7a532 format: regenerate internal/flatbuf from arrow repo and newer
flatc (#555)
fac7a532 is described below
commit fac7a532829fa79a55f91971ff2e754441b94787
Author: pixelherodev <[email protected]>
AuthorDate: Thu Oct 30 10:44:51 2025 -0500
format: regenerate internal/flatbuf from arrow repo and newer flatc (#555)
I plan on at least sending a PR to optimize these files, so regenerating
them using upstream data as is without modifications should make such
PRs easier to review.
Co-authored-by: Noam Preil <[email protected]>
---
arrow/internal/flatbuf/Binary.go | 17 +-
arrow/internal/flatbuf/BinaryView.go | 29 ++-
arrow/internal/flatbuf/Block.go | 19 +-
arrow/internal/flatbuf/BodyCompression.go | 33 ++-
arrow/internal/flatbuf/BodyCompressionMethod.go | 6 +-
arrow/internal/flatbuf/Bool.go | 15 ++
arrow/internal/flatbuf/Buffer.go | 34 ++-
arrow/internal/flatbuf/Date.go | 27 ++-
arrow/internal/flatbuf/Decimal.go | 15 ++
arrow/internal/flatbuf/DictionaryBatch.go | 39 ++--
arrow/internal/flatbuf/DictionaryEncoding.go | 63 +++---
arrow/internal/flatbuf/DictionaryKind.go | 10 +-
arrow/internal/flatbuf/Duration.go | 15 ++
arrow/internal/flatbuf/Endianness.go | 4 +-
arrow/internal/flatbuf/Feature.go | 38 ++--
arrow/internal/flatbuf/Field.go | 49 +++--
arrow/internal/flatbuf/FieldNode.go | 40 ++--
arrow/internal/flatbuf/FixedSizeBinary.go | 19 +-
arrow/internal/flatbuf/FixedSizeList.go | 19 +-
arrow/internal/flatbuf/FloatingPoint.go | 15 ++
arrow/internal/flatbuf/Footer.go | 25 ++-
arrow/internal/flatbuf/Int.go | 15 ++
arrow/internal/flatbuf/Interval.go | 15 ++
arrow/internal/flatbuf/KeyValue.go | 21 +-
arrow/internal/flatbuf/LargeBinary.go | 19 +-
arrow/internal/flatbuf/LargeList.go | 19 +-
arrow/internal/flatbuf/LargeListView.go | 19 +-
arrow/internal/flatbuf/LargeUtf8.go | 19 +-
arrow/internal/flatbuf/List.go | 15 ++
arrow/internal/flatbuf/ListView.go | 21 +-
arrow/internal/flatbuf/Map.go | 69 +++---
arrow/internal/flatbuf/Message.go | 15 ++
arrow/internal/flatbuf/MessageHeader.go | 16 +-
arrow/internal/flatbuf/Null.go | 17 +-
arrow/internal/flatbuf/RecordBatch.go | 117 ++++++-----
arrow/internal/flatbuf/RunEndEncoded.go | 25 ++-
arrow/internal/flatbuf/Schema.go | 35 ++-
arrow/internal/flatbuf/SparseMatrixIndexCSX.go | 157 +++++++-------
arrow/internal/flatbuf/SparseTensor.go | 43 ++--
arrow/internal/flatbuf/SparseTensorIndexCOO.go | 115 +++++-----
arrow/internal/flatbuf/SparseTensorIndexCSF.go | 269 +++++++++++++-----------
arrow/internal/flatbuf/Struct_.go | 21 +-
arrow/internal/flatbuf/Tensor.go | 39 ++--
arrow/internal/flatbuf/TensorDim.go | 29 ++-
arrow/internal/flatbuf/Time.go | 43 ++--
arrow/internal/flatbuf/Timestamp.go | 265 ++++++++++++-----------
arrow/internal/flatbuf/Type.go | 6 +-
arrow/internal/flatbuf/Union.go | 23 +-
arrow/internal/flatbuf/Utf8.go | 17 +-
arrow/internal/flatbuf/Utf8View.go | 29 ++-
50 files changed, 1326 insertions(+), 718 deletions(-)
diff --git a/arrow/internal/flatbuf/Binary.go b/arrow/internal/flatbuf/Binary.go
index 95e01559..fde7d8e2 100644
--- a/arrow/internal/flatbuf/Binary.go
+++ b/arrow/internal/flatbuf/Binary.go
@@ -22,7 +22,7 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Opaque binary data
+/// Opaque binary data
type Binary struct {
_tab flatbuffers.Table
}
@@ -34,6 +34,21 @@ func GetRootAsBinary(buf []byte, offset
flatbuffers.UOffsetT) *Binary {
return x
}
+func FinishBinaryBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBinary(buf []byte, offset flatbuffers.UOffsetT)
*Binary {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Binary{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedBinaryBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Binary) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/BinaryView.go
b/arrow/internal/flatbuf/BinaryView.go
index f6906674..969e2d26 100644
--- a/arrow/internal/flatbuf/BinaryView.go
+++ b/arrow/internal/flatbuf/BinaryView.go
@@ -22,13 +22,13 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Logically the same as Binary, but the internal representation uses a view
-// / struct that contains the string length and either the string's entire data
-// / inline (for small strings) or an inlined prefix, an index of another
buffer,
-// / and an offset pointing to a slice in that buffer (for non-small strings).
-// /
-// / Since it uses a variable number of data buffers, each Field with this type
-// / must have a corresponding entry in `variadicBufferCounts`.
+/// Logically the same as Binary, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another
buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// 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
}
@@ -40,6 +40,21 @@ func GetRootAsBinaryView(buf []byte, offset
flatbuffers.UOffsetT) *BinaryView {
return x
}
+func FinishBinaryViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT)
*BinaryView {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &BinaryView{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedBinaryViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *BinaryView) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Block.go b/arrow/internal/flatbuf/Block.go
index 8e33d3e6..57a697b1 100644
--- a/arrow/internal/flatbuf/Block.go
+++ b/arrow/internal/flatbuf/Block.go
@@ -35,34 +35,31 @@ func (rcv *Block) Table() flatbuffers.Table {
return rcv._tab.Table
}
-// / Index to the start of the RecordBlock (note this is past the Message
header)
+/// 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))
}
-
-// / Index to the start of the RecordBlock (note this is past the Message
header)
+/// 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)
}
-// / Length of the metadata
+/// Length of the metadata
func (rcv *Block) MetaDataLength() int32 {
return rcv._tab.GetInt32(rcv._tab.Pos + flatbuffers.UOffsetT(8))
}
-
-// / Length of the metadata
+/// Length of the metadata
func (rcv *Block) MutateMetaDataLength(n int32) bool {
return rcv._tab.MutateInt32(rcv._tab.Pos+flatbuffers.UOffsetT(8), n)
}
-// / Length of the data (this is aligned so there can be a gap between this and
-// / the metadata).
+/// 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))
}
-
-// / Length of the data (this is aligned so there can be a gap between this and
-// / the metadata).
+/// 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)
}
diff --git a/arrow/internal/flatbuf/BodyCompression.go
b/arrow/internal/flatbuf/BodyCompression.go
index c23c2919..e5a231aa 100644
--- a/arrow/internal/flatbuf/BodyCompression.go
+++ b/arrow/internal/flatbuf/BodyCompression.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Optional compression for the memory buffers constituting IPC message
-// / bodies. Intended for use with RecordBatch but could be used for other
-// / message types
+/// Optional compression for the memory buffers constituting IPC message
+/// bodies. Intended for use with RecordBatch but could be used for other
+/// message types
type BodyCompression struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsBodyCompression(buf []byte, offset
flatbuffers.UOffsetT) *BodyComp
return x
}
+func FinishBodyCompressionBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBodyCompression(buf []byte, offset
flatbuffers.UOffsetT) *BodyCompression {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &BodyCompression{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedBodyCompressionBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *BodyCompression) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -45,8 +60,8 @@ func (rcv *BodyCompression) Table() flatbuffers.Table {
return rcv._tab
}
-// / Compressor library.
-// / For LZ4_FRAME, each compressed buffer must consist of a single frame.
+/// 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))
if o != 0 {
@@ -55,13 +70,13 @@ func (rcv *BodyCompression) Codec() CompressionType {
return 0
}
-// / Compressor library.
-// / For LZ4_FRAME, each compressed buffer must consist of a single frame.
+/// 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))
}
-// / Indicates the way the record batch body was compressed
+/// Indicates the way the record batch body was compressed
func (rcv *BodyCompression) Method() BodyCompressionMethod {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
@@ -70,7 +85,7 @@ func (rcv *BodyCompression) Method() BodyCompressionMethod {
return 0
}
-// / Indicates the way the record batch body was compressed
+/// Indicates the way the record batch body was compressed
func (rcv *BodyCompression) MutateMethod(n BodyCompressionMethod) bool {
return rcv._tab.MutateInt8Slot(6, int8(n))
}
diff --git a/arrow/internal/flatbuf/BodyCompressionMethod.go
b/arrow/internal/flatbuf/BodyCompressionMethod.go
index bb7234b3..108ab3e0 100644
--- a/arrow/internal/flatbuf/BodyCompressionMethod.go
+++ b/arrow/internal/flatbuf/BodyCompressionMethod.go
@@ -20,9 +20,9 @@ package flatbuf
import "strconv"
-// / Provided for forward compatibility in case we need to support different
-// / strategies for compressing the IPC message body (like whole-body
-// / compression rather than buffer-level) in the future
+/// Provided for forward compatibility in case we need to support different
+/// strategies for compressing the IPC message body (like whole-body
+/// compression rather than buffer-level) in the future
type BodyCompressionMethod int8
const (
diff --git a/arrow/internal/flatbuf/Bool.go b/arrow/internal/flatbuf/Bool.go
index 6a4a9d26..6a2ca99f 100644
--- a/arrow/internal/flatbuf/Bool.go
+++ b/arrow/internal/flatbuf/Bool.go
@@ -33,6 +33,21 @@ func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT)
*Bool {
return x
}
+func FinishBoolBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Bool{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedBoolBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Bool) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Buffer.go b/arrow/internal/flatbuf/Buffer.go
index e650e06a..eba8d99b 100644
--- a/arrow/internal/flatbuf/Buffer.go
+++ b/arrow/internal/flatbuf/Buffer.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / A Buffer represents a single contiguous memory segment
+/// ----------------------------------------------------------------------
+/// A Buffer represents a single contiguous memory segment
type Buffer struct {
_tab flatbuffers.Struct
}
@@ -37,32 +37,30 @@ func (rcv *Buffer) Table() flatbuffers.Table {
return rcv._tab.Table
}
-// / The relative offset into the shared memory page where the bytes for this
-// / buffer starts
+/// 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))
}
-
-// / The relative offset into the shared memory page where the bytes for this
-// / buffer starts
+/// 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)
}
-// / The absolute length (in bytes) of the memory buffer. The memory is found
-// / from offset (inclusive) to offset + length (non-inclusive). When building
-// / messages using the encapsulated IPC message, padding bytes may be written
-// / after a buffer, but such padding bytes do not need to be accounted for in
-// / the size here.
+/// The absolute length (in bytes) of the memory buffer. The memory is found
+/// from offset (inclusive) to offset + length (non-inclusive). When building
+/// messages using the encapsulated IPC message, padding bytes may be written
+/// 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))
}
-
-// / The absolute length (in bytes) of the memory buffer. The memory is found
-// / from offset (inclusive) to offset + length (non-inclusive). When building
-// / messages using the encapsulated IPC message, padding bytes may be written
-// / after a buffer, but such padding bytes do not need to be accounted for in
-// / the size here.
+/// The absolute length (in bytes) of the memory buffer. The memory is found
+/// from offset (inclusive) to offset + length (non-inclusive). When building
+/// messages using the encapsulated IPC message, padding bytes may be written
+/// 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)
}
diff --git a/arrow/internal/flatbuf/Date.go b/arrow/internal/flatbuf/Date.go
index 985a8f79..ae3c1540 100644
--- a/arrow/internal/flatbuf/Date.go
+++ b/arrow/internal/flatbuf/Date.go
@@ -22,12 +22,12 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Date is either a 32-bit or 64-bit signed integer type representing an
-// / elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
-// /
-// / * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
-// / leap seconds), where the values are evenly divisible by 86400000
-// / * Days (32 bits) since the UNIX epoch
+/// Date is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
+///
+/// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
+/// leap seconds), where the values are evenly divisible by 86400000
+/// * Days (32 bits) since the UNIX epoch
type Date struct {
_tab flatbuffers.Table
}
@@ -39,6 +39,21 @@ func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT)
*Date {
return x
}
+func FinishDateBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Date{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedDateBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Date) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Decimal.go
b/arrow/internal/flatbuf/Decimal.go
index 234c3964..8602cb3c 100644
--- a/arrow/internal/flatbuf/Decimal.go
+++ b/arrow/internal/flatbuf/Decimal.go
@@ -37,6 +37,21 @@ func GetRootAsDecimal(buf []byte, offset
flatbuffers.UOffsetT) *Decimal {
return x
}
+func FinishDecimalBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT)
*Decimal {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Decimal{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedDecimalBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Decimal) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/DictionaryBatch.go
b/arrow/internal/flatbuf/DictionaryBatch.go
index 999c5fda..3bcf7244 100644
--- a/arrow/internal/flatbuf/DictionaryBatch.go
+++ b/arrow/internal/flatbuf/DictionaryBatch.go
@@ -22,12 +22,12 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / For sending dictionary encoding information. Any Field can be
-// / dictionary-encoded, but in this case none of its children may be
-// / dictionary-encoded.
-// / There is one vector / column per dictionary, but that vector / column
-// / may be spread across multiple dictionary batches by using the isDelta
-// / flag
+/// For sending dictionary encoding information. Any Field can be
+/// dictionary-encoded, but in this case none of its children may be
+/// dictionary-encoded.
+/// There is one vector / column per dictionary, but that vector / column
+/// may be spread across multiple dictionary batches by using the isDelta
+/// flag
type DictionaryBatch struct {
_tab flatbuffers.Table
}
@@ -39,6 +39,21 @@ func GetRootAsDictionaryBatch(buf []byte, offset
flatbuffers.UOffsetT) *Dictiona
return x
}
+func FinishDictionaryBatchBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDictionaryBatch(buf []byte, offset
flatbuffers.UOffsetT) *DictionaryBatch {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &DictionaryBatch{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedDictionaryBatchBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *DictionaryBatch) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -73,9 +88,9 @@ func (rcv *DictionaryBatch) Data(obj *RecordBatch)
*RecordBatch {
return nil
}
-// / 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.
+/// 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))
if o != 0 {
@@ -84,9 +99,9 @@ func (rcv *DictionaryBatch) IsDelta() bool {
return false
}
-// / 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.
+/// 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) MutateIsDelta(n bool) bool {
return rcv._tab.MutateBoolSlot(8, n)
}
diff --git a/arrow/internal/flatbuf/DictionaryEncoding.go
b/arrow/internal/flatbuf/DictionaryEncoding.go
index 44c38742..69167802 100644
--- a/arrow/internal/flatbuf/DictionaryEncoding.go
+++ b/arrow/internal/flatbuf/DictionaryEncoding.go
@@ -33,6 +33,21 @@ func GetRootAsDictionaryEncoding(buf []byte, offset
flatbuffers.UOffsetT) *Dicti
return x
}
+func FinishDictionaryEncodingBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDictionaryEncoding(buf []byte, offset
flatbuffers.UOffsetT) *DictionaryEncoding {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &DictionaryEncoding{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedDictionaryEncodingBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *DictionaryEncoding) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -42,9 +57,9 @@ func (rcv *DictionaryEncoding) Table() flatbuffers.Table {
return rcv._tab
}
-// / 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
+/// 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))
if o != 0 {
@@ -53,18 +68,18 @@ func (rcv *DictionaryEncoding) Id() int64 {
return 0
}
-// / 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
+/// 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) MutateId(n int64) bool {
return rcv._tab.MutateInt64Slot(4, n)
}
-// / The dictionary indices are constrained to be non-negative integers. If
-// / this field is null, the indices must be signed int32. To maximize
-// / 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.
+/// The dictionary indices are constrained to be non-negative integers. If
+/// this field is null, the indices must be signed int32. To maximize
+/// 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))
if o != 0 {
@@ -78,15 +93,15 @@ func (rcv *DictionaryEncoding) IndexType(obj *Int) *Int {
return nil
}
-// / The dictionary indices are constrained to be non-negative integers. If
-// / this field is null, the indices must be signed int32. To maximize
-// / 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.
-// / By default, dictionaries are not ordered, or the order does not have
-// / semantic meaning. In some statistical, applications, dictionary-encoding
-// / is used to represent ordered categorical data, and we provide a way to
-// / preserve that metadata here
+/// The dictionary indices are constrained to be non-negative integers. If
+/// this field is null, the indices must be signed int32. To maximize
+/// 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.
+/// By default, dictionaries are not ordered, or the order does not have
+/// semantic meaning. In some statistical, applications, dictionary-encoding
+/// 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))
if o != 0 {
@@ -95,10 +110,10 @@ func (rcv *DictionaryEncoding) IsOrdered() bool {
return false
}
-// / By default, dictionaries are not ordered, or the order does not have
-// / semantic meaning. In some statistical, applications, dictionary-encoding
-// / is used to represent ordered categorical data, and we provide a way to
-// / preserve that metadata here
+/// By default, dictionaries are not ordered, or the order does not have
+/// semantic meaning. In some statistical, applications, dictionary-encoding
+/// 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)
}
diff --git a/arrow/internal/flatbuf/DictionaryKind.go
b/arrow/internal/flatbuf/DictionaryKind.go
index 68251005..126ba5f7 100644
--- a/arrow/internal/flatbuf/DictionaryKind.go
+++ b/arrow/internal/flatbuf/DictionaryKind.go
@@ -20,11 +20,11 @@ package flatbuf
import "strconv"
-// / ----------------------------------------------------------------------
-// / Dictionary encoding metadata
-// / Maintained for forwards compatibility, in the future
-// / Dictionaries might be explicit maps between integers and values
-// / allowing for non-contiguous index values
+/// ----------------------------------------------------------------------
+/// Dictionary encoding metadata
+/// Maintained for forwards compatibility, in the future
+/// Dictionaries might be explicit maps between integers and values
+/// allowing for non-contiguous index values
type DictionaryKind int16
const (
diff --git a/arrow/internal/flatbuf/Duration.go
b/arrow/internal/flatbuf/Duration.go
index 57b7b2a0..e49f04d8 100644
--- a/arrow/internal/flatbuf/Duration.go
+++ b/arrow/internal/flatbuf/Duration.go
@@ -33,6 +33,21 @@ func GetRootAsDuration(buf []byte, offset
flatbuffers.UOffsetT) *Duration {
return x
}
+func FinishDurationBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDuration(buf []byte, offset flatbuffers.UOffsetT)
*Duration {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Duration{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedDurationBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Duration) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Endianness.go
b/arrow/internal/flatbuf/Endianness.go
index c9619b7b..cefa2ff9 100644
--- a/arrow/internal/flatbuf/Endianness.go
+++ b/arrow/internal/flatbuf/Endianness.go
@@ -20,8 +20,8 @@ package flatbuf
import "strconv"
-// / ----------------------------------------------------------------------
-// / Endianness of the platform producing the data
+/// ----------------------------------------------------------------------
+/// Endianness of the platform producing the data
type Endianness int16
const (
diff --git a/arrow/internal/flatbuf/Feature.go
b/arrow/internal/flatbuf/Feature.go
index 2204c440..7aacc21c 100644
--- a/arrow/internal/flatbuf/Feature.go
+++ b/arrow/internal/flatbuf/Feature.go
@@ -20,35 +20,35 @@ package flatbuf
import "strconv"
-// / Represents Arrow Features that might not have full support
-// / within implementations. This is intended to be used in
-// / two scenarios:
-// / 1. A mechanism for readers of Arrow Streams
-// / and files to understand that the stream or file makes
-// / use of a feature that isn't supported or unknown to
-// / the implementation (and therefore can meet the Arrow
-// / forward compatibility guarantees).
-// / 2. A means of negotiating between a client and server
-// / what features a stream is allowed to use. The enums
-// / values here are intented to represent higher level
-// / features, additional details maybe negotiated
-// / with key-value pairs specific to the protocol.
-// /
-// / Enums added to this list should be assigned power-of-two values
-// / to facilitate exchanging and comparing bitmaps for supported
-// / features.
+/// Represents Arrow Features that might not have full support
+/// within implementations. This is intended to be used in
+/// two scenarios:
+/// 1. A mechanism for readers of Arrow Streams
+/// and files to understand that the stream or file makes
+/// use of a feature that isn't supported or unknown to
+/// the implementation (and therefore can meet the Arrow
+/// forward compatibility guarantees).
+/// 2. A means of negotiating between a client and server
+/// what features a stream is allowed to use. The enums
+/// values here are intended to represent higher level
+/// features, additional details may be negotiated
+/// with key-value pairs specific to the protocol.
+///
+/// Enums added to this list should be assigned power-of-two values
+/// to facilitate exchanging and comparing bitmaps for supported
+/// features.
type Feature int64
const (
/// Needed to make flatbuffers happy.
- FeatureUNUSED Feature = 0
+ FeatureUNUSED Feature = 0
/// The stream makes use of multiple full dictionaries with the
/// same ID and assumes clients implement dictionary replacement
/// correctly.
FeatureDICTIONARY_REPLACEMENT Feature = 1
/// The stream makes use of compressed bodies as described
/// in Message.fbs.
- FeatureCOMPRESSED_BODY Feature = 2
+ FeatureCOMPRESSED_BODY Feature = 2
)
var EnumNamesFeature = map[Feature]string{
diff --git a/arrow/internal/flatbuf/Field.go b/arrow/internal/flatbuf/Field.go
index 8aed29bc..a955fc68 100644
--- a/arrow/internal/flatbuf/Field.go
+++ b/arrow/internal/flatbuf/Field.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / A field represents a named column in a record / row batch or child of a
-// / nested type.
+/// ----------------------------------------------------------------------
+/// A field represents a named column in a record / row batch or child of a
+/// nested type.
type Field struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT)
*Field {
return x
}
+func FinishFieldBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsField(buf []byte, offset flatbuffers.UOffsetT)
*Field {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Field{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedFieldBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Field) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -45,7 +60,7 @@ func (rcv *Field) Table() flatbuffers.Table {
return rcv._tab
}
-// / Name is not required, in i.e. a List
+/// Name is not required (e.g., in a List)
func (rcv *Field) Name() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -54,8 +69,8 @@ func (rcv *Field) Name() []byte {
return nil
}
-// / Name is not required, in i.e. a List
-// / Whether or not this field can contain nulls. Should be true in general.
+/// 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))
if o != 0 {
@@ -64,7 +79,7 @@ func (rcv *Field) Nullable() bool {
return false
}
-// / Whether or not this field can contain nulls. Should be true in general.
+/// 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)
}
@@ -81,7 +96,7 @@ func (rcv *Field) MutateTypeType(n Type) bool {
return rcv._tab.MutateByteSlot(8, byte(n))
}
-// / This is the type of the decoded value if the field is dictionary encoded.
+/// 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))
if o != 0 {
@@ -91,8 +106,8 @@ func (rcv *Field) Type(obj *flatbuffers.Table) bool {
return false
}
-// / This is the type of the decoded value if the field is dictionary encoded.
-// / Present only if the field is dictionary encoded.
+/// 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))
if o != 0 {
@@ -106,9 +121,9 @@ func (rcv *Field) Dictionary(obj *DictionaryEncoding)
*DictionaryEncoding {
return nil
}
-// / 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.
+/// 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))
if o != 0 {
@@ -129,9 +144,9 @@ func (rcv *Field) ChildrenLength() int {
return 0
}
-// / children apply only to nested data types like Struct, List and Union. For
-// / primitive types children will have length 0.
-// / User-defined metadata
+/// 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))
if o != 0 {
@@ -152,7 +167,7 @@ func (rcv *Field) CustomMetadataLength() int {
return 0
}
-// / User-defined metadata
+/// User-defined metadata
func FieldStart(builder *flatbuffers.Builder) {
builder.StartObject(7)
}
diff --git a/arrow/internal/flatbuf/FieldNode.go
b/arrow/internal/flatbuf/FieldNode.go
index 0e258a3d..606b30bf 100644
--- a/arrow/internal/flatbuf/FieldNode.go
+++ b/arrow/internal/flatbuf/FieldNode.go
@@ -22,15 +22,15 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / Data structures for describing a table row batch (a collection of
-// / equal-length Arrow arrays)
-// / Metadata about a field at some level of a nested type tree (but not
-// / its children).
-// /
-// / For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6],
null]`
-// / 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
+/// ----------------------------------------------------------------------
+/// Data structures for describing a table row batch (a collection of
+/// equal-length Arrow arrays)
+/// Metadata about a field at some level of a nested type tree (but not
+/// its children).
+///
+/// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6],
null]`
+/// 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
}
@@ -44,28 +44,26 @@ func (rcv *FieldNode) Table() flatbuffers.Table {
return rcv._tab.Table
}
-// / The number of value slots in the Arrow array at this level of a nested
-// / tree
+/// 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))
}
-
-// / The number of value slots in the Arrow array at this level of a nested
-// / tree
+/// 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)
}
-// / 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.
+/// 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))
}
-
-// / 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.
+/// 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)
}
diff --git a/arrow/internal/flatbuf/FixedSizeBinary.go
b/arrow/internal/flatbuf/FixedSizeBinary.go
index 2725dfb9..57d7c25e 100644
--- a/arrow/internal/flatbuf/FixedSizeBinary.go
+++ b/arrow/internal/flatbuf/FixedSizeBinary.go
@@ -33,6 +33,21 @@ func GetRootAsFixedSizeBinary(buf []byte, offset
flatbuffers.UOffsetT) *FixedSiz
return x
}
+func FinishFixedSizeBinaryBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsFixedSizeBinary(buf []byte, offset
flatbuffers.UOffsetT) *FixedSizeBinary {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &FixedSizeBinary{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedFixedSizeBinaryBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *FixedSizeBinary) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -42,7 +57,7 @@ func (rcv *FixedSizeBinary) Table() flatbuffers.Table {
return rcv._tab
}
-// / Number of bytes per value
+/// Number of bytes per value
func (rcv *FixedSizeBinary) ByteWidth() int32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -51,7 +66,7 @@ func (rcv *FixedSizeBinary) ByteWidth() int32 {
return 0
}
-// / Number of bytes per value
+/// Number of bytes per value
func (rcv *FixedSizeBinary) MutateByteWidth(n int32) bool {
return rcv._tab.MutateInt32Slot(4, n)
}
diff --git a/arrow/internal/flatbuf/FixedSizeList.go
b/arrow/internal/flatbuf/FixedSizeList.go
index 534ca27f..83e7211b 100644
--- a/arrow/internal/flatbuf/FixedSizeList.go
+++ b/arrow/internal/flatbuf/FixedSizeList.go
@@ -33,6 +33,21 @@ func GetRootAsFixedSizeList(buf []byte, offset
flatbuffers.UOffsetT) *FixedSizeL
return x
}
+func FinishFixedSizeListBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsFixedSizeList(buf []byte, offset
flatbuffers.UOffsetT) *FixedSizeList {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &FixedSizeList{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedFixedSizeListBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *FixedSizeList) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -42,7 +57,7 @@ func (rcv *FixedSizeList) Table() flatbuffers.Table {
return rcv._tab
}
-// / Number of list items per value
+/// Number of list items per value
func (rcv *FixedSizeList) ListSize() int32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -51,7 +66,7 @@ func (rcv *FixedSizeList) ListSize() int32 {
return 0
}
-// / Number of list items per value
+/// Number of list items per value
func (rcv *FixedSizeList) MutateListSize(n int32) bool {
return rcv._tab.MutateInt32Slot(4, n)
}
diff --git a/arrow/internal/flatbuf/FloatingPoint.go
b/arrow/internal/flatbuf/FloatingPoint.go
index 241d448d..e38241f0 100644
--- a/arrow/internal/flatbuf/FloatingPoint.go
+++ b/arrow/internal/flatbuf/FloatingPoint.go
@@ -33,6 +33,21 @@ func GetRootAsFloatingPoint(buf []byte, offset
flatbuffers.UOffsetT) *FloatingPo
return x
}
+func FinishFloatingPointBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsFloatingPoint(buf []byte, offset
flatbuffers.UOffsetT) *FloatingPoint {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &FloatingPoint{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedFloatingPointBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *FloatingPoint) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Footer.go b/arrow/internal/flatbuf/Footer.go
index d65af41e..338bbd69 100644
--- a/arrow/internal/flatbuf/Footer.go
+++ b/arrow/internal/flatbuf/Footer.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / Arrow File metadata
-// /
+/// ----------------------------------------------------------------------
+/// Arrow File metadata
+///
type Footer struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsFooter(buf []byte, offset
flatbuffers.UOffsetT) *Footer {
return x
}
+func FinishFooterBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsFooter(buf []byte, offset flatbuffers.UOffsetT)
*Footer {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Footer{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedFooterBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Footer) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -108,7 +123,7 @@ func (rcv *Footer) RecordBatchesLength() int {
return 0
}
-// / User-defined metadata
+/// User-defined metadata
func (rcv *Footer) CustomMetadata(obj *KeyValue, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
@@ -129,7 +144,7 @@ func (rcv *Footer) CustomMetadataLength() int {
return 0
}
-// / User-defined metadata
+/// User-defined metadata
func FooterStart(builder *flatbuffers.Builder) {
builder.StartObject(5)
}
diff --git a/arrow/internal/flatbuf/Int.go b/arrow/internal/flatbuf/Int.go
index 9f4b1911..b4ef5054 100644
--- a/arrow/internal/flatbuf/Int.go
+++ b/arrow/internal/flatbuf/Int.go
@@ -33,6 +33,21 @@ func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT)
*Int {
return x
}
+func FinishIntBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Int{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedIntBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Int) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Interval.go
b/arrow/internal/flatbuf/Interval.go
index 12c56d5c..69018c58 100644
--- a/arrow/internal/flatbuf/Interval.go
+++ b/arrow/internal/flatbuf/Interval.go
@@ -33,6 +33,21 @@ func GetRootAsInterval(buf []byte, offset
flatbuffers.UOffsetT) *Interval {
return x
}
+func FinishIntervalBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsInterval(buf []byte, offset flatbuffers.UOffsetT)
*Interval {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Interval{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedIntervalBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Interval) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/KeyValue.go
b/arrow/internal/flatbuf/KeyValue.go
index 0cd5dc62..c9cad2f9 100644
--- a/arrow/internal/flatbuf/KeyValue.go
+++ b/arrow/internal/flatbuf/KeyValue.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / user defined key value pairs to add custom metadata to arrow
-// / key namespacing is the responsibility of the user
+/// ----------------------------------------------------------------------
+/// 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
}
@@ -36,6 +36,21 @@ func GetRootAsKeyValue(buf []byte, offset
flatbuffers.UOffsetT) *KeyValue {
return x
}
+func FinishKeyValueBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT)
*KeyValue {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &KeyValue{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedKeyValueBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *KeyValue) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/LargeBinary.go
b/arrow/internal/flatbuf/LargeBinary.go
index b25ecc41..efb377db 100644
--- a/arrow/internal/flatbuf/LargeBinary.go
+++ b/arrow/internal/flatbuf/LargeBinary.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Same as Binary, but with 64-bit offsets, allowing to represent
-// / extremely large data values.
+/// Same as Binary, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
type LargeBinary struct {
_tab flatbuffers.Table
}
@@ -35,6 +35,21 @@ func GetRootAsLargeBinary(buf []byte, offset
flatbuffers.UOffsetT) *LargeBinary
return x
}
+func FinishLargeBinaryBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT)
*LargeBinary {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &LargeBinary{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedLargeBinaryBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *LargeBinary) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/LargeList.go
b/arrow/internal/flatbuf/LargeList.go
index d8bfb9c0..426780ad 100644
--- a/arrow/internal/flatbuf/LargeList.go
+++ b/arrow/internal/flatbuf/LargeList.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Same as List, but with 64-bit offsets, allowing to represent
-// / extremely large data values.
+/// Same as List, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
type LargeList struct {
_tab flatbuffers.Table
}
@@ -35,6 +35,21 @@ func GetRootAsLargeList(buf []byte, offset
flatbuffers.UOffsetT) *LargeList {
return x
}
+func FinishLargeListBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT)
*LargeList {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &LargeList{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedLargeListBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *LargeList) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/LargeListView.go
b/arrow/internal/flatbuf/LargeListView.go
index 4608c1de..b06657c3 100644
--- a/arrow/internal/flatbuf/LargeListView.go
+++ b/arrow/internal/flatbuf/LargeListView.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Same as ListView, but with 64-bit offsets and sizes, allowing to represent
-// / extremely large data values.
+/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+/// extremely large data values.
type LargeListView struct {
_tab flatbuffers.Table
}
@@ -35,6 +35,21 @@ func GetRootAsLargeListView(buf []byte, offset
flatbuffers.UOffsetT) *LargeListV
return x
}
+func FinishLargeListViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLargeListView(buf []byte, offset
flatbuffers.UOffsetT) *LargeListView {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &LargeListView{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedLargeListViewBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *LargeListView) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/LargeUtf8.go
b/arrow/internal/flatbuf/LargeUtf8.go
index 4478fed8..de289319 100644
--- a/arrow/internal/flatbuf/LargeUtf8.go
+++ b/arrow/internal/flatbuf/LargeUtf8.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Same as Utf8, but with 64-bit offsets, allowing to represent
-// / extremely large data values.
+/// Same as Utf8, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
type LargeUtf8 struct {
_tab flatbuffers.Table
}
@@ -35,6 +35,21 @@ func GetRootAsLargeUtf8(buf []byte, offset
flatbuffers.UOffsetT) *LargeUtf8 {
return x
}
+func FinishLargeUtf8Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT)
*LargeUtf8 {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &LargeUtf8{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedLargeUtf8Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *LargeUtf8) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/List.go b/arrow/internal/flatbuf/List.go
index ba84319d..eb02ae1e 100644
--- a/arrow/internal/flatbuf/List.go
+++ b/arrow/internal/flatbuf/List.go
@@ -33,6 +33,21 @@ func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT)
*List {
return x
}
+func FinishListBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &List{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedListBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *List) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/ListView.go
b/arrow/internal/flatbuf/ListView.go
index cde43cf5..50b38cf8 100644
--- a/arrow/internal/flatbuf/ListView.go
+++ b/arrow/internal/flatbuf/ListView.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Represents the same logical types that List can, but contains offsets and
-// / sizes allowing for writes in any order and sharing of child values among
-// / list values.
+/// Represents the same logical types that List can, but contains offsets and
+/// sizes allowing for writes in any order and sharing of child values among
+/// list values.
type ListView struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsListView(buf []byte, offset
flatbuffers.UOffsetT) *ListView {
return x
}
+func FinishListViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsListView(buf []byte, offset flatbuffers.UOffsetT)
*ListView {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ListView{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedListViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *ListView) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Map.go b/arrow/internal/flatbuf/Map.go
index d4871e55..021cfb17 100644
--- a/arrow/internal/flatbuf/Map.go
+++ b/arrow/internal/flatbuf/Map.go
@@ -22,31 +22,31 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / A Map is a logical nested type that is represented as
-// /
-// / List<entries: Struct<key: K, value: V>>
-// /
-// / In this layout, the keys and values are each respectively contiguous. We
do
-// / not constrain the key and value types, so the application is responsible
-// / for ensuring that the keys are hashable and unique. Whether the keys are
sorted
-// / may be set in the metadata for this field.
-// /
-// / In a field with Map type, the field has a child Struct field, which then
-// / has two children: key type and the second the value type. The names of the
-// / child fields may be respectively "entries", "key", and "value", but this
is
-// / not enforced.
-// /
-// / Map
-// / ```text
-// / - child[0] entries: Struct
-// / - child[0] key: K
-// / - child[1] value: V
-// / ```
-// / Neither the "entries" field nor the "key" field may be nullable.
-// /
-// / The metadata is structured so that Arrow systems without special handling
-// / for Map can make Map an alias for List. The "layout" attribute for the Map
-// / field must have the same contents as a List.
+/// A Map is a logical nested type that is represented as
+///
+/// List<entries: Struct<key: K, value: V>>
+///
+/// In this layout, the keys and values are each respectively contiguous. We do
+/// not constrain the key and value types, so the application is responsible
+/// for ensuring that the keys are hashable and unique. Whether the keys are
sorted
+/// may be set in the metadata for this field.
+///
+/// In a field with Map type, the field has a child Struct field, which then
+/// has two children: key type and the second the value type. The names of the
+/// child fields may be respectively "entries", "key", and "value", but this is
+/// not enforced.
+///
+/// Map
+/// ```text
+/// - child[0] entries: Struct
+/// - child[0] key: K
+/// - child[1] value: V
+/// ```
+/// Neither the "entries" field nor the "key" field may be nullable.
+///
+/// The metadata is structured so that Arrow systems without special handling
+/// 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
}
@@ -58,6 +58,21 @@ func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT)
*Map {
return x
}
+func FinishMapBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Map{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedMapBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Map) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -67,7 +82,7 @@ func (rcv *Map) Table() flatbuffers.Table {
return rcv._tab
}
-// / Set to true if the keys within each value are sorted
+/// Set to true if the keys within each value are sorted
func (rcv *Map) KeysSorted() bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -76,7 +91,7 @@ func (rcv *Map) KeysSorted() bool {
return false
}
-// / Set to true if the keys within each value are sorted
+/// Set to true if the keys within each value are sorted
func (rcv *Map) MutateKeysSorted(n bool) bool {
return rcv._tab.MutateBoolSlot(4, n)
}
diff --git a/arrow/internal/flatbuf/Message.go
b/arrow/internal/flatbuf/Message.go
index f4b4a0ff..0975bf12 100644
--- a/arrow/internal/flatbuf/Message.go
+++ b/arrow/internal/flatbuf/Message.go
@@ -33,6 +33,21 @@ func GetRootAsMessage(buf []byte, offset
flatbuffers.UOffsetT) *Message {
return x
}
+func FinishMessageBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsMessage(buf []byte, offset flatbuffers.UOffsetT)
*Message {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Message{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedMessageBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Message) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/MessageHeader.go
b/arrow/internal/flatbuf/MessageHeader.go
index d7f9907c..c12fc105 100644
--- a/arrow/internal/flatbuf/MessageHeader.go
+++ b/arrow/internal/flatbuf/MessageHeader.go
@@ -20,14 +20,14 @@ package flatbuf
import "strconv"
-// / ----------------------------------------------------------------------
-// / The root Message type
-// / This union enables us to easily send different message types without
-// / redundant storage, and in the future we can easily add new message types.
-// /
-// / Arrow implementations do not need to implement all of the message types,
-// / which may include experimental metadata types. For maximum compatibility,
-// / it is best to send data using RecordBatch
+/// ----------------------------------------------------------------------
+/// The root Message type
+/// This union enables us to easily send different message types without
+/// redundant storage, and in the future we can easily add new message types.
+///
+/// Arrow implementations do not need to implement all of the message types,
+/// which may include experimental metadata types. For maximum compatibility,
+/// it is best to send data using RecordBatch
type MessageHeader byte
const (
diff --git a/arrow/internal/flatbuf/Null.go b/arrow/internal/flatbuf/Null.go
index 3b93a1b6..8c831251 100644
--- a/arrow/internal/flatbuf/Null.go
+++ b/arrow/internal/flatbuf/Null.go
@@ -22,7 +22,7 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / These are stored in the flatbuffer in the Type union below
+/// These are stored in the flatbuffer in the Type union below
type Null struct {
_tab flatbuffers.Table
}
@@ -34,6 +34,21 @@ func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT)
*Null {
return x
}
+func FinishNullBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Null{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedNullBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Null) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/RecordBatch.go
b/arrow/internal/flatbuf/RecordBatch.go
index 52c72a8a..f9a35c96 100644
--- a/arrow/internal/flatbuf/RecordBatch.go
+++ b/arrow/internal/flatbuf/RecordBatch.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / A data header describing the shared memory layout of a "record" or "row"
-// / batch. Some systems call this a "row batch" internally and others a
"record
-// / batch".
+/// A data header describing the shared memory layout of a "record" or "row"
+/// batch. Some systems call this a "row batch" internally and others a "record
+/// batch".
type RecordBatch struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsRecordBatch(buf []byte, offset
flatbuffers.UOffsetT) *RecordBatch
return x
}
+func FinishRecordBatchBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT)
*RecordBatch {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &RecordBatch{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedRecordBatchBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *RecordBatch) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -45,8 +60,8 @@ func (rcv *RecordBatch) Table() flatbuffers.Table {
return rcv._tab
}
-// / number of records / rows. The arrays in the batch should all have this
-// / length
+/// 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))
if o != 0 {
@@ -55,13 +70,13 @@ func (rcv *RecordBatch) Length() int64 {
return 0
}
-// / number of records / rows. The arrays in the batch should all have this
-// / length
+/// 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)
}
-// / Nodes correspond to the pre-ordered flattened logical schema
+/// 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))
if o != 0 {
@@ -81,13 +96,13 @@ func (rcv *RecordBatch) NodesLength() int {
return 0
}
-// / Nodes correspond to the pre-ordered flattened logical schema
-// / Buffers correspond to the pre-ordered flattened buffer tree
-// /
-// / The number of buffers appended to this list depends on the schema. For
-// / 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
+/// Nodes correspond to the pre-ordered flattened logical schema
+/// Buffers correspond to the pre-ordered flattened buffer tree
+///
+/// The number of buffers appended to this list depends on the schema. For
+/// 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))
if o != 0 {
@@ -107,13 +122,13 @@ func (rcv *RecordBatch) BuffersLength() int {
return 0
}
-// / Buffers correspond to the pre-ordered flattened buffer tree
-// /
-// / The number of buffers appended to this list depends on the schema. For
-// / 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
-// / Optional compression of the message body
+/// Buffers correspond to the pre-ordered flattened buffer tree
+///
+/// The number of buffers appended to this list depends on the schema. For
+/// 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
+/// Optional compression of the message body
func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
@@ -127,21 +142,21 @@ func (rcv *RecordBatch) Compression(obj *BodyCompression)
*BodyCompression {
return nil
}
-// / Optional compression of the message body
-// / Some types such as Utf8View are represented using a variable number of
buffers.
-// / For each such Field in the pre-ordered flattened logical schema, there
will be
-// / an entry in variadicBufferCounts to indicate the number of number of
variadic
-// / buffers which belong to that Field in the current RecordBatch.
-// /
-// / For example, the schema
-// / col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
-// / col2: Utf8View
-// / contains two Fields with variadic buffers so variadicBufferCounts will
have
-// / two entries, the first counting the variadic buffers of `col1.beta` and
the
-// / second counting `col2`'s.
-// /
-// / 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.
+/// Optional compression of the message body
+/// Some types such as Utf8View are represented using a variable number of
buffers.
+/// For each such Field in the pre-ordered flattened logical schema, there
will be
+/// an entry in variadicBufferCounts to indicate the number of number of
variadic
+/// buffers which belong to that Field in the current RecordBatch.
+///
+/// For example, the schema
+/// col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+/// col2: Utf8View
+/// contains two Fields with variadic buffers so variadicBufferCounts will have
+/// two entries, the first counting the variadic buffers of `col1.beta` and the
+/// second counting `col2`'s.
+///
+/// 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))
if o != 0 {
@@ -159,20 +174,20 @@ func (rcv *RecordBatch) VariadicBufferCountsLength() int {
return 0
}
-// / Some types such as Utf8View are represented using a variable number of
buffers.
-// / For each such Field in the pre-ordered flattened logical schema, there
will be
-// / an entry in variadicBufferCounts to indicate the number of number of
variadic
-// / buffers which belong to that Field in the current RecordBatch.
-// /
-// / For example, the schema
-// / col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
-// / col2: Utf8View
-// / contains two Fields with variadic buffers so variadicBufferCounts will
have
-// / two entries, the first counting the variadic buffers of `col1.beta` and
the
-// / second counting `col2`'s.
-// /
-// / 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.
+/// Some types such as Utf8View are represented using a variable number of
buffers.
+/// For each such Field in the pre-ordered flattened logical schema, there
will be
+/// an entry in variadicBufferCounts to indicate the number of number of
variadic
+/// buffers which belong to that Field in the current RecordBatch.
+///
+/// For example, the schema
+/// col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+/// col2: Utf8View
+/// contains two Fields with variadic buffers so variadicBufferCounts will have
+/// two entries, the first counting the variadic buffers of `col1.beta` and the
+/// second counting `col2`'s.
+///
+/// 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))
if o != 0 {
diff --git a/arrow/internal/flatbuf/RunEndEncoded.go
b/arrow/internal/flatbuf/RunEndEncoded.go
index b88460b2..3c1d6c7b 100644
--- a/arrow/internal/flatbuf/RunEndEncoded.go
+++ b/arrow/internal/flatbuf/RunEndEncoded.go
@@ -22,11 +22,11 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Contains two child arrays, run_ends and values.
-// / The run_ends child array must be a 16/32/64-bit integer array
-// / which encodes the indices at which the run with the value in
-// / each corresponding index in the values child array ends.
-// / Like list/struct types, the value array can be of any type.
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in
+/// 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
}
@@ -38,6 +38,21 @@ func GetRootAsRunEndEncoded(buf []byte, offset
flatbuffers.UOffsetT) *RunEndEnco
return x
}
+func FinishRunEndEncodedBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRunEndEncoded(buf []byte, offset
flatbuffers.UOffsetT) *RunEndEncoded {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &RunEndEncoded{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedRunEndEncodedBuffer(builder *flatbuffers.Builder,
offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *RunEndEncoded) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Schema.go b/arrow/internal/flatbuf/Schema.go
index ae5b248a..fa31c22c 100644
--- a/arrow/internal/flatbuf/Schema.go
+++ b/arrow/internal/flatbuf/Schema.go
@@ -22,8 +22,8 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / A Schema describes the columns in a row batch
+/// ----------------------------------------------------------------------
+/// A Schema describes the columns in a row batch
type Schema struct {
_tab flatbuffers.Table
}
@@ -35,6 +35,21 @@ func GetRootAsSchema(buf []byte, offset
flatbuffers.UOffsetT) *Schema {
return x
}
+func FinishSchemaBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSchema(buf []byte, offset flatbuffers.UOffsetT)
*Schema {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Schema{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedSchemaBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Schema) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -44,9 +59,9 @@ func (rcv *Schema) Table() flatbuffers.Table {
return rcv._tab
}
-// / 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
+/// 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))
if o != 0 {
@@ -55,9 +70,9 @@ func (rcv *Schema) Endianness() Endianness {
return 0
}
-// / 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
+/// 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) MutateEndianness(n Endianness) bool {
return rcv._tab.MutateInt16Slot(4, int16(n))
}
@@ -102,7 +117,7 @@ func (rcv *Schema) CustomMetadataLength() int {
return 0
}
-// / Features used in the stream/file.
+/// Features used in the stream/file.
func (rcv *Schema) Features(j int) Feature {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
@@ -120,7 +135,7 @@ func (rcv *Schema) FeaturesLength() int {
return 0
}
-// / Features used in the stream/file.
+/// Features used in the stream/file.
func (rcv *Schema) MutateFeatures(j int, n Feature) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
diff --git a/arrow/internal/flatbuf/SparseMatrixIndexCSX.go
b/arrow/internal/flatbuf/SparseMatrixIndexCSX.go
index 7f262dee..07f9a00b 100644
--- a/arrow/internal/flatbuf/SparseMatrixIndexCSX.go
+++ b/arrow/internal/flatbuf/SparseMatrixIndexCSX.go
@@ -22,7 +22,7 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Compressed Sparse format, that is matrix-specific.
+/// Compressed Sparse format, that is matrix-specific.
type SparseMatrixIndexCSX struct {
_tab flatbuffers.Table
}
@@ -34,6 +34,21 @@ func GetRootAsSparseMatrixIndexCSX(buf []byte, offset
flatbuffers.UOffsetT) *Spa
return x
}
+func FinishSparseMatrixIndexCSXBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSparseMatrixIndexCSX(buf []byte, offset
flatbuffers.UOffsetT) *SparseMatrixIndexCSX {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &SparseMatrixIndexCSX{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedSparseMatrixIndexCSXBuffer(builder
*flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *SparseMatrixIndexCSX) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -43,7 +58,7 @@ func (rcv *SparseMatrixIndexCSX) Table() flatbuffers.Table {
return rcv._tab
}
-// / Which axis, row or column, is compressed
+/// Which axis, row or column, is compressed
func (rcv *SparseMatrixIndexCSX) CompressedAxis() SparseMatrixCompressedAxis {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -52,12 +67,12 @@ func (rcv *SparseMatrixIndexCSX) CompressedAxis()
SparseMatrixCompressedAxis {
return 0
}
-// / Which axis, row or column, is compressed
+/// Which axis, row or column, is compressed
func (rcv *SparseMatrixIndexCSX) MutateCompressedAxis(n
SparseMatrixCompressedAxis) bool {
return rcv._tab.MutateInt16Slot(4, int16(n))
}
-// / The type of values in indptrBuffer
+/// The type of values in indptrBuffer
func (rcv *SparseMatrixIndexCSX) IndptrType(obj *Int) *Int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
@@ -71,30 +86,30 @@ func (rcv *SparseMatrixIndexCSX) IndptrType(obj *Int) *Int {
return nil
}
-// / The type of values in indptrBuffer
-// / indptrBuffer stores the location and size of indptr array that
-// / represents the range of the rows.
-// / The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
-// / The length of this array is 1 + (the number of rows), and the type
-// / of index value is long.
-// /
-// / For example, let X be the following 6x4 matrix:
-// / ```text
-// / X := [[0, 1, 2, 0],
-// / [0, 0, 3, 0],
-// / [0, 4, 0, 5],
-// / [0, 0, 0, 0],
-// / [6, 0, 7, 8],
-// / [0, 9, 0, 0]].
-// / ```
-// / The array of non-zero values in X is:
-// / ```text
-// / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
-// / ```
-// / And the indptr of X is:
-// / ```text
-// / indptr(X) = [0, 2, 3, 5, 5, 8, 10].
-// / ```
+/// The type of values in indptrBuffer
+/// indptrBuffer stores the location and size of indptr array that
+/// represents the range of the rows.
+/// The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
+/// The length of this array is 1 + (the number of rows), and the type
+/// of index value is long.
+///
+/// For example, let X be the following 6x4 matrix:
+/// ```text
+/// X := [[0, 1, 2, 0],
+/// [0, 0, 3, 0],
+/// [0, 4, 0, 5],
+/// [0, 0, 0, 0],
+/// [6, 0, 7, 8],
+/// [0, 9, 0, 0]].
+/// ```
+/// The array of non-zero values in X is:
+/// ```text
+/// values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
+/// ```
+/// And the indptr of X is:
+/// ```text
+/// indptr(X) = [0, 2, 3, 5, 5, 8, 10].
+/// ```
func (rcv *SparseMatrixIndexCSX) IndptrBuffer(obj *Buffer) *Buffer {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
@@ -108,30 +123,30 @@ func (rcv *SparseMatrixIndexCSX) IndptrBuffer(obj
*Buffer) *Buffer {
return nil
}
-// / indptrBuffer stores the location and size of indptr array that
-// / represents the range of the rows.
-// / The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
-// / The length of this array is 1 + (the number of rows), and the type
-// / of index value is long.
-// /
-// / For example, let X be the following 6x4 matrix:
-// / ```text
-// / X := [[0, 1, 2, 0],
-// / [0, 0, 3, 0],
-// / [0, 4, 0, 5],
-// / [0, 0, 0, 0],
-// / [6, 0, 7, 8],
-// / [0, 9, 0, 0]].
-// / ```
-// / The array of non-zero values in X is:
-// / ```text
-// / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
-// / ```
-// / And the indptr of X is:
-// / ```text
-// / indptr(X) = [0, 2, 3, 5, 5, 8, 10].
-// / ```
-// / The type of values in indicesBuffer
+/// indptrBuffer stores the location and size of indptr array that
+/// represents the range of the rows.
+/// The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
+/// The length of this array is 1 + (the number of rows), and the type
+/// of index value is long.
+///
+/// For example, let X be the following 6x4 matrix:
+/// ```text
+/// X := [[0, 1, 2, 0],
+/// [0, 0, 3, 0],
+/// [0, 4, 0, 5],
+/// [0, 0, 0, 0],
+/// [6, 0, 7, 8],
+/// [0, 9, 0, 0]].
+/// ```
+/// The array of non-zero values in X is:
+/// ```text
+/// values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
+/// ```
+/// And the indptr of X is:
+/// ```text
+/// 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))
if o != 0 {
@@ -145,16 +160,16 @@ func (rcv *SparseMatrixIndexCSX) IndicesType(obj *Int)
*Int {
return nil
}
-// / The type of values in indicesBuffer
-// / indicesBuffer stores the location and size of the array that
-// / contains the column indices of the corresponding non-zero values.
-// / The type of index value is long.
-// /
-// / For example, the indices of the above X is:
-// / ```text
-// / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
-// / ```
-// / Note that the indices are sorted in lexicographical order for each row.
+/// The type of values in indicesBuffer
+/// indicesBuffer stores the location and size of the array that
+/// contains the column indices of the corresponding non-zero values.
+/// The type of index value is long.
+///
+/// For example, the indices of the above X is:
+/// ```text
+/// 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))
if o != 0 {
@@ -168,15 +183,15 @@ func (rcv *SparseMatrixIndexCSX) IndicesBuffer(obj
*Buffer) *Buffer {
return nil
}
-// / indicesBuffer stores the location and size of the array that
-// / contains the column indices of the corresponding non-zero values.
-// / The type of index value is long.
-// /
-// / For example, the indices of the above X is:
-// / ```text
-// / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
-// / ```
-// / Note that the indices are sorted in lexicographical order for each row.
+/// indicesBuffer stores the location and size of the array that
+/// contains the column indices of the corresponding non-zero values.
+/// The type of index value is long.
+///
+/// For example, the indices of the above X is:
+/// ```text
+/// indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
+/// ```
+/// Note that the indices are sorted in lexicographical order for each row.
func SparseMatrixIndexCSXStart(builder *flatbuffers.Builder) {
builder.StartObject(5)
}
diff --git a/arrow/internal/flatbuf/SparseTensor.go
b/arrow/internal/flatbuf/SparseTensor.go
index 8f67e1fc..478a91a8 100644
--- a/arrow/internal/flatbuf/SparseTensor.go
+++ b/arrow/internal/flatbuf/SparseTensor.go
@@ -33,6 +33,21 @@ func GetRootAsSparseTensor(buf []byte, offset
flatbuffers.UOffsetT) *SparseTenso
return x
}
+func FinishSparseTensorBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSparseTensor(buf []byte, offset
flatbuffers.UOffsetT) *SparseTensor {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &SparseTensor{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedSparseTensorBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *SparseTensor) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -54,9 +69,9 @@ func (rcv *SparseTensor) MutateTypeType(n Type) bool {
return rcv._tab.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.
+/// 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))
if o != 0 {
@@ -66,10 +81,10 @@ func (rcv *SparseTensor) Type(obj *flatbuffers.Table) bool {
return false
}
-// / 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.
+/// 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 *SparseTensor) Shape(obj *TensorDim, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
@@ -90,8 +105,8 @@ func (rcv *SparseTensor) ShapeLength() int {
return 0
}
-// / The dimensions of the tensor, optionally named.
-// / The number of non-zero values in a sparse tensor.
+/// 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))
if o != 0 {
@@ -100,7 +115,7 @@ func (rcv *SparseTensor) NonZeroLength() int64 {
return 0
}
-// / The number of non-zero values in a sparse tensor.
+/// The number of non-zero values in a sparse tensor.
func (rcv *SparseTensor) MutateNonZeroLength(n int64) bool {
return rcv._tab.MutateInt64Slot(10, n)
}
@@ -117,7 +132,7 @@ func (rcv *SparseTensor) MutateSparseIndexType(n
SparseTensorIndex) bool {
return rcv._tab.MutateByteSlot(12, byte(n))
}
-// / Sparse tensor index
+/// Sparse tensor index
func (rcv *SparseTensor) SparseIndex(obj *flatbuffers.Table) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
if o != 0 {
@@ -127,8 +142,8 @@ func (rcv *SparseTensor) SparseIndex(obj
*flatbuffers.Table) bool {
return false
}
-// / Sparse tensor index
-// / The location and size of the tensor's data
+/// 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))
if o != 0 {
@@ -142,7 +157,7 @@ func (rcv *SparseTensor) Data(obj *Buffer) *Buffer {
return nil
}
-// / The location and size of the tensor's data
+/// The location and size of the tensor's data
func SparseTensorStart(builder *flatbuffers.Builder) {
builder.StartObject(7)
}
diff --git a/arrow/internal/flatbuf/SparseTensorIndexCOO.go
b/arrow/internal/flatbuf/SparseTensorIndexCOO.go
index bf1c218e..48b5667e 100644
--- a/arrow/internal/flatbuf/SparseTensorIndexCOO.go
+++ b/arrow/internal/flatbuf/SparseTensorIndexCOO.go
@@ -22,38 +22,38 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / EXPERIMENTAL: Data structures for sparse tensors
-// / Coordinate (COO) format of sparse tensor index.
-// /
-// / COO's index list are represented as a NxM matrix,
-// / where N is the number of non-zero values,
-// / and M is the number of dimensions of a sparse tensor.
-// /
-// / indicesBuffer stores the location and size of the data of this indices
-// / matrix. The value type and the stride of the indices matrix is
-// / specified in indicesType and indicesStrides fields.
-// /
-// / For example, let X be a 2x3x4x5 tensor, and it has the following
-// / 6 non-zero values:
-// / ```text
-// / X[0, 1, 2, 0] := 1
-// / X[1, 1, 2, 3] := 2
-// / X[0, 2, 1, 0] := 3
-// / X[0, 1, 3, 0] := 4
-// / X[0, 1, 2, 1] := 5
-// / X[1, 2, 0, 4] := 6
-// / ```
-// / In COO format, the index matrix of X is the following 4x6 matrix:
-// / ```text
-// / [[0, 0, 0, 0, 1, 1],
-// / [1, 1, 1, 2, 1, 2],
-// / [2, 2, 3, 1, 2, 0],
-// / [0, 1, 0, 0, 3, 4]]
-// / ```
-// / When isCanonical is true, the indices is sorted in lexicographical order
-// / (row-major order), and it does not have duplicated entries. Otherwise,
-// / the indices may not be sorted, or may have duplicated entries.
+/// ----------------------------------------------------------------------
+/// EXPERIMENTAL: Data structures for sparse tensors
+/// Coordinate (COO) format of sparse tensor index.
+///
+/// COO's index list are represented as a NxM matrix,
+/// where N is the number of non-zero values,
+/// and M is the number of dimensions of a sparse tensor.
+///
+/// indicesBuffer stores the location and size of the data of this indices
+/// matrix. The value type and the stride of the indices matrix is
+/// specified in indicesType and indicesStrides fields.
+///
+/// For example, let X be a 2x3x4x5 tensor, and it has the following
+/// 6 non-zero values:
+/// ```text
+/// X[0, 1, 2, 0] := 1
+/// X[1, 1, 2, 3] := 2
+/// X[0, 2, 1, 0] := 3
+/// X[0, 1, 3, 0] := 4
+/// X[0, 1, 2, 1] := 5
+/// X[1, 2, 0, 4] := 6
+/// ```
+/// In COO format, the index matrix of X is the following 4x6 matrix:
+/// ```text
+/// [[0, 0, 0, 0, 1, 1],
+/// [1, 1, 1, 2, 1, 2],
+/// [2, 2, 3, 1, 2, 0],
+/// [0, 1, 0, 0, 3, 4]]
+/// ```
+/// When isCanonical is true, the indices is sorted in lexicographical order
+/// (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
}
@@ -65,6 +65,21 @@ func GetRootAsSparseTensorIndexCOO(buf []byte, offset
flatbuffers.UOffsetT) *Spa
return x
}
+func FinishSparseTensorIndexCOOBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSparseTensorIndexCOO(buf []byte, offset
flatbuffers.UOffsetT) *SparseTensorIndexCOO {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &SparseTensorIndexCOO{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedSparseTensorIndexCOOBuffer(builder
*flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *SparseTensorIndexCOO) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -74,7 +89,7 @@ func (rcv *SparseTensorIndexCOO) Table() flatbuffers.Table {
return rcv._tab
}
-// / The type of values in indicesBuffer
+/// The type of values in indicesBuffer
func (rcv *SparseTensorIndexCOO) IndicesType(obj *Int) *Int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -88,9 +103,9 @@ func (rcv *SparseTensorIndexCOO) IndicesType(obj *Int) *Int {
return nil
}
-// / 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).
+/// 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))
if o != 0 {
@@ -108,8 +123,8 @@ func (rcv *SparseTensorIndexCOO) IndicesStridesLength() int
{
return 0
}
-// / Non-negative byte offsets to advance one value cell along each dimension
-// / If omitted, default to row-major order (C-like).
+/// 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))
if o != 0 {
@@ -119,7 +134,7 @@ func (rcv *SparseTensorIndexCOO) MutateIndicesStrides(j
int, n int64) bool {
return false
}
-// / The location and size of the indices matrix's data
+/// The location and size of the indices matrix's data
func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
@@ -133,12 +148,12 @@ func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj
*Buffer) *Buffer {
return nil
}
-// / The location and size of the indices matrix's data
-// / This flag is true if and only if the indices matrix is sorted in
-// / row-major order, and does not have duplicated entries.
-// / This sort order is the same as of Tensorflow's SparseTensor,
-// / but it is inverse order of SciPy's canonical coo_matrix
-// / (SciPy employs column-major order for its coo_matrix).
+/// The location and size of the indices matrix's data
+/// This flag is true if and only if the indices matrix is sorted in
+/// row-major order, and does not have duplicated entries.
+/// This sort order is the same as of Tensorflow's SparseTensor,
+/// 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))
if o != 0 {
@@ -147,11 +162,11 @@ func (rcv *SparseTensorIndexCOO) IsCanonical() bool {
return false
}
-// / This flag is true if and only if the indices matrix is sorted in
-// / row-major order, and does not have duplicated entries.
-// / This sort order is the same as of Tensorflow's SparseTensor,
-// / but it is inverse order of SciPy's canonical coo_matrix
-// / (SciPy employs column-major order for its coo_matrix).
+/// This flag is true if and only if the indices matrix is sorted in
+/// row-major order, and does not have duplicated entries.
+/// This sort order is the same as of Tensorflow's SparseTensor,
+/// 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)
}
diff --git a/arrow/internal/flatbuf/SparseTensorIndexCSF.go
b/arrow/internal/flatbuf/SparseTensorIndexCSF.go
index 66226e04..08d7e486 100644
--- a/arrow/internal/flatbuf/SparseTensorIndexCSF.go
+++ b/arrow/internal/flatbuf/SparseTensorIndexCSF.go
@@ -22,7 +22,7 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Compressed Sparse Fiber (CSF) sparse tensor index.
+/// Compressed Sparse Fiber (CSF) sparse tensor index.
type SparseTensorIndexCSF struct {
_tab flatbuffers.Table
}
@@ -34,6 +34,21 @@ func GetRootAsSparseTensorIndexCSF(buf []byte, offset
flatbuffers.UOffsetT) *Spa
return x
}
+func FinishSparseTensorIndexCSFBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsSparseTensorIndexCSF(buf []byte, offset
flatbuffers.UOffsetT) *SparseTensorIndexCSF {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &SparseTensorIndexCSF{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedSparseTensorIndexCSFBuffer(builder
*flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *SparseTensorIndexCSF) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -43,37 +58,37 @@ func (rcv *SparseTensorIndexCSF) Table() flatbuffers.Table {
return rcv._tab
}
-// / CSF is a generalization of compressed sparse row (CSR) index.
-// / See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
-// /
-// / CSF index recursively compresses each dimension of a tensor into a set
-// / of prefix trees. Each path from a root to leaf forms one tensor
-// / non-zero index. CSF is implemented with two arrays of buffers and one
-// / arrays of integers.
-// /
-// / For example, let X be a 2x3x4x5 tensor and let it have the following
-// / 8 non-zero values:
-// / ```text
-// / X[0, 0, 0, 1] := 1
-// / X[0, 0, 0, 2] := 2
-// / X[0, 1, 0, 0] := 3
-// / X[0, 1, 0, 2] := 4
-// / X[0, 1, 1, 0] := 5
-// / X[1, 1, 1, 0] := 6
-// / X[1, 1, 1, 1] := 7
-// / X[1, 1, 1, 2] := 8
-// / ```
-// / As a prefix tree this would be represented as:
-// / ```text
-// / 0 1
-// / / \ |
-// / 0 1 1
-// / / / \ |
-// / 0 0 1 1
-// / /| /| | /| |
-// / 1 2 0 2 0 0 1 2
-// / ```
-// / The type of values in indptrBuffers
+/// CSF is a generalization of compressed sparse row (CSR) index.
+/// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
+///
+/// CSF index recursively compresses each dimension of a tensor into a set
+/// of prefix trees. Each path from a root to leaf forms one tensor
+/// non-zero index. CSF is implemented with two arrays of buffers and one
+/// arrays of integers.
+///
+/// For example, let X be a 2x3x4x5 tensor and let it have the following
+/// 8 non-zero values:
+/// ```text
+/// X[0, 0, 0, 1] := 1
+/// X[0, 0, 0, 2] := 2
+/// X[0, 1, 0, 0] := 3
+/// X[0, 1, 0, 2] := 4
+/// X[0, 1, 1, 0] := 5
+/// X[1, 1, 1, 0] := 6
+/// X[1, 1, 1, 1] := 7
+/// X[1, 1, 1, 2] := 8
+/// ```
+/// As a prefix tree this would be represented as:
+/// ```text
+/// 0 1
+/// / \ |
+/// 0 1 1
+/// / / \ |
+/// 0 0 1 1
+/// /| /| | /| |
+/// 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))
if o != 0 {
@@ -87,51 +102,51 @@ func (rcv *SparseTensorIndexCSF) IndptrType(obj *Int) *Int
{
return nil
}
-// / CSF is a generalization of compressed sparse row (CSR) index.
-// / See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
-// /
-// / CSF index recursively compresses each dimension of a tensor into a set
-// / of prefix trees. Each path from a root to leaf forms one tensor
-// / non-zero index. CSF is implemented with two arrays of buffers and one
-// / arrays of integers.
-// /
-// / For example, let X be a 2x3x4x5 tensor and let it have the following
-// / 8 non-zero values:
-// / ```text
-// / X[0, 0, 0, 1] := 1
-// / X[0, 0, 0, 2] := 2
-// / X[0, 1, 0, 0] := 3
-// / X[0, 1, 0, 2] := 4
-// / X[0, 1, 1, 0] := 5
-// / X[1, 1, 1, 0] := 6
-// / X[1, 1, 1, 1] := 7
-// / X[1, 1, 1, 2] := 8
-// / ```
-// / As a prefix tree this would be represented as:
-// / ```text
-// / 0 1
-// / / \ |
-// / 0 1 1
-// / / / \ |
-// / 0 0 1 1
-// / /| /| | /| |
-// / 1 2 0 2 0 0 1 2
-// / ```
-// / The type of values in indptrBuffers
-// / indptrBuffers stores the sparsity structure.
-// / Each two consecutive dimensions in a tensor correspond to a buffer in
-// / indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
-// / and `indptrBuffers[dim][i + 1]` signify a range of nodes in
-// / `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]`
node.
-// /
-// / For example, the indptrBuffers for the above X is:
-// / ```text
-// / indptrBuffer(X) = [
-// / [0, 2, 3],
-// / [0, 1, 3, 4],
-// / [0, 2, 4, 5, 8]
-// / ].
-// / ```
+/// CSF is a generalization of compressed sparse row (CSR) index.
+/// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
+///
+/// CSF index recursively compresses each dimension of a tensor into a set
+/// of prefix trees. Each path from a root to leaf forms one tensor
+/// non-zero index. CSF is implemented with two arrays of buffers and one
+/// arrays of integers.
+///
+/// For example, let X be a 2x3x4x5 tensor and let it have the following
+/// 8 non-zero values:
+/// ```text
+/// X[0, 0, 0, 1] := 1
+/// X[0, 0, 0, 2] := 2
+/// X[0, 1, 0, 0] := 3
+/// X[0, 1, 0, 2] := 4
+/// X[0, 1, 1, 0] := 5
+/// X[1, 1, 1, 0] := 6
+/// X[1, 1, 1, 1] := 7
+/// X[1, 1, 1, 2] := 8
+/// ```
+/// As a prefix tree this would be represented as:
+/// ```text
+/// 0 1
+/// / \ |
+/// 0 1 1
+/// / / \ |
+/// 0 0 1 1
+/// /| /| | /| |
+/// 1 2 0 2 0 0 1 2
+/// ```
+/// The type of values in indptrBuffers
+/// indptrBuffers stores the sparsity structure.
+/// Each two consecutive dimensions in a tensor correspond to a buffer in
+/// indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
+/// and `indptrBuffers[dim][i + 1]` signify a range of nodes in
+/// `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]`
node.
+///
+/// For example, the indptrBuffers for the above X is:
+/// ```text
+/// indptrBuffer(X) = [
+/// [0, 2, 3],
+/// [0, 1, 3, 4],
+/// [0, 2, 4, 5, 8]
+/// ].
+/// ```
func (rcv *SparseTensorIndexCSF) IndptrBuffers(obj *Buffer, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
@@ -151,21 +166,21 @@ func (rcv *SparseTensorIndexCSF) IndptrBuffersLength()
int {
return 0
}
-// / indptrBuffers stores the sparsity structure.
-// / Each two consecutive dimensions in a tensor correspond to a buffer in
-// / indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
-// / and `indptrBuffers[dim][i + 1]` signify a range of nodes in
-// / `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]`
node.
-// /
-// / For example, the indptrBuffers for the above X is:
-// / ```text
-// / indptrBuffer(X) = [
-// / [0, 2, 3],
-// / [0, 1, 3, 4],
-// / [0, 2, 4, 5, 8]
-// / ].
-// / ```
-// / The type of values in indicesBuffers
+/// indptrBuffers stores the sparsity structure.
+/// Each two consecutive dimensions in a tensor correspond to a buffer in
+/// indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
+/// and `indptrBuffers[dim][i + 1]` signify a range of nodes in
+/// `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]`
node.
+///
+/// For example, the indptrBuffers for the above X is:
+/// ```text
+/// indptrBuffer(X) = [
+/// [0, 2, 3],
+/// [0, 1, 3, 4],
+/// [0, 2, 4, 5, 8]
+/// ].
+/// ```
+/// The type of values in indicesBuffers
func (rcv *SparseTensorIndexCSF) IndicesType(obj *Int) *Int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
@@ -179,18 +194,18 @@ func (rcv *SparseTensorIndexCSF) IndicesType(obj *Int)
*Int {
return nil
}
-// / The type of values in indicesBuffers
-// / indicesBuffers stores values of nodes.
-// / Each tensor dimension corresponds to a buffer in indicesBuffers.
-// / For example, the indicesBuffers for the above X is:
-// / ```text
-// / indicesBuffer(X) = [
-// / [0, 1],
-// / [0, 1, 1],
-// / [0, 0, 1, 1],
-// / [1, 2, 0, 2, 0, 0, 1, 2]
-// / ].
-// / ```
+/// The type of values in indicesBuffers
+/// indicesBuffers stores values of nodes.
+/// Each tensor dimension corresponds to a buffer in indicesBuffers.
+/// For example, the indicesBuffers for the above X is:
+/// ```text
+/// indicesBuffer(X) = [
+/// [0, 1],
+/// [0, 1, 1],
+/// [0, 0, 1, 1],
+/// [1, 2, 0, 2, 0, 0, 1, 2]
+/// ].
+/// ```
func (rcv *SparseTensorIndexCSF) IndicesBuffers(obj *Buffer, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
@@ -210,23 +225,23 @@ func (rcv *SparseTensorIndexCSF) IndicesBuffersLength()
int {
return 0
}
-// / indicesBuffers stores values of nodes.
-// / Each tensor dimension corresponds to a buffer in indicesBuffers.
-// / For example, the indicesBuffers for the above X is:
-// / ```text
-// / indicesBuffer(X) = [
-// / [0, 1],
-// / [0, 1, 1],
-// / [0, 0, 1, 1],
-// / [1, 2, 0, 2, 0, 0, 1, 2]
-// / ].
-// / ```
-// / axisOrder stores the sequence in which dimensions were traversed to
-// / produce the prefix tree.
-// / For example, the axisOrder for the above X is:
-// / ```text
-// / axisOrder(X) = [0, 1, 2, 3].
-// / ```
+/// indicesBuffers stores values of nodes.
+/// Each tensor dimension corresponds to a buffer in indicesBuffers.
+/// For example, the indicesBuffers for the above X is:
+/// ```text
+/// indicesBuffer(X) = [
+/// [0, 1],
+/// [0, 1, 1],
+/// [0, 0, 1, 1],
+/// [1, 2, 0, 2, 0, 0, 1, 2]
+/// ].
+/// ```
+/// axisOrder stores the sequence in which dimensions were traversed to
+/// produce the prefix tree.
+/// For example, the axisOrder for the above X is:
+/// ```text
+/// axisOrder(X) = [0, 1, 2, 3].
+/// ```
func (rcv *SparseTensorIndexCSF) AxisOrder(j int) int32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
@@ -244,12 +259,12 @@ func (rcv *SparseTensorIndexCSF) AxisOrderLength() int {
return 0
}
-// / axisOrder stores the sequence in which dimensions were traversed to
-// / produce the prefix tree.
-// / For example, the axisOrder for the above X is:
-// / ```text
-// / axisOrder(X) = [0, 1, 2, 3].
-// / ```
+/// axisOrder stores the sequence in which dimensions were traversed to
+/// produce the prefix tree.
+/// For example, the axisOrder for the above X is:
+/// ```text
+/// axisOrder(X) = [0, 1, 2, 3].
+/// ```
func (rcv *SparseTensorIndexCSF) MutateAxisOrder(j int, n int32) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
diff --git a/arrow/internal/flatbuf/Struct_.go
b/arrow/internal/flatbuf/Struct_.go
index 73752a17..64571608 100644
--- a/arrow/internal/flatbuf/Struct_.go
+++ b/arrow/internal/flatbuf/Struct_.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
-// / (according to the physical memory layout). We used Struct_ here as
-// / Struct is a reserved word in Flatbuffers
+/// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
+/// (according to the physical memory layout). We used Struct_ here as
+/// Struct is a reserved word in Flatbuffers
type Struct_ struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsStruct_(buf []byte, offset
flatbuffers.UOffsetT) *Struct_ {
return x
}
+func FinishStruct_Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT)
*Struct_ {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Struct_{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedStruct_Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Struct_) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Tensor.go b/arrow/internal/flatbuf/Tensor.go
index 47bfe806..ff3bbaa4 100644
--- a/arrow/internal/flatbuf/Tensor.go
+++ b/arrow/internal/flatbuf/Tensor.go
@@ -33,6 +33,21 @@ func GetRootAsTensor(buf []byte, offset
flatbuffers.UOffsetT) *Tensor {
return x
}
+func FinishTensorBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTensor(buf []byte, offset flatbuffers.UOffsetT)
*Tensor {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Tensor{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedTensorBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Tensor) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -54,8 +69,8 @@ func (rcv *Tensor) MutateTypeType(n Type) bool {
return rcv._tab.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
+/// 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))
if o != 0 {
@@ -65,9 +80,9 @@ func (rcv *Tensor) Type(obj *flatbuffers.Table) bool {
return false
}
-// / 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
+/// 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))
if o != 0 {
@@ -88,9 +103,9 @@ func (rcv *Tensor) ShapeLength() int {
return 0
}
-// / The dimensions of the tensor, optionally named
-// / Non-negative byte offsets to advance one value cell along each dimension
-// / If omitted, default to row-major order (C-like).
+/// The dimensions of the tensor, optionally named
+/// 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))
if o != 0 {
@@ -108,8 +123,8 @@ func (rcv *Tensor) StridesLength() int {
return 0
}
-// / Non-negative byte offsets to advance one value cell along each dimension
-// / If omitted, default to row-major order (C-like).
+/// 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))
if o != 0 {
@@ -119,7 +134,7 @@ func (rcv *Tensor) MutateStrides(j int, n int64) bool {
return false
}
-// / The location and size of the tensor's data
+/// The location and size of the tensor's data
func (rcv *Tensor) Data(obj *Buffer) *Buffer {
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
@@ -133,7 +148,7 @@ func (rcv *Tensor) Data(obj *Buffer) *Buffer {
return nil
}
-// / The location and size of the tensor's data
+/// The location and size of the tensor's data
func TensorStart(builder *flatbuffers.Builder) {
builder.StartObject(5)
}
diff --git a/arrow/internal/flatbuf/TensorDim.go
b/arrow/internal/flatbuf/TensorDim.go
index c6413b6a..55f2389f 100644
--- a/arrow/internal/flatbuf/TensorDim.go
+++ b/arrow/internal/flatbuf/TensorDim.go
@@ -22,9 +22,9 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / ----------------------------------------------------------------------
-// / Data structures for dense tensors
-// / Shape data for a single axis in a tensor
+/// ----------------------------------------------------------------------
+/// Data structures for dense tensors
+/// Shape data for a single axis in a tensor
type TensorDim struct {
_tab flatbuffers.Table
}
@@ -36,6 +36,21 @@ func GetRootAsTensorDim(buf []byte, offset
flatbuffers.UOffsetT) *TensorDim {
return x
}
+func FinishTensorDimBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT)
*TensorDim {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &TensorDim{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedTensorDimBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *TensorDim) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -45,7 +60,7 @@ func (rcv *TensorDim) Table() flatbuffers.Table {
return rcv._tab
}
-// / Length of dimension
+/// Length of dimension
func (rcv *TensorDim) Size() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
@@ -54,12 +69,12 @@ func (rcv *TensorDim) Size() int64 {
return 0
}
-// / Length of dimension
+/// Length of dimension
func (rcv *TensorDim) MutateSize(n int64) bool {
return rcv._tab.MutateInt64Slot(4, n)
}
-// / Name of the dimension, optional
+/// Name of the dimension, optional
func (rcv *TensorDim) Name() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
@@ -68,7 +83,7 @@ func (rcv *TensorDim) Name() []byte {
return nil
}
-// / Name of the dimension, optional
+/// Name of the dimension, optional
func TensorDimStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
diff --git a/arrow/internal/flatbuf/Time.go b/arrow/internal/flatbuf/Time.go
index 13038a6e..89b8ee73 100644
--- a/arrow/internal/flatbuf/Time.go
+++ b/arrow/internal/flatbuf/Time.go
@@ -22,20 +22,20 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Time is either a 32-bit or 64-bit signed integer type representing an
-// / elapsed time since midnight, stored in either of four units: seconds,
-// / milliseconds, microseconds or nanoseconds.
-// /
-// / The integer `bitWidth` depends on the `unit` and must be one of the
following:
-// / * SECOND and MILLISECOND: 32 bits
-// / * MICROSECOND and NANOSECOND: 64 bits
-// /
-// / The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
-// / (exclusive), adjusted for the time unit (for example, up to 86400000
-// / exclusive for the MILLISECOND unit).
-// / This definition doesn't allow for leap seconds. Time values from
-// / measurements with leap seconds will need to be corrected when ingesting
-// / into Arrow (for example by replacing the value 86400 with 86399).
+/// Time is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since midnight, stored in either of four units: seconds,
+/// milliseconds, microseconds or nanoseconds.
+///
+/// The integer `bitWidth` depends on the `unit` and must be one of the
following:
+/// * SECOND and MILLISECOND: 32 bits
+/// * MICROSECOND and NANOSECOND: 64 bits
+///
+/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
+/// (exclusive), adjusted for the time unit (for example, up to 86400000
+/// exclusive for the MILLISECOND unit).
+/// This definition doesn't allow for leap seconds. Time values from
+/// 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
}
@@ -47,6 +47,21 @@ func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT)
*Time {
return x
}
+func FinishTimeBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Time{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedTimeBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Time) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Timestamp.go
b/arrow/internal/flatbuf/Timestamp.go
index ce172bac..b580c031 100644
--- a/arrow/internal/flatbuf/Timestamp.go
+++ b/arrow/internal/flatbuf/Timestamp.go
@@ -22,111 +22,111 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Timestamp is a 64-bit signed integer representing an elapsed time since a
-// / fixed epoch, stored in either of four units: seconds, milliseconds,
-// / microseconds or nanoseconds, and is optionally annotated with a timezone.
-// /
-// / Timestamp values do not include any leap seconds (in other words, all
-// / days are considered 86400 seconds long).
-// /
-// / Timestamps with a non-empty timezone
-// / ------------------------------------
-// /
-// / If a Timestamp column has a non-empty timezone value, its epoch is
-// / 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
-// / (the Unix epoch), regardless of the Timestamp's own timezone.
-// /
-// / Therefore, timestamp values with a non-empty timezone correspond to
-// / physical points in time together with some additional information about
-// / how the data was obtained and/or how to display it (the timezone).
-// /
-// / For example, the timestamp value 0 with the timezone string
"Europe/Paris"
-// / corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
-// / application may prefer to display it as "January 1st 1970, 01h00" in
-// / the Europe/Paris timezone (which is the same physical point in time).
-// /
-// / One consequence is that timestamp values with a non-empty timezone
-// / can be compared and ordered directly, since they all share the same
-// / well-known point of reference (the Unix epoch).
-// /
-// / Timestamps with an unset / empty timezone
-// / -----------------------------------------
-// /
-// / If a Timestamp column has no timezone value, its epoch is
-// / 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
-// /
-// / Therefore, timestamp values without a timezone cannot be meaningfully
-// / interpreted as physical points in time, but only as calendar / clock
-// / indications ("wall clock time") in an unspecified timezone.
-// /
-// / For example, the timestamp value 0 with an empty timezone string
-// / corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
-// / is not enough information to interpret it as a well-defined physical
-// / point in time.
-// /
-// / One consequence is that timestamp values without a timezone cannot
-// / be reliably compared or ordered, since they may have different points of
-// / reference. In particular, it is *not* possible to interpret an unset
-// / or empty timezone as the same as "UTC".
-// /
-// / Conversion between timezones
-// / ----------------------------
-// /
-// / If a Timestamp column has a non-empty timezone, changing the timezone
-// / to a different non-empty value is a metadata-only operation:
-// / the timestamp values need not change as their point of reference remains
-// / the same (the Unix epoch).
-// /
-// / However, if a Timestamp column has no timezone value, changing it to a
-// / non-empty value requires to think about the desired semantics.
-// / One possibility is to assume that the original timestamp values are
-// / relative to the epoch of the timezone being set; timestamp values should
-// / then adjusted to the Unix epoch (for example, changing the timezone from
-// / empty to "Europe/Paris" would require converting the timestamp values
-// / from "Europe/Paris" to "UTC", which seems counter-intuitive but is
-// / nevertheless correct).
-// /
-// / Guidelines for encoding data from external libraries
-// / ----------------------------------------------------
-// /
-// / Date & time libraries often have multiple different data types for
temporal
-// / data. In order to ease interoperability between different implementations
the
-// / Arrow project has some recommendations for encoding these types into a
Timestamp
-// / column.
-// /
-// / An "instant" represents a physical point in time that has no relevant
timezone
-// / (for example, astronomical data). To encode an instant, use a Timestamp
with
-// / the timezone string set to "UTC", and make sure the Timestamp values
-// / are relative to the UTC epoch (January 1st 1970, midnight).
-// /
-// / A "zoned date-time" represents a physical point in time annotated with an
-// / informative timezone (for example, the timezone in which the data was
-// / recorded). To encode a zoned date-time, use a Timestamp with the timezone
-// / string set to the name of the timezone, and make sure the Timestamp values
-// / are relative to the UTC epoch (January 1st 1970, midnight).
-// /
-// / (There is some ambiguity between an instant and a zoned date-time with
the
-// / UTC timezone. Both of these are stored the same in Arrow. Typically,
-// / this distinction does not matter. If it does, then an application
should
-// / use custom metadata or an extension type to distinguish between the two
cases.)
-// /
-// / An "offset date-time" represents a physical point in time combined with an
-// / explicit offset from UTC. To encode an offset date-time, use a Timestamp
-// / with the timezone string set to the numeric timezone offset string
-// / (e.g. "+03:00"), and make sure the Timestamp values are relative to
-// / the UTC epoch (January 1st 1970, midnight).
-// /
-// / A "naive date-time" (also called "local date-time" in some libraries)
-// / represents a wall clock time combined with a calendar date, but with
-// / no indication of how to map this information to a physical point in time.
-// / Naive date-times must be handled with care because of this missing
-// / information, and also because daylight saving time (DST) may make
-// / some values ambiguous or nonexistent. A naive date-time may be
-// / stored as a struct with Date and Time fields. However, it may also be
-// / encoded into a Timestamp column with an empty timezone. The timestamp
-// / values should be computed "as if" the timezone of the date-time values
-// / was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
-// / be encoded as timestamp value 0.
+/// Timestamp is a 64-bit signed integer representing an elapsed time since a
+/// fixed epoch, stored in either of four units: seconds, milliseconds,
+/// microseconds or nanoseconds, and is optionally annotated with a timezone.
+///
+/// Timestamp values do not include any leap seconds (in other words, all
+/// days are considered 86400 seconds long).
+///
+/// Timestamps with a non-empty timezone
+/// ------------------------------------
+///
+/// If a Timestamp column has a non-empty timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+/// (the Unix epoch), regardless of the Timestamp's own timezone.
+///
+/// Therefore, timestamp values with a non-empty timezone correspond to
+/// physical points in time together with some additional information about
+/// how the data was obtained and/or how to display it (the timezone).
+///
+/// For example, the timestamp value 0 with the timezone string
"Europe/Paris"
+/// corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+/// application may prefer to display it as "January 1st 1970, 01h00" in
+/// the Europe/Paris timezone (which is the same physical point in time).
+///
+/// One consequence is that timestamp values with a non-empty timezone
+/// can be compared and ordered directly, since they all share the same
+/// well-known point of reference (the Unix epoch).
+///
+/// Timestamps with an unset / empty timezone
+/// -----------------------------------------
+///
+/// If a Timestamp column has no timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+///
+/// Therefore, timestamp values without a timezone cannot be meaningfully
+/// interpreted as physical points in time, but only as calendar / clock
+/// indications ("wall clock time") in an unspecified timezone.
+///
+/// For example, the timestamp value 0 with an empty timezone string
+/// corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+/// is not enough information to interpret it as a well-defined physical
+/// point in time.
+///
+/// One consequence is that timestamp values without a timezone cannot
+/// be reliably compared or ordered, since they may have different points of
+/// reference. In particular, it is *not* possible to interpret an unset
+/// or empty timezone as the same as "UTC".
+///
+/// Conversion between timezones
+/// ----------------------------
+///
+/// If a Timestamp column has a non-empty timezone, changing the timezone
+/// to a different non-empty value is a metadata-only operation:
+/// the timestamp values need not change as their point of reference remains
+/// the same (the Unix epoch).
+///
+/// However, if a Timestamp column has no timezone value, changing it to a
+/// non-empty value requires to think about the desired semantics.
+/// One possibility is to assume that the original timestamp values are
+/// relative to the epoch of the timezone being set; timestamp values should
+/// then adjusted to the Unix epoch (for example, changing the timezone from
+/// empty to "Europe/Paris" would require converting the timestamp values
+/// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+/// nevertheless correct).
+///
+/// Guidelines for encoding data from external libraries
+/// ----------------------------------------------------
+///
+/// Date & time libraries often have multiple different data types for temporal
+/// data. In order to ease interoperability between different implementations
the
+/// Arrow project has some recommendations for encoding these types into a
Timestamp
+/// column.
+///
+/// An "instant" represents a physical point in time that has no relevant
timezone
+/// (for example, astronomical data). To encode an instant, use a Timestamp
with
+/// the timezone string set to "UTC", and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// A "zoned date-time" represents a physical point in time annotated with an
+/// informative timezone (for example, the timezone in which the data was
+/// recorded). To encode a zoned date-time, use a Timestamp with the timezone
+/// string set to the name of the timezone, and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// (There is some ambiguity between an instant and a zoned date-time with the
+/// UTC timezone. Both of these are stored the same in Arrow. Typically,
+/// this distinction does not matter. If it does, then an application should
+/// use custom metadata or an extension type to distinguish between the two
cases.)
+///
+/// An "offset date-time" represents a physical point in time combined with an
+/// explicit offset from UTC. To encode an offset date-time, use a Timestamp
+/// with the timezone string set to the numeric timezone offset string
+/// (e.g. "+03:00"), and make sure the Timestamp values are relative to
+/// the UTC epoch (January 1st 1970, midnight).
+///
+/// A "naive date-time" (also called "local date-time" in some libraries)
+/// represents a wall clock time combined with a calendar date, but with
+/// no indication of how to map this information to a physical point in time.
+/// Naive date-times must be handled with care because of this missing
+/// information, and also because daylight saving time (DST) may make
+/// some values ambiguous or nonexistent. A naive date-time may be
+/// stored as a struct with Date and Time fields. However, it may also be
+/// encoded into a Timestamp column with an empty timezone. The timestamp
+/// values should be computed "as if" the timezone of the date-time values
+/// 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
}
@@ -138,6 +138,21 @@ func GetRootAsTimestamp(buf []byte, offset
flatbuffers.UOffsetT) *Timestamp {
return x
}
+func FinishTimestampBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT)
*Timestamp {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Timestamp{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedTimestampBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Timestamp) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -159,16 +174,16 @@ func (rcv *Timestamp) MutateUnit(n TimeUnit) bool {
return rcv._tab.MutateInt16Slot(4, int16(n))
}
-// / The timezone is an optional string indicating the name of a timezone,
-// / one of:
-// /
-// / * As used in the Olson timezone database (the "tz database" or
-// / "tzdata"), such as "America/New_York".
-// / * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
-// / such as "+07:30".
-// /
-// / Whether a timezone string is present indicates different semantics about
-// / the data (see above).
+/// The timezone is an optional string indicating the name of a timezone,
+/// one of:
+///
+/// * As used in the Olson timezone database (the "tz database" or
+/// "tzdata"), such as "America/New_York".
+/// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+/// such as "+07:30".
+///
+/// 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))
if o != 0 {
@@ -177,16 +192,16 @@ func (rcv *Timestamp) Timezone() []byte {
return nil
}
-// / The timezone is an optional string indicating the name of a timezone,
-// / one of:
-// /
-// / * As used in the Olson timezone database (the "tz database" or
-// / "tzdata"), such as "America/New_York".
-// / * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
-// / such as "+07:30".
-// /
-// / Whether a timezone string is present indicates different semantics about
-// / the data (see above).
+/// The timezone is an optional string indicating the name of a timezone,
+/// one of:
+///
+/// * As used in the Olson timezone database (the "tz database" or
+/// "tzdata"), such as "America/New_York".
+/// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+/// such as "+07:30".
+///
+/// Whether a timezone string is present indicates different semantics about
+/// the data (see above).
func TimestampStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
diff --git a/arrow/internal/flatbuf/Type.go b/arrow/internal/flatbuf/Type.go
index df8ba865..ab2bce9c 100644
--- a/arrow/internal/flatbuf/Type.go
+++ b/arrow/internal/flatbuf/Type.go
@@ -20,9 +20,9 @@ package flatbuf
import "strconv"
-// / ----------------------------------------------------------------------
-// / Top-level Type value, enabling extensible type-specific metadata. We can
-// / add new logical types to Type without breaking backwards compatibility
+/// ----------------------------------------------------------------------
+/// Top-level Type value, enabling extensible type-specific metadata. We can
+/// add new logical types to Type without breaking backwards compatibility
type Type byte
const (
diff --git a/arrow/internal/flatbuf/Union.go b/arrow/internal/flatbuf/Union.go
index 0367fb3c..90a68171 100644
--- a/arrow/internal/flatbuf/Union.go
+++ b/arrow/internal/flatbuf/Union.go
@@ -22,10 +22,10 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / A union is a complex type with children in Field
-// / By default ids in the type vector refer to the offsets in the children
-// / 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
+/// A union is a complex type with children in Field
+/// By default ids in the type vector refer to the offsets in the children
+/// 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
}
@@ -37,6 +37,21 @@ func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT)
*Union {
return x
}
+func FinishUnionBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUnion(buf []byte, offset flatbuffers.UOffsetT)
*Union {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Union{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedUnionBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Union) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Utf8.go b/arrow/internal/flatbuf/Utf8.go
index cab4ce77..63a0b42c 100644
--- a/arrow/internal/flatbuf/Utf8.go
+++ b/arrow/internal/flatbuf/Utf8.go
@@ -22,7 +22,7 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Unicode with UTF-8 encoding
+/// Unicode with UTF-8 encoding
type Utf8 struct {
_tab flatbuffers.Table
}
@@ -34,6 +34,21 @@ func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT)
*Utf8 {
return x
}
+func FinishUtf8Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8 {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Utf8{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedUtf8Buffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Utf8) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/arrow/internal/flatbuf/Utf8View.go
b/arrow/internal/flatbuf/Utf8View.go
index f294126a..78a76f2b 100644
--- a/arrow/internal/flatbuf/Utf8View.go
+++ b/arrow/internal/flatbuf/Utf8View.go
@@ -22,13 +22,13 @@ import (
flatbuffers "github.com/google/flatbuffers/go"
)
-// / Logically the same as Utf8, but the internal representation uses a view
-// / struct that contains the string length and either the string's entire data
-// / inline (for small strings) or an inlined prefix, an index of another
buffer,
-// / and an offset pointing to a slice in that buffer (for non-small strings).
-// /
-// / Since it uses a variable number of data buffers, each Field with this type
-// / must have a corresponding entry in `variadicBufferCounts`.
+/// Logically the same as Utf8, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another
buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// 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
}
@@ -40,6 +40,21 @@ func GetRootAsUtf8View(buf []byte, offset
flatbuffers.UOffsetT) *Utf8View {
return x
}
+func FinishUtf8ViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT)
*Utf8View {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Utf8View{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func FinishSizePrefixedUtf8ViewBuffer(builder *flatbuffers.Builder, offset
flatbuffers.UOffsetT) {
+ builder.FinishSizePrefixed(offset)
+}
+
func (rcv *Utf8View) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
