sql

type Aggregation 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(ctx *Context, buffer, row Row) error
	// Merge merges a partial buffer into a global one.
	Merge(ctx *Context, buffer, partial Row) error
}

type Alterable interface {
	Create(name string, schema Schema) error
}

type AscendIndex interface {
	// AscendGreaterOrEqual returns an IndexLookup for keys that are greater
	// or equal to the given keys.
	AscendGreaterOrEqual(keys ...interface{}) (IndexLookup, error)
	// AscendLessThan returns an IndexLookup for keys that are less than the
	// given keys.
	AscendLessThan(keys ...interface{}) (IndexLookup, error)
	// AscendRange returns an IndexLookup for keys that are within the given
	// range.
	AscendRange(greaterOrEqual, lessThan []interface{}) (IndexLookup, error)
}

type BaseSession struct {
}

type Catalog struct {
	Databases
	FunctionRegistry
	*IndexRegistry
}

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
	// Source is the name of the table this column came from.
	Source string
}

type Context struct {
	context.Context
	Session
	// contains filtered or unexported fields
}

type ContextOption func(*Context)

type Database interface {
	Nameable
	// Tables returns the information of all tables.
	Tables() map[string]Table
}

type Databases []Database

type DescendIndex interface {
	// DescendGreater returns an IndexLookup for keys that are greater
	// than the given keys.
	DescendGreater(keys ...interface{}) (IndexLookup, error)
	// DescendLessOrEqual returns an IndexLookup for keys that are less than or
	// equal to the given keys.
	DescendLessOrEqual(keys ...interface{}) (IndexLookup, error)
	// DescendRange returns an IndexLookup for keys that are within the given
	// range.
	DescendRange(lessOrEqual, greaterThan []interface{}) (IndexLookup, error)
}

type Expression interface {
	Resolvable
	fmt.Stringer
	// Type returns the expression type.
	Type() Type
	// IsNullable returns whether the expression can be null.
	IsNullable() bool
	// Eval evaluates the given row and returns a result.
	Eval(*Context, Row) (interface{}, error)
	// TransformUp transforms the expression and all its children with the
	// given transform function.
	TransformUp(TransformExprFunc) (Expression, error)
	// Children returns the children expressions of this expression.
	Children() []Expression
}

type ExpressionHash []byte

type Expressioner interface {
	// Expressions returns the list of expressions contained by the node.
	Expressions() []Expression
	// TransformExpressions applies for each expression in this node
	// the expression's TransformUp method with the given function, and
	// return a new node with the transformed expressions.
	TransformExpressions(TransformExprFunc) (Node, error)
}

type Function interface {
	// Call invokes the function.
	Call(...Expression) (Expression, error)
	// contains filtered or unexported methods
}

type Function1 func(e Expression) Expression

type Function2 func(e1, e2 Expression) Expression

type Function3 func(e1, e2, e3 Expression) Expression

type Function4 func(e1, e2, e3, e4 Expression) Expression

type Function5 func(e1, e2, e3, e4, e5 Expression) Expression

type Function6 func(e1, e2, e3, e4, e5, e6 Expression) Expression

type Function7 func(e1, e2, e3, e4, e5, e6, e7 Expression) Expression

type FunctionN func(...Expression) (Expression, error)

type FunctionRegistry map[string]Function

type Functions map[string]Function

type Index interface {
	// Get returns an IndexLookup for the given key in the index.
	Get(key ...interface{}) (IndexLookup, error)
	// Has checks if the given key is present in the index.
	Has(key ...interface{}) (bool, error)
	// ID returns the identifier of the index.
	ID() string
	// Database returns the database name this index belongs to.
	Database() string
	// Table returns the table name this index belongs to.
	Table() string
	// Expressions returns the indexed expressions. If the result is more than
	// one expression, it means the index has multiple columns indexed. If it's
	// just one, it means it may be an expression or a column.
	ExpressionHashes() []ExpressionHash
	// Driver ID of the index.
	Driver() string
}

type IndexDriver interface {
	// ID returns the unique name of the driver.
	ID() string
	// Create a new index. If exprs is more than one expression, it means the
	// index has multiple columns indexed. If it's just one, it means it may
	// be an expression or a column.
	Create(db, table, id string, expressionHashes []ExpressionHash, config map[string]string) (Index, error)
	// LoadAll loads all indexes for given db and table
	LoadAll(db, table string) ([]Index, error)
	// Save the given index
	Save(ctx *Context, index Index, iter IndexKeyValueIter) error
	// Delete the given index.
	Delete(index Index) error
}

