Add built-in functions: position, ocetet_len, bit_len (#282)

- Add implementations
- Update partiql-tests

Author: jpschorr

partiql-conformance-tests/partiql-tests

@@ -1218,6 +1218,32 @@ impl EvalExpr for EvalFnCharLength {
     }
 }
 
+/// Represents a built-in octet length string function, e.g. `octet_length('123456789')`.
+#[derive(Debug)]
+pub struct EvalFnOctetLength {
+    pub value: Box<dyn EvalExpr>,
+}
+
+impl EvalExpr for EvalFnOctetLength {
+    #[inline]
+    fn evaluate(&self, bindings: &Tuple, ctx: &dyn EvalContext) -> Value {
+        string_transform(self.value.evaluate(bindings, ctx), |s| s.len().into())
+    }
+}
+
+/// Represents a built-in bit length string function, e.g. `bit_length('123456789')`.
+#[derive(Debug)]
+pub struct EvalFnBitLength {
+    pub value: Box<dyn EvalExpr>,
+}
+
+impl EvalExpr for EvalFnBitLength {
+    #[inline]
+    fn evaluate(&self, bindings: &Tuple, ctx: &dyn EvalContext) -> Value {
+        string_transform(self.value.evaluate(bindings, ctx), |s| (s.len() * 8).into())
+    }
+}
+
 /// Represents a built-in substring string function, e.g. `substring('123456789' FROM 2)`.
 #[derive(Debug)]
 pub struct EvalFnSubstring {
@@ -1276,6 +1302,38 @@ impl EvalExpr for EvalFnSubstring {
     }
 }
 
+/// Represents a built-in position string function, e.g. `position('3' IN '123456789')`.
+#[derive(Debug)]
+pub struct EvalFnPosition {
+    pub needle: Box<dyn EvalExpr>,
+    pub haystack: Box<dyn EvalExpr>,
+}
+
+impl EvalExpr for EvalFnPosition {
+    #[inline]
+    fn evaluate(&self, bindings: &Tuple, ctx: &dyn EvalContext) -> Value {
+        let needle = match self.needle.evaluate(bindings, ctx) {
+            Null => None,
+            Value::String(s) => Some(s),
+            _ => return Value::Missing,
+        };
+        let haystack = match self.haystack.evaluate(bindings, ctx) {
+            Value::Null => return Value::Null,
+            Value::String(s) => s,
+            _ => return Value::Missing,
+        };
+        if let Some(needle) = needle {
+            haystack
+                .find(needle.as_ref())
+                .map(|l| l + 1)
+                .unwrap_or(0)
+                .into()
+        } else {
+            Value::Null
+        }
+    }
+}
+
 #[inline]
 #[track_caller]
 fn trim<FnTrim>(value: Value, to_trim: Value, trim_fn: FnTrim) -> Value

partiql-eval/src/eval.rs

@@ -11,10 +11,11 @@ use partiql_logical::{
 use crate::eval;
 use crate::eval::{
     EvalBagExpr, EvalBetweenExpr, EvalBinOp, EvalBinOpExpr, EvalDynamicLookup, EvalExpr,
-    EvalFnBtrim, EvalFnCharLength, EvalFnExists, EvalFnLower, EvalFnLtrim, EvalFnRtrim,
-    EvalFnSubstring, EvalFnUpper, EvalIsTypeExpr, EvalJoinKind, EvalLikeMatch, EvalListExpr,
-    EvalLitExpr, EvalPath, EvalPlan, EvalSearchedCaseExpr, EvalSubQueryExpr, EvalTupleExpr,
-    EvalUnaryOp, EvalUnaryOpExpr, EvalVarRef, Evaluable,
+    EvalFnBitLength, EvalFnBtrim, EvalFnCharLength, EvalFnExists, EvalFnLower, EvalFnLtrim,
+    EvalFnOctetLength, EvalFnPosition, EvalFnRtrim, EvalFnSubstring, EvalFnUpper, EvalIsTypeExpr,
+    EvalJoinKind, EvalLikeMatch, EvalListExpr, EvalLitExpr, EvalPath, EvalPlan,
+    EvalSearchedCaseExpr, EvalSubQueryExpr, EvalTupleExpr, EvalUnaryOp, EvalUnaryOpExpr,
+    EvalVarRef, Evaluable,
 };
 use crate::pattern_match::like_to_re_pattern;
 use partiql_value::Value::Null;
@@ -362,6 +363,18 @@ impl EvaluatorPlanner {
                             value: args.pop().unwrap(),
                         })
                     }
