Move box down, demonstrate specialized functions

Signed-off-by: Moritz Hoffmann <mh@materialize.com>

Author: antiguru

src/compute/src/compute_state.rs

@@ -1392,7 +1392,7 @@ impl IndexPeek {
         let mut literals = peek.literal_constraints.iter().flatten();
         let mut current_literal = None;
 
-        let static_mfp = StaticMapFilterProject::from(peek.map_filter_project.clone());
+        let static_mfp = StaticMapFilterProject::from(&peek.map_filter_project);
 
         while cursor.key_valid(&storage) {
             if has_literal_constraints {

src/expr/src/linear.rs

@@ -2121,22 +2121,18 @@ pub struct StaticMapFilterProject {
     pub input_arity: usize,
 }
 
-impl From<SafeMfpPlan> for StaticMapFilterProject {
-    fn from(value: SafeMfpPlan) -> Self {
-        value.mfp.into()
+impl From<&SafeMfpPlan> for StaticMapFilterProject {
+    fn from(value: &SafeMfpPlan) -> Self {
+        (&value.mfp).into()
     }
 }
 
-impl From<MapFilterProject> for StaticMapFilterProject {
-    fn from(mfp: MapFilterProject) -> Self {
+impl From<&MapFilterProject> for StaticMapFilterProject {
+    fn from(mfp: &MapFilterProject) -> Self {
         Self {
-            expressions: mfp.expressions.into_iter().map(Into::into).collect(),
-            predicates: mfp
-                .predicates
-                .into_iter()
-                .map(|(i, e)| (i, e.into()))
-                .collect(),
-            projection: mfp.projection,
+            expressions: mfp.expressions.iter().map(|e| e.into()).collect(),
+            predicates: mfp.predicates.iter().map(|(i, e)| (*i, e.into())).collect(),
+            projection: mfp.projection.clone(),
             input_arity: mfp.input_arity,
         }
     }

src/expr/src/scalar/func.rs

@@ -60,11 +60,11 @@ use sha1::Sha1;
 use sha2::{Sha224, Sha256, Sha384, Sha512};
 use subtle::ConstantTimeEq;
 
-use crate::static_eval::StaticMirScalarExpr;
 use crate::scalar::func::format::DateTimeFormat;
 use crate::scalar::{
     ProtoBinaryFunc, ProtoUnaryFunc, ProtoUnmaterializableFunc, ProtoVariadicFunc,
 };
+use crate::static_eval::StaticMirScalarExpr;
 use crate::{like_pattern, EvalError, MirScalarExpr};
 
 #[macro_use]

src/expr/src/static_eval.rs

@@ -7,9 +7,10 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
-use crate::{BinaryFunc, EvalError, MirScalarExpr, UnaryFunc, UnmaterializableFunc, VariadicFunc};
 use mz_repr::{Datum, Row, RowArena};
 
+use crate::{BinaryFunc, EvalError, MirScalarExpr, UnaryFunc, UnmaterializableFunc, VariadicFunc};
+
 type StaticMSEFn = for<'a> fn(
     this: &'a StaticMirScalarExpr,
     datums: &[Datum<'a>],
@@ -19,14 +20,16 @@ type StaticMSEFn = for<'a> fn(
 #[derive(Debug)]
 pub struct StaticMirScalarExpr {
     func: StaticMSEFn,
-    params: StaticMirScalarExprParams,
+    params: Option<Box<StaticMirScalarExprParams>>,
 }
 
 impl StaticMirScalarExpr {
+    #[inline(always)]
     pub(crate) fn params(&self) -> &StaticMirScalarExprParams {
-        &self.params
+        self.params.as_ref().expect("params should exist")
     }
 
+    #[inline(always)]
     pub fn eval<'a>(
         &'a self,
         datums: &[Datum<'a>],
@@ -41,15 +44,47 @@ fn static_column<'a>(
     datums: &[Datum<'a>],
     _temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    Ok(datums[this.params.unwrap_column()])
+    Ok(datums[this.params().unwrap_column()])
+}
+
+fn static_column_0<'a>(
+    _this: &'a StaticMirScalarExpr,
+    datums: &[Datum<'a>],
+    _temp_storage: &'a RowArena,
+) -> Result<Datum<'a>, EvalError> {
+    Ok(datums[0])
+}
+
+fn static_column_1<'a>(
+    _this: &'a StaticMirScalarExpr,
+    datums: &[Datum<'a>],
+    _temp_storage: &'a RowArena,
+) -> Result<Datum<'a>, EvalError> {
+    Ok(datums[1])
+}
+
+fn static_column_2<'a>(
+    _this: &'a StaticMirScalarExpr,
+    datums: &[Datum<'a>],
+    _temp_storage: &'a RowArena,
+) -> Result<Datum<'a>, EvalError> {
+    Ok(datums[2])
+}
+
+fn static_column_3<'a>(
+    _this: &'a StaticMirScalarExpr,
+    datums: &[Datum<'a>],
+    _temp_storage: &'a RowArena,
+) -> Result<Datum<'a>, EvalError> {
+    Ok(datums[3])
 }
 
 fn static_literal<'a>(
     this: &'a StaticMirScalarExpr,
     _datums: &[Datum<'a>],
     _temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    let res = this.params.unwrap_literal();
+    let res = this.params().unwrap_literal();
     match res {
         Ok(row) => Ok(row.unpack_first()),
         Err(e) => Err(e.clone()),
@@ -61,7 +96,7 @@ fn static_call_unmaterializable<'a>(
     _datums: &[Datum<'a>],
     _temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    let x = this.params.unwrap_call_unmaterializable();
+    let x = this.params().unwrap_call_unmaterializable();
     Err(EvalError::Internal(
         format!("cannot evaluate unmaterializable function: {:?}", x).into(),
     ))
@@ -72,7 +107,7 @@ fn static_call_binary<'a>(
     datums: &[Datum<'a>],
     temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    let (func, expr1, expr2) = this.params.unwrap_call_binary();
+    let (func, expr1, expr2) = this.params().unwrap_call_binary();
     let a = expr1.eval(datums, temp_storage)?;
     let b = expr2.eval(datums, temp_storage)?;
     func.eval_input(temp_storage, a, b)
@@ -83,7 +118,7 @@ fn static_call_variadic<'a>(
     datums: &[Datum<'a>],
     temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    let (func, exprs) = this.params.unwrap_call_variadic();
+    let (func, exprs) = this.params().unwrap_call_variadic();
     func.eval_static(datums, temp_storage, exprs)
 }
 
@@ -92,7 +127,7 @@ fn static_if<'a>(
     datums: &[Datum<'a>],
     temp_storage: &'a RowArena,
 ) -> Result<Datum<'a>, EvalError> {
-    let (cond, then, els) = this.params.unwrap_if();
+    let (cond, then, els) = this.params().unwrap_if();
     match cond.eval(datums, temp_storage)? {
         Datum::True => then.eval(datums, temp_storage),
         Datum::False | Datum::Null => els.eval(datums, temp_storage),
@@ -117,13 +152,13 @@ pub(crate) enum StaticMirScalarExprParams {
     /// A function call that takes one expression as an argument.
     CallUnary {
         func: UnaryFunc,
-        expr: Box<StaticMirScalarExpr>,
+        expr: StaticMirScalarExpr,
     },
     /// A function call that takes two expressions as arguments.
     CallBinary {
         func: BinaryFunc,
-        expr1: Box<StaticMirScalarExpr>,
-        expr2: Box<StaticMirScalarExpr>,
+        expr1: StaticMirScalarExpr,
+        expr2: StaticMirScalarExpr,
     },
     /// A function call that takes an arbitrary number of arguments.
     CallVariadic {
@@ -137,9 +172,9 @@ pub(crate) enum StaticMirScalarExprParams {
     /// users can guard execution (other logical operator do not
     /// short-circuit) and we need to preserve that.
     If {
-        cond: Box<StaticMirScalarExpr>,
-        then: Box<StaticMirScalarExpr>,
-        els: Box<StaticMirScalarExpr>,
+        cond: StaticMirScalarExpr,
+        then: StaticMirScalarExpr,
+        els: StaticMirScalarExpr,
     },
 }
 
@@ -200,54 +235,76 @@ impl StaticMirScalarExprParams {
     }
 }
 
-impl From<MirScalarExpr> for StaticMirScalarExpr {
-    fn from(value: MirScalarExpr) -> Self {
+impl From<&MirScalarExpr> for StaticMirScalarExpr {
+    fn from(value: &MirScalarExpr) -> Self {
         match value {
+            MirScalarExpr::Column(0) => StaticMirScalarExpr {
+                func: static_column_0,
+                params: None,
+            },
+            MirScalarExpr::Column(1) => StaticMirScalarExpr {
+                func: static_column_1,
+                params: None,
+            },
+            MirScalarExpr::Column(2) => StaticMirScalarExpr {
+                func: static_column_2,
+                params: None,
+            },
+            MirScalarExpr::Column(3) => StaticMirScalarExpr {
+                func: static_column_3,
+                params: None,
+            },
             MirScalarExpr::Column(col) => StaticMirScalarExpr {
                 func: static_column,
-                params: StaticMirScalarExprParams::Column(col),
+                params: Some(Box::new(StaticMirScalarExprParams::Column(*col))),
             },
             MirScalarExpr::Literal(res, _) => StaticMirScalarExpr {
                 func: static_literal,
-                params: StaticMirScalarExprParams::Literal(res),
+                params: Some(Box::new(StaticMirScalarExprParams::Literal(res.clone()))),
             },
             MirScalarExpr::CallUnmaterializable(f) => StaticMirScalarExpr {
                 func: static_call_unmaterializable,
-                params: StaticMirScalarExprParams::CallUnmaterializable(f),
+                params: Some(Box::new(StaticMirScalarExprParams::CallUnmaterializable(
+                    f.clone(),
+                ))),
             },
             MirScalarExpr::CallUnary { func, expr } => StaticMirScalarExpr {
                 func: func.static_fn(),
-                params: StaticMirScalarExprParams::CallUnary {
-                    func,
-                    expr: Box::new((*expr).into()),
-                },
+                params: Box::new(StaticMirScalarExprParams::CallUnary {
+                    func: func.clone(),
+                    expr: expr.as_ref().into(),
+                })
+                .into(),
             },
             MirScalarExpr::CallBinary { func, expr1, expr2 } => StaticMirScalarExpr {
                 func: static_call_binary,
-                params: StaticMirScalarExprParams::CallBinary {
-                    func,
-                    expr1: Box::new((*expr1).into()),
-                    expr2: Box::new((*expr2).into()),
-                },
+                params: Box::new(StaticMirScalarExprParams::CallBinary {
+                    func: func.clone(),
+                    expr1: expr1.as_ref().into(),
+                    expr2: expr2.as_ref().into(),
+                })
+                .into(),
             },
             MirScalarExpr::CallVariadic { func, exprs } => StaticMirScalarExpr {
                 func: static_call_variadic,
-                params: StaticMirScalarExprParams::CallVariadic {
-                    func,
+                params: Box::new(StaticMirScalarExprParams::CallVariadic {
+                    func: func.clone(),
                     exprs: exprs
                         .into_iter()
                         .map(|e| e.into())
                         .collect::<Vec<_>>()
                         .into_boxed_slice(),
-                },
+                })
+                .into(),
             },
             MirScalarExpr::If { cond, then, els } => StaticMirScalarExpr {
                 func: static_if,
-                params: StaticMirScalarExprParams::If {
-                    cond: Box::new((*cond).into()),
-                    then: Box::new((*then).into()),
-                    els: Box::new((*els).into()),
-                },
+                params: Box::new(StaticMirScalarExprParams::If {
+                    cond: cond.as_ref().into(),
+                    then: then.as_ref().into(),
+                    els: els.as_ref().into(),
+                })
+                .into(),
             },
         }
     }