operator

package
v0.5.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2022 License: Apache-2.0 Imports: 20 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	CaseWhenUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[uint8](vs, proc, types.Type{Oid: types.T_uint8})
	}

	CaseWhenUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[uint16](vs, proc, types.Type{Oid: types.T_uint16})
	}

	CaseWhenUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[uint32](vs, proc, types.Type{Oid: types.T_uint32})
	}

	CaseWhenUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[uint64](vs, proc, types.Type{Oid: types.T_uint64})
	}

	CaseWhenInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[int8](vs, proc, types.Type{Oid: types.T_int8})
	}

	CaseWhenInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[int16](vs, proc, types.Type{Oid: types.T_int16})
	}

	CaseWhenInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[int32](vs, proc, types.Type{Oid: types.T_int32})
	}

	CaseWhenInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[int64](vs, proc, types.Type{Oid: types.T_int64})
	}

	CaseWhenFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	CaseWhenFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[float64](vs, proc, types.Type{Oid: types.T_float64})
	}

	CaseWhenBool = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[bool](vs, proc, types.Type{Oid: types.T_bool})
	}

	CaseWhenDate = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[types.Date](vs, proc, types.Type{Oid: types.T_date})
	}

	CaseWhenDateTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[types.Datetime](vs, proc, types.Type{Oid: types.T_datetime})
	}

	CaseWhenVarchar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwString(vs, proc, types.Type{Oid: types.T_varchar})
	}

	CaseWhenChar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwString(vs, proc, types.Type{Oid: types.T_char})
	}

	CaseWhenDecimal64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[types.Decimal64](vs, proc, types.Type{Oid: types.T_decimal64})
	}

	CaseWhenDecimal128 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[types.Decimal128](vs, proc, types.Type{Oid: types.T_decimal128})
	}

	CaseWhenTimestamp = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return cwGeneral[types.Timestamp](vs, proc, types.Type{Oid: types.T_timestamp})
	}
)

case-when operator only support format like that 

`
	case
	when A = a1 then ...
	when A = a2 then ...
	when A = a3 then ...
	(else ...)
`

format `case A when a1 then ... when a2 then ...` should be converted to required format.

View Source 
var (
	Float32Div = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Div[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	Float64Div = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Div[float64](vs, proc, types.Type{Oid: types.T_float64})
	}
)
View Source 
var (
	IfBool = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[bool](vs, proc, types.Type{Oid: types.T_bool})
	}

	IfUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[uint8](vs, proc, types.Type{Oid: types.T_uint8})
	}

	IfUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[uint16](vs, proc, types.Type{Oid: types.T_uint16})
	}

	IfUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[uint32](vs, proc, types.Type{Oid: types.T_uint32})
	}

	IfUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[uint64](vs, proc, types.Type{Oid: types.T_uint64})
	}

	IfInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[int8](vs, proc, types.Type{Oid: types.T_int8})
	}

	IfInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[int16](vs, proc, types.Type{Oid: types.T_int16})
	}

	IfInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[int32](vs, proc, types.Type{Oid: types.T_int32})
	}

	IfInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[int64](vs, proc, types.Type{Oid: types.T_int64})
	}

	IfFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	IfFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[float64](vs, proc, types.Type{Oid: types.T_float64})
	}

	IfDecimal64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[types.Decimal64](vs, proc, types.Type{Oid: types.T_decimal64})
	}

	IfDecimal128 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[types.Decimal128](vs, proc, types.Type{Oid: types.T_decimal128})
	}

	IfDate = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[types.Date](vs, proc, types.Type{Oid: types.T_date})
	}

	IfDateTime = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[types.Datetime](vs, proc, types.Type{Oid: types.T_datetime})
	}

	IfVarchar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifForString(vs, proc, types.Type{Oid: types.T_varchar})
	}

	IfChar = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifForString(vs, proc, types.Type{Oid: types.T_char})
	}

	IfTimestamp = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return ifGeneral[types.Timestamp](vs, proc, types.Type{Oid: types.T_timestamp})
	}
)

If operator supported format like that 

