maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/dataframe/datastore/to_csv.py

@@ -12,17 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
-
 from ... import opcodes
-from ...core import EntityData
 from ...serialization.serializables import (
     AnyField,
     BoolField,
     DictField,
     Int32Field,
     Int64Field,
-    KeyField,
     ListField,
     StringField,
 )
@@ -33,27 +29,26 @@ from .core import DataFrameDataStore
 class DataFrameToCSV(DataFrameDataStore):
     _op_type_ = opcodes.TO_CSV
 
-    input = KeyField("input")
-    path = AnyField("path")
-    sep = StringField("sep")
-    na_rep = StringField("na_rep")
-    float_format = StringField("float_format")
-    columns = ListField("columns")
-    header = AnyField("header")
-    index = BoolField("index")
-    index_label = AnyField("index_label")
-    mode = StringField("mode")
-    encoding = StringField("encoding")
-    compression = AnyField("compression")
-    quoting = Int32Field("quoting")
-    quotechar = StringField("quotechar")
-    line_terminator = StringField("line_terminator")
-    chunksize = Int64Field("chunksize")
-    date_format = StringField("date_format")
-    doublequote = BoolField("doublequote")
-    escapechar = StringField("escapechar")
-    decimal = StringField("decimal")
-    storage_options = DictField("storage_options")
+    path = AnyField("path", default=None)
+    sep = StringField("sep", default=None)
+    na_rep = StringField("na_rep", default=None)
+    float_format = StringField("float_format", default=None)
+    columns = ListField("columns", default=None)
+    header = AnyField("header", default=None)
+    index = BoolField("index", default=None)
+    index_label = AnyField("index_label", default=None)
+    mode = StringField("mode", default=None)
+    encoding = StringField("encoding", default=None)
+    compression = AnyField("compression", default=None)
+    quoting = Int32Field("quoting", default=None)
+    quotechar = StringField("quotechar", default=None)
+    line_terminator = StringField("line_terminator", default=None)
+    chunksize = Int64Field("chunksize", default=None)
+    date_format = StringField("date_format", default=None)
+    doublequote = BoolField("doublequote", default=None)
+    escapechar = StringField("escapechar", default=None)
+    decimal = StringField("decimal", default=None)
+    storage_options = DictField("storage_options", default=None)
 
     def __init__(self, output_types=None, **kw):
         super().__init__(_output_types=output_types, **kw)
@@ -63,19 +58,6 @@ class DataFrameToCSV(DataFrameDataStore):
         # if wildcard in path, write csv into multiple files
         return "*" not in self.path
 
-    @property
-    def output_stat(self):
-        return self.output_stat
-
-    @property
-    def output_limit(self):
-        return 1 if not self.output_stat else 2
-
-    @classmethod
-    def _set_inputs(cls, op: "DataFrameToCSV", inputs: List[EntityData]):
-        super()._set_inputs(op, inputs)
-        op._input = op._inputs[0]
-
     def __call__(self, df):
         index_value = parse_index(df.index_value.to_pandas()[:0], df)
         if df.ndim == 2:
@@ -110,13 +92,14 @@ def to_csv(
     compression="infer",
     quoting=None,
     quotechar='"',
-    line_terminator=None,
+    lineterminator=None,
     chunksize=None,
     date_format=None,
     doublequote=True,
     escapechar=None,
     decimal=".",
     storage_options=None,
+    **kw,
 ):
     r"""
     Write object to a comma-separated values (csv) file.
@@ -169,7 +152,7 @@ def to_csv(
         will treat them as non-numeric.
     quotechar : str, default '\"'
         String of length 1. Character used to quote fields.
-    line_terminator : str, optional
+    lineterminator : str, optional
         The newline character or character sequence to use in the output
         file. Defaults to `os.linesep`, which depends on the OS in which
         this method is called ('\n' for linux, '\r\n' for Windows, i.e.).
@@ -203,6 +186,11 @@ def to_csv(
     ...                    'weapon': ['sai', 'bo staff']})
     >>> df.to_csv('out.csv', index=False).execute()
     """
+    lineterminator = lineterminator or kw.pop("line_terminator", None)
+    if kw:
+        raise TypeError(
+            f"to_csv() got an unexpected keyword argument '{next(iter(kw))}'"
+        )
 
     if mode != "w":  # pragma: no cover
         raise NotImplementedError("only support to_csv with mode 'w' for now")
@@ -220,7 +208,7 @@ def to_csv(
         compression=compression,
         quoting=quoting,
         quotechar=quotechar,
-        line_terminator=line_terminator,
+        line_terminator=lineterminator,
         chunksize=chunksize,
         date_format=date_format,
         doublequote=doublequote,

maxframe/dataframe/datastore/to_odps.py

@@ -56,10 +56,17 @@ class DataFrameToODPSTable(DataFrameDataStore):
     index_label = ListField("index_label", FieldTypes.string, default=None)
     lifecycle = Int64Field("lifecycle", default=None)
     table_properties = DictField("table_properties", default=None)
+    primary_key = ListField("primary_key", FieldTypes.string, default=None)
+    use_generated_table_meta = BoolField("use_generated_table_meta", default=False)
 
     def __init__(self, **kw):
         super().__init__(_output_types=[OutputType.dataframe], **kw)
 
+    def check_inputs(self, inputs: List[TileableType]):
+        if self.use_generated_table_meta:
+            return None
+        return super().check_inputs(inputs)
+
     def __call__(self, x):
         shape = (0,) * len(x.shape)
         index_value = parse_index(x.index_value.to_pandas()[:0], x.key, "index")
@@ -100,11 +107,12 @@ def to_odps_table(
     partition: Optional[str] = None,
     partition_col: Union[None, str, List[str]] = None,
     overwrite: bool = False,
-    unknown_as_string: Optional[bool] = None,
+    unknown_as_string: Optional[bool] = True,
     index: bool = True,
     index_label: Union[None, str, List[str]] = None,
     lifecycle: Optional[int] = None,
     table_properties: Optional[dict] = None,
+    primary_key: Union[None, str, List[str]] = None,
 ):
     """
     Write DataFrame object into a MaxCompute (ODPS) table.
@@ -145,6 +153,10 @@ def to_odps_table(
         Specify lifecycle of the output table.
     table_properties: Optional[dict]
         Specify properties of the output table.
+    primary_key: Union[None, str, List[str]]
+        If provided and target table does not exist, target table
+        will be a delta table with columns specified in this argument
+        as primary key.
 
     Returns
     -------
@@ -201,12 +213,14 @@ def to_odps_table(
         index_table_intersect = index_cols & table_cols
         if index_table_intersect:
             raise ValueError(
-                f"Index column(s) {index_table_intersect} conflict with column(s) of the input dataframe."
+                f"Index column(s) {index_table_intersect} conflict with "
+                f"column(s) of the input dataframe."
             )
         index_partition_intersect = index_cols & partition_col_set
         if index_partition_intersect:
             raise ValueError(
-                f"Index column(s) {index_partition_intersect} conflict with partition column(s)."
+                f"Index column(s) {index_partition_intersect} conflict "
+                f"with partition column(s)."
             )
 
     if partition_col:
@@ -217,6 +231,23 @@ def to_odps_table(
                 " is not the data column(s) of the input dataframe."
             )
 
+    table_properties = table_properties or {}
+    if primary_key is not None:
+        table_properties["transactional"] = "true"
+    if odps_entry.exist_table(table):
+        table_obj = odps_entry.get_table(table)
+        if table_obj.is_transactional:
+            table_properties = table_properties or {}
+            table_properties["transactional"] = "true"
+            primary_key = primary_key or table_obj.primary_key or ()
+            if set(primary_key) != set(table_obj.primary_key or ()):
+                raise ValueError(
+                    f"Primary keys between existing table {table} and "
+                    f"provided arguments are not same."
+                )
+    if primary_key and not isinstance(primary_key, (list, tuple)):
+        primary_key = [primary_key]
+
     op = DataFrameToODPSTable(
         dtypes=df.dtypes,
         table_name=table,
@@ -227,6 +258,7 @@ def to_odps_table(
         index=index,
         index_label=index_label,
         lifecycle=lifecycle or options.session.table_lifecycle,
-        table_properties=table_properties,
+        table_properties=table_properties or None,
+        primary_key=primary_key or None,
     )
     return op(df)

maxframe/dataframe/extensions/__init__.py

@@ -24,20 +24,36 @@ from .apply_chunk import (
     df_apply_chunk,
     series_apply_chunk,
 )
+from .cartesian_chunk import cartesian_chunk
+from .collect_kv import collect_kv
+from .extract_kv import extract_kv
 from .flatjson import series_flatjson
 from .flatmap import df_flatmap, series_flatmap
+from .map_reduce import map_reduce
+from .rebalance import DataFrameRebalance, rebalance
 from .reshuffle import DataFrameReshuffle, df_reshuffle
 
 
 def _install():
     from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
 
-    DataFrameMaxFrameAccessor._register("reshuffle", df_reshuffle)
-    DataFrameMaxFrameAccessor._register("flatmap", df_flatmap)
     DataFrameMaxFrameAccessor._register("apply_chunk", df_apply_chunk)
-    SeriesMaxFrameAccessor._register("flatmap", series_flatmap)
-    SeriesMaxFrameAccessor._register("flatjson", series_flatjson)
+    DataFrameMaxFrameAccessor._register("cartesian_chunk", cartesian_chunk)
+    DataFrameMaxFrameAccessor._register("collect_kv", collect_kv)
+    DataFrameMaxFrameAccessor._register("extract_kv", extract_kv)
+    DataFrameMaxFrameAccessor._register("flatmap", df_flatmap)
+    DataFrameMaxFrameAccessor._register("map_reduce", map_reduce)
+    DataFrameMaxFrameAccessor._register("rebalance", rebalance)
+    DataFrameMaxFrameAccessor._register("reshuffle", df_reshuffle)
+
     SeriesMaxFrameAccessor._register("apply_chunk", series_apply_chunk)
+    SeriesMaxFrameAccessor._register("cartesian_chunk", cartesian_chunk)
+    SeriesMaxFrameAccessor._register("extract_kv", extract_kv)
+    SeriesMaxFrameAccessor._register("flatjson", series_flatjson)
+    SeriesMaxFrameAccessor._register("flatmap", series_flatmap)
+    SeriesMaxFrameAccessor._register("rebalance", rebalance)
+
+    IndexMaxFrameAccessor._register("rebalance", rebalance)
 
     if DataFrameMaxFrameAccessor._api_count:
         for t in DATAFRAME_TYPE:

maxframe/dataframe/extensions/apply_chunk.py

@@ -26,9 +26,10 @@ from ...serialization.serializables import (
     Int32Field,
     TupleField,
 )
+from ...typing_ import TileableType
 from ...udf import BuiltinFunction, MarkedFunction
 from ...utils import copy_if_possible, make_dtype, make_dtypes
-from ..core import DATAFRAME_TYPE, DataFrame, IndexValue, Series
+from ..core import DATAFRAME_TYPE, INDEX_TYPE, DataFrame, IndexValue, Series
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import (
     InferredDataFrameMeta,
@@ -43,7 +44,7 @@ from ..utils import (
 
 class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.APPLY_CHUNK
-    _legacy_name = "DataFrameApplyChunkOperator"
+    _legacy_name = "DataFrameApplyChunkOperator"  # since v2.0.0
 
     func = FunctionField("func")
     batch_rows = Int32Field("batch_rows", default=None)
@@ -60,16 +61,26 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
     def has_custom_code(self) -> bool:
         return not isinstance(self.func, BuiltinFunction)
 
+    def check_inputs(self, inputs: List[TileableType]):
+        # for apply_chunk we allow called on non-deterministic tileables
+        pass
+
     def _call_dataframe(self, df, dtypes, dtype, name, index_value, element_wise):
         # return dataframe
         if self.output_types[0] == OutputType.dataframe:
             dtypes = make_dtypes(dtypes)
+            if dtypes is not None:
+                shape = df.shape if element_wise else (np.nan, len(dtypes))
+                cols_value = parse_index(dtypes.index, store_data=True)
+            else:
+                shape = (np.nan, np.nan)
+                cols_value = None
             # apply_chunk will use generate new range index for results
             return self.new_dataframe(
                 [df],
-                shape=df.shape if element_wise else (np.nan, len(dtypes)),
+                shape=shape,
                 index_value=index_value,
-                columns_value=parse_index(dtypes.index, store_data=True),
+                columns_value=cols_value,
                 dtypes=dtypes,
             )
 
@@ -106,11 +117,17 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
         name: Any = None,
         output_type=None,
         index=None,
+        skip_infer=False,
     ):
         args = self.args or ()
         kwargs = self.kwargs or {}
         # if not dtypes and not skip_infer:
-        packed_func = get_packed_func(df_or_series, self.func, *args, **kwargs)
+        try:
+            packed_func = get_packed_func(df_or_series, self.func, *args, **kwargs)
+        except:
+            if not skip_infer:
+                raise
+            packed_func = self.func
 
         # if skip_infer, directly build a frame
         if self.output_types and self.output_types[0] == OutputType.df_or_series:
@@ -125,13 +142,15 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
             dtype=dtype,
             name=name,
             index=index,
+            skip_infer=skip_infer,
         )
 
         if inferred_meta.index_value is None:
             inferred_meta.index_value = parse_index(
                 None, (df_or_series.key, df_or_series.index_value.key, self.func)
             )
-        inferred_meta.check_absence("output_type", "dtypes", "dtype")
+        if not skip_infer:
+            inferred_meta.check_absence("output_type", "dtypes", "dtype")
 
         if isinstance(df_or_series, DATAFRAME_TYPE):
             return self._call_dataframe(
@@ -163,6 +182,7 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
         name: Any = None,
         index: Union[pd.Index, IndexValue] = None,
         elementwise: bool = None,
+        skip_infer: bool = False,
         **kwargs,
     ) -> InferredDataFrameMeta:
         inferred_meta = infer_dataframe_return_value(
@@ -174,7 +194,10 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
             name=name,
             index=index,
             elementwise=elementwise,
+            skip_infer=skip_infer,
         )
+        if skip_infer:
+            return inferred_meta
 
         # merge specified and inferred index, dtypes, output_type
         # elementwise used to decide shape
@@ -186,6 +209,8 @@ class DataFrameApplyChunk(DataFrameOperator, DataFrameOperatorMixin):
         if self.output_types:
             inferred_meta.output_type = self.output_types[0]
         inferred_meta.dtypes = dtypes if dtypes is not None else inferred_meta.dtypes
+        if isinstance(index, INDEX_TYPE):
+            index = index.index_value
         if index is not None:
             inferred_meta.index_value = (
                 parse_index(index)
@@ -458,6 +483,7 @@ def df_apply_chunk(
         name=name,
         index=index,
         output_type=output_type,
+        skip_infer=skip_infer,
     )
 
 

maxframe/dataframe/extensions/cartesian_chunk.py

@@ -0,0 +1,153 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import EntityData, OutputType
+from ...serialization.serializables import (
+    DictField,
+    FunctionField,
+    KeyField,
+    TupleField,
+)
+from ...udf import BuiltinFunction
+from ...utils import quiet_stdio
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import (
+    build_df,
+    build_empty_df,
+    build_series,
+    parse_index,
+    validate_output_types,
+)
+
+
+class DataFrameCartesianChunk(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.CARTESIAN_CHUNK
+
+    left = KeyField("left")
+    right = KeyField("right")
+    func = FunctionField("func")
+    args = TupleField("args")
+    kwargs = DictField("kwargs")
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+        if self.memory_scale is None:
+            self.memory_scale = 2.0
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameCartesianChunk", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.left, op.right = op.inputs[:2]
+
+    @staticmethod
+    def _build_test_obj(obj):
+        return (
+            build_df(obj, size=2)
+            if obj.ndim == 2
+            else build_series(obj, size=2, name=obj.name)
+        )
+
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.func, BuiltinFunction)
+
+    def __call__(self, left, right, index=None, dtypes=None):
+        test_left = self._build_test_obj(left)
+        test_right = self._build_test_obj(right)
+        output_type = self._output_types[0] if self._output_types else None
+
+        if output_type == OutputType.df_or_series:
+            return self.new_df_or_series([left, right])
+
+        # try run to infer meta
+        try:
+            with np.errstate(all="ignore"), quiet_stdio():
+                obj = self.func(test_left, test_right, *self.args, **self.kwargs)
+        except:  # noqa: E722  # nosec  # pylint: disable=bare-except
+            if output_type == OutputType.series:
+                obj = pd.Series([], dtype=np.dtype(object))
+            elif output_type == OutputType.dataframe and dtypes is not None:
+                obj = build_empty_df(dtypes)
+            else:
+                raise TypeError(
+                    "Cannot determine `output_type`, "
+                    "you have to specify it as `dataframe` or `series`, "
+                    "for dataframe, `dtypes` is required as well "
+                    "if output_type='dataframe'"
+                )
+
+        if getattr(obj, "ndim", 0) == 1 or output_type == OutputType.series:
+            shape = self.kwargs.pop("shape", (np.nan,))
+            if index is None:
+                index = obj.index
+            index_value = parse_index(
+                index, left, right, self.func, self.args, self.kwargs
+            )
+            return self.new_series(
+                [left, right],
+                dtype=obj.dtype,
+                shape=shape,
+                index_value=index_value,
+                name=obj.name,
+            )
+        else:
+            dtypes = dtypes if dtypes is not None else obj.dtypes
+            # dataframe
+            shape = (np.nan, len(dtypes))
+            columns_value = parse_index(dtypes.index, store_data=True)
+            if index is None:
+                index = obj.index
+            index_value = parse_index(
+                index, left, right, self.func, self.args, self.kwargs
+            )
+            return self.new_dataframe(
+                [left, right],
+                shape=shape,
+                dtypes=dtypes,
+                index_value=index_value,
+                columns_value=columns_value,
+            )
+
+
+def cartesian_chunk(left, right, func, skip_infer=False, args=(), **kwargs):
+    output_type = kwargs.pop("output_type", None)
+    output_types = kwargs.pop("output_types", None)
+    object_type = kwargs.pop("object_type", None)
+    output_types = validate_output_types(
+        output_type=output_type, output_types=output_types, object_type=object_type
+    )
+    output_type = output_types[0] if output_types else None
+    if output_type:
+        output_types = [output_type]
+    elif skip_infer:
+        output_types = [OutputType.df_or_series]
+    index = kwargs.pop("index", None)
+    dtypes = kwargs.pop("dtypes", None)
+    memory_scale = kwargs.pop("memory_scale", None)
+
+    op = DataFrameCartesianChunk(
+        left=left,
+        right=right,
+        func=func,
+        args=args,
+        kwargs=kwargs,
+        output_types=output_types,
+        memory_scale=memory_scale,
+    )
+    return op(left, right, index=index, dtypes=dtypes)

maxframe/dataframe/extensions/collect_kv.py

@@ -0,0 +1,126 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, StringField
+from ...utils import no_default
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import make_column_list
+
+
+class DataFrameCollectKv(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.COLLECT_KV
+
+    columns = AnyField("columns", default=None)
+    kv_delim = StringField("kv_delim", default=None)
+    item_delim = StringField("item_delim", default=None)
+    kv_col = StringField("kv_col", default=None)
+
+    def __call__(self, df):
+        if self.columns is None:
+            cols = list(df.dtypes.index)
+        else:
+            cols = self.columns if isinstance(self.columns, list) else [self.columns]
+        new_dtypes = df.dtypes.drop(cols, errors="ignore")
+        new_dtypes = pd.concat(
+            [new_dtypes, pd.Series([np.dtype("object")], index=[self.kv_col])]
+        )
+        shape = (df.shape[0], len(new_dtypes))
+        return self.new_dataframe(
+            [df],
+            shape=shape,
+            dtypes=new_dtypes,
+            index_value=df.index_value,
+            columns_value=new_dtypes.index,
+        )
+
+
+def collect_kv(
+    data,
+    columns=None,
+    kv_delim="=",
+    item_delim=",",
+    kv_col="kv_col",
+):
+    """
+    Merge values in specified columns into a key-value represented column.
+
+    Parameters
+    ----------
+    columns : list, default None
+        The columns to be merged.
+    kv_delim : str, default '='
+        Delimiter between key and value.
+    item_delim : str, default ','
+        Delimiter between key-value pairs.
+    kv_col : str, default 'kv_col'
+        Name of the new key-value column
+
+    Returns
+    -------
+    DataFrame
+        converted data frame
+
+    See Also
+    --------
+    DataFrame.mf.extract_kv
+
+    Examples
+    -------
+    >>> import maxframe.dataframe as md
+
+    >>> df = md.DataFrame({"name": ["name1", "name2", "name3", "name4", "name5"],
+    ...                    "k1": [1.0, NaN, 7.1, NaN, NaN],
+    ...                    "k2": [3.0, 3.0, NaN, 1.2, 1.0],
+    ...                    "k3": [NaN, 5.1, NaN, 1.5, NaN],
+    ...                    "k5": [10.0, NaN, NaN, NaN, NaN,],
+    ...                    "k7": [NaN, NaN, 8.2, NaN, NaN, ],
+    ...                    "k9": [NaN, NaN, NaN, NaN, 1.1]})
+    >>> df.execute()
+       name   k1   k2   k3   k5    k7   k9
+    0  name1  1.0  3.0  NaN  10.0  NaN  NaN
+    1  name2  NaN  3.0  5.1  NaN   NaN  NaN
+    2  name3  7.1  NaN  NaN  NaN   8.2  NaN
+    3  name4  NaN  1.2  1.5  NaN   NaN  NaN
+    4  name5  NaN  1.0  NaN  NaN   NaN  1.1
+
+    The field names to be merged are specified by columns
+    kv_delim is to delimit the key and value and '=' is default
+    item_delim is to delimit the Key-Value pairs, ',' is default
+    The new column name is specified by kv_col, 'kv_col' is default
+
+    >>> df.mf.collect_kv(columns=['k1', 'k2', 'k3', 'k5', 'k7', 'k9']).execute()
+       name   kv_col
+    0  name1  k1=1.0,k2=3.0,k5=10.0
+    1  name2  k2=3.0,k3=5.1
+    2  name3  k1=7.1,k7=8.2
+    3  name4  k2=1.2,k3=1.5
+    4  name5  k2=1.0,k9=1.1
+    """
+    columns_list = make_column_list(columns, data.dtypes) or []
+    non_exist_key = next(
+        (c for c in columns_list if c not in data.dtypes.index), no_default
+    )
+    if columns_list and non_exist_key is not no_default:
+        raise ValueError(f"Column {non_exist_key} specified is not a valid column.")
+    op = DataFrameCollectKv(
+        columns=columns,
+        kv_delim=kv_delim,
+        item_delim=item_delim,
+        kv_col=kv_col,
+    )
+    return op(data)