github.com/matrixorigin/matrixone@v0.7.0/pkg/testutil/util_function.go

// Copyright 2021 Matrix Origin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package testutil

import (
	"fmt"
	"github.com/matrixorigin/matrixone/pkg/common/mpool"
	"github.com/matrixorigin/matrixone/pkg/container/nulls"
	"github.com/matrixorigin/matrixone/pkg/container/types"
	"github.com/matrixorigin/matrixone/pkg/container/vector"
	"github.com/matrixorigin/matrixone/pkg/vm/process"
)

type fEvalFn func(parameters []*vector.Vector, result vector.FunctionResultWrapper, proc *process.Process, length int) error

type FunctionTestCase struct {
	proc       *process.Process
	parameters []*vector.Vector
	result     vector.FunctionResultWrapper
	expected   FunctionTestResult
	fn         fEvalFn
	fnLength   int
}

// FunctionTestInput
// the values should fit to typ.
// for example:
// if typ is int64, the values should be []int64
// if your typ is string type (varchar or others), the values should be []string.
type FunctionTestInput struct {
	typ      types.Type
	values   any
	nullList []bool
}

// FunctionTestResult
// the wanted should fit to typ.
// for example:
// if typ is int64, the wanted should be []int64
// if your typ is string type (varchar or others), the wanted should be []string.
type FunctionTestResult struct {
	typ      types.Type
	wantErr  bool
	wanted   any
	nullList []bool
}

func NewFunctionTestInput(typ types.Type, values any, nullList []bool) FunctionTestInput {
	return FunctionTestInput{
		typ:      typ,
		values:   values,
		nullList: nullList,
	}
}

func NewFunctionTestResult(typ types.Type, wantErr bool, wanted any, nullList []bool) FunctionTestResult {
	return FunctionTestResult{
		typ:      typ,
		wantErr:  wantErr,
		wanted:   wanted,
		nullList: nullList,
	}
}

// NewFunctionTestCase generate a testcase for built-in function F.
// fn is the evaluate method of F.
func NewFunctionTestCase(
	proc *process.Process,
	inputs []FunctionTestInput,
	wanted FunctionTestResult,
	fn fEvalFn) FunctionTestCase {
	f := FunctionTestCase{proc: proc}
	mp := proc.Mp()
	// allocate vector for function parameters
	f.parameters = make([]*vector.Vector, len(inputs))
	for i := range f.parameters {
		typ := inputs[i].typ
		// generate the nulls.
		var nsp *nulls.Nulls = nil
		if len(inputs[i].nullList) != 0 {
			nsp = nulls.NewWithSize(len(inputs[i].nullList))
			for j, b := range inputs[i].nullList {
				if b {
					nsp.Set(uint64(j))
				}
			}
		}
		// new the vector.
		f.parameters[i] = newVectorByType(proc.Mp(), typ, inputs[i].values, nsp)
	}
	// new the result
	if len(f.parameters) == 0 {
		f.result = vector.NewFunctionResultWrapper(wanted.typ, mp, false, 1)
		f.fnLength = 1
	} else {
		f.result = vector.NewFunctionResultWrapper(wanted.typ, mp, false, f.parameters[0].Length())
		f.fnLength = f.parameters[0].Length()
	}
	f.expected = wanted
	f.fn = fn
	return f
}

// Run will run the function case and do the correctness check for result.
func (fc *FunctionTestCase) Run() (succeed bool, errInfo string) {
	err := fc.fn(fc.parameters, fc.result, fc.proc, fc.fnLength)
	if err != nil {
		if fc.expected.wantErr {
			return true, ""
		}
		return false, fmt.Sprintf("expected to run success, but get an error that '%s'",
			err.Error())
	}
	if fc.expected.wantErr {
		return false, "expected to run failed, but run succeed with no error"
	}
	v := fc.result.GetResultVector()
	// check the length
	if fc.fnLength != v.Length() {
		return false, fmt.Sprintf("expected %d rows but get %d rows", fc.fnLength, v.Length())
	}
	// check type (it's stupid, haha
	if v.Typ.Oid != fc.expected.typ.Oid {
		return false, fmt.Sprintf("expected result type %s but get type %s", fc.expected.typ,
			v.Typ)
	}
	// generate the expected nsp
	var expectedNsp *nulls.Nulls = nil
	if fc.expected.nullList != nil {
		expectedNsp = nulls.NewWithSize(len(fc.expected.nullList))
		for i, b := range fc.expected.nullList {
			if b {
				expectedNsp.Np.Add(uint64(i))
			}
		}
	}
	// check the value
	col := fc.expected.wanted
	vExpected := newVectorByType(fc.proc.Mp(), fc.expected.typ, col, expectedNsp)
	var i uint64
	switch v.Typ.Oid {
	case types.T_bool:
		r := vector.GenerateFunctionFixedTypeParameter[bool](v)
		s := vector.GenerateFunctionFixedTypeParameter[bool](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_int8:
		r := vector.GenerateFunctionFixedTypeParameter[int8](v)
		s := vector.GenerateFunctionFixedTypeParameter[int8](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_int16:
		r := vector.GenerateFunctionFixedTypeParameter[int16](v)
		s := vector.GenerateFunctionFixedTypeParameter[int16](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_int32:
		r := vector.GenerateFunctionFixedTypeParameter[int32](v)
		s := vector.GenerateFunctionFixedTypeParameter[int32](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_int64:
		r := vector.GenerateFunctionFixedTypeParameter[int64](v)
		s := vector.GenerateFunctionFixedTypeParameter[int64](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_uint8:
		r := vector.GenerateFunctionFixedTypeParameter[uint8](v)
		s := vector.GenerateFunctionFixedTypeParameter[uint8](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_uint16:
		r := vector.GenerateFunctionFixedTypeParameter[uint16](v)
		s := vector.GenerateFunctionFixedTypeParameter[uint16](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_uint32:
		r := vector.GenerateFunctionFixedTypeParameter[uint32](v)
		s := vector.GenerateFunctionFixedTypeParameter[uint32](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_uint64:
		r := vector.GenerateFunctionFixedTypeParameter[uint64](v)
		s := vector.GenerateFunctionFixedTypeParameter[uint64](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_float32:
		r := vector.GenerateFunctionFixedTypeParameter[float32](v)
		s := vector.GenerateFunctionFixedTypeParameter[float32](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_float64:
		r := vector.GenerateFunctionFixedTypeParameter[float64](v)
		s := vector.GenerateFunctionFixedTypeParameter[float64](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_decimal64:
		r := vector.GenerateFunctionFixedTypeParameter[types.Decimal64](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Decimal64](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_decimal128:
		r := vector.GenerateFunctionFixedTypeParameter[types.Decimal128](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Decimal128](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_date:
		r := vector.GenerateFunctionFixedTypeParameter[types.Date](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Date](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_datetime:
		r := vector.GenerateFunctionFixedTypeParameter[types.Datetime](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Datetime](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_time:
		r := vector.GenerateFunctionFixedTypeParameter[types.Time](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Time](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_timestamp:
		r := vector.GenerateFunctionFixedTypeParameter[types.Timestamp](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Timestamp](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_char, types.T_varchar, types.T_blob, types.T_text:
		r := vector.GenerateFunctionStrParameter(v)
		s := vector.GenerateFunctionStrParameter(vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetStrValue(i)
			get, null2 := r.GetStrValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if string(want) != string(get) {
				return false, fmt.Sprintf("the %dth row expected %s, but get %s",
					i+1, string(want), string(get))
			}
		}
	case types.T_uuid:
		r := vector.GenerateFunctionFixedTypeParameter[types.Uuid](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Uuid](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_TS:
		r := vector.GenerateFunctionFixedTypeParameter[types.TS](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.TS](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_Rowid:
		r := vector.GenerateFunctionFixedTypeParameter[types.Rowid](v)
		s := vector.GenerateFunctionFixedTypeParameter[types.Rowid](vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetValue(i)
			get, null2 := r.GetValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if want != get {
				return false, fmt.Sprintf("the %dth row expected %v, but get %v",
					i+1, want, get)
			}
		}
	case types.T_json:
		r := vector.GenerateFunctionStrParameter(v)
		s := vector.GenerateFunctionStrParameter(vExpected)
		for i = 0; i < uint64(fc.fnLength); i++ {
			want, null1 := s.GetStrValue(i)
			get, null2 := r.GetStrValue(i)
			if null1 {
				if null2 {
					continue
				} else {
					return false, fmt.Sprintf("the %dth row expected NULL, but get not null", i+1)
				}
			}
			if string(want) != string(get) {
				return false, fmt.Sprintf("the %dth row expected %s, but get %s",
					i+1, string(want), string(get))
			}
		}
	default:
		panic(fmt.Sprintf("unsupported result type %s for function ut framework", v.Typ))
	}
	return true, ""
}

// DebugRun will not run the compare logic for function result but return the result vector directly.
func (fc *FunctionTestCase) DebugRun() (*vector.Vector, error) {
	err := fc.fn(fc.parameters, fc.result, fc.proc, fc.fnLength)
	return fc.result.GetResultVector(), err
}

// BenchMarkRun will run the function case N times without correctness check for result.
func (fc *FunctionTestCase) BenchMarkRun() error {
	num := 100
	for num > 0 {
		num--
		err := fc.fn(fc.parameters, fc.result, fc.proc, fc.fnLength)
		// XXX maybe free is unnecessary.
		fc.result.Free()
		if err != nil {
			return err
		}
	}
	return nil
}

func newVectorByType(
	mp *mpool.MPool,
	typ types.Type, val any, nsp *nulls.Nulls) *vector.Vector {
	switch typ.Oid {
	case types.T_bool:
		values := val.([]bool)
		return vector.NewWithFixed[bool](typ, values, nsp, mp)
	case types.T_int8:
		values := val.([]int8)
		return vector.NewWithFixed[int8](typ, values, nsp, mp)
	case types.T_int16:
		values := val.([]int16)
		return vector.NewWithFixed[int16](typ, values, nsp, mp)
	case types.T_int32:
		values := val.([]int32)
		return vector.NewWithFixed[int32](typ, values, nsp, mp)
	case types.T_int64:
		values := val.([]int64)
		return vector.NewWithFixed[int64](typ, values, nsp, mp)
	case types.T_uint8:
		values := val.([]uint8)
		return vector.NewWithFixed[uint8](typ, values, nsp, mp)
	case types.T_uint16:
		values := val.([]uint16)
		return vector.NewWithFixed[uint16](typ, values, nsp, mp)
	case types.T_uint32:
		values := val.([]uint32)
		return vector.NewWithFixed[uint32](typ, values, nsp, mp)
	case types.T_uint64:
		values := val.([]uint64)
		return vector.NewWithFixed[uint64](typ, values, nsp, mp)
	case types.T_float32:
		values := val.([]float32)
		return vector.NewWithFixed[float32](typ, values, nsp, mp)
	case types.T_float64:
		values := val.([]float64)
		return vector.NewWithFixed[float64](typ, values, nsp, mp)
	case types.T_decimal64:
		values := val.([]types.Decimal64)
		return vector.NewWithFixed[types.Decimal64](typ, values, nsp, mp)
	case types.T_decimal128:
		values := val.([]types.Decimal128)
		return vector.NewWithFixed[types.Decimal128](typ, values, nsp, mp)
	case types.T_date:
		values := val.([]types.Date)
		return vector.NewWithFixed[types.Date](typ, values, nsp, mp)
	case types.T_datetime:
		values := val.([]types.Datetime)
		return vector.NewWithFixed[types.Datetime](typ, values, nsp, mp)
	case types.T_time:
		values := val.([]types.Time)
		return vector.NewWithFixed[types.Time](typ, values, nsp, mp)
	case types.T_timestamp:
		values := val.([]types.Timestamp)
		return vector.NewWithFixed[types.Timestamp](typ, values, nsp, mp)
	case types.T_char, types.T_varchar, types.T_blob, types.T_text:
		values := val.([]string)
		return vector.NewWithStrings(typ, values, nsp, mp)
	case types.T_uuid:
		values := val.([]types.Uuid)
		return vector.NewWithFixed[types.Uuid](typ, values, nsp, mp)
	case types.T_TS:
		values := val.([]types.TS)
		return vector.NewWithFixed[types.TS](typ, values, nsp, mp)
	case types.T_Rowid:
		values := val.([]types.Rowid)
		return vector.NewWithFixed[types.Rowid](typ, values, nsp, mp)
	case types.T_json:
		values := val.([]string)
		return vector.NewWithStrings(typ, values, nsp, mp)
	}
	panic(fmt.Sprintf("function test framework do not support typ %s", typ))
}