Documentation

Index

Constants

This section is empty.

Variables

View Source
var EnumNamesBodyCompressionMethod = map[BodyCompressionMethod]string{
	BodyCompressionMethodBUFFER: "BUFFER",
}
View Source
var EnumNamesCompressionType = map[CompressionType]string{
	CompressionTypeLZ4_FRAME: "LZ4_FRAME",
	CompressionTypeZSTD:      "ZSTD",
}
View Source
var EnumNamesDateUnit = map[DateUnit]string{
	DateUnitDAY:         "DAY",
	DateUnitMILLISECOND: "MILLISECOND",
}
View Source
var EnumNamesDictionaryKind = map[DictionaryKind]string{
	DictionaryKindDenseArray: "DenseArray",
}
View Source
var EnumNamesEndianness = map[Endianness]string{
	EndiannessLittle: "Little",
	EndiannessBig:    "Big",
}
View Source
var EnumNamesFeature = map[Feature]string{
	FeatureUNUSED:                 "UNUSED",
	FeatureDICTIONARY_REPLACEMENT: "DICTIONARY_REPLACEMENT",
	FeatureCOMPRESSED_BODY:        "COMPRESSED_BODY",
}
View Source
var EnumNamesIntervalUnit = map[IntervalUnit]string{
	IntervalUnitYEAR_MONTH: "YEAR_MONTH",
	IntervalUnitDAY_TIME:   "DAY_TIME",
}
View Source
var EnumNamesMessageHeader = map[MessageHeader]string{
	MessageHeaderNONE:            "NONE",
	MessageHeaderSchema:          "Schema",
	MessageHeaderDictionaryBatch: "DictionaryBatch",
	MessageHeaderRecordBatch:     "RecordBatch",
	MessageHeaderTensor:          "Tensor",
	MessageHeaderSparseTensor:    "SparseTensor",
}
View Source
var EnumNamesMetadataVersion = map[MetadataVersion]string{
	MetadataVersionV1: "V1",
	MetadataVersionV2: "V2",
	MetadataVersionV3: "V3",
	MetadataVersionV4: "V4",
	MetadataVersionV5: "V5",
}
View Source
var EnumNamesPrecision = map[Precision]string{
	PrecisionHALF:   "HALF",
	PrecisionSINGLE: "SINGLE",
	PrecisionDOUBLE: "DOUBLE",
}
View Source
var EnumNamesSparseMatrixCompressedAxis = map[SparseMatrixCompressedAxis]string{
	SparseMatrixCompressedAxisRow:    "Row",
	SparseMatrixCompressedAxisColumn: "Column",
}
View Source
var EnumNamesSparseTensorIndex = map[SparseTensorIndex]string{
	SparseTensorIndexNONE:                 "NONE",
	SparseTensorIndexSparseTensorIndexCOO: "SparseTensorIndexCOO",
	SparseTensorIndexSparseMatrixIndexCSX: "SparseMatrixIndexCSX",
	SparseTensorIndexSparseTensorIndexCSF: "SparseTensorIndexCSF",
}
View Source
var EnumNamesTimeUnit = map[TimeUnit]string{
	TimeUnitSECOND:      "SECOND",
	TimeUnitMILLISECOND: "MILLISECOND",
	TimeUnitMICROSECOND: "MICROSECOND",
	TimeUnitNANOSECOND:  "NANOSECOND",
}
View Source
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",
}
View Source
var EnumNamesUnionMode = map[UnionMode]string{
	UnionModeSparse: "Sparse",
	UnionModeDense:  "Dense",
}
View Source
var EnumValuesBodyCompressionMethod = map[string]BodyCompressionMethod{
	"BUFFER": BodyCompressionMethodBUFFER,
}
View Source
var EnumValuesCompressionType = map[string]CompressionType{
	"LZ4_FRAME": CompressionTypeLZ4_FRAME,
	"ZSTD":      CompressionTypeZSTD,
}
View Source
var EnumValuesDateUnit = map[string]DateUnit{
	"DAY":         DateUnitDAY,
	"MILLISECOND": DateUnitMILLISECOND,
}
View Source
var EnumValuesDictionaryKind = map[string]DictionaryKind{
	"DenseArray": DictionaryKindDenseArray,
}
View Source
var EnumValuesEndianness = map[string]Endianness{
	"Little": EndiannessLittle,
	"Big":    EndiannessBig,
}
View Source
var EnumValuesFeature = map[string]Feature{
	"UNUSED":                 FeatureUNUSED,
	"DICTIONARY_REPLACEMENT": FeatureDICTIONARY_REPLACEMENT,
	"COMPRESSED_BODY":        FeatureCOMPRESSED_BODY,
}
View Source
var EnumValuesIntervalUnit = map[string]IntervalUnit{
	"YEAR_MONTH": IntervalUnitYEAR_MONTH,
	"DAY_TIME":   IntervalUnitDAY_TIME,
}
View Source
var EnumValuesMessageHeader = map[string]MessageHeader{
	"NONE":            MessageHeaderNONE,
	"Schema":          MessageHeaderSchema,
	"DictionaryBatch": MessageHeaderDictionaryBatch,
	"RecordBatch":     MessageHeaderRecordBatch,
	"Tensor":          MessageHeaderTensor,
	"SparseTensor":    MessageHeaderSparseTensor,
}
View Source
var EnumValuesMetadataVersion = map[string]MetadataVersion{
	"V1": MetadataVersionV1,
	"V2": MetadataVersionV2,
	"V3": MetadataVersionV3,
	"V4": MetadataVersionV4,
	"V5": MetadataVersionV5,
}
View Source
var EnumValuesPrecision = map[string]Precision{
	"HALF":   PrecisionHALF,
	"SINGLE": PrecisionSINGLE,
	"DOUBLE": PrecisionDOUBLE,
}
View Source
var EnumValuesSparseMatrixCompressedAxis = map[string]SparseMatrixCompressedAxis{
	"Row":    SparseMatrixCompressedAxisRow,
	"Column": SparseMatrixCompressedAxisColumn,
}
View Source
var EnumValuesSparseTensorIndex = map[string]SparseTensorIndex{
	"NONE":                 SparseTensorIndexNONE,
	"SparseTensorIndexCOO": SparseTensorIndexSparseTensorIndexCOO,
	"SparseMatrixIndexCSX": SparseTensorIndexSparseMatrixIndexCSX,
	"SparseTensorIndexCSF": SparseTensorIndexSparseTensorIndexCSF,
}
View Source
var EnumValuesTimeUnit = map[string]TimeUnit{
	"SECOND":      TimeUnitSECOND,
	"MILLISECOND": TimeUnitMILLISECOND,
	"MICROSECOND": TimeUnitMICROSECOND,
	"NANOSECOND":  TimeUnitNANOSECOND,
}
View Source
var EnumValuesType = map[string]Type{
	"NONE":            TypeNONE,
	"Null":            TypeNull,
	"Int":             TypeInt,
	"FloatingPoint":   TypeFloatingPoint,
	"Binary":          TypeBinary,
	"Utf8":            TypeUtf8,
	"Bool":            TypeBool,
	"Decimal":         TypeDecimal,
	"Date":            TypeDate,
	"Time":            TypeTime,
	"Timestamp":       TypeTimestamp,
	"Interval":        TypeInterval,
	"List":            TypeList,
	"Struct_":         TypeStruct_,
	"Union":           TypeUnion,
	"FixedSizeBinary": TypeFixedSizeBinary,
	"FixedSizeList":   TypeFixedSizeList,
	"Map":             TypeMap,
	"Duration":        TypeDuration,
	"LargeBinary":     TypeLargeBinary,
	"LargeUtf8":       TypeLargeUtf8,
	"LargeList":       TypeLargeList,
}
View Source
var EnumValuesUnionMode = map[string]UnionMode{
	"Sparse": UnionModeSparse,
	"Dense":  UnionModeDense,
}

