operator

package

Go to main page

Versions in this module

v0

v0.7.0

Feb 18, 2023

Changes in this version

+ func CastDateAsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDatetimeAsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastJsonToString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CompareValenaInline(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func ILike(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func INGeneral(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func INString(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IfTypeCastSupported(sourceType, targetType types.T) bool

+ func NewCast(parameters []*vector.Vector, result vector.FunctionResultWrapper, ...) error

+ func NotINGeneral(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NotINString(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

v0.6.0

Nov 29, 2022

Changes in this version

+ const AND

+ const OR

+ const XOR

+ var CaseWhenBlob = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenJson = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenText = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenUuid = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceBlob = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceBool = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceChar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceDate = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceDateTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceDecimal128 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceDecimal64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceJson = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceText = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceTimestamp = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceUuid = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CoalesceVarchar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfBlob = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfJson = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfText = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfUuid = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Arith(vectors []*vector.Vector, proc *process.Process, typ types.Type, afn arithFn) (*vector.Vector, error)

+ func BoolResult(isMatch bool, isReg bool) bool

+ func CastBoolToNumeric(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDateAsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDatetimeAsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128AsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToInt32(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64AsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastIntAsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials2Uint(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastStringToJson(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastStringToUuid(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsDate(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsDatetime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsDecimal128(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsDecimal64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsNumeric(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimeAsString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastUIntAsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastUuidToString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastVarcharAsTime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CoalesceTypeCheckFn(inputTypes []types.T, _ []types.T, ret types.T) bool

+ func CompareUuid(vs []*vector.Vector, fn compUuidFn, proc *process.Process) (*vector.Vector, error)

+ func CompareUuidEq(v1, v2 [16]byte) bool

+ func CompareUuidGe(v1, v2 [16]byte) bool

+ func CompareUuidGt(v1, v2 [16]byte) bool

+ func CompareUuidLe(v1, v2 [16]byte) bool

+ func CompareUuidLt(v1, v2 [16]byte) bool

+ func CompareUuidNe(v1, v2 [16]byte) bool

+ func DivFloat(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func EqUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GeUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IntegerDivFloat(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsDecimal(t types.T) bool

+ func IsFalse(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsFloat(t types.T) bool

+ func IsInteger(t types.T) bool

+ func IsNotFalse(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsNotTrue(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsNumeric(t types.T) bool

+ func IsTrue(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Logic(vectors []*vector.Vector, proc *process.Process, cfn logicFn, op logicType) (*vector.Vector, error)

+ func LogicAnd(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LogicNot(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LogicOr(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LogicXor(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MinusDatetime(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MinusFloat(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MinusInt(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MinusUint(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func ModUint(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MultFloat(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MultInt(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MultUint(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeUuid(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NotRegMatch(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func OpBitAndFun(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func OpBitLeftShiftFun(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func OpBitOrFun(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func OpBitRightShiftFun(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func OpBitXorFun(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func PlusFloat(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func PlusInt(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func PlusUint(args []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func RegMatch(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func RegMatchWithALL(lv, rv []string, rs []bool, isReg bool) error

+ func RegMatchWithAllConst(lv, rv []string, rs []bool, isReg bool) error

+ func RegMatchWithLeftConst(lv, rv []string, rs []bool, isReg bool) error

+ func RegMatchWithRightConst(lv, rv []string, rs []bool, isReg bool) error

+ func UnaryTilde(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

v0.5.1

Aug 17, 2022

Changes in this version

+ func CompareBoolEq(v1, v2 bool, s1, s2 int32) bool

+ func CompareBoolGe(v1, v2 bool, s1, s2 int32) bool

+ func CompareBoolGt(v1, v2 bool, s1, s2 int32) bool

+ func CompareBoolLe(v1, v2 bool, s1, s2 int32) bool

+ func CompareBoolLt(v1, v2 bool, s1, s2 int32) bool

+ func CompareBoolNe(v1, v2 bool, s1, s2 int32) bool

+ func CompareBytesEq(v1, v2 []byte, s1, s2 int32) bool

+ func CompareBytesGe(v1, v2 []byte, s1, s2 int32) bool

+ func CompareBytesGt(v1, v2 []byte, s1, s2 int32) bool

+ func CompareBytesLe(v1, v2 []byte, s1, s2 int32) bool

+ func CompareBytesLt(v1, v2 []byte, s1, s2 int32) bool

+ func CompareBytesNe(v1, v2 []byte, s1, s2 int32) bool

+ func CompareDecimal128Eq(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal128Ge(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal128Gt(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal128Le(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal128Lt(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal128Ne(v1, v2 types.Decimal128, s1, s2 int32) bool

+ func CompareDecimal64Eq(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareDecimal64Ge(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareDecimal64Gt(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareDecimal64Le(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareDecimal64Lt(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareDecimal64Ne(v1, v2 types.Decimal64, s1, s2 int32) bool

+ func CompareOrdered(c C, vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CompareString(vs []*vector.Vector, fn compStringFn, proc *process.Process) (*vector.Vector, error)

+ func CompareWithFn(vs []*vector.Vector, fn compFn[T], proc *process.Process) (*vector.Vector, error)

+ func EqBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ type CompEq struct

+ func (c CompEq[T]) Eval(a, b T) bool

+ type CompGe struct

+ func (c CompGe[T]) Eval(a, b T) bool

+ type CompGt struct

+ func (c CompGt[T]) Eval(a, b T) bool

+ type CompLe struct

+ func (c CompLe[T]) Eval(a, b T) bool

+ type CompLt struct

+ func (c CompLt[T]) Eval(a, b T) bool

+ type CompNe struct

+ func (c CompNe[T]) Eval(a, b T) bool

+ type CompOp interface

+ Eval func(a, b T) bool

v0.5.0

Jul 14, 2022

Changes in this version

+ var CaseWhenBool = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenChar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenDate = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenDateTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenDecimal128 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenDecimal64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenTimestamp = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var CaseWhenVarchar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var Decimal128Mul = decimal128Mul

+ var Decimal128MulScalar = decimal128MulScalar

+ var Decimal128MulScalarSels = decimal128MulScalarSels

+ var Decimal128MulSels = decimal128MulSels

+ var Decimal128Sub = decimal128Sub

+ var Decimal128SubByScalar = decimal128SubByScalar

+ var Decimal128SubByScalarSels = decimal128SubByScalarSels

+ var Decimal128SubScalar = decimal128SubScalar

+ var Decimal128SubScalarSels = decimal128SubScalarSels

+ var Decimal128SubSels = decimal128SubSels

+ var Decimal64Mul = decimal64Mul

+ var Decimal64MulScalar = decimal64MulScalar

+ var Decimal64MulScalarSels = decimal64MulScalarSels

+ var Decimal64MulSels = decimal64MulSels

+ var Decimal64Sub = decimal64Sub

+ var Decimal64SubByScalar = decimal64SubByScalar

+ var Decimal64SubByScalarSels = decimal64SubByScalarSels

+ var Decimal64SubScalar = decimal64SubScalar

+ var Decimal64SubScalarSels = decimal64SubScalarSels

+ var Decimal64SubSels = decimal64SubSels

+ var ErrDivByZero = errors.New(errno.SyntaxErrororAccessRuleViolation, "division by zero")

+ var ErrModByZero = errors.New(errno.SyntaxErrororAccessRuleViolation, "zero modulus")

+ var Float32Div = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var Float32Float64Mul = NumericMul2[float32, float64]

+ var Float32Float64MulSels = NumericMulSels2[float32, float64]

+ var Float32Float64Sub = NumericBigSmall[float64, float32]

+ var Float32Float64SubSels = NumericSelsBigSmall[float64, float32]

+ var Float32Mod = FloatMod[float32]

+ var Float32ModByScalar = FloatModByScalar[float32]

+ var Float32ModByScalarSels = FloatModByScalarSels[float32]

+ var Float32ModScalar = FloatModScalar[float32]

+ var Float32ModScalarSels = FloatModScalarSels[float32]

+ var Float32ModSels = FloatModSels[float32]

+ var Float32Mul = NumericMul[float32]

+ var Float32MulScalar = NumericMulScalar[float32]

+ var Float32MulScalarSels = NumericMulScalarSels[float32]

+ var Float32MulSels = NumericMulSels[float32]

+ var Float32Sub = Numeric[float32]

+ var Float32SubByScalar = NumericByScalar[float32]

+ var Float32SubByScalarSels = NumericByScalarSels[float32]

+ var Float32SubScalar = NumericScalar[float32]

+ var Float32SubScalarSels = NumericScalarSels[float32]

+ var Float32SubSels = NumericSels[float32]

+ var Float64Div = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var Float64Mod = FloatMod[float64]

+ var Float64ModByScalar = FloatModByScalar[float64]

+ var Float64ModByScalarSels = FloatModByScalarSels[float64]

+ var Float64ModScalar = FloatModScalar[float64]

+ var Float64ModScalarSels = FloatModScalarSels[float64]

+ var Float64ModSels = FloatModSels[float64]

+ var Float64Mul = NumericMul[float64]

+ var Float64MulScalar = NumericMulScalar[float64]

+ var Float64MulScalarSels = NumericMulScalarSels[float64]

+ var Float64MulSels = NumericMulSels[float64]

+ var Float64Sub = Numeric[float64]

+ var Float64SubByScalar = NumericByScalar[float64]

+ var Float64SubByScalarSels = NumericByScalarSels[float64]

+ var Float64SubScalar = NumericScalar[float64]

+ var Float64SubScalarSels = NumericScalarSels[float64]

+ var Float64SubSels = NumericSels[float64]

+ var IfBool = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfChar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfDate = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfDateTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfDecimal128 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfDecimal64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfTimestamp = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var IfVarchar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var Int16Int32Mul = NumericMul2[int16, int32]

+ var Int16Int32MulSels = NumericMulSels2[int16, int32]

+ var Int16Int32Sub = NumericBigSmall[int32, int16]

+ var Int16Int32SubSels = NumericSelsBigSmall[int32, int16]

+ var Int16Int64Mul = NumericMul2[int16, int64]

+ var Int16Int64MulSels = NumericMulSels2[int16, int64]

+ var Int16Int64Sub = NumericBigSmall[int64, int16]

+ var Int16Int64SubSels = NumericSelsBigSmall[int64, int16]

+ var Int16Mod = IntMod[int16]

+ var Int16ModByScalar = IntModByScalar[int16]

+ var Int16ModByScalarSels = IntModByScalarSels[int16]

+ var Int16ModScalar = IntModScalar[int16]

+ var Int16ModScalarSels = IntModScalarSels[int16]

+ var Int16ModSels = IntModSels[int16]

+ var Int16Mul = NumericMulInts[int16]

+ var Int16MulScalar = NumericMulScalarInts[int16]

+ var Int16MulScalarSels = NumericMulScalarSelsInts[int16]

+ var Int16MulSels = NumericMulSelsInts[int16]

+ var Int16Sub = NumericSigned[int16]

+ var Int16SubByScalar = NumericByScalarSigned[int16]

+ var Int16SubByScalarSels = NumericByScalarSelsSigned[int16]

+ var Int16SubScalar = NumericScalarSigned[int16]

+ var Int16SubScalarSels = NumericScalarSelsSigned[int16]

+ var Int16SubSels = NumericSelsSigned[int16]

+ var Int32Int64Mul = NumericMul2[int32, int64]

+ var Int32Int64MulSels = NumericMulSels2[int32, int64]

+ var Int32Int64Sub = NumericBigSmall[int64, int32]

+ var Int32Int64SubSels = NumericSelsBigSmall[int64, int32]

+ var Int32Mod = IntMod[int32]

+ var Int32ModByScalar = IntModByScalar[int32]

+ var Int32ModByScalarSels = IntModByScalarSels[int32]

+ var Int32ModScalar = IntModScalar[int32]

+ var Int32ModScalarSels = IntModScalarSels[int32]

+ var Int32ModSels = IntModSels[int32]

+ var Int32Mul = NumericMulInts[int32]

+ var Int32MulScalar = NumericMulScalarInts[int32]

+ var Int32MulScalarSels = NumericMulScalarSelsInts[int32]

+ var Int32MulSels = NumericMulSelsInts[int32]

+ var Int32Sub = NumericSigned[int32]

+ var Int32SubByScalar = NumericByScalarSigned[int32]

+ var Int32SubByScalarSels = NumericByScalarSelsSigned[int32]

+ var Int32SubScalar = NumericScalarSigned[int32]

+ var Int32SubScalarSels = NumericScalarSelsSigned[int32]

+ var Int32SubSels = NumericSelsSigned[int32]

+ var Int64Mod = IntMod[int64]

+ var Int64ModByScalar = IntModByScalar[int64]

+ var Int64ModByScalarSels = IntModByScalarSels[int64]

+ var Int64ModScalar = IntModScalar[int64]

+ var Int64ModScalarSels = IntModScalarSels[int64]

+ var Int64ModSels = IntModSels[int64]

+ var Int64Mul = NumericMulInts[int64]

+ var Int64MulScalar = NumericMulScalarInts[int64]

+ var Int64MulScalarSels = NumericMulScalarSelsInts[int64]

+ var Int64MulSels = NumericMulSelsInts[int64]

+ var Int64Sub = NumericSigned[int64]

+ var Int64SubByScalar = NumericByScalarSigned[int64]

+ var Int64SubByScalarSels = NumericByScalarSelsSigned[int64]

+ var Int64SubScalar = NumericScalarSigned[int64]

+ var Int64SubScalarSels = NumericScalarSelsSigned[int64]

+ var Int64SubSels = NumericSelsSigned[int64]

+ var Int8Int16Mul = NumericMul2[int8, int16]

+ var Int8Int16MulSels = NumericMulSels2[int8, int16]

+ var Int8Int16Sub = NumericBigSmall[int16, int8]

+ var Int8Int16SubSels = NumericSelsBigSmall[int16, int8]

+ var Int8Int32Mul = NumericMul2[int8, int32]

+ var Int8Int32MulSels = NumericMulSels2[int8, int32]

+ var Int8Int32Sub = NumericBigSmall[int32, int8]

+ var Int8Int32SubSels = NumericSelsBigSmall[int32, int8]

+ var Int8Int64Mul = NumericMul2[int8, int64]

+ var Int8Int64MulSels = NumericMulSels2[int8, int64]

+ var Int8Int64Sub = NumericBigSmall[int64, int8]

+ var Int8Int64SubSels = NumericSelsBigSmall[int64, int8]

+ var Int8Mod = IntMod[int8]

+ var Int8ModByScalar = IntModByScalar[int8]

+ var Int8ModByScalarSels = IntModByScalarSels[int8]

+ var Int8ModScalar = IntModScalar[int8]

+ var Int8ModScalarSels = IntModScalarSels[int8]

+ var Int8ModSels = IntModSels[int8]

+ var Int8Mul = NumericMulInts[int8]

+ var Int8MulScalar = NumericMulScalarInts[int8]

+ var Int8MulScalarSels = NumericMulScalarSelsInts[int8]

+ var Int8MulSels = NumericMulSelsInts[int8]

+ var Int8Sub = NumericSigned[int8]

+ var Int8SubByScalar = NumericByScalarSigned[int8]

+ var Int8SubByScalarSels = NumericByScalarSelsSigned[int8]

+ var Int8SubScalar = NumericScalarSigned[int8]

+ var Int8SubScalarSels = NumericScalarSelsSigned[int8]

+ var Int8SubSels = NumericSelsSigned[int8]

+ var MinusFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MinusUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var MultUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var PlusUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ var Uint16Mod = IntMod[uint16]

+ var Uint16ModByScalar = IntModByScalar[uint16]

+ var Uint16ModByScalarSels = IntModByScalarSels[uint16]

+ var Uint16ModScalar = IntModScalar[uint16]

+ var Uint16ModScalarSels = IntModScalarSels[uint16]

+ var Uint16ModSels = IntModSels[uint16]

+ var Uint16Mul = NumericMulInts[uint16]

+ var Uint16MulScalar = NumericMulScalarInts[uint16]

+ var Uint16MulScalarSels = NumericMulScalarSelsInts[uint16]

+ var Uint16MulSels = NumericMulSelsInts[uint16]

+ var Uint16Sub = NumericUnsigned[uint16]

+ var Uint16SubByScalar = NumericByScalarUnsigned[uint16]

+ var Uint16SubByScalarSels = NumericByScalarSelsUnsigned[uint16]

+ var Uint16SubScalar = NumericScalarUnsigned[uint16]

+ var Uint16SubScalarSels = NumericScalarSelsUnsigned[uint16]

+ var Uint16SubSels = NumericSelsUnsigned[uint16]

+ var Uint16Uint32Mul = NumericMul2[uint16, uint32]

+ var Uint16Uint32MulSels = NumericMulSels2[uint16, uint32]

+ var Uint16Uint32Sub = NumericBigSmall[uint32, uint16]

+ var Uint16Uint32SubSels = NumericSelsBigSmall[uint32, uint16]

+ var Uint16Uint64Mul = NumericMul2[uint16, uint64]

+ var Uint16Uint64MulSels = NumericMulSels2[uint16, uint64]

+ var Uint16Uint64Sub = NumericBigSmall[uint64, uint16]

+ var Uint16Uint64SubSels = NumericSelsBigSmall[uint64, uint16]

+ var Uint32Mod = IntMod[uint32]

+ var Uint32ModByScalar = IntModByScalar[uint32]

+ var Uint32ModByScalarSels = IntModByScalarSels[uint32]

+ var Uint32ModScalar = IntModScalar[uint32]

+ var Uint32ModScalarSels = IntModScalarSels[uint32]

+ var Uint32ModSels = IntModSels[uint32]

+ var Uint32Mul = NumericMulInts[uint32]

+ var Uint32MulScalar = NumericMulScalarInts[uint32]

+ var Uint32MulScalarSels = NumericMulScalarSelsInts[uint32]

+ var Uint32MulSels = NumericMulSelsInts[uint32]

+ var Uint32Sub = NumericUnsigned[uint32]

+ var Uint32SubByScalar = NumericByScalarUnsigned[uint32]

+ var Uint32SubByScalarSels = NumericByScalarSelsUnsigned[uint32]

+ var Uint32SubScalar = NumericScalarUnsigned[uint32]

+ var Uint32SubScalarSels = NumericScalarSelsUnsigned[uint32]

+ var Uint32SubSels = NumericSelsUnsigned[uint32]

+ var Uint32Uint64Mul = NumericMul2[uint32, uint64]

+ var Uint32Uint64MulSels = NumericMulSels2[uint32, uint64]

+ var Uint32Uint64Sub = NumericBigSmall[uint64, uint32]

+ var Uint32Uint64SubSels = NumericSelsBigSmall[uint64, uint32]

+ var Uint64Mod = IntMod[uint64]

+ var Uint64ModByScalar = IntModByScalar[uint64]

+ var Uint64ModByScalarSels = IntModByScalarSels[uint64]

+ var Uint64ModScalar = IntModScalar[uint64]

+ var Uint64ModScalarSels = IntModScalarSels[uint64]

+ var Uint64ModSels = IntModSels[uint64]

+ var Uint64Mul = NumericMulInts[uint64]

+ var Uint64MulScalar = NumericMulScalarInts[uint64]

+ var Uint64MulScalarSels = NumericMulScalarSelsInts[uint64]

+ var Uint64MulSels = NumericMulSelsInts[uint64]

+ var Uint64Sub = NumericUnsigned[uint64]

+ var Uint64SubByScalar = NumericByScalarUnsigned[uint64]

+ var Uint64SubByScalarSels = NumericByScalarSelsUnsigned[uint64]

+ var Uint64SubScalar = NumericScalarUnsigned[uint64]

+ var Uint64SubScalarSels = NumericScalarSelsUnsigned[uint64]

+ var Uint64SubSels = NumericSelsUnsigned[uint64]

+ var Uint8Mod = IntMod[uint8]

+ var Uint8ModByScalar = IntModByScalar[uint8]

+ var Uint8ModByScalarSels = IntModByScalarSels[uint8]

+ var Uint8ModScalar = IntModScalar[uint8]

+ var Uint8ModScalarSels = IntModScalarSels[uint8]

+ var Uint8ModSels = IntModSels[uint8]

+ var Uint8Mul = NumericMulInts[uint8]

+ var Uint8MulScalar = NumericMulScalarInts[uint8]

+ var Uint8MulScalarSels = NumericMulScalarSelsInts[uint8]

+ var Uint8MulSels = NumericMulSelsInts[uint8]

+ var Uint8Sub = NumericUnsigned[uint8]

+ var Uint8SubByScalar = NumericByScalarUnsigned[uint8]

+ var Uint8SubByScalarSels = NumericByScalarSelsUnsigned[uint8]

+ var Uint8SubScalar = NumericScalarUnsigned[uint8]

+ var Uint8SubScalarSels = NumericScalarSelsUnsigned[uint8]

+ var Uint8SubSels = NumericSelsUnsigned[uint8]

+ var Uint8Uint16Mul = NumericMul2[uint8, uint16]

+ var Uint8Uint16MulSels = NumericMulSels2[uint8, uint16]

+ var Uint8Uint16Sub = NumericBigSmall[uint16, uint8]

+ var Uint8Uint16SubSels = NumericSelsBigSmall[uint16, uint8]

+ var Uint8Uint32Mul = NumericMul2[uint8, uint32]

+ var Uint8Uint32MulSels = NumericMulSels2[uint8, uint32]

+ var Uint8Uint32Sub = NumericBigSmall[uint32, uint8]

+ var Uint8Uint32SubSels = NumericSelsBigSmall[uint32, uint8]

+ var Uint8Uint64Mul = NumericMul2[uint8, uint64]

+ var Uint8Uint64MulSels = NumericMulSels2[uint8, uint64]

+ var Uint8Uint64Sub = NumericBigSmall[uint64, uint8]

+ var Uint8Uint64SubSels = NumericSelsBigSmall[uint64, uint8]

+ func And(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Cast(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastBoolToString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDateAsDatetime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDateAsString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDateAsTimeStamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDatetimeAsDate(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDatetimeAsString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDatetimeAsTimeStamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128AsDecimal128(lv, _ *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128AsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToDecimal64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToFloat32(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToFloat64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToInt64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal128ToUint64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64AsDecimal128(lv, _ *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64AsDecimal64(lv, _ *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64AsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64ToFloat32(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64ToFloat64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64ToInt64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64ToString(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastDecimal64ToUint64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastFloat64ToInt64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastFloatAsDecimal128(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastFloatAsDecimal64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastFloatToInt(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastInt64ToUint64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastIntAsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastLeftToRight(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastNumValToBool(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSameType(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSameType2(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecialIntToDecimal(lv, _ *vector.Vector, ...) (*vector.Vector, error)

+ func CastSpecialIntToDecimal64(lv, rv *vector.Vector, ...) (*vector.Vector, error)

+ func CastSpecials1Float(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials1Int(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials1Uint(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials2Float(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials2Int(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials3(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials4(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecials4_64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastSpecialu4(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastStringAsDecimal128(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastStringAsDecimal64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastStringToBool(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastTimestampAsDate(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastUIntAsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastUint64ToInt64(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastVarcharAsDate(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastVarcharAsDatetime(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CastVarcharAsTimestamp(lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func CwTypeCheckFn(inputTypes []types.T, _ []types.T, ret types.T) bool

+ func Div(vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

+ func DivDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func DivDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func EqDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func EqDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func EqGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func EqString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func FillNullPos(vec *vector.Vector)

+ func FloatMod(xs, ys, rs []T) []T

+ func FloatModByScalar(x T, ys, rs []T) []T

+ func FloatModByScalarSels(x T, ys, rs []T, sels []int64) []T

+ func FloatModScalar(x T, ys, rs []T) []T

+ func FloatModScalarSels(x T, ys, rs []T, sels []int64) []T

+ func FloatModSels(xs, ys, rs []T, sels []int64) []T

+ func GeBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GeDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GeDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GeGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GeString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func GtString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func HandleAndNullCol(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func HandleOrNullCol(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func HandleWithNullCol(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IfTypeCheckFn(inputTypes []types.T, _ []types.T, ret types.T) bool

+ func IntMod(xs, ys, rs []T) []T

+ func IntModByScalar(x T, ys, rs []T) []T

+ func IntModByScalarSels(x T, ys, rs []T, sels []int64) []T

+ func IntModScalar(x T, ys, rs []T) []T

+ func IntModScalarSels(x T, ys, rs []T, sels []int64) []T

+ func IntModSels(xs, ys, rs []T, sels []int64) []T

+ func IntegerDiv(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Is(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsNot(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsNotNull(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsNull(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsStringNotNull(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func IsStringNull(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LeString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Like(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtBool(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func LtString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Minus(vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

+ func MinusDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MinusDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func ModFloat(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func ModInt(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Mult(vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

+ func MultDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func MultDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeDecimal128(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeDecimal64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeGeneral(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NeString(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Not(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func NotScalar(sv, nsv *vector.Vector, col1, col2 []bool, proc *process.Process) (*vector.Vector, error)

+ func NotScalarBoolGeScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func NotScalarBoolGtScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func NotScalarBoolLeScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func NotScalarBoolLtScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func NotScalarDecimal128GeScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func NotScalarDecimal128GtScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func NotScalarDecimal128LeScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func NotScalarDecimal128LtScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func NotScalarDecimal64GeScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func NotScalarDecimal64GtScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func NotScalarDecimal64LeScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func NotScalarDecimal64LtScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func NotScalarGeScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func NotScalarGtScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func NotScalarLeScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func NotScalarLtScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func NotScalarStringGeScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func NotScalarStringGtScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func NotScalarStringLeScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func NotScalarStringLtScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func Numeric(xs, ys, rs []T) []T

+ func NumericBigSmall(xs []TBig, ys []TSmall, rs []TBig) []TBig

+ func NumericByScalar(x T, ys, rs []T) []T

+ func NumericByScalarSels(x T, ys, rs []T, sels []int64) []T

+ func NumericByScalarSelsSigned(x T, ys, rs []T, sels []int64) []T

+ func NumericByScalarSelsUnsigned(x T, ys, rs []T, sels []int64) []T

+ func NumericByScalarSigned(x T, ys, rs []T) []T

+ func NumericByScalarUnsigned(x T, ys, rs []T) []T

+ func NumericMul(xs, ys, rs []T) []T

+ func NumericMul2(xs []TSmall, ys, rs []TBig) []TBig

+ func NumericMulInts(xs, ys, rs []T) []T

+ func NumericMulScalar(x T, ys, rs []T) []T

+ func NumericMulScalarInts(x T, ys, rs []T) []T

+ func NumericMulScalarSels(x T, ys, rs []T, sels []int64) []T

+ func NumericMulScalarSelsInts(x T, ys, rs []T, sels []int64) []T

+ func NumericMulSels(xs, ys, rs []T, sels []int64) []T

+ func NumericMulSels2(xs []TSmall, ys, rs []TBig, sels []int64) []TBig

+ func NumericMulSelsInts(xs, ys, rs []T, sels []int64) []T

+ func NumericScalar(x T, ys, rs []T) []T

+ func NumericScalarSels(x T, ys, rs []T, sels []int64) []T

+ func NumericScalarSelsSigned(x T, ys, rs []T, sels []int64) []T

+ func NumericScalarSelsUnsigned(x T, ys, rs []T, sels []int64) []T

+ func NumericScalarSigned(x T, ys, rs []T) []T

+ func NumericScalarUnsigned(x T, ys, rs []T) []T

+ func NumericSels(xs, ys, rs []T, sels []int64) []T

+ func NumericSelsBigSmall(xs []TBig, ys []TSmall, rs []TBig, sels []int64) []TBig

+ func NumericSelsSigned(xs, ys, rs []T, sels []int64) []T

+ func NumericSelsUnsigned(xs, ys, rs []T, sels []int64) []T

+ func NumericSigned(xs, ys, rs []T) []T

+ func NumericUnsigned(xs, ys, rs []T) []T

+ func Or(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Plus(vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

+ func PlusDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func PlusDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func ScalarAndNotScalar(sv, nsv *vector.Vector, col1, col2 []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarBoolGeNotScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarBoolGtNotScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarBoolLeNotScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarBoolLtNotScalar(sv, nsv *vector.Vector, value bool, col []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarDecimal128EqNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal128GeNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal128GtNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal128LeNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal128LtNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal128NeNotScalar(sv, nsv *vector.Vector, str types.Decimal128, col []types.Decimal128, ...) (*vector.Vector, error)

+ func ScalarDecimal64EqNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarDecimal64GeNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarDecimal64GtNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarDecimal64LeNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarDecimal64LtNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarDecimal64NeNotScalar(sv, nsv *vector.Vector, str types.Decimal64, col []types.Decimal64, ...) (*vector.Vector, error)

+ func ScalarEqNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarGeNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarGtNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarLeNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarLtNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarNeNotScalar(sv, nsv *vector.Vector, col1, col2 []T, proc *process.Process) (*vector.Vector, error)

+ func ScalarOrNotScalar(sv, nsv *vector.Vector, col1, col2 []bool, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringEqNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringGeNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringGtNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringLeNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringLtNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarStringNeNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, proc *process.Process) (*vector.Vector, error)

+ func ScalarXorNotScalar(sv, nsv *vector.Vector, col1, col2 []bool, proc *process.Process) (*vector.Vector, error)

+ func UnaryMinus(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func UnaryMinusDecimal128(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func UnaryMinusDecimal64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ func Xor(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

+ type IfRet interface

+ type NormalType interface

+ type OrderedValue interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL