Remove windows in expresion

Signed-off-by: Xuanwo <github@xuanwo.io>

Author: Xuanwo

src/query/legacy-planners/src/plan_expression.rs

@@ -20,7 +20,6 @@ use common_exception::ErrorCode;
 use common_exception::Result;
 use common_functions::aggregates::AggregateFunctionFactory;
 use common_functions::aggregates::AggregateFunctionRef;
-use common_functions::window::WindowFrame;
 use once_cell::sync::Lazy;
 
 use crate::plan_expression_common::ExpressionDataTypeVisitor;
@@ -75,22 +74,6 @@ pub enum Expression {
         args: Vec<Expression>,
     },
 
-    /// WindowFunction
-    WindowFunction {
-        /// operation performed
-        op: String,
-        /// params
-        params: Vec<DataValue>,
-        /// arguments
-        args: Vec<Expression>,
-        /// partition by
-        partition_by: Vec<Expression>,
-        /// order by
-        order_by: Vec<Expression>,
-        /// window frame
-        window_frame: Option<WindowFrame>,
-    },
-
     /// A sort expression, that can be used to sort values.
     Sort {
         /// The expression to sort on
@@ -348,53 +331,6 @@ impl fmt::Debug for Expression {
                 Ok(())
             }
 
-            Expression::WindowFunction {
-                op,
-                params,
-                args,
-                partition_by,
-                order_by,
-                window_frame,
-            } => {
-                let args_column_name = args.iter().map(Expression::column_name).collect::<Vec<_>>();
-                let params_name = params
-                    .iter()
-                    .map(|v| DataValue::custom_display(v, true))
-                    .collect::<Vec<_>>();
-
-                if params.is_empty() {
-                    write!(f, "{}", op)?;
-                } else {
-                    write!(f, "{}({})", op, params_name.join(", "))?;
-                }
-
-                write!(f, "({})", args_column_name.join(","))?;
-
-                write!(f, " OVER(")?;
-                if !partition_by.is_empty() {
-                    write!(f, "PARTITION BY {:?}", partition_by)?;
-                }
-                if !order_by.is_empty() {
-                    if !partition_by.is_empty() {
-                        write!(f, " ")?;
-                    }
-                    write!(f, "ORDER BY {:?}", order_by)?;
-                }
-                if let Some(window_frame) = window_frame {
-                    if !partition_by.is_empty() || !order_by.is_empty() {
-                        write!(f, " ")?;
-                    }
-                    write!(
-                        f,
-                        "{} BETWEEN {} AND {}",
-                        window_frame.units, window_frame.start_bound, window_frame.end_bound
-                    )?;
-                }
-                write!(f, ")")?;
-
-                Ok(())
-            }
-
             Expression::Sort { expr, .. } => write!(f, "{:?}", expr),
             Expression::Wildcard => write!(f, "*"),
             Expression::Cast {

src/query/legacy-planners/src/plan_expression_chain.rs

@@ -179,8 +179,6 @@ impl ExpressionChain {
                 ));
             }
 
-            Expression::WindowFunction { .. } => {}
-
             Expression::Wildcard | Expression::Sort { .. } => {}
 
             Expression::Cast {

src/query/legacy-planners/src/plan_expression_common.rs

@@ -17,7 +17,6 @@ use std::collections::HashSet;
 use common_datavalues::prelude::*;
 use common_exception::ErrorCode;
 use common_exception::Result;
-use common_functions::aggregates::AggregateFunctionFactory;
 use common_functions::scalars::FunctionFactory;
 
 use crate::validate_function_arg;
@@ -119,37 +118,7 @@ impl ExpressionVisitor for ExpressionDataTypeVisitor {
                 self.stack.push(return_type);
                 Ok(self)
             }
-            Expression::WindowFunction {
-                op,
-                params,
-                args,
-                partition_by,
-                order_by,
-                ..
-            } => {
-                for _ in 0..partition_by.len() + order_by.len() {
-                    self.stack.remove(0);
-                }
-
-                if !AggregateFunctionFactory::instance().check(op) {
-                    return Err(ErrorCode::LogicalError(
-                        "not yet support non aggr window function",
-                    ));
-                }
-
-                let mut fields = Vec::with_capacity(args.len());
-                for arg in args.iter() {
-                    let arg_type = self.stack.remove(0);
-                    fields.push(DataField::new(&arg.column_name(), arg_type));
-                }
 
-                let aggregate_window_function =
-                    AggregateFunctionFactory::instance().get(op, params.clone(), fields);
-                let return_type = aggregate_window_function.unwrap().return_type().unwrap();
-
-                self.stack.push(return_type);
-                Ok(self)
-            }
             Expression::Cast { data_type, .. } => {
                 let inner_type = match self.stack.pop() {
                     None => Err(ErrorCode::LogicalError(

src/query/legacy-planners/src/plan_expression_visitor.rs

@@ -66,22 +66,6 @@ pub trait ExpressionVisitor: Sized {
                                         stack.push(RecursionProcessing::Call(arg));
                                     }
                                 }
-                                Expression::WindowFunction {
-                                    args,
-                                    partition_by,
-                                    order_by,
-                                    ..
-                                } => {
-                                    for arg_expr in args {
-                                        stack.push(RecursionProcessing::Call(arg_expr));
-                                    }
-                                    for part_by_expr in partition_by {
-                                        stack.push(RecursionProcessing::Call(part_by_expr));
-                                    }
-                                    for order_by_expr in order_by {
-                                        stack.push(RecursionProcessing::Call(order_by_expr));
-                                    }
-                                }
                                 Expression::Cast { expr, .. } => {
                                     stack.push(RecursionProcessing::Call(expr));
                                 }