sql

type Aggregation interface {
	Update(Row) (Row, error)
	Merge(Row)
	Eval() interface{}
}

type AggregationExpression interface {
	Expression
	// NewBuffer creates a new aggregation buffer and returns it as a Row.
	NewBuffer() Row
	// Update updates the given buffer with the given row.
	Update(buffer, row Row)
	// Merge merges a partial buffer into a global one.
	Merge(buffer, partial Row)
}

type Catalog struct {
	Databases
	FunctionRegistry
}

type Column struct {
	// Name is the name of the column.
	Name string
	// Type is the data type of the column.
	Type Type
	// Default contains the default value of the column or nil if it is NULL.
	Default interface{}
	// Nullable is true if the column can contain NULL values, or false
	// otherwise.
	Nullable bool
}

type Database interface {
	Nameable
	Tables() map[string]Table
}

type Databases []Database

type Expression interface {
	Resolvable
	Type() Type
	Name() string
	IsNullable() bool
	Eval(Row) interface{}
	TransformUp(func(Expression) Expression) Expression
}

type ExpressionBuilder interface {
	Build(...Expression) (Expression, error)
}

type FunctionRegistry map[string]ExpressionBuilder

type Inserter interface {
	Insert(row Row) error
}

type Nameable interface {
	Name() string
}

type Node interface {
	Resolvable
	Transformable
	Schema() Schema
	Children() []Node
	RowIter() (RowIter, error)
}

type Resolvable interface {
	Resolved() bool
}

type Row []interface{}

type RowIter interface {
	Next() (Row, error)
	Close() error
}

type Schema []*Column

type Table interface {
	Nameable
	Node
}

type Transformable interface {
	TransformUp(func(Node) Node) Node
	TransformExpressionsUp(func(Expression) Expression) Node
}

type Type interface {
	Name() string
	InternalType() reflect.Kind
	Check(interface{}) bool
	Convert(interface{}) (interface{}, error)
	Compare(interface{}, interface{}) int
	Native(interface{}) driver.Value
	Default() interface{}
}

type UnresolvedDatabase struct{}