dataflow-expression: Add support for the length's functions

This commit adds support for the length, char_length, character_length
and octet_length functions. These functions behavior depend on their
dialect. PostgreSQL counts amount of bytes when using octet_length and
characters otherwise. For MySQL, length and octet_length is the number
 of bytes in the string, and char_length or character_length is the
number of characters in the string.
Also, PostgreSQL is strict to on the input type, so it will return an
error if the input is not a string. MySQL, on the other hand, will
convert the input to a string and return the length of the string.

Release-Note-Core: Add support for `length`, `char_length`,
  `character_length` and `octet_length` functions.
Change-Id: I888f1e8bfde1c61cd4a00a66fd40727a8f344bc1
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/8004
Tested-by: Buildkite CI
Reviewed-by: Jason Brown <jason.b@readyset.io>

Author: altmannmarcelo

dataflow-expression/src/eval/builtins.rs

@@ -12,6 +12,7 @@ use chrono_tz::Tz;
 use itertools::Either;
 use mysql_time::MySqlTime;
 use nom_sql::TimestampField;
+use readyset_data::dialect::SqlEngine;
 use readyset_data::{DfType, DfValue, TimestampTz};
 use readyset_errors::{internal, invalid_query_err, unsupported, ReadySetError, ReadySetResult};
 use readyset_util::math::integer_rnd;
@@ -1267,6 +1268,52 @@ impl BuiltinFunction {
                 }
                 .and_then(|value| value.coerce_to(ty, &DfType::Unknown))
             }
+            BuiltinFunction::Length {
+                expr,
+                in_bytes,
+                dialect,
+            } => {
+                let s = non_null!(expr.eval(record)?);
+                match dialect.engine() {
+                    SqlEngine::PostgreSQL => {
+                        if !matches!(s, DfValue::Text(_) | DfValue::TinyText(_)) {
+                            return Err(invalid_query_err!("LENGTH() requires a string argument"));
+                        };
+                        let s = s.to_string();
+                        let len = if *in_bytes {
+                            s.len() as i64
+                        } else {
+                            s.chars().count() as i64
+                        };
+                        Ok(DfValue::Int(len))
+                    }
+                    SqlEngine::MySQL => match s {
+                        DfValue::None
+                        | DfValue::Max
+                        | DfValue::PassThrough(_)
+                        | DfValue::BitVector(_)
+                        | DfValue::Array(_)
+                        | DfValue::ByteArray(_) => Ok(DfValue::None),
+                        DfValue::Double(_)
+                        | DfValue::Float(_)
+                        | DfValue::Int(_)
+                        | DfValue::Numeric(_)
+                        | DfValue::Text(_)
+                        | DfValue::Time(_)
+                        | DfValue::TimestampTz(_)
+                        | DfValue::TinyText(_)
+                        | DfValue::UnsignedInt(_) => {
+                            let s = s.to_string();
+                            let len = if *in_bytes {
+                                s.len() as i64
+                            } else {
+                                s.chars().count() as i64
+                            };
+                            Ok(DfValue::Int(len))
+                        }
+                    },
+                }
+            }
         }
     }
 }
@@ -3335,4 +3382,50 @@ mod tests {
         test_with_null_string("{null,1,2,3,null,5}", "*,1,2,3,*,5");
         test_with_null_string("{{1,2},{3,4},{null,5}}", "1,2,3,4,*,5");
     }
+
+    #[test]
+    fn length() {
+        // MySQL
+        let expr = "octet_length('ザ')";
+        assert_eq!(eval_expr(expr, MySQL), 3.into());
+
+        let expr = "length('hello')";
+        assert_eq!(eval_expr(expr, MySQL), 5.into());
+
+        let expr = "length('')";
+        assert_eq!(eval_expr(expr, MySQL), 0.into());
+
+        let expr = "length(null)";
+        assert_eq!(eval_expr(expr, MySQL), DfValue::None);
+
+        let expr = "length('ザ')";
+        assert_eq!(eval_expr(expr, MySQL), 3.into());
+
+        let expr = "char_length('ザ')";
+        assert_eq!(eval_expr(expr, MySQL), 1.into());
+
+        let expr = "character_length('ザ')";
+        assert_eq!(eval_expr(expr, MySQL), 1.into());
+
+        let expr = "length(1)";
+        assert_eq!(eval_expr(expr, MySQL), 1.into());
+
+        let expr = "char_length(1)";
+        assert_eq!(eval_expr(expr, MySQL), 1.into());
+
+        // PostgreSQL
+        let expr = "length('ザ')";
+        assert_eq!(eval_expr(expr, PostgreSQL), 1.into());
+
+        let expr = "char_length('ザ')";
+        assert_eq!(eval_expr(expr, PostgreSQL), 1.into());
+
+        let expr = "octet_length('ザ')";
+        assert_eq!(eval_expr(expr, PostgreSQL), 3.into());
+
+        let expr = "length(1)";
+        if let Ok(value) = try_eval_expr(expr, PostgreSQL) {
+            panic!("Expected error for `{expr}`, got {value:?}");
+        }
+    }
 }

dataflow-expression/src/lib.rs

@@ -115,6 +115,16 @@ pub enum BuiltinFunction {
 
     /// [`date_trunc`](https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC)
     Extract(TimestampField, Expr),
+
+    /// `length` | `char_length` | `character_length`:
+    /// * [MySQL](https://dev.mysql.com/doc/refman/8.4/en/string-functions.html#function_length)
+    /// * [Postgres](https://www.postgresql.org/docs/current/functions-string.html#FUNCTIONS-LENGTH)
+    ///
+    Length {
+        expr: Expr,
+        in_bytes: bool, // if true, return the length in bytes, otherwise in characters
+        dialect: Dialect,
+    },
 }
 
 impl BuiltinFunction {
@@ -150,6 +160,7 @@ impl BuiltinFunction {
             ArrayToString { .. } => "array_to_string",
             DateTrunc { .. } => "date_trunc",
             Extract { .. } => "extract",
+            Length { .. } => "length",
         }
     }
 }
@@ -251,6 +262,9 @@ impl Display for BuiltinFunction {
             Extract(field, expr) => {
                 write!(f, "({} FROM {})", field, expr)
             }
+            Length { expr, .. } => {
+                write!(f, "({})", expr)
+            }
         }
     }
 }

dataflow-expression/src/lower.rs

@@ -448,6 +448,26 @@ impl BuiltinFunction {
 
                 (Self::DateTrunc(precision, source), ret_type)
             }
+            "length" | "octet_length" | "char_length" | "character_length" => {
+                // MySQL - `LENGTH()`, `OCTET_LENGTH()` = in bytes | `CHAR_LENGTH()`, `CHARACTER_LENGTH()` = in characters
+                // PostgreSQL - `OCTET_LENGTH()` = in bytes | `LENGTH()`, `CHAR_LENGTH()`, `CHARACTER_LENGTH()` = in characters
+                let expr = next_arg()?;
+                let ty = if expr.ty().is_any_text() {
+                    DfType::BigInt
+                } else {
+                    DfType::Int
+                };
+                let in_bytes = (matches!(dialect.engine(), SqlEngine::MySQL) && name == "length")
+                    || name == "octet_length";
+                (
+                    Self::Length {
+                        expr,
+                        in_bytes,
+                        dialect,
+                    },
+                    ty,
+                )
+            }
             _ => unsupported!("Function {name} does not exist"),
         };