type IndexKeyValueIter interface {
	// Next returns the next tuple of index key values. The length of the
	// returned slice will be the same as the number of columns used to
	// create this iterator. The second returned parameter is a repo's location.
	Next() ([]interface{}, []byte, error)
	io.Closer
}

type IndexLookup interface {
	// Values returns the values in the subset of the index.
	Values() (IndexValueIter, error)
}

type IndexRegistry struct {
	// Root path where all the data of the indexes is stored on disk.
	Root string
	// contains filtered or unexported fields
}

type IndexStatus bool

type IndexValueIter interface {
	// Next returns the next value (repo's location) - see IndexKeyValueIter.
	Next() ([]byte, error)
	io.Closer
}

type Indexable interface {
	PushdownProjectionAndFiltersTable
	// IndexKeyValueIter returns an iterator with the values of each row in
	// the table for the given column names.
	IndexKeyValueIter(ctx *Context, colNames []string) (IndexKeyValueIter, error)
	// WithProjectFiltersAndIndex is meant to be called instead of RowIter
	// method of the table. Returns a new iterator given the columns,
	// filters and the index so the table can improve its speed instead of
	// making a full scan.
	WithProjectFiltersAndIndex(
		ctx *Context,
		columns, filters []Expression,
		index IndexValueIter,
	) (RowIter, error)
}

type Inserter interface {
	// Insert the given row.
	Insert(row Row) error
}

type Mergeable interface {
	// IsMergeable checks whether the current IndexLookup can be merged with
	// the given one.
	IsMergeable(IndexLookup) bool
}

type Nameable interface {
	// Name returns the name.
	Name() string
}

type Node interface {
	Resolvable
	Transformable
	fmt.Stringer
	// Schema of the node.
	Schema() Schema
	// Children nodes.
	Children() []Node
	// RowIter produces a row iterator from this node.
	RowIter(*Context) (RowIter, error)
}

type PushdownProjectionAndFiltersTable interface {
	Table
	// HandledFilters returns the subset of filters that can be handled by this
	// table.
	HandledFilters(filters []Expression) []Expression
	// WithProjectAndFilters replaces the RowIter method of the table and
	// return a new row iterator given the column names that are projected
	// and the filters applied to this table.
	WithProjectAndFilters(ctx *Context, columns, filters []Expression) (RowIter, error)
}

type PushdownProjectionTable interface {
	Table
	// WithProject replaces the RowIter method of the table and returns a new
	// row iterator given the column names that are projected.
	WithProject(ctx *Context, colNames []string) (RowIter, error)
}

type Resolvable interface {
	// Resolved returns whether the node is resolved.
	Resolved() bool
}

type Row []interface{}

type RowIter interface {
	// Next retrieves the next row. It will return io.EOF if it's the last row.
	// After retrieving the last row, Close will be automatically closed.
	Next() (Row, error)
	// Close the iterator.
	Close() error
}

type Schema []*Column

type Session interface {
}

type SetOperations interface {
	// Intersection returns a new index subset with the intersection of the
	// current IndexLookup and the ones given.
	Intersection(...IndexLookup) IndexLookup
	// Union returns a new index subset with the union of the current
	// IndexLookup and the ones given.
	Union(...IndexLookup) IndexLookup
	// Difference returns a new index subset with the difference between the
	// current IndexLookup and the ones given.
	Difference(...IndexLookup) IndexLookup
}

type Table interface {
	Nameable
	Node
}

type Tableable interface {
	// Table returns the table name.
	Table() string
}

type TransformExprFunc func(Expression) (Expression, error)

type TransformNodeFunc func(Node) (Node, error)

type Transformable interface {
	// TransformUp transforms all nodes and returns the result of this transformation.
	// Transformation is not propagated to subqueries.
	TransformUp(TransformNodeFunc) (Node, error)
	// TransformExpressionsUp transforms all expressions inside the node and all its
	// children and returns a node with the result of the transformations.
	// Transformation is not propagated to subqueries.
	TransformExpressionsUp(TransformExprFunc) (Node, error)
}

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

type Type interface {
	// Type returns the query.Type for the given Type.
	Type() query.Type
	// Covert a value of a compatible type to a most accurate type.
	Convert(interface{}) (interface{}, error)
	// Compare returns an integer comparing two values.
	// The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
	Compare(interface{}, interface{}) (int, error)
	// SQL returns the sqltypes.Value for the given value.
	SQL(interface{}) sqltypes.Value
}

type UnresolvedDatabase struct{}