Documentation
¶
Overview ¶
Package command defines a command model, known as the intermediary representation. It can be compiled from an *ast.SQLStmt using a (compiler.Compiler).
Index ¶
- type BinaryExpr
- type Column
- type Command
- type ConstantBooleanExpr
- type Delete
- type Distinct
- type DropIndex
- type DropTable
- type DropTrigger
- type DropView
- type Empty
- type EqualityExpr
- type Explain
- type Expr
- type FunctionExpr
- type Insert
- type InsertOr
- type Join
- type JoinType
- type Limit
- type List
- type LiteralExpr
- type Offset
- type Project
- type RangeExpr
- type Scan
- type Select
- type SimpleTable
- type Table
- type UnaryExpr
- type Update
- type UpdateOr
- type UpdateSetter
- type Values
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type BinaryExpr ¶
type BinaryExpr struct {
// Operator is the binary operator of the expression.
Operator string
// Left is the left hand side argument of the operator.
Left Expr
// Right is the right hand side argument of the operator.
Right Expr
}
BinaryExpr represents a binary expression of the form <Left><Operand><Right>.
func (BinaryExpr) String ¶
func (e BinaryExpr) String() string
type Column ¶
type Column struct {
// Table is the table name that this column belongs to. May be empty, as
// this is a representation derived from the AST. If this is empty, the
// executor has to interpolate the table from the execution context.
Table string
// Column is the name of the column.
Column Expr
// Alias is the alias name for this table. May be empty.
Alias string
}
Column represents a database table column.
type Command ¶
Command describes a structure that can be executed by the database executor. Instead of using bytecode, we use a hierarchical structure for the executor. This is mainly to increase readability.
type ConstantBooleanExpr ¶
type ConstantBooleanExpr struct {
// Value is the simple bool value of this expression.
Value bool
}
ConstantBooleanExpr is a simple expression that represents a boolean value. It is rarely emitted by the compiler and rather used by optimizations.
func (ConstantBooleanExpr) String ¶
func (b ConstantBooleanExpr) String() string
type Delete ¶
type Delete struct {
// Table is the table to delete datasets from.
Table Table
// Filter is an expression that a dataset has to match in order to be
// deleted. This must not be nil. If all datasets from the table have to
// be deleted, the filter will be a constant true expression.
Filter Expr
}
Delete instructs the executor to delete all datasets from a table, that match the filter.
type Distinct ¶
type Distinct struct {
// Input is the input list that is filtered.
Input List
}
Distinct skips datasets from the list that already have been encountered and returns a list with only distinct entries.
type DropIndex ¶
type DropIndex drop
DropIndex instructs the executor to drop the index with the name and schema defined in this command.
type DropTable ¶
type DropTable drop
DropTable instructs the executor to drop the table with the name and schema defined in this command.
type DropTrigger ¶
type DropTrigger drop
DropTrigger instructs the executor to drop the trigger with the name and schema defined in this command.
func (DropTrigger) String ¶
func (d DropTrigger) String() string
type DropView ¶
type DropView drop
DropView instructs the executor to drop the view with the name and schema defined in this command.
type Empty ¶
type Empty struct {
// Cols are the columns in this empty list. This may be empty to
// indicate a completely empty list.
Cols []Column
}
Empty instructs the executor to consider an empty list of datasets.
type EqualityExpr ¶
type EqualityExpr struct {
// Left is the left hand side expression.
Left Expr
// Right is the right hand side expression.
Right Expr
// Invert determines whether this equality expression must be considered
// as in-equality expression.
Invert bool
}
EqualityExpr is an expression with a left and right side expression, and represents the condition that both expressions are equal. If this equality expression is inverted, the condition is, that both sides are un-equal.
func (EqualityExpr) String ¶
func (e EqualityExpr) String() string
type Explain ¶
type Explain struct {
// Command is the command that will be explained, but not executed.
Command Command
}
Explain instructs the executor to explain the nested command instead of executing it.
type Expr ¶
Expr is a marker interface for anything that is an expression. Different implementations of this interface represent different productions of the expression rule in the SQL grammar.
type FunctionExpr ¶
type FunctionExpr struct {
// Name is the name of the function.
Name string
// Distinct determines, whether only distinct elements in the arguments'
// input lists must be considered.
Distinct bool
// Args are the function argument expressions.
Args []Expr
}
FunctionExpr represents a function call expression.
func (FunctionExpr) String ¶
func (f FunctionExpr) String() string
type Insert ¶
type Insert struct {
// InsertOr is the specified fallback to perform when the insertion
// fails.
InsertOr InsertOr
// Table is the specified table, where the input list is inserted into.
Table Table
// Cols are the columns, which are modified. The columns of the input
// list have to match these columns.
Cols []Column
// DefaultValues determines whether to insert default values for all
// (specified) columns. If this is set to true, the input list must not
// be present.
DefaultValues bool
// Input is the input list of datasets, that will be inserted.
Input List
}
Insert instructs the executor to insert the input list into the specified table. The specified columns must match the columns from the input list.
type InsertOr ¶
type InsertOr uint8
InsertOr is the type of insert alternative that is specified in an insert statement.
type Join ¶
type Join struct {
// Natural indicates whether this join is a natural one.
Natural bool
// Type is the type of join that this join is.
Type JoinType
// Filter defines the condition that has to apply to two datasets from
// the left and right list in order to be merged.
Filter Expr
// Left is the left input list.
Left List
// Right is the right input list.
Right List
}
Join instructs the executor to produce a list from the left and right input list. Lists are merged with respect to the given filter.
type Limit ¶
type Limit struct {
// Limit is the amount of datasets that are respected from the input
// list (top to bottom).
Limit Expr
// Input is the input list of datasets.
Input List
}
Limit instructs the executor to only respect the first Limit datasets from the input list.
type List ¶
type List interface {
Command
// contains filtered or unexported methods
}
List is a marker interface that facilitates creating a type hierarchy for the command model.
type LiteralExpr ¶
type LiteralExpr struct {
// Value is the simple string value of this expression.
Value string
}
LiteralExpr is a simple literal expression that has a single string value.
func (LiteralExpr) String ¶
func (l LiteralExpr) String() string
type Offset ¶
type Offset struct {
// Offset is the amount of datasets that should be skipped from the
// input list.
Offset Expr
// Input is the input list to truncate.
Input List
}
Offset instructs to executor to skip the first Offset datasets from the input list and return that truncated list. When used together with Limit, please notice that the function composition (Limit ∘ Offset)(x) is not commutative.
type Project ¶
type Project struct {
// Cols are the columns that this projection projects. Most of the time,
// this will be the columns from the SELECT statement.
Cols []Column
// Input is the input list over which the projection takes place.
Input List
}
Project represents a projection that should be performed by the executor over the nested input. The projected columns are specified in (command.Project).Cols.
type RangeExpr ¶
type RangeExpr struct {
// Needle is the value that is evaluated if it is between Lo and Hi.
Needle Expr
// Lo is the lower bound of this range.
Lo Expr
// Hi is the upper bound of this range.
Hi Expr
// Invert determines if Needle must be between or not between the bounds
// of this range.
Invert bool
}
RangeExpr is an expression with a needle, an upper and a lower bound. It must be evaluated to true, if needle is within the lower and upper bound, or if the needle is not between the bounds and the range is inverted.
type Scan ¶
type Scan struct {
// Table is the table whose contents will be used.
Table Table
}
Scan instructs the executor to use the contents of the nested table. It is up to the executor whether he performs a full table scan or applies possible optimizations, like a search through indices.
type Select ¶
type Select struct {
// Filter is an expression that filters elements in this selection to
// only elements, that pass this filter.
Filter Expr
// Input is the input list over which the selection takes place.
Input List
}
Select represents a selection that should be performed by the executor over the nested input. Additionally, a filter can be specified which must be respected by the executor.
type SimpleTable ¶
type SimpleTable struct {
// Schema name of the table. May be empty.
Schema string
// Table name of this table. Since this is a simple table, the table
// name is a string and not an expression. Use other Table
// implementations for more complex tables.
Table string
// Alias name of this table. May be empty.
Alias string
// Indexed indicates, whether this table is indexed by an index. If this
// is false, Index must be the empty string.
Indexed bool
// Index is the name of the index that indexed this table, or empty, if
// Indexed is false.
Index string
}
SimpleTable is a table that is only specified by schema and table name, and an optional alias. It is also optionally indexed by an index.
SimpleTable represents the first grammar production of table-or-subquery.
func (SimpleTable) QualifiedName ¶
func (t SimpleTable) QualifiedName() string
QualifiedName returns '<Schema>.<TableName>', or only '<TableName>' if no schema is specified.
func (SimpleTable) String ¶
func (t SimpleTable) String() string
type Table ¶
type Table interface {
QualifiedName() string
// contains filtered or unexported methods
}
Table is a marker interface, allowing for different specifications of tables, such as a simple table, specified by schema and table name, or a more sophisticated table, such as a combination of multiple sub-tables or select statements.
type UnaryExpr ¶
type UnaryExpr struct {
// Operator is the unary operator of the expression.
Operator string
// Value is the value that the unary operator operates on.
Value Expr
}
UnaryExpr represents a unary expression of the form <Operand><Value>.
type Update ¶
type Update struct {
// UpdateOr is the OR clause in an update statement.
UpdateOr UpdateOr
// Table is the table on which the update should be performed.
Table Table
// Updates is a list of updates that must be applied.
Updates []UpdateSetter
// Filter is the filter expression, that determines, which datasets are
// to be updated.
Filter Expr
}
Update instructs the executor to update all datasets, for which the filter expression evaluates to true, with the defined updates.
type UpdateOr ¶
type UpdateOr uint8
UpdateOr is the type of update alternative that is specified in an update statement.
type UpdateSetter ¶
type UpdateSetter struct {
// Cols are the columns of the dataset, that have to be updated. Because
// the columns must be inside the table that this update refers to, and
// no alias can be specified according to the grammar, this is just a
// string, and not a full blown column.
Cols []string
// Value is the expression that the columns have to be set to.
Value Expr
}
UpdateSetter is an update that can be applied to a value in a dataset.
func (UpdateSetter) String ¶
func (u UpdateSetter) String() string
Source Files