Add struct.explode() method

python/cudf/cudf/core/column/column.py

@@ -2037,13 +2037,20 @@ def as_column(
             np_type = None
             try:
                 if dtype is not None:
+                    if is_categorical_dtype(dtype) or is_interval_dtype(dtype):
+                        raise TypeError
                     if is_list_dtype(dtype):
                         data = pa.array(arbitrary)
                         if type(data) not in (pa.ListArray, pa.NullArray):
                             raise ValueError(
                                 "Cannot create list column from given data"
                             )
                         return as_column(data, nan_as_null=nan_as_null)
+                    elif isinstance(
+                        dtype, cudf.StructDtype
+                    ) and not isinstance(dtype, cudf.IntervalDtype):
+                        data = pa.array(arbitrary, type=dtype.to_arrow())
+                        return as_column(data, nan_as_null=nan_as_null)
                     if isinstance(dtype, cudf.core.dtypes.Decimal64Dtype):
                         data = pa.array(
                             arbitrary,
@@ -2065,14 +2072,11 @@ def as_column(
                             data
                         )
                     dtype = pd.api.types.pandas_dtype(dtype)
-                    if is_categorical_dtype(dtype) or is_interval_dtype(dtype):
-                        raise TypeError
+                    np_type = np.dtype(dtype).type
+                    if np_type == np.bool_:
+                        pa_type = pa.bool_()
                     else:
-                        np_type = np.dtype(dtype).type
-                        if np_type == np.bool_:
-                            pa_type = pa.bool_()
-                        else:
-                            pa_type = np_to_pa_dtype(np.dtype(dtype))
+                        pa_type = np_to_pa_dtype(np.dtype(dtype))
                 data = as_column(
                     pa.array(
                         arbitrary,

python/cudf/cudf/core/column/struct.py

@@ -141,6 +141,8 @@ class StructMethods(ColumnMethods):
     Struct methods for Series
     """
 
+    _column: StructColumn
+
     def __init__(self, parent=None):
         if not is_struct_dtype(parent.dtype):
             raise AttributeError(
@@ -181,3 +183,35 @@ def field(self, key):
             return self._return_or_inplace(self._column.children[pos])
         else:
             return self._return_or_inplace(self._column.children[key])
+
+    def explode(self):
+        """
+        Return a DataFrame whose columns are the fields of this struct Series.
+        No columns are copied during this operation.
+
+        Examples
+        --------
+        >>> s
+        0    {'a': 1, 'b': 'x'}
+        1    {'a': 2, 'b': 'y'}
+        2    {'a': 3, 'b': 'z'}
+        3    {'a': 4, 'b': 'a'}
+        dtype: struct
+
+        >>> s.struct.explode()
+           a  b
+        0  1  x
+        1  2  y
+        2  3  z
+        3  4  a
+        """
+        return cudf.DataFrame._from_data(
+            cudf.core.column_accessor.ColumnAccessor(
+                {
+                    name: col
+                    for name, col in zip(
+                        self._column.dtype.fields, self._column.children
+                    )
+                }
+            )
+        )

python/cudf/cudf/core/dataframe.py

@@ -7477,6 +7477,29 @@ def to_dict(self, orient="dict", into=dict):
             "`.to_pandas().to_dict()` to construct a Python dictionary."
         )
 
+    def to_struct(self, name=None, index=None):
+        """
+        Return a struct Series composed of the columns of the DataFrame.
+        Note that no copies of the data are made.
+
+        Parameters
+        ----------
+        name: optional
+            Name of the resulting Series
+        index: optional
+            Index of the resulting Series. If not provided, the index
+            of the DataFrame is used.
+        """
+        col = cudf.core.column.build_struct_column(
+            names=self._data.names, children=self._data.columns, size=len(self)
+        )
+        index = index if index is not None else self.index
+        return cudf.Series._from_data(
+            cudf.core.column_accessor.ColumnAccessor({name: col}),
+            index=as_index(index),
+            name=name,
+        )
+
     def keys(self):
         """
         Get the columns.

python/cudf/cudf/tests/test_struct.py

@@ -119,3 +119,20 @@ def test_struct_scalar_host_construction(data):
 def test_struct_scalar_null():
     slr = cudf.Scalar(cudf.NA, dtype=StructDtype)
     assert slr.device_value.value is cudf.NA
+
+
+def test_struct_explode():
+    s = cudf.Series([], dtype=cudf.StructDtype({}))
+    expect = cudf.DataFrame({})
+    assert_eq(expect, s.struct.explode())
+
+    s = cudf.Series(
+        [
+            {"a": 1, "b": "x"},
+            {"a": 2, "b": "y"},
+            {"a": 3, "b": "z"},
+            {"a": 4, "b": "a"},
+        ]
+    )
+    expect = cudf.DataFrame({"a": [1, 2, 3, 4], "b": ["x", "y", "z", "a"]})
+    assert_eq(expect, s.struct.explode())