bintb

package module
v0.0.0-...-7de8d89 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 4, 2020 License: Apache-2.0 Imports: 28 Imported by: 2

README

bintb

Binary IO Data Table Read and Writer

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ColumnTypeTool = newColumnTypeTool()

Functions

func BinStreamFullIterate 

func BinStreamFullIterate(dec *Decoder, r io.Reader, opt ...*StreamReaderOptions) error

func BinStreamWriteF 

func BinStreamWriteF(w io.Writer, enc *Encoder, next func() (rec Recorde, err error), maxBufSize ...uint32) (err error)

func CsvStreamFullIterate 

func CsvStreamFullIterate(r *csv.Reader, opt ...*CsvStreamReaderOptions) error

func CsvStreamWriteF 

func CsvStreamWriteF(opt CsvStreamWriterOptions, w *csv.Writer, next func() (rec Recorde, err error)) (err error)

func Each 

func Each(it RecordsIterator, cb func(i int, r Recorde) error) (err error)

func IOWriter 

func IOWriter(f func(data []byte) (n int, err error)) io.Writer

func IsDateTimeTool 

func IsDateTimeTool(typ ColumnType) (ok bool)

func IsDateTool 

func IsDateTool(typ ColumnType) (ok bool)

func IsZonedTimeTool 

func IsZonedTimeTool(typ ColumnType) (ok bool)

func Iterate 

func Iterate(it RecordsIterator) (err error)

func JsonStreamWriteF 

func JsonStreamWriteF(config *JsonStreamWriterConfig, next func() (rec Recorde, err error)) (err error)

func NextRecords 

func NextRecords(recs []Recorde) (next func() (rec Recorde, err error))

func OpenDB 

func OpenDB(name string) (db *sql.DB, err error)

func OpenDBv 

func OpenDBv(name string) (db *sql.DB, err error)

func OpenIterate 

func OpenIterate(opener RecordsIteratorOpener) (err error)

Types

type BinColumnReader 

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

func (*BinColumnReader) Read 

func (this *BinColumnReader) Read() (col *Column, err error)

type BinColumnWriter 

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

func NewBinColumnWriter 

func NewBinColumnWriter(w io.Writer) *BinColumnWriter

func (*BinColumnWriter) Write 

func (this *BinColumnWriter) Write(col *Column) (err error)

type BinRecordReader 

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

func NewBinRecordReader 

func NewBinRecordReader(ed *Decoder, r io.Reader) *BinRecordReader

func (*BinRecordReader) Read 

func (this *BinRecordReader) Read() (rec Recorde, err error)

type BinRecordWriter 

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

func NewBinRecordWriter 

func NewBinRecordWriter(ed *Encoder, w io.Writer) *BinRecordWriter

func (*BinRecordWriter) Write 

func (this *BinRecordWriter) Write(rec Recorde) (err error)

type BinRecordsStreamIterator 

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

func (BinRecordsStreamIterator) Done 

func (BinRecordsStreamIterator) Done(state interface{}) (ok bool)

func (*BinRecordsStreamIterator) Next 

func (this *BinRecordsStreamIterator) Next(state interface{}) (rec Recorde, newState interface{}, err error)

func (*BinRecordsStreamIterator) Start 

func (this *BinRecordsStreamIterator) Start() (state interface{}, err error)

type BinStreamReader 

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

func NewBinStreamReader 

func NewBinStreamReader(dec *Decoder, r io.Reader, opts ...*StreamReaderOptions) *BinStreamReader

func (*BinStreamReader) Open 

func (this *BinStreamReader) Open() (header *ReadHeader, it RecordsIterator, err error)

type BinStreamWriter 

type BinStreamWriter struct {
	MaxBufferSize uint32
	// contains filtered or unexported fields
}

func NewBinStreamWriter 

func NewBinStreamWriter(encoder *Encoder, w io.Writer, maxBufSize ...uint32) *BinStreamWriter

func (*BinStreamWriter) Close 

func (this *BinStreamWriter) Close() error

func (*BinStreamWriter) Columns 

func (this *BinStreamWriter) Columns() []*Column

func (*BinStreamWriter) Encoder 

func (this *BinStreamWriter) Encoder() *Encoder

func (*BinStreamWriter) Failed 

func (this *BinStreamWriter) Failed() bool

func (*BinStreamWriter) Flush 

func (this *BinStreamWriter) Flush() (err error)

