Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

encoding

package

Go to main page

Versions in this module

v9

v9.1.3

Sep 28, 2022

v9.1.2

Sep 28, 2022

v9.1.1

Sep 28, 2022

v9.1.0

Sep 28, 2022

v9.0.5

Sep 28, 2022

v9.0.4

Sep 28, 2022

v9.0.3

Sep 28, 2022

v9.0.2

Sep 28, 2022

v9.0.1

Sep 28, 2022

Changes in this version

+ var BooleanDecoderTraits boolDecoderTraits

+ var BooleanEncoderTraits boolEncoderTraits

+ var ByteArrayDecoderTraits byteArrayDecoderTraits

+ var ByteArrayEncoderTraits byteArrayEncoderTraits

+ var FixedLenByteArrayDecoderTraits fixedLenByteArrayDecoderTraits

+ var FixedLenByteArrayEncoderTraits fixedLenByteArrayEncoderTraits

+ var Float32DecoderTraits float32DecoderTraits

+ var Float32EncoderTraits float32EncoderTraits

+ var Float64DecoderTraits float64DecoderTraits

+ var Float64EncoderTraits float64EncoderTraits

+ var Int32DecoderTraits int32DecoderTraits

+ var Int32EncoderTraits int32EncoderTraits

+ var Int64DecoderTraits int64DecoderTraits

+ var Int64EncoderTraits int64EncoderTraits

+ var Int96DecoderTraits int96DecoderTraits

+ var Int96EncoderTraits int96EncoderTraits

+ func LevelEncodingMaxBufferSize(encoding parquet.Encoding, maxLvl int16, nbuffered int) int

+ func NewDictConverter(dict TypedDecoder) utils.DictionaryConverter

+ type BinaryMemoTable interface

+ CopyFixedWidthValues func(start int, width int, out []byte)

+ CopyOffsets func(out []int32)

+ CopyOffsetsSubset func(start int, out []int32)

+ Release func()

+ Retain func()

+ ValuesSize func() int

+ VisitValues func(start int, visitFn func([]byte))

+ func NewBinaryDictionary(mem memory.Allocator) BinaryMemoTable

+ func NewBinaryMemoTable(mem memory.Allocator) BinaryMemoTable

+ type BooleanDecoder interface

+ Decode func([]bool) (int, error)

+ DecodeSpaced func([]bool, int, []byte, int64) (int, error)

+ type BooleanEncoder interface

+ Put func([]bool)

+ PutSpaced func([]bool, []byte, int64)

+ type Buffer interface

+ Buf func() []byte

+ Bytes func() []byte

+ Len func() int

+ Release func()

+ Resize func(int)

+ type BufferWriter struct

+ func NewBufferWriter(initial int, mem memory.Allocator) *BufferWriter

+ func NewBufferWriterFromBuffer(b *memory.Buffer, mem memory.Allocator) *BufferWriter

+ func (b *BufferWriter) Bytes() []byte

+ func (b *BufferWriter) Cap() int

+ func (b *BufferWriter) Finish() *memory.Buffer

+ func (b *BufferWriter) Len() int

+ func (b *BufferWriter) Reserve(nbytes int)

+ func (b *BufferWriter) Reset(initial int)

+ func (b *BufferWriter) Seek(offset int64, whence int) (int64, error)

+ func (b *BufferWriter) SetOffset(offset int)

+ func (b *BufferWriter) Tell() int64

+ func (b *BufferWriter) Truncate()

+ func (b *BufferWriter) UnsafeWrite(buf []byte) (int, error)

+ func (b *BufferWriter) UnsafeWriteCopy(ncopies int, pattern []byte) (int, error)

+ func (b *BufferWriter) Write(buf []byte) (int, error)

+ func (b *BufferWriter) WriteAt(p []byte, offset int64) (n int, err error)

+ type ByteArrayDecoder interface

+ Decode func([]parquet.ByteArray) (int, error)

+ DecodeSpaced func([]parquet.ByteArray, int, []byte, int64) (int, error)

+ type ByteArrayDictConverter struct

+ func (dc *ByteArrayDictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *ByteArrayDictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *ByteArrayDictConverter) FillZero(out interface{})

+ func (dc *ByteArrayDictConverter) IsValid(idxes ...utils.IndexType) bool

+ type ByteArrayEncoder interface

+ Put func([]parquet.ByteArray)

+ PutSpaced func([]parquet.ByteArray, []byte, int64)

+ type DecoderTraits interface

+ BytesRequired func(int) int

+ Decoder func(e parquet.Encoding, descr *schema.Column, useDict bool, mem memory.Allocator) TypedDecoder

+ type DeltaBitPackInt32Decoder struct

+ func (DeltaBitPackInt32Decoder) Type() parquet.Type

+ func (d *DeltaBitPackInt32Decoder) Decode(out []int32) (int, error)