+                    CallName::OctetLength => {
+                        assert_eq!(args.len(), 1);
+                        Box::new(EvalFnOctetLength {
+                            value: args.pop().unwrap(),
+                        })
+                    }
+                    CallName::BitLength => {
+                        assert_eq!(args.len(), 1);
+                        Box::new(EvalFnBitLength {
+                            value: args.pop().unwrap(),
+                        })
+                    }
                     CallName::LTrim => {
                         assert_eq!(args.len(), 2);
                         let value = args.pop().unwrap();
@@ -397,6 +410,12 @@ impl EvaluatorPlanner {
                             length,
                         })
                     }
+                    CallName::Position => {
+                        assert_eq!(args.len(), 2);
+                        let haystack = args.pop().unwrap();
+                        let needle = args.pop().unwrap();
+                        Box::new(EvalFnPosition { needle, haystack })
+                    }
                     CallName::Exists => {
                         assert_eq!(args.len(), 1);
                         Box::new(EvalFnExists {

partiql-eval/src/plan.rs

@@ -96,6 +96,36 @@ fn function_call_def_char_len() -> CallDef {
     }
 }
 
+fn function_call_def_octet_len() -> CallDef {
+    CallDef {
+        names: vec!["octet_length"],
+        overloads: vec![CallSpec {
+            input: vec![CallSpecArg::Positional],
+            output: Box::new(|args| {
+                logical::ValueExpr::Call(logical::CallExpr {
+                    name: logical::CallName::OctetLength,
+                    arguments: args,
+                })
+            }),
+        }],
+    }
+}
+
+fn function_call_def_bit_len() -> CallDef {
+    CallDef {
+        names: vec!["bit_length"],
+        overloads: vec![CallSpec {
+            input: vec![CallSpecArg::Positional],
+            output: Box::new(|args| {
+                logical::ValueExpr::Call(logical::CallExpr {
+                    name: logical::CallName::BitLength,
+                    arguments: args,
+                })
+            }),
+        }],
+    }
+}
+
 fn function_call_def_lower() -> CallDef {
     CallDef {
         names: vec!["lower"],
@@ -188,6 +218,21 @@ fn function_call_def_substring() -> CallDef {
     }
 }
 
+fn function_call_def_position() -> CallDef {
+    CallDef {
+        names: vec!["position"],
+        overloads: vec![CallSpec {
+            input: vec![CallSpecArg::Positional, CallSpecArg::Named("in".into())],
+            output: Box::new(|args| {
+                logical::ValueExpr::Call(logical::CallExpr {
+                    name: logical::CallName::Position,
+                    arguments: args,
+                })
+            }),
+        }],
+    }
+}
+
 fn function_call_def_trim() -> CallDef {
     CallDef {
         names: vec!["trim"],
@@ -335,9 +380,12 @@ pub fn function_call_def() -> FnSymTab {
 
     for def in [
         function_call_def_char_len(),
+        function_call_def_octet_len(),
+        function_call_def_bit_len(),
         function_call_def_lower(),
         function_call_def_upper(),
         function_call_def_substring(),
+        function_call_def_position(),
         function_call_def_trim(),
         function_call_def_coalesce(),
         function_call_def_nullif(),

partiql-logical-planner/src/call_defs.rs

@@ -466,10 +466,13 @@ pub enum CallName {
     Lower,
     Upper,
     CharLength,
+    OctetLength,
+    BitLength,
     LTrim,
     BTrim,
     RTrim,
     Substring,
+    Position,
     Exists,
 }
 

partiql-logical/src/lib.rs

@@ -13,7 +13,7 @@ use crate::token_parser::{BufferedToken, TokenParser};
 use once_cell::sync::Lazy;
 use partiql_source_map::line_offset_tracker::LineOffsetTracker;
 
-pub(crate) static BUILT_INS: Lazy<FnExprSet<'static>> = Lazy::new(|| built_ins());
+pub(crate) static BUILT_INS: Lazy<FnExprSet<'static>> = Lazy::new(built_ins);
 
 /// A single "function expression" argument match.
 #[derive(Debug, Clone)]
@@ -107,7 +107,7 @@ mod built_ins {
             #[rustfmt::skip]
             patterns: vec![
                 // e.g. position('foo' in 'xyzfooxyz') => position('foo', in: 'xyzfooxyz')
-                vec![AnyOne(false), AnyStar(false), Kw(Token::In), AnyOne(true), AnyStar(false)]
+                vec![AnyOne(true), AnyStar(false), Kw(Token::In), AnyOne(true), AnyStar(false)]
             ],
         }
     }