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

     1  // Copyright 2021 - 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/vm/process"
    21  )
    22  
    23  func DatetimeToHour(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
    24  	inputVector := vectors[0]
    25  	resultType := types.T_uint8.ToType()
    26  	inputValues := vector.MustTCols[types.Datetime](inputVector)
    27  	if inputVector.IsScalar() {
    28  		if inputVector.IsScalarNull() {
    29  			return proc.AllocScalarNullVector(resultType), nil
    30  		}
    31  		resultVector := vector.NewConstFixed(resultType, 1, uint8(inputValues[0].Hour()), proc.Mp())
    32  		return resultVector, nil
    33  	} else {
    34  		resultVector := vector.New(resultType)
    35  		for i, v := range inputValues {
    36  			if inputVector.GetNulls().Contains(uint64(i)) {
    37  				resultVector.GetNulls().Set(uint64(i))
    38  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
    39  					return nil, err
    40  				}
    41  				continue
    42  			}
    43  			if err := resultVector.Append(uint8(v.Hour()), false, proc.Mp()); err != nil {
    44  				return nil, err
    45  			}
    46  		}
    47  		return resultVector, nil
    48  	}
    49  }
    50  
    51  func TimestampToHour(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
    52  	inputVector := vectors[0]
    53  	resultType := types.T_uint8.ToType()
    54  	inputValues := vector.MustTCols[types.Timestamp](inputVector)
    55  	convertedInputValues := make([]types.Datetime, len(inputValues))
    56  	if _, err := types.TimestampToDatetime(proc.SessionInfo.TimeZone, inputValues, convertedInputValues); err != nil {
    57  		return nil, err
    58  	}
    59  	if inputVector.IsScalar() {
    60  		if inputVector.IsScalarNull() {
    61  			return proc.AllocScalarNullVector(resultType), nil
    62  		}
    63  		resultVector := vector.NewConstFixed(resultType, 1, uint8(convertedInputValues[0].Hour()), proc.Mp())
    64  		return resultVector, nil
    65  	} else {
    66  		resultVector := vector.New(resultType)
    67  		for i, v := range convertedInputValues {
    68  			if inputVector.GetNulls().Contains(uint64(i)) {
    69  				resultVector.GetNulls().Set(uint64(i))
    70  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
    71  					return nil, err
    72  				}
    73  				continue
    74  			}
    75  			if err := resultVector.Append(uint8(v.Hour()), false, proc.Mp()); err != nil {
    76  				return nil, err
    77  			}
    78  		}
    79  		return resultVector, nil
    80  	}
    81  }
    82  
    83  func DatetimeToMinute(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
    84  	inputVector := vectors[0]
    85  	resultType := types.T_uint8.ToType()
    86  	inputValues := vector.MustTCols[types.Datetime](inputVector)
    87  
    88  	if inputVector.IsScalar() {
    89  		if inputVector.IsScalarNull() {
    90  			return proc.AllocScalarNullVector(resultType), nil
    91  		}
    92  		resultVector := vector.NewConstFixed(resultType, 1, uint8(inputValues[0].Minute()), proc.Mp())
    93  		return resultVector, nil
    94  	} else {
    95  		resultVector := vector.New(resultType)
    96  		for i, v := range inputValues {
    97  			if inputVector.GetNulls().Contains(uint64(i)) {
    98  				resultVector.GetNulls().Set(uint64(i))
    99  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
   100  					return nil, err
   101  				}
   102  				continue
   103  			}
   104  			if err := resultVector.Append(uint8(v.Minute()), false, proc.Mp()); err != nil {
   105  				return nil, err
   106  			}
   107  		}
   108  		return resultVector, nil
   109  	}
   110  }
   111  
   112  func TimestampToMinute(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
   113  	inputVector := vectors[0]
   114  	resultType := types.T_uint8.ToType()
   115  	inputValues := vector.MustTCols[types.Timestamp](inputVector)
   116  	convertedInputValues := make([]types.Datetime, len(inputValues))
   117  	if _, err := types.TimestampToDatetime(proc.SessionInfo.TimeZone, inputValues, convertedInputValues); err != nil {
   118  		return nil, err
   119  	}
   120  	if inputVector.IsScalar() {
   121  		if inputVector.IsScalarNull() {
   122  			return proc.AllocScalarNullVector(resultType), nil
   123  		}
   124  		resultVector := vector.NewConstFixed(resultType, 1, uint8(convertedInputValues[0].Minute()), proc.Mp())
   125  		return resultVector, nil
   126  	} else {
   127  		resultVector := vector.New(resultType)
   128  		for i, v := range convertedInputValues {
   129  			if inputVector.GetNulls().Contains(uint64(i)) {
   130  				resultVector.GetNulls().Set(uint64(i))
   131  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
   132  					return nil, err
   133  				}
   134  				continue
   135  			}
   136  			if err := resultVector.Append(uint8(v.Minute()), false, proc.Mp()); err != nil {
   137  				return nil, err
   138  			}
   139  		}
   140  		return resultVector, nil
   141  	}
   142  }
   143  
   144  func DatetimeToSecond(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
   145  	inputVector := vectors[0]
   146  	resultType := types.T_uint8.ToType()
   147  	inputValues := vector.MustTCols[types.Datetime](inputVector)
   148  	if inputVector.IsScalar() {
   149  		if inputVector.IsScalarNull() {
   150  			return proc.AllocScalarNullVector(resultType), nil
   151  		}
   152  		resultVector := vector.NewConstFixed(resultType, 1, uint8(inputValues[0].Sec()), proc.Mp())
   153  		return resultVector, nil
   154  	} else {
   155  		resultVector := vector.New(resultType)
   156  		for i, v := range inputValues {
   157  			if inputVector.GetNulls().Contains(uint64(i)) {
   158  				resultVector.GetNulls().Set(uint64(i))
   159  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
   160  					return nil, err
   161  				}
   162  				continue
   163  			}
   164  			if err := resultVector.Append(uint8(v.Sec()), false, proc.Mp()); err != nil {
   165  				return nil, err
   166  			}
   167  		}
   168  		return resultVector, nil
   169  	}
   170  }
   171  
   172  func TimestampToSecond(vectors []*vector.Vector, proc *process.Process) (*vector.Vector, error) {
   173  	inputVector := vectors[0]
   174  	resultType := types.T_uint8.ToType()
   175  	inputValues := vector.MustTCols[types.Timestamp](inputVector)
   176  	convertedInputValues := make([]types.Datetime, len(inputValues))
   177  	if _, err := types.TimestampToDatetime(proc.SessionInfo.TimeZone, inputValues, convertedInputValues); err != nil {
   178  		return nil, err
   179  	}
   180  	if inputVector.IsScalar() {
   181  		if inputVector.IsScalarNull() {
   182  			return proc.AllocScalarNullVector(resultType), nil
   183  		}
   184  		resultVector := vector.NewConstFixed(resultType, 1, uint8(convertedInputValues[0].Sec()), proc.Mp())
   185  		return resultVector, nil
   186  	} else {
   187  		resultVector := vector.New(resultType)
   188  		for i, v := range convertedInputValues {
   189  			if inputVector.GetNulls().Contains(uint64(i)) {
   190  				resultVector.GetNulls().Set(uint64(i))
   191  				if err := resultVector.Append(uint8(0), true, proc.Mp()); err != nil {
   192  					return nil, err
   193  				}
   194  				continue
   195  			}
   196  			if err := resultVector.Append(uint8(v.Sec()), false, proc.Mp()); err != nil {
   197  				return nil, err
   198  			}
   199  		}
   200  		return resultVector, nil
   201  	}
   202  }