sql

Documentation

Index

• Variables
• type Catalog
  • func (c Catalog) Database(name string) (Database, error)
  • func (c Catalog) Table(dbName string, tableName string) (PhysicalRelation, error)
• type Database
• type Expression
• type Field
• type MemoryRow
  • func NewMemoryRow(fields ...interface{}) MemoryRow
  • func (r MemoryRow) Fields() []interface{}
• type Nameable
• type Node
• type PhysicalRelation
• type Resolvable
• type Row
• type RowIter
• type Schema
• type Transformable
• type Type

Variables

var BigInteger = bigIntegerType{}

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

var Integer = integerType{}

var String = stringType{}

var Timestamp = timestampType{}

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) (PhysicalRelation, error)

type Database

type Database interface {
	Nameable
	Relations() map[string]PhysicalRelation
}

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 PhysicalRelation

type PhysicalRelation interface {
	Nameable
	Node
}

type Resolvable

type Resolvable interface {
	Resolved() bool
}

type Row

type Row interface {
	Fields() []interface{}
}

type RowIter

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

type Schema

type Schema []Field

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