perf: Apply logical regexp optimizations to Utf8View and LargeUtf8 inputs

[petern48]

Which issue does this PR close?

• Closes bug: regexp simplify optimizations don't work on utf8view #20580

Rationale for this change

I ran into a bug that prevented some regexp optimizations from working that were introduced in #15299. After #16290, some SQL types were updated to utf8view. As part of that PR, some expected query plans in sqllogictest were updated to expect the unoptimized version.

I need this fixed to avoid additional test failures while implementing a new regexp optimization for #20579.

What changes are included in this PR?

• Add support for Utf8View and LargeUtf8 in regex.rs.
• Properly return Transformed::no() on cases when the plan isn't modified (previously, it was always returning Transformed::yes()
• Updates the tests back to expect the optimized query plans

Are these changes tested?

Fixed existing tests that previously weren't working. Now they reflect the optimization being reflected properly.

Are there any user-facing changes?

No. Just applying the optimizations to more cases.

[alamb]

Thanks @petern48 -- this looks like an improvement to me

I do think we should add documentation for the newly added pub API (or I have some ideas on how to improve it too)

[alamb]

this is certainly a better plan

[alamb]

If we are going to make this a pub API, we should at least document them, and maybe we can clean it up bit?

Maybe the simplest thing would be to just make it pub (crate) rather than pub

What do you think about something like

pub enum StringScalar<'a> {
  Utf8(&'a ScalarValue, &'str),
  LargeUtf8(&'a ScalarValue, &'str),
  Utf8View(&'a ScalarValue, &'str),
}

impl StringScalar {
  fn try_from_scalar(scalar: &ScalarValue) -> Self { 
...
  }
 
  fn to_scalar(&self, val: &str) -> Expr {
}

That would:

1. Avoid creating DataTypes
2. Put some better documentation in place
3. Encapsulate the logic a bit more

[petern48]

Sounds good! I ended up with a slightly different interface. The main differences between what you proposed and what I ended up with are:

• Utf8(&'a ScalarValue, &'str) -> Utf8(&'a ScalarValue) We can retrieve the str from the ScalarValue
• Renamed to_scalar to to_expr since it returns an Expr
• Added as_str() for convenience
• Added try_from_expr(). I found that using this was cleaner because both call sites provide Exprs, and handle the None cases in the same way. It mainly just collapsed some redundant error handling.
  • I still added try_from_scalar for possible future use, but I left it as private since it isn't used anywhere atm (other than try_from_expr calling it).

impl<'a> StringScalar<'a> {
    pub(crate) fn try_from_expr(expr: &'a Expr) -> Option<Self> { (calls try_from_scalar) }

      // (not actually used anywhere)
    fn try_from_scalar(scalar: &'a ScalarValue) -> Option<Self> { ... }

    pub(crate) fn as_str(&self) -> Option<&'a str> { ... }

    pub(crate) fn to_expr(&self, val: &str) -> Expr { ... }
}

Let me know what you think

[alamb]

Love it -- thank you @petern48