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