sql

Documentation

Index

• Variables
• type Aggregation
• type AggregationExpression
• type Catalog
  • func NewCatalog() *Catalog
  • func (c Catalog) Database(name string) (Database, error)
  • func (c Catalog) Function(name string) (*FunctionEntry, error)
  • func (c Catalog) RegisterFunction(name string, f interface{}) error
  • func (c Catalog) Table(dbName string, tableName string) (Table, error)
• type Database
• type Expression
• type Field
• type FunctionEntry
  • func (e *FunctionEntry) Build(args ...Expression) (Expression, error)
• type Nameable
• type Node
• type Resolvable
• type Row
  • func NewRow(values ...interface{}) Row
  • func NodeToRows(n Node) ([]Row, error)
  • func RowIterToRows(i RowIter) ([]Row, error)
  • func (r Row) Copy() Row
• type RowIter
• type Schema
  • func (s Schema) CheckRow(row Row) error
• type Table
• type Transformable
• type Type
• type UnresolvedDatabase
  • func (d *UnresolvedDatabase) Name() string
  • func (d *UnresolvedDatabase) Tables() map[string]Table
• type Value

Variables

var BigInteger = bigIntegerType{}

var ErrInvalidType = errors.New("invalid type")

var Integer = integerType{}

var Null = nullType{}

var String = stringType{}

var TimestampWithTimezone = timestampWithTimeZoneType{}

TimestampWithTimezone is a timestamp with timezone.

Types

type Aggregation

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

type AggregationExpression

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)
}

AggregationExpression implements an aggregation expression, where an aggregation buffer is created for each grouping (NewBuffer) and rows in the grouping are fed to the buffer (Update). Multiple buffers can be merged (Merge), making partial aggregations possible. Note that Eval must be called with the final aggregation buffer in order to get the final result.

type Catalog

type Catalog struct {
	Databases []Database
	Functions map[string]*FunctionEntry
}

func NewCatalog

func NewCatalog() *Catalog

func (Catalog) Database

func (c Catalog) Database(name string) (Database, error)

func (Catalog) Function

func (c Catalog) Function(name string) (*FunctionEntry, error)

func (Catalog) RegisterFunction

func (c Catalog) RegisterFunction(name string, f interface{}) error

func (Catalog) Table

func (c Catalog) Table(dbName string, tableName string) (Table, error)

type Database

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

type Expression

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

type Field

type Field struct {
	Name string
	Type Type
}

type FunctionEntry

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

func (*FunctionEntry) Build

func (e *FunctionEntry) Build(args ...Expression) (Expression, error)

type Nameable

type Nameable interface {
	Name() string
}

type Node

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

type Resolvable

type Resolvable interface {
	Resolved() bool
}

type Row

type Row []Value

func NewRow

func NewRow(values ...interface{}) Row

func NodeToRows

func NodeToRows(n Node) ([]Row, error)

func RowIterToRows

func RowIterToRows(i RowIter) ([]Row, error)

func (Row) Copy

func (r Row) Copy() Row

type RowIter

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

type Schema

type Schema []Field

func (Schema) CheckRow

func (s Schema) CheckRow(row Row) error

type Table

type Table interface {
	Nameable
	Node
}

type Transformable

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

type Type

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

var Boolean Type = booleanType{}

var Float Type = floatType{}

type UnresolvedDatabase

type UnresolvedDatabase struct{}

func (*UnresolvedDatabase) Name

func (d *UnresolvedDatabase) Name() string

func (*UnresolvedDatabase) Tables

func (d *UnresolvedDatabase) Tables() map[string]Table

type Value

type Value interface{}