package flatbuf

import "git.sr.ht/~sbinet/go-arrow/internal/flatbuf"

Index

Variables 

var EnumNamesDateUnit = map[DateUnit]string{
	DateUnitDAY:         "DAY",
	DateUnitMILLISECOND: "MILLISECOND",
}
var EnumNamesEndianness = map[Endianness]string{
	EndiannessLittle: "Little",
	EndiannessBig:    "Big",
}
var EnumNamesIntervalUnit = map[IntervalUnit]string{
	IntervalUnitYEAR_MONTH: "YEAR_MONTH",
	IntervalUnitDAY_TIME:   "DAY_TIME",
}
var EnumNamesMessageHeader = map[MessageHeader]string{
	MessageHeaderNONE:            "NONE",
	MessageHeaderSchema:          "Schema",
	MessageHeaderDictionaryBatch: "DictionaryBatch",
	MessageHeaderRecordBatch:     "RecordBatch",
	MessageHeaderTensor:          "Tensor",
	MessageHeaderSparseTensor:    "SparseTensor",
}
var EnumNamesMetadataVersion = map[MetadataVersion]string{
	MetadataVersionV1: "V1",
	MetadataVersionV2: "V2",
	MetadataVersionV3: "V3",
	MetadataVersionV4: "V4",
}
var EnumNamesPrecision = map[Precision]string{
	PrecisionHALF:   "HALF",
	PrecisionSINGLE: "SINGLE",
	PrecisionDOUBLE: "DOUBLE",
}
var EnumNamesSparseTensorIndex = map[SparseTensorIndex]string{
	SparseTensorIndexNONE:                 "NONE",
	SparseTensorIndexSparseTensorIndexCOO: "SparseTensorIndexCOO",
	SparseTensorIndexSparseMatrixIndexCSR: "SparseMatrixIndexCSR",
}
var EnumNamesTimeUnit = map[TimeUnit]string{
	TimeUnitSECOND:      "SECOND",
	TimeUnitMILLISECOND: "MILLISECOND",
	TimeUnitMICROSECOND: "MICROSECOND",
	TimeUnitNANOSECOND:  "NANOSECOND",
}
var EnumNamesType = map[Type]string{
	TypeNONE:            "NONE",
	TypeNull:            "Null",
	TypeInt:             "Int",
	TypeFloatingPoint:   "FloatingPoint",
	TypeBinary:          "Binary",
	TypeUtf8:            "Utf8",
	TypeBool:            "Bool",
	TypeDecimal:         "Decimal",
	TypeDate:            "Date",
	TypeTime:            "Time",
	TypeTimestamp:       "Timestamp",
	TypeInterval:        "Interval",
	TypeList:            "List",
	TypeStruct_:         "Struct_",
	TypeUnion:           "Union",
	TypeFixedSizeBinary: "FixedSizeBinary",
	TypeFixedSizeList:   "FixedSizeList",
	TypeMap:             "Map",
	TypeDuration:        "Duration",
	TypeLargeBinary:     "LargeBinary",
	TypeLargeUtf8:       "LargeUtf8",
	TypeLargeList:       "LargeList",
}
var EnumNamesUnionMode = map[UnionMode]string{
	UnionModeSparse: "Sparse",
	UnionModeDense:  "Dense",
}

Functions

func BinaryEnd 

func BinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BinaryStart 

func BinaryStart(builder *flatbuffers.Builder)

func BoolEnd 

func BoolEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BoolStart 

func BoolStart(builder *flatbuffers.Builder)

func CreateBlock 

func CreateBlock(builder *flatbuffers.Builder, offset int64, metaDataLength int32, bodyLength int64) flatbuffers.UOffsetT

func CreateBuffer 

func CreateBuffer(builder *flatbuffers.Builder, offset int64, length int64) flatbuffers.UOffsetT

func CreateFieldNode 

func CreateFieldNode(builder *flatbuffers.Builder, length int64, nullCount int64) flatbuffers.UOffsetT

func DateAddUnit 

func DateAddUnit(builder *flatbuffers.Builder, unit int16)

func DateEnd 

func DateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DateStart 

func DateStart(builder *flatbuffers.Builder)

func DecimalAddPrecision 

func DecimalAddPrecision(builder *flatbuffers.Builder, precision int32)

func DecimalAddScale 

func DecimalAddScale(builder *flatbuffers.Builder, scale int32)

func DecimalEnd 

func DecimalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DecimalStart 

func DecimalStart(builder *flatbuffers.Builder)

func DictionaryBatchAddData 

func DictionaryBatchAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func DictionaryBatchAddId 

func DictionaryBatchAddId(builder *flatbuffers.Builder, id int64)

func DictionaryBatchAddIsDelta 

func DictionaryBatchAddIsDelta(builder *flatbuffers.Builder, isDelta bool)

func DictionaryBatchEnd 

func DictionaryBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DictionaryBatchStart 

func DictionaryBatchStart(builder *flatbuffers.Builder)

func DictionaryEncodingAddId 

func DictionaryEncodingAddId(builder *flatbuffers.Builder, id int64)

func DictionaryEncodingAddIndexType 

func DictionaryEncodingAddIndexType(builder *flatbuffers.Builder, indexType flatbuffers.UOffsetT)

func DictionaryEncodingAddIsOrdered 

func DictionaryEncodingAddIsOrdered(builder *flatbuffers.Builder, isOrdered bool)

func DictionaryEncodingEnd 

func DictionaryEncodingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DictionaryEncodingStart 

func DictionaryEncodingStart(builder *flatbuffers.Builder)

func DurationAddUnit 

func DurationAddUnit(builder *flatbuffers.Builder, unit int16)

func DurationEnd 

func DurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DurationStart 

func DurationStart(builder *flatbuffers.Builder)

func FieldAddChildren 

func FieldAddChildren(builder *flatbuffers.Builder, children flatbuffers.UOffsetT)

func FieldAddCustomMetadata 

func FieldAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func FieldAddDictionary 

func FieldAddDictionary(builder *flatbuffers.Builder, dictionary flatbuffers.UOffsetT)

func FieldAddName 

func FieldAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func FieldAddNullable 

