Trying to fix rebase issues

Author: edmondop

datafusion/core/tests/dataframe/mod.rs

@@ -52,7 +52,7 @@ use datafusion_execution::runtime_env::RuntimeEnv;
 use datafusion_expr::expr::{GroupingSet, Sort};
 use datafusion_expr::var_provider::{VarProvider, VarType};
 use datafusion_expr::{
-    array_agg, avg, cast, col, exists, expr, in_subquery, lit, max, out_ref_col,
+    array_agg, avg, cast, col, exists, expr, in_subquery, lit, out_ref_col,
     placeholder, scalar_subquery, when, wildcard, Expr, ExprSchemable, WindowFrame,
     WindowFrameBound, WindowFrameUnits, WindowFunctionDefinition,
 };

datafusion/expr/src/aggregate_function.rs

@@ -154,11 +154,6 @@ impl AggregateFunction {
             AggregateFunction::Grouping | AggregateFunction::ArrayAgg => {
                 Signature::any(1, Volatility::Immutable)
             }
-            AggregateFunction::BitAnd
-            | AggregateFunction::BitOr
-            | AggregateFunction::BitXor => {
-                Signature::uniform(1, INTEGERS.to_vec(), Volatility::Immutable)
-            }
             AggregateFunction::BoolAnd | AggregateFunction::BoolOr => {
                 Signature::uniform(1, vec![DataType::Boolean], Volatility::Immutable)
             }

datafusion/expr/src/type_coercion/aggregates.rs

@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::ops::Deref;
 
 use crate::{AggregateFunction, Signature, TypeSignature};
 
@@ -203,22 +202,6 @@ pub fn check_arg_count(
     Ok(())
 }
 
-fn get_min_max_result_type(input_types: &[DataType]) -> Result<Vec<DataType>> {
-    // make sure that the input types only has one element.
-    assert_eq!(input_types.len(), 1);
-    // min and max support the dictionary data type
-    // unpack the dictionary to get the value
-    match &input_types[0] {
-        DataType::Dictionary(_, dict_value_type) => {
-            // TODO add checker, if the value type is complex data type
-            Ok(vec![dict_value_type.deref().clone()])
-        }
-        // TODO add checker for datatype which min and max supported
-        // For example, the `Struct` and `Map` type are not supported in the MIN and MAX function
-        _ => Ok(input_types.to_vec()),
-    }
-}
-
 /// function return type of a sum
 pub fn sum_return_type(arg_type: &DataType) -> Result<DataType> {
     match arg_type {

datafusion/functions-aggregate/src/min_max.rs

@@ -572,7 +572,7 @@ impl AggregateUDFImpl for Max {
     }
 
     fn accumulator(&self, acc_args: AccumulatorArgs) -> Result<Box<dyn Accumulator>> {
-        Ok(Box::new(MaxAccumulator::try_new(&acc_args.data_type)?))
+        Ok(Box::new(MaxAccumulator::try_new(acc_args.data_type)?))
     }
 
     fn aliases(&self) -> &[String] {
@@ -744,7 +744,7 @@ impl AggregateUDFImpl for Min {
     }
 
     fn accumulator(&self, acc_args: AccumulatorArgs) -> Result<Box<dyn Accumulator>> {
-        Ok(Box::new(MinAccumulator::try_new(&acc_args.data_type)?))
+        Ok(Box::new(MinAccumulator::try_new(acc_args.data_type)?))
     }
 
     fn aliases(&self) -> &[String] {

datafusion/proto/src/logical_plan/from_proto.rs

@@ -145,7 +145,6 @@ impl From<protobuf::AggregateFunction> for AggregateFunction {
             protobuf::AggregateFunction::Correlation => Self::Correlation,
             protobuf::AggregateFunction::Grouping => Self::Grouping,
             protobuf::AggregateFunction::NthValueAgg => Self::NthValue,
-            protobuf::AggregateFunction::StringAgg => Self::StringAgg,
             protobuf::AggregateFunction::UNUSED => panic!("This should never happen, we are retiring this but protobuf doesn't support enum with no 0 values"),
         }
     }

datafusion/proto/src/logical_plan/to_proto.rs

@@ -372,9 +372,6 @@ pub fn serialize_expr(
             AggregateFunctionDefinition::BuiltIn(fun) => {
                 let aggr_function = match fun {
                     AggregateFunction::ArrayAgg => protobuf::AggregateFunction::ArrayAgg,
-                    AggregateFunction::BitAnd => protobuf::AggregateFunction::BitAnd,
-                    AggregateFunction::BitOr => protobuf::AggregateFunction::BitOr,
-                    AggregateFunction::BitXor => protobuf::AggregateFunction::BitXor,
                     AggregateFunction::BoolAnd => protobuf::AggregateFunction::BoolAnd,
                     AggregateFunction::BoolOr => protobuf::AggregateFunction::BoolOr,
                     AggregateFunction::Avg => protobuf::AggregateFunction::Avg,

datafusion/proto/src/physical_plan/to_proto.rs

@@ -23,11 +23,11 @@ use datafusion::datasource::file_format::parquet::ParquetSink;
 use datafusion::physical_expr::window::{NthValueKind, SlidingAggregateWindowExpr};
 use datafusion::physical_expr::{PhysicalSortExpr, ScalarFunctionExpr};
 use datafusion::physical_plan::expressions::{
-    ArrayAgg, Avg, BinaryExpr, BitAnd, BitOr, BitXor, BoolAnd, BoolOr, CaseExpr,
-    CastExpr, Column, Correlation, CumeDist, DistinctArrayAgg, DistinctBitXor, Grouping,
+    ArrayAgg, Avg, BinaryExpr, BoolAnd, BoolOr, CaseExpr,
+    CastExpr, Column, Correlation, CumeDist, DistinctArrayAgg, Grouping,
     InListExpr, IsNotNullExpr, IsNullExpr, Literal, NegativeExpr, NotExpr,
     NthValue, NthValueAgg, Ntile, OrderSensitiveArrayAgg, Rank, RankType, RowNumber,
-    StringAgg, TryCastExpr, WindowShift,
+    TryCastExpr, WindowShift,
 };
 use datafusion::physical_plan::udaf::AggregateFunctionExpr;
 use datafusion::physical_plan::windows::{BuiltInWindowExpr, PlainAggregateWindowExpr};

datafusion/proto/tests/cases/roundtrip_logical_plan.rs

@@ -54,7 +54,7 @@ use datafusion_expr::expr::{
 };
 use datafusion_expr::logical_plan::{Extension, UserDefinedLogicalNodeCore};
 use datafusion_expr::{
-    Accumulator, AggregateExt, AggregateFunction, ColumnarValue, ExprSchemable,
+    Accumulator, AggregateExt,  ColumnarValue, ExprSchemable,
     LogicalPlan, Operator, PartitionEvaluator, ScalarUDF, ScalarUDFImpl, Signature,
     TryCast, Volatility, WindowFrame, WindowFrameBound, WindowFrameUnits,
     WindowFunctionDefinition, WindowUDF, WindowUDFImpl,
@@ -2026,14 +2026,6 @@ fn roundtrip_window() {
         WindowFrameBound::Following(ScalarValue::UInt64(Some(2))),
     );
 
-    let test_expr4 = Expr::WindowFunction(expr::WindowFunction::new(
-        WindowFunctionDefinition::AggregateFunction(AggregateFunction::Max),
-        vec![col("col1")],
-        vec![col("col1")],
-        vec![col("col2")],
-        row_number_frame.clone(),
-        None,
-    ));
 
     // 5. test with AggregateUDF
     #[derive(Debug)]
@@ -2168,7 +2160,6 @@ fn roundtrip_window() {
     roundtrip_expr_test(test_expr1, ctx.clone());
     roundtrip_expr_test(test_expr2, ctx.clone());
     roundtrip_expr_test(test_expr3, ctx.clone());
-    roundtrip_expr_test(test_expr4, ctx.clone());
     roundtrip_expr_test(test_expr5, ctx.clone());
     roundtrip_expr_test(test_expr6, ctx);
 }