core: vm: sqlvm: introduce interfaces for AST nodes

In order to make our AST easier and safer to use, all declarations with
empty interface type are now removed.

This changes also makes it possible to traverse the AST without using
reflection or understanding what each type means because all AST nodes
have at least one common interface.

9 files changed, 2956 insertions, 1704 deletions

diff --git a/core/vm/sqlvm/ast/ast.go b/core/vm/sqlvm/ast/ast.go
index 654e778e4..ffd4a1011 100644
--- a/core/vm/sqlvm/ast/ast.go
+++ b/core/vm/sqlvm/ast/ast.go
@@ -1,18 +1,110 @@
 package ast
 
 import (
+	"strconv"
+
+	"github.com/dexon-foundation/dexon/core/vm/sqlvm/errors"
 	"github.com/shopspring/decimal"
 )
 
 // ---------------------------------------------------------------------------
+// Base
+// ---------------------------------------------------------------------------
+
+// Node is an interface which should be satisfied by all nodes in AST.
+type Node interface {
+	GetPosition() uint32
+	SetPosition(uint32)
+	GetLength() uint32
+	SetLength(uint32)
+	GetChildren() []Node
+}
+
+// NodeBase is a base struct embedded by structs implementing Node interface.
+type NodeBase struct {
+	Position uint32 `print:"-"`
+	Length   uint32 `print:"-"`
+}
+
+// GetPosition returns the offset in bytes where the corresponding token starts.
+func (n NodeBase) GetPosition() uint32 {
+	return n.Position
+}
+
+// SetPosition sets the offset in bytes where the corresponding token starts.
+func (n *NodeBase) SetPosition(position uint32) {
+	n.Position = position
+}
+
+// GetLength returns the length in bytes of the corresponding token.
+func (n NodeBase) GetLength() uint32 {
+	return n.Length
+}
+
+// SetLength sets the length in bytes of the corresponding token.
+func (n *NodeBase) SetLength(length uint32) {
+	n.Length = length
+}
+
+// ---------------------------------------------------------------------------
 // Identifiers
 // ---------------------------------------------------------------------------
 
+// ExprNode is an interface which should be satisfied all nodes in expressions.
+type ExprNode interface {
+	Node
+	IsConstant() bool
+	GetType() DataType
+	SetType(DataType)
+}
+
+// UntaggedExprNodeBase is a base struct embedded by nodes whose types can be
+// decided without any context and database schema.
+type UntaggedExprNodeBase struct {
+	NodeBase
+}
+
+// SetType always panics because it is not reasonable to set data type on nodes
+// whose types are already decided.
+func (n *UntaggedExprNodeBase) SetType(t DataType) {
+	panic("setting type on untagged expression node")
+}
+
+// TaggedExprNodeBase is a base struct embedded by nodes whose types depend on
+// the context and can only be decided after loading database schemas.
+type TaggedExprNodeBase struct {
+	NodeBase
+	Type DataType `print:"-"`
+}
+
+// GetType gets the data type of the node.
+func (n TaggedExprNodeBase) GetType() DataType {
+	return n.Type
+}
+
+// SetType sets the data type of the node.
+func (n *TaggedExprNodeBase) SetType(t DataType) {
+	n.Type = t
+}
+
 // IdentifierNode references table, column, or function.
 type IdentifierNode struct {
+	TaggedExprNodeBase
 	Name []byte
 }
 
+var _ ExprNode = (*IdentifierNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n IdentifierNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n IdentifierNode) IsConstant() bool {
+	return false
+}
+
 // ---------------------------------------------------------------------------
 // Values
 // ---------------------------------------------------------------------------
@@ -24,54 +116,192 @@ type Valuer interface {
 
 // BoolValueNode is a boolean constant.
 type BoolValueNode struct {
+	UntaggedExprNodeBase
 	V bool
 }
 
+var _ ExprNode = (*BoolValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n BoolValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n BoolValueNode) IsConstant() bool {
+	return true
+}
+
+// GetType returns the type of 'bool'.
+func (n BoolValueNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
+
 // Value returns the value of BoolValueNode.
-func (n BoolValueNode) Value() interface{} { return n.V }
+func (n BoolValueNode) Value() interface{} {
+	return n.V
+}
+
+// String is used for printing AST.
+func (n BoolValueNode) String() string {
+	return strconv.FormatBool(n.V)
+}
 
 // IntegerValueNode is an integer constant.
 type IntegerValueNode struct {
+	TaggedExprNodeBase
 	IsAddress bool
 	V         decimal.Decimal
 }
 
+var _ ExprNode = (*IntegerValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n IntegerValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n IntegerValueNode) IsConstant() bool {
+	return true
+}
+
 // Value returns the value of IntegerValueNode.
-func (n IntegerValueNode) Value() interface{} { return n.V }
-func (n IntegerValueNode) String() string     { return n.V.String() }
+func (n IntegerValueNode) Value() interface{} {
+	return n.V
+}
+
+// String is used for printing AST.
+func (n IntegerValueNode) String() string {
+	return n.V.String()
+}
 
 // DecimalValueNode is a number constant.
 type DecimalValueNode struct {
+	TaggedExprNodeBase
 	V decimal.Decimal
 }
 
+var _ ExprNode = (*DecimalValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n DecimalValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n DecimalValueNode) IsConstant() bool {
+	return true
+}
+
 // Value returns the value of DecimalValueNode.
-func (n DecimalValueNode) Value() interface{} { return n.V }
-func (n DecimalValueNode) String() string     { return n.V.String() }
+func (n DecimalValueNode) Value() interface{} {
+	return n.V
+}
+
+// String is used for printing AST.
+func (n DecimalValueNode) String() string {
+	return n.V.String()
+}
 
 // BytesValueNode is a dynamic or fixed bytes constant.
 type BytesValueNode struct {
+	TaggedExprNodeBase
 	V []byte
 }
 
+var _ ExprNode = (*BytesValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n BytesValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n BytesValueNode) IsConstant() bool {
+	return true
+}
+
 // Value returns the value of BytesValueNode.
-func (n BytesValueNode) Value() interface{} { return n.V }
-func (n BytesValueNode) String() string     { return string(n.V) }
+func (n BytesValueNode) Value() interface{} {
+	return n.V
+}
+
+// String is used for printing AST.
+func (n BytesValueNode) String() string {
+	return string(n.V)
+}
 
 // AnyValueNode is '*' used in SELECT and function call.
-type AnyValueNode struct{}
+type AnyValueNode struct {
+	UntaggedExprNodeBase
+}
+
+var _ ExprNode = (*AnyValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n AnyValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n AnyValueNode) IsConstant() bool {
+	return false
+}
+
+// GetType returns the type of '*'.
+func (n AnyValueNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorSpecial, DataTypeMinorSpecialAny)
+}
 
 // Value returns itself.
-func (n AnyValueNode) Value() interface{} { return n }
+func (n AnyValueNode) Value() interface{} {
+	return n
+}
 
 // DefaultValueNode represents the default value used in INSERT and UPDATE.
-type DefaultValueNode struct{}
+type DefaultValueNode struct {
+	UntaggedExprNodeBase
+}
+
+var _ ExprNode = (*DefaultValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n DefaultValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n DefaultValueNode) IsConstant() bool {
+	return true
+}
+
+// GetType returns the type of 'DEFAULT'.
+func (n DefaultValueNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorSpecial, DataTypeMinorSpecialDefault)
+}
 
 // Value returns itself.
-func (n DefaultValueNode) Value() interface{} { return n }
+func (n DefaultValueNode) Value() interface{} {
+	return n
+}
 
 // NullValueNode is NULL.
-type NullValueNode struct{}
+type NullValueNode struct {
+	TaggedExprNodeBase
+}
+
+var _ ExprNode = (*NullValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n NullValueNode) GetChildren() []Node {
+	return nil
+}
+
+// IsConstant returns whether a node is a constant.
+func (n NullValueNode) IsConstant() bool {
+	return true
+}
 
 // Value returns itself.
 func (n NullValueNode) Value() interface{} { return n }
@@ -80,32 +310,162 @@ func (n NullValueNode) Value() interface{} { return n }
 // Types
 // ---------------------------------------------------------------------------
 
+// TypeNode is an interface which should be satisfied nodes representing types.
+type TypeNode interface {
+	Node
+	GetType() (DataType, errors.ErrorCode)
+}
+
 // IntTypeNode represents solidity int{X} and uint{X} types.
 type IntTypeNode struct {
+	NodeBase
 	Unsigned bool
 	Size     uint32
 }
 
+var _ TypeNode = (*IntTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n IntTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n IntTypeNode) GetType() (DataType, errors.ErrorCode) {
+	if n.Size%8 != 0 || n.Size == 0 || n.Size > 256 {
+		if n.Unsigned {
+			return DataTypeUnknown, errors.ErrorCodeInvalidUintSize
+		}
+		return DataTypeUnknown, errors.ErrorCodeInvalidIntSize
+	}
+	var major DataTypeMajor
+	var minor DataTypeMinor
+	if n.Unsigned {
+		major = DataTypeMajorUint
+	} else {
+		major = DataTypeMajorInt
+	}
+	minor = DataTypeMinor(n.Size/8 - 1)
+	return ComposeDataType(major, minor), errors.ErrorCodeNil
+}
+
 // FixedTypeNode represents solidity fixed{M}x{N} and ufixed{M}x{N} types.
 type FixedTypeNode struct {
+	NodeBase
 	Unsigned         bool
 	Size             uint32
 	FractionalDigits uint32
 }
 
+var _ TypeNode = (*FixedTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n FixedTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n FixedTypeNode) GetType() (DataType, errors.ErrorCode) {
+	if n.Size%8 != 0 || n.Size == 0 || n.Size > 256 {
+		if n.Unsigned {
+			return DataTypeUnknown, errors.ErrorCodeInvalidUfixedSize
+		}
+		return DataTypeUnknown, errors.ErrorCodeInvalidFixedSize
+	}
+	if n.FractionalDigits > 80 {
+		if n.Unsigned {
+			return DataTypeUnknown, errors.ErrorCodeInvalidUfixedFractionalDigits
+		}
+		return DataTypeUnknown, errors.ErrorCodeInvalidFixedFractionalDigits
+	}
+	var major DataTypeMajor
+	var minor DataTypeMinor
+	if n.Unsigned {
+		major = DataTypeMajorUfixed
+	} else {
+		major = DataTypeMajorFixed
+	}
+	major += DataTypeMajor(n.Size/8 - 1)
+	minor = DataTypeMinor(n.FractionalDigits)
+	return ComposeDataType(major, minor), errors.ErrorCodeNil
+}
+
 // DynamicBytesTypeNode represents solidity bytes type.
-type DynamicBytesTypeNode struct{}
+type DynamicBytesTypeNode struct {
+	NodeBase
+}
+
+var _ TypeNode = (*DynamicBytesTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n DynamicBytesTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n DynamicBytesTypeNode) GetType() (DataType, errors.ErrorCode) {
+	return ComposeDataType(DataTypeMajorDynamicBytes, DataTypeMinorDontCare),
+		errors.ErrorCodeNil
+}
 
 // FixedBytesTypeNode represents solidity bytes{X} type.
 type FixedBytesTypeNode struct {
+	NodeBase
 	Size uint32
 }
 
+var _ TypeNode = (*FixedBytesTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n FixedBytesTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n FixedBytesTypeNode) GetType() (DataType, errors.ErrorCode) {
+	if n.Size == 0 || n.Size > 32 {
+		return DataTypeUnknown, errors.ErrorCodeInvalidBytesSize
+	}
+	major := DataTypeMajorFixedBytes
+	minor := DataTypeMinor(n.Size - 1)
+	return ComposeDataType(major, minor), errors.ErrorCodeNil
+}
+
 // AddressTypeNode represents solidity address type.
-type AddressTypeNode struct{}
+type AddressTypeNode struct {
+	NodeBase
+}
+
+var _ TypeNode = (*AddressTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n AddressTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n AddressTypeNode) GetType() (DataType, errors.ErrorCode) {
+	return ComposeDataType(DataTypeMajorAddress, DataTypeMinorDontCare),
+		errors.ErrorCodeNil
+}
 
 // BoolTypeNode represents solidity bool type.
-type BoolTypeNode struct{}
+type BoolTypeNode struct {
+	NodeBase
+}
+
+var _ TypeNode = (*BoolTypeNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n BoolTypeNode) GetChildren() []Node {
+	return nil
+}
+
+// GetType returns the type represented by the node.
+func (n BoolTypeNode) GetType() (DataType, errors.ErrorCode) {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare),
+		errors.ErrorCodeNil
+}
 
 // ---------------------------------------------------------------------------
 // Operators
@@ -113,127 +473,410 @@ type BoolTypeNode struct{}
 
 // UnaryOperator defines the interface of a unary operator.
 type UnaryOperator interface {
-	GetTarget() interface{}
-	SetTarget(interface{})
+	ExprNode
+	GetTarget() ExprNode
+	SetTarget(ExprNode)
 }
 
 // BinaryOperator defines the interface of a binary operator.
 type BinaryOperator interface {
-	GetObject() interface{}
-	GetSubject() interface{}
-	SetObject(interface{})
-	SetSubject(interface{})
+	ExprNode
+	GetObject() ExprNode
+	GetSubject() ExprNode
+	SetObject(ExprNode)
+	SetSubject(ExprNode)
 }
 
 // UnaryOperatorNode is a base struct of unary operators.
 type UnaryOperatorNode struct {
-	Target interface{}
+	Target ExprNode
+}
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n UnaryOperatorNode) GetChildren() []Node {
+	return []Node{n.Target}
+}
+
+// IsConstant returns whether a node is a constant.
+func (n UnaryOperatorNode) IsConstant() bool {
+	return n.Target.IsConstant()
 }
 
 // GetTarget gets the target of the operation.
-func (n UnaryOperatorNode) GetTarget() interface{} {
+func (n UnaryOperatorNode) GetTarget() ExprNode {
 	return n.Target
 }
 
 // SetTarget sets the target of the operation.
-func (n *UnaryOperatorNode) SetTarget(t interface{}) {
+func (n *UnaryOperatorNode) SetTarget(t ExprNode) {
 	n.Target = t
 }
 
 // BinaryOperatorNode is a base struct of binary operators.
 type BinaryOperatorNode struct {
-	Object  interface{}
-	Subject interface{}
+	Object  ExprNode
+	Subject ExprNode
+}
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n BinaryOperatorNode) GetChildren() []Node {
+	return []Node{n.Object, n.Subject}
+}
+
+// IsConstant returns whether a node is a constant.
+func (n BinaryOperatorNode) IsConstant() bool {
+	return n.Object.IsConstant() && n.Subject.IsConstant()
 }
 
 // GetObject gets the node on which the operation is applied.
-func (n BinaryOperatorNode) GetObject() interface{} {
+func (n BinaryOperatorNode) GetObject() ExprNode {
 	return n.Object
 }
 
 // GetSubject gets the node whose value is applied on the object.
-func (n BinaryOperatorNode) GetSubject() interface{} {
+func (n BinaryOperatorNode) GetSubject() ExprNode {
 	return n.Subject
 }
 
 // SetObject sets the object of the operation.
-func (n *BinaryOperatorNode) SetObject(o interface{}) {
+func (n *BinaryOperatorNode) SetObject(o ExprNode) {
 	n.Object = o
 }
 
 // SetSubject sets the subject of the operation.
-func (n *BinaryOperatorNode) SetSubject(s interface{}) {
+func (n *BinaryOperatorNode) SetSubject(s ExprNode) {
 	n.Subject = s
 }
 
 // PosOperatorNode is '+'.
-type PosOperatorNode struct{ UnaryOperatorNode }
+type PosOperatorNode struct {
+	TaggedExprNodeBase
+	UnaryOperatorNode
+}
+
+var _ UnaryOperator = (*PosOperatorNode)(nil)
 
 // NegOperatorNode is '-'.
-type NegOperatorNode struct{ UnaryOperatorNode }
+type NegOperatorNode struct {
+	TaggedExprNodeBase
+	UnaryOperatorNode
+}
+
+var _ UnaryOperator = (*NegOperatorNode)(nil)
 
 // NotOperatorNode is 'NOT'.
-type NotOperatorNode struct{ UnaryOperatorNode }
+type NotOperatorNode struct {
+	UntaggedExprNodeBase
+	UnaryOperatorNode
+}
+
+var _ UnaryOperator = (*NotOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n NotOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // AndOperatorNode is 'AND'.
-type AndOperatorNode struct{ BinaryOperatorNode }
+type AndOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*AndOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n AndOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // OrOperatorNode is 'OR'.
-type OrOperatorNode struct{ BinaryOperatorNode }
+type OrOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*OrOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n OrOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // GreaterOrEqualOperatorNode is '>='.
-type GreaterOrEqualOperatorNode struct{ BinaryOperatorNode }
+type GreaterOrEqualOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*GreaterOrEqualOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n GreaterOrEqualOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // LessOrEqualOperatorNode is '<='.
-type LessOrEqualOperatorNode struct{ BinaryOperatorNode }
+type LessOrEqualOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*LessOrEqualOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n LessOrEqualOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // NotEqualOperatorNode is '<>'.
-type NotEqualOperatorNode struct{ BinaryOperatorNode }
+type NotEqualOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*NotEqualOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n NotEqualOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // EqualOperatorNode is '=' used in expressions.
-type EqualOperatorNode struct{ BinaryOperatorNode }
+type EqualOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*EqualOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n EqualOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // GreaterOperatorNode is '>'.
-type GreaterOperatorNode struct{ BinaryOperatorNode }
+type GreaterOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*GreaterOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n GreaterOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // LessOperatorNode is '<'.
-type LessOperatorNode struct{ BinaryOperatorNode }
+type LessOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*LessOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n LessOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // ConcatOperatorNode is '||'.
-type ConcatOperatorNode struct{ BinaryOperatorNode }
+type ConcatOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*ConcatOperatorNode)(nil)
+
+// GetType returns the type of 'bytes'.
+func (n ConcatOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorDynamicBytes, DataTypeMinorDontCare)
+}
 
 // AddOperatorNode is '+'.
-type AddOperatorNode struct{ BinaryOperatorNode }
+type AddOperatorNode struct {
+	TaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*AddOperatorNode)(nil)
 
 // SubOperatorNode is '-'.
-type SubOperatorNode struct{ BinaryOperatorNode }
+type SubOperatorNode struct {
+	TaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*SubOperatorNode)(nil)
 
 // MulOperatorNode is '*'.
-type MulOperatorNode struct{ BinaryOperatorNode }
+type MulOperatorNode struct {
+	TaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*MulOperatorNode)(nil)
 
 // DivOperatorNode is '/'.
-type DivOperatorNode struct{ BinaryOperatorNode }
+type DivOperatorNode struct {
+	TaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*DivOperatorNode)(nil)
 
 // ModOperatorNode is '%'.
-type ModOperatorNode struct{ BinaryOperatorNode }
+type ModOperatorNode struct {
+	TaggedExprNodeBase
+	BinaryOperatorNode
+}
 
-// InOperatorNode is 'IN'.
-type InOperatorNode struct{ BinaryOperatorNode }
+var _ BinaryOperator = (*ModOperatorNode)(nil)
 
 // IsOperatorNode is 'IS NULL'.
-type IsOperatorNode struct{ BinaryOperatorNode }
+type IsOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*IsOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n IsOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
 
 // LikeOperatorNode is 'LIKE'.
-type LikeOperatorNode struct{ BinaryOperatorNode }
+type LikeOperatorNode struct {
+	UntaggedExprNodeBase
+	BinaryOperatorNode
+}
+
+var _ BinaryOperator = (*LikeOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n LikeOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
+
+// ---------------------------------------------------------------------------
+// Cast
+// ---------------------------------------------------------------------------
 
 // CastOperatorNode is 'CAST(expr AS type)'.
-type CastOperatorNode struct{ BinaryOperatorNode }
+type CastOperatorNode struct {
+	UntaggedExprNodeBase
+	SourceExpr ExprNode
+	TargetType TypeNode
+}
+
+var _ ExprNode = (*CastOperatorNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n CastOperatorNode) GetChildren() []Node {
+	return []Node{n.SourceExpr, n.TargetType}
+}
+
+// IsConstant returns whether a node is a constant.
+func (n CastOperatorNode) IsConstant() bool {
+	return n.SourceExpr.IsConstant()
+}
+
+// GetType returns the type of CAST expression, which is always the target type.
+func (n CastOperatorNode) GetType() DataType {
+	if dt, code := n.TargetType.GetType(); code == errors.ErrorCodeNil {
+		return dt
+	}
+	return DataTypeUnknown
+}
+
+// ---------------------------------------------------------------------------
+// Assignment
+// ---------------------------------------------------------------------------
 
 // AssignOperatorNode is '=' used in UPDATE to set values.
-type AssignOperatorNode struct{ BinaryOperatorNode }
+type AssignOperatorNode struct {
+	NodeBase
+	Column *IdentifierNode
+	Expr   ExprNode
+}
+
+var _ Node = (*AssignOperatorNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n AssignOperatorNode) GetChildren() []Node {
+	return []Node{n.Column, n.Expr}
+}
+
+// ---------------------------------------------------------------------------
+// In
+// ---------------------------------------------------------------------------
+
+// InOperatorNode is 'IN'.
+type InOperatorNode struct {
+	UntaggedExprNodeBase
+	Left  ExprNode
+	Right []ExprNode
+}
+
+var _ ExprNode = (*InOperatorNode)(nil)
+
+// GetType returns the type of 'bool'.
+func (n InOperatorNode) GetType() DataType {
+	return ComposeDataType(DataTypeMajorBool, DataTypeMinorDontCare)
+}
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n InOperatorNode) GetChildren() []Node {
+	nodes := make([]Node, 1+len(n.Right))
+	nodes[0] = n.Left
+	for i := 0; i < len(n.Right); i++ {
+		nodes[i+1] = n.Right[i]
+	}
+	return nodes
+}
+
+// IsConstant returns whether a node is a constant.
+func (n InOperatorNode) IsConstant() bool {
+	if !n.Left.IsConstant() {
+		return false
+	}
+	for i := 0; i < len(n.Right); i++ {
+		if !n.Right[i].IsConstant() {
+			return false
+		}
+	}
+	return true
+}
+
+// ---------------------------------------------------------------------------
+// Function
+// ---------------------------------------------------------------------------
 
 // FunctionOperatorNode is a function call.
-type FunctionOperatorNode struct{ BinaryOperatorNode }
+type FunctionOperatorNode struct {
+	TaggedExprNodeBase
+	Name *IdentifierNode
+	Args []ExprNode
+}
+
+var _ ExprNode = (*FunctionOperatorNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n FunctionOperatorNode) GetChildren() []Node {
+	nodes := make([]Node, 1+len(n.Args))
+	nodes[0] = n.Name
+	for i := 0; i < len(n.Args); i++ {
+		nodes[i+1] = n.Args[i]
+	}
+	return nodes
+}
+
+// IsConstant returns whether a node is a constant.
+func (n FunctionOperatorNode) IsConstant() bool {
+	return false
+}
 
 // ---------------------------------------------------------------------------
 // Options
@@ -241,61 +884,184 @@ type FunctionOperatorNode struct{ BinaryOperatorNode }
 
 // WhereOptionNode is 'WHERE' used in SELECT, UPDATE, DELETE.
 type WhereOptionNode struct {
-	Condition interface{}
+	NodeBase
+	Condition ExprNode
+}
+
+var _ Node = (*WhereOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n WhereOptionNode) GetChildren() []Node {
+	return []Node{n.Condition}
 }
 
 // OrderOptionNode is an expression in 'ORDER BY' used in SELECT.
 type OrderOptionNode struct {
-	Expr       interface{}
+	NodeBase
+	Expr       ExprNode
 	Desc       bool
 	NullsFirst bool
 }
 
+var _ Node = (*OrderOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n OrderOptionNode) GetChildren() []Node {
+	return []Node{n.Expr}
+}
+
 // GroupOptionNode is 'GROUP BY' used in SELECT.
 type GroupOptionNode struct {
-	Expr interface{}
+	NodeBase
+	Expr ExprNode
+}
+
+var _ Node = (*GroupOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n GroupOptionNode) GetChildren() []Node {
+	return []Node{n.Expr}
 }
 
 // OffsetOptionNode is 'OFFSET' used in SELECT.
 type OffsetOptionNode struct {
-	Value IntegerValueNode
+	NodeBase
+	Value *IntegerValueNode
+}
+
+var _ Node = (*OffsetOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n OffsetOptionNode) GetChildren() []Node {
+	return []Node{n.Value}
 }
 
 // LimitOptionNode is 'LIMIT' used in SELECT.
 type LimitOptionNode struct {
-	Value IntegerValueNode
+	NodeBase
+	Value *IntegerValueNode
+}
+
+var _ Node = (*LimitOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n LimitOptionNode) GetChildren() []Node {
+	return []Node{n.Value}
 }
 
 // InsertWithColumnOptionNode stores columns and values used in INSERT.
 type InsertWithColumnOptionNode struct {
-	Column []interface{}
-	Value  []interface{}
+	NodeBase
+	Column []*IdentifierNode
+	Value  [][]ExprNode
+}
+
+var _ Node = (*InsertWithColumnOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n InsertWithColumnOptionNode) GetChildren() []Node {
+	size := len(n.Column)
+	for i := 0; i < len(n.Value); i++ {
+		size += len(n.Value[i])
+	}
+	nodes := make([]Node, size)
+	idx := 0
+	for i := 0; i < len(n.Column); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Column[i]
+	}
+	for i := 0; i < len(n.Value); i++ {
+		for j := 0; j < len(n.Value[i]); j, idx = j+1, idx+1 {
+			nodes[idx] = n.Value[i][j]
+		}
+	}
+	return nodes
 }
 
 // InsertWithDefaultOptionNode is 'DEFAULT VALUES' used in INSERT.
-type InsertWithDefaultOptionNode struct{}
+type InsertWithDefaultOptionNode struct {
+	NodeBase
+}
+
+var _ Node = (*InsertWithDefaultOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n InsertWithDefaultOptionNode) GetChildren() []Node {
+	return nil
+}
 
 // PrimaryOptionNode is 'PRIMARY KEY' used in CREATE TABLE.
-type PrimaryOptionNode struct{}
+type PrimaryOptionNode struct {
+	NodeBase
+}
+
+var _ Node = (*PrimaryOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n PrimaryOptionNode) GetChildren() []Node {
+	return nil
+}
 
 // NotNullOptionNode is 'NOT NULL' used in CREATE TABLE.
-type NotNullOptionNode struct{}
+type NotNullOptionNode struct {
+	NodeBase
+}
+
+var _ Node = (*NotNullOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n NotNullOptionNode) GetChildren() []Node {
+	return nil
+}
 
 // UniqueOptionNode is 'UNIQUE' used in CREATE TABLE and CREATE INDEX.
-type UniqueOptionNode struct{}
+type UniqueOptionNode struct {
+	NodeBase
+}
+
+var _ Node = (*UniqueOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n UniqueOptionNode) GetChildren() []Node {
+	return nil
+}
 
 // AutoIncrementOptionNode is 'AUTOINCREMENT' used in CREATE TABLE.
-type AutoIncrementOptionNode struct{}
+type AutoIncrementOptionNode struct {
+	NodeBase
+}
+
+var _ Node = (*AutoIncrementOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n AutoIncrementOptionNode) GetChildren() []Node {
+	return nil
+}
 
 // DefaultOptionNode is 'DEFAULT' used in CREATE TABLE.
 type DefaultOptionNode struct {
-	Value interface{}
+	NodeBase
+	Value ExprNode
+}
+
+var _ Node = (*DefaultValueNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n DefaultOptionNode) GetChildren() []Node {
+	return []Node{n.Value}
 }
 
 // ForeignOptionNode is 'REFERENCES' used in CREATE TABLE.
 type ForeignOptionNode struct {
-	Table  IdentifierNode
-	Column IdentifierNode
+	NodeBase
+	Table  *IdentifierNode
+	Column *IdentifierNode
+}
+
+var _ Node = (*ForeignOptionNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n ForeignOptionNode) GetChildren() []Node {
+	return []Node{n.Table, n.Column}
 }
 
 // ---------------------------------------------------------------------------
@@ -304,116 +1070,156 @@ type ForeignOptionNode struct {
 
 // SelectStmtNode is SELECT.
 type SelectStmtNode struct {
-	Column []interface{}
+	NodeBase
+	Column []ExprNode
 	Table  *IdentifierNode
 	Where  *WhereOptionNode
-	Group  []interface{}
-	Order  []interface{}
+	Group  []*GroupOptionNode
+	Order  []*OrderOptionNode
 	Limit  *LimitOptionNode
 	Offset *OffsetOptionNode
 }
 
-// GetOption returns a value for printing AST.
-func (n SelectStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Column": n.Column,
-		"Table":  n.Table,
-		"Where":  n.Where,
-		"Group":  n.Group,
-		"Order":  n.Order,
-		"Limit":  n.Limit,
-		"Offset": n.Offset,
+var _ Node = (*SelectStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n SelectStmtNode) GetChildren() []Node {
+	nodes := make([]Node, len(n.Column)+2+len(n.Group)+len(n.Order)+2)
+	idx := 0
+	for i := 0; i < len(n.Column); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Column[i]
+	}
+	nodes[idx] = n.Table
+	idx++
+	nodes[idx] = n.Where
+	idx++
+	for i := 0; i < len(n.Group); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Group[i]
 	}
+	for i := 0; i < len(n.Order); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Order[i]
+	}
+	nodes[idx] = n.Limit
+	idx++
+	nodes[idx] = n.Offset
+	idx++
+	return nodes
 }
 
 // UpdateStmtNode is UPDATE.
 type UpdateStmtNode struct {
-	Table      IdentifierNode
-	Assignment []interface{}
+	NodeBase
+	Table      *IdentifierNode
+	Assignment []*AssignOperatorNode
 	Where      *WhereOptionNode
 }
 
-// GetOption returns a value for printing AST.
-func (n UpdateStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Table":      n.Table,
-		"Assignment": n.Assignment,
-		"Where":      n.Where,
+var _ Node = (*UpdateStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n UpdateStmtNode) GetChildren() []Node {
+	nodes := make([]Node, 1+len(n.Assignment)+1)
+	idx := 0
+	nodes[idx] = n.Table
+	for i := 0; i < len(n.Assignment); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Assignment[i]
 	}
+	nodes[idx] = n.Where
+	idx++
+	return nodes
 }
 
 // DeleteStmtNode is DELETE.
 type DeleteStmtNode struct {
-	Table IdentifierNode
+	NodeBase
+	Table *IdentifierNode
 	Where *WhereOptionNode
 }
 
-// GetOption returns a value for printing AST.
-func (n DeleteStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Table": n.Table,
-		"Where": n.Where,
-	}
+var _ Node = (*DeleteStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n DeleteStmtNode) GetChildren() []Node {
+	return []Node{n.Table, n.Where}
 }
 
 // InsertStmtNode is INSERT.
 type InsertStmtNode struct {
-	Table  IdentifierNode
-	Insert interface{}
+	NodeBase
+	Table  *IdentifierNode
+	Insert Node
 }
 
-// GetOption returns a value for printing AST.
-func (n InsertStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Table":  n.Table,
-		"Insert": n.Insert,
-	}
+var _ Node = (*InsertStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n InsertStmtNode) GetChildren() []Node {
+	return []Node{n.Table, n.Insert}
 }
 
 // CreateTableStmtNode is CREATE TABLE.
 type CreateTableStmtNode struct {
-	Table  IdentifierNode
-	Column []interface{}
+	NodeBase
+	Table  *IdentifierNode
+	Column []*ColumnSchemaNode
 }
 
-// GetOption returns a value for printing AST.
-func (n CreateTableStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Table":  n.Table,
-		"Column": n.Column,
+var _ Node = (*CreateTableStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n CreateTableStmtNode) GetChildren() []Node {
+	nodes := make([]Node, 1+len(n.Column))
+	nodes[0] = n.Table
+	for i := 0; i < len(n.Column); i++ {
+		nodes[i+1] = n.Column[i]
 	}
+	return nodes
 }
 
 // ColumnSchemaNode specifies a column in CREATE TABLE.
 type ColumnSchemaNode struct {
-	Column     IdentifierNode
-	DataType   interface{}
-	Constraint []interface{}
+	NodeBase
+	Column     *IdentifierNode
+	DataType   TypeNode
+	Constraint []Node
 }
 
-// GetOption returns a value for printing AST.
-func (n ColumnSchemaNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Column":     n.Column,
-		"DataYype":   n.DataType,
-		"Constraint": n.Constraint,
+var _ Node = (*ColumnSchemaNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n ColumnSchemaNode) GetChildren() []Node {
+	nodes := make([]Node, 2+len(n.Constraint))
+	nodes[0] = n.Column
+	nodes[1] = n.DataType
+	for i := 0; i < len(n.Constraint); i++ {
+		nodes[i+2] = n.Constraint[i]
 	}
+	return nodes
 }
 
 // CreateIndexStmtNode is CREATE INDEX.
 type CreateIndexStmtNode struct {
-	Index  IdentifierNode
-	Table  IdentifierNode
-	Column []interface{}
+	NodeBase
+	Index  *IdentifierNode
+	Table  *IdentifierNode
+	Column []*IdentifierNode
 	Unique *UniqueOptionNode
 }
 
-// GetOption returns a value for printing AST.
-func (n CreateIndexStmtNode) GetOption() map[string]interface{} {
-	return map[string]interface{}{
-		"Index":  n.Index,
-		"Table":  n.Table,
-		"Column": n.Column,
-		"Unique": n.Unique,
+var _ Node = (*CreateIndexStmtNode)(nil)
+
+// GetChildren returns a list of child nodes used for traversing.
+func (n CreateIndexStmtNode) GetChildren() []Node {
+	nodes := make([]Node, 2+len(n.Column)+1)
+	idx := 0
+	nodes[idx] = n.Index
+	idx++
+	nodes[idx] = n.Table
+	idx++
+	for i := 0; i < len(n.Column); i, idx = i+1, idx+1 {
+		nodes[idx] = n.Column[i]
 	}
+	nodes[idx] = n.Unique
+	idx++
+	return nodes
 }
diff --git a/core/vm/sqlvm/ast/printer.go b/core/vm/sqlvm/ast/printer.go
index 32da47859..a3dd1ba07 100644
--- a/core/vm/sqlvm/ast/printer.go
+++ b/core/vm/sqlvm/ast/printer.go
@@ -54,6 +54,7 @@ func printAST(w io.Writer, n interface{}, depth int, base string, detail bool) {
 		valueOf = valueOf.Elem()
 		typeOf = typeOf.Elem()
 	}
+	kind := typeOf.Kind()
 	name = name + typeOf.Name()
 
 	if op, ok := n.(UnaryOperator); ok {
@@ -70,45 +71,69 @@ func printAST(w io.Writer, n interface{}, depth int, base string, detail bool) {
 		printAST(w, op.GetSubject(), depth+2, base, detail)
 		return
 	}
-	if arr, ok := n.([]interface{}); ok {
-		if len(arr) == 0 {
+	if stringer, ok := n.(fmt.Stringer); ok {
+		s := stringer.String()
+		fmt.Fprintf(w, "%s%s: %s\n", indent, name, formatString(s))
+		return
+	}
+	if bs, ok := n.([]byte); ok {
+		fmt.Fprintf(w, "%s%s\n", indent, formatBytes(bs))
+		return
+	}
+	if kind == reflect.Slice {
+		l := valueOf.Len()
+		if l == 0 {
 			fmt.Fprintf(w, "%s[]\n", indent)
 			return
 		}
 		fmt.Fprintf(w, "%s[\n", indent)
-		for idx := range arr {
-			printAST(w, arr[idx], depth+1, base, detail)
+		for i := 0; i < l; i++ {
+			v := valueOf.Index(i)
+			printAST(w, v.Interface(), depth+1, base, detail)
 		}
 		fmt.Fprintf(w, "%s]\n", indent)
 		return
 	}
-	if stringer, ok := n.(fmt.Stringer); ok {
-		s := stringer.String()
-		fmt.Fprintf(w, "%s%s: %s\n", indent, name, formatString(s))
-		return
-	}
-	if typeOf.Kind() == reflect.Struct {
+	if kind == reflect.Struct {
+		type field struct {
+			name  string
+			value interface{}
+		}
+		var fields []field
+		var collect func(reflect.Type, reflect.Value)
+		collect = func(typeOf reflect.Type, valueOf reflect.Value) {
+			l := typeOf.NumField()
+			for i := 0; i < l; i++ {
+				if !detail && typeOf.Field(i).Tag.Get("print") == "-" {
+					continue
+				}
+				if typeOf.Field(i).Anonymous {
+					embeddedInterface := valueOf.Field(i).Interface()
+					embeddedTypeOf := reflect.TypeOf(embeddedInterface)
+					embeddedValueOf := reflect.ValueOf(embeddedInterface)
+					collect(embeddedTypeOf, embeddedValueOf)
+					continue
+				}
+				fields = append(fields, field{
+					name:  typeOf.Field(i).Name,
+					value: valueOf.Field(i).Interface(),
+				})
+			}
+		}
+		collect(typeOf, valueOf)
 		fmt.Fprintf(w, "%s%s", indent, name)
-		l := typeOf.NumField()
-		if l == 0 {
+		if len(fields) == 0 {
 			fmt.Fprintf(w, " {}\n")
 			return
 		}
 		fmt.Fprintf(w, " {\n")
-		for i := 0; i < l; i++ {
-			if !detail && typeOf.Field(i).Tag.Get("print") == "-" {
-				continue
-			}
-			fmt.Fprintf(w, "%s%s:\n", indentLong, typeOf.Field(i).Name)
-			printAST(w, valueOf.Field(i).Interface(), depth+2, base, detail)
+		for i := 0; i < len(fields); i++ {
+			fmt.Fprintf(w, "%s%s:\n", indentLong, fields[i].name)
+			printAST(w, fields[i].value, depth+2, base, detail)
 		}
 		fmt.Fprintf(w, "%s}\n", indent)
 		return
 	}
-	if bs, ok := n.([]byte); ok {
-		fmt.Fprintf(w, "%s%s\n", indent, formatBytes(bs))
-		return
-	}
 	fmt.Fprintf(w, "%s%+v\n", indent, valueOf.Interface())
 }
 
diff --git a/core/vm/sqlvm/ast/types.go b/core/vm/sqlvm/ast/types.go
index cb8c62c04..0742bbc14 100644
--- a/core/vm/sqlvm/ast/types.go
+++ b/core/vm/sqlvm/ast/types.go
@@ -60,6 +60,14 @@ const (
 	DataTypeMajorUfixed DataTypeMajor = 0x30
 )
 
+// DataTypeMinor enums.
+const (
+	DataTypeMinorDontCare       DataTypeMinor = 0x00
+	DataTypeMinorSpecialNull    DataTypeMinor = 0x00
+	DataTypeMinorSpecialAny     DataTypeMinor = 0x01
+	DataTypeMinorSpecialDefault DataTypeMinor = 0x02
+)
+
 // DataTypeUnknown for unknown data type.
 const DataTypeUnknown DataType = 0
 
diff --git a/core/vm/sqlvm/cmd/ast-printer/main.go b/core/vm/sqlvm/cmd/ast-printer/main.go
index 6965a1d4e..86a742909 100644
--- a/core/vm/sqlvm/cmd/ast-printer/main.go
+++ b/core/vm/sqlvm/cmd/ast-printer/main.go
@@ -17,9 +17,9 @@ func main() {
 
 	n, err := parser.Parse([]byte(flag.Arg(0)))
 	fmt.Printf("detail: %t\n", detail)
-	if err == nil {
-		ast.PrintAST(os.Stdout, n, "  ", detail)
-	} else {
-		fmt.Printf("err:\n%+v\n", err)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "err:\n%+v\n", err)
+		os.Exit(1)
 	}
+	ast.PrintAST(os.Stdout, n, "  ", detail)
 }
diff --git a/core/vm/sqlvm/errors/errors.go b/core/vm/sqlvm/errors/errors.go
index 6062ae5d9..f8c23f554 100644
--- a/core/vm/sqlvm/errors/errors.go
+++ b/core/vm/sqlvm/errors/errors.go
@@ -91,6 +91,13 @@ const (
 	ErrorCodeEscapeSequenceTooShort
 	ErrorCodeInvalidUnicodeCodePoint
 	ErrorCodeUnknownEscapeSequence
+	ErrorCodeInvalidBytesSize
+	ErrorCodeInvalidIntSize
+	ErrorCodeInvalidUintSize
+	ErrorCodeInvalidFixedSize
+	ErrorCodeInvalidUfixedSize
+	ErrorCodeInvalidFixedFractionalDigits
+	ErrorCodeInvalidUfixedFractionalDigits
 	// Runtime Error
 	ErrorCodeInvalidDataType
 	ErrorCodeOverflow
@@ -101,15 +108,22 @@ const (
 )
 
 var errorCodeMap = [...]string{
-	ErrorCodeParser:                  "parser error",
-	ErrorCodeInvalidIntegerSyntax:    "invalid integer syntax",
-	ErrorCodeInvalidNumberSyntax:     "invalid number syntax",
-	ErrorCodeIntegerOutOfRange:       "integer out of range",
-	ErrorCodeNumberOutOfRange:        "number out of range",
-	ErrorCodeFractionalPartTooLong:   "fractional part too long",
-	ErrorCodeEscapeSequenceTooShort:  "escape sequence too short",
-	ErrorCodeInvalidUnicodeCodePoint: "invalid unicode code point",
-	ErrorCodeUnknownEscapeSequence:   "unknown escape sequence",
+	ErrorCodeParser:                        "parser error",
+	ErrorCodeInvalidIntegerSyntax:          "invalid integer syntax",
+	ErrorCodeInvalidNumberSyntax:           "invalid number syntax",
+	ErrorCodeIntegerOutOfRange:             "integer out of range",
+	ErrorCodeNumberOutOfRange:              "number out of range",
+	ErrorCodeFractionalPartTooLong:         "fractional part too long",
+	ErrorCodeEscapeSequenceTooShort:        "escape sequence too short",
+	ErrorCodeInvalidUnicodeCodePoint:       "invalid unicode code point",
+	ErrorCodeUnknownEscapeSequence:         "unknown escape sequence",
+	ErrorCodeInvalidBytesSize:              "invalid bytes size",
+	ErrorCodeInvalidIntSize:                "invalid int size",
+	ErrorCodeInvalidUintSize:               "invalid uint size",
+	ErrorCodeInvalidFixedSize:              "invalid fixed size",
+	ErrorCodeInvalidUfixedSize:             "invalid ufixed size",
+	ErrorCodeInvalidFixedFractionalDigits:  "invalid fixed fractional digits",
+	ErrorCodeInvalidUfixedFractionalDigits: "invalid ufixed fractional digits",
 	// Runtime Error
 	ErrorCodeInvalidDataType: "invalid data type",
 	ErrorCodeOverflow:        "overflow",
diff --git a/core/vm/sqlvm/parser/grammar.go b/core/vm/sqlvm/parser/grammar.go
index 4f9432e41..8c69fd866 100644
--- a/core/vm/sqlvm/parser/grammar.go
+++ b/core/vm/sqlvm/parser/grammar.go
@@ -18,7 +18,6 @@ import (
 
 	"github.com/dexon-foundation/dexon/core/vm/sqlvm/ast"
 	"github.com/dexon-foundation/dexon/core/vm/sqlvm/errors"
-	"github.com/shopspring/decimal"
 )
 
 var g = &grammar{
@@ -101,32 +100,32 @@ var g = &grammar{
 		},
 		{
 			name: "Stmt",
-			pos:  position{line: 15, col: 1, offset: 258},
+			pos:  position{line: 15, col: 1, offset: 271},
 			expr: &choiceExpr{
-				pos: position{line: 16, col: 4, offset: 266},
+				pos: position{line: 16, col: 4, offset: 279},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 16, col: 4, offset: 266},
+						pos:  position{line: 16, col: 4, offset: 279},
 						name: "SelectStmt",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 17, col: 4, offset: 280},
+						pos:  position{line: 17, col: 4, offset: 293},
 						name: "UpdateStmt",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 18, col: 4, offset: 294},
+						pos:  position{line: 18, col: 4, offset: 307},
 						name: "DeleteStmt",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 19, col: 4, offset: 308},
+						pos:  position{line: 19, col: 4, offset: 321},
 						name: "InsertStmt",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 20, col: 4, offset: 322},
+						pos:  position{line: 20, col: 4, offset: 335},
 						name: "CreateTableStmt",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 21, col: 4, offset: 341},
+						pos:  position{line: 21, col: 4, offset: 354},
 						name: "CreateIndexStmt",
 					},
 				},
@@ -134,57 +133,57 @@ var g = &grammar{
 		},
 		{
 			name: "SelectStmt",
-			pos:  position{line: 23, col: 1, offset: 358},
+			pos:  position{line: 23, col: 1, offset: 371},
 			expr: &actionExpr{
-				pos: position{line: 24, col: 4, offset: 372},
+				pos: position{line: 24, col: 4, offset: 385},
 				run: (*parser).callonSelectStmt1,
 				expr: &seqExpr{
-					pos: position{line: 24, col: 4, offset: 372},
+					pos: position{line: 24, col: 4, offset: 385},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 24, col: 4, offset: 372},
+							pos:  position{line: 24, col: 4, offset: 385},
 							name: "SelectToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 25, col: 2, offset: 385},
+							pos:  position{line: 25, col: 2, offset: 398},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 25, col: 4, offset: 387},
+							pos:   position{line: 25, col: 4, offset: 400},
 							label: "f",
 							expr: &ruleRefExpr{
-								pos:  position{line: 25, col: 6, offset: 389},
+								pos:  position{line: 25, col: 6, offset: 402},
 								name: "SelectColumn",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 25, col: 19, offset: 402},
+							pos:   position{line: 25, col: 19, offset: 415},
 							label: "fs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 25, col: 22, offset: 405},
+								pos: position{line: 25, col: 22, offset: 418},
 								expr: &actionExpr{
-									pos: position{line: 25, col: 24, offset: 407},
+									pos: position{line: 25, col: 24, offset: 420},
 									run: (*parser).callonSelectStmt9,
 									expr: &seqExpr{
-										pos: position{line: 25, col: 24, offset: 407},
+										pos: position{line: 25, col: 24, offset: 420},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 25, col: 24, offset: 407},
+												pos:  position{line: 25, col: 24, offset: 420},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 25, col: 26, offset: 409},
+												pos:  position{line: 25, col: 26, offset: 422},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 25, col: 41, offset: 424},
+												pos:  position{line: 25, col: 41, offset: 437},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 25, col: 43, offset: 426},
+												pos:   position{line: 25, col: 43, offset: 439},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 25, col: 45, offset: 428},
+													pos:  position{line: 25, col: 45, offset: 441},
 													name: "SelectColumn",
 												},
 											},
@@ -194,33 +193,33 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 26, col: 2, offset: 463},
+							pos:   position{line: 26, col: 2, offset: 476},
 							label: "table",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 26, col: 8, offset: 469},
+								pos: position{line: 26, col: 8, offset: 482},
 								expr: &actionExpr{
-									pos: position{line: 26, col: 10, offset: 471},
+									pos: position{line: 26, col: 10, offset: 484},
 									run: (*parser).callonSelectStmt18,
 									expr: &seqExpr{
-										pos: position{line: 26, col: 10, offset: 471},
+										pos: position{line: 26, col: 10, offset: 484},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 26, col: 10, offset: 471},
+												pos:  position{line: 26, col: 10, offset: 484},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 26, col: 12, offset: 473},
+												pos:  position{line: 26, col: 12, offset: 486},
 												name: "FromToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 26, col: 22, offset: 483},
+												pos:  position{line: 26, col: 22, offset: 496},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 26, col: 24, offset: 485},
+												pos:   position{line: 26, col: 24, offset: 498},
 												label: "i",
 												expr: &ruleRefExpr{
-													pos:  position{line: 26, col: 26, offset: 487},
+													pos:  position{line: 26, col: 26, offset: 500},
 													name: "Identifier",
 												},
 											},
@@ -230,25 +229,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 27, col: 2, offset: 520},
+							pos:   position{line: 27, col: 2, offset: 533},
 							label: "where",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 27, col: 8, offset: 526},
+								pos: position{line: 27, col: 8, offset: 539},
 								expr: &actionExpr{
-									pos: position{line: 27, col: 10, offset: 528},
+									pos: position{line: 27, col: 10, offset: 541},
 									run: (*parser).callonSelectStmt27,
 									expr: &seqExpr{
-										pos: position{line: 27, col: 10, offset: 528},
+										pos: position{line: 27, col: 10, offset: 541},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 27, col: 10, offset: 528},
+												pos:  position{line: 27, col: 10, offset: 541},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 27, col: 12, offset: 530},
+												pos:   position{line: 27, col: 12, offset: 543},
 												label: "w",
 												expr: &ruleRefExpr{
-													pos:  position{line: 27, col: 14, offset: 532},
+													pos:  position{line: 27, col: 14, offset: 545},
 													name: "WhereClause",
 												},
 											},
@@ -258,25 +257,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 28, col: 2, offset: 566},
+							pos:   position{line: 28, col: 2, offset: 579},
 							label: "group",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 28, col: 8, offset: 572},
+								pos: position{line: 28, col: 8, offset: 585},
 								expr: &actionExpr{
-									pos: position{line: 28, col: 10, offset: 574},
+									pos: position{line: 28, col: 10, offset: 587},
 									run: (*parser).callonSelectStmt34,
 									expr: &seqExpr{
-										pos: position{line: 28, col: 10, offset: 574},
+										pos: position{line: 28, col: 10, offset: 587},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 28, col: 10, offset: 574},
+												pos:  position{line: 28, col: 10, offset: 587},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 28, col: 12, offset: 576},
+												pos:   position{line: 28, col: 12, offset: 589},
 												label: "g",
 												expr: &ruleRefExpr{
-													pos:  position{line: 28, col: 14, offset: 578},
+													pos:  position{line: 28, col: 14, offset: 591},
 													name: "GroupByClause",
 												},
 											},
@@ -286,25 +285,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 29, col: 2, offset: 614},
+							pos:   position{line: 29, col: 2, offset: 627},
 							label: "order",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 29, col: 8, offset: 620},
+								pos: position{line: 29, col: 8, offset: 633},
 								expr: &actionExpr{
-									pos: position{line: 29, col: 10, offset: 622},
+									pos: position{line: 29, col: 10, offset: 635},
 									run: (*parser).callonSelectStmt41,
 									expr: &seqExpr{
-										pos: position{line: 29, col: 10, offset: 622},
+										pos: position{line: 29, col: 10, offset: 635},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 29, col: 10, offset: 622},
+												pos:  position{line: 29, col: 10, offset: 635},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 29, col: 12, offset: 624},
+												pos:   position{line: 29, col: 12, offset: 637},
 												label: "or",
 												expr: &ruleRefExpr{
-													pos:  position{line: 29, col: 15, offset: 627},
+													pos:  position{line: 29, col: 15, offset: 640},
 													name: "OrderByClause",
 												},
 											},
@@ -314,25 +313,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 30, col: 2, offset: 664},
+							pos:   position{line: 30, col: 2, offset: 677},
 							label: "limit",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 30, col: 8, offset: 670},
+								pos: position{line: 30, col: 8, offset: 683},
 								expr: &actionExpr{
-									pos: position{line: 30, col: 10, offset: 672},
+									pos: position{line: 30, col: 10, offset: 685},
 									run: (*parser).callonSelectStmt48,
 									expr: &seqExpr{
-										pos: position{line: 30, col: 10, offset: 672},
+										pos: position{line: 30, col: 10, offset: 685},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 30, col: 10, offset: 672},
+												pos:  position{line: 30, col: 10, offset: 685},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 30, col: 12, offset: 674},
+												pos:   position{line: 30, col: 12, offset: 687},
 												label: "l",
 												expr: &ruleRefExpr{
-													pos:  position{line: 30, col: 14, offset: 676},
+													pos:  position{line: 30, col: 14, offset: 689},
 													name: "LimitClause",
 												},
 											},
@@ -342,25 +341,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 31, col: 2, offset: 710},
+							pos:   position{line: 31, col: 2, offset: 723},
 							label: "offset",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 31, col: 9, offset: 717},
+								pos: position{line: 31, col: 9, offset: 730},
 								expr: &actionExpr{
-									pos: position{line: 31, col: 11, offset: 719},
+									pos: position{line: 31, col: 11, offset: 732},
 									run: (*parser).callonSelectStmt55,
 									expr: &seqExpr{
-										pos: position{line: 31, col: 11, offset: 719},
+										pos: position{line: 31, col: 11, offset: 732},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 31, col: 11, offset: 719},
+												pos:  position{line: 31, col: 11, offset: 732},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 31, col: 13, offset: 721},
+												pos:   position{line: 31, col: 13, offset: 734},
 												label: "of",
 												expr: &ruleRefExpr{
-													pos:  position{line: 31, col: 16, offset: 724},
+													pos:  position{line: 31, col: 16, offset: 737},
 													name: "OffsetClause",
 												},
 											},
@@ -375,16 +374,16 @@ var g = &grammar{
 		},
 		{
 			name: "SelectColumn",
-			pos:  position{line: 66, col: 1, offset: 1408},
+			pos:  position{line: 60, col: 1, offset: 1527},
 			expr: &choiceExpr{
-				pos: position{line: 67, col: 4, offset: 1424},
+				pos: position{line: 61, col: 4, offset: 1543},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 67, col: 4, offset: 1424},
+						pos:  position{line: 61, col: 4, offset: 1543},
 						name: "AnyLiteral",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 68, col: 4, offset: 1438},
+						pos:  position{line: 62, col: 4, offset: 1557},
 						name: "Expr",
 					},
 				},
@@ -392,77 +391,77 @@ var g = &grammar{
 		},
 		{
 			name: "UpdateStmt",
-			pos:  position{line: 70, col: 1, offset: 1444},
+			pos:  position{line: 64, col: 1, offset: 1563},
 			expr: &actionExpr{
-				pos: position{line: 71, col: 4, offset: 1458},
+				pos: position{line: 65, col: 4, offset: 1577},
 				run: (*parser).callonUpdateStmt1,
 				expr: &seqExpr{
-					pos: position{line: 71, col: 4, offset: 1458},
+					pos: position{line: 65, col: 4, offset: 1577},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 71, col: 4, offset: 1458},
+							pos:  position{line: 65, col: 4, offset: 1577},
 							name: "UpdateToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 72, col: 2, offset: 1471},
+							pos:  position{line: 66, col: 2, offset: 1590},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 72, col: 4, offset: 1473},
+							pos:   position{line: 66, col: 4, offset: 1592},
 							label: "table",
 							expr: &ruleRefExpr{
-								pos:  position{line: 72, col: 10, offset: 1479},
+								pos:  position{line: 66, col: 10, offset: 1598},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 73, col: 2, offset: 1491},
+							pos:  position{line: 67, col: 2, offset: 1610},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 73, col: 4, offset: 1493},
+							pos:  position{line: 67, col: 4, offset: 1612},
 							name: "SetToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 74, col: 2, offset: 1503},
+							pos:  position{line: 68, col: 2, offset: 1622},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 74, col: 4, offset: 1505},
+							pos:   position{line: 68, col: 4, offset: 1624},
 							label: "a",
 							expr: &ruleRefExpr{
-								pos:  position{line: 74, col: 6, offset: 1507},
+								pos:  position{line: 68, col: 6, offset: 1626},
 								name: "Assignment",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 74, col: 17, offset: 1518},
+							pos:   position{line: 68, col: 17, offset: 1637},
 							label: "as",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 74, col: 20, offset: 1521},
+								pos: position{line: 68, col: 20, offset: 1640},
 								expr: &actionExpr{
-									pos: position{line: 74, col: 22, offset: 1523},
+									pos: position{line: 68, col: 22, offset: 1642},
 									run: (*parser).callonUpdateStmt14,
 									expr: &seqExpr{
-										pos: position{line: 74, col: 22, offset: 1523},
+										pos: position{line: 68, col: 22, offset: 1642},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 74, col: 22, offset: 1523},
+												pos:  position{line: 68, col: 22, offset: 1642},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 74, col: 24, offset: 1525},
+												pos:  position{line: 68, col: 24, offset: 1644},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 74, col: 39, offset: 1540},
+												pos:  position{line: 68, col: 39, offset: 1659},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 74, col: 41, offset: 1542},
+												pos:   position{line: 68, col: 41, offset: 1661},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 74, col: 43, offset: 1544},
+													pos:  position{line: 68, col: 43, offset: 1663},
 													name: "Assignment",
 												},
 											},
@@ -472,25 +471,25 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 75, col: 2, offset: 1577},
+							pos:   position{line: 69, col: 2, offset: 1696},
 							label: "where",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 75, col: 8, offset: 1583},
+								pos: position{line: 69, col: 8, offset: 1702},
 								expr: &actionExpr{
-									pos: position{line: 75, col: 10, offset: 1585},
+									pos: position{line: 69, col: 10, offset: 1704},
 									run: (*parser).callonUpdateStmt23,
 									expr: &seqExpr{
-										pos: position{line: 75, col: 10, offset: 1585},
+										pos: position{line: 69, col: 10, offset: 1704},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 75, col: 10, offset: 1585},
+												pos:  position{line: 69, col: 10, offset: 1704},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 75, col: 12, offset: 1587},
+												pos:   position{line: 69, col: 12, offset: 1706},
 												label: "w",
 												expr: &ruleRefExpr{
-													pos:  position{line: 75, col: 14, offset: 1589},
+													pos:  position{line: 69, col: 14, offset: 1708},
 													name: "WhereClause",
 												},
 											},
@@ -505,57 +504,57 @@ var g = &grammar{
 		},
 		{
 			name: "DeleteStmt",
-			pos:  position{line: 91, col: 1, offset: 1877},
+			pos:  position{line: 84, col: 1, offset: 2119},
 			expr: &actionExpr{
-				pos: position{line: 92, col: 4, offset: 1891},
+				pos: position{line: 85, col: 4, offset: 2133},
 				run: (*parser).callonDeleteStmt1,
 				expr: &seqExpr{
-					pos: position{line: 92, col: 4, offset: 1891},
+					pos: position{line: 85, col: 4, offset: 2133},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 92, col: 4, offset: 1891},
+							pos:  position{line: 85, col: 4, offset: 2133},
 							name: "DeleteToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 93, col: 2, offset: 1904},
+							pos:  position{line: 86, col: 2, offset: 2146},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 93, col: 4, offset: 1906},
+							pos:  position{line: 86, col: 4, offset: 2148},
 							name: "FromToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 94, col: 2, offset: 1917},
+							pos:  position{line: 87, col: 2, offset: 2159},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 94, col: 4, offset: 1919},
+							pos:   position{line: 87, col: 4, offset: 2161},
 							label: "table",
 							expr: &ruleRefExpr{
-								pos:  position{line: 94, col: 10, offset: 1925},
+								pos:  position{line: 87, col: 10, offset: 2167},
 								name: "Identifier",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 95, col: 2, offset: 1937},
+							pos:   position{line: 88, col: 2, offset: 2179},
 							label: "where",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 95, col: 8, offset: 1943},
+								pos: position{line: 88, col: 8, offset: 2185},
 								expr: &actionExpr{
-									pos: position{line: 95, col: 10, offset: 1945},
+									pos: position{line: 88, col: 10, offset: 2187},
 									run: (*parser).callonDeleteStmt11,
 									expr: &seqExpr{
-										pos: position{line: 95, col: 10, offset: 1945},
+										pos: position{line: 88, col: 10, offset: 2187},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 95, col: 10, offset: 1945},
+												pos:  position{line: 88, col: 10, offset: 2187},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 95, col: 12, offset: 1947},
+												pos:   position{line: 88, col: 12, offset: 2189},
 												label: "w",
 												expr: &ruleRefExpr{
-													pos:  position{line: 95, col: 14, offset: 1949},
+													pos:  position{line: 88, col: 14, offset: 2191},
 													name: "WhereClause",
 												},
 											},
@@ -570,53 +569,53 @@ var g = &grammar{
 		},
 		{
 			name: "InsertStmt",
-			pos:  position{line: 110, col: 1, offset: 2197},
+			pos:  position{line: 98, col: 1, offset: 2386},
 			expr: &actionExpr{
-				pos: position{line: 111, col: 4, offset: 2211},
+				pos: position{line: 99, col: 4, offset: 2400},
 				run: (*parser).callonInsertStmt1,
 				expr: &seqExpr{
-					pos: position{line: 111, col: 4, offset: 2211},
+					pos: position{line: 99, col: 4, offset: 2400},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 111, col: 4, offset: 2211},
+							pos:  position{line: 99, col: 4, offset: 2400},
 							name: "InsertToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 112, col: 2, offset: 2224},
+							pos:  position{line: 100, col: 2, offset: 2413},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 112, col: 4, offset: 2226},
+							pos:  position{line: 100, col: 4, offset: 2415},
 							name: "IntoToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 113, col: 2, offset: 2237},
+							pos:  position{line: 101, col: 2, offset: 2426},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 113, col: 4, offset: 2239},
+							pos:   position{line: 101, col: 4, offset: 2428},
 							label: "table",
 							expr: &ruleRefExpr{
-								pos:  position{line: 113, col: 10, offset: 2245},
+								pos:  position{line: 101, col: 10, offset: 2434},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 114, col: 2, offset: 2257},
+							pos:  position{line: 102, col: 2, offset: 2446},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 114, col: 4, offset: 2259},
+							pos:   position{line: 102, col: 4, offset: 2448},
 							label: "insert",
 							expr: &choiceExpr{
-								pos: position{line: 114, col: 13, offset: 2268},
+								pos: position{line: 102, col: 13, offset: 2457},
 								alternatives: []interface{}{
 									&ruleRefExpr{
-										pos:  position{line: 114, col: 13, offset: 2268},
+										pos:  position{line: 102, col: 13, offset: 2457},
 										name: "InsertWithColumnClause",
 									},
 									&ruleRefExpr{
-										pos:  position{line: 114, col: 38, offset: 2293},
+										pos:  position{line: 102, col: 38, offset: 2482},
 										name: "InsertWithDefaultClause",
 									},
 								},
@@ -628,36 +627,36 @@ var g = &grammar{
 		},
 		{
 			name: "InsertValue",
-			pos:  position{line: 122, col: 1, offset: 2416},
+			pos:  position{line: 117, col: 1, offset: 2816},
 			expr: &actionExpr{
-				pos: position{line: 123, col: 4, offset: 2431},
+				pos: position{line: 118, col: 4, offset: 2831},
 				run: (*parser).callonInsertValue1,
 				expr: &seqExpr{
-					pos: position{line: 123, col: 4, offset: 2431},
+					pos: position{line: 118, col: 4, offset: 2831},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 123, col: 4, offset: 2431},
+							pos:        position{line: 118, col: 4, offset: 2831},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 123, col: 8, offset: 2435},
+							pos:  position{line: 118, col: 8, offset: 2835},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 123, col: 10, offset: 2437},
+							pos:   position{line: 118, col: 10, offset: 2837},
 							label: "e",
 							expr: &ruleRefExpr{
-								pos:  position{line: 123, col: 12, offset: 2439},
+								pos:  position{line: 118, col: 12, offset: 2839},
 								name: "MultiExprWithDefault",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 123, col: 33, offset: 2460},
+							pos:  position{line: 118, col: 33, offset: 2860},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 123, col: 35, offset: 2462},
+							pos:        position{line: 118, col: 35, offset: 2862},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -667,97 +666,97 @@ var g = &grammar{
 		},
 		{
 			name: "CreateTableStmt",
-			pos:  position{line: 126, col: 1, offset: 2485},
+			pos:  position{line: 121, col: 1, offset: 2885},
 			expr: &actionExpr{
-				pos: position{line: 127, col: 4, offset: 2504},
+				pos: position{line: 122, col: 4, offset: 2904},
 				run: (*parser).callonCreateTableStmt1,
 				expr: &seqExpr{
-					pos: position{line: 127, col: 4, offset: 2504},
+					pos: position{line: 122, col: 4, offset: 2904},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 127, col: 4, offset: 2504},
+							pos:  position{line: 122, col: 4, offset: 2904},
 							name: "CreateToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 128, col: 2, offset: 2517},
+							pos:  position{line: 123, col: 2, offset: 2917},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 128, col: 4, offset: 2519},
+							pos:  position{line: 123, col: 4, offset: 2919},
 							name: "TableToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 129, col: 2, offset: 2531},
+							pos:  position{line: 124, col: 2, offset: 2931},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 129, col: 4, offset: 2533},
+							pos:   position{line: 124, col: 4, offset: 2933},
 							label: "table",
 							expr: &ruleRefExpr{
-								pos:  position{line: 129, col: 10, offset: 2539},
+								pos:  position{line: 124, col: 10, offset: 2939},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 130, col: 2, offset: 2551},
+							pos:  position{line: 125, col: 2, offset: 2951},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 130, col: 4, offset: 2553},
+							pos:        position{line: 125, col: 4, offset: 2953},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 131, col: 2, offset: 2558},
+							pos:  position{line: 126, col: 2, offset: 2958},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 131, col: 4, offset: 2560},
+							pos:   position{line: 126, col: 4, offset: 2960},
 							label: "column",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 131, col: 11, offset: 2567},
+								pos: position{line: 126, col: 11, offset: 2967},
 								expr: &actionExpr{
-									pos: position{line: 132, col: 3, offset: 2571},
+									pos: position{line: 127, col: 3, offset: 2971},
 									run: (*parser).callonCreateTableStmt14,
 									expr: &seqExpr{
-										pos: position{line: 132, col: 3, offset: 2571},
+										pos: position{line: 127, col: 3, offset: 2971},
 										exprs: []interface{}{
 											&labeledExpr{
-												pos:   position{line: 132, col: 3, offset: 2571},
+												pos:   position{line: 127, col: 3, offset: 2971},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 132, col: 5, offset: 2573},
+													pos:  position{line: 127, col: 5, offset: 2973},
 													name: "ColumnSchema",
 												},
 											},
 											&labeledExpr{
-												pos:   position{line: 133, col: 3, offset: 2588},
+												pos:   position{line: 128, col: 3, offset: 2988},
 												label: "ss",
 												expr: &zeroOrMoreExpr{
-													pos: position{line: 133, col: 6, offset: 2591},
+													pos: position{line: 128, col: 6, offset: 2991},
 													expr: &actionExpr{
-														pos: position{line: 133, col: 8, offset: 2593},
+														pos: position{line: 128, col: 8, offset: 2993},
 														run: (*parser).callonCreateTableStmt20,
 														expr: &seqExpr{
-															pos: position{line: 133, col: 8, offset: 2593},
+															pos: position{line: 128, col: 8, offset: 2993},
 															exprs: []interface{}{
 																&ruleRefExpr{
-																	pos:  position{line: 133, col: 8, offset: 2593},
+																	pos:  position{line: 128, col: 8, offset: 2993},
 																	name: "_",
 																},
 																&ruleRefExpr{
-																	pos:  position{line: 133, col: 10, offset: 2595},
+																	pos:  position{line: 128, col: 10, offset: 2995},
 																	name: "SeparatorToken",
 																},
 																&ruleRefExpr{
-																	pos:  position{line: 133, col: 25, offset: 2610},
+																	pos:  position{line: 128, col: 25, offset: 3010},
 																	name: "_",
 																},
 																&labeledExpr{
-																	pos:   position{line: 133, col: 27, offset: 2612},
+																	pos:   position{line: 128, col: 27, offset: 3012},
 																	label: "t",
 																	expr: &ruleRefExpr{
-																		pos:  position{line: 133, col: 29, offset: 2614},
+																		pos:  position{line: 128, col: 29, offset: 3014},
 																		name: "ColumnSchema",
 																	},
 																},
@@ -772,11 +771,11 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 136, col: 2, offset: 2686},
+							pos:  position{line: 131, col: 2, offset: 3099},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 136, col: 4, offset: 2688},
+							pos:        position{line: 131, col: 4, offset: 3101},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -786,53 +785,53 @@ var g = &grammar{
 		},
 		{
 			name: "ColumnSchema",
-			pos:  position{line: 144, col: 1, offset: 2803},
+			pos:  position{line: 143, col: 1, offset: 3402},
 			expr: &actionExpr{
-				pos: position{line: 145, col: 4, offset: 2819},
+				pos: position{line: 144, col: 4, offset: 3418},
 				run: (*parser).callonColumnSchema1,
 				expr: &seqExpr{
-					pos: position{line: 145, col: 4, offset: 2819},
+					pos: position{line: 144, col: 4, offset: 3418},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 145, col: 4, offset: 2819},
+							pos:   position{line: 144, col: 4, offset: 3418},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 145, col: 6, offset: 2821},
+								pos:  position{line: 144, col: 6, offset: 3420},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 146, col: 2, offset: 2833},
+							pos:  position{line: 145, col: 2, offset: 3432},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 146, col: 4, offset: 2835},
+							pos:   position{line: 145, col: 4, offset: 3434},
 							label: "t",
 							expr: &ruleRefExpr{
-								pos:  position{line: 146, col: 6, offset: 2837},
+								pos:  position{line: 145, col: 6, offset: 3436},
 								name: "DataType",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 147, col: 2, offset: 2847},
+							pos:   position{line: 146, col: 2, offset: 3446},
 							label: "cs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 147, col: 5, offset: 2850},
+								pos: position{line: 146, col: 5, offset: 3449},
 								expr: &actionExpr{
-									pos: position{line: 147, col: 7, offset: 2852},
+									pos: position{line: 146, col: 7, offset: 3451},
 									run: (*parser).callonColumnSchema10,
 									expr: &seqExpr{
-										pos: position{line: 147, col: 7, offset: 2852},
+										pos: position{line: 146, col: 7, offset: 3451},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 147, col: 7, offset: 2852},
+												pos:  position{line: 146, col: 7, offset: 3451},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 147, col: 9, offset: 2854},
+												pos:   position{line: 146, col: 9, offset: 3453},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 147, col: 11, offset: 2856},
+													pos:  position{line: 146, col: 11, offset: 3455},
 													name: "ColumnConstraint",
 												},
 											},
@@ -847,32 +846,32 @@ var g = &grammar{
 		},
 		{
 			name: "ColumnConstraint",
-			pos:  position{line: 156, col: 1, offset: 3019},
+			pos:  position{line: 174, col: 1, offset: 4230},
 			expr: &choiceExpr{
-				pos: position{line: 157, col: 4, offset: 3039},
+				pos: position{line: 175, col: 4, offset: 4250},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 157, col: 4, offset: 3039},
+						pos:  position{line: 175, col: 4, offset: 4250},
 						name: "PrimaryKeyClause",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 158, col: 4, offset: 3059},
+						pos:  position{line: 176, col: 4, offset: 4270},
 						name: "NotNullClause",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 159, col: 4, offset: 3076},
+						pos:  position{line: 177, col: 4, offset: 4287},
 						name: "UniqueClause",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 160, col: 4, offset: 3092},
+						pos:  position{line: 178, col: 4, offset: 4303},
 						name: "DefaultClause",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 161, col: 4, offset: 3109},
+						pos:  position{line: 179, col: 4, offset: 4320},
 						name: "ForeignClause",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 162, col: 4, offset: 3126},
+						pos:  position{line: 180, col: 4, offset: 4337},
 						name: "AutoincrementClause",
 					},
 				},
@@ -880,37 +879,37 @@ var g = &grammar{
 		},
 		{
 			name: "CreateIndexStmt",
-			pos:  position{line: 164, col: 1, offset: 3147},
+			pos:  position{line: 182, col: 1, offset: 4358},
 			expr: &actionExpr{
-				pos: position{line: 165, col: 4, offset: 3166},
+				pos: position{line: 183, col: 4, offset: 4377},
 				run: (*parser).callonCreateIndexStmt1,
 				expr: &seqExpr{
-					pos: position{line: 165, col: 4, offset: 3166},
+					pos: position{line: 183, col: 4, offset: 4377},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 165, col: 4, offset: 3166},
+							pos:  position{line: 183, col: 4, offset: 4377},
 							name: "CreateToken",
 						},
 						&labeledExpr{
-							pos:   position{line: 166, col: 2, offset: 3179},
+							pos:   position{line: 184, col: 2, offset: 4390},
 							label: "unique",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 166, col: 9, offset: 3186},
+								pos: position{line: 184, col: 9, offset: 4397},
 								expr: &actionExpr{
-									pos: position{line: 166, col: 11, offset: 3188},
+									pos: position{line: 184, col: 11, offset: 4399},
 									run: (*parser).callonCreateIndexStmt6,
 									expr: &seqExpr{
-										pos: position{line: 166, col: 11, offset: 3188},
+										pos: position{line: 184, col: 11, offset: 4399},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 166, col: 11, offset: 3188},
+												pos:  position{line: 184, col: 11, offset: 4399},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 166, col: 13, offset: 3190},
+												pos:   position{line: 184, col: 13, offset: 4401},
 												label: "u",
 												expr: &ruleRefExpr{
-													pos:  position{line: 166, col: 15, offset: 3192},
+													pos:  position{line: 184, col: 15, offset: 4403},
 													name: "UniqueClause",
 												},
 											},
@@ -920,94 +919,94 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 167, col: 2, offset: 3227},
+							pos:  position{line: 185, col: 2, offset: 4438},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 167, col: 4, offset: 3229},
+							pos:  position{line: 185, col: 4, offset: 4440},
 							name: "IndexToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 168, col: 2, offset: 3241},
+							pos:  position{line: 186, col: 2, offset: 4452},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 168, col: 4, offset: 3243},
+							pos:   position{line: 186, col: 4, offset: 4454},
 							label: "index",
 							expr: &ruleRefExpr{
-								pos:  position{line: 168, col: 10, offset: 3249},
+								pos:  position{line: 186, col: 10, offset: 4460},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 169, col: 2, offset: 3261},
+							pos:  position{line: 187, col: 2, offset: 4472},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 169, col: 4, offset: 3263},
+							pos:  position{line: 187, col: 4, offset: 4474},
 							name: "OnToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 170, col: 2, offset: 3272},
+							pos:  position{line: 188, col: 2, offset: 4483},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 170, col: 4, offset: 3274},
+							pos:   position{line: 188, col: 4, offset: 4485},
 							label: "table",
 							expr: &ruleRefExpr{
-								pos:  position{line: 170, col: 10, offset: 3280},
+								pos:  position{line: 188, col: 10, offset: 4491},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 171, col: 2, offset: 3292},
+							pos:  position{line: 189, col: 2, offset: 4503},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 171, col: 4, offset: 3294},
+							pos:        position{line: 189, col: 4, offset: 4505},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 171, col: 8, offset: 3298},
+							pos:  position{line: 189, col: 8, offset: 4509},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 171, col: 10, offset: 3300},
+							pos:   position{line: 189, col: 10, offset: 4511},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 171, col: 12, offset: 3302},
+								pos:  position{line: 189, col: 12, offset: 4513},
 								name: "Identifier",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 171, col: 23, offset: 3313},
+							pos:   position{line: 189, col: 23, offset: 4524},
 							label: "is",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 171, col: 26, offset: 3316},
+								pos: position{line: 189, col: 26, offset: 4527},
 								expr: &actionExpr{
-									pos: position{line: 171, col: 28, offset: 3318},
+									pos: position{line: 189, col: 28, offset: 4529},
 									run: (*parser).callonCreateIndexStmt28,
 									expr: &seqExpr{
-										pos: position{line: 171, col: 28, offset: 3318},
+										pos: position{line: 189, col: 28, offset: 4529},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 171, col: 28, offset: 3318},
+												pos:  position{line: 189, col: 28, offset: 4529},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 171, col: 30, offset: 3320},
+												pos:  position{line: 189, col: 30, offset: 4531},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 171, col: 45, offset: 3335},
+												pos:  position{line: 189, col: 45, offset: 4546},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 171, col: 47, offset: 3337},
+												pos:   position{line: 189, col: 47, offset: 4548},
 												label: "x",
 												expr: &ruleRefExpr{
-													pos:  position{line: 171, col: 49, offset: 3339},
+													pos:  position{line: 189, col: 49, offset: 4550},
 													name: "Identifier",
 												},
 											},
@@ -1017,11 +1016,11 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 171, col: 81, offset: 3371},
+							pos:  position{line: 189, col: 81, offset: 4582},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 171, col: 83, offset: 3373},
+							pos:        position{line: 189, col: 83, offset: 4584},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -1031,26 +1030,26 @@ var g = &grammar{
 		},
 		{
 			name: "WhereClause",
-			pos:  position{line: 189, col: 1, offset: 3684},
+			pos:  position{line: 206, col: 1, offset: 5028},
 			expr: &actionExpr{
-				pos: position{line: 190, col: 4, offset: 3699},
+				pos: position{line: 207, col: 4, offset: 5043},
 				run: (*parser).callonWhereClause1,
 				expr: &seqExpr{
-					pos: position{line: 190, col: 4, offset: 3699},
+					pos: position{line: 207, col: 4, offset: 5043},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 190, col: 4, offset: 3699},
+							pos:  position{line: 207, col: 4, offset: 5043},
 							name: "WhereToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 190, col: 15, offset: 3710},
+							pos:  position{line: 207, col: 15, offset: 5054},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 190, col: 17, offset: 3712},
+							pos:   position{line: 207, col: 17, offset: 5056},
 							label: "e",
 							expr: &ruleRefExpr{
-								pos:  position{line: 190, col: 19, offset: 3714},
+								pos:  position{line: 207, col: 19, offset: 5058},
 								name: "Expr",
 							},
 						},
