refactor(cubesql): Finally drop MySQL 💀

rust/cubesql/cubesql/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.28.0"
 authors = ["Cube Dev, Inc."]
 edition = "2018"
 license = "Apache-2.0"
-description = "SQL API for Cube as proxy over MySQL protocol"
+description = "SQL API for Cube as proxy over PostgreSQL protocol"
 documentation = "https://cube.dev/docs"
 homepage = "https://cube.dev"
 

rust/cubesql/cubesql/README.md

@@ -10,7 +10,7 @@
 
 # Cube SQL API
 
-Cube SQL API allows querying Cube via MySQL-compatible SQL.
+Cube SQL API allows querying Cube via PostgreSQL-compatible SQL.
 
 ## License
 

rust/cubesql/cubesql/src/compile/engine/mod.rs

@@ -3,10 +3,7 @@ pub mod information_schema;
 pub mod udf;
 
 mod context;
-mod context_mysql;
 mod context_postgresql;
-mod variable_provider;
 
 // Public API
 pub use context::*;
-pub use variable_provider::*;

rust/cubesql/cubesql/src/compile/engine/udf/common.rs

@@ -12,11 +12,11 @@ use datafusion::{
         array::{
             new_null_array, Array, ArrayBuilder, ArrayRef, BooleanArray, BooleanBuilder,
             Date32Array, Float64Array, Float64Builder, GenericStringArray, Int32Array,
-            Int32Builder, Int64Array, Int64Builder, IntervalDayTimeBuilder,
-            IntervalMonthDayNanoArray, ListArray, ListBuilder, PrimitiveArray, PrimitiveBuilder,
-            StringArray, StringBuilder, StructBuilder, TimestampMicrosecondArray,
-            TimestampMillisecondArray, TimestampNanosecondArray, TimestampNanosecondBuilder,
-            TimestampSecondArray, UInt32Builder, UInt64Builder,
+            Int32Builder, Int64Array, Int64Builder, IntervalMonthDayNanoArray, ListArray,
+            ListBuilder, PrimitiveArray, PrimitiveBuilder, StringArray, StringBuilder,
+            StructBuilder, TimestampMicrosecondArray, TimestampMillisecondArray,
+            TimestampNanosecondArray, TimestampNanosecondBuilder, TimestampSecondArray,
+            UInt32Builder, UInt64Builder,
         },
         compute::{cast, concat},
         datatypes::{
@@ -101,28 +101,6 @@ pub fn create_db_udf(name: String, state: Arc<SessionState>) -> ScalarUDF {
     )
 }
 
-// It's the same as current_user UDF, but with another host
-pub fn create_user_udf(state: Arc<SessionState>) -> ScalarUDF {
-    let fun = make_scalar_function(move |_args: &[ArrayRef]| {
-        let mut builder = StringBuilder::new(1);
-        if let Some(user) = &state.user() {
-            builder.append_value(user.clone() + "@127.0.0.1").unwrap();
-        } else {
-            builder.append_null()?;
-        }
-
-        Ok(Arc::new(builder.finish()) as ArrayRef)
-    });
-
-    create_udf(
-        "user",
-        vec![],
-        Arc::new(DataType::Utf8),
-        Volatility::Immutable,
-        fun,
-    )
-}
-
 pub fn create_current_user_udf(state: Arc<SessionState>, name: &str, with_host: bool) -> ScalarUDF {
     let fun = make_scalar_function(move |_args: &[ArrayRef]| {
         let mut builder = StringBuilder::new(1);
@@ -776,134 +754,6 @@ pub fn create_greatest_udf() -> ScalarUDF {
     )
 }
 
-// CONVERT_TZ() converts a datetime value dt from the time zone given by from_tz to the time zone given by to_tz and returns the resulting value.
-pub fn create_convert_tz_udf() -> ScalarUDF {
-    let fun = make_scalar_function(move |args: &[ArrayRef]| {
-        assert!(args.len() == 3);
-
-        let input_dt = &args[0];
-        let from_tz = &args[1];
-        let to_tz = &args[2];
-
-        let (_, input_tz) = match input_dt.data_type() {
-            DataType::Timestamp(unit, tz) => (unit, tz),
-            _ => {
-                return Err(DataFusionError::Execution(format!(
-                    "dt argument must be a Timestamp, actual: {}",
-                    from_tz.data_type()
-                )));
-            }
-        };
-
-        if from_tz.data_type() == &DataType::UInt8 {
-            return Err(DataFusionError::Execution(format!(
-                "from_tz argument must be a Utf8, actual: {}",
-                from_tz.data_type()
-            )));
-        };
-
-        if to_tz.data_type() == &DataType::UInt8 {
-            return Err(DataFusionError::Execution(format!(
-                "to_tz argument must be a Utf8, actual: {}",
-                to_tz.data_type()
-            )));
-        };
-
-        let from_tz = downcast_string_arg!(&from_tz, "from_tz", i32);
-        let to_tz = downcast_string_arg!(&to_tz, "to_tz", i32);
-
-        if from_tz.value(0) != "SYSTEM" || to_tz.value(0) != "+00:00" {
-            return Err(DataFusionError::NotImplemented(format!(
-                "convert_tz is not implemented, it's stub"
-            )));
-        }
-
-        if let Some(tz) = input_tz {
-            if tz != "UTC" {
-                return Err(DataFusionError::NotImplemented(format!(
-                    "convert_tz does not non UTC timezone as input, actual {}",
-                    tz
-                )));
-            };
-        };
-
-        Ok(input_dt.clone())
-    });
-
-    let return_type: ReturnTypeFunction = Arc::new(move |types| {
-        assert!(types.len() == 3);
-
-        Ok(Arc::new(types[0].clone()))
-    });
-
-    ScalarUDF::new(
-        "convert_tz",
-        &Signature::any(3, Volatility::Immutable),
-        &return_type,
-        &fun,
-    )
-}
-
-pub fn create_timediff_udf() -> ScalarUDF {
-    let fun = make_scalar_function(move |args: &[ArrayRef]| {
-        assert!(args.len() == 2);
-
-        let left_dt = &args[0];
-        let right_dt = &args[1];
-
-        let left_date = match left_dt.data_type() {
-            DataType::Timestamp(TimeUnit::Nanosecond, _) => {
-                let arr = downcast_primitive_arg!(left_dt, "left_dt", TimestampNanosecondType);
-                let ts = arr.value(0);
-
-                // NaiveDateTime::from_timestamp(ts, 0)
-                ts
-            }
-            _ => {
-                return Err(DataFusionError::Execution(format!(
-                    "left_dt argument must be a Timestamp, actual: {}",
-                    left_dt.data_type()
-                )));
-            }
-        };
-
-        let right_date = match right_dt.data_type() {
-            DataType::Timestamp(TimeUnit::Nanosecond, _) => {
-                let arr = downcast_primitive_arg!(right_dt, "right_dt", TimestampNanosecondType);
-                arr.value(0)
-            }
-            _ => {
-                return Err(DataFusionError::Execution(format!(
-                    "right_dt argument must be a Timestamp, actual: {}",
-                    right_dt.data_type()
-                )));
-            }
-        };
-
-        let diff = right_date - left_date;
-        if diff != 0 {
-            return Err(DataFusionError::NotImplemented(format!(
-                "timediff is not implemented, it's stub"
-            )));
-        }
-
-        let mut interal_arr = IntervalDayTimeBuilder::new(1);
-        interal_arr.append_value(diff)?;
-
-        Ok(Arc::new(interal_arr.finish()) as ArrayRef)
-    });
-
-    let return_type: ReturnTypeFunction =
-        Arc::new(move |_| Ok(Arc::new(DataType::Interval(IntervalUnit::DayTime))));
-
-    ScalarUDF::new(
-        "timediff",
-        &Signature::any(2, Volatility::Immutable),
-        &return_type,
-        &fun,
-    )
-}
-
 pub fn create_ends_with_udf() -> ScalarUDF {
     let fun = make_scalar_function(move |args: &[ArrayRef]| {
         assert!(args.len() == 2);