metadata

type AsyncWriteResult ¶

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

func (r *AsyncWriteResult) Done() <-chan error

func (r *AsyncWriteResult) Wait() error

type AsyncWriter ¶

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

AsyncWriter allows callers to schedule values to be stored, but in a non-blocking way TODO: at the moment AsyncWriter serializes and doesn't bufferize the store requests, making them behave as if they were blocking for all the requesters. It can be a problem in case of "high pressure" with many simultaneous requests, which can be a bit slow. In such scenarios, one possibility to be verified is to accumulate many requests in a single transaction as SQLite can be slow on storing multiple independent pieces of data, but is quite efficient when grouping them into a single transaction.

func (w *AsyncWriter) Store(items []Item) *AsyncWriteResult

func (w *AsyncWriter) StoreJson(key, value interface{}) *AsyncWriteResult

func (w *AsyncWriter) StoreJsonSync(ctx context.Context, key, value interface{}) error

type DefaultValues ¶

type DefaultValues map[string]interface{}

type Handler ¶

type Handler struct {
	Reader Reader
	Writer *Writer
}

func NewDefaultedHandler(conn *dbconn.PooledPair, defaultValues DefaultValues) (*Handler, error)

func NewHandler(conn *dbconn.PooledPair) (*Handler, error)

type Item ¶

type Item struct {
	Key   interface{}
	Value interface{}
}

type Key ¶

type Key interface{}

type Reader ¶

type Reader interface {
	Retrieve(context.Context, Key) (Value, error)
	RetrieveJson(context.Context, Key, Value) error
}

func NewReader(pool *dbconn.RoPool) Reader

type SerialWriteRunner ¶

type SerialWriteRunner struct {
	runner.CancellableRunner
	// contains filtered or unexported fields
}

SerialWriteRunner aims to serialize all requests to write in a single goroutine, which effectively owns writing access to the connection

func NewSerialWriteRunner(h *Handler) *SerialWriteRunner

func (runner *SerialWriteRunner) Writer() *AsyncWriter

type Value ¶

type Value = interface{}

type Writer ¶

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

func (writer *Writer) Store(ctx context.Context, items []Item) error

func (writer *Writer) StoreJson(ctx context.Context, key Key, value Value) (err error)