feat(expr-ir): Add a concrete impl for cs.by_name

Adding `parse_into_selector_ir` will require calling this a lot
I'd rather skip using `re` when a more performant option is there

Author: dangotbanned

narwhals/_plan/expressions/selectors.py

@@ -96,6 +96,30 @@ def matches_column(self, name: str, dtype: DType) -> bool:
         return dtype in self.dtypes
 
 
+class ByName(Selector):
+    # NOTE: `polars` allows this and `by_index` to redefine schema order in a `select`
+    # > Matching columns are returned in the order in which they are declared in
+    # > the selector, not the underlying schema order.
+    # If you wanna support that (later), then a `frozenset` won't work
+    __slots__ = ("names",)
+    names: frozenset[str]
+
+    def __repr__(self) -> str:
+        els = ", ".join(f"{nm!r}" for nm in sorted(self.names))
+        return f"ncs.by_name({els})"
+
+    @staticmethod
+    def from_names(*names: OneOrIterable[str]) -> ByName:
+        return ByName(names=frozenset(flatten_hash_safe(names)))
+
+    @staticmethod
+    def from_name(name: str, /) -> ByName:
+        return ByName(names=frozenset((name,)))
+
+    def matches_column(self, name: str, dtype: DType) -> bool:
+        return name in self.names
+
+
 class Categorical(Selector):
     def __repr__(self) -> str:
         return "ncs.categorical()"
@@ -192,12 +216,6 @@ class Matches(Selector):
     def from_string(pattern: str, /) -> Matches:
         return Matches(pattern=re.compile(pattern))
 
-    @staticmethod
-    def from_names(*names: OneOrIterable[str]) -> Matches:
-        """Implements `cs.by_name` to support `__r<op>__` with column selections."""
-        it = flatten_hash_safe(names)
-        return Matches.from_string(f"^({'|'.join(re.escape(name) for name in it)})$")
-
     def __repr__(self) -> str:
         return f"ncs.matches(pattern={self.pattern.pattern!r})"
 
@@ -245,7 +263,11 @@ def by_dtype(*dtypes: OneOrIterable[DType | type[DType]]) -> expr.Selector:
 
 
 def by_name(*names: OneOrIterable[str]) -> expr.Selector:
-    return Matches.from_names(*names).to_selector().to_narwhals()
+    if len(names) == 1 and isinstance(names[0], str):
+        sel = ByName.from_name(names[0])
+    else:
+        sel = ByName.from_names(*names)
+    return sel.to_selector().to_narwhals()
 
 
 def boolean() -> expr.Selector:

tests/plan/over_test.py

@@ -27,11 +27,21 @@ def data() -> Data:
     }
 
 
+@pytest.fixture
+def data_with_null(data: Data) -> Data:
+    return data | {"b": [1, 2, None, 5, 3]}
+
+
 @pytest.fixture
 def data_alt() -> Data:
     return {"a": [3, 5, 1, 2, None], "b": [0, 1, 3, 2, 1], "c": [9, 1, 2, 1, 1]}
 
 
+XFAIL_REQUIRES_PARTITION_BY = pytest.mark.xfail(
+    reason="Native group_by isn't enough", raises=InvalidOperationError
+)
+
+
 @pytest.mark.parametrize(
     "partition_by",
     [
@@ -100,6 +110,25 @@ def test_over_multiple(data: Data, partition_by: OneOrIterable[IntoExprColumn])
     assert_equal_data(result, expected)
 
 
+@XFAIL_REQUIRES_PARTITION_BY
+def test_over_cum_sum(data_with_null: Data) -> None:  # pragma: no cover
+    df = dataframe(data_with_null)
+    expected = {
+        "a": ["a", "a", "b", "b", "b"],
+        "b": [1, 2, None, 5, 3],
+        "c": [5, 4, 3, 2, 1],
+        "b_cum_sum": [1, 3, None, 5, 8],
+        "c_cum_sum": [5, 9, 3, 5, 6],
+    }
+
+    result = (
+        df.with_columns(nwp.col("b", "c").cum_sum().over("a").name.suffix("_cum_sum"))
+        .sort("i")
+        .drop("i")
+    )
+    assert_equal_data(result, expected)
+
+
 def test_over_std_var(data: Data) -> None:
     expected = {
         "a": ["a", "a", "b", "b", "b"],