tuple

type Data []Value

type DataFilter interface {
	FilterData(d Data) bool
}

type DataFilters []filter.ValueFilter

type Deleter interface {
	// DeleteTuplesByKey removes tuples by key.
	DeleteTuplesByKey(ctx context.Context, keys []Key) error
	Scanner
}

type Field struct {
	Name string // field name
	Type Type   // field type
}

type Filter struct {
	KeyFilter
	DataFilter
}

type Header struct {
	Name string     // name of the table
	Key  []KeyField // primary key fields
	Data []Field    // payload fields
}

type Iterator interface {
	base.Iterator
	// Reset the iterator to the starting state. Closed iterator can not reset.
	Reset()
	// Key returns a primary key of the tuple.
	Key() Key
	// Data returns a payload the tuple.
	Data() Data
}

type Key []Sortable

type KeyField struct {
	Name string  // field name
	Type KeyType // field type
	Auto bool    // autoincrement
}

type KeyFilter interface {
	FilterKey(k Key) bool
}

type KeyFilters []filter.ValueFilter

type KeyType = values.SortableType

type Keys []Key

type LazyTuple interface {
	Key() Key
	Data() Data
}

type ScanOptions struct {
	// KeysOnly is a hint for backend to omit fetching keys for an iterator.
	KeysOnly bool
	// Sort is an optional sorting order for a tuple key. Defaults to a native order of the backend.
	Sort Sorting
	// Filter is an optional filter for tuples.
	Filter *Filter
	// Limit limits the maximal number of tuples to return. Limit <= 0 indicates an unlimited number of results.
	Limit int
}

type Scanner interface {
	// Scan iterates over all tuples matching specific parameters.
	Scan(ctx context.Context, opt *ScanOptions) Iterator
}

type Sortable = values.Sortable

type Sorting int

type Store interface {
	base.DB
	// Tx opens a read-only or read-write transaction in the tuple store.
	Tx(ctx context.Context, rw bool) (Tx, error)
	// View provides functional-style read-only transactional access the tuple store.
	View(ctx context.Context, view func(tx Tx) error) error
	// Update provides functional-style read-write transactional access to the tuple store.
	Update(ctx context.Context, update func(tx Tx) error) error
	// Table returns a table info. It returns ErrTableNotFound if table does not exists.
	// TableInfo can be used to open a Table from transactions more efficiently.
	Table(ctx context.Context, name string) (TableInfo, error)
	// ListTables lists all available tables.
	ListTables(ctx context.Context) ([]TableInfo, error)
}

type Table interface {
	TableInfo

	// Drop clears the data and removes the table.
	Drop(ctx context.Context) error
	// Clear removes all tuples from the table.
	Clear(ctx context.Context) error

	// GetTuple fetches one tuple with a specific key.
	// It returns ErrNotFound if tuple does not exists.
	GetTuple(ctx context.Context, key Key) (Data, error)
	// GetTupleBatch fetches multiple tuples with provided keys.
	// Nil values in the returned slice indicates that specific key does not exists.
	GetTupleBatch(ctx context.Context, keys []Key) ([]Data, error)
	// InsertTuple creates a new tuple. If the tuple with specified key already exists it returns ErrExists.
	InsertTuple(ctx context.Context, t Tuple) (Key, error)
	// UpdateTuple rewrites specified tuple. Options can be provided to create a tuple if ti does not exists.
	// If this flag is not provided and the tuple is missing, it returns ErrNotFound.
	UpdateTuple(ctx context.Context, t Tuple, opt *UpdateOpt) error
	// DeleteTuples removes all tuples that matches a filter.
	DeleteTuples(ctx context.Context, f *Filter) error

	// Scanner adds the Scan function.
	Scanner
}

type TableInfo interface {
	// Header returns a tuple header used in this table.
	Header() Header
	// Open binds a table to the transaction and opens it for further operations.
	Open(ctx context.Context, tx Tx) (Table, error)
}

type Tuple struct {
	Key  Key  // primary key
	Data Data // payload
}

type Tx interface {
	base.Tx
	// Table opens a tuple table. It returns ErrTableNotFound if table does not exists.
	Table(ctx context.Context, name string) (Table, error)
	// ListTables lists all available tables.
	ListTables(ctx context.Context) ([]Table, error)
	// CreateTable creates and opens a table with a specific schema.
	CreateTable(ctx context.Context, table Header) (Table, error)
}

type Type = values.Type

type UpdateOpt struct {
	Upsert bool // create a tuple if it does not exists
}

type Value = values.Value