marshal

Documentation

Index

• func Marshal(srcInterface []interface{}, schemaHandler *schema.SchemaHandler) (tb *map[string]*layout.Table, err error)
• func MarshalArrow(recs []interface{}, schemaHandler *schema.SchemaHandler) (tb *map[string]*layout.Table, err error)
• func MarshalCSV(records []interface{}, schemaHandler *schema.SchemaHandler) (*map[string]*layout.Table, error)
• func MarshalJSON(ss []interface{}, schemaHandler *schema.SchemaHandler) (tb *map[string]*layout.Table, err error)
• func Unmarshal(tableMap *map[string]*layout.Table, bgn int, end int, dstInterface interface{}, ...) (err error)
• type KeyValue
• type MapRecord
• type Marshaler
• type Node
• type NodeBufType
  • func NewNodeBuf(ln int) *NodeBufType
  • func (nbt *NodeBufType) GetNode() *Node
  • func (nbt *NodeBufType) Reset()
• type ParquetMap
  • func (p *ParquetMap) Marshal(node *Node, nodeBuf *NodeBufType) []*Node
• type ParquetMapStruct
  • func (p *ParquetMapStruct) Marshal(node *Node, nodeBuf *NodeBufType) []*Node
• type ParquetPtr
  • func (p *ParquetPtr) Marshal(node *Node, nodeBuf *NodeBufType) []*Node
• type ParquetSlice
  • func (p *ParquetSlice) Marshal(node *Node, nodeBuf *NodeBufType) []*Node
• type ParquetStruct
  • func (p *ParquetStruct) Marshal(node *Node, nodeBuf *NodeBufType) []*Node
• type SliceRecord

Functions

func Marshal

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

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

func MarshalArrow

func MarshalArrow(recs []interface{}, schemaHandler *schema.SchemaHandler) (
	tb *map[string]*layout.Table, err error)

MarshalArrow accepts a slice of rows with which it creates a table object. We need to append row by row as opposed to the arrow go provided way of column by column since the wrapper ParquetWriter uses the number of rows to execute intermediate flush depending on the size of the objects, determined by row, which are currently written.

func MarshalCSV

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

Marshal function for CSV like data

func MarshalJSON

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

ss is []string

func Unmarshal

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. dstInterface is a slice of pointers of objects

Types

type KeyValue

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

Record Map KeyValue pair

type MapRecord

type MapRecord struct {
	KeyValues []KeyValue
	Index     int
}

type Marshaler

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

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

type Node

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

type NodeBufType

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

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

func NewNodeBuf

func NewNodeBuf(ln int) *NodeBufType

func (*NodeBufType) GetNode

func (nbt *NodeBufType) GetNode() *Node

func (*NodeBufType) Reset

func (nbt *NodeBufType) Reset()

type ParquetMap

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

func (*ParquetMap) Marshal

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

type ParquetMapStruct

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

func (*ParquetMapStruct) Marshal

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

type ParquetPtr

type ParquetPtr struct{}

func (*ParquetPtr) Marshal

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

type ParquetSlice

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

func (*ParquetSlice) Marshal

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

type ParquetStruct

type ParquetStruct struct{}

func (*ParquetStruct) Marshal

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

type SliceRecord

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