overload

var (
	// ErrDivByZero is reported on a division by zero.
	ErrDivByZero = errors.New(errno.SyntaxErrororAccessRuleViolation, "division by zero")
	// ErrModByZero is reported when computing the rest of a division by zero.
	ErrModByZero = errors.New(errno.SyntaxErrororAccessRuleViolation, "zero modulus")

	// BinOps contains the binary operations indexed by operation type.
	BinOps = map[int][]*BinOp{}
)

var (
	// OperatorCastRules records implicit type conversion rule for all operators and built-in functions
	// map's key is operator id or function id (eg: overload.Plus)
	OperatorCastRules = make(map[int][]castRule)

	// OperatorReturnType records return type for all operator and built-in functions
	// first map : key is operator or function id (eg: overload.Minus), value is second map :
	// key is numbers of args, and value is a slice of struct retType (contains information about arg types and return type)
	OperatorReturnType = make(map[int]map[uint8][]retType)
)

var LogicalOps = map[int]uint8{
	Or:      MayLogical,
	And:     MayLogical,
	Like:    MustLogical,
	NotLike: MustLogical,
	EQ:      MustLogical,
	LT:      MustLogical,
	LE:      MustLogical,
	GT:      MustLogical,
	GE:      MustLogical,
	NE:      MustLogical,
}

var MultiOps = map[int][]*MultiOp{}

var NegOps = map[int]int{
	Or:   And,
	And:  Or,
	EQ:   NE,
	LT:   GE,
	LE:   GT,
	GT:   LE,
	GE:   LT,
	Like: NotLike,
}

var OpName = map[int]string{
	UnaryMinus: "-",
	Not:        "not",

	Or:         "or",
	And:        "and",
	Plus:       "+",
	Minus:      "-",
	Mult:       "*",
	Div:        "/",
	IntegerDiv: "div",
	Mod:        "%",

	Like:    "like",
	NotLike: "notLike",

	Typecast: "cast",

	EQ: "=",
	LT: "<",
	LE: "<=",
	GT: ">",
	GE: ">=",
	NE: "<>",
}

var OpTypes = map[int]int{
	UnaryMinus: Unary,
	Or:         Binary,
	And:        Binary,
	Plus:       Binary,
	Minus:      Binary,
	Mult:       Binary,
	Div:        Binary,
	Mod:        Binary,
	Like:       Binary,
	NotLike:    Binary,
	Typecast:   Binary,
	EQ:         Binary,
	LT:         Binary,
	LE:         Binary,
	GT:         Binary,
	GE:         Binary,
	NE:         Binary,
}

var SelsType = types.Type{Oid: types.T_sel, Size: 8}

var (
	// UnaryOps contains the unary operations indexed by operation type.
	UnaryOps = map[int][]*UnaryOp{}
)