sql

Documentation

Index

• Variables
• type Catalog
  • func (c Catalog) Database(name string) (Database, error)
  • func (c Catalog) Table(dbName string, tableName string) (Table, error)
• type Database
• type Expression
• type Field
• type MemoryRow
  • func NewMemoryRow(fields ...interface{}) MemoryRow
  • func (r MemoryRow) Fields() []interface{}
• type Nameable
• type Node
• type Resolvable
• type Row
  • func NodeToRows(n Node) ([]Row, error)
  • func RowIterToRows(i RowIter) ([]Row, error)
• 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

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 Catalog

type Catalog struct {
	Databases []Database
}

func (Catalog) Database

func (c Catalog) Database(name string) (Database, 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 MemoryRow

type MemoryRow []interface{}

func NewMemoryRow

func NewMemoryRow(fields ...interface{}) MemoryRow

func (MemoryRow) Fields

func (r MemoryRow) Fields() []interface{}

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 interface {
	Fields() []interface{}
}

func NodeToRows

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

func RowIterToRows

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

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