diff --git a/src/db.rs b/src/db.rs index 2a87fd2a..efacbca9 100644 --- a/src/db.rs +++ b/src/db.rs @@ -5,8 +5,12 @@ use crate::execution::{build_write, try_collect}; use crate::expression::function::scala::ScalarFunctionImpl; use crate::expression::function::table::TableFunctionImpl; use crate::expression::function::FunctionSummary; +use crate::function::char_length::CharLength; +use crate::function::char_length::CharacterLength; use crate::function::current_date::CurrentDate; +use crate::function::lower::Lower; use crate::function::numbers::Numbers; +use crate::function::upper::Upper; use crate::optimizer::heuristic::batch::HepBatchStrategy; use crate::optimizer::heuristic::optimizer::HepOptimizer; use crate::optimizer::rule::implementation::ImplementationRuleImpl; @@ -48,7 +52,11 @@ impl DataBaseBuilder { scala_functions: Default::default(), table_functions: Default::default(), }; + builder = builder.register_scala_function(CharLength::new()); + builder = builder.register_scala_function(CharacterLength::new2()); builder = builder.register_scala_function(CurrentDate::new()); + builder = builder.register_scala_function(Lower::new()); + builder = builder.register_scala_function(Upper::new()); builder = builder.register_table_function(Numbers::new()); builder } diff --git a/src/function/char_length.rs b/src/function/char_length.rs new file mode 100644 index 00000000..b5a94d44 --- /dev/null +++ b/src/function/char_length.rs @@ -0,0 +1,88 @@ +use crate::catalog::ColumnRef; +use crate::errors::DatabaseError; +use crate::expression::function::scala::FuncMonotonicity; +use crate::expression::function::scala::ScalarFunctionImpl; +use crate::expression::function::FunctionSummary; +use crate::expression::ScalarExpression; +use crate::types::tuple::Tuple; +use crate::types::value::DataValue; +use crate::types::LogicalType; +use serde::Deserialize; +use serde::Serialize; +use sqlparser::ast::CharLengthUnits; +use std::sync::Arc; + +#[derive(Debug, Serialize, Deserialize)] +pub(crate) struct CharLength { + summary: FunctionSummary, +} + +impl CharLength { + #[allow(unused_mut)] + pub(crate) fn new() -> Arc { + let function_name = "char_length".to_lowercase(); + let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)]; + Arc::new(Self { + summary: FunctionSummary { + name: function_name, + arg_types, + }, + }) + } +} + +pub type CharacterLength = CharLength; + +impl CharacterLength { + #[allow(unused_mut)] + pub(crate) fn new2() -> Arc { + let function_name = "character_length".to_lowercase(); + let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)]; + Arc::new(Self { + summary: FunctionSummary { + name: function_name, + arg_types, + }, + }) + } +} + +#[typetag::serde] +impl ScalarFunctionImpl for CharLength { + #[allow(unused_variables, clippy::redundant_closure_call)] + fn eval( + &self, + exprs: &[ScalarExpression], + tuples: &Tuple, + columns: &[ColumnRef], + ) -> Result { + let value = exprs[0].eval(tuples, columns)?; + let mut value = DataValue::clone(&value); + if !matches!(value.logical_type(), LogicalType::Varchar(_, _)) { + value = DataValue::clone(&value) + .cast(&LogicalType::Varchar(None, CharLengthUnits::Characters))?; + } + let mut length: u64 = 0; + if let DataValue::Utf8 { + value: Some(value), + ty, + unit, + } = &mut value + { + length = value.len() as u64; + } + Ok(DataValue::UInt64(Some(length))) + } + + fn monotonicity(&self) -> Option { + todo!() + } + + fn return_type(&self) -> &LogicalType { + &LogicalType::Varchar(None, CharLengthUnits::Characters) + } + + fn summary(&self) -> &FunctionSummary { + &self.summary + } +} diff --git a/src/function/lower.rs b/src/function/lower.rs new file mode 100644 index 00000000..86ed71e3 --- /dev/null +++ b/src/function/lower.rs @@ -0,0 +1,71 @@ +use crate::catalog::ColumnRef; +use crate::errors::DatabaseError; +use crate::expression::function::scala::FuncMonotonicity; +use crate::expression::function::scala::ScalarFunctionImpl; +use crate::expression::function::FunctionSummary; +use crate::expression::ScalarExpression; +use crate::types::tuple::Tuple; +use crate::types::value::DataValue; +use crate::types::LogicalType; +use serde::Deserialize; +use serde::Serialize; +use sqlparser::ast::CharLengthUnits; +use std::sync::Arc; + +#[derive(Debug, Serialize, Deserialize)] +pub(crate) struct Lower { + summary: FunctionSummary, +} + +impl Lower { + #[allow(unused_mut)] + pub(crate) fn new() -> Arc { + let function_name = "lower".to_lowercase(); + let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)]; + Arc::new(Self { + summary: FunctionSummary { + name: function_name, + arg_types, + }, + }) + } +} + +#[typetag::serde] +impl ScalarFunctionImpl for Lower { + #[allow(unused_variables, clippy::redundant_closure_call)] + fn eval( + &self, + exprs: &[ScalarExpression], + tuples: &Tuple, + columns: &[ColumnRef], + ) -> Result { + let value = exprs[0].eval(tuples, columns)?; + let mut value = DataValue::clone(&value); + if !matches!(value.logical_type(), LogicalType::Varchar(_, _)) { + value = DataValue::clone(&value) + .cast(&LogicalType::Varchar(None, CharLengthUnits::Characters))?; + } + if let DataValue::Utf8 { + value: Some(value), + ty, + unit, + } = &mut value + { + *value = value.to_lowercase(); + } + Ok(value) + } + + fn monotonicity(&self) -> Option { + todo!() + } + + fn return_type(&self) -> &LogicalType { + &LogicalType::Varchar(None, CharLengthUnits::Characters) + } + + fn summary(&self) -> &FunctionSummary { + &self.summary + } +} diff --git a/src/function/mod.rs b/src/function/mod.rs index a469edb3..6c660c57 100644 --- a/src/function/mod.rs +++ b/src/function/mod.rs @@ -1,2 +1,5 @@ +pub(crate) mod char_length; pub(crate) mod current_date; +pub(crate) mod lower; pub(crate) mod numbers; +pub(crate) mod upper; diff --git a/src/function/upper.rs b/src/function/upper.rs new file mode 100644 index 00000000..bc346aa2 --- /dev/null +++ b/src/function/upper.rs @@ -0,0 +1,71 @@ +use crate::catalog::ColumnRef; +use crate::errors::DatabaseError; +use crate::expression::function::scala::FuncMonotonicity; +use crate::expression::function::scala::ScalarFunctionImpl; +use crate::expression::function::FunctionSummary; +use crate::expression::ScalarExpression; +use crate::types::tuple::Tuple; +use crate::types::value::DataValue; +use crate::types::LogicalType; +use serde::Deserialize; +use serde::Serialize; +use sqlparser::ast::CharLengthUnits; +use std::sync::Arc; + +#[derive(Debug, Serialize, Deserialize)] +pub(crate) struct Upper { + summary: FunctionSummary, +} + +impl Upper { + #[allow(unused_mut)] + pub(crate) fn new() -> Arc { + let function_name = "upper".to_lowercase(); + let arg_types = vec![LogicalType::Varchar(None, CharLengthUnits::Characters)]; + Arc::new(Self { + summary: FunctionSummary { + name: function_name, + arg_types, + }, + }) + } +} + +#[typetag::serde] +impl ScalarFunctionImpl for Upper { + #[allow(unused_variables, clippy::redundant_closure_call)] + fn eval( + &self, + exprs: &[ScalarExpression], + tuples: &Tuple, + columns: &[ColumnRef], + ) -> Result { + let value = exprs[0].eval(tuples, columns)?; + let mut value = DataValue::clone(&value); + if !matches!(value.logical_type(), LogicalType::Varchar(_, _)) { + value = DataValue::clone(&value) + .cast(&LogicalType::Varchar(None, CharLengthUnits::Characters))?; + } + if let DataValue::Utf8 { + value: Some(value), + ty, + unit, + } = &mut value + { + *value = value.to_uppercase(); + } + Ok(value) + } + + fn monotonicity(&self) -> Option { + todo!() + } + + fn return_type(&self) -> &LogicalType { + &LogicalType::Varchar(None, CharLengthUnits::Characters) + } + + fn summary(&self) -> &FunctionSummary { + &self.summary + } +} diff --git a/tests/slt/sql_2016/E021_04.slt b/tests/slt/sql_2016/E021_04.slt index dc7a3a52..72ec6019 100644 --- a/tests/slt/sql_2016/E021_04.slt +++ b/tests/slt/sql_2016/E021_04.slt @@ -1,14 +1,11 @@ # E021-04: CHARACTER_LENGTH function -# TODO: CHARACTER_LENGTH()/CHAR_LENGTH() - -# query I -# SELECT CHARACTER_LENGTH ( 'foo' ) -# ---- -# 3 - - -# query I -# SELECT CHAR_LENGTH ( 'foo' ) -# ---- -# 3 +query I +SELECT CHARACTER_LENGTH ( 'foo' ) +---- +3 + +query I +SELECT CHAR_LENGTH ( 'foo' ) +---- +3 diff --git a/tests/slt/sql_2016/E021_08.slt b/tests/slt/sql_2016/E021_08.slt index 8c0ba89a..49214b9c 100644 --- a/tests/slt/sql_2016/E021_08.slt +++ b/tests/slt/sql_2016/E021_08.slt @@ -1,13 +1,31 @@ # E021-08: UPPER and LOWER functions -# TODO: LOWER()/UPPER() +query T +SELECT LOWER ( 'FOO' ) +---- +foo -# query T -# SELECT LOWER ( 'foo' ) -# ---- -# 'foo' +query T +SELECT LOWER ( 'foo' ) +---- +foo -# query T -# SELECT UPPER ( 'foo' ) -# ---- -# 'FOO' +query T +SELECT UPPER ( 'foo' ) +---- +FOO + +query T +SELECT UPPER ( 'FOO' ) +---- +FOO + +query T +SELECT UPPER ( LOWER ( 'FOO' ) ) +---- +FOO + +query T +SELECT LOWER ( UPPER ( 'foo' ) ) +---- +foo