func FieldAddNullable(builder *flatbuffers.Builder, nullable bool)

func FieldAddType 

func FieldAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func FieldAddTypeType 

func FieldAddTypeType(builder *flatbuffers.Builder, typeType byte)

func FieldEnd 

func FieldEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FieldStart 

func FieldStart(builder *flatbuffers.Builder)

/ User-defined metadata

func FieldStartChildrenVector 

func FieldStartChildrenVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FieldStartCustomMetadataVector 

func FieldStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FixedSizeBinaryAddByteWidth 

func FixedSizeBinaryAddByteWidth(builder *flatbuffers.Builder, byteWidth int32)

func FixedSizeBinaryEnd 

func FixedSizeBinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FixedSizeBinaryStart 

func FixedSizeBinaryStart(builder *flatbuffers.Builder)

func FixedSizeListAddListSize 

func FixedSizeListAddListSize(builder *flatbuffers.Builder, listSize int32)

func FixedSizeListEnd 

func FixedSizeListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FixedSizeListStart 

func FixedSizeListStart(builder *flatbuffers.Builder)

func FloatingPointAddPrecision 

func FloatingPointAddPrecision(builder *flatbuffers.Builder, precision int16)

func FloatingPointEnd 

func FloatingPointEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FloatingPointStart 

func FloatingPointStart(builder *flatbuffers.Builder)

func FooterAddDictionaries 

func FooterAddDictionaries(builder *flatbuffers.Builder, dictionaries flatbuffers.UOffsetT)

func FooterAddRecordBatches 

func FooterAddRecordBatches(builder *flatbuffers.Builder, recordBatches flatbuffers.UOffsetT)

func FooterAddSchema 

func FooterAddSchema(builder *flatbuffers.Builder, schema flatbuffers.UOffsetT)

func FooterAddVersion 

func FooterAddVersion(builder *flatbuffers.Builder, version int16)

func FooterEnd 

func FooterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FooterStart 

func FooterStart(builder *flatbuffers.Builder)

func FooterStartDictionariesVector 

func FooterStartDictionariesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FooterStartRecordBatchesVector 

func FooterStartRecordBatchesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func IntAddBitWidth 

func IntAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)

func IntAddIsSigned 

func IntAddIsSigned(builder *flatbuffers.Builder, isSigned bool)

func IntEnd 

func IntEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IntStart 

func IntStart(builder *flatbuffers.Builder)

func IntervalAddUnit 

func IntervalAddUnit(builder *flatbuffers.Builder, unit int16)

func IntervalEnd 

func IntervalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IntervalStart 

func IntervalStart(builder *flatbuffers.Builder)

func KeyValueAddKey 

func KeyValueAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT)

func KeyValueAddValue 

func KeyValueAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func KeyValueEnd 

func KeyValueEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func KeyValueStart 

func KeyValueStart(builder *flatbuffers.Builder)

func ListEnd 

func ListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ListStart 

func ListStart(builder *flatbuffers.Builder)

func MapAddKeysSorted 

func MapAddKeysSorted(builder *flatbuffers.Builder, keysSorted bool)

func MapEnd 

func MapEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MapStart 

func MapStart(builder *flatbuffers.Builder)

func MessageAddBodyLength 

func MessageAddBodyLength(builder *flatbuffers.Builder, bodyLength int64)

func MessageAddCustomMetadata 

func MessageAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func MessageAddHeader 

func MessageAddHeader(builder *flatbuffers.Builder, header flatbuffers.UOffsetT)

func MessageAddHeaderType 

func MessageAddHeaderType(builder *flatbuffers.Builder, headerType byte)

func MessageAddVersion 

func MessageAddVersion(builder *flatbuffers.Builder, version int16)

func MessageEnd 

func MessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MessageStart 

func MessageStart(builder *flatbuffers.Builder)

func MessageStartCustomMetadataVector 

func MessageStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func NullEnd 

func NullEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func NullStart 

func NullStart(builder *flatbuffers.Builder)

func RecordBatchAddBuffers 

func RecordBatchAddBuffers(builder *flatbuffers.Builder, buffers flatbuffers.UOffsetT)

func RecordBatchAddLength 

func RecordBatchAddLength(builder *flatbuffers.Builder, length int64)

func RecordBatchAddNodes 

func RecordBatchAddNodes(builder *flatbuffers.Builder, nodes flatbuffers.UOffsetT)

func RecordBatchEnd 

func RecordBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func RecordBatchStart 

func RecordBatchStart(builder *flatbuffers.Builder)

/ 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 RecordBatchStartBuffersVector 

func RecordBatchStartBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func RecordBatchStartNodesVector 

func RecordBatchStartNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SchemaAddCustomMetadata 

func SchemaAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func SchemaAddEndianness 

func SchemaAddEndianness(builder *flatbuffers.Builder, endianness int16)

func SchemaAddFields 

func SchemaAddFields(builder *flatbuffers.Builder, fields flatbuffers.UOffsetT)

func SchemaEnd 

func SchemaEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SchemaStart 

func SchemaStart(builder *flatbuffers.Builder)

func SchemaStartCustomMetadataVector 

func SchemaStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SchemaStartFieldsVector 

func SchemaStartFieldsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseMatrixIndexCSRAddIndicesBuffer 

func SparseMatrixIndexCSRAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndicesType 

func SparseMatrixIndexCSRAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndptrBuffer 

func SparseMatrixIndexCSRAddIndptrBuffer(builder *flatbuffers.Builder, indptrBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndptrType 

func SparseMatrixIndexCSRAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)

func SparseMatrixIndexCSREnd 

func SparseMatrixIndexCSREnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseMatrixIndexCSRStart 

func SparseMatrixIndexCSRStart(builder *flatbuffers.Builder)

/ 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: / / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / / Note that the indices are sorted in lexicographical order for each row.

func SparseTensorAddData 

func SparseTensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func SparseTensorAddNonZeroLength 

func SparseTensorAddNonZeroLength(builder *flatbuffers.Builder, nonZeroLength int64)

func SparseTensorAddShape 

func SparseTensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)

func SparseTensorAddSparseIndex 