func (*BinStreamWriter) RecordsCount 

func (this *BinStreamWriter) RecordsCount() int64

func (*BinStreamWriter) Write 

func (this *BinStreamWriter) Write(rec Recorde) (err error)

type CTFloat32 

type CTFloat32 struct {
	UnLimitColumnTool
}

func (CTFloat32) BinRead 

func (CTFloat32) BinRead(r io.Reader) (v interface{}, err error)

func (CTFloat32) BinWrite 

func (CTFloat32) BinWrite(w io.Writer, v interface{}) (err error)

func (CTFloat32) Decode 

func (CTFloat32) Decode(value string) (v interface{}, err error)

func (CTFloat32) Encode 

func (CTFloat32) Encode(value interface{}) string

func (CTFloat32) Zero 

func (CTFloat32) Zero() interface{}

type CTFloat64 

type CTFloat64 struct {
	UnLimitColumnTool
}

func (CTFloat64) BinRead 

func (CTFloat64) BinRead(r io.Reader) (v interface{}, err error)

func (CTFloat64) BinWrite 

func (CTFloat64) BinWrite(w io.Writer, v interface{}) (err error)

func (CTFloat64) Decode 

func (CTFloat64) Decode(value string) (v interface{}, err error)

func (CTFloat64) Encode 

func (CTFloat64) Encode(value interface{}) string

func (CTFloat64) Zero 

func (CTFloat64) Zero() interface{}

type CTbid 

type CTbid struct{}

func (CTbid) BinRead 

func (CTbid) BinRead(r io.Reader) (v interface{}, err error)

func (CTbid) BinWrite 

func (CTbid) BinWrite(w io.Writer, v interface{}) (err error)

func (*CTbid) DateOf 

func (this *CTbid) DateOf(value interface{}) civil.Date

func (CTbid) Decode 

func (CTbid) Decode(value string) (v interface{}, err error)

func (CTbid) Encode 

func (CTbid) Encode(value interface{}) string

func (CTbid) Limited 

func (CTbid) Limited() bool

func (CTbid) Zero 

func (CTbid) Zero() interface{}

type CTbool 

type CTbool struct{ UnLimitColumnTool }

func (CTbool) BinRead 

func (CTbool) BinRead(r io.Reader) (v interface{}, err error)

func (CTbool) BinWrite 

func (CTbool) BinWrite(w io.Writer, v interface{}) (err error)

func (CTbool) Decode 

func (CTbool) Decode(value string) (v interface{}, err error)

func (CTbool) Description 

func (CTbool) Description() string

func (CTbool) Encode 

func (CTbool) Encode(value interface{}) string

func (CTbool) Zero 

func (CTbool) Zero() interface{}

type CTbyte 

type CTbyte struct{ UnLimitColumnTool }

func (CTbyte) BinRead 

func (CTbyte) BinRead(r io.Reader) (v interface{}, err error)

func (CTbyte) BinWrite 

func (CTbyte) BinWrite(w io.Writer, v interface{}) (err error)

func (CTbyte) Decode 

func (CTbyte) Decode(value string) (v interface{}, err error)

func (CTbyte) Description 

func (CTbyte) Description() string

func (CTbyte) Encode 

func (CTbyte) Encode(value interface{}) string

func (CTbyte) TypeName 

func (CTbyte) TypeName() string

func (CTbyte) Zero 

func (CTbyte) Zero() interface{}

type CTbytes 

type CTbytes struct{ LimitColumnTool }

func (CTbytes) BinRead 

func (CTbytes) BinRead(r io.Reader) (v interface{}, err error)

func (CTbytes) BinWrite 

func (CTbytes) BinWrite(w io.Writer, v interface{}) (err error)

func (CTbytes) Decode 

func (CTbytes) Decode(value string) (v interface{}, err error)

func (CTbytes) Description 

func (CTbytes) Description() string

func (CTbytes) Encode 

func (CTbytes) Encode(value interface{}) string

func (CTbytes) TypeName 

func (CTbytes) TypeName() string

func (CTbytes) Zero 

func (CTbytes) Zero() interface{}

type CTdate 

type CTdate struct {
	UnLimitColumnTool
	TimeZero
	DateTool
}

func (CTdate) BinRead 

func (CTdate) BinRead(r io.Reader) (v interface{}, err error)

func (CTdate) BinWrite 

