dal

type Adder interface {
	// Add adds a new ValueGetter to the buffer
	Add(context.Context, ValueGetter) (err error)
}

type Aggregate struct {
	Ident     string
	RelSource string
	Filter    filter.Filter

	Group         []AggregateAttr
	OutAttributes []AggregateAttr

	SourceAttributes []AttributeMapping
	// contains filtered or unexported fields
}

type AggregateAttr struct {
	Key bool

	// @todo change; temporary for compose service
	RawExpr string

	Identifier string
	Label      string
	Expression *ql.ASTNode
	Type       Type
	Store      Codec
}

type Alteration struct {
	ID           uint64
	BatchID      uint64
	DependsOn    uint64
	Resource     string
	ResourceType string
	ConnectionID uint64

	AttributeAdd      *AttributeAdd
	AttributeDelete   *AttributeDelete
	AttributeReType   *AttributeReType
	AttributeReEncode *AttributeReEncode
	ModelAdd          *ModelAdd
	ModelDelete       *ModelDelete
}

type AlterationSet []*Alteration

type Attribute struct {
	Ident string `json:"ident"`
	Label string `json:"label"`

	SensitivityLevelID uint64 `json:"sensitivityLevelID"`

	MultiValue bool `json:"multiValue"`

	PrimaryKey bool `json:"primaryKey"`

	// If attribute has SoftDeleteFlag=true we use it
	// when filtering out deleted items
	SoftDeleteFlag bool `json:"softDeleteFlag"`

	// System indicates the attribute was defined by the system
	System bool `json:"system"`

	// Is attribute sortable?
	// Note: all primary keys are sortable
	Sortable bool `json:"sortable"`

	// Can attribute be used in query expression?
	Filterable bool `json:"filterable"`

	// Store describes the strategy the underlying storage system should
	// apply to the underlying value
	Store Codec `json:"store"`

	// Type describes what the value represents and how it should be
	// encoded/decoded
	Type Type `json:"type"`
}

type AttributeAdd struct {
	Attr *Attribute `json:"attr"`
}

type AttributeCodecType string

type AttributeDelete struct {
	Attr *Attribute `json:"attr"`
}

type AttributeMapping interface {
	Identifier() string
	Expression() (expression string)
	Source() (ident string)
	Properties() MapProperties
}

type AttributeReEncode struct {
	Attr *Attribute `json:"attr"`
	To   Codec      `json:"to"`
}

type AttributeReType struct {
	Attr *Attribute `json:"attr"`
	To   Type       `json:"to"`
}

type AttributeSet []*Attribute

type AttributeType string

type Buffer interface {
	// Seek moves the index pointer to the specified location
	// After the Seek call, a Next() call is required
	Seek(context.Context, int) error

	// Len returns the number of elements in the buffer
	Len() int

	Iterator
	Adder
}

type Codec interface {
	Type() AttributeCodecType
	SingleValueOnly() bool
}

type CodecAlias struct {
	Ident string
}

type CodecPlain struct{}

type CodecRecordValueSetJSON struct {
	Ident string
}

type Connection interface {

	// Models returns all the models the underlying connection already supports
	//
	// This is useful when adding support for new models since we can find out what
	// can work out of the box.
	Models(context.Context) (ModelSet, error)

	// Operations returns all of the operations the given store supports
	Operations() OperationSet

	// Can returns true if this store can handle the given operations
	Can(operations ...Operation) bool

	// Create stores the given data into the underlying database
	Create(ctx context.Context, m *Model, rr ...ValueGetter) error

	// Update updates the given value in the underlying connection
	Update(ctx context.Context, m *Model, r ValueGetter) error

	// Lookup returns one bit of data
	Lookup(context.Context, *Model, ValueGetter, ValueSetter) error

	// Search returns an iterator which can be used to access all if the bits
	Search(context.Context, *Model, filter.Filter) (Iterator, error)

	// Analyze returns the operation analysis the connection can perform for the model
	Analyze(ctx context.Context, m *Model) (map[string]OpAnalysis, error)

	// Aggregate returns the iterator with aggregated data from the base model
	Aggregate(ctx context.Context, m *Model, f filter.Filter, groupBy []AggregateAttr, aggrExpr []AggregateAttr, having *ql.ASTNode) (i Iterator, _ error)

	// Delete deletes the given value
	Delete(ctx context.Context, m *Model, pkv ValueGetter) error

	// Truncate deletes all the data for the given model
	Truncate(ctx context.Context, m *Model) error

	// CreateModel adds support for the given models to the underlying database
	//
	// The operation returns an error if any of the models already exists.
	CreateModel(context.Context, ...*Model) error

	// DeleteModel removes support for the given model from the underlying database
	DeleteModel(context.Context, ...*Model) error

	// UpdateModel requests for metadata changes to the existing model
	//
	// Only metadata (such as idents) are affected; attributes can not be changed here
	UpdateModel(ctx context.Context, old *Model, new *Model) error

	// AssertSchemaAlterations returns a new set of Alterations based on what the underlying
	// schema already provides -- it discards alterations for column additions that already exist, etc.
	AssertSchemaAlterations(ctx context.Context, sch *Model, aa ...*Alteration) ([]*Alteration, error)

	// ApplyAlteration applies the given alterations to the underlying schema
	ApplyAlteration(ctx context.Context, sch *Model, aa ...*Alteration) []error
}

