From ab2fdcb47180d7f8e746c3b30ab99ed26a88a53b Mon Sep 17 00:00:00 2001
From: dongdongyang <47596332+dongdongyang33@users.noreply.github.com>
Date: Mon, 6 Jun 2022 21:24:43 +0800
Subject: [PATCH] Use generics to migrate sinh/tan (#2800)
---
pkg/sql/plan2/function/builtin/unary/sinh.go | 71 ++-------
pkg/sql/plan2/function/builtin/unary/tan.go | 71 ++-------
pkg/sql/plan2/function/buitins.go | 146 +++++++++++++++++--
pkg/vectorize/sinh/sinh.go | 13 +-
pkg/vectorize/tan/tan.go | 9 ++
5 files changed, 175 insertions(+), 135 deletions(-)
diff --git a/pkg/sql/plan2/function/builtin/unary/sinh.go b/pkg/sql/plan2/function/builtin/unary/sinh.go
index eba65659a..b5b32417c 100644
--- a/pkg/sql/plan2/function/builtin/unary/sinh.go
+++ b/pkg/sql/plan2/function/builtin/unary/sinh.go
@@ -21,23 +21,24 @@ import (
"github.com/matrixorigin/matrixone/pkg/encoding"
"github.com/matrixorigin/matrixone/pkg/vectorize/sinh"
"github.com/matrixorigin/matrixone/pkg/vm/process"
+ "golang.org/x/exp/constraints"
)
-// sinh function's evaluation for arguments: [uint64]
-func SinhUint64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
+func Sinh[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
- origVecCol := origVec.Col.([]uint64)
+ origVecCol := origVec.Col.([]T)
+ resultType := types.Type{Oid: types.T_float64, Size: 8}
if origVec.IsScalar() {
if origVec.IsScalarNull() {
- return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
+ return proc.AllocScalarNullVector(resultType), nil
}
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
+ resultVector := proc.AllocScalarVector(resultType)
results := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, sinh.SinhUint64(origVecCol, results))
+ vector.SetCol(resultVector, sinh.Sinh(origVecCol, results))
return resultVector, nil
} else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
+ resultVector, err := proc.AllocVector(resultType, 8*int64(len(origVecCol)))
if err != nil {
return nil, err
}
@@ -45,61 +46,7 @@ func SinhUint64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, err
results = results[:len(origVecCol)]
resultVector.Col = results
nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, sinh.SinhUint64(origVecCol, results))
- return resultVector, nil
- }
-}
-
-// sinh function's evaluation for arguments: [int64]
-func SinhInt64(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_float64, Size: 8}), nil
- }
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
- results := make([]float64, 1)
- nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, sinh.SinhInt64(origVecCol, results))
- return resultVector, nil
- } else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
- 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, sinh.SinhInt64(origVecCol, results))
- return resultVector, nil
- }
-}
-
-// sinh function's evaluation for arguments: [float64]
-func SinhFloat64(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
- }
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
- results := make([]float64, 1)
- nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, sinh.SinhFloat64(origVecCol, results))
- return resultVector, nil
- } else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
- 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, sinh.SinhFloat64(origVecCol, results))
+ vector.SetCol(resultVector, sinh.Sinh(origVecCol, results))
return resultVector, nil
}
}
diff --git a/pkg/sql/plan2/function/builtin/unary/tan.go b/pkg/sql/plan2/function/builtin/unary/tan.go
index 48e683cd9..5a3702d2b 100644
--- a/pkg/sql/plan2/function/builtin/unary/tan.go
+++ b/pkg/sql/plan2/function/builtin/unary/tan.go
@@ -21,23 +21,24 @@ import (
"github.com/matrixorigin/matrixone/pkg/encoding"
"github.com/matrixorigin/matrixone/pkg/vectorize/tan"
"github.com/matrixorigin/matrixone/pkg/vm/process"
+ "golang.org/x/exp/constraints"
)
-// tan function's evaluation for arguments: [uint64]
-func TanUint64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
+func Tan[T constraints.Integer | constraints.Float](vs []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
origVec := vs[0]
- origVecCol := origVec.Col.([]uint64)
+ origVecCol := origVec.Col.([]T)
+ resultType := types.Type{Oid: types.T_float64, Size: 8}
if origVec.IsScalar() {
if origVec.IsScalarNull() {
- return proc.AllocScalarNullVector(types.Type{Oid: types.T_float64, Size: 8}), nil
+ return proc.AllocScalarNullVector(resultType), nil
}
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
+ resultVector := proc.AllocScalarVector(resultType)
results := make([]float64, 1)
nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, tan.TanUint64(origVecCol, results))
+ vector.SetCol(resultVector, tan.Tan(origVecCol, results))
return resultVector, nil
} else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
+ resultVector, err := proc.AllocVector(resultType, 8*int64(len(origVecCol)))
if err != nil {
return nil, err
}
@@ -45,61 +46,7 @@ func TanUint64(vs []*vector.Vector, proc *process.Process) (*vector.Vector, erro
results = results[:len(origVecCol)]
resultVector.Col = results
nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, tan.TanUint64(origVecCol, results))
- return resultVector, nil
- }
-}
-
-// tan function's evaluation for arguments: [int64]
-func TanInt64(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_float64, Size: 8}), nil
- }
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
- results := make([]float64, 1)
- nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, tan.TanInt64(origVecCol, results))
- return resultVector, nil
- } else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
- 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, tan.TanInt64(origVecCol, results))
- return resultVector, nil
- }
-}
-
-// tan function's evaluation for arguments: [float64]
-func TanFloat64(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
- }
- resultVector := proc.AllocScalarVector(types.Type{Oid: types.T_float64, Size: 8})
- results := make([]float64, 1)
- nulls.Set(resultVector.Nsp, origVec.Nsp)
- vector.SetCol(resultVector, tan.TanFloat64(origVecCol, results))
- return resultVector, nil
- } else {
- resultVector, err := proc.AllocVector(types.Type{Oid: types.T_float64, Size: 8}, 8*int64(len(origVecCol)))
- 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, tan.TanFloat64(origVecCol, results))
+ vector.SetCol(resultVector, tan.Tan(origVecCol, results))
return resultVector, nil
}
}
diff --git a/pkg/sql/plan2/function/buitins.go b/pkg/sql/plan2/function/buitins.go
index 7a38ec233..11149b85b 100644
--- a/pkg/sql/plan2/function/buitins.go
+++ b/pkg/sql/plan2/function/buitins.go
@@ -1621,28 +1621,91 @@ var builtins = map[int][]Function{
Index: 0,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
- Args: []types.T{types.T_uint64},
+ Args: []types.T{types.T_uint8},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.TanUint64,
+ Fn: unary.Tan[uint8],
},
{
Index: 1,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
- Args: []types.T{types.T_int64},
+ Args: []types.T{types.T_uint16},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.TanInt64,
+ Fn: unary.Tan[uint16],
},
{
Index: 2,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_uint32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[uint32],
+ },
+ {
+ Index: 3,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_uint64},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[uint64],
+ },
+ {
+ Index: 4,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int8},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[int8],
+ },
+ {
+ Index: 5,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int16},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[int16],
+ },
+ {
+ Index: 6,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[int32],
+ },
+ {
+ Index: 7,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int64},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[int64],
+ },
+ {
+ Index: 8,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_float32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Tan[float32],
+ },
+ {
+ Index: 9,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
Args: []types.T{types.T_float64},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.TanFloat64,
+ Fn: unary.Tan[float64],
},
},
SINH: {
@@ -1650,28 +1713,91 @@ var builtins = map[int][]Function{
Index: 0,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
- Args: []types.T{types.T_uint64},
+ Args: []types.T{types.T_uint8},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.SinhUint64,
+ Fn: unary.Sinh[uint8],
},
{
Index: 1,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
- Args: []types.T{types.T_int64},
+ Args: []types.T{types.T_uint16},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.SinhInt64,
+ Fn: unary.Sinh[uint16],
},
{
Index: 2,
Flag: plan.Function_STRICT,
Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_uint32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[uint32],
+ },
+ {
+ Index: 3,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_uint64},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[uint64],
+ },
+ {
+ Index: 4,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int8},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[int8],
+ },
+ {
+ Index: 5,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int16},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[int16],
+ },
+ {
+ Index: 6,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[int32],
+ },
+ {
+ Index: 7,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_int64},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[int64],
+ },
+ {
+ Index: 8,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
+ Args: []types.T{types.T_float32},
+ ReturnTyp: types.T_float64,
+ TypeCheckFn: strictTypeCheck,
+ Fn: unary.Sinh[float32],
+ },
+ {
+ Index: 9,
+ Flag: plan.Function_STRICT,
+ Layout: STANDARD_FUNCTION,
Args: []types.T{types.T_float64},
ReturnTyp: types.T_float64,
TypeCheckFn: strictTypeCheck,
- Fn: unary.SinhFloat64,
+ Fn: unary.Sinh[float64],
},
},
ATAN: {
diff --git a/pkg/vectorize/sinh/sinh.go b/pkg/vectorize/sinh/sinh.go
index 23deb715c..193193faf 100644
--- a/pkg/vectorize/sinh/sinh.go
+++ b/pkg/vectorize/sinh/sinh.go
@@ -14,7 +14,11 @@
package sinh
-import "math"
+import (
+ "math"
+
+ "golang.org/x/exp/constraints"
+)
var (
SinhUint8 func([]uint8, []float64) []float64
@@ -111,3 +115,10 @@ func sinhInt64(xs []int64, rs []float64) []float64 {
}
return rs
}
+
+func Sinh[T constraints.Integer | constraints.Float](inputValues []T, resultValues []float64) []float64 {
+ for i, n := range inputValues {
+ resultValues[i] = math.Sinh(float64(n))
+ }
+ return resultValues
+}
diff --git a/pkg/vectorize/tan/tan.go b/pkg/vectorize/tan/tan.go
index 9a1211c3b..9afe93b41 100644
--- a/pkg/vectorize/tan/tan.go
+++ b/pkg/vectorize/tan/tan.go
@@ -16,6 +16,8 @@ package tan
import (
"math"
+
+ "golang.org/x/exp/constraints"
)
var (
@@ -113,3 +115,10 @@ func tanFloat64(xs []float64, rs []float64) []float64 {
}
return rs
}
+
+func Tan[T constraints.Integer | constraints.Float](inputValues []T, resultValues []float64) []float64 {
+ for i, n := range inputValues {
+ resultValues[i] = math.Tan(float64(n))
+ }
+ return resultValues
+}
--
GitLab