@@ -1060,65 +1059,65 @@ var g = &grammar{
 		},
 		{
 			name: "OrderByClause",
-			pos:  position{line: 193, col: 1, offset: 3770},
+			pos:  position{line: 214, col: 1, offset: 5153},
 			expr: &actionExpr{
-				pos: position{line: 194, col: 4, offset: 3787},
+				pos: position{line: 215, col: 4, offset: 5170},
 				run: (*parser).callonOrderByClause1,
 				expr: &seqExpr{
-					pos: position{line: 194, col: 4, offset: 3787},
+					pos: position{line: 215, col: 4, offset: 5170},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 194, col: 4, offset: 3787},
+							pos:  position{line: 215, col: 4, offset: 5170},
 							name: "OrderToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 195, col: 2, offset: 3799},
+							pos:  position{line: 216, col: 2, offset: 5182},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 195, col: 4, offset: 3801},
+							pos:  position{line: 216, col: 4, offset: 5184},
 							name: "ByToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 196, col: 2, offset: 3810},
+							pos:  position{line: 217, col: 2, offset: 5193},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 196, col: 4, offset: 3812},
+							pos:   position{line: 217, col: 4, offset: 5195},
 							label: "f",
 							expr: &ruleRefExpr{
-								pos:  position{line: 196, col: 6, offset: 3814},
+								pos:  position{line: 217, col: 6, offset: 5197},
 								name: "OrderColumn",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 197, col: 2, offset: 3827},
+							pos:   position{line: 218, col: 2, offset: 5210},
 							label: "fs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 197, col: 5, offset: 3830},
+								pos: position{line: 218, col: 5, offset: 5213},
 								expr: &actionExpr{
-									pos: position{line: 197, col: 7, offset: 3832},
+									pos: position{line: 218, col: 7, offset: 5215},
 									run: (*parser).callonOrderByClause11,
 									expr: &seqExpr{
-										pos: position{line: 197, col: 7, offset: 3832},
+										pos: position{line: 218, col: 7, offset: 5215},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 197, col: 7, offset: 3832},
+												pos:  position{line: 218, col: 7, offset: 5215},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 197, col: 9, offset: 3834},
+												pos:  position{line: 218, col: 9, offset: 5217},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 197, col: 24, offset: 3849},
+												pos:  position{line: 218, col: 24, offset: 5232},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 197, col: 26, offset: 3851},
+												pos:   position{line: 218, col: 26, offset: 5234},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 197, col: 28, offset: 3853},
+													pos:  position{line: 218, col: 28, offset: 5236},
 													name: "OrderColumn",
 												},
 											},
@@ -1133,48 +1132,48 @@ var g = &grammar{
 		},
 		{
 			name: "OrderColumn",
-			pos:  position{line: 200, col: 1, offset: 3918},
+			pos:  position{line: 223, col: 1, offset: 5315},
 			expr: &actionExpr{
-				pos: position{line: 201, col: 4, offset: 3933},
+				pos: position{line: 224, col: 4, offset: 5330},
 				run: (*parser).callonOrderColumn1,
 				expr: &seqExpr{
-					pos: position{line: 201, col: 4, offset: 3933},
+					pos: position{line: 224, col: 4, offset: 5330},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 201, col: 4, offset: 3933},
+							pos:   position{line: 224, col: 4, offset: 5330},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 201, col: 6, offset: 3935},
+								pos:  position{line: 224, col: 6, offset: 5332},
 								name: "Expr",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 202, col: 2, offset: 3941},
+							pos:   position{line: 225, col: 2, offset: 5338},
 							label: "s",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 202, col: 4, offset: 3943},
+								pos: position{line: 225, col: 4, offset: 5340},
 								expr: &actionExpr{
-									pos: position{line: 202, col: 6, offset: 3945},
+									pos: position{line: 225, col: 6, offset: 5342},
 									run: (*parser).callonOrderColumn7,
 									expr: &seqExpr{
-										pos: position{line: 202, col: 6, offset: 3945},
+										pos: position{line: 225, col: 6, offset: 5342},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 202, col: 6, offset: 3945},
+												pos:  position{line: 225, col: 6, offset: 5342},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 202, col: 8, offset: 3947},
+												pos:   position{line: 225, col: 8, offset: 5344},
 												label: "t",
 												expr: &choiceExpr{
-													pos: position{line: 202, col: 12, offset: 3951},
+													pos: position{line: 225, col: 12, offset: 5348},
 													alternatives: []interface{}{
 														&ruleRefExpr{
-															pos:  position{line: 202, col: 12, offset: 3951},
+															pos:  position{line: 225, col: 12, offset: 5348},
 															name: "AscToken",
 														},
 														&ruleRefExpr{
-															pos:  position{line: 202, col: 23, offset: 3962},
+															pos:  position{line: 225, col: 23, offset: 5359},
 															name: "DescToken",
 														},
 													},
@@ -1186,40 +1185,40 @@ var g = &grammar{
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 203, col: 2, offset: 3996},
+							pos:   position{line: 226, col: 2, offset: 5393},
 							label: "n",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 203, col: 4, offset: 3998},
+								pos: position{line: 226, col: 4, offset: 5395},
 								expr: &actionExpr{
-									pos: position{line: 203, col: 6, offset: 4000},
+									pos: position{line: 226, col: 6, offset: 5397},
 									run: (*parser).callonOrderColumn16,
 									expr: &seqExpr{
-										pos: position{line: 203, col: 6, offset: 4000},
+										pos: position{line: 226, col: 6, offset: 5397},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 203, col: 6, offset: 4000},
+												pos:  position{line: 226, col: 6, offset: 5397},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 203, col: 8, offset: 4002},
+												pos:  position{line: 226, col: 8, offset: 5399},
 												name: "NullsToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 203, col: 19, offset: 4013},
+												pos:  position{line: 226, col: 19, offset: 5410},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 203, col: 21, offset: 4015},
+												pos:   position{line: 226, col: 21, offset: 5412},
 												label: "l",
 												expr: &choiceExpr{
-													pos: position{line: 203, col: 25, offset: 4019},
+													pos: position{line: 226, col: 25, offset: 5416},
 													alternatives: []interface{}{
 														&ruleRefExpr{
-															pos:  position{line: 203, col: 25, offset: 4019},
+															pos:  position{line: 226, col: 25, offset: 5416},
 															name: "LastToken",
 														},
 														&ruleRefExpr{
-															pos:  position{line: 203, col: 37, offset: 4031},
+															pos:  position{line: 226, col: 37, offset: 5428},
 															name: "FirstToken",
 														},
 													},
@@ -1236,66 +1235,66 @@ var g = &grammar{
 		},
 		{
 			name: "GroupByClause",
-			pos:  position{line: 212, col: 1, offset: 4237},
+			pos:  position{line: 235, col: 1, offset: 5662},
 			expr: &actionExpr{
-				pos: position{line: 213, col: 4, offset: 4254},
+				pos: position{line: 236, col: 4, offset: 5679},
 				run: (*parser).callonGroupByClause1,
 				expr: &seqExpr{
-					pos: position{line: 213, col: 4, offset: 4254},
+					pos: position{line: 236, col: 4, offset: 5679},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 213, col: 4, offset: 4254},
+							pos:  position{line: 236, col: 4, offset: 5679},
 							name: "GroupToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 214, col: 2, offset: 4266},
+							pos:  position{line: 237, col: 2, offset: 5691},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 214, col: 4, offset: 4268},
+							pos:  position{line: 237, col: 4, offset: 5693},
 							name: "ByToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 215, col: 2, offset: 4277},
+							pos:  position{line: 238, col: 2, offset: 5702},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 215, col: 4, offset: 4279},
-							label: "i",
+							pos:   position{line: 238, col: 4, offset: 5704},
+							label: "f",
 							expr: &ruleRefExpr{
-								pos:  position{line: 215, col: 6, offset: 4281},
-								name: "Expr",
+								pos:  position{line: 238, col: 6, offset: 5706},
+								name: "GroupColumn",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 216, col: 2, offset: 4287},
-							label: "is",
+							pos:   position{line: 239, col: 2, offset: 5719},
+							label: "fs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 216, col: 5, offset: 4290},
+								pos: position{line: 239, col: 5, offset: 5722},
 								expr: &actionExpr{
-									pos: position{line: 216, col: 7, offset: 4292},
+									pos: position{line: 239, col: 7, offset: 5724},
 									run: (*parser).callonGroupByClause11,
 									expr: &seqExpr{
-										pos: position{line: 216, col: 7, offset: 4292},
+										pos: position{line: 239, col: 7, offset: 5724},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 216, col: 7, offset: 4292},
+												pos:  position{line: 239, col: 7, offset: 5724},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 216, col: 9, offset: 4294},
+												pos:  position{line: 239, col: 9, offset: 5726},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 216, col: 24, offset: 4309},
+												pos:  position{line: 239, col: 24, offset: 5741},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 216, col: 26, offset: 4311},
+												pos:   position{line: 239, col: 26, offset: 5743},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 216, col: 28, offset: 4313},
-													name: "Expr",
+													pos:  position{line: 239, col: 28, offset: 5745},
+													name: "GroupColumn",
 												},
 											},
 										},
@@ -1308,27 +1307,43 @@ var g = &grammar{
 			},
 		},
 		{
+			name: "GroupColumn",
+			pos:  position{line: 244, col: 1, offset: 5824},
+			expr: &actionExpr{
+				pos: position{line: 245, col: 4, offset: 5839},
+				run: (*parser).callonGroupColumn1,
+				expr: &labeledExpr{
+					pos:   position{line: 245, col: 4, offset: 5839},
+					label: "i",
+					expr: &ruleRefExpr{
+						pos:  position{line: 245, col: 6, offset: 5841},
+						name: "Expr",
+					},
+				},
+			},
+		},
+		{
 			name: "OffsetClause",
-			pos:  position{line: 219, col: 1, offset: 4425},
+			pos:  position{line: 252, col: 1, offset: 5931},
 			expr: &actionExpr{
-				pos: position{line: 220, col: 4, offset: 4441},
+				pos: position{line: 253, col: 4, offset: 5947},
 				run: (*parser).callonOffsetClause1,
 				expr: &seqExpr{
-					pos: position{line: 220, col: 4, offset: 4441},
+					pos: position{line: 253, col: 4, offset: 5947},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 220, col: 4, offset: 4441},
+							pos:  position{line: 253, col: 4, offset: 5947},
 							name: "OffsetToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 220, col: 16, offset: 4453},
+							pos:  position{line: 253, col: 16, offset: 5959},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 220, col: 18, offset: 4455},
+							pos:   position{line: 253, col: 18, offset: 5961},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 220, col: 20, offset: 4457},
+								pos:  position{line: 253, col: 20, offset: 5963},
 								name: "Integer",
 							},
 						},
@@ -1338,26 +1353,26 @@ var g = &grammar{
 		},
 		{
 			name: "LimitClause",
-			pos:  position{line: 223, col: 1, offset: 4536},
+			pos:  position{line: 260, col: 1, offset: 6067},
 			expr: &actionExpr{
-				pos: position{line: 224, col: 4, offset: 4551},
+				pos: position{line: 261, col: 4, offset: 6082},
 				run: (*parser).callonLimitClause1,
 				expr: &seqExpr{
-					pos: position{line: 224, col: 4, offset: 4551},
+					pos: position{line: 261, col: 4, offset: 6082},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 224, col: 4, offset: 4551},
+							pos:  position{line: 261, col: 4, offset: 6082},
 							name: "LimitToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 224, col: 15, offset: 4562},
+							pos:  position{line: 261, col: 15, offset: 6093},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 224, col: 17, offset: 4564},
+							pos:   position{line: 261, col: 17, offset: 6095},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 224, col: 19, offset: 4566},
+								pos:  position{line: 261, col: 19, offset: 6097},
 								name: "Integer",
 							},
 						},
@@ -1367,69 +1382,69 @@ var g = &grammar{
 		},
 		{
 			name: "InsertWithColumnClause",
-			pos:  position{line: 227, col: 1, offset: 4644},
+			pos:  position{line: 268, col: 1, offset: 6200},
 			expr: &actionExpr{
-				pos: position{line: 228, col: 4, offset: 4670},
+				pos: position{line: 269, col: 4, offset: 6226},
 				run: (*parser).callonInsertWithColumnClause1,
 				expr: &seqExpr{
-					pos: position{line: 228, col: 4, offset: 4670},
+					pos: position{line: 269, col: 4, offset: 6226},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 228, col: 4, offset: 4670},
+							pos:   position{line: 269, col: 4, offset: 6226},
 							label: "cs",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 228, col: 7, offset: 4673},
+								pos: position{line: 269, col: 7, offset: 6229},
 								expr: &actionExpr{
-									pos: position{line: 228, col: 9, offset: 4675},
+									pos: position{line: 269, col: 9, offset: 6231},
 									run: (*parser).callonInsertWithColumnClause5,
 									expr: &seqExpr{
-										pos: position{line: 228, col: 9, offset: 4675},
+										pos: position{line: 269, col: 9, offset: 6231},
 										exprs: []interface{}{
 											&litMatcher{
-												pos:        position{line: 228, col: 9, offset: 4675},
+												pos:        position{line: 269, col: 9, offset: 6231},
 												val:        "(",
 												ignoreCase: false,
 											},
 											&ruleRefExpr{
-												pos:  position{line: 229, col: 4, offset: 4682},
+												pos:  position{line: 270, col: 4, offset: 6238},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 229, col: 6, offset: 4684},
+												pos:   position{line: 270, col: 6, offset: 6240},
 												label: "f",
 												expr: &ruleRefExpr{
-													pos:  position{line: 229, col: 8, offset: 4686},
+													pos:  position{line: 270, col: 8, offset: 6242},
 													name: "Identifier",
 												},
 											},
 											&labeledExpr{
-												pos:   position{line: 230, col: 4, offset: 4700},
+												pos:   position{line: 271, col: 4, offset: 6256},
 												label: "fs",
 												expr: &zeroOrMoreExpr{
-													pos: position{line: 230, col: 7, offset: 4703},
+													pos: position{line: 271, col: 7, offset: 6259},
 													expr: &actionExpr{
-														pos: position{line: 230, col: 9, offset: 4705},
+														pos: position{line: 271, col: 9, offset: 6261},
 														run: (*parser).callonInsertWithColumnClause13,
 														expr: &seqExpr{
-															pos: position{line: 230, col: 9, offset: 4705},
+															pos: position{line: 271, col: 9, offset: 6261},
 															exprs: []interface{}{
 																&ruleRefExpr{
-																	pos:  position{line: 230, col: 9, offset: 4705},
+																	pos:  position{line: 271, col: 9, offset: 6261},
 																	name: "_",
 																},
 																&ruleRefExpr{
-																	pos:  position{line: 230, col: 11, offset: 4707},
+																	pos:  position{line: 271, col: 11, offset: 6263},
 																	name: "SeparatorToken",
 																},
 																&ruleRefExpr{
-																	pos:  position{line: 230, col: 26, offset: 4722},
+																	pos:  position{line: 271, col: 26, offset: 6278},
 																	name: "_",
 																},
 																&labeledExpr{
-																	pos:   position{line: 230, col: 28, offset: 4724},
+																	pos:   position{line: 271, col: 28, offset: 6280},
 																	label: "x",
 																	expr: &ruleRefExpr{
-																		pos:  position{line: 230, col: 30, offset: 4726},
+																		pos:  position{line: 271, col: 30, offset: 6282},
 																		name: "Identifier",
 																	},
 																},
@@ -1439,16 +1454,16 @@ var g = &grammar{
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 231, col: 4, offset: 4761},
+												pos:  position{line: 272, col: 4, offset: 6317},
 												name: "_",
 											},
 											&litMatcher{
-												pos:        position{line: 231, col: 6, offset: 4763},
+												pos:        position{line: 272, col: 6, offset: 6319},
 												val:        ")",
 												ignoreCase: false,
 											},
 											&ruleRefExpr{
-												pos:  position{line: 232, col: 4, offset: 4770},
+												pos:  position{line: 273, col: 4, offset: 6326},
 												name: "_",
 											},
 										},
@@ -1457,49 +1472,49 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 234, col: 3, offset: 4810},
+							pos:  position{line: 275, col: 3, offset: 6379},
 							name: "ValuesToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 235, col: 2, offset: 4823},
+							pos:  position{line: 276, col: 2, offset: 6392},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 235, col: 4, offset: 4825},
+							pos:   position{line: 276, col: 4, offset: 6394},
 							label: "v",
 							expr: &ruleRefExpr{
-								pos:  position{line: 235, col: 6, offset: 4827},
+								pos:  position{line: 276, col: 6, offset: 6396},
 								name: "InsertValue",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 236, col: 2, offset: 4840},
+							pos:   position{line: 277, col: 2, offset: 6409},
 							label: "vs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 236, col: 5, offset: 4843},
+								pos: position{line: 277, col: 5, offset: 6412},
 								expr: &actionExpr{
-									pos: position{line: 236, col: 7, offset: 4845},
+									pos: position{line: 277, col: 7, offset: 6414},
 									run: (*parser).callonInsertWithColumnClause29,
 									expr: &seqExpr{
-										pos: position{line: 236, col: 7, offset: 4845},
+										pos: position{line: 277, col: 7, offset: 6414},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 236, col: 7, offset: 4845},
+												pos:  position{line: 277, col: 7, offset: 6414},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 236, col: 9, offset: 4847},
+												pos:  position{line: 277, col: 9, offset: 6416},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 236, col: 24, offset: 4862},
+												pos:  position{line: 277, col: 24, offset: 6431},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 236, col: 26, offset: 4864},
+												pos:   position{line: 277, col: 26, offset: 6433},
 												label: "y",
 												expr: &ruleRefExpr{
-													pos:  position{line: 236, col: 28, offset: 4866},
+													pos:  position{line: 277, col: 28, offset: 6435},
 													name: "InsertValue",
 												},
 											},
@@ -1514,23 +1529,23 @@ var g = &grammar{
 		},
 		{
 			name: "InsertWithDefaultClause",
-			pos:  position{line: 244, col: 1, offset: 5001},
+			pos:  position{line: 294, col: 1, offset: 6934},
 			expr: &actionExpr{
-				pos: position{line: 245, col: 4, offset: 5028},
+				pos: position{line: 295, col: 4, offset: 6961},
 				run: (*parser).callonInsertWithDefaultClause1,
 				expr: &seqExpr{
-					pos: position{line: 245, col: 4, offset: 5028},
+					pos: position{line: 295, col: 4, offset: 6961},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 245, col: 4, offset: 5028},
+							pos:  position{line: 295, col: 4, offset: 6961},
 							name: "DefaultToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 245, col: 17, offset: 5041},
+							pos:  position{line: 295, col: 17, offset: 6974},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 245, col: 19, offset: 5043},
+							pos:  position{line: 295, col: 19, offset: 6976},
 							name: "ValuesToken",
 						},
 					},
@@ -1539,23 +1554,23 @@ var g = &grammar{
 		},
 		{
 			name: "PrimaryKeyClause",
-			pos:  position{line: 248, col: 1, offset: 5106},
+			pos:  position{line: 301, col: 1, offset: 7055},
 			expr: &actionExpr{
-				pos: position{line: 249, col: 4, offset: 5126},
+				pos: position{line: 302, col: 4, offset: 7075},
 				run: (*parser).callonPrimaryKeyClause1,
 				expr: &seqExpr{
-					pos: position{line: 249, col: 4, offset: 5126},
+					pos: position{line: 302, col: 4, offset: 7075},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 249, col: 4, offset: 5126},
+							pos:  position{line: 302, col: 4, offset: 7075},
 							name: "PrimaryToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 249, col: 17, offset: 5139},
+							pos:  position{line: 302, col: 17, offset: 7088},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 249, col: 19, offset: 5141},
+							pos:  position{line: 302, col: 19, offset: 7090},
 							name: "KeyToken",
 						},
 					},
@@ -1564,23 +1579,23 @@ var g = &grammar{
 		},
 		{
 			name: "NotNullClause",
-			pos:  position{line: 252, col: 1, offset: 5191},
+			pos:  position{line: 308, col: 1, offset: 7156},
 			expr: &actionExpr{
-				pos: position{line: 253, col: 4, offset: 5208},
+				pos: position{line: 309, col: 4, offset: 7173},
 				run: (*parser).callonNotNullClause1,
 				expr: &seqExpr{
-					pos: position{line: 253, col: 4, offset: 5208},
+					pos: position{line: 309, col: 4, offset: 7173},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 253, col: 4, offset: 5208},
+							pos:  position{line: 309, col: 4, offset: 7173},
 							name: "NotToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 253, col: 13, offset: 5217},
+							pos:  position{line: 309, col: 13, offset: 7182},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 253, col: 15, offset: 5219},
+							pos:  position{line: 309, col: 15, offset: 7184},
 							name: "NullToken",
 						},
 					},
@@ -1589,38 +1604,38 @@ var g = &grammar{
 		},
 		{
 			name: "UniqueClause",
-			pos:  position{line: 256, col: 1, offset: 5270},
+			pos:  position{line: 315, col: 1, offset: 7251},
 			expr: &actionExpr{
-				pos: position{line: 257, col: 4, offset: 5286},
+				pos: position{line: 316, col: 4, offset: 7267},
 				run: (*parser).callonUniqueClause1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 257, col: 4, offset: 5286},
+					pos:  position{line: 316, col: 4, offset: 7267},
 					name: "UniqueToken",
 				},
 			},
 		},
 		{
 			name: "DefaultClause",
-			pos:  position{line: 260, col: 1, offset: 5338},
+			pos:  position{line: 322, col: 1, offset: 7335},
 			expr: &actionExpr{
-				pos: position{line: 261, col: 4, offset: 5355},
+				pos: position{line: 323, col: 4, offset: 7352},
 				run: (*parser).callonDefaultClause1,
 				expr: &seqExpr{
-					pos: position{line: 261, col: 4, offset: 5355},
+					pos: position{line: 323, col: 4, offset: 7352},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 261, col: 4, offset: 5355},
+							pos:  position{line: 323, col: 4, offset: 7352},
 							name: "DefaultToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 261, col: 17, offset: 5368},
+							pos:  position{line: 323, col: 17, offset: 7365},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 261, col: 19, offset: 5370},
+							pos:   position{line: 323, col: 19, offset: 7367},
 							label: "e",
 							expr: &ruleRefExpr{
-								pos:  position{line: 261, col: 21, offset: 5372},
+								pos:  position{line: 323, col: 21, offset: 7369},
 								name: "Expr",
 							},
 						},
@@ -1630,56 +1645,56 @@ var g = &grammar{
 		},
 		{
 			name: "ForeignClause",
-			pos:  position{line: 264, col: 1, offset: 5426},
+			pos:  position{line: 330, col: 1, offset: 7462},
 			expr: &actionExpr{
-				pos: position{line: 265, col: 4, offset: 5443},
+				pos: position{line: 331, col: 4, offset: 7479},
 				run: (*parser).callonForeignClause1,
 				expr: &seqExpr{
-					pos: position{line: 265, col: 4, offset: 5443},
+					pos: position{line: 331, col: 4, offset: 7479},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 265, col: 4, offset: 5443},
+							pos:  position{line: 331, col: 4, offset: 7479},
 							name: "ReferencesToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 265, col: 20, offset: 5459},
+							pos:  position{line: 331, col: 20, offset: 7495},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 265, col: 22, offset: 5461},
+							pos:   position{line: 331, col: 22, offset: 7497},
 							label: "t",
 							expr: &ruleRefExpr{
-								pos:  position{line: 265, col: 24, offset: 5463},
+								pos:  position{line: 331, col: 24, offset: 7499},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 265, col: 35, offset: 5474},
+							pos:  position{line: 331, col: 35, offset: 7510},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 265, col: 37, offset: 5476},
+							pos:        position{line: 331, col: 37, offset: 7512},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 265, col: 41, offset: 5480},
+							pos:  position{line: 331, col: 41, offset: 7516},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 265, col: 43, offset: 5482},
+							pos:   position{line: 331, col: 43, offset: 7518},
 							label: "f",
 							expr: &ruleRefExpr{
-								pos:  position{line: 265, col: 45, offset: 5484},
+								pos:  position{line: 331, col: 45, offset: 7520},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 265, col: 56, offset: 5495},
+							pos:  position{line: 331, col: 56, offset: 7531},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 265, col: 58, offset: 5497},
+							pos:        position{line: 331, col: 58, offset: 7533},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -1689,48 +1704,48 @@ var g = &grammar{
 		},
 		{
 			name: "AutoincrementClause",
-			pos:  position{line: 273, col: 1, offset: 5613},
+			pos:  position{line: 339, col: 1, offset: 7671},
 			expr: &actionExpr{
-				pos: position{line: 274, col: 4, offset: 5636},
+				pos: position{line: 340, col: 4, offset: 7694},
 				run: (*parser).callonAutoincrementClause1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 274, col: 4, offset: 5636},
+					pos:  position{line: 340, col: 4, offset: 7694},
 					name: "AutoincrementToken",
 				},
 			},
 		},
 		{
 			name: "Expr",
-			pos:  position{line: 278, col: 1, offset: 5720},
+			pos:  position{line: 347, col: 1, offset: 7794},
 			expr: &ruleRefExpr{
-				pos:  position{line: 279, col: 4, offset: 5728},
+				pos:  position{line: 348, col: 4, offset: 7802},
 				name: "LogicExpr",
 			},
 		},
 		{
 			name: "ExprWithDefault",
-			pos:  position{line: 281, col: 1, offset: 5739},
+			pos:  position{line: 350, col: 1, offset: 7813},
 			expr: &choiceExpr{
-				pos: position{line: 282, col: 4, offset: 5758},
+				pos: position{line: 351, col: 4, offset: 7832},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 282, col: 4, offset: 5758},
+						pos: position{line: 351, col: 4, offset: 7832},
 						run: (*parser).callonExprWithDefault2,
 						expr: &seqExpr{
-							pos: position{line: 282, col: 4, offset: 5758},
+							pos: position{line: 351, col: 4, offset: 7832},
 							exprs: []interface{}{
 								&andExpr{
-									pos: position{line: 282, col: 4, offset: 5758},
+									pos: position{line: 351, col: 4, offset: 7832},
 									expr: &ruleRefExpr{
-										pos:  position{line: 282, col: 6, offset: 5760},
+										pos:  position{line: 351, col: 6, offset: 7834},
 										name: "DefaultLiteral",
 									},
 								},
 								&labeledExpr{
-									pos:   position{line: 282, col: 22, offset: 5776},
+									pos:   position{line: 351, col: 22, offset: 7850},
 									label: "d",
 									expr: &ruleRefExpr{
-										pos:  position{line: 282, col: 24, offset: 5778},
+										pos:  position{line: 351, col: 24, offset: 7852},
 										name: "DefaultLiteral",
 									},
 								},
@@ -1738,7 +1753,7 @@ var g = &grammar{
 						},
 					},
 					&ruleRefExpr{
-						pos:  position{line: 283, col: 4, offset: 5814},
+						pos:  position{line: 352, col: 4, offset: 7888},
 						name: "Expr",
 					},
 				},
@@ -1746,61 +1761,61 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr",
-			pos:  position{line: 285, col: 1, offset: 5820},
+			pos:  position{line: 354, col: 1, offset: 7894},
 			expr: &ruleRefExpr{
-				pos:  position{line: 286, col: 4, offset: 5833},
+				pos:  position{line: 355, col: 4, offset: 7907},
 				name: "LogicExpr4",
 			},
 		},
 		{
 			name: "LogicExpr4",
-			pos:  position{line: 288, col: 1, offset: 5845},
+			pos:  position{line: 357, col: 1, offset: 7919},
 			expr: &actionExpr{
-				pos: position{line: 289, col: 4, offset: 5859},
+				pos: position{line: 358, col: 4, offset: 7933},
 				run: (*parser).callonLogicExpr41,
 				expr: &seqExpr{
-					pos: position{line: 289, col: 4, offset: 5859},
+					pos: position{line: 358, col: 4, offset: 7933},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 289, col: 4, offset: 5859},
+							pos:   position{line: 358, col: 4, offset: 7933},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 289, col: 6, offset: 5861},
+								pos:  position{line: 358, col: 6, offset: 7935},
 								name: "LogicExpr3",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 290, col: 3, offset: 5874},
+							pos:   position{line: 359, col: 3, offset: 7948},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 290, col: 6, offset: 5877},
+								pos: position{line: 359, col: 6, offset: 7951},
 								expr: &actionExpr{
-									pos: position{line: 290, col: 8, offset: 5879},
+									pos: position{line: 359, col: 8, offset: 7953},
 									run: (*parser).callonLogicExpr47,
 									expr: &seqExpr{
-										pos: position{line: 290, col: 8, offset: 5879},
+										pos: position{line: 359, col: 8, offset: 7953},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 290, col: 8, offset: 5879},
+												pos:  position{line: 359, col: 8, offset: 7953},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 290, col: 10, offset: 5881},
+												pos:   position{line: 359, col: 10, offset: 7955},
 												label: "op",
 												expr: &ruleRefExpr{
-													pos:  position{line: 290, col: 13, offset: 5884},
+													pos:  position{line: 359, col: 13, offset: 7958},
 													name: "OrOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 290, col: 24, offset: 5895},
+												pos:  position{line: 359, col: 24, offset: 7969},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 290, col: 26, offset: 5897},
+												pos:   position{line: 359, col: 26, offset: 7971},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 290, col: 28, offset: 5899},
+													pos:  position{line: 359, col: 28, offset: 7973},
 													name: "LogicExpr3",
 												},
 											},
@@ -1815,53 +1830,53 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr3",
-			pos:  position{line: 293, col: 1, offset: 5992},
+			pos:  position{line: 363, col: 1, offset: 8136},
 			expr: &actionExpr{
-				pos: position{line: 294, col: 4, offset: 6006},
+				pos: position{line: 364, col: 4, offset: 8150},
 				run: (*parser).callonLogicExpr31,
 				expr: &seqExpr{
-					pos: position{line: 294, col: 4, offset: 6006},
+					pos: position{line: 364, col: 4, offset: 8150},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 294, col: 4, offset: 6006},
+							pos:   position{line: 364, col: 4, offset: 8150},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 294, col: 6, offset: 6008},
+								pos:  position{line: 364, col: 6, offset: 8152},
 								name: "LogicExpr2",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 295, col: 3, offset: 6021},
+							pos:   position{line: 365, col: 3, offset: 8165},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 295, col: 6, offset: 6024},
+								pos: position{line: 365, col: 6, offset: 8168},
 								expr: &actionExpr{
-									pos: position{line: 295, col: 8, offset: 6026},
+									pos: position{line: 365, col: 8, offset: 8170},
 									run: (*parser).callonLogicExpr37,
 									expr: &seqExpr{
-										pos: position{line: 295, col: 8, offset: 6026},
+										pos: position{line: 365, col: 8, offset: 8170},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 295, col: 8, offset: 6026},
+												pos:  position{line: 365, col: 8, offset: 8170},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 295, col: 10, offset: 6028},
+												pos:   position{line: 365, col: 10, offset: 8172},
 												label: "op",
 												expr: &ruleRefExpr{
-													pos:  position{line: 295, col: 13, offset: 6031},
+													pos:  position{line: 365, col: 13, offset: 8175},
 													name: "AndOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 295, col: 25, offset: 6043},
+												pos:  position{line: 365, col: 25, offset: 8187},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 295, col: 27, offset: 6045},
+												pos:   position{line: 365, col: 27, offset: 8189},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 295, col: 29, offset: 6047},
+													pos:  position{line: 365, col: 29, offset: 8191},
 													name: "LogicExpr2",
 												},
 											},
@@ -1876,33 +1891,33 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr2",
-			pos:  position{line: 298, col: 1, offset: 6140},
+			pos:  position{line: 369, col: 1, offset: 8354},
 			expr: &choiceExpr{
-				pos: position{line: 299, col: 4, offset: 6154},
+				pos: position{line: 370, col: 4, offset: 8368},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 299, col: 4, offset: 6154},
+						pos: position{line: 370, col: 4, offset: 8368},
 						run: (*parser).callonLogicExpr22,
 						expr: &seqExpr{
-							pos: position{line: 299, col: 4, offset: 6154},
+							pos: position{line: 370, col: 4, offset: 8368},
 							exprs: []interface{}{
 								&labeledExpr{
-									pos:   position{line: 299, col: 4, offset: 6154},
+									pos:   position{line: 370, col: 4, offset: 8368},
 									label: "op",
 									expr: &ruleRefExpr{
-										pos:  position{line: 299, col: 7, offset: 6157},
+										pos:  position{line: 370, col: 7, offset: 8371},
 										name: "NotOperator",
 									},
 								},
 								&ruleRefExpr{
-									pos:  position{line: 299, col: 19, offset: 6169},
+									pos:  position{line: 370, col: 19, offset: 8383},
 									name: "_",
 								},
 								&labeledExpr{
-									pos:   position{line: 299, col: 21, offset: 6171},
+									pos:   position{line: 370, col: 21, offset: 8385},
 									label: "s",
 									expr: &ruleRefExpr{
-										pos:  position{line: 299, col: 23, offset: 6173},
+										pos:  position{line: 370, col: 23, offset: 8387},
 										name: "LogicExpr2",
 									},
 								},
@@ -1910,7 +1925,7 @@ var g = &grammar{
 						},
 					},
 					&ruleRefExpr{
-						pos:  position{line: 301, col: 4, offset: 6223},
+						pos:  position{line: 372, col: 4, offset: 8472},
 						name: "LogicExpr1",
 					},
 				},
@@ -1918,41 +1933,41 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr1",
-			pos:  position{line: 303, col: 1, offset: 6235},
+			pos:  position{line: 374, col: 1, offset: 8484},
 			expr: &actionExpr{
-				pos: position{line: 304, col: 4, offset: 6249},
+				pos: position{line: 375, col: 4, offset: 8498},
 				run: (*parser).callonLogicExpr11,
 				expr: &seqExpr{
-					pos: position{line: 304, col: 4, offset: 6249},
+					pos: position{line: 375, col: 4, offset: 8498},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 304, col: 4, offset: 6249},
+							pos:   position{line: 375, col: 4, offset: 8498},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 304, col: 6, offset: 6251},
+								pos:  position{line: 375, col: 6, offset: 8500},
 								name: "ArithmeticExpr",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 304, col: 21, offset: 6266},
+							pos:   position{line: 375, col: 21, offset: 8515},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 304, col: 24, offset: 6269},
+								pos: position{line: 375, col: 24, offset: 8518},
 								expr: &actionExpr{
-									pos: position{line: 304, col: 26, offset: 6271},
+									pos: position{line: 375, col: 26, offset: 8520},
 									run: (*parser).callonLogicExpr17,
 									expr: &seqExpr{
-										pos: position{line: 304, col: 26, offset: 6271},
+										pos: position{line: 375, col: 26, offset: 8520},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 304, col: 26, offset: 6271},
+												pos:  position{line: 375, col: 26, offset: 8520},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 304, col: 28, offset: 6273},
+												pos:   position{line: 375, col: 28, offset: 8522},
 												label: "l",
 												expr: &ruleRefExpr{
-													pos:  position{line: 304, col: 30, offset: 6275},
+													pos:  position{line: 375, col: 30, offset: 8524},
 													name: "LogicExpr1Op",
 												},
 											},
@@ -1967,24 +1982,24 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr1Op",
-			pos:  position{line: 307, col: 1, offset: 6352},
+			pos:  position{line: 378, col: 1, offset: 8633},
 			expr: &choiceExpr{
-				pos: position{line: 308, col: 4, offset: 6368},
+				pos: position{line: 379, col: 4, offset: 8649},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 308, col: 4, offset: 6368},
+						pos:  position{line: 379, col: 4, offset: 8649},
 						name: "LogicExpr1In",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 309, col: 4, offset: 6384},
-						name: "LogicExpr1Null",
+						pos:  position{line: 380, col: 4, offset: 8665},
+						name: "LogicExpr1Is",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 310, col: 4, offset: 6402},
+						pos:  position{line: 381, col: 4, offset: 8681},
 						name: "LogicExpr1Like",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 311, col: 4, offset: 6420},
+						pos:  position{line: 382, col: 4, offset: 8699},
 						name: "LogicExpr1Cmp",
 					},
 				},
@@ -1992,34 +2007,34 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr1In",
-			pos:  position{line: 313, col: 1, offset: 6435},
+			pos:  position{line: 384, col: 1, offset: 8714},
 			expr: &actionExpr{
-				pos: position{line: 314, col: 4, offset: 6451},
+				pos: position{line: 385, col: 4, offset: 8730},
 				run: (*parser).callonLogicExpr1In1,
 				expr: &seqExpr{
-					pos: position{line: 314, col: 4, offset: 6451},
+					pos: position{line: 385, col: 4, offset: 8730},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 314, col: 4, offset: 6451},
+							pos:   position{line: 385, col: 4, offset: 8730},
 							label: "n",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 314, col: 6, offset: 6453},
+								pos: position{line: 385, col: 6, offset: 8732},
 								expr: &actionExpr{
-									pos: position{line: 314, col: 8, offset: 6455},
+									pos: position{line: 385, col: 8, offset: 8734},
 									run: (*parser).callonLogicExpr1In5,
 									expr: &seqExpr{
-										pos: position{line: 314, col: 8, offset: 6455},
+										pos: position{line: 385, col: 8, offset: 8734},
 										exprs: []interface{}{
 											&labeledExpr{
-												pos:   position{line: 314, col: 8, offset: 6455},
+												pos:   position{line: 385, col: 8, offset: 8734},
 												label: "t",
 												expr: &ruleRefExpr{
-													pos:  position{line: 314, col: 10, offset: 6457},
+													pos:  position{line: 385, col: 10, offset: 8736},
 													name: "NotOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 314, col: 22, offset: 6469},
+												pos:  position{line: 385, col: 22, offset: 8748},
 												name: "_",
 											},
 										},
@@ -2028,36 +2043,36 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 314, col: 45, offset: 6492},
+							pos:  position{line: 385, col: 45, offset: 8771},
 							name: "InToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 314, col: 53, offset: 6500},
+							pos:  position{line: 385, col: 53, offset: 8779},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 314, col: 55, offset: 6502},
+							pos:        position{line: 385, col: 55, offset: 8781},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 314, col: 59, offset: 6506},
+							pos:  position{line: 385, col: 59, offset: 8785},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 314, col: 61, offset: 6508},
+							pos:   position{line: 385, col: 61, offset: 8787},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 314, col: 63, offset: 6510},
+								pos:  position{line: 385, col: 63, offset: 8789},
 								name: "MultiExpr",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 314, col: 73, offset: 6520},
+							pos:  position{line: 385, col: 73, offset: 8799},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 314, col: 75, offset: 6522},
+							pos:        position{line: 385, col: 75, offset: 8801},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -2066,38 +2081,38 @@ var g = &grammar{
 			},
 		},
 		{
-			name: "LogicExpr1Null",
-			pos:  position{line: 323, col: 1, offset: 6644},
+			name: "LogicExpr1Is",
+			pos:  position{line: 395, col: 1, offset: 8965},
 			expr: &actionExpr{
-				pos: position{line: 324, col: 4, offset: 6662},
-				run: (*parser).callonLogicExpr1Null1,
+				pos: position{line: 396, col: 4, offset: 8981},
+				run: (*parser).callonLogicExpr1Is1,
 				expr: &seqExpr{
-					pos: position{line: 324, col: 4, offset: 6662},
+					pos: position{line: 396, col: 4, offset: 8981},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 324, col: 4, offset: 6662},
+							pos:  position{line: 396, col: 4, offset: 8981},
 							name: "IsToken",
 						},
 						&labeledExpr{
-							pos:   position{line: 324, col: 12, offset: 6670},
+							pos:   position{line: 396, col: 12, offset: 8989},
 							label: "n",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 324, col: 14, offset: 6672},
+								pos: position{line: 396, col: 14, offset: 8991},
 								expr: &actionExpr{
-									pos: position{line: 324, col: 16, offset: 6674},
-									run: (*parser).callonLogicExpr1Null6,
+									pos: position{line: 396, col: 16, offset: 8993},
+									run: (*parser).callonLogicExpr1Is6,
 									expr: &seqExpr{
-										pos: position{line: 324, col: 16, offset: 6674},
+										pos: position{line: 396, col: 16, offset: 8993},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 324, col: 16, offset: 6674},
+												pos:  position{line: 396, col: 16, offset: 8993},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 324, col: 18, offset: 6676},
+												pos:   position{line: 396, col: 18, offset: 8995},
 												label: "t",
 												expr: &ruleRefExpr{
-													pos:  position{line: 324, col: 20, offset: 6678},
+													pos:  position{line: 396, col: 20, offset: 8997},
 													name: "NotOperator",
 												},
 											},
@@ -2107,11 +2122,11 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 324, col: 53, offset: 6711},
+							pos:  position{line: 396, col: 53, offset: 9030},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 324, col: 55, offset: 6713},
+							pos:  position{line: 396, col: 55, offset: 9032},
 							name: "NullToken",
 						},
 					},
@@ -2120,34 +2135,34 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr1Like",
-			pos:  position{line: 333, col: 1, offset: 6859},
+			pos:  position{line: 407, col: 1, offset: 9225},
 			expr: &actionExpr{
-				pos: position{line: 334, col: 4, offset: 6877},
+				pos: position{line: 408, col: 4, offset: 9243},
 				run: (*parser).callonLogicExpr1Like1,
 				expr: &seqExpr{
-					pos: position{line: 334, col: 4, offset: 6877},
+					pos: position{line: 408, col: 4, offset: 9243},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 334, col: 4, offset: 6877},
+							pos:   position{line: 408, col: 4, offset: 9243},
 							label: "n",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 334, col: 6, offset: 6879},
+								pos: position{line: 408, col: 6, offset: 9245},
 								expr: &actionExpr{
-									pos: position{line: 334, col: 8, offset: 6881},
+									pos: position{line: 408, col: 8, offset: 9247},
 									run: (*parser).callonLogicExpr1Like5,
 									expr: &seqExpr{
-										pos: position{line: 334, col: 8, offset: 6881},
+										pos: position{line: 408, col: 8, offset: 9247},
 										exprs: []interface{}{
 											&labeledExpr{
-												pos:   position{line: 334, col: 8, offset: 6881},
+												pos:   position{line: 408, col: 8, offset: 9247},
 												label: "t",
 												expr: &ruleRefExpr{
-													pos:  position{line: 334, col: 10, offset: 6883},
+													pos:  position{line: 408, col: 10, offset: 9249},
 													name: "NotOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 334, col: 22, offset: 6895},
+												pos:  position{line: 408, col: 22, offset: 9261},
 												name: "_",
 											},
 										},
@@ -2156,18 +2171,18 @@ var g = &grammar{
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 334, col: 45, offset: 6918},
+							pos:  position{line: 408, col: 45, offset: 9284},
 							name: "LikeToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 334, col: 55, offset: 6928},
+							pos:  position{line: 408, col: 55, offset: 9294},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 334, col: 57, offset: 6930},
+							pos:   position{line: 408, col: 57, offset: 9296},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 334, col: 59, offset: 6932},
+								pos:  position{line: 408, col: 59, offset: 9298},
 								name: "Expr",
 							},
 						},
@@ -2177,30 +2192,30 @@ var g = &grammar{
 		},
 		{
 			name: "LogicExpr1Cmp",
-			pos:  position{line: 343, col: 1, offset: 7057},
+			pos:  position{line: 418, col: 1, offset: 9470},
 			expr: &actionExpr{
-				pos: position{line: 344, col: 4, offset: 7074},
+				pos: position{line: 419, col: 4, offset: 9487},
 				run: (*parser).callonLogicExpr1Cmp1,
 				expr: &seqExpr{
-					pos: position{line: 344, col: 4, offset: 7074},
+					pos: position{line: 419, col: 4, offset: 9487},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 344, col: 4, offset: 7074},
+							pos:   position{line: 419, col: 4, offset: 9487},
 							label: "op",
 							expr: &ruleRefExpr{
-								pos:  position{line: 344, col: 7, offset: 7077},
+								pos:  position{line: 419, col: 7, offset: 9490},
 								name: "CmpOperator",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 344, col: 19, offset: 7089},
+							pos:  position{line: 419, col: 19, offset: 9502},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 344, col: 21, offset: 7091},
+							pos:   position{line: 419, col: 21, offset: 9504},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 344, col: 23, offset: 7093},
+								pos:  position{line: 419, col: 23, offset: 9506},
 								name: "ArithmeticExpr",
 							},
 						},
@@ -2210,61 +2225,61 @@ var g = &grammar{
 		},
 		{
 			name: "ArithmeticExpr",
-			pos:  position{line: 347, col: 1, offset: 7145},
+			pos:  position{line: 422, col: 1, offset: 9594},
 			expr: &ruleRefExpr{
-				pos:  position{line: 348, col: 4, offset: 7163},
+				pos:  position{line: 423, col: 4, offset: 9612},
 				name: "ArithmeticExpr3",
 			},
 		},
 		{
 			name: "ArithmeticExpr3",
-			pos:  position{line: 350, col: 1, offset: 7180},
+			pos:  position{line: 425, col: 1, offset: 9629},
 			expr: &actionExpr{
-				pos: position{line: 351, col: 4, offset: 7199},
+				pos: position{line: 426, col: 4, offset: 9648},
 				run: (*parser).callonArithmeticExpr31,
 				expr: &seqExpr{
-					pos: position{line: 351, col: 4, offset: 7199},
+					pos: position{line: 426, col: 4, offset: 9648},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 351, col: 4, offset: 7199},
+							pos:   position{line: 426, col: 4, offset: 9648},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 351, col: 6, offset: 7201},
+								pos:  position{line: 426, col: 6, offset: 9650},
 								name: "ArithmeticExpr2",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 351, col: 22, offset: 7217},
+							pos:   position{line: 427, col: 3, offset: 9668},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 351, col: 25, offset: 7220},
+								pos: position{line: 427, col: 6, offset: 9671},
 								expr: &actionExpr{
-									pos: position{line: 351, col: 27, offset: 7222},
+									pos: position{line: 427, col: 8, offset: 9673},
 									run: (*parser).callonArithmeticExpr37,
 									expr: &seqExpr{
-										pos: position{line: 351, col: 27, offset: 7222},
+										pos: position{line: 427, col: 8, offset: 9673},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 351, col: 27, offset: 7222},
+												pos:  position{line: 427, col: 8, offset: 9673},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 351, col: 29, offset: 7224},
+												pos:   position{line: 427, col: 10, offset: 9675},
 												label: "op",
 												expr: &ruleRefExpr{
-													pos:  position{line: 351, col: 32, offset: 7227},
+													pos:  position{line: 427, col: 13, offset: 9678},
 													name: "ConcatOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 351, col: 47, offset: 7242},
+												pos:  position{line: 427, col: 28, offset: 9693},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 351, col: 49, offset: 7244},
+												pos:   position{line: 427, col: 30, offset: 9695},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 351, col: 51, offset: 7246},
+													pos:  position{line: 427, col: 32, offset: 9697},
 													name: "ArithmeticExpr2",
 												},
 											},
@@ -2279,53 +2294,53 @@ var g = &grammar{
 		},
 		{
 			name: "ArithmeticExpr2",
-			pos:  position{line: 354, col: 1, offset: 7344},
+			pos:  position{line: 431, col: 1, offset: 9865},
 			expr: &actionExpr{
-				pos: position{line: 355, col: 4, offset: 7363},
+				pos: position{line: 432, col: 4, offset: 9884},
 				run: (*parser).callonArithmeticExpr21,
 				expr: &seqExpr{
-					pos: position{line: 355, col: 4, offset: 7363},
+					pos: position{line: 432, col: 4, offset: 9884},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 355, col: 4, offset: 7363},
+							pos:   position{line: 432, col: 4, offset: 9884},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 355, col: 6, offset: 7365},
+								pos:  position{line: 432, col: 6, offset: 9886},
 								name: "ArithmeticExpr1",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 355, col: 22, offset: 7381},
+							pos:   position{line: 433, col: 3, offset: 9904},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 355, col: 25, offset: 7384},
+								pos: position{line: 433, col: 6, offset: 9907},
 								expr: &actionExpr{
-									pos: position{line: 355, col: 27, offset: 7386},
+									pos: position{line: 433, col: 8, offset: 9909},
 									run: (*parser).callonArithmeticExpr27,
 									expr: &seqExpr{
-										pos: position{line: 355, col: 27, offset: 7386},
+										pos: position{line: 433, col: 8, offset: 9909},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 355, col: 27, offset: 7386},
+												pos:  position{line: 433, col: 8, offset: 9909},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 355, col: 29, offset: 7388},
+												pos:   position{line: 433, col: 10, offset: 9911},
 												label: "op",
 												expr: &ruleRefExpr{
-													pos:  position{line: 355, col: 32, offset: 7391},
+													pos:  position{line: 433, col: 13, offset: 9914},
 													name: "AddSubOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 355, col: 47, offset: 7406},
+												pos:  position{line: 433, col: 28, offset: 9929},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 355, col: 49, offset: 7408},
+												pos:   position{line: 433, col: 30, offset: 9931},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 355, col: 51, offset: 7410},
+													pos:  position{line: 433, col: 32, offset: 9933},
 													name: "ArithmeticExpr1",
 												},
 											},
@@ -2340,53 +2355,53 @@ var g = &grammar{
 		},
 		{
 			name: "ArithmeticExpr1",
-			pos:  position{line: 358, col: 1, offset: 7508},
+			pos:  position{line: 437, col: 1, offset: 10101},
 			expr: &actionExpr{
-				pos: position{line: 359, col: 4, offset: 7527},
+				pos: position{line: 438, col: 4, offset: 10120},
 				run: (*parser).callonArithmeticExpr11,
 				expr: &seqExpr{
-					pos: position{line: 359, col: 4, offset: 7527},
+					pos: position{line: 438, col: 4, offset: 10120},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 359, col: 4, offset: 7527},
+							pos:   position{line: 438, col: 4, offset: 10120},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 359, col: 6, offset: 7529},
+								pos:  position{line: 438, col: 6, offset: 10122},
 								name: "Operand",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 359, col: 14, offset: 7537},
+							pos:   position{line: 439, col: 3, offset: 10132},
 							label: "os",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 359, col: 17, offset: 7540},
+								pos: position{line: 439, col: 6, offset: 10135},
 								expr: &actionExpr{
-									pos: position{line: 359, col: 19, offset: 7542},
+									pos: position{line: 439, col: 8, offset: 10137},
 									run: (*parser).callonArithmeticExpr17,
 									expr: &seqExpr{
-										pos: position{line: 359, col: 19, offset: 7542},
+										pos: position{line: 439, col: 8, offset: 10137},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 359, col: 19, offset: 7542},
+												pos:  position{line: 439, col: 8, offset: 10137},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 359, col: 21, offset: 7544},
+												pos:   position{line: 439, col: 10, offset: 10139},
 												label: "op",
 												expr: &ruleRefExpr{
-													pos:  position{line: 359, col: 24, offset: 7547},
+													pos:  position{line: 439, col: 13, offset: 10142},
 													name: "MulDivModOperator",
 												},
 											},
 											&ruleRefExpr{
-												pos:  position{line: 359, col: 42, offset: 7565},
+												pos:  position{line: 439, col: 31, offset: 10160},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 359, col: 44, offset: 7567},
+												pos:   position{line: 439, col: 33, offset: 10162},
 												label: "s",
 												expr: &ruleRefExpr{
-													pos:  position{line: 359, col: 46, offset: 7569},
+													pos:  position{line: 439, col: 35, offset: 10164},
 													name: "Operand",
 												},
 											},
@@ -2401,49 +2416,49 @@ var g = &grammar{
 		},
 		{
 			name: "MultiExpr",
-			pos:  position{line: 362, col: 1, offset: 7659},
+			pos:  position{line: 443, col: 1, offset: 10324},
 			expr: &actionExpr{
-				pos: position{line: 363, col: 4, offset: 7672},
+				pos: position{line: 444, col: 4, offset: 10337},
 				run: (*parser).callonMultiExpr1,
 				expr: &seqExpr{
-					pos: position{line: 363, col: 4, offset: 7672},
+					pos: position{line: 444, col: 4, offset: 10337},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 363, col: 4, offset: 7672},
+							pos:   position{line: 444, col: 4, offset: 10337},
 							label: "x",
 							expr: &ruleRefExpr{
-								pos:  position{line: 363, col: 6, offset: 7674},
+								pos:  position{line: 444, col: 6, offset: 10339},
 								name: "Expr",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 363, col: 11, offset: 7679},
+							pos:   position{line: 444, col: 11, offset: 10344},
 							label: "xs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 363, col: 14, offset: 7682},
+								pos: position{line: 444, col: 14, offset: 10347},
 								expr: &actionExpr{
-									pos: position{line: 363, col: 16, offset: 7684},
+									pos: position{line: 444, col: 16, offset: 10349},
 									run: (*parser).callonMultiExpr7,
 									expr: &seqExpr{
-										pos: position{line: 363, col: 16, offset: 7684},
+										pos: position{line: 444, col: 16, offset: 10349},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 363, col: 16, offset: 7684},
+												pos:  position{line: 444, col: 16, offset: 10349},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 363, col: 18, offset: 7686},
+												pos:  position{line: 444, col: 18, offset: 10351},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 363, col: 33, offset: 7701},
+												pos:  position{line: 444, col: 33, offset: 10366},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 363, col: 35, offset: 7703},
+												pos:   position{line: 444, col: 35, offset: 10368},
 												label: "e",
 												expr: &ruleRefExpr{
-													pos:  position{line: 363, col: 37, offset: 7705},
+													pos:  position{line: 444, col: 37, offset: 10370},
 													name: "Expr",
 												},
 											},
@@ -2458,49 +2473,49 @@ var g = &grammar{
 		},
 		{
 			name: "MultiExprWithDefault",
-			pos:  position{line: 366, col: 1, offset: 7763},
+			pos:  position{line: 447, col: 1, offset: 10458},
 			expr: &actionExpr{
-				pos: position{line: 367, col: 4, offset: 7787},
+				pos: position{line: 448, col: 4, offset: 10482},
 				run: (*parser).callonMultiExprWithDefault1,
 				expr: &seqExpr{
-					pos: position{line: 367, col: 4, offset: 7787},
+					pos: position{line: 448, col: 4, offset: 10482},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 367, col: 4, offset: 7787},
+							pos:   position{line: 448, col: 4, offset: 10482},
 							label: "x",
 							expr: &ruleRefExpr{
-								pos:  position{line: 367, col: 6, offset: 7789},
+								pos:  position{line: 448, col: 6, offset: 10484},
 								name: "ExprWithDefault",
 							},
 						},
 						&labeledExpr{
-							pos:   position{line: 367, col: 22, offset: 7805},
+							pos:   position{line: 448, col: 22, offset: 10500},
 							label: "xs",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 367, col: 25, offset: 7808},
+								pos: position{line: 448, col: 25, offset: 10503},
 								expr: &actionExpr{
-									pos: position{line: 367, col: 27, offset: 7810},
+									pos: position{line: 448, col: 27, offset: 10505},
 									run: (*parser).callonMultiExprWithDefault7,
 									expr: &seqExpr{
-										pos: position{line: 367, col: 27, offset: 7810},
+										pos: position{line: 448, col: 27, offset: 10505},
 										exprs: []interface{}{
 											&ruleRefExpr{
-												pos:  position{line: 367, col: 27, offset: 7810},
+												pos:  position{line: 448, col: 27, offset: 10505},
 												name: "_",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 367, col: 29, offset: 7812},
+												pos:  position{line: 448, col: 29, offset: 10507},
 												name: "SeparatorToken",
 											},
 											&ruleRefExpr{
-												pos:  position{line: 367, col: 44, offset: 7827},
+												pos:  position{line: 448, col: 44, offset: 10522},
 												name: "_",
 											},
 											&labeledExpr{
-												pos:   position{line: 367, col: 46, offset: 7829},
+												pos:   position{line: 448, col: 46, offset: 10524},
 												label: "e",
 												expr: &ruleRefExpr{
-													pos:  position{line: 367, col: 48, offset: 7831},
+													pos:  position{line: 448, col: 48, offset: 10526},
 													name: "ExprWithDefault",
 												},
 											},
@@ -2515,33 +2530,33 @@ var g = &grammar{
 		},
 		{
 			name: "Operand",
-			pos:  position{line: 370, col: 1, offset: 7900},
+			pos:  position{line: 451, col: 1, offset: 10625},
 			expr: &choiceExpr{
-				pos: position{line: 371, col: 4, offset: 7911},
+				pos: position{line: 452, col: 4, offset: 10636},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 371, col: 4, offset: 7911},
+						pos: position{line: 452, col: 4, offset: 10636},
 						run: (*parser).callonOperand2,
 						expr: &seqExpr{
-							pos: position{line: 371, col: 4, offset: 7911},
+							pos: position{line: 452, col: 4, offset: 10636},
 							exprs: []interface{}{
 								&labeledExpr{
-									pos:   position{line: 371, col: 4, offset: 7911},
+									pos:   position{line: 452, col: 4, offset: 10636},
 									label: "op",
 									expr: &ruleRefExpr{
-										pos:  position{line: 371, col: 7, offset: 7914},
+										pos:  position{line: 452, col: 7, offset: 10639},
 										name: "UnaryOperator",
 									},
 								},
 								&ruleRefExpr{
-									pos:  position{line: 371, col: 21, offset: 7928},
+									pos:  position{line: 452, col: 21, offset: 10653},
 									name: "_",
 								},
 								&labeledExpr{
-									pos:   position{line: 371, col: 23, offset: 7930},
+									pos:   position{line: 452, col: 23, offset: 10655},
 									label: "s",
 									expr: &ruleRefExpr{
-										pos:  position{line: 371, col: 25, offset: 7932},
+										pos:  position{line: 452, col: 25, offset: 10657},
 										name: "Operand",
 									},
 								},
@@ -2549,34 +2564,34 @@ var g = &grammar{
 						},
 					},
 					&actionExpr{
-						pos: position{line: 372, col: 4, offset: 7978},
+						pos: position{line: 454, col: 4, offset: 10740},
 						run: (*parser).callonOperand9,
 						expr: &seqExpr{
-							pos: position{line: 372, col: 4, offset: 7978},
+							pos: position{line: 454, col: 4, offset: 10740},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 372, col: 4, offset: 7978},
+									pos:        position{line: 454, col: 4, offset: 10740},
 									val:        "(",
 									ignoreCase: false,
 								},
 								&ruleRefExpr{
-									pos:  position{line: 372, col: 8, offset: 7982},
+									pos:  position{line: 454, col: 8, offset: 10744},
 									name: "_",
 								},
 								&labeledExpr{
-									pos:   position{line: 372, col: 10, offset: 7984},
+									pos:   position{line: 454, col: 10, offset: 10746},
 									label: "e",
 									expr: &ruleRefExpr{
-										pos:  position{line: 372, col: 12, offset: 7986},
+										pos:  position{line: 454, col: 12, offset: 10748},
 										name: "Expr",
 									},
 								},
 								&ruleRefExpr{
-									pos:  position{line: 372, col: 17, offset: 7991},
+									pos:  position{line: 454, col: 17, offset: 10753},
 									name: "_",
 								},
 								&litMatcher{
-									pos:        position{line: 372, col: 19, offset: 7993},
+									pos:        position{line: 454, col: 19, offset: 10755},
 									val:        ")",
 									ignoreCase: false,
 								},
@@ -2584,23 +2599,23 @@ var g = &grammar{
 						},
 					},
 					&actionExpr{
-						pos: position{line: 373, col: 4, offset: 8018},
+						pos: position{line: 455, col: 4, offset: 10780},
 						run: (*parser).callonOperand17,
 						expr: &seqExpr{
-							pos: position{line: 373, col: 4, offset: 8018},
+							pos: position{line: 455, col: 4, offset: 10780},
 							exprs: []interface{}{
 								&andExpr{
-									pos: position{line: 373, col: 4, offset: 8018},
+									pos: position{line: 455, col: 4, offset: 10780},
 									expr: &ruleRefExpr{
-										pos:  position{line: 373, col: 6, offset: 8020},
+										pos:  position{line: 455, col: 6, offset: 10782},
 										name: "CastToken",
 									},
 								},
 								&labeledExpr{
-									pos:   position{line: 373, col: 17, offset: 8031},
+									pos:   position{line: 455, col: 17, offset: 10793},
 									label: "t",
 									expr: &ruleRefExpr{
-										pos:  position{line: 373, col: 19, offset: 8033},
+										pos:  position{line: 455, col: 19, offset: 10795},
 										name: "TypeCast",
 									},
 								},
@@ -2608,15 +2623,15 @@ var g = &grammar{
 						},
 					},
 					&ruleRefExpr{
-						pos:  position{line: 374, col: 4, offset: 8063},
+						pos:  position{line: 456, col: 4, offset: 10825},
 						name: "FunctionCall",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 375, col: 4, offset: 8079},
+						pos:  position{line: 457, col: 4, offset: 10841},
 						name: "Value",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 376, col: 4, offset: 8088},
+						pos:  position{line: 458, col: 4, offset: 10850},
 						name: "Identifier",
 					},
 				},
@@ -2624,64 +2639,64 @@ var g = &grammar{
 		},
 		{
 			name: "TypeCast",
-			pos:  position{line: 378, col: 1, offset: 8100},
+			pos:  position{line: 460, col: 1, offset: 10862},
 			expr: &actionExpr{
-				pos: position{line: 379, col: 4, offset: 8112},
+				pos: position{line: 461, col: 4, offset: 10874},
 				run: (*parser).callonTypeCast1,
 				expr: &seqExpr{
-					pos: position{line: 379, col: 4, offset: 8112},
+					pos: position{line: 461, col: 4, offset: 10874},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 4, offset: 8112},
+							pos:  position{line: 461, col: 4, offset: 10874},
 							name: "CastToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 14, offset: 8122},
+							pos:  position{line: 461, col: 14, offset: 10884},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 379, col: 16, offset: 8124},
+							pos:        position{line: 461, col: 16, offset: 10886},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 20, offset: 8128},
+							pos:  position{line: 461, col: 20, offset: 10890},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 379, col: 22, offset: 8130},
+							pos:   position{line: 461, col: 22, offset: 10892},
 							label: "o",
 							expr: &ruleRefExpr{
-								pos:  position{line: 379, col: 24, offset: 8132},
+								pos:  position{line: 461, col: 24, offset: 10894},
 								name: "Expr",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 29, offset: 8137},
+							pos:  position{line: 461, col: 29, offset: 10899},
 							name: "_",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 31, offset: 8139},
+							pos:  position{line: 461, col: 31, offset: 10901},
 							name: "AsToken",
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 39, offset: 8147},
+							pos:  position{line: 461, col: 39, offset: 10909},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 379, col: 41, offset: 8149},
+							pos:   position{line: 461, col: 41, offset: 10911},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 379, col: 43, offset: 8151},
+								pos:  position{line: 461, col: 43, offset: 10913},
 								name: "DataType",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 379, col: 52, offset: 8160},
+							pos:  position{line: 461, col: 52, offset: 10922},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 379, col: 54, offset: 8162},
+							pos:        position{line: 461, col: 54, offset: 10924},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -2691,51 +2706,51 @@ var g = &grammar{
 		},
 		{
 			name: "FunctionCall",
-			pos:  position{line: 382, col: 1, offset: 8240},
+			pos:  position{line: 469, col: 1, offset: 11056},
 			expr: &actionExpr{
-				pos: position{line: 383, col: 4, offset: 8256},
+				pos: position{line: 470, col: 4, offset: 11072},
 				run: (*parser).callonFunctionCall1,
 				expr: &seqExpr{
-					pos: position{line: 383, col: 4, offset: 8256},
+					pos: position{line: 470, col: 4, offset: 11072},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 383, col: 4, offset: 8256},
+							pos:   position{line: 470, col: 4, offset: 11072},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 383, col: 6, offset: 8258},
+								pos:  position{line: 470, col: 6, offset: 11074},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 383, col: 17, offset: 8269},
+							pos:  position{line: 470, col: 17, offset: 11085},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 383, col: 19, offset: 8271},
+							pos:        position{line: 470, col: 19, offset: 11087},
 							val:        "(",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 383, col: 23, offset: 8275},
+							pos:  position{line: 470, col: 23, offset: 11091},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 383, col: 25, offset: 8277},
+							pos:   position{line: 470, col: 25, offset: 11093},
 							label: "r",
 							expr: &zeroOrOneExpr{
-								pos: position{line: 383, col: 27, offset: 8279},
+								pos: position{line: 470, col: 27, offset: 11095},
 								expr: &ruleRefExpr{
-									pos:  position{line: 383, col: 27, offset: 8279},
+									pos:  position{line: 470, col: 27, offset: 11095},
 									name: "FunctionArgs",
 								},
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 383, col: 41, offset: 8293},
+							pos:  position{line: 470, col: 41, offset: 11109},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 383, col: 43, offset: 8295},
+							pos:        position{line: 470, col: 43, offset: 11111},
 							val:        ")",
 							ignoreCase: false,
 						},
@@ -2745,24 +2760,24 @@ var g = &grammar{
 		},
 		{
 			name: "FunctionArgs",
-			pos:  position{line: 386, col: 1, offset: 8377},
+			pos:  position{line: 480, col: 1, offset: 11263},
 			expr: &choiceExpr{
-				pos: position{line: 387, col: 4, offset: 8393},
+				pos: position{line: 481, col: 4, offset: 11279},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 387, col: 4, offset: 8393},
+						pos: position{line: 481, col: 4, offset: 11279},
 						run: (*parser).callonFunctionArgs2,
 						expr: &labeledExpr{
-							pos:   position{line: 387, col: 4, offset: 8393},
+							pos:   position{line: 481, col: 4, offset: 11279},
 							label: "a",
 							expr: &ruleRefExpr{
-								pos:  position{line: 387, col: 6, offset: 8395},
+								pos:  position{line: 481, col: 6, offset: 11281},
 								name: "AnyLiteral",
 							},
 						},
 					},
 					&ruleRefExpr{
-						pos:  position{line: 388, col: 4, offset: 8442},
+						pos:  position{line: 482, col: 4, offset: 11349},
 						name: "MultiExpr",
 					},
 				},
@@ -2770,39 +2785,39 @@ var g = &grammar{
 		},
 		{
 			name: "Assignment",
-			pos:  position{line: 390, col: 1, offset: 8453},
+			pos:  position{line: 484, col: 1, offset: 11360},
 			expr: &actionExpr{
-				pos: position{line: 391, col: 4, offset: 8467},
+				pos: position{line: 485, col: 4, offset: 11374},
 				run: (*parser).callonAssignment1,
 				expr: &seqExpr{
-					pos: position{line: 391, col: 4, offset: 8467},
+					pos: position{line: 485, col: 4, offset: 11374},
 					exprs: []interface{}{
 						&labeledExpr{
-							pos:   position{line: 391, col: 4, offset: 8467},
+							pos:   position{line: 485, col: 4, offset: 11374},
 							label: "i",
 							expr: &ruleRefExpr{
-								pos:  position{line: 391, col: 6, offset: 8469},
+								pos:  position{line: 485, col: 6, offset: 11376},
 								name: "Identifier",
 							},
 						},
 						&ruleRefExpr{
-							pos:  position{line: 391, col: 17, offset: 8480},
+							pos:  position{line: 485, col: 17, offset: 11387},
 							name: "_",
 						},
 						&litMatcher{
-							pos:        position{line: 391, col: 19, offset: 8482},
+							pos:        position{line: 485, col: 19, offset: 11389},
 							val:        "=",
 							ignoreCase: false,
 						},
 						&ruleRefExpr{
-							pos:  position{line: 391, col: 23, offset: 8486},
+							pos:  position{line: 485, col: 23, offset: 11393},
 							name: "_",
 						},
 						&labeledExpr{
-							pos:   position{line: 391, col: 25, offset: 8488},
+							pos:   position{line: 485, col: 25, offset: 11395},
 							label: "e",
 							expr: &ruleRefExpr{
-								pos:  position{line: 391, col: 27, offset: 8490},
+								pos:  position{line: 485, col: 27, offset: 11397},
 								name: "ExprWithDefault",
 							},
 						},
@@ -2812,91 +2827,91 @@ var g = &grammar{
 		},
 		{
 			name: "UnaryOperator",
-			pos:  position{line: 395, col: 1, offset: 8598},
+			pos:  position{line: 494, col: 1, offset: 11556},
 			expr: &ruleRefExpr{
-				pos:  position{line: 396, col: 4, offset: 8615},
+				pos:  position{line: 495, col: 4, offset: 11573},
 				name: "SignOperator",
 			},
 		},
 		{
 			name: "SignOperator",
-			pos:  position{line: 398, col: 1, offset: 8629},
+			pos:  position{line: 497, col: 1, offset: 11587},
 			expr: &actionExpr{
-				pos: position{line: 399, col: 4, offset: 8645},
+				pos: position{line: 498, col: 4, offset: 11603},
 				run: (*parser).callonSignOperator1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 399, col: 4, offset: 8645},
+					pos:  position{line: 498, col: 4, offset: 11603},
 					name: "Sign",
 				},
 			},
 		},
 		{
 			name: "NotOperator",
-			pos:  position{line: 410, col: 1, offset: 8826},
+			pos:  position{line: 512, col: 1, offset: 11831},
 			expr: &actionExpr{
-				pos: position{line: 411, col: 4, offset: 8841},
+				pos: position{line: 513, col: 4, offset: 11846},
 				run: (*parser).callonNotOperator1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 411, col: 4, offset: 8841},
+					pos:  position{line: 513, col: 4, offset: 11846},
 					name: "NotToken",
 				},
 			},
 		},
 		{
 			name: "AndOperator",
-			pos:  position{line: 414, col: 1, offset: 8890},
+			pos:  position{line: 519, col: 1, offset: 11910},
 			expr: &actionExpr{
-				pos: position{line: 415, col: 4, offset: 8905},
+				pos: position{line: 520, col: 4, offset: 11925},
 				run: (*parser).callonAndOperator1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 415, col: 4, offset: 8905},
+					pos:  position{line: 520, col: 4, offset: 11925},
 					name: "AndToken",
 				},
 			},
 		},
 		{
 			name: "OrOperator",
-			pos:  position{line: 418, col: 1, offset: 8954},
+			pos:  position{line: 526, col: 1, offset: 11989},
 			expr: &actionExpr{
-				pos: position{line: 419, col: 4, offset: 8968},
+				pos: position{line: 527, col: 4, offset: 12003},
 				run: (*parser).callonOrOperator1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 419, col: 4, offset: 8968},
+					pos:  position{line: 527, col: 4, offset: 12003},
 					name: "OrToken",
 				},
 			},
 		},
 		{
 			name: "CmpOperator",
-			pos:  position{line: 422, col: 1, offset: 9015},
+			pos:  position{line: 533, col: 1, offset: 12065},
 			expr: &actionExpr{
-				pos: position{line: 423, col: 4, offset: 9030},
+				pos: position{line: 534, col: 4, offset: 12080},
 				run: (*parser).callonCmpOperator1,
 				expr: &choiceExpr{
-					pos: position{line: 423, col: 6, offset: 9032},
+					pos: position{line: 534, col: 6, offset: 12082},
 					alternatives: []interface{}{
 						&litMatcher{
-							pos:        position{line: 423, col: 6, offset: 9032},
+							pos:        position{line: 534, col: 6, offset: 12082},
 							val:        "<=",
 							ignoreCase: false,
 						},
 						&litMatcher{
-							pos:        position{line: 423, col: 13, offset: 9039},
+							pos:        position{line: 534, col: 13, offset: 12089},
 							val:        ">=",
 							ignoreCase: false,
 						},
 						&litMatcher{
-							pos:        position{line: 423, col: 20, offset: 9046},
+							pos:        position{line: 534, col: 20, offset: 12096},
 							val:        "<>",
 							ignoreCase: false,
 						},
 						&litMatcher{
-							pos:        position{line: 423, col: 27, offset: 9053},
+							pos:        position{line: 534, col: 27, offset: 12103},
 							val:        "!=",
 							ignoreCase: false,
 						},
 						&charClassMatcher{
-							pos:        position{line: 423, col: 34, offset: 9060},
+							pos:        position{line: 534, col: 34, offset: 12110},
 							val:        "[<>=]",
 							chars:      []rune{'<', '>', '='},
 							ignoreCase: false,
@@ -2908,12 +2923,12 @@ var g = &grammar{
 		},
 		{
 			name: "ConcatOperator",
-			pos:  position{line: 444, col: 1, offset: 9539},
+			pos:  position{line: 558, col: 1, offset: 12612},
 			expr: &actionExpr{
-				pos: position{line: 445, col: 4, offset: 9557},
+				pos: position{line: 559, col: 4, offset: 12630},
 				run: (*parser).callonConcatOperator1,
 				expr: &litMatcher{
-					pos:        position{line: 445, col: 4, offset: 9557},
+					pos:        position{line: 559, col: 4, offset: 12630},
 					val:        "||",
 					ignoreCase: false,
 				},
@@ -2921,12 +2936,12 @@ var g = &grammar{
 		},
 		{
 			name: "AddSubOperator",
-			pos:  position{line: 448, col: 1, offset: 9605},
+			pos:  position{line: 565, col: 1, offset: 12693},
 			expr: &actionExpr{
-				pos: position{line: 449, col: 4, offset: 9623},
+				pos: position{line: 566, col: 4, offset: 12711},
 				run: (*parser).callonAddSubOperator1,
 				expr: &charClassMatcher{
-					pos:        position{line: 449, col: 4, offset: 9623},
+					pos:        position{line: 566, col: 4, offset: 12711},
 					val:        "[+-]",
 					chars:      []rune{'+', '-'},
 					ignoreCase: false,
@@ -2936,12 +2951,12 @@ var g = &grammar{
 		},
 		{
 			name: "MulDivModOperator",
-			pos:  position{line: 460, col: 1, offset: 9832},
+			pos:  position{line: 580, col: 1, offset: 12968},
 			expr: &actionExpr{
-				pos: position{line: 461, col: 4, offset: 9853},
+				pos: position{line: 581, col: 4, offset: 12989},
 				run: (*parser).callonMulDivModOperator1,
 				expr: &charClassMatcher{
-					pos:        position{line: 461, col: 4, offset: 9853},
+					pos:        position{line: 581, col: 4, offset: 12989},
 					val:        "[*/%]",
 					chars:      []rune{'*', '/', '%'},
 					ignoreCase: false,
@@ -2951,40 +2966,40 @@ var g = &grammar{
 		},
 		{
 			name: "DataType",
-			pos:  position{line: 475, col: 1, offset: 10133},
+			pos:  position{line: 598, col: 1, offset: 13312},
 			expr: &choiceExpr{
-				pos: position{line: 476, col: 4, offset: 10145},
+				pos: position{line: 599, col: 4, offset: 13324},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 476, col: 4, offset: 10145},
+						pos:  position{line: 599, col: 4, offset: 13324},
 						name: "UIntType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 477, col: 4, offset: 10157},
+						pos:  position{line: 600, col: 4, offset: 13336},
 						name: "IntType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 478, col: 4, offset: 10168},
+						pos:  position{line: 601, col: 4, offset: 13347},
 						name: "UFixedType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 479, col: 4, offset: 10182},
+						pos:  position{line: 602, col: 4, offset: 13361},
 						name: "FixedType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 480, col: 4, offset: 10195},
+						pos:  position{line: 603, col: 4, offset: 13374},
 						name: "FixedBytesType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 481, col: 4, offset: 10213},
+						pos:  position{line: 604, col: 4, offset: 13392},
 						name: "DynamicBytesType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 482, col: 4, offset: 10233},
+						pos:  position{line: 605, col: 4, offset: 13412},
 						name: "BoolType",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 483, col: 4, offset: 10245},
+						pos:  position{line: 606, col: 4, offset: 13424},
 						name: "AddressType",
 					},
 				},
@@ -2992,30 +3007,30 @@ var g = &grammar{
 		},
 		{
 			name: "UIntType",
-			pos:  position{line: 485, col: 1, offset: 10258},
+			pos:  position{line: 608, col: 1, offset: 13437},
 			expr: &actionExpr{
-				pos: position{line: 486, col: 4, offset: 10270},
+				pos: position{line: 609, col: 4, offset: 13449},
 				run: (*parser).callonUIntType1,
 				expr: &seqExpr{
-					pos: position{line: 486, col: 4, offset: 10270},
+					pos: position{line: 609, col: 4, offset: 13449},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 486, col: 4, offset: 10270},
+							pos:        position{line: 609, col: 4, offset: 13449},
 							val:        "uint",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 486, col: 12, offset: 10278},
+							pos:   position{line: 609, col: 12, offset: 13457},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 486, col: 14, offset: 10280},
+								pos:  position{line: 609, col: 14, offset: 13459},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&notExpr{
-							pos: position{line: 486, col: 36, offset: 10302},
+							pos: position{line: 609, col: 36, offset: 13481},
 							expr: &ruleRefExpr{
-								pos:  position{line: 486, col: 37, offset: 10303},
+								pos:  position{line: 609, col: 37, offset: 13482},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3025,30 +3040,30 @@ var g = &grammar{
 		},
 		{
 			name: "IntType",
-			pos:  position{line: 505, col: 1, offset: 10741},
+			pos:  position{line: 629, col: 1, offset: 13929},
 			expr: &actionExpr{
-				pos: position{line: 506, col: 4, offset: 10752},
+				pos: position{line: 630, col: 4, offset: 13940},
 				run: (*parser).callonIntType1,
 				expr: &seqExpr{
-					pos: position{line: 506, col: 4, offset: 10752},
+					pos: position{line: 630, col: 4, offset: 13940},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 506, col: 4, offset: 10752},
+							pos:        position{line: 630, col: 4, offset: 13940},
 							val:        "int",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 506, col: 11, offset: 10759},
+							pos:   position{line: 630, col: 11, offset: 13947},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 506, col: 13, offset: 10761},
+								pos:  position{line: 630, col: 13, offset: 13949},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&notExpr{
-							pos: position{line: 506, col: 35, offset: 10783},
+							pos: position{line: 630, col: 35, offset: 13971},
 							expr: &ruleRefExpr{
-								pos:  position{line: 506, col: 36, offset: 10784},
+								pos:  position{line: 630, col: 36, offset: 13972},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3058,43 +3073,43 @@ var g = &grammar{
 		},
 		{
 			name: "UFixedType",
-			pos:  position{line: 525, col: 1, offset: 11222},
+			pos:  position{line: 650, col: 1, offset: 14419},
 			expr: &actionExpr{
-				pos: position{line: 526, col: 4, offset: 11236},
+				pos: position{line: 651, col: 4, offset: 14433},
 				run: (*parser).callonUFixedType1,
 				expr: &seqExpr{
-					pos: position{line: 526, col: 4, offset: 11236},
+					pos: position{line: 651, col: 4, offset: 14433},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 526, col: 4, offset: 11236},
+							pos:        position{line: 651, col: 4, offset: 14433},
 							val:        "ufixed",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 526, col: 14, offset: 11246},
+							pos:   position{line: 651, col: 14, offset: 14443},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 526, col: 16, offset: 11248},
+								pos:  position{line: 651, col: 16, offset: 14445},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 526, col: 38, offset: 11270},
+							pos:        position{line: 651, col: 38, offset: 14467},
 							val:        "x",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 526, col: 43, offset: 11275},
+							pos:   position{line: 651, col: 43, offset: 14472},
 							label: "t",
 							expr: &ruleRefExpr{
-								pos:  position{line: 526, col: 45, offset: 11277},
+								pos:  position{line: 651, col: 45, offset: 14474},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&notExpr{
-							pos: position{line: 526, col: 67, offset: 11299},
+							pos: position{line: 651, col: 67, offset: 14496},
 							expr: &ruleRefExpr{
-								pos:  position{line: 526, col: 68, offset: 11300},
+								pos:  position{line: 651, col: 68, offset: 14497},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3104,43 +3119,43 @@ var g = &grammar{
 		},
 		{
 			name: "FixedType",
-			pos:  position{line: 558, col: 1, offset: 12133},
+			pos:  position{line: 684, col: 1, offset: 15339},
 			expr: &actionExpr{
-				pos: position{line: 559, col: 4, offset: 12146},
+				pos: position{line: 685, col: 4, offset: 15352},
 				run: (*parser).callonFixedType1,
 				expr: &seqExpr{
-					pos: position{line: 559, col: 4, offset: 12146},
+					pos: position{line: 685, col: 4, offset: 15352},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 559, col: 4, offset: 12146},
+							pos:        position{line: 685, col: 4, offset: 15352},
 							val:        "fixed",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 559, col: 13, offset: 12155},
+							pos:   position{line: 685, col: 13, offset: 15361},
 							label: "s",
 							expr: &ruleRefExpr{
-								pos:  position{line: 559, col: 15, offset: 12157},
+								pos:  position{line: 685, col: 15, offset: 15363},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 559, col: 37, offset: 12179},
+							pos:        position{line: 685, col: 37, offset: 15385},
 							val:        "x",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 559, col: 42, offset: 12184},
+							pos:   position{line: 685, col: 42, offset: 15390},
 							label: "t",
 							expr: &ruleRefExpr{
-								pos:  position{line: 559, col: 44, offset: 12186},
+								pos:  position{line: 685, col: 44, offset: 15392},
 								name: "NonZeroLeadingInteger",
 							},
 						},
 						&notExpr{
-							pos: position{line: 559, col: 66, offset: 12208},
+							pos: position{line: 685, col: 66, offset: 15414},
 							expr: &ruleRefExpr{
-								pos:  position{line: 559, col: 67, offset: 12209},
+								pos:  position{line: 685, col: 67, offset: 15415},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3150,33 +3165,33 @@ var g = &grammar{
 		},
 		{
 			name: "FixedBytesType",
-			pos:  position{line: 591, col: 1, offset: 13041},
+			pos:  position{line: 718, col: 1, offset: 16256},
 			expr: &choiceExpr{
-				pos: position{line: 592, col: 4, offset: 13059},
+				pos: position{line: 719, col: 4, offset: 16274},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 592, col: 4, offset: 13059},
+						pos: position{line: 719, col: 4, offset: 16274},
 						run: (*parser).callonFixedBytesType2,
 						expr: &seqExpr{
-							pos: position{line: 592, col: 4, offset: 13059},
+							pos: position{line: 719, col: 4, offset: 16274},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 592, col: 4, offset: 13059},
+									pos:        position{line: 719, col: 4, offset: 16274},
 									val:        "bytes",
 									ignoreCase: true,
 								},
 								&labeledExpr{
-									pos:   position{line: 592, col: 13, offset: 13068},
+									pos:   position{line: 719, col: 13, offset: 16283},
 									label: "s",
 									expr: &ruleRefExpr{
-										pos:  position{line: 592, col: 15, offset: 13070},
+										pos:  position{line: 719, col: 15, offset: 16285},
 										name: "NonZeroLeadingInteger",
 									},
 								},
 								&notExpr{
-									pos: position{line: 592, col: 37, offset: 13092},
+									pos: position{line: 719, col: 37, offset: 16307},
 									expr: &ruleRefExpr{
-										pos:  position{line: 592, col: 38, offset: 13093},
+										pos:  position{line: 719, col: 38, offset: 16308},
 										name: "NormalIdentifierRest",
 									},
 								},
@@ -3184,20 +3199,20 @@ var g = &grammar{
 						},
 					},
 					&actionExpr{
-						pos: position{line: 610, col: 4, offset: 13532},
+						pos: position{line: 737, col: 4, offset: 16748},
 						run: (*parser).callonFixedBytesType9,
 						expr: &seqExpr{
-							pos: position{line: 610, col: 4, offset: 13532},
+							pos: position{line: 737, col: 4, offset: 16748},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 610, col: 4, offset: 13532},
+									pos:        position{line: 737, col: 4, offset: 16748},
 									val:        "byte",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 610, col: 12, offset: 13540},
+									pos: position{line: 737, col: 12, offset: 16756},
 									expr: &ruleRefExpr{
-										pos:  position{line: 610, col: 13, offset: 13541},
+										pos:  position{line: 737, col: 13, offset: 16757},
 										name: "NormalIdentifierRest",
 									},
 								},
@@ -3209,59 +3224,59 @@ var g = &grammar{
 		},
 		{
 			name: "DynamicBytesType",
-			pos:  position{line: 615, col: 1, offset: 13612},
+			pos:  position{line: 744, col: 1, offset: 16851},
 			expr: &actionExpr{
-				pos: position{line: 616, col: 4, offset: 13632},
+				pos: position{line: 745, col: 4, offset: 16871},
 				run: (*parser).callonDynamicBytesType1,
 				expr: &choiceExpr{
-					pos: position{line: 616, col: 6, offset: 13634},
+					pos: position{line: 745, col: 6, offset: 16873},
 					alternatives: []interface{}{
 						&seqExpr{
-							pos: position{line: 616, col: 6, offset: 13634},
+							pos: position{line: 745, col: 6, offset: 16873},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 616, col: 6, offset: 13634},
+									pos:        position{line: 745, col: 6, offset: 16873},
 									val:        "bytes",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 616, col: 15, offset: 13643},
+									pos: position{line: 745, col: 15, offset: 16882},
 									expr: &ruleRefExpr{
-										pos:  position{line: 616, col: 16, offset: 13644},
+										pos:  position{line: 745, col: 16, offset: 16883},
 										name: "NormalIdentifierRest",
 									},
 								},
 							},
 						},
 						&seqExpr{
-							pos: position{line: 617, col: 5, offset: 13669},
+							pos: position{line: 746, col: 5, offset: 16908},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 617, col: 5, offset: 13669},
+									pos:        position{line: 746, col: 5, offset: 16908},
 									val:        "string",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 617, col: 15, offset: 13679},
+									pos: position{line: 746, col: 15, offset: 16918},
 									expr: &ruleRefExpr{
-										pos:  position{line: 617, col: 16, offset: 13680},
+										pos:  position{line: 746, col: 16, offset: 16919},
 										name: "NormalIdentifierRest",
 									},
 								},
 							},
 						},
 						&seqExpr{
-							pos: position{line: 618, col: 5, offset: 13705},
+							pos: position{line: 747, col: 5, offset: 16944},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 618, col: 5, offset: 13705},
+									pos:        position{line: 747, col: 5, offset: 16944},
 									val:        "text",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 618, col: 13, offset: 13713},
+									pos: position{line: 747, col: 13, offset: 16952},
 									expr: &ruleRefExpr{
-										pos:  position{line: 618, col: 14, offset: 13714},
+										pos:  position{line: 747, col: 14, offset: 16953},
 										name: "NormalIdentifierRest",
 									},
 								},
@@ -3273,22 +3288,22 @@ var g = &grammar{
 		},
 		{
 			name: "AddressType",
-			pos:  position{line: 622, col: 1, offset: 13782},
+			pos:  position{line: 754, col: 1, offset: 17037},
 			expr: &actionExpr{
-				pos: position{line: 623, col: 4, offset: 13797},
+				pos: position{line: 755, col: 4, offset: 17052},
 				run: (*parser).callonAddressType1,
 				expr: &seqExpr{
-					pos: position{line: 623, col: 4, offset: 13797},
+					pos: position{line: 755, col: 4, offset: 17052},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 623, col: 4, offset: 13797},
+							pos:        position{line: 755, col: 4, offset: 17052},
 							val:        "address",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 623, col: 15, offset: 13808},
+							pos: position{line: 755, col: 15, offset: 17063},
 							expr: &ruleRefExpr{
-								pos:  position{line: 623, col: 16, offset: 13809},
+								pos:  position{line: 755, col: 16, offset: 17064},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3298,42 +3313,42 @@ var g = &grammar{
 		},
 		{
 			name: "BoolType",
-			pos:  position{line: 626, col: 1, offset: 13869},
+			pos:  position{line: 761, col: 1, offset: 17140},
 			expr: &actionExpr{
-				pos: position{line: 627, col: 4, offset: 13881},
+				pos: position{line: 762, col: 4, offset: 17152},
 				run: (*parser).callonBoolType1,
 				expr: &choiceExpr{
-					pos: position{line: 627, col: 6, offset: 13883},
+					pos: position{line: 762, col: 6, offset: 17154},
 					alternatives: []interface{}{
 						&seqExpr{
-							pos: position{line: 627, col: 6, offset: 13883},
+							pos: position{line: 762, col: 6, offset: 17154},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 627, col: 6, offset: 13883},
+									pos:        position{line: 762, col: 6, offset: 17154},
 									val:        "bool",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 627, col: 14, offset: 13891},
+									pos: position{line: 762, col: 14, offset: 17162},
 									expr: &ruleRefExpr{
-										pos:  position{line: 627, col: 15, offset: 13892},
+										pos:  position{line: 762, col: 15, offset: 17163},
 										name: "NormalIdentifierRest",
 									},
 								},
 							},
 						},
 						&seqExpr{
-							pos: position{line: 628, col: 5, offset: 13917},
+							pos: position{line: 763, col: 5, offset: 17188},
 							exprs: []interface{}{
 								&litMatcher{
-									pos:        position{line: 628, col: 5, offset: 13917},
+									pos:        position{line: 763, col: 5, offset: 17188},
 									val:        "boolean",
 									ignoreCase: true,
 								},
 								&notExpr{
-									pos: position{line: 628, col: 16, offset: 13928},
+									pos: position{line: 763, col: 16, offset: 17199},
 									expr: &ruleRefExpr{
-										pos:  position{line: 628, col: 17, offset: 13929},
+										pos:  position{line: 763, col: 17, offset: 17200},
 										name: "NormalIdentifierRest",
 									},
 								},
@@ -3345,24 +3360,24 @@ var g = &grammar{
 		},
 		{
 			name: "Value",
-			pos:  position{line: 633, col: 1, offset: 14002},
+			pos:  position{line: 771, col: 1, offset: 17289},
 			expr: &choiceExpr{
-				pos: position{line: 634, col: 4, offset: 14011},
+				pos: position{line: 772, col: 4, offset: 17298},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 634, col: 4, offset: 14011},
+						pos:  position{line: 772, col: 4, offset: 17298},
 						name: "NumberLiteral",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 635, col: 4, offset: 14028},
+						pos:  position{line: 773, col: 4, offset: 17315},
 						name: "StringLiteral",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 636, col: 4, offset: 14045},
+						pos:  position{line: 774, col: 4, offset: 17332},
 						name: "BoolLiteral",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 637, col: 4, offset: 14060},
+						pos:  position{line: 775, col: 4, offset: 17347},
 						name: "NullLiteral",
 					},
 				},
@@ -3370,46 +3385,46 @@ var g = &grammar{
 		},
 		{
 			name: "AnyLiteral",
-			pos:  position{line: 639, col: 1, offset: 14073},
+			pos:  position{line: 777, col: 1, offset: 17360},
 			expr: &actionExpr{
-				pos: position{line: 640, col: 4, offset: 14087},
+				pos: position{line: 778, col: 4, offset: 17374},
 				run: (*parser).callonAnyLiteral1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 640, col: 4, offset: 14087},
+					pos:  position{line: 778, col: 4, offset: 17374},
 					name: "AnyToken",
 				},
 			},
 		},
 		{
 			name: "DefaultLiteral",
-			pos:  position{line: 643, col: 1, offset: 14132},
+			pos:  position{line: 784, col: 1, offset: 17435},
 			expr: &actionExpr{
-				pos: position{line: 644, col: 4, offset: 14150},
+				pos: position{line: 785, col: 4, offset: 17453},
 				run: (*parser).callonDefaultLiteral1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 644, col: 4, offset: 14150},
+					pos:  position{line: 785, col: 4, offset: 17453},
 					name: "DefaultToken",
 				},
 			},
 		},
 		{
 			name: "BoolLiteral",
-			pos:  position{line: 647, col: 1, offset: 14203},
+			pos:  position{line: 791, col: 1, offset: 17522},
 			expr: &actionExpr{
-				pos: position{line: 648, col: 4, offset: 14218},
+				pos: position{line: 792, col: 4, offset: 17537},
 				run: (*parser).callonBoolLiteral1,
 				expr: &labeledExpr{
-					pos:   position{line: 648, col: 4, offset: 14218},
+					pos:   position{line: 792, col: 4, offset: 17537},
 					label: "b",
 					expr: &choiceExpr{
-						pos: position{line: 648, col: 8, offset: 14222},
+						pos: position{line: 792, col: 8, offset: 17541},
 						alternatives: []interface{}{
 							&ruleRefExpr{
-								pos:  position{line: 648, col: 8, offset: 14222},
+								pos:  position{line: 792, col: 8, offset: 17541},
 								name: "TrueToken",
 							},
 							&ruleRefExpr{
-								pos:  position{line: 648, col: 20, offset: 14234},
+								pos:  position{line: 792, col: 20, offset: 17553},
 								name: "FalseToken",
 							},
 						},
@@ -3419,40 +3434,40 @@ var g = &grammar{
 		},
 		{
 			name: "NullLiteral",
-			pos:  position{line: 651, col: 1, offset: 14315},
+			pos:  position{line: 799, col: 1, offset: 17658},
 			expr: &actionExpr{
-				pos: position{line: 652, col: 4, offset: 14330},
+				pos: position{line: 800, col: 4, offset: 17673},
 				run: (*parser).callonNullLiteral1,
 				expr: &ruleRefExpr{
-					pos:  position{line: 652, col: 4, offset: 14330},
+					pos:  position{line: 800, col: 4, offset: 17673},
 					name: "NullToken",
 				},
 			},
 		},
 		{
 			name: "NumberLiteral",
-			pos:  position{line: 655, col: 1, offset: 14377},
+			pos:  position{line: 806, col: 1, offset: 17736},
 			expr: &choiceExpr{
-				pos: position{line: 656, col: 4, offset: 14394},
+				pos: position{line: 807, col: 4, offset: 17753},
 				alternatives: []interface{}{
 					&actionExpr{
-						pos: position{line: 656, col: 4, offset: 14394},
+						pos: position{line: 807, col: 4, offset: 17753},
 						run: (*parser).callonNumberLiteral2,
 						expr: &seqExpr{
-							pos: position{line: 656, col: 4, offset: 14394},
+							pos: position{line: 807, col: 4, offset: 17753},
 							exprs: []interface{}{
 								&andExpr{
-									pos: position{line: 656, col: 4, offset: 14394},
+									pos: position{line: 807, col: 4, offset: 17753},
 									expr: &seqExpr{
-										pos: position{line: 656, col: 6, offset: 14396},
+										pos: position{line: 807, col: 6, offset: 17755},
 										exprs: []interface{}{
 											&litMatcher{
-												pos:        position{line: 656, col: 6, offset: 14396},
+												pos:        position{line: 807, col: 6, offset: 17755},
 												val:        "0",
 												ignoreCase: false,
 											},
 											&litMatcher{
-												pos:        position{line: 656, col: 10, offset: 14400},
+												pos:        position{line: 807, col: 10, offset: 17759},
 												val:        "x",
 												ignoreCase: true,
 											},
@@ -3460,10 +3475,10 @@ var g = &grammar{
 									},
 								},
 								&labeledExpr{
-									pos:   position{line: 656, col: 16, offset: 14406},
+									pos:   position{line: 807, col: 16, offset: 17765},
 									label: "h",
 									expr: &ruleRefExpr{
-										pos:  position{line: 656, col: 18, offset: 14408},
+										pos:  position{line: 807, col: 18, offset: 17767},
 										name: "Hex",
 									},
 								},
@@ -3471,7 +3486,7 @@ var g = &grammar{
 						},
 					},
 					&ruleRefExpr{
-						pos:  position{line: 657, col: 4, offset: 14433},
+						pos:  position{line: 808, col: 4, offset: 17792},
 						name: "Decimal",
 					},
 				},
@@ -3479,9 +3494,9 @@ var g = &grammar{
 		},
 		{
 			name: "Sign",
-			pos:  position{line: 659, col: 1, offset: 14442},
+			pos:  position{line: 810, col: 1, offset: 17801},
 			expr: &charClassMatcher{
-				pos:        position{line: 660, col: 4, offset: 14450},
+				pos:        position{line: 811, col: 4, offset: 17809},
 				val:        "[-+]",
 				chars:      []rune{'-', '+'},
 				ignoreCase: false,
@@ -3490,14 +3505,14 @@ var g = &grammar{
 		},
 		{
 			name: "Integer",
-			pos:  position{line: 662, col: 1, offset: 14456},
+			pos:  position{line: 813, col: 1, offset: 17815},
 			expr: &actionExpr{
-				pos: position{line: 663, col: 4, offset: 14467},
+				pos: position{line: 814, col: 4, offset: 17826},
 				run: (*parser).callonInteger1,
 				expr: &oneOrMoreExpr{
-					pos: position{line: 663, col: 4, offset: 14467},
+					pos: position{line: 814, col: 4, offset: 17826},
 					expr: &charClassMatcher{
-						pos:        position{line: 663, col: 4, offset: 14467},
+						pos:        position{line: 814, col: 4, offset: 17826},
 						val:        "[0-9]",
 						ranges:     []rune{'0', '9'},
 						ignoreCase: false,
@@ -3508,32 +3523,32 @@ var g = &grammar{
 		},
 		{
 			name: "NonZeroLeadingInteger",
-			pos:  position{line: 682, col: 1, offset: 14910},
+			pos:  position{line: 834, col: 1, offset: 18261},
 			expr: &actionExpr{
-				pos: position{line: 683, col: 4, offset: 14935},
+				pos: position{line: 835, col: 4, offset: 18286},
 				run: (*parser).callonNonZeroLeadingInteger1,
 				expr: &choiceExpr{
-					pos: position{line: 683, col: 6, offset: 14937},
+					pos: position{line: 835, col: 6, offset: 18288},
 					alternatives: []interface{}{
 						&litMatcher{
-							pos:        position{line: 683, col: 6, offset: 14937},
+							pos:        position{line: 835, col: 6, offset: 18288},
 							val:        "0",
 							ignoreCase: false,
 						},
 						&seqExpr{
-							pos: position{line: 683, col: 12, offset: 14943},
+							pos: position{line: 835, col: 12, offset: 18294},
 							exprs: []interface{}{
 								&charClassMatcher{
-									pos:        position{line: 683, col: 12, offset: 14943},
+									pos:        position{line: 835, col: 12, offset: 18294},
 									val:        "[1-9]",
 									ranges:     []rune{'1', '9'},
 									ignoreCase: false,
 									inverted:   false,
 								},
 								&zeroOrMoreExpr{
-									pos: position{line: 683, col: 17, offset: 14948},
+									pos: position{line: 835, col: 17, offset: 18299},
 									expr: &charClassMatcher{
-										pos:        position{line: 683, col: 17, offset: 14948},
+										pos:        position{line: 835, col: 17, offset: 18299},
 										val:        "[0-9]",
 										ranges:     []rune{'0', '9'},
 										ignoreCase: false,
@@ -3548,39 +3563,39 @@ var g = &grammar{
 		},
 		{
 			name: "Fixnum",
-			pos:  position{line: 686, col: 1, offset: 14981},
+			pos:  position{line: 838, col: 1, offset: 18332},
 			expr: &choiceExpr{
-				pos: position{line: 687, col: 4, offset: 14991},
+				pos: position{line: 839, col: 4, offset: 18342},
 				alternatives: []interface{}{
 					&seqExpr{
-						pos: position{line: 687, col: 4, offset: 14991},
+						pos: position{line: 839, col: 4, offset: 18342},
 						exprs: []interface{}{
 							&ruleRefExpr{
-								pos:  position{line: 687, col: 4, offset: 14991},
+								pos:  position{line: 839, col: 4, offset: 18342},
 								name: "Integer",
 							},
 							&litMatcher{
-								pos:        position{line: 687, col: 12, offset: 14999},
+								pos:        position{line: 839, col: 12, offset: 18350},
 								val:        ".",
 								ignoreCase: false,
 							},
 							&ruleRefExpr{
-								pos:  position{line: 687, col: 16, offset: 15003},
+								pos:  position{line: 839, col: 16, offset: 18354},
 								name: "Integer",
 							},
 						},
 					},
 					&seqExpr{
-						pos: position{line: 688, col: 4, offset: 15014},
+						pos: position{line: 840, col: 4, offset: 18365},
 						exprs: []interface{}{
 							&ruleRefExpr{
-								pos:  position{line: 688, col: 4, offset: 15014},
+								pos:  position{line: 840, col: 4, offset: 18365},
 								name: "Integer",
 							},
 							&zeroOrOneExpr{
-								pos: position{line: 688, col: 12, offset: 15022},
+								pos: position{line: 840, col: 12, offset: 18373},
 								expr: &litMatcher{
-									pos:        position{line: 688, col: 12, offset: 15022},
+									pos:        position{line: 840, col: 12, offset: 18373},
 									val:        ".",
 									ignoreCase: false,
 								},
@@ -3588,15 +3603,15 @@ var g = &grammar{
 						},
 					},
 					&seqExpr{
-						pos: position{line: 689, col: 4, offset: 15030},
+						pos: position{line: 841, col: 4, offset: 18381},
 						exprs: []interface{}{
 							&litMatcher{
-								pos:        position{line: 689, col: 4, offset: 15030},
+								pos:        position{line: 841, col: 4, offset: 18381},
 								val:        ".",
 								ignoreCase: false,
 							},
 							&ruleRefExpr{
-								pos:  position{line: 689, col: 8, offset: 15034},
+								pos:  position{line: 841, col: 8, offset: 18385},
 								name: "Integer",
 							},
 						},
@@ -3606,36 +3621,36 @@ var g = &grammar{
 		},
 		{
 			name: "Decimal",
-			pos:  position{line: 691, col: 1, offset: 15043},
+			pos:  position{line: 843, col: 1, offset: 18394},
 			expr: &actionExpr{
-				pos: position{line: 692, col: 4, offset: 15054},
+				pos: position{line: 844, col: 4, offset: 18405},
 				run: (*parser).callonDecimal1,
 				expr: &seqExpr{
-					pos: position{line: 692, col: 4, offset: 15054},
+					pos: position{line: 844, col: 4, offset: 18405},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 692, col: 4, offset: 15054},
+							pos:  position{line: 844, col: 4, offset: 18405},
 							name: "Fixnum",
 						},
 						&zeroOrOneExpr{
-							pos: position{line: 692, col: 11, offset: 15061},
+							pos: position{line: 844, col: 11, offset: 18412},
 							expr: &seqExpr{
-								pos: position{line: 692, col: 13, offset: 15063},
+								pos: position{line: 844, col: 13, offset: 18414},
 								exprs: []interface{}{
 									&litMatcher{
-										pos:        position{line: 692, col: 13, offset: 15063},
+										pos:        position{line: 844, col: 13, offset: 18414},
 										val:        "e",
 										ignoreCase: true,
 									},
 									&zeroOrOneExpr{
-										pos: position{line: 692, col: 18, offset: 15068},
+										pos: position{line: 844, col: 18, offset: 18419},
 										expr: &ruleRefExpr{
-											pos:  position{line: 692, col: 18, offset: 15068},
+											pos:  position{line: 844, col: 18, offset: 18419},
 											name: "Sign",
 										},
 									},
 									&ruleRefExpr{
-										pos:  position{line: 692, col: 24, offset: 15074},
+										pos:  position{line: 844, col: 24, offset: 18425},
 										name: "Integer",
 									},
 								},
@@ -3647,30 +3662,30 @@ var g = &grammar{
 		},
 		{
 			name: "Hex",
-			pos:  position{line: 711, col: 1, offset: 15503},
+			pos:  position{line: 863, col: 1, offset: 18840},
 			expr: &actionExpr{
-				pos: position{line: 712, col: 4, offset: 15510},
+				pos: position{line: 864, col: 4, offset: 18847},
 				run: (*parser).callonHex1,
 				expr: &seqExpr{
-					pos: position{line: 712, col: 4, offset: 15510},
+					pos: position{line: 864, col: 4, offset: 18847},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 712, col: 4, offset: 15510},
+							pos:        position{line: 864, col: 4, offset: 18847},
 							val:        "0",
 							ignoreCase: false,
 						},
 						&litMatcher{
-							pos:        position{line: 712, col: 8, offset: 15514},
+							pos:        position{line: 864, col: 8, offset: 18851},
 							val:        "x",
 							ignoreCase: true,
 						},
 						&labeledExpr{
-							pos:   position{line: 712, col: 13, offset: 15519},
+							pos:   position{line: 864, col: 13, offset: 18856},
 							label: "s",
 							expr: &oneOrMoreExpr{
-								pos: position{line: 712, col: 15, offset: 15521},
+								pos: position{line: 864, col: 15, offset: 18858},
 								expr: &charClassMatcher{
-									pos:        position{line: 712, col: 17, offset: 15523},
+									pos:        position{line: 864, col: 17, offset: 18860},
 									val:        "[0-9A-Fa-f]",
 									ranges:     []rune{'0', '9', 'A', 'F', 'a', 'f'},
 									ignoreCase: false,
@@ -3679,9 +3694,9 @@ var g = &grammar{
 							},
 						},
 						&notExpr{
-							pos: position{line: 712, col: 32, offset: 15538},
+							pos: position{line: 864, col: 32, offset: 18875},
 							expr: &ruleRefExpr{
-								pos:  position{line: 712, col: 33, offset: 15539},
+								pos:  position{line: 864, col: 33, offset: 18876},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -3691,16 +3706,16 @@ var g = &grammar{
 		},
 		{
 			name: "StringLiteral",
-			pos:  position{line: 715, col: 1, offset: 15604},
+			pos:  position{line: 867, col: 1, offset: 18954},
 			expr: &choiceExpr{
-				pos: position{line: 716, col: 4, offset: 15621},
+				pos: position{line: 868, col: 4, offset: 18971},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 716, col: 4, offset: 15621},
+						pos:  position{line: 868, col: 4, offset: 18971},
 						name: "HexString",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 717, col: 4, offset: 15634},
+						pos:  position{line: 869, col: 4, offset: 18984},
 						name: "NormalString",
 					},
 				},
@@ -3708,53 +3723,53 @@ var g = &grammar{
 		},
 		{
 			name: "HexString",
-			pos:  position{line: 719, col: 1, offset: 15648},
+			pos:  position{line: 871, col: 1, offset: 18998},
 			expr: &actionExpr{
-				pos: position{line: 720, col: 4, offset: 15661},
+				pos: position{line: 872, col: 4, offset: 19011},
 				run: (*parser).callonHexString1,
 				expr: &seqExpr{
-					pos: position{line: 720, col: 4, offset: 15661},
+					pos: position{line: 872, col: 4, offset: 19011},
 					exprs: []interface{}{
 						&choiceExpr{
-							pos: position{line: 720, col: 6, offset: 15663},
+							pos: position{line: 872, col: 6, offset: 19013},
 							alternatives: []interface{}{
 								&litMatcher{
-									pos:        position{line: 720, col: 6, offset: 15663},
+									pos:        position{line: 872, col: 6, offset: 19013},
 									val:        "hex",
 									ignoreCase: true,
 								},
 								&litMatcher{
-									pos:        position{line: 720, col: 15, offset: 15672},
+									pos:        position{line: 872, col: 15, offset: 19022},
 									val:        "x",
 									ignoreCase: true,
 								},
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 720, col: 22, offset: 15679},
+							pos:        position{line: 872, col: 22, offset: 19029},
 							val:        "'",
 							ignoreCase: false,
 						},
 						&labeledExpr{
-							pos:   position{line: 720, col: 26, offset: 15683},
+							pos:   position{line: 872, col: 26, offset: 19033},
 							label: "s",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 720, col: 28, offset: 15685},
+								pos: position{line: 872, col: 28, offset: 19035},
 								expr: &actionExpr{
-									pos: position{line: 720, col: 29, offset: 15686},
+									pos: position{line: 872, col: 29, offset: 19036},
 									run: (*parser).callonHexString9,
 									expr: &seqExpr{
-										pos: position{line: 720, col: 29, offset: 15686},
+										pos: position{line: 872, col: 29, offset: 19036},
 										exprs: []interface{}{
 											&charClassMatcher{
-												pos:        position{line: 720, col: 29, offset: 15686},
+												pos:        position{line: 872, col: 29, offset: 19036},
 												val:        "[0-9a-fA-F]",
 												ranges:     []rune{'0', '9', 'a', 'f', 'A', 'F'},
 												ignoreCase: false,
 												inverted:   false,
 											},
 											&charClassMatcher{
-												pos:        position{line: 720, col: 40, offset: 15697},
+												pos:        position{line: 872, col: 40, offset: 19047},
 												val:        "[0-9a-fA-F]",
 												ranges:     []rune{'0', '9', 'a', 'f', 'A', 'F'},
 												ignoreCase: false,
@@ -3766,7 +3781,7 @@ var g = &grammar{
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 720, col: 78, offset: 15735},
+							pos:        position{line: 872, col: 78, offset: 19085},
 							val:        "'",
 							ignoreCase: false,
 						},
@@ -3776,46 +3791,46 @@ var g = &grammar{
 		},
 		{
 			name: "NormalString",
-			pos:  position{line: 723, col: 1, offset: 15804},
+			pos:  position{line: 879, col: 1, offset: 19191},
 			expr: &actionExpr{
-				pos: position{line: 724, col: 4, offset: 15820},
+				pos: position{line: 880, col: 4, offset: 19207},
 				run: (*parser).callonNormalString1,
 				expr: &seqExpr{
-					pos: position{line: 724, col: 4, offset: 15820},
+					pos: position{line: 880, col: 4, offset: 19207},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 724, col: 4, offset: 15820},
+							pos:        position{line: 880, col: 4, offset: 19207},
 							val:        "'",
 							ignoreCase: false,
 						},
 						&labeledExpr{
-							pos:   position{line: 724, col: 8, offset: 15824},
+							pos:   position{line: 880, col: 8, offset: 19211},
 							label: "s",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 724, col: 10, offset: 15826},
+								pos: position{line: 880, col: 10, offset: 19213},
 								expr: &actionExpr{
-									pos: position{line: 724, col: 12, offset: 15828},
+									pos: position{line: 880, col: 12, offset: 19215},
 									run: (*parser).callonNormalString6,
 									expr: &choiceExpr{
-										pos: position{line: 724, col: 14, offset: 15830},
+										pos: position{line: 880, col: 14, offset: 19217},
 										alternatives: []interface{}{
 											&charClassMatcher{
-												pos:        position{line: 724, col: 14, offset: 15830},
+												pos:        position{line: 880, col: 14, offset: 19217},
 												val:        "[^'\\r\\n\\\\]",
 												chars:      []rune{'\'', '\r', '\n', '\\'},
 												ignoreCase: false,
 												inverted:   true,
 											},
 											&seqExpr{
-												pos: position{line: 724, col: 27, offset: 15843},
+												pos: position{line: 880, col: 27, offset: 19230},
 												exprs: []interface{}{
 													&litMatcher{
-														pos:        position{line: 724, col: 27, offset: 15843},
+														pos:        position{line: 880, col: 27, offset: 19230},
 														val:        "\\",
 														ignoreCase: false,
 													},
 													&anyMatcher{
-														line: 724, col: 32, offset: 15848,
+														line: 880, col: 32, offset: 19235,
 													},
 												},
 											},
@@ -3825,7 +3840,7 @@ var g = &grammar{
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 724, col: 62, offset: 15878},
+							pos:        position{line: 880, col: 62, offset: 19265},
 							val:        "'",
 							ignoreCase: false,
 						},
@@ -3835,19 +3850,19 @@ var g = &grammar{
 		},
 		{
 			name: "SelectToken",
-			pos:  position{line: 747, col: 1, offset: 16367},
+			pos:  position{line: 903, col: 1, offset: 19768},
 			expr: &seqExpr{
-				pos: position{line: 748, col: 4, offset: 16382},
+				pos: position{line: 904, col: 4, offset: 19783},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 748, col: 4, offset: 16382},
+						pos:        position{line: 904, col: 4, offset: 19783},
 						val:        "select",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 748, col: 14, offset: 16392},
+						pos: position{line: 904, col: 14, offset: 19793},
 						expr: &ruleRefExpr{
-							pos:  position{line: 748, col: 15, offset: 16393},
+							pos:  position{line: 904, col: 15, offset: 19794},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3856,19 +3871,19 @@ var g = &grammar{
 		},
 		{
 			name: "FromToken",
-			pos:  position{line: 750, col: 1, offset: 16415},
+			pos:  position{line: 906, col: 1, offset: 19816},
 			expr: &seqExpr{
-				pos: position{line: 751, col: 4, offset: 16428},
+				pos: position{line: 907, col: 4, offset: 19829},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 751, col: 4, offset: 16428},
+						pos:        position{line: 907, col: 4, offset: 19829},
 						val:        "from",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 751, col: 12, offset: 16436},
+						pos: position{line: 907, col: 12, offset: 19837},
 						expr: &ruleRefExpr{
-							pos:  position{line: 751, col: 13, offset: 16437},
+							pos:  position{line: 907, col: 13, offset: 19838},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3877,19 +3892,19 @@ var g = &grammar{
 		},
 		{
 			name: "WhereToken",
-			pos:  position{line: 753, col: 1, offset: 16459},
+			pos:  position{line: 909, col: 1, offset: 19860},
 			expr: &seqExpr{
-				pos: position{line: 754, col: 4, offset: 16473},
+				pos: position{line: 910, col: 4, offset: 19874},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 754, col: 4, offset: 16473},
+						pos:        position{line: 910, col: 4, offset: 19874},
 						val:        "where",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 754, col: 13, offset: 16482},
+						pos: position{line: 910, col: 13, offset: 19883},
 						expr: &ruleRefExpr{
-							pos:  position{line: 754, col: 14, offset: 16483},
+							pos:  position{line: 910, col: 14, offset: 19884},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3898,19 +3913,19 @@ var g = &grammar{
 		},
 		{
 			name: "OrderToken",
-			pos:  position{line: 756, col: 1, offset: 16505},
+			pos:  position{line: 912, col: 1, offset: 19906},
 			expr: &seqExpr{
-				pos: position{line: 757, col: 4, offset: 16519},
+				pos: position{line: 913, col: 4, offset: 19920},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 757, col: 4, offset: 16519},
+						pos:        position{line: 913, col: 4, offset: 19920},
 						val:        "order",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 757, col: 13, offset: 16528},
+						pos: position{line: 913, col: 13, offset: 19929},
 						expr: &ruleRefExpr{
-							pos:  position{line: 757, col: 14, offset: 16529},
+							pos:  position{line: 913, col: 14, offset: 19930},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3919,19 +3934,19 @@ var g = &grammar{
 		},
 		{
 			name: "ByToken",
-			pos:  position{line: 759, col: 1, offset: 16551},
+			pos:  position{line: 915, col: 1, offset: 19952},
 			expr: &seqExpr{
-				pos: position{line: 760, col: 4, offset: 16562},
+				pos: position{line: 916, col: 4, offset: 19963},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 760, col: 4, offset: 16562},
+						pos:        position{line: 916, col: 4, offset: 19963},
 						val:        "by",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 760, col: 10, offset: 16568},
+						pos: position{line: 916, col: 10, offset: 19969},
 						expr: &ruleRefExpr{
-							pos:  position{line: 760, col: 11, offset: 16569},
+							pos:  position{line: 916, col: 11, offset: 19970},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3940,19 +3955,19 @@ var g = &grammar{
 		},
 		{
 			name: "GroupToken",
-			pos:  position{line: 762, col: 1, offset: 16591},
+			pos:  position{line: 918, col: 1, offset: 19992},
 			expr: &seqExpr{
-				pos: position{line: 763, col: 4, offset: 16605},
+				pos: position{line: 919, col: 4, offset: 20006},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 763, col: 4, offset: 16605},
+						pos:        position{line: 919, col: 4, offset: 20006},
 						val:        "group",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 763, col: 13, offset: 16614},
+						pos: position{line: 919, col: 13, offset: 20015},
 						expr: &ruleRefExpr{
-							pos:  position{line: 763, col: 14, offset: 16615},
+							pos:  position{line: 919, col: 14, offset: 20016},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3961,19 +3976,19 @@ var g = &grammar{
 		},
 		{
 			name: "LimitToken",
-			pos:  position{line: 765, col: 1, offset: 16637},
+			pos:  position{line: 921, col: 1, offset: 20038},
 			expr: &seqExpr{
-				pos: position{line: 766, col: 4, offset: 16651},
+				pos: position{line: 922, col: 4, offset: 20052},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 766, col: 4, offset: 16651},
+						pos:        position{line: 922, col: 4, offset: 20052},
 						val:        "limit",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 766, col: 13, offset: 16660},
+						pos: position{line: 922, col: 13, offset: 20061},
 						expr: &ruleRefExpr{
-							pos:  position{line: 766, col: 14, offset: 16661},
+							pos:  position{line: 922, col: 14, offset: 20062},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -3982,19 +3997,19 @@ var g = &grammar{
 		},
 		{
 			name: "OffsetToken",
-			pos:  position{line: 768, col: 1, offset: 16683},
+			pos:  position{line: 924, col: 1, offset: 20084},
 			expr: &seqExpr{
-				pos: position{line: 769, col: 4, offset: 16698},
+				pos: position{line: 925, col: 4, offset: 20099},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 769, col: 4, offset: 16698},
+						pos:        position{line: 925, col: 4, offset: 20099},
 						val:        "offset",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 769, col: 14, offset: 16708},
+						pos: position{line: 925, col: 14, offset: 20109},
 						expr: &ruleRefExpr{
-							pos:  position{line: 769, col: 15, offset: 16709},
+							pos:  position{line: 925, col: 15, offset: 20110},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4003,19 +4018,19 @@ var g = &grammar{
 		},
 		{
 			name: "UpdateToken",
-			pos:  position{line: 771, col: 1, offset: 16731},
+			pos:  position{line: 927, col: 1, offset: 20132},
 			expr: &seqExpr{
-				pos: position{line: 772, col: 4, offset: 16746},
+				pos: position{line: 928, col: 4, offset: 20147},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 772, col: 4, offset: 16746},
+						pos:        position{line: 928, col: 4, offset: 20147},
 						val:        "update",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 772, col: 14, offset: 16756},
+						pos: position{line: 928, col: 14, offset: 20157},
 						expr: &ruleRefExpr{
-							pos:  position{line: 772, col: 15, offset: 16757},
+							pos:  position{line: 928, col: 15, offset: 20158},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4024,19 +4039,19 @@ var g = &grammar{
 		},
 		{
 			name: "SetToken",
-			pos:  position{line: 774, col: 1, offset: 16779},
+			pos:  position{line: 930, col: 1, offset: 20180},
 			expr: &seqExpr{
-				pos: position{line: 775, col: 4, offset: 16791},
+				pos: position{line: 931, col: 4, offset: 20192},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 775, col: 4, offset: 16791},
+						pos:        position{line: 931, col: 4, offset: 20192},
 						val:        "set",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 775, col: 11, offset: 16798},
+						pos: position{line: 931, col: 11, offset: 20199},
 						expr: &ruleRefExpr{
-							pos:  position{line: 775, col: 12, offset: 16799},
+							pos:  position{line: 931, col: 12, offset: 20200},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4045,19 +4060,19 @@ var g = &grammar{
 		},
 		{
 			name: "DeleteToken",
-			pos:  position{line: 777, col: 1, offset: 16821},
+			pos:  position{line: 933, col: 1, offset: 20222},
 			expr: &seqExpr{
-				pos: position{line: 778, col: 4, offset: 16836},
+				pos: position{line: 934, col: 4, offset: 20237},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 778, col: 4, offset: 16836},
+						pos:        position{line: 934, col: 4, offset: 20237},
 						val:        "delete",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 778, col: 14, offset: 16846},
+						pos: position{line: 934, col: 14, offset: 20247},
 						expr: &ruleRefExpr{
-							pos:  position{line: 778, col: 15, offset: 16847},
+							pos:  position{line: 934, col: 15, offset: 20248},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4066,19 +4081,19 @@ var g = &grammar{
 		},
 		{
 			name: "InsertToken",
-			pos:  position{line: 780, col: 1, offset: 16869},
+			pos:  position{line: 936, col: 1, offset: 20270},
 			expr: &seqExpr{
-				pos: position{line: 781, col: 4, offset: 16884},
+				pos: position{line: 937, col: 4, offset: 20285},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 781, col: 4, offset: 16884},
+						pos:        position{line: 937, col: 4, offset: 20285},
 						val:        "insert",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 781, col: 14, offset: 16894},
+						pos: position{line: 937, col: 14, offset: 20295},
 						expr: &ruleRefExpr{
-							pos:  position{line: 781, col: 15, offset: 16895},
+							pos:  position{line: 937, col: 15, offset: 20296},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4087,19 +4102,19 @@ var g = &grammar{
 		},
 		{
 			name: "IntoToken",
-			pos:  position{line: 783, col: 1, offset: 16917},
+			pos:  position{line: 939, col: 1, offset: 20318},
 			expr: &seqExpr{
-				pos: position{line: 784, col: 4, offset: 16930},
+				pos: position{line: 940, col: 4, offset: 20331},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 784, col: 4, offset: 16930},
+						pos:        position{line: 940, col: 4, offset: 20331},
 						val:        "into",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 784, col: 12, offset: 16938},
+						pos: position{line: 940, col: 12, offset: 20339},
 						expr: &ruleRefExpr{
-							pos:  position{line: 784, col: 13, offset: 16939},
+							pos:  position{line: 940, col: 13, offset: 20340},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4108,19 +4123,19 @@ var g = &grammar{
 		},
 		{
 			name: "ValuesToken",
-			pos:  position{line: 786, col: 1, offset: 16961},
+			pos:  position{line: 942, col: 1, offset: 20362},
 			expr: &seqExpr{
-				pos: position{line: 787, col: 4, offset: 16976},
+				pos: position{line: 943, col: 4, offset: 20377},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 787, col: 4, offset: 16976},
+						pos:        position{line: 943, col: 4, offset: 20377},
 						val:        "values",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 787, col: 14, offset: 16986},
+						pos: position{line: 943, col: 14, offset: 20387},
 						expr: &ruleRefExpr{
-							pos:  position{line: 787, col: 15, offset: 16987},
+							pos:  position{line: 943, col: 15, offset: 20388},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4129,19 +4144,19 @@ var g = &grammar{
 		},
 		{
 			name: "CreateToken",
-			pos:  position{line: 789, col: 1, offset: 17009},
+			pos:  position{line: 945, col: 1, offset: 20410},
 			expr: &seqExpr{
-				pos: position{line: 790, col: 4, offset: 17024},
+				pos: position{line: 946, col: 4, offset: 20425},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 790, col: 4, offset: 17024},
+						pos:        position{line: 946, col: 4, offset: 20425},
 						val:        "create",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 790, col: 14, offset: 17034},
+						pos: position{line: 946, col: 14, offset: 20435},
 						expr: &ruleRefExpr{
-							pos:  position{line: 790, col: 15, offset: 17035},
+							pos:  position{line: 946, col: 15, offset: 20436},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4150,19 +4165,19 @@ var g = &grammar{
 		},
 		{
 			name: "TableToken",
-			pos:  position{line: 792, col: 1, offset: 17057},
+			pos:  position{line: 948, col: 1, offset: 20458},
 			expr: &seqExpr{
-				pos: position{line: 793, col: 4, offset: 17071},
+				pos: position{line: 949, col: 4, offset: 20472},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 793, col: 4, offset: 17071},
+						pos:        position{line: 949, col: 4, offset: 20472},
 						val:        "table",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 793, col: 13, offset: 17080},
+						pos: position{line: 949, col: 13, offset: 20481},
 						expr: &ruleRefExpr{
-							pos:  position{line: 793, col: 14, offset: 17081},
+							pos:  position{line: 949, col: 14, offset: 20482},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4171,19 +4186,19 @@ var g = &grammar{
 		},
 		{
 			name: "IndexToken",
-			pos:  position{line: 795, col: 1, offset: 17103},
+			pos:  position{line: 951, col: 1, offset: 20504},
 			expr: &seqExpr{
-				pos: position{line: 796, col: 4, offset: 17117},
+				pos: position{line: 952, col: 4, offset: 20518},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 796, col: 4, offset: 17117},
+						pos:        position{line: 952, col: 4, offset: 20518},
 						val:        "index",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 796, col: 13, offset: 17126},
+						pos: position{line: 952, col: 13, offset: 20527},
 						expr: &ruleRefExpr{
-							pos:  position{line: 796, col: 14, offset: 17127},
+							pos:  position{line: 952, col: 14, offset: 20528},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4192,19 +4207,19 @@ var g = &grammar{
 		},
 		{
 			name: "UniqueToken",
-			pos:  position{line: 798, col: 1, offset: 17149},
+			pos:  position{line: 954, col: 1, offset: 20550},
 			expr: &seqExpr{
-				pos: position{line: 799, col: 4, offset: 17164},
+				pos: position{line: 955, col: 4, offset: 20565},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 799, col: 4, offset: 17164},
+						pos:        position{line: 955, col: 4, offset: 20565},
 						val:        "unique",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 799, col: 14, offset: 17174},
+						pos: position{line: 955, col: 14, offset: 20575},
 						expr: &ruleRefExpr{
-							pos:  position{line: 799, col: 15, offset: 17175},
+							pos:  position{line: 955, col: 15, offset: 20576},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4213,19 +4228,19 @@ var g = &grammar{
 		},
 		{
 			name: "DefaultToken",
-			pos:  position{line: 801, col: 1, offset: 17197},
+			pos:  position{line: 957, col: 1, offset: 20598},
 			expr: &seqExpr{
-				pos: position{line: 802, col: 4, offset: 17213},
+				pos: position{line: 958, col: 4, offset: 20614},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 802, col: 4, offset: 17213},
+						pos:        position{line: 958, col: 4, offset: 20614},
 						val:        "default",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 802, col: 15, offset: 17224},
+						pos: position{line: 958, col: 15, offset: 20625},
 						expr: &ruleRefExpr{
-							pos:  position{line: 802, col: 16, offset: 17225},
+							pos:  position{line: 958, col: 16, offset: 20626},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4234,19 +4249,19 @@ var g = &grammar{
 		},
 		{
 			name: "PrimaryToken",
-			pos:  position{line: 804, col: 1, offset: 17247},
+			pos:  position{line: 960, col: 1, offset: 20648},
 			expr: &seqExpr{
-				pos: position{line: 805, col: 4, offset: 17263},
+				pos: position{line: 961, col: 4, offset: 20664},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 805, col: 4, offset: 17263},
+						pos:        position{line: 961, col: 4, offset: 20664},
 						val:        "primary",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 805, col: 15, offset: 17274},
+						pos: position{line: 961, col: 15, offset: 20675},
 						expr: &ruleRefExpr{
-							pos:  position{line: 805, col: 16, offset: 17275},
+							pos:  position{line: 961, col: 16, offset: 20676},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4255,19 +4270,19 @@ var g = &grammar{
 		},
 		{
 			name: "KeyToken",
-			pos:  position{line: 807, col: 1, offset: 17297},
+			pos:  position{line: 963, col: 1, offset: 20698},
 			expr: &seqExpr{
-				pos: position{line: 808, col: 4, offset: 17309},
+				pos: position{line: 964, col: 4, offset: 20710},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 808, col: 4, offset: 17309},
+						pos:        position{line: 964, col: 4, offset: 20710},
 						val:        "key",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 808, col: 11, offset: 17316},
+						pos: position{line: 964, col: 11, offset: 20717},
 						expr: &ruleRefExpr{
-							pos:  position{line: 808, col: 12, offset: 17317},
+							pos:  position{line: 964, col: 12, offset: 20718},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4276,19 +4291,19 @@ var g = &grammar{
 		},
 		{
 			name: "ReferencesToken",
-			pos:  position{line: 810, col: 1, offset: 17339},
+			pos:  position{line: 966, col: 1, offset: 20740},
 			expr: &seqExpr{
-				pos: position{line: 811, col: 4, offset: 17358},
+				pos: position{line: 967, col: 4, offset: 20759},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 811, col: 4, offset: 17358},
+						pos:        position{line: 967, col: 4, offset: 20759},
 						val:        "references",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 811, col: 18, offset: 17372},
+						pos: position{line: 967, col: 18, offset: 20773},
 						expr: &ruleRefExpr{
-							pos:  position{line: 811, col: 19, offset: 17373},
+							pos:  position{line: 967, col: 19, offset: 20774},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4297,19 +4312,19 @@ var g = &grammar{
 		},
 		{
 			name: "AutoincrementToken",
-			pos:  position{line: 813, col: 1, offset: 17395},
+			pos:  position{line: 969, col: 1, offset: 20796},
 			expr: &seqExpr{
-				pos: position{line: 814, col: 4, offset: 17417},
+				pos: position{line: 970, col: 4, offset: 20818},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 814, col: 4, offset: 17417},
+						pos:        position{line: 970, col: 4, offset: 20818},
 						val:        "autoincrement",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 814, col: 21, offset: 17434},
+						pos: position{line: 970, col: 21, offset: 20835},
 						expr: &ruleRefExpr{
-							pos:  position{line: 814, col: 22, offset: 17435},
+							pos:  position{line: 970, col: 22, offset: 20836},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4318,19 +4333,19 @@ var g = &grammar{
 		},
 		{
 			name: "OnToken",
-			pos:  position{line: 816, col: 1, offset: 17457},
+			pos:  position{line: 972, col: 1, offset: 20858},
 			expr: &seqExpr{
-				pos: position{line: 817, col: 4, offset: 17468},
+				pos: position{line: 973, col: 4, offset: 20869},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 817, col: 4, offset: 17468},
+						pos:        position{line: 973, col: 4, offset: 20869},
 						val:        "on",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 817, col: 10, offset: 17474},
+						pos: position{line: 973, col: 10, offset: 20875},
 						expr: &ruleRefExpr{
-							pos:  position{line: 817, col: 11, offset: 17475},
+							pos:  position{line: 973, col: 11, offset: 20876},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4339,22 +4354,22 @@ var g = &grammar{
 		},
 		{
 			name: "TrueToken",
-			pos:  position{line: 819, col: 1, offset: 17497},
+			pos:  position{line: 975, col: 1, offset: 20898},
 			expr: &actionExpr{
-				pos: position{line: 820, col: 4, offset: 17510},
+				pos: position{line: 976, col: 4, offset: 20911},
 				run: (*parser).callonTrueToken1,
 				expr: &seqExpr{
-					pos: position{line: 820, col: 4, offset: 17510},
+					pos: position{line: 976, col: 4, offset: 20911},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 820, col: 4, offset: 17510},
+							pos:        position{line: 976, col: 4, offset: 20911},
 							val:        "true",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 820, col: 12, offset: 17518},
+							pos: position{line: 976, col: 12, offset: 20919},
 							expr: &ruleRefExpr{
-								pos:  position{line: 820, col: 13, offset: 17519},
+								pos:  position{line: 976, col: 13, offset: 20920},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4364,22 +4379,22 @@ var g = &grammar{
 		},
 		{
 			name: "FalseToken",
-			pos:  position{line: 823, col: 1, offset: 17573},
+			pos:  position{line: 979, col: 1, offset: 20974},
 			expr: &actionExpr{
-				pos: position{line: 824, col: 4, offset: 17587},
+				pos: position{line: 980, col: 4, offset: 20988},
 				run: (*parser).callonFalseToken1,
 				expr: &seqExpr{
-					pos: position{line: 824, col: 4, offset: 17587},
+					pos: position{line: 980, col: 4, offset: 20988},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 824, col: 4, offset: 17587},
+							pos:        position{line: 980, col: 4, offset: 20988},
 							val:        "false",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 824, col: 13, offset: 17596},
+							pos: position{line: 980, col: 13, offset: 20997},
 							expr: &ruleRefExpr{
-								pos:  position{line: 824, col: 14, offset: 17597},
+								pos:  position{line: 980, col: 14, offset: 20998},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4389,19 +4404,19 @@ var g = &grammar{
 		},
 		{
 			name: "NullToken",
-			pos:  position{line: 827, col: 1, offset: 17651},
+			pos:  position{line: 983, col: 1, offset: 21052},
 			expr: &seqExpr{
-				pos: position{line: 828, col: 4, offset: 17664},
+				pos: position{line: 984, col: 4, offset: 21065},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 828, col: 4, offset: 17664},
+						pos:        position{line: 984, col: 4, offset: 21065},
 						val:        "null",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 828, col: 12, offset: 17672},
+						pos: position{line: 984, col: 12, offset: 21073},
 						expr: &ruleRefExpr{
-							pos:  position{line: 828, col: 13, offset: 17673},
+							pos:  position{line: 984, col: 13, offset: 21074},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4410,19 +4425,19 @@ var g = &grammar{
 		},
 		{
 			name: "IsToken",
-			pos:  position{line: 830, col: 1, offset: 17695},
+			pos:  position{line: 986, col: 1, offset: 21096},
 			expr: &seqExpr{
-				pos: position{line: 831, col: 4, offset: 17706},
+				pos: position{line: 987, col: 4, offset: 21107},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 831, col: 4, offset: 17706},
+						pos:        position{line: 987, col: 4, offset: 21107},
 						val:        "is",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 831, col: 10, offset: 17712},
+						pos: position{line: 987, col: 10, offset: 21113},
 						expr: &ruleRefExpr{
-							pos:  position{line: 831, col: 11, offset: 17713},
+							pos:  position{line: 987, col: 11, offset: 21114},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4431,19 +4446,19 @@ var g = &grammar{
 		},
 		{
 			name: "NullsToken",
-			pos:  position{line: 833, col: 1, offset: 17735},
+			pos:  position{line: 989, col: 1, offset: 21136},
 			expr: &seqExpr{
-				pos: position{line: 834, col: 4, offset: 17749},
+				pos: position{line: 990, col: 4, offset: 21150},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 834, col: 4, offset: 17749},
+						pos:        position{line: 990, col: 4, offset: 21150},
 						val:        "nulls",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 834, col: 13, offset: 17758},
+						pos: position{line: 990, col: 13, offset: 21159},
 						expr: &ruleRefExpr{
-							pos:  position{line: 834, col: 14, offset: 17759},
+							pos:  position{line: 990, col: 14, offset: 21160},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4452,22 +4467,22 @@ var g = &grammar{
 		},
 		{
 			name: "LastToken",
-			pos:  position{line: 836, col: 1, offset: 17781},
+			pos:  position{line: 992, col: 1, offset: 21182},
 			expr: &actionExpr{
-				pos: position{line: 837, col: 4, offset: 17794},
+				pos: position{line: 993, col: 4, offset: 21195},
 				run: (*parser).callonLastToken1,
 				expr: &seqExpr{
-					pos: position{line: 837, col: 4, offset: 17794},
+					pos: position{line: 993, col: 4, offset: 21195},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 837, col: 4, offset: 17794},
+							pos:        position{line: 993, col: 4, offset: 21195},
 							val:        "last",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 837, col: 12, offset: 17802},
+							pos: position{line: 993, col: 12, offset: 21203},
 							expr: &ruleRefExpr{
-								pos:  position{line: 837, col: 13, offset: 17803},
+								pos:  position{line: 993, col: 13, offset: 21204},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4477,22 +4492,22 @@ var g = &grammar{
 		},
 		{
 			name: "FirstToken",
-			pos:  position{line: 840, col: 1, offset: 17857},
+			pos:  position{line: 996, col: 1, offset: 21258},
 			expr: &actionExpr{
-				pos: position{line: 841, col: 4, offset: 17871},
+				pos: position{line: 997, col: 4, offset: 21272},
 				run: (*parser).callonFirstToken1,
 				expr: &seqExpr{
-					pos: position{line: 841, col: 4, offset: 17871},
+					pos: position{line: 997, col: 4, offset: 21272},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 841, col: 4, offset: 17871},
+							pos:        position{line: 997, col: 4, offset: 21272},
 							val:        "first",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 841, col: 13, offset: 17880},
+							pos: position{line: 997, col: 13, offset: 21281},
 							expr: &ruleRefExpr{
-								pos:  position{line: 841, col: 14, offset: 17881},
+								pos:  position{line: 997, col: 14, offset: 21282},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4502,19 +4517,19 @@ var g = &grammar{
 		},
 		{
 			name: "AndToken",
-			pos:  position{line: 844, col: 1, offset: 17935},
+			pos:  position{line: 1000, col: 1, offset: 21336},
 			expr: &seqExpr{
-				pos: position{line: 845, col: 4, offset: 17947},
+				pos: position{line: 1001, col: 4, offset: 21348},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 845, col: 4, offset: 17947},
+						pos:        position{line: 1001, col: 4, offset: 21348},
 						val:        "and",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 845, col: 11, offset: 17954},
+						pos: position{line: 1001, col: 11, offset: 21355},
 						expr: &ruleRefExpr{
-							pos:  position{line: 845, col: 12, offset: 17955},
+							pos:  position{line: 1001, col: 12, offset: 21356},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4523,19 +4538,19 @@ var g = &grammar{
 		},
 		{
 			name: "OrToken",
-			pos:  position{line: 847, col: 1, offset: 17977},
+			pos:  position{line: 1003, col: 1, offset: 21378},
 			expr: &seqExpr{
-				pos: position{line: 848, col: 4, offset: 17988},
+				pos: position{line: 1004, col: 4, offset: 21389},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 848, col: 4, offset: 17988},
+						pos:        position{line: 1004, col: 4, offset: 21389},
 						val:        "or",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 848, col: 10, offset: 17994},
+						pos: position{line: 1004, col: 10, offset: 21395},
 						expr: &ruleRefExpr{
-							pos:  position{line: 848, col: 11, offset: 17995},
+							pos:  position{line: 1004, col: 11, offset: 21396},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4544,19 +4559,19 @@ var g = &grammar{
 		},
 		{
 			name: "NotToken",
-			pos:  position{line: 850, col: 1, offset: 18017},
+			pos:  position{line: 1006, col: 1, offset: 21418},
 			expr: &seqExpr{
-				pos: position{line: 851, col: 4, offset: 18029},
+				pos: position{line: 1007, col: 4, offset: 21430},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 851, col: 4, offset: 18029},
+						pos:        position{line: 1007, col: 4, offset: 21430},
 						val:        "not",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 851, col: 11, offset: 18036},
+						pos: position{line: 1007, col: 11, offset: 21437},
 						expr: &ruleRefExpr{
-							pos:  position{line: 851, col: 12, offset: 18037},
+							pos:  position{line: 1007, col: 12, offset: 21438},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4565,19 +4580,19 @@ var g = &grammar{
 		},
 		{
 			name: "InToken",
-			pos:  position{line: 853, col: 1, offset: 18059},
+			pos:  position{line: 1009, col: 1, offset: 21460},
 			expr: &seqExpr{
-				pos: position{line: 854, col: 4, offset: 18070},
+				pos: position{line: 1010, col: 4, offset: 21471},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 854, col: 4, offset: 18070},
+						pos:        position{line: 1010, col: 4, offset: 21471},
 						val:        "in",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 854, col: 10, offset: 18076},
+						pos: position{line: 1010, col: 10, offset: 21477},
 						expr: &ruleRefExpr{
-							pos:  position{line: 854, col: 11, offset: 18077},
+							pos:  position{line: 1010, col: 11, offset: 21478},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4586,19 +4601,19 @@ var g = &grammar{
 		},
 		{
 			name: "LikeToken",
-			pos:  position{line: 856, col: 1, offset: 18099},
+			pos:  position{line: 1012, col: 1, offset: 21500},
 			expr: &seqExpr{
-				pos: position{line: 857, col: 4, offset: 18112},
+				pos: position{line: 1013, col: 4, offset: 21513},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 857, col: 4, offset: 18112},
+						pos:        position{line: 1013, col: 4, offset: 21513},
 						val:        "like",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 857, col: 12, offset: 18120},
+						pos: position{line: 1013, col: 12, offset: 21521},
 						expr: &ruleRefExpr{
-							pos:  position{line: 857, col: 13, offset: 18121},
+							pos:  position{line: 1013, col: 13, offset: 21522},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4607,22 +4622,22 @@ var g = &grammar{
 		},
 		{
 			name: "AscToken",
-			pos:  position{line: 859, col: 1, offset: 18143},
+			pos:  position{line: 1015, col: 1, offset: 21544},
 			expr: &actionExpr{
-				pos: position{line: 860, col: 4, offset: 18155},
+				pos: position{line: 1016, col: 4, offset: 21556},
 				run: (*parser).callonAscToken1,
 				expr: &seqExpr{
-					pos: position{line: 860, col: 4, offset: 18155},
+					pos: position{line: 1016, col: 4, offset: 21556},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 860, col: 4, offset: 18155},
+							pos:        position{line: 1016, col: 4, offset: 21556},
 							val:        "asc",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 860, col: 11, offset: 18162},
+							pos: position{line: 1016, col: 11, offset: 21563},
 							expr: &ruleRefExpr{
-								pos:  position{line: 860, col: 12, offset: 18163},
+								pos:  position{line: 1016, col: 12, offset: 21564},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4632,22 +4647,22 @@ var g = &grammar{
 		},
 		{
 			name: "DescToken",
-			pos:  position{line: 863, col: 1, offset: 18217},
+			pos:  position{line: 1019, col: 1, offset: 21618},
 			expr: &actionExpr{
-				pos: position{line: 864, col: 4, offset: 18230},
+				pos: position{line: 1020, col: 4, offset: 21631},
 				run: (*parser).callonDescToken1,
 				expr: &seqExpr{
-					pos: position{line: 864, col: 4, offset: 18230},
+					pos: position{line: 1020, col: 4, offset: 21631},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 864, col: 4, offset: 18230},
+							pos:        position{line: 1020, col: 4, offset: 21631},
 							val:        "desc",
 							ignoreCase: true,
 						},
 						&notExpr{
-							pos: position{line: 864, col: 12, offset: 18238},
+							pos: position{line: 1020, col: 12, offset: 21639},
 							expr: &ruleRefExpr{
-								pos:  position{line: 864, col: 13, offset: 18239},
+								pos:  position{line: 1020, col: 13, offset: 21640},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4657,19 +4672,19 @@ var g = &grammar{
 		},
 		{
 			name: "CastToken",
-			pos:  position{line: 867, col: 1, offset: 18293},
+			pos:  position{line: 1023, col: 1, offset: 21694},
 			expr: &seqExpr{
-				pos: position{line: 868, col: 4, offset: 18306},
+				pos: position{line: 1024, col: 4, offset: 21707},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 868, col: 4, offset: 18306},
+						pos:        position{line: 1024, col: 4, offset: 21707},
 						val:        "cast",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 868, col: 12, offset: 18314},
+						pos: position{line: 1024, col: 12, offset: 21715},
 						expr: &ruleRefExpr{
-							pos:  position{line: 868, col: 13, offset: 18315},
+							pos:  position{line: 1024, col: 13, offset: 21716},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4678,19 +4693,19 @@ var g = &grammar{
 		},
 		{
 			name: "AsToken",
-			pos:  position{line: 870, col: 1, offset: 18337},
+			pos:  position{line: 1026, col: 1, offset: 21738},
 			expr: &seqExpr{
-				pos: position{line: 871, col: 4, offset: 18348},
+				pos: position{line: 1027, col: 4, offset: 21749},
 				exprs: []interface{}{
 					&litMatcher{
-						pos:        position{line: 871, col: 4, offset: 18348},
+						pos:        position{line: 1027, col: 4, offset: 21749},
 						val:        "as",
 						ignoreCase: true,
 					},
 					&notExpr{
-						pos: position{line: 871, col: 10, offset: 18354},
+						pos: position{line: 1027, col: 10, offset: 21755},
 						expr: &ruleRefExpr{
-							pos:  position{line: 871, col: 11, offset: 18355},
+							pos:  position{line: 1027, col: 11, offset: 21756},
 							name: "NormalIdentifierRest",
 						},
 					},
@@ -4699,34 +4714,34 @@ var g = &grammar{
 		},
 		{
 			name: "SeparatorToken",
-			pos:  position{line: 873, col: 1, offset: 18377},
+			pos:  position{line: 1029, col: 1, offset: 21778},
 			expr: &litMatcher{
-				pos:        position{line: 874, col: 4, offset: 18395},
+				pos:        position{line: 1030, col: 4, offset: 21796},
 				val:        ",",
 				ignoreCase: false,
 			},
 		},
 		{
 			name: "AnyToken",
-			pos:  position{line: 876, col: 1, offset: 18400},
+			pos:  position{line: 1032, col: 1, offset: 21801},
 			expr: &litMatcher{
-				pos:        position{line: 877, col: 4, offset: 18412},
+				pos:        position{line: 1033, col: 4, offset: 21813},
 				val:        "*",
 				ignoreCase: false,
 			},
 		},
 		{
 			name: "Identifier",
-			pos:  position{line: 880, col: 1, offset: 18435},
+			pos:  position{line: 1036, col: 1, offset: 21836},
 			expr: &choiceExpr{
-				pos: position{line: 881, col: 4, offset: 18449},
+				pos: position{line: 1037, col: 4, offset: 21850},
 				alternatives: []interface{}{
 					&ruleRefExpr{
-						pos:  position{line: 881, col: 4, offset: 18449},
+						pos:  position{line: 1037, col: 4, offset: 21850},
 						name: "NormalIdentifier",
 					},
 					&ruleRefExpr{
-						pos:  position{line: 882, col: 4, offset: 18469},
+						pos:  position{line: 1038, col: 4, offset: 21870},
 						name: "StringIdentifier",
 					},
 				},
@@ -4734,21 +4749,21 @@ var g = &grammar{
 		},
 		{
 			name: "NormalIdentifier",
-			pos:  position{line: 884, col: 1, offset: 18487},
+			pos:  position{line: 1040, col: 1, offset: 21888},
 			expr: &actionExpr{
-				pos: position{line: 885, col: 4, offset: 18507},
+				pos: position{line: 1041, col: 4, offset: 21908},
 				run: (*parser).callonNormalIdentifier1,
 				expr: &seqExpr{
-					pos: position{line: 885, col: 4, offset: 18507},
+					pos: position{line: 1041, col: 4, offset: 21908},
 					exprs: []interface{}{
 						&ruleRefExpr{
-							pos:  position{line: 885, col: 4, offset: 18507},
+							pos:  position{line: 1041, col: 4, offset: 21908},
 							name: "NormalIdentifierStart",
 						},
 						&zeroOrMoreExpr{
-							pos: position{line: 885, col: 26, offset: 18529},
+							pos: position{line: 1041, col: 26, offset: 21930},
 							expr: &ruleRefExpr{
-								pos:  position{line: 885, col: 26, offset: 18529},
+								pos:  position{line: 1041, col: 26, offset: 21930},
 								name: "NormalIdentifierRest",
 							},
 						},
@@ -4758,9 +4773,9 @@ var g = &grammar{
 		},
 		{
 			name: "NormalIdentifierStart",
-			pos:  position{line: 890, col: 1, offset: 18616},
+			pos:  position{line: 1048, col: 1, offset: 22040},
 			expr: &charClassMatcher{
-				pos:        position{line: 891, col: 4, offset: 18641},
+				pos:        position{line: 1049, col: 4, offset: 22065},
 				val:        "[a-zA-Z@#_\\x80-\\xff]",
 				chars:      []rune{'@', '#', '_'},
 				ranges:     []rune{'a', 'z', 'A', 'Z', '\u0080', 'ÿ'},
@@ -4770,9 +4785,9 @@ var g = &grammar{
 		},
 		{
 			name: "NormalIdentifierRest",
-			pos:  position{line: 893, col: 1, offset: 18663},
+			pos:  position{line: 1051, col: 1, offset: 22087},
 			expr: &charClassMatcher{
-				pos:        position{line: 894, col: 4, offset: 18687},
+				pos:        position{line: 1052, col: 4, offset: 22111},
 				val:        "[a-zA-Z0-9@#$_\\x80-\\xff]",
 				chars:      []rune{'@', '#', '$', '_'},
 				ranges:     []rune{'a', 'z', 'A', 'Z', '0', '9', '\u0080', 'ÿ'},
@@ -4782,46 +4797,46 @@ var g = &grammar{
 		},
 		{
 			name: "StringIdentifier",
-			pos:  position{line: 896, col: 1, offset: 18713},
+			pos:  position{line: 1054, col: 1, offset: 22137},
 			expr: &actionExpr{
-				pos: position{line: 897, col: 4, offset: 18733},
+				pos: position{line: 1055, col: 4, offset: 22157},
 				run: (*parser).callonStringIdentifier1,
 				expr: &seqExpr{
-					pos: position{line: 897, col: 4, offset: 18733},
+					pos: position{line: 1055, col: 4, offset: 22157},
 					exprs: []interface{}{
 						&litMatcher{
-							pos:        position{line: 897, col: 4, offset: 18733},
+							pos:        position{line: 1055, col: 4, offset: 22157},
 							val:        "\"",
 							ignoreCase: false,
 						},
 						&labeledExpr{
-							pos:   position{line: 897, col: 9, offset: 18738},
+							pos:   position{line: 1055, col: 9, offset: 22162},
 							label: "s",
 							expr: &zeroOrMoreExpr{
-								pos: position{line: 897, col: 11, offset: 18740},
+								pos: position{line: 1055, col: 11, offset: 22164},
 								expr: &actionExpr{
-									pos: position{line: 897, col: 13, offset: 18742},
+									pos: position{line: 1055, col: 13, offset: 22166},
 									run: (*parser).callonStringIdentifier6,
 									expr: &choiceExpr{
-										pos: position{line: 897, col: 15, offset: 18744},
+										pos: position{line: 1055, col: 15, offset: 22168},
 										alternatives: []interface{}{
 											&charClassMatcher{
-												pos:        position{line: 897, col: 15, offset: 18744},
+												pos:        position{line: 1055, col: 15, offset: 22168},
 												val:        "[^\"\\r\\n\\\\]",
 												chars:      []rune{'"', '\r', '\n', '\\'},
 												ignoreCase: false,
 												inverted:   true,
 											},
 											&seqExpr{
-												pos: position{line: 897, col: 28, offset: 18757},
+												pos: position{line: 1055, col: 28, offset: 22181},
 												exprs: []interface{}{
 													&litMatcher{
-														pos:        position{line: 897, col: 28, offset: 18757},
+														pos:        position{line: 1055, col: 28, offset: 22181},
 														val:        "\\",
 														ignoreCase: false,
 													},
 													&anyMatcher{
-														line: 897, col: 33, offset: 18762,
+														line: 1055, col: 33, offset: 22186,
 													},
 												},
 											},
@@ -4831,7 +4846,7 @@ var g = &grammar{
 							},
 						},
 						&litMatcher{
-							pos:        position{line: 897, col: 63, offset: 18792},
+							pos:        position{line: 1055, col: 63, offset: 22216},
 							val:        "\"",
 							ignoreCase: false,
 						},
@@ -4841,48 +4856,48 @@ var g = &grammar{
 		},
 		{
 			name: "_",
-			pos:  position{line: 920, col: 1, offset: 19293},
+			pos:  position{line: 1078, col: 1, offset: 22731},
 			expr: &zeroOrMoreExpr{
-				pos: position{line: 921, col: 4, offset: 19298},
+				pos: position{line: 1079, col: 4, offset: 22736},
 				expr: &ruleRefExpr{
-					pos:  position{line: 921, col: 4, offset: 19298},
+					pos:  position{line: 1079, col: 4, offset: 22736},
 					name: "Whitespace",
 				},
 			},
 		},
 		{
 			name: "Whitespace",
-			pos:  position{line: 923, col: 1, offset: 19311},
+			pos:  position{line: 1081, col: 1, offset: 22749},
 			expr: &choiceExpr{
-				pos: position{line: 924, col: 4, offset: 19325},
+				pos: position{line: 1082, col: 4, offset: 22763},
 				alternatives: []interface{}{
 					&litMatcher{
-						pos:        position{line: 924, col: 4, offset: 19325},
+						pos:        position{line: 1082, col: 4, offset: 22763},
 						val:        "\t",
 						ignoreCase: false,
 					},
 					&litMatcher{
-						pos:        position{line: 925, col: 4, offset: 19346},
+						pos:        position{line: 1083, col: 4, offset: 22784},
 						val:        "\n",
 						ignoreCase: false,
 					},
 					&litMatcher{
-						pos:        position{line: 926, col: 4, offset: 19367},
+						pos:        position{line: 1084, col: 4, offset: 22805},
 						val:        "\v",
 						ignoreCase: false,
 					},
 					&litMatcher{
-						pos:        position{line: 927, col: 4, offset: 19388},
+						pos:        position{line: 1085, col: 4, offset: 22826},
 						val:        "\f",
 						ignoreCase: false,
 					},
 					&litMatcher{
-						pos:        position{line: 928, col: 4, offset: 19409},
+						pos:        position{line: 1086, col: 4, offset: 22847},
 						val:        "\r",
 						ignoreCase: false,
 					},
 					&litMatcher{
-						pos:        position{line: 929, col: 4, offset: 19430},
+						pos:        position{line: 1087, col: 4, offset: 22868},
 						val:        " ",
 						ignoreCase: false,
 					},
@@ -4891,11 +4906,11 @@ var g = &grammar{
 		},
 		{
 			name: "EOF",
-			pos:  position{line: 931, col: 1, offset: 19452},
+			pos:  position{line: 1089, col: 1, offset: 22890},
 			expr: &notExpr{
-				pos: position{line: 932, col: 4, offset: 19459},
+				pos: position{line: 1090, col: 4, offset: 22897},
 				expr: &anyMatcher{
-					line: 932, col: 5, offset: 19460,
+					line: 1090, col: 5, offset: 22898,
 				},
 			},
 		},
@@ -4913,7 +4928,7 @@ func (p *parser) callonS10() (interface{}, error) {
 }
 
 func (c *current) onS1(x, xs interface{}) (interface{}, error) {
-	return prepend(x, xs), nil
+	return prepend(x, assertSlice(xs)), nil
 }
 
 func (p *parser) callonS1() (interface{}, error) {
@@ -4993,37 +5008,31 @@ func (p *parser) callonSelectStmt55() (interface{}, error) {
 }
 
 func (c *current) onSelectStmt1(f, fs, table, where, group, order, limit, offset interface{}) (interface{}, error) {
-	var (
-		tableNode  *ast.IdentifierNode
-		whereNode  *ast.WhereOptionNode
-		limitNode  *ast.LimitOptionNode
-		offsetNode *ast.OffsetOptionNode
-	)
+	node := &ast.SelectStmtNode{}
+	node.Column = assertExprSlice(prepend(f, assertSlice(fs)))
 	if table != nil {
-		t := table.(ast.IdentifierNode)
-		tableNode = &t
+		node.Table = table.(*ast.IdentifierNode)
 	}
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
+	}
+	groupSlice := assertSlice(group)
+	node.Group = make([]*ast.GroupOptionNode, len(groupSlice))
+	for idx := range groupSlice {
+		node.Group[idx] = groupSlice[idx].(*ast.GroupOptionNode)
+	}
+	orderSlice := assertSlice(order)
+	node.Order = make([]*ast.OrderOptionNode, len(orderSlice))
+	for idx := range orderSlice {
+		node.Order[idx] = orderSlice[idx].(*ast.OrderOptionNode)
 	}
 	if limit != nil {
-		l := limit.(ast.LimitOptionNode)
-		limitNode = &l
+		node.Limit = limit.(*ast.LimitOptionNode)
 	}
 	if offset != nil {
-		o := offset.(ast.OffsetOptionNode)
-		offsetNode = &o
+		node.Offset = offset.(*ast.OffsetOptionNode)
 	}
-	return ast.SelectStmtNode{
-		Column: prepend(f, fs),
-		Table:  tableNode,
-		Where:  whereNode,
-		Group:  toSlice(group),
-		Order:  toSlice(order),
-		Limit:  limitNode,
-		Offset: offsetNode,
-	}, nil
+	return node, nil
 }
 
 func (p *parser) callonSelectStmt1() (interface{}, error) {
@@ -5053,18 +5062,17 @@ func (p *parser) callonUpdateStmt23() (interface{}, error) {
 }
 
 func (c *current) onUpdateStmt1(table, a, as, where interface{}) (interface{}, error) {
-	var (
-		whereNode *ast.WhereOptionNode
-	)
+	node := &ast.UpdateStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	assignSlice := prepend(a, assertSlice(as))
+	node.Assignment = make([]*ast.AssignOperatorNode, len(assignSlice))
+	for idx := range assignSlice {
+		node.Assignment[idx] = assignSlice[idx].(*ast.AssignOperatorNode)
+	}
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
 	}
-	return ast.UpdateStmtNode{
-		Table:      table.(ast.IdentifierNode),
-		Assignment: prepend(a, as),
-		Where:      whereNode,
-	}, nil
+	return node, nil
 }
 
 func (p *parser) callonUpdateStmt1() (interface{}, error) {
@@ -5084,17 +5092,12 @@ func (p *parser) callonDeleteStmt11() (interface{}, error) {
 }
 
 func (c *current) onDeleteStmt1(table, where interface{}) (interface{}, error) {
-	var (
-		whereNode *ast.WhereOptionNode
-	)
+	node := &ast.DeleteStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
 	}
-	return ast.DeleteStmtNode{
-		Table: table.(ast.IdentifierNode),
-		Where: whereNode,
-	}, nil
+	return node, nil
 }
 
 func (p *parser) callonDeleteStmt1() (interface{}, error) {
@@ -5104,10 +5107,17 @@ func (p *parser) callonDeleteStmt1() (interface{}, error) {
 }
 
 func (c *current) onInsertStmt1(table, insert interface{}) (interface{}, error) {
-	return ast.InsertStmtNode{
-		Table:  table.(ast.IdentifierNode),
-		Insert: insert,
-	}, nil
+	node := &ast.InsertStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	switch i := insert.(type) {
+	case *ast.InsertWithColumnOptionNode:
+		node.Insert = i
+	case *ast.InsertWithDefaultOptionNode:
+		node.Insert = i
+	default:
+		panic(fmt.Sprintf("unknown insert type %T", insert))
+	}
+	return node, nil
 }
 
 func (p *parser) callonInsertStmt1() (interface{}, error) {
@@ -5137,7 +5147,7 @@ func (p *parser) callonCreateTableStmt20() (interface{}, error) {
 }
 
 func (c *current) onCreateTableStmt14(s, ss interface{}) (interface{}, error) {
-	return prepend(s, ss), nil
+	return prepend(s, assertSlice(ss)), nil
 }
 
 func (p *parser) callonCreateTableStmt14() (interface{}, error) {
@@ -5147,10 +5157,14 @@ func (p *parser) callonCreateTableStmt14() (interface{}, error) {
 }
 
 func (c *current) onCreateTableStmt1(table, column interface{}) (interface{}, error) {
-	return ast.CreateTableStmtNode{
-		Table:  table.(ast.IdentifierNode),
-		Column: toSlice(column),
-	}, nil
+	node := &ast.CreateTableStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	columnSlice := assertSlice(column)
+	node.Column = make([]*ast.ColumnSchemaNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.ColumnSchemaNode)
+	}
+	return node, nil
 }
 
 func (p *parser) callonCreateTableStmt1() (interface{}, error) {
@@ -5170,11 +5184,30 @@ func (p *parser) callonColumnSchema10() (interface{}, error) {
 }
 
 func (c *current) onColumnSchema1(i, t, cs interface{}) (interface{}, error) {
-	return ast.ColumnSchemaNode{
-		Column:     i.(ast.IdentifierNode),
-		DataType:   t,
-		Constraint: toSlice(cs),
-	}, nil
+	node := &ast.ColumnSchemaNode{}
+	node.Column = i.(*ast.IdentifierNode)
+	node.DataType = t.(ast.TypeNode)
+	constraintSlice := assertSlice(cs)
+	node.Constraint = make([]ast.Node, len(constraintSlice))
+	for idx, constraint := range constraintSlice {
+		switch c := constraint.(type) {
+		case *ast.PrimaryOptionNode:
+			node.Constraint[idx] = c
+		case *ast.NotNullOptionNode:
+			node.Constraint[idx] = c
+		case *ast.UniqueOptionNode:
+			node.Constraint[idx] = c
+		case *ast.DefaultOptionNode:
+			node.Constraint[idx] = c
+		case *ast.ForeignOptionNode:
+			node.Constraint[idx] = c
+		case *ast.AutoIncrementOptionNode:
+			node.Constraint[idx] = c
+		default:
+			panic(fmt.Sprintf("unknown constraint type %T", c))
+		}
+	}
+	return node, nil
 }
 
 func (p *parser) callonColumnSchema1() (interface{}, error) {
@@ -5204,19 +5237,18 @@ func (p *parser) callonCreateIndexStmt28() (interface{}, error) {
 }
 
 func (c *current) onCreateIndexStmt1(unique, index, table, i, is interface{}) (interface{}, error) {
-	var (
-		uniqueNode *ast.UniqueOptionNode
-	)
+	node := &ast.CreateIndexStmtNode{}
+	node.Index = index.(*ast.IdentifierNode)
+	node.Table = table.(*ast.IdentifierNode)
+	columnSlice := assertSlice(prepend(i, assertSlice(is)))
+	node.Column = make([]*ast.IdentifierNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.IdentifierNode)
+	}
 	if unique != nil {
-		u := unique.(ast.UniqueOptionNode)
-		uniqueNode = &u
+		node.Unique = unique.(*ast.UniqueOptionNode)
 	}
-	return ast.CreateIndexStmtNode{
-		Index:  index.(ast.IdentifierNode),
-		Table:  table.(ast.IdentifierNode),
-		Column: prepend(i, is),
-		Unique: uniqueNode,
-	}, nil
+	return node, nil
 }
 
 func (p *parser) callonCreateIndexStmt1() (interface{}, error) {
@@ -5226,7 +5258,9 @@ func (p *parser) callonCreateIndexStmt1() (interface{}, error) {
 }
 
 func (c *current) onWhereClause1(e interface{}) (interface{}, error) {
-	return ast.WhereOptionNode{Condition: e}, nil
+	node := &ast.WhereOptionNode{}
+	node.Condition = e.(ast.ExprNode)
+	return node, nil
 }
 
 func (p *parser) callonWhereClause1() (interface{}, error) {
@@ -5246,7 +5280,7 @@ func (p *parser) callonOrderByClause11() (interface{}, error) {
 }
 
 func (c *current) onOrderByClause1(f, fs interface{}) (interface{}, error) {
-	return prepend(f, fs), nil
+	return prepend(f, assertSlice(fs)), nil
 }
 
 func (p *parser) callonOrderByClause1() (interface{}, error) {
@@ -5276,11 +5310,11 @@ func (p *parser) callonOrderColumn16() (interface{}, error) {
 }
 
 func (c *current) onOrderColumn1(i, s, n interface{}) (interface{}, error) {
-	return ast.OrderOptionNode{
-		Expr:       i,
-		Desc:       s != nil && string(s.([]byte)) == "desc",
-		NullsFirst: n != nil && string(n.([]byte)) == "first",
-	}, nil
+	node := &ast.OrderOptionNode{}
+	node.Expr = i.(ast.ExprNode)
+	node.Desc = s != nil && string(s.([]byte)) == "desc"
+	node.NullsFirst = n != nil && string(n.([]byte)) == "first"
+	return node, nil
 }
 
 func (p *parser) callonOrderColumn1() (interface{}, error) {
@@ -5290,7 +5324,7 @@ func (p *parser) callonOrderColumn1() (interface{}, error) {
 }
 
 func (c *current) onGroupByClause11(s interface{}) (interface{}, error) {
-	return ast.GroupOptionNode{Expr: s}, nil
+	return s, nil
 }
 
 func (p *parser) callonGroupByClause11() (interface{}, error) {
@@ -5299,18 +5333,32 @@ func (p *parser) callonGroupByClause11() (interface{}, error) {
 	return p.cur.onGroupByClause11(stack["s"])
 }
 
-func (c *current) onGroupByClause1(i, is interface{}) (interface{}, error) {
-	return prepend(ast.GroupOptionNode{Expr: i}, is), nil
+func (c *current) onGroupByClause1(f, fs interface{}) (interface{}, error) {
+	return prepend(f, assertSlice(fs)), nil
 }
 
 func (p *parser) callonGroupByClause1() (interface{}, error) {
 	stack := p.vstack[len(p.vstack)-1]
 	_ = stack
-	return p.cur.onGroupByClause1(stack["i"], stack["is"])
+	return p.cur.onGroupByClause1(stack["f"], stack["fs"])
+}
+
+func (c *current) onGroupColumn1(i interface{}) (interface{}, error) {
+	node := &ast.GroupOptionNode{}
+	node.Expr = i.(ast.ExprNode)
+	return node, nil
+}
+
+func (p *parser) callonGroupColumn1() (interface{}, error) {
+	stack := p.vstack[len(p.vstack)-1]
+	_ = stack
+	return p.cur.onGroupColumn1(stack["i"])
 }
 
 func (c *current) onOffsetClause1(i interface{}) (interface{}, error) {
-	return ast.OffsetOptionNode{Value: i.(ast.IntegerValueNode)}, nil
+	node := &ast.OffsetOptionNode{}
+	node.Value = i.(*ast.IntegerValueNode)
+	return node, nil
 }
 
 func (p *parser) callonOffsetClause1() (interface{}, error) {
@@ -5320,7 +5368,9 @@ func (p *parser) callonOffsetClause1() (interface{}, error) {
 }
 
 func (c *current) onLimitClause1(i interface{}) (interface{}, error) {
-	return ast.LimitOptionNode{Value: i.(ast.IntegerValueNode)}, nil
+	node := &ast.LimitOptionNode{}
+	node.Value = i.(*ast.IntegerValueNode)
+	return node, nil
 }
 
 func (p *parser) callonLimitClause1() (interface{}, error) {
@@ -5340,7 +5390,7 @@ func (p *parser) callonInsertWithColumnClause13() (interface{}, error) {
 }
 
 func (c *current) onInsertWithColumnClause5(f, fs interface{}) (interface{}, error) {
-	return prepend(f, fs), nil
+	return prepend(f, assertSlice(fs)), nil
 }
 
 func (p *parser) callonInsertWithColumnClause5() (interface{}, error) {
@@ -5360,10 +5410,19 @@ func (p *parser) callonInsertWithColumnClause29() (interface{}, error) {
 }
 
 func (c *current) onInsertWithColumnClause1(cs, v, vs interface{}) (interface{}, error) {
-	return ast.InsertWithColumnOptionNode{
-		Column: toSlice(cs),
-		Value:  prepend(v, vs),
-	}, nil
+	node := &ast.InsertWithColumnOptionNode{}
+	columnSlice := assertSlice(cs)
+	node.Column = make([]*ast.IdentifierNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.IdentifierNode)
+	}
+	valueSlice := assertSlice(vs)
+	node.Value = make([][]ast.ExprNode, len(valueSlice)+1)
+	node.Value[0] = v.([]ast.ExprNode)
+	for idx := range valueSlice {
+		node.Value[idx+1] = valueSlice[idx].([]ast.ExprNode)
+	}
+	return node, nil
 }
 
 func (p *parser) callonInsertWithColumnClause1() (interface{}, error) {
@@ -5373,7 +5432,8 @@ func (p *parser) callonInsertWithColumnClause1() (interface{}, error) {
 }
 
 func (c *current) onInsertWithDefaultClause1() (interface{}, error) {
-	return ast.InsertWithDefaultOptionNode{}, nil
+	node := &ast.InsertWithDefaultOptionNode{}
+	return node, nil
 }
 
 func (p *parser) callonInsertWithDefaultClause1() (interface{}, error) {
@@ -5383,7 +5443,8 @@ func (p *parser) callonInsertWithDefaultClause1() (interface{}, error) {
 }
 
 func (c *current) onPrimaryKeyClause1() (interface{}, error) {
-	return ast.PrimaryOptionNode{}, nil
+	node := &ast.PrimaryOptionNode{}
+	return node, nil
 }
 
 func (p *parser) callonPrimaryKeyClause1() (interface{}, error) {
@@ -5393,7 +5454,8 @@ func (p *parser) callonPrimaryKeyClause1() (interface{}, error) {
 }
 
 func (c *current) onNotNullClause1() (interface{}, error) {
-	return ast.NotNullOptionNode{}, nil
+	node := &ast.NotNullOptionNode{}
+	return node, nil
 }
 
 func (p *parser) callonNotNullClause1() (interface{}, error) {
@@ -5403,7 +5465,8 @@ func (p *parser) callonNotNullClause1() (interface{}, error) {
 }
 
 func (c *current) onUniqueClause1() (interface{}, error) {
-	return ast.UniqueOptionNode{}, nil
+	node := &ast.UniqueOptionNode{}
+	return node, nil
 }
 
 func (p *parser) callonUniqueClause1() (interface{}, error) {
@@ -5413,7 +5476,9 @@ func (p *parser) callonUniqueClause1() (interface{}, error) {
 }
 
 func (c *current) onDefaultClause1(e interface{}) (interface{}, error) {
-	return ast.DefaultOptionNode{Value: e}, nil
+	node := &ast.DefaultOptionNode{}
+	node.Value = e.(ast.ExprNode)
+	return node, nil
 }
 
 func (p *parser) callonDefaultClause1() (interface{}, error) {
@@ -5423,10 +5488,10 @@ func (p *parser) callonDefaultClause1() (interface{}, error) {
 }
 
 func (c *current) onForeignClause1(t, f interface{}) (interface{}, error) {
-	return ast.ForeignOptionNode{
-		Table:  t.(ast.IdentifierNode),
-		Column: f.(ast.IdentifierNode),
-	}, nil
+	node := &ast.ForeignOptionNode{}
+	node.Table = t.(*ast.IdentifierNode)
+	node.Column = f.(*ast.IdentifierNode)
+	return node, nil
 }
 
 func (p *parser) callonForeignClause1() (interface{}, error) {
@@ -5436,7 +5501,8 @@ func (p *parser) callonForeignClause1() (interface{}, error) {
 }
 
 func (c *current) onAutoincrementClause1() (interface{}, error) {
-	return ast.AutoIncrementOptionNode{}, nil
+	node := &ast.AutoIncrementOptionNode{}
+	return node, nil
 }
 
 func (p *parser) callonAutoincrementClause1() (interface{}, error) {
@@ -5456,7 +5522,7 @@ func (p *parser) callonExprWithDefault2() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr47(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonLogicExpr47() (interface{}, error) {
@@ -5466,7 +5532,7 @@ func (p *parser) callonLogicExpr47() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr41(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonLogicExpr41() (interface{}, error) {
@@ -5476,7 +5542,7 @@ func (p *parser) callonLogicExpr41() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr37(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonLogicExpr37() (interface{}, error) {
@@ -5486,7 +5552,7 @@ func (p *parser) callonLogicExpr37() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr31(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonLogicExpr31() (interface{}, error) {
@@ -5496,7 +5562,7 @@ func (p *parser) callonLogicExpr31() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr22(op, s interface{}) (interface{}, error) {
-	return opSetTarget(op, s), nil
+	return opSetTarget(op.(ast.UnaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonLogicExpr22() (interface{}, error) {
@@ -5516,7 +5582,7 @@ func (p *parser) callonLogicExpr17() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr11(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonLogicExpr11() (interface{}, error) {
@@ -5536,11 +5602,12 @@ func (p *parser) callonLogicExpr1In5() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr1In1(n, s interface{}) (interface{}, error) {
-	op := opSetSubject(&ast.InOperatorNode{}, s)
+	node := &ast.InOperatorNode{}
+	node.Right = s.([]ast.ExprNode)
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
 func (p *parser) callonLogicExpr1In1() (interface{}, error) {
@@ -5549,28 +5616,30 @@ func (p *parser) callonLogicExpr1In1() (interface{}, error) {
 	return p.cur.onLogicExpr1In1(stack["n"], stack["s"])
 }
 
-func (c *current) onLogicExpr1Null6(t interface{}) (interface{}, error) {
+func (c *current) onLogicExpr1Is6(t interface{}) (interface{}, error) {
 	return t, nil
 }
 
-func (p *parser) callonLogicExpr1Null6() (interface{}, error) {
+func (p *parser) callonLogicExpr1Is6() (interface{}, error) {
 	stack := p.vstack[len(p.vstack)-1]
 	_ = stack
-	return p.cur.onLogicExpr1Null6(stack["t"])
+	return p.cur.onLogicExpr1Is6(stack["t"])
 }
 
-func (c *current) onLogicExpr1Null1(n interface{}) (interface{}, error) {
-	op := opSetSubject(&ast.IsOperatorNode{}, ast.NullValueNode{})
+func (c *current) onLogicExpr1Is1(n interface{}) (interface{}, error) {
+	node := &ast.IsOperatorNode{}
+	null := &ast.NullValueNode{}
+	opSetSubject(node, null)
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
-func (p *parser) callonLogicExpr1Null1() (interface{}, error) {
+func (p *parser) callonLogicExpr1Is1() (interface{}, error) {
 	stack := p.vstack[len(p.vstack)-1]
 	_ = stack
-	return p.cur.onLogicExpr1Null1(stack["n"])
+	return p.cur.onLogicExpr1Is1(stack["n"])
 }
 
 func (c *current) onLogicExpr1Like5(t interface{}) (interface{}, error) {
@@ -5584,11 +5653,12 @@ func (p *parser) callonLogicExpr1Like5() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr1Like1(n, s interface{}) (interface{}, error) {
-	op := opSetSubject(&ast.LikeOperatorNode{}, s)
+	node := &ast.LikeOperatorNode{}
+	opSetSubject(node, s.(ast.ExprNode))
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
 func (p *parser) callonLogicExpr1Like1() (interface{}, error) {
@@ -5598,7 +5668,7 @@ func (p *parser) callonLogicExpr1Like1() (interface{}, error) {
 }
 
 func (c *current) onLogicExpr1Cmp1(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonLogicExpr1Cmp1() (interface{}, error) {
@@ -5608,7 +5678,7 @@ func (p *parser) callonLogicExpr1Cmp1() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr37(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonArithmeticExpr37() (interface{}, error) {
@@ -5618,7 +5688,7 @@ func (p *parser) callonArithmeticExpr37() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr31(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonArithmeticExpr31() (interface{}, error) {
@@ -5628,7 +5698,7 @@ func (p *parser) callonArithmeticExpr31() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr27(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonArithmeticExpr27() (interface{}, error) {
@@ -5638,7 +5708,7 @@ func (p *parser) callonArithmeticExpr27() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr21(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonArithmeticExpr21() (interface{}, error) {
@@ -5648,7 +5718,7 @@ func (p *parser) callonArithmeticExpr21() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr17(op, s interface{}) (interface{}, error) {
-	return opSetSubject(op, s), nil
+	return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonArithmeticExpr17() (interface{}, error) {
@@ -5658,7 +5728,7 @@ func (p *parser) callonArithmeticExpr17() (interface{}, error) {
 }
 
 func (c *current) onArithmeticExpr11(o, os interface{}) (interface{}, error) {
-	return rightJoinOperators(o, os), nil
+	return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil
 }
 
 func (p *parser) callonArithmeticExpr11() (interface{}, error) {
@@ -5678,7 +5748,7 @@ func (p *parser) callonMultiExpr7() (interface{}, error) {
 }
 
 func (c *current) onMultiExpr1(x, xs interface{}) (interface{}, error) {
-	return prepend(x, xs), nil
+	return assertExprSlice(prepend(x, assertSlice(xs))), nil
 }
 
 func (p *parser) callonMultiExpr1() (interface{}, error) {
@@ -5698,7 +5768,7 @@ func (p *parser) callonMultiExprWithDefault7() (interface{}, error) {
 }
 
 func (c *current) onMultiExprWithDefault1(x, xs interface{}) (interface{}, error) {
-	return prepend(x, xs), nil
+	return assertExprSlice(prepend(x, assertSlice(xs))), nil
 }
 
 func (p *parser) callonMultiExprWithDefault1() (interface{}, error) {
@@ -5708,7 +5778,7 @@ func (p *parser) callonMultiExprWithDefault1() (interface{}, error) {
 }
 
 func (c *current) onOperand2(op, s interface{}) (interface{}, error) {
-	return opSetTarget(op, s), nil
+	return opSetTarget(op.(ast.UnaryOperator), s.(ast.ExprNode)), nil
 }
 
 func (p *parser) callonOperand2() (interface{}, error) {
@@ -5738,7 +5808,10 @@ func (p *parser) callonOperand17() (interface{}, error) {
 }
 
 func (c *current) onTypeCast1(o, s interface{}) (interface{}, error) {
-	return opSetSubject(opSetObject(&ast.CastOperatorNode{}, o), s), nil
+	node := &ast.CastOperatorNode{}
+	node.SourceExpr = o.(ast.ExprNode)
+	node.TargetType = s.(ast.TypeNode)
+	return node, nil
 }
 
 func (p *parser) callonTypeCast1() (interface{}, error) {
@@ -5748,7 +5821,12 @@ func (p *parser) callonTypeCast1() (interface{}, error) {
 }
 
 func (c *current) onFunctionCall1(i, r interface{}) (interface{}, error) {
-	return opSetSubject(opSetObject(&ast.FunctionOperatorNode{}, i), r), nil
+	node := &ast.FunctionOperatorNode{}
+	node.Name = i.(*ast.IdentifierNode)
+	if r != nil {
+		node.Args = r.([]ast.ExprNode)
+	}
+	return node, nil
 }
 
 func (p *parser) callonFunctionCall1() (interface{}, error) {
@@ -5758,7 +5836,7 @@ func (p *parser) callonFunctionCall1() (interface{}, error) {
 }
 
 func (c *current) onFunctionArgs2(a interface{}) (interface{}, error) {
-	return []interface{}{a}, nil
+	return []ast.ExprNode{a.(*ast.AnyValueNode)}, nil
 }
 
 func (p *parser) callonFunctionArgs2() (interface{}, error) {
@@ -5768,7 +5846,10 @@ func (p *parser) callonFunctionArgs2() (interface{}, error) {
 }
 
 func (c *current) onAssignment1(i, e interface{}) (interface{}, error) {
-	return opSetSubject(opSetObject(&ast.AssignOperatorNode{}, i), e), nil
+	node := &ast.AssignOperatorNode{}
+	node.Column = i.(*ast.IdentifierNode)
+	node.Expr = e.(ast.ExprNode)
+	return node, nil
 }
 
 func (p *parser) callonAssignment1() (interface{}, error) {
@@ -5778,13 +5859,16 @@ func (p *parser) callonAssignment1() (interface{}, error) {
 }
 
 func (c *current) onSignOperator1() (interface{}, error) {
+	var node ast.UnaryOperator
 	switch string(c.text) {
 	case "+":
-		return &ast.PosOperatorNode{}, nil
+		node = &ast.PosOperatorNode{}
 	case "-":
-		return &ast.NegOperatorNode{}, nil
+		node = &ast.NegOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown sign %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown sign %s", c.text))
+	return node, nil
 }
 
 func (p *parser) callonSignOperator1() (interface{}, error) {
@@ -5794,7 +5878,8 @@ func (p *parser) callonSignOperator1() (interface{}, error) {
 }
 
 func (c *current) onNotOperator1() (interface{}, error) {
-	return &ast.NotOperatorNode{}, nil
+	node := &ast.NotOperatorNode{}
+	return node, nil
 }
 
 func (p *parser) callonNotOperator1() (interface{}, error) {
@@ -5804,7 +5889,8 @@ func (p *parser) callonNotOperator1() (interface{}, error) {
 }
 
 func (c *current) onAndOperator1() (interface{}, error) {
-	return &ast.AndOperatorNode{}, nil
+	node := &ast.AndOperatorNode{}
+	return node, nil
 }
 
 func (p *parser) callonAndOperator1() (interface{}, error) {
@@ -5814,7 +5900,8 @@ func (p *parser) callonAndOperator1() (interface{}, error) {
 }
 
 func (c *current) onOrOperator1() (interface{}, error) {
-	return &ast.OrOperatorNode{}, nil
+	node := &ast.OrOperatorNode{}
+	return node, nil
 }
 
 func (p *parser) callonOrOperator1() (interface{}, error) {
@@ -5824,23 +5911,26 @@ func (p *parser) callonOrOperator1() (interface{}, error) {
 }
 
 func (c *current) onCmpOperator1() (interface{}, error) {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "<=":
-		return &ast.LessOrEqualOperatorNode{}, nil
+		node = &ast.LessOrEqualOperatorNode{}
 	case ">=":
-		return &ast.GreaterOrEqualOperatorNode{}, nil
+		node = &ast.GreaterOrEqualOperatorNode{}
 	case "<>":
-		return &ast.NotEqualOperatorNode{}, nil
+		node = &ast.NotEqualOperatorNode{}
 	case "!=":
-		return &ast.NotEqualOperatorNode{}, nil
+		node = &ast.NotEqualOperatorNode{}
 	case "<":
-		return &ast.LessOperatorNode{}, nil
+		node = &ast.LessOperatorNode{}
 	case ">":
-		return &ast.GreaterOperatorNode{}, nil
+		node = &ast.GreaterOperatorNode{}
 	case "=":
-		return &ast.EqualOperatorNode{}, nil
+		node = &ast.EqualOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown comparison operator %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown comparison operator %s", c.text))
+	return node, nil
 }
 
 func (p *parser) callonCmpOperator1() (interface{}, error) {
@@ -5850,7 +5940,8 @@ func (p *parser) callonCmpOperator1() (interface{}, error) {
 }
 
 func (c *current) onConcatOperator1() (interface{}, error) {
-	return &ast.ConcatOperatorNode{}, nil
+	node := &ast.ConcatOperatorNode{}
+	return node, nil
 }
 
 func (p *parser) callonConcatOperator1() (interface{}, error) {
@@ -5860,13 +5951,16 @@ func (p *parser) callonConcatOperator1() (interface{}, error) {
 }
 
 func (c *current) onAddSubOperator1() (interface{}, error) {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "+":
-		return &ast.AddOperatorNode{}, nil
+		node = &ast.AddOperatorNode{}
 	case "-":
-		return &ast.SubOperatorNode{}, nil
+		node = &ast.SubOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown addition or subtraction operator %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown addition or subtraction operator %s", c.text))
+	return node, nil
 }
 
 func (p *parser) callonAddSubOperator1() (interface{}, error) {
@@ -5876,15 +5970,18 @@ func (p *parser) callonAddSubOperator1() (interface{}, error) {
 }
 
 func (c *current) onMulDivModOperator1() (interface{}, error) {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "*":
-		return &ast.MulOperatorNode{}, nil
+		node = &ast.MulOperatorNode{}
 	case "/":
-		return &ast.DivOperatorNode{}, nil
+		node = &ast.DivOperatorNode{}
 	case "%":
-		return &ast.ModOperatorNode{}, nil
+		node = &ast.ModOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown multiplication, division, modulo operator: %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown multiplication, division, modulo operator: %s", c.text))
+	return node, nil
 }
 
 func (p *parser) callonMulDivModOperator1() (interface{}, error) {
@@ -5894,7 +5991,8 @@ func (p *parser) callonMulDivModOperator1() (interface{}, error) {
 }
 
 func (c *current) onUIntType1(s interface{}) (interface{}, error) {
-	node := ast.IntTypeNode{Unsigned: true}
+	node := &ast.IntTypeNode{}
+	node.Unsigned = true
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -5918,7 +6016,8 @@ func (p *parser) callonUIntType1() (interface{}, error) {
 }
 
 func (c *current) onIntType1(s interface{}) (interface{}, error) {
-	node := ast.IntTypeNode{Unsigned: false}
+	node := &ast.IntTypeNode{}
+	node.Unsigned = false
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -5942,7 +6041,8 @@ func (p *parser) callonIntType1() (interface{}, error) {
 }
 
 func (c *current) onUFixedType1(s, t interface{}) (interface{}, error) {
-	node := ast.FixedTypeNode{Unsigned: true}
+	node := &ast.FixedTypeNode{}
+	node.Unsigned = true
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -5979,7 +6079,8 @@ func (p *parser) callonUFixedType1() (interface{}, error) {
 }
 
 func (c *current) onFixedType1(s, t interface{}) (interface{}, error) {
-	node := ast.FixedTypeNode{Unsigned: false}
+	node := &ast.FixedTypeNode{}
+	node.Unsigned = false
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -6016,7 +6117,7 @@ func (p *parser) callonFixedType1() (interface{}, error) {
 }
 
 func (c *current) onFixedBytesType2(s interface{}) (interface{}, error) {
-	node := ast.FixedBytesTypeNode{}
+	node := &ast.FixedBytesTypeNode{}
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -6040,7 +6141,9 @@ func (p *parser) callonFixedBytesType2() (interface{}, error) {
 }
 
 func (c *current) onFixedBytesType9() (interface{}, error) {
-	return ast.FixedBytesTypeNode{Size: 1}, nil
+	node := &ast.FixedBytesTypeNode{}
+	node.Size = 1
+	return node, nil
 }
 
 func (p *parser) callonFixedBytesType9() (interface{}, error) {
@@ -6050,7 +6153,8 @@ func (p *parser) callonFixedBytesType9() (interface{}, error) {
 }
 
 func (c *current) onDynamicBytesType1() (interface{}, error) {
-	return ast.DynamicBytesTypeNode{}, nil
+	node := &ast.DynamicBytesTypeNode{}
+	return node, nil
 }
 
 func (p *parser) callonDynamicBytesType1() (interface{}, error) {
@@ -6060,7 +6164,8 @@ func (p *parser) callonDynamicBytesType1() (interface{}, error) {
 }
 
 func (c *current) onAddressType1() (interface{}, error) {
-	return ast.AddressTypeNode{}, nil
+	node := &ast.AddressTypeNode{}
+	return node, nil
 }
 
 func (p *parser) callonAddressType1() (interface{}, error) {
@@ -6070,7 +6175,8 @@ func (p *parser) callonAddressType1() (interface{}, error) {
 }
 
 func (c *current) onBoolType1() (interface{}, error) {
-	return ast.BoolTypeNode{}, nil
+	node := &ast.BoolTypeNode{}
+	return node, nil
 }
 
 func (p *parser) callonBoolType1() (interface{}, error) {
@@ -6080,7 +6186,8 @@ func (p *parser) callonBoolType1() (interface{}, error) {
 }
 
 func (c *current) onAnyLiteral1() (interface{}, error) {
-	return ast.AnyValueNode{}, nil
+	node := &ast.AnyValueNode{}
+	return node, nil
 }
 
 func (p *parser) callonAnyLiteral1() (interface{}, error) {
@@ -6090,7 +6197,8 @@ func (p *parser) callonAnyLiteral1() (interface{}, error) {
 }
 
 func (c *current) onDefaultLiteral1() (interface{}, error) {
-	return ast.DefaultValueNode{}, nil
+	node := &ast.DefaultValueNode{}
+	return node, nil
 }
 
 func (p *parser) callonDefaultLiteral1() (interface{}, error) {
@@ -6100,7 +6208,9 @@ func (p *parser) callonDefaultLiteral1() (interface{}, error) {
 }
 
 func (c *current) onBoolLiteral1(b interface{}) (interface{}, error) {
-	return ast.BoolValueNode{V: string(b.([]byte)) == "true"}, nil
+	node := &ast.BoolValueNode{}
+	node.V = string(b.([]byte)) == "true"
+	return node, nil
 }
 
 func (p *parser) callonBoolLiteral1() (interface{}, error) {
@@ -6110,7 +6220,8 @@ func (p *parser) callonBoolLiteral1() (interface{}, error) {
 }
 
 func (c *current) onNullLiteral1() (interface{}, error) {
-	return ast.NullValueNode{}, nil
+	node := &ast.NullValueNode{}
+	return node, nil
 }
 
 func (p *parser) callonNullLiteral1() (interface{}, error) {
@@ -6130,7 +6241,8 @@ func (p *parser) callonNumberLiteral2() (interface{}, error) {
 }
 
 func (c *current) onInteger1() (interface{}, error) {
-	node := ast.IntegerValueNode{IsAddress: false, V: decimal.Zero}
+	node := &ast.IntegerValueNode{}
+	node.IsAddress = false
 	v, code := toDecimal(c.text)
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -6164,7 +6276,7 @@ func (p *parser) callonNonZeroLeadingInteger1() (interface{}, error) {
 }
 
 func (c *current) onDecimal1() (interface{}, error) {
-	node := ast.DecimalValueNode{V: decimal.Zero}
+	node := &ast.DecimalValueNode{}
 	v, code := toDecimal(c.text)
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -6188,7 +6300,7 @@ func (p *parser) callonDecimal1() (interface{}, error) {
 }
 
 func (c *current) onHex1(s interface{}) (interface{}, error) {
-	return hexToInteger(joinBytes(s)), nil
+	return hexToInteger(joinBytes(assertSlice(s))), nil
 }
 
 func (p *parser) callonHex1() (interface{}, error) {
@@ -6208,7 +6320,9 @@ func (p *parser) callonHexString9() (interface{}, error) {
 }
 
 func (c *current) onHexString1(s interface{}) (interface{}, error) {
-	return ast.BytesValueNode{V: hexToBytes(joinBytes(s))}, nil
+	node := &ast.BytesValueNode{}
+	node.V = hexToBytes(joinBytes(assertSlice(s)))
+	return node, nil
 }
 
 func (p *parser) callonHexString1() (interface{}, error) {
@@ -6228,8 +6342,8 @@ func (p *parser) callonNormalString6() (interface{}, error) {
 }
 
 func (c *current) onNormalString1(s interface{}) (interface{}, error) {
-	node := ast.BytesValueNode{}
-	bs := joinBytes(s)
+	node := &ast.BytesValueNode{}
+	bs := joinBytes(assertSlice(s))
 	v, bad, code := resolveString(bs)
 	if code != errors.ErrorCodeNil {
 		msg := fmt.Sprintf("cannot resolve escape sequence '%s': %v",
@@ -6315,7 +6429,9 @@ func (p *parser) callonDescToken1() (interface{}, error) {
 }
 
 func (c *current) onNormalIdentifier1() (interface{}, error) {
-	return ast.IdentifierNode{Name: decodeString(c.text)}, nil
+	node := &ast.IdentifierNode{}
+	node.Name = decodeString(c.text)
+	return node, nil
 }
 
 func (p *parser) callonNormalIdentifier1() (interface{}, error) {
@@ -6335,8 +6451,8 @@ func (p *parser) callonStringIdentifier6() (interface{}, error) {
 }
 
 func (c *current) onStringIdentifier1(s interface{}) (interface{}, error) {
-	node := ast.IdentifierNode{}
-	bs := joinBytes(s)
+	node := &ast.IdentifierNode{}
+	bs := joinBytes(assertSlice(s))
 	name, bad, code := resolveString(bs)
 	if code != errors.ErrorCodeNil {
 		msg := fmt.Sprintf("cannot resolve escape sequence '%s': %v",
diff --git a/core/vm/sqlvm/parser/grammar.peg b/core/vm/sqlvm/parser/grammar.peg
index d25e23547..4c01421d6 100644
--- a/core/vm/sqlvm/parser/grammar.peg
+++ b/core/vm/sqlvm/parser/grammar.peg
@@ -9,7 +9,7 @@ import (
 
 S
 	<- _ x:Stmt? _ xs:( ';' _ s:Stmt? _ { return s, nil } )* EOF
-{ return prepend(x, xs), nil }
+{ return prepend(x, assertSlice(xs)), nil }
 
 /* Statements */
 Stmt
@@ -30,37 +30,31 @@ SelectStmt
 	limit:( _ l:LimitClause { return l, nil } )?
 	offset:( _ of:OffsetClause { return of, nil } )?
 {
-	var (
-		tableNode  *ast.IdentifierNode
-		whereNode  *ast.WhereOptionNode
-		limitNode  *ast.LimitOptionNode
-		offsetNode *ast.OffsetOptionNode
-	)
+	node := &ast.SelectStmtNode{}
+	node.Column = assertExprSlice(prepend(f, assertSlice(fs)))
 	if table != nil {
-		t := table.(ast.IdentifierNode)
-		tableNode = &t
+		node.Table = table.(*ast.IdentifierNode)
 	}
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
+	}
+	groupSlice := assertSlice(group)
+	node.Group = make([]*ast.GroupOptionNode, len(groupSlice))
+	for idx := range groupSlice {
+		node.Group[idx] = groupSlice[idx].(*ast.GroupOptionNode)
+	}
+	orderSlice := assertSlice(order)
+	node.Order = make([]*ast.OrderOptionNode, len(orderSlice))
+	for idx := range orderSlice {
+		node.Order[idx] = orderSlice[idx].(*ast.OrderOptionNode)
 	}
 	if limit != nil {
-		l := limit.(ast.LimitOptionNode)
-		limitNode = &l
+		node.Limit = limit.(*ast.LimitOptionNode)
 	}
 	if offset != nil {
-		o := offset.(ast.OffsetOptionNode)
-		offsetNode = &o
+		node.Offset = offset.(*ast.OffsetOptionNode)
 	}
-	return ast.SelectStmtNode{
-		Column: prepend(f, fs),
-		Table:  tableNode,
-		Where:  whereNode,
-		Group:  toSlice(group),
-		Order:  toSlice(order),
-		Limit:  limitNode,
-		Offset: offsetNode,
-	}, nil
+	return node, nil
 }
 
 SelectColumn
@@ -74,18 +68,17 @@ UpdateStmt
 	_ a:Assignment as:( _ SeparatorToken _ s:Assignment { return s, nil } )*
 	where:( _ w:WhereClause { return w, nil } )?
 {
-	var (
-		whereNode *ast.WhereOptionNode
-	)
+	node := &ast.UpdateStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	assignSlice := prepend(a, assertSlice(as))
+	node.Assignment = make([]*ast.AssignOperatorNode, len(assignSlice))
+	for idx := range assignSlice {
+		node.Assignment[idx] = assignSlice[idx].(*ast.AssignOperatorNode)
+	}
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
 	}
-	return ast.UpdateStmtNode{
-		Table:      table.(ast.IdentifierNode),
-		Assignment: prepend(a, as),
-		Where:      whereNode,
-	}, nil
+	return node, nil
 }
 
 DeleteStmt
@@ -94,17 +87,12 @@ DeleteStmt
 	_ table:Identifier
 	where:( _ w:WhereClause { return w, nil } )?
 {
-	var (
-		whereNode *ast.WhereOptionNode
-	)
+	node := &ast.DeleteStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
 	if where != nil {
-		w := where.(ast.WhereOptionNode)
-		whereNode = &w
+		node.Where = where.(*ast.WhereOptionNode)
 	}
-	return ast.DeleteStmtNode{
-		Table: table.(ast.IdentifierNode),
-		Where: whereNode,
-	}, nil
+	return node, nil
 }
 
 InsertStmt
@@ -113,10 +101,17 @@ InsertStmt
 	_ table:Identifier
 	_ insert:( InsertWithColumnClause / InsertWithDefaultClause )
 {
-	return ast.InsertStmtNode{
-		Table:  table.(ast.IdentifierNode),
-		Insert: insert,
-	}, nil
+	node := &ast.InsertStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	switch i := insert.(type) {
+	case *ast.InsertWithColumnOptionNode:
+		node.Insert = i
+	case *ast.InsertWithDefaultOptionNode:
+		node.Insert = i
+	default:
+		panic(fmt.Sprintf("unknown insert type %T", insert))
+	}
+	return node, nil
 }
 
 InsertValue
@@ -131,14 +126,18 @@ CreateTableStmt
 	_ column:(
 		s:ColumnSchema
 		ss:( _ SeparatorToken _ t:ColumnSchema { return t, nil } )*
-		{ return prepend(s, ss), nil }
+		{ return prepend(s, assertSlice(ss)), nil }
 	)?
 	_ ')'
 {
-	return ast.CreateTableStmtNode{
-		Table:  table.(ast.IdentifierNode),
-		Column: toSlice(column),
-	}, nil
+	node := &ast.CreateTableStmtNode{}
+	node.Table = table.(*ast.IdentifierNode)
+	columnSlice := assertSlice(column)
+	node.Column = make([]*ast.ColumnSchemaNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.ColumnSchemaNode)
+	}
+	return node, nil
 }
 
 ColumnSchema
@@ -146,11 +145,30 @@ ColumnSchema
 	_ t:DataType
 	cs:( _ s:ColumnConstraint { return s, nil } )*
 {
-	return ast.ColumnSchemaNode{
-		Column:     i.(ast.IdentifierNode),
-		DataType:   t,
-		Constraint: toSlice(cs),
-	}, nil
+	node := &ast.ColumnSchemaNode{}
+	node.Column = i.(*ast.IdentifierNode)
+	node.DataType = t.(ast.TypeNode)
+	constraintSlice := assertSlice(cs)
+	node.Constraint = make([]ast.Node, len(constraintSlice))
+	for idx, constraint := range constraintSlice {
+		switch c := constraint.(type) {
+		case *ast.PrimaryOptionNode:
+			node.Constraint[idx] = c
+		case *ast.NotNullOptionNode:
+			node.Constraint[idx] = c
+		case *ast.UniqueOptionNode:
+			node.Constraint[idx] = c
+		case *ast.DefaultOptionNode:
+			node.Constraint[idx] = c
+		case *ast.ForeignOptionNode:
+			node.Constraint[idx] = c
+		case *ast.AutoIncrementOptionNode:
+			node.Constraint[idx] = c
+		default:
+			panic(fmt.Sprintf("unknown constraint type %T", c))
+		}
+	}
+	return node, nil
 }
 
 ColumnConstraint
@@ -170,109 +188,160 @@ CreateIndexStmt
 	_ table:Identifier
 	_ '(' _ i:Identifier is:( _ SeparatorToken _ x:Identifier { return x, nil } )* _ ')'
 {
-	var (
-		uniqueNode *ast.UniqueOptionNode
-	)
+	node := &ast.CreateIndexStmtNode{}
+	node.Index = index.(*ast.IdentifierNode)
+	node.Table = table.(*ast.IdentifierNode)
+	columnSlice := assertSlice(prepend(i, assertSlice(is)))
+	node.Column = make([]*ast.IdentifierNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.IdentifierNode)
+	}
 	if unique != nil {
-		u := unique.(ast.UniqueOptionNode)
-		uniqueNode = &u
+		node.Unique = unique.(*ast.UniqueOptionNode)
 	}
-	return ast.CreateIndexStmtNode{
-		Index:  index.(ast.IdentifierNode),
-		Table:  table.(ast.IdentifierNode),
-		Column: prepend(i, is),
-		Unique: uniqueNode,
-	}, nil
+	return node, nil
 }
 
 /* Clauses */
 WhereClause
 	= WhereToken _ e:Expr
-{ return ast.WhereOptionNode{Condition: e}, nil }
+{
+	node := &ast.WhereOptionNode{}
+	node.Condition = e.(ast.ExprNode)
+	return node, nil
+}
 
 OrderByClause
 	= OrderToken
 	_ ByToken
 	_ f:OrderColumn
 	fs:( _ SeparatorToken _ s:OrderColumn { return s, nil } )*
-{ return prepend(f, fs), nil }
+{
+	return prepend(f, assertSlice(fs)), nil
+}
 
 OrderColumn
 	= i:Expr
 	s:( _ t:( AscToken / DescToken ) { return t, nil } )?
 	n:( _ NullsToken _ l:( LastToken / FirstToken ) { return l, nil } )?
 {
-	return ast.OrderOptionNode{
-		Expr:       i,
-		Desc:       s != nil && string(s.([]byte)) == "desc",
-		NullsFirst: n != nil && string(n.([]byte)) == "first",
-	}, nil
+	node := &ast.OrderOptionNode{}
+	node.Expr = i.(ast.ExprNode)
+	node.Desc = s != nil && string(s.([]byte)) == "desc"
+	node.NullsFirst = n != nil && string(n.([]byte)) == "first"
+	return node, nil
 }
 
 GroupByClause
 	= GroupToken
 	_ ByToken
-	_ i:Expr
-	is:( _ SeparatorToken _ s:Expr { return ast.GroupOptionNode{Expr: s}, nil } )*
-{ return prepend(ast.GroupOptionNode{Expr: i}, is), nil }
+	_ f:GroupColumn
+	fs:( _ SeparatorToken _ s:GroupColumn { return s, nil } )*
+{
+	return prepend(f, assertSlice(fs)), nil
+}
+
+GroupColumn
+	= i:Expr
+{
+	node := &ast.GroupOptionNode{}
+	node.Expr = i.(ast.ExprNode)
+	return node, nil
+}
 
 OffsetClause
 	= OffsetToken _ i:Integer
-{ return ast.OffsetOptionNode{Value: i.(ast.IntegerValueNode)}, nil }
+{
+	node := &ast.OffsetOptionNode{}
+	node.Value = i.(*ast.IntegerValueNode)
+	return node, nil
+}
 
 LimitClause
 	= LimitToken _ i:Integer
-{ return ast.LimitOptionNode{Value: i.(ast.IntegerValueNode)}, nil }
+{
+	node := &ast.LimitOptionNode{}
+	node.Value = i.(*ast.IntegerValueNode)
+	return node, nil
+}
 
 InsertWithColumnClause
 	= cs:( '('
 			_ f:Identifier
 			fs:( _ SeparatorToken _ x:Identifier { return x, nil } )*
 			_ ')'
-			_ { return prepend(f, fs), nil }
+			_ { return prepend(f, assertSlice(fs)), nil }
 		)?
 		ValuesToken
 	_ v:InsertValue
 	vs:( _ SeparatorToken _ y:InsertValue { return y, nil } )*
 {
-	return ast.InsertWithColumnOptionNode{
-		Column: toSlice(cs),
-		Value:  prepend(v, vs),
-	}, nil
+	node := &ast.InsertWithColumnOptionNode{}
+	columnSlice := assertSlice(cs)
+	node.Column = make([]*ast.IdentifierNode, len(columnSlice))
+	for idx := range columnSlice {
+		node.Column[idx] = columnSlice[idx].(*ast.IdentifierNode)
+	}
+	valueSlice := assertSlice(vs)
+	node.Value = make([][]ast.ExprNode, len(valueSlice)+1)
+	node.Value[0] = v.([]ast.ExprNode)
+	for idx := range valueSlice {
+		node.Value[idx+1] = valueSlice[idx].([]ast.ExprNode)
+	}
+	return node, nil
 }
 
 InsertWithDefaultClause
 	= DefaultToken _ ValuesToken
-{ return ast.InsertWithDefaultOptionNode{}, nil }
+{
+	node := &ast.InsertWithDefaultOptionNode{}
+	return node, nil
+}
 
 PrimaryKeyClause
 	= PrimaryToken _ KeyToken
-{ return ast.PrimaryOptionNode{}, nil }
+{
+	node := &ast.PrimaryOptionNode{}
+	return node, nil
+}
 
 NotNullClause
 	= NotToken _ NullToken
-{ return ast.NotNullOptionNode{}, nil }
+{
+	node := &ast.NotNullOptionNode{}
+	return node, nil
+}
 
 UniqueClause
 	= UniqueToken
-{ return ast.UniqueOptionNode{}, nil }
+{
+	node := &ast.UniqueOptionNode{}
+	return node, nil
+}
 
 DefaultClause
 	= DefaultToken _ e:Expr
-{ return ast.DefaultOptionNode{Value: e}, nil }
+{
+	node := &ast.DefaultOptionNode{}
+	node.Value = e.(ast.ExprNode)
+	return node, nil
+}
 
 ForeignClause
 	= ReferencesToken _ t:Identifier _ '(' _ f:Identifier _ ')'
 {
-	return ast.ForeignOptionNode{
-		Table:  t.(ast.IdentifierNode),
-		Column: f.(ast.IdentifierNode),
-	}, nil
+	node := &ast.ForeignOptionNode{}
+	node.Table = t.(*ast.IdentifierNode)
+	node.Column = f.(*ast.IdentifierNode)
+	return node, nil
 }
 
 AutoincrementClause
 	= AutoincrementToken
-{ return ast.AutoIncrementOptionNode{}, nil }
+{
+	node := &ast.AutoIncrementOptionNode{}
+	return node, nil
+}
 
 /* Expressions */
 Expr
@@ -287,88 +356,101 @@ LogicExpr
 
 LogicExpr4
 	= o:LogicExpr3
-		os:( _ op:OrOperator _ s:LogicExpr3 { return opSetSubject(op, s), nil } )*
-{ return rightJoinOperators(o, os), nil }
+		os:( _ op:OrOperator _ s:LogicExpr3
+		{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil } )*
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 LogicExpr3
 	= o:LogicExpr2
-		os:( _ op:AndOperator _ s:LogicExpr2 { return opSetSubject(op, s), nil } )*
-{ return rightJoinOperators(o, os), nil }
+		os:( _ op:AndOperator _ s:LogicExpr2
+		{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil } )*
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 LogicExpr2
 	= op:NotOperator _ s:LogicExpr2
-	{ return opSetTarget(op, s), nil }
+	{ return opSetTarget(op.(ast.UnaryOperator), s.(ast.ExprNode)), nil }
 	/ LogicExpr1
 
 LogicExpr1
 	= o:ArithmeticExpr os:( _ l:LogicExpr1Op { return l, nil } )*
-{ return rightJoinOperators(o, os), nil }
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 LogicExpr1Op
 	= LogicExpr1In
-	/ LogicExpr1Null
+	/ LogicExpr1Is
 	/ LogicExpr1Like
 	/ LogicExpr1Cmp
 
 LogicExpr1In
 	= n:( t:NotOperator _ { return t, nil } )? InToken _ '(' _ s:MultiExpr _ ')'
 {
-	op := opSetSubject(&ast.InOperatorNode{}, s)
+	node := &ast.InOperatorNode{}
+	node.Right = s.([]ast.ExprNode)
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
-LogicExpr1Null
+LogicExpr1Is
 	= IsToken n:( _ t:NotOperator { return t, nil } )? _ NullToken
 {
-	op := opSetSubject(&ast.IsOperatorNode{}, ast.NullValueNode{})
+	node := &ast.IsOperatorNode{}
+	null := &ast.NullValueNode{}
+	opSetSubject(node, null)
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
 LogicExpr1Like
 	= n:( t:NotOperator _ { return t, nil } )? LikeToken _ s:Expr
 {
-	op := opSetSubject(&ast.LikeOperatorNode{}, s)
+	node := &ast.LikeOperatorNode{}
+	opSetSubject(node, s.(ast.ExprNode))
 	if n != nil {
-		return opSetTarget(n, op), nil
+		return opSetTarget(n.(ast.UnaryOperator), node), nil
 	}
-	return op, nil
+	return node, nil
 }
 
 LogicExpr1Cmp
 	= op:CmpOperator _ s:ArithmeticExpr
-{ return opSetSubject(op, s), nil }
+{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil }
 
 ArithmeticExpr
 	= ArithmeticExpr3
 
 ArithmeticExpr3
-	= o:ArithmeticExpr2 os:( _ op:ConcatOperator _ s:ArithmeticExpr2 { return opSetSubject(op, s), nil } )*
-{ return rightJoinOperators(o, os), nil }
+	= o:ArithmeticExpr2
+		os:( _ op:ConcatOperator _ s:ArithmeticExpr2
+		{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil } )*
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 ArithmeticExpr2
-	= o:ArithmeticExpr1 os:( _ op:AddSubOperator _ s:ArithmeticExpr1 { return opSetSubject(op, s), nil } )*
-{ return rightJoinOperators(o, os), nil }
+	= o:ArithmeticExpr1
+		os:( _ op:AddSubOperator _ s:ArithmeticExpr1
+		{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil } )*
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 ArithmeticExpr1
-	= o:Operand os:( _ op:MulDivModOperator _ s:Operand { return opSetSubject(op, s), nil } )*
-{ return rightJoinOperators(o, os), nil }
+	= o:Operand
+		os:( _ op:MulDivModOperator _ s:Operand
+		{ return opSetSubject(op.(ast.BinaryOperator), s.(ast.ExprNode)), nil } )*
+{ return rightJoinOperators(o.(ast.ExprNode), assertExprSlice(os)), nil }
 
 MultiExpr
 	= x:Expr xs:( _ SeparatorToken _ e:Expr { return e, nil } )*
-{ return prepend(x, xs), nil }
+{ return assertExprSlice(prepend(x, assertSlice(xs))), nil }
 
 MultiExprWithDefault
 	= x:ExprWithDefault xs:( _ SeparatorToken _ e:ExprWithDefault { return e, nil } )*
-{ return prepend(x, xs), nil }
+{ return assertExprSlice(prepend(x, assertSlice(xs))), nil }
 
 Operand
-	= op:UnaryOperator _ s:Operand { return opSetTarget(op, s), nil }
+	= op:UnaryOperator _ s:Operand
+		{ return opSetTarget(op.(ast.UnaryOperator), s.(ast.ExprNode)), nil }
 	/ '(' _ e:Expr _ ')' { return e, nil }
 	/ &(CastToken) t:TypeCast { return t, nil }
 	/ FunctionCall
@@ -377,19 +459,36 @@ Operand
 
 TypeCast
 	= CastToken _ '(' _ o:Expr _ AsToken _ s:DataType _ ')'
-{ return opSetSubject(opSetObject(&ast.CastOperatorNode{}, o), s), nil }
+{
+	node := &ast.CastOperatorNode{}
+	node.SourceExpr = o.(ast.ExprNode)
+	node.TargetType = s.(ast.TypeNode)
+	return node, nil
+}
 
 FunctionCall
 	= i:Identifier _ '(' _ r:FunctionArgs? _ ')'
-{ return opSetSubject(opSetObject(&ast.FunctionOperatorNode{}, i), r), nil }
+{
+	node := &ast.FunctionOperatorNode{}
+	node.Name = i.(*ast.IdentifierNode)
+	if r != nil {
+		node.Args = r.([]ast.ExprNode)
+	}
+	return node, nil
+}
 
 FunctionArgs
-	= a:AnyLiteral { return []interface{}{a}, nil }
+	= a:AnyLiteral { return []ast.ExprNode{a.(*ast.AnyValueNode)}, nil }
 	/ MultiExpr
 
 Assignment
 	= i:Identifier _ '=' _ e:ExprWithDefault
-{ return opSetSubject(opSetObject(&ast.AssignOperatorNode{}, i), e), nil }
+{
+	node := &ast.AssignOperatorNode{}
+	node.Column = i.(*ast.IdentifierNode)
+	node.Expr = e.(ast.ExprNode)
+	return node, nil
+}
 
 /* Operators */
 UnaryOperator
@@ -398,77 +497,101 @@ UnaryOperator
 SignOperator
 	= Sign
 {
+	var node ast.UnaryOperator
 	switch string(c.text) {
 	case "+":
-		return &ast.PosOperatorNode{}, nil
+		node = &ast.PosOperatorNode{}
 	case "-":
-		return &ast.NegOperatorNode{}, nil
+		node = &ast.NegOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown sign %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown sign %s", c.text))
+	return node, nil
 }
 
 NotOperator
 	= NotToken
-{ return &ast.NotOperatorNode{}, nil }
+{
+	node := &ast.NotOperatorNode{}
+	return node, nil
+}
 
 AndOperator
 	= AndToken
-{ return &ast.AndOperatorNode{}, nil }
+{
+	node := &ast.AndOperatorNode{}
+	return node, nil
+}
 
 OrOperator
 	= OrToken
-{ return &ast.OrOperatorNode{}, nil }
+{
+	node := &ast.OrOperatorNode{}
+	return node, nil
+}
 
 CmpOperator
 	= ( "<=" / ">=" / "<>" / "!=" / [<>=] )
 {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "<=":
-		return &ast.LessOrEqualOperatorNode{}, nil
+		node = &ast.LessOrEqualOperatorNode{}
 	case ">=":
-		return &ast.GreaterOrEqualOperatorNode{}, nil
+		node = &ast.GreaterOrEqualOperatorNode{}
 	case "<>":
-		return &ast.NotEqualOperatorNode{}, nil
+		node = &ast.NotEqualOperatorNode{}
 	case "!=":
-		return &ast.NotEqualOperatorNode{}, nil
+		node = &ast.NotEqualOperatorNode{}
 	case "<":
-		return &ast.LessOperatorNode{}, nil
+		node = &ast.LessOperatorNode{}
 	case ">":
-		return &ast.GreaterOperatorNode{}, nil
+		node = &ast.GreaterOperatorNode{}
 	case "=":
-		return &ast.EqualOperatorNode{}, nil
+		node = &ast.EqualOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown comparison operator %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown comparison operator %s", c.text))
+	return node, nil
 }
 
 ConcatOperator
 	= "||"
-{ return &ast.ConcatOperatorNode{}, nil }
+{
+	node := &ast.ConcatOperatorNode{}
+	return node, nil
+}
 
 AddSubOperator
 	= [+-]
 {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "+":
-		return &ast.AddOperatorNode{}, nil
+		node = &ast.AddOperatorNode{}
 	case "-":
-		return &ast.SubOperatorNode{}, nil
+		node = &ast.SubOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown addition or subtraction operator %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown addition or subtraction operator %s", c.text))
+	return node, nil
 }
 
 MulDivModOperator
 	= [*/%]
 {
+	var node ast.BinaryOperator
 	switch string(c.text) {
 	case "*":
-		return &ast.MulOperatorNode{}, nil
+		node = &ast.MulOperatorNode{}
 	case "/":
-		return &ast.DivOperatorNode{}, nil
+		node = &ast.DivOperatorNode{}
 	case "%":
-		return &ast.ModOperatorNode{}, nil
+		node = &ast.ModOperatorNode{}
+	default:
+		panic(fmt.Sprintf("unknown multiplication, division, modulo operator: %s", c.text))
 	}
-	panic(fmt.Sprintf("unknown multiplication, division, modulo operator: %s", c.text))
+	return node, nil
 }
 
 /* Types */
@@ -485,7 +608,8 @@ DataType
 UIntType
 	= "UINT"i s:NonZeroLeadingInteger !NormalIdentifierRest
 {
-	node := ast.IntTypeNode{Unsigned: true}
+	node := &ast.IntTypeNode{}
+	node.Unsigned = true
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -505,7 +629,8 @@ UIntType
 IntType
 	= "INT"i s:NonZeroLeadingInteger !NormalIdentifierRest
 {
-	node := ast.IntTypeNode{Unsigned: false}
+	node := &ast.IntTypeNode{}
+	node.Unsigned = false
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -525,7 +650,8 @@ IntType
 UFixedType
 	= "UFIXED"i s:NonZeroLeadingInteger "X"i t:NonZeroLeadingInteger !NormalIdentifierRest
 {
-	node := ast.FixedTypeNode{Unsigned: true}
+	node := &ast.FixedTypeNode{}
+	node.Unsigned = true
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -558,7 +684,8 @@ UFixedType
 FixedType
 	= "FIXED"i s:NonZeroLeadingInteger "X"i t:NonZeroLeadingInteger !NormalIdentifierRest
 {
-	node := ast.FixedTypeNode{Unsigned: false}
+	node := &ast.FixedTypeNode{}
+	node.Unsigned = false
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -591,7 +718,7 @@ FixedType
 FixedBytesType
 	= "BYTES"i s:NonZeroLeadingInteger !NormalIdentifierRest
 {
-	node := ast.FixedBytesTypeNode{}
+	node := &ast.FixedBytesTypeNode{}
 	size, code := toUint(s.([]byte))
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -609,7 +736,9 @@ FixedBytesType
 }
 	/ "BYTE"i !NormalIdentifierRest
 {
-	return ast.FixedBytesTypeNode{Size: 1}, nil
+	node := &ast.FixedBytesTypeNode{}
+	node.Size = 1
+	return node, nil
 }
 
 DynamicBytesType
@@ -617,17 +746,26 @@ DynamicBytesType
 		/ "STRING"i !NormalIdentifierRest
 		/ "TEXT"i !NormalIdentifierRest
 	)
-{ return ast.DynamicBytesTypeNode{}, nil }
+{
+	node := &ast.DynamicBytesTypeNode{}
+	return node, nil
+}
 
 AddressType
 	= "ADDRESS"i !NormalIdentifierRest
-{ return ast.AddressTypeNode{}, nil }
+{
+	node := &ast.AddressTypeNode{}
+	return node, nil
+}
 
 BoolType
 	= ( "BOOL"i !NormalIdentifierRest
 		/ "BOOLEAN"i !NormalIdentifierRest
 	)
-{ return ast.BoolTypeNode{}, nil }
+{
+	node := &ast.BoolTypeNode{}
+	return node, nil
+}
 
 /* Values */
 Value
@@ -638,19 +776,32 @@ Value
 
 AnyLiteral
 	= AnyToken
-{ return ast.AnyValueNode{}, nil }
+{
+	node := &ast.AnyValueNode{}
+	return node, nil
+}
 
 DefaultLiteral
 	= DefaultToken
-{ return ast.DefaultValueNode{}, nil }
+{
+	node := &ast.DefaultValueNode{}
+	return node, nil
+}
 
 BoolLiteral
 	= b:( TrueToken / FalseToken )
-{ return ast.BoolValueNode{V: string(b.([]byte)) == "true"}, nil }
+{
+	node := &ast.BoolValueNode{}
+	node.V = string(b.([]byte)) == "true"
+	return node, nil
+}
 
 NullLiteral
 	= NullToken
-{ return ast.NullValueNode{}, nil }
+{
+	node := &ast.NullValueNode{}
+	return node, nil
+}
 
 NumberLiteral
 	= &("0" "X"i) h:Hex { return h, nil }
@@ -662,7 +813,8 @@ Sign
 Integer
 	= [0-9]+
 {
-	node := ast.IntegerValueNode{IsAddress: false, V: decimal.Zero}
+	node := &ast.IntegerValueNode{}
+	node.IsAddress = false
 	v, code := toDecimal(c.text)
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -691,7 +843,7 @@ Fixnum
 Decimal
 	= Fixnum ( "E"i Sign? Integer )?
 {
-	node := ast.DecimalValueNode{V: decimal.Zero}
+	node := &ast.DecimalValueNode{}
 	v, code := toDecimal(c.text)
 	if code != errors.ErrorCodeNil {
 		err := errors.Error{
@@ -710,7 +862,7 @@ Decimal
 
 Hex
 	= "0" "X"i s:( [0-9A-Fa-f] )+ !NormalIdentifierRest
-{ return hexToInteger(joinBytes(s)), nil }
+{ return hexToInteger(joinBytes(assertSlice(s))), nil }
 
 StringLiteral
 	= HexString
@@ -718,13 +870,17 @@ StringLiteral
 
 HexString
 	= ( "HEX"i / "X"i ) "'" s:([0-9a-fA-F][0-9a-fA-F] { return c.text, nil } )* "'"
-{ return ast.BytesValueNode{V: hexToBytes(joinBytes(s))}, nil }
+{
+	node := &ast.BytesValueNode{}
+	node.V = hexToBytes(joinBytes(assertSlice(s)))
+	return node, nil
+}
 
 NormalString
 	= "'" s:( ( [^'\r\n\\] / "\\" . ) { return c.text, nil } )* "'"
 {
-	node := ast.BytesValueNode{}
-	bs := joinBytes(s)
+	node := &ast.BytesValueNode{}
+	bs := joinBytes(assertSlice(s))
 	v, bad, code := resolveString(bs)
 	if code != errors.ErrorCodeNil {
 		msg := fmt.Sprintf("cannot resolve escape sequence '%s': %v",
@@ -884,7 +1040,9 @@ Identifier
 NormalIdentifier
 	= NormalIdentifierStart NormalIdentifierRest*
 {
-	return ast.IdentifierNode{Name: decodeString(c.text)}, nil
+	node := &ast.IdentifierNode{}
+	node.Name = decodeString(c.text)
+	return node, nil
 }
 
 NormalIdentifierStart
@@ -896,8 +1054,8 @@ NormalIdentifierRest
 StringIdentifier
 	= "\"" s:( ( [^"\r\n\\] / "\\" . ) { return c.text, nil } )* "\""
 {
-	node := ast.IdentifierNode{}
-	bs := joinBytes(s)
+	node := &ast.IdentifierNode{}
+	bs := joinBytes(assertSlice(s))
 	name, bad, code := resolveString(bs)
 	if code != errors.ErrorCodeNil {
 		msg := fmt.Sprintf("cannot resolve escape sequence '%s': %v",
diff --git a/core/vm/sqlvm/parser/parser.go b/core/vm/sqlvm/parser/parser.go
index 2e882ea3c..5cfe9400e 100644
--- a/core/vm/sqlvm/parser/parser.go
+++ b/core/vm/sqlvm/parser/parser.go
@@ -19,23 +19,45 @@ import (
 //go:generate mv grammar_new.go grammar.go
 //go:generate goimports -w grammar.go
 
-func prepend(x interface{}, xs interface{}) []interface{} {
-	return append([]interface{}{x}, toSlice(xs)...)
+func prepend(x interface{}, xs []interface{}) []interface{} {
+	return append([]interface{}{x}, xs...)
 }
 
-func toSlice(x interface{}) []interface{} {
+func assertSlice(x interface{}) []interface{} {
 	if x == nil {
 		return nil
 	}
 	return x.([]interface{})
 }
 
+func assertNodeSlice(x interface{}) []ast.Node {
+	xs := assertSlice(x)
+	ns := make([]ast.Node, len(xs))
+	for i := 0; i < len(xs); i++ {
+		if xs[i] != nil {
+			ns[i] = xs[i].(ast.Node)
+		}
+	}
+	return ns
+}
+
+func assertExprSlice(x interface{}) []ast.ExprNode {
+	xs := assertSlice(x)
+	es := make([]ast.ExprNode, len(xs))
+	for i := 0; i < len(xs); i++ {
+		if xs[i] != nil {
+			es[i] = xs[i].(ast.ExprNode)
+		}
+	}
+	return es
+}
+
 // TODO(wmin0): finish it.
 func isAddress(h []byte) bool {
 	return false
 }
 
-func hexToInteger(h []byte) interface{} {
+func hexToInteger(h []byte) *ast.IntegerValueNode {
 	d := decimal.Zero
 	l := len(h)
 	base := decimal.New(16, 0)
@@ -49,7 +71,10 @@ func hexToInteger(h []byte) interface{} {
 				Mul(base.Pow(decimal.New(int64(l-idx-1), 0))),
 		)
 	}
-	return ast.IntegerValueNode{V: d, IsAddress: isAddress(h)}
+	node := &ast.IntegerValueNode{}
+	node.IsAddress = isAddress(h)
+	node.V = d
+	return node
 }
 
 func hexToBytes(h []byte) []byte {
@@ -106,55 +131,54 @@ func toLower(b []byte) []byte {
 	return bytes.ToLower(b)
 }
 
-func joinBytes(x interface{}) []byte {
-	xs := toSlice(x)
+func joinBytes(x []interface{}) []byte {
 	bs := []byte{}
-	for _, b := range xs {
+	for _, b := range x {
 		bs = append(bs, b.([]byte)...)
 	}
 	return bs
 }
 
-func opSetSubject(op interface{}, s interface{}) interface{} {
-	x := op.(ast.BinaryOperator)
-	x.SetSubject(s)
-	return x
+func opSetSubject(op ast.BinaryOperator, s ast.ExprNode) ast.BinaryOperator {
+	op.SetSubject(s)
+	return op
 }
 
-func opSetObject(op interface{}, o interface{}) interface{} {
-	x := op.(ast.BinaryOperator)
-	x.SetObject(o)
-	return x
+func opSetObject(op ast.BinaryOperator, o ast.ExprNode) ast.BinaryOperator {
+	op.SetObject(o)
+	return op
 }
 
-func opSetTarget(op interface{}, t interface{}) interface{} {
-	x := op.(ast.UnaryOperator)
-	x.SetTarget(t)
-	return x
+func opSetTarget(op ast.UnaryOperator, t ast.ExprNode) ast.UnaryOperator {
+	op.SetTarget(t)
+	return op
 }
 
-func joinOperator(x interface{}, o interface{}) {
-	if op, ok := x.(ast.UnaryOperator); ok {
+func joinOperator(x ast.ExprNode, o ast.ExprNode) {
+	switch op := x.(type) {
+	case ast.UnaryOperator:
 		joinOperator(op.GetTarget(), o)
-		return
-	}
-	if op, ok := x.(ast.BinaryOperator); ok {
+	case ast.BinaryOperator:
 		op.SetObject(o)
-		return
+	case *ast.CastOperatorNode:
+		op.SourceExpr = o
+	case *ast.InOperatorNode:
+		op.Left = o
+	default:
+		panic(fmt.Sprintf("unable to join operators %T and %T", x, o))
 	}
 }
 
-func rightJoinOperators(o interface{}, x interface{}) interface{} {
-	xs := toSlice(x)
-	if len(xs) == 0 {
+func rightJoinOperators(o ast.ExprNode, x []ast.ExprNode) ast.ExprNode {
+	if len(x) == 0 {
 		return o
 	}
-	l := len(xs)
+	l := len(x)
 	for idx := 0; idx < l-1; idx++ {
-		joinOperator(xs[idx+1], xs[idx])
+		joinOperator(x[idx+1], x[idx])
 	}
-	joinOperator(xs[0], o)
-	return xs[l-1]
+	joinOperator(x[0], o)
+	return x[l-1]
 }
 
 func sanitizeBadEscape(s []byte) []byte {
@@ -254,7 +278,7 @@ func resolveString(s []byte) ([]byte, []byte, errors.ErrorCode) {
 				if err != nil {
 					return nil, s[i : i+10], convertNumError(err)
 				}
-				if r >= 0x10ffff || (r >= 0xd800 && r <= 0xdfff) {
+				if r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff) {
 					return nil, s[i : i+10], errors.ErrorCodeInvalidUnicodeCodePoint
 				}
 				o.WriteRune(rune(r))
@@ -272,7 +296,7 @@ func resolveString(s []byte) ([]byte, []byte, errors.ErrorCode) {
 }
 
 // Parse parses SQL commands text and return an AST.
-func Parse(b []byte, o ...Option) (interface{}, error) {
+func Parse(b []byte, o ...Option) ([]ast.Node, error) {
 	// The string sent from the caller is not guaranteed to be valid UTF-8.
 	// We don't really care non-ASCII characters in the string because all
 	// keywords and special symbols are defined in ASCII. Therefore, as long
@@ -301,10 +325,11 @@ func Parse(b []byte, o ...Option) (interface{}, error) {
 	eb := encBuf.Bytes()
 	options := append([]Option{Recover(false)}, o...)
 	root, pigeonErr := parse("", eb, options...)
+	stmts := assertNodeSlice(root)
 
 	// Process the AST.
 	if pigeonErr == nil {
-		return root, pigeonErr
+		return stmts, pigeonErr
 	}
 
 	// Process errors.
@@ -333,5 +358,5 @@ func Parse(b []byte, o ...Option) (interface{}, error) {
 				"cannot fix byte offset %d", sqlvmErrList[i].Position))
 		}
 	}
-	return root, sqlvmErrList
+	return stmts, sqlvmErrList
 }
diff --git a/core/vm/sqlvm/parser/parser_test.go b/core/vm/sqlvm/parser/parser_test.go
index bed734c60..f5c4312a8 100644
--- a/core/vm/sqlvm/parser/parser_test.go
+++ b/core/vm/sqlvm/parser/parser_test.go
@@ -80,6 +80,106 @@ func (s *ParserTestSuite) TestParse() {
 	s.requireParseNoError(`create index ㄅㄆㄇ on 👍 ( 🌍 , 💯 )`)
 }
 
+func (s *ParserTestSuite) TestParseRules() {
+	s.requireParseNoError(`
+		SELECT
+			C1,
+			*,
+			SUM(*),
+			COUNT(*) + 1,
+			*,
+			NOT A >= B,
+			NULL IS NULL,
+			C2 OR C3 AND TRUE OR FALSE,
+			C4 NOT IN (C5, 849, 2899 - C6),
+			C7 + C8 IN (C9, 5566, 9487 * C10),
+			C10 IS NULL,
+			C11 IS NOT NULL,
+			C12 LIKE 'dek_s%n',
+			C13 || C14 NOT LIKE 'cob%h__d%',
+			C15 <= C16 + 45,
+			C17 >= C18 - 54,
+			C19 <> 46 * C20,
+			C21 != 64 / C21,
+			C22 < C23 % C24,
+			C25 > C26 / (C27 + C28),
+			C29 = C30 * (C31 - C32),
+			C33 || C34 || 'vm' || 'sql',
+			C35 + C36 - C37 * C38 / C39 % C40,
+			C41 - - C42 + + (C43) * -C44 ++ C45 / -C46,
+			C47 + CAST(C48 % C49 AS INT88) - TSAC(),
+			F(C50) * "F"(C51, "C52") + "!"('\U0010FFFF', '\x11\x23\xfd'),
+			0x845 - 0x6ea - 0xbf,
+			00244 - 1.56 + 24. - .34,
+			1.2e1 - 2.04e-5 + -4.53e+10,
+			1e1 + 1.e1 - .1e1,
+			-1e1 + -1.e1 - -.1e1,
+			0.0 + 0e0 - 0.e0 + .0e0 * 0.,
+			-0.0 + -0e0 - -0.e0 + -.0e0 * -0.,
+			'normal' || x'8e7a' || hex'abcdef' || C53
+			FROM T
+			WHERE W
+			GROUP BY
+				1,
+				C1,
+				C2 + 2,
+				C3 - C4,
+				C5 AND C6
+			ORDER BY
+				1,
+				2 ASC,
+				C1 DESC,
+				C2 NULLS FIRST,
+				C3 + C4 NULLS LAST,
+				C5 * (C6 - C7) ASC NULLS FIRST,
+				C8 || C9 || 'dexon' DESC NULLS LAST
+			LIMIT 218 OFFSET 2019;
+
+		UPDATE T
+			SET
+				C1 = C1 = C2 OR C3 <> C4,
+				C2 = C2 IS NOT NULL,
+				C3 = DEFAULT
+			WHERE W;
+
+		DELETE FROM T WHERE W;
+
+		INSERT INTO T DEFAULT VALUES;
+		INSERT INTO T VALUES (V1, V2, V3, V4, V5);
+		INSERT INTO T VALUES (DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT);
+		INSERT INTO T (C1) VALUES (V1), (DEFAULT);
+		INSERT INTO T (C1, C2, C3)
+			VALUES (V1, V2, V3 + V4), (V5 IS NULL, DEFAULT, NULL);
+
+		CREATE TABLE T (
+			C1 UINT64 PRIMARY KEY AUTOINCREMENT,
+			C2 ADDRESS REFERENCES U (D) NOT NULL,
+			C3 UINT256 DEFAULT 3 * 2 + 1,
+			C4 BYTES5 DEFAULT 'hello',
+			C5 INT24 UNIQUE NOT NULL,
+			C6 TEXT
+		);
+
+		CREATE TABLE T (
+			C1 INT224,
+			C2 UINT168,
+			C3 FIXED72X0,
+			C4 UFIXED80X80,
+			C5 BYTES32,
+			C6 BYTES1,
+			C7 BYTE,
+			C8 BYTES,
+			C9 TEXT,
+			C10 STRING,
+			C11 ADDRESS,
+			C12 BOOL
+		);
+
+		CREATE INDEX I ON T (C1);
+		CREATE UNIQUE INDEX I ON T (C2, C3);
+	`)
+}
+
 func (s *ParserTestSuite) TestParseInvalidUTF8() {
 	query := `SELECT ㄅ FROM 東 WHERE — - ─ = ██`
 	query, err := traditionalchinese.Big5.NewEncoder().String(query)