daft.functions.regexp_replace#

def regexp_replace(
    expr: Expression,
    pattern: str | Expression,
    replacement: str | Expression,
) -> Expression:
    r"""Replaces all occurrences of a regex pattern in a string column with a replacement string.

    In the replacement, `\1`-`\9`/`$1`-`$9` reference capture groups and `\0`/`$0` the
    whole match; `${name}`/`$name` reference a named group. Only one digit follows a
    backslash, so `\10` is group 1 then a literal `0` and `${10}` reaches group 10.
    `\\` emits a literal backslash and `$$` a literal `$`; any other backslash is
    literal, so `\n` is a backslash followed by `n`, not a newline.

    Args:
        expr: The string expression to be replaced
        pattern: The pattern to replace
        replacement: The replacement string

    Returns:
        Expression: a String expression with patterns replaced by the replacement string

    Examples:
        >>> import daft
        >>> from daft.functions import regexp_replace
        >>>
        >>> df = daft.from_pydict({"data": ["foo", "fooo", "foooo"]})
        >>> df.with_column("replace", regexp_replace(df["data"], r"o+", "a")).collect()
        ╭────────┬─────────╮
        │ data   ┆ replace │
        │ ---    ┆ ---     │
        │ String ┆ String  │
        ╞════════╪═════════╡
        │ foo    ┆ fa      │
        ├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
        │ fooo   ┆ fa      │
        ├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
        │ foooo  ┆ fa      │
        ╰────────┴─────────╯
        <BLANKLINE>
        (Showing first 3 of 3 rows)

        Capture groups and a literal backslash:

        >>> df = daft.from_pydict({"data": ["2024-01-31"]})
        >>> df = df.select(regexp_replace(df["data"], r"(\d+)-(\d+)-(\d+)", r"\3\\\2\\\1"))
        >>> df.to_pydict()["data"]
        ['31\\01\\2024']

    """
    return Expression._call_builtin_scalar_fn("regexp_replace", expr, pattern, replacement)