type ConnectionCloser interface {
	// Close closes the store connection allowing the driver to perform potential
	// cleanup operations
	Close(ctx context.Context) error
}

type ConnectionConfig struct {
	SensitivityLevelID uint64
	Label              string

	// When model does not specify the ident (table name for example), fallback to this
	ModelIdent string

	// when a new model is added on a connection, it's ident
	// is verified against this regexp
	//
	// ident is considered valid if it matches one of the expressions
	// or if the list of checks is empty
	ModelIdentCheck []*regexp.Regexp
}

type ConnectionParams struct {
	Type   string         `json:"type"`
	Params map[string]any `json:"params"`
}

type ConnectionWrap struct {
	ID uint64

	Config ConnectionConfig
	// contains filtered or unexported fields
}

type ConnectorFn func(ctx context.Context, dsn string) (Connection, error)

type Datasource struct {
	Ident    string
	Filter   filter.Filter
	ModelRef ModelRef

	OutAttributes []AttributeMapping
	// contains filtered or unexported fields
}

type Driver struct {
	Type       string                 `json:"type"`
	Connection DriverConnectionConfig `json:"connection"`
	Operations OperationSet           `json:"operations"`
}

type DriverConnectionConfig struct {
	Type   string                  `json:"type"`
	Params []DriverConnectionParam `json:"params"`
}

type DriverConnectionParam struct {
	Key        string `json:"key"`
	ValueType  string `json:"valueType"`
	MultiValue bool   `json:"multiValue"`
}

type FullService interface {
	Drivers() (drivers []Driver)

	ReplaceSensitivityLevel(levels ...SensitivityLevel) (err error)
	RemoveSensitivityLevel(levelIDs ...uint64) (err error)

	GetConnectionByID(connectionID uint64) *ConnectionWrap

	ReplaceConnection(ctx context.Context, cw *ConnectionWrap, isDefault bool) (err error)
	RemoveConnection(ctx context.Context, ID uint64) (err error)

	SearchModels(ctx context.Context) (out ModelSet, err error)
	ReplaceModel(ctx context.Context, currentAlts []*Alteration, model *Model) (newAlts []*Alteration, err error)
	RemoveModel(ctx context.Context, connectionID, ID uint64) (err error)
	FindModelByResourceID(connectionID uint64, resourceID uint64) *Model
	FindModelByResourceIdent(connectionID uint64, resourceType, resourceIdent string) *Model
	FindModelByIdent(connectionID uint64, ident string) *Model

	Create(ctx context.Context, mf ModelRef, operations OperationSet, rr ...ValueGetter) (err error)
	Update(ctx context.Context, mf ModelRef, operations OperationSet, rr ...ValueGetter) (err error)
	Search(ctx context.Context, mf ModelRef, operations OperationSet, f filter.Filter) (iter Iterator, err error)
	Lookup(ctx context.Context, mf ModelRef, operations OperationSet, lookup ValueGetter, dst ValueSetter) (err error)
	Delete(ctx context.Context, mf ModelRef, operations OperationSet, vv ...ValueGetter) (err error)
	Truncate(ctx context.Context, mf ModelRef, operations OperationSet) (err error)

	Run(ctx context.Context, pp Pipeline) (iter Iterator, err error)
	Dryrun(ctx context.Context, pp Pipeline) (err error)

	ApplyAlteration(ctx context.Context, alts ...*Alteration) (errs []error, err error)
	ReloadModel(ctx context.Context, currentAlts []*Alteration, model *Model) (newAlts []*Alteration, err error)

	SearchConnectionIssues(connectionID uint64) (out []Issue)
	SearchModelIssues(resourceID uint64) (out []Issue)
	SearchResourceIssues(resourceType, resource string) (out []Issue)
}

type Index struct {
	Ident  string
	Type   string
	Unique bool

	Fields []*IndexField

	Predicate string
}

type IndexField struct {
	AttributeIdent string
	Modifiers      []IndexFieldModifier
	Sort           IndexFieldSort
	Nulls          IndexFieldNulls
}

type IndexFieldModifier string

type IndexFieldNulls int

type IndexFieldSort int

type IndexSet []*Index

type Issue struct {
	Issue string `json:"issue,omitempty"`

	Kind issueKind      `json:"kind,omitempty"`
	Meta map[string]any `json:"meta,omitempty"`
	// contains filtered or unexported fields
}

type Iterator interface {
	Next(ctx context.Context) bool
	More(uint, ValueGetter) error
	Err() error
	Scan(ValueSetter) error
	Close() error

	BackCursor(ValueGetter) (*filter.PagingCursor, error)
	ForwardCursor(ValueGetter) (*filter.PagingCursor, error)
}

type Join struct {
	Ident    string
	RelLeft  string
	RelRight string
	// @todo allow multiple join predicates; for now (for easier indexing)
	// only allow one (this is the same as we had before)
	On     JoinPredicate
	Filter filter.Filter

	OutAttributes   []AttributeMapping
	LeftAttributes  []AttributeMapping
	RightAttributes []AttributeMapping
	// contains filtered or unexported fields
}

type JoinPredicate struct {
	Left  string
	Right string
}

type Link struct {
	Ident    string
	RelLeft  string
	RelRight string
	// @todo allow multiple link predicates; for now (for easier indexing)
	// only allow one (this is the same as we had before)
	On LinkPredicate

	Filter filter.Filter

	OutLeftAttributes  []AttributeMapping
	OutRightAttributes []AttributeMapping
	LeftAttributes     []AttributeMapping
	RightAttributes    []AttributeMapping
	// contains filtered or unexported fields
}

type LinkPredicate struct {
	Left  string
	Right string
}

type MapProperties struct {
	Label               string
	IsPrimary           bool
	IsSystem            bool
	IsFilterable        bool
	IsSortable          bool
	IsMultivalue        bool
	MultivalueDelimiter string
	Nullable            bool
	Type                Type
}

type Model struct {
	ConnectionID uint64 `json:"connectionID"`
	Ident        string `json:"ident"`
	Label        string `json:"label"`

	Resource     string `json:"resource"`
	ResourceID   uint64 `json:"resourceID"`
	ResourceType string `json:"resourceType"`

	// Refs is an arbitrary map to identify a model
	// @todo consider reworking this; I'm not the biggest fan
	Refs map[string]any `json:"refs"`

	SensitivityLevelID uint64 `json:"sensitivityLevelID"`

	Attributes AttributeSet `json:"attributes"`

	Constraints map[string][]any `json:"constraints"`
	Indexes     IndexSet         `json:"indexes"`
}

type ModelAdd struct {
	Model *Model `json:"model"`
}

type ModelDelete struct {
	Model *Model `json:"model"`
}

type ModelDiff struct {
	Type modelDiffType
	// Original will be nil when a new attribute is being added
	Original *Attribute
	// Asserted will be nil wen an existing attribute is being removed
	Asserted *Attribute
}

type ModelDiffSet []*ModelDiff

type ModelRef struct {
	ConnectionID uint64

	ResourceID uint64

	ResourceType string
	Resource     string

	Refs map[string]any
}

type ModelSet []*Model

type OpAnalysis struct {
	ScanCost   opCost
	SearchCost opCost
	FilterCost opCost
	SortCost   opCost

	OutputSize dsSize
}

type Operation string

type OperationSet []Operation

type OrderedBuffer interface {
	Buffer

	// InOrder makes the buffer provide the stored data in the specified order
	InOrder(ss ...*filter.SortExpr) (err error)
}

type PKValues map[string]any

type Pipeline []PipelineStep

type PipelineStep interface {
	Identifier() string
	Sources() []string
	Attributes() [][]AttributeMapping

	Analyze(ctx context.Context) error
	Analysis() map[string]OpAnalysis
}

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

type SensitivityLevel struct {
	Handle string
	ID     uint64
	Level  int
}

type SensitivityLevelSet []SensitivityLevel

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

type SimpleAttr struct {
	Ident string
	Expr  string
	Src   string
	Props MapProperties
}

type Type interface {
	Type() AttributeType
	IsNullable() bool
}

type TypeBlob struct {
	//
	Nullable bool
}

type TypeBoolean struct {
	//
	Nullable bool

	HasDefault   bool
	DefaultValue bool
}

type TypeDate struct {
	//
	Nullable bool

	DefaultCurrentTimestamp bool
}

type TypeEnum struct {
	Values   []string
	Nullable bool

	HasDefault   bool
	DefaultValue string
}

type TypeGeometry struct {
	//
	Nullable bool
}

type TypeID struct {
	GeneratedByStore bool
	Nullable         bool

	HasDefault   bool
	DefaultValue uint64
}

type TypeJSON struct {
	//
	Nullable bool

	HasDefault   bool
	DefaultValue any
}

type TypeNumber struct {
	Precision int
	Scale     int
	Nullable  bool

	HasDefault   bool
	DefaultValue float64
	Meta         map[string]any
}

type TypeNumberStoreNativeType string

type TypeRef struct {
	// defaults to ID
	RefAttribute string
	RefModel     *ModelRef

	Nullable bool

	HasDefault   bool
	DefaultValue uint64
}

type TypeText struct {
	Length   uint
	Nullable bool

	HasDefault   bool
	DefaultValue string
}

type TypeTime struct {
	Timezone          bool
	TimezonePrecision bool
	Precision         int
	Nullable          bool

	DefaultCurrentTimestamp bool
}

type TypeTimestamp struct {
	Timezone  bool
	Precision int
	Nullable  bool

	DefaultCurrentTimestamp bool
}

type TypeUUID struct {
	Nullable bool
}

type ValueGetter interface {
	CountValues() map[string]uint
	GetValue(string, uint) (any, error)
}

type ValueSetter interface {
	SetValue(string, uint, any) error
}