func (CTdate) BinWrite(w io.Writer, v interface{}) (err error)

func (CTdate) Decode 

func (CTdate) Decode(value string) (v interface{}, err error)

func (CTdate) Encode 

func (CTdate) Encode(value interface{}) string

type CTdtime 

type CTdtime struct {
	TimeZero
	DateTool
	DateTime
}

func (CTdtime) BinRead 

func (CTdtime) BinRead(r io.Reader) (v interface{}, err error)

func (CTdtime) BinWrite 

func (CTdtime) BinWrite(w io.Writer, v interface{}) (err error)

func (CTdtime) Decode 

func (CTdtime) Decode(value string) (v interface{}, err error)

func (CTdtime) Description 

func (CTdtime) Description() string

func (CTdtime) Encode 

func (CTdtime) Encode(value interface{}) string

type CTdtimeZ 

type CTdtimeZ struct {
	TimeZero
	DateTool
	DateTime
}

func (CTdtimeZ) BinRead 

func (CTdtimeZ) BinRead(r io.Reader) (v interface{}, err error)

func (CTdtimeZ) BinWrite 

func (CTdtimeZ) BinWrite(w io.Writer, v interface{}) (err error)

func (CTdtimeZ) Decode 

func (CTdtimeZ) Decode(value string) (v interface{}, err error)

func (CTdtimeZ) Description 

func (CTdtimeZ) Description() string

func (CTdtimeZ) Encode 

func (CTdtimeZ) Encode(value interface{}) string

func (CTdtimeZ) Zone 

func (CTdtimeZ) Zone(value interface{}) (h, m int)

type CTint16 

type CTint16 struct{ UnLimitColumnTool }

func (CTint16) BinRead 

func (CTint16) BinRead(r io.Reader) (v interface{}, err error)

func (CTint16) BinWrite 

func (CTint16) BinWrite(w io.Writer, v interface{}) (err error)

func (CTint16) Decode 

func (CTint16) Decode(value string) (v interface{}, err error)

func (CTint16) Encode 

func (CTint16) Encode(value interface{}) string

func (CTint16) Zero 

func (CTint16) Zero() interface{}

type CTint32 

type CTint32 struct{ UnLimitColumnTool }

func (CTint32) BinRead 

func (CTint32) BinRead(r io.Reader) (v interface{}, err error)

func (CTint32) BinWrite 

func (CTint32) BinWrite(w io.Writer, v interface{}) (err error)

func (CTint32) Decode 

func (CTint32) Decode(value string) (v interface{}, err error)

func (CTint32) Encode 

func (CTint32) Encode(value interface{}) string

func (CTint32) Zero 

func (CTint32) Zero() interface{}

type CTint64 

type CTint64 struct{ UnLimitColumnTool }

func (CTint64) BinRead 

func (CTint64) BinRead(r io.Reader) (v interface{}, err error)

func (CTint64) BinWrite 

func (CTint64) BinWrite(w io.Writer, v interface{}) (err error)

func (CTint64) Decode 

func (CTint64) Decode(value string) (v interface{}, err error)

func (CTint64) Encode 

func (CTint64) Encode(value interface{}) string

func (CTint64) Zero 

func (CTint64) Zero() interface{}

type CTint8 

type CTint8 struct{ UnLimitColumnTool }

func (CTint8) BinRead 

func (CTint8) BinRead(r io.Reader) (v interface{}, err error)

func (CTint8) BinWrite 

func (CTint8) BinWrite(w io.Writer, v interface{}) (err error)

func (CTint8) Decode 

func (CTint8) Decode(value string) (v interface{}, err error)

func (CTint8) Encode 

func (CTint8) Encode(value interface{}) string

func (CTint8) Zero 

func (CTint8) Zero() interface{}

type CTstring 

type CTstring struct{ LimitColumnTool }

func (CTstring) BinRead 

func (CTstring) BinRead(r io.Reader) (v interface{}, err error)

func (CTstring) BinWrite 

func (CTstring) BinWrite(w io.Writer, v interface{}) (err error)

func (CTstring) Decode 

func (CTstring) Decode(value string) (v interface{}, err error)

func (CTstring) Description 

func (CTstring) Description() string

func (CTstring) Encode 

func (CTstring) Encode(value interface{}) string

func (CTstring) Zero 

func (CTstring) Zero() interface{}

type CTtime 

