// Copyright 2024 KipData/KiteSQL

//

// 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.

use crate::errors::DatabaseError;

use crate::expression::function::scala::FuncMonotonicity;

use crate::expression::function::scala::ScalarFunctionImpl;

use crate::expression::function::FunctionSummary;

use crate::planner::ExprRef;

use crate::types::tuple::TupleLike;

use crate::types::value::DataValue;

use crate::types::CharLengthUnits;

use crate::types::LogicalType;

use std::sync::Arc;

#[derive(Debug)]

pub(crate) struct CharLength {

summary: FunctionSummary,

}

impl CharLength {

pub(crate) fn new(function_name: String) -> Arc<Self> {

let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)];

Arc::new(Self {

summary: FunctionSummary {

name: function_name.into(),

arg_types,

},

})

}

}

impl ScalarFunctionImpl for CharLength {

#[allow(unused_variables, clippy::redundant_closure_call)]

fn eval(

&self,

exprs: &[ExprRef],

arena: &crate::planner::PlanArena<'_>,

tuples: Option<&dyn TupleLike>,

) -> Result<DataValue, DatabaseError> {

let mut value = arena.expression(exprs[0]).eval(arena, tuples)?;

if !matches!(value.logical_type(), LogicalType::Varchar(_, _)) {

value = value.cast(&LogicalType::Varchar(None, CharLengthUnits::Characters))?;

}

let mut length: u64 = 0;

if let DataValue::Utf8 { value, ty, unit } = &mut value {

length = value.chars().count() as u64;

}

Ok(DataValue::UInt64(length))

}

fn monotonicity(&self) -> Option<FuncMonotonicity> {

todo!()

}

fn return_type(&self) -> &LogicalType {

&LogicalType::Varchar(None, CharLengthUnits::Characters)

}

fn summary(&self) -> &FunctionSummary {

&self.summary

}

}