Delete unused code from stringfunction evaluator

python/cudf_polars/cudf_polars/dsl/expr.py

@@ -688,13 +688,12 @@ def do_evaluate(
                     else pat.obj
                 )
                 return Column(plc.strings.find.contains(column.obj, pattern))
-            else:
-                assert isinstance(arg, Literal)
-                prog = plc.strings.regex_program.RegexProgram.create(
-                    arg.value.as_py(),
-                    flags=plc.strings.regex_flags.RegexFlags.DEFAULT,
-                )
-                return Column(plc.strings.contains.contains_re(column.obj, prog))
+            assert isinstance(arg, Literal)
+            prog = plc.strings.regex_program.RegexProgram.create(
+                arg.value.as_py(),
+                flags=plc.strings.regex_flags.RegexFlags.DEFAULT,
+            )
+            return Column(plc.strings.contains.contains_re(column.obj, prog))
         columns = [
             child.evaluate(df, context=context, mapping=mapping)
             for child in self.children
@@ -725,26 +724,9 @@ def do_evaluate(
                     else prefix.obj,
                 )
             )
-        else:
-            columns = [
-                child.evaluate(df, context=context, mapping=mapping)
-                for child in self.children
-            ]
-            if self.name == pl_expr.StringFunction.Lowercase:
-                (column,) = columns
-                return Column(plc.strings.case.to_lower(column.obj))
-            elif self.name == pl_expr.StringFunction.Uppercase:
-                (column,) = columns
-                return Column(plc.strings.case.to_upper(column.obj))
-            elif self.name == pl_expr.StringFunction.EndsWith:
-                column, suffix = columns
-                return Column(plc.strings.find.ends_with(column.obj, suffix.obj))
-            elif self.name == pl_expr.StringFunction.StartsWith:
-                column, suffix = columns
-                return Column(plc.strings.find.starts_with(column.obj, suffix.obj))
-            raise NotImplementedError(
-                f"StringFunction {self.name}"
-            )  # pragma: no cover; handled by init raising
+        raise NotImplementedError(
+            f"StringFunction {self.name}"
+        )  # pragma: no cover; handled by init raising
 
 
 class Sort(Expr):

python/cudf_polars/tests/expressions/test_stringfunction.py

@@ -2,11 +2,13 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+from functools import partial
+
 import pytest
 
 import polars as pl
 
-from cudf_polars import translate_ir
+from cudf_polars import execute_with_cudf, translate_ir
 from cudf_polars.testing.asserts import assert_gpu_result_equal
 
 
@@ -39,3 +41,70 @@ def test_unsupported_stringfunction():
 
     with pytest.raises(NotImplementedError):
         _ = translate_ir(q._ldf.visit())
+
+
+def test_contains_re_non_strict_raises():
+    df = pl.LazyFrame({"a": ["a"]})
+
+    q = df.select(pl.col("a").str.contains(".", strict=False))
+
+    with pytest.raises(NotImplementedError):
+        _ = translate_ir(q._ldf.visit())
+
+
+def test_contains_re_non_literal_raises():
+    df = pl.LazyFrame({"a": ["a", "b"], "b": [".", "e"]})
+
+    q = df.select(pl.col("a").str.contains(pl.col("b"), literal=False))
+
+    with pytest.raises(NotImplementedError):
+        _ = translate_ir(q._ldf.visit())
+
+
+@pytest.fixture
+def ldf():
+    return pl.DataFrame(
+        {"a": ["AbC", "de", "FGHI", "j", "kLm", "nOPq", None, "RsT", None, "uVw"]}
+    ).lazy()
+
+
+@pytest.mark.parametrize(
+    "substr",
+    [
+        "A",
+        "de",
+        ".*",
+        "^a",
+        "^A",
+        "[^a-z]",
+        "[a-z]{3,}",
+        "^[A-Z]{2,}",
+        "j|u",
+    ],
+)
+def test_contains_regex(ldf, substr):
+    query = ldf.select(pl.col("a").str.contains(substr))
+    assert_gpu_result_equal(query)
+
+
+@pytest.mark.parametrize(
+    "literal", ["A", "de", "FGHI", "j", "kLm", "nOPq", "RsT", "uVw"]
+)
+def test_contains_literal(ldf, literal):
+    query = ldf.select(pl.col("a").str.contains(pl.lit(literal), literal=True))
+    assert_gpu_result_equal(query)
+
+
+def test_contains_column(ldf):
+    query = ldf.select(pl.col("a").str.contains(pl.col("a"), literal=True))
+    assert_gpu_result_equal(query)
+
+
+@pytest.mark.parametrize("pat", ["["])
+def test_contains_invalid(ldf, pat):
+    query = ldf.select(pl.col("a").str.contains(pat))
+
+    with pytest.raises(pl.exceptions.ComputeError):
+        query.collect()
+    with pytest.raises(pl.exceptions.ComputeError):
+        query.collect(post_opt_callback=partial(execute_with_cudf, raise_on_fail=True))