From fb448095c1a78b0155e67454b284709b1a3f6e68 Mon Sep 17 00:00:00 2001 From: NANASE Date: Sun, 20 Oct 2024 02:56:07 +0800 Subject: [PATCH 1/3] feat: add function Lower & Upper --- src/db.rs | 4 ++ src/function/lower.rs | 72 ++++++++++++++++++++++++++++++++++ src/function/mod.rs | 2 + src/function/upper.rs | 72 ++++++++++++++++++++++++++++++++++ tests/slt/sql_2016/E021_08.slt | 36 ++++++++++++----- 5 files changed, 177 insertions(+), 9 deletions(-) create mode 100644 src/function/lower.rs create mode 100644 src/function/upper.rs diff --git a/src/db.rs b/src/db.rs index 2a87fd2a..61bf6e3d 100644 --- a/src/db.rs +++ b/src/db.rs @@ -6,7 +6,9 @@ use crate::expression::function::scala::ScalarFunctionImpl; use crate::expression::function::table::TableFunctionImpl; use crate::expression::function::FunctionSummary; 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; @@ -49,6 +51,8 @@ impl DataBaseBuilder { table_functions: Default::default(), }; 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/lower.rs b/src/function/lower.rs new file mode 100644 index 00000000..fd5b55be --- /dev/null +++ b/src/function/lower.rs @@ -0,0 +1,72 @@ +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..9026a026 100644 --- a/src/function/mod.rs +++ b/src/function/mod.rs @@ -1,2 +1,4 @@ pub(crate) mod current_date; pub(crate) mod numbers; +pub(crate) mod lower; +pub(crate) mod upper; \ No newline at end of file diff --git a/src/function/upper.rs b/src/function/upper.rs new file mode 100644 index 00000000..dc5e775c --- /dev/null +++ b/src/function/upper.rs @@ -0,0 +1,72 @@ +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_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 From 643b469616e15da891b80638f78c3ba0f2bd2869 Mon Sep 17 00:00:00 2001 From: NANASE Date: Sun, 20 Oct 2024 03:08:42 +0800 Subject: [PATCH 2/3] chore: codefmt --- src/function/lower.rs | 1 - src/function/mod.rs | 4 ++-- src/function/upper.rs | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/function/lower.rs b/src/function/lower.rs index fd5b55be..86ed71e3 100644 --- a/src/function/lower.rs +++ b/src/function/lower.rs @@ -55,7 +55,6 @@ impl ScalarFunctionImpl for Lower { *value = value.to_lowercase(); } Ok(value) - } fn monotonicity(&self) -> Option { diff --git a/src/function/mod.rs b/src/function/mod.rs index 9026a026..e48c7c2d 100644 --- a/src/function/mod.rs +++ b/src/function/mod.rs @@ -1,4 +1,4 @@ pub(crate) mod current_date; -pub(crate) mod numbers; pub(crate) mod lower; -pub(crate) mod upper; \ No newline at end of file +pub(crate) mod numbers; +pub(crate) mod upper; diff --git a/src/function/upper.rs b/src/function/upper.rs index dc5e775c..bc346aa2 100644 --- a/src/function/upper.rs +++ b/src/function/upper.rs @@ -55,7 +55,6 @@ impl ScalarFunctionImpl for Upper { *value = value.to_uppercase(); } Ok(value) - } fn monotonicity(&self) -> Option { From f6c1afa21c6f6f8b5133eb35ef0166e42b3835ea Mon Sep 17 00:00:00 2001 From: NANASE Date: Sun, 20 Oct 2024 23:49:24 +0800 Subject: [PATCH 3/3] feat: add functions CharLength & CharacterLength --- src/db.rs | 4 ++ src/function/characterlength.rs | 72 +++++++++++++++++++++++++++++++++ src/function/charlength.rs | 72 +++++++++++++++++++++++++++++++++ src/function/mod.rs | 2 + tests/slt/sql_2016/E021_04.slt | 25 +++++++----- 5 files changed, 166 insertions(+), 9 deletions(-) create mode 100644 src/function/characterlength.rs create mode 100644 src/function/charlength.rs diff --git a/src/db.rs b/src/db.rs index 61bf6e3d..de180acb 100644 --- a/src/db.rs +++ b/src/db.rs @@ -5,6 +5,8 @@ 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::characterlength::CharacterLength; +use crate::function::charlength::CharLength; use crate::function::current_date::CurrentDate; use crate::function::lower::Lower; use crate::function::numbers::Numbers; @@ -50,6 +52,8 @@ impl DataBaseBuilder { scala_functions: Default::default(), table_functions: Default::default(), }; + builder = builder.register_scala_function(CharLength::new()); + builder = builder.register_scala_function(CharacterLength::new()); builder = builder.register_scala_function(CurrentDate::new()); builder = builder.register_scala_function(Lower::new()); builder = builder.register_scala_function(Upper::new()); diff --git a/src/function/characterlength.rs b/src/function/characterlength.rs new file mode 100644 index 00000000..f1709643 --- /dev/null +++ b/src/function/characterlength.rs @@ -0,0 +1,72 @@ +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 CharacterLength { + summary: FunctionSummary, +} + +impl CharacterLength { + #[allow(unused_mut)] + pub(crate) fn new() -> 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 CharacterLength { + #[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/charlength.rs b/src/function/charlength.rs new file mode 100644 index 00000000..b67a33e4 --- /dev/null +++ b/src/function/charlength.rs @@ -0,0 +1,72 @@ +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, + }, + }) + } +} + +#[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/mod.rs b/src/function/mod.rs index e48c7c2d..ad3267df 100644 --- a/src/function/mod.rs +++ b/src/function/mod.rs @@ -1,3 +1,5 @@ +pub(crate) mod characterlength; +pub(crate) mod charlength; pub(crate) mod current_date; pub(crate) mod lower; pub(crate) mod numbers; diff --git a/tests/slt/sql_2016/E021_04.slt b/tests/slt/sql_2016/E021_04.slt index dc7a3a52..085213f4 100644 --- a/tests/slt/sql_2016/E021_04.slt +++ b/tests/slt/sql_2016/E021_04.slt @@ -1,14 +1,21 @@ # E021-04: CHARACTER_LENGTH function -# TODO: CHARACTER_LENGTH()/CHAR_LENGTH() +query I +SELECT CHARACTER_LENGTH ( 'foo' ) +---- +3 -# query I -# SELECT CHARACTER_LENGTH ( 'foo' ) -# ---- -# 3 +query I +SELECT CHARACTER_LENGTH ( 'foooof' ) +---- +6 +query I +SELECT CHAR_LENGTH ( 'foo' ) +---- +3 -# query I -# SELECT CHAR_LENGTH ( 'foo' ) -# ---- -# 3 +query I +SELECT CHAR_LENGTH ( 'foooof' ) +---- +6