type CTtime struct{ UnLimitColumnTool }

func (CTtime) BinRead 

func (CTtime) BinRead(r io.Reader) (v interface{}, err error)

func (CTtime) BinWrite 

func (CTtime) BinWrite(w io.Writer, v interface{}) (err error)

func (CTtime) Decode 

func (CTtime) Decode(value string) (v interface{}, err error)

func (CTtime) Description 

func (CTtime) Description() string

func (CTtime) Encode 

func (CTtime) Encode(value interface{}) string

func (CTtime) Zero 

func (CTtime) Zero() interface{}

type CTtimeZ 

type CTtimeZ struct{ UnLimitColumnTool }

func (CTtimeZ) BinRead 

func (CTtimeZ) BinRead(r io.Reader) (v interface{}, err error)

func (CTtimeZ) BinWrite 

func (CTtimeZ) BinWrite(w io.Writer, v interface{}) (err error)

func (CTtimeZ) Decode 

func (CTtimeZ) Decode(value string) (v interface{}, err error)

func (CTtimeZ) Description 

func (CTtimeZ) Description() string

func (CTtimeZ) Encode 

func (CTtimeZ) Encode(value interface{}) string

func (CTtimeZ) Zero 

func (CTtimeZ) Zero() interface{}

func (CTtimeZ) Zone 

func (CTtimeZ) Zone(value interface{}) (h, m int)

type CTuint16 

type CTuint16 struct{ UnLimitColumnTool }

func (CTuint16) BinRead 

func (CTuint16) BinRead(r io.Reader) (v interface{}, err error)

func (CTuint16) BinWrite 

func (CTuint16) BinWrite(w io.Writer, v interface{}) (err error)

func (CTuint16) Decode 

func (CTuint16) Decode(value string) (v interface{}, err error)

func (CTuint16) Encode 

func (CTuint16) Encode(value interface{}) string

func (CTuint16) Zero 

func (CTuint16) Zero() interface{}

type CTuint32 

type CTuint32 struct{ UnLimitColumnTool }

func (CTuint32) BinRead 

func (CTuint32) BinRead(r io.Reader) (v interface{}, err error)

func (CTuint32) BinWrite 

func (CTuint32) BinWrite(w io.Writer, v interface{}) (err error)

func (CTuint32) Decode 

func (CTuint32) Decode(value string) (v interface{}, err error)

func (CTuint32) Encode 

func (CTuint32) Encode(value interface{}) string

func (CTuint32) Zero 

func (CTuint32) Zero() interface{}

type CTuint64 

type CTuint64 struct{ UnLimitColumnTool }

func (CTuint64) BinRead 

func (CTuint64) BinRead(r io.Reader) (v interface{}, err error)

func (CTuint64) BinWrite 

func (CTuint64) BinWrite(w io.Writer, v interface{}) (err error)

func (CTuint64) Decode 

func (CTuint64) Decode(value string) (v interface{}, err error)

func (CTuint64) Encode 

func (CTuint64) Encode(value interface{}) string

func (CTuint64) Zero 

func (CTuint64) Zero() interface{}

type CTuint8 

type CTuint8 struct{ UnLimitColumnTool }

func (CTuint8) BinRead 

func (CTuint8) BinRead(r io.Reader) (v interface{}, err error)

func (CTuint8) BinWrite 

func (CTuint8) BinWrite(w io.Writer, v interface{}) (err error)

func (CTuint8) Decode 

func (CTuint8) Decode(value string) (v interface{}, err error)

func (CTuint8) Encode 

func (CTuint8) Encode(value interface{}) string

func (CTuint8) Zero 

func (CTuint8) Zero() interface{}

type Cache 

type Cache struct {
	DB    *sql.DB
	Table string
	Qinsert,
	Qshow,
	Qdelete string
	// contains filtered or unexported fields
}

func NewCache 

func NewCache(DB *sql.DB, Table string) *Cache

func (*Cache) Init 

func (this *Cache) Init() (err error)

func (*Cache) Store 

func (this *Cache) Store(uid string, rec Recorde) (sysId bid.BID)

type Column 

type Column struct {
	Name string

	Tool ColumnTool

	Data map[interface{}]interface{}
	// contains filtered or unexported fields
}

func MustParseColumn 

func MustParseColumn(def string) (c *Column)

func MustParseColumns 

func MustParseColumns(def ...string) (columns []*Column)

