Skip to content
Snippets Groups Projects
Unverified Commit 974e574a authored by broccoliSpicy's avatar broccoliSpicy Committed by GitHub
Browse files

Fix panic interface conversion (#2872)

parent 666bf7be
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 205 additions and 185 deletions
pkg/sql/plan2/function/builtin/binary/endswith.go
+ 4
− 1
View file @ 974e574a
......@@ -25,7 +25,6 @@ import (
func Endswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
left, right := vectors[0], vectors[1]
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_uint8, Size: 1}
resultElementSize := int(resultType.Size)
switch {
......@@ -33,6 +32,7 @@ func Endswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if left.ConstVectorIsNull() || right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint8, 1)
vector.SetCol(resultVector, endswith.EndsWithAllConst(leftValues, rightValues, resultValues))
......@@ -41,6 +41,7 @@ func Endswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if left.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......@@ -54,6 +55,7 @@ func Endswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(leftValues.Lengths)))
if err != nil {
return nil, err
......@@ -64,6 +66,7 @@ func Endswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
vector.SetCol(resultVector, endswith.EndsWithRightConst(leftValues, rightValues, resultValues))
return resultVector, nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/binary/findinset.go
+ 4
− 1
View file @ 974e574a
......@@ -25,7 +25,6 @@ import (
func FindInSet(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
left, right := vectors[0], vectors[1]
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_uint64, Size: 8}
resultElementSize := int(resultType.Size)
switch {
......@@ -33,6 +32,7 @@ func FindInSet(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if left.ConstVectorIsNull() || right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint64, 1)
vector.SetCol(resultVector, findinset.FindInSetWithAllConst(leftValues, rightValues, resultValues))
......@@ -41,6 +41,7 @@ func FindInSet(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if left.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......@@ -54,6 +55,7 @@ func FindInSet(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
if right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(leftValues.Lengths)))
if err != nil {
return nil, err
......@@ -64,6 +66,7 @@ func FindInSet(vectors []*vector.Vector, proc *process.Process) (*vector.Vector,
vector.SetCol(resultVector, findinset.FindInSetWithRightConst(leftValues, rightValues, resultValues))
return resultVector, nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/binary/power.go
+ 11
− 12
View file @ 974e574a
......@@ -26,25 +26,22 @@ import (
func Power(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
left, right := vectors[0], vectors[1]
resultType := types.Type{Oid: types.T_float64, Size: 8}
if left.IsScalarNull() || right.IsScalarNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.([]float64), right.Col.([]float64)
resultElementSize := int(resultType.Size)
switch {
case left.IsConst && right.IsConst:
//if left.ConstVectorIsNull() || right.ConstVectorIsNull() {
// return proc.AllocScalarNullVector(resultType), nil
//}
case left.IsScalar() && right.IsScalar():
if left.ConstVectorIsNull() || right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.([]float64), right.Col.([]float64)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
vector.SetCol(resultVector, power.Power(leftValues, rightValues, resultValues)) // if our input contains null, this step may be redundant,
vector.SetCol(resultVector, power.Power(leftValues, rightValues, resultValues))
return resultVector, nil
case left.IsConst && !right.IsConst:
case left.IsScalar() && !right.IsScalar():
if left.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.([]float64), right.Col.([]float64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues)))
if err != nil {
return nil, err
......@@ -54,10 +51,11 @@ func Power(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, err
nulls.Set(resultVector.Nsp, right.Nsp)
vector.SetCol(resultVector, power.PowerScalarLeftConst(leftValues[0], rightValues, resultValues))
return resultVector, nil
case !left.IsConst && right.IsConst:
case !left.IsScalar() && right.IsScalar():
if right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.([]float64), right.Col.([]float64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(leftValues)))
if err != nil {
return nil, err
......@@ -68,6 +66,7 @@ func Power(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, err
vector.SetCol(resultVector, power.PowerScalarRightConst(rightValues[0], leftValues, resultValues))
return resultVector, nil
}
leftValues, rightValues := left.Col.([]float64), right.Col.([]float64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/binary/startswith.go
+ 4
− 1
View file @ 974e574a
......@@ -25,7 +25,6 @@ import (
func Startswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
left, right := vectors[0], vectors[1]
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_uint8, Size: 1}
resultElementSize := int(resultType.Size)
switch {
......@@ -33,6 +32,7 @@ func Startswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector
if left.ConstVectorIsNull() || right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint8, 1)
vector.SetCol(resultVector, startswith.StartsWithAllConst(leftValues, rightValues, resultValues))
......@@ -41,6 +41,7 @@ func Startswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector
if left.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......@@ -54,6 +55,7 @@ func Startswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector
if right.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(leftValues.Lengths)))
if err != nil {
return nil, err
......@@ -64,6 +66,7 @@ func Startswith(vectors []*vector.Vector, proc *process.Process) (*vector.Vector
vector.SetCol(resultVector, startswith.StartsWithRightConst(leftValues, rightValues, resultValues))
return resultVector, nil
}
leftValues, rightValues := left.Col.(*types.Bytes), right.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(rightValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/multi/ceil.go
+ 1
− 2
View file @ 974e574a
......@@ -112,7 +112,7 @@ func CeilFloat64(vecs []*vector.Vector, proc *process.Process) (*vector.Vector,
}
if vecs[0].IsScalar() {
vec := proc.AllocScalarVector(types.Type{Oid: types.T_int64, Size: 8})
vec := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
rs := make([]float64, 1)
nulls.Set(vec.Nsp, vecs[0].Nsp)
vector.SetCol(vec, ceil.CeilFloat64(vs, rs, digits))
......@@ -129,5 +129,4 @@ func CeilFloat64(vecs []*vector.Vector, proc *process.Process) (*vector.Vector,
vector.SetCol(vec, ceil.CeilFloat64(vs, rs, digits))
return vec, nil
}
}
pkg/sql/plan2/function/builtin/unary/abs.go
+ 54
− 55
View file @ 974e574a
......@@ -24,86 +24,85 @@ import (
)
// abs function's evaluation for arguments: [uint64]
func AbsUInt64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]uint64)
if origVec.IsScalar() {
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_uint64, Size: 8}), nil
} else {
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_uint64, Size: 8})
resultValues := make([]uint64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsUint64(origVecCol, resultValues))
//resultVector.Length = origVec.Length
return resultVector, nil
func AbsUInt64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_uint64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]uint64)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint64, 1)
vector.SetCol(resultVector, abs.AbsUint64(inputValues, resultValues))
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_uint64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]uint64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeUint64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsUint64(origVecCol, results))
resultValues := encoding.DecodeUint64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
nulls.Set(resultVector.Nsp, inputVector.Nsp)
vector.SetCol(resultVector, abs.AbsUint64(inputValues, resultValues))
return resultVector, nil
}
}
// abs function's evaluation for arguments: [int64]
func AbsInt64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]int64)
if origVec.IsScalar() {
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_int64, Size: 8}), nil
} else {
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_int64, Size: 8})
resultValues := make([]int64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsInt64(origVecCol, resultValues))
//resultVector.Length = origVec.Length
return resultVector, nil
func AbsInt64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_int64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]int64)
resultVector := vector.NewConst(resultType)
resultValues := make([]int64, 1)
vector.SetCol(resultVector, abs.AbsInt64(inputValues, resultValues))
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_int64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]int64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeInt64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsInt64(origVecCol, results))
resultValues := encoding.DecodeInt64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
nulls.Set(resultVector.Nsp, inputVector.Nsp)
vector.SetCol(resultVector, abs.AbsInt64(inputValues, resultValues))
return resultVector, nil
}
}
// abs function's evaluation for arguments: [float64]
func AbsFloat64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]float64)
if origVec.IsScalar() {
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
} else {
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
resultValues := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsFloat64(origVecCol, resultValues))
//resultVector.Length = origVec.Length
return resultVector, nil
func AbsFloat64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]float64)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
vector.SetCol(resultVector, abs.AbsFloat64(inputValues, resultValues))
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]float64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeFloat64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, abs.AbsFloat64(origVecCol, results))
resultValues := encoding.DecodeFloat64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
nulls.Set(resultVector.Nsp, inputVector.Nsp)
vector.SetCol(resultVector, abs.AbsFloat64(inputValues, resultValues))
return resultVector, nil
}
}
pkg/sql/plan2/function/builtin/unary/acos.go
+ 70
− 68
View file @ 974e574a
......@@ -23,96 +23,98 @@ import (
"github.com/matrixorigin/matrixone/pkg/vm/process"
)
// acos function's evaluation for arguments: [int64]
func AcosInt64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVecCol := vs[0].Col.([]int64)
if vs[0].IsScalar() {
if vs[0].IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
} else {
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
results := make([]float64, 1)
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosInt64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
return resultVector, nil
func AcosUint64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]uint64)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
results := acos.AcosUint64(inputValues, resultValues)
if nulls.Any(results.Nsp) {
return proc.AllocScalarNullVector(resultType), nil
}
vector.SetCol(resultVector, results.Result)
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]uint64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeFloat64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosInt64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
return resultVector, err
resultValues := encoding.DecodeFloat64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
results := acos.AcosUint64(inputValues, resultValues)
nulls.Or(inputVector.Nsp, results.Nsp, resultVector.Nsp)
vector.SetCol(resultVector, results.Result)
return resultVector, nil
}
}
// acos function's evaluation for arguments: [uint64]
func AcosUint64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVecCol := vs[0].Col.([]uint64)
if vs[0].IsScalar() {
if vs[0].IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
func AcosInt64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
results := make([]float64, 1)
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosUint64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
inputValues := inputVector.Col.([]int64)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
results := acos.AcosInt64(inputValues, resultValues)
if nulls.Any(results.Nsp) {
return proc.AllocScalarNullVector(resultType), nil
}
vector.SetCol(resultVector, results.Result)
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]int64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeFloat64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosUint64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
return resultVector, err
resultValues := encoding.DecodeFloat64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
results := acos.AcosInt64(inputValues, resultValues)
nulls.Or(inputVector.Nsp, results.Nsp, resultVector.Nsp)
vector.SetCol(resultVector, results.Result)
return resultVector, nil
}
}
// acos function's evaluation for arguments: [float64]
func AcosFloat64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVecCol := vs[0].Col.([]float64)
if vs[0].IsScalar() {
if vs[0].IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
func AcosFloat64(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]float64)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
results := acos.AcosFloat64(inputValues, resultValues)
if nulls.Any(results.Nsp) {
return proc.AllocScalarNullVector(resultType), nil
}
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
results := make([]float64, 1)
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosFloat64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
vector.SetCol(resultVector, results.Result)
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]float64)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeFloat64Slice(resultVector.Data)
results = results[:len(origVecCol)]
nulls.Set(resultVector.Nsp, vs[0].Nsp)
acosResult := acos.AcosFloat64(origVecCol, results)
checkResultValues(resultVector, vs[0], acosResult)
return resultVector, err
}
}
// checkResultValues : Check whether the acosresult result contains a null value. If so, reset the resultvector NSP
func checkResultValues(resultVector *vector.Vector, srcVector *vector.Vector, acosResult acos.AcosResult) {
if nulls.Any(acosResult.Nsp) {
if !nulls.Any(srcVector.Nsp) {
resultVector.Nsp = acosResult.Nsp
} else {
resultVector.Nsp.Or(acosResult.Nsp)
}
resultValues := encoding.DecodeFloat64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
results := acos.AcosFloat64(inputValues, resultValues)
nulls.Or(inputVector.Nsp, results.Nsp, resultVector.Nsp)
vector.SetCol(resultVector, results.Result)
return resultVector, nil
}
resultVector.Col = acosResult.Result
}
pkg/sql/plan2/function/builtin/unary/atan.go
+ 18
− 23
View file @ 974e574a
......@@ -24,34 +24,29 @@ import (
"golang.org/x/exp/constraints"
)
func Atan[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]T)
//Here we need to classfy it into three scenes
//1. if it is a constant
// 1.1 if it's not a null value
// 1.2 if it's a null value
//2 common scene
if origVec.IsScalar() {
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
} else {
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
resultValues := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, atan.Atan[T](origVecCol, resultValues))
return resultVector, nil
func Atan[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]T)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
vector.SetCol(resultVector, atan.Atan[T](inputValues, resultValues))
return resultVector, nil
} else {
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
inputValues := inputVector.Col.([]T)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
}
results := encoding.DecodeFloat64Slice(resultVector.Data)
results = results[:len(origVecCol)]
resultVector.Col = results
nulls.Set(resultVector.Nsp, origVec.Nsp)
vector.SetCol(resultVector, atan.Atan[T](origVecCol, results))
resultValues := encoding.DecodeFloat64Slice(resultVector.Data)
resultValues = resultValues[:len(inputValues)]
nulls.Set(resultVector.Nsp, inputVector.Nsp)
vector.SetCol(resultVector, atan.Atan[T](inputValues, resultValues))
return resultVector, nil
}
}
pkg/sql/plan2/function/builtin/unary/bit_length.go
+ 2
− 1
View file @ 974e574a
......@@ -25,18 +25,19 @@ import (
func BitLengthFunc(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_int64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]int64, 1)
vector.SetCol(resultVector, bit_length.StrBitLength(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/cos.go
+ 2
− 1
View file @ 974e574a
......@@ -26,7 +26,6 @@ import (
func Cos[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]T)
//Here we need to classfy it into three scenes
//1. if it is a constant
// 1.1 if it's not a null value
......@@ -36,6 +35,7 @@ func Cos[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *p
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
} else {
origVecCol := origVec.Col.([]T)
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
resultValues := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
......@@ -43,6 +43,7 @@ func Cos[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *p
return resultVector, nil
}
} else {
origVecCol := origVec.Col.([]T)
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/cot.go
+ 2
− 1
View file @ 974e574a
......@@ -26,7 +26,6 @@ import (
func Cot[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
origVecCol := origVec.Col.([]T)
//Here we need to classfy it into three scenes
//1. if it is a constant
// 1.1 if it's not a null value
......@@ -36,6 +35,7 @@ func Cot[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *p
if origVec.IsScalarNull() {
return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
} else {
origVecCol := origVec.Col.([]T)
resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
resultValues := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
......@@ -43,6 +43,7 @@ func Cot[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *p
return resultVector, nil
}
} else {
origVecCol := origVec.Col.([]T)
resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/date.go
+ 4
− 2
View file @ 974e574a
......@@ -25,19 +25,20 @@ import (
func DateToDate(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.([]types.Date)
resultType := types.Type{Oid: types.T_date, Size: 4}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]types.Date)
resultVector := vector.NewConst(resultType)
resultValues := make([]types.Date, 1)
copy(resultValues, inputValues)
vector.SetCol(resultVector, resultValues)
return resultVector, nil
} else {
inputValues := inputVector.Col.([]types.Date)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......@@ -53,18 +54,19 @@ func DateToDate(vectors []*vector.Vector, proc *process.Process) (*vector.Vector
func DatetimeToDate(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.([]types.Datetime)
resultType := types.Type{Oid: types.T_date, Size: 4}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]types.Datetime)
resultVector := vector.NewConst(resultType)
resultValues := make([]types.Date, 1)
vector.SetCol(resultVector, date.DatetimeToDate(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.([]types.Datetime)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/dayofyear.go
+ 2
− 1
View file @ 974e574a
......@@ -25,18 +25,19 @@ import (
func DayOfYear(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.([]types.Date)
resultType := types.Type{Oid: types.T_uint16, Size: 2}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]types.Date)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint16, 1)
vector.SetCol(resultVector, dayofyear.GetDayOfYear(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.([]types.Date)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/empty.go
+ 2
− 1
View file @ 974e574a
......@@ -25,18 +25,19 @@ import (
func Empty(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_uint8, Size: 1}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint8, 1)
vector.SetCol(resultVector, empty.Empty(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/exp.go
+ 5
− 4
View file @ 974e574a
......@@ -27,17 +27,18 @@ import (
func Exp[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0] // so these kinds of indexing are always guaranteed success because all the checks are done in the plan?
resultType := types.Type{Oid: types.T_float64, Size: 8}
if inputVector.IsScalarNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]T)
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]T)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
vector.SetCol(resultVector, exp.Exp[T](inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.([]T)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/length.go
+ 5
− 1
View file @ 974e574a
......@@ -29,14 +29,18 @@ func Length(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, er
if inputVector.IsScalarNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]int64, 1)
vector.SetCol(resultVector, length.StrLength(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/lengthutf8.go
+ 2
− 1
View file @ 974e574a
......@@ -25,18 +25,19 @@ import (
func LengthUTF8(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
inputValues := inputVector.Col.(*types.Bytes)
resultType := types.Type{Oid: types.T_uint64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
resultVector := vector.NewConst(resultType)
resultValues := make([]uint64, 1)
vector.SetCol(resultVector, lengthutf8.StrLengthUTF8(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.(*types.Bytes)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues.Lengths)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/ln.go
+ 2
− 1
View file @ 974e574a
......@@ -26,13 +26,13 @@ import (
func Ln[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0] // so these kinds of indexing are always guaranteed success because all the checks are done in the plan?
inputValues := inputVector.Col.([]T)
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]T)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
......@@ -43,6 +43,7 @@ func Ln[T constraints.Integer | constraints.Float](vectors []*vector.Vector, pro
vector.SetCol(resultVector, lnResult.Result)
return resultVector, nil
} else {
inputValues := inputVector.Col.([]T)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/log.go
+ 2
− 1
View file @ 974e574a
......@@ -26,13 +26,13 @@ import (
func Log[T constraints.Integer | constraints.Float](vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0] // so these kinds of indexing are always guaranteed success because all the checks are done in the plan?
inputValues := inputVector.Col.([]T)
resultType := types.Type{Oid: types.T_float64, Size: 8}
resultElementSize := int(resultType.Size)
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.([]T)
resultVector := vector.NewConst(resultType)
resultValues := make([]float64, 1)
......@@ -43,6 +43,7 @@ func Log[T constraints.Integer | constraints.Float](vectors []*vector.Vector, pr
vector.SetCol(resultVector, logResult.Result)
return resultVector, nil
} else {
inputValues := inputVector.Col.([]T)
resultVector, err := proc.AllocVector(resultType, int64(resultElementSize*len(inputValues)))
if err != nil {
return nil, err
......
pkg/sql/plan2/function/builtin/unary/ltrim.go
+ 9
− 7
View file @ 974e574a
......@@ -25,15 +25,14 @@ import (
func Ltrim(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
inputVector := vectors[0]
resultType := types.Type{Oid: types.T_varchar, Size: 24}
if inputVector.IsScalarNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
// totalCount - spaceCount is the total bytes need for the ltrim-ed string
spaceCount := ltrim.CountSpacesFromLeft(inputValues)
totalCount := int32(len(inputValues.Data))
if inputVector.IsScalar() {
if inputVector.ConstVectorIsNull() {
return proc.AllocScalarNullVector(resultType), nil
}
inputValues := inputVector.Col.(*types.Bytes)
spaceCount := ltrim.CountSpacesFromLeft(inputValues)
totalCount := int32(len(inputValues.Data))
resultVector := vector.NewConst(resultType)
resultValues := &types.Bytes{
Data: make([]byte, totalCount-spaceCount),
......@@ -43,6 +42,9 @@ func Ltrim(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, err
vector.SetCol(resultVector, ltrim.LtrimChar(inputValues, resultValues))
return resultVector, nil
} else {
inputValues := inputVector.Col.(*types.Bytes)
spaceCount := ltrim.CountSpacesFromLeft(inputValues)
totalCount := int32(len(inputValues.Data))
resultVector, err := proc.AllocVector(resultType, int64(totalCount-spaceCount))
if err != nil {
return nil, err
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment