cx

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

type Buffer interface {
	Write(Vector)
	Read() []Vector
	Len() int
	Flush()
}

type Clickhouse interface {
	Insert(context.Context, View, []Vector) (uint64, error)
	Close() error
}

type Client interface {
	// Options returns the options associated with client
	Options() *Options
	// WriteBatch method of sending data to Clickhouse is used implicitly in a non - blocking record,
	// and explicitly in a blocking record
	WriteBatch(context.Context, View, *Batch) error
	// Writer returns the asynchronous, non-blocking, Writer client.
	// Ensures using a single Writer instance for each table pair.
	Writer(View, Buffer) Writer
	// WriterBlocking returns the synchronous, blocking, WriterBlocking client.
	// Ensures using a single WriterBlocking instance for each table pair.
	WriterBlocking(View) WriterBlocking
	// RetryClient Get retry client
	RetryClient() Retryable
	// Close ensures all ongoing asynchronous write clients finish.
	Close()
}

type Closable interface {
	Close() error
	CloseMessage() string
}

type Countable interface {
	Inc() uint64
	Dec() uint64
	Val() uint64
}

type Logger interface {
	Log(message interface{})
	Logf(format string, v ...interface{})
}

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

type Queueable interface {
	Queue(packet *RetryPacket)
	Retries() <-chan *RetryPacket
}

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

type Retryable interface {
	Retry(packet *RetryPacket)
	Metrics() (uint64, uint64, uint64)
}

type Vector []interface{}

type VectorDecoded string

type Vectorable interface {
	Row() Vector
}

type View struct {
	Name    string
	Columns []string
}

type Writeable interface {
	Write(ctx context.Context, view View, batch *Batch) (uint64, error)
}

type Writer interface {
	// WriteRow writes asynchronously line protocol record into bucket.
	WriteRow(vector Vectorable)
	// Errors returns a channel for reading errors which occurs during async writes.
	Errors() <-chan error
	// Close writer
	Close()
}

type WriterBlocking interface {
	// WriteRow writes row(s) into bucket.
	// WriteRow writes without implicit batching. Batch is created from given number of records
	// Non-blocking alternative is available in the Writer interface
	WriteRow(ctx context.Context, row ...Vectorable) error
}