If(<boolean operator>, <value operator>, <value operator>)
View Source 
var (
	MinusUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[uint8](vs, proc, types.Type{Oid: types.T_uint8})
	}

	MinusUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[uint16](vs, proc, types.Type{Oid: types.T_uint16})
	}

	MinusUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[uint32](vs, proc, types.Type{Oid: types.T_uint32})
	}

	MinusUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[uint64](vs, proc, types.Type{Oid: types.T_uint64})
	}

	MinusInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[int8](vs, proc, types.Type{Oid: types.T_int8})
	}

	MinusInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[int16](vs, proc, types.Type{Oid: types.T_int16})
	}

	MinusInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[int32](vs, proc, types.Type{Oid: types.T_int32})
	}

	MinusInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[int64](vs, proc, types.Type{Oid: types.T_int64})
	}

	MinusFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	MinusFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Minus[float64](vs, proc, types.Type{Oid: types.T_float64})
	}
)
View Source 
var (
	Int8Sub                = NumericSigned[int8]
	Int8SubScalar          = NumericScalarSigned[int8]
	Int8SubByScalar        = NumericByScalarSigned[int8]
	Int16Sub               = NumericSigned[int16]
	Int16SubScalar         = NumericScalarSigned[int16]
	Int16SubByScalar       = NumericByScalarSigned[int16]
	Int32Sub               = NumericSigned[int32]
	Int32SubScalar         = NumericScalarSigned[int32]
	Int32SubByScalar       = NumericByScalarSigned[int32]
	Int64Sub               = NumericSigned[int64]
	Int64SubScalar         = NumericScalarSigned[int64]
	Int64SubByScalar       = NumericByScalarSigned[int64]
	Uint8Sub               = NumericUnsigned[uint8]
	Uint8SubScalar         = NumericScalarUnsigned[uint8]
	Uint8SubByScalar       = NumericByScalarUnsigned[uint8]
	Uint16Sub              = NumericUnsigned[uint16]
	Uint16SubScalar        = NumericScalarUnsigned[uint16]
	Uint16SubByScalar      = NumericByScalarUnsigned[uint16]
	Uint32Sub              = NumericUnsigned[uint32]
	Uint32SubScalar        = NumericScalarUnsigned[uint32]
	Uint32SubByScalar      = NumericByScalarUnsigned[uint32]
	Uint64Sub              = NumericUnsigned[uint64]
	Uint64SubScalar        = NumericScalarUnsigned[uint64]
	Uint64SubByScalar      = NumericByScalarUnsigned[uint64]
	Float32Sub             = Numeric[float32]
	Float32SubScalar       = NumericScalar[float32]
	Float32SubByScalar     = NumericByScalar[float32]
	Float64Sub             = Numeric[float64]
	Float64SubScalar       = NumericScalar[float64]
	Float64SubByScalar     = NumericByScalar[float64]
	Int8SubSels            = NumericSelsSigned[int8]
	Int8SubScalarSels      = NumericScalarSelsSigned[int8]
	Int8SubByScalarSels    = NumericByScalarSelsSigned[int8]
	Int16SubSels           = NumericSelsSigned[int16]
	Int16SubScalarSels     = NumericScalarSelsSigned[int16]
	Int16SubByScalarSels   = NumericByScalarSelsSigned[int16]
	Int32SubSels           = NumericSelsSigned[int32]
	Int32SubScalarSels     = NumericScalarSelsSigned[int32]
	Int32SubByScalarSels   = NumericByScalarSelsSigned[int32]
	Int64SubSels           = NumericSelsSigned[int64]
	Int64SubScalarSels     = NumericScalarSelsSigned[int64]
	Int64SubByScalarSels   = NumericByScalarSelsSigned[int64]
	Uint8SubSels           = NumericSelsUnsigned[uint8]
	Uint8SubScalarSels     = NumericScalarSelsUnsigned[uint8]
	Uint8SubByScalarSels   = NumericByScalarSelsUnsigned[uint8]
	Uint16SubSels          = NumericSelsUnsigned[uint16]
	Uint16SubScalarSels    = NumericScalarSelsUnsigned[uint16]
	Uint16SubByScalarSels  = NumericByScalarSelsUnsigned[uint16]
	Uint32SubSels          = NumericSelsUnsigned[uint32]
	Uint32SubScalarSels    = NumericScalarSelsUnsigned[uint32]
	Uint32SubByScalarSels  = NumericByScalarSelsUnsigned[uint32]
	Uint64SubSels          = NumericSelsUnsigned[uint64]
	Uint64SubScalarSels    = NumericScalarSelsUnsigned[uint64]
	Uint64SubByScalarSels  = NumericByScalarSelsUnsigned[uint64]
	Float32SubSels         = NumericSels[float32]
	Float32SubScalarSels   = NumericScalarSels[float32]
	Float32SubByScalarSels = NumericByScalarSels[float32]
	Float64SubSels         = NumericSels[float64]
	Float64SubScalarSels   = NumericScalarSels[float64]
	Float64SubByScalarSels = NumericByScalarSels[float64]

	Decimal64Sub              = decimal64Sub
	Decimal64SubSels          = decimal64SubSels
	Decimal64SubScalar        = decimal64SubScalar
	Decimal64SubScalarSels    = decimal64SubScalarSels
	Decimal64SubByScalar      = decimal64SubByScalar
	Decimal64SubByScalarSels  = decimal64SubByScalarSels
	Decimal128Sub             = decimal128Sub
	Decimal128SubSels         = decimal128SubSels
	Decimal128SubScalar       = decimal128SubScalar
	Decimal128SubScalarSels   = decimal128SubScalarSels
	Decimal128SubByScalar     = decimal128SubByScalar
	Decimal128SubByScalarSels = decimal128SubByScalarSels

	Int32Int64Sub         = NumericBigSmall[int64, int32]
	Int32Int64SubSels     = NumericSelsBigSmall[int64, int32]
	Int16Int64Sub         = NumericBigSmall[int64, int16]
	Int16Int64SubSels     = NumericSelsBigSmall[int64, int16]
	Int8Int64Sub          = NumericBigSmall[int64, int8]
	Int8Int64SubSels      = NumericSelsBigSmall[int64, int8]
	Int16Int32Sub         = NumericBigSmall[int32, int16]
	Int16Int32SubSels     = NumericSelsBigSmall[int32, int16]
	Int8Int32Sub          = NumericBigSmall[int32, int8]
	Int8Int32SubSels      = NumericSelsBigSmall[int32, int8]
	Int8Int16Sub          = NumericBigSmall[int16, int8]
	Int8Int16SubSels      = NumericSelsBigSmall[int16, int8]
	Uint32Uint64Sub       = NumericBigSmall[uint64, uint32]
	Uint32Uint64SubSels   = NumericSelsBigSmall[uint64, uint32]
	Uint16Uint64Sub       = NumericBigSmall[uint64, uint16]
	Uint16Uint64SubSels   = NumericSelsBigSmall[uint64, uint16]
	Uint8Uint64Sub        = NumericBigSmall[uint64, uint8]
	Uint8Uint64SubSels    = NumericSelsBigSmall[uint64, uint8]
	Uint16Uint32Sub       = NumericBigSmall[uint32, uint16]
	Uint16Uint32SubSels   = NumericSelsBigSmall[uint32, uint16]
	Uint8Uint32Sub        = NumericBigSmall[uint32, uint8]
	Uint8Uint32SubSels    = NumericSelsBigSmall[uint32, uint8]
	Uint8Uint16Sub        = NumericBigSmall[uint16, uint8]
	Uint8Uint16SubSels    = NumericSelsBigSmall[uint16, uint8]
	Float32Float64Sub     = NumericBigSmall[float64, float32]
	Float32Float64SubSels = NumericSelsBigSmall[float64, float32]
)
View Source 
var (
	Int8Mod                = IntMod[int8]
	Int8ModSels            = IntModSels[int8]
	Int8ModScalar          = IntModScalar[int8]
	Int8ModScalarSels      = IntModScalarSels[int8]
	Int8ModByScalar        = IntModByScalar[int8]
	Int8ModByScalarSels    = IntModByScalarSels[int8]
	Int16Mod               = IntMod[int16]
	Int16ModSels           = IntModSels[int16]
	Int16ModScalar         = IntModScalar[int16]
	Int16ModScalarSels     = IntModScalarSels[int16]
	Int16ModByScalar       = IntModByScalar[int16]
	Int16ModByScalarSels   = IntModByScalarSels[int16]
	Int32Mod               = IntMod[int32]
	Int32ModSels           = IntModSels[int32]
	Int32ModScalar         = IntModScalar[int32]
	Int32ModScalarSels     = IntModScalarSels[int32]
	Int32ModByScalar       = IntModByScalar[int32]
	Int32ModByScalarSels   = IntModByScalarSels[int32]
	Int64Mod               = IntMod[int64]
	Int64ModSels           = IntModSels[int64]
	Int64ModScalar         = IntModScalar[int64]
	Int64ModScalarSels     = IntModScalarSels[int64]
	Int64ModByScalar       = IntModByScalar[int64]
	Int64ModByScalarSels   = IntModByScalarSels[int64]
	Uint8Mod               = IntMod[uint8]
	Uint8ModSels           = IntModSels[uint8]
	Uint8ModScalar         = IntModScalar[uint8]
	Uint8ModScalarSels     = IntModScalarSels[uint8]
	Uint8ModByScalar       = IntModByScalar[uint8]
	Uint8ModByScalarSels   = IntModByScalarSels[uint8]
	Uint16Mod              = IntMod[uint16]
	Uint16ModSels          = IntModSels[uint16]
	Uint16ModScalar        = IntModScalar[uint16]
	Uint16ModScalarSels    = IntModScalarSels[uint16]
	Uint16ModByScalar      = IntModByScalar[uint16]
	Uint16ModByScalarSels  = IntModByScalarSels[uint16]
	Uint32Mod              = IntMod[uint32]
	Uint32ModSels          = IntModSels[uint32]
	Uint32ModScalar        = IntModScalar[uint32]
	Uint32ModScalarSels    = IntModScalarSels[uint32]
	Uint32ModByScalar      = IntModByScalar[uint32]
	Uint32ModByScalarSels  = IntModByScalarSels[uint32]
	Uint64Mod              = IntMod[uint64]
	Uint64ModSels          = IntModSels[uint64]
	Uint64ModScalar        = IntModScalar[uint64]
	Uint64ModScalarSels    = IntModScalarSels[uint64]
	Uint64ModByScalar      = IntModByScalar[uint64]
	Uint64ModByScalarSels  = IntModByScalarSels[uint64]
	Float32Mod             = FloatMod[float32]
	Float32ModSels         = FloatModSels[float32]
	Float32ModScalar       = FloatModScalar[float32]
	Float32ModScalarSels   = FloatModScalarSels[float32]
	Float32ModByScalar     = FloatModByScalar[float32]
	Float32ModByScalarSels = FloatModByScalarSels[float32]
	Float64Mod             = FloatMod[float64]
	Float64ModSels         = FloatModSels[float64]
	Float64ModScalar       = FloatModScalar[float64]
	Float64ModScalarSels   = FloatModScalarSels[float64]
	Float64ModByScalar     = FloatModByScalar[float64]
	Float64ModByScalarSels = FloatModByScalarSels[float64]
)
View Source 
var (
	MultUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[uint8](vs, proc, types.Type{Oid: types.T_uint8})
	}

	MultUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[uint16](vs, proc, types.Type{Oid: types.T_uint16})
	}

	MultUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[uint32](vs, proc, types.Type{Oid: types.T_uint32})
	}

	MultUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[uint64](vs, proc, types.Type{Oid: types.T_uint64})
	}

	MultInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[int8](vs, proc, types.Type{Oid: types.T_int8})
	}

	MultInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[int16](vs, proc, types.Type{Oid: types.T_int16})
	}

	MultInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[int32](vs, proc, types.Type{Oid: types.T_int32})
	}

	MultInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[int64](vs, proc, types.Type{Oid: types.T_int64})
	}

	MultFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	MultFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Mult[float64](vs, proc, types.Type{Oid: types.T_float64})
	}
)
View Source 
var (
	Int8Mul              = NumericMulInts[int8]
	Int8MulSels          = NumericMulSelsInts[int8]
	Int8MulScalar        = NumericMulScalarInts[int8]
	Int8MulScalarSels    = NumericMulScalarSelsInts[int8]
	Int16Mul             = NumericMulInts[int16]
	Int16MulSels         = NumericMulSelsInts[int16]
	Int16MulScalar       = NumericMulScalarInts[int16]
	Int16MulScalarSels   = NumericMulScalarSelsInts[int16]
	Int32Mul             = NumericMulInts[int32]
	Int32MulSels         = NumericMulSelsInts[int32]
	Int32MulScalar       = NumericMulScalarInts[int32]
	Int32MulScalarSels   = NumericMulScalarSelsInts[int32]
	Int64Mul             = NumericMulInts[int64]
	Int64MulSels         = NumericMulSelsInts[int64]
	Int64MulScalar       = NumericMulScalarInts[int64]
	Int64MulScalarSels   = NumericMulScalarSelsInts[int64]
	Uint8Mul             = NumericMulInts[uint8]
	Uint8MulSels         = NumericMulSelsInts[uint8]
	Uint8MulScalar       = NumericMulScalarInts[uint8]
	Uint8MulScalarSels   = NumericMulScalarSelsInts[uint8]
	Uint16Mul            = NumericMulInts[uint16]
	Uint16MulSels        = NumericMulSelsInts[uint16]
	Uint16MulScalar      = NumericMulScalarInts[uint16]
	Uint16MulScalarSels  = NumericMulScalarSelsInts[uint16]
	Uint32Mul            = NumericMulInts[uint32]
	Uint32MulSels        = NumericMulSelsInts[uint32]
	Uint32MulScalar      = NumericMulScalarInts[uint32]
	Uint32MulScalarSels  = NumericMulScalarSelsInts[uint32]
	Uint64Mul            = NumericMulInts[uint64]
	Uint64MulSels        = NumericMulSelsInts[uint64]
	Uint64MulScalar      = NumericMulScalarInts[uint64]
	Uint64MulScalarSels  = NumericMulScalarSelsInts[uint64]
	Float32Mul           = NumericMul[float32]
	Float32MulSels       = NumericMulSels[float32]
	Float32MulScalar     = NumericMulScalar[float32]
	Float32MulScalarSels = NumericMulScalarSels[float32]
	Float64Mul           = NumericMul[float64]
	Float64MulSels       = NumericMulSels[float64]
	Float64MulScalar     = NumericMulScalar[float64]
	Float64MulScalarSels = NumericMulScalarSels[float64]

	Int32Int64Mul         = NumericMul2[int32, int64]
	Int32Int64MulSels     = NumericMulSels2[int32, int64]
	Int16Int64Mul         = NumericMul2[int16, int64]
	Int16Int64MulSels     = NumericMulSels2[int16, int64]
	Int8Int64Mul          = NumericMul2[int8, int64]
	Int8Int64MulSels      = NumericMulSels2[int8, int64]
	Int16Int32Mul         = NumericMul2[int16, int32]
	Int16Int32MulSels     = NumericMulSels2[int16, int32]
	Int8Int32Mul          = NumericMul2[int8, int32]
	Int8Int32MulSels      = NumericMulSels2[int8, int32]
	Int8Int16Mul          = NumericMul2[int8, int16]
	Int8Int16MulSels      = NumericMulSels2[int8, int16]
	Float32Float64Mul     = NumericMul2[float32, float64]
	Float32Float64MulSels = NumericMulSels2[float32, float64]
	Uint32Uint64Mul       = NumericMul2[uint32, uint64]
	Uint32Uint64MulSels   = NumericMulSels2[uint32, uint64]
	Uint16Uint64Mul       = NumericMul2[uint16, uint64]
	Uint16Uint64MulSels   = NumericMulSels2[uint16, uint64]
	Uint8Uint64Mul        = NumericMul2[uint8, uint64]
	Uint8Uint64MulSels    = NumericMulSels2[uint8, uint64]
	Uint16Uint32Mul       = NumericMul2[uint16, uint32]
	Uint16Uint32MulSels   = NumericMulSels2[uint16, uint32]
	Uint8Uint32Mul        = NumericMul2[uint8, uint32]
	Uint8Uint32MulSels    = NumericMulSels2[uint8, uint32]
	Uint8Uint16Mul        = NumericMul2[uint8, uint16]
	Uint8Uint16MulSels    = NumericMulSels2[uint8, uint16]

	Decimal64Mul            = decimal64Mul
	Decimal64MulSels        = decimal64MulSels
	Decimal64MulScalar      = decimal64MulScalar
	Decimal64MulScalarSels  = decimal64MulScalarSels
	Decimal128Mul           = decimal128Mul
	Decimal128MulSels       = decimal128MulSels
	Decimal128MulScalar     = decimal128MulScalar
	Decimal128MulScalarSels = decimal128MulScalarSels
)
View Source 
var (
	PlusUint8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[uint8](vs, proc, types.Type{Oid: types.T_uint8})
	}

	PlusUint16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[uint16](vs, proc, types.Type{Oid: types.T_uint16})
	}

	PlusUint32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[uint32](vs, proc, types.Type{Oid: types.T_uint32})
	}

	PlusUint64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[uint64](vs, proc, types.Type{Oid: types.T_uint64})
	}

	PlusInt8 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[int8](vs, proc, types.Type{Oid: types.T_int8})
	}

	PlusInt16 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[int16](vs, proc, types.Type{Oid: types.T_int16})
	}

	PlusInt32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[int32](vs, proc, types.Type{Oid: types.T_int32})
	}

	PlusInt64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[int64](vs, proc, types.Type{Oid: types.T_int64})
	}

	PlusFloat32 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[float32](vs, proc, types.Type{Oid: types.T_float32})
	}

	PlusFloat64 = func(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
		return Plus[float64](vs, proc, types.Type{Oid: types.T_float64})
	}
)
View Source 
var ErrDivByZero = errors.New(errno.SyntaxErrororAccessRuleViolation, "division by zero")