func SparseTensorAddSparseIndex(builder *flatbuffers.Builder, sparseIndex flatbuffers.UOffsetT)

func SparseTensorAddSparseIndexType 

func SparseTensorAddSparseIndexType(builder *flatbuffers.Builder, sparseIndexType byte)

func SparseTensorAddType 

func SparseTensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func SparseTensorAddTypeType 

func SparseTensorAddTypeType(builder *flatbuffers.Builder, typeType byte)

func SparseTensorEnd 

func SparseTensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseTensorIndexCOOAddIndicesBuffer 

func SparseTensorIndexCOOAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)

func SparseTensorIndexCOOAddIndicesStrides 

func SparseTensorIndexCOOAddIndicesStrides(builder *flatbuffers.Builder, indicesStrides flatbuffers.UOffsetT)

func SparseTensorIndexCOOAddIndicesType 

func SparseTensorIndexCOOAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseTensorIndexCOOEnd 

func SparseTensorIndexCOOEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseTensorIndexCOOStart 

func SparseTensorIndexCOOStart(builder *flatbuffers.Builder)

/ The location and size of the indices matrix's data

func SparseTensorIndexCOOStartIndicesStridesVector 

func SparseTensorIndexCOOStartIndicesStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseTensorStart 

func SparseTensorStart(builder *flatbuffers.Builder)

/ The location and size of the tensor's data

func SparseTensorStartShapeVector 

func SparseTensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func Struct_End 

func Struct_End(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func Struct_Start 

func Struct_Start(builder *flatbuffers.Builder)

func TensorAddData 

func TensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func TensorAddShape 

func TensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)

func TensorAddStrides 

func TensorAddStrides(builder *flatbuffers.Builder, strides flatbuffers.UOffsetT)

func TensorAddType 

func TensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func TensorAddTypeType 

func TensorAddTypeType(builder *flatbuffers.Builder, typeType byte)

func TensorDimAddName 

func TensorDimAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func TensorDimAddSize 

func TensorDimAddSize(builder *flatbuffers.Builder, size int64)

func TensorDimEnd 

func TensorDimEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TensorDimStart 

func TensorDimStart(builder *flatbuffers.Builder)

/ Name of the dimension, optional

func TensorEnd 

func TensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TensorStart 

func TensorStart(builder *flatbuffers.Builder)

/ The location and size of the tensor's data

func TensorStartShapeVector 

func TensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func TensorStartStridesVector 

func TensorStartStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func TimeAddBitWidth 

func TimeAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)

func TimeAddUnit 

func TimeAddUnit(builder *flatbuffers.Builder, unit int16)

func TimeEnd 

func TimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TimeStart 

func TimeStart(builder *flatbuffers.Builder)

func TimestampAddTimezone 

func TimestampAddTimezone(builder *flatbuffers.Builder, timezone flatbuffers.UOffsetT)

func TimestampAddUnit 

func TimestampAddUnit(builder *flatbuffers.Builder, unit int16)

func TimestampEnd 

func TimestampEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TimestampStart 

func TimestampStart(builder *flatbuffers.Builder)

/ The time zone is a string indicating the name of a time zone, one of: / / * As used in the Olson time zone database (the "tz database" or / "tzdata"), such as "America/New_York" / * An absolute time zone 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: / / * If the time zone is null or equal to an empty string, the data is "time / zone naive" and shall be displayed *as is* to the user, not localized / to the locale of the user. This data can be though of as UTC but / without having "UTC" as the time zone, it is not considered to be / localized to any time zone / / * If the time zone is set to a valid value, values can be displayed as / "localized" to that time zone, even though the underlying 64-bit / integers are identical to the same data stored in UTC. Converting / between time zones is a metadata-only operation and does not change the / underlying values

func UnionAddMode 

func UnionAddMode(builder *flatbuffers.Builder, mode int16)

func UnionAddTypeIds 

func UnionAddTypeIds(builder *flatbuffers.Builder, typeIds flatbuffers.UOffsetT)

func UnionEnd 

func UnionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func UnionStart 

func UnionStart(builder *flatbuffers.Builder)

func UnionStartTypeIdsVector 

func UnionStartTypeIdsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func Utf8End 

func Utf8End(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func Utf8Start 

func Utf8Start(builder *flatbuffers.Builder)

Types

type Binary 

type Binary struct {
	// contains filtered or unexported fields
}

/ Opaque binary data

func GetRootAsBinary 

func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary

func (*Binary) Init 

func (rcv *Binary) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Binary) Table 

func (rcv *Binary) Table() flatbuffers.Table

type Block 

type Block struct {
	// contains filtered or unexported fields
}

func (*Block) BodyLength 

func (rcv *Block) BodyLength() int64

/ Length of the data (this is aligned so there can be a gap between this and / the metatdata).

func (*Block) Init 

func (rcv *Block) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Block) MetaDataLength 

func (rcv *Block) MetaDataLength() int32

/ Length of the metadata

func (*Block) MutateBodyLength 

func (rcv *Block) MutateBodyLength(n int64) bool

/ Length of the data (this is aligned so there can be a gap between this and / the metatdata).

func (*Block) MutateMetaDataLength 

func (rcv *Block) MutateMetaDataLength(n int32) bool

/ Length of the metadata

func (*Block) MutateOffset 

func (rcv *Block) MutateOffset(n int64) bool

/ Index to the start of the RecordBlock (note this is past the Message header)

func (*Block) Offset 

func (rcv *Block) Offset() int64

/ Index to the start of the RecordBlock (note this is past the Message header)

func (*Block) Table 

func (rcv *Block) Table() flatbuffers.Table

type Bool 

type Bool struct {
	// contains filtered or unexported fields
}

func GetRootAsBool 

func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool

func (*Bool) Init 

func (rcv *Bool) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Bool) Table 

func (rcv *Bool) Table() flatbuffers.Table

type Buffer 

type Buffer struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A Buffer represents a single contiguous memory segment

func (*Buffer) Init 

func (rcv *Buffer) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Buffer) Length 

func (rcv *Buffer) Length() int64

/ 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 (*Buffer) MutateLength 

func (rcv *Buffer) MutateLength(n int64) bool

/ 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 (*Buffer) MutateOffset 

func (rcv *Buffer) MutateOffset(n int64) bool

/ The relative offset into the shared memory page where the bytes for this / buffer starts

func (*Buffer) Offset 

func (rcv *Buffer) Offset() int64

/ The relative offset into the shared memory page where the bytes for this / buffer starts

func (*Buffer) Table 

func (rcv *Buffer) Table() flatbuffers.Table

type Date 

type Date struct {
	// contains filtered or unexported fields
}

/ Date is either a 32-bit or 64-bit type representing 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

func GetRootAsDate 

func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date

func (*Date) Init 

func (rcv *Date) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Date) MutateUnit 

func (rcv *Date) MutateUnit(n DateUnit) bool

func (*Date) Table 

func (rcv *Date) Table() flatbuffers.Table

func (*Date) Unit 

func (rcv *Date) Unit() DateUnit

type DateUnit 

type DateUnit = int16
const (
	DateUnitDAY         DateUnit = 0
	DateUnitMILLISECOND DateUnit = 1
)

type Decimal 

type Decimal struct {
	// contains filtered or unexported fields
}

func GetRootAsDecimal 

func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal

func (*Decimal) Init 

func (rcv *Decimal) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Decimal) MutatePrecision 

func (rcv *Decimal) MutatePrecision(n int32) bool

/ Total number of decimal digits

func (*Decimal) MutateScale 

func (rcv *Decimal) MutateScale(n int32) bool

/ Number of digits after the decimal point "."

func (*Decimal) Precision 

func (rcv *Decimal) Precision() int32

/ Total number of decimal digits

func (*Decimal) Scale 

func (rcv *Decimal) Scale() int32

/ Number of digits after the decimal point "."

func (*Decimal) Table 

func (rcv *Decimal) Table() flatbuffers.Table

type DictionaryBatch 

type DictionaryBatch struct {
	// contains filtered or unexported fields
}

/ 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

func GetRootAsDictionaryBatch 

func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch

func (*DictionaryBatch) Data 

func (rcv *DictionaryBatch) Data(obj *RecordBatch) *RecordBatch

func (*DictionaryBatch) Id 

func (rcv *DictionaryBatch) Id() int64

func (*DictionaryBatch) Init 

func (rcv *DictionaryBatch) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DictionaryBatch) IsDelta 

func (rcv *DictionaryBatch) IsDelta() bool

/ If isDelta is true the values in the dictionary are to be appended to a / dictionary with the indicated id

func (*DictionaryBatch) MutateId 

func (rcv *DictionaryBatch) MutateId(n int64) bool

func (*DictionaryBatch) MutateIsDelta 

func (rcv *DictionaryBatch) MutateIsDelta(n bool) bool

/ If isDelta is true the values in the dictionary are to be appended to a / dictionary with the indicated id

func (*DictionaryBatch) Table 

func (rcv *DictionaryBatch) Table() flatbuffers.Table

type DictionaryEncoding 

type DictionaryEncoding struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Dictionary encoding metadata

func GetRootAsDictionaryEncoding 

func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding

func (*DictionaryEncoding) Id 

func (rcv *DictionaryEncoding) Id() int64

/ 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 (*DictionaryEncoding) IndexType 

func (rcv *DictionaryEncoding) IndexType(obj *Int) *Int

/ The dictionary indices are constrained to be positive integers. If this / field is null, the indices must be signed int32

func (*DictionaryEncoding) Init 

func (rcv *DictionaryEncoding) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DictionaryEncoding) IsOrdered 

func (rcv *DictionaryEncoding) IsOrdered() bool

/ The dictionary indices are constrained to be positive integers. If this / field is null, the indices must be signed int32 / 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 (*DictionaryEncoding) MutateId 

func (rcv *DictionaryEncoding) MutateId(n int64) bool

/ 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 (*DictionaryEncoding) MutateIsOrdered 

func (rcv *DictionaryEncoding) MutateIsOrdered(n bool) bool

/ 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 (*DictionaryEncoding) Table 

func (rcv *DictionaryEncoding) Table() flatbuffers.Table

type Duration 

type Duration struct {
	// contains filtered or unexported fields
}

func GetRootAsDuration 

func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration

func (*Duration) Init 

func (rcv *Duration) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Duration) MutateUnit 

func (rcv *Duration) MutateUnit(n TimeUnit) bool

func (*Duration) Table 

func (rcv *Duration) Table() flatbuffers.Table

func (*Duration) Unit 

func (rcv *Duration) Unit() TimeUnit

type Endianness 

type Endianness = int16

/ ---------------------------------------------------------------------- / Endianness of the platform producing the data 

const (
	EndiannessLittle Endianness = 0
	EndiannessBig    Endianness = 1
)

type Field 

type Field struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A field represents a named column in a record / row batch or child of a / nested type.

func GetRootAsField 

func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field

func (*Field) Children 

func (rcv *Field) Children(obj *Field, j int) bool

/ 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 (*Field) ChildrenLength 

func (rcv *Field) ChildrenLength() int

func (*Field) CustomMetadata 

func (rcv *Field) CustomMetadata(obj *KeyValue, j int) bool

/ children apply only to nested data types like Struct, List and Union. For / primitive types children will have length 0. / User-defined metadata

func (*Field) CustomMetadataLength 

func (rcv *Field) CustomMetadataLength() int

func (*Field) Dictionary 

func (rcv *Field) Dictionary(obj *DictionaryEncoding) *DictionaryEncoding

/ This is the type of the decoded value if the field is dictionary encoded. / Present only if the field is dictionary encoded.

func (*Field) Init 

func (rcv *Field) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Field) MutateNullable 

func (rcv *Field) MutateNullable(n bool) bool

/ Whether or not this field can contain nulls. Should be true in general.

func (*Field) MutateTypeType 

func (rcv *Field) MutateTypeType(n byte) bool

func (*Field) Name 

func (rcv *Field) Name() []byte

/ Name is not required, in i.e. a List

func (*Field) Nullable 

func (rcv *Field) Nullable() bool

/ Name is not required, in i.e. a List / Whether or not this field can contain nulls. Should be true in general.