func NewColumn 

func NewColumn(name string, typ ColumnType, flags ...Flags) *Column

func ParseColumn 

func ParseColumn(def string) (c *Column, err error)

func ParseColumns 

func ParseColumns(defs ...string) (columns []*Column, err error)

func (*Column) AllowBlank 

func (this *Column) AllowBlank() bool

func (*Column) MaxLength 

func (this *Column) MaxLength() uint16

func (*Column) Required 

func (this *Column) Required() bool

func (*Column) SetMaxLength 

func (this *Column) SetMaxLength(maxLength uint16)

func (*Column) String 

func (this *Column) String() string

func (*Column) Type 

func (this *Column) Type() ColumnType

func (*Column) Unique 

func (this *Column) Unique() bool

func (*Column) Validate 

func (this *Column) Validate(ctx context.Context, value interface{}) (err error)

func (*Column) Validator 

func (this *Column) Validator(f ...ColumnValidator)

func (*Column) Validators 

func (this *Column) Validators() []ColumnValidator

func (*Column) ValueType 

func (this *Column) ValueType() reflect.Type

type ColumnReader 

type ColumnReader interface {
	Read() (col *Column, err error)
}

type ColumnTool 

type ColumnTool interface {
	Limited() bool
	Zero() interface{}
	Decode(value string) (v interface{}, err error)
	Encode(value interface{}) string
	BinRead(r io.Reader) (v interface{}, err error)
	BinWrite(w io.Writer, v interface{}) (err error)
}

type ColumnType 

type ColumnType string
const (
	CtBool   ColumnType = "b"
	CtString ColumnType = "s"
	CtByte   ColumnType = "B"
	CtBytes  ColumnType = "Bs"
)
const (
	CtDTime  ColumnType = "T"
	CtDTimeZ ColumnType = "Tz"
)
const (
	CtFloat32 ColumnType = "f32"
	CtFloat64 ColumnType = "f64"
)
const (
	CtInt8  ColumnType = "i8"
	CtInt16 ColumnType = "i16"
	CtInt32 ColumnType = "i32"
	CtInt64 ColumnType = "i64"
)
const (
	CtTime  ColumnType = "t"
	CtTimeZ ColumnType = "tz"
)
const (
	CtUint8  ColumnType = "u8"
	CtUint16 ColumnType = "u16"
	CtUint32 ColumnType = "u32"
	CtUint64 ColumnType = "u64"
)
const (
	CtBid ColumnType = "bid"
)
const (
	CtDate ColumnType = "d"
)

type ColumnValidator 

type ColumnValidator = func(ctx context.Context, value interface{}) error

type ColumnWriter 

type ColumnWriter interface {
	Write(col *Column) (err error)
}

type CsvDataBridge 

type CsvDataBridge struct {
	UidColumns []int
	Columns    []*Column

	Log logging.Logger
	// contains filtered or unexported fields
}

func New 

func New(cache *Cache, columns []*Column, r ...*csv.Reader) *CsvDataBridge

func (*CsvDataBridge) IsRunning 

func (this *CsvDataBridge) IsRunning() bool

func (*CsvDataBridge) Start 

func (this *CsvDataBridge) Start(done func()) (stop task.Stoper, err error)

func (*CsvDataBridge) Stop 

func (this *CsvDataBridge) Stop()

type CsvRecordReader 

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

func NewCsvReadDecode 

func NewCsvReadDecode(ed *Decoder, r *csv.Reader) *CsvRecordReader

func (*CsvRecordReader) Read 

func (this *CsvRecordReader) Read() (rec Recorde, err error)

type CsvRecordWriter 

type CsvRecordWriter struct {
	OnlyColumnNames bool
	// contains filtered or unexported fields
}

func NewCsvRecordWriter 

func NewCsvRecordWriter(enc *Encoder, w *csv.Writer) *CsvRecordWriter

func (*CsvRecordWriter) Write 

func (this *CsvRecordWriter) Write(rec Recorde) (err error)

type CsvStreamReader 

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

func NewCsvStreamReader 

func NewCsvStreamReader(r *csv.Reader, opts ...*CsvStreamReaderOptions) *CsvStreamReader

func (*CsvStreamReader) Open 

func (this *CsvStreamReader) Open() (header *ReadHeader, it RecordsIterator, err error)

func (*CsvStreamReader) RecordeCount 

func (this *CsvStreamReader) RecordeCount() int

type CsvStreamReaderIterator 

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

func (CsvStreamReaderIterator) Done 

func (CsvStreamReaderIterator) Done(state interface{}) (ok bool)

func (CsvStreamReaderIterator) Next 

func (CsvStreamReaderIterator) Next(state interface{}) (rec Recorde, newState interface{}, err error)

func (*CsvStreamReaderIterator) Start 

func (this *CsvStreamReaderIterator) Start() (state interface{}, err error)

type CsvStreamReaderOptions 

type CsvStreamReaderOptions struct {
	Decoder         *Decoder
	OnlyColumnNames bool
	StreamReaderOptions
	OnStrings       func(i int, values []string) []string
	OnHeaderStrings func(values []string) []string
}

type CsvStreamWriter 

type CsvStreamWriter struct {
	OnlyColumnNames bool
	OnlyRecords     bool

	BeforeRecordeWrite,
	AfterRecordWrite func(w *CsvStreamWriter, rec Recorde) (err error)
	// contains filtered or unexported fields
}

func NewCsvStreamWriter 

func NewCsvStreamWriter(opt CsvStreamWriterOptions, w *csv.Writer) *CsvStreamWriter

func (*CsvStreamWriter) Close 

func (this *CsvStreamWriter) Close() (err error)

func (*CsvStreamWriter) Columns 

func (this *CsvStreamWriter) Columns() []*Column

func (*CsvStreamWriter) CsvWriter 

func (this *CsvStreamWriter) CsvWriter() *csv.Writer

func (*CsvStreamWriter) Encoder 

func (this *CsvStreamWriter) Encoder() *Encoder

func (*CsvStreamWriter) Failed 

func (this *CsvStreamWriter) Failed() bool

func (*CsvStreamWriter) Last 

func (this *CsvStreamWriter) Last() Recorde

func (*CsvStreamWriter) RecordsCount 

func (this *CsvStreamWriter) RecordsCount() int64

func (*CsvStreamWriter) Write 

func (this *CsvStreamWriter) Write(rec Recorde) (err error)

type CsvStreamWriterOptions 

type CsvStreamWriterOptions struct {
	Encoder         *Encoder
	OnlyColumnNames bool
	OnlyRecords     bool

	BeforeRecordeWrite,
	AfterRecordWrite func(w *CsvStreamWriter, rec Recorde) (err error)
}

type DateTime 

type DateTime struct{}

type DateTool 

type DateTool struct{}

func (DateTool) DateOf 

func (DateTool) DateOf(value interface{}) civil.Date

func (DateTool) DateTimerOf 

func (DateTool) DateTimerOf(value interface{}) time.Time

type Decoder 

type Decoder struct {
	Columns []*Column
	Context context.Context
}

func NewDecoder 

func NewDecoder(columns []*Column, ctx ...context.Context) *Decoder

func (*Decoder) BinRead 

func (this *Decoder) BinRead(r io.Reader) (rec []interface{}, err error)

func (*Decoder) BinReadLoopN 

func (this *Decoder) BinReadLoopN(r io.Reader, n int, onRec func(rec Recorde) error) error

func (*Decoder) Decode 

func (this *Decoder) Decode(values ...string) (rec []interface{}, err error)

type Encoder 

type Encoder struct {
	Columns []*Column
	Context context.Context
}

func NewEncoder 

func NewEncoder(columns []*Column, ctx ...context.Context) *Encoder

func (*Encoder) BinWrite 

func (this *Encoder) BinWrite(w io.Writer, values ...interface{}) (err error)

func (*Encoder) Encode 

func (this *Encoder) Encode(values ...interface{}) (rec []string, err error)

type Flags 

type Flags uint8
const (
	Flag     Flags = 0
	Required Flags = 1 << iota
	AllowBlank
	Unique = Required | 4
)

func (Flags) Clear 

func (f Flags) Clear(flag Flags) Flags

func (Flags) Has 

func (f Flags) Has(flag Flags) bool

func (Flags) Set 

func (f Flags) Set(flag Flags) Flags

func (Flags) Toggle 

func (f Flags) Toggle(flag Flags) Flags

type InputCmd 

type InputCmd struct {
	Name   string
	Args   []string
	Env    []string
	Log    logging.Logger
	OnData io.Writer
}

func (*InputCmd) Start 

func (this *InputCmd) Start(done func()) (stop task.Stoper, err error)

