operator

package
v0.5.0 Latest Latest
Warning

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

 Go to latest Published: Jul 14, 2022 License: Apache-2.0 Imports: 21 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 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 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 NormalType](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error)

func EqString 

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

func FillNullPos 

func FillNullPos(vec *vector.Vector)

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 OrderedValue](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 OrderedValue](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 HandleWithNullCol 

func HandleWithNullCol(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 OrderedValue](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 OrderedValue](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 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 NormalType](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 NotScalarBoolGeScalar 

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

func NotScalarBoolGtScalar 

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

func NotScalarBoolLeScalar 

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

func NotScalarBoolLtScalar 

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

func NotScalarDecimal128GeScalar 

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

func NotScalarDecimal128GtScalar 

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

func NotScalarDecimal128LeScalar 

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

func NotScalarDecimal128LtScalar 

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

func NotScalarDecimal64GeScalar 

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

func NotScalarDecimal64GtScalar 

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

func NotScalarDecimal64LeScalar 

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

func NotScalarDecimal64LtScalar 

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

func NotScalarGeScalar 

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

func NotScalarGtScalar 

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

func NotScalarLeScalar 

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

func NotScalarLtScalar 

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

func NotScalarStringGeScalar 

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

func NotScalarStringGtScalar 

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

func NotScalarStringLeScalar 

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

func NotScalarStringLtScalar 

func NotScalarStringLtScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, 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 ScalarBoolGeNotScalar 

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

func ScalarBoolGtNotScalar 

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

func ScalarBoolLeNotScalar 

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

func ScalarBoolLtNotScalar 

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

func ScalarDecimal128EqNotScalar 

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

func ScalarDecimal128GeNotScalar 

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

func ScalarDecimal128GtNotScalar 

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

func ScalarDecimal128LeNotScalar 

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

func ScalarDecimal128LtNotScalar 

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

func ScalarDecimal128NeNotScalar 

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

func ScalarDecimal64EqNotScalar 

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

func ScalarDecimal64GeNotScalar 

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

func ScalarDecimal64GtNotScalar 

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

func ScalarDecimal64LeNotScalar 

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

func ScalarDecimal64LtNotScalar 

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

func ScalarDecimal64NeNotScalar 

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

func ScalarEqNotScalar 

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

func ScalarGeNotScalar 

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

func ScalarGtNotScalar 

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

func ScalarLeNotScalar 

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

func ScalarLtNotScalar 

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

func ScalarNeNotScalar 

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

func ScalarOrNotScalar 

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

func ScalarStringEqNotScalar 

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

func ScalarStringGeNotScalar 

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

func ScalarStringGtNotScalar 

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

func ScalarStringLeNotScalar 

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

func ScalarStringLtNotScalar 

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

func ScalarStringNeNotScalar 

func ScalarStringNeNotScalar(sv, nsv *vector.Vector, str []byte, col *types.Bytes, 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 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.