+ func (d *DeltaBitPackInt32Decoder) DecodeSpaced(out []int32, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d DeltaBitPackInt32Decoder) Allocator() memory.Allocator

+ func (d DeltaBitPackInt32Decoder) SetData(nvalues int, data []byte) error

+ type DeltaBitPackInt32Encoder struct

+ func (DeltaBitPackInt32Encoder) Type() parquet.Type

+ func (enc DeltaBitPackInt32Encoder) EstimatedDataEncodedSize() int64

+ func (enc DeltaBitPackInt32Encoder) FlushValues() (Buffer, error)

+ func (enc DeltaBitPackInt32Encoder) Put(in []int32)

+ func (enc DeltaBitPackInt32Encoder) PutSpaced(in []int32, validBits []byte, validBitsOffset int64)

+ type DeltaBitPackInt64Decoder struct

+ func (DeltaBitPackInt64Decoder) Type() parquet.Type

+ func (d *DeltaBitPackInt64Decoder) Decode(out []int64) (int, error)

+ func (d DeltaBitPackInt64Decoder) Allocator() memory.Allocator

+ func (d DeltaBitPackInt64Decoder) DecodeSpaced(out []int64, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d DeltaBitPackInt64Decoder) SetData(nvalues int, data []byte) error

+ type DeltaBitPackInt64Encoder struct

+ func (DeltaBitPackInt64Encoder) Type() parquet.Type

+ func (enc DeltaBitPackInt64Encoder) EstimatedDataEncodedSize() int64

+ func (enc DeltaBitPackInt64Encoder) FlushValues() (Buffer, error)

+ func (enc DeltaBitPackInt64Encoder) Put(in []int64)

+ func (enc DeltaBitPackInt64Encoder) PutSpaced(in []int64, validBits []byte, validBitsOffset int64)

+ type DeltaByteArrayDecoder struct

+ func (DeltaByteArrayDecoder) Type() parquet.Type

+ func (d *DeltaByteArrayDecoder) Allocator() memory.Allocator

+ func (d *DeltaByteArrayDecoder) Decode(out []parquet.ByteArray) (int, error)

+ func (d *DeltaByteArrayDecoder) DecodeSpaced(out []parquet.ByteArray, nullCount int, validBits []byte, ...) (int, error)

+ func (d *DeltaByteArrayDecoder) SetData(nvalues int, data []byte) error

+ func (d DeltaByteArrayDecoder) Encoding() parquet.Encoding

+ func (d DeltaByteArrayDecoder) ValuesLeft() int

+ type DeltaByteArrayEncoder struct

+ func (DeltaByteArrayEncoder) Type() parquet.Type

+ func (e *DeltaByteArrayEncoder) Allocator() memory.Allocator

+ func (e *DeltaByteArrayEncoder) Bytes() []byte

+ func (e *DeltaByteArrayEncoder) Encoding() parquet.Encoding

+ func (e *DeltaByteArrayEncoder) ReserveForWrite(n int)

+ func (e *DeltaByteArrayEncoder) Reset()

