dal

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

type CollectionRef struct {
	Name   string
	Parent *Key
}

type Database interface {
	TransactionCoordinator
	ReadSession
}

type ErrDuplicateUser struct {
	// TODO: Should it be moved out of this package to strongo/app/user?
	SearchCriteria   string
	DuplicateUserIDs []int64
}

type ErrNotFoundByKey interface {
	Key() Key
	Cause() error
	error
}

type FieldPath []string

type FieldVal struct {
	Name  string      `json:"name"`
	Value interface{} `json:"value"`
}

type IDGenerator = func(ctx context.Context, record Record) error

type InsertOption func(options *insertOptions)

type InsertOptions interface {
	IDGenerator() IDGenerator
}

type Key struct {
	ID interface{}
	// contains filtered or unexported fields
}

type KeyOption = func(*Key)

type Precondition = func(preconditions *preConditions)

type Preconditions interface {
	Exists() bool
}

type ROTxWorker = func(ctx context.Context, tx ReadTransaction) error

type RWTxWorker = func(ctx context.Context, tx ReadwriteTransaction) error

type RandomStringOptions interface {
	Prefix() string
}

type ReadSession interface {

	// Get gets a single record from database by key
	Get(ctx context.Context, record Record) error

	// GetMulti gets multiples records from database by keys
	GetMulti(ctx context.Context, records []Record) error

	// Select executes a data retrieval query
	Select(ctx context.Context, query Select) (Reader, error)
}

type ReadTransaction interface {
	Transaction
	ReadSession
}

type ReadTransactionCoordinator interface {
	// RunReadonlyTransaction starts readonly transaction
	RunReadonlyTransaction(ctx context.Context, f ROTxWorker, options ...TransactionOption) error
}

type Reader interface {

	// Next returns the next record for a query.
	// If no more records a nil record and ErrNoMoreRecords are returned.
	Next() (Record, error)
}

type ReadwriteSession interface {
	ReadSession
	WriteSession
}

type ReadwriteTransaction interface {
	Transaction
	ReadwriteSession
}

type ReadwriteTransactionCoordinator interface {
	// RunReadwriteTransaction starts read-write transaction
	RunReadwriteTransaction(ctx context.Context, f RWTxWorker, options ...TransactionOption) error
}

type Record interface {
	// Key keeps a `table` name of an entity and an ID within that table or a chain of nested keys
	Key() *Key

	// Error keeps an error for the last operation on the record. Not found is not treated as an error
	Error() error

	// Exists indicates if record was found in database. Throws panic if called before a `Get` or `Set`.
	Exists() bool

	// SetError sets error relevant to specific record. Intended to be used only by DALgo DB drivers.
	SetError(err error)

	// Data returns record data (without ID/key).
	// Requires either record to be created by NewRecordWithData()
	// or DataTo() to be called first, otherwise panics.
	Data() interface{}

	// HasChanged & MarkAsChanged are methods of convenience
	HasChanged() bool

	// MarkAsChanged & HasChanged are methods of convenience
	MarkAsChanged()
}

type Select struct {

	// From defines target table/collection
	From *CollectionRef

	// Where defines filter condition
	Where query.Condition

	// GroupBy defines expressions to group by
	GroupBy []query.Expression

	// OrderBy defines expressions to order by
	OrderBy []query.Expression

	// Columns defines what columns to return
	Columns []query.Column

	Into func() interface{}

	// Limit specifies maximum number of records to be returned
	Limit int
}

type Transaction interface {
	// Options indicates parameters that were requested at time of transaction creation.
	Options() TransactionOptions
}

type TransactionCoordinator interface {
	ReadTransactionCoordinator
	ReadwriteTransactionCoordinator
}

type TransactionOption func(options *txOptions)

type TransactionOptions interface {

	// IsolationLevel indicates requested isolation level
	IsolationLevel() TxIsolationLevel

	// IsReadonly indicates a readonly transaction
	IsReadonly() bool

	// IsCrossGroup indicates a cross-group transaction. Makes sense for Google App Engine.
	IsCrossGroup() bool

	// Attempts returns number of attempts to execute a transaction. This is used in Google Datastore for example.
	Attempts() int
}

type Transform interface {

	// Name returns name of a transform
	Name() string

	// Value returns arguments of transform
	Value() interface{}
}

type TxIsolationLevel int

type Update struct {
	Field     string
	FieldPath FieldPath
	Value     interface{}
}

type WriteSession interface {

	// Insert inserts a single record in database
	Insert(c context.Context, record Record, opts ...InsertOption) error

	// Set sets a single record in database by key
	Set(ctx context.Context, record Record) error

	// SetMulti sets multiples records in database by keys
	SetMulti(ctx context.Context, records []Record) error

	// Update updates a single record in database by key
	Update(ctx context.Context, key *Key, updates []Update, preconditions ...Precondition) error

	// UpdateMulti updates multiples records in database by keys
	UpdateMulti(c context.Context, keys []*Key, updates []Update, preconditions ...Precondition) error

	// Delete deletes a single record from database by key
	Delete(ctx context.Context, key *Key) error

	// DeleteMulti deletes multiple records from database by keys
	DeleteMulti(ctx context.Context, keys []*Key) error
}