feat: add binary string operations (length and concatenation)

daft/daft/__init__.pyi

@@ -1200,6 +1200,13 @@ def utf8_normalize(
     expr: PyExpr, remove_punct: bool, lowercase: bool, nfd_unicode: bool, white_space: bool
 ) -> PyExpr: ...
 
+# ---
+# expr.binary namespace
+# ---
+def binary_length(expr: PyExpr) -> PyExpr: ...
+def binary_concat(left: PyExpr, right: PyExpr) -> PyExpr: ...
+def binary_slice(expr: PyExpr, start: PyExpr, length: PyExpr | None = None) -> PyExpr: ...
+
 class PyCatalog:
     @staticmethod
     def new() -> PyCatalog: ...

daft/expressions/expressions.py

@@ -273,6 +273,15 @@ def json(self) -> ExpressionJsonNamespace:
         """Access methods that work on columns of json."""
         return ExpressionJsonNamespace.from_expression(self)
 
+    @property
+    def binary(self) -> ExpressionBinaryNamespace:
+        """Access binary string operations for this expression.
+
+        Returns:
+            ExpressionBinaryNamespace: A namespace containing binary string operations
+        """
+        return ExpressionBinaryNamespace.from_expression(self)
+
     @staticmethod
     def _from_pyexpr(pyexpr: _PyExpr) -> Expression:
         expr = Expression.__new__(Expression)
@@ -3554,3 +3563,100 @@ class ExpressionEmbeddingNamespace(ExpressionNamespace):
     def cosine_distance(self, other: Expression) -> Expression:
         """Compute the cosine distance between two embeddings."""
         return Expression._from_pyexpr(native.cosine_distance(self._expr, other._expr))
+
+
+class ExpressionBinaryNamespace(ExpressionNamespace):
+    def length(self) -> Expression:
+        """Retrieves the length for a binary string column.
+
+        Example:
+            >>> import daft
+            >>> df = daft.from_pydict({"x": [b"foo", b"bar", b"baz"]})
+            >>> df = df.select(df["x"].binary.length())
+            >>> df.show()
+            ╭────────╮
+            │ x      │
+            │ ---    │
+            │ UInt64 │
+            ╞════════╡
+            │ 3      │
+            ├╌╌╌╌╌╌╌╌┤
+            │ 3      │
+            ├╌╌╌╌╌╌╌╌┤
+            │ 3      │
+            ╰────────╯
+            <BLANKLINE>
+            (Showing first 3 of 3 rows)
+
+        Returns:
+            Expression: an UInt64 expression with the length of each binary string in bytes
+        """
+        return Expression._from_pyexpr(native.binary_length(self._expr))
+
+    def concat(self, other: Expression) -> Expression:
+        r"""Concatenates two binary strings.
+
+        Example:
+            >>> import daft
+            >>> df = daft.from_pydict(
+            ...     {"a": [b"Hello", b"\\xff\\xfe", b"", b"World"], "b": [b" World", b"\\x00", b"empty", b"!"]}
+            ... )
+            >>> df = df.select(df["a"].binary.concat(df["b"]))
+            >>> df.show()
+            ╭────────────────────╮
+            │ a                  │
+            │ ---                │
+            │ Binary             │
+            ╞════════════════════╡
+            │ b"Hello World"     │
+            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+            │ b"\\xff\\xfe\\x00" │
+            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+            │ b"empty"           │
+            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+            │ b"World!"          │
+            ╰────────────────────╯
+            <BLANKLINE>
+            (Showing first 4 of 4 rows)
+
+        Args:
+            other: The binary string to concatenate with, can be either an Expression or a bytes literal
+
+        Returns:
+            Expression: A binary expression containing the concatenated strings
+        """
+        other_expr = Expression._to_expression(other)
+        return Expression._from_pyexpr(native.binary_concat(self._expr, other_expr._expr))
+
+    def slice(self, start: Expression | int, length: Expression | int | None = None) -> Expression:
+        r"""Returns a slice of each binary string.
+
+        Example:
+            >>> import daft
+            >>> df = daft.from_pydict({"x": [b"Hello World", b"\xff\xfe\x00", b"empty"]})
+            >>> df = df.select(df["x"].binary.slice(1, 3))
+            >>> df.show()
+            ╭─────────────╮
+            │ x           │
+            │ ---         │
+            │ Binary      │
+            ╞═════════════╡
+            │ b"ell"      │
+            ├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+            │ b"\xfe\x00" │
+            ├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
+            │ b"mpt"      │
+            ╰─────────────╯
+            <BLANKLINE>
+            (Showing first 3 of 3 rows)
+
+        Args:
+            start: The starting position (0-based) of the slice.
+            length: The length of the slice. If None, returns all characters from start to the end.
+
+        Returns:
+            A new expression representing the slice.
+        """
+        start_expr = Expression._to_expression(start)
+        length_expr = Expression._to_expression(length)
+        return Expression._from_pyexpr(native.binary_slice(self._expr, start_expr._expr, length_expr._expr))

docs/source/api_docs/expressions.rst

@@ -169,6 +169,22 @@ The following methods are available under the ``expr.str`` attribute.
    Expression.str.tokenize_decode
    Expression.str.count_matches
 
+.. _api-binary-expression-operations:
+
+Binary
+######
+
+The following methods are available under the ``expr.binary`` attribute.
+
+.. autosummary::
+   :nosignatures:
+   :toctree: doc_gen/expression_methods
+   :template: autosummary/accessor_method.rst
+
+   Expression.binary.concat
+   Expression.binary.length
+   Expression.binary.slice
+
 .. _api-float-expression-operations:
 
 Floats

pyproject.toml

@@ -55,7 +55,7 @@ check-hidden = true
 ignore-words-list = "crate,arithmetics,ser"
 # Feel free to un-skip examples, and experimental, you will just need to
 # work through many typos (--write-changes and --interactive will help)
-skip = "tests/series/*,target,.git,.venv,venv,data,*.csv,*.csv.*,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb,*.tiktoken,*.sql"
+skip = "tests/series/*,target,.git,.venv,venv,data,*.csv,*.csv.*,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb,*.tiktoken,*.sql,tests/table/utf8/*,tests/table/binary/*"
 
 [tool.maturin]
 # "python" tells pyo3 we want to build an extension module (skips linking against libpython.so)