github.com/matrixorigin/matrixone@v0.7.0/pkg/sql/plan/function/builtin/unary/ascii.go (about)

     1  // Copyright 2022 Matrix Origin
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package unary
    16  
    17  import (
    18  	"github.com/matrixorigin/matrixone/pkg/container/types"
    19  	"github.com/matrixorigin/matrixone/pkg/container/vector"
    20  	"github.com/matrixorigin/matrixone/pkg/vectorize/ascii"
    21  	"github.com/matrixorigin/matrixone/pkg/vm/process"
    22  )
    23  
    24  var (
    25  	intStartMap = map[types.T]int{
    26  		types.T_int8:  3,
    27  		types.T_int16: 2,
    28  		types.T_int32: 1,
    29  		types.T_int64: 0,
    30  	}
    31  	uintStartMap = map[types.T]int{
    32  		types.T_uint8:  3,
    33  		types.T_uint16: 2,
    34  		types.T_uint32: 1,
    35  		types.T_uint64: 0,
    36  	}
    37  )
    38  
    39  func AsciiInt[T types.Ints](vecs []*vector.Vector, proc *process.Process) (ret *vector.Vector, err error) {
    40  	vec := vecs[0]
    41  	resultType := types.T_uint8.ToType()
    42  	defer func() {
    43  		if err != nil && ret != nil {
    44  			ret.Free(proc.Mp())
    45  		}
    46  	}()
    47  	if vec.IsScalarNull() {
    48  		ret = proc.AllocScalarNullVector(resultType)
    49  		return
    50  	}
    51  	start := intStartMap[vec.Typ.Oid]
    52  	if vec.IsScalar() {
    53  		ret = proc.AllocScalarVector(resultType)
    54  		rs := vector.MustTCols[uint8](ret)
    55  		v := vector.MustTCols[T](vec)[0]
    56  		rs[0] = ascii.IntSingle(int64(v), start)
    57  		return
    58  	}
    59  	ret, err = proc.AllocVectorOfRows(resultType, int64(vec.Length()), vec.Nsp)
    60  	if err != nil {
    61  		return
    62  	}
    63  	rs := vector.MustTCols[uint8](ret)
    64  	vs := vector.MustTCols[T](vec)
    65  	ascii.IntBatch(vs, start, rs, ret.Nsp)
    66  	return
    67  }
    68  
    69  func AsciiUint[T types.UInts](vecs []*vector.Vector, proc *process.Process) (ret *vector.Vector, err error) {
    70  	vec := vecs[0]
    71  	resultType := types.T_uint8.ToType()
    72  	defer func() {
    73  		if err != nil && ret != nil {
    74  			ret.Free(proc.Mp())
    75  		}
    76  	}()
    77  	if vec.IsScalarNull() {
    78  		ret = proc.AllocScalarNullVector(resultType)
    79  		return
    80  	}
    81  	start := uintStartMap[vec.Typ.Oid]
    82  	if vec.IsScalar() {
    83  		ret = proc.AllocScalarVector(resultType)
    84  		rs := vector.MustTCols[uint8](ret)
    85  		v := vector.MustTCols[T](vec)[0]
    86  		rs[0] = ascii.UintSingle(uint64(v), start)
    87  		return
    88  	}
    89  	ret, err = proc.AllocVectorOfRows(resultType, int64(vec.Length()), vec.Nsp)
    90  	if err != nil {
    91  		return
    92  	}
    93  	rs := vector.MustTCols[uint8](ret)
    94  	vs := vector.MustTCols[T](vec)
    95  	ascii.UintBatch(vs, start, rs, ret.Nsp)
    96  	return
    97  }
    98  
    99  func AsciiString(vecs []*vector.Vector, proc *process.Process) (ret *vector.Vector, err error) {
   100  	vec := vecs[0]
   101  	resultType := types.T_uint8.ToType()
   102  	defer func() {
   103  		if err != nil && ret != nil {
   104  			ret.Free(proc.Mp())
   105  		}
   106  	}()
   107  	if vec.IsScalarNull() {
   108  		ret = proc.AllocScalarNullVector(resultType)
   109  		return
   110  	}
   111  	if vec.IsScalar() {
   112  		ret = proc.AllocScalarVector(resultType)
   113  		rs := vector.MustTCols[uint8](ret)
   114  		v := vector.MustBytesCols(vec)[0]
   115  		rs[0] = ascii.StringSingle(v)
   116  		return
   117  	}
   118  	ret, err = proc.AllocVectorOfRows(resultType, int64(vec.Length()), vec.Nsp)
   119  	if err != nil {
   120  		return
   121  	}
   122  	rs := vector.MustTCols[uint8](ret)
   123  	vs := vector.MustBytesCols(vec)
   124  	ascii.StringBatch(vs, rs, ret.Nsp)
   125  	return
   126  }