ErrDivByZero is reported on a division by zero.

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

ErrModByZero is reported when computing the rest of a division by zero.

Functions

func And 

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

func Cast 

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

func CastBoolToString 

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

func CastDateAsDatetime 

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

func CastDateAsString 

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

func CastDateAsTimeStamp 

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

CastDateAsTimeStamp : Cast converts date to timestamp

func CastDatetimeAsDate 

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

CastDatetimeAsDate : convert datetime to date DateTime : high 44 bits stands for the seconds passed by, low 20 bits stands for the microseconds passed by

func CastDatetimeAsString 

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

func CastDatetimeAsTimeStamp 

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

CastDatetimeAsTimeStamp : Cast converts datetime to timestamp

func CastDecimal128AsDecimal128 

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

CastDecimal128AsDecimal128 : Cast converts decimal128 to timestamp decimal128

func CastDecimal128AsTimestamp 

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

func CastDecimal128ToDecimal64 

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

this cast function is too slow, and therefore only temporary, rewrite needed

func CastDecimal128ToFloat32 

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

func CastDecimal128ToFloat64 

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

func CastDecimal128ToInt64 

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

func CastDecimal128ToString 

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

func CastDecimal128ToUint64 

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

func CastDecimal64AsDecimal128 

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

CastDecimal64AsDecimal128 : Cast converts decimal64 to timestamp decimal128