func (*Field) Table 

func (rcv *Field) Table() flatbuffers.Table

func (*Field) Type 

func (rcv *Field) Type(obj *flatbuffers.Table) bool

/ This is the type of the decoded value if the field is dictionary encoded.

func (*Field) TypeType 

func (rcv *Field) TypeType() byte

type FieldNode 

type FieldNode struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / 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

func (*FieldNode) Init 

func (rcv *FieldNode) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FieldNode) Length 

func (rcv *FieldNode) Length() int64

/ The number of value slots in the Arrow array at this level of a nested / tree

func (*FieldNode) MutateLength 

func (rcv *FieldNode) MutateLength(n int64) bool

/ The number of value slots in the Arrow array at this level of a nested / tree

func (*FieldNode) MutateNullCount 

func (rcv *FieldNode) MutateNullCount(n int64) bool

/ 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 (*FieldNode) NullCount 

func (rcv *FieldNode) NullCount() int64

/ 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 (*FieldNode) Table 

func (rcv *FieldNode) Table() flatbuffers.Table

type FixedSizeBinary 

type FixedSizeBinary struct {
	// contains filtered or unexported fields
}

func GetRootAsFixedSizeBinary 

func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary

func (*FixedSizeBinary) ByteWidth 

func (rcv *FixedSizeBinary) ByteWidth() int32

/ Number of bytes per value

func (*FixedSizeBinary) Init 

func (rcv *FixedSizeBinary) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FixedSizeBinary) MutateByteWidth 

func (rcv *FixedSizeBinary) MutateByteWidth(n int32) bool

/ Number of bytes per value

func (*FixedSizeBinary) Table 

func (rcv *FixedSizeBinary) Table() flatbuffers.Table

type FixedSizeList 

type FixedSizeList struct {
	// contains filtered or unexported fields
}

func GetRootAsFixedSizeList 

func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList

func (*FixedSizeList) Init 

func (rcv *FixedSizeList) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FixedSizeList) ListSize 

func (rcv *FixedSizeList) ListSize() int32

/ Number of list items per value

func (*FixedSizeList) MutateListSize 

func (rcv *FixedSizeList) MutateListSize(n int32) bool

/ Number of list items per value

func (*FixedSizeList) Table 

func (rcv *FixedSizeList) Table() flatbuffers.Table

type FloatingPoint 

type FloatingPoint struct {
	// contains filtered or unexported fields
}

func GetRootAsFloatingPoint 

func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint

func (*FloatingPoint) Init 

func (rcv *FloatingPoint) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FloatingPoint) MutatePrecision 

func (rcv *FloatingPoint) MutatePrecision(n Precision) bool

func (*FloatingPoint) Precision 

func (rcv *FloatingPoint) Precision() Precision

func (*FloatingPoint) Table 

func (rcv *FloatingPoint) Table() flatbuffers.Table
type Footer struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Arrow File metadata /

func GetRootAsFooter 

func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer

func (*Footer) Dictionaries 

func (rcv *Footer) Dictionaries(obj *Block, j int) bool

func (*Footer) DictionariesLength 

func (rcv *Footer) DictionariesLength() int

func (*Footer) Init 

func (rcv *Footer) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Footer) MutateVersion 

func (rcv *Footer) MutateVersion(n MetadataVersion) bool

func (*Footer) RecordBatches 

func (rcv *Footer) RecordBatches(obj *Block, j int) bool

func (*Footer) RecordBatchesLength 

func (rcv *Footer) RecordBatchesLength() int

func (*Footer) Schema 

func (rcv *Footer) Schema(obj *Schema) *Schema

func (*Footer) Table 

func (rcv *Footer) Table() flatbuffers.Table

func (*Footer) Version 

func (rcv *Footer) Version() MetadataVersion

type Int 

type Int struct {
	// contains filtered or unexported fields
}

func GetRootAsInt 

func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int

func (*Int) BitWidth 

func (rcv *Int) BitWidth() int32

func (*Int) Init 

func (rcv *Int) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Int) IsSigned 

func (rcv *Int) IsSigned() bool

func (*Int) MutateBitWidth 

func (rcv *Int) MutateBitWidth(n int32) bool

func (*Int) MutateIsSigned 

func (rcv *Int) MutateIsSigned(n bool) bool

func (*Int) Table 

func (rcv *Int) Table() flatbuffers.Table

type Interval 

type Interval struct {
	// contains filtered or unexported fields
}

func GetRootAsInterval 

func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval

func (*Interval) Init 

func (rcv *Interval) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Interval) MutateUnit 

func (rcv *Interval) MutateUnit(n IntervalUnit) bool

func (*Interval) Table 

func (rcv *Interval) Table() flatbuffers.Table

func (*Interval) Unit 

func (rcv *Interval) Unit() IntervalUnit

type IntervalUnit 

type IntervalUnit = int16
const (
	IntervalUnitYEAR_MONTH IntervalUnit = 0
	IntervalUnitDAY_TIME   IntervalUnit = 1
)

type KeyValue 

type KeyValue struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / user defined key value pairs to add custom metadata to arrow / key namespacing is the responsibility of the user

func GetRootAsKeyValue 

func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue

func (*KeyValue) Init 

func (rcv *KeyValue) Init(buf []byte, i flatbuffers.UOffsetT)

func (*KeyValue) Key 

func (rcv *KeyValue) Key() []byte

func (*KeyValue) Table 

func (rcv *KeyValue) Table() flatbuffers.Table

func (*KeyValue) Value 

func (rcv *KeyValue) Value() []byte

type List 

type List struct {
	// contains filtered or unexported fields
}

func GetRootAsList 

func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List

func (*List) Init 

func (rcv *List) Init(buf []byte, i flatbuffers.UOffsetT)

func (*List) Table 

func (rcv *List) Table() flatbuffers.Table

type Map 

type Map struct {
	// contains filtered or unexported fields
}

/ 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 / - 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.

func GetRootAsMap 

func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map

func (*Map) Init 

func (rcv *Map) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Map) KeysSorted 

func (rcv *Map) KeysSorted() bool

/ Set to true if the keys within each value are sorted

func (*Map) MutateKeysSorted 

func (rcv *Map) MutateKeysSorted(n bool) bool

/ Set to true if the keys within each value are sorted

func (*Map) Table 

func (rcv *Map) Table() flatbuffers.Table

type Message 

type Message struct {
	// contains filtered or unexported fields
}

func GetRootAsMessage 

func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message

func (*Message) BodyLength 

func (rcv *Message) BodyLength() int64

func (*Message) CustomMetadata 

func (rcv *Message) CustomMetadata(obj *KeyValue, j int) bool

func (*Message) CustomMetadataLength 

func (rcv *Message) CustomMetadataLength() int

func (*Message) Header 

func (rcv *Message) Header(obj *flatbuffers.Table) bool

func (*Message) HeaderType 

func (rcv *Message) HeaderType() byte

func (*Message) Init 

func (rcv *Message) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Message) MutateBodyLength 

func (rcv *Message) MutateBodyLength(n int64) bool

func (*Message) MutateHeaderType 

func (rcv *Message) MutateHeaderType(n byte) bool

func (*Message) MutateVersion 

func (rcv *Message) MutateVersion(n MetadataVersion) bool

func (*Message) Table 

func (rcv *Message) Table() flatbuffers.Table

func (*Message) Version 

func (rcv *Message) Version() MetadataVersion

type MessageHeader 

type MessageHeader = byte

/ ---------------------------------------------------------------------- / 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 

const (
	MessageHeaderNONE            MessageHeader = 0
	MessageHeaderSchema          MessageHeader = 1
	MessageHeaderDictionaryBatch MessageHeader = 2
	MessageHeaderRecordBatch     MessageHeader = 3
	MessageHeaderTensor          MessageHeader = 4
	MessageHeaderSparseTensor    MessageHeader = 5
)

type MetadataVersion 

type MetadataVersion = int16
const (
	/// 0.1.0
	MetadataVersionV1 MetadataVersion = 0
	/// 0.2.0
	MetadataVersionV2 MetadataVersion = 1
	/// 0.3.0 -> 0.7.1
	MetadataVersionV3 MetadataVersion = 2
	/// >= 0.8.0
	MetadataVersionV4 MetadataVersion = 3
)

type Null 

type Null struct {
	// contains filtered or unexported fields
}

/ These are stored in the flatbuffer in the Type union below

func GetRootAsNull 

func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null

func (*Null) Init 

func (rcv *Null) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Null) Table 

func (rcv *Null) Table() flatbuffers.Table

type Precision 

type Precision = int16
const (
	PrecisionHALF   Precision = 0
	PrecisionSINGLE Precision = 1
	PrecisionDOUBLE Precision = 2
)

type RecordBatch 

type RecordBatch struct {
	// contains filtered or unexported fields
}

/ 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".

func GetRootAsRecordBatch 

func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch

func (*RecordBatch) Buffers 

func (rcv *RecordBatch) Buffers(obj *Buffer, j int) bool

/ 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 (*RecordBatch) BuffersLength 

func (rcv *RecordBatch) BuffersLength() int

func (*RecordBatch) Init 

func (rcv *RecordBatch) Init(buf []byte, i flatbuffers.UOffsetT)

func (*RecordBatch) Length 

func (rcv *RecordBatch) Length() int64

/ number of records / rows. The arrays in the batch should all have this / length

func (*RecordBatch) MutateLength 

func (rcv *RecordBatch) MutateLength(n int64) bool

/ number of records / rows. The arrays in the batch should all have this / length

func (*RecordBatch) Nodes 

func (rcv *RecordBatch) Nodes(obj *FieldNode, j int) bool

/ Nodes correspond to the pre-ordered flattened logical schema

func (*RecordBatch) NodesLength 

func (rcv *RecordBatch) NodesLength() int

func (*RecordBatch) Table 

func (rcv *RecordBatch) Table() flatbuffers.Table

type Schema 

type Schema struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A Schema describes the columns in a row batch

func GetRootAsSchema 

func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema

func (*Schema) CustomMetadata 

func (rcv *Schema) CustomMetadata(obj *KeyValue, j int) bool

func (*Schema) CustomMetadataLength 

func (rcv *Schema) CustomMetadataLength() int

func (*Schema) Endianness 

func (rcv *Schema) Endianness() Endianness

/ 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 (*Schema) Fields 

func (rcv *Schema) Fields(obj *Field, j int) bool

func (*Schema) FieldsLength 

func (rcv *Schema) FieldsLength() int

func (*Schema) Init 

func (rcv *Schema) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Schema) MutateEndianness 

func (rcv *Schema) MutateEndianness(n Endianness) bool

/ 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 (*Schema) Table 

func (rcv *Schema) Table() flatbuffers.Table

type SparseMatrixIndexCSR 

type SparseMatrixIndexCSR struct {
	// contains filtered or unexported fields
}

/ Compressed Sparse Row format, that is matrix-specific.

func GetRootAsSparseMatrixIndexCSR 

func GetRootAsSparseMatrixIndexCSR(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSR

func (*SparseMatrixIndexCSR) IndicesBuffer 

func (rcv *SparseMatrixIndexCSR) IndicesBuffer(obj *Buffer) *Buffer

/ 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: / / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / / Note that the indices are sorted in lexicographical order for each row.

func (*SparseMatrixIndexCSR) IndicesType 

func (rcv *SparseMatrixIndexCSR) IndicesType(obj *Int) *Int

/ 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: / / 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: / / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / / And the indptr of X is: / / indptr(X) = [0, 2, 3, 5, 5, 8, 10]. / The type of values in indicesBuffer

func (*SparseMatrixIndexCSR) IndptrBuffer 

func (rcv *SparseMatrixIndexCSR) IndptrBuffer(obj *Buffer) *Buffer

/ 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: / / 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: / / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / / And the indptr of X is: / / indptr(X) = [0, 2, 3, 5, 5, 8, 10].

func (*SparseMatrixIndexCSR) IndptrType 

func (rcv *SparseMatrixIndexCSR) IndptrType(obj *Int) *Int

/ The type of values in indptrBuffer

func (*SparseMatrixIndexCSR) Init 

func (rcv *SparseMatrixIndexCSR) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseMatrixIndexCSR) Table 

func (rcv *SparseMatrixIndexCSR) Table() flatbuffers.Table

type SparseTensor 

type SparseTensor struct {
	// contains filtered or unexported fields
}

func GetRootAsSparseTensor 

func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor

func (*SparseTensor) Data 

func (rcv *SparseTensor) Data(obj *Buffer) *Buffer

/ Sparse tensor index / The location and size of the tensor's data

func (*SparseTensor) Init 

func (rcv *SparseTensor) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseTensor) MutateNonZeroLength 

func (rcv *SparseTensor) MutateNonZeroLength(n int64) bool

/ The number of non-zero values in a sparse tensor.

func (*SparseTensor) MutateSparseIndexType 

func (rcv *SparseTensor) MutateSparseIndexType(n byte) bool

func (*SparseTensor) MutateTypeType 

func (rcv *SparseTensor) MutateTypeType(n byte) bool

func (*SparseTensor) NonZeroLength 

func (rcv *SparseTensor) NonZeroLength() int64

/ The dimensions of the tensor, optionally named. / The number of non-zero values in a sparse tensor.

func (*SparseTensor) Shape 

func (rcv *SparseTensor) Shape(obj *TensorDim, j int) bool

/ The type of data contained in a value cell. / Currently only fixed-width value types are supported, / no strings or nested types. / The dimensions of the tensor, optionally named.

func (*SparseTensor) ShapeLength 

func (rcv *SparseTensor) ShapeLength() int

func (*SparseTensor) SparseIndex 

func (rcv *SparseTensor) SparseIndex(obj *flatbuffers.Table) bool

/ Sparse tensor index

func (*SparseTensor) SparseIndexType 

func (rcv *SparseTensor) SparseIndexType() byte

func (*SparseTensor) Table 

func (rcv *SparseTensor) Table() flatbuffers.Table

func (*SparseTensor) Type 

func (rcv *SparseTensor) Type(obj *flatbuffers.Table) bool

/ The type of data contained in a value cell. / Currently only fixed-width value types are supported, / no strings or nested types.

func (*SparseTensor) TypeType 

func (rcv *SparseTensor) TypeType() byte

type SparseTensorIndex 

type SparseTensorIndex = byte
const (
	SparseTensorIndexNONE                 SparseTensorIndex = 0
	SparseTensorIndexSparseTensorIndexCOO SparseTensorIndex = 1
	SparseTensorIndexSparseMatrixIndexCSR SparseTensorIndex = 2
)

type SparseTensorIndexCOO 

type SparseTensorIndexCOO struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / EXPERIMENTAL: Data structures for sparse tensors / Coodinate (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: / / 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: / / [[0, 0, 0, 0, 1, 1], / [1, 1, 1, 2, 1, 2], / [2, 2, 3, 1, 2, 0], / [0, 1, 0, 0, 3, 4]] / / Note that the indices are sorted in lexicographical order.

func GetRootAsSparseTensorIndexCOO 

func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO

func (*SparseTensorIndexCOO) IndicesBuffer 

func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer

/ The location and size of the indices matrix's data

func (*SparseTensorIndexCOO) IndicesStrides 

func (rcv *SparseTensorIndexCOO) IndicesStrides(j int) int64

/ The type of values in indicesBuffer / Non-negative byte offsets to advance one value cell along each dimension

func (*SparseTensorIndexCOO) IndicesStridesLength 

func (rcv *SparseTensorIndexCOO) IndicesStridesLength() int

func (*SparseTensorIndexCOO) IndicesType 

func (rcv *SparseTensorIndexCOO) IndicesType(obj *Int) *Int

/ The type of values in indicesBuffer

func (*SparseTensorIndexCOO) Init 

func (rcv *SparseTensorIndexCOO) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseTensorIndexCOO) MutateIndicesStrides 

func (rcv *SparseTensorIndexCOO) MutateIndicesStrides(j int, n int64) bool

/ Non-negative byte offsets to advance one value cell along each dimension

func (*SparseTensorIndexCOO) Table 

func (rcv *SparseTensorIndexCOO) Table() flatbuffers.Table

type Struct_ 

type Struct_ struct {
	// contains filtered or unexported fields
}

/ 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

func GetRootAsStruct_ 

func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_

func (*Struct_) Init 

func (rcv *Struct_) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Struct_) Table 

func (rcv *Struct_) Table() flatbuffers.Table

type Tensor 

type Tensor struct {
	// contains filtered or unexported fields
}

func GetRootAsTensor 

func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor

func (*Tensor) Data 

func (rcv *Tensor) Data(obj *Buffer) *Buffer

/ The location and size of the tensor's data

func (*Tensor) Init 

func (rcv *Tensor) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Tensor) MutateStrides 

func (rcv *Tensor) MutateStrides(j int, n int64) bool

/ Non-negative byte offsets to advance one value cell along each dimension

func (*Tensor) MutateTypeType 

func (rcv *Tensor) MutateTypeType(n byte) bool

func (*Tensor) Shape 

func (rcv *Tensor) Shape(obj *TensorDim, j int) bool

/ The type of data contained in a value cell. Currently only fixed-width / value types are supported, no strings or nested types / The dimensions of the tensor, optionally named

func (*Tensor) ShapeLength 

func (rcv *Tensor) ShapeLength() int

func (*Tensor) Strides 

func (rcv *Tensor) Strides(j int) int64

/ The dimensions of the tensor, optionally named / Non-negative byte offsets to advance one value cell along each dimension

func (*Tensor) StridesLength 

func (rcv *Tensor) StridesLength() int

func (*Tensor) Table 

func (rcv *Tensor) Table() flatbuffers.Table

func (*Tensor) Type 

func (rcv *Tensor) Type(obj *flatbuffers.Table) bool

/ The type of data contained in a value cell. Currently only fixed-width / value types are supported, no strings or nested types

func (*Tensor) TypeType 

func (rcv *Tensor) TypeType() byte

type TensorDim 

type TensorDim struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Data structures for dense tensors / Shape data for a single axis in a tensor

func GetRootAsTensorDim 

func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim

func (*TensorDim) Init 

func (rcv *TensorDim) Init(buf []byte, i flatbuffers.UOffsetT)

func (*TensorDim) MutateSize 

func (rcv *TensorDim) MutateSize(n int64) bool

/ Length of dimension

func (*TensorDim) Name 

func (rcv *TensorDim) Name() []byte

/ Name of the dimension, optional

func (*TensorDim) Size 

func (rcv *TensorDim) Size() int64

/ Length of dimension

func (*TensorDim) Table 

func (rcv *TensorDim) Table() flatbuffers.Table

type Time 

type Time struct {
	// contains filtered or unexported fields
}

/ Time type. The physical storage type depends on the unit / - SECOND and MILLISECOND: 32 bits / - MICROSECOND and NANOSECOND: 64 bits

func GetRootAsTime 

func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time

func (*Time) BitWidth 

func (rcv *Time) BitWidth() int32

func (*Time) Init 

func (rcv *Time) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Time) MutateBitWidth 

func (rcv *Time) MutateBitWidth(n int32) bool

func (*Time) MutateUnit 

func (rcv *Time) MutateUnit(n TimeUnit) bool

func (*Time) Table 

func (rcv *Time) Table() flatbuffers.Table

func (*Time) Unit 

func (rcv *Time) Unit() TimeUnit

type TimeUnit 

type TimeUnit = int16
const (
	TimeUnitSECOND      TimeUnit = 0
	TimeUnitMILLISECOND TimeUnit = 1
	TimeUnitMICROSECOND TimeUnit = 2
	TimeUnitNANOSECOND  TimeUnit = 3
)

type Timestamp 

type Timestamp struct {
	// contains filtered or unexported fields
}

/ Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding / leap seconds, as a 64-bit integer. Note that UNIX time does not include / leap seconds. / / The Timestamp metadata supports both "time zone naive" and "time zone / aware" timestamps. Read about the timezone attribute for more detail

func GetRootAsTimestamp 

func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp

func (*Timestamp) Init 

func (rcv *Timestamp) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Timestamp) MutateUnit 

func (rcv *Timestamp) MutateUnit(n TimeUnit) bool

func (*Timestamp) Table 

func (rcv *Timestamp) Table() flatbuffers.Table

func (*Timestamp) Timezone 

func (rcv *Timestamp) Timezone() []byte

/ The time zone is a string indicating the name of a time zone, one of: / / * As used in the Olson time zone database (the "tz database" or / "tzdata"), such as "America/New_York" / * An absolute time zone 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: / / * If the time zone is null or equal to an empty string, the data is "time / zone naive" and shall be displayed *as is* to the user, not localized / to the locale of the user. This data can be though of as UTC but / without having "UTC" as the time zone, it is not considered to be / localized to any time zone / / * If the time zone is set to a valid value, values can be displayed as / "localized" to that time zone, even though the underlying 64-bit / integers are identical to the same data stored in UTC. Converting / between time zones is a metadata-only operation and does not change the / underlying values

func (*Timestamp) Unit 

func (rcv *Timestamp) Unit() TimeUnit

type Type 

type Type = byte

/ ---------------------------------------------------------------------- / Top-level Type value, enabling extensible type-specific metadata. We can / add new logical types to Type without breaking backwards compatibility 

const (
	TypeNONE            Type = 0
	TypeNull            Type = 1
	TypeInt             Type = 2
	TypeFloatingPoint   Type = 3
	TypeBinary          Type = 4
	TypeUtf8            Type = 5
	TypeBool            Type = 6
	TypeDecimal         Type = 7
	TypeDate            Type = 8
	TypeTime            Type = 9
	TypeTimestamp       Type = 10
	TypeInterval        Type = 11
	TypeList            Type = 12
	TypeStruct_         Type = 13
	TypeUnion           Type = 14
	TypeFixedSizeBinary Type = 15
	TypeFixedSizeList   Type = 16
	TypeMap             Type = 17
	TypeDuration        Type = 18
	TypeLargeBinary     Type = 19
	TypeLargeUtf8       Type = 20
	TypeLargeList       Type = 21
)

type Union 

type Union struct {
	// contains filtered or unexported fields
}

/ 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

func GetRootAsUnion 

func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union

func (*Union) Init 

func (rcv *Union) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Union) Mode 

func (rcv *Union) Mode() UnionMode

func (*Union) MutateMode 

func (rcv *Union) MutateMode(n UnionMode) bool

func (*Union) MutateTypeIds 

func (rcv *Union) MutateTypeIds(j int, n int32) bool

func (*Union) Table 

func (rcv *Union) Table() flatbuffers.Table

func (*Union) TypeIds 

func (rcv *Union) TypeIds(j int) int32

func (*Union) TypeIdsLength 

func (rcv *Union) TypeIdsLength() int

type UnionMode 

type UnionMode = int16
const (
	UnionModeSparse UnionMode = 0
	UnionModeDense  UnionMode = 1
)

type Utf8 

type Utf8 struct {
	// contains filtered or unexported fields
}

/ Unicode with UTF-8 encoding

func GetRootAsUtf8 

func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8

func (*Utf8) Init 

func (rcv *Utf8) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Utf8) Table 

func (rcv *Utf8) Table() flatbuffers.Table

Source Files

Binary.go Block.go Bool.go Buffer.go Date.go DateUnit.go Decimal.go DictionaryBatch.go DictionaryEncoding.go Duration.go Endianness.go Field.go FieldNode.go FixedSizeBinary.go FixedSizeList.go FloatingPoint.go Footer.go Int.go Interval.go IntervalUnit.go KeyValue.go List.go Map.go Message.go MessageHeader.go MetadataVersion.go Null.go Precision.go RecordBatch.go Schema.go SparseMatrixIndexCSR.go SparseTensor.go SparseTensorIndex.go SparseTensorIndexCOO.go Struct_.go Tensor.go TensorDim.go Time.go TimeUnit.go Timestamp.go Type.go Union.go UnionMode.go Utf8.go

Version
v0.3.0 (latest)
Published
Feb 17, 2025
Platform
linux/amd64
Imports
1 packages
Last checked
2 months ago –

Tools for package owners.