+ func (enc *DeltaByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (enc *DeltaByteArrayEncoder) FlushValues() (Buffer, error)

+ func (enc *DeltaByteArrayEncoder) Put(in []parquet.ByteArray)

+ func (enc *DeltaByteArrayEncoder) PutSpaced(in []parquet.ByteArray, validBits []byte, validBitsOffset int64)

+ type DeltaLengthByteArrayDecoder struct

+ func (DeltaLengthByteArrayDecoder) Type() parquet.Type

+ func (d *DeltaLengthByteArrayDecoder) Allocator() memory.Allocator

+ func (d *DeltaLengthByteArrayDecoder) Decode(out []parquet.ByteArray) (int, error)

+ func (d *DeltaLengthByteArrayDecoder) DecodeSpaced(out []parquet.ByteArray, nullCount int, validBits []byte, ...) (int, error)

+ func (d *DeltaLengthByteArrayDecoder) Encoding() parquet.Encoding

+ func (d *DeltaLengthByteArrayDecoder) SetData(nvalues int, data []byte) error

+ func (d *DeltaLengthByteArrayDecoder) ValuesLeft() int

+ type DeltaLengthByteArrayEncoder struct

+ func (DeltaLengthByteArrayEncoder) Type() parquet.Type

+ func (e *DeltaLengthByteArrayEncoder) Allocator() memory.Allocator

+ func (e *DeltaLengthByteArrayEncoder) Bytes() []byte

+ func (e *DeltaLengthByteArrayEncoder) Encoding() parquet.Encoding

+ func (e *DeltaLengthByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (e *DeltaLengthByteArrayEncoder) ReserveForWrite(n int)

+ func (e *DeltaLengthByteArrayEncoder) Reset()

+ func (enc *DeltaLengthByteArrayEncoder) FlushValues() (Buffer, error)

+ func (enc *DeltaLengthByteArrayEncoder) Put(in []parquet.ByteArray)

+ func (enc *DeltaLengthByteArrayEncoder) PutSpaced(in []parquet.ByteArray, validBits []byte, validBitsOffset int64)

+ type DictByteArrayDecoder struct

+ func (DictByteArrayDecoder) Type() parquet.Type

+ func (d *DictByteArrayDecoder) Decode(out []parquet.ByteArray) (int, error)

+ func (d *DictByteArrayDecoder) DecodeSpaced(out []parquet.ByteArray, nullCount int, validBits []byte, ...) (int, error)

+ func (d *DictByteArrayDecoder) SetData(nvals int, data []byte) error

+ func (d *DictByteArrayDecoder) SetDict(dict TypedDecoder)

+ type DictByteArrayEncoder struct

+ func (d *DictByteArrayEncoder) BitWidth() int

+ func (d *DictByteArrayEncoder) DictEncodedSize() int

+ func (d *DictByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (d *DictByteArrayEncoder) FlushValues() (Buffer, error)

+ func (d *DictByteArrayEncoder) NumEntries() int

+ func (d *DictByteArrayEncoder) Reset()

+ func (d *DictByteArrayEncoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictByteArrayEncoder) Put(in []parquet.ByteArray)

+ func (enc *DictByteArrayEncoder) PutByteArray(in parquet.ByteArray)

+ func (enc *DictByteArrayEncoder) PutSpaced(in []parquet.ByteArray, validBits []byte, validBitsOffset int64)

+ func (enc *DictByteArrayEncoder) Type() parquet.Type

+ func (enc *DictByteArrayEncoder) WriteDict(out []byte)

+ type DictDecoder interface

+ SetDict func(TypedDecoder)

+ func NewDictDecoder(t parquet.Type, descr *schema.Column, mem memory.Allocator) DictDecoder

+ type DictEncoder interface

+ BitWidth func() int

+ DictEncodedSize func() int

+ NumEntries func() int

+ WriteDict func(out []byte)

+ WriteIndices func(out []byte) (int, error)

+ type DictFixedLenByteArrayDecoder struct

+ func (DictFixedLenByteArrayDecoder) Type() parquet.Type

+ func (d *DictFixedLenByteArrayDecoder) Decode(out []parquet.FixedLenByteArray) (int, error)

+ func (d *DictFixedLenByteArrayDecoder) DecodeSpaced(out []parquet.FixedLenByteArray, nullCount int, validBits []byte, ...) (int, error)

+ func (d *DictFixedLenByteArrayDecoder) SetData(nvals int, data []byte) error

+ func (d *DictFixedLenByteArrayDecoder) SetDict(dict TypedDecoder)

+ type DictFixedLenByteArrayEncoder struct

+ func (d *DictFixedLenByteArrayEncoder) BitWidth() int

+ func (d *DictFixedLenByteArrayEncoder) DictEncodedSize() int

+ func (d *DictFixedLenByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (d *DictFixedLenByteArrayEncoder) FlushValues() (Buffer, error)

+ func (d *DictFixedLenByteArrayEncoder) NumEntries() int

+ func (d *DictFixedLenByteArrayEncoder) Reset()

+ func (d *DictFixedLenByteArrayEncoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictFixedLenByteArrayEncoder) Put(in []parquet.FixedLenByteArray)

+ func (enc *DictFixedLenByteArrayEncoder) PutSpaced(in []parquet.FixedLenByteArray, validBits []byte, validBitsOffset int64)

+ func (enc *DictFixedLenByteArrayEncoder) Type() parquet.Type

+ func (enc *DictFixedLenByteArrayEncoder) WriteDict(out []byte)

+ type DictFloat32Decoder struct

+ func (DictFloat32Decoder) Type() parquet.Type

+ func (d *DictFloat32Decoder) Decode(out []float32) (int, error)

+ func (d *DictFloat32Decoder) DecodeSpaced(out []float32, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d *DictFloat32Decoder) SetData(nvals int, data []byte) error

+ func (d *DictFloat32Decoder) SetDict(dict TypedDecoder)

+ type DictFloat32Encoder struct

+ func (d *DictFloat32Encoder) BitWidth() int

+ func (d *DictFloat32Encoder) DictEncodedSize() int

+ func (d *DictFloat32Encoder) EstimatedDataEncodedSize() int64

+ func (d *DictFloat32Encoder) FlushValues() (Buffer, error)

+ func (d *DictFloat32Encoder) NumEntries() int

+ func (d *DictFloat32Encoder) Reset()

+ func (d *DictFloat32Encoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictFloat32Encoder) Put(in []float32)

+ func (enc *DictFloat32Encoder) PutSpaced(in []float32, validBits []byte, validBitsOffset int64)

+ func (enc *DictFloat32Encoder) Type() parquet.Type

+ func (enc *DictFloat32Encoder) WriteDict(out []byte)

+ type DictFloat64Decoder struct

+ func (DictFloat64Decoder) Type() parquet.Type

+ func (d *DictFloat64Decoder) Decode(out []float64) (int, error)

+ func (d *DictFloat64Decoder) DecodeSpaced(out []float64, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d *DictFloat64Decoder) SetData(nvals int, data []byte) error

+ func (d *DictFloat64Decoder) SetDict(dict TypedDecoder)

+ type DictFloat64Encoder struct

+ func (d *DictFloat64Encoder) BitWidth() int

+ func (d *DictFloat64Encoder) DictEncodedSize() int

+ func (d *DictFloat64Encoder) EstimatedDataEncodedSize() int64

+ func (d *DictFloat64Encoder) FlushValues() (Buffer, error)

+ func (d *DictFloat64Encoder) NumEntries() int

+ func (d *DictFloat64Encoder) Reset()

+ func (d *DictFloat64Encoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictFloat64Encoder) Put(in []float64)

+ func (enc *DictFloat64Encoder) PutSpaced(in []float64, validBits []byte, validBitsOffset int64)

+ func (enc *DictFloat64Encoder) Type() parquet.Type

+ func (enc *DictFloat64Encoder) WriteDict(out []byte)

+ type DictInt32Decoder struct

+ func (DictInt32Decoder) Type() parquet.Type

+ func (d *DictInt32Decoder) Decode(out []int32) (int, error)

+ func (d *DictInt32Decoder) DecodeSpaced(out []int32, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d *DictInt32Decoder) SetData(nvals int, data []byte) error

+ func (d *DictInt32Decoder) SetDict(dict TypedDecoder)

+ type DictInt32Encoder struct

+ func (d *DictInt32Encoder) BitWidth() int

+ func (d *DictInt32Encoder) DictEncodedSize() int

+ func (d *DictInt32Encoder) EstimatedDataEncodedSize() int64

+ func (d *DictInt32Encoder) FlushValues() (Buffer, error)

+ func (d *DictInt32Encoder) NumEntries() int

+ func (d *DictInt32Encoder) Reset()

+ func (d *DictInt32Encoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictInt32Encoder) Put(in []int32)

+ func (enc *DictInt32Encoder) PutSpaced(in []int32, validBits []byte, validBitsOffset int64)

+ func (enc *DictInt32Encoder) Type() parquet.Type

+ func (enc *DictInt32Encoder) WriteDict(out []byte)

+ type DictInt64Decoder struct

+ func (DictInt64Decoder) Type() parquet.Type

+ func (d *DictInt64Decoder) Decode(out []int64) (int, error)

+ func (d *DictInt64Decoder) DecodeSpaced(out []int64, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d *DictInt64Decoder) SetData(nvals int, data []byte) error

+ func (d *DictInt64Decoder) SetDict(dict TypedDecoder)

+ type DictInt64Encoder struct

+ func (d *DictInt64Encoder) BitWidth() int

+ func (d *DictInt64Encoder) DictEncodedSize() int

+ func (d *DictInt64Encoder) EstimatedDataEncodedSize() int64

+ func (d *DictInt64Encoder) FlushValues() (Buffer, error)

+ func (d *DictInt64Encoder) NumEntries() int

+ func (d *DictInt64Encoder) Reset()

+ func (d *DictInt64Encoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictInt64Encoder) Put(in []int64)

+ func (enc *DictInt64Encoder) PutSpaced(in []int64, validBits []byte, validBitsOffset int64)

+ func (enc *DictInt64Encoder) Type() parquet.Type

+ func (enc *DictInt64Encoder) WriteDict(out []byte)

+ type DictInt96Decoder struct

+ func (DictInt96Decoder) Type() parquet.Type

+ func (d *DictInt96Decoder) Decode(out []parquet.Int96) (int, error)

+ func (d *DictInt96Decoder) DecodeSpaced(out []parquet.Int96, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (d *DictInt96Decoder) SetData(nvals int, data []byte) error

+ func (d *DictInt96Decoder) SetDict(dict TypedDecoder)

+ type DictInt96Encoder struct

+ func (d *DictInt96Encoder) BitWidth() int

+ func (d *DictInt96Encoder) DictEncodedSize() int

+ func (d *DictInt96Encoder) EstimatedDataEncodedSize() int64

+ func (d *DictInt96Encoder) FlushValues() (Buffer, error)

+ func (d *DictInt96Encoder) NumEntries() int

+ func (d *DictInt96Encoder) Reset()

+ func (d *DictInt96Encoder) WriteIndices(out []byte) (int, error)

+ func (enc *DictInt96Encoder) Put(in []parquet.Int96)

+ func (enc *DictInt96Encoder) PutSpaced(in []parquet.Int96, validBits []byte, validBitsOffset int64)

+ func (enc *DictInt96Encoder) Type() parquet.Type

+ func (enc *DictInt96Encoder) WriteDict(out []byte)

+ type EncoderTraits interface

+ Encoder func(format.Encoding, bool, *schema.Column, memory.Allocator) TypedEncoder

+ type FixedLenByteArrayDecoder interface

+ Decode func([]parquet.FixedLenByteArray) (int, error)

+ DecodeSpaced func([]parquet.FixedLenByteArray, int, []byte, int64) (int, error)

+ type FixedLenByteArrayDictConverter struct

+ func (dc *FixedLenByteArrayDictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *FixedLenByteArrayDictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *FixedLenByteArrayDictConverter) FillZero(out interface{})

+ func (dc *FixedLenByteArrayDictConverter) IsValid(idxes ...utils.IndexType) bool

+ type FixedLenByteArrayEncoder interface

+ Put func([]parquet.FixedLenByteArray)

+ PutSpaced func([]parquet.FixedLenByteArray, []byte, int64)

+ type Float32Decoder interface

+ Decode func([]float32) (int, error)

+ DecodeSpaced func([]float32, int, []byte, int64) (int, error)

+ type Float32DictConverter struct

+ func (dc *Float32DictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *Float32DictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *Float32DictConverter) FillZero(out interface{})

+ func (dc *Float32DictConverter) IsValid(idxes ...utils.IndexType) bool

+ type Float32Encoder interface

+ Put func([]float32)

+ PutSpaced func([]float32, []byte, int64)

+ type Float64Decoder interface

+ Decode func([]float64) (int, error)

+ DecodeSpaced func([]float64, int, []byte, int64) (int, error)

+ type Float64DictConverter struct

+ func (dc *Float64DictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *Float64DictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *Float64DictConverter) FillZero(out interface{})

+ func (dc *Float64DictConverter) IsValid(idxes ...utils.IndexType) bool

+ type Float64Encoder interface

+ Put func([]float64)

+ PutSpaced func([]float64, []byte, int64)

+ type Int32Decoder interface

+ Decode func([]int32) (int, error)

+ DecodeSpaced func([]int32, int, []byte, int64) (int, error)

+ type Int32DictConverter struct

+ func (dc *Int32DictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *Int32DictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *Int32DictConverter) FillZero(out interface{})

+ func (dc *Int32DictConverter) IsValid(idxes ...utils.IndexType) bool

+ type Int32Encoder interface

+ Put func([]int32)

+ PutSpaced func([]int32, []byte, int64)

+ type Int64Decoder interface

+ Decode func([]int64) (int, error)

+ DecodeSpaced func([]int64, int, []byte, int64) (int, error)

+ type Int64DictConverter struct

+ func (dc *Int64DictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *Int64DictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *Int64DictConverter) FillZero(out interface{})

+ func (dc *Int64DictConverter) IsValid(idxes ...utils.IndexType) bool

+ type Int64Encoder interface

+ Put func([]int64)

+ PutSpaced func([]int64, []byte, int64)

+ type Int96Decoder interface

+ Decode func([]parquet.Int96) (int, error)

+ DecodeSpaced func([]parquet.Int96, int, []byte, int64) (int, error)

+ type Int96DictConverter struct

+ func (dc *Int96DictConverter) Copy(out interface{}, vals []utils.IndexType) error

+ func (dc *Int96DictConverter) Fill(out interface{}, val utils.IndexType) error

+ func (dc *Int96DictConverter) FillZero(out interface{})

+ func (dc *Int96DictConverter) IsValid(idxes ...utils.IndexType) bool

+ type Int96Encoder interface

+ Put func([]parquet.Int96)

+ PutSpaced func([]parquet.Int96, []byte, int64)

+ type LevelDecoder struct

+ func (l *LevelDecoder) Decode(levels []int16) (int, int64)

+ func (l *LevelDecoder) SetData(encoding parquet.Encoding, maxLvl int16, nbuffered int, data []byte) (int, error)

+ func (l *LevelDecoder) SetDataV2(nbytes int32, maxLvl int16, nbuffered int, data []byte) error

+ type LevelEncoder struct

+ func (l *LevelEncoder) Encode(lvls []int16) (nencoded int, err error)

+ func (l *LevelEncoder) EncodeNoFlush(lvls []int16) (nencoded int, err error)

+ func (l *LevelEncoder) Flush()

+ func (l *LevelEncoder) Init(encoding parquet.Encoding, maxLvl int16, w io.WriterAt)

+ func (l *LevelEncoder) Len() int

+ func (l *LevelEncoder) Reset(maxLvl int16)

+ type MemoTable interface

+ CopyValues func(out interface{})

+ CopyValuesSubset func(start int, out interface{})

+ Get func(val interface{}) (int, bool)

+ GetNull func() (int, bool)

+ GetOrInsert func(val interface{}) (idx int, existed bool, err error)

+ GetOrInsertNull func() (idx int, existed bool)

+ Reset func()

+ Size func() int

+ WriteOut func(out []byte)

+ WriteOutSubset func(start int, out []byte)

+ func NewFloat32Dictionary() MemoTable

+ func NewFloat32MemoTable(memory.Allocator) MemoTable

+ func NewFloat64Dictionary() MemoTable

+ func NewFloat64MemoTable(memory.Allocator) MemoTable

+ func NewInt32Dictionary() MemoTable

+ func NewInt32MemoTable(memory.Allocator) MemoTable

+ func NewInt64Dictionary() MemoTable

+ func NewInt64MemoTable(memory.Allocator) MemoTable

+ func NewInt96MemoTable(memory.Allocator) MemoTable

+ type NumericMemoTable interface

+ WriteOutLE func(out []byte)

+ WriteOutSubsetLE func(start int, out []byte)

+ type PlainBooleanDecoder struct

+ func (PlainBooleanDecoder) Type() parquet.Type

+ func (d *PlainBooleanDecoder) Encoding() parquet.Encoding

+ func (d *PlainBooleanDecoder) ValuesLeft() int

+ func (dec *PlainBooleanDecoder) Decode(out []bool) (int, error)

+ func (dec *PlainBooleanDecoder) DecodeSpaced(out []bool, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ func (dec *PlainBooleanDecoder) SetData(nvals int, data []byte) error

+ type PlainBooleanEncoder struct

+ func (PlainBooleanEncoder) Type() parquet.Type

+ func (e *PlainBooleanEncoder) Allocator() memory.Allocator

+ func (e *PlainBooleanEncoder) Bytes() []byte

+ func (e *PlainBooleanEncoder) Encoding() parquet.Encoding

+ func (e *PlainBooleanEncoder) ReserveForWrite(n int)

+ func (e *PlainBooleanEncoder) Reset()

+ func (enc *PlainBooleanEncoder) EstimatedDataEncodedSize() int64

+ func (enc *PlainBooleanEncoder) FlushValues() (Buffer, error)

+ func (enc *PlainBooleanEncoder) Put(in []bool)

+ func (enc *PlainBooleanEncoder) PutSpaced(in []bool, validBits []byte, validBitsOffset int64)

+ type PlainByteArrayDecoder struct

+ func (PlainByteArrayDecoder) Type() parquet.Type

+ func (d *PlainByteArrayDecoder) Encoding() parquet.Encoding

+ func (d *PlainByteArrayDecoder) SetData(nvals int, data []byte) error

+ func (d *PlainByteArrayDecoder) ValuesLeft() int

+ func (pbad *PlainByteArrayDecoder) Decode(out []parquet.ByteArray) (int, error)

+ func (pbad *PlainByteArrayDecoder) DecodeSpaced(out []parquet.ByteArray, nullCount int, validBits []byte, ...) (int, error)

+ type PlainByteArrayEncoder struct

+ func (PlainByteArrayEncoder) Type() parquet.Type

+ func (e *PlainByteArrayEncoder) Allocator() memory.Allocator

+ func (e *PlainByteArrayEncoder) Bytes() []byte

+ func (e *PlainByteArrayEncoder) Encoding() parquet.Encoding

+ func (e *PlainByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (e *PlainByteArrayEncoder) FlushValues() (Buffer, error)

+ func (e *PlainByteArrayEncoder) ReserveForWrite(n int)

+ func (e *PlainByteArrayEncoder) Reset()

+ func (enc *PlainByteArrayEncoder) Put(in []parquet.ByteArray)

+ func (enc *PlainByteArrayEncoder) PutByteArray(val parquet.ByteArray)

+ func (enc *PlainByteArrayEncoder) PutSpaced(in []parquet.ByteArray, validBits []byte, validBitsOffset int64)

+ type PlainFixedLenByteArrayDecoder struct

+ func (PlainFixedLenByteArrayDecoder) Type() parquet.Type

+ func (d *PlainFixedLenByteArrayDecoder) Encoding() parquet.Encoding

+ func (d *PlainFixedLenByteArrayDecoder) SetData(nvals int, data []byte) error

+ func (d *PlainFixedLenByteArrayDecoder) ValuesLeft() int

+ func (pflba *PlainFixedLenByteArrayDecoder) Decode(out []parquet.FixedLenByteArray) (int, error)

+ func (pflba *PlainFixedLenByteArrayDecoder) DecodeSpaced(out []parquet.FixedLenByteArray, nullCount int, validBits []byte, ...) (int, error)

+ type PlainFixedLenByteArrayEncoder struct

+ func (PlainFixedLenByteArrayEncoder) Type() parquet.Type

+ func (e *PlainFixedLenByteArrayEncoder) Allocator() memory.Allocator

+ func (e *PlainFixedLenByteArrayEncoder) Bytes() []byte

+ func (e *PlainFixedLenByteArrayEncoder) Encoding() parquet.Encoding

+ func (e *PlainFixedLenByteArrayEncoder) EstimatedDataEncodedSize() int64

+ func (e *PlainFixedLenByteArrayEncoder) FlushValues() (Buffer, error)

+ func (e *PlainFixedLenByteArrayEncoder) ReserveForWrite(n int)

+ func (e *PlainFixedLenByteArrayEncoder) Reset()

+ func (enc *PlainFixedLenByteArrayEncoder) Put(in []parquet.FixedLenByteArray)

+ func (enc *PlainFixedLenByteArrayEncoder) PutSpaced(in []parquet.FixedLenByteArray, validBits []byte, validBitsOffset int64)

+ type PlainFloat32Decoder struct

+ func (PlainFloat32Decoder) Type() parquet.Type

+ func (d *PlainFloat32Decoder) Encoding() parquet.Encoding

+ func (d *PlainFloat32Decoder) SetData(nvals int, data []byte) error

+ func (d *PlainFloat32Decoder) ValuesLeft() int

+ func (dec *PlainFloat32Decoder) Decode(out []float32) (int, error)

+ func (dec *PlainFloat32Decoder) DecodeSpaced(out []float32, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ type PlainFloat32Encoder struct

+ func (PlainFloat32Encoder) Type() parquet.Type

+ func (e *PlainFloat32Encoder) Allocator() memory.Allocator

+ func (e *PlainFloat32Encoder) Bytes() []byte

+ func (e *PlainFloat32Encoder) Encoding() parquet.Encoding

+ func (e *PlainFloat32Encoder) EstimatedDataEncodedSize() int64

+ func (e *PlainFloat32Encoder) FlushValues() (Buffer, error)

+ func (e *PlainFloat32Encoder) ReserveForWrite(n int)

+ func (e *PlainFloat32Encoder) Reset()

+ func (enc *PlainFloat32Encoder) Put(in []float32)

+ func (enc *PlainFloat32Encoder) PutSpaced(in []float32, validBits []byte, validBitsOffset int64)

+ type PlainFloat64Decoder struct

+ func (PlainFloat64Decoder) Type() parquet.Type

+ func (d *PlainFloat64Decoder) Encoding() parquet.Encoding

+ func (d *PlainFloat64Decoder) SetData(nvals int, data []byte) error

+ func (d *PlainFloat64Decoder) ValuesLeft() int

+ func (dec *PlainFloat64Decoder) Decode(out []float64) (int, error)

+ func (dec *PlainFloat64Decoder) DecodeSpaced(out []float64, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ type PlainFloat64Encoder struct

+ func (PlainFloat64Encoder) Type() parquet.Type

+ func (e *PlainFloat64Encoder) Allocator() memory.Allocator

+ func (e *PlainFloat64Encoder) Bytes() []byte

+ func (e *PlainFloat64Encoder) Encoding() parquet.Encoding

+ func (e *PlainFloat64Encoder) EstimatedDataEncodedSize() int64

+ func (e *PlainFloat64Encoder) FlushValues() (Buffer, error)

+ func (e *PlainFloat64Encoder) ReserveForWrite(n int)

+ func (e *PlainFloat64Encoder) Reset()

+ func (enc *PlainFloat64Encoder) Put(in []float64)

+ func (enc *PlainFloat64Encoder) PutSpaced(in []float64, validBits []byte, validBitsOffset int64)

+ type PlainInt32Decoder struct

+ func (PlainInt32Decoder) Type() parquet.Type

+ func (d *PlainInt32Decoder) Encoding() parquet.Encoding

+ func (d *PlainInt32Decoder) SetData(nvals int, data []byte) error

+ func (d *PlainInt32Decoder) ValuesLeft() int

+ func (dec *PlainInt32Decoder) Decode(out []int32) (int, error)

+ func (dec *PlainInt32Decoder) DecodeSpaced(out []int32, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ type PlainInt32Encoder struct

+ func (PlainInt32Encoder) Type() parquet.Type

+ func (e *PlainInt32Encoder) Allocator() memory.Allocator

+ func (e *PlainInt32Encoder) Bytes() []byte

+ func (e *PlainInt32Encoder) Encoding() parquet.Encoding

+ func (e *PlainInt32Encoder) EstimatedDataEncodedSize() int64

+ func (e *PlainInt32Encoder) FlushValues() (Buffer, error)

+ func (e *PlainInt32Encoder) ReserveForWrite(n int)

+ func (e *PlainInt32Encoder) Reset()

+ func (enc *PlainInt32Encoder) Put(in []int32)

+ func (enc *PlainInt32Encoder) PutSpaced(in []int32, validBits []byte, validBitsOffset int64)

+ type PlainInt64Decoder struct

+ func (PlainInt64Decoder) Type() parquet.Type

+ func (d *PlainInt64Decoder) Encoding() parquet.Encoding

+ func (d *PlainInt64Decoder) SetData(nvals int, data []byte) error

+ func (d *PlainInt64Decoder) ValuesLeft() int

+ func (dec *PlainInt64Decoder) Decode(out []int64) (int, error)

+ func (dec *PlainInt64Decoder) DecodeSpaced(out []int64, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ type PlainInt64Encoder struct

+ func (PlainInt64Encoder) Type() parquet.Type

+ func (e *PlainInt64Encoder) Allocator() memory.Allocator

+ func (e *PlainInt64Encoder) Bytes() []byte

+ func (e *PlainInt64Encoder) Encoding() parquet.Encoding

+ func (e *PlainInt64Encoder) EstimatedDataEncodedSize() int64

+ func (e *PlainInt64Encoder) FlushValues() (Buffer, error)

+ func (e *PlainInt64Encoder) ReserveForWrite(n int)

+ func (e *PlainInt64Encoder) Reset()

+ func (enc *PlainInt64Encoder) Put(in []int64)

+ func (enc *PlainInt64Encoder) PutSpaced(in []int64, validBits []byte, validBitsOffset int64)

+ type PlainInt96Decoder struct

+ func (PlainInt96Decoder) Type() parquet.Type

+ func (d *PlainInt96Decoder) Encoding() parquet.Encoding

+ func (d *PlainInt96Decoder) SetData(nvals int, data []byte) error

+ func (d *PlainInt96Decoder) ValuesLeft() int

+ func (dec *PlainInt96Decoder) Decode(out []parquet.Int96) (int, error)

+ func (dec *PlainInt96Decoder) DecodeSpaced(out []parquet.Int96, nullCount int, validBits []byte, validBitsOffset int64) (int, error)

+ type PlainInt96Encoder struct

+ func (PlainInt96Encoder) Type() parquet.Type

+ func (e *PlainInt96Encoder) Allocator() memory.Allocator

+ func (e *PlainInt96Encoder) Bytes() []byte

+ func (e *PlainInt96Encoder) Encoding() parquet.Encoding

+ func (e *PlainInt96Encoder) EstimatedDataEncodedSize() int64

+ func (e *PlainInt96Encoder) FlushValues() (Buffer, error)

+ func (e *PlainInt96Encoder) ReserveForWrite(n int)

+ func (e *PlainInt96Encoder) Reset()

+ func (enc *PlainInt96Encoder) Put(in []parquet.Int96)

+ func (enc *PlainInt96Encoder) PutSpaced(in []parquet.Int96, validBits []byte, validBitsOffset int64)

+ type PooledBufferWriter struct

+ func NewPooledBufferWriter(initial int) *PooledBufferWriter

+ func (b *PooledBufferWriter) Bytes() []byte

+ func (b *PooledBufferWriter) Finish() Buffer

+ func (b *PooledBufferWriter) Len() int

+ func (b *PooledBufferWriter) Reserve(nbytes int)

+ func (b *PooledBufferWriter) Reset(initial int)

+ func (b *PooledBufferWriter) SetOffset(offset int)

+ func (b *PooledBufferWriter) Tell() int64

+ func (b *PooledBufferWriter) UnsafeWrite(buf []byte) (n int, err error)

+ func (b *PooledBufferWriter) UnsafeWriteCopy(ncopies int, pattern []byte) (int, error)

+ func (b *PooledBufferWriter) Write(buf []byte) (int, error)

+ func (b *PooledBufferWriter) WriteAt(p []byte, offset int64) (n int, err error)

+ type TypedDecoder interface

+ Encoding func() parquet.Encoding

+ SetData func(buffered int, buf []byte) error

+ Type func() parquet.Type

+ ValuesLeft func() int

+ func NewDecoder(t parquet.Type, e parquet.Encoding, descr *schema.Column, mem memory.Allocator) TypedDecoder

+ type TypedEncoder interface

+ Allocator func() memory.Allocator

+ Bytes func() []byte

+ Encoding func() parquet.Encoding

+ EstimatedDataEncodedSize func() int64

+ FlushValues func() (Buffer, error)

+ ReserveForWrite func(n int)

+ Reset func()

+ Type func() parquet.Type

+ func NewEncoder(t parquet.Type, e parquet.Encoding, useDict bool, descr *schema.Column, ...) TypedEncoder