func CastDecimal64AsDecimal64 

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

CastDecimal64AsDecimal64 : Cast converts decimal64 to timestamp decimal64

func CastDecimal64AsTimestamp 

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

func CastDecimal64ToFloat32 

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

func CastDecimal64ToFloat64 

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

func CastDecimal64ToInt64 

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

func CastDecimal64ToString 

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

func CastDecimal64ToUint64 

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

func CastFloat64ToInt64 

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

CastFloat64ToInt64 : cast float64 to int64

func CastFloatAsDecimal128 

func CastFloatAsDecimal128[T constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastFloatAsDecimal64 

func CastFloatAsDecimal64[T constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastFloatToInt 

func CastFloatToInt[T1 constraints.Float, T2 constraints.Integer](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastInt64ToUint64 

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

CastInt64ToUint64 : cast int64 to uint64

func CastIntAsTimestamp 

func CastIntAsTimestamp[T constraints.Signed](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastLeftToRight 

func CastLeftToRight[T1, T2 constraints.Integer | constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastLeftToRight : Cast handles conversions in the form of cast (left as right), where left and right are different types, 

and both left and right are numeric types, Contains the following:

int8 -> (int16/int32/int64/uint8/uint16/uint32/uint64/float32/float64) int16 -> (int8/int32/int64/uint8/uint16/uint32/uint64/float32/float64) int32 -> (int8/int16/int64/uint8/uint16/uint32/uint64/float32/float64) int64 -> (int8/int16/int32/uint8/uint16/uint32/uint64/float32/float64) uint8 -> (int8/int16/int32/int64/uint16/uint32/uint64/float32/float64) uint16 -> (int8/int16/int32/int64/uint8/uint32/uint64/float32/float64) uint32 -> (int8/int16/int32/int64/uint8/uint16/uint64/float32/float64) uint64 -> (int8/int16/int32/int64/uint8/uint16/uint32/float32/float64)

func CastNumValToBool 

func CastNumValToBool[T constraints.Integer | constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastSameType 

func CastSameType[T constraints.Integer | constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSameType : Cast handles the same data type and is numeric , Contains the following: int8 -> int8, int16 -> int16, int32 -> int32, int64 -> int64, uint8 -> uint8, uint16 -> uint16, uint32 -> uint32, uint64 -> uint64, float32 -> float32, float64 -> float64,

func CastSameType2 

func CastSameType2[T types.Date | types.Datetime | types.Timestamp](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSameType2 : Cast handles the same data type and is date series , Contains the following: date -> date datetime -> datetime timestamp -> timestamp

func CastSpecialIntToDecimal 

func CastSpecialIntToDecimal[T constraints.Integer](
	lv, _ *vector.Vector,
	i2d func(xs []T, rs []types.Decimal128) ([]types.Decimal128, error),
	proc *process.Process) (*vector.Vector, error)

func CastSpecialIntToDecimal64 

func CastSpecialIntToDecimal64[T constraints.Integer](
	lv, rv *vector.Vector,
	i2d func(xs []T, rs []types.Decimal64, scale int64) ([]types.Decimal64, error),
	proc *process.Process) (*vector.Vector, error)

func CastSpecials1Float 

func CastSpecials1Float[T constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecials1Float : Cast converts string to floating point number,Contains the following: (char / varhcar) -> (float32 / float64)

func CastSpecials1Int 

func CastSpecials1Int[T constraints.Signed](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecials1Int : Cast converts string to integer,Contains the following: (char / varhcar) -> (int8 / int16 / int32/ int64 / uint8 / uint16 / uint32 / uint64)

func CastSpecials1Uint 

func CastSpecials1Uint[T constraints.Unsigned](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastSpecials2Float 

func CastSpecials2Float[T constraints.Float](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecials2Float : Cast converts floating point number to string ,Contains the following: (float32/float64) -> (char / varhcar)

func CastSpecials2Int 

func CastSpecials2Int[T constraints.Integer](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecials2Int : Cast converts integer to string,Contains the following: (int8 /int16/int32/int64/uint8/uint16/uint32/uint64) -> (char / varhcar)

func CastSpecials3 

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

CastSpecials3 : Cast converts string to string ,Contains the following: char -> char char -> varhcar varchar -> char varchar -> varhcar

func CastSpecials4 

func CastSpecials4[T constraints.Signed](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecials4 : Cast converts signed integer to decimal128 ,Contains the following: (int8/int16/int32/int64) to decimal128

func CastSpecials4_64 

func CastSpecials4_64[T constraints.Signed](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastSpecialu4 

func CastSpecialu4[T constraints.Unsigned](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

CastSpecialu4 : Cast converts unsigned integer to decimal128 ,Contains the following: (uint8/uint16/uint32/uint64) to decimal128

func CastStringAsDecimal128 

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

CastStringAsDecimal128 : onverts char/varchar as decimal128

func CastStringAsDecimal64 

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

CastStringAsDecimal64 : onverts char/varchar as decimal64

func CastStringToBool 

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

func CastTimestampAsDate 

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

func CastUIntAsTimestamp 

func CastUIntAsTimestamp[T constraints.Unsigned](lv, rv *vector.Vector, proc *process.Process) (*vector.Vector, error)

func CastUint64ToInt64 

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

CastUint64ToInt64 : cast uint64 to int64

func CastVarcharAsDate 

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

CastVarcharAsDate : Cast converts varchar to date type

func CastVarcharAsDatetime 

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

CastVarcharAsDatetime : Cast converts varchar to datetime type

func CastVarcharAsTimestamp 

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

CastVarcharAsTimestamp : Cast converts varchar to timestamp type

func CompareBoolEq added in v0.5.1 

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

func CompareBoolGe added in v0.5.1 

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

func CompareBoolGt added in v0.5.1 

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

func CompareBoolLe added in v0.5.1 

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

func CompareBoolLt added in v0.5.1 

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

func CompareBoolNe added in v0.5.1 

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

func CompareBytesEq added in v0.5.1 

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

func CompareBytesGe added in v0.5.1 

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

func CompareBytesGt added in v0.5.1 

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

func CompareBytesLe added in v0.5.1 

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

func CompareBytesLt added in v0.5.1 

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

func CompareBytesNe added in v0.5.1 

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

func CompareDecimal128Eq added in v0.5.1 

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

func CompareDecimal128Ge added in v0.5.1 

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

func CompareDecimal128Gt added in v0.5.1 

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

func CompareDecimal128Le added in v0.5.1 

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

func CompareDecimal128Lt added in v0.5.1 

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

func CompareDecimal128Ne added in v0.5.1 

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

func CompareDecimal64Eq added in v0.5.1 

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

func CompareDecimal64Ge added in v0.5.1 

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

func CompareDecimal64Gt added in v0.5.1 

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

func CompareDecimal64Le added in v0.5.1 

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

func CompareDecimal64Lt added in v0.5.1 

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

func CompareDecimal64Ne added in v0.5.1 

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

func CompareOrdered added in v0.5.1 

func CompareOrdered[T constraints.Integer | constraints.Float, C CompOp[T]](c C, vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func CompareString added in v0.5.1 

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

func CompareWithFn added in v0.5.1 

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

func CwTypeCheckFn 

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

CwTypeCheckFn is type check function for case-when operator

func Div 

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

func DivDecimal128 

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

func DivDecimal64 

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

func EqBool added in v0.5.1 

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

func EqDecimal128 

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

func EqDecimal64 

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

func EqGeneral 

func EqGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func EqString 

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

func FloatMod 

func FloatMod[T constraints.Float](xs, ys, rs []T) []T

func FloatModByScalar 

func FloatModByScalar[T constraints.Float](x T, ys, rs []T) []T

func FloatModByScalarSels 

func FloatModByScalarSels[T constraints.Float](x T, ys, rs []T, sels []int64) []T

func FloatModScalar 

func FloatModScalar[T constraints.Float](x T, ys, rs []T) []T

func FloatModScalarSels 

func FloatModScalarSels[T constraints.Float](x T, ys, rs []T, sels []int64) []T

func FloatModSels 

func FloatModSels[T constraints.Float](xs, ys, rs []T, sels []int64) []T

func GeBool 

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

func GeDecimal128 

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

func GeDecimal64 

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

func GeGeneral 

func GeGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func GeString 

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

func GtBool 

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

func GtDecimal128 

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

func GtDecimal64 

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

func GtGeneral 

func GtGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func GtString 

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

func HandleAndNullCol 

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

func HandleOrNullCol 

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

func IfTypeCheckFn 

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

func IntMod 

func IntMod[T constraints.Integer](xs, ys, rs []T) []T

func IntModByScalar 

func IntModByScalar[T constraints.Integer](x T, ys, rs []T) []T

func IntModByScalarSels 

func IntModByScalarSels[T constraints.Integer](x T, ys, rs []T, sels []int64) []T

func IntModScalar 

func IntModScalar[T constraints.Integer](x T, ys, rs []T) []T

func IntModScalarSels 

func IntModScalarSels[T constraints.Integer](x T, ys, rs []T, sels []int64) []T

func IntModSels 

func IntModSels[T constraints.Integer](xs, ys, rs []T, sels []int64) []T

func IntegerDiv 

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

func Is 

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

func IsNot 

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

func IsNotNull 

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

func IsNull 

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

func IsStringNotNull 

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

func IsStringNull 

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

func LeBool 

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

func LeDecimal128 

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

func LeDecimal64 

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

func LeGeneral 

func LeGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func LeString 

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

func Like 

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

func LtBool 

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

func LtDecimal128 

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

func LtDecimal64 

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

func LtGeneral 

func LtGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func LtString 

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

func Minus 

func Minus[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

func MinusDecimal128 

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

func MinusDecimal64 

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

Since the underlying operator does not generically process decimal64 and decimal128, sub of decimal64 and decimal128 are not generalized

func ModFloat 

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

func ModInt 

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

func Mult 

func Mult[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

func MultDecimal128 

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

LeftType: types.T_decimal128, RightType: types.T_decimal128, ReturnType: types.T_decimal128,

func MultDecimal64 

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

LeftType: types.T_decimal64, RightType: types.T_decimal64, ReturnType: types.T_decimal128,

func NeBool added in v0.5.1 

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

func NeDecimal128 

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

func NeDecimal64 

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

func NeGeneral 

func NeGeneral[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func NeString 

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

func Not 

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

func NotScalar 

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

func Numeric 

func Numeric[T constraints.Integer | constraints.Float](xs, ys, rs []T) []T

func NumericBigSmall 

func NumericBigSmall[TBig, TSmall constraints.Integer | constraints.Float](xs []TBig, ys []TSmall, rs []TBig) []TBig

func NumericByScalar 

func NumericByScalar[T constraints.Integer | constraints.Float](x T, ys, rs []T) []T

func NumericByScalarSels 

func NumericByScalarSels[T constraints.Integer | constraints.Float](x T, ys, rs []T, sels []int64) []T

func NumericByScalarSelsSigned 

func NumericByScalarSelsSigned[T constraints.Signed](x T, ys, rs []T, sels []int64) []T

func NumericByScalarSelsUnsigned 

func NumericByScalarSelsUnsigned[T constraints.Unsigned](x T, ys, rs []T, sels []int64) []T

func NumericByScalarSigned 

func NumericByScalarSigned[T constraints.Signed](x T, ys, rs []T) []T

func NumericByScalarUnsigned 

func NumericByScalarUnsigned[T constraints.Unsigned](x T, ys, rs []T) []T

func NumericMul 

func NumericMul[T constraints.Integer | constraints.Float](xs, ys, rs []T) []T

func NumericMul2 

func NumericMul2[TSmall, TBig constraints.Integer | constraints.Float](xs []TSmall, ys, rs []TBig) []TBig

func NumericMulInts 

func NumericMulInts[T constraints.Integer](xs, ys, rs []T) []T

the slowest overflow check

func NumericMulScalar 

func NumericMulScalar[T constraints.Integer | constraints.Float](x T, ys, rs []T) []T

func NumericMulScalarInts 

func NumericMulScalarInts[T constraints.Integer](x T, ys, rs []T) []T

func NumericMulScalarSels 

func NumericMulScalarSels[T constraints.Integer | constraints.Float](x T, ys, rs []T, sels []int64) []T

func NumericMulScalarSelsInts 

func NumericMulScalarSelsInts[T constraints.Integer](x T, ys, rs []T, sels []int64) []T

func NumericMulSels 

func NumericMulSels[T constraints.Integer | constraints.Float](xs, ys, rs []T, sels []int64) []T

func NumericMulSels2 

func NumericMulSels2[TSmall, TBig constraints.Integer | constraints.Float](xs []TSmall, ys, rs []TBig, sels []int64) []TBig

func NumericMulSelsInts 

func NumericMulSelsInts[T constraints.Integer](xs, ys, rs []T, sels []int64) []T

func NumericScalar 

func NumericScalar[T constraints.Integer | constraints.Float](x T, ys, rs []T) []T

func NumericScalarSels 

func NumericScalarSels[T constraints.Integer | constraints.Float](x T, ys, rs []T, sels []int64) []T

func NumericScalarSelsSigned 

func NumericScalarSelsSigned[T constraints.Signed](x T, ys, rs []T, sels []int64) []T

func NumericScalarSelsUnsigned 

func NumericScalarSelsUnsigned[T constraints.Unsigned](x T, ys, rs []T, sels []int64) []T

func NumericScalarSigned 

func NumericScalarSigned[T constraints.Signed](x T, ys, rs []T) []T

func NumericScalarUnsigned 

func NumericScalarUnsigned[T constraints.Unsigned](x T, ys, rs []T) []T

func NumericSels 

func NumericSels[T constraints.Integer | constraints.Float](xs, ys, rs []T, sels []int64) []T

func NumericSelsBigSmall 

func NumericSelsBigSmall[TBig, TSmall constraints.Integer | constraints.Float](xs []TBig, ys []TSmall, rs []TBig, sels []int64) []TBig

func NumericSelsSigned 

func NumericSelsSigned[T constraints.Signed](xs, ys, rs []T, sels []int64) []T

func NumericSelsUnsigned 

func NumericSelsUnsigned[T constraints.Unsigned](xs, ys, rs []T, sels []int64) []T

func NumericSigned 

func NumericSigned[T constraints.Signed](xs, ys, rs []T) []T

func NumericUnsigned 

func NumericUnsigned[T constraints.Unsigned](xs, ys, rs []T) []T

func Or 

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

func Plus 

func Plus[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process, typ types.Type) (*vector.Vector, error)

func PlusDecimal128 

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

LeftType: types.T_decimal128, RightType: types.T_decimal128, ReturnType: types.T_decimal128,

func PlusDecimal64 

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

LeftType: types.T_decimal64, RightType: types.T_decimal64, ReturnType: types.T_decimal64,

func ScalarAndNotScalar 

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

func ScalarOrNotScalar 

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

func ScalarXorNotScalar 

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

func UnaryMinus 

func UnaryMinus[T constraints.Signed | constraints.Float](vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func UnaryMinusDecimal128 

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

func UnaryMinusDecimal64 

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

func Xor 

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

Types

type CompEq added in v0.5.1 

type CompEq[T constraints.Integer | constraints.Float] struct{}

func (CompEq[T]) Eval added in v0.5.1 

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

type CompGe added in v0.5.1 

type CompGe[T constraints.Integer | constraints.Float] struct{}

func (CompGe[T]) Eval added in v0.5.1 

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

type CompGt added in v0.5.1 

type CompGt[T constraints.Integer | constraints.Float] struct{}

func (CompGt[T]) Eval added in v0.5.1 

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

type CompLe added in v0.5.1 

type CompLe[T constraints.Integer | constraints.Float] struct{}

func (CompLe[T]) Eval added in v0.5.1 

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

type CompLt added in v0.5.1 

type CompLt[T constraints.Integer | constraints.Float] struct{}

func (CompLt[T]) Eval added in v0.5.1 

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

type CompNe added in v0.5.1 

type CompNe[T constraints.Integer | constraints.Float] struct{}

func (CompNe[T]) Eval added in v0.5.1 

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

type CompOp added in v0.5.1 

type CompOp[T constraints.Integer | constraints.Float] interface {
	CompEq[T] | CompGe[T] | CompGt[T] | CompLe[T] | CompLt[T] | CompNe[T]
	Eval(a, b T) bool
}

type IfRet 

type IfRet interface {
	constraints.Integer | constraints.Float | bool | types.Date | types.Datetime |
		types.Decimal64 | types.Decimal128 | types.Timestamp
}

type NormalType 

type NormalType interface {
	constraints.Integer | constraints.Float | bool | types.Date | types.Datetime |
		types.Decimal64 | types.Decimal128 | types.Timestamp
}

type OrderedValue 

type OrderedValue interface {
	constraints.Integer | constraints.Float | types.Date | types.Datetime | types.Decimal64 | types.Timestamp
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.