parquet-go: github.com/xitongsys/parquet-go/marshal Index | Files

package marshal

import "github.com/xitongsys/parquet-go/marshal"

Index

Package Files

csv.go json.go marshal.go unmarshal.go

func Marshal Uses

func Marshal(srcInterface []interface{}, bgn int, end int, schemaHandler *schema.SchemaHandler) (tb *map[string]*layout.Table, err error)

Convert the objects to table map. srcInterface is a slice of objects

func MarshalCSV Uses

func MarshalCSV(records []interface{}, bgn int, end int, schemaHandler *schema.SchemaHandler) (*map[string]*layout.Table, error)

Marshal function for CSV like data

func MarshalJSON Uses

func MarshalJSON(ss []interface{}, bgn int, end int, schemaHandler *schema.SchemaHandler) (tb *map[string]*layout.Table, err error)

ss is []string

func Unmarshal Uses

func Unmarshal(tableMap *map[string]*layout.Table, bgn int, end int, dstInterface interface{}, schemaHandler *schema.SchemaHandler, prefixPath string) (err error)

Convert the table map to objects slice. desInterface is a slice of pointers of objects

type KeyValue Uses

type KeyValue struct {
    Key   reflect.Value
    Value reflect.Value
}

Record Map KeyValue pair

type MapRecord Uses

type MapRecord struct {
    KeyValues []KeyValue
    Index     int
}

type Marshaler Uses

type Marshaler interface {
    Marshal(node *Node, nodeBuf *NodeBufType) []*Node
}

//////for improve performance///////////////////////////////////

type Node Uses

type Node struct {
    Val     reflect.Value
    PathMap *schema.PathMapType
    RL      int32
    DL      int32
}

type NodeBufType Uses

type NodeBufType struct {
    Index int
    Buf   []*Node
}

Improve Performance/////////////////////////// NodeBuf

func NewNodeBuf Uses

func NewNodeBuf(ln int) *NodeBufType

func (*NodeBufType) GetNode Uses

func (self *NodeBufType) GetNode() *Node

func (*NodeBufType) Reset Uses

func (self *NodeBufType) Reset()

type ParquetMap Uses

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

func (*ParquetMap) Marshal Uses

func (p *ParquetMap) Marshal(node *Node, nodeBuf *NodeBufType) []*Node

type ParquetMapStruct Uses

type ParquetMapStruct struct{}

func (*ParquetMapStruct) Marshal Uses

func (p *ParquetMapStruct) Marshal(node *Node, nodeBuf *NodeBufType) []*Node

type ParquetPtr Uses

type ParquetPtr struct{}

func (*ParquetPtr) Marshal Uses

func (p *ParquetPtr) Marshal(node *Node, nodeBuf *NodeBufType) []*Node

type ParquetSlice Uses

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

func (*ParquetSlice) Marshal Uses

func (p *ParquetSlice) Marshal(node *Node, nodeBuf *NodeBufType) []*Node

type ParquetStruct Uses

type ParquetStruct struct{}

func (*ParquetStruct) Marshal Uses

func (p *ParquetStruct) Marshal(node *Node, nodeBuf *NodeBufType) []*Node

type SliceRecord Uses

type SliceRecord struct {
    Values []reflect.Value
    Index  int
}

Package marshal imports 9 packages (graph) and is imported by 2 packages. Updated 2019-09-17. Refresh now. Tools for package owners.