type InputCmdStoper 

type InputCmdStoper struct {
	Input *InputCmd
	// contains filtered or unexported fields
}

func (*InputCmdStoper) IsRunning 

func (this *InputCmdStoper) IsRunning() bool

func (*InputCmdStoper) Stop 

func (this *InputCmdStoper) Stop()

type JsonRecordWriter 

type JsonRecordWriter struct {
	*JsonWriterConfig
}

func NewJsonRecordWriter 

func NewJsonRecordWriter(config *JsonWriterConfig) *JsonRecordWriter

func (*JsonRecordWriter) Write 

func (this *JsonRecordWriter) Write(rec Recorde) (err error)

type JsonStreamWriter 

type JsonStreamWriter struct {
	Config *JsonStreamWriterConfig
	// contains filtered or unexported fields
}

func NewJsonStreamWriter 

func NewJsonStreamWriter(config *JsonStreamWriterConfig) *JsonStreamWriter

func (*JsonStreamWriter) Close 

func (this *JsonStreamWriter) Close() (err error)

func (*JsonStreamWriter) Columns 

func (this *JsonStreamWriter) Columns() []*Column

func (*JsonStreamWriter) Encoder 

func (this *JsonStreamWriter) Encoder() *Encoder

func (*JsonStreamWriter) Failed 

func (this *JsonStreamWriter) Failed() bool

func (*JsonStreamWriter) RecordsCount 

func (this *JsonStreamWriter) RecordsCount() int64

func (*JsonStreamWriter) Write 

func (this *JsonStreamWriter) Write(rec Recorde) (err error)

type JsonStreamWriterConfig 

type JsonStreamWriterConfig struct {
	JsonWriterConfig
	OnlyRecords bool
	IndentLevel int
}

type JsonWriterConfig 

type JsonWriterConfig struct {
	Encoder           *Encoder
	OnlyNames, Arrays bool
	JosonEncoder      *json.Encoder
}

type LimitColumnTool 

type LimitColumnTool struct{}

func (LimitColumnTool) Limited 

func (LimitColumnTool) Limited() bool

type MemCacheReader 

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

func NewMemCacheReader 

func NewMemCacheReader(r io.Reader) *MemCacheReader

func (MemCacheReader) Read 

func (this MemCacheReader) Read(p []byte) (n int, err error)

type ReadHeader 

type ReadHeader struct {
	Items  []*Column
	ByName map[string]int
	HasID  bool
}

func NewReadHeader 

func NewReadHeader() *ReadHeader

func (*ReadHeader) Add 

func (this *ReadHeader) Add(col ...*Column) error

func (*ReadHeader) Get 

func (this *ReadHeader) Get(name string, recorde Recorde) interface{}

type RecordReader 

type RecordReader interface {
	Read() (rec Recorde, err error)
}

type RecordWriter 

type RecordWriter interface {
	Write(rec Recorde) (err error)
}

type Recorde 

type Recorde []interface{}

func (Recorde) String 

func (this Recorde) String() string

type RecordsIterator 

type RecordsIterator interface {
	Start() (state interface{}, err error)
	Done(state interface{}) (ok bool)
	Next(state interface{}) (rec Recorde, newState interface{}, err error)
}

type RecordsIteratorOpener 

type RecordsIteratorOpener interface {
	Open() (header *ReadHeader, it RecordsIterator, err error)
}

type StreamReaderOptions 

type StreamReaderOptions struct {
	IdColumn  *Column
	OnHeader  func(header *ReadHeader) (err error)
	OnRecorde func(i int, r Recorde) error
}

type TimeZero 

type TimeZero struct{ UnLimitColumnTool }

func (TimeZero) Zero 

func (TimeZero) Zero() interface{}

type ToolDateTimer 

type ToolDateTimer interface {
	DateTimerOf(value interface{}) time.Time
}

type ToolDater 

type ToolDater interface {
	DateOf(value interface{}) civil.Date
}

type ToolZonedTimer 

type ToolZonedTimer interface {
	Zone(value interface{}) (h, m int)
}

type UnLimitColumnTool 

type UnLimitColumnTool struct{}

func (UnLimitColumnTool) Limited 

func (UnLimitColumnTool) Limited() bool

Source Files

View all Source files

Directories

Path Synopsis
assets
cmd
hooks/post-build
hooks/pre-build

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.