sum_ansi_mode_checks_fix_tests

Author: coderfender

native/spark-expr/src/agg_funcs/sum_int.rs

@@ -573,102 +573,3 @@ impl GroupsAccumulator for SumIntGroupsAccumulator {
         size_of_val(self)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use arrow::array::builder::StringBuilder;
-    use arrow::array::{Int64Builder, RecordBatch};
-    use arrow::datatypes::DataType::Int64;
-    use arrow::datatypes::*;
-    use datafusion::common::Result;
-    use datafusion::datasource::memory::MemorySourceConfig;
-    use datafusion::datasource::source::DataSourceExec;
-    use datafusion::execution::TaskContext;
-    use datafusion::logical_expr::AggregateUDF;
-    use datafusion::physical_expr::aggregate::AggregateExprBuilder;
-    use datafusion::physical_expr::expressions::Column;
-    use datafusion::physical_expr::PhysicalExpr;
-    use datafusion::physical_plan::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy};
-    use datafusion::physical_plan::ExecutionPlan;
-    use futures::StreamExt;
-
-    #[test]
-    fn invalid_data_type() {
-        assert!(SumInteger::try_new(DataType::Date32, EvalMode::Legacy).is_err());
-    }
-
-    #[tokio::test]
-    async fn sum_no_overflow() -> Result<()> {
-        let num_rows = 8192;
-        let batch = create_record_batch(num_rows);
-        let mut batches = Vec::new();
-        for _ in 0..10 {
-            batches.push(batch.clone());
-        }
-        let partitions = &[batches];
-        let c0: Arc<dyn PhysicalExpr> = Arc::new(Column::new("c0", 0));
-        let c1: Arc<dyn PhysicalExpr> = Arc::new(Column::new("c1", 1));
-
-        let data_type = Int64;
-        let schema = Arc::clone(&partitions[0][0].schema());
-        let scan: Arc<dyn ExecutionPlan> = Arc::new(DataSourceExec::new(Arc::new(
-            MemorySourceConfig::try_new(partitions, Arc::clone(&schema), None)?,
-        )));
-
-        let aggregate_udf = Arc::new(AggregateUDF::new_from_impl(SumInteger::try_new(
-            data_type.clone(),
-            EvalMode::Legacy,
-        )?));
-
-        let aggr_expr = AggregateExprBuilder::new(aggregate_udf, vec![c1])
-            .schema(Arc::clone(&schema))
-            .alias("sum")
-            .with_ignore_nulls(false)
-            .with_distinct(false)
-            .build()?;
-
-        let aggregate = Arc::new(AggregateExec::try_new(
-            AggregateMode::Partial,
-            PhysicalGroupBy::new_single(vec![(c0, "c0".to_string())]),
-            vec![aggr_expr.into()],
-            vec![None], // no filter expressions
-            scan,
-            Arc::clone(&schema),
-        )?);
-
-        let mut stream = aggregate
-            .execute(0, Arc::new(TaskContext::default()))
-            .unwrap();
-        while let Some(batch) = stream.next().await {
-            let _batch = batch?;
-        }
-
-        Ok(())
-    }
-
-    fn create_record_batch(num_rows: usize) -> RecordBatch {
-        let mut int_builder = Int64Builder::with_capacity(num_rows);
-        let mut string_builder = StringBuilder::with_capacity(num_rows, num_rows * 32);
-        for i in 0..num_rows {
-            int_builder.append_value(i as i64);
-            string_builder.append_value(format!("this is string #{}", i % 1024));
-        }
-        let int_array = Arc::new(int_builder.finish());
-        let string_array = Arc::new(string_builder.finish());
-
-        let mut fields = vec![];
-        let mut columns: Vec<ArrayRef> = vec![];
-
-        // string column
-        fields.push(Field::new("c0", DataType::Utf8, false));
-        columns.push(string_array);
-
-        // decimal column
-        fields.push(Field::new("c1", DataType::Int64, false));
-        columns.push(int_array);
-
-        let schema = Schema::new(fields);
-        RecordBatch::try_new(Arc::new(schema), columns).unwrap()
-    }
-}