branch 49

Author: xudong963

datafusion/expr/src/expr.rs

@@ -284,13 +284,8 @@ pub enum Expr {
     Column(Column),
     /// A named reference to a variable in a registry.
     ScalarVariable(DataType, Vec<String>),
-<<<<<<< HEAD
-    /// A constant value along with associated metadata
-    Literal(ScalarValue, Option<BTreeMap<String, String>>),
-=======
     /// A constant value along with associated [`FieldMetadata`].
     Literal(ScalarValue, Option<FieldMetadata>),
->>>>>>> upstream/branch-49
     /// A binary expression such as "age > 21"
     BinaryExpr(BinaryExpr),
     /// LIKE expression

datafusion/expr/src/literal.rs

@@ -20,7 +20,6 @@
 use crate::expr::FieldMetadata;
 use crate::Expr;
 use datafusion_common::ScalarValue;
-use std::collections::HashMap;
 
 /// Create a literal expression
 pub fn lit<T: Literal>(n: T) -> Expr {

datafusion/optimizer/src/push_down_filter.rs

@@ -40,7 +40,6 @@ use datafusion_expr::{
 };
 
 use crate::optimizer::ApplyOrder;
-use crate::simplify_expressions::simplify_predicates;
 use crate::utils::{has_all_column_refs, is_restrict_null_predicate};
 use crate::{simplify_predicates::simplify_predicates, OptimizerConfig, OptimizerRule};
 

datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs

@@ -18,7 +18,7 @@
 //! Expression simplification API
 
 use std::borrow::Cow;
-use std::collections::{BTreeMap, HashSet};
+use std::collections::HashSet;
 use std::ops::Not;
 
 use arrow::{

datafusion/optimizer/src/simplify_predicates.rs

@@ -43,8 +43,8 @@ pub(crate) fn simplify_predicates(predicates: Vec<Expr>) -> Result<Vec<Expr>> {
             {
                 let left_col = extract_column_from_expr(left);
                 let right_col = extract_column_from_expr(right);
-                let left_lit = left.is_literal();
-                let right_lit = right.is_literal();
+                let left_lit = left.as_literal().is_some();
+                let right_lit = right.as_literal().is_some();
                 if let (Some(col), true) = (&left_col, right_lit) {
                     column_predicates.entry(col.clone()).or_default().push(pred);
                 } else if let (true, Some(col)) = (left_lit, &right_col) {
@@ -80,7 +80,7 @@ fn simplify_column_predicates(predicates: Vec<Expr>) -> Result<Vec<Expr>> {
     for pred in predicates {
         match &pred {
             Expr::BinaryExpr(BinaryExpr { left: _, op, right }) => {
-                let right_is_literal = right.is_literal();
+                let right_is_literal = right.as_literal().is_some();
                 match (op, right_is_literal) {
                     (Operator::Gt, true)
                     | (Operator::Lt, false)
@@ -149,14 +149,11 @@ fn find_most_restrictive_predicate(
         if let Expr::BinaryExpr(BinaryExpr { left, op: _, right }) = pred {
             // Extract the literal value based on which side has it
             let mut scalar_value = None;
-            if right.is_literal() {
-                if let Expr::Literal(scalar, _) = right.as_ref() {
-                    scalar_value = Some(scalar.clone());
-                }
-            } else if left.is_literal() {
-                if let Expr::Literal(scalar, _) = left.as_ref() {
-                    scalar_value = Some(scalar.clone());
-                }
+            if let Some(scalar) = right.as_literal() {
+                scalar_value = Some(scalar.clone());
+            }
+            if let Some(scalar) = left.as_literal() {
+                scalar_value = Some(scalar.clone());
             }
 
             if let Some(scalar) = scalar_value {

datafusion/physical-expr/src/expressions/in_list.rs

@@ -1451,11 +1451,7 @@ mod tests {
         let sql_string = fmt_sql(expr.as_ref()).to_string();
         let display_string = expr.to_string();
         assert_eq!(sql_string, "a IN (a, b)");
-<<<<<<< HEAD
-        assert_eq!(display_string, "Use a@0 IN (SET) ([Literal { value: Utf8(\"a\"), field: Field { name: \"a\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} } }, Literal { value: Utf8(\"b\"), field: Field { name: \"b\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} } }])");
-=======
         assert_eq!(display_string, "Use a@0 IN (SET) ([Literal { value: Utf8(\"a\"), field: Field { name: \"lit\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} } }, Literal { value: Utf8(\"b\"), field: Field { name: \"lit\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} } }])");
->>>>>>> upstream/branch-49
 
         // Test: a NOT IN ('a', 'b')
         let list = vec![lit("a"), lit("b")];

datafusion/physical-expr/src/expressions/literal.rs

@@ -18,7 +18,6 @@
 //! Literal expressions for physical operations
 
 use std::any::Any;
-use std::collections::HashMap;
 use std::hash::Hash;
 use std::sync::Arc;
 

datafusion/physical-expr/src/planner.rs

@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::collections::HashMap;
 use std::sync::Arc;
 
 use crate::ScalarFunctionExpr;

datafusion/physical-expr/src/window/aggregate.rs

@@ -46,6 +46,7 @@ pub struct PlainAggregateWindowExpr {
     partition_by: Vec<Arc<dyn PhysicalExpr>>,
     order_by: Vec<PhysicalSortExpr>,
     window_frame: Arc<WindowFrame>,
+    is_constant_in_partition: bool,
 }
 
 impl PlainAggregateWindowExpr {
@@ -56,11 +57,14 @@ impl PlainAggregateWindowExpr {
         order_by: &[PhysicalSortExpr],
         window_frame: Arc<WindowFrame>,
     ) -> Self {
+        let is_constant_in_partition =
+            Self::is_window_constant_in_partition(order_by, &window_frame);
         Self {
             aggregate,
             partition_by: partition_by.to_vec(),
             order_by: order_by.to_vec(),
             window_frame,
+            is_constant_in_partition,
         }
     }
 
@@ -246,4 +250,8 @@ impl AggregateWindowExpr for PlainAggregateWindowExpr {
             accumulator.evaluate()
         }
     }
+
+    fn is_constant_in_partition(&self) -> bool {
+        self.is_constant_in_partition
+    }
 }

datafusion/physical-expr/src/window/sliding_aggregate.rs

@@ -217,4 +217,8 @@ impl AggregateWindowExpr for SlidingAggregateWindowExpr {
             accumulator.evaluate()
         }
     }
+
+    fn is_constant_in_partition(&self) -> bool {
+        false
+    }
 }