Functions

func BinaryEnd

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

func BinaryStart

func BinaryStart(builder *flatbuffers.Builder)

func BodyCompressionAddCodec

func BodyCompressionAddCodec(builder *flatbuffers.Builder, codec CompressionType)

func BodyCompressionAddMethod

func BodyCompressionAddMethod(builder *flatbuffers.Builder, method BodyCompressionMethod)

func BodyCompressionEnd

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

func BodyCompressionStart

func BodyCompressionStart(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 DateUnit)

func DateEnd

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

func DateStart

func DateStart(builder *flatbuffers.Builder)

func DecimalAddBitWidth

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

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 DictionaryEncodingAddDictionaryKind

func DictionaryEncodingAddDictionaryKind(builder *flatbuffers.Builder, dictionaryKind DictionaryKind)

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 TimeUnit)

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 Type)

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 Precision)

    func FloatingPointEnd

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

    func FloatingPointStart

    func FloatingPointStart(builder *flatbuffers.Builder)

    func FooterAddCustomMetadata

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

    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 MetadataVersion)

    func FooterEnd

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

    func FooterStart

    func FooterStart(builder *flatbuffers.Builder)

      / User-defined metadata

      func FooterStartCustomMetadataVector

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

      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 IntervalUnit)

      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 LargeBinaryEnd

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

      func LargeBinaryStart

      func LargeBinaryStart(builder *flatbuffers.Builder)

      func LargeListEnd

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

      func LargeListStart

      func LargeListStart(builder *flatbuffers.Builder)

      func LargeUtf8End

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

      func LargeUtf8Start

      func LargeUtf8Start(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 MessageHeader)

      func MessageAddVersion

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

      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 RecordBatchAddCompression

      func RecordBatchAddCompression(builder *flatbuffers.Builder, compression 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)

        / Optional compression of the message body

        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 Endianness)

        func SchemaAddFeatures

        func SchemaAddFeatures(builder *flatbuffers.Builder, features flatbuffers.UOffsetT)

        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 SchemaStartFeaturesVector

        func SchemaStartFeaturesVector(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 SparseMatrixIndexCSXAddCompressedAxis

          func SparseMatrixIndexCSXAddCompressedAxis(builder *flatbuffers.Builder, compressedAxis SparseMatrixCompressedAxis)

          func SparseMatrixIndexCSXAddIndicesBuffer

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

          func SparseMatrixIndexCSXAddIndicesType

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

          func SparseMatrixIndexCSXAddIndptrBuffer

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

          func SparseMatrixIndexCSXAddIndptrType

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

          func SparseMatrixIndexCSXEnd

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

          func SparseMatrixIndexCSXStart

          func SparseMatrixIndexCSXStart(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: / “`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 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 SparseTensorIndex)

            func SparseTensorAddType

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

            func SparseTensorAddTypeType

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

            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 SparseTensorIndexCOOAddIsCanonical

            func SparseTensorIndexCOOAddIsCanonical(builder *flatbuffers.Builder, isCanonical bool)

            func SparseTensorIndexCOOEnd

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

            func SparseTensorIndexCOOStart

            func SparseTensorIndexCOOStart(builder *flatbuffers.Builder)

            func SparseTensorIndexCOOStartIndicesStridesVector

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

            func SparseTensorIndexCSFAddAxisOrder

            func SparseTensorIndexCSFAddAxisOrder(builder *flatbuffers.Builder, axisOrder flatbuffers.UOffsetT)

            func SparseTensorIndexCSFAddIndicesBuffers

            func SparseTensorIndexCSFAddIndicesBuffers(builder *flatbuffers.Builder, indicesBuffers flatbuffers.UOffsetT)

            func SparseTensorIndexCSFAddIndicesType

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

            func SparseTensorIndexCSFAddIndptrBuffers

            func SparseTensorIndexCSFAddIndptrBuffers(builder *flatbuffers.Builder, indptrBuffers flatbuffers.UOffsetT)

            func SparseTensorIndexCSFAddIndptrType

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

            func SparseTensorIndexCSFEnd

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

            func SparseTensorIndexCSFStart

            func SparseTensorIndexCSFStart(builder *flatbuffers.Builder)

            func SparseTensorIndexCSFStartAxisOrderVector

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

            func SparseTensorIndexCSFStartIndicesBuffersVector

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

            func SparseTensorIndexCSFStartIndptrBuffersVector

            func SparseTensorIndexCSFStartIndptrBuffersVector(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 Type)

              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 TimeUnit)

                  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 TimeUnit)

                  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 UnionMode)

                    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 metadata).

                        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 metadata).

                            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 BodyCompression

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

                                    / Optional compression for the memory buffers constituting IPC message / bodies. Intended for use with RecordBatch but could be used for other / message types

                                    func GetRootAsBodyCompression

                                    func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression

                                    func (*BodyCompression) Codec

                                    func (rcv *BodyCompression) Codec() CompressionType

                                      / Compressor library

                                      func (*BodyCompression) Init

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

                                      func (*BodyCompression) Method

                                      func (rcv *BodyCompression) Method() BodyCompressionMethod

                                        / Indicates the way the record batch body was compressed

                                        func (*BodyCompression) MutateCodec

                                        func (rcv *BodyCompression) MutateCodec(n CompressionType) bool

                                          / Compressor library

                                          func (*BodyCompression) MutateMethod

                                          func (rcv *BodyCompression) MutateMethod(n BodyCompressionMethod) bool

                                            / Indicates the way the record batch body was compressed

                                            func (*BodyCompression) Table

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

                                            type BodyCompressionMethod

                                            type BodyCompressionMethod int8

                                              / 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

                                              const (
                                              	/// Each constituent buffer is first compressed with the indicated
                                              	/// compressor, and then written with the uncompressed length in the first 8
                                              	/// bytes as a 64-bit little-endian signed integer followed by the compressed
                                              	/// buffer bytes (and then padding as required by the protocol). The
                                              	/// uncompressed length may be set to -1 to indicate that the data that
                                              	/// follows is not compressed, which can be useful for cases where
                                              	/// compression does not yield appreciable savings.
                                              	BodyCompressionMethodBUFFER BodyCompressionMethod = 0
                                              )

                                              func (BodyCompressionMethod) String

                                              func (v BodyCompressionMethod) String() string

                                              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 CompressionType

                                                        type CompressionType int8
                                                        const (
                                                        	CompressionTypeLZ4_FRAME CompressionType = 0
                                                        	CompressionTypeZSTD      CompressionType = 1
                                                        )

                                                        func (CompressionType) String

                                                        func (v CompressionType) String() string

                                                        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
                                                          )

                                                          func (DateUnit) String

                                                          func (v DateUnit) String() string

                                                          type Decimal

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

                                                            / Exact decimal value represented as an integer value in two's / complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers / are used. The representation uses the endianness indicated / in the Schema.

                                                            func GetRootAsDecimal

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

                                                            func (*Decimal) BitWidth

                                                            func (rcv *Decimal) BitWidth() int32

                                                              / Number of bits per value. The only accepted widths are 128 and 256. / We use bitWidth for consistency with Int::bitWidth.

                                                              func (*Decimal) Init

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

                                                              func (*Decimal) MutateBitWidth

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

                                                                / Number of bits per value. The only accepted widths are 128 and 256. / We use bitWidth for consistency with Int::bitWidth.

                                                                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. If isDelta is false this dictionary / should replace the existing dictionary.

                                                                            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. If isDelta is false this dictionary / should replace the existing dictionary.

                                                                              func (*DictionaryBatch) Table

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

                                                                              type DictionaryEncoding

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

                                                                              func GetRootAsDictionaryEncoding

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

                                                                              func (*DictionaryEncoding) DictionaryKind

                                                                              func (rcv *DictionaryEncoding) DictionaryKind() DictionaryKind

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

                                                                                    func (rcv *DictionaryEncoding) MutateDictionaryKind(n DictionaryKind) bool

                                                                                    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 DictionaryKind

                                                                                        type DictionaryKind int16

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

                                                                                          const (
                                                                                          	DictionaryKindDenseArray DictionaryKind = 0
                                                                                          )

                                                                                          func (DictionaryKind) String

                                                                                          func (v DictionaryKind) String() string

                                                                                          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
                                                                                            )

                                                                                            func (Endianness) String

                                                                                            func (v Endianness) String() string

                                                                                            type Feature

                                                                                            type Feature int64

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

                                                                                              const (
                                                                                              	/// Needed to make flatbuffers happy.
                                                                                              	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
                                                                                              )

                                                                                              func (Feature) String

                                                                                              func (v Feature) String() string

                                                                                              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 Type) 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() Type

                                                                                                              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) CustomMetadata

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

                                                                                                                                    / User-defined metadata

                                                                                                                                    func (*Footer) CustomMetadataLength

                                                                                                                                    func (rcv *Footer) CustomMetadataLength() int

                                                                                                                                    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
                                                                                                                                    )

                                                                                                                                    func (IntervalUnit) String

                                                                                                                                    func (v IntervalUnit) String() string

                                                                                                                                    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 LargeBinary

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

                                                                                                                                        / Same as Binary, but with 64-bit offsets, allowing to represent / extremely large data values.

                                                                                                                                        func GetRootAsLargeBinary

                                                                                                                                        func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary

                                                                                                                                        func (*LargeBinary) Init

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

                                                                                                                                        func (*LargeBinary) Table

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

                                                                                                                                        type LargeList

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

                                                                                                                                          / Same as List, but with 64-bit offsets, allowing to represent / extremely large data values.

                                                                                                                                          func GetRootAsLargeList

                                                                                                                                          func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList

                                                                                                                                          func (*LargeList) Init

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

                                                                                                                                          func (*LargeList) Table

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

                                                                                                                                          type LargeUtf8

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

                                                                                                                                            / Same as Utf8, but with 64-bit offsets, allowing to represent / extremely large data values.

                                                                                                                                            func GetRootAsLargeUtf8

                                                                                                                                            func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8

                                                                                                                                            func (*LargeUtf8) Init

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

                                                                                                                                            func (*LargeUtf8) Table

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

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

                                                                                                                                              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() MessageHeader

                                                                                                                                                  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 MessageHeader) 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
                                                                                                                                                    )

                                                                                                                                                    func (MessageHeader) String

                                                                                                                                                    func (v MessageHeader) String() string

                                                                                                                                                    type MetadataVersion

                                                                                                                                                    type MetadataVersion int16
                                                                                                                                                    const (
                                                                                                                                                    	/// 0.1.0 (October 2016).
                                                                                                                                                    	MetadataVersionV1 MetadataVersion = 0
                                                                                                                                                    	/// 0.2.0 (February 2017). Non-backwards compatible with V1.
                                                                                                                                                    	MetadataVersionV2 MetadataVersion = 1
                                                                                                                                                    	/// 0.3.0 -> 0.7.1 (May - December 2017). Non-backwards compatible with V2.
                                                                                                                                                    	MetadataVersionV3 MetadataVersion = 2
                                                                                                                                                    	/// >= 0.8.0 (December 2017). Non-backwards compatible with V3.
                                                                                                                                                    	MetadataVersionV4 MetadataVersion = 3
                                                                                                                                                    	/// >= 1.0.0 (July 2020. Backwards compatible with V4 (V5 readers can read V4
                                                                                                                                                    	/// metadata and IPC messages). Implementations are recommended to provide a
                                                                                                                                                    	/// V4 compatibility mode with V5 format changes disabled.
                                                                                                                                                    	///
                                                                                                                                                    	/// Incompatible changes between V4 and V5:
                                                                                                                                                    	/// - Union buffer layout has changed. In V5, Unions don't have a validity
                                                                                                                                                    	///   bitmap buffer.
                                                                                                                                                    	MetadataVersionV5 MetadataVersion = 4
                                                                                                                                                    )

                                                                                                                                                    func (MetadataVersion) String

                                                                                                                                                    func (v MetadataVersion) String() string

                                                                                                                                                    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
                                                                                                                                                      )

                                                                                                                                                      func (Precision) String

                                                                                                                                                      func (v Precision) String() string

                                                                                                                                                      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) Compression

                                                                                                                                                          func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression

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

                                                                                                                                                                      func (rcv *Schema) Features(j int) Feature

                                                                                                                                                                        / Features used in the stream/file.

                                                                                                                                                                        func (*Schema) FeaturesLength

                                                                                                                                                                        func (rcv *Schema) FeaturesLength() int

                                                                                                                                                                        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) MutateFeatures

                                                                                                                                                                          func (rcv *Schema) MutateFeatures(j int, n Feature) bool

                                                                                                                                                                            / Features used in the stream/file.

                                                                                                                                                                            func (*Schema) Table

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

                                                                                                                                                                            type SparseMatrixCompressedAxis

                                                                                                                                                                            type SparseMatrixCompressedAxis int16
                                                                                                                                                                            const (
                                                                                                                                                                            	SparseMatrixCompressedAxisRow    SparseMatrixCompressedAxis = 0
                                                                                                                                                                            	SparseMatrixCompressedAxisColumn SparseMatrixCompressedAxis = 1
                                                                                                                                                                            )

                                                                                                                                                                            func (SparseMatrixCompressedAxis) String

                                                                                                                                                                            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 SparseMatrixIndexCSX

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

                                                                                                                                                                                        / Compressed Sparse format, that is matrix-specific.

                                                                                                                                                                                        func GetRootAsSparseMatrixIndexCSX

                                                                                                                                                                                        func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX

                                                                                                                                                                                        func (*SparseMatrixIndexCSX) CompressedAxis

                                                                                                                                                                                        func (rcv *SparseMatrixIndexCSX) CompressedAxis() SparseMatrixCompressedAxis

                                                                                                                                                                                          / Which axis, row or column, is compressed

                                                                                                                                                                                          func (*SparseMatrixIndexCSX) IndicesBuffer

                                                                                                                                                                                          func (rcv *SparseMatrixIndexCSX) 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: / “`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 (*SparseMatrixIndexCSX) IndicesType

                                                                                                                                                                                            func (rcv *SparseMatrixIndexCSX) 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: / “`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 (*SparseMatrixIndexCSX) IndptrBuffer

                                                                                                                                                                                              func (rcv *SparseMatrixIndexCSX) 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: / “`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 (*SparseMatrixIndexCSX) IndptrType

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

                                                                                                                                                                                                  / The type of values in indptrBuffer

                                                                                                                                                                                                  func (*SparseMatrixIndexCSX) Init

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

                                                                                                                                                                                                  func (*SparseMatrixIndexCSX) MutateCompressedAxis

                                                                                                                                                                                                  func (rcv *SparseMatrixIndexCSX) MutateCompressedAxis(n SparseMatrixCompressedAxis) bool

                                                                                                                                                                                                    / Which axis, row or column, is compressed

                                                                                                                                                                                                    func (*SparseMatrixIndexCSX) Table

                                                                                                                                                                                                    func (rcv *SparseMatrixIndexCSX) 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 SparseTensorIndex) bool

                                                                                                                                                                                                        func (*SparseTensor) MutateTypeType

                                                                                                                                                                                                        func (rcv *SparseTensor) MutateTypeType(n Type) 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() SparseTensorIndex

                                                                                                                                                                                                              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() Type

                                                                                                                                                                                                                type SparseTensorIndex

                                                                                                                                                                                                                type SparseTensorIndex byte
                                                                                                                                                                                                                const (
                                                                                                                                                                                                                	SparseTensorIndexNONE                 SparseTensorIndex = 0
                                                                                                                                                                                                                	SparseTensorIndexSparseTensorIndexCOO SparseTensorIndex = 1
                                                                                                                                                                                                                	SparseTensorIndexSparseMatrixIndexCSX SparseTensorIndex = 2
                                                                                                                                                                                                                	SparseTensorIndexSparseTensorIndexCSF SparseTensorIndex = 3
                                                                                                                                                                                                                )

                                                                                                                                                                                                                func (SparseTensorIndex) String

                                                                                                                                                                                                                func (v SparseTensorIndex) String() string

                                                                                                                                                                                                                type SparseTensorIndexCOO

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

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

                                                                                                                                                                                                                  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 / If omitted, default to row-major order (C-like).

                                                                                                                                                                                                                      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) IsCanonical

                                                                                                                                                                                                                        func (rcv *SparseTensorIndexCOO) IsCanonical() bool

                                                                                                                                                                                                                          / 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 (*SparseTensorIndexCOO) MutateIndicesStrides

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

                                                                                                                                                                                                                            / Non-negative byte offsets to advance one value cell along each dimension / If omitted, default to row-major order (C-like).

                                                                                                                                                                                                                            func (*SparseTensorIndexCOO) MutateIsCanonical

                                                                                                                                                                                                                            func (rcv *SparseTensorIndexCOO) MutateIsCanonical(n bool) bool

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

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

                                                                                                                                                                                                                              type SparseTensorIndexCSF

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

                                                                                                                                                                                                                                / Compressed Sparse Fiber (CSF) sparse tensor index.

                                                                                                                                                                                                                                func GetRootAsSparseTensorIndexCSF

                                                                                                                                                                                                                                func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF

                                                                                                                                                                                                                                func (*SparseTensorIndexCSF) AxisOrder

                                                                                                                                                                                                                                func (rcv *SparseTensorIndexCSF) AxisOrder(j int) int32

                                                                                                                                                                                                                                  / 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 (*SparseTensorIndexCSF) AxisOrderLength

                                                                                                                                                                                                                                  func (rcv *SparseTensorIndexCSF) AxisOrderLength() int

                                                                                                                                                                                                                                  func (*SparseTensorIndexCSF) IndicesBuffers

                                                                                                                                                                                                                                  func (rcv *SparseTensorIndexCSF) IndicesBuffers(obj *Buffer, j int) bool

                                                                                                                                                                                                                                    / 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 (*SparseTensorIndexCSF) IndicesBuffersLength

                                                                                                                                                                                                                                    func (rcv *SparseTensorIndexCSF) IndicesBuffersLength() int

                                                                                                                                                                                                                                    func (*SparseTensorIndexCSF) IndicesType

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

                                                                                                                                                                                                                                      / 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 (*SparseTensorIndexCSF) IndptrBuffers

                                                                                                                                                                                                                                      func (rcv *SparseTensorIndexCSF) IndptrBuffers(obj *Buffer, j int) bool

                                                                                                                                                                                                                                        / 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 (*SparseTensorIndexCSF) IndptrBuffersLength

                                                                                                                                                                                                                                        func (rcv *SparseTensorIndexCSF) IndptrBuffersLength() int

                                                                                                                                                                                                                                        func (*SparseTensorIndexCSF) IndptrType

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

                                                                                                                                                                                                                                          / 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 (*SparseTensorIndexCSF) Init

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

                                                                                                                                                                                                                                          func (*SparseTensorIndexCSF) MutateAxisOrder

                                                                                                                                                                                                                                          func (rcv *SparseTensorIndexCSF) MutateAxisOrder(j int, n int32) bool

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

                                                                                                                                                                                                                                            func (rcv *SparseTensorIndexCSF) 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 / If omitted, default to row-major order (C-like).

                                                                                                                                                                                                                                                  func (*Tensor) MutateTypeType

                                                                                                                                                                                                                                                  func (rcv *Tensor) MutateTypeType(n Type) 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 / If omitted, default to row-major order (C-like).

                                                                                                                                                                                                                                                      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() Type

                                                                                                                                                                                                                                                        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
                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                  func (TimeUnit) String

                                                                                                                                                                                                                                                                  func (v TimeUnit) String() string

                                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                        func (Type) String

                                                                                                                                                                                                                                                                        func (v Type) String() string

                                                                                                                                                                                                                                                                        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
                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                          func (UnionMode) String

                                                                                                                                                                                                                                                                          func (v UnionMode) String() string

                                                                                